Don't add parent refinements if they are typed as skolems

Author: KacperFKorban

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

@@ -8,6 +8,7 @@ import ContextOps.enter
 import TypeApplications.EtaExpansion
 import collection.mutable
 import config.Printers.typr
+import ast.untpd
 
 /** Operations that are shared between Namer and TreeUnpickler */
 object NamerOps:
@@ -38,19 +39,22 @@ object NamerOps:
    *  unless it is null.
    */
   extension (tp: Type)
-    def separateRefinements(cls: ClassSymbol, refinements: mutable.LinkedHashMap[Name, Type] | Null)(using Context): Type =
+    def separateRefinements(cls: ClassSymbol, refinements: mutable.LinkedHashMap[Name, Type] | Null, parent: untpd.Tree)(using Context): Type =
       tp match
         case RefinedType(tp1, rname, rinfo) =>
-          try tp1.separateRefinements(cls, refinements)
+          try tp1.separateRefinements(cls, refinements, parent)
           finally
             if refinements != null then
-              refinements(rname) = refinements.get(rname) match
-                case Some(tp) => tp & rinfo
-                case None => rinfo
+              if rinfo.existsPart(_.isInstanceOf[SkolemType]) then
+                report.warning(em"Couldn't determine the precise type of refinement $rname in $tp", parent.srcPos)
+              else
+                refinements(rname) = refinements.get(rname) match
+                  case Some(tp) => tp & rinfo
+                  case None => rinfo
         case tp @ AnnotatedType(tp1, ann) =>
-          tp.derivedAnnotatedType(tp1.separateRefinements(cls, refinements), ann)
+          tp.derivedAnnotatedType(tp1.separateRefinements(cls, refinements, parent), ann)
         case tp: RecType =>
-          tp.parent.substRecThis(tp, cls.thisType).separateRefinements(cls, refinements)
+          tp.parent.substRecThis(tp, cls.thisType).separateRefinements(cls, refinements, parent)
         case tp =>
           tp
 

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

@@ -1080,7 +1080,7 @@ class TreeUnpickler(reader: TastyReader,
       }
       val parentReader = fork
       val parents = readParents(withArgs = false)(using parentCtx)
-      val parentTypes = parents.map(_.tpe.dealiasKeepAnnots.separateRefinements(cls, null))
+      val parentTypes = parents.map(p => p.tpe.dealiasKeepAnnots.separateRefinements(cls, null, p))
       if cls.is(JavaDefined) && parentTypes.exists(_.derivesFrom(defn.JavaAnnotationClass)) then
         cls.setFlag(JavaAnnotation)
       val self =

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -654,6 +654,9 @@ private class ExtractAPICollector(nonLocalClassSymbols: mutable.HashSet[Symbol])
       case SuperType(thistpe, supertpe) =>
         val s = combineApiTypes(apiType(thistpe), apiType(supertpe))
         withMarker(s, superMarker)
+      case SkolemType(info) =>
+        // for skolem types, fallback to the underlying type
+        apiType(info)
       case _ => {
         internalError(i"Unhandled type $tp of class ${tp.getClass}")
         Constants.emptyType

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

@@ -1615,7 +1615,7 @@ class Namer { typer: Typer =>
         else {
           val pt = checkClassType(
               if Feature.enabled(modularity)
-              then ptype.separateRefinements(cls, parentRefinements)
+              then ptype.separateRefinements(cls, parentRefinements, parent)
               else ptype,
               parent.srcPos,
               traitReq = parent ne parents.head,

tests/warn/i22456.check

@@ -0,0 +1,6 @@
+-- Warning: tests/warn/i22456.scala:5:10 -------------------------------------------------------------------------------
+5 |  extends T(x + 1) // warn
+  |          ^^^^^^^^
+  |          Couldn't determine the precise type of refinement y in T{val y: (?1 : Int)}
+  |
+  |          where:    ?1 is an unknown value of type Int

tests/warn/i22456.scala

@@ -0,0 +1,5 @@
+import language.experimental.modularity
+
+class T(tracked val y: Int)
+class C(tracked val x: Int)
+  extends T(x + 1) // warn