bugfix: Fix after changes in presentation compiler

Author: tgodzik

presentation-compiler/src/main/dotty/tools/pc/CompletionItemResolver.scala

@@ -62,7 +62,7 @@ object CompletionItemResolver extends ItemResolver:
     if companion == NoSymbol || gsym.is(JavaDefined) then
       if gsymDoc.isEmpty() then
         if gsym.isAliasType then
-          fullDocstring(gsym.info.deepDealias.typeSymbol, search)
+          fullDocstring(gsym.info.deepDealiasAndSimplify.typeSymbol, search)
         else if gsym.is(Method) then
           gsym.info.finalResultType match
             case tr @ TermRef(_, sym) =>

presentation-compiler/src/main/dotty/tools/pc/HoverProvider.scala

@@ -108,7 +108,7 @@ object HoverProvider:
             if symbol.name == nme.selectDynamic || symbol.name == nme.applyDynamic =>
           fallbackToDynamics(path, printer, contentType)
         case symbolTpes @ ((symbol, tpe, _) :: _) =>
-          val exprTpw = tpe.widenTermRefExpr.deepDealias
+          val exprTpw = tpe.widenTermRefExpr.deepDealiasAndSimplify
           val hoverString =
             tpw match
               // https://github.com/lampepfl/dotty/issues/8891
@@ -123,7 +123,7 @@ object HoverProvider:
                   if tpe != NoType then tpe
                   else tpw
 
-                printer.hoverSymbol(sym, finalTpe.deepDealias)
+                printer.hoverSymbol(sym, finalTpe.deepDealiasAndSimplify)
             end match
           end hoverString
 
@@ -177,7 +177,7 @@ object HoverProvider:
             val resultType =
               rest match
                 case Select(_, asInstanceOf) :: TypeApply(_, List(tpe)) :: _ if asInstanceOf == nme.asInstanceOfPM =>
-                    tpe.tpe.widenTermRefExpr.deepDealias
+                    tpe.tpe.widenTermRefExpr.deepDealiasAndSimplify
                 case _ if n == nme.selectDynamic => tpe.resultType
                 case _ => tpe
 
@@ -202,9 +202,9 @@ object HoverProvider:
             findRefinement(parent)
           case _ => None
 
-      val refTpe = sel.typeOpt.widen.deepDealias match
+      val refTpe = sel.typeOpt.widen.deepDealiasAndSimplify match
         case r: RefinedType => Some(r)
-        case t: (TermRef | TypeProxy) => Some(t.termSymbol.info.deepDealias)
+        case t: (TermRef | TypeProxy) => Some(t.termSymbol.info.deepDealiasAndSimplify)
         case _ => None
 
       refTpe.flatMap(findRefinement).asJava

presentation-compiler/src/main/dotty/tools/pc/InferredTypeProvider.scala

