Analyzer Plugins

AnnotationCheckers are insufficient because they live outside the
compiler cake and it's not possible to pass a Typer into an annotation
checker.

Analyzer plugins hook into important places of the compiler:

  - when the namer assigns a type to a symbol (plus a special hook for
    accessors)
  - before typing a tree, to modify the expected type
  - after typing a tree, to modify the type assigned to the tree

Analyzer plugins and annotation checker can be activated only during
selected phases of the compiler.

Refactored the CPS plugin to use an analyzer plugin (since
adaptToAnnotations is now part of analyzer plugins, no longer
annotation checkers).

6 files changed, 265 insertions, 28 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
index 78175f393a..b50486306d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
@@ -25,6 +25,7 @@ trait Analyzer extends AnyRef
             with TypeDiagnostics
             with ContextErrors
             with StdAttachments
+            with AnalyzerPlugins
 {
   val global : Global
   import global._
diff --git a/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala b/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala
new file mode 100644
index 0000000000..28f620dbb5
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala
@@ -0,0 +1,225 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2013 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package scala.tools.nsc
+package typechecker
+
+/**
+ *  @author Lukas Rytz
+ *  @version 1.0
+ */
+trait AnalyzerPlugins { self: Analyzer =>
+  import global._
+
+
+  trait AnalyzerPlugin {
+    /**
+     * Selectively activate this analyzer plugin, e.g. according to the compiler phase.
+     *
+     * Note that the current phase can differ from the global compiler phase (look for `enteringPhase`
+     * invocations in the compiler). For instance, lazy types created by the UnPickler are completed
+     * at the phase in which their symbol is created. Observations show that this can even be the
+     * parser phase. Since symbol completion can trigger subtyping, typing etc, your plugin might
+     * need to be active also in phases other than namer and typer.
+     *
+     * Typically, this method can be implemented as
+     *
+     *   global.phase.id < global.currentRun.picklerPhase.id
+     */
+    def isActive(): Boolean = true
+
+    /**
+     * Let analyzer plugins change the expected type before type checking a tree.
+     */
+    def pluginsPt(pt: Type, typer: Typer, tree: Tree, mode: Int): Type = pt
+
+    /**
+     * Let analyzer plugins modify the type that has been computed for a tree.
+     *
+     * @param tpe   The type inferred by the type checker, initially (for first plugin) `tree.tpe`
+     * @param typer The yper that type checked `tree`
+     * @param tree  The type-checked tree
+     * @param mode  Mode that was used for typing `tree`
+     * @param pt    Expected type that was used for typing `tree`
+     */
+    def pluginsTyped(tpe: Type, typer: Typer, tree: Tree, mode: Int, pt: Type): Type = tpe
+
+    /**
+     * Let analyzer plugins change the types assigned to definitions. For definitions that have
+     * an annotated type, the assigned type is obtained by typing that type tree. Otherwise, the
+     * type is inferred by typing the definition's righthand side.
+     *
+     * In order to know if the type was inferred, you can query the `wasEmpty` field in the `tpt`
+     * TypeTree of the definition (for DefDef and ValDef).
+     *
+     * (*) If the type of a method or value is inferred, the type-checked tree is stored in the
+     * `analyzer.transformed` hash map, indexed by the definition's rhs tree.
+     *
+     * NOTE: Invoking the type checker can lead to cyclic reference errors. For instance, if this
+     * method is called from the type completer of a recursive method, type checking the mehtod
+     * rhs will invoke the same completer again. It might be possible to avoid this situation by
+     * assigning `tpe` to `defTree.symbol` (untested) - the final type computed by this method
+     * will then be assigned to the definition's symbol by monoTypeCompleter (in Namers).
+     *
+     * The hooks into `typeSig` allow analyzer plugins to add annotations to (or change the types
+     * of) definition symbols. This cannot not be achieved by using `pluginsTyped`: this method
+     * is only called during type checking, so changing the type of a symbol at this point is too
+     * late: references to the symbol might already be typed and therefore obtain the the original
+     * type assigned during naming.
+     *
+     * @param defTree is the definition for which the type was computed. The different cases are
+     * outlined below. Note that this type is untyped (for methods and values with inferred type,
+     * the typed rhs trees are available in analyzer.transformed).
+     *
+     * Case defTree: Template
+     *   - tpe  : A ClassInfoType for the template
+     *   - typer: The typer for template members, i.e. expressions and definitions of defTree.body
+     *   - pt   : WildcardType
+     *   - the class symbol is accessible through typer.context.owner
+     *
+     * Case defTree: ClassDef
+     *   - tpe  : A ClassInfoType, or a PolyType(params, ClassInfoType) for polymorphic classes.
+     *            The class type is the one computed by templateSig, i.e. through the above case
+     *   - typer: The typer for the class. Note that this typer has a different context than the
+     *            typer for the template.
+     *   - pt   : WildcardType
+     *
+     * Case defTree: ModuleDef
+     *   - tpe  : A ClassInfoType computed by templateSig
+     *   - typer: The typer for the module. context.owner of this typer is the module class symbol
+     *   - pt   : WildcardType
+     *
+     * Case defTree: DefDef
+     *   - tpe  : The type of the method (MethodType, PolyType or NullaryMethodType). (*)
+     *   - typer: The typer the rhs of this method
+     *   - pt   : If tpt.isEmpty, either the result type from the overridden method, or WildcardType.
+     *            Otherwise the type obtained from typing tpt.
+     *   - Note that for constructors, pt is the class type which the constructor creates. To type
+     *     check the rhs of the constructor however, the expected type has to be WildcardType (see
+     *     Typers.typedDefDef)
+     *
+     * Case defTree: ValDef
+     *   - tpe  : The type of this value. (*)
+     *   - typer: The typer for the rhs of this value
+     *   - pt   : If tpt.isEmpty, WildcardType. Otherwise the type obtained from typing tpt.
+     *   - Note that pluginsTypeSig might be called multiple times for the same ValDef since it is
+     *     used to compute the types of the accessor methods (see `pluginsTypeSigAccessor`)
+     *
+     * Case defTree: TypeDef
+     *   - tpe  : The type obtained from typing rhs (PolyType if the TypeDef defines a polymorphic type)
+     *   - typer: The typer for the rhs of this type
+     *   - pt   : WildcardType
+     */
+    def pluginsTypeSig(tpe: Type, typer: Typer, defTree: Tree, pt: Type): Type = tpe
+
+    /**
+     * Modify the types of field accessors. The namer phase creates method types for getters and
+     * setters based on the type of the corresponding field.
+     *
+     * Note: in order to compute the method type of an accessor, the namer calls `typeSig` on the
+     * `ValDef` tree of the corresponding field. This implies that the `pluginsTypeSig` method
+     * is potentially called multiple times for the same ValDef tree.
+     *
+     * @param tpe   The method type created by the namer for the accessor
+     * @param typer The typer for the ValDef (not for the rhs)
+     * @param tree  The ValDef corresponding to the accessor
+     * @param sym   The accessor method symbol (getter, setter, beanGetter or beanSetter)
+     */
+    def pluginsTypeSigAccessor(tpe: Type, typer: Typer, tree: ValDef, sym: Symbol): Type = tpe
+
+    /**
+     * Decide whether this analyzer plugin can adapt a tree that has an annotated type to the
+     * given type tp, taking into account the given mode (see method adapt in trait Typers).
+     */
+    def canAdaptAnnotations(tree: Tree, typer: Typer, mode: Int, pt: Type): Boolean = false
+
+    /**
+     * Adapt a tree that has an annotated type to the given type tp, taking into account the given
+     * mode (see method adapt in trait Typers).
+     *
+     * An implementation cannot rely on canAdaptAnnotations being called before. If the implementing
+     * class cannot do the adapting, it should return the tree unchanged.
+     */
+    def adaptAnnotations(tree: Tree, typer: Typer, mode: Int, pt: Type): Tree = tree
+
+    /**
+     * Modify the type of a return expression. By default, return expressions have type
+     * NothingClass.tpe.
+     *
+     * @param tpe   The type of the return expression
+     * @param typer The typer that was used for typing the return tree
+     * @param tree  The typed return expression tree
+     * @param pt    The return type of the enclosing method
+     */
+    def pluginsTypedReturn(tpe: Type, typer: Typer, tree: Return, pt: Type): Type = tpe
+  }
+
+
+
+  /** A list of registered analyzer plugins */
+  private var analyzerPlugins: List[AnalyzerPlugin] = Nil
+
+  /** Registers a new analyzer plugin */
+  def addAnalyzerPlugin(plugin: AnalyzerPlugin) {
+    if (!analyzerPlugins.contains(plugin))
+      analyzerPlugins = plugin :: analyzerPlugins
+  }
+
+
+  /** @see AnalyzerPlugin.pluginsPt */
+  def pluginsPt(pt: Type, typer: Typer, tree: Tree, mode: Int): Type =
+    if (analyzerPlugins.isEmpty) pt
+    else analyzerPlugins.foldLeft(pt)((pt, plugin) =>
+      if (!plugin.isActive()) pt else plugin.pluginsPt(pt, typer, tree, mode))
+
+  /** @see AnalyzerPlugin.pluginsTyped */
+  def pluginsTyped(tpe: Type, typer: Typer, tree: Tree, mode: Int, pt: Type): Type = {
+    // support deprecated methods in annotation checkers
+    val annotCheckersTpe = addAnnotations(tree, tpe)
+    if (analyzerPlugins.isEmpty) annotCheckersTpe
+    else analyzerPlugins.foldLeft(annotCheckersTpe)((tpe, plugin) =>
+      if (!plugin.isActive()) tpe else plugin.pluginsTyped(tpe, typer, tree, mode, pt))
+  }
+
+  /** @see AnalyzerPlugin.pluginsTypeSig */
+  def pluginsTypeSig(tpe: Type, typer: Typer, defTree: Tree, pt: Type): Type =
+    if (analyzerPlugins.isEmpty) tpe
+    else analyzerPlugins.foldLeft(tpe)((tpe, plugin) =>
+      if (!plugin.isActive()) tpe else plugin.pluginsTypeSig(tpe, typer, defTree, pt))
+
+  /** @see AnalyzerPlugin.pluginsTypeSigAccessor */
+  def pluginsTypeSigAccessor(tpe: Type, typer: Typer, tree: ValDef, sym: Symbol): Type =
+    if (analyzerPlugins.isEmpty) tpe
+    else analyzerPlugins.foldLeft(tpe)((tpe, plugin) =>
+      if (!plugin.isActive()) tpe else plugin.pluginsTypeSigAccessor(tpe, typer, tree, sym))
+
+  /** @see AnalyzerPlugin.canAdaptAnnotations */
+  def canAdaptAnnotations(tree: Tree, typer: Typer, mode: Int, pt: Type): Boolean = {
+    // support deprecated methods in annotation checkers
+    val annotCheckersExists = global.canAdaptAnnotations(tree, mode, pt)
+    annotCheckersExists || {
+      if (analyzerPlugins.isEmpty) false
+      else analyzerPlugins.exists(plugin =>
+        plugin.isActive() && plugin.canAdaptAnnotations(tree, typer, mode, pt))
+    }
+  }
+
+  /** @see AnalyzerPlugin.adaptAnnotations */
+  def adaptAnnotations(tree: Tree, typer: Typer, mode: Int, pt: Type): Tree = {
+    // support deprecated methods in annotation checkers
+    val annotCheckersTree = global.adaptAnnotations(tree, mode, pt)
+    if (analyzerPlugins.isEmpty) annotCheckersTree
+    else analyzerPlugins.foldLeft(annotCheckersTree)((tree, plugin) =>
+      if (!plugin.isActive()) tree else plugin.adaptAnnotations(tree, typer, mode, pt))
+  }
+
+  /** @see AnalyzerPlugin.pluginsTypedReturn */
+  def pluginsTypedReturn(tpe: Type, typer: Typer, tree: Return, pt: Type): Type = {
+    val annotCheckersType = adaptTypeOfReturn(tree.expr, pt, tpe)
+    if (analyzerPlugins.isEmpty) annotCheckersType
+    else analyzerPlugins.foldLeft(annotCheckersType)((tpe, plugin) =>
+      if (!plugin.isActive()) tpe else plugin.pluginsTypedReturn(tpe, typer, tree, pt))
+  }
+}
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index 579eacb08d..620665126e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -35,7 +35,7 @@ trait Contexts { self: Analyzer =>
     val completeList     = JavaLangPackage :: ScalaPackage :: PredefModule :: Nil
   }
 
-  private val startContext = {
+  private lazy val startContext = {
     NoContext.make(
     Template(List(), emptyValDef, List()) setSymbol global.NoSymbol setType global.NoType,
     rootMirror.RootClass,
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 581f9f3bfa..0fad744506 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -257,8 +257,8 @@ trait Infer extends Checkable {
       tp1 // @MAT aliases already handled by subtyping
   }
 
-  private val stdErrorClass = rootMirror.RootClass.newErrorClass(tpnme.ERROR)
-  private val stdErrorValue = stdErrorClass.newErrorValue(nme.ERROR)
+  private lazy val stdErrorClass = rootMirror.RootClass.newErrorClass(tpnme.ERROR)
+  private lazy val stdErrorValue = stdErrorClass.newErrorValue(nme.ERROR)
 
   /** The context-dependent inferencer part */
   class Inferencer(context: Context) extends InferencerContextErrors with InferCheckable {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 833a606565..c728185d4e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -755,10 +755,9 @@ trait Namers extends MethodSynthesis {
     def accessorTypeCompleter(tree: ValDef, isSetter: Boolean) = mkTypeCompleter(tree) { sym =>
       logAndValidate(sym) {
         sym setInfo {
-          if (isSetter)
-            MethodType(List(sym.newSyntheticValueParam(typeSig(tree))), UnitClass.tpe)
-          else
-            NullaryMethodType(typeSig(tree))
+          val tp = if (isSetter) MethodType(List(sym.newSyntheticValueParam(typeSig(tree))), UnitClass.tpe)
+                   else NullaryMethodType(typeSig(tree))
+          pluginsTypeSigAccessor(tp, typer, tree, sym)
         }
       }
     }
@@ -903,7 +902,8 @@ trait Namers extends MethodSynthesis {
       for (cda <- module.attachments.get[ConstructorDefaultsAttachment]) {
         cda.companionModuleClassNamer = templateNamer
       }
-      ClassInfoType(parents, decls, clazz)
+      val classTp = ClassInfoType(parents, decls, clazz)
+      pluginsTypeSig(classTp, templateNamer.typer, templ, WildcardType)
     }
 
     private def classSig(cdef: ClassDef): Type = {
@@ -913,17 +913,18 @@ trait Namers extends MethodSynthesis {
       val resultType = templateSig(impl)
 
       val res = GenPolyType(tparams0, resultType)
+      val pluginsTp = pluginsTypeSig(res, typer, cdef, WildcardType)
 
       // Already assign the type to the class symbol (monoTypeCompleter will do it again).
       // Allows isDerivedValueClass to look at the info.
-      clazz setInfo res
+      clazz setInfo pluginsTp
       if (clazz.isDerivedValueClass) {
         log("Ensuring companion for derived value class " + cdef.name + " at " + cdef.pos.show)
         clazz setFlag FINAL
         // Don't force the owner's info lest we create cycles as in SI-6357.
         enclosingNamerWithScope(clazz.owner.rawInfo.decls).ensureCompanionObject(cdef)
       }
-      res
+      pluginsTp
     }
 
     private def moduleSig(mdef: ModuleDef): Type = {
@@ -931,9 +932,10 @@ trait Namers extends MethodSynthesis {
       // The info of both the module and the moduleClass symbols need to be assigned. monoTypeCompleter assigns
       // the result of typeSig to the module symbol. The module class info is assigned here as a side-effect.
       val result = templateSig(mdef.impl)
+      val pluginsTp = pluginsTypeSig(result, typer, mdef, WildcardType)
       // Assign the moduleClass info (templateSig returns a ClassInfoType)
       val clazz = moduleSym.moduleClass
-      clazz setInfo result
+      clazz setInfo pluginsTp
       // clazz.tpe returns a `ModuleTypeRef(clazz)`, a typeRef that links to the module class `clazz`
       // (clazz.info would the ClassInfoType, which is not what should be assigned to the module symbol)
       clazz.tpe
@@ -1134,7 +1136,7 @@ trait Namers extends MethodSynthesis {
         typer.computeMacroDefType(ddef, resTpFromOverride)
       }
 
-      thisMethodType({
+      val res = thisMethodType({
         val rt = (
           if (!tpt.isEmpty) {
             methResTp
@@ -1150,6 +1152,7 @@ trait Namers extends MethodSynthesis {
           rt.withAnnotation(AnnotationInfo(uncheckedVarianceClass.tpe, List(), List()))
         else rt
       })
+      pluginsTypeSig(res, typer, ddef, methResTp)
     }
 
     /**
@@ -1286,7 +1289,7 @@ trait Namers extends MethodSynthesis {
 
     private def valDefSig(vdef: ValDef) = {
       val ValDef(_, _, tpt, rhs) = vdef
-      if (tpt.isEmpty) {
+      val result = if (tpt.isEmpty) {
         if (rhs.isEmpty) {
           MissingParameterOrValTypeError(tpt)
           ErrorType
@@ -1295,6 +1298,8 @@ trait Namers extends MethodSynthesis {
       } else {
         typer.typedType(tpt).tpe
       }
+      pluginsTypeSig(result, typer, vdef, if (tpt.isEmpty) WildcardType else result)
+
     }
 
     //@M! an abstract type definition (abstract type member/type parameter)
@@ -1328,7 +1333,8 @@ trait Namers extends MethodSynthesis {
       // However, separate compilation requires the symbol info to be
       // loaded to do this check, but loading the info will probably
       // lead to spurious cyclic errors.  So omit the check.
-      GenPolyType(tparamSyms, tp)
+      val res = GenPolyType(tparamSyms, tp)
+      pluginsTypeSig(res, typer, tdef, WildcardType)
     }
 
     private def importSig(imp: Import) = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 1154173d85..a910d0b608 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -872,7 +872,9 @@ trait Typers extends Modes with Adaptations with Tags {
               case _ =>
                 debuglog("fallback on implicits: " + tree + "/" + resetAllAttrs(original))
                 val tree1 = typed(resetAllAttrs(original), mode, WildcardType)
-                tree1.tpe = addAnnotations(tree1, tree1.tpe)
+                // Q: `typed` already calls `pluginsTyped` and `adapt`. the only difference here is that
+                // we pass `EmptyTree` as the `original`. intended? added in 2009 (53d98e7d42) by martin.
+                tree1.tpe = pluginsTyped(tree1.tpe, this, tree1, mode, pt)
                 if (tree1.isEmpty) tree1 else adapt(tree1, mode, pt, EmptyTree)
             }
           else
@@ -1077,8 +1079,8 @@ trait Typers extends Modes with Adaptations with Tags {
 
       // begin adapt
       tree.tpe match {
-        case atp @ AnnotatedType(_, _, _) if canAdaptAnnotations(tree, mode, pt) => // (-1)
-          adaptAnnotations(tree, mode, pt)
+        case atp @ AnnotatedType(_, _, _) if canAdaptAnnotations(tree, this, mode, pt) => // (-1)
+          adaptAnnotations(tree, this, mode, pt)
         case ct @ ConstantType(value) if inNoModes(mode, TYPEmode | FUNmode) && (ct <:< pt) && !forScaladoc && !forInteractive => // (0)
           val sym = tree.symbol
           if (sym != null && sym.isDeprecated) {
@@ -1182,8 +1184,8 @@ trait Typers extends Modes with Adaptations with Tags {
                           Select(tree, "to" + sym.name)
                         }
                       }
-                    case AnnotatedType(_, _, _) if canAdaptAnnotations(tree, mode, pt) => // (13)
-                      return typed(adaptAnnotations(tree, mode, pt), mode, pt)
+                    case AnnotatedType(_, _, _) if canAdaptAnnotations(tree, this, mode, pt) => // (13)
+                      return typed(adaptAnnotations(tree, this, mode, pt), mode, pt)
                     case _ =>
                   }
                   if (!context.undetparams.isEmpty) {
@@ -4467,8 +4469,9 @@ trait Typers extends Modes with Adaptations with Tags {
               if (typed(expr).tpe.typeSymbol != UnitClass)
                 unit.warning(tree.pos, "enclosing method " + name + " has result type Unit: return value discarded")
             }
-            treeCopy.Return(tree, checkDead(expr1)).setSymbol(enclMethod.owner)
-                                                   .setType(adaptTypeOfReturn(expr1, restpt.tpe, NothingClass.tpe))
+            val res = treeCopy.Return(tree, checkDead(expr1)).setSymbol(enclMethod.owner)
+            val tp = pluginsTypedReturn(NothingClass.tpe, this, res, restpt.tpe)
+            res.setType(tp)
           }
         }
       }
@@ -5666,11 +5669,13 @@ trait Typers extends Modes with Adaptations with Tags {
       lastTreeToTyper = tree
       indentTyping()
 
+      val ptPlugins = pluginsPt(pt, this, tree, mode)
+
       val startByType = if (Statistics.canEnable) Statistics.pushTimer(byTypeStack, byTypeNanos(tree.getClass)) else null
       if (Statistics.canEnable) Statistics.incCounter(visitsByType, tree.getClass)
       try {
         if (context.retyping &&
-            (tree.tpe ne null) && (tree.tpe.isErroneous || !(tree.tpe <:< pt))) {
+            (tree.tpe ne null) && (tree.tpe.isErroneous || !(tree.tpe <:< ptPlugins))) {
           tree.tpe = null
           if (tree.hasSymbol) tree.symbol = NoSymbol
         }
@@ -5678,7 +5683,7 @@ trait Typers extends Modes with Adaptations with Tags {
         val alreadyTyped = tree.tpe ne null
         var tree1: Tree = if (alreadyTyped) tree else {
           printTyping(
-            ptLine("typing %s: pt = %s".format(ptTree(tree), pt),
+            ptLine("typing %s: pt = %s".format(ptTree(tree), ptPlugins),
               "undetparams"      -> context.undetparams,
               "implicitsEnabled" -> context.implicitsEnabled,
               "enrichmentEnabled"   -> context.enrichmentEnabled,
@@ -5687,7 +5692,7 @@ trait Typers extends Modes with Adaptations with Tags {
               "context.owner"    -> context.owner
             )
           )
-          typed1(tree, mode, dropExistential(pt))
+          typed1(tree, mode, dropExistential(ptPlugins))
         }
         // Can happen during erroneous compilation - error(s) have been
         // reported, but we need to avoid causing an NPE with this tree
@@ -5701,12 +5706,12 @@ trait Typers extends Modes with Adaptations with Tags {
           )
         }
 
-        tree1.tpe = addAnnotations(tree1, tree1.tpe)
-        val result = if (tree1.isEmpty) tree1 else adapt(tree1, mode, pt, tree)
+        tree1.tpe = pluginsTyped(tree1.tpe, this, tree1, mode, ptPlugins)
+        val result = if (tree1.isEmpty) tree1 else adapt(tree1, mode, ptPlugins, tree)
 
         if (!alreadyTyped) {
           printTyping("adapted %s: %s to %s, %s".format(
-            tree1, tree1.tpe.widen, pt, context.undetparamsString)
+            tree1, tree1.tpe.widen, ptPlugins, context.undetparamsString)
           ) //DEBUG
         }
         if (!isPastTyper) signalDone(context.asInstanceOf[analyzer.Context], tree, result)
@@ -5721,7 +5726,7 @@ trait Typers extends Modes with Adaptations with Tags {
           setError(tree)
         case ex: Exception =>
           if (settings.debug.value) // @M causes cyclic reference error
-            Console.println("exception when typing "+tree+", pt = "+pt)
+            Console.println("exception when typing "+tree+", pt = "+ptPlugins)
           if (context != null && context.unit.exists && tree != null)
             logError("AT: " + (tree.pos).dbgString, ex)
           throw ex