Merge pull request #2061 from lrytz/analyzerPluginsMaster

Merge Analyzer Plugins for Master

29 files changed, 1135 insertions, 382 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 63908a38e3..413ef473c3 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -213,15 +213,22 @@ abstract class UnCurry extends InfoTransform
      *    new $anon()
      *
      */
-    def transformFunction(fun: Function): Tree =
+    def transformFunction(fun: Function): Tree = {
+      fun.tpe match {
+        // can happen when analyzer plugins assign refined types to functions, e.g.
+        // (() => Int) { def apply(): Int @typeConstraint }
+        case RefinedType(List(funTp), decls) =>
+          debuglog(s"eliminate refinement from function type ${fun.tpe}")
+          fun.tpe = funTp
+        case _ =>
+          ()
+      }
+
       deEta(fun) match {
         // nullary or parameterless
         case fun1 if fun1 ne fun => fun1
         case _ =>
-          val parents = (
-            if (isFunctionType(fun.tpe)) addSerializable(abstractFunctionForFunctionType(fun.tpe))
-            else addSerializable(ObjectClass.tpe, fun.tpe)
-          )
+          val parents = addSerializable(abstractFunctionForFunctionType(fun.tpe))
           val anonClass = fun.symbol.owner newAnonymousFunctionClass(fun.pos, inConstructorFlag) addAnnotation serialVersionUIDAnnotation
           anonClass setInfo ClassInfoType(parents, newScope, anonClass)
 
@@ -254,6 +261,7 @@ abstract class UnCurry extends InfoTransform
           }
 
       }
