[backport] SI-6301 / SI-6572 specialization regressions

Squashed commit of the following:

commit a3680be29ccd5314c5d027d473b37940eaecd530
Author: Paul Phillips <paulp@improving.org>
Date:   Fri Aug 31 10:20:16 2012 -0700

    Actual fix for SI-6301, specialized crasher.

    This means the workaround in the previous commit is no
    longer reached, but it should remain where it is as a much
    needed layer of robustness/useful error reporting.

    Conflicts:
    	src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
    	src/compiler/scala/tools/nsc/typechecker/Duplicators.scala

commit f4c45ae204ce3ff3c16b19cab266d0b6515b6e0f
Author: Paul Phillips <paulp@improving.org>
Date:   Fri Aug 31 10:49:24 2012 -0700

    Rewrite of GenICode adapt.

    Started for debuggability, stayed for clarify/performance.

    Conflicts:
    	src/compiler/scala/tools/nsc/backend/icode/GenICode.scala

commit 74842f72a0af485e5def796f777f7003f969d75b
Author: Paul Phillips <paulp@improving.org>
Date:   Fri Aug 31 08:45:34 2012 -0700

    Workaround for SI-6301, @specialize crasher.

    SpecializeTypes is generating symbols with overloaded types
    which then proceed to crash in CleanUp or GenICode.  Until I
    or someone works out why that is, take a look in case the
    overload is easily disambiguated by the argument list arity,
    in which case warn and proceed.

4 files changed, 114 insertions, 110 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
index fd2b11898c..44d7a1929b 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
@@ -1164,34 +1164,28 @@ abstract class GenICode extends SubComponent  {
       resCtx
     }
 
