Allow case classes to be inline arguments

Author: nicolasstucki

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

@@ -295,12 +295,16 @@ object Splicer {
       case _ if tree.symbol == defn.TastyTasty_macroContext =>
         interpretTastyContext()
 
-      case StaticCall(fn, args) =>
-        if (fn.symbol.is(Module)) {
-          assert(args.isEmpty)
-          interpretModuleAccess(fn)
+      case Call(fn, args) =>
+        if (fn.symbol.isConstructor && fn.symbol.owner.owner.is(Package)) {
+          interpretNew(fn, args.map(interpretTree))
+        } else if (fn.symbol.isStatic) {
+          if (fn.symbol.is(Module)) interpretModuleAccess(fn)
+          else interpretStaticMethodCall(fn, args.map(arg => interpretTree(arg)))
+        } else if (env.contains(fn.name)) {
+          env(fn.name)
         } else {
-          interpretStaticMethodCall(fn, args.map(arg => interpretTree(arg)))
+          unexpectedTree(tree)
         }
 
       // Interpret `foo(j = x, i = y)` which it is expanded to
@@ -313,28 +317,21 @@ object Splicer {
         })
         interpretTree(expr)(newEnv)
       case NamedArg(_, arg) => interpretTree(arg)
-      case Ident(name) if env.contains(name) => env(name)
 
       case Inlined(EmptyTree, Nil, expansion) => interpretTree(expansion)
 
-      case Apply(TypeApply(fun: RefTree, _), args) if fun.symbol.isConstructor && fun.symbol.owner.owner.is(Package) =>
-        interpretNew(fun, args.map(interpretTree))
-
-      case Apply(fun: RefTree, args) if fun.symbol.isConstructor && fun.symbol.owner.owner.is(Package)=>
-        interpretNew(fun, args.map(interpretTree))
-
       case Typed(SeqLiteral(elems, _), _) =>
         interpretVarargs(elems.map(e => interpretTree(e)))
 
       case _ =>
         unexpectedTree(tree)
     }
 
-    object StaticCall {
+    object Call {
       def unapply(arg: Tree): Option[(RefTree, List[Tree])] = arg match {
-        case fn: RefTree if fn.symbol.isStatic => Some((fn, Nil))
-        case Apply(StaticCall(fn, args1), args2) => Some((fn, args1 ::: args2)) // TODO improve performance
-        case TypeApply(StaticCall(fn, args), _) => 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
       }
     }

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -679,35 +679,28 @@ trait Checking {
     tree.tpe.widenTermRefExpr match {
       case tp: ConstantType if exprPurity(tree) >= purityLevel => // ok
       case tp =>
-        def isCaseClassApply(sym: Symbol): Boolean = {
-          sym.name == nme.apply && (
-            tree.symbol.owner == defn.SomeClass.companionModule.moduleClass ||
-            defn.isTupleClass(tree.symbol.owner.companionClass)
-          )
-        }
-        def isCaseClassNew(sym: Symbol): Boolean = {
-          sym.isPrimaryConstructor && (
-            sym.eq(defn.SomeClass.primaryConstructor) ||
-            defn.isTupleClass(tree.symbol.owner)
-          )
-        }
+        def isCaseClassApply(sym: Symbol): Boolean =
+          sym.name == nme.apply && sym.owner.is(Module) && sym.owner.companionClass.is(Case)
+        def isCaseClassNew(sym: Symbol): Boolean =
+          sym.isPrimaryConstructor && sym.owner.is(Case) && sym.owner.isStatic
         def isCaseObject(sym: Symbol): Boolean = {
           // TODO add alias to Nil in scala package
-          sym.is(Case) && sym.is(Module) && sym.isStatic
+          sym.is(Case) && sym.is(Module)
         }
         val allow =
           ctx.erasedTypes ||
           ctx.inInlineMethod ||
-          isCaseClassApply(tree.symbol) ||
-          isCaseClassNew(tree.symbol) ||
-          isCaseObject(tree.symbol)
-        if (!allow) ctx.error(em"$what must be a constant expression", tree.pos)
-        else tree match {
-          // TODO: add cases for type apply and multiple applies
-          case Apply(_, args) =>
-            for (arg <- args)
-              checkInlineConformant(arg, isFinal, what)
-          case _ =>
+          (tree.symbol.isStatic && isCaseObject(tree.symbol) || isCaseClassApply(tree.symbol)) ||
+          (tree.symbol.owner.isStatic && isCaseClassNew(tree.symbol))
+        if (!allow) ctx.error(em"$what must be a known value", tree.pos)
+        else {
+          def checkArgs(tree: Tree): Unit = tree match {
+            case Apply(fn, args) =>
+              args.foreach(arg => checkInlineConformant(arg, isFinal, what))
+              checkArgs(fn)
+            case _ =>
+          }
+          checkArgs(tree)
         }
     }
   }

compiler/test/dotc/run-test-pickling.blacklist

@@ -26,6 +26,7 @@ inline-varargs-1
 implicitShortcut
 inline-case-objects
 inline-option
+inline-macro-staged-interpreter
 inline-tuples-1
 inline-tuples-2
 lazy-implicit-lists.scala

tests/neg/inline-macro-staged-interpreter/Macro_1.scala

@@ -0,0 +1,33 @@
+
+import scala.quoted._
+
+object E {
+
+  inline def eval[T](inline x: E[T]): T = ~impl(x)
+
+  def impl[T](x: E[T]): Expr[T] = x.lift
+
+}
+
+trait E[T] {
+  def lift: Expr[T]
+}
+
+case class I(n: Int) extends E[Int] {
+  def lift: Expr[Int] = n.toExpr
+}
+
+case class Plus[T](x: E[T], y: E[T])(implicit op: Plus2[T]) extends E[T] {
+  def lift: Expr[T] = op(x.lift, y.lift)
+}
+
+trait Op2[T] {
+  def apply(x: Expr[T], y: Expr[T]): Expr[T]
+}
+
+trait Plus2[T] extends Op2[T]
+object Plus2 {
+  implicit case object IPlus extends Plus2[Int] {
+    def apply(x: Expr[Int], y: Expr[Int]): Expr[Int] = '(~x + ~y)
+  }
+}

tests/neg/inline-macro-staged-interpreter/Main_2.scala

@@ -0,0 +1,20 @@
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    val i = I(2)
+    E.eval(
+      i // error
+    )
+
+    E.eval(Plus(
+      i, // error
+      I(4)))
+
+    val plus = Plus2.IPlus
+    E.eval(Plus(I(2), I(4))(
+      plus // error
+    ))
+  }
+
+}