@@ -102,7 +102,7 @@ final class InferredTypeProvider(
           case _ => true
       if isInScope(tpe)
       then tpe
-      else tpe.deepDealias
+      else tpe.deepDealiasAndSimplify
 
     val printer = ShortenedTypePrinter(
       symbolSearch,

presentation-compiler/src/main/dotty/tools/pc/PcInlayHintsProvider.scala

@@ -140,7 +140,7 @@ class PcInlayHintsProvider(
             isInScope(tycon) && args.forall(isInScope)
           case _ => true
       if isInScope(tpe) then tpe
-      else tpe.deepDealias(using indexedCtx.ctx)
+      else tpe.deepDealiasAndSimplify(using indexedCtx.ctx)
 
     val dealiased = optDealias(tpe)
     val tpeStr = printer.tpe(dealiased)

presentation-compiler/src/main/dotty/tools/pc/SymbolInformationProvider.scala

@@ -11,7 +11,7 @@ import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Names.*
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.Symbols.*
-import dotty.tools.pc.utils.InteractiveEnrichments.deepDealias
+import dotty.tools.pc.utils.InteractiveEnrichments.deepDealiasAndSimplify
 import dotty.tools.pc.SemanticdbSymbols
 import dotty.tools.pc.utils.InteractiveEnrichments.allSymbols
 import dotty.tools.pc.utils.InteractiveEnrichments.stripBackticks
@@ -51,7 +51,7 @@ class SymbolInformationProvider(using Context):
           collect(classSym)
           visited.toList.map(SemanticdbSymbols.symbolName)
         val dealisedSymbol =
-          if sym.isAliasType then sym.info.deepDealias.typeSymbol else sym
+          if sym.isAliasType then sym.info.deepDealiasAndSimplify.typeSymbol else sym
         val classOwner =
           sym.ownersIterator.drop(1).find(s => s.isClass || s.is(Flags.Module))
         val overridden = sym.denot.allOverriddenSymbols.toList

presentation-compiler/src/main/dotty/tools/pc/completions/MatchCaseCompletions.scala

@@ -93,7 +93,7 @@ object CaseKeywordCompletion:
                     case (Ident(v), tpe) => v.decoded == value
                     case (Select(_, v), tpe) => v.decoded == value
                     case t => false
-                  .map((_, id) => argPts(id).widen.deepDealias)
+                  .map((_, id) => argPts(id).widen.deepDealiasAndSimplify)
           /* Parent is a function expecting a case match expression */
           case TreeApply(fun, _) if !fun.tpe.isErroneous =>
             fun.tpe.paramInfoss match
@@ -103,12 +103,12 @@ object CaseKeywordCompletion:
                   ) =>
                 val args = head.argTypes.init
                 if args.length > 1 then
-                  Some(definitions.tupleType(args).widen.deepDealias)
-                else args.headOption.map(_.widen.deepDealias)
+                  Some(definitions.tupleType(args).widen.deepDealiasAndSimplify)
+                else args.headOption.map(_.widen.deepDealiasAndSimplify)
               case _ => None
           case _ => None
       case sel =>
-          Some(sel.tpe.widen.deepDealias)
+          Some(sel.tpe.widen.deepDealiasAndSimplify)
 
     selTpe
       .collect { case selTpe if selTpe != NoType =>
@@ -279,8 +279,8 @@ object CaseKeywordCompletion:
       clientSupportsSnippets
     )
 
-    val tpeStr = printer.tpe(selector.tpe.widen.deepDealias.bounds.hi)
-    val tpe = selector.typeOpt.widen.deepDealias.bounds.hi match
+    val tpeStr = printer.tpe(selector.tpe.widen.deepDealiasAndSimplify.bounds.hi)
+    val tpe = selector.typeOpt.widen.deepDealiasAndSimplify.bounds.hi match
       case tr @ TypeRef(_, _) => tr.underlying
       case t => t
 

presentation-compiler/src/main/dotty/tools/pc/completions/SingletonCompletions.scala

@@ -42,7 +42,7 @@ object SingletonCompletions:
     } yield value
 
   private def collectSingletons(tpe: Type)(using Context): List[Constant] =
-    tpe.deepDealias match
+    tpe.deepDealiasAndSimplify match
       case ConstantType(value) => List(value)
       case OrType(tpe1, tpe2) =>
         collectSingletons(tpe1) ++ collectSingletons(tpe2)

presentation-compiler/src/main/dotty/tools/pc/utils/InteractiveEnrichments.scala

@@ -178,7 +178,7 @@ object InteractiveEnrichments extends CommonMtagsEnrichments:
       if sym.is(Module) then sym.companionClass else sym.companionModule
 
     def dealiasType: Symbol =
-      if sym.isType then sym.info.deepDealias.typeSymbol else sym
+      if sym.isType then sym.info.deepDealiasAndSimplify.typeSymbol else sym
 
     def nameBackticked: String = nameBackticked(Set.empty[String])
 
@@ -402,16 +402,16 @@ object InteractiveEnrichments extends CommonMtagsEnrichments:
   end extension
 
   extension (tpe: Type)
-    def deepDealias(using Context): Type =
-      tpe.dealias match
+    def deepDealiasAndSimplify(using Context): Type =
+      val dealiased = tpe.dealias match
         case app @ AppliedType(tycon, params) =>
-          AppliedType(tycon, params.map(_.deepDealias))
+          AppliedType(tycon, params.map(_.deepDealiasAndSimplify))
         case aliasingBounds: AliasingBounds =>
           aliasingBounds.derivedAlias(aliasingBounds.alias.deepDealiasAndSimplify)
         case TypeBounds(lo, hi) =>
           TypeBounds(lo.dealias, hi.dealias)
         case RefinedType(parent, name, refinedInfo) =>
-          RefinedType(parent.dealias, name, refinedInfo.deepDealias)
+          RefinedType(parent.dealias, name, refinedInfo.deepDealiasAndSimplify)
         case dealised => dealised
       dealiased.simplified