Massaging compiler to integrate with IDE, no su...

Massaging compiler to integrate with IDE, no supercial changes. Just
don't want to get out of synch with Martin's changes. Also, changed
compiler to use RichInt.until instead of Iterator.range

1 files changed, 23 insertions, 20 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 411662c96e..7e210856e9 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -59,6 +59,7 @@ 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>
@@ -133,6 +134,7 @@ 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 = (
@@ -176,9 +178,10 @@ 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)
     }
 
@@ -187,9 +190,10 @@ trait Typers requires Analyzer {
     private var namerCache: Namer = null
     def namer = {
       if ((namerCache eq null) || namerCache.context != context)
-        namerCache = new Namer(context)
+        namerCache = newNamer(context)
       namerCache
     }
+    protected def newNamer(context : Context) = new Namer(context)
 
     private[typechecker] var context = context0
     def context1 = context
@@ -1018,7 +1022,7 @@ trait Typers requires Analyzer {
     }
     protected def enterSym(txt : Context, tree : Tree) : Context =
       if (txt eq context) namer.enterSym(tree)
-      else new Namer(txt).enterSym(tree)
+      else newNamer(txt).enterSym(tree)
 
     /**
      *  @param templ    ...
@@ -1199,7 +1203,7 @@ trait Typers requires Analyzer {
       case ldef @ LabelDef(_, _, _) =>
         if (ldef.symbol == NoSymbol)
           ldef.symbol = namer.enterInScope(
-            context.owner.newLabel(ldef.pos, ldef.name) setInfo MethodType(List(), UnitClass.tpe))
+            namer.newLabel(context.owner, ldef.pos, ldef.name) setInfo MethodType(List(), UnitClass.tpe))
       case _ =>
     }
 
@@ -1240,7 +1244,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)
@@ -1411,7 +1415,7 @@ trait Typers requires Analyzer {
                 (e.sym.isType || inBlock || (e.sym.tpe matches e1.sym.tpe)))
               if (!e.sym.isErroneous && !e1.sym.isErroneous)
                 error(e.sym.pos, e1.sym+" is defined twice"+
-	{if(!settings.debug.value) "" else " in "+unit.toString});
+        {if(!settings.debug.value) "" else " in "+unit.toString});
             e1 = scope.lookupNextEntry(e1);
           }
           e = e.next
@@ -1569,8 +1573,7 @@ trait Typers requires Analyzer {
           assert(unapp.exists, tree)
           val unappType = otpe.memberType(unapp)
           val argDummyType = pt // was unappArg
-          val argDummy =  context.owner.newValue(fun.pos, nme.SELECTOR_DUMMY)
-            .setFlag(SYNTHETIC)
+          val argDummy =  namer.newValue(fun.pos, nme.SELECTOR_DUMMY, SYNTHETIC)
             .setInfo(argDummyType)
           if (args.length > MaxTupleArity)
             error(fun.pos, "too many arguments for unapply pattern, maximum = "+MaxTupleArity)
@@ -1645,15 +1648,15 @@ trait Typers requires Analyzer {
           else {
             val annType = tpt.tpe
 
-	    val needsConstant =
-	      (!settings.Xplugtypes.value ||
-	       annType <:< ClassfileAnnotationClass.tpe)
+            val needsConstant =
+              (!settings.Xplugtypes.value ||
+               annType <:< ClassfileAnnotationClass.tpe)
 
             def annotArg(tree: Tree): AnnotationArgument = {
               val arg = new AnnotationArgument(liftcode.reify(tree))
               if(needsConstant && !arg.isConstant)
-		needConst(tree)
-	      arg
+                needConst(tree)
+              arg
             }
             val constrArgs = args map annotArg
 
@@ -1743,16 +1746,16 @@ trait Typers requires Analyzer {
           if (vble == NoSymbol)
             vble =
               if (isFullyDefined(pt))
-                context.owner.newAliasType(tree.pos, name) setInfo pt
+                namer.newAliasType(tree.pos, name, 0) setInfo pt
               else
-                context.owner.newAbstractType(tree.pos, name) setInfo
+                namer.newAbstractType(tree.pos, name, 0) 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 = context.owner.newValue(tree.pos, name)
+            vble = namer.newValue(tree.pos, name, 0)
           if (vble.name.toTermName != nme.WILDCARD) {
 /*
           if (namesSomeIdent(vble.name))
@@ -2461,8 +2464,8 @@ trait Typers requires Analyzer {
 
         case tree @ Function(_, _) =>
           if (tree.symbol == NoSymbol)
-            tree.symbol = context.owner.newValue(tree.pos, nme.ANON_FUN_NAME)
-              .setFlag(SYNTHETIC).setInfo(NoType)
+            tree.symbol = namer.newValue(tree.pos, nme.ANON_FUN_NAME, SYNTHETIC)
+              .setInfo(NoType)
           newTyper(makeNewScope(context, tree, tree.symbol)).typedFunction(tree, mode, pt)
 
         case Assign(lhs, rhs) =>
@@ -2471,11 +2474,11 @@ trait Typers requires Analyzer {
         case If(cond, thenp, elsep) =>
           typedIf(cond, thenp, elsep)
 
-        case Match(selector, cases) =>
+        case tree @ 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), unit.fresh.newName("x$"), TypeTree(), EmptyTree)
+              ValDef(Modifiers(PARAM | SYNTHETIC), freshName("x$", tree.pos, i), 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)