Allow case objects to be inline arguments

Author: nicolasstucki

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

@@ -111,14 +111,13 @@ object Splicer {
       }
 
     protected def interpretStaticMethodCall(fn: Tree, args: => List[Object])(implicit env: Env): Object = {
-      if (fn.symbol == defn.NoneModuleRef.termSymbol) {
-        // TODO generalize
-        None
-      } else {
-        val (clazz, instance) = loadModule(fn.symbol.owner)
-        val method = getMethod(clazz, fn.symbol.name, paramsSig(fn.symbol))
-        stopIfRuntimeException(method.invoke(instance, args: _*))
-      }
+      val (clazz, instance) = loadModule(fn.symbol.owner)
+      val method = getMethod(clazz, fn.symbol.name, paramsSig(fn.symbol))
+      stopIfRuntimeException(method.invoke(instance, args: _*))
+    }
+
+    protected def interpretModuleAccess(fn: Tree)(implicit env: Env): Object = {
+      loadModule(fn.symbol.moduleClass)._2
     }
 
     protected def interpretNew(fn: RefTree, args: => List[Result])(implicit env: Env): Object = {
@@ -147,7 +146,7 @@ object Splicer {
       try classLoader.loadClass(name.toString)
       catch {
         case _: ClassNotFoundException =>
-          val msg = s"Could not find macro class $name in classpath$extraMsg"
+          val msg = s"Could not find class $name in classpath$extraMsg"
           throw new StopInterpretation(msg, pos)
       }
     }
@@ -156,7 +155,7 @@ object Splicer {
       try clazz.getMethod(name.toString, paramClasses: _*)
       catch {
         case _: NoSuchMethodException =>
-          val msg = em"Could not find macro method ${clazz.getCanonicalName}.$name with parameters ($paramClasses%, %)$extraMsg"
+          val msg = em"Could not find method ${clazz.getCanonicalName}.$name with parameters ($paramClasses%, %)$extraMsg"
           throw new StopInterpretation(msg, pos)
       }
     }
@@ -257,7 +256,8 @@ object Splicer {
     protected def interpretVarargs(args: List[Boolean])(implicit env: Env): Boolean = args.forall(identity)
     protected def interpretTastyContext()(implicit env: Env): Boolean = true
     protected def interpretStaticMethodCall(fn: tpd.Tree, args: => List[Boolean])(implicit env: Env): Boolean = args.forall(identity)
-    protected def interpretNew(fn: RefTree, args: => List[Result])(implicit env: Env): Boolean = args.forall(identity)
+    protected def interpretModuleAccess(fn: Tree)(implicit env: Env): Boolean = true
+    protected def interpretNew(fn: RefTree, args: => List[Boolean])(implicit env: Env): Boolean = args.forall(identity)
 
     def unexpectedTree(tree: tpd.Tree)(implicit env: Env): Boolean = {
       // Assuming that top-level splices can only be in inline methods
@@ -278,6 +278,7 @@ object Splicer {
     protected def interpretVarargs(args: List[Result])(implicit env: Env): Result
     protected def interpretTastyContext()(implicit env: Env): Result
     protected def interpretStaticMethodCall(fn: Tree, args: => List[Result])(implicit env: Env): Result
+    protected def interpretModuleAccess(fn: Tree)(implicit env: Env): Result
     protected def interpretNew(fn: RefTree, args: => List[Result])(implicit env: Env): Result
     protected def unexpectedTree(tree: Tree)(implicit env: Env): Result
 
@@ -294,8 +295,13 @@ object Splicer {
       case _ if tree.symbol == defn.TastyTasty_macroContext =>
         interpretTastyContext()
 
-      case StaticMethodCall(fn, args) =>
-        interpretStaticMethodCall(fn, args.map(arg => interpretTree(arg)))
+      case StaticCall(fn, args) =>
+        if (fn.symbol.is(Module)) {
+          assert(args.isEmpty)
+          interpretModuleAccess(fn)
+        } else {
+          interpretStaticMethodCall(fn, args.map(arg => interpretTree(arg)))
+        }
 
       // Interpret `foo(j = x, i = y)` which it is expanded to
       // `val j$1 = x; val i$1 = y; foo(i = y, j = x)`
@@ -324,11 +330,11 @@ object Splicer {
         unexpectedTree(tree)
     }
 
-    object StaticMethodCall {
+    object StaticCall {
       def unapply(arg: Tree): Option[(RefTree, List[Tree])] = arg match {
         case fn: RefTree if fn.symbol.isStatic => Some((fn, Nil))
-        case Apply(StaticMethodCall(fn, args1), args2) => Some((fn, args1 ::: args2)) // TODO improve performance
-        case TypeApply(StaticMethodCall(fn, args), _) => Some((fn, args))
+        case Apply(StaticCall(fn, args1), args2) => Some((fn, args1 ::: args2)) // TODO improve performance
+        case TypeApply(StaticCall(fn, args), _) => Some((fn, args))
         case _ => None
       }
     }

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

@@ -679,7 +679,6 @@ trait Checking {
     tree.tpe.widenTermRefExpr match {
       case tp: ConstantType if exprPurity(tree) >= purityLevel => // ok
       case tp =>
-        // TODO: Make None and Some constant types?
         def isCaseClassApply(sym: Symbol): Boolean = {
           sym.name == nme.apply && (
             tree.symbol.owner == defn.SomeClass.companionModule.moduleClass ||
@@ -693,7 +692,8 @@ trait Checking {
           )
         }
         def isCaseObject(sym: Symbol): Boolean = {
-          tree.symbol.eq(defn.NoneModuleRef.termSymbol)
+          // TODO add alias to Nil in scala package
+          sym.is(Case) && sym.is(Module) && sym.isStatic
         }
         val allow =
           ctx.erasedTypes ||

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

@@ -24,6 +24,7 @@ i5119
 i5119b
 inline-varargs-1
 implicitShortcut
+inline-case-objects
 inline-option
 inline-tuples-1
 inline-tuples-2

tests/neg/inline-case-objects/Macro_1.scala

@@ -0,0 +1,16 @@
+
+import scala.quoted._
+
+object Macros {
+  def impl(foo: Any): Expr[String] = foo.getClass.getCanonicalName.toExpr
+}
+
+class Bar {
+  case object Baz
+}
+
+package foo {
+  class Bar {
+    case object Baz
+  }
+}

tests/neg/inline-case-objects/Main_2.scala

@@ -0,0 +1,11 @@
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    val bar = new Bar
+    println(fooString(bar.Baz)) // error
+  }
+
+  inline def fooString(inline x: Any): String = ~Macros.impl(x)
+
+}

tests/run/inline-case-objects.check

@@ -0,0 +1,6 @@
+scala.collection.immutable.Nil$
+scala.None$
+Bar$
+Bar.Baz$
+foo.Bar$
+Bar.Baz$

tests/run/inline-case-objects/Macro_1.scala

@@ -0,0 +1,16 @@
+
+import scala.quoted._
+
+object Macros {
+  def impl(foo: Any): Expr[String] = foo.getClass.getCanonicalName.toExpr
+}
+
+case object Bar {
+  case object Baz
+}
+
+package foo {
+  case object Bar {
+    case object Baz
+  }
+}

tests/run/inline-case-objects/Main_2.scala

@@ -0,0 +1,15 @@
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    println(fooString(scala.collection.immutable.Nil))
+    println(fooString(None))
+    println(fooString(Bar))
+    println(fooString(Bar.Baz))
+    println(fooString(foo.Bar))
+    println(fooString(foo.Bar.Baz))
+  }
+
+  inline def fooString(inline x: Any): String = ~Macros.impl(x)
+
+}