+    }
 
     def transformArgs(pos: Position, fun: Symbol, args: List[Tree], formals: List[Type]) = {
       val isJava = fun.isJavaDefined
diff --git a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
index d4d6def3cb..36121f2653 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
@@ -24,6 +24,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..4210d0b9fb
--- /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: Mode): 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: Mode, 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: Mode, 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: Mode, 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: Mode): 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: Mode, 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: Mode, 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: Mode, 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 a160a9894e..22a28b7895 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -39,7 +39,7 @@ trait Contexts { self: Analyzer =>
   def ambiguousDefnAndImport(owner: Symbol, imp: ImportInfo) =
     LookupAmbiguous(s"it is both defined in $owner and imported subsequently by \n$imp")
 
-  private val startContext = {
+  private lazy val startContext = {
     NoContext.make(
     Template(List(), emptyValDef, List()) setSymbol global.NoSymbol setType global.NoType,
     rootMirror.RootClass,
@@ -361,6 +361,16 @@ trait Contexts { self: Analyzer =>
       c
     }
 
+    /**
+     * A context for typing constructor parameter ValDefs, super or self invocation arguments and default getters
+     * of constructors. These expressions need to be type checked in a scope outside the class, cf. spec 5.3.1.
+     *
+     * This method is called by namer / typer where `this` is the context for the constructor DefDef. The
+     * owner of the resulting (new) context is the outer context for the Template, i.e. the context for the
+     * ClassDef. This means that class type parameters will be in scope. The value parameters of the current
+     * constructor are also entered into the new constructor scope. Members of the class however will not be
+     * accessible.
+     */
     def makeConstructorContext = {
       var baseContext = enclClass.outer
       while (baseContext.tree.isInstanceOf[Template])
@@ -380,6 +390,8 @@ trait Contexts { self: Analyzer =>
           enterLocalElems(c.scope.elems)
         }
       }
+      // Enter the scope elements of this (the scope for the constructor DefDef) into the new constructor scope.
+      // Concretely, this will enter the value parameters of constructor.
       enterElems(this)
       argContext
     }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index e652b68b14..27f157e3a6 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -258,8 +258,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/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
index b226591c8d..ed1334e857 100644
--- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
@@ -219,8 +219,8 @@ trait MethodSynthesis {
         context.unit.synthetics get meth match {
           case Some(mdef) =>
             context.unit.synthetics -= meth
-            meth setAnnotations deriveAnnotations(annotations, MethodTargetClass, false)
-            cd.symbol setAnnotations deriveAnnotations(annotations, ClassTargetClass, true)
+            meth setAnnotations deriveAnnotations(annotations, MethodTargetClass, keepClean = false)
+            cd.symbol setAnnotations deriveAnnotations(annotations, ClassTargetClass, keepClean = true)
             List(cd, mdef)
           case _ =>
             // Shouldn't happen, but let's give ourselves a reasonable error when it does
@@ -311,6 +311,7 @@ trait MethodSynthesis {
        */
       def category: Symbol
 
+      /* Explicit isSetter required for bean setters (beanSetterSym.isSetter is false) */
       final def completer(sym: Symbol) = namerOf(sym).accessorTypeCompleter(tree, isSetter)
       final def fieldSelection         = Select(This(enclClass), basisSym)
       final def derivedMods: Modifiers = mods & flagsMask | flagsExtra mapAnnotations (_ => Nil)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 2eabc126e3..6fde0b7370 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -63,7 +63,18 @@ trait Namers extends MethodSynthesis {
         case ModuleDef(_, _, _) => tree.symbol.moduleClass
         case _                  => tree.symbol
       }
-      newNamer(context.makeNewScope(tree, sym))
+      def isConstrParam(vd: ValDef) = {
+        (sym hasFlag PARAM | PRESUPER) &&
+        !vd.mods.isJavaDefined &&
+        sym.owner.isConstructor
+      }
+      val ownerCtx = tree match {
+        case vd: ValDef if isConstrParam(vd) =>
+          context.makeConstructorContext
+        case _ =>
+          context
+      }
+      newNamer(ownerCtx.makeNewScope(tree, sym))
     }
     def createInnerNamer() = {
       newNamer(context.make(context.tree, owner, newScope))
@@ -436,6 +447,7 @@ trait Namers extends MethodSynthesis {
     def enterSyms(trees: List[Tree]): Namer = {
       trees.foldLeft(this: Namer) { (namer, t) =>
         val ctx = namer enterSym t
+        // for Import trees, enterSym returns a changed context, so we need a new namer
         if (ctx eq namer.context) namer
         else newNamer(ctx)
       }
@@ -534,20 +546,19 @@ trait Namers extends MethodSynthesis {
       noDuplicates(selectors map (_.rename), AppearsTwice)
     }
 
-    def enterCopyMethod(copyDefDef: Tree, tparams: List[TypeDef]): Symbol = {
-      val sym      = copyDefDef.symbol
-      val lazyType = completerOf(copyDefDef, tparams)
+    def enterCopyMethod(copyDef: DefDef): Symbol = {
+      val sym      = copyDef.symbol
+      val lazyType = completerOf(copyDef)
 
       /** Assign the types of the class parameters to the parameters of the
        *  copy method. See comment in `Unapplies.caseClassCopyMeth` */
       def assignParamTypes() {
         val clazz = sym.owner
         val constructorType = clazz.primaryConstructor.tpe
-        val subst = new SubstSymMap(clazz.typeParams, tparams map (_.symbol))
+        val subst = new SubstSymMap(clazz.typeParams, copyDef.tparams map (_.symbol))
         val classParamss = constructorType.paramss
-        val DefDef(_, _, _, copyParamss, _, _) = copyDefDef
 
-        map2(copyParamss, classParamss)((copyParams, classParams) =>
+        map2(copyDef.vparamss, classParamss)((copyParams, classParams) =>
           map2(copyParams, classParams)((copyP, classP) =>
             copyP.tpt setType subst(classP.tpe)
           )
@@ -555,24 +566,28 @@ trait Namers extends MethodSynthesis {
       }
 
       sym setInfo {
-        mkTypeCompleter(copyDefDef) { sym =>
+        mkTypeCompleter(copyDef) { sym =>
           assignParamTypes()
           lazyType complete sym
         }
       }
     }
-    def completerOf(tree: Tree): TypeCompleter = completerOf(tree, treeInfo.typeParameters(tree))
-    def completerOf(tree: Tree, tparams: List[TypeDef]): TypeCompleter = {
+
+    def completerOf(tree: Tree): TypeCompleter = {
       val mono = namerOf(tree.symbol) monoTypeCompleter tree
+      val tparams = treeInfo.typeParameters(tree)
       if (tparams.isEmpty) mono
       else {
-        //@M! TypeDef's type params are handled differently
-        //@M e.g., in [A[x <: B], B], A and B are entered first as both are in scope in the definition of x
-        //@M x is only in scope in `A[x <: B]'
+        /* @M! TypeDef's type params are handled differently, e.g., in `type T[A[x <: B], B]`, A and B are entered
+         * first as both are in scope in the definition of x. x is only in scope in `A[x <: B]`.
+         * No symbols are created for the abstract type's params at this point, i.e. the following assertion holds:
+         *     !tree.symbol.isAbstractType || { tparams.forall(_.symbol == NoSymbol)
+         * (tested with the above example, `trait C { type T[A[X <: B], B] }`). See also comment in PolyTypeCompleter.
+         */
         if (!tree.symbol.isAbstractType) //@M TODO: change to isTypeMember ?
           createNamer(tree) enterSyms tparams
 
-        new PolyTypeCompleter(tparams, mono, tree, context) //@M
+        new PolyTypeCompleter(tparams, mono, context) //@M
       }
     }
 
@@ -634,9 +649,9 @@ trait Namers extends MethodSynthesis {
         val sym = assignAndEnterSymbol(tree) setFlag bridgeFlag
 
         if (name == nme.copy && sym.isSynthetic)
-          enterCopyMethod(tree, tparams)
+          enterCopyMethod(tree)
         else
-          sym setInfo completerOf(tree, tparams)
+          sym setInfo completerOf(tree)
     }
 
     def enterClassDef(tree: ClassDef) {
@@ -763,13 +778,13 @@ trait Namers extends MethodSynthesis {
       }
     }
 
-    def accessorTypeCompleter(tree: ValDef, isSetter: Boolean = false) = mkTypeCompleter(tree) { sym =>
+    /* Explicit isSetter required for bean setters (beanSetterSym.isSetter is false) */
+    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)
         }
       }
     }
@@ -832,17 +847,12 @@ trait Namers extends MethodSynthesis {
      *  assigns the type to the tpt's node.  Returns the type.
      */
     private def assignTypeToTree(tree: ValOrDefDef, defnTyper: Typer, pt: Type): Type = {
-      // compute result type from rhs
-      val typedBody =
+      val rhsTpe =
         if (tree.symbol.isTermMacro) defnTyper.computeMacroDefType(tree, pt)
         else defnTyper.computeType(tree.rhs, pt)
 
-      val typedDefn = widenIfNecessary(tree.symbol, typedBody, pt)
-      assignTypeToTree(tree, typedDefn)
-    }
-
-    private def assignTypeToTree(tree: ValOrDefDef, tpe: Type): Type = {
-      tree.tpt defineType tpe setPos tree.pos.focus
+      val defnTpe = widenIfNecessary(tree.symbol, rhsTpe, pt)
+      tree.tpt defineType defnTpe setPos tree.pos.focus
       tree.tpt.tpe
     }
 
@@ -918,163 +928,257 @@ 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(tparams: List[TypeDef], impl: Template): Type = {
+    private def classSig(cdef: ClassDef): Type = {
+      val clazz = cdef.symbol
+      val ClassDef(_, _, tparams, impl) = cdef
       val tparams0   = typer.reenterTypeParams(tparams)
       val resultType = templateSig(impl)
 
-      GenPolyType(tparams0, resultType)
+      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 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)
+      }
+      pluginsTp
     }
 
-    private def methodSig(ddef: DefDef, mods: Modifiers, tparams: List[TypeDef],
-                          vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): Type = {
-      val meth  = owner
-      val clazz = meth.owner
-      // enters the skolemized version into scope, returns the deSkolemized symbols
-      val tparamSyms = typer.reenterTypeParams(tparams)
-      // since the skolemized tparams are in scope, the TypeRefs in vparamSymss refer to skolemized tparams
-      var vparamSymss = enterValueParams(vparamss)
+    private def moduleSig(mdef: ModuleDef): Type = {
+      val moduleSym = mdef.symbol
+      // 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 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_*
+    }
+
+    /**
+     * The method type for `ddef`.
+     *
+     * If a PolyType(tparams, restp) is returned, `tparams` are the external symbols (not type skolems),
+     * i.e. instances of AbstractTypeSymbol. All references in `restp` to the type parameters are TypeRefs
+     * to these non-skolems.
+     *
+     * For type-checking the rhs (in case the result type is inferred), the type skolems of the type parameters
+     * are entered in scope. Equally, the parameter symbols entered into scope have types which refer to those
+     * skolems: when type-checking the rhs, references to parameters need to have types that refer to the skolems.
+     * In summary, typing an rhs happens with respect to the skolems.
+     *
+     * This means that the method's result type computed by the typer refers to skolems. In order to put it
+     * into the method type (the result of methodSig), typeRefs to skolems have to be replaced by references
+     * to the non-skolems.
+     */
+    private def methodSig(ddef: DefDef): Type = {
 
       // DEPMETTODO: do we need to skolemize value parameter symbols?
-      if (tpt.isEmpty && meth.name == nme.CONSTRUCTOR) {
-        tpt defineType context.enclClass.owner.tpe_*
-        tpt setPos meth.pos.focus
-      }
-      var resultPt = if (tpt.isEmpty) WildcardType else typer.typedType(tpt).tpe
-      val site = clazz.thisType
 
-      /** Called for all value parameter lists, right to left
-       *  @param vparams the symbols of one parameter list
-       *  @param restpe  the result type (possibly a MethodType)
+      val DefDef(_, _, tparams, vparamss, tpt, _) = ddef
+
+      val meth = owner
+      val methOwner = meth.owner
+      val site = methOwner.thisType
+
+      /* tparams already have symbols (created in enterDefDef/completerOf), namely the skolemized ones (created
+       * by the PolyTypeCompleter constructor, and assigned to tparams). reenterTypeParams enters the type skolems
+       * into scope and returns the non-skolems.
        */
-      def makeMethodType(vparams: List[Symbol], restpe: Type) = {
-        // TODODEPMET: check that we actually don't need to do anything here
-        // new dependent method types: probably OK already, since 'enterValueParams' above
-        // enters them in scope, and all have a lazy type. so they may depend on other params. but: need to
-        // check that params only depend on ones in earlier sections, not the same. (done by checkDependencies,
-        // so re-use / adapt that)
-        if (owner.isJavaDefined)
-          // TODODEPMET necessary?? new dependent types: replace symbols in restpe with the ones in vparams
-          JavaMethodType(vparams map (p => p setInfo objToAny(p.tpe)), restpe)
-        else
-          MethodType(vparams, restpe)
-      }
+      val tparamSyms = typer.reenterTypeParams(tparams)
+
+      val tparamSkolems = tparams.map(_.symbol)
+
+      /* since the skolemized tparams are in scope, the TypeRefs in types of vparamSymss refer to the type skolems
+       * note that for parameters with missing types, `methodSig` reassigns types of these symbols (the parameter
+       * types from the overridden method).
+       */
+      var vparamSymss = enterValueParams(vparamss)
+
 
+      /**
+       * Creates a method type using tparamSyms and vparamsSymss as argument symbols and `respte` as result type.
+       * All typeRefs to type skolems are replaced by references to the corresponding non-skolem type parameter,
+       * so the resulting type is a valid external method type, it does not contain (references to) skolems.
+       */
       def thisMethodType(restpe: Type) = {
         val checkDependencies = new DependentTypeChecker(context)(this)
         checkDependencies check vparamSymss
         // DEPMETTODO: check not needed when they become on by default
         checkDependencies(restpe)
 
-        GenPolyType(
+        val makeMethodType = (vparams: List[Symbol], restpe: Type) => {
+          // TODODEPMET: check that we actually don't need to do anything here
+          // new dependent method types: probably OK already, since 'enterValueParams' above
+          // enters them in scope, and all have a lazy type. so they may depend on other params. but: need to
+          // check that params only depend on ones in earlier sections, not the same. (done by checkDependencies,
+          // so re-use / adapt that)
+          if (meth.isJavaDefined)
+          // TODODEPMET necessary?? new dependent types: replace symbols in restpe with the ones in vparams
+            JavaMethodType(vparams map (p => p setInfo objToAny(p.tpe)), restpe)
+          else
+            MethodType(vparams, restpe)
+        }
+
+
+        val res = GenPolyType(
           tparamSyms, // deSkolemized symbols  -- TODO: check that their infos don't refer to method args?
           if (vparamSymss.isEmpty) NullaryMethodType(restpe)
           // vparamss refer (if they do) to skolemized tparams
           else (vparamSymss :\ restpe) (makeMethodType)
         )
+        res.substSym(tparamSkolems, tparamSyms)
       }
 
-      def transformedResult =
-        thisMethodType(resultPt).substSym(tparams map (_.symbol), tparamSyms)
+      /**
+       * Creates a schematic method type which has WildcardTypes for non specified
+       * return or parameter types. For instance, in `def f[T](a: T, b) = ...`, the
+       * type schema is
+       *
+       *   PolyType(T, MethodType(List(a: T, b: WildcardType), WildcardType))
+       *
+       * where T are non-skolems.
+       */
+      def methodTypeSchema(resTp: Type) = {
+        // for all params without type set WildcaradType
+        mforeach(vparamss)(v => if (v.tpt.isEmpty) v.symbol setInfo WildcardType)
+        thisMethodType(resTp)
+      }
 
-      // luc: added .substSym from skolemized to deSkolemized
-      // site.memberType(sym): PolyType(tparams, MethodType(..., ...))
-      //    ==> all references to tparams are deSkolemized
-      // thisMethodType: tparams in PolyType are deSkolemized, the references in the MethodTypes are skolemized.
-      //    ==> the two didn't match
-      //
-      // for instance, B.foo would not override A.foo, and the default on parameter b would not be inherited
-      //   class A { def foo[T](a: T)(b: T = a) = a }
-      //   class B extends A { override def foo[U](a: U)(b: U) = b }
-      def overriddenSymbol =
-        intersectionType(clazz.info.parents).nonPrivateMember(meth.name).filter { sym =>
-          sym != NoSymbol && (site.memberType(sym) matches transformedResult)
+      def overriddenSymbol(resTp: Type) = {
+        intersectionType(methOwner.info.parents).nonPrivateMember(meth.name).filter { sym =>
+          sym != NoSymbol && (site.memberType(sym) matches methodTypeSchema(resTp))
         }
-      // TODO: see whether this or something similar would work instead.
-      //
+      }
+      // TODO: see whether this or something similar would work instead:
       // def overriddenSymbol = meth.nextOverriddenSymbol
 
-      // fill in result type and parameter types from overridden symbol if there is a unique one.
-      if (clazz.isClass && (tpt.isEmpty || mexists(vparamss)(_.tpt.isEmpty))) {
-        // try to complete from matching definition in base type
-        mforeach(vparamss)(v => if (v.tpt.isEmpty) v.symbol setInfo WildcardType)
-        val overridden = overriddenSymbol
-        if (overridden != NoSymbol && !overridden.isOverloaded) {
-          overridden.cookJavaRawInfo() // #3404 xform java rawtypes into existentials
-          resultPt = site.memberType(overridden) match {
-            case PolyType(tparams, rt) => rt.substSym(tparams, tparamSyms)
-            case mt => mt
-          }
 
+      /**
+       * If `meth` doesn't have an explicit return type, extracts the return type from the method
+       * overridden by `meth` (if there's an unique one). This type is lateron used as the expected
+       * type for computing the type of the rhs. The resulting type references type skolems for
+       * type parameters (consistent with the result of `typer.typedType(tpt).tpe`).
+       *
+       * As a first side effect, this method assigns a MethodType constructed using this
+       * return type to `meth`. This allows omitting the result type for recursive methods.
+       *
+       * As another side effect, this method also assigns paramter types from the overridden
+       * method to parameters of `meth` that have missing types (the parser accepts missing
+       * parameter types under -Yinfer-argument-types).
+       */
+      def typesFromOverridden(methResTp: Type): Type = {
+        val overridden = overriddenSymbol(methResTp)
+        if (overridden == NoSymbol || overridden.isOverloaded) {
+          methResTp
+        } else {
+          overridden.cookJavaRawInfo() // #3404 xform java rawtypes into existentials
+          var overriddenTp = site.memberType(overridden) match {
+              case PolyType(tparams, rt) => rt.substSym(tparams, tparamSkolems)
+              case mt => mt
+            }
           for (vparams <- vparamss) {
-            var pps = resultPt.params
+            var overriddenParams = overriddenTp.params
             for (vparam <- vparams) {
               if (vparam.tpt.isEmpty) {
-                val paramtpe = pps.head.tpe
-                vparam.symbol setInfo paramtpe
-                vparam.tpt defineType paramtpe setPos vparam.pos.focus
+                val overriddenParamTp = overriddenParams.head.tpe
+                // references to type parameteres in overriddenParamTp link to the type skolems, so the
+                // assigned type is consistent with the other / existing parameter types in vparamSymss.
+                vparam.symbol setInfo overriddenParamTp
+                vparam.tpt defineType overriddenParamTp setPos vparam.pos.focus
               }
-              pps = pps.tail
+              overriddenParams = overriddenParams.tail
             }
-            resultPt = resultPt.resultType
+            overriddenTp = overriddenTp.resultType
           }
-          resultPt match {
-            case NullaryMethodType(rtpe) => resultPt = rtpe
-            case MethodType(List(), rtpe) => resultPt = rtpe
+
+          overriddenTp match {
+            case NullaryMethodType(rtpe) => overriddenTp = rtpe
+            case MethodType(List(), rtpe) => overriddenTp = rtpe
             case _ =>
           }
+
           if (tpt.isEmpty) {
             // provisionally assign `meth` a method type with inherited result type
             // that way, we can leave out the result type even if method is recursive.
-            meth setInfo thisMethodType(resultPt)
+            meth setInfo thisMethodType(overriddenTp)
+            overriddenTp
+          } else {
+            methResTp
           }
         }
       }
-      // Add a () parameter section if this overrides some method with () parameters.
-      if (clazz.isClass && vparamss.isEmpty && overriddenSymbol.alternatives.exists(
-        _.info.isInstanceOf[MethodType])) {
+
+      if (tpt.isEmpty && meth.name == nme.CONSTRUCTOR) {
+        tpt defineType context.enclClass.owner.tpe_*
+        tpt setPos meth.pos.focus
+      }
+
+      val methResTp = if (tpt.isEmpty) WildcardType else typer.typedType(tpt).tpe
+      val resTpFromOverride = if (methOwner.isClass && (tpt.isEmpty || mexists(vparamss)(_.tpt.isEmpty))) {
+          typesFromOverridden(methResTp)
+        } else {
+          methResTp
+        }
+
+      // Add a () parameter section if this overrides some method with () parameters
+      if (methOwner.isClass && vparamss.isEmpty &&
+        overriddenSymbol(methResTp).alternatives.exists(_.info.isInstanceOf[MethodType])) {
         vparamSymss = ListOfNil
       }
+
+      // issue an error for missing parameter types
       mforeach(vparamss) { vparam =>
         if (vparam.tpt.isEmpty) {
           MissingParameterOrValTypeError(vparam)
           vparam.tpt defineType ErrorType
         }
       }
-      addDefaultGetters(meth, vparamss, tparams, overriddenSymbol)
+
+      addDefaultGetters(meth, vparamss, tparams, overriddenSymbol(methResTp))
 
       // fast track macros, i.e. macros defined inside the compiler, are hardcoded
       // hence we make use of that and let them have whatever right-hand side they need
       // (either "macro ???" as they used to or just "???" to maximally simplify their compilation)
-      if (fastTrack contains ddef.symbol) ddef.symbol setFlag MACRO
+      if (fastTrack contains meth) meth setFlag MACRO
 
       // macro defs need to be typechecked in advance
       // because @macroImpl annotation only gets assigned during typechecking
       // otherwise macro defs wouldn't be able to robustly coexist with their clients
       // because a client could be typechecked before a macro def that it uses
-      if (ddef.symbol.isMacro) {
-        val pt = resultPt.substSym(tparamSyms, tparams map (_.symbol))
-        typer.computeMacroDefType(ddef, pt)
+      if (meth.isMacro) {
+        typer.computeMacroDefType(ddef, resTpFromOverride)
       }
 
-      thisMethodType({
+      val res = thisMethodType({
         val rt = (
           if (!tpt.isEmpty) {
-            typer.typedType(tpt).tpe
+            methResTp
           } else {
-            // replace deSkolemized symbols with skolemized ones
-            // (for resultPt computed by looking at overridden symbol, right?)
-            val pt = resultPt.substSym(tparamSyms, tparams map (_.symbol))
-            assignTypeToTree(ddef, typer, pt)
-          }
-        )
+            // return type is inferred, we don't just use resTpFromOverride. Here, C.f has type String:
+            //   trait T { def f: Object }; class C <: T { def f = "" }
+            // using resTpFromOverride as expected type allows for the following (C.f has type A):
+            //   trait T { def f: A }; class C <: T { implicit def b2a(t: B): A = ???; def f = new B }
+            assignTypeToTree(ddef, typer, resTpFromOverride)
+          })
         // #2382: return type of default getters are always @uncheckedVariance
         if (meth.hasDefault)
           rt.withAnnotation(AnnotationInfo(uncheckedVarianceClass.tpe, List(), List()))
         else rt
       })
+      pluginsTypeSig(res, typer, ddef, methResTp)
     }
 
     /**
@@ -1086,9 +1190,9 @@ trait Namers extends MethodSynthesis {
      * flag.
      */
     private def addDefaultGetters(meth: Symbol, vparamss: List[List[ValDef]], tparams: List[TypeDef], overriddenSymbol: => Symbol) {
-      val clazz      = meth.owner
+      val methOwner  = meth.owner
       val isConstr   = meth.isConstructor
-      val overridden = if (isConstr || !clazz.isClass) NoSymbol else overriddenSymbol
+      val overridden = if (isConstr || !methOwner.isClass) NoSymbol else overriddenSymbol
       val overrides  = overridden != NoSymbol && !overridden.isOverloaded
       // value parameters of the base class (whose defaults might be overridden)
       var baseParamss = (vparamss, overridden.tpe.paramss) match {
@@ -1138,7 +1242,7 @@ trait Namers extends MethodSynthesis {
 
             val parentNamer = if (isConstr) {
               val (cdef, nmr) = moduleNamer.getOrElse {
-                val module = companionSymbolOf(clazz, context)
+                val module = companionSymbolOf(methOwner, context)
                 module.initialize // call type completer (typedTemplate), adds the
                                   // module's templateNamer to classAndNamerOfModule
                 module.attachments.get[ConstructorDefaultsAttachment] match {
@@ -1184,7 +1288,7 @@ trait Namers extends MethodSynthesis {
                 name, deftParams, defvParamss, defTpt, defRhs)
             }
             if (!isConstr)
-              clazz.resetFlag(INTERFACE) // there's a concrete member now
+              methOwner.resetFlag(INTERFACE) // there's a concrete member now
             val default = parentNamer.enterSyntheticSym(defaultTree)
             if (forInteractive && default.owner.isTerm) {
               // save the default getters as attachments in the method symbol. if compiling the
@@ -1209,15 +1313,31 @@ trait Namers extends MethodSynthesis {
       }
     }
 
+    private def valDefSig(vdef: ValDef) = {
+      val ValDef(_, _, tpt, rhs) = vdef
+      val result = if (tpt.isEmpty) {
+        if (rhs.isEmpty) {
+          MissingParameterOrValTypeError(tpt)
+          ErrorType
+        }
+        else assignTypeToTree(vdef, typer, WildcardType)
+      } 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)
     // may take type parameters, which are in scope in its bounds
-    private def typeDefSig(tpsym: Symbol, tparams: List[TypeDef], rhs: Tree) = {
+    private def typeDefSig(tdef: TypeDef) = {
+      val TypeDef(_, _, tparams, rhs) = tdef
       // log("typeDefSig(" + tpsym + ", " + tparams + ")")
       val tparamSyms = typer.reenterTypeParams(tparams) //@M make tparams available in scope (just for this abstypedef)
       val tp = typer.typedType(rhs).tpe match {
         case TypeBounds(lt, rt) if (lt.isError || rt.isError) =>
           TypeBounds.empty
-        case tp @ TypeBounds(lt, rt) if (tpsym hasFlag JAVA) =>
+        case tp @ TypeBounds(lt, rt) if (tdef.symbol hasFlag JAVA) =>
           TypeBounds(lt, objToAny(rt))
         case tp =>
           tp
@@ -1239,9 +1359,31 @@ 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) = {
+      val Import(expr, selectors) = imp
+      val expr1 = typer.typedQualifier(expr)
+      typer checkStable expr1
+      if (expr1.symbol != null && expr1.symbol.isRootPackage)
+        RootImportError(imp)
+
+      if (expr1.isErrorTyped)
+        ErrorType
+      else {
+        val newImport = treeCopy.Import(imp, expr1, selectors).asInstanceOf[Import]
+        checkSelectors(newImport)
+        transformed(imp) = newImport
+        // copy symbol and type attributes back into old expression
+        // so that the structure builder will find it.
+        expr setSymbol expr1.symbol setType expr1.tpe
+        ImportType(expr1)
+      }
+    }
+
+
     /** Given a case class
      *   case class C[Ts] (ps: Us)
      *  Add the following methods to toScope:
@@ -1265,6 +1407,11 @@ trait Namers extends MethodSynthesis {
       caseClassCopyMeth(cdef) foreach namer.enterSyntheticSym
     }
 
+    /**
+     * TypeSig is invoked by monoTypeCompleters. It returns the type of a definition which
+     * is then assigned to the corresponding symbol (typeSig itself does not need to assign
+     * the type to the symbol, but it can if necessary).
+     */
     def typeSig(tree: Tree): Type = {
       // log("typeSig " + tree)
       /** For definitions, transform Annotation trees to AnnotationInfos, assign
@@ -1297,83 +1444,33 @@ trait Namers extends MethodSynthesis {
       }
 
       val sym: Symbol = tree.symbol
-      // @Lukas: I am not sure this is the right way to do things.
-      // We used to only decorate the module class with annotations, which is
-      // clearly wrong. Now we decorate both the class and the object.
-      // But maybe some annotations are only meant for one of these but not for the other?
-      //
-      // TODO: meta-annotations to indicate class vs. object.
+
+      // TODO: meta-annotations to indicate where module annotations should go (module vs moduleClass)
       annotate(sym)
       if (sym.isModule) annotate(sym.moduleClass)
 
       def getSig = tree match {
-        case cdef @ ClassDef(_, name, tparams, impl) =>
-          val clazz = tree.symbol
-          val result = createNamer(tree).classSig(tparams, impl)
-          clazz setInfo result
-          if (clazz.isDerivedValueClass) {
-            log("Ensuring companion for derived value class " + 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)
-          }
-          result
-
-        case ModuleDef(_, _, impl) =>
-          val clazz = sym.moduleClass
-          clazz setInfo createNamer(tree).templateSig(impl)
-          clazz.tpe
-
-        case ddef @ DefDef(mods, _, tparams, vparamss, tpt, rhs) =>
-          // TODO: cleanup parameter list
-          createNamer(tree).methodSig(ddef, mods, tparams, vparamss, tpt, rhs)
-
-        case vdef @ ValDef(mods, name, tpt, rhs) =>
-          val isBeforeSupercall = (
-               (sym hasFlag PARAM | PRESUPER)
-            && !mods.isJavaDefined
-            && sym.owner.isConstructor
-          )
-          val typer1 = typer.constrTyperIf(isBeforeSupercall)
-          if (tpt.isEmpty) {
-            if (rhs.isEmpty) {
-              MissingParameterOrValTypeError(tpt)
-              ErrorType
-            }
-            else assignTypeToTree(vdef, newTyper(typer1.context.make(vdef, sym)), WildcardType)
-          }
-          else typer1.typedType(tpt).tpe
-
-        case TypeDef(_, _, tparams, rhs) =>
-          createNamer(tree).typeDefSig(sym, tparams, rhs) //@M!
-
-        case Import(expr, selectors) =>
-          val expr1 = typer.typedQualifier(expr)
-          typer checkStable expr1
-          if (expr1.symbol != null && expr1.symbol.isRootPackage)
-            RootImportError(tree)
-
-          if (expr1.isErrorTyped)
-            ErrorType
-          else {
-            val newImport = treeCopy.Import(tree, expr1, selectors).asInstanceOf[Import]
-            checkSelectors(newImport)
-            transformed(tree) = newImport
-            // copy symbol and type attributes back into old expression
-            // so that the structure builder will find it.
-            expr setSymbol expr1.symbol setType expr1.tpe
-            ImportType(expr1)
-          }
-      }
+        case cdef: ClassDef =>
+          createNamer(tree).classSig(cdef)
+
+        case mdef: ModuleDef =>
+          createNamer(tree).moduleSig(mdef)
+
+        case ddef: DefDef =>
+          createNamer(tree).methodSig(ddef)
 
-      val result =
-        try getSig
-        catch typeErrorHandler(tree, ErrorType)
+        case vdef: ValDef =>
+          createNamer(tree).valDefSig(vdef)
 
-      result match {
-        case PolyType(tparams @ (tp :: _), _) if tp.owner.isTerm => deskolemizeTypeParams(tparams)(result)
-        case _                                                   => result
+        case tdef: TypeDef =>
+          createNamer(tree).typeDefSig(tdef) //@M!
+
+        case imp: Import =>
+          importSig(imp)
       }
+
+      try getSig
+      catch typeErrorHandler(tree, ErrorType)
     }
 
     def includeParent(tpe: Type, parent: Symbol): Type = tpe match {
@@ -1527,14 +1624,25 @@ trait Namers extends MethodSynthesis {
     }
   }
 
-  /** A class representing a lazy type with known type parameters.
+  /**
+   * A class representing a lazy type with known type parameters. `ctx` is the namer context in which the
+   * `owner` is defined.
+   *
+   * Constructing a PolyTypeCompleter for a DefDef creates type skolems for the type parameters and
+   * assigns them to the `tparams` trees.
    */
-  class PolyTypeCompleter(tparams: List[TypeDef], restp: TypeCompleter, owner: Tree, ctx: Context) extends LockingTypeCompleter with FlagAgnosticCompleter {
-    private val ownerSym    = owner.symbol
-    override val typeParams = tparams map (_.symbol) //@M
-    override val tree       = restp.tree
+  class PolyTypeCompleter(tparams: List[TypeDef], restp: TypeCompleter, ctx: Context) extends LockingTypeCompleter with FlagAgnosticCompleter {
+    // @M. If `owner` is an abstract type member, `typeParams` are all NoSymbol (see comment in `completerOf`),
+    // otherwise, the non-skolemized (external) type parameter symbols
+    override val typeParams = tparams map (_.symbol)
+
+    /* The definition tree (poly ClassDef, poly DefDef or HK TypeDef) */
+    override val tree = restp.tree
+
+    private val defnSym = tree.symbol
 
-    if (ownerSym.isTerm) {
+    if (defnSym.isTerm) {
+      // for polymorphic DefDefs, create type skolems and assign them to the tparam trees.
       val skolems = deriveFreshSkolems(tparams map (_.symbol))
       map2(tparams, skolems)(_ setSymbol _)
     }
@@ -1542,8 +1650,8 @@ trait Namers extends MethodSynthesis {
     def completeImpl(sym: Symbol) = {
       // @M an abstract type's type parameters are entered.
       // TODO: change to isTypeMember ?
-      if (ownerSym.isAbstractType)
-        newNamerFor(ctx, owner) enterSyms tparams //@M
+      if (defnSym.isAbstractType)
+        newNamerFor(ctx, tree) enterSyms tparams //@M
       restp complete sym
     }
   }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 5217911d19..6cf9dfdd5b 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -429,12 +429,12 @@ trait Typers extends Adaptations with Tags {
     def reenterValueParams(vparamss: List[List[ValDef]]) {
       for (vparams <- vparamss)
         for (vparam <- vparams)
-          vparam.symbol = context.scope enter vparam.symbol
+          context.scope enter vparam.symbol
     }
 
     def reenterTypeParams(tparams: List[TypeDef]): List[Symbol] =
       for (tparam <- tparams) yield {
-        tparam.symbol = context.scope enter tparam.symbol
+        context.scope enter tparam.symbol
         tparam.symbol.deSkolemize
       }
 
@@ -822,9 +822,9 @@ trait Typers extends Adaptations with Tags {
               orElse { _ =>
                 debuglog("fallback on implicits: " + tree + "/" + resetAllAttrs(original))
                 val tree1 = typed(resetAllAttrs(original), mode, WildcardType)
-                // Q: `typed` already calls `addAnnotations` and `adapt`. the only difference here is that
+                // 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 setType addAnnotations(tree1, tree1.tpe)
+                tree1 setType pluginsTyped(tree1.tpe, this, tree1, mode, pt)
                 if (tree1.isEmpty) tree1 else adapt(tree1, mode, pt, EmptyTree)
             }
             )
@@ -1032,8 +1032,8 @@ trait Typers extends 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 mode.inNone(TYPEmode | FUNmode) && (ct <:< pt) && !forScaladoc && !forInteractive => // (0)
           val sym = tree.symbol
           if (sym != null && sym.isDeprecated) {
@@ -1133,8 +1133,8 @@ trait Typers extends 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) {
@@ -1980,12 +1980,23 @@ trait Typers extends Adaptations with Tags {
       mods.copy(annotations = Nil) setPositions mods.positions
 
     def typedValDef(vdef: ValDef): ValDef = {
+      val sym = vdef.symbol
+      val valDefTyper = {
+        val maybeConstrCtx =
+          if ((sym.isParameter || sym.isEarlyInitialized) && sym.owner.isConstructor) context.makeConstructorContext
+          else context
+        newTyper(maybeConstrCtx.makeNewScope(vdef, sym))
+      }
+      valDefTyper.typedValDefImpl(vdef)
+    }
+
+    // use typedValDef instead. this version is called after creating a new context for the ValDef
+    private def typedValDefImpl(vdef: ValDef) = {
       val sym = vdef.symbol.initialize
-      val typer1 = constrTyperIf(sym.isParameter && sym.owner.isConstructor)
       val typedMods = typedModifiers(vdef.mods)
 
       sym.annotations.map(_.completeInfo)
-      val tpt1 = checkNoEscaping.privates(sym, typer1.typedType(vdef.tpt))
+      val tpt1 = checkNoEscaping.privates(sym, typedType(vdef.tpt))
       checkNonCyclic(vdef, tpt1)
 
       if (sym.hasAnnotation(definitions.VolatileAttr) && !sym.isMutable)
@@ -2013,7 +2024,7 @@ trait Typers extends Adaptations with Tags {
               else subst(tpt1.tpe.typeArgs(0))
             else subst(tpt1.tpe)
           } else tpt1.tpe
-          newTyper(typer1.context.make(vdef, sym)).transformedOrTyped(vdef.rhs, EXPRmode | BYVALmode, tpt2)
+          transformedOrTyped(vdef.rhs, EXPRmode | BYVALmode, tpt2)
         }
       treeCopy.ValDef(vdef, typedMods, vdef.name, tpt1, checkDead(rhs1)) setType NoType
     }
@@ -2263,13 +2274,12 @@ trait Typers extends Adaptations with Tags {
     }
 
     def typedTypeDef(tdef: TypeDef): TypeDef =
-      typerWithCondLocalContext(context.makeNewScope(tdef, tdef.symbol))(tdef.tparams.nonEmpty){
-        _.typedTypeDef0(tdef)
+      typerWithCondLocalContext(context.makeNewScope(tdef, tdef.symbol))(tdef.tparams.nonEmpty) {
+        _.typedTypeDefImpl(tdef)
       }
 
-    // call typedTypeDef instead
-    // a TypeDef with type parameters must always be type checked in a new scope
-    private def typedTypeDef0(tdef: TypeDef): TypeDef = {
+    // use typedTypeDef instead. this version is called after creating a new context for the TypeDef
+    private def typedTypeDefImpl(tdef: TypeDef): TypeDef = {
       tdef.symbol.initialize
       reenterTypeParams(tdef.tparams)
       val tparams1 = tdef.tparams mapConserve typedTypeDef
@@ -4248,8 +4258,9 @@ trait Typers extends 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)
           }
         }
       }
@@ -4914,10 +4925,15 @@ trait Typers extends Adaptations with Tags {
           .typedStats(pdef.stats, NoSymbol)
         treeCopy.PackageDef(tree, pid1, stats1) setType NoType
       }
+
+      /**
+       * The typer with the correct context for a method definition. If the method is a default getter for
+       * a constructor default, the resulting typer has a constructor context (fixes SI-5543).
+       */
       def defDefTyper(ddef: DefDef) = {
-        val flag = ddef.mods.hasDefaultFlag && sym.owner.isModuleClass &&
+        val isConstrDefaultGetter = ddef.mods.hasDefaultFlag && sym.owner.isModuleClass &&
             nme.defaultGetterToMethod(sym.name) == nme.CONSTRUCTOR
-        newTyper(context.makeNewScope(ddef, sym)).constrTyperIf(flag)
+        newTyper(context.makeNewScope(ddef, sym)).constrTyperIf(isConstrDefaultGetter)
       }
 
       def typedAlternative(alt: Alternative) = {
@@ -5198,11 +5214,13 @@ trait Typers extends 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.clearType()
           if (tree.hasSymbolField) tree.symbol = NoSymbol
         }
@@ -5210,7 +5228,7 @@ trait Typers extends Adaptations with Tags {
         val alreadyTyped = tree.tpe ne null
         val 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,
@@ -5219,7 +5237,7 @@ trait Typers extends 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
@@ -5233,17 +5251,17 @@ trait Typers extends Adaptations with Tags {
           )
         }
 
-        tree1 modifyType (addAnnotations(tree1, _))
+        tree1 modifyType (pluginsTyped(_, this, tree1, mode, ptPlugins))
         val result =
           if (tree1.isEmpty) tree1
           else {
-            val result = adapt(tree1, mode, pt, tree)
+            val result = adapt(tree1, mode, ptPlugins, tree)
             if (hasPendingMacroExpansions) macroExpandAll(this, result) else result
           }
 
         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)
@@ -5258,7 +5276,7 @@ trait Typers extends 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
diff --git a/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala b/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala
index e95184ac6d..9c04462d7a 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala
@@ -100,7 +100,7 @@ trait Unapplies extends ast.TreeDSL
     def createFun      = gen.scalaFunctionConstr(primaries, toIdent(cdef), abstractFun = true)
     def parents        = if (inheritFromFun) List(createFun) else Nil
     def toString       = DefDef(
-      Modifiers(OVERRIDE | FINAL),
+      Modifiers(OVERRIDE | FINAL | SYNTHETIC),
       nme.toString_,
       Nil,
       ListOfNil,
diff --git a/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala b/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala
index 600b51f376..beab271a3b 100644
--- a/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala
+++ b/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala
@@ -8,6 +8,7 @@ import scala.tools.nsc.MissingRequirementError
 abstract class CPSAnnotationChecker extends CPSUtils {
   val global: Global
   import global._
+  import analyzer.{AnalyzerPlugin, Typer}
   import definitions._
 
   //override val verbose = true
@@ -17,12 +18,12 @@ abstract class CPSAnnotationChecker extends CPSUtils {
    *  Checks whether @cps annotations conform
    */
   object checker extends AnnotationChecker {
-    private def addPlusMarker(tp: Type)  = tp withAnnotation newPlusMarker()
-    private def addMinusMarker(tp: Type) = tp withAnnotation newMinusMarker()
+    private[CPSAnnotationChecker] def addPlusMarker(tp: Type)  = tp withAnnotation newPlusMarker()
+    private[CPSAnnotationChecker] def addMinusMarker(tp: Type) = tp withAnnotation newMinusMarker()
 
-    private def cleanPlus(tp: Type) =
+    private[CPSAnnotationChecker] def cleanPlus(tp: Type) =
       removeAttribs(tp, MarkerCPSAdaptPlus, MarkerCPSTypes)
-    private def cleanPlusWith(tp: Type)(newAnnots: AnnotationInfo*) =
+    private[CPSAnnotationChecker] def cleanPlusWith(tp: Type)(newAnnots: AnnotationInfo*) =
       cleanPlus(tp) withAnnotations newAnnots.toList
 
     /** Check annotations to decide whether tpe1 <:< tpe2 */
@@ -115,8 +116,13 @@ abstract class CPSAnnotationChecker extends CPSUtils {
       } else
         bounds
     }
+  }
+
+  object plugin extends AnalyzerPlugin {
+
+    import checker._
 
-    override def canAdaptAnnotations(tree: Tree, mode: Mode, pt: Type): Boolean = {
+    override def canAdaptAnnotations(tree: Tree, typer: Typer, mode: Mode, pt: Type): Boolean = {
       if (!cpsEnabled) return false
       vprintln("can adapt annotations? " + tree + " / " + tree.tpe + " / " + mode + " / " + pt)
 
@@ -182,7 +188,7 @@ abstract class CPSAnnotationChecker extends CPSUtils {
       } else false
     }
 
-    override def adaptAnnotations(tree: Tree, mode: Mode, pt: Type): Tree = {
+    override def adaptAnnotations(tree: Tree, typer: Typer, mode: Mode, pt: Type): Tree = {
       if (!cpsEnabled) return tree
 
       vprintln("adapt annotations " + tree + " / " + tree.tpe + " / " + mode + " / " + pt)
@@ -238,14 +244,15 @@ abstract class CPSAnnotationChecker extends CPSUtils {
      *  is in tail position. Therefore, we are making sure that only the types of return expressions
      *  are adapted which will either be removed, or lead to an error.
      */
-    override def adaptTypeOfReturn(tree: Tree, pt: Type, default: => Type): Type = {
+    override def pluginsTypedReturn(default: Type, typer: Typer, tree: Return, pt: Type): Type = {
+      val expr = tree.expr
       // only adapt if method's result type (pt) is cps type
       val annots = cpsParamAnnotation(pt)
       if (annots.nonEmpty) {
-        // return type of `tree` without plus marker, but only if it doesn't have other cps annots
-        if (hasPlusMarker(tree.tpe) && !hasCpsParamTypes(tree.tpe))
-          tree.setType(removeAttribs(tree.tpe, MarkerCPSAdaptPlus))
-        tree.tpe
+        // return type of `expr` without plus marker, but only if it doesn't have other cps annots
+        if (hasPlusMarker(expr.tpe) && !hasCpsParamTypes(expr.tpe))
+          expr.setType(removeAttribs(expr.tpe, MarkerCPSAdaptPlus))
+        expr.tpe
       } else default
     }
 
@@ -392,7 +399,7 @@ abstract class CPSAnnotationChecker extends CPSUtils {
     /** Modify the type that has thus far been inferred
      *  for a tree.  All this should do is add annotations. */
 
-    override def addAnnotations(tree: Tree, tpe: Type): Type = {
+    override def pluginsTyped(tpe: Type, typer: Typer, tree: Tree, mode: Mode, pt: Type): Type = {
       import scala.util.control._
       if (!cpsEnabled) {
         val report = try hasCpsParamTypes(tpe) catch { case _: MissingRequirementError => false }
diff --git a/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSPlugin.scala b/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSPlugin.scala
index 90e64d8171..c16cce2f2c 100644
--- a/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSPlugin.scala
+++ b/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSPlugin.scala
@@ -28,6 +28,7 @@ class SelectiveCPSPlugin(val global: Global) extends Plugin {
     val global: SelectiveCPSPlugin.this.global.type = SelectiveCPSPlugin.this.global
   }
   global.addAnnotationChecker(checker.checker)
+  global.analyzer.addAnalyzerPlugin(checker.plugin)
 
   global.log("instantiated cps plugin: " + this)
 
diff --git a/src/reflect/scala/reflect/internal/AnnotationCheckers.scala b/src/reflect/scala/reflect/internal/AnnotationCheckers.scala
index 13346d9151..73cc7fbbd6 100644
--- a/src/reflect/scala/reflect/internal/AnnotationCheckers.scala
+++ b/src/reflect/scala/reflect/internal/AnnotationCheckers.scala
@@ -16,7 +16,15 @@ trait AnnotationCheckers {
   /** An additional checker for annotations on types.
    *  Typically these are registered by compiler plugins
    *  with the addAnnotationChecker method. */
-  abstract class AnnotationChecker {
+  trait AnnotationChecker {
+
+    /**
+     * Selectively activate this annotation checker. When using both an annotation checker
+     * and an analyzer plugin, it is common to run both of them only during selected
+     * compiler phases. See documentation in AnalyzerPlugin.isActive.
+     */
+    def isActive(): Boolean = true
+
     /** Check the annotations on two types conform. */
     def annotationsConform(tpe1: Type, tpe2: Type): Boolean
 
@@ -29,39 +37,51 @@ trait AnnotationCheckers {
     def annotationsGlb(tp: Type, ts: List[Type]): Type = tp
 
     /** Refine the bounds on type parameters to the given type arguments. */
-    def adaptBoundsToAnnotations(bounds: List[TypeBounds],
-      tparams: List[Symbol], targs: List[Type]): List[TypeBounds] = bounds
+    def adaptBoundsToAnnotations(bounds: List[TypeBounds], tparams: List[Symbol],
+                                 targs: List[Type]): List[TypeBounds] = bounds
 
-    /** Modify the type that has thus far been inferred
-     *  for a tree.  All this should do is add annotations. */
+    /**
+     * Modify the type that has thus far been inferred for a tree. All this should
+     * do is add annotations.
+     */
+    @deprecated("Create an AnalyzerPlugin and use pluginsTyped", "2.10.1")
     def addAnnotations(tree: Tree, tpe: Type): Type = tpe
 
-    /** Decide whether this annotation checker 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).*/
+    /**
+     * 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).
+     */
+    @deprecated("Create an AnalyzerPlugin and use canAdaptAnnotations", "2.10.1")
     def canAdaptAnnotations(tree: Tree, mode: Mode, 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 adaptiong, it
-     *  should return the tree unchanged.*/
+    /**
+     * 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 adaptiong, it should return the tree unchanged.
+     */
+    @deprecated("Create an AnalyzerPlugin and use adaptAnnotations", "2.10.1")
     def adaptAnnotations(tree: Tree, mode: Mode, pt: Type): Tree = tree
 
-    /** Adapt the type of a return expression. The decision of an annotation checker
-     *  whether the type should be adapted is based on the type of the expression
-     *  which is returned, as well as the result type of the method (pt).
-     *  By default, this method simply returns the passed `default` type.
+    /**
+     * Adapt the type of a return expression. The decision of a typer plugin whether the type
+     * should be adapted is based on the type of the expression which is returned, as well as the
+     * result type of the method (pt).
+     *
+     * By default, this method simply returns the passed `default` type.
      */
+    @deprecated("Create an AnalyzerPlugin and use pluginsTypedReturn. Note: the 'tree' argument here is\n"+
+                "the 'expr' of a Return tree; 'pluginsTypedReturn' takes the Return tree itself as argument", "2.10.1")
     def adaptTypeOfReturn(tree: Tree, pt: Type, default: => Type): Type = default
   }
 
   // Syncnote: Annotation checkers inaccessible to reflection, so no sync in var necessary.
+
   /** The list of annotation checkers that have been registered */
   private var annotationCheckers: List[AnnotationChecker] = Nil
 
-  /** Register an annotation checker.  Typically these
-   *  are added by compiler plugins. */
+  /** Register an annotation checker.  Typically these are added by compiler plugins. */
   def addAnnotationChecker(checker: AnnotationChecker) {
     if (!(annotationCheckers contains checker))
       annotationCheckers = checker :: annotationCheckers
@@ -72,76 +92,53 @@ trait AnnotationCheckers {
     annotationCheckers = Nil
   }
 
-  /** Check that the annotations on two types conform.  To do
-   *  so, consult all registered annotation checkers. */
-  def annotationsConform(tp1: Type, tp2: Type): Boolean = {
-    /* Finish quickly if there are no annotations */
-    if (tp1.annotations.isEmpty && tp2.annotations.isEmpty)
-      true
-    else
-     annotationCheckers.forall(
-       _.annotationsConform(tp1,tp2))
-  }
-
-  /** Refine the computed least upper bound of a list of types.
-   *  All this should do is add annotations. */
-  def annotationsLub(tpe: Type, ts: List[Type]): Type = {
-    annotationCheckers.foldLeft(tpe)((tpe, checker) =>
-      checker.annotationsLub(tpe, ts))
-  }
-
-  /** Refine the computed greatest lower bound of a list of types.
-   *  All this should do is add annotations. */
-  def annotationsGlb(tpe: Type, ts: List[Type]): Type = {
-    annotationCheckers.foldLeft(tpe)((tpe, checker) =>
-      checker.annotationsGlb(tpe, ts))
-  }
-
-  /** Refine the bounds on type parameters to the given type arguments. */
-  def adaptBoundsToAnnotations(bounds: List[TypeBounds],
-    tparams: List[Symbol], targs: List[Type]): List[TypeBounds] = {
-      annotationCheckers.foldLeft(bounds)((bounds, checker) =>
-        checker.adaptBoundsToAnnotations(bounds, tparams, targs))
-  }
-
-  /** Let all annotations checkers add extra annotations
-   *  to this tree's type. */
-  def addAnnotations(tree: Tree, tpe: Type): Type = {
-    annotationCheckers.foldLeft(tpe)((tpe, checker) =>
-      checker.addAnnotations(tree, tpe))
-  }
-
-  /** Find out whether any annotation checker can adapt a tree
-   *  to a given type. Called by Typers.adapt. */
-  def canAdaptAnnotations(tree: Tree, mode: Mode, pt: Type): Boolean = {
-    annotationCheckers.exists(_.canAdaptAnnotations(tree, mode, pt))
-  }
-
-  /** Let registered annotation checkers adapt a tree
-   *  to a given type (called by Typers.adapt). Annotation checkers
-   *  that cannot do the adaption should pass the tree through
-   *  unchanged. */
-  def adaptAnnotations(tree: Tree, mode: Mode, pt: Type): Tree = {
-    annotationCheckers.foldLeft(tree)((tree, checker) =>
-      checker.adaptAnnotations(tree, mode, pt))
-  }
-
-  /** Let a registered annotation checker adapt the type of a return expression.
-   *  Annotation checkers that cannot do the adaptation should simply return
-   *  the `default` argument.
-   *
-   *  Note that the result is undefined if more than one annotation checker
-   *  returns an adapted type which is not a subtype of `default`.
-   */
-  def adaptTypeOfReturn(tree: Tree, pt: Type, default: => Type): Type = {
-    val adaptedTypes = annotationCheckers flatMap { checker =>
-      val adapted = checker.adaptTypeOfReturn(tree, pt, default)
-      if (!(adapted <:< default)) List(adapted)
-      else List()
-    }
-    adaptedTypes match {
-      case fst :: _ => fst
-      case List() => default
-    }
-  }
+  /** @see AnnotationChecker.annotationsConform */
+  def annotationsConform(tp1: Type, tp2: Type): Boolean =
+    if (annotationCheckers.isEmpty || (tp1.annotations.isEmpty && tp2.annotations.isEmpty)) true
+    else annotationCheckers.forall(checker => {
+      !checker.isActive() || checker.annotationsConform(tp1,tp2)
+    })
+
+  /** @see AnnotationChecker.annotationsLub */
+  def annotationsLub(tpe: Type, ts: List[Type]): Type =
+    if (annotationCheckers.isEmpty) tpe
+    else annotationCheckers.foldLeft(tpe)((tpe, checker) =>
+      if (!checker.isActive()) tpe else checker.annotationsLub(tpe, ts))
+
+  /** @see AnnotationChecker.annotationsGlb */
+  def annotationsGlb(tpe: Type, ts: List[Type]): Type =
+    if (annotationCheckers.isEmpty) tpe
+    else annotationCheckers.foldLeft(tpe)((tpe, checker) =>
+      if (!checker.isActive()) tpe else checker.annotationsGlb(tpe, ts))
+
+  /** @see AnnotationChecker.adaptBoundsToAnnotations */
+  def adaptBoundsToAnnotations(bounds: List[TypeBounds], tparams: List[Symbol],
+                               targs: List[Type]): List[TypeBounds] =
+    if (annotationCheckers.isEmpty) bounds
+    else annotationCheckers.foldLeft(bounds)((bounds, checker) =>
+      if (!checker.isActive()) bounds else checker.adaptBoundsToAnnotations(bounds, tparams, targs))
+
+
+  /* The following methods will be removed with the deprecated methods is AnnotationChecker. */
+
+  def addAnnotations(tree: Tree, tpe: Type): Type =
+    if (annotationCheckers.isEmpty) tpe
+    else annotationCheckers.foldLeft(tpe)((tpe, checker) =>
+      if (!checker.isActive()) tpe else checker.addAnnotations(tree, tpe))
+
+  def canAdaptAnnotations(tree: Tree, mode: Mode, pt: Type): Boolean =
+    if (annotationCheckers.isEmpty) false
+    else annotationCheckers.exists(checker => {
+      checker.isActive() && checker.canAdaptAnnotations(tree, mode, pt)
+    })
+
+  def adaptAnnotations(tree: Tree, mode: Mode, pt: Type): Tree =
+    if (annotationCheckers.isEmpty) tree
+    else annotationCheckers.foldLeft(tree)((tree, checker) =>
+      if (!checker.isActive()) tree else checker.adaptAnnotations(tree, mode, pt))
+
+  def adaptTypeOfReturn(tree: Tree, pt: Type, default: => Type): Type =
+    if (annotationCheckers.isEmpty) default
+    else annotationCheckers.foldLeft(default)((tpe, checker) =>
+      if (!checker.isActive()) tpe else checker.adaptTypeOfReturn(tree, pt, tpe))
 }
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 1b0bbe5a06..8cca309d11 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -653,9 +653,10 @@ trait Definitions extends api.StandardDefinitions {
       case tp                     => tp
     }
 
-    def abstractFunctionForFunctionType(tp: Type) =
-      if (isFunctionType(tp)) abstractFunctionType(tp.typeArgs.init, tp.typeArgs.last)
-      else NoType
+    def abstractFunctionForFunctionType(tp: Type) = {
+      assert(isFunctionType(tp), tp)
+      abstractFunctionType(tp.typeArgs.init, tp.typeArgs.last)
+    }
 
     def isFunctionType(tp: Type): Boolean = tp.dealiasWiden match {
       case TypeRef(_, sym, args) if args.nonEmpty =>
diff --git a/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala b/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala
index 2a0fe9d19a..281a32caf6 100644
--- a/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala
+++ b/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala
@@ -31,19 +31,4 @@ trait ExistentialsAndSkolems {
     }
     (new Deskolemizer).typeSkolems
   }
-
-  /** Convert to corresponding type parameters all skolems of method
-   *  parameters which appear in `tparams`.
-   */
-  def deskolemizeTypeParams(tparams: List[Symbol])(tp: Type): Type = {
-    class DeSkolemizeMap extends TypeMap {
-      def apply(tp: Type): Type = tp match {
-        case TypeRef(pre, sym, args) if sym.isTypeSkolem && (tparams contains sym.deSkolemize) =>
-          mapOver(typeRef(NoPrefix, sym.deSkolemize, args))
-        case _ =>
-          mapOver(tp)
-      }
-    }
-    new DeSkolemizeMap mapOver tp
-  }
 }
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index bd9c1576a1..9b7b8bd683 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -1180,6 +1180,10 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      *  Since tpe forwards to tpe_*, if you call it on a type symbol with unapplied
      *  type parameters, the type returned will contain dummies types.  These will
      *  hide legitimate errors or create spurious ones if used as normal types.
+     *
+     *  For type symbols, `tpe` is different than `info`. `tpe` returns a typeRef
+     *  to the type symbol, `info` returns the type information of the type symbol,
+     *  e.g. a ClassInfoType for classes or a TypeBounds for abstract types.
      */
     final def tpe: Type = tpe_*
 
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 71343cfce2..e34d695a61 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -4586,23 +4586,13 @@ trait Types extends api.Types { self: SymbolTable =>
           case idx  => Some(to(idx))
         }
 
-        override def transform(tree: Tree) =
-          tree match {
-            case tree@Ident(_) =>
-              termMapsTo(tree.symbol) match {
-                case Some(tosym) =>
-                  if (tosym.info.bounds.hi.typeSymbol isSubClass SingletonClass) {
-                    Ident(tosym.existentialToString)
-                      .setSymbol(tosym)
-                      .setPos(tosym.pos)
-                      .setType(dropSingletonType(tosym.info.bounds.hi))
-                  } else {
-                    giveup()
-                  }
-                case none => super.transform(tree)
-              }
-            case tree => super.transform(tree)
+        override def transform(tree: Tree) = {
+          termMapsTo(tree.symbol) match {
+            case Some(tosym) => tree.symbol = tosym
+            case None => ()
           }
+          super.transform(tree)
+        }
       }
       trans.transform(tree)
     }
@@ -5802,7 +5792,7 @@ trait Types extends api.Types { self: SymbolTable =>
             (sameLength(params1, params2) &&
              mt1.isImplicit == mt2.isImplicit &&
              matchingParams(params1, params2, mt1.isJava, mt2.isJava) &&
-             isSubType(res1, res2.substSym(params2, params1), depth))
+             isSubType(res1.substSym(params1, params2), res2, depth))
           // TODO: if mt1.params.isEmpty, consider NullaryMethodType?
           case _ =>
             false
@@ -6332,7 +6322,7 @@ trait Types extends api.Types { self: SymbolTable =>
     val ts0 = elimSub0(ts)
     if (ts0.isEmpty || ts0.tail.isEmpty) ts0
     else {
-      val ts1 = ts0 mapConserve (t => elimAnonymousClass(t.underlying))
+      val ts1 = ts0 mapConserve (t => elimAnonymousClass(t.dealiasWiden))
       if (ts1 eq ts0) ts0
       else elimSub(ts1, depth)
     }
@@ -6462,6 +6452,8 @@ trait Types extends api.Types { self: SymbolTable =>
         NullaryMethodType(lub0(matchingRestypes(ts, Nil)))
       case ts @ TypeBounds(_, _) :: rest =>
         TypeBounds(glb(ts map (_.bounds.lo), depth), lub(ts map (_.bounds.hi), depth))
+      case ts @ AnnotatedType(annots, tpe, _) :: rest =>
+        annotationsLub(lub0(ts map (_.withoutAnnotations)), ts)
       case ts =>
         lubResults get (depth, ts) match {
           case Some(lubType) =>
diff --git a/test/files/neg/t5543.check b/test/files/neg/t5543.check
new file mode 100644
index 0000000000..b61de0f78b
--- /dev/null
+++ b/test/files/neg/t5543.check
@@ -0,0 +1,10 @@
+t5543.scala:3: error: not found: type T
+  def this(x: T) { this() }
+              ^
+t5543.scala:11: error: not found: value x
+   def this(a: Int, b: Int = x) {
+                             ^
+t5543.scala:18: error: not found: value x
+  def this(a: Int = x) { this() }
+                    ^
+three errors found
diff --git a/test/files/neg/t5543.scala b/test/files/neg/t5543.scala
new file mode 100644
index 0000000000..4e03e6e114
--- /dev/null
+++ b/test/files/neg/t5543.scala
@@ -0,0 +1,19 @@
+class C1 {
+  type T
+  def this(x: T) { this() }
+}
+
+class C1a[T] {
+  def this(x: T) { this() } // works, no error here
+}
+
+class C2(x: Int) {
+   def this(a: Int, b: Int = x) {
+     this(b)
+  }
+}
+
+class C3 {
+  val x = 0
+  def this(a: Int = x) { this() }
+}
diff --git a/test/files/neg/t6829.check b/test/files/neg/t6829.check
index 8ee6d182eb..7c3c66e0f2 100644
--- a/test/files/neg/t6829.check
+++ b/test/files/neg/t6829.check
@@ -1,6 +1,6 @@
 t6829.scala:35: error: type mismatch;
  found   : AgentSimulation.this.state.type (with underlying type G#State)
- required: _10.State
+ required: _9.State
     lazy val actions: Map[G#Agent,G#Action] = agents.map(a => a -> a.chooseAction(state)).toMap
                                                                                   ^
 t6829.scala:45: error: trait AgentSimulation takes type parameters
@@ -17,12 +17,12 @@ t6829.scala:49: error: not found: value nextState
                                              ^
 t6829.scala:50: error: type mismatch;
  found   : s.type (with underlying type Any)
- required: _54.State where val _54: G
+ required: _53.State where val _53: G
         val r = rewards(agent).r(s,a,s2)
                                  ^
 t6829.scala:51: error: type mismatch;
  found   : s.type (with underlying type Any)
- required: _51.State
+ required: _50.State
         agent.learn(s,a,s2,r): G#Agent
                     ^
 t6829.scala:53: error: not found: value nextState
diff --git a/test/files/pos/lubs.scala b/test/files/pos/lubs.scala
new file mode 100644
index 0000000000..d7651f86b0
--- /dev/null
+++ b/test/files/pos/lubs.scala
@@ -0,0 +1,3 @@
+object Test {
+  List(new { def f = 1; def g = 1}, new { def f = 2}).map(_.f)
+}
diff --git a/test/files/pos/presuperContext.scala b/test/files/pos/presuperContext.scala
new file mode 100644
index 0000000000..cc34263073
--- /dev/null
+++ b/test/files/pos/presuperContext.scala
@@ -0,0 +1,13 @@
+class A {
+  class C extends { val x: A = this } with AnyRef
+}
+
+class B(x: Int)
+
+class D {
+  class C(x: Int) extends B({val test: D = this; x}) {
+    def this() {
+      this({val test: D = this; 1})
+    }
+  }
+}
diff --git a/test/files/pos/t1014.scala b/test/files/pos/t1014.scala
index 1ac87b225b..3fc10d10dc 100644
--- a/test/files/pos/t1014.scala
+++ b/test/files/pos/t1014.scala
@@ -1,6 +1,8 @@
 import scala.xml.{NodeSeq, Elem}
 
-class EO extends App with Moo{
+class EO extends App with Moo {
+  // return type is Flog, inherited from overridden method.
+  // implicit conversions are applied because expected type `pt` is `Flog` when `computeType(rhs, pt)`.
   def cat = <cat>dog</cat>
 
   implicit def nodeSeqToFlog(in: Elem): Flog = new Flog(in)
diff --git a/test/files/pos/t1803.flags b/test/files/pos/t1803.flags
new file mode 100644
index 0000000000..d1a8244169
--- /dev/null
+++ b/test/files/pos/t1803.flags
@@ -0,0 +1 @@
+-Yinfer-argument-types
\ No newline at end of file
diff --git a/test/files/pos/t1803.scala b/test/files/pos/t1803.scala
new file mode 100644
index 0000000000..42f4e784a3
--- /dev/null
+++ b/test/files/pos/t1803.scala
@@ -0,0 +1,2 @@
+class A { def foo[A](a: A) = a }
+class B extends A { override def foo[A](b) = b }
diff --git a/test/files/run/analyzerPlugins.check b/test/files/run/analyzerPlugins.check
new file mode 100644
index 0000000000..0788086459
--- /dev/null
+++ b/test/files/run/analyzerPlugins.check
@@ -0,0 +1,197 @@
+adaptBoundsToAnnots(List( <: Int), List(type T), List(Int @testAnn)) [2]
+annotationsConform(Boolean @testAnn, Boolean) [1]
+annotationsConform(Boolean(false), Boolean @testAnn) [1]
+annotationsConform(Int @testAnn, ?A) [1]
+annotationsConform(Int @testAnn, Any) [1]
+annotationsConform(Int @testAnn, Int) [2]
+annotationsConform(Int(1) @testAnn, Int) [1]
+annotationsConform(Int(1), Int @testAnn) [1]
+annotationsConform(Nothing, Int @testAnn) [2]
+annotationsConform(String @testAnn, String) [1]
+canAdaptAnnotations(Trees$Ident, String) [1]
+canAdaptAnnotations(Trees$Select, ?) [1]
+canAdaptAnnotations(Trees$Select, Boolean @testAnn) [1]
+canAdaptAnnotations(Trees$Select, Boolean) [1]
+canAdaptAnnotations(Trees$Select, String @testAnn) [1]
+canAdaptAnnotations(Trees$TypeTree, ?) [10]
+canAdaptAnnotations(Trees$Typed, ?) [3]
+canAdaptAnnotations(Trees$Typed, Any) [1]
+canAdaptAnnotations(Trees$Typed, Int) [1]
+lub(List(Int @testAnn, Int)) [1]
+pluginsPt(?, Trees$Annotated) [7]
+pluginsPt(?, Trees$Apply) [8]
+pluginsPt(?, Trees$ApplyImplicitView) [2]
+pluginsPt(?, Trees$Assign) [7]
+pluginsPt(?, Trees$Block) [4]
+pluginsPt(?, Trees$ClassDef) [2]
+pluginsPt(?, Trees$DefDef) [14]
+pluginsPt(?, Trees$Ident) [51]
+pluginsPt(?, Trees$If) [2]
+pluginsPt(?, Trees$Literal) [16]
+pluginsPt(?, Trees$New) [5]
+pluginsPt(?, Trees$PackageDef) [1]
+pluginsPt(?, Trees$Return) [1]
+pluginsPt(?, Trees$Select) [51]
+pluginsPt(?, Trees$Super) [2]
+pluginsPt(?, Trees$This) [20]
+pluginsPt(?, Trees$TypeApply) [3]
+pluginsPt(?, Trees$TypeBoundsTree) [2]
+pluginsPt(?, Trees$TypeDef) [1]
+pluginsPt(?, Trees$TypeTree) [38]
+pluginsPt(?, Trees$Typed) [1]
+pluginsPt(?, Trees$ValDef) [21]
+pluginsPt(Any, Trees$Literal) [2]
+pluginsPt(Any, Trees$Typed) [1]
+pluginsPt(Array[Any], Trees$ArrayValue) [1]
+pluginsPt(Boolean @testAnn, Trees$Literal) [1]
+pluginsPt(Boolean @testAnn, Trees$Select) [1]
+pluginsPt(Boolean, Trees$Apply) [1]
+pluginsPt(Boolean, Trees$Ident) [1]
+pluginsPt(Boolean, Trees$Literal) [1]
+pluginsPt(Double, Trees$Select) [1]
+pluginsPt(Int @testAnn, Trees$Literal) [1]
+pluginsPt(Int, Trees$Apply) [1]
+pluginsPt(Int, Trees$Ident) [2]
+pluginsPt(Int, Trees$If) [1]
+pluginsPt(Int, Trees$Literal) [5]
+pluginsPt(Int, Trees$Select) [3]
+pluginsPt(List, Trees$Apply) [1]
+pluginsPt(List[Any], Trees$Select) [1]
+pluginsPt(String @testAnn, Trees$Select) [1]
+pluginsPt(String, Trees$Apply) [1]
+pluginsPt(String, Trees$Block) [2]
+pluginsPt(String, Trees$Ident) [4]
+pluginsPt(String, Trees$Literal) [1]
+pluginsPt(String, Trees$Select) [1]
+pluginsPt(String, Trees$Typed) [1]
+pluginsPt(Unit, Trees$Assign) [1]
+pluginsPt(testAnn, Trees$Apply) [5]
+pluginsTypeSig(<none>, Trees$Template) [2]
+pluginsTypeSig(class A, Trees$ClassDef) [1]
+pluginsTypeSig(class testAnn, Trees$ClassDef) [1]
+pluginsTypeSig(constructor A, Trees$DefDef) [2]
+pluginsTypeSig(constructor testAnn, Trees$DefDef) [1]
+pluginsTypeSig(method foo, Trees$DefDef) [1]
+pluginsTypeSig(method method, Trees$DefDef) [1]
+pluginsTypeSig(method nested, Trees$DefDef) [1]
+pluginsTypeSig(type T, Trees$TypeDef) [2]
+pluginsTypeSig(value annotField, Trees$ValDef) [2]
+pluginsTypeSig(value f, Trees$ValDef) [1]
+pluginsTypeSig(value inferField, Trees$ValDef) [2]
+pluginsTypeSig(value lub1, Trees$ValDef) [2]
+pluginsTypeSig(value lub2, Trees$ValDef) [2]
+pluginsTypeSig(value param, Trees$ValDef) [2]
+pluginsTypeSig(value str, Trees$ValDef) [1]
+pluginsTypeSig(value x, Trees$ValDef) [4]
+pluginsTypeSig(value y, Trees$ValDef) [4]
+pluginsTypeSig(variable count, Trees$ValDef) [3]
+pluginsTypeSigAccessor(value annotField) [1]
+pluginsTypeSigAccessor(value inferField) [1]
+pluginsTypeSigAccessor(value lub1) [1]
+pluginsTypeSigAccessor(value lub2) [1]
+pluginsTypeSigAccessor(value x) [1]
+pluginsTypeSigAccessor(value y) [1]
+pluginsTypeSigAccessor(variable count) [2]
+pluginsTyped( <: Int, Trees$TypeBoundsTree) [2]
+pluginsTyped(()Object, Trees$Select) [1]
+pluginsTyped(()String, Trees$Ident) [1]
+pluginsTyped(()String, Trees$TypeApply) [1]
+pluginsTyped(()scala.annotation.Annotation, Trees$Select) [1]
+pluginsTyped(()testAnn, Trees$Select) [10]
+pluginsTyped((str: String)A <and> (param: Double)A, Trees$Select) [1]
+pluginsTyped((x$1: Any)Boolean <and> (x: Double)Boolean <and> (x: Float)Boolean <and> (x: Long)Boolean <and> (x: Int)Boolean <and> (x: Char)Boolean <and> (x: Short)Boolean <and> (x: Byte)Boolean, Trees$Select) [1]
+pluginsTyped((x$1: Int)Unit, Trees$Select) [1]
+pluginsTyped((x: Double)Double <and> (x: Float)Float <and> (x: Long)Long <and> (x: Int)Int <and> (x: Char)Int <and> (x: Short)Int <and> (x: Byte)Int <and> (x: String)String, Trees$Select) [1]
+pluginsTyped((x: String)scala.collection.immutable.StringOps, Trees$Select) [2]
+pluginsTyped((xs: Array[Any])scala.collection.mutable.WrappedArray[Any], Trees$TypeApply) [1]
+pluginsTyped(<empty>.type, Trees$Ident) [1]
+pluginsTyped(<error>, Trees$Select) [1]
+pluginsTyped(<notype>, Trees$ClassDef) [2]
+pluginsTyped(<notype>, Trees$DefDef) [14]
+pluginsTyped(<notype>, Trees$PackageDef) [1]
+pluginsTyped(<notype>, Trees$TypeDef) [1]
+pluginsTyped(<notype>, Trees$ValDef) [21]
+pluginsTyped(<root>, Trees$Ident) [1]
+pluginsTyped(=> Boolean @testAnn, Trees$Select) [1]
+pluginsTyped(=> Double, Trees$Select) [4]
+pluginsTyped(=> Int, Trees$Select) [5]
+pluginsTyped(=> Int, Trees$TypeApply) [1]
+pluginsTyped(=> String @testAnn, Trees$Select) [1]
+pluginsTyped(A, Trees$Apply) [1]
+pluginsTyped(A, Trees$Ident) [2]
+pluginsTyped(A, Trees$This) [8]
+pluginsTyped(A, Trees$TypeTree) [4]
+pluginsTyped(A.super.type, Trees$Super) [1]
+pluginsTyped(A.this.type, Trees$This) [11]
+pluginsTyped(Any, Trees$TypeTree) [1]
+pluginsTyped(AnyRef, Trees$Select) [4]
+pluginsTyped(Array[Any], Trees$ArrayValue) [1]
+pluginsTyped(Boolean @testAnn, Trees$Select) [1]
+pluginsTyped(Boolean @testAnn, Trees$TypeTree) [4]
+pluginsTyped(Boolean(false), Trees$Literal) [2]
+pluginsTyped(Boolean, Trees$Apply) [1]
+pluginsTyped(Boolean, Trees$Select) [4]
+pluginsTyped(Char('c'), Trees$Literal) [2]
+pluginsTyped(Double, Trees$Select) [6]
+pluginsTyped(Int @testAnn, Trees$TypeTree) [2]
+pluginsTyped(Int @testAnn, Trees$Typed) [2]
+pluginsTyped(Int(0), Trees$Literal) [3]
+pluginsTyped(Int(1) @testAnn, Trees$Typed) [1]
+pluginsTyped(Int(1), Trees$Literal) [8]
+pluginsTyped(Int(2), Trees$Literal) [1]
+pluginsTyped(Int, Trees$Apply) [1]
+pluginsTyped(Int, Trees$Ident) [2]
+pluginsTyped(Int, Trees$If) [2]
+pluginsTyped(Int, Trees$Select) [15]
+pluginsTyped(Int, Trees$TypeTree) [13]
+pluginsTyped(List, Trees$Apply) [1]
+pluginsTyped(List, Trees$Select) [1]
+pluginsTyped(List[Any], Trees$Apply) [1]
+pluginsTyped(List[Any], Trees$Select) [1]
+pluginsTyped(List[Any], Trees$TypeTree) [3]
+pluginsTyped(Nothing, Trees$Return) [1]
+pluginsTyped(Nothing, Trees$Select) [2]
+pluginsTyped(Object, Trees$Apply) [1]
+pluginsTyped(String @testAnn, Trees$Ident) [1]
+pluginsTyped(String @testAnn, Trees$Select) [1]
+pluginsTyped(String @testAnn, Trees$TypeTree) [4]
+pluginsTyped(String(""), Trees$Literal) [2]
+pluginsTyped(String("huhu"), Trees$Literal) [1]
+pluginsTyped(String("str") @testAnn, Trees$Typed) [1]
+pluginsTyped(String("str"), Trees$Literal) [1]
+pluginsTyped(String("str"), Trees$Typed) [1]
+pluginsTyped(String("two"), Trees$Literal) [2]
+pluginsTyped(String, Trees$Apply) [2]
+pluginsTyped(String, Trees$Block) [2]
+pluginsTyped(String, Trees$Ident) [1]
+pluginsTyped(String, Trees$Select) [9]
+pluginsTyped(String, Trees$TypeTree) [7]
+pluginsTyped(Unit, Trees$Apply) [2]
+pluginsTyped(Unit, Trees$Assign) [8]
+pluginsTyped(Unit, Trees$Block) [4]
+pluginsTyped(Unit, Trees$If) [1]
+pluginsTyped(Unit, Trees$Literal) [5]
+pluginsTyped(Unit, Trees$TypeTree) [1]
+pluginsTyped([A](xs: A*)List[A], Trees$Select) [1]
+pluginsTyped([T <: Int]=> Int, Trees$Select) [1]
+pluginsTyped([T0]()T0, Trees$Select) [1]
+pluginsTyped([T](xs: Array[T])scala.collection.mutable.WrappedArray[T], Trees$Select) [1]
+pluginsTyped(annotation.type, Trees$Select) [4]
+pluginsTyped(math.type, Trees$Select) [9]
+pluginsTyped(scala.annotation.Annotation, Trees$Apply) [1]
+pluginsTyped(scala.annotation.TypeConstraint, Trees$Select) [4]
+pluginsTyped(scala.annotation.TypeConstraint, Trees$TypeTree) [2]
+pluginsTyped(scala.collection.immutable.List.type, Trees$Select) [2]
+pluginsTyped(scala.collection.immutable.StringOps, Trees$ApplyImplicitView) [2]
+pluginsTyped(scala.collection.mutable.WrappedArray[Any], Trees$Apply) [1]
+pluginsTyped(scala.type, Trees$Ident) [1]
+pluginsTyped(scala.type, Trees$Select) [1]
+pluginsTyped(str.type, Trees$Ident) [3]
+pluginsTyped(testAnn, Trees$Apply) [5]
+pluginsTyped(testAnn, Trees$Ident) [5]
+pluginsTyped(testAnn, Trees$New) [5]
+pluginsTyped(testAnn, Trees$This) [1]
+pluginsTyped(testAnn, Trees$TypeTree) [2]
+pluginsTyped(testAnn.super.type, Trees$Super) [1]
+pluginsTyped(type, Trees$Select) [1]
+pluginsTypedReturn(return f, String) [1]
diff --git a/test/files/run/analyzerPlugins.scala b/test/files/run/analyzerPlugins.scala
new file mode 100644
index 0000000000..b20a734fe6
--- /dev/null
+++ b/test/files/run/analyzerPlugins.scala
@@ -0,0 +1,121 @@
+import scala.tools.partest._
+import scala.tools.nsc._
+
+object Test extends DirectTest {
+
+  override def extraSettings: String = "-usejavacp"
+
+  def code = """
+    class testAnn extends annotation.TypeConstraint
+
+    class A(param: Double) extends { val x: Int = 1; val y = "two"; type T = A } with AnyRef {
+      val inferField = ("str": @testAnn)
+      val annotField: Boolean @testAnn = false
+
+      val lub1 = List('c', (1: Int @testAnn), "")
+      val lub2 = if (annotField) (1: @testAnn) else 2
+
+      def foo[T <: Int] = 0
+      foo[Int @testAnn]
+
+      var count = 0
+
+      math.random // some statement
+
+      def method: String = {
+        math.random
+        val f = inferField
+
+        def nested(): String = {
+          if(count == 1)
+            return f
+          "huhu"
+        }
+        nested()
+      }
+
+      def this(str: String) {
+        this(str.toDouble)
+        math.random
+        count += 1
+      }
+    }
+  """.trim
+
+
+  def show() {
+    val global = newCompiler()
+    import global._
+    import analyzer._
+
+    val output = collection.mutable.ListBuffer[String]()
+
+    object annotChecker extends AnnotationChecker {
+      def hasTestAnn(tps: Type*) = {
+        tps exists (_.annotations.map(_.toString) contains "testAnn")
+      }
+
+      def annotationsConform(tpe1: Type, tpe2: Type): Boolean = {
+        if (hasTestAnn(tpe1, tpe2))
+          output += s"annotationsConform($tpe1, $tpe2)"
+        true
+      }
+
+      override def annotationsLub(tp: Type, ts: List[Type]): Type = {
+        if (hasTestAnn(ts: _*))
+          output += s"lub($ts)"
+        tp
+      }
+
+      override def adaptBoundsToAnnotations(bounds: List[TypeBounds], tparams: List[Symbol], targs: List[Type]): List[TypeBounds] = {
+        if (hasTestAnn(targs: _*))
+          output += s"adaptBoundsToAnnots($bounds, $tparams, $targs)"
+        bounds
+      }
+    }
+
+    object analyzerPlugin extends AnalyzerPlugin {
+      def treeClass(t: Tree) = t.getClass.toString.split('.').last
+
+      override def pluginsPt(pt: Type, typer: Typer, tree: Tree, mode: Mode): Type = {
+        output += s"pluginsPt($pt, ${treeClass(tree)})"
+        pt
+      }
+  
+      override def pluginsTyped(tpe: Type, typer: Typer, tree: Tree, mode: Mode, pt: Type): Type = {
+        output += s"pluginsTyped($tpe, ${treeClass(tree)})"
+        tpe
+      }
+
+      override def pluginsTypeSig(tpe: Type, typer: Typer, defTree: Tree, pt: Type): Type = {
+        output += s"pluginsTypeSig(${defTree.symbol}, ${treeClass(defTree)})"
+        tpe
+      }
+
+      override def pluginsTypeSigAccessor(tpe: Type, typer: Typer, tree: ValDef, sym: Symbol): Type = {
+        output += s"pluginsTypeSigAccessor(${tree.symbol})"
+        tpe
+      }
+
+
+      override def canAdaptAnnotations(tree: Tree, typer: Typer, mode: Mode, pt: Type): Boolean = {
+        output += s"canAdaptAnnotations(${treeClass(tree)}, $pt)"
+        false
+      }
+
+      override def pluginsTypedReturn(tpe: Type, typer: Typer, tree: Return, pt: Type): Type = {
+        output += s"pluginsTypedReturn($tree, $pt)"
+        tpe
+      }
+
+    }
+
+    addAnnotationChecker(annotChecker)
+    addAnalyzerPlugin(analyzerPlugin)
+    compileString(global)(code)
+
+    val res = output.groupBy(identity).mapValues(_.size).map { case (k,v) => s"$k [$v]" }.toList.sorted
+    println(res.mkString("\n"))
+  }
+
+}
diff --git a/test/files/run/idempotency-case-classes.check b/test/files/run/idempotency-case-classes.check
index 700af3b81b..80d178cba3 100644
--- a/test/files/run/idempotency-case-classes.check
+++ b/test/files/run/idempotency-case-classes.check
@@ -42,7 +42,7 @@ C(2,3)
       C.super.<init>();
       ()
     };
-    final override def toString(): String = "C";
+    final override <synthetic> def toString(): String = "C";
     case <synthetic> def apply(x: Int, y: Int): C = new C(x, y);
     case <synthetic> def unapply(x$0: C): Option[(Int, Int)] = if (x$0.==(null))
       scala.this.None
diff --git a/test/files/run/t5543.check b/test/files/run/t5543.check
index 517038f4c7..2ef2d51ff4 100644
--- a/test/files/run/t5543.check
+++ b/test/files/run/t5543.check
@@ -1,3 +1,9 @@
 Test, 7, 119
 m, 3, 19
 Test, 5, 85
+T
+C
+T
+T
+D
+T
diff --git a/test/files/run/t5543.scala b/test/files/run/t5543.scala
index 651bc7f2b2..3684bf9690 100644
--- a/test/files/run/t5543.scala
+++ b/test/files/run/t5543.scala
@@ -22,5 +22,24 @@ object Test extends Function0[Int] {
     println(sut.toString)
     println(sut.m())
     println(A.init()())
+
+    println((new T.C()).x)
+    println((new T.D(0,0)).x)
+  }
+}
+
+object T {
+  override def toString = "T"
+
+  // `this` refers to T
+  class C(val x: Any = {println(this); this}) { // prints T
+    println(this) // prints C
+    override def toString() = "C"
+  }
+
+  class D(val x: Any) {
+    override def toString() = "D"
+    // `this` refers again to T
+    def this(a: Int, b: Int, c: Any = {println(this); this}) { this(c); println(this) } // prints T, then prints D
   }
 }