tests/run/inline-macro-staged-interpreter.check

@@ -0,0 +1,9 @@
+2
+3
+6
+7
+8
+14
+3.1
+20.4
+20.8

tests/run/inline-macro-staged-interpreter/Macro_1.scala

@@ -0,0 +1,56 @@
+
+import scala.quoted._
+
+object E {
+
+  inline def eval[T](inline x: E[T]): T = ~impl(x)
+
+  def impl[T](x: E[T]): Expr[T] = x.lift
+
+}
+
+trait E[T] {
+  def lift: Expr[T]
+}
+
+case class I(n: Int) extends E[Int] {
+  def lift: Expr[Int] = n.toExpr
+}
+
+case class D(n: Double) extends E[Double] {
+  def lift: Expr[Double] = n.toExpr
+}
+
+case class Plus[T](x: E[T], y: E[T])(implicit op: Plus2[T]) extends E[T] {
+  def lift: Expr[T] = op(x.lift, y.lift)
+}
+
+case class Times[T](x: E[T], y: E[T])(implicit op: Times2[T]) extends E[T] {
+  def lift: Expr[T] = op(x.lift, y.lift)
+}
+
+trait Op2[T] {
+  def apply(x: Expr[T], y: Expr[T]): Expr[T]
+}
+
+trait Plus2[T] extends Op2[T]
+object Plus2 {
+  implicit case object IPlus extends Plus2[Int] {
+    def apply(x: Expr[Int], y: Expr[Int]): Expr[Int] = '(~x + ~y)
+  }
+
+  implicit case object DPlus extends Plus2[Double] {
+    def apply(x: Expr[Double], y: Expr[Double]): Expr[Double] = '(~x + ~y)
+  }
+}
+
+trait Times2[T] extends Op2[T]
+object Times2 {
+  implicit case object ITimes extends Times2[Int] {
+    def apply(x: Expr[Int], y: Expr[Int]): Expr[Int] = '(~x * ~y)
+  }
+
+  implicit case object DTimes extends Times2[Double] {
+    def apply(x: Expr[Double], y: Expr[Double]): Expr[Double] = '(~x * ~y)
+  }
+}

tests/run/inline-macro-staged-interpreter/Main_2.scala

@@ -0,0 +1,17 @@
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    println(E.eval(I(2)))
+    println(E.eval(new I(3)))
+    println(E.eval(Plus(I(2), I(4))))
+    println(E.eval(new Plus(I(3), I(4))))
+    println(E.eval(Times(I(2), I(4))))
+    println(E.eval(Times(I(2), Plus(I(3), I(4)))))
+
+    println(E.eval(D(3.1)))
+    println(E.eval(Times(D(2.4), Plus(D(3.9), D(4.6)))))
+    println(E.eval(new Times(D(2.6), Plus(D(3.9), new D(4.1)))))
+  }
+
+}