Cleaning up after brutal merge of 2.10.x into master.

That's the best I can do. The tests pass, if someone wants
a cleaner merge it is all theirs.

For reference, the merge leading up to this commit was achieved
as follows. The lines with -s ours are where the merge commit
being merged was completely made up of backports from master.

  git merge -s ours eff78b852e  c1dd8bbaa4  && \
  git merge         7026376dcc  ccd7abe897 && \
  git merge -s ours 62681e191a    && \
  git merge         74b3e9aefe 7d80e08469 d24f341f08 c4f49759fe \
    27d73a2352 ba72ee7c6f 42c4cc7a1e d672102fd8 644eb7078a && \
  git merge -s ours 08596af059 b573c287d2   && \
  git merge         d1b6d8b20f    && \
  git merge -s ours 110b54a575 36f78dd606 309ff57ba6  && \
  git merge         06295f9682 d3886086c3 adf51eef76 b403234a27 && \
  git merge -s ours 09d1433064    && \
  git merge         9ddcc1b90e   cabf626bbc && \
  git merge -s ours 283924bfa5

1 files changed, 86 insertions, 73 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
index f929b1c48e..672d9d232a 100644
--- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
@@ -83,7 +83,7 @@ abstract class ExtensionMethods extends Transform with TypingTransformers {
            |
            | ${candidates.map(c => c.name+":"+normalize(c.tpe, imeth.owner)).mkString("\n")}
            |
-           | Eligible Names: ${extensionNames(imeth).mkString(",")}"""")
+           | Eligible Names: ${extensionNames(imeth).mkString(",")}" """)
     matching.head
   }
 
