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

@@ -436,7 +436,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

@@ -325,7 +325,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

@@ -403,7 +403,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

@@ -1300,11 +1300,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 =>
@@ -1846,11 +1846,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, after */
     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, after */
     def typeSize(using Context): Int =
       (new TypeSizeAccumulator).apply(0, this)
 
@@ -6137,11 +6137,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 =>
@@ -6151,23 +6152,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)
@@ -6179,7 +6181,7 @@ object Types {
           case tp: TypeParamRef =>
             apply(cs, TypeComparer.bounds(tp))
           case other =>
-            foldOver(cs, tp)
+            foldOver(cs, tp0)
         }
       }
   }

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

tests/neg-macros/i6997.scala

@@ -3,6 +3,6 @@ import scala.quoted.*
 class Foo {
   def mcrImpl(body: Expr[Any])(using t: Type[_ <: Any])(using ctx: Quotes): Expr[Any] = '{
     val tmp = ???.asInstanceOf[t.Underlying] // error // error
-    tmp
+    tmp // error
   }
 }