Fixed retyping of ThisTypes and less aggressive...

Fixed retyping of ThisTypes and less aggressive calls to makeNotPrivate

2 files changed, 23 insertions, 11 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index d5d7ca254e..51bc404f8c 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -893,16 +893,12 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
     satisfiable(env, silent)
   }
 
-  import java.io.PrintWriter
-
   /*************************** Term transformation ************************************/
 
   class Duplicator extends {
     val global: SpecializeTypes.this.global.type = SpecializeTypes.this.global
   } with typechecker.Duplicators
 
-  import global.typer.typed
-
   def specializeCalls(unit: CompilationUnit) = new TypingTransformer(unit) {
     /** Map a specializable method to it's rhs, when not deferred. */
     val body: mutable.Map[Symbol, Tree] = new mutable.HashMap
@@ -928,8 +924,6 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       }
     }
 
-    import posAssigner._
-
     override def transform(tree: Tree): Tree = {
       val symbol = tree.symbol
 
@@ -986,6 +980,8 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         case Select(qual, name) =>
           if (settings.debug.value)
             log("looking at Select: " + tree + " sym: " + symbol + ": " + symbol.info + "[tree.tpe: " + tree.tpe + "]")
+          if (name.toString == "zero")
+            println("zero")
           //if (settings.debug.value) log("\toverloads: " + overloads.mkString("", "\n", ""))
           if (!specializedTypeVars(symbol.info).isEmpty && name != nme.CONSTRUCTOR) {
             if (settings.debug.value)
@@ -1036,7 +1032,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
             case (tpe, idx) => TypeTree(tpe) setPos parents(idx).pos
           }
           treeCopy.Template(tree,
-            parents1    /*currentOwner.info.parents.map(tpe => TypeTree(tpe) setPos parents.head.pos)*/,
+            parents1    /*currentOwner.info.parents.map(tpe => TypeTree(tpe) setPos parents.head.pos)*/ ,
             self,
             atOwner(currentOwner)(transformTrees(body ::: specMembers)))
 
@@ -1201,10 +1197,12 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
        */
       override def transform(tree: Tree): Tree = tree match {
         case Select(qual, name) =>
-          if (tree.symbol.hasFlag(PRIVATE | PROTECTED)) {
-            log("changing private flag of " + tree.symbol + " privateWithin: " + tree.symbol.privateWithin)
+          val sym = tree.symbol
+          if (sym.hasFlag(PRIVATE | PROTECTED) && !nme.isLocalName(sym.name)
+              && (currentClass != sym.owner.enclClass)) {
+            log("changing private flag of " + sym)
 //            tree.symbol.resetFlag(PRIVATE).setFlag(PROTECTED)
-            tree.symbol.makeNotPrivate(tree.symbol.owner)
+            sym.makeNotPrivate(sym.owner)
 //            tree.symbol.resetFlag(PRIVATE | PROTECTED)
 //            tree.symbol.privateWithin = NoSymbol
           }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
index 1dbeb0afd9..de9318d6b6 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
@@ -94,6 +94,15 @@ abstract class Duplicators extends Analyzer {
           } else
             super.mapOver(tpe)
 
+        case ThisType(sym) =>
+          val sym1 = updateSym(sym)
+          if (sym1 ne sym) {
+            log("fixing " + sym + " -> " + sym1)
+            ThisType(sym1)
+          } else
+            super.mapOver(tpe)
+
+
         case _ =>
           super.mapOver(tpe)
       }
@@ -136,7 +145,7 @@ abstract class Duplicators extends Analyzer {
             ldef.symbol = newsym
             log("newsym: " + newsym + " info: " + newsym.info)
 
-          case DefDef(_, _, tparams, vparamss, _, rhs) =>
+          case DefDef(_, name, tparams, vparamss, _, rhs) =>
             // invalidate parameters
             invalidate(tparams ::: vparamss.flatten)
             tree.symbol = NoSymbol
@@ -244,6 +253,11 @@ abstract class Duplicators extends Analyzer {
           if (settings.debug.value) log("mapped " + tree + " to " + tree1)
           super.typed(atPos(tree.pos)(tree1), mode, pt)
 
+        case This(_) =>
+          tree.symbol = updateSym(tree.symbol)
+          tree.tpe = null
+          super.typed(tree, mode, pt)
+
         case Super(qual, mix) if (oldClassOwner ne null) && (tree.symbol == oldClassOwner) =>
           val tree1 = Super(qual, mix)
           log("changed " + tree + " to " + tree1)