@@ -98,7 +98,7 @@ abstract class ExtensionMethods extends Transform with TypingTransformers {
   object ExtensionMethodType {
     def unapply(tp: Type) = tp match {
       case MethodType(thiz :: rest, restpe) if thiz.name == nme.SELF =>
-        Some( if (rest.isEmpty) restpe else MethodType(rest, restpe) )
+        Some((thiz, if (rest.isEmpty) restpe else MethodType(rest, restpe) ))
       case _ =>
         None
     }
@@ -107,36 +107,22 @@ abstract class ExtensionMethods extends Transform with TypingTransformers {
   /** This method removes the `$this` argument from the parameter list a method.
    *
    *  A method may be a `PolyType`, in which case we tear out the `$this` and the class
-   *  type params from its nested `MethodType`.
-   *  It may be a `MethodType`, either with a curried parameter list in which the first argument
-   *  is a `$this` - we just return the rest of the list.
-   *  This means that the corresponding symbol was generated during `extmethods`.
-   *
-   *  It may also be a `MethodType` in which the `$this` does not appear in a curried parameter list.
-   *  The curried lists disappear during `uncurry`, and the methods may be duplicated afterwards,
-   *  for instance, during `specialize`.
-   *  In this case, the first argument is `$this` and we just get rid of it.
+   *  type params from its nested `MethodType`.  Or it may be a MethodType, as
+   *  described at the ExtensionMethodType extractor.
    */
   private def normalize(stpe: Type, clazz: Symbol): Type = stpe match {
     case PolyType(tparams, restpe) =>
-      // Split the type parameters of the extension method into two groups,
-      // corresponding the to class and method type parameters.
-      val numClassParams = clazz.typeParams.length
-      val methTParams = tparams dropRight numClassParams
-      val classTParams = tparams takeRight numClassParams
-
-      GenPolyType(methTParams,
-        normalize(restpe.substSym(classTParams, clazz.typeParams), clazz))
-    case MethodType(List(thiz), restpe) if thiz.name == nme.SELF =>
-      restpe.substituteTypes(thiz :: Nil, clazz.thisType :: Nil)
-    case MethodType(thiz :: params, restpe) =>
-      MethodType(params, restpe)
+      // method type parameters, class type parameters
+      val (mtparams, ctparams) = tparams splitAt (tparams.length - clazz.typeParams.length)
+      GenPolyType(mtparams,
+        normalize(restpe.substSym(ctparams, clazz.typeParams), clazz))
+    case ExtensionMethodType(thiz, etpe) =>
+      etpe.substituteTypes(thiz :: Nil, clazz.thisType :: Nil)
     case _ =>
       stpe
   }
 
   class Extender(unit: CompilationUnit) extends TypingTransformer(unit) {
-
     private val extensionDefs = mutable.Map[Symbol, mutable.ListBuffer[Tree]]()
 
     def checkNonCyclic(pos: Position, seen: Set[Symbol], clazz: Symbol): Unit =
@@ -164,28 +150,36 @@ abstract class ExtensionMethods extends Transform with TypingTransformers {
     *  some higher level facilities.
     */
     def extensionMethInfo(extensionMeth: Symbol, origInfo: Type, clazz: Symbol): Type = {
-      // No variance for method type parameters
-      var newTypeParams = cloneSymbolsAtOwner(clazz.typeParams, extensionMeth) map (_ resetFlag COVARIANT | CONTRAVARIANT)
-      val thisParamType = appliedType(clazz.typeConstructor, newTypeParams map (_.tpeHK))
+      val GenPolyType(tparamsFromMethod, methodResult) = origInfo cloneInfo extensionMeth
+      // Start with the class type parameters - clones will be method type parameters
+      // so must drop their variance.
+      val tparamsFromClass = cloneSymbolsAtOwner(clazz.typeParams, extensionMeth) map (_ resetFlag COVARIANT | CONTRAVARIANT)
+
+      val thisParamType = appliedType(clazz, tparamsFromClass map (_.tpeHK): _*)
       val thisParam     = extensionMeth.newValueParameter(nme.SELF, extensionMeth.pos) setInfo thisParamType
-      def transform(clonedType: Type): Type = clonedType match {
-        case MethodType(params, restpe) =>
-          // I assume it was a bug that this was dropping params... [Martin]: No, it wasn't; it's curried.
-          MethodType(List(thisParam), clonedType)
-        case NullaryMethodType(restpe) =>
-          MethodType(List(thisParam), restpe)
-      }
-      val GenPolyType(tparams, restpe) = origInfo cloneInfo extensionMeth
-      val selfParamSingletonType = singleType(currentOwner.companionModule.thisType, thisParam)
-      GenPolyType(
-        tparams ::: newTypeParams,
-        transform(restpe) substThisAndSym (clazz, selfParamSingletonType, clazz.typeParams, newTypeParams)
-      )
-    }
+      val resultType    = MethodType(List(thisParam), dropNullaryMethod(methodResult))
+      val selfParamType = singleType(currentOwner.companionModule.thisType, thisParam)
 
-    private def allParams(tpe: Type): List[Symbol] = tpe match {
-      case MethodType(params, res) => params ::: allParams(res)
-      case _ => List()
+      def fixres(tp: Type)    = tp substThisAndSym (clazz, selfParamType, clazz.typeParams, tparamsFromClass)
+      def fixtparam(tp: Type) = tp substSym (clazz.typeParams, tparamsFromClass)
+
+      // We can't substitute symbols on the entire polytype because we
+      // need to modify the bounds of the cloned type parameters, but we
+      // don't want to substitute for the cloned type parameters themselves.
+      val tparams = tparamsFromMethod ::: tparamsFromClass
+      GenPolyType(tparams map (_ modifyInfo fixtparam), fixres(resultType))
+
+      // For reference, calling fix on the GenPolyType plays out like this:
+      // error: scala.reflect.internal.Types$TypeError: type arguments [B#7344,A#6966]
+      // do not conform to method extension$baz#16148's type parameter bounds
+      //
+      // And the difference is visible here.  See how B is bounded from below by A#16149
+      // in both cases, but in the failing case, the other type parameter has turned into
+      // a different A. (What is that A? It is a clone of the original A created in
+      // SubstMap during the call to substSym, but I am not clear on all the particulars.)
+      //
+      //  bad: [B#16154 >: A#16149, A#16155 <: AnyRef#2189]($this#16156: Foo#6965[A#16155])(x#16157: B#16154)List#2457[B#16154]
+      // good: [B#16151 >: A#16149, A#16149 <: AnyRef#2189]($this#16150: Foo#6965[A#16149])(x#16153: B#16151)List#2457[B#16151]
     }
 
     override def transform(tree: Tree): Tree = {
@@ -202,37 +196,56 @@ abstract class ExtensionMethods extends Transform with TypingTransformers {
             super.transform(tree)
           } else tree
         case DefDef(_, _, tparams, vparamss, _, rhs) if tree.symbol.isMethodWithExtension =>
-          val companion = currentOwner.companionModule
-          val origMeth = tree.symbol
-          val extensionName = extensionNames(origMeth).head
-          val extensionMeth = companion.moduleClass.newMethod(extensionName, origMeth.pos, origMeth.flags & ~OVERRIDE & ~PROTECTED | FINAL)
-            .setAnnotations(origMeth.annotations)
-          companion.info.decls.enter(extensionMeth)
-          val newInfo = extensionMethInfo(extensionMeth, origMeth.info, currentOwner)
+          val origMeth      = tree.symbol
+          val origThis      = currentOwner
+          val origTpeParams = tparams.map(_.symbol) ::: origThis.typeParams   // method type params ++ class type params
+          val origParams    = vparamss.flatten map (_.symbol)
+          val companion     = origThis.companionModule
+
+          def makeExtensionMethodSymbol = {
+            val extensionName = extensionNames(origMeth).head.toTermName
+            val extensionMeth = (
+              companion.moduleClass.newMethod(extensionName, origMeth.pos, origMeth.flags & ~OVERRIDE & ~PROTECTED | FINAL)
+                setAnnotations origMeth.annotations
+            )
+            companion.info.decls.enter(extensionMeth)
+          }
+
+          val extensionMeth = makeExtensionMethodSymbol
+          val newInfo       = extensionMethInfo(extensionMeth, origMeth.info, origThis)
           extensionMeth setInfo newInfo
-          log("Value class %s spawns extension method.\n  Old: %s\n  New: %s".format(
-            currentOwner,
-            origMeth.defString,
-            extensionMeth.defString)) // extensionMeth.defStringSeenAs(origInfo
-
-          def thisParamRef = gen.mkAttributedStableRef(extensionMeth.info.params.head setPos extensionMeth.pos)
-          val GenPolyType(extensionTpeParams, extensionMono) = extensionMeth.info
-          val origTpeParams = (tparams map (_.symbol)) ::: currentOwner.typeParams
-          val extensionBody = rhs
+
+          log(s"Value class $origThis spawns extension method.\n  Old: ${origMeth.defString}\n  New: ${extensionMeth.defString}")
+
+          val GenPolyType(extensionTpeParams, MethodType(thiz :: Nil, extensionMono)) = newInfo
+          val extensionParams = allParameters(extensionMono)
+          val extensionThis   = gen.mkAttributedStableRef(thiz setPos extensionMeth.pos)
+
+          val extensionBody = (
+            rhs
               .substituteSymbols(origTpeParams, extensionTpeParams)
-              .substituteSymbols(vparamss.flatten map (_.symbol), allParams(extensionMono).tail)
-              .substituteThis(currentOwner, thisParamRef)
-              .changeOwner((origMeth, extensionMeth))
-          extensionDefs(companion) += atPos(tree.pos) { DefDef(extensionMeth, extensionBody) }
-          val extensionCallPrefix = Apply(
-              gen.mkTypeApply(gen.mkAttributedRef(companion), extensionMeth, origTpeParams map (_.tpeHK)),
-              List(This(currentOwner)))
-          val extensionCall = atOwner(origMeth) {
-            localTyper.typedPos(rhs.pos) {
-              gen.mkForwarder(extensionCallPrefix, mmap(vparamss)(_.symbol))
-            }
-          }
-          deriveDefDef(tree)(_ => extensionCall)
+              .substituteSymbols(origParams, extensionParams)
+              .substituteThis(origThis, extensionThis)
+              .changeOwner(origMeth -> extensionMeth)
+          )
+
+          // Record the extension method ( FIXME: because... ? )
+          extensionDefs(companion) += atPos(tree.pos)(DefDef(extensionMeth, extensionBody))
+
+          // These three lines are assembling Foo.bar$extension[T1, T2, ...]($this)
+          // which leaves the actual argument application for extensionCall.
+          val sel        = Select(gen.mkAttributedRef(companion), extensionMeth)
+          val targs      = origTpeParams map (_.tpeHK)
+          val callPrefix = gen.mkMethodCall(sel, targs, This(origThis) :: Nil)
+
+          // Apply all the argument lists.
+          deriveDefDef(tree)(_ =>
+            atOwner(origMeth)(
+              localTyper.typedPos(rhs.pos)(
+                gen.mkForwarder(callPrefix, mmap(vparamss)(_.symbol))
+              )
+            )
+          )
         case _ =>
           super.transform(tree)
       }