Add experimental Scala 2 macro compat

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -237,8 +237,10 @@ object desugar {
       cpy.TypeDef(tparam)(rhs = desugarContextBounds(tparam.rhs))
     }
 
-    val meth1 = addEvidenceParams(
-      cpy.DefDef(meth)(name = methName, tparams = tparams1), epbuf.toList)
+    val meth1 =
+      rhs match
+        case MacroTree(call) => cpy.DefDef(meth)(rhs = call).withMods(mods | Macro | Erased)
+        case _ => addEvidenceParams(cpy.DefDef(meth)(name = methName, tparams = tparams1), epbuf.toList)
 
     /** The longest prefix of parameter lists in vparamss whose total length does not exceed `n` */
     def takeUpTo(vparamss: List[List[ValDef]], n: Int): List[List[ValDef]] = vparamss match {

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -112,6 +112,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class ContextBounds(bounds: TypeBoundsTree, cxBounds: List[Tree])(implicit @constructorOnly src: SourceFile) extends TypTree
   case class PatDef(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree)(implicit @constructorOnly src: SourceFile) extends DefTree
   case class Export(expr: Tree, selectors: List[ImportSelector])(implicit @constructorOnly src: SourceFile) extends Tree
+  case class MacroTree(call: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
 
   case class ImportSelector(imported: Ident, renamed: Tree = EmptyTree, bound: Tree = EmptyTree)(implicit @constructorOnly src: SourceFile) extends Tree {
     // TODO: Make bound a typed tree?
@@ -736,6 +737,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         x
       case TypedSplice(splice) =>
         this(x, splice)
+      case MacroTree(call) =>
+        this(x, call)
       case _ =>
         super.foldMoreCases(x, tree)
     }

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -168,6 +168,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YexplicitNulls: Setting[Boolean] = BooleanSetting("-Yexplicit-nulls", "Make reference types non-nullable. Nullable types can be expressed with unions: e.g. String|Null.")
   val YerasedTerms: Setting[Boolean] = BooleanSetting("-Yerased-terms", "Allows the use of erased terms.")
   val YcheckInit: Setting[Boolean] = BooleanSetting("-Ycheck-init", "Check initialization of objects")
+  val YScala2ExperimentalCompat: Setting[Boolean] = BooleanSetting("-Yscala2-experimental-compat", "Allows Scala 2 macro definitions (no checks performed)")
 
   /** Area-specific debug output */
   val YexplainLowlevel: Setting[Boolean] = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -995,7 +995,11 @@ object SymDenotations {
       && allOverriddenSymbols.exists(!_.is(Inline))
 
     /** Is this a Scala 2 macro */
-    final def isScala2Macro(implicit ctx: Context): Boolean = is(Macro) && symbol.owner.is(Scala2x)
+    final def isScala2Macro(implicit ctx: Context): Boolean =
+      is(Macro, butNot = Inline) && (
+        is(Erased) // Scala 2 macro defined in Scala 3
+        || symbol.owner.is(Scala2x) // Scala 2 macro defined in Scala 2
+      )
 
     /** An erased value or an inline method.
      */

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2248,15 +2248,20 @@ object Parsers {
           newExpr()
         case MACRO =>
           val start = in.skipToken()
-          val call = ident()
-          // The standard library uses "macro ???" to denote "fast track" macros
-          // hardcoded in the compiler, don't issue an error for those macros
-          // since we want to be able to compile the standard library.
-          if (call `ne` nme.???)
-            syntaxError(
-              "Scala 2 macros are not supported, see https://dotty.epfl.ch/docs/reference/dropped-features/macros.html",
-              start)
-          unimplementedExpr
+          val call = simpleExpr()
+          call match
+            case Ident(name) if name eq nme.??? =>
+              // The standard library uses "macro ???" to denote "fast track" macros
+              // hardcoded in the compiler, don't issue an error for those macros
+              // since we want to be able to compile the standard library.
+              MacroTree(call)
+            case _ if ctx.settings.YScala2ExperimentalCompat.value =>
+              MacroTree(call)
+            case _ =>
+              syntaxError(
+                "Scala 2 macros are not supported, see https://dotty.epfl.ch/docs/reference/dropped-features/macros.html",
+                start)
+              unimplementedExpr
         case COLONEOL =>
           syntaxError("':' not allowed here")
           in.nextToken()

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -632,6 +632,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         toText(tree.app) ~ Str("(with integrated type args)").provided(printDebug)
       case Thicket(trees) =>
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
+      case MacroTree(call) =>
+        keywordStr("macro ") ~ toTextGlobal(call)
       case _ =>
         tree.fallbackToText(this)
     }
@@ -786,7 +788,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
         addVparamssText(prefix ~ tparamsText(tree.tparams), vparamss) ~
           optAscription(tree.tpt) ~
-          optText(tree.rhs)(" = " ~ _)
+          optText(tree.rhs)(" = " ~ keywordText("macro ").provided(tree.symbol.isScala2Macro) ~ _)
       }
     }
   }

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

