For a typeRef, prefer info.isAlias over symbol.isAliasType

Reason: This works even for typeRefs with joint-ref denotations, even if the symbol does not exist. The only reason to use symbol.isAliasType is if info.isAlias can produce a cycle.

3 files changed, 5 insertions, 12 deletions

diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala
index 1ee34e4be..0969562da 100644
--- a/src/dotty/tools/dotc/typer/Applications.scala
+++ b/src/dotty/tools/dotc/typer/Applications.scala
@@ -544,7 +544,7 @@ trait Applications extends Compatibility { self: Typer =>
         case tree: untpd.RefTree =>
           val ttree = typedType(tree.withName(tree.name.toTypeName))
           ttree.tpe match {
-            case alias: TypeRef if alias.symbol.isAliasType =>
+            case alias: TypeRef if alias.info.isAlias =>
               companionRef(alias) match {
                 case companion: TermRef => return untpd.ref(companion) withPos tree.pos
                 case _ =>
diff --git a/src/dotty/tools/dotc/typer/Implicits.scala b/src/dotty/tools/dotc/typer/Implicits.scala
index 9cc472ba4..10ba90055 100644
--- a/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/src/dotty/tools/dotc/typer/Implicits.scala
@@ -485,7 +485,7 @@ class SearchHistory(val searchDepth: Int, val seen: Map[ClassSymbol, Int]) {
       def apply(n: Int, tp: Type): Int = tp match {
         case tp: RefinedType =>
           foldOver(n + 1, tp)
-        case tp: TypeRef if tp.symbol.isAliasType =>
+        case tp: TypeRef if tp.info.isAlias =>
           apply(n, tp.info.bounds.hi)
         case _ =>
           foldOver(n, tp)
diff --git a/src/dotty/tools/dotc/typer/Inferencing.scala b/src/dotty/tools/dotc/typer/Inferencing.scala
index fba2201bf..6e522b831 100644
--- a/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -305,16 +305,9 @@ object Inferencing {
       inst
     }
     private var toMaximize: Boolean = false
-    def apply(x: Boolean, tp: Type): Boolean = tp match {
+    def apply(x: Boolean, tp: Type): Boolean = tp.dealias match {
       case _: WildcardType =>
         false
-      case tp: TypeRef =>
-        // todo: factor out? same logic is also used in avoid.
-        // and interestingly it does not work with #dealias
-        tp.info match {
-          case TypeAlias(ref) => apply(x, ref)
-          case _ => foldOver(x, tp)
-        }
       case tvar: TypeVar if !tvar.isInstantiated =>
         if (force == ForceDegree.none) false
         else {
@@ -324,9 +317,9 @@ object Inferencing {
               isBottomType(ctx.typeComparer.approximation(tvar.origin, fromBelow = true)))
           if (minimize) instantiate(tvar, fromBelow = true)
           else toMaximize = true
-          foldOver(x, tp)
+          foldOver(x, tvar)
         }
-      case _ =>
+      case tp =>
         foldOver(x, tp)
     }