Split dealias 2.1 WIP

Author: odersky

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

@@ -78,7 +78,7 @@ object desugar {
           case tp: NamedType if tp.symbol.exists && (tp.symbol.owner eq originalOwner) =>
             val defctx = ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next()
             var local = defctx.denotNamed(tp.name ++ suffix).suchThat(_.isParamOrAccessor).symbol
-            if (local.exists) (defctx.owner.thisType select local).dealias
+            if (local.exists) (defctx.owner.thisType select local).dealiasKeepAnnots
             else {
               def msg =
                 s"no matching symbol for ${tp.symbol.showLocated} in ${defctx.owner} / ${defctx.effectiveScope.toList}"

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

@@ -691,7 +691,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    */
   def isStructuralTermSelect(tree: Tree)(implicit ctx: Context) = tree match {
     case tree: Select =>
-      def hasRefinement(qualtpe: Type): Boolean = qualtpe.dealias match {
+      def hasRefinement(qualtpe: Type): Boolean = qualtpe.dealiasStripAnnots match {
         case RefinedType(parent, rname, rinfo) =>
           rname == tree.name || hasRefinement(parent)
         case tp: TypeProxy =>

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

@@ -353,7 +353,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Ident(tp)
     else {
       val pre = tp.prefix
-      if (pre.isSingleton) followOuterLinks(singleton(pre.dealias)).select(tp)
+      if (pre.isSingleton) followOuterLinks(singleton(pre.dealiasStripAnnots)).select(tp)
       else Select(TypeTree(pre), tp)
     }
 
@@ -791,7 +791,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       applyOverloaded(tree, nme.EQ, that :: Nil, Nil, defn.BooleanType)
 
     /** `tree.isInstanceOf[tp]`, with special treatment of singleton types */
-    def isInstance(tp: Type)(implicit ctx: Context): Tree = tp.dealias match {
+    def isInstance(tp: Type)(implicit ctx: Context): Tree = tp.dealiasStripAnnots match {
       case tp: SingletonType =>
         if (tp.widen.derivesFrom(defn.ObjectClass))
           tree.ensureConforms(defn.ObjectType).select(defn.Object_eq).appliedTo(singleton(tp))

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

@@ -69,7 +69,7 @@ class CheckRealizable(implicit ctx: Context) {
   private def isLateInitialized(sym: Symbol) = sym.is(Lazy, butNot = Module)
 
   /** The realizability status of given type `tp`*/
-  def realizability(tp: Type): Realizability = tp.dealias match {
+  def realizability(tp: Type): Realizability = tp.dealiasStripAnnots match {
     case tp: TermRef =>
       val sym = tp.symbol
       if (sym.is(Stable)) realizability(tp.prefix)
@@ -85,7 +85,7 @@ class CheckRealizable(implicit ctx: Context) {
     case _: SingletonType | NoPrefix =>
       Realizable
     case tp =>
-      def isConcrete(tp: Type): Boolean = tp.dealias match {
+      def isConcrete(tp: Type): Boolean = tp.dealiasStripAnnots match {
         case tp: TypeRef => tp.symbol.isClass
         case tp: TypeProxy => isConcrete(tp.underlying)
         case tp: AndType => isConcrete(tp.tp1) && isConcrete(tp.tp2)
@@ -96,7 +96,7 @@ class CheckRealizable(implicit ctx: Context) {
       else boundsRealizability(tp).andAlso(memberRealizability(tp))
   }
 
-  private def refinedNames(tp: Type): Set[Name] = tp.dealias match {
+  private def refinedNames(tp: Type): Set[Name] = tp.dealiasStripAnnots match {
     case tp: RefinedType => refinedNames(tp.parent) + tp.refinedName
     case tp: AndType => refinedNames(tp.tp1) ++ refinedNames(tp.tp2)
     case tp: OrType  => refinedNames(tp.tp1) ++ refinedNames(tp.tp2)

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

@@ -152,7 +152,7 @@ object Constants {
     /** Convert constant value to conform to given type.
      */
     def convertTo(pt: Type)(implicit ctx: Context): Constant = {
-      def classBound(pt: Type): Type = pt.dealias.stripTypeVar match {
+      def classBound(pt: Type): Type = pt.dealiasStripAnnots.stripTypeVar match {
         case tref: TypeRef if !tref.symbol.isClass && tref.info.exists =>
           classBound(tref.info.bounds.lo)
         case param: TypeParamRef =>

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

@@ -50,7 +50,7 @@ trait ConstraintHandling {
   private def addOneBound(param: TypeParamRef, bound: Type, isUpper: Boolean): Boolean =
     !constraint.contains(param) || {
       def occursIn(bound: Type): Boolean = {
-        val b = bound.dealias
+        val b = bound.dealiasStripAnnots
         (b eq param) || {
           b match {
             case b: AndType => occursIn(b.tp1) || occursIn(b.tp2)
@@ -275,7 +275,7 @@ trait ConstraintHandling {
       case tp: OrType  => isFullyDefined(tp.tp1) && isFullyDefined(tp.tp2)
       case _ => true
     }
-    def isOrType(tp: Type): Boolean = tp.stripTypeVar.dealias match {
+    def isOrType(tp: Type): Boolean = tp.dealiasStripAnnots match {
       case tp: OrType => true
       case tp: RefinedOrRecType => isOrType(tp.parent)
       case AndType(tp1, tp2) => isOrType(tp1) | isOrType(tp2)

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

@@ -797,7 +797,7 @@ class Definitions {
     def unapply(ft: Type)(implicit ctx: Context) = {
       val tsym = ft.typeSymbol
       if (isFunctionClass(tsym)) {
-        val targs = ft.dealias.argInfos
+        val targs = ft.dealiasStripAnnots.argInfos
         if (targs.isEmpty) None
         else Some(targs.init, targs.last, tsym.name.isImplicitFunction, tsym.name.isErasedFunction)
       }
@@ -810,7 +810,7 @@ class Definitions {
       PartialFunctionType.appliedTo(arg :: result :: Nil)
     def unapply(pft: Type)(implicit ctx: Context) = {
       if (pft.isRef(PartialFunctionClass)) {
-        val targs = pft.dealias.argInfos
+        val targs = pft.dealiasStripAnnots.argInfos
         if (targs.length == 2) Some((targs.head, targs.tail)) else None
       }
       else None
@@ -821,7 +821,7 @@ class Definitions {
     def apply(elem: Type)(implicit ctx: Context) =
       if (ctx.erasedTypes) JavaArrayType(elem)
       else ArrayType.appliedTo(elem :: Nil)
-    def unapply(tp: Type)(implicit ctx: Context): Option[Type] = tp.dealias match {
+    def unapply(tp: Type)(implicit ctx: Context): Option[Type] = tp.dealiasStripAnnots match {
       case AppliedType(at, arg :: Nil) if at isRef ArrayType.symbol => Some(arg)
       case _ => None
     }
@@ -842,7 +842,7 @@ class Definitions {
       if (ndims == 0) elem else ArrayOf(apply(elem, ndims - 1))
     def unapply(tp: Type)(implicit ctx: Context): Option[(Type, Int)] = tp match {
       case ArrayOf(elemtp) =>
-        def recur(elemtp: Type): Option[(Type, Int)] = elemtp.dealias match {
+        def recur(elemtp: Type): Option[(Type, Int)] = elemtp.dealiasStripAnnots match {
           case TypeBounds(lo, hi) => recur(hi)
           case MultiArrayOf(finalElemTp, n) => Some(finalElemTp, n + 1)
           case _ => Some(elemtp, 1)
@@ -1022,7 +1022,7 @@ class Definitions {
      (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf)
 
   def isTupleType(tp: Type)(implicit ctx: Context) = {
-    val arity = tp.dealias.argInfos.length
+    val arity = tp.dealiasStripAnnots.argInfos.length
     arity <= MaxTupleArity && TupleType(arity) != null && (tp isRef TupleType(arity).symbol)
   }
 
@@ -1038,7 +1038,7 @@ class Definitions {
    */
   def isNonDepFunctionType(tp: Type)(implicit ctx: Context) = {
     val arity = functionArity(tp)
-    val sym = tp.dealias.typeSymbol
+    val sym = tp.dealiasStripAnnots.typeSymbol
     arity >= 0 && isFunctionClass(sym) && tp.isRef(FunctionType(arity, sym.name.isImplicitFunction, sym.name.isErasedFunction).typeSymbol)
   }
 
@@ -1084,7 +1084,7 @@ class Definitions {
         false
     })
 
-  def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
+  def functionArity(tp: Type)(implicit ctx: Context) = tp.dealiasStripAnnots.argInfos.length - 1
 
   /** Return underlying immplicit function type (i.e. instance of an ImplicitFunctionN class)
    *  or NoType if none exists. The following types are considered as underlying types:
@@ -1093,7 +1093,7 @@ class Definitions {
    *   - the upper bound of a TypeParamRef in the current constraint
    */
   def asImplicitFunctionType(tp: Type)(implicit ctx: Context): Type =
-    tp.stripTypeVar.dealias match {
+    tp.stripTypeVar.dealiasStripAnnots match {
       case tp1: TypeParamRef if ctx.typerState.constraint.contains(tp1) =>
         asImplicitFunctionType(ctx.typeComparer.bounds(tp1).hiBound)
       case tp1 =>
@@ -1106,7 +1106,7 @@ class Definitions {
     asImplicitFunctionType(tp).exists
 
   def isErasedFunctionType(tp: Type)(implicit ctx: Context) =
-    isFunctionType(tp) && tp.dealias.typeSymbol.name.isErasedFunction
+    isFunctionType(tp) && tp.dealiasStripAnnots.typeSymbol.name.isErasedFunction
 
   // ----- primitive value class machinery ------------------------------------------
 

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

@@ -387,7 +387,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
    *  that are not top-level are not affected.
    */
   def replace(param: TypeParamRef, tp: Type)(implicit ctx: Context): OrderingConstraint = {
-    val replacement = tp.dealias.stripTypeVar
+    val replacement = tp.dealiasKeepAnnots.stripTypeVar
     if (param == replacement) this
     else {
       assert(replacement.isValueTypeOrLambda)

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

@@ -125,7 +125,7 @@ trait Symbols { this: Context =>
       def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
         val cls = denot.asClass.classSymbol
         val decls = newScope
-        denot.info = ClassInfo(owner.thisType, cls, parentTypes.map(_.dealias), decls)
+        denot.info = ClassInfo(owner.thisType, cls, parentTypes.map(_.dealiasStripAnnots), decls)
       }
     }
     newClassSymbol(owner, name, flags, completer, privateWithin, coord, assocFile)

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

@@ -220,7 +220,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** If self type is higher-kinded, its result type, otherwise NoType.
    *  Note: The hkResult of an any-kinded type is again AnyKind.
    */
-  def hkResult(implicit ctx: Context): Type = self.dealias match {
+  def hkResult(implicit ctx: Context): Type = self.dealiasStripAnnots match {
     case self: TypeRef =>
       if (self.symbol == defn.AnyKindClass) self else self.info.hkResult
     case self: AppliedType =>