@@ -435,7 +435,7 @@ class Namer { typer: Typer =>
     *  package members are not entered twice in the same run.
     */
   def enterSymbol(sym: Symbol)(using Context): Symbol = {
-    if (sym.exists) {
+    if (sym.exists && !sym.isScala2Macro) {
       typr.println(s"entered: $sym in ${ctx.owner}")
       ctx.enter(sym)
     }

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

@@ -0,0 +1,27 @@
+package dotty.tools.dotc.typer
+
+import dotty.tools.dotc.ast._
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.core._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Symbols._
+
+trait Scala2MacroDeclatration { self: Typer =>
+  import tpd._
+
+  /** Types the body Scala 2 macro declaration `def f = macro <body>` */
+  def typedScala2MacroBody(call: untpd.Tree)(using Context): Tree =
+    // TODO check that call is to a method with valid signature
+    call match
+      case rhs0: Ident =>
+        typedIdent(rhs0, defn.AnyType)
+      case rhs0: Select =>
+        typedSelect(rhs0, defn.AnyType)
+      case rhs0: TypeApply =>
+        typedTypeApply(rhs0, defn.AnyType)
+      case _ =>
+        ctx.error("Invalid Scala 2 macro", call.sourcePos)
+        EmptyTree
+
+}

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

@@ -91,6 +91,7 @@ class Typer extends Namer
                with Dynamic
                with Checking
                with QuotesAndSplices
+               with Scala2MacroDeclatration
                with Deriving {
 
   import Typer._
@@ -1862,12 +1863,14 @@ class Typer extends Namer
         }
       }
     }
-
     if (sym.isInlineMethod) rhsCtx.addMode(Mode.InlineableBody)
-    val rhs1 = typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(using rhsCtx)
-    val rhsToInline = PrepareInlineable.wrapRHS(ddef, tpt1, rhs1)
+
+    val rhs1 =
+      if sym.isScala2Macro then typedScala2MacroBody(ddef.rhs)(using rhsCtx)
+      else typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(using rhsCtx)
 
     if (sym.isInlineMethod)
+      val rhsToInline = PrepareInlineable.wrapRHS(ddef, tpt1, rhs1)
       PrepareInlineable.registerInlineInfo(sym, rhsToInline)
 
     if (sym.isConstructor && !sym.isPrimaryConstructor) {

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -65,6 +65,9 @@ class CompilationTests extends ParallelTesting {
       compileFile("tests/pos-special/kind-projector.scala", defaultOptions.and("-Ykind-projector")),
       compileFile("tests/run/i5606.scala", defaultOptions.and("-Yretain-trees")),
       compileFile("tests/pos-custom-args/i5498-postfixOps.scala", defaultOptions withoutLanguageFeature "postfixOps"),
+      compileFile("tests/pos-custom-args/scala2-macro-compat-1.scala", defaultOptions.and("-Yscala2-experimental-compat")),
+      compileFile("tests/pos-custom-args/scala2-macro-compat-2.scala", defaultOptions.and("-Yscala2-experimental-compat")),
+
     ).checkCompile()
   }
 

tests/neg-macro-compat/Macro1.scala

@@ -0,0 +1,16 @@
+import scala.language.experimental.macros
+import scala.reflect.macros._
+
+object Macros {
+
+  def foo0(x: Int): Int = macro foo0Impl // error
+  def foo1(x: Int): Int = macro foo1Impl // error
+  def foo2(x: Int, y: String): Int = macro foo2Impl // error
+  def foo3(x: Int): Int = macro foo3Impl // error
+
+  def foo0Impl: Nothing = ???
+  def foo1Impl(context: scala.reflect.macros.Context)(x: context.Expr[String]): context.Expr[Int] = ???
+  def foo2Impl(context: scala.reflect.macros.Context)(x: context.Expr[Int], y: context.Expr[String]): Nothing = ???
+  def foo3Impl(x: Int): Int = ???
+
+}

tests/pos-custom-args/scala2-macro-compat-1.scala

@@ -0,0 +1,26 @@
+
+
+object Macro1 {
+  import scala.language.experimental.macros
+  def lineNumber: Int = macro LineNumberMacro2.thisLineNumberImpl
+  inline def lineNumber: Int = ${ LineNumberMacro3.thisLineNumberExpr }
+}
+
+object LineNumberMacro2 {
+  class Context: // Dummy scala.reflect.macros.Context
+    type Expr[+T]
+
+  def thisLineNumberImpl(context: Context): context.Expr[Int] = {
+    // val lineNumber = context.enclosingPosition.line
+    // context.literal(lineNumber)
+    ???
+  }
+}
+
+object LineNumberMacro3 {
+  import scala.quoted._
+  def thisLineNumberExpr(using qctx: QuoteContext): Expr[Int] = {
+    import qctx.tasty.{_, given _}
+    Expr(rootPosition.startLine + 1)
+  }
+}

tests/pos-custom-args/scala2-macro-compat-2.scala

@@ -0,0 +1,14 @@
+import scala.language.experimental.macros
+
+class Context: // Dummy scala.reflect.macros.Context
+  type Expr[T]
+
+object Macros {
+
+  def foo1(x: Int): Int = macro foo1Impl
+  def foo2(x: Int, y: String): Int = macro foo2Impl
+
+  def foo1Impl(context: Context)(x: context.Expr[Int]): context.Expr[Int] = ???
+  def foo2Impl(context: Context)(x: context.Expr[Int], y: context.Expr[String]): context.Expr[Int] = ???
+
+}