Rolling back changes on Namers and Typers.

2 files changed, 98 insertions, 114 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 7fcb5bd9ae..2d48cef72c 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -80,23 +80,22 @@ trait Namers requires Analyzer {
 
     private var innerNamerCache: Namer = null
 
-    protected def newNamer(context : Context) : Namer = new Namer(context)
-
     def namerOf(sym: Symbol): Namer = {
+
       def innerNamer: Namer = {
         if (innerNamerCache eq null)
           innerNamerCache =
             if (!isTemplateContext(context)) this
-            else newNamer(context.make(context.tree, context.owner, newScope))
+            else new Namer(context.make(context.tree, context.owner, newScope))
         innerNamerCache
       }
 
       def primaryConstructorParamNamer: Namer = { //todo: can we merge this with SCCmode?
         val classContext = context.enclClass
         val outerContext = classContext.outer.outer
-        val paramContext = makeNewScope(outerContext, outerContext.tree, outerContext.owner)
-        classContext.owner.unsafeTypeParams foreach paramContext.scope.enter
-        newNamer(paramContext)
+        val paramContext = outerContext.makeNewScope(outerContext.tree, outerContext.owner)
+        classContext.owner.unsafeTypeParams foreach(sym => paramContext.scope.enter(sym))
+        new Namer(paramContext)
       }
 
       if (sym.isTerm &&
@@ -111,11 +110,10 @@ trait Namers requires Analyzer {
         sym.name.toString() + " is already defined as " +
         (if (sym.hasFlag(CASE)) "case class " + sym.name else sym.toString()))
 
-    def enterInScope[Sym <: Symbol](sym: Sym): Sym = {
+    def enterInScope(sym: Symbol): Symbol = {
       // allow for overloaded methods
       if (!(sym.isSourceMethod && sym.owner.isClass && !sym.owner.isPackageClass)) {
         val prev = context.scope.lookupEntry(sym.name);
-        if ((prev ne null) && (prev.sym eq sym)) return sym
         if ((prev ne null) && prev.owner == context.scope &&
             (!prev.sym.isSourceMethod ||
              nme.isSetterName(sym.name) ||
@@ -128,7 +126,6 @@ trait Namers requires Analyzer {
       sym
     }
 
-
     def enterPackageSymbol(pos: Position, name: Name): Symbol = {
       val cscope = if (context.owner == EmptyPackageClass) RootClass.info.decls
                    else context.scope
@@ -137,10 +134,10 @@ trait Namers requires Analyzer {
         p
       } else {
         val cowner = if (context.owner == EmptyPackageClass) RootClass else context.owner
-        val pkg = newPackage(cowner, pos, name)
+        val pkg = cowner.newPackage(pos, name)
         pkg.moduleClass.setInfo(new PackageClassInfoType(newScope, pkg.moduleClass))
-        //pkg.setInfo(pkg.moduleClass.tpe)
-        enterInScope(pkg) setInfo (pkg.moduleClass.tpe)
+        pkg.setInfo(pkg.moduleClass.tpe)
+        enterInScope(pkg)
       }
     }
 
@@ -148,14 +145,12 @@ trait Namers requires Analyzer {
       if (context.owner.isConstructor && !context.inConstructorSuffix || context.owner.isEarly) INCONSTRUCTOR
       else 0l
 
-
-    private def enterClassSymbol(tree : ClassDef, flags: long, name: Name): Symbol = {
+    private def enterClassSymbol(pos: Position, flags: long, name: Name): Symbol = {
       var c: Symbol = context.scope.lookup(name)
       if (c.isType && !currentRun.compiles(c) && context.scope == c.owner.info.decls) {
-        updatePosFlags(setPrivateWithin(tree, c, tree.mods), tree.pos, flags)
+        updatePosFlags(c, pos, flags)
       } else {
-        c = enterAndSet(tree)
-        {newClass(tree.pos, name, flags | inConstructorFlag)}
+        c = enterInScope(context.owner.newClass(pos, name)).setFlag(flags | inConstructorFlag)
       }
       if (c.owner.isPackageClass) {
         val file = context.unit.source.getFile()
@@ -172,17 +167,18 @@ trait Namers requires Analyzer {
       c
     }
 
-    private def enterModuleSymbol(tree: ModuleDef, flags: long, name: Name): Symbol = {
+    private def enterModuleSymbol(pos: Position, flags: long, name: Name): Symbol = {
       var m: Symbol = context.scope.lookup(name)
       if (m.isModule && !m.isPackage && !currentRun.compiles(m) &&
          (context.scope == m.owner.info.decls)) {
-        updatePosFlags(setPrivateWithin(tree, m, tree.mods), tree.pos, flags)
+        updatePosFlags(m, pos, flags)
       } else {
         if (m.isTerm && !m.isPackage && !currentRun.compiles(m) && (context.scope == m.owner.info.decls))
           context.scope.unlink(m)
-        m = enterAndSet(tree)
-        {newModule(tree.pos, name, flags)}
+        m = context.owner.newModule(pos, name)
+        m.setFlag(flags)
         m.moduleClass.setFlag(flags | inConstructorFlag)
+        enterInScope(m)
       }
       if (m.owner.isPackageClass) {
         m.moduleClass.sourceFile = context.unit.source.getFile()
@@ -190,31 +186,13 @@ trait Namers requires Analyzer {
       }
       m
     }
-    def newMethod(pos : Position, name : Name, flags : Long) : TermSymbol = context.owner.newMethod(pos, name).setFlag(flags)
-    def newValue(pos : Position, name : Name, flags : Long) : TermSymbol = context.owner.newValue(pos, name).setFlag(flags)
-    def newConstructor(pos : Position, flags : Long) : TermSymbol = context.owner.newConstructor(pos).setFlag(flags)
-    def newModule(pos : Position, name : Name, flags : Long) : TermSymbol = context.owner.newModule(pos, name).setFlag(flags)
-    def newClass(pos : Position, name : Name, flags : Long) : ClassSymbol = context.owner.newClass(pos, name).setFlag(flags)
-    def newPackage(owner : Symbol, pos : Position, name : Name) : TermSymbol = owner.newPackage(pos, name)
-    def newImport(pos : Position) : TermSymbol = NoSymbol.newImport(pos)
-
-    def newAbstractType(pos : Position, name : Name, flags : Long) : TypeSymbol = context.owner.newAbstractType(pos, name).setFlag(flags)
-    def newAliasType(pos : Position, name : Name, flags : Long) : TypeSymbol = context.owner.newAliasType(pos, name).setFlag(flags)
-    def newValueParameter(owner : Symbol, pos : Position, name : Name, flags : Long) : TermSymbol = owner.newValueParameter(pos, name).setFlag(flags)
-    def newThisSym(owner : Symbol, pos : Position) : TermSymbol = owner.newThisSym(pos)
-    def newTypeSkolem(sym : Symbol) = sym.newTypeSkolem
-    def newLabel(owner : Symbol, pos : Position, name : Name) = owner.newLabel(pos, name)
-
-    protected def setInfo(t : LazyType)(sym : Symbol) : Symbol =
-      sym setInfo t
-
-    private def enterCaseFactorySymbol(tree : ClassDef, flags: long, name: Name): Symbol = {
+
+    private def enterCaseFactorySymbol(pos: Position, flags: long, name: Name): Symbol = {
       var m: Symbol = context.scope.lookup(name)
       if (m.isTerm && !m.isPackage && !currentRun.compiles(m) && context.scope == m.owner.info.decls) {
-        updatePosFlags(setPrivateWithin(tree, m, tree.mods), tree.pos, flags)
+        updatePosFlags(m, pos, flags)
       } else {
-        m = enterAndSet(tree)
-        {newMethod(tree.pos, name, flags)}
+        m = enterInScope(context.owner.newMethod(pos, name)).setFlag(flags)
       }
       if (m.owner.isPackageClass)
         currentRun.symSource(m) = context.unit.source.getFile()
@@ -225,18 +203,18 @@ trait Namers requires Analyzer {
       var namer : Namer = this
       for (tree <- trees) {
         val txt = namer.enterSym(tree)
-        if (!(txt eq namer.context)) namer = newNamer(txt)
+        if (!(txt eq namer.context)) namer = new Namer(txt)
       }
       namer
     }
 
     def newTypeSkolems(tparams: List[Symbol]): List[Symbol] = {
-      val tskolems = tparams map (newTypeSkolem)
+      val tskolems = tparams map (.newTypeSkolem)
       val ltp = new LazyType {
         override def complete(sym: Symbol): unit =
           sym setInfo sym.deSkolemize.info.substSym(tparams, tskolems) //@M the info of a skolem is the skolemized info of the actual type parameter of the skolem
       }
-      tskolems foreach (setInfo(ltp))
+      tskolems foreach (.setInfo(ltp))
       tskolems
     }
 
@@ -260,15 +238,13 @@ trait Namers requires Analyzer {
       override val typeParams: List[Symbol]= tparams map (.symbol) //@M
       override def complete(sym: Symbol): unit = {
         if(ownerSym.isAbstractType) //@M an abstract type's type parameters are entered
-          newNamer(makeNewScope(ctx, owner, ownerSym)).enterSyms(tparams) //@M
+          new Namer(ctx.makeNewScope(owner, ownerSym)).enterSyms(tparams) //@M
         restp.complete(sym)
       }
     }
 
-    protected def enterAndSet(tree : MemberDef)(sym : Symbol) : Symbol =
-      enterInScope(setPrivateWithin(tree, sym, tree.mods))
-
     def enterSym(tree: Tree): Context = {
+
       def finishWith(tparams: List[AbsTypeDef]): unit = {
         val sym = tree.symbol
         if (settings.debug.value) log("entered " + sym + " in " + context.owner + ", scope-id = " + context.scope.hashCode());
@@ -278,83 +254,93 @@ trait Namers requires Analyzer {
           //@M e.g., in [A[x <: B], B], A and B are entered first as both are in scope in the definition of x
           //@M x is only in scope in `A[x <: B]'
           if(!sym.isAbstractType) //@M
-            new Namer(makeNewScope(context, tree, sym)).enterSyms(tparams)
+            new Namer(context.makeNewScope(tree, sym)).enterSyms(tparams)
           ltype = new LazyPolyType(tparams, ltype, tree, sym, context) //@M
           if (sym.isTerm) skolemize(tparams)
         }
-        setInfo(ltype)(sym)
+        sym.setInfo(ltype)
       }
       def finish = finishWith(List())
 
+
       if (tree.symbol == NoSymbol) {
-        //val owner = context.owner
+        val owner = context.owner
         tree match {
           case PackageDef(name, stats) =>
             tree.symbol = enterPackageSymbol(tree.pos, name)
-            val namer = newNamer{
-              context.make(tree, tree.symbol.moduleClass, tree.symbol.info.decls)
-            }
+            val namer = new Namer(
+                context.make(tree, tree.symbol.moduleClass, tree.symbol.info.decls))
             namer.enterSyms(stats)
-          case tree @ ClassDef(mods, name, tparams, impl) =>
+          case ClassDef(mods, name, tparams, impl) =>
             if ((mods.flags & CASE) != 0) { // enter case factory method.
               tree.symbol = enterCaseFactorySymbol(
-                  tree, mods.flags & AccessFlags | METHOD | CASE, name.toTermName)
-              setInfo(namerOf(tree.symbol).caseFactoryCompleter(tree))(tree.symbol)
+                  tree.pos, mods.flags & AccessFlags | METHOD | CASE, name.toTermName)
+              tree.symbol.setInfo(namerOf(tree.symbol).caseFactoryCompleter(tree))
+              setPrivateWithin(tree, tree.symbol, mods)
             }
-            tree.symbol = enterClassSymbol(tree, mods.flags, name)
+            tree.symbol = enterClassSymbol(tree.pos, mods.flags, name)
+            setPrivateWithin(tree, tree.symbol, mods)
             finishWith(tparams)
-          case tree @ ModuleDef(mods, name, _) =>
-            tree.symbol = enterModuleSymbol(tree, mods.flags | MODULE | FINAL, name)
-            // additional stuff with moduleClass, note that module class doesn't go into the symbol table, so we don't care about it
+          case ModuleDef(mods, name, _) =>
+            tree.symbol = enterModuleSymbol(tree.pos, mods.flags | MODULE | FINAL, name)
+            setPrivateWithin(tree, tree.symbol, mods)
             setPrivateWithin(tree, tree.symbol.moduleClass, mods)
-            setInfo(namerOf(tree.symbol).moduleClassTypeCompleter(tree))(tree.symbol.moduleClass)
+            tree.symbol.moduleClass.setInfo(namerOf(tree.symbol).moduleClassTypeCompleter(tree))
             finish
-          case tree @ ValDef(mods, name, tp, rhs) =>
+          case ValDef(mods, name, tp, rhs) =>
             if (context.owner.isClass && (mods.flags & (PRIVATE | LOCAL)) != (PRIVATE | LOCAL)) {
               val accflags = ACCESSOR |
                 (if ((mods.flags & MUTABLE) != 0) mods.flags & ~MUTABLE & ~PRESUPER
                  else mods.flags & ~PRESUPER | STABLE)
-              val getter = enterAndSet(tree)
-              {newMethod(tree.pos, name, accflags)}
-              setInfo(namerOf(getter).getterTypeCompleter(tree))(getter)
+              val getter = owner.newMethod(tree.pos, name).setFlag(accflags)
+              getter.setInfo(namerOf(getter).getterTypeCompleter(tree))
+              setPrivateWithin(tree, getter, mods)
+              enterInScope(getter)
               if ((mods.flags & MUTABLE) != 0) {
-                val setter = enterAndSet(tree)
-                {newMethod(tree.pos, nme.getterToSetter(name),
-                    accflags & ~STABLE & ~CASEACCESSOR)}
-                setInfo(namerOf(setter).setterTypeCompleter(tree))(setter)
+                val setter = owner.newMethod(tree.pos, nme.getterToSetter(name))
+                                .setFlag(accflags & ~STABLE & ~CASEACCESSOR)
+                setter.setInfo(namerOf(setter).setterTypeCompleter(tree))
+                setPrivateWithin(tree, setter, mods)
+                enterInScope(setter)
               }
               tree.symbol =
                 if ((mods.flags & DEFERRED) == 0) {
                   val value =
-                    enterInScope(newValue(tree.pos, nme.getterToLocal(name), mods.flags & FieldFlags | PRIVATE | LOCAL))
-                  setInfo(namerOf(value).typeCompleter(tree))(value)
+                    enterInScope(owner.newValue(tree.pos, nme.getterToLocal(name)))
+                                  .setFlag(mods.flags & FieldFlags | PRIVATE | LOCAL)
+                  value.setInfo(namerOf(value).typeCompleter(tree))
                   value
                 } else getter;
             } else {
-              tree.symbol = enterInScope(newValue(tree.pos, name, mods.flags))
+              tree.symbol = enterInScope(owner.newValue(tree.pos, name))
+                .setFlag(mods.flags)
               finish
             }
-          case tree @ DefDef(mods, nme.CONSTRUCTOR, tparams, _, _, _) =>
-            tree.symbol = enterAndSet(tree)
-            {newConstructor(tree.pos, mods.flags | context.owner.getFlag(ConstrFlags))}
+          case DefDef(mods, nme.CONSTRUCTOR, tparams, _, _, _) =>
+            tree.symbol = enterInScope(owner.newConstructor(tree.pos))
+              .setFlag(mods.flags | owner.getFlag(ConstrFlags))
+            setPrivateWithin(tree, tree.symbol, mods)
             finishWith(tparams)
-          case tree @ DefDef(mods, name, tparams, _, _, _) =>
-            tree.symbol = enterAndSet(tree)
-            {newMethod(tree.pos, name, mods.flags)}
+          case DefDef(mods, name, tparams, _, _, _) =>
+            tree.symbol = enterInScope(owner.newMethod(tree.pos, name))
+              .setFlag(mods.flags)
+            setPrivateWithin(tree, tree.symbol, mods)
             finishWith(tparams)
-          case tree @ AbsTypeDef(mods, name, tparams, _, _) =>
-            tree.symbol = enterAndSet(tree)
-            {newAbstractType(tree.pos, name, mods.flags)}
+          case AbsTypeDef(mods, name, tparams, _, _) =>
+            tree.symbol = enterInScope(owner.newAbstractType(tree.pos, name))
+              .setFlag(mods.flags)
+            setPrivateWithin(tree, tree.symbol, mods)
             finishWith(tparams)
-          case tree @ AliasTypeDef(mods, name, tparams, _) =>
-            tree.symbol = enterAndSet(tree)
-            {newAliasType(tree.pos, name, mods.flags)}
+          case AliasTypeDef(mods, name, tparams, _) =>
+            tree.symbol = enterInScope(owner.newAliasType(tree.pos, name))
+              .setFlag(mods.flags)
+            setPrivateWithin(tree, tree.symbol, mods)
             finishWith(tparams)
           case DocDef(_, defn) =>
             enterSym(defn)
           case imp @ Import(_, _) =>
-            tree.symbol = newImport(tree.pos)
-            setInfo(namerOf(tree.symbol).typeCompleter(tree))(tree.symbol)
+            tree.symbol = NoSymbol.newImport(tree.pos)
+            tree.symbol.setInfo(namerOf(tree.symbol).typeCompleter(tree))
             return (context.makeNewImport(imp))
           case _ =>
         }
@@ -402,7 +388,7 @@ trait Namers requires Analyzer {
       }
     }
 
-    def selfTypeCompleter(tree: Tree) : Type = new TypeCompleter(tree) {
+    def selfTypeCompleter(tree: Tree) = new TypeCompleter(tree) {
       override def complete(sym: Symbol): unit = {
         sym.setInfo(typer.typedType(tree).tpe)
       }
@@ -427,11 +413,11 @@ trait Namers requires Analyzer {
 
     def enterValueParams(owner: Symbol, vparamss: List[List[ValDef]]): List[List[Symbol]] = {
       def enterValueParam(param: ValDef): Symbol = if (doEnterValueParams) {
-        param.symbol = setInfo(typeCompleter(param))(
-            enterAndSet(param)
-            {newValueParameter(owner, param.pos, param.name,
-                param.mods.flags & (BYNAMEPARAM | IMPLICIT))})
-
+        param.symbol = owner.newValueParameter(param.pos, param.name)
+          .setInfo(typeCompleter(param))
+          .setFlag(param.mods.flags & (BYNAMEPARAM | IMPLICIT))
+        setPrivateWithin(param, param.symbol, param.mods)
+        enterInScope(param.symbol)
         param.symbol
       } else param.symbol
       vparamss.map(.map(enterValueParam))
@@ -558,6 +544,7 @@ trait Namers requires Analyzer {
             case PolyType(tparams, rt) => rt.substSym(tparams, tparamSyms)
             case mt => mt
           }
+
           for (vparams <- vparamss) {
             var pfs = resultPt.paramTypes
             for (vparam <- vparams) {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 7e210856e9..30f693155d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -59,7 +59,6 @@ trait Typers requires Analyzer {
   def newDecls(tree : Template, clazz : Symbol) = newScope
   def newTemplateScope(impl : Template, clazz : Symbol) = newScope
 
-
   // Mode constants
 
   /** The three mode <code>NOmode</code>, <code>EXPRmode</code>
@@ -134,7 +133,6 @@ trait Typers requires Analyzer {
 
   class Typer(context0: Context) {
     import context0.unit
-    def freshName(prefix : String, pos : Position, n : Int) = unit.fresh.newName(prefix)
 
     val infer = new Inferencer(context0) {
       override def isCoercible(tp: Type, pt: Type): boolean = (
@@ -178,10 +176,9 @@ trait Typers requires Analyzer {
      */
     private def inferView(pos: Position, from: Type, name: Name, tp: Type, reportAmbiguous: boolean): Tree = {
       val to = refinedType(List(WildcardType), NoSymbol)
-      // Sean: how to reuse from IDE? bad bad bad...
       val psym = (if (name.isTypeName) to.symbol.newAbstractType(pos, name)
                   else to.symbol.newValue(pos, name)) setInfo tp
-      to.decls enter psym
+      to.decls.enter(psym)
       inferView(pos, from, to, reportAmbiguous)
     }
 
@@ -190,10 +187,9 @@ trait Typers requires Analyzer {
     private var namerCache: Namer = null
     def namer = {
       if ((namerCache eq null) || namerCache.context != context)
-        namerCache = newNamer(context)
+        namerCache = new Namer(context)
       namerCache
     }
-    protected def newNamer(context : Context) = new Namer(context)
 
     private[typechecker] var context = context0
     def context1 = context
@@ -766,7 +762,7 @@ trait Typers requires Analyzer {
       else adaptToMember(qual, name, WildcardType)
 
     private def typePrimaryConstrBody(cbody: Tree, tparams: List[Symbol], enclTparams: List[Symbol], vparamss: List[List[ValDef]]): Tree = {
-      enclTparams foreach context.scope.enter
+      enclTparams foreach (sym => context.scope.enter(sym))
       namer.enterValueParams(context.owner, vparamss)
       typed(cbody)
     }
@@ -1022,7 +1018,7 @@ trait Typers requires Analyzer {
     }
     protected def enterSym(txt : Context, tree : Tree) : Context =
       if (txt eq context) namer.enterSym(tree)
-      else newNamer(txt).enterSym(tree)
+      else new Namer(txt).enterSym(tree)
 
     /**
      *  @param templ    ...
@@ -1203,7 +1199,7 @@ trait Typers requires Analyzer {
       case ldef @ LabelDef(_, _, _) =>
         if (ldef.symbol == NoSymbol)
           ldef.symbol = namer.enterInScope(
-            namer.newLabel(context.owner, ldef.pos, ldef.name) setInfo MethodType(List(), UnitClass.tpe))
+            context.owner.newLabel(ldef.pos, ldef.name) setInfo MethodType(List(), UnitClass.tpe))
       case _ =>
     }
 
@@ -1244,7 +1240,7 @@ trait Typers requires Analyzer {
     def typedBlock(block: Block, mode: int, pt: Type): Block = {
       if (context.retyping) {
         for (val stat <- block.stats) {
-          if (stat.isDef) context.scope enter (stat.symbol)
+          if (stat.isDef) context.scope.enter(stat.symbol)
         }
       }
       if (!inIDE)
@@ -1573,7 +1569,8 @@ trait Typers requires Analyzer {
           assert(unapp.exists, tree)
           val unappType = otpe.memberType(unapp)
           val argDummyType = pt // was unappArg
-          val argDummy =  namer.newValue(fun.pos, nme.SELECTOR_DUMMY, SYNTHETIC)
+          val argDummy =  context.owner.newValue(fun.pos, nme.SELECTOR_DUMMY)
+            .setFlag(SYNTHETIC)
             .setInfo(argDummyType)
           if (args.length > MaxTupleArity)
             error(fun.pos, "too many arguments for unapply pattern, maximum = "+MaxTupleArity)
@@ -1593,7 +1590,7 @@ trait Typers requires Analyzer {
             }
             val (unappFormal, freeVars) = freshArgType(unappType)
             val context1 = context.makeNewScope(context.tree, context.owner)
-            freeVars foreach context1.scope.enter
+            freeVars foreach(sym => context1.scope.enter(sym))
             val typer1 = new Typer(context1)
             arg.tpe = typer1.infer.inferTypedPattern(tree.pos, unappFormal, arg.tpe)
             //todo: replace arg with arg.asInstanceOf[inferTypedPattern(unappFormal, arg.tpe)] instead.
@@ -1746,16 +1743,16 @@ trait Typers requires Analyzer {
           if (vble == NoSymbol)
             vble =
               if (isFullyDefined(pt))
-                namer.newAliasType(tree.pos, name, 0) setInfo pt
+                context.owner.newAliasType(tree.pos, name) setInfo pt
               else
-                namer.newAbstractType(tree.pos, name, 0) setInfo
+                context.owner.newAbstractType(tree.pos, name) setInfo
                   mkTypeBounds(AllClass.tpe, AnyClass.tpe)
           if (vble.name == nme.WILDCARD.toTypeName) context.scope.enter(vble)
           else namer.enterInScope(vble)
           tree setSymbol vble setType vble.tpe
         } else {
           if (vble == NoSymbol)
-            vble = namer.newValue(tree.pos, name, 0)
+            vble = context.owner.newValue(tree.pos, name)
           if (vble.name.toTermName != nme.WILDCARD) {
 /*
           if (namesSomeIdent(vble.name))
@@ -2464,8 +2461,8 @@ trait Typers requires Analyzer {
 
         case tree @ Function(_, _) =>
           if (tree.symbol == NoSymbol)
-            tree.symbol = namer.newValue(tree.pos, nme.ANON_FUN_NAME, SYNTHETIC)
-              .setInfo(NoType)
+            tree.symbol = context.owner.newValue(tree.pos, nme.ANON_FUN_NAME)
+              .setFlag(SYNTHETIC).setInfo(NoType)
           newTyper(makeNewScope(context, tree, tree.symbol)).typedFunction(tree, mode, pt)
 
         case Assign(lhs, rhs) =>
@@ -2474,11 +2471,11 @@ trait Typers requires Analyzer {
         case If(cond, thenp, elsep) =>
           typedIf(cond, thenp, elsep)
 
-        case tree @ Match(selector, cases) =>
+        case Match(selector, cases) =>
           if (selector == EmptyTree) {
             val arity = if (isFunctionType(pt)) pt.normalize.typeArgs.length - 1 else 1
             val params = for (i <- List.range(0, arity)) yield
-              ValDef(Modifiers(PARAM | SYNTHETIC), freshName("x$", tree.pos, i), TypeTree(), EmptyTree)
+              ValDef(Modifiers(PARAM | SYNTHETIC), unit.fresh.newName("x$"), TypeTree(), EmptyTree)
             val ids = for (p <- params) yield Ident(p.name)
             val selector1 = atPos(tree.pos) { if (arity == 1) ids.head else gen.mkTuple(ids) }
             val body = copy.Match(tree, selector1, cases)