Make forwardTypeParams configurable

A new setting, -Ysuppress-param-forwarding is used
to make forwarding type parameters confihurable.

Forwarding type parameters from base class to subclass instance
is done in `normalizeToClassRefs` for optimization, but I just found
out this optimization is not always type-preserving and in fact can
lead to type errors.

SortedMap.scala in the collection strawman is an example. With parameter
forwarding enabled, we get:

    Error: immutable/SortedMap.scala --------------------------------------------
    |    with MapValuePolyTransforms[K, V, C] {
    |                                      ^
    |Type argument C does not conform to upper bound [=X, +Y] =>
    |  strawman.collection.immutable.Map[=X, +Y] &
    |    strawman.collection.immutable.MapValuePolyTransforms[=X', +Y', LazyRef(C)]
    |
    |where:    +Y  is a type variable
    |          +Y' is a type variable
    |          =X  is a type variable
    |          =X' is a type variable

If we turn off forwarding with the option, the strawman compiles OK.

Unfortunately turning the option off altogether does not work (yet).
It leads to increased compile times, and more tests fail with deep subtype
recursions. Dotty bootstrap seems to not terminate at all.

Related: Refine notion of self in RefChecks. This is
Needed to make pos/i1401.scala compile when forwardTypeParams is off.

# Conflicts:
#	compiler/src/dotty/tools/dotc/typer/RefChecks.scala

Author: odersky

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -96,6 +96,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YforceSbtPhases = BooleanSetting("-Yforce-sbt-phases", "Run the phases used by sbt for incremental compilation (ExtractDependencies and ExtractAPI) even if the compiler is ran outside of sbt, for debugging.")
   val YdumpSbtInc = BooleanSetting("-Ydump-sbt-inc", "For every compiled foo.scala, output the API representation and dependencies used for sbt incremental compilation in foo.inc, implies -Yforce-sbt-phases.")
   val YcheckAllPatmat = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm)")
+  val YsuppressParamForwarding = BooleanSetting("-Ysuppress-param-forwarding", "Don't install aliases for base type parameters.")
 
   /** Area-specific debug output */
   val Yexplainlowlevel = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")

compiler/src/dotty/tools/dotc/core/Mode.scala

@@ -39,6 +39,7 @@ object Mode {
   val TypevarsMissContext = newMode(4, "TypevarsMissContext")
   val CheckCyclic = newMode(5, "CheckCyclic")
 
+  /** We are looking at the arguments of a supercall */
   val InSuperCall = newMode(6, "InSuperCall")
 
   /** Allow GADTFlexType labelled types to have their bounds adjusted */
@@ -81,7 +82,7 @@ object Mode {
   val ReadPositions = newMode(16, "ReadPositions")
 
   val PatternOrType = Pattern | Type
-  
+
   /** We are elaborating the fully qualified name of a package clause.
    *  In this case, identifiers should never be imported.
    */

compiler/src/dotty/tools/dotc/core/TypeOps.scala

@@ -338,7 +338,8 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         if (name == from.name &&
             (lo2 eq hi2) &&
             info.variance == to.variance &&
-            !decls.lookup(argSym.name).exists) {
+            !decls.lookup(argSym.name).exists &&
+            !ctx.settings.YsuppressParamForwarding.value) {
               // println(s"short-circuit ${argSym.name} was: ${argSym.info}, now: $to")
               enterArgBinding(argSym, to, cls, decls)
             }

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -3030,6 +3030,8 @@ object Types {
     override def hashCode: Int = identityHash
     override def equals(that: Any) = this eq that.asInstanceOf[AnyRef]
 
+    def withName(name: Name): this.type = { myRepr = name; this }
+
     private var myRepr: Name = null
     def repr(implicit ctx: Context): Name = {
       if (myRepr == null) myRepr = SkolemName.fresh()

tests/pos/i1401.scala

@@ -1,7 +1,7 @@
 package i1401
 
-trait Subtractable[A, +Repr <: Subtractable[A, Repr]] {
-  def -(elem: A): Repr
+trait Subtractable[AS, +Repr <: Subtractable[AS, Repr]] {
+  def -(elem: AS): Repr
 }
 
 trait BufferLike[BA, +This <: BufferLike[BA, This] with Buffer[BA]]