Address review

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/transform/Splicer.scala

@@ -321,27 +321,19 @@ object Splicer {
     protected def interpretNew(fn: Symbol, args: => List[Result])(implicit env: Env): Result
     protected def unexpectedTree(tree: Tree)(implicit env: Env): Result
 
-    private final def removeEraisedArguments(args: List[Tree], fnTpe: Type): List[Tree] = {
-      var result = args
-      var index = 0
-      def loop(tp: Type): Unit = tp match {
-        case tp: TermRef  => loop(tp.underlying)
-        case tp: PolyType => loop(tp.resType)
-        case tp: MethodType if tp.isErasedMethod =>
-          tp.paramInfos.foreach { _ =>
-            result = result.updated(index, null)
-            index += 1
-          }
-          loop(tp.resType)
+    private final def removeErasedArguments(args: List[List[Tree]], fnTpe: Type): List[List[Tree]] =
+      fnTpe match {
+        case tp: TermRef  => removeErasedArguments(args, tp.underlying)
+        case tp: PolyType => removeErasedArguments(args, tp.resType)
+        case tp: ExprType => removeErasedArguments(args, tp.resType)
         case tp: MethodType =>
-          index += tp.paramInfos.size
-          loop(tp.resType)
-        case _ => ()
+          val tail = removeErasedArguments(args.tail, tp.resType)
+          if (tp.isErasedMethod) tail else args.head :: tail
+        case tp: AppliedType if defn.isImplicitFunctionType(tp) =>
+          val tail = removeErasedArguments(args.tail, tp.args.last)
+          if (defn.isErasedFunctionType(tp)) tail else args.head :: tail
+        case tp => assert(args.isEmpty, tp); Nil
       }
-      loop(fnTpe)
-      assert(index == args.size)
-      result.filterNot(null.eq)
-    }
 
     protected final def interpretTree(tree: Tree)(implicit env: Env): Result = tree match {
       case Apply(TypeApply(fn, _), quoted :: Nil) if fn.symbol == defn.InternalQuoted_exprQuote =>
@@ -368,16 +360,16 @@ object Splicer {
 
       case Call(fn, args) =>
         if (fn.symbol.isConstructor && fn.symbol.owner.owner.is(Package)) {
-          interpretNew(fn.symbol, args.map(interpretTree))
+          interpretNew(fn.symbol, args.flatten.map(interpretTree))
         } else if (fn.symbol.is(Module)) {
           interpretModuleAccess(fn.symbol)
         } else if (fn.symbol.isStatic) {
           val module = fn.symbol.owner
-          def interpretedArgs = removeEraisedArguments(args, fn.tpe).map(arg => interpretTree(arg))
+          def interpretedArgs = removeErasedArguments(args, fn.tpe).flatten.map(interpretTree)
           interpretStaticMethodCall(module, fn.symbol, interpretedArgs)
         } else if (fn.qualifier.symbol.is(Module) && fn.qualifier.symbol.isStatic) {
           val module = fn.qualifier.symbol.moduleClass
-          def interpretedArgs = removeEraisedArguments(args, fn.tpe).map(arg => interpretTree(arg))
+          def interpretedArgs = removeErasedArguments(args, fn.tpe).flatten.map(interpretTree)
           interpretStaticMethodCall(module, fn.symbol, interpretedArgs)
         } else if (env.contains(fn.name)) {
           env(fn.name)
@@ -418,15 +410,19 @@ object Splicer {
     }
 
     object Call {
-      def unapply(arg: Tree): Option[(RefTree, List[Tree])] = arg match {
-        case Select(Call(fn, args), nme.apply) if defn.isImplicitFunctionType(fn.tpe.widenDealias.finalResultType) =>
-          Some((fn, args))
-        case fn: RefTree => Some((fn, Nil))
-        case Apply(Call(fn, args1), args2) => Some((fn, args1 ::: args2)) // TODO improve performance
-        case TypeApply(Call(fn, args), _) => Some((fn, args))
-        case _ => None
+      def unapply(arg: Tree): Option[(RefTree, List[List[Tree]])] =
+        Call0.unapply(arg).map((fn, args) => (fn, args.reverse))
+
+      object Call0 {
+        def unapply(arg: Tree): Option[(RefTree, List[List[Tree]])] = arg match {
+          case Select(Call0(fn, args), nme.apply) if defn.isImplicitFunctionType(fn.tpe.widenDealias.finalResultType) =>
+            Some((fn, args))
+          case fn: RefTree => Some((fn, Nil))
+          case Apply(Call0(fn, args1), args2) => Some((fn, args2 :: args1))
+          case TypeApply(Call0(fn, args), _) => Some((fn, args))
+          case _ => None
+        }
       }
     }
   }
-
 }

tests/run-macros/erased-arg-macro/2.scala

@@ -1,10 +1,12 @@
 object Test {
-  assert(Macro.foo1(1) == 0)
-  assert(Macro.foo2(1) == 0)
-  assert(Macro.foo3(1) == 0)
-  assert(Macro.foo4(1) == 0)
-  assert(Macro.foo5(1) == 0)
-  assert(Macro.foo6(1) == 0)
-  assert(Macro.foo7(1) == 0)
-  assert(Macro.foo8(1) == 0)
+  def main(args: Array[String]): Unit = {
+    assert(Macro.foo1(1) == 0)
+    assert(Macro.foo2(1) == 0)
+    assert(Macro.foo3(1) == 0)
+    assert(Macro.foo4(1) == 0)
+    assert(Macro.foo5(1) == 0)
+    assert(Macro.foo6(1) == 0)
+    assert(Macro.foo7(1) == 0)
+    assert(Macro.foo8(1) == 0)
+  }
 }