Drop BaseTypeArg flag

 ... and related code

Author: odersky

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

@@ -67,7 +67,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val Ycheck = PhasesSetting("-Ycheck", "Check the tree at the end of")
   val YcheckMods = BooleanSetting("-Ycheck-mods", "Check that symbols and their defining trees have modifiers in sync")
   val debug = BooleanSetting("-Ydebug", "Increase the quantity of debugging output.")
-  val debugAlias = BooleanSetting("-Ydebug-alias", "Never follow alias when printing types")
   val debugTrace = BooleanSetting("-Ydebug-trace", "Trace core operations")
   val debugFlags = BooleanSetting("-Ydebug-flags", "Print all flags of definitions")
   val debugNames = BooleanSetting("-Ydebug-names", "Show internal representation of names")

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

@@ -719,7 +719,6 @@ class Definitions {
       else ArrayType.appliedTo(elem :: Nil)
     def unapply(tp: Type)(implicit ctx: Context): Option[Type] = tp.dealias match {
       case AppliedType(at, arg :: Nil) if at isRef ArrayType.symbol => Some(arg)
-      case at: RefinedType if (at isRef ArrayType.symbol) && at.argInfos.length == 1 => Some(at.argInfos.head) // @!!!
       case _ => None
     }
   }

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

@@ -303,12 +303,6 @@ object Flags {
   /** A case parameter accessor */
   final val CaseAccessor = termFlag(25, "<caseaccessor>")
 
-  /** A binding for a type parameter of a base class or trait.
-   */
-  final val BaseTypeArg = typeFlag(25, "<basetypearg>")  // @!!!
-
-  final val CaseAccessorOrBaseTypeArg = CaseAccessor.toCommonFlags
-
   /** A super accessor */
   final val Scala2SuperAccessor = termFlag(26, "<superaccessor>")
 
@@ -451,7 +445,7 @@ object Flags {
   final val FromStartFlags =
     Module | Package | Deferred | MethodOrHKCommon | Param | ParamAccessor.toCommonFlags |
     Scala2ExistentialCommon | Mutable.toCommonFlags | Touched | JavaStatic |
-    CovariantOrOuter | ContravariantOrLabel | CaseAccessorOrBaseTypeArg |
+    CovariantOrOuter | ContravariantOrLabel | CaseAccessor.toCommonFlags |
     Fresh | Erroneous | ImplicitCommon | Permanent | Synthetic |
     SuperAccessorOrScala2x | Inline
 
@@ -573,9 +567,6 @@ object Flags {
   /** value that's final or inline */
   final val FinalOrInline = Final | Inline
 
-  /** If symbol of a type alias has these flags, prefer the alias */
-  final val AliasPreferred = TypeParam | BaseTypeArg
-
   /** A covariant type parameter instance */
   final val LocalCovariant = allOf(Local, Covariant)
 

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

@@ -243,21 +243,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       }
   }
 
-  private def enterArgBinding(formal: Symbol, info: Type, cls: ClassSymbol, decls: Scope) = {
-    val lazyInfo = new LazyType { // needed so we do not force `formal`.
-      def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
-        denot setFlag formal.flags & RetainedTypeArgFlags
-        denot.info = info
-      }
-    }
-    val sym = ctx.newSymbol(
-      cls, formal.name,
-      formal.flagsUNSAFE & RetainedTypeArgFlags | BaseTypeArg | Override,
-      lazyInfo,
-      coord = cls.coord)
-    cls.enter(sym, decls)
-  }
-
   /** An argument bounds violation is a triple consisting of
    *   - the argument tree
    *   - a string "upper" or "lower" indicating which bound is violated

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -144,8 +144,6 @@ class TreePickler(pickler: TastyPickler) {
       withLength { pickleType(tycon); args.foreach(pickleType(_)) }
     case ConstantType(value) =>
       pickleConstant(value)
-    case tpe: TypeRef if tpe.info.isAlias && tpe.symbol.isAliasPreferred =>
-      pickleType(tpe.superType)
     case tpe: WithFixedSym =>
       val sym = tpe.symbol
       def pickleRef() =

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -158,14 +158,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case EtaExpansion(tycon) =>
         return toText(tycon)
       case tp: TypeRef =>
-        val hideType = !ctx.settings.debugAlias.value && (tp.symbol.isAliasPreferred)
-        if (hideType && !ctx.phase.erasedTypes && !tp.symbol.isCompleting) {
-          tp.info match {
-            case TypeAlias(alias) => return toText(alias)
-            case _ => if (tp.prefix.isInstanceOf[ThisType]) return nameString(tp.symbol)
-          }
-        }
-        else if (tp.symbol.isAnonymousClass && !ctx.settings.uniqid.value)
+        if (tp.symbol.isAnonymousClass && !ctx.settings.uniqid.value)
           return toText(tp.info)
       case ExprType(result) =>
         return "=> " ~ toText(result)

compiler/src/dotty/tools/dotc/transform/SymUtils.scala

@@ -55,9 +55,6 @@ class SymUtils(val self: Symbol) extends AnyVal {
   def isAnyOverride(implicit ctx: Context) = self.is(Override) || self.is(AbsOverride)
     // careful: AbsOverride is a term only flag. combining with Override would catch only terms.
 
-  def isAliasPreferred(implicit ctx: Context) =
-    self.is(AliasPreferred) || self.name.is(ExpandedName)
-
   def isSuperAccessor(implicit ctx: Context) = self.name.is(SuperAccessorName)
 
   /** A type or term parameter or a term parameter accessor */

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -487,8 +487,6 @@ object TreeChecker {
           assert(definedBinders.get(tp.binder) != null, s"orphan param: ${tp.show}, hash of binder = ${System.identityHashCode(tp.binder)}, tree = ${tree.show}, type = $tp0")
         case tp: TypeVar =>
           apply(tp.underlying)
-        case tp: TypeRef if tp.info.isAlias && tp.symbol.isAliasPreferred =>
-          apply(tp.superType)
         case _ =>
           mapOver(tp)
       }

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -253,7 +253,6 @@ object RefChecks {
       def compatibleTypes(memberTp: Type, otherTp: Type): Boolean =
         try
           if (member.isType) // intersection of bounds to refined types must be nonempty
-            member.is(BaseTypeArg) || // @!!!
             memberTp.bounds.hi.hasSameKindAs(otherTp.bounds.hi) &&
             ((memberTp frozen_<:< otherTp) ||
              !member.owner.derivesFrom(other.owner) && {

compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala

@@ -62,7 +62,7 @@ class VarianceChecker()(implicit ctx: Context) {
     /** Check variance of abstract type `tvar` when referred from `base`. */
     private def checkVarianceOfSymbol(tvar: Symbol): Option[VarianceError] = {
       val relative = relativeVariance(tvar, base)
-      if (relative == Bivariant || tvar.is(BaseTypeArg)) None
+      if (relative == Bivariant) None
       else {
         val required = compose(relative, this.variance)
         def tvar_s = s"$tvar (${varianceString(tvar.flags)} ${tvar.showLocated})"

compiler/test/dotty/tools/dotc/ast/DesugarTests.scala

@@ -15,8 +15,6 @@ class DesugarTests extends DottyTest {
       assert(
         // remaining symbols must be either synthetic:
         sym.is(Synthetic) ||
-        // or be a type argument from product:
-        (sym.isType && sym.is(BaseTypeArg)) ||
         // or be a constructor:
         sym.name == nme.CONSTRUCTOR,
         s"found: $sym (${sym.flags})"