-    private def adapt(from: TypeKind, to: TypeKind, ctx: Context, pos: Position): Unit = {
-      if (!(from <:< to) && !(from == NullReference && to == NothingReference)) {
-        to match {
-          case UNIT =>
-            ctx.bb.emit(DROP(from), pos)
-            debuglog("Dropped an " + from);
-
-          case _ =>
-            debugassert(from != UNIT, "Can't convert from UNIT to " + to + " at: " + pos)
-            assert(!from.isReferenceType && !to.isReferenceType,
-              "type error: can't convert from " + from + " to " + to +" in unit " + unit.source + " at " + pos)
-
-            ctx.bb.emit(CALL_PRIMITIVE(Conversion(from, to)), pos)
-        }
-      } else if (from == NothingReference) {
-        ctx.bb.emit(THROW(ThrowableClass))
-        ctx.bb.enterIgnoreMode
-      } else if (from == NullReference) {
-        ctx.bb.emit(DROP(from))
-        ctx.bb.emit(CONSTANT(Constant(null)))
+    private def adapt(from: TypeKind, to: TypeKind, ctx: Context, pos: Position) {
+      // An awful lot of bugs explode here - let's leave ourselves more clues.
+      // A typical example is an overloaded type assigned after typer.
+      log(s"GenICode#adapt($from, $to, $ctx, $pos)")
+
+      val conforms = (from <:< to) || (from == NullReference && to == NothingReference)
+      def coerce(from: TypeKind, to: TypeKind) = ctx.bb.emit(CALL_PRIMITIVE(Conversion(from, to)), pos)
+      def checkAssertions() {
+        def msg = s"Can't convert from $from to $to in unit ${unit.source} at $pos"
+        debugassert(from != UNIT, msg)
+        assert(!from.isReferenceType && !to.isReferenceType, msg)
       }
-      else if (from == ThrowableReference && !(ThrowableClass.tpe <:< to.toType)) {
-        log("Inserted check-cast on throwable to " + to + " at " + pos)
-        ctx.bb.emit(CHECK_CAST(to))
+      if (conforms) from match {
+        case NothingReference                                          => ctx.bb.emit(THROW(ThrowableClass)) ; ctx.bb.enterIgnoreMode
+        case NullReference                                             => ctx.bb.emit(Seq(DROP(from), CONSTANT(Constant(null))))
+        case ThrowableReference if !(ThrowableClass.tpe <:< to.toType) => ctx.bb.emit(CHECK_CAST(to)) // downcast throwables
+        case BYTE | SHORT | CHAR | INT if to == LONG                   => coerce(INT, LONG)           // widen subrange types
+        case _                                                         => ()
       }
-      else (from, to) match  {
-        case (BYTE, LONG) | (SHORT, LONG) | (CHAR, LONG) | (INT, LONG) => ctx.bb.emit(CALL_PRIMITIVE(Conversion(INT, LONG)))
-        case _ => ()
+      else to match {
+        case UNIT => ctx.bb.emit(DROP(from), pos)           // value discarding
+        case _    => checkAssertions() ; coerce(from, to)   // other primitive coercions
       }
     }
 
@@ -1907,18 +1901,8 @@ abstract class GenICode extends SubComponent  {
 
       var handlerCount = 0
 
-      override def toString(): String = {
-        val buf = new StringBuilder()
-        buf.append("\tpackage: ").append(packg).append('\n')
-        buf.append("\tclazz: ").append(clazz).append('\n')
-        buf.append("\tmethod: ").append(method).append('\n')
-        buf.append("\tbb: ").append(bb).append('\n')
-        buf.append("\tlabels: ").append(labels).append('\n')
-        buf.append("\texception handlers: ").append(handlers).append('\n')
-        buf.append("\tcleanups: ").append(cleanups).append('\n')
-        buf.append("\tscope: ").append(scope).append('\n')
-        buf.toString()
-      }
+      override def toString =
+        s"package $packg { class $clazz { def $method { bb=$bb } } }"
 
       def loadException(ctx: Context, exh: ExceptionHandler, pos: Position) = {
         debuglog("Emitting LOAD_EXCEPTION for class: " + exh.loadExceptionClass)
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
index 44510ab0c2..7a0b034fd0 100644
--- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala
+++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -450,19 +450,31 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
            *   is a value type (int et al.) in which case it must cast to the boxed version
            *   because invoke only returns object and erasure made sure the result is
            *   expected to be an AnyRef. */
-          val t: Tree = ad.symbol.tpe match {
-            case MethodType(mparams, resType) =>
-              assert(params.length == mparams.length, mparams)
-
-              typedPos {
-                val sym = currentOwner.newValue(mkTerm("qual"), ad.pos) setInfo qual0.tpe
-                qual = REF(sym)
+          val t: Tree = {
+            val (mparams, resType) = ad.symbol.tpe match {
+              case MethodType(mparams, resType) =>
+                assert(params.length == mparams.length, ((params, mparams)))
+                (mparams, resType)
+              case tpe @ OverloadedType(pre, alts) =>
+                unit.warning(ad.pos, s"Overloaded type reached the backend! This is a bug in scalac.\n     Symbol: ${ad.symbol}\n  Overloads: $tpe\n  Arguments: " + ad.args.map(_.tpe))
+                alts filter (_.paramss.flatten.size == params.length) map (_.tpe) match {
+                  case mt @ MethodType(mparams, resType) :: Nil =>
+                    unit.warning(NoPosition, "Only one overload has the right arity, proceeding with overload " + mt)
+                    (mparams, resType)
+                  case _ =>
+                    unit.error(ad.pos, "Cannot resolve overload.")
+                    (Nil, NoType)
+                }
+            }
+            typedPos {
+              val sym = currentOwner.newValue(mkTerm("qual"), ad.pos) setInfo qual0.tpe
+              qual = REF(sym)
 
-                BLOCK(
-                  VAL(sym) === qual0,
-                  callAsReflective(mparams map (_.tpe), resType)
-                )
-              }
+              BLOCK(
+                VAL(sym) === qual0,
+                callAsReflective(mparams map (_.tpe), resType)
+              )
+            }
           }
 
           /* For testing purposes, the dynamic application's condition
diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index 64051b56ec..232148676c 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -178,6 +178,14 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
 
   case class Overload(sym: Symbol, env: TypeEnv) {
     override def toString = "specialized overload " + sym + " in " + env
+    def matchesSym(other: Symbol) = sym.tpe =:= other.tpe
+    def matchesEnv(env1: TypeEnv) = TypeEnv.includes(env, env1)
+  }
+  private def newOverload(method: Symbol, specializedMethod: Symbol, env: TypeEnv) = {
+    assert(!specializedMethod.isOverloaded, specializedMethod.defString)
+    val om = Overload(specializedMethod, env)
+    overloads(method) ::= om
+    om
   }
 
   /** Just to mark uncheckable */
@@ -289,10 +297,6 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
     }
   }
 
-  /** Return the specialized overload of sym in the given env, if any. */
-  def overload(sym: Symbol, env: TypeEnv) =
-    overloads(sym).find(ov => TypeEnv.includes(ov.env, env))
-
   /** Return the specialized name of 'sym' in the given environment. It
    *  guarantees the same result regardless of the map order by sorting
    *  type variables alphabetically.
@@ -628,7 +632,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         info(om)         = if (original.isDeferred) Forward(original) else Implementation(original)
         typeEnv(om)      = env ++ typeEnv(m) // add the environment for any method tparams
 
-        overloads(specMember) ::= Overload(om, typeEnv(om))
+        newOverload(specMember, om, typeEnv(om))
         enterMember(om)
       }
 
@@ -835,7 +839,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
 
           debuglog("%s expands to %s in %s".format(sym, specMember.name.decode, pp(env)))
           info(specMember) = NormalizedMember(sym)
-          overloads(sym) ::= Overload(specMember, env)
+          newOverload(sym, specMember, env)
           owner.info.decls.enter(specMember)
           specMember
         }
@@ -877,9 +881,8 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       if (wasSpec.nonEmpty)
         debuglog("specialized overload for %s in %s".format(specMember, pp(typeEnv(specMember))))
 
-      overloads(sym) ::= Overload(specMember, spec)
+      newOverload(sym, specMember, spec)
       info(specMember) = SpecialOverload(sym, typeEnv(specMember))
-
       specMember
     }
 
@@ -994,7 +997,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
               SpecialOverride(impl)
             }
           )
-          overloads(overriding) ::= Overload(om, env)
+          newOverload(overriding, om, env)
           ifDebug(afterSpecialize(assert(
             overridden.owner.info.decl(om.name) != NoSymbol,
             "Could not find " + om.name + " in " + overridden.owner.info.decls))
@@ -1476,54 +1479,41 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
           }
           transformTypeApply
 
-        case Select(qual, name) =>
-          def transformSelect = {
-            qual match {
-              case _: Super if illegalSpecializedInheritance(currentClass) =>
-                val pos = tree.pos
-                debuglog(pos.source.file.name+":"+pos.line+": not specializing call to super inside illegal specialized inheritance class.")
-                debuglog(pos.lineContent)
-                tree
-              case _ =>
+        case Select(Super(_, _), _) if illegalSpecializedInheritance(currentClass) =>
+          val pos = tree.pos
+          debuglog(pos.source.file.name+":"+pos.line+": not specializing call to super inside illegal specialized inheritance class.\n" + pos.lineContent)
+          tree
 
+        case Select(qual, name) if name != nme.CONSTRUCTOR && specializedTypeVars(symbol.info).nonEmpty =>
           debuglog("specializing Select %s [tree.tpe: %s]".format(symbol.defString, tree.tpe))
-
-          //log("!!! select " + tree + " -> " + symbol.info + " specTypeVars: " + specializedTypeVars(symbol.info))
-          if (specializedTypeVars(symbol.info).nonEmpty && name != nme.CONSTRUCTOR) {
-            // log("!!! unifying " + (symbol, symbol.tpe) + " and " + (tree, tree.tpe))
-            val env = unify(symbol.tpe, tree.tpe, emptyEnv, false)
-            // log("!!! found env: " + env + "; overloads: " + overloads(symbol))
-            if (!env.isEmpty) {
-              // debuglog("checking for rerouting: " + tree + " with sym.tpe: " + symbol.tpe + " tree.tpe: " + tree.tpe + " env: " + env)
-              val specMember = overload(symbol, env)
-              if (specMember.isDefined) {
-                localTyper.typedOperator(atPos(tree.pos)(Select(transform(qual), specMember.get.sym.name)))
-              }
-              else {
-                val qual1 = transform(qual)
+          val env = unify(symbol.tpe, tree.tpe, emptyEnv, false)
+          if (env.isEmpty) super.transform(tree)
+          else {
+            val qual1 = transform(qual)
+            def reselect(member: Symbol) = {
+              val newSelect = atPos(tree.pos)(Select(qual1, member))
+              if (member.isMethod) localTyper typedOperator newSelect
+              else localTyper typed newSelect
+            }
+            overloads(symbol) find (_ matchesEnv env) match {
+              case Some(Overload(member, _)) => reselect(member)
+              case _                         =>
                 val specMember = qual1.tpe.member(specializedName(symbol, env)).suchThat(_.tpe matches subst(env, symbol.tpe))
-                if (specMember ne NoSymbol) {
-                  val tree1 = atPos(tree.pos)(Select(qual1, specMember))
-                  if (specMember.isMethod)
-                    localTyper.typedOperator(tree1)
-                  else
-                    localTyper.typed(tree1)
-                } else
+                if (specMember ne NoSymbol)
+                  reselect(specMember)
+                else
                   treeCopy.Select(tree, qual1, name)
-              }
-            } else
-              super.transform(tree)
-          } else overloads(symbol).find(_.sym.info =:= symbol.info) match {
-              case Some(specMember) =>
-                val qual1 = transform(qual)
-                debuglog("** routing " + tree + " to " + specMember.sym.fullName + " tree: " + Select(qual1, specMember.sym))
-                localTyper.typedOperator(atPos(tree.pos)(Select(qual1, specMember.sym)))
-              case None =>
-                super.transform(tree)
-          }
+            }
           }
+        case Select(qual, _) =>
+          overloads(symbol) find (_ matchesSym symbol) match {
+            case Some(Overload(member, _)) =>
+              val newTree = Select(transform(qual), member)
+              debuglog(s"** routing $tree to ${member.fullName} tree: $newTree")
+              localTyper.typedOperator(atPos(tree.pos)(newTree))
+            case None =>
+              super.transform(tree)
           }
-          transformSelect
 
         case PackageDef(pid, stats) =>
           tree.symbol.info // make sure specializations have been performed
diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
index df753ba53c..0b46582cbf 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
@@ -317,15 +317,33 @@ abstract class Duplicators extends Analyzer {
           super.typed(tree, mode, pt)
 
         case Select(th @ This(_), sel) if (oldClassOwner ne null) && (th.symbol == oldClassOwner) =>
-          // log("selection on this, no type ascription required")
-          // we use the symbol name instead of the tree name because the symbol may have been
-          // name mangled, rendering the tree name obsolete
-          // log(tree)
-          val t = super.typedPos(tree.pos, mode, pt) {
-            Select(This(newClassOwner), tree.symbol.name)
-          }
-          // log("typed to: " + t + "; tpe = " + t.tpe + "; " + inspectTpe(t.tpe))
-          t
+          // We use the symbol name instead of the tree name because the symbol
+          // may have been name mangled, rendering the tree name obsolete.
+          // ...but you can't just do a Select on a name because if the symbol is
+          // overloaded, you will crash in the backend.
+          val memberByName  = newClassOwner.thisType.member(tree.symbol.name)
+          def nameSelection = Select(This(newClassOwner), tree.symbol.name)
+          val newTree = (
+            if (memberByName.isOverloaded) {
+              // Find the types of the overload alternatives as seen in the new class,
+              // and filter the list down to those which match the old type (after
+              // fixing the old type so it is seen as if from the new class.)
+              val typeInNewClass = fixType(oldClassOwner.info memberType tree.symbol)
+              val alts           = memberByName.alternatives
+              val memberTypes    = alts map (newClassOwner.info memberType _)
+              val memberString   = memberByName.defString
+              alts zip memberTypes filter (_._2 =:= typeInNewClass) match {
+                case ((alt, tpe)) :: Nil =>
+                  log(s"Arrested overloaded type in Duplicators, narrowing to ${alt.defStringSeenAs(tpe)}\n  Overload was: $memberString")
+                  Select(This(newClassOwner), alt)
+                case _ =>
+                  log(s"Could not disambiguate $memberString in Duplicators. Attempting name-based selection, but this may not end well...")
+                  nameSelection
+              }
+            }
+            else nameSelection
+          )
+          super.typed(atPos(tree.pos)(newTree), mode, pt)
 
         case This(_) if (oldClassOwner ne null) && (tree.symbol == oldClassOwner) =>
 //          val tree1 = Typed(This(newClassOwner), TypeTree(fixType(tree.tpe.widen)))