A lot of minor code adjustments to ease the bur...

A lot of minor code adjustments to ease the burden on the optimizer, and
various cleanups encountered along the way.

1 files changed, 57 insertions, 56 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index e36e8ffb02..bd4bde2511 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -290,52 +290,55 @@ trait Namers { self: Analyzer =>
       if (m.isModule && inCurrentScope(m) && currentRun.compiles(m)) m
       else enterSyntheticSym(creator)
     }
-
-    def enterSym(tree: Tree): Context = try {
-
-      def finishWith(tparams: List[TypeDef]) {
-        val sym = tree.symbol
-        if (settings.debug.value) log("entered " + sym + " in " + context.owner + ", scope-id = " + context.scope.hashCode());
-        var ltype = namerOf(sym).typeCompleter(tree)
-        if (!tparams.isEmpty) {
-          //@M! TypeDef's type params are handled differently
-          //@M e.g., in [A[x <: B], B], A and B are entered first as both are in scope in the definition of x
-          //@M x is only in scope in `A[x <: B]'
-          if(!sym.isAbstractType) //@M TODO: change to isTypeMember ?
-            newNamer(context.makeNewScope(tree, sym)).enterSyms(tparams)
-
-          ltype = new PolyTypeCompleter(tparams, ltype, tree, sym, context) //@M
-          if (sym.isTerm) skolemize(tparams)
-        }
-        def copyIsSynthetic() = sym.owner.info.member(nme.copy).hasFlag(SYNTHETIC)
-        if (sym.name == nme.copy && sym.hasFlag(SYNTHETIC) ||
-            sym.name.startsWith(nme.copy + "$default$") && copyIsSynthetic()){
-          // the 'copy' method of case classes needs a special type completer to make bug0054.scala (and others)
-          // work. the copy method has to take exactly the same parameter types as the primary constructor.
-          setInfo(sym)(mkTypeCompleter(tree)(copySym => {
-            val constrType = copySym.owner.primaryConstructor.tpe
-            val subst = new SubstSymMap(copySym.owner.typeParams, tparams map (_.symbol))
-            for ((params, cparams) <- tree.asInstanceOf[DefDef].vparamss.zip(constrType.paramss);
-                 (param, cparam) <- params.zip(cparams)) {
-              // need to clone the type cparam.tpe??? problem is: we don't have the new owner yet (the new param symbol)
-              param.tpt.setType(subst(cparam.tpe))
-              () // @LUC TODO workaround for #1996
-            }
-            ltype.complete(sym)
-          }))
-        } else setInfo(sym)(ltype)
+    private def enterSymFinishWith(tree: Tree, tparams: List[TypeDef]) {
+      val sym = tree.symbol
+      if (settings.debug.value) log("entered " + sym + " in " + context.owner + ", scope-id = " + context.scope.hashCode());
+      var ltype = namerOf(sym).typeCompleter(tree)
+      if (!tparams.isEmpty) {
+        //@M! TypeDef's type params are handled differently
+        //@M e.g., in [A[x <: B], B], A and B are entered first as both are in scope in the definition of x
+        //@M x is only in scope in `A[x <: B]'
+        if(!sym.isAbstractType) //@M TODO: change to isTypeMember ?
+          newNamer(context.makeNewScope(tree, sym)).enterSyms(tparams)
+
+        ltype = new PolyTypeCompleter(tparams, ltype, tree, sym, context) //@M
+        if (sym.isTerm) skolemize(tparams)
       }
-      def finish = finishWith(List())
+      def copyIsSynthetic() = sym.owner.info.member(nme.copy).hasFlag(SYNTHETIC)
+      if (sym.name == nme.copy && sym.hasFlag(SYNTHETIC) ||
+          sym.name.startsWith(nme.copy + "$default$") && copyIsSynthetic()){
+        // the 'copy' method of case classes needs a special type completer to make bug0054.scala (and others)
+        // work. the copy method has to take exactly the same parameter types as the primary constructor.
+        setInfo(sym)(mkTypeCompleter(tree)(copySym => {
+          val constrType = copySym.owner.primaryConstructor.tpe
+          val subst = new SubstSymMap(copySym.owner.typeParams, tparams map (_.symbol))
+          for ((params, cparams) <- tree.asInstanceOf[DefDef].vparamss.zip(constrType.paramss);
+               (param, cparam) <- params.zip(cparams)) {
+            // need to clone the type cparam.tpe??? problem is: we don't have the new owner yet (the new param symbol)
+            param.tpt.setType(subst(cparam.tpe))
+            () // @LUC TODO workaround for #1996
+          }
+          ltype.complete(sym)
+        }))
+      } else setInfo(sym)(ltype)
+    }
 
-      if (tree.symbol == NoSymbol) {
+    def enterSym(tree: Tree): Context = {
+      def finishWith(tparams: List[TypeDef]) { enterSymFinishWith(tree, tparams) }
+      def finish = finishWith(Nil)
+      def sym = tree.symbol
+      if (sym != NoSymbol)
+        return this.context
+
+      try {
         val owner = context.owner
         tree match {
           case PackageDef(pid, stats) =>
             tree.symbol = enterPackageSymbol(tree.pos, pid,
               if (context.owner == EmptyPackageClass) RootClass else context.owner)
-            val namer = newNamer(
-                context.make(tree, tree.symbol.moduleClass, tree.symbol.info.decls))
-            namer.enterSyms(stats)
+            val namer = newNamer(context.make(tree, sym.moduleClass, sym.info.decls))
+            namer enterSyms stats
+
           case tree @ ClassDef(mods, name, tparams, impl) =>
             tree.symbol = enterClassSymbol(tree)
             finishWith(tparams)
@@ -343,21 +346,18 @@ trait Namers { self: Analyzer =>
               val m = ensureCompanionObject(tree, caseModuleDef(tree))
               caseClassOfModuleClass(m.moduleClass) = tree
             }
-            val constrs = impl.body filter {
-              case DefDef(_, name, _, _, _, _) => name == nme.CONSTRUCTOR
-              case _ => false
-            }
-            val hasDefault = constrs.exists(c => {
-              val DefDef(_, _, _, vparamss, _, _) = c
-              vparamss.exists(_.exists(_.mods hasFlag DEFAULTPARAM))
-            })
+            val hasDefault = impl.body flatMap {
+              case DefDef(_, nme.CONSTRUCTOR, _, vparamss, _, _)  => vparamss.flatten
+              case _                                              => Nil
+            } exists (_.mods hasFlag DEFAULTPARAM)
+
             if (hasDefault) {
               val m = ensureCompanionObject(tree, companionModuleDef(tree, List(gen.scalaScalaObjectConstr)))
               classAndNamerOfModule(m) = (tree, null)
             }
           case tree @ ModuleDef(mods, name, _) =>
             tree.symbol = enterModuleSymbol(tree)
-            tree.symbol.moduleClass.setInfo(namerOf(tree.symbol).moduleClassTypeCompleter((tree)))
+            sym.moduleClass setInfo namerOf(sym).moduleClassTypeCompleter(tree)
             finish
 
           case vd @ ValDef(mods, name, tp, rhs) =>
@@ -372,14 +372,14 @@ trait Namers { self: Analyzer =>
             } else {
               // add getter and possibly also setter
               val accflags: Long = ACCESSOR |
-                (if ((mods.flags & MUTABLE) != 0L) mods.flags & ~MUTABLE & ~PRESUPER
+                (if (mods.isVariable) mods.flags & ~MUTABLE & ~PRESUPER
                  else mods.flags & ~PRESUPER | STABLE)
               if (nme.isSetterName(name))
                 context.error(tree.pos, "Names of vals or vars may not end in `_='")
               // .isInstanceOf[..]: probably for (old) IDE hook. is this obsolete?
               val getter = enterAliasMethod(tree, name, accflags, mods)
               setInfo(getter)(namerOf(getter).getterTypeCompleter(vd))
-              if ((mods.flags & MUTABLE) != 0L) {
+              if (mods.isVariable) {
                 val setter = enterAliasMethod(tree, nme.getterToSetter(name),
                                             accflags & ~STABLE & ~CASEACCESSOR,
                                             mods)
@@ -427,17 +427,18 @@ trait Namers { self: Analyzer =>
             enterSym(defn)
           case imp @ Import(_, _) =>
             tree.symbol = NoSymbol.newImport(tree.pos)
-            setInfo(tree.symbol)(namerOf(tree.symbol).typeCompleter(tree))
+            setInfo(sym)(namerOf(sym).typeCompleter(tree))
             return (context.makeNewImport(imp))
           case _ =>
         }
       }
+      catch {
+        case ex: TypeError =>
+          //Console.println("caught " + ex + " in enterSym")//DEBUG
+          typer.reportTypeError(tree.pos, ex)
+          this.context
+      }
       this.context
-    } catch {
-      case ex: TypeError =>
-        //Console.println("caught " + ex + " in enterSym")//DEBUG
-        typer.reportTypeError(tree.pos, ex)
-        this.context
     }
 
     def enterSyntheticSym(tree: Tree): Symbol = {