less eager dealiasing of type aliases

pweisenburger · pweisenburger · commit c0dcf97c7320 · 2022-02-28T01:09:24.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/config/Config.scala b/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
diff --git a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala b/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)
diff --git a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala b/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
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/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
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/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))
         }
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/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)
         }
       }
   }
diff --git a/compiler/test-resources/repl/i5177 b/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
diff --git a/scaladoc/test/dotty/tools/scaladoc/ExternalLocationProviderIntegrationTest.scala b/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",
diff --git a/tests/neg-custom-args/deprecation/type-alias.scala b/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
diff --git a/tests/neg-macros/i6997.scala b/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
   }
 }
diff --git a/tests/neg/12974.scala b/tests/neg/12974.scala
@@ -25,7 +25,7 @@ object RecMap {
 
     val foo: Any = Rec.empty.fetch("foo") // error
     //                            ^
-    // Match type reduction failed since selector  EmptyTuple.type
+    // Match type reduction failed since selector  EmptyTuple
     // matches none of the cases
     //
     //     case (("foo" : String), t) *: _ => t
diff --git a/tests/neg/i12049.check b/tests/neg/i12049.check
@@ -18,7 +18,7 @@
 -- Error: tests/neg/i12049.scala:14:23 ---------------------------------------------------------------------------------
 14 |val y3: String = ??? : Last[Int *: Int *: Boolean *: String *: EmptyTuple]  // error
    |                       ^
-   |                       Match type reduction failed since selector  EmptyTuple.type
+   |                       Match type reduction failed since selector  EmptyTuple
    |                       matches none of the cases
    |
    |                           case _ *: _ *: t => Last[t]
@@ -48,7 +48,7 @@
 -- Error: tests/neg/i12049.scala:25:26 ---------------------------------------------------------------------------------
 25 |val _ = summon[String =:= Last[Int *: Int *: Boolean *: String *: EmptyTuple]] // error
    |                          ^
-   |                          Match type reduction failed since selector  EmptyTuple.type
+   |                          Match type reduction failed since selector  EmptyTuple
    |                          matches none of the cases
    |
    |                              case _ *: _ *: t => Last[t]
diff --git a/tests/neg/i4565.check b/tests/neg/i4565.check
@@ -0,0 +1,49 @@
+-- [E007] Type Mismatch Error: tests/neg/i4565.scala:17:13 -------------------------------------------------------------
+17 |def b: Int = a // error
+   |             ^
+   |             Found:    Test1[F[Int, String]]
+   |             Required: Int
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i4565.scala:20:13 -------------------------------------------------------------
+20 |def d: Int = c // error
+   |             ^
+   |             Found:    F[Int, String]
+   |             Required: Int
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i4565.scala:23:13 -------------------------------------------------------------
+23 |def f: Int = e // error
+   |             ^
+   |             Found:    F[Int, String]
+   |             Required: Int
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i4565.scala:26:13 -------------------------------------------------------------
+26 |def h: Int = g // error
+   |             ^
+   |             Found:    Test1[B]
+   |             Required: Int
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i4565.scala:29:13 -------------------------------------------------------------
+29 |def j: Int = i // error
+   |             ^
+   |             Found:    Test2[B]
+   |             Required: Int
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i4565.scala:32:13 -------------------------------------------------------------
+32 |def l: Int = k // error
+   |             ^
+   |             Found:    Test3[B]
+   |             Required: Int
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i4565.scala:35:13 -------------------------------------------------------------
+35 |def n: Int = m // error
+   |             ^
+   |             Found:    MyAlias
+   |             Required: Int
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/i4565.scala b/tests/neg/i4565.scala
@@ -0,0 +1,35 @@
+type F[A, B] = A => B
+
+type LongComplictedType
+type B = LongComplictedType
+
+case class Test1[T](v: T)
+case class Test2[T <: B](v: T)
+case class Test3[T <: LongComplictedType](v: T)
+
+class MyClass
+type MyAlias = MyClass
+
+
+// these tests check that the inferred types are not dealiased
+
+def a = Test1(??? : F[Int, String])
+def b: Int = a // error
+
+def c: F[Int, String] = ???
+def d: Int = c // error
+
+def e = { val v = ??? : F[Int, String]; v }
+def f: Int = e // error
+
+def g = Test1(??? : B)
+def h: Int = g // error
+
+def i = Test2(??? : B)
+def j: Int = i // error
+
+def k = Test3(??? : B)
+def l: Int = k // error
+
+def m: MyAlias = new MyClass
+def n: Int = m // error
diff --git a/tests/pos/i14171.scala b/tests/pos/i14171.scala
@@ -0,0 +1,26 @@
+object Test1:
+  trait MyTypeclass[F[_]]
+  def f[F[_]: MyTypeclass, U](t: F[U]) = ???
+
+  type MyType[T] = String
+  given MyTypeclass[MyType] = ???
+
+  val stream: Option[MyType[Int]] = ???
+  for
+    keyStream <- stream
+    x = 17
+  yield f(keyStream)
+
+
+object Test2:
+  trait MyTypeclass[F[_]]
+  def f[F[_]: MyTypeclass, U](t: F[U]) = ???
+
+  type MyType[T] = Nil.type
+  given MyTypeclass[MyType] = ???
+
+  val stream: Option[MyType[Int]] = ???
+  for
+    keyStream <- stream
+    x = 17
+  yield f(keyStream)
diff --git a/tests/printing/i13306.check b/tests/printing/i13306.check
@@ -8,7 +8,7 @@ package example {
   final module class Exports() extends Object() { this: example.Exports.type =>
     val instance: example.MembersContainer = new example.MembersContainer()
     export example.Exports.instance.*
-    final type MyType[T <: example.MyClass] = Comparable[T]
+    final type MyType[T <: example.MyClass] = example.Exports.instance.MyType[T]
   }
 }
 
diff --git a/tests/run-macros/i10863.check b/tests/run-macros/i10863.check
@@ -1 +1 @@
-[A >: scala.Nothing <: scala.Any] => scala.collection.immutable.List[A]
+scala.List
diff --git a/tests/run-macros/quote-matching-optimize-3.check b/tests/run-macros/quote-matching-optimize-3.check
@@ -17,10 +17,10 @@ Optimized: ls.foreach[scala.Any](((x: scala.Int) => if (((`x₂`: scala.Int) =>
 Result: ()
 
 Original: ls.map[scala.Long](((a: scala.Int) => a.toLong)).map[java.lang.String](((b: scala.Long) => b.toString()))
-Optimized: ls.map[java.lang.String](((x: scala.Int) => ((b: scala.Long) => b.toString()).apply(((a: scala.Int) => a.toLong).apply(x))))
+Optimized: ls.map[scala.Predef.String](((x: scala.Int) => ((b: scala.Long) => b.toString()).apply(((a: scala.Int) => a.toLong).apply(x))))
 Result: List(1, 2, 3)
 
 Original: ls.map[scala.Char](((a: scala.Int) => a.toChar)).map[java.lang.String](((b: scala.Char) => b.toString()))
-Optimized: ls.map[java.lang.String](((x: scala.Int) => ((b: scala.Char) => b.toString()).apply(((a: scala.Int) => a.toChar).apply(x))))
+Optimized: ls.map[scala.Predef.String](((x: scala.Int) => ((b: scala.Char) => b.toString()).apply(((a: scala.Int) => a.toChar).apply(x))))
 Result: List(, , )
 
diff --git a/tests/run-macros/quote-type-matcher.check b/tests/run-macros/quote-type-matcher.check
@@ -10,11 +10,11 @@ Scrutinee: scala.Int
 Pattern: 2
 Result: None
 
-Scrutinee: scala.collection.immutable.List[scala.Int]
-Pattern: scala.collection.immutable.List[scala.Int]
+Scrutinee: scala.List[scala.Int]
+Pattern: scala.List[scala.Int]
 Result: Some(List())
 
-Scrutinee: scala.collection.immutable.List[scala.Int]
-Pattern: scala.collection.immutable.List[scala.Double]
+Scrutinee: scala.List[scala.Int]
+Pattern: scala.List[scala.Double]
 Result: None
 
diff --git a/tests/run-macros/tasty-definitions-1.check b/tests/run-macros/tasty-definitions-1.check
@@ -165,8 +165,8 @@ TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Double")
 TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Boolean")
 TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "<root>")), "scala"), "Any")
 TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "<root>")), "scala"), "AnyVal")
-TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "java")), "lang"), "Object")
+TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "<root>")), "scala"), "AnyRef")
 TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "java")), "lang"), "Object")
 TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "<root>")), "scala"), "Nothing")
 TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "<root>")), "scala"), "Null")
-TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "java")), "lang"), "String")
+TypeRef(TermRef(TermRef(ThisType(TypeRef(NoPrefix(), "<root>")), "scala"), "Predef"), "String")
diff --git a/tests/run-macros/tasty-extractors-2.check b/tests/run-macros/tasty-extractors-2.check
@@ -14,7 +14,7 @@ Inlined(None, Nil, Typed(Literal(IntConstant(1)), TypeIdent("Int")))
 TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "<root>")), "scala"), "Int")
 
 Inlined(None, Nil, Typed(Ident("Nil"), Applied(TypeIdent("List"), List(TypeIdent("Int")))))
-AppliedType(TypeRef(ThisType(TypeRef(NoPrefix(), "immutable")), "List"), List(TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "<root>")), "scala"), "Int")))
+AppliedType(TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "scala")), "package"), "List"), List(TypeRef(TermRef(ThisType(TypeRef(NoPrefix(), "<root>")), "scala"), "Int")))
 
 Inlined(None, Nil, Typed(Apply(Select(New(TypeIdent("Baz")), "<init>"), Nil), Applied(TypeIdent("&"), List(TypeIdent("Foo"), TypeIdent("Bar")))))
 AndType(TypeRef(ThisType(TypeRef(NoPrefix(), "<empty>")), "Foo"), TypeRef(ThisType(TypeRef(NoPrefix(), "<empty>")), "Bar"))
diff --git a/tests/run-macros/tasty-extractors-types.check b/tests/run-macros/tasty-extractors-types.check
diff --git a/tests/run-macros/tasty-simplified.check b/tests/run-macros/tasty-simplified.check
diff --git a/tests/run-macros/tasty-typeof.check b/tests/run-macros/tasty-typeof.check
diff --git a/tests/run-staging/i3847-b.check b/tests/run-staging/i3847-b.check
diff --git a/tests/run-staging/i4350.check b/tests/run-staging/i4350.check
diff --git a/tests/run-staging/i5247.check b/tests/run-staging/i5247.check
diff --git a/tests/run-staging/liftables.check b/tests/run-staging/liftables.check
diff --git a/tests/run-staging/quote-owners-2.check b/tests/run-staging/quote-owners-2.check
diff --git a/tests/run-staging/quote-unrolled-foreach.check b/tests/run-staging/quote-unrolled-foreach.check
diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect

Original file line number	Diff line number	Diff line change
`@@ -423,7 +423,7 @@ object TypeOps:`
`423`	`423`	`override def apply(tp: Type): Type = tp match`
`424`	`424`	`case tp: TermRef`
`425`	`425`	`if toAvoid(tp) =>`
`426`		`- tp.info.widenExpr.dealias match {`
	`426`	`+ tp.info.widenExpr match {`
`427`	`427`	`case info: SingletonType => apply(info)`
`428`	`428`	`case info => range(defn.NothingType, apply(info))`
`429`	`429`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,6 @@ import scala.quoted.*`
`3`	`3`	`class Foo {`
`4`	`4`	`def mcrImpl(body: Expr[Any])(using t: Type[_ <: Any])(using ctx: Quotes): Expr[Any] = '{`
`5`	`5`	`val tmp = ???.asInstanceOf[t.Underlying] // error // error`
`6`		`- tmp`
	`6`	`+ tmp // error`
`7`	`7`	`}`
`8`	`8`	`}`