Eliminate Config switches

We are going to dismantle the old scheme code, so no need to keep
the switches.

Author: odersky

compiler/src/dotty/tools/dotc/Run.scala

@@ -118,7 +118,7 @@ class Run(comp: Compiler, ictx: Context) {
     ctx.usePhases(phases)
     var lastPrintedTree: PrintedTree = NoPrintedTree
     for (phase <- ctx.allPhases)
-      if (phase.isRunnable) // @!!! check? was: !ctx.reporter.hasErrors
+      if (phase.isRunnable)
         Stats.trackTime(s"$phase ms ") {
           val start = System.currentTimeMillis
           units = phase.runOn(units)

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -238,23 +238,6 @@ object desugar {
         Nil
     }
 
-  /** Fill in empty type bounds with Nothing/Any. Expand private local type parameters as follows:
-   *
-   *     class C[v T]
-   * ==>
-   *     class C { type v C$T; type v T = C$T }
-   */
-  def typeDef(tdef: TypeDef)(implicit ctx: Context): Tree = {
-    if (tdef.mods.is(PrivateLocalParam) && !dotty.tools.dotc.config.Config.newScheme) {
-      val tparam = cpy.TypeDef(tdef)(name = tdef.name.expandedName(ctx.owner))
-        .withMods(tdef.mods &~ PrivateLocal)
-      val alias = cpy.TypeDef(tdef)(rhs = refOfDef(tparam))
-        .withMods(tdef.mods & VarianceFlags | PrivateLocalParamAccessor | Synthetic)
-      Thicket(tparam, alias)
-    }
-    else tdef
-  }
-
   @sharable private val synthetic = Modifiers(Synthetic)
 
   private def toDefParam(tparam: TypeDef): TypeDef =
@@ -696,7 +679,7 @@ object desugar {
 
   def defTree(tree: Tree)(implicit ctx: Context): Tree = tree match {
     case tree: ValDef => valDef(tree)
-    case tree: TypeDef => if (tree.isClassDef) classDef(tree) else typeDef(tree)
+    case tree: TypeDef => if (tree.isClassDef) classDef(tree) else tree
     case tree: DefDef => defDef(tree)
     case tree: ModuleDef => moduleDef(tree)
     case tree: PatDef => patDef(tree)
@@ -1133,7 +1116,6 @@ object desugar {
   def refinedTypeToClass(parent: tpd.Tree, refinements: List[Tree])(implicit ctx: Context): TypeDef = {
     def stripToCore(tp: Type): List[Type] = tp match {
       case tp: AppliedType => tp :: Nil
-      case tp: RefinedType if !config.Config.newScheme && tp.argInfos.nonEmpty => tp :: Nil // parameterized class type
       case tp: TypeRef if tp.symbol.isClass => tp :: Nil     // monomorphic class type
       case tp: TypeProxy => stripToCore(tp.underlying)
       case AndType(tp1, tp2) => stripToCore(tp1) ::: stripToCore(tp2)

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -213,16 +213,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.TypeDef(sym.name, TypeTree(sym.info)), sym)
 
   def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree], superArgs: List[Tree] = Nil)(implicit ctx: Context): TypeDef = {
-    val (firstParent, otherParents) =
-      if (config.Config.newScheme) {
-        val firstParent :: otherParents = cls.info.parentsNEW
-        (firstParent, otherParents)
-      }
-      else {
-        val firstParentRef :: otherParentRefs = cls.info.parentRefs // @!!! adapt
-        val firstParent = cls.appliedRef.baseTypeWithArgs(firstParentRef.symbol)
-        (firstParent, otherParentRefs)
-      }
+    val firstParent :: otherParents = cls.info.parentsNEW
     val superRef =
       if (cls is Trait) TypeTree(firstParent)
       else {
@@ -269,9 +260,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def AnonClass(parents: List[Type], fns: List[TermSymbol], methNames: List[TermName])(implicit ctx: Context): Block = {
     val owner = fns.head.owner
     val parents1 =
-      if (parents.head.classSymbol.is(Trait))
-        if (config.Config.newScheme) parents.head.parentsNEW.head :: parents
-        else parents.head.parentRefs.head :: parents
+      if (parents.head.classSymbol.is(Trait)) parents.head.parentsNEW.head :: parents
       else parents
     val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_FUN, Synthetic, parents1,
         coord = fns.map(_.pos).reduceLeft(_ union _))

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

@@ -181,7 +181,4 @@ object Config {
 
   /** When in IDE, turn StaleSymbol errors into warnings instead of crashing */
   final val ignoreStaleInIDE = true
-
-  val newScheme = true
-  val newBoundsScheme = true
 }

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

@@ -334,9 +334,7 @@ object Contexts {
      *    from constructor parameters to class parameter accessors.
      */
     def superCallContext: Context = {
-      val locals = newScopeWith(
-        (if (Config.newScheme) owner.typeParams ++ owner.asClass.paramAccessors
-        else owner.asClass.paramAccessors): _*)
+      val locals = newScopeWith(owner.typeParams ++ owner.asClass.paramAccessors: _*)
       superOrThisCallContext(owner.primaryConstructor, locals)
     }
 

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

@@ -645,8 +645,7 @@ object Denotations {
 
     /** The TypeRef representing this type denotation at its original location. */
     def appliedRef(implicit ctx: Context): Type =
-      if (Config.newScheme) typeRef.appliedTo(symbol.typeParams.map(_.typeRef))
-      else typeRef
+      typeRef.appliedTo(symbol.typeParams.map(_.typeRef))
 
     def typeRef(implicit ctx: Context): TypeRef =
       TypeRef(symbol.owner.thisType, symbol.name.asTypeName, this)

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

@@ -497,7 +497,7 @@ object Flags {
 
   /** The flags of a class type parameter */
   final val ClassTypeParamCreationFlags =
-    TypeParam | Deferred | (if (config.Config.newScheme) Private else Protected) | Local
+    TypeParam | Deferred | Private | Local
 
   /** Flags that can apply to both a module val and a module class, except those that
     *  are added at creation anyway
@@ -593,7 +593,7 @@ object Flags {
   /** Is valid forever */
   final val ValidForever = Package | Permanent | Scala2ExistentialCommon
 
-  /** A type parameter of a class or trait (works only under Config.newScheme) */
+  /** A type parameter of a class or trait */
   final val ClassTypeParam = allOf(TypeParam, Private)
 
   /** Is a default parameter in Scala 2*/

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

@@ -402,54 +402,6 @@ class TypeApplications(val self: Type) extends AnyVal {
     }
     val stripped = self.stripTypeVar
     val dealiased = stripped.safeDealias
-
-    /** Normalize a TypeBounds argument. This involves (1) propagating bounds
-     *  from the type parameters into the argument, (2) possibly choosing the argument's
-     *  upper or lower bound according to variance.
-     *
-     *  Bounds propagation works as follows: If the dealiased type constructor is a TypeRef
-     *  `p.c`,
-     *    - take the type paramater bounds of `c` as seen from `p`,
-     *    - substitute concrete (non-bound) arguments for corresponding formal type parameters,
-     *    - interpolate, so that any (F-bounded) type parameters in the resulting bounds are avoided.
-     *  The resulting bounds are joined (via &) with corresponding type bound arguments.
-     */
-    def normalizeWildcardArg(typParams: List[TypeSymbol])(arg: Type, tparam: TypeSymbol): Type = arg match {
-      case TypeBounds(lo, hi) =>
-        if (Config.newBoundsScheme) arg
-        else {
-        def avoidParams(seen: Set[Symbol], v: Int): ApproximatingTypeMap = new ApproximatingTypeMap {
-          variance = if (v >= 0) 1 else -1
-          def apply(t: Type) = t match {
-            case t: TypeRef if typParams contains t.symbol =>
-              val lo = atVariance(-variance)(apply(t.info.loBound))
-              val hi =
-                if (seen.contains(t.symbol)) t.topType
-                else avoidParams(seen + t.symbol, variance)(t.info.hiBound)
-              range(lo, hi)
-            case _ => mapOver(t)
-          }
-        }
-        val v = tparam.paramVariance
-        val pbounds = dealiased match {
-          case dealiased @ TypeRef(prefix, _) =>
-            val (concreteArgs, concreteParams) = // @!!! optimize?
-              args.zip(typParams).filter(!_._1.isInstanceOf[TypeBounds]).unzip
-            if (tparam.isCompleting) TypeBounds.empty
-            else avoidParams(Set(tparam), v)(
-              tparam.paramInfo.asSeenFrom(prefix, tparam.owner)
-                .subst(concreteParams, concreteArgs))
-          case _ =>
-            TypeBounds.empty
-        }
-        typr.println(i"normalize arg $arg for $tparam in $self app $args%, %, pbounds, = $pbounds")
-        if (v > 0) hi & pbounds.hiBound
-        else if (v < 0) lo | pbounds.loBound
-        else arg recoverable_& pbounds
-        }
-      case _ => arg
-    }
-
     if (args.isEmpty || ctx.erasedTypes) self
     else dealiased match {
       case dealiased: HKTypeLambda =>
@@ -500,11 +452,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       case _ if typParams.isEmpty || typParams.head.isInstanceOf[LambdaParam] =>
         HKApply(self, args)
       case dealiased =>
-        if (Config.newScheme) {
-          val tparamSyms = typParams.asInstanceOf[List[TypeSymbol]]
-          AppliedType(self, args.zipWithConserve(tparamSyms)(normalizeWildcardArg(tparamSyms)))
-        } else
-          matchParams(dealiased, typParams, args)
+        AppliedType(self, args)
     }
   }
 
@@ -540,48 +488,16 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** The type arguments of this type's base type instance wrt. `base`.
    *  Wildcard types in arguments are returned as TypeBounds instances.
    */
-  final def baseArgInfos(base: Symbol)(implicit ctx: Context): List[Type] =
-    if (Config.newScheme)
-      self.baseType(base).argInfos
-    else if (self derivesFrom base)
-      self.dealias match {
-        case self: TypeRef if !self.symbol.isClass => self.superType.baseArgInfos(base)
-        case self: HKApply => self.superType.baseArgInfos(base)
-        case _ => base.typeParams.map(param => self.member(param.name).info.argInfo)
-      }
-    else
-      Nil
+  final def baseArgInfos(base: Symbol)(implicit ctx: Context): List[Type] = // @!!! drop
+    self.baseType(base).argInfos
 
   /** The base type including all type arguments and applicable refinements
    *  of this type. Refinements are applicable if they refine a member of
    *  the parent type which furthermore is not a name-mangled type parameter.
    *  Existential types in arguments are returned as TypeBounds instances.
    */
-  final def baseTypeWithArgs(base: Symbol)(implicit ctx: Context): Type =
-    if (Config.newScheme) self.baseType(base)
-    else ctx.traceIndented(s"btwa ${self.show} wrt $base", core, show = true) {
-    def default = self.baseTypeTycon(base).appliedTo(baseArgInfos(base))
-    def isExpandedTypeParam(sym: Symbol) = sym.is(TypeParam) && sym.name.is(ExpandedName)
-    self match {
-      case tp: TypeRef =>
-        tp.info match {
-          case TypeBounds(_, hi) => hi.baseTypeWithArgs(base)
-          case _ => default
-        }
-      case tp @ RefinedType(parent, name, _) if !Config.newScheme && !isExpandedTypeParam(tp.member(name).symbol) =>
-        tp.wrapIfMember(parent.baseTypeWithArgs(base))
-      case tp: TermRef =>
-        tp.underlying.baseTypeWithArgs(base)
-      case tp: HKApply =>
-        tp.superType.baseTypeWithArgs(base)
-      case AndType(tp1, tp2) =>
-        tp1.baseTypeWithArgs(base) & tp2.baseTypeWithArgs(base)
-      case OrType(tp1, tp2) =>
-        tp1.baseTypeWithArgs(base) | tp2.baseTypeWithArgs(base)
-      case _ =>
-        default
-    }
-  }
+  final def baseTypeWithArgs(base: Symbol)(implicit ctx: Context): Type = // @!!! drop
+    self.baseType(base)
 
   /** Translate a type of the form From[T] to To[T], keep other types as they are.
    *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
@@ -593,8 +509,7 @@ class TypeApplications(val self: Type) extends AnyVal {
     case _ =>
       if (self.derivesFrom(from))
         if (ctx.erasedTypes) to.typeRef // @!!! can be dropped; appliedTo does the right thing anyway
-        else if (Config.newScheme) to.typeRef.appliedTo(self.baseType(from).argInfos)
-        else RefinedType(to.typeRef, to.typeParams.head.name, self.member(from.typeParams.head.name).info)
+        else to.typeRef.appliedTo(self.baseType(from).argInfos)
       else self
   }
 

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

@@ -1026,20 +1026,11 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     val classBounds = tp2.classSymbols
     def recur(bcs: List[ClassSymbol]): Boolean = bcs match {
       case bc :: bcs1 =>
-        if (Config.newScheme)
-          (classBounds.exists(bc.derivesFrom) &&
-           variancesConform(bc.typeParams, tparams) &&
-           p(tp1.baseType(bc))
-          ||
-          recur(bcs1))
-        else {
-          val baseRef = tp1.baseTypeTycon(bc)
-          (classBounds.exists(bc.derivesFrom) &&
-          variancesConform(baseRef.typeParams, tparams) &&
-          p(baseRef.appliedTo(tp1.baseArgInfos(bc)))
-          ||
-          recur(bcs1))
-        }
+        (classBounds.exists(bc.derivesFrom) &&
+          variancesConform(bc.typeParams, tparams) &&
+          p(tp1.baseType(bc))
+        ||
+        recur(bcs1))
       case nil =>
         false
     }

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

@@ -268,56 +268,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
    *  all (possibly applied) references to classes.
    */
   def normalizeToClassRefs(parents: List[Type], cls: ClassSymbol, decls: Scope): List[Type] = {
-    if (Config.newScheme) return parents.mapConserve(_.dealias) // !@@@ track and eliminate usages?
-    // println(s"normalizing $parents of $cls in ${cls.owner}") // !!! DEBUG
-
-    // A map consolidating all refinements arising from parent type parameters
-    var refinements: SimpleMap[TypeName, Type] = SimpleMap.Empty
-
-    // A map of all formal type parameters of base classes that get refined
-    var formals: SimpleMap[TypeName, Symbol] = SimpleMap.Empty // A map of all formal parent parameter
-
-    // Strip all refinements from parent type, populating `refinements` and `formals` maps.
-    def normalizeToRef(tp: Type): TypeRef = {
-      def fail = throw new TypeError(s"unexpected parent type: $tp")
-      tp.dealias match {
-        case tp: TypeRef =>
-          tp
-        case tp @ RefinedType(tp1, name: TypeName, rinfo) =>
-          val prevInfo = refinements(name)
-          refinements = refinements.updated(name,
-            if (prevInfo == null) tp.refinedInfo else prevInfo & tp.refinedInfo)
-          formals = formals.updated(name, tp1.typeParamNamed(name))
-          normalizeToRef(tp1)
-        case tp @ RefinedType(tp1, _: TermName, _) =>
-            normalizeToRef(tp1)
-        case _: ErrorType =>
-          defn.AnyType
-        case AnnotatedType(tpe, _) =>
-          normalizeToRef(tpe)
-        case HKApply(tycon: TypeRef, args) =>
-          tycon.info match {
-            case TypeAlias(alias) => normalizeToRef(alias.appliedTo(args))
-            case _ => fail
-          }
-        case _ =>
-          fail
-      }
-    }
-
-    val parentRefs = parents map normalizeToRef
-
-    // Enter all refinements into current scope.
-    refinements foreachBinding { (name, refinedInfo) =>
-      assert(decls.lookup(name) == NoSymbol, // DEBUG
-        s"redefinition of ${decls.lookup(name).debugString} in ${cls.showLocated}")
-      enterArgBinding(formals(name), refinedInfo, cls, decls)
-    }
-
-    if (Config.forwardTypeParams)
-      forwardParamBindings(parentRefs, refinements, cls, decls)
-
-    parentRefs
+    parents.mapConserve(_.dealias) // !@@@ track and eliminate usages?
   }
 
   /** Forward parameter bindings in baseclasses to argument types of