Fix issues after merging

Author: dwijnand

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

@@ -5,7 +5,6 @@ package core
 import Symbols.*, Types.*, Contexts.*, Flags.*, Names.*, StdNames.*, Phases.*
 import Flags.JavaDefined
 import Uniques.unique
-import TypeOps.makePackageObjPrefixExplicit
 import backend.sjs.JSDefinitions
 import transform.ExplicitOuter.*
 import transform.ValueClasses.*

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

@@ -598,36 +598,6 @@ object TypeOps:
     widenMap(tp)
   }
 
-  /** If `tpe` is of the form `p.x` where `p` refers to a package
-   *  but `x` is not owned by a package, expand it to
-   *
-   *      p.package.x
-   */
-  def makePackageObjPrefixExplicit(tpe: NamedType)(using Context): Type = {
-    def tryInsert(pkgClass: SymDenotation): Type = pkgClass match {
-      case pkg: PackageClassDenotation =>
-        var sym = tpe.symbol
-        if !sym.exists && tpe.denot.isOverloaded then
-          // we know that all alternatives must come from the same package object, since
-          // otherwise we would get "is already defined" errors. So we can take the first
-          // symbol we see.
-          sym = tpe.denot.alternatives.head.symbol
-        val pobj = pkg.packageObjFor(sym)
-        if (pobj.exists) tpe.derivedSelect(pobj.termRef)
-        else tpe
-      case _ =>
-        tpe
-    }
-    if (tpe.symbol.isRoot)
-      tpe
-    else
-      tpe.prefix match {
-        case pre: ThisType if pre.cls.is(Package) => tryInsert(pre.cls)
-        case pre: TermRef if pre.symbol.is(Package) => tryInsert(pre.symbol.moduleClass)
-        case _ => tpe
-      }
-  }
-
   /** An argument bounds violation is a triple consisting of
    *   - the argument tree
    *   - a string "upper" or "lower" indicating which bound is violated

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

@@ -3,7 +3,7 @@ package dotc
 package core
 
 import TypeErasure.ErasedValueType
-import Types.*, Contexts.*, Symbols.*, Flags.*, Decorators.*
+import Types.*, Contexts.*, Symbols.*, Flags.*, Decorators.*, SymDenotations.*
 import Names.Name
 import StdNames.nme
 
@@ -147,6 +147,41 @@ class TypeUtils:
         val cls = self.underlyingClassRef(refinementOK = false).typeSymbol
         cls.isTransparentClass && (!traitOnly || cls.is(Trait))
 
+    /** If `self` is of the form `p.x` where `p` refers to a package
+     *  but `x` is not owned by a package, expand it to
+     *
+     *      p.package.x
+     */
+    def makePackageObjPrefixExplicit(using Context): Type =
+      def tryInsert(tpe: NamedType, pkgClass: SymDenotation): Type = pkgClass match
+        case pkg: PackageClassDenotation =>
+          var sym = tpe.symbol
+          if !sym.exists && tpe.denot.isOverloaded then
+            // we know that all alternatives must come from the same package object, since
+            // otherwise we would get "is already defined" errors. So we can take the first
+            // symbol we see.
+            sym = tpe.denot.alternatives.head.symbol
+          val pobj = pkg.packageObjFor(sym)
+          if pobj.exists then tpe.derivedSelect(pobj.termRef)
+          else tpe
+        case _ =>
+          tpe
+      self match
+      case tpe: NamedType =>
+        if tpe.symbol.isRoot then
+          tpe
+        else
+          tpe.prefix match
+            case pre: ThisType if pre.cls.is(Package) => tryInsert(tpe, pre.cls)
+            case pre: TermRef if pre.symbol.is(Package) => tryInsert(tpe, pre.symbol.moduleClass)
+            case _ => tpe
+      case tpe => tpe
+
+    /** Strip all outer refinements off this type */
+    def stripRefinement: Type = self match
+      case self: RefinedOrRecType => self.parent.stripRefinement
+      case seld => self
+
     /** The constructors of this type that are applicable to `argTypes`, without needing
      *  an implicit conversion. Curried constructors are always excluded.
      *  @param adaptVarargs   if true, allow a constructor with just a varargs argument to

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1192,7 +1192,7 @@ class TreeUnpickler(reader: TastyReader,
         val tpe0 = name match
           case name: TypeName => TypeRef(qualType, name, denot)
           case name: TermName => TermRef(qualType, name, denot)
-        val tpe = TypeOps.makePackageObjPrefixExplicit(tpe0)
+        val tpe = tpe0.makePackageObjPrefixExplicit
         ConstFold.Select(untpd.Select(qual, name).withType(tpe))
 
       def completeSelect(name: Name, sig: Signature, target: Name): Select =

compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -81,7 +81,7 @@ trait TypeAssigner {
       defn.FromJavaObjectType
     else tpe match
       case tpe: NamedType =>
-        val tpe1 = TypeOps.makePackageObjPrefixExplicit(tpe)
+        val tpe1 = tpe.makePackageObjPrefixExplicit
         if tpe1 ne tpe then
           accessibleType(tpe1, superAccess)
         else