Add MacroTransform that allows implicit search

Also, drop redundant clause in existing MacroTransform

Author: odersky

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

@@ -359,6 +359,15 @@ object Contexts {
       else if (untpd.isSuperConstrCall(stat) && this.owner.isClass) superCallContext
       else ctx.fresh.setOwner(exprOwner)
 
+    /** A new context that summarizes an import statement */
+    def importContext(imp: Import[_], sym: Symbol) = {
+      val impNameOpt = imp.expr match {
+        case ref: RefTree[_] => Some(ref.name.asTermName)
+        case _               => None
+      }
+      ctx.fresh.setImportInfo(new ImportInfo(implicit ctx => sym, imp.selectors, impNameOpt))
+    }
+
     /** The current source file; will be derived from current
      *  compilation unit.
      */

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

@@ -276,6 +276,10 @@ object Phases {
      *  and type applications.
      */
     def relaxedTyping: Boolean = false
+
+    /** If set, implicit search is enabled */
+    def allowsImplicitSearch: Boolean = false
+
      /** List of names of phases that should precede this phase */
     def runsAfter: Set[Class[_ <: Phase]] = Set.empty
 

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

@@ -41,7 +41,6 @@ abstract class MacroTransform extends Phase {
     def transformStats(trees: List[Tree], exprOwner: Symbol)(implicit ctx: Context): List[Tree] = {
       def transformStat(stat: Tree): Tree = stat match {
         case _: Import | _: DefTree => transform(stat)
-        case Thicket(stats) => cpy.Thicket(stat)(stats mapConserve transformStat)
         case _ => transform(stat)(ctx.exprContext(stat, exprOwner))
       }
       flatten(trees.mapconserve(transformStat(_)))

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

@@ -0,0 +1,90 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import typer._
+import ast.Trees._
+import Contexts._
+import Symbols._
+import Decorators._
+import collection.mutable
+import annotation.tailrec
+
+/** A Macrotransform that maintains the necessary infrastructore to support
+ *  contxtual implicit searches (type-scope implicits are supported anyway).
+ */
+abstract class MacroTransformWithImplicits extends MacroTransform {
+  import ast.tpd._
+
+  override def allowsImplicitSearch = true
+
+  class ImplicitsTransformer extends Transformer {
+
+    /** Transform statements, while maintaining import contexts and expression contexts
+     *  in the same way as Typer does. The code addresses additional concerns:
+     *   - be tail-recursive where possible
+     *   - don't re-allocate trees where nothing has changed
+     */
+    override def transformStats(stats: List[Tree], exprOwner: Symbol)(implicit ctx: Context): List[Tree] = {
+
+      @tailrec def traverse(curStats: List[Tree])(implicit ctx: Context): List[Tree] = {
+
+        def recur(stats: List[Tree], changed: Tree, rest: List[Tree])(implicit ctx: Context): List[Tree] = {
+          if (stats eq curStats) {
+            val rest1 = transformStats(rest, exprOwner)
+            changed match {
+              case Thicket(trees) => trees ::: rest1
+              case tree => tree :: rest1
+            }
+          }
+          else stats.head :: recur(stats.tail, changed, rest)
+        }
+
+        curStats match {
+          case stat :: rest =>
+            val statCtx = stat match {
+              case stat: DefTree => ctx
+              case _ => ctx.exprContext(stat, exprOwner)
+            }
+            val restCtx = stat match {
+              case stat: Import => ctx.importContext(stat, stat.symbol)
+              case _ => ctx
+            }
+            val stat1 = transform(stat)(statCtx)
+            if (stat1 ne stat) recur(stats, stat1, rest)(restCtx)
+            else traverse(rest)(restCtx)
+          case nil =>
+            stats
+        }
+      }
+      traverse(stats)
+    }
+
+    private def nestedScopeCtx(defs: List[Tree])(implicit ctx: Context): Context = {
+      val nestedCtx = ctx.fresh.setNewScope
+      defs foreach {
+        case d: DefTree => nestedCtx.enter(d.symbol)
+        case _ =>
+      }
+      nestedCtx
+    }
+
+    override def transform(tree: Tree)(implicit ctx: Context): Tree = {
+      def localCtx = ctx.withOwner(tree.symbol)
+      tree match {
+        case tree: Block =>
+          super.transform(tree)(nestedScopeCtx(tree.stats))
+        case tree: DefDef =>
+          implicit val ctx = localCtx
+          cpy.DefDef(tree)(
+            tree.name,
+            transformSub(tree.tparams),
+            tree.vparamss mapConserve (transformSub(_)),
+            transform(tree.tpt),
+            transform(tree.rhs)(nestedScopeCtx(tree.vparamss.flatten)))
+        case _ =>
+          super.transform(tree)
+      }
+    }
+  }
+}

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

@@ -19,6 +19,8 @@ class FrontEnd extends Phase {
   override def isTyper = true
   import ast.tpd
 
+  override def allowsImplicitSearch = true
+
   /** The contexts for compilation units that are parsed but not yet entered */
   private[this] var remaining: List[Context] = Nil
 

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

@@ -749,7 +749,7 @@ trait Implicits { self: Typer =>
    *  !!! todo: catch potential cycles
    */
   def inferImplicit(pt: Type, argument: Tree, pos: Position)(implicit ctx: Context): SearchResult = track("inferImplicit") {
-    assert(!ctx.isAfterTyper,
+    assert(ctx.phase.allowsImplicitSearch,
       if (argument.isEmpty) i"missing implicit parameter of type $pt after typer"
       else i"type error: ${argument.tpe} does not conform to $pt${err.whyNoMatchStr(argument.tpe, pt)}")
     trace(s"search implicit ${pt.show}, arg = ${argument.show}: ${argument.tpe.show}", implicits, show = true) {

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

@@ -385,15 +385,6 @@ class Namer { typer: Typer =>
     case _ => tree
   }
 
-  /** A new context that summarizes an import statement */
-  def importContext(imp: Import, sym: Symbol)(implicit ctx: Context) = {
-    val impNameOpt = imp.expr match {
-      case ref: RefTree => Some(ref.name.asTermName)
-      case _            => None
-    }
-    ctx.fresh.setImportInfo(new ImportInfo(implicit ctx => sym, imp.selectors, impNameOpt))
-  }
-
   /** A new context for the interior of a class */
   def inClassContext(selfInfo: DotClass /* Should be Type | Symbol*/)(implicit ctx: Context): Context = {
     val localCtx: Context = ctx.fresh.setNewScope
@@ -441,7 +432,7 @@ class Namer { typer: Typer =>
         setDocstring(pkg, stat)
         ctx
       case imp: Import =>
-        importContext(imp, createSymbol(imp))
+        ctx.importContext(imp, createSymbol(imp))
       case mdef: DefTree =>
         val sym = enterSymbol(createSymbol(mdef))
         setDocstring(sym, origStat)

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

@@ -1775,7 +1775,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case (imp: untpd.Import) :: rest =>
         val imp1 = typed(imp)
         buf += imp1
-        traverse(rest)(importContext(imp, imp1.symbol))
+        traverse(rest)(ctx.importContext(imp, imp1.symbol))
       case (mdef: untpd.DefTree) :: rest =>
         mdef.removeAttachment(ExpandedTree) match {
           case Some(xtree) =>