less eager dealiasing of type aliases

Author: pweisenburger

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

@@ -174,9 +174,10 @@ object Config {
 
   /** If this flag is on, always rewrite an application `S[Ts]` where `S` is an alias for
    *  `[Xs] -> U` to `[Xs := Ts]U`.
-   *  Turning this flag on was observed to give a ~6% speedup on the JUnit test suite.
+   *  Turning this flag on was observed to give a ~6% speedup on the JUnit test suite
+   *  but over-eagerly dealiases type aliases.
    */
-  inline val simplifyApplications = true
+  inline val simplifyApplications = false
 
   /** Assume -indent by default */
   inline val defaultIndent = true

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

@@ -443,7 +443,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
    *  of the parameter elsewhere in the constraint by type `tp`.
    */
   def replace(param: TypeParamRef, tp: Type)(using Context): OrderingConstraint =
-    val replacement = tp.dealiasKeepAnnots.stripTypeVar
+    val replacement = tp.stripTypeVar
     if param == replacement then this.checkNonCyclic()
     else
       assert(replacement.isValueTypeOrLambda)

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

@@ -329,7 +329,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       case dealiased: HKTypeLambda =>
         def tryReduce =
           if (!args.exists(isBounds)) {
-            val followAlias = Config.simplifyApplications && {
+            val followAlias = (Config.simplifyApplications || self.typeSymbol.isPrivate) && {
               dealiased.resType match {
                 case AppliedType(tyconBody, dealiasedArgs) =>
                   // Reduction should not affect type inference when it's

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

@@ -407,7 +407,25 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case tp1: NamedType =>
         tp1.info match {
           case info1: TypeAlias =>
-            if (recur(info1.alias, tp2)) return true
+            def realiasConstraint() = tp2 match {
+              case tp2: TypeParamRef =>
+                constraint.entry(tp2) match {
+                  case TypeBounds(lo, hi) =>
+                    val aliasLo = tp1 != lo && info1.alias == lo
+                    val aliasHi = tp1 != hi && info1.alias == hi
+                    if aliasLo || aliasHi then
+                      constraint = constraint.updateEntry(tp2, TypeBounds(
+                        if aliasLo then tp1 else lo,
+                        if aliasHi then tp1 else hi))
+                  case tp =>
+                    if tp1 != tp && info1.alias == tp then
+                      constraint = constraint.updateEntry(tp2, tp1)
+                }
+              case _ =>
+            }
+            val res = recur(info1.alias, tp2)
+            if (tp1.symbol.isStatic) realiasConstraint()
+            if (res) return true
             if (tp1.prefix.isStable) return tryLiftedToThis1
           case _ =>
             if (tp1 eq NothingType) || isBottom(tp1) then return true

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

@@ -423,7 +423,7 @@ object TypeOps:
     override def apply(tp: Type): Type = tp match
       case tp: TermRef
       if toAvoid(tp) =>
-        tp.info.widenExpr.dealias match {
+        tp.info.widenExpr match {
           case info: SingletonType => apply(info)
           case info => range(defn.NothingType, apply(info))
         }

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

@@ -1304,11 +1304,11 @@ object Types {
       case tp =>
         tp
 
-    /** Widen all top-level singletons reachable by dealiasing
-     *  and going to the operands of & and |.
+    /** Widen all top-level singletons reachable
+     *  by going to the operands of & and |.
      *  Overridden and cached in OrType.
      */
-    def widenSingletons(using Context): Type = dealias match {
+    def widenSingletons(using Context): Type = this match {
       case tp: SingletonType =>
         tp.widen
       case tp: OrType =>
@@ -1856,11 +1856,11 @@ object Types {
       case _ => this
     }
 
-    /** The set of distinct symbols referred to by this type, after all aliases are expanded */
+    /** The set of distinct symbols referred to by this type */
     def coveringSet(using Context): Set[Symbol] =
       (new CoveringSetAccumulator).apply(Set.empty[Symbol], this)
 
-    /** The number of applications and refinements in this type, after all aliases are expanded */
+    /** The number of applications and refinements in this type */
     def typeSize(using Context): Int =
       (new TypeSizeAccumulator).apply(0, this)
 
@@ -6178,11 +6178,12 @@ object Types {
 
   class TypeSizeAccumulator(using Context) extends TypeAccumulator[Int] {
     var seen = util.HashSet[Type](initialCapacity = 8)
-    def apply(n: Int, tp: Type): Int =
-      if seen.contains(tp) then n
+    def apply(n: Int, tp1: Type): Int =
+      val tp0 = tp1.dealias
+      if seen.contains(tp0) then n
       else {
-        seen += tp
-        tp match {
+        seen += tp0
+        tp0 match {
           case tp: AppliedType =>
             foldOver(n + 1, tp)
           case tp: RefinedType =>
@@ -6192,23 +6193,24 @@ object Types {
           case tp: TypeParamRef =>
             apply(n, TypeComparer.bounds(tp))
           case _ =>
-            foldOver(n, tp)
+            foldOver(n, tp0)
         }
       }
   }
 
   class CoveringSetAccumulator(using Context) extends TypeAccumulator[Set[Symbol]] {
     var seen = util.HashSet[Type](initialCapacity = 8)
-    def apply(cs: Set[Symbol], tp: Type): Set[Symbol] =
-      if seen.contains(tp) then cs
+    def apply(cs: Set[Symbol], tp1: Type): Set[Symbol] =
+      val tp0 = tp1.dealias
+      if seen.contains(tp0) then cs
       else {
-        seen += tp
-        tp match {
+        seen += tp0
+        tp0 match {
           case tp if tp.isExactlyAny || tp.isExactlyNothing =>
             cs
-          case tp: AppliedType =>
+          case tp: AppliedType if !tp.typeSymbol.isAliasType =>
             foldOver(cs + tp.typeSymbol, tp)
-          case tp: RefinedType =>
+          case tp: RefinedType if !tp.typeSymbol.isAliasType =>
             foldOver(cs + tp.typeSymbol, tp)
           case tp: TypeRef if tp.info.isTypeAlias =>
             apply(cs, tp.superType)
@@ -6220,7 +6222,7 @@ object Types {
           case tp: TypeParamRef =>
             apply(cs, TypeComparer.bounds(tp))
           case other =>
-            foldOver(cs, tp)
+            foldOver(cs, tp0)
         }
       }
   }

compiler/src/dotty/tools/dotc/util/Signatures.scala

@@ -105,18 +105,20 @@ object Signatures {
     ctx.definitions.isTupleClass(tree.symbol.owner.companionClass)
 
   private def extractParamTypess(resultType: Type)(using Context): List[List[Type]] =
-    resultType match {
+    resultType.dealias match {
       // Reference to a type which is not a type class
       case ref: TypeRef if !ref.symbol.isPrimitiveValueClass =>
         getExtractorMembers(ref)
       // Option or Some applied type. There is special syntax for multiple returned arguments:
       //   Option[TupleN] and Option[Seq],
-      // We are not intrested in them, instead we extract proper type parameters from the Option type parameter.
-      case AppliedType(TypeRef(_, cls), (appliedType @ AppliedType(tycon, args)) :: Nil)
-          if (cls == ctx.definitions.OptionClass || cls == ctx.definitions.SomeClass) =>
-        tycon match
-          case TypeRef(_, cls) if cls == ctx.definitions.SeqClass => List(List(appliedType))
-          case _ => List(args)
+      // We are not interested in them, instead we extract proper type parameters from the Option type parameter.
+      case AppliedType(TypeRef(_, cls), (appliedType @ AppliedType(_, args)) :: Nil)
+          if cls == ctx.definitions.OptionClass || cls == ctx.definitions.SomeClass =>
+        appliedType.dealias match
+          case appliedType @ AppliedType(TypeRef(_, cls), args) =>
+            if cls == ctx.definitions.SeqClass then List(List(appliedType)) else List(args)
+          case _ =>
+            List(args)
       // Applied type extractor. We must extract from applied type to retain type parameters
       case appliedType: AppliedType => getExtractorMembers(appliedType)
       // This is necessary to extract proper result type as unapply can return other methods eg. apply

compiler/test-resources/repl/i5177

@@ -0,0 +1,12 @@
+scala> class A[T]
+// defined class A
+scala> type B[T] = A[T]
+// defined alias type B[T] = A[T]
+scala> def b: B[String] = ??? 
+def b: B[String]
+scala> class C
+// defined class C
+scala> type D = C
+// defined alias type D = C
+scala> def d: D = ??? 
+def d: D

scaladoc/test/dotty/tools/scaladoc/ExternalLocationProviderIntegrationTest.scala

@@ -47,7 +47,7 @@ class Scaladoc3ExternalLocationProviderIntegrationTest extends ExternalLocationP
     ".*externalStubs.*::scaladoc3::https://external.stubs/api/"
   ),
   List(
-    "https://dotty.epfl.ch/api/scala/collection/immutable/Map.html",
+    "https://dotty.epfl.ch/api/scala/Predef$.html#Map-0",
     "https://dotty.epfl.ch/api/scala/Predef$.html#String-0",
     "https://dotty.epfl.ch/api/scala/util/matching/Regex$$Match.html",
     "https://external.stubs/api/tests/externalStubs/$div$bslash$.html",

tests/neg-custom-args/deprecation/type-alias.scala

@@ -0,0 +1,5 @@
+trait Iterable[T]
+
+@deprecated type Traversable[T] = Iterable[T]
+
+def test: Traversable[Int] = ??? // error