Merge commit 'refs/pull/412/head'; commit 'refs/pull/413/head' into develop

27 files changed, 641 insertions, 452 deletions

diff --git a/src/compiler/scala/reflect/internal/Importers.scala b/src/compiler/scala/reflect/internal/Importers.scala
index ab5e19fca9..596d400628 100644
--- a/src/compiler/scala/reflect/internal/Importers.scala
+++ b/src/compiler/scala/reflect/internal/Importers.scala
@@ -71,9 +71,9 @@ trait Importers { self: SymbolTable =>
           case x: from.ModuleSymbol =>
             linkReferenced(myowner.newModuleSymbol(myname, mypos, myflags), x, importSymbol)
           case x: from.FreeTerm =>
-            newFreeTerm(importName(x.name).toTermName, importType(x.info), x.value, x.origin, myflags)
+            newFreeTermSymbol(importName(x.name).toTermName, importType(x.info), x.value, x.flags, x.origin)
           case x: from.FreeType =>
-            newFreeType(importName(x.name).toTypeName, importType(x.info), x.value, x.origin, myflags)
+            newFreeTypeSymbol(importName(x.name).toTypeName, importType(x.info), x.value, x.flags, x.origin)
           case x: from.TermSymbol =>
             linkReferenced(myowner.newValue(myname, mypos, myflags), x, importSymbol)
           case x: from.TypeSkolem =>
diff --git a/src/compiler/scala/reflect/internal/StdAttachments.scala b/src/compiler/scala/reflect/internal/StdAttachments.scala
new file mode 100644
index 0000000000..488195b7dd
--- /dev/null
+++ b/src/compiler/scala/reflect/internal/StdAttachments.scala
@@ -0,0 +1,12 @@
+package scala.reflect
+package internal
+
+import scala.reflect.makro.runtime.{Context => MacroContext}
+
+trait StdAttachments {
+  self: SymbolTable =>
+
+  case class ReifyAttachment(original: Symbol)
+
+  case class MacroAttachment(delayed: Boolean, context: Option[MacroContext])
+}
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/internal/StdNames.scala b/src/compiler/scala/reflect/internal/StdNames.scala
index bf468affe6..c5fe1ecb45 100644
--- a/src/compiler/scala/reflect/internal/StdNames.scala
+++ b/src/compiler/scala/reflect/internal/StdNames.scala
@@ -291,11 +291,14 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     val AnnotationInfo: NameType       = "AnnotationInfo"
     val Any: NameType                  = "Any"
     val AnyVal: NameType               = "AnyVal"
+    val AppliedTypeTree: NameType      = "AppliedTypeTree"
     val Apply: NameType                = "Apply"
     val ArrayAnnotArg: NameType        = "ArrayAnnotArg"
+    val Constant: NameType             = "Constant"
     val ConstantType: NameType         = "ConstantType"
     val EmptyPackage: NameType         = "EmptyPackage"
     val EmptyPackageClass: NameType    = "EmptyPackageClass"
+    val ExistentialTypeTree: NameType  = "ExistentialTypeTree"
     val Expr: NameType                 = "Expr"
     val Ident: NameType                = "Ident"
     val Import: NameType               = "Import"
@@ -404,13 +407,15 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     val name: NameType                 = "name"
     val ne: NameType                   = "ne"
     val newArray: NameType             = "newArray"
+    val newFreeExistential: NameType   = "newFreeExistential"
     val newFreeTerm: NameType          = "newFreeTerm"
     val newFreeType: NameType          = "newFreeType"
     val newNestedSymbol: NameType      = "newNestedSymbol"
     val newScopeWith: NameType         = "newScopeWith"
+    val next: NameType                 = "next"
     val nmeNewTermName: NameType       = "newTermName"
     val nmeNewTypeName: NameType       = "newTypeName"
-    val next: NameType                 = "next"
+    val normalize: NameType            = "normalize"
     val notifyAll_ : NameType          = "notifyAll"
     val notify_ : NameType             = "notify"
     val null_ : NameType               = "null"
@@ -465,6 +470,7 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     val view_ : NameType               = "view"
     val wait_ : NameType               = "wait"
     val withFilter: NameType           = "withFilter"
+    val wrap: NameType                 = "wrap"
     val zip: NameType                  = "zip"
 
     val synthSwitch: NameType          = "$synthSwitch"
diff --git a/src/compiler/scala/reflect/internal/SymbolTable.scala b/src/compiler/scala/reflect/internal/SymbolTable.scala
index 0268339ed0..0688d13ae5 100644
--- a/src/compiler/scala/reflect/internal/SymbolTable.scala
+++ b/src/compiler/scala/reflect/internal/SymbolTable.scala
@@ -38,6 +38,7 @@ abstract class SymbolTable extends api.Universe
                               with TreeBuildUtil
                               with Reporters
                               with CapturedVariables
+                              with StdAttachments
 {
   def rootLoader: LazyType
   def log(msg: => AnyRef): Unit
diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index 6eaae7f1ee..74e924add4 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -47,13 +47,13 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
   /** Create a new free term.  Its owner is NoSymbol.
    */
-  def newFreeTerm(name: TermName, info: Type, value: => Any, origin: String, newFlags: Long = 0L): FreeTerm =
-    new FreeTerm(name, value, origin) initFlags newFlags setInfo info
+  def newFreeTermSymbol(name: TermName, info: Type, value: => Any, flags: Long = 0L, origin: String): FreeTerm =
+    new FreeTerm(name, value, origin) initFlags flags setInfo info
 
   /** Create a new free type.  Its owner is NoSymbol.
    */
-  def newFreeType(name: TypeName, info: Type, value: => Any, origin: String, newFlags: Long = 0L): FreeType =
-    new FreeType(name, value, origin) initFlags newFlags setInfo info
+  def newFreeTypeSymbol(name: TypeName, info: Type, value: => Any, flags: Long = 0L, origin: String): FreeType =
+    new FreeType(name, value, origin) initFlags flags setInfo info
 
   /** The original owner of a class. Used by the backend to generate
    *  EnclosingMethod attributes.
diff --git a/src/compiler/scala/reflect/internal/TreeBuildUtil.scala b/src/compiler/scala/reflect/internal/TreeBuildUtil.scala
index fbcd5043bc..d4d4652e91 100644
--- a/src/compiler/scala/reflect/internal/TreeBuildUtil.scala
+++ b/src/compiler/scala/reflect/internal/TreeBuildUtil.scala
@@ -1,6 +1,8 @@
 package scala.reflect
 package internal
 
+import Flags._
+
 trait TreeBuildUtil extends api.TreeBuildUtil { self: SymbolTable =>
 
   // ``staticClass'' and ``staticModule'' rely on ClassLoaders
@@ -51,9 +53,11 @@ trait TreeBuildUtil extends api.TreeBuildUtil { self: SymbolTable =>
     try selectOverloadedMethod(owner, name, index)
     catch { case _: MissingRequirementError => NoSymbol }
 
-  def newFreeTerm(name: String, info: Type, value: => Any, origin: String) = newFreeTerm(newTermName(name), info, value, origin)
+  def newFreeTerm(name: String, info: Type, value: => Any, flags: Long = 0L, origin: String = null) = newFreeTermSymbol(newTermName(name), info, value, flags, origin)
+
+  def newFreeType(name: String, info: Type, value: => Any, flags: Long = 0L, origin: String = null) = newFreeTypeSymbol(newTypeName(name), info, value, (if (flags == 0L) PARAM else flags) | DEFERRED, origin)
 
-  def newFreeType(name: String, info: Type, value: => Any, origin: String) = newFreeType(newTypeName(name), info, value, origin)
+  def newFreeExistential(name: String, info: Type, value: => Any, flags: Long = 0L, origin: String = null) = newFreeTypeSymbol(newTypeName(name), info, value, (if (flags == 0L) EXISTENTIAL else flags) | DEFERRED, origin)
 
   def modifiersFromInternalFlags(flags: Long, privateWithin: Name, annotations: List[Tree]): Modifiers =
     Modifiers(flags, privateWithin, annotations)
diff --git a/src/compiler/scala/reflect/internal/TreeInfo.scala b/src/compiler/scala/reflect/internal/TreeInfo.scala
index 039c8e557a..937b3ea5d6 100644
--- a/src/compiler/scala/reflect/internal/TreeInfo.scala
+++ b/src/compiler/scala/reflect/internal/TreeInfo.scala
@@ -629,7 +629,7 @@ abstract class TreeInfo {
 
   object ReifiedType {
     def unapply(tree: Tree): Option[(Tree, List[Tree], Tree)] = tree match {
-      case reifee @ Block((mrDef @ ValDef(_, _, _, _)) :: symbolTable, Apply(_, List(tpe))) if mrDef.name == nme.MIRROR_SHORT =>
+      case reifee @ Block((mrDef @ ValDef(_, _, _, _)) :: symbolTable, Apply(_, tpe :: _)) if mrDef.name == nme.MIRROR_SHORT =>
         Some(reifee, symbolTable, tpe)
       case _ =>
         None
@@ -646,11 +646,11 @@ abstract class TreeInfo {
   }
 
   object FreeDef {
-    def unapply(tree: Tree): Option[(Tree, TermName, Tree, String)] = tree match {
-      case FreeTermDef(mrRef, name, binding, origin) =>
-        Some(mrRef, name, binding, origin)
-      case FreeTypeDef(mrRef, name, binding, origin) =>
-        Some(mrRef, name, binding, origin)
+    def unapply(tree: Tree): Option[(Tree, TermName, Tree, Long, String)] = tree match {
+      case FreeTermDef(mrRef, name, binding, flags, origin) =>
+        Some(mrRef, name, binding, flags, origin)
+      case FreeTypeDef(mrRef, name, binding, flags, origin) =>
+        Some(mrRef, name, binding, flags, origin)
       case _ =>
         None
     }
@@ -659,28 +659,29 @@ abstract class TreeInfo {
   object FreeTermDef {
     lazy val newFreeTermMethod = getMember(getRequiredClass("scala.reflect.api.TreeBuildUtil"), nme.newFreeTerm)
 
-    def unapply(tree: Tree): Option[(Tree, TermName, Tree, String)] = tree match {
-      case ValDef(_, name, _, Apply(Select(mrRef @ Ident(_), newFreeTerm), List(_, _, binding, Literal(Constant(origin: String)))))
+    def unapply(tree: Tree): Option[(Tree, TermName, Tree, Long, String)] = tree match {
+      case ValDef(_, name, _, Apply(Select(mrRef @ Ident(_), newFreeTerm), List(_, _, binding, Literal(Constant(flags: Long)), Literal(Constant(origin: String)))))
       if mrRef.name == nme.MIRROR_SHORT && newFreeTerm == newFreeTermMethod.name =>
-        Some(mrRef, name, binding, origin)
+        Some(mrRef, name, binding, flags, origin)
       case _ =>
         None
     }
   }
 
   object FreeTypeDef {
-    lazy val newFreeTypeMethod = getMember(getRequiredClass("scala.reflect.api.TreeBuildUtil"), nme.newFreeType)
+    lazy val newFreeExistentialMethod = getMember(getRequiredClass("scala.reflect.api.TreeBuildUtil"), nme.newFreeType)
+    lazy val newFreeTypeMethod = getMember(getRequiredClass("scala.reflect.api.TreeBuildUtil"), nme.newFreeExistential)
 
-    def unapply(tree: Tree): Option[(Tree, TermName, Tree, String)] = tree match {
-      case ValDef(_, name, _, Apply(Select(mrRef1 @ Ident(_), newFreeType), List(_, _, value, Literal(Constant(origin: String)))))
-      if mrRef1.name == nme.MIRROR_SHORT && newFreeType == newFreeTypeMethod.name =>
+    def unapply(tree: Tree): Option[(Tree, TermName, Tree, Long, String)] = tree match {
+      case ValDef(_, name, _, Apply(Select(mrRef1 @ Ident(_), newFreeType), List(_, _, value, Literal(Constant(flags: Long)), Literal(Constant(origin: String)))))
+      if mrRef1.name == nme.MIRROR_SHORT && (newFreeType == newFreeTypeMethod.name || newFreeType == newFreeExistentialMethod.name) =>
         value match {
           case Apply(TypeApply(Select(Select(mrRef2 @ Ident(_), typeTag), apply), List(binding)), List(Literal(Constant(null))))
           if mrRef2.name == nme.MIRROR_SHORT && typeTag == nme.TypeTag && apply == nme.apply =>
-            Some(mrRef1, name, binding, origin)
+            Some(mrRef1, name, binding, flags, origin)
           case Apply(TypeApply(Select(mrRef2 @ Ident(_), typeTag), List(binding)), List(Literal(Constant(null))))
           if mrRef2.name == nme.MIRROR_SHORT && typeTag == nme.TypeTag =>
-            Some(mrRef1, name, binding, origin)
+            Some(mrRef1, name, binding, flags, origin)
           case _ =>
             throw new Error("unsupported free type def: " + showRaw(tree))
         }
diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala
index fc57a130d1..7115cafc33 100644
--- a/src/compiler/scala/reflect/internal/Types.scala
+++ b/src/compiler/scala/reflect/internal/Types.scala
@@ -277,7 +277,7 @@ trait Types extends api.Types { self: SymbolTable =>
         case SuperType(_, _) => false
         case SingleType(pre, sym) => notConcreteSym(sym)
         case ConstantType(_) => false
-        case TypeRef(_, sym, _) => notConcreteSym(sym)
+        case TypeRef(_, sym, args) => notConcreteSym(sym) || (args exists (arg => notConcreteTpe(arg)))
         case RefinedType(_, _) => false
         case ExistentialType(_, _) => false
         case AnnotatedType(_, tp, _) => notConcreteTpe(tp)
diff --git a/src/compiler/scala/reflect/makro/runtime/Enclosures.scala b/src/compiler/scala/reflect/makro/runtime/Enclosures.scala
index f9a6987e48..72e9e568c0 100644
--- a/src/compiler/scala/reflect/makro/runtime/Enclosures.scala
+++ b/src/compiler/scala/reflect/makro/runtime/Enclosures.scala
@@ -11,7 +11,7 @@ trait Enclosures {
 
   val macroApplication: Tree = expandee
 
-  val enclosingMacros: List[Context] = this :: mirror.analyzer.openMacros
+  val enclosingMacros: List[Context] = this :: mirror.analyzer.openMacros // include self
 
   val enclosingImplicits: List[(Type, Tree)] = callsiteTyper.context.openImplicits
 
diff --git a/src/compiler/scala/reflect/makro/runtime/Reifiers.scala b/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
index 2488b06d6c..7c96b568bd 100644
--- a/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
+++ b/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
@@ -10,6 +10,7 @@ trait Reifiers {
   self: Context =>
 
   import mirror._
+  import definitions._
 
   lazy val reflectMirrorPrefix: Tree = {
     // [Eugene] how do I typecheck this without undergoing this tiresome (and, in general, incorrect) procedure?
@@ -24,6 +25,44 @@ trait Reifiers {
   def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, requireConcreteTypeTag: Boolean = false): Tree =
     reifyTopLevel(prefix, tpe, dontSpliceAtTopLevel, requireConcreteTypeTag)
 
+  def reifyErasure(tpe: Type): Tree = {
+    val positionBearer = enclosingMacros.find(c => c.macroApplication.pos != NoPosition).map(_.macroApplication).getOrElse(EmptyTree).asInstanceOf[Tree]
+    val typetagInScope = callsiteTyper.context.withMacrosDisabled(callsiteTyper.resolveTypeTag(positionBearer, singleType(Reflect_mirror.owner.thisPrefix, Reflect_mirror), tpe, full = true))
+    def typetagIsSynthetic(tree: Tree) = tree.isInstanceOf[Block] || (tree exists (sub => sub.symbol == TypeTagModule || sub.symbol == ConcreteTypeTagModule))
+    typetagInScope match {
+      case success if !success.isEmpty && !typetagIsSynthetic(success) =>
+        val factory = TypeApply(Select(Ident(ClassTagModule), nme.apply), List(TypeTree(tpe)))
+        Apply(factory, List(typetagInScope))
+      case _ =>
+        if (tpe.typeSymbol == ArrayClass) {
+          val componentTpe = tpe.typeArguments(0)
+          val componentTag = callsiteTyper.resolveClassTag(positionBearer, componentTpe)
+          Select(componentTag, nme.wrap)
+        } else {
+          // [Eugene] what's the intended behavior? there's no spec on ClassManifests
+          // for example, should we ban Array[T] or should we tag them with Array[AnyRef]?
+          // if its the latter, what should be the result of tagging Array[T] where T <: Int?
+          if (tpe.isSpliceable) throw new ReificationError(enclosingPosition, "tpe %s is an unresolved spliceable type".format(tpe))
+          // [Eugene] imho this logic should be moved into `erasure`
+          var erasure = tpe match {
+            case tpe if tpe.typeSymbol.isDerivedValueClass => tpe // [Eugene to Martin] is this correct?
+            case ConstantType(value) => tpe.widen.erasure
+            case _ => {
+              // [Eugene] magikz. needs review
+              var result = tpe.erasure.normalize // necessary to deal with erasures of HK types, typeConstructor won't work
+              result = result match {
+                case PolyType(undets, underlying) => existentialAbstraction(undets, underlying) // we don't want undets in the result
+                case _ => result
+              }
+              result
+            }
+          }
+          val factory = TypeApply(Select(Ident(ClassTagModule), nme.apply), List(TypeTree(tpe)))
+          Apply(factory, List(TypeApply(Select(Ident(PredefModule), nme.classOf), List(TypeTree(erasure)))))
+        }
+    }
+ }
+
   def unreifyTree(tree: Tree): Tree =
     Select(tree, definitions.ExprEval)
 
@@ -34,7 +73,7 @@ trait Reifiers {
 
     try {
       val result = reifier.reified
-      logFreeVars(expandee.pos, result)
+      logFreeVars(enclosingPosition, result)
       result
     } catch {
       case ex: reifier.ReificationError =>
diff --git a/src/compiler/scala/reflect/makro/runtime/Typers.scala b/src/compiler/scala/reflect/makro/runtime/Typers.scala
index 38e819746d..98dbd65b72 100644
--- a/src/compiler/scala/reflect/makro/runtime/Typers.scala
+++ b/src/compiler/scala/reflect/makro/runtime/Typers.scala
@@ -4,9 +4,9 @@ package runtime
 trait Typers {
   self: Context =>
 
-  val openMacros: List[Context] = this :: mirror.analyzer.openMacros
+  def openMacros: List[Context] = this :: mirror.analyzer.openMacros
 
-  val openImplicits: List[(Type, Tree)] = callsiteTyper.context.openImplicits
+  def openImplicits: List[(Type, Tree)] = callsiteTyper.context.openImplicits
 
   def typeCheck(tree: Tree, pt: Type = mirror.WildcardType, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): Tree = {
     def trace(msg: Any) = if (mirror.settings.Ymacrodebug.value) println(msg)
@@ -34,9 +34,9 @@ trait Typers {
     def trace(msg: Any) = if (mirror.settings.Ymacrodebug.value) println(msg)
     trace("inferring implicit value of type %s, macros = %s".format(pt, !withMacrosDisabled))
     import mirror.analyzer.SearchResult
-    val wrapper1 = if (!withMacrosDisabled) (callsiteTyper.context.withMacrosEnabled[SearchResult] _) else (callsiteTyper.context.withMacrosDisabled[SearchResult] _)
+    val context = callsiteTyper.context
+    val wrapper1 = if (!withMacrosDisabled) (context.withMacrosEnabled[SearchResult] _) else (context.withMacrosDisabled[SearchResult] _)
     def wrapper (inference: => SearchResult) = wrapper1(inference)
-    val context = callsiteTyper.context.makeImplicit(true)
     wrapper(mirror.analyzer.inferImplicit(mirror.EmptyTree, pt, true, false, context, !silent, pos)) match {
       case failure if failure.tree.isEmpty =>
         trace("implicit search has failed. to find out the reason, turn on -Xlog-implicits")
@@ -51,12 +51,12 @@ trait Typers {
     def trace(msg: Any) = if (mirror.settings.Ymacrodebug.value) println(msg)
     trace("inferring implicit view from %s to %s for %s, macros = %s, reportAmbiguous = %s".format(from, to, tree, !withMacrosDisabled, reportAmbiguous))
     import mirror.analyzer.SearchResult
-    val wrapper1 = if (!withMacrosDisabled) (callsiteTyper.context.withMacrosEnabled[SearchResult] _) else (callsiteTyper.context.withMacrosDisabled[SearchResult] _)
+    val context = callsiteTyper.context
+    val wrapper1 = if (!withMacrosDisabled) (context.withMacrosEnabled[SearchResult] _) else (context.withMacrosDisabled[SearchResult] _)
     def wrapper (inference: => SearchResult) = wrapper1(inference)
     val fun1 = mirror.definitions.FunctionClass(1)
     val viewTpe = mirror.TypeRef(fun1.typeConstructor.prefix, fun1, List(from, to))
-    val context = callsiteTyper.context.makeImplicit(reportAmbiguous)
-    wrapper(mirror.analyzer.inferImplicit(mirror.EmptyTree, viewTpe, reportAmbiguous, true, context, !silent, pos)) match {
+    wrapper(mirror.analyzer.inferImplicit(tree, viewTpe, reportAmbiguous, true, context, !silent, pos)) match {
       case failure if failure.tree.isEmpty =>
         trace("implicit search has failed. to find out the reason, turn on -Xlog-implicits")
         if (context.hasErrors) throw new mirror.TypeError(context.errBuffer.head.errPos, context.errBuffer.head.errMsg)
diff --git a/src/compiler/scala/reflect/reify/Reifier.scala b/src/compiler/scala/reflect/reify/Reifier.scala
index 16c26734b2..c89ebf0d39 100644
--- a/src/compiler/scala/reflect/reify/Reifier.scala
+++ b/src/compiler/scala/reflect/reify/Reifier.scala
@@ -47,6 +47,15 @@ abstract class Reifier extends Phases
       if (prefix exists (_.isErroneous)) CannotReifyErroneousPrefix(prefix)
       if (prefix.tpe == null) CannotReifyUntypedPrefix(prefix)
 
+      def reifyErasure(tpe: Type): Tree = {
+        val result = typer.resolveClassTag(positionBearer, tpe)
+        if (result == EmptyTree) throw new Error("cannot reify erasure for %s: ".format(tpe))
+        result match {
+          case Apply(TypeApply(Select(_, _), _), List(clazz)) => clazz
+          case _ => Select(result, nme.erasure)
+        }
+      }
+
       val rtree = reifee match {
         case tree: Tree =>
           reifyTrace("reifying = ")(if (opt.showTrees) "\n" + nodePrinters.nodeToString(tree).trim else tree.toString)
@@ -73,11 +82,11 @@ abstract class Reifier extends Phases
             CannotReifyReifeeThatHasTypeLocalToReifee(tree)
 
           val manifestedType = typer.packedType(tree, NoSymbol)
-          val manifestedRtype = reifyType(manifestedType)
           val tagModule = if (definitelyConcrete) ConcreteTypeTagModule else TypeTagModule
-          var typeTagCtor = TypeApply(Select(Ident(nme.MIRROR_SHORT), tagModule.name), List(TypeTree(manifestedType)))
-          var exprCtor = TypeApply(Select(Ident(nme.MIRROR_SHORT), ExprModule.name), List(TypeTree(manifestedType)))
-          Apply(Apply(exprCtor, List(rtree)), List(Apply(typeTagCtor, List(manifestedRtype))))
+          val tagCtor = TypeApply(Select(Ident(nme.MIRROR_SHORT), tagModule.name), List(TypeTree(manifestedType)))
+          val exprCtor = TypeApply(Select(Ident(nme.MIRROR_SHORT), ExprModule.name), List(TypeTree(manifestedType)))
+          val tagArgs = if (definitelyConcrete) List(reify(manifestedType), reifyErasure(manifestedType)) else List(reify(manifestedType))
+          Apply(Apply(exprCtor, List(rtree)), List(Apply(tagCtor, tagArgs)))
 
         case tpe: Type =>
           reifyTrace("reifying = ")(tpe.toString)
@@ -85,9 +94,10 @@ abstract class Reifier extends Phases
           val rtree = reify(tpe)
 
           val manifestedType = tpe
-          var tagModule = if (definitelyConcrete) ConcreteTypeTagModule else TypeTagModule
-          var ctor = TypeApply(Select(Ident(nme.MIRROR_SHORT), tagModule.name), List(TypeTree(manifestedType)))
-          Apply(ctor, List(rtree))
+          val tagModule = if (definitelyConcrete) ConcreteTypeTagModule else TypeTagModule
+          val ctor = TypeApply(Select(Ident(nme.MIRROR_SHORT), tagModule.name), List(TypeTree(manifestedType)))
+          val args = if (definitelyConcrete) List(rtree, reifyErasure(manifestedType)) else List(rtree)
+          Apply(ctor, args)
 
         case _ =>
           throw new Error("reifee %s of type %s is not supported".format(reifee, if (reifee == null) "null" else reifee.getClass.toString))
@@ -126,7 +136,7 @@ abstract class Reifier extends Phases
       // 3) local freeterm inlining in Metalevels
       // 4) trivial tree splice inlining in Reify (Trees.scala)
       // 5) trivial type splice inlining in Reify (Types.scala)
-      val freevarBindings = symbolTable collect { case freedef @ FreeDef(_, _, binding, _) => binding.symbol } toSet
+      val freevarBindings = symbolTable collect { case entry @ FreeDef(_, _, binding, _, _) => binding.symbol } toSet
       val untyped = resetAllAttrs(wrapped, leaveAlone = {
         case ValDef(_, mr, _, _) if mr == nme.MIRROR_SHORT => true
         case tree if freevarBindings contains tree.symbol => true
diff --git a/src/compiler/scala/reflect/reify/codegen/Symbols.scala b/src/compiler/scala/reflect/reify/codegen/Symbols.scala
index 2fc0002838..7f8b9c53b6 100644
--- a/src/compiler/scala/reflect/reify/codegen/Symbols.scala
+++ b/src/compiler/scala/reflect/reify/codegen/Symbols.scala
@@ -63,9 +63,9 @@ trait Symbols {
           assert(value.isInstanceOf[Ident], showRaw(value))
           val capturedTpe = capturedVariableType(sym)
           val capturedValue = referenceCapturedVariable(sym)
-          locallyReify(sym, name, mirrorCall(nme.newFreeTerm, reify(sym.name.toString), reify(capturedTpe), capturedValue, reify(origin(sym))))
+          locallyReify(sym, name, mirrorCall(nme.newFreeTerm, reify(sym.name.toString), reify(capturedTpe), capturedValue, reify(sym.flags), reify(origin(sym))))
         } else {
-          locallyReify(sym, name, mirrorCall(nme.newFreeTerm, reify(sym.name.toString), reify(sym.tpe), value, reify(origin(sym))))
+          locallyReify(sym, name, mirrorCall(nme.newFreeTerm, reify(sym.name.toString), reify(sym.tpe), value, reify(sym.flags), reify(origin(sym))))
         }
     }
 
@@ -77,8 +77,8 @@ trait Symbols {
         if (reifyDebug) println("Free type: %s (%s)".format(sym, sym.accurateKindString))
         var name = newTermName(nme.MIRROR_FREE_PREFIX + sym.name)
         val phantomTypeTag = Apply(TypeApply(Select(Ident(nme.MIRROR_SHORT), nme.TypeTag), List(value)), List(Literal(Constant(null))))
-        // todo. implement info reification for free types: type bounds, HK-arity, whatever else that can be useful
-        locallyReify(sym, name, mirrorCall(nme.newFreeType, reify(sym.name.toString), reify(sym.info), phantomTypeTag, reify(origin(sym))))
+        val flavor = if (sym.isExistential) nme.newFreeExistential else nme.newFreeType
+        locallyReify(sym, name, mirrorCall(flavor, reify(sym.name.toString), reify(sym.info), phantomTypeTag, reify(sym.flags), reify(origin(sym))))
     }
 
   def reifySymDef(sym: Symbol): Tree =
@@ -105,9 +105,9 @@ trait Symbols {
     filledIn = false
     newSymbolTable foreach {
       case entry =>
-        val att = entry.attachment
+        val att = entry.attachmentOpt[ReifyAttachment]
         att match {
-          case sym: Symbol =>
+          case Some(ReifyAttachment(sym)) =>
             // don't duplicate reified symbols when merging inlined reifee
             if (!(locallyReified contains sym)) {
               val ValDef(_, name, _, _) = entry
@@ -134,7 +134,7 @@ trait Symbols {
     // todo. tried to declare a private class here to carry an attachment, but it's path-dependent
     // so got troubles with exchanging free variables between nested and enclosing quasiquotes
     // attaching just Symbol isn't good either, so we need to think of a principled solution
-    val local = ValDef(NoMods, name, TypeTree(), reified) setAttachment sym
+    val local = ValDef(NoMods, name, TypeTree(), reified) withAttachment ReifyAttachment(sym)
     localReifications += local
     filledIn = false
     locallyReified(sym) = Ident(name)
@@ -149,8 +149,9 @@ trait Symbols {
       while (i < localReifications.length) {
         // fillInSymbol might create new locallyReified symbols, that's why this is done iteratively
         val reified = localReifications(i)
-        reified.attachment match {
-          case sym: Symbol => fillIns += fillInSymbol(sym)
+        val att = reified.attachmentOpt[ReifyAttachment]
+        att match {
+          case Some(ReifyAttachment(sym)) => fillIns += fillInSymbol(sym)
           case other => // do nothing
         }
         i += 1
@@ -169,9 +170,15 @@ trait Symbols {
       if (sym.annotations.isEmpty) EmptyTree
       else Apply(Select(locallyReified(sym), nme.setAnnotations), List(reify(sym.annotations)))
     } else {
-      val rset = Apply(Select(locallyReified(sym), nme.setTypeSignature), List(reifyType(sym.info)))
-      if (sym.annotations.isEmpty) rset
-      else Apply(Select(rset, nme.setAnnotations), List(reify(sym.annotations)))
+     import scala.reflect.internal.Flags._
+     if (sym hasFlag LOCKED) {
+       // [Eugene] better to have a symbol without a type signature, than to crash with a CyclicReference
+       EmptyTree
+     } else {
+       val rset = Apply(Select(locallyReified(sym), nme.setTypeSignature), List(reify(sym.info)))
+       if (sym.annotations.isEmpty) rset
+       else Apply(Select(rset, nme.setAnnotations), List(reify(sym.annotations)))
+     }
     }
   }
 }
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/reify/codegen/Trees.scala b/src/compiler/scala/reflect/reify/codegen/Trees.scala
index 5ad53c0009..c9f5fc5b8d 100644
--- a/src/compiler/scala/reflect/reify/codegen/Trees.scala
+++ b/src/compiler/scala/reflect/reify/codegen/Trees.scala
@@ -7,6 +7,7 @@ trait Trees {
   import mirror._
   import definitions._
   import treeInfo._
+  import scala.reflect.api.Modifier
 
   // unfortunately, these are necessary to reify AnnotatedTypes
   // I'd gladly got rid of them, but I don't fancy making a metaprogramming API that doesn't work with annotated types
@@ -46,7 +47,7 @@ trait Trees {
         reifyMirrorObject(EmptyTree)
       case mirror.emptyValDef =>
         mirrorSelect(nme.emptyValDef)
-      case FreeDef(_, _, _, _) =>
+      case FreeDef(_, _, _, _, _) =>
         reifyNestedFreeDef(tree)
       case FreeRef(_, _) =>
         reifyNestedFreeRef(tree)
@@ -57,6 +58,28 @@ trait Trees {
       case NestedExpr(_, _, _) =>
         reifyNestedExpr(tree)
       case Literal(const @ Constant(_)) =>
+        // [Eugene] was necessary when we reified erasures as normalized tycons
+        // now, when we do existentialAbstraction on normalizations, everything works great
+        // todo. find an explanation
+//        if (const.tag == ClazzTag) {
+////          def preprocess(tpe: Type): Type = tpe.typeSymbol match {
+////            case ArrayClass => appliedType(ArrayClass, preprocess(tpe.typeArgs.head))
+////            case _ => tpe.typeConstructor
+////          }
+////          val tpe = preprocess(const.typeValue)
+//          val tpe = const.typeValue
+//          var reified = reify(tpe)
+//          reified = mirrorCall(nme.Literal, mirrorCall(nme.Constant, reified))
+////          val skolems = ClassClass.typeParams map (_ => newTypeName(typer.context.unit.fresh.newName("_$")))
+////          var existential = mirrorCall(nme.AppliedTypeTree, mirrorCall(nme.TypeTree, reify(ClassClass.typeConstructor)), mkList(skolems map (skolem => mirrorCall(nme.Ident, reify(skolem)))))
+////          existential = mirrorCall(nme.ExistentialTypeTree, existential, reify(skolems map (skolem => TypeDef(Modifiers(Set(Modifier.deferred: Modifier)), skolem, Nil, TypeBoundsTree(Ident(NothingClass) setType NothingClass.tpe, Ident(AnyClass) setType AnyClass.tpe)))))
+////          reified = mirrorCall(nme.TypeApply, mirrorCall(nme.Select, reified, reify(nme.asInstanceOf_)), mkList(List(existential)))
+//          // why is this required??
+////          reified = mirrorCall(nme.TypeApply, mirrorCall(nme.Select, reified, reify(nme.asInstanceOf_)), mkList(List(mirrorCall(nme.TypeTree, reify(appliedType(ClassClass.tpe, List(AnyClass.tpe)))))))
+//          reified
+//        } else {
+//          mirrorCall(nme.Literal, reifyProduct(const))
+//        }
         mirrorCall(nme.Literal, reifyProduct(const))
       case Import(expr, selectors) =>
         mirrorCall(nme.Import, reify(expr), mkList(selectors map reifyProduct))
@@ -68,11 +91,11 @@ trait Trees {
     // however, reification of AnnotatedTypes is special. see ``reifyType'' to find out why.
     if (reifyTreeSymbols && tree.hasSymbol) {
       if (reifyDebug) println("reifying symbol %s for tree %s".format(tree.symbol, tree))
-      rtree = Apply(Select(rtree, nme.setSymbol), List(reifySymRef(tree.symbol)))
+      rtree = Apply(Select(rtree, nme.setSymbol), List(reify(tree.symbol)))
     }
     if (reifyTreeTypes && tree.tpe != null) {
       if (reifyDebug) println("reifying type %s for tree %s".format(tree.tpe, tree))
-      rtree = Apply(Select(rtree, nme.setType), List(reifyType(tree.tpe)))
+      rtree = Apply(Select(rtree, nme.setType), List(reify(tree.tpe)))
     }
 
     rtree
@@ -98,7 +121,7 @@ trait Trees {
             case InlinedTreeSplice(_, inlinedSymbolTable, tree, _) =>
               if (reifyDebug) println("inlining the splicee")
               // all free vars local to the enclosing reifee should've already been inlined by ``Metalevels''
-              inlinedSymbolTable collect { case freedef @ FreeDef(_, _, binding, _) if binding.symbol.isLocalToReifee => assert(false, freedef) }
+              inlinedSymbolTable collect { case freedef @ FreeDef(_, _, binding, _, _) if binding.symbol.isLocalToReifee => assert(false, freedef) }
               symbolTable ++= inlinedSymbolTable
               tree
             case tree =>
@@ -172,7 +195,7 @@ trait Trees {
           val spliced = spliceType(tpe)
           if (spliced == EmptyTree) {
             if (reifyDebug) println("splicing failed: reify as is")
-            mirrorCall(nme.TypeTree, reifyType(tpe))
+            mirrorCall(nme.TypeTree, reify(tpe))
           } else {
             spliced match {
               case TypeRefToFreeType(freeType) =>
@@ -189,7 +212,7 @@ trait Trees {
             mirrorCall(nme.Ident, reify(sym))
           } else {
             if (reifyDebug) println("tpe is an alias, but not a locatable: reify as TypeTree(%s)".format(tpe))
-            mirrorCall(nme.TypeTree, reifyType(tpe))
+            mirrorCall(nme.TypeTree, reify(tpe))
           }
         }
       }
diff --git a/src/compiler/scala/reflect/reify/codegen/Types.scala b/src/compiler/scala/reflect/reify/codegen/Types.scala
index 948728088e..e2a2a69828 100644
--- a/src/compiler/scala/reflect/reify/codegen/Types.scala
+++ b/src/compiler/scala/reflect/reify/codegen/Types.scala
@@ -65,8 +65,16 @@ trait Types {
   private var spliceTypesEnabled = !dontSpliceAtTopLevel
 
   /** Keeps track of whether this reification contains abstract type parameters */
-  var maybeConcrete = true
-  var definitelyConcrete = true
+  private var _definitelyConcrete = true
+  def definitelyConcrete = _definitelyConcrete
+  def definitelyConcrete_=(value: Boolean) {
+    _definitelyConcrete = value
+    if (!value && requireConcreteTypeTag) {
+      assert(current.isInstanceOf[Type], current)
+      val offender = current.asInstanceOf[Type]
+      CannotReifyConcreteTypeTagHavingUnresolvedTypeParameters(offender)
+    }
+  }
 
   private type SpliceCacheKey = (Symbol, Symbol)
   private lazy val spliceCache: collection.mutable.Map[SpliceCacheKey, Tree] = {
@@ -75,7 +83,9 @@ trait Types {
   }
 
   def spliceType(tpe: Type): Tree = {
-    if (tpe.isSpliceable) {
+    // [Eugene] it seems that depending on the context the very same symbol can be either a spliceable tparam or a quantified existential. very weird!
+    val quantified = currents collect { case ExistentialType(quantified, _) => quantified } flatMap identity
+    if (tpe.isSpliceable && !(quantified contains tpe.typeSymbol)) {
       if (reifyDebug) println("splicing " + tpe)
 
       if (spliceTypesEnabled) {
@@ -89,22 +99,18 @@ trait Types {
           // if this fails, it might produce the dreaded "erroneous or inaccessible type" error
           // to find out the whereabouts of the error run scalac with -Ydebug
           if (reifyDebug) println("launching implicit search for %s.%s[%s]".format(prefix, tagClass.name, tpe))
-          val positionBearer = mirror.analyzer.openMacros.find(c => c.macroApplication.pos != NoPosition).map(_.macroApplication).getOrElse(EmptyTree).asInstanceOf[Tree]
           typer.resolveTypeTag(positionBearer, prefix.tpe, tpe, requireConcreteTypeTag) match {
             case failure if failure.isEmpty =>
               if (reifyDebug) println("implicit search was fruitless")
-              definitelyConcrete &= false
-              maybeConcrete &= false
               EmptyTree
             case success =>
               if (reifyDebug) println("implicit search has produced a result: " + success)
-              definitelyConcrete |= requireConcreteTypeTag
-              maybeConcrete |= true
+              definitelyConcrete &= requireConcreteTypeTag
               var splice = Select(success, nme.tpe)
               splice match {
                 case InlinedTypeSplice(_, inlinedSymbolTable, tpe) =>
                   // all free vars local to the enclosing reifee should've already been inlined by ``Metalevels''
-                  inlinedSymbolTable collect { case freedef @ FreeDef(_, _, binding, _) if binding.symbol.isLocalToReifee => assert(false, freedef) }
+                  inlinedSymbolTable collect { case freedef @ FreeDef(_, _, binding, _, _) if binding.symbol.isLocalToReifee => assert(false, freedef) }
                   symbolTable ++= inlinedSymbolTable
                   reifyTrace("inlined the splicee: ")(tpe)
                 case tpe =>
@@ -117,8 +123,7 @@ trait Types {
         if (reifyDebug) println("splicing has been cancelled: spliceTypesEnabled = false")
       }
 
-      if (requireConcreteTypeTag)
-        CannotReifyConcreteTypeTagHavingUnresolvedTypeParameters(tpe)
+      definitelyConcrete = false
     }
 
     spliceTypesEnabled = true
diff --git a/src/compiler/scala/reflect/reify/codegen/Util.scala b/src/compiler/scala/reflect/reify/codegen/Util.scala
index bb369a1adb..8d7cf39ff7 100644
--- a/src/compiler/scala/reflect/reify/codegen/Util.scala
+++ b/src/compiler/scala/reflect/reify/codegen/Util.scala
@@ -14,6 +14,8 @@ trait Util {
   object reifiedNodePrinters extends { val global: mirror.type = mirror } with tools.nsc.ast.NodePrinters with NodePrinters
   val reifiedNodeToString = reifiedNodePrinters.reifiedNodeToString
 
+  val positionBearer = mirror.analyzer.openMacros.find(c => c.macroApplication.pos != NoPosition).map(_.macroApplication).getOrElse(EmptyTree).asInstanceOf[Tree]
+
   def reifyList(xs: List[Any]): Tree =
     mkList(xs map reify)
 
diff --git a/src/compiler/scala/reflect/reify/phases/Metalevels.scala b/src/compiler/scala/reflect/reify/phases/Metalevels.scala
index bb0b8ac138..206f3b1118 100644
--- a/src/compiler/scala/reflect/reify/phases/Metalevels.scala
+++ b/src/compiler/scala/reflect/reify/phases/Metalevels.scala
@@ -115,7 +115,7 @@ trait Metalevels {
         if (reifyDebug) println("entering inlineable splice: " + splicee)
         val Block(mrDef :: symbolTable, expr) = splicee
         // [Eugene] how to express the fact that a scrutinee is both of some type and matches an extractor?
-        val freedefsToInline = symbolTable collect { case freedef @ FreeTermDef(_, _, binding, _) if binding.symbol.isLocalToReifee => freedef.asInstanceOf[ValDef] }
+        val freedefsToInline = symbolTable collect { case freedef @ FreeTermDef(_, _, binding, _, _) if binding.symbol.isLocalToReifee => freedef.asInstanceOf[ValDef] }
         freedefsToInline foreach (vdef => this.freedefsToInline(vdef.name) = vdef)
         val symbolTable1 = symbolTable diff freedefsToInline
         val tree1 = Select(Block(mrDef :: symbolTable1, expr), flavor)
@@ -138,7 +138,7 @@ trait Metalevels {
       // some of them need to be rebuilt, some of them need to be removed, because they're no longer necessary
       case FreeRef(mr, name) if freedefsToInline contains name =>
         if (reifyDebug) println("inlineable free ref: %s in %s".format(name, showRaw(tree)))
-        val freedef @ FreeDef(_, _, binding, _) = freedefsToInline(name)
+        val freedef @ FreeDef(_, _, binding, _, _) = freedefsToInline(name)
         if (reifyDebug) println("related definition: %s".format(showRaw(freedef)))
         val inlined = reify(binding)
         if (reifyDebug) println("verdict: inlined as %s".format(showRaw(inlined)))
diff --git a/src/compiler/scala/reflect/reify/phases/Reify.scala b/src/compiler/scala/reflect/reify/phases/Reify.scala
index 02a96987ed..a1ff486ed7 100644
--- a/src/compiler/scala/reflect/reify/phases/Reify.scala
+++ b/src/compiler/scala/reflect/reify/phases/Reify.scala
@@ -23,24 +23,33 @@ trait Reify extends Symbols
    *  Reifies any supported value.
    *  For internal use only, use ``reified'' instead.
    */
-  def reify(reifee: Any): Tree = reifee match {
-    // before adding some case here, in global scope, please, consider
-    // whether it can be localized like reifyAnnotationInfo or reifyScope
-    // this will help reification stay as sane as possible
-    case sym: Symbol              => reifySymRef(sym)
-    case tpe: Type                => reifyType(tpe)
-    case name: Name               => reifyName(name)
-    case tree: Tree               => reifyTree(tree)
-    // disabled because this is a very special case that I plan to remove later
-    // why do I dislike annotations? see comments to `reifyAnnotationInfo`
-//    case ann: AnnotationInfo      => reifyAnnotationInfo(ann)
-    case pos: Position            => reifyPosition(pos)
-    case mods: mirror.Modifiers   => reifyModifiers(mods)
-    case xs: List[_]              => reifyList(xs)
-    case s: String                => Literal(Constant(s))
-    case v if isAnyVal(v)         => Literal(Constant(v))
-    case null                     => Literal(Constant(null))
-    case _                        =>
-      throw new Error("reifee %s of type %s is not supported".format(reifee, reifee.getClass))
+  var currents: List[Any] = reifee :: Nil
+  def current = currents.head
+  def reify(reifee: Any): Tree = {
+    currents = reifee :: currents
+    try {
+      reifee match {
+        // before adding some case here, in global scope, please, consider
+        // whether it can be localized like reifyAnnotationInfo or reifyScope
+        // this will help reification stay as sane as possible
+        case sym: Symbol              => reifySymRef(sym)
+        case tpe: Type                => reifyType(tpe)
+        case name: Name               => reifyName(name)
+        case tree: Tree               => reifyTree(tree)
+        // disabled because this is a very special case that I plan to remove later
+        // why do I dislike annotations? see comments to `reifyAnnotationInfo`
+//        case ann: AnnotationInfo      => reifyAnnotationInfo(ann)
+        case pos: Position            => reifyPosition(pos)
+        case mods: mirror.Modifiers   => reifyModifiers(mods)
+        case xs: List[_]              => reifyList(xs)
+        case s: String                => Literal(Constant(s))
+        case v if isAnyVal(v)         => Literal(Constant(v))
+        case null                     => Literal(Constant(null))
+        case _                        =>
+          throw new Error("reifee %s of type %s is not supported".format(reifee, reifee.getClass))
+      }
+    } finally {
+      currents = currents.tail
+    }
   }
 }
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/reify/phases/Reshape.scala b/src/compiler/scala/reflect/reify/phases/Reshape.scala
index e700604612..4ab306a13f 100644
--- a/src/compiler/scala/reflect/reify/phases/Reshape.scala
+++ b/src/compiler/scala/reflect/reify/phases/Reshape.scala
@@ -78,12 +78,6 @@ trait Reshape {
           if (reifyDebug) println("unapplying unapply: " + tree)
           val fun1 = extractExtractor(fun)
           Apply(fun1, args).copyAttrs(unapply)
-        case Literal(const @ Constant(tpe: Type)) =>
-          // todo. implement this
-          ???
-        case Literal(const @ Constant(sym: Symbol)) =>
-          // todo. implement this
-          ???
         case _ =>
           tree
       }
diff --git a/src/compiler/scala/reflect/runtime/SynchronizedSymbols.scala b/src/compiler/scala/reflect/runtime/SynchronizedSymbols.scala
index 6fc5f7ed8a..4048e94d0f 100644
--- a/src/compiler/scala/reflect/runtime/SynchronizedSymbols.scala
+++ b/src/compiler/scala/reflect/runtime/SynchronizedSymbols.scala
@@ -14,11 +14,11 @@ trait SynchronizedSymbols extends internal.Symbols { self: SymbolTable =>
   override def connectModuleToClass(m: ModuleSymbol, moduleClass: ClassSymbol): ModuleSymbol =
     synchronized { super.connectModuleToClass(m, moduleClass) }
 
-  override def newFreeTerm(name: TermName, info: Type, value: => Any, origin: String = null, newFlags: Long = 0L): FreeTerm =
-    new FreeTerm(name, value, origin) with SynchronizedTermSymbol initFlags newFlags setInfo info
+  override def newFreeTermSymbol(name: TermName, info: Type, value: => Any, flags: Long = 0L, origin: String = null): FreeTerm =
+    new FreeTerm(name, value, origin) with SynchronizedTermSymbol initFlags flags setInfo info
 
-  override def newFreeType(name: TypeName, info: Type, value: => Any, origin: String = null, newFlags: Long = 0L): FreeType =
-    new FreeType(name, value, origin) with SynchronizedTypeSymbol initFlags newFlags setInfo info
+  override def newFreeTypeSymbol(name: TypeName, info: Type, value: => Any, flags: Long = 0L, origin: String = null): FreeType =
+    new FreeType(name, value, origin) with SynchronizedTypeSymbol initFlags flags setInfo info
 
   override protected def makeNoSymbol: NoSymbol = new NoSymbol with SynchronizedSymbol
 
diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala
index 767df0791e..f89f278338 100644
--- a/src/compiler/scala/tools/nsc/CompilationUnits.scala
+++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala
@@ -91,7 +91,7 @@ trait CompilationUnits { self: Global =>
       currentRun.deprecationWarnings.warn(pos, msg)
 
     def uncheckedWarning(pos: Position, msg: String) =
-      currentRun.uncheckedWarnings.warn(pos, msg)
+      currentRun.uncheckedWarnings0.warn(pos, msg)
 
     def inlinerWarning(pos: Position, msg: String) =
       currentRun.inlinerWarnings.warn(pos, msg)
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index bbeee3220b..c9394b37b5 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -8,7 +8,6 @@ package scala.tools.nsc
 import java.io.{ File, FileOutputStream, PrintWriter, IOException, FileNotFoundException }
 import java.nio.charset.{ Charset, CharsetDecoder, IllegalCharsetNameException, UnsupportedCharsetException }
 import compat.Platform.currentTime
-
 import scala.tools.util.{ Profiling, PathResolver }
 import scala.collection.{ mutable, immutable }
 import io.{ SourceReader, AbstractFile, Path }
@@ -16,7 +15,6 @@ import reporters.{ Reporter => NscReporter, ConsoleReporter }
 import util.{ NoPosition, Exceptional, ClassPath, SourceFile, NoSourceFile, Statistics, StatisticsInfo, BatchSourceFile, ScriptSourceFile, ShowPickled, ScalaClassLoader, returning }
 import scala.reflect.internal.pickling.{ PickleBuffer, PickleFormat }
 import settings.{ AestheticSettings }
-
 import symtab.{ Flags, SymbolTable, SymbolLoaders, SymbolTrackers }
 import symtab.classfile.Pickler
 import dependencies.DependencyAnalysis
@@ -25,13 +23,13 @@ import ast._
 import ast.parser._
 import typechecker._
 import transform._
-
 import backend.icode.{ ICodes, GenICode, ICodeCheckers }
 import backend.{ ScalaPrimitives, Platform, MSILPlatform, JavaPlatform }
 import backend.jvm.GenJVM
 import backend.opt.{ Inliners, InlineExceptionHandlers, ClosureElimination, DeadCodeElimination }
 import backend.icode.analysis._
 import language.postfixOps
+import reflect.internal.StdAttachments
 
 class Global(var currentSettings: Settings, var reporter: NscReporter) extends SymbolTable
                                                                           with ClassLoaders
@@ -135,6 +133,16 @@ class Global(var currentSettings: Settings, var reporter: NscReporter) extends S
     infolevel = InfoLevel.Verbose
   }
 
+  def withInfoLevel[T](infolevel: nodePrinters.InfoLevel.Value)(op: => T) = {
+    val saved = nodePrinters.infolevel
+    try {
+      nodePrinters.infolevel = infolevel
+      op
+    } finally {
+      nodePrinters.infolevel = saved
+    }
+  }
+
   /** Representing ASTs as graphs */
   object treeBrowsers extends {
     val global: Global.this.type = Global.this
@@ -967,10 +975,15 @@ class Global(var currentSettings: Settings, var reporter: NscReporter) extends S
     var currentUnit: CompilationUnit = NoCompilationUnit
 
     val deprecationWarnings = new ConditionalWarning("deprecation", settings.deprecation)
-    val uncheckedWarnings = new ConditionalWarning("unchecked", settings.unchecked)
+    // This change broke sbt; I gave it the thrilling name of uncheckedWarnings0 so
+    // as to recover uncheckedWarnings for its ever-fragile compiler interface.
+    val uncheckedWarnings0 = new ConditionalWarning("unchecked", settings.unchecked)
     val featureWarnings = new ConditionalWarning("feature", settings.feature)
     val inlinerWarnings = new ConditionalWarning("inliner", settings.YinlinerWarnings)
-    val allConditionalWarnings = List(deprecationWarnings, uncheckedWarnings, featureWarnings, inlinerWarnings)
+    val allConditionalWarnings = List(deprecationWarnings, uncheckedWarnings0, featureWarnings, inlinerWarnings)
+
+    // for sbt's benefit
+    def uncheckedWarnings: List[(Position, String)] = uncheckedWarnings0.warnings.toList
 
     var reportedFeature = Set[Symbol]()
 
diff --git a/src/compiler/scala/tools/nsc/ast/FreeVars.scala b/src/compiler/scala/tools/nsc/ast/FreeVars.scala
index 1bf36e8bf2..a1983d1834 100644
--- a/src/compiler/scala/tools/nsc/ast/FreeVars.scala
+++ b/src/compiler/scala/tools/nsc/ast/FreeVars.scala
@@ -13,9 +13,9 @@ trait FreeVars extends reflect.internal.FreeVars { self: Global =>
         case Reified(_, symbolTable, _) =>
           // logging free vars only when they are untyped prevents avalanches of duplicate messages
           symbolTable foreach {
-            case FreeTermDef(_, _, binding, origin) if settings.logFreeTerms.value && binding.tpe == null =>
+            case FreeTermDef(_, _, binding, _, origin) if settings.logFreeTerms.value && binding.tpe == null =>
               reporter.echo(position, "free term: %s %s".format(showRaw(binding), origin))
-            case FreeTypeDef(_, _, binding, origin) if settings.logFreeTypes.value && binding.tpe == null =>
+            case FreeTypeDef(_, _, binding, _, origin) if settings.logFreeTypes.value && binding.tpe == null =>
               reporter.echo(position, "free type: %s %s".format(showRaw(binding), origin))
             case _ =>
               // do nothing
diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala
index 0e44933ac6..4e03dc8788 100644
--- a/src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala
@@ -246,6 +246,7 @@ trait ModelFactoryImplicitSupport {
       val appliedTree = new ApplyImplicitView(viewTree, List(Ident("<argument>") setType viewTree.tpe.paramTypes.head))
       val appliedTreeTyped: Tree = {
         val newContext = context.makeImplicit(context.ambiguousErrors)
+        newContext.macrosEnabled = false // [Eugene] I assume you want macro signature, not macro expansion
         val newTyper = global.analyzer.newTyper(newContext)
           newTyper.silent(_.typed(appliedTree, global.analyzer.EXPRmode, WildcardType), false) match {
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 4fb9362ccc..651120db4f 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -32,10 +32,10 @@ trait Implicits {
   import global.typer.{ printTyping, deindentTyping, indentTyping, printInference }
 
   def inferImplicit(tree: Tree, pt: Type, reportAmbiguous: Boolean, isView: Boolean, context: Context): SearchResult =
-    inferImplicit(tree, pt, reportAmbiguous, isView, context, true, NoPosition)
+    inferImplicit(tree, pt, reportAmbiguous, isView, context, true, tree.pos)
 
   def inferImplicit(tree: Tree, pt: Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean): SearchResult =
-    inferImplicit(tree, pt, reportAmbiguous, isView, context, saveAmbiguousDivergent, NoPosition)
+    inferImplicit(tree, pt, reportAmbiguous, isView, context, saveAmbiguousDivergent, tree.pos)
 
   /** Search for an implicit value. See the comment on `result` at the end of class `ImplicitSearch`
    *  for more info how the search is conducted.
@@ -633,6 +633,7 @@ trait Implicits {
               else {
                 val subst = new TreeTypeSubstituter(okParams, okArgs)
                 subst traverse itree2
+                notifyUndetparamsInferred(okParams, okArgs)
                 subst
               }
 
@@ -1161,7 +1162,8 @@ trait Implicits {
       // todo. migrate hardcoded materialization in Implicits to corresponding implicit macros
       var materializer = atPos(pos.focus)(Apply(TypeApply(Ident(TagMaterializers(tagClass)), List(TypeTree(tp))), List(prefix)))
       if (settings.XlogImplicits.value) println("materializing requested %s.%s[%s] using %s".format(pre, tagClass.name, tp, materializer))
-      success(materializer)
+      if (context.macrosEnabled) success(materializer)
+      else failure(materializer, "macros are disabled")
     }
 
     /** The manifest corresponding to type `pt`, provided `pt` is an instance of Manifest.
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 62a0e08aad..539ddfb19c 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -294,6 +294,8 @@ trait Macros { self: Analyzer =>
               } finally {
                 openMacros = openMacros.tail
               }
+            case Delay(result) =>
+              result
             case Fallback(fallback) =>
               typer.typed1(fallback, EXPRmode, WildcardType)
             case Other(result) =>
@@ -641,139 +643,147 @@ trait Macros { self: Analyzer =>
    *  @return Some(runtime) if macro implementation can be loaded successfully from either of the mirrors,
    *          None otherwise.
    */
-  private def macroRuntime(macroDef: Symbol): Option[List[Any] => Any] = {
-    macroTrace("looking for macro implementation: ")(macroDef)
-    macroTrace("macroDef is annotated with: ")(macroDef.annotations)
-
-    val ann = macroDef.getAnnotation(MacroImplAnnotation)
-    if (ann == None) {
-      macroTrace("@macroImpl annotation is missing (this means that macro definition failed to typecheck)")(macroDef)
-      return None
-    }
-
-    val macroImpl = ann.get.args(0).symbol
-    if (macroImpl == NoSymbol) {
-      macroTrace("@macroImpl annotation is malformed (this means that macro definition failed to typecheck)")(macroDef)
-      return None
-    }
-
-    if (macroDebug) println("resolved implementation %s at %s".format(macroImpl, macroImpl.pos))
-    if (macroImpl.isErroneous) {
-      macroTrace("macro implementation is erroneous (this means that either macro body or macro implementation signature failed to typecheck)")(macroDef)
-      return None
-    }
-
-    def loadMacroImpl(macroMirror: Mirror): Option[(Object, macroMirror.Symbol)] = {
-      try {
-        // this logic relies on the assumptions that were valid for the old macro prototype
-        // namely that macro implementations can only be defined in top-level classes and modules
-        // with the new prototype that materialized in a SIP, macros need to be statically accessible, which is different
-        // for example, a macro def could be defined in a trait that is implemented by an object
-        // there are some more clever cases when seemingly non-static method ends up being statically accessible
-        // however, the code below doesn't account for these guys, because it'd take a look of time to get it right
-        // for now I leave it as a todo and move along to more the important stuff
-
-        macroTrace("loading implementation class from %s: ".format(macroMirror))(macroImpl.owner.fullName)
-        macroTrace("classloader is: ")("%s of type %s".format(macroMirror.classLoader, if (macroMirror.classLoader != null) macroMirror.classLoader.getClass.toString else "primordial classloader"))
-        def inferClasspath(cl: ClassLoader) = cl match {
-          case cl: java.net.URLClassLoader => "[" + (cl.getURLs mkString ",") + "]"
-          case null => "[" + scala.tools.util.PathResolver.Environment.javaBootClassPath + "]"
-          case _ => "<unknown>"
+  private type MacroRuntime = List[Any] => Any
+  private val macroRuntimesCache = perRunCaches.newWeakMap[Symbol, Option[MacroRuntime]]
+  private def macroRuntime(macroDef: Symbol): Option[MacroRuntime] =
+    macroRuntimesCache.getOrElseUpdate(macroDef, {
+      val runtime = {
+        macroTrace("looking for macro implementation: ")(macroDef)
+        macroTrace("macroDef is annotated with: ")(macroDef.annotations)
+
+        val ann = macroDef.getAnnotation(MacroImplAnnotation)
+        if (ann == None) {
+          macroTrace("@macroImpl annotation is missing (this means that macro definition failed to typecheck)")(macroDef)
+          return None
         }
-        macroTrace("classpath is: ")(inferClasspath(macroMirror.classLoader))
-
-        // [Eugene] relies on the fact that macro implementations can only be defined in static classes
-        // [Martin to Eugene] There's similar logic buried in Symbol#flatname. Maybe we can refactor?
-        def classfile(sym: Symbol): String = {
-          def recur(sym: Symbol): String = sym match {
-            case sym if sym.owner.isPackageClass =>
-              val suffix = if (sym.isModuleClass) "$" else ""
-              sym.fullName + suffix
-            case sym =>
-              val separator = if (sym.owner.isModuleClass) "" else "$"
-              recur(sym.owner) + separator + sym.javaSimpleName.toString
-          }
 
-          if (sym.isClass || sym.isModule) recur(sym)
-          else recur(sym.enclClass)
+        val macroImpl = ann.get.args(0).symbol
+        if (macroImpl == NoSymbol) {
+          macroTrace("@macroImpl annotation is malformed (this means that macro definition failed to typecheck)")(macroDef)
+          return None
         }
 
-        // [Eugene] this doesn't work for inner classes
-        // neither does macroImpl.owner.javaClassName, so I had to roll my own implementation
-        //val receiverName = macroImpl.owner.fullName
-        val implClassName = classfile(macroImpl.owner)
-        val implClassSymbol: macroMirror.Symbol = macroMirror.symbolForName(implClassName)
-
-        if (macroDebug) {
-          println("implClassSymbol is: " + implClassSymbol.fullNameString)
-
-          if (implClassSymbol != macroMirror.NoSymbol) {
-            val implClass = macroMirror.classToJava(implClassSymbol)
-            val implSource = implClass.getProtectionDomain.getCodeSource
-            println("implClass is %s from %s".format(implClass, implSource))
-            println("implClassLoader is %s with classpath %s".format(implClass.getClassLoader, inferClasspath(implClass.getClassLoader)))
-          }
+        if (macroDebug) println("resolved implementation %s at %s".format(macroImpl, macroImpl.pos))
+        if (macroImpl.isErroneous) {
+          macroTrace("macro implementation is erroneous (this means that either macro body or macro implementation signature failed to typecheck)")(macroDef)
+          return None
         }
 
-        val implObjSymbol = implClassSymbol.companionModule
-        macroTrace("implObjSymbol is: ")(implObjSymbol.fullNameString)
+        def loadMacroImpl(macroMirror: Mirror): Option[(Object, macroMirror.Symbol)] = {
+          try {
+            // this logic relies on the assumptions that were valid for the old macro prototype
+            // namely that macro implementations can only be defined in top-level classes and modules
+            // with the new prototype that materialized in a SIP, macros need to be statically accessible, which is different
+            // for example, a macro def could be defined in a trait that is implemented by an object
+            // there are some more clever cases when seemingly non-static method ends up being statically accessible
+            // however, the code below doesn't account for these guys, because it'd take a look of time to get it right
+            // for now I leave it as a todo and move along to more the important stuff
+
+            macroTrace("loading implementation class from %s: ".format(macroMirror))(macroImpl.owner.fullName)
+            macroTrace("classloader is: ")("%s of type %s".format(macroMirror.classLoader, if (macroMirror.classLoader != null) macroMirror.classLoader.getClass.toString else "primordial classloader"))
+            def inferClasspath(cl: ClassLoader) = cl match {
+              case cl: java.net.URLClassLoader => "[" + (cl.getURLs mkString ",") + "]"
+              case null => "[" + scala.tools.util.PathResolver.Environment.javaBootClassPath + "]"
+              case _ => "<unknown>"
+            }
+            macroTrace("classpath is: ")(inferClasspath(macroMirror.classLoader))
+
+            // [Eugene] relies on the fact that macro implementations can only be defined in static classes
+            // [Martin to Eugene] There's similar logic buried in Symbol#flatname. Maybe we can refactor?
+            def classfile(sym: Symbol): String = {
+              def recur(sym: Symbol): String = sym match {
+                case sym if sym.owner.isPackageClass =>
+                  val suffix = if (sym.isModuleClass) "$" else ""
+                  sym.fullName + suffix
+                case sym =>
+                  val separator = if (sym.owner.isModuleClass) "" else "$"
+                  recur(sym.owner) + separator + sym.javaSimpleName.toString
+              }
 
-        if (implObjSymbol == macroMirror.NoSymbol) None
-        else {
-          // yet another reflection method that doesn't work for inner classes
-          //val receiver = macroMirror.companionInstance(receiverClass)
-          val implObj = try {
-            val implObjClass = java.lang.Class.forName(implClassName, true, macroMirror.classLoader)
-            implObjClass getField "MODULE$" get null
-          } catch {
-            case ex: NoSuchFieldException => macroTrace("exception when loading implObj: ")(ex); null
-            case ex: NoClassDefFoundError => macroTrace("exception when loading implObj: ")(ex); null
-            case ex: ClassNotFoundException => macroTrace("exception when loading implObj: ")(ex); null
-          }
+              if (sym.isClass || sym.isModule) recur(sym)
+              else recur(sym.enclClass)
+            }
+
+            // [Eugene] this doesn't work for inner classes
+            // neither does macroImpl.owner.javaClassName, so I had to roll my own implementation
+            //val receiverName = macroImpl.owner.fullName
+            val implClassName = classfile(macroImpl.owner)
+            val implClassSymbol: macroMirror.Symbol = macroMirror.symbolForName(implClassName)
 
-          if (implObj == null) None
-          else {
-            val implMethSymbol = implObjSymbol.info.member(macroMirror.newTermName(macroImpl.name.toString))
             if (macroDebug) {
-              println("implMethSymbol is: " + implMethSymbol.fullNameString)
-              println("jimplMethSymbol is: " + macroMirror.methodToJava(implMethSymbol))
+              println("implClassSymbol is: " + implClassSymbol.fullNameString)
+
+              if (implClassSymbol != macroMirror.NoSymbol) {
+                val implClass = macroMirror.classToJava(implClassSymbol)
+                val implSource = implClass.getProtectionDomain.getCodeSource
+                println("implClass is %s from %s".format(implClass, implSource))
+                println("implClassLoader is %s with classpath %s".format(implClass.getClassLoader, inferClasspath(implClass.getClassLoader)))
+              }
             }
 
-            if (implMethSymbol == macroMirror.NoSymbol) None
+            val implObjSymbol = implClassSymbol.companionModule
+            macroTrace("implObjSymbol is: ")(implObjSymbol.fullNameString)
+
+            if (implObjSymbol == macroMirror.NoSymbol) None
             else {
-              if (macroDebug) println("successfully loaded macro impl as (%s, %s)".format(implObj, implMethSymbol))
-              Some((implObj, implMethSymbol))
+              // yet another reflection method that doesn't work for inner classes
+              //val receiver = macroMirror.companionInstance(receiverClass)
+              val implObj = try {
+                val implObjClass = java.lang.Class.forName(implClassName, true, macroMirror.classLoader)
+                implObjClass getField "MODULE$" get null
+              } catch {
+                case ex: NoSuchFieldException => macroTrace("exception when loading implObj: ")(ex); null
+                case ex: NoClassDefFoundError => macroTrace("exception when loading implObj: ")(ex); null
+                case ex: ClassNotFoundException => macroTrace("exception when loading implObj: ")(ex); null
+              }
+
+              if (implObj == null) None
+              else {
+                val implMethSymbol = implObjSymbol.info.member(macroMirror.newTermName(macroImpl.name.toString))
+                if (macroDebug) {
+                  println("implMethSymbol is: " + implMethSymbol.fullNameString)
+                  println("jimplMethSymbol is: " + macroMirror.methodToJava(implMethSymbol))
+                }
+
+                if (implMethSymbol == macroMirror.NoSymbol) None
+                else {
+                  if (macroDebug) println("successfully loaded macro impl as (%s, %s)".format(implObj, implMethSymbol))
+                  Some((implObj, implMethSymbol))
+                }
+              }
             }
+          } catch {
+            case ex: ClassNotFoundException =>
+              macroTrace("implementation class failed to load: ")(ex.toString)
+              None
           }
         }
-      } catch {
-        case ex: ClassNotFoundException =>
-          macroTrace("implementation class failed to load: ")(ex.toString)
-          None
-      }
-    }
 
-    val primary = loadMacroImpl(primaryMirror)
-    primary match {
-      case Some((implObj, implMethSymbol)) =>
-        def runtime(args: List[Any]) = primaryMirror.invoke(implObj, implMethSymbol)(args: _*).asInstanceOf[Any]
-        Some(runtime)
-      case None =>
-        if (settings.XmacroFallbackClasspath.value != "") {
-          if (macroDebug) println("trying to load macro implementation from the fallback mirror: %s".format(settings.XmacroFallbackClasspath.value))
-          val fallback = loadMacroImpl(fallbackMirror)
-          fallback match {
-            case Some((implObj, implMethSymbol)) =>
-              def runtime(args: List[Any]) = fallbackMirror.invoke(implObj, implMethSymbol)(args: _*).asInstanceOf[Any]
-              Some(runtime)
-            case None =>
+        val primary = loadMacroImpl(primaryMirror)
+        primary match {
+          case Some((implObj, implMethSymbol)) =>
+            def runtime(args: List[Any]) = primaryMirror.invoke(implObj, implMethSymbol)(args: _*).asInstanceOf[Any]
+            Some(runtime _)
+          case None =>
+            if (settings.XmacroFallbackClasspath.value != "") {
+              if (macroDebug) println("trying to load macro implementation from the fallback mirror: %s".format(settings.XmacroFallbackClasspath.value))
+              val fallback = loadMacroImpl(fallbackMirror)
+              fallback match {
+                case Some((implObj, implMethSymbol)) =>
+                  def runtime(args: List[Any]) = fallbackMirror.invoke(implObj, implMethSymbol)(args: _*).asInstanceOf[Any]
+                  Some(runtime _)
+                case None =>
+                  None
+              }
+            } else {
               None
-          }
-        } else {
-          None
+            }
         }
-    }
-  }
+      }
+
+      if (runtime == None) macroDef setFlag IS_ERROR
+      runtime
+    })
 
   /** Should become private again once we're done with migrating typetag generation from implicits */
   def macroContext(typer: Typer, prefixTree: Tree, expandeeTree: Tree): MacroContext { val mirror: global.type } =
@@ -784,7 +794,7 @@ trait Macros { self: Analyzer =>
       val prefix = Expr(prefixTree)(TypeTag.Nothing)
       val expandee = expandeeTree
     } with MacroContext {
-      override def toString = "MacroContext(%s@%s +%d)".format(expandee.symbol.name, expandee.pos, openMacros.length - 1 /* exclude myself */)
+      override def toString = "MacroContext(%s@%s +%d)".format(expandee.symbol.name, expandee.pos, enclosingMacros.length - 1 /* exclude myself */)
     }
 
   /** Calculate the arguments to pass to a macro implementation when expanding the provided tree.
@@ -795,6 +805,10 @@ trait Macros { self: Analyzer =>
    *  @return list of runtime objects to pass to the implementation obtained by ``macroRuntime''
    */
   private def macroArgs(typer: Typer, expandee: Tree): Option[List[Any]] = {
+    val macroDef = expandee.symbol
+    val runtime = macroRuntime(macroDef)
+    if (runtime == None) return None
+
     var prefixTree: Tree = EmptyTree
     var typeArgs = List[Tree]()
     val exprArgs = new ListBuffer[List[Expr[_]]]
@@ -811,11 +825,10 @@ trait Macros { self: Analyzer =>
       case _ =>
     }
     collectMacroArgs(expandee)
-    val context = macroContext(typer, prefixTree, expandee)
+    val context = expandee.attachmentOpt[MacroAttachment].flatMap(_.context).getOrElse(macroContext(typer, prefixTree, expandee))
     var argss: List[List[Any]] = List(context) :: exprArgs.toList
     macroTrace("argss: ")(argss)
 
-    val macroDef = expandee.symbol
     val ann = macroDef.getAnnotation(MacroImplAnnotation).getOrElse(throw new Error("assertion failed. %s: %s".format(macroDef, macroDef.annotations)))
     val macroImpl = ann.args(0).symbol
     var paramss = macroImpl.paramss
@@ -923,62 +936,92 @@ trait Macros { self: Analyzer =>
    *    the expandee with an error marker set   if the expansion has been cancelled due malformed arguments or implementation
    *    the expandee with an error marker set   if there has been an error
    */
-  def macroExpand(typer: Typer, expandee: Tree, pt: Type): Tree =
-    macroExpand1(typer, expandee) match {
-      case Success(expanded) =>
-        try {
-          var expectedTpe = expandee.tpe
-
-          // [Eugene] weird situation. what's the conventional way to deal with it?
-          val isNullaryInvocation = expandee match {
-            case TypeApply(Select(_, _), _) => true
-            case Select(_, _) => true
-            case _ => false
-          }
-          if (isNullaryInvocation) expectedTpe match {
-            case MethodType(Nil, restpe) =>
-              macroTrace("nullary invocation of a method with an empty parameter list. unwrapping expectedTpe from " + expectedTpe + " to:")(restpe)
-              expectedTpe = restpe
-            case _ => ;
-          }
+  def macroExpand(typer: Typer, expandee: Tree, mode: Int = EXPRmode, pt: Type = WildcardType): Tree = {
+    val start = startTimer(macroExpandNanos)
+    incCounter(macroExpandCount)
+    try {
+      macroExpand1(typer, expandee) match {
+        case Success(expanded) =>
+          try {
+            var expectedTpe = expandee.tpe
+
+            // [Eugene] weird situation. what's the conventional way to deal with it?
+            val isNullaryInvocation = expandee match {
+              case TypeApply(Select(_, _), _) => true
+              case TypeApply(Ident(_), _) => true
+              case Select(_, _) => true
+              case Ident(_) => true
+              case _ => false
+            }
+            if (isNullaryInvocation) expectedTpe match {
+              case NullaryMethodType(restpe) =>
+                macroTrace("nullary invocation of a nullary method. unwrapping expectedTpe from " + expectedTpe + " to: ")(restpe)
+                expectedTpe = restpe
+              case MethodType(Nil, restpe) =>
+                macroTrace("nullary invocation of a method with an empty parameter list. unwrapping expectedTpe from " + expectedTpe + " to: ")(restpe)
+                expectedTpe = restpe
+              case _ => ;
+            }
 
-          var typechecked = typer.context.withImplicitsEnabled(typer.typed(expanded, EXPRmode, expectedTpe))
-          if (macroDebug) {
-            println("typechecked1:")
-            println(typechecked)
-            println(showRaw(typechecked))
-          }
+            def fail(what: String): Tree = {
+              val err = typer.context.errBuffer.head
+              this.fail(typer, expanded, "failed to perform %s: %s at %s".format(what, err.errMsg, err.errPos))
+              return expandee
+            }
 
-          typechecked = typer.context.withImplicitsEnabled(typer.typed(typechecked, EXPRmode, pt))
-          if (macroDebug) {
-            println("typechecked2:")
-            println(typechecked)
-            println(showRaw(typechecked))
-          }
+            if (macroDebug) println("typechecking1 against %s: %s".format(expectedTpe, expanded))
+            var typechecked = typer.context.withImplicitsEnabled(typer.typed(expanded, EXPRmode, expectedTpe))
+            if (typer.context.hasErrors) fail("typecheck1")
+            if (macroDebug) {
+              println("typechecked1:")
+              println(typechecked)
+              println(showRaw(typechecked))
+            }
 
-          typechecked
-        } finally {
-          openMacros = openMacros.tail
-        }
-      case Fallback(fallback) =>
-        typer.context.withImplicitsEnabled(typer.typed(fallback, EXPRmode, pt))
-      case Other(result) =>
-        result
+            if (macroDebug) println("typechecking2 against %s: %s".format(pt, expanded))
+            typechecked = typer.context.withImplicitsEnabled(typer.typed(typechecked, EXPRmode, pt))
+            if (typer.context.hasErrors) fail("typecheck2")
+            if (macroDebug) {
+              println("typechecked2:")
+              println(typechecked)
+              println(showRaw(typechecked))
+            }
+
+            typechecked
+          } finally {
+            openMacros = openMacros.tail
+          }
+        case Delay(expandee) =>
+          // need to save the context to preserve enclosures
+          val args = macroArgs(typer, expandee)
+          assert(args.isDefined, expandee)
+          val context = args.get.head.asInstanceOf[MacroContext]
+          var result = expandee withAttachment MacroAttachment(delayed = true, context = Some(context))
+          // adapting here would be premature, we must wait until undetparams are inferred
+//          result = typer.adapt(result, mode, pt)
+          result
+        case Fallback(fallback) =>
+          typer.context.withImplicitsEnabled(typer.typed(fallback, EXPRmode, pt))
+        case Other(result) =>
+          result
+      }
+    } finally {
+      stopTimer(macroExpandNanos, start)
     }
+  }
 
   private sealed abstract class MacroExpansionResult extends Product with Serializable
   private case class Success(expanded: Tree) extends MacroExpansionResult
   private case class Fallback(fallback: Tree) extends MacroExpansionResult
+  private case class Delay(expandee: Tree) extends MacroExpansionResult
   private case class Other(result: Tree) extends MacroExpansionResult
-  private def Delay(expandee: Tree) = Other(expandee)
   private def Skip(expanded: Tree) = Other(expanded)
   private def Cancel(expandee: Tree) = Other(expandee)
   private def Failure(expandee: Tree) = Other(expandee)
   private def fail(typer: Typer, expandee: Tree, msg: String = null) = {
     if (macroDebug || macroCopypaste) {
       var msg1 = if (msg contains "exception during macro expansion") msg.split(EOL).drop(1).headOption.getOrElse("?") else msg
-      if (macroDebug) msg1 = msg
-      println("macro expansion has failed: %s".format(msg1))
+      if (macroDebug) println("macro expansion has failed: %s".format(msg1))
     }
     val pos = if (expandee.pos != NoPosition) expandee.pos else openMacros.find(c => c.expandee.pos != NoPosition).map(_.expandee.pos).getOrElse(NoPosition)
     if (msg != null) typer.context.error(pos, msg)
@@ -989,191 +1032,200 @@ trait Macros { self: Analyzer =>
   /** Does the same as ``macroExpand'', but without typechecking the expansion
    *  Meant for internal use within the macro infrastructure, don't use it elsewhere.
    */
-  private def macroExpand1(typer: Typer, expandee: Tree): MacroExpansionResult = {
-    // if a macro implementation is incompatible or any of the arguments are erroneous
-    // there is no sense to expand the macro itself => it will only make matters worse
-    if (expandee.symbol.isErroneous || (expandee exists (_.isErroneous))) {
-      val reason = if (expandee.symbol.isErroneous) "incompatible macro implementation" else "erroneous arguments"
-      macroTrace("cancelled macro expansion because of %s: ".format(reason))(expandee)
-      return Cancel(typer.infer.setError(expandee))
-    }
+  private def macroExpand1(typer: Typer, expandee: Tree): MacroExpansionResult =
+    // InfoLevel.Verbose examines and prints out infos of symbols
+    // by the means of this'es these symbols can climb up the lexical scope
+    // when these symbols will be examined by a node printer
+    // they will enumerate and analyze their children (ask for infos and tpes)
+    // if one of those children involves macro expansion, things might get nasty
+    // that's why I'm temporarily turning this behavior off
+    withInfoLevel(nodePrinters.InfoLevel.Quiet) {
+      // if a macro implementation is incompatible or any of the arguments are erroneous
+      // there is no sense to expand the macro itself => it will only make matters worse
+      if (expandee.symbol.isErroneous || (expandee exists (_.isErroneous))) {
+        val reason = if (expandee.symbol.isErroneous) "incompatible macro implementation" else "erroneous arguments"
+        macroTrace("cancelled macro expansion because of %s: ".format(reason))(expandee)
+        return Cancel(typer.infer.setError(expandee))
+      }
 
-    if (!isDelayed(expandee)) {
-      if (macroDebug || macroCopypaste) println("typechecking macro expansion %s at %s".format(expandee, expandee.pos))
+      macroRuntime(expandee.symbol) match {
+        case Some(runtime) =>
+          macroExpandWithRuntime(typer, expandee, runtime)
+        case None =>
+          macroExpandWithoutRuntime(typer, expandee)
+      }
+    }
 
+  /** Expands a macro when a runtime (i.e. the macro implementation) can be successfully loaded
+   *  Meant for internal use within the macro infrastructure, don't use it elsewhere.
+   */
+  private def macroExpandWithRuntime(typer: Typer, expandee: Tree, runtime: MacroRuntime): MacroExpansionResult =
+    try {
+      val wasDelayed = isDelayed(expandee)
       val undetparams = calculateUndetparams(expandee)
-      if (undetparams.size != 0) {
-        macroTrace("macro expansion is delayed: ")(expandee)
-        delayed += expandee -> (typer.context, undetparams)
-        Delay(expandee)
-      } else {
-        val start = startTimer(macroExpandNanos)
-        incCounter(macroExpandCount)
-        try {
-          val macroDef = expandee.symbol
-          macroRuntime(macroDef) match {
-            case Some(runtime) =>
-              val savedInfolevel = nodePrinters.infolevel
-              try {
-                // InfoLevel.Verbose examines and prints out infos of symbols
-                // by the means of this'es these symbols can climb up the lexical scope
-                // when these symbols will be examined by a node printer
-                // they will enumerate and analyze their children (ask for infos and tpes)
-                // if one of those children involves macro expansion, things might get nasty
-                // that's why I'm temporarily turning this behavior off
-                nodePrinters.infolevel = nodePrinters.InfoLevel.Quiet
-                val args = macroArgs(typer, expandee)
-                args match {
-                  case Some(args) =>
-                    // adding stuff to openMacros is easy, but removing it is a nightmare
-                    // it needs to be sprinkled over several different code locations
-                    val (context: MacroContext) :: _ = args
-                    openMacros = context :: openMacros
-                    val expanded: MacroExpansionResult = try {
-                      val prevNumErrors = reporter.ERROR.count
-                      val expanded = runtime(args)
+      val nowDelayed = !typer.context.macrosEnabled || undetparams.size != 0
+
+      if (!wasDelayed) {
+        if (macroDebug || macroCopypaste) println("typechecking macro expansion %s at %s".format(expandee, expandee.pos))
+        if (nowDelayed) {
+          if (macroDebug || macroCopypaste) println("macro expansion is delayed: %s".format(expandee))
+          delayed += expandee -> (typer.context, undetparams)
+          Delay(expandee)
+        } else {
+          val args = macroArgs(typer, expandee)
+          args match {
+            case Some(args) =>
+              // adding stuff to openMacros is easy, but removing it is a nightmare
+              // it needs to be sprinkled over several different code locations
+              val (context: MacroContext) :: _ = args
+              openMacros = context :: openMacros
+              val expanded: MacroExpansionResult = try {
+                val prevNumErrors = reporter.ERROR.count
+                expandee.detach(null)
+                val expanded = runtime(args)
+                val currNumErrors = reporter.ERROR.count
+                if (currNumErrors != prevNumErrors) {
+                  fail(typer, expandee) // errors have been reported by the macro itself
+                } else {
+                  expanded match {
+                    case expanded: Expr[_] =>
+                      if (macroDebug || macroCopypaste) {
+                        if (macroDebug) println("original:")
+                        println(expanded.tree)
+                        println(showRaw(expanded.tree))
+                      }
+
+                      freeTerms(expanded.tree) foreach (fte => typer.context.error(expandee.pos,
+                          ("macro expansion contains free term variable %s %s. "+
+                          "have you forgot to use eval when splicing this variable into a reifee? " +
+                          "if you have troubles tracking free term variables, consider using -Xlog-free-terms").format(fte.name, fte.origin)))
+                      freeTypes(expanded.tree) foreach (fty => typer.context.error(expandee.pos,
+                          ("macro expansion contains free type variable %s %s. "+
+                          "have you forgot to use c.TypeTag annotation for this type parameter? " +
+                          "if you have troubles tracking free type variables, consider using -Xlog-free-types").format(fty.name, fty.origin)))
+
                       val currNumErrors = reporter.ERROR.count
                       if (currNumErrors != prevNumErrors) {
-                        fail(typer, expandee) // errors have been reported by the macro itself
+                        fail(typer, expandee)
                       } else {
-                        expanded match {
-                          case expanded: Expr[_] =>
-                            if (macroDebug || macroCopypaste) {
-                              if (macroDebug) println("original:")
-                              println(expanded.tree)
-                              println(showRaw(expanded.tree))
-                            }
-
-                            freeTerms(expanded.tree) foreach (fte => typer.context.error(expandee.pos,
-                                ("macro expansion contains free term variable %s %s. "+
-                                "have you forgot to use eval when splicing this variable into a reifee? " +
-                                "if you have troubles tracking free term variables, consider using -Xlog-free-terms").format(fte.name, fte.origin)))
-                            freeTypes(expanded.tree) foreach (fty => typer.context.error(expandee.pos,
-                                ("macro expansion contains free type variable %s %s. "+
-                                "have you forgot to use c.TypeTag annotation for this type parameter? " +
-                                "if you have troubles tracking free type variables, consider using -Xlog-free-types").format(fty.name, fty.origin)))
-
-                            val currNumErrors = reporter.ERROR.count
-                            if (currNumErrors != prevNumErrors) {
-                              fail(typer, expandee)
-                            } else {
-                              // inherit the position from the first position-ful expandee in macro callstack
-                              // this is essential for sane error messages
-                              var tree = expanded.tree
-                              var position = openMacros.find(c => c.expandee.pos != NoPosition).map(_.expandee.pos).getOrElse(NoPosition)
-                              tree = atPos(position.focus)(tree)
-
-                              // now macro expansion gets typechecked against the macro definition return type
-                              // however, this happens in macroExpand, not here in macroExpand1
-                              Success(tree)
-                            }
-                          case expanded if expanded.isInstanceOf[Expr[_]] =>
-                            val msg = "macro must return a compiler-specific expr; returned value is Expr, but it doesn't belong to this compiler's universe"
-                            fail(typer, expandee, msg)
-                          case expanded =>
-                            val msg = "macro must return a compiler-specific expr; returned value is of class: %s".format(expanded.getClass)
-                            fail(typer, expandee, msg)
-                        }
+                        // inherit the position from the first position-ful expandee in macro callstack
+                        // this is essential for sane error messages
+                        var tree = expanded.tree
+                        var position = openMacros.find(c => c.expandee.pos != NoPosition).map(_.expandee.pos).getOrElse(NoPosition)
+                        tree = atPos(position.focus)(tree)
+
+                        // now macro expansion gets typechecked against the macro definition return type
+                        // however, this happens in macroExpand, not here in macroExpand1
+                        Success(tree)
                       }
-                    } catch {
-                      case ex: Throwable =>
-                        openMacros = openMacros.tail
-                        throw ex
-                    }
-                    if (!expanded.isInstanceOf[Success]) openMacros = openMacros.tail
-                    expanded
-                  case None =>
-                    fail(typer, expandee) // error has been reported by macroArgs
+                    case expanded if expanded.isInstanceOf[Expr[_]] =>
+                      val msg = "macro must return a compiler-specific expr; returned value is Expr, but it doesn't belong to this compiler's universe"
+                      fail(typer, expandee, msg)
+                    case expanded =>
+                      val msg = "macro must return a compiler-specific expr; returned value is of class: %s".format(expanded.getClass)
+                      fail(typer, expandee, msg)
+                  }
                 }
               } catch {
-                case ex =>
-                  // [Eugene] any ideas about how to improve this one?
-                  val realex = ReflectionUtils.unwrapThrowable(ex)
-                  realex match {
-                    case realex: reflect.makro.runtime.AbortMacroException =>
-                      if (macroDebug || macroCopypaste) println("macro expansion has failed: %s".format(realex.msg))
-                      fail(typer, expandee) // error has been reported by abort
-                    case _ =>
-                      val message = {
-                        try {
-                          // the most reliable way of obtaining currently executing method
-                          // http://stackoverflow.com/questions/442747/getting-the-name-of-the-current-executing-method
-                          val currentMethodName = new Object(){}.getClass().getEnclosingMethod().getName
-                          val relevancyThreshold = realex.getStackTrace().indexWhere(este => este.getMethodName == currentMethodName)
-                          if (relevancyThreshold == -1) None
-                          else {
-                            var relevantElements = realex.getStackTrace().take(relevancyThreshold + 1)
-                            var framesTillReflectiveInvocationOfMacroImpl = relevantElements.reverse.indexWhere(_.isNativeMethod) + 1
-                            relevantElements = relevantElements dropRight framesTillReflectiveInvocationOfMacroImpl
-
-                            realex.setStackTrace(relevantElements)
-                            val message = new java.io.StringWriter()
-                            realex.printStackTrace(new java.io.PrintWriter(message))
-                            Some(EOL + message)
-                          }
-                        } catch {
-                          // if the magic above goes boom, just fall back to uninformative, but better than nothing, getMessage
-                          case ex: Throwable =>
-                            None
-                        }
-                      } getOrElse realex.getMessage
-                      fail(typer, expandee, "exception during macro expansion: " + message)
-                  }
-              } finally {
-                nodePrinters.infolevel = savedInfolevel
+                case ex: Throwable =>
+                  openMacros = openMacros.tail
+                  throw ex
               }
+              if (!expanded.isInstanceOf[Success]) openMacros = openMacros.tail
+              expanded
             case None =>
-              def notFound() = {
-                typer.context.error(expandee.pos, "macro implementation not found: " + macroDef.name + " " +
-                  "(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)\n" +
-                  "if you do need to define macro implementations along with the rest of your program, consider two-phase compilation with -Xmacro-fallback-classpath " +
-                  "in the second phase pointing to the output of the first phase")
-                None
-              }
-              def fallBackToOverridden(tree: Tree): Option[Tree] = {
-                tree match {
-                  case Select(qual, name) if (macroDef.isTermMacro) =>
-                    macroDef.allOverriddenSymbols match {
-                      case first :: _ =>
-                        Some(Select(qual, name) setPos tree.pos setSymbol first)
-                      case _ =>
-                        macroTrace("macro is not overridden: ")(tree)
-                        notFound()
-                    }
-                  case Apply(fn, args) =>
-                    fallBackToOverridden(fn) match {
-                      case Some(fn1) => Some(Apply(fn1, args) setPos tree.pos)
-                      case _         => None
-                    }
-                  case TypeApply(fn, args) =>
-                    fallBackToOverridden(fn) match {
-                      case Some(fn1) => Some(TypeApply(fn1, args) setPos tree.pos)
-                      case _         => None
-                    }
-                  case _ =>
-                    macroTrace("unexpected tree in fallback: ")(tree)
-                    notFound()
-                }
-              }
-              fallBackToOverridden(expandee) match {
-                case Some(tree1) =>
-                  macroTrace("falling back to ")(tree1)
-                  currentRun.macroExpansionFailed = true
-                  Fallback(tree1)
-                case None =>
-                  fail(typer, expandee)
-              }
+              fail(typer, expandee) // error has been reported by macroArgs
           }
-        } finally {
-          stopTimer(macroExpandNanos, start)
         }
+      } else {
+        if (nowDelayed)
+          Delay(expandee)
+        else
+          Skip(macroExpandAll(typer, expandee))
       }
-    } else {
-      val undetparams = calculateUndetparams(expandee)
-      if (undetparams.size != 0)
-        Delay(expandee)
-      else
-        Skip(macroExpandAll(typer, expandee))
+    } catch {
+      case ex => handleMacroExpansionException(typer, expandee, ex)
+    } finally {
+      expandee.detach(classOf[MacroAttachment])
+    }
+
+  private def macroExpandWithoutRuntime(typer: Typer, expandee: Tree): MacroExpansionResult = {
+    val macroDef = expandee.symbol
+    def notFound() = {
+      typer.context.error(expandee.pos, "macro implementation not found: " + macroDef.name + " " +
+        "(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)\n" +
+        "if you do need to define macro implementations along with the rest of your program, consider two-phase compilation with -Xmacro-fallback-classpath " +
+        "in the second phase pointing to the output of the first phase")
+      None
+    }
+    def fallBackToOverridden(tree: Tree): Option[Tree] = {
+      tree match {
+        case Select(qual, name) if (macroDef.isTermMacro) =>
+          macroDef.allOverriddenSymbols match {
+            case first :: _ =>
+              Some(Select(qual, name) setPos tree.pos setSymbol first)
+            case _ =>
+              macroTrace("macro is not overridden: ")(tree)
+              notFound()
+          }
+        case Apply(fn, args) =>
+          fallBackToOverridden(fn) match {
+            case Some(fn1) => Some(Apply(fn1, args) setPos tree.pos)
+            case _         => None
+          }
+        case TypeApply(fn, args) =>
+          fallBackToOverridden(fn) match {
+            case Some(fn1) => Some(TypeApply(fn1, args) setPos tree.pos)
+            case _         => None
+          }
+        case _ =>
+          macroTrace("unexpected tree in fallback: ")(tree)
+          notFound()
+      }
+    }
+    fallBackToOverridden(expandee) match {
+      case Some(tree1) =>
+        macroTrace("falling back to: ")(tree1)
+        currentRun.macroExpansionFailed = true
+        Fallback(tree1)
+      case None =>
+        fail(typer, expandee)
+    }
+  }
+
+  private def handleMacroExpansionException(typer: Typer, expandee: Tree, ex: Throwable): MacroExpansionResult = {
+    // [Eugene] any ideas about how to improve this one?
+    val realex = ReflectionUtils.unwrapThrowable(ex)
+    realex match {
+      case realex: reflect.makro.runtime.AbortMacroException =>
+        if (macroDebug || macroCopypaste) println("macro expansion has failed: %s".format(realex.msg))
+        fail(typer, expandee) // error has been reported by abort
+      case err: TypeError =>
+        if (macroDebug || macroCopypaste) println("macro expansion has failed: %s at %s".format(err.msg, err.pos))
+        throw err // error should be propagated, don't report
+      case _ =>
+        val message = {
+          try {
+            // [Eugene] is there a better way?
+            val relevancyThreshold = realex.getStackTrace().indexWhere(este => este.getMethodName == "macroExpand1")
+            if (relevancyThreshold == -1) None
+            else {
+              var relevantElements = realex.getStackTrace().take(relevancyThreshold + 1)
+              var framesTillReflectiveInvocationOfMacroImpl = relevantElements.reverse.indexWhere(_.isNativeMethod) + 1
+              relevantElements = relevantElements dropRight framesTillReflectiveInvocationOfMacroImpl
+
+              realex.setStackTrace(relevantElements)
+              val message = new java.io.StringWriter()
+              realex.printStackTrace(new java.io.PrintWriter(message))
+              Some(EOL + message)
+            }
+          } catch {
+            // if the magic above goes boom, just fall back to uninformative, but better than nothing, getMessage
+            case ex: Throwable =>
+              None
+          }
+        } getOrElse realex.getMessage
+        fail(typer, expandee, "exception during macro expansion: " + message)
     }
   }
 
@@ -1194,18 +1246,23 @@ trait Macros { self: Analyzer =>
   private def isDelayed(expandee: Tree) = delayed contains expandee
   private def calculateUndetparams(expandee: Tree): collection.mutable.Set[Int] =
     delayed.get(expandee).map(_._2).getOrElse {
-      val calculated = collection.mutable.Set[Int]()
+      val calculated = collection.mutable.Set[Symbol]()
       expandee foreach (sub => {
-        def traverse(sym: Symbol) = if (sym != null && (undetparams contains sym.id)) calculated += sym.id
+        def traverse(sym: Symbol) = if (sym != null && (undetparams contains sym.id)) calculated += sym
         if (sub.symbol != null) traverse(sub.symbol)
         if (sub.tpe != null) sub.tpe foreach (sub => traverse(sub.typeSymbol))
       })
-      calculated
+      if (macroDebug) println("calculateUndetparams: %s".format(calculated))
+      calculated map (_.id)
     }
   private val undetparams = perRunCaches.newSet[Int]
-  def notifyUndetparamsAdded(newUndets: List[Symbol]): Unit = undetparams ++= newUndets map (_.id)
+  def notifyUndetparamsAdded(newUndets: List[Symbol]): Unit = {
+    undetparams ++= newUndets map (_.id)
+    if (macroDebug) newUndets foreach (sym => println("undetParam added: %s".format(sym)))
+  }
   def notifyUndetparamsInferred(undetNoMore: List[Symbol], inferreds: List[Type]): Unit = {
     undetparams --= undetNoMore map (_.id)
+    if (macroDebug) (undetNoMore zip inferreds) foreach {case (sym, tpe) => println("undetParam inferred: %s as %s".format(sym, tpe))}
     if (!delayed.isEmpty)
       delayed.toList foreach {
         case (expandee, (_, undetparams)) if !undetparams.isEmpty =>
@@ -1230,7 +1287,10 @@ trait Macros { self: Analyzer =>
         case wannabe if (delayed contains wannabe) && calculateUndetparams(wannabe).isEmpty =>
           val (context, _) = delayed(wannabe)
           delayed -= wannabe
-          macroExpand(newTyper(context), wannabe, WildcardType)
+          context.implicitsEnabled = typer.context.implicitsEnabled
+          context.enrichmentEnabled = typer.context.enrichmentEnabled
+          context.macrosEnabled = typer.context.macrosEnabled
+          macroExpand(newTyper(context), wannabe, EXPRmode, WildcardType)
         case _ =>
           tree
       })
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 8f5b3fb519..9a59d8f28a 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1082,10 +1082,10 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           }
           if (tree.isType)
             adaptType()
-          else if (context.macrosEnabled &&                            // when macros are enabled
-                   inExprModeButNot(mode, FUNmode) && !tree.isDef &&   // and typechecking application
-                   tree.symbol != null && tree.symbol.isTermMacro)     // of a term macro
-            macroExpand(this, tree, pt)
+          else if (
+              inExprModeButNot(mode, FUNmode) && !tree.isDef &&   // typechecking application
+              tree.symbol != null && tree.symbol.isTermMacro)     // of a macro
+            macroExpand(this, tree, mode, pt)
           else if ((mode & (PATTERNmode | FUNmode)) == (PATTERNmode | FUNmode))
             adaptConstrPattern()
           else if (inAllModes(mode, EXPRmode | FUNmode) &&