Allow case classes to be inline arguments

Author: nicolasstucki

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

@@ -679,12 +679,8 @@ 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 isCaseClassApply(sym: Symbol): Boolean =
+          sym.name == nme.apply && sym.isStatic && sym.owner.is(Module) && sym.owner.companionClass.is(Case)
         def isCaseClassNew(sym: Symbol): Boolean = {
           sym.isPrimaryConstructor && (
             sym.eq(defn.SomeClass.primaryConstructor) ||
@@ -701,13 +697,15 @@ trait Checking {
           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 _ =>
+        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,6 @@
+2
+6
+8
+14
+3.1
+20.4

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,14 @@
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    println(E.eval(I(2)))
+    println(E.eval(Plus(I(2), 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)))))
+  }
+
+}