Handle dependent refinements in class parents

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -902,7 +902,9 @@ object desugar {
       }
       if mods.isAllOf(Given | Inline | Transparent) then
         report.error("inline given instances cannot be trasparent", cdef)
-      val classMods = if mods.is(Given) then mods &~ (Inline | Transparent) | Synthetic else mods
+      var classMods = if mods.is(Given) then mods &~ (Inline | Transparent) | Synthetic else mods
+      if vparamAccessors.exists(_.mods.is(Tracked)) then
+        classMods |= Dependent
       cpy.TypeDef(cdef: TypeDef)(
         name = className,
         rhs = cpy.Template(impl)(constr, parents1, clsDerived, self1,

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

@@ -377,7 +377,7 @@ object Flags {
   /** Symbol cannot be found as a member during typer */
   val (Invisible @ _, _, _) = newFlags(45, "<invisible>")
 
-  val (Tracked @ _, _, _) = newFlags(46, "tracked")
+  val (Tracked @ _, _, Dependent @ _) = newFlags(46, "tracked", "dependent")
 
   // ------------ Flags following this one are not pickled ----------------------------------
 
@@ -470,7 +470,7 @@ object Flags {
     Scala2SpecialFlags, MutableOrOpen, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor,
     Extension, NonMember, Implicit, Given, Permanent, Synthetic, Exported,
-    SuperParamAliasOrScala2x, Inline, Macro, ConstructorProxy, Invisible)
+    SuperParamAliasOrScala2x, Inline, Macro, ConstructorProxy, Invisible, Tracked)
 
   /** Flags that are not (re)set when completing the denotation, or, if symbol is
    *  a top-level class or object, when completing the denotation once the class

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

@@ -10,6 +10,7 @@ import Contexts.ctx
 import dotty.tools.dotc.reporting.trace
 import config.Feature.migrateTo3
 import config.Printers.*
+import transform.TypeUtils.stripRefinement
 
 trait PatternTypeConstrainer { self: TypeComparer =>
 
@@ -88,11 +89,6 @@ trait PatternTypeConstrainer { self: TypeComparer =>
       }
     }
 
-    def stripRefinement(tp: Type): Type = tp match {
-      case tp: RefinedOrRecType => stripRefinement(tp.parent)
-      case tp => tp
-    }
-
     def tryConstrainSimplePatternType(pat: Type, scrut: Type) = {
       val patCls = pat.classSymbol
       val scrCls = scrut.classSymbol

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

@@ -17,6 +17,7 @@ import Denotations.*
 import printing.Texts.*
 import printing.Printer
 import SymDenotations.NoDenotation
+import util.common.alwaysFalse
 
 import collection.mutable
 import scala.compiletime.uninitialized
@@ -94,15 +95,13 @@ object Scopes {
     def foreach[U](f: Symbol => U)(using Context): Unit = toList.foreach(f)
 
     /** Selects all Symbols of this Scope which satisfy a predicate. */
-    def filter(p: Symbol => Boolean)(using Context): List[Symbol] = {
+    def filter(p: Symbol => Boolean, stopAt: Symbol => Boolean = alwaysFalse)(using Context): List[Symbol] = {
       ensureComplete()
       var syms: List[Symbol] = Nil
       var e = lastEntry
-      while ((e != null) && e.owner == this) {
-        val sym = e.sym
-        if (p(sym)) syms = sym :: syms
+      while e != null && e.owner == this && !stopAt(e.sym) do
+        if p(e.sym) then syms = e.sym :: syms
         e = e.prev
-      }
       syms
     }
 

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

@@ -2380,7 +2380,7 @@ object SymDenotations {
      *  Both getters and setters are returned in this list.
      */
     def paramAccessors(using Context): List[Symbol] =
-      unforcedDecls.filter(_.is(ParamAccessor))
+      unforcedDecls.filter(_.is(ParamAccessor))//, stopAt = sym => sym.is(Method, butNot = ParamAccessor))
 
     /** The term parameter getters of this class. */
     def paramGetters(using Context): List[Symbol] =

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -18,6 +18,7 @@ import config.Printers.typr
 import config.Feature
 import util.SrcPos
 import reporting.*
+import transform.TypeUtils.stripRefinement
 import NameKinds.WildcardParamName
 
 object PostTyper {
@@ -411,8 +412,12 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
                   // Constructor parameters are in scope when typing a parent.
                   // While they can safely appear in a parent tree, to preserve
                   // soundness we need to ensure they don't appear in a parent
-                  // type (#16270).
-                  val illegalRefs = parent.tpe.namedPartsWith(p => p.symbol.is(ParamAccessor) && (p.symbol.owner eq sym))
+                  // type (#16270). We can strip any refinement of a parent type since
+                  // these refinements are split off from the parent type constructor
+                  // application `parent` in Namer and don't show up as parent types
+                  // of the class.
+                  val illegalRefs = parent.tpe.stripRefinement.namedPartsWith:
+                      p => p.symbol.is(ParamAccessor) && (p.symbol.owner eq sym)
                   if illegalRefs.nonEmpty then
                     report.error(
                       em"The type of a class parent cannot refer to constructor parameters, but ${parent.tpe} refers to ${illegalRefs.map(_.name.show).mkString(",")}", parent.srcPos)

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

@@ -7,11 +7,11 @@ import TypeErasure.ErasedValueType
 import Types.*, Contexts.*, Symbols.*, Flags.*, Decorators.*
 import Names.Name
 
-object TypeUtils {
+object TypeUtils:
   /** A decorator that provides methods on types
    *  that are needed in the transformer pipeline.
    */
-  extension (self: Type) {
+  extension (self: Type)
 
     def isErasedValueType(using Context): Boolean =
       self.isInstanceOf[ErasedValueType]
@@ -104,5 +104,11 @@ object TypeUtils {
       case _ =>
         val cls = self.underlyingClassRef(refinementOK = false).typeSymbol
         cls.isTransparentClass && (!traitOnly || cls.is(Trait))
-  }
-}
+
+    /** Strip all outer refinements off this type */
+    def stripRefinement: Type = self match
+      case self: RefinedOrRecType => self.parent.stripRefinement
+      case seld => self
+
+end TypeUtils
+

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

@@ -198,7 +198,7 @@ object Checking {
    *  and that the instance conforms to the self type of the created class.
    */
   def checkInstantiable(tp: Type, srcTp: Type, pos: SrcPos)(using Context): Unit =
-    tp.underlyingClassRef(refinementOK = false) match
+    tp.underlyingClassRef(refinementOK = true) match
       case tref: TypeRef =>
         val cls = tref.symbol
         if (cls.isOneOf(AbstractOrTrait)) {

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

@@ -1500,8 +1500,13 @@ class Namer { typer: Typer =>
           core match
             case Select(New(tpt), nme.CONSTRUCTOR) =>
               val targs1 = targs map (typedAheadType(_))
-              val ptype = typedAheadType(tpt).tpe appliedTo targs1.tpes
-              if (ptype.typeParams.isEmpty) ptype
+              val ptype = typedAheadType(tpt).tpe.appliedTo(targs1.tpes)
+              if ptype.typeParams.isEmpty
+                  //&& !ptype.dealias.typeSymbol.primaryConstructor.info.finalResultType.isInstanceOf[RefinedType]
+                  && !ptype.dealias.typeSymbol.is(Dependent)
+                  || ctx.erasedTypes
+              then
+                ptype
               else
                 if (denot.is(ModuleClass) && denot.sourceModule.isOneOf(GivenOrImplicit))
                   missingType(denot.symbol, "parent ")(using creationContext)
@@ -1539,7 +1544,7 @@ class Namer { typer: Typer =>
         if (cls.isRefinementClass) ptype
         else {
           val pt = checkClassType(ptype, parent.srcPos,
-              traitReq = parent ne parents.head, stablePrefixReq = true)
+              traitReq = parent ne parents.head, stablePrefixReq = true, refinementOK = true)
           if (pt.derivesFrom(cls)) {
             val addendum = parent match {
               case Select(qual: Super, _) if Feature.migrateTo3 =>
@@ -1605,14 +1610,52 @@ class Namer { typer: Typer =>
       completeConstructor(denot)
       denot.info = tempInfo.nn
 
-      val parentTypes = defn.adjustForTuple(cls, cls.typeParams,
-        defn.adjustForBoxedUnit(cls,
-          addUsingTraits(
-            ensureFirstIsClass(cls, parents.map(checkedParentType(_)))
-          )
-        )
-      )
-      typr.println(i"completing $denot, parents = $parents%, %, parentTypes = $parentTypes%, %")
+      /** The refinements coming from all parent class constructor applications */
+      val parentRefinements = mutable.LinkedHashMap[Name, Type]()
+
+      /** Split refinements off parent type and add them to `parentRefinements` */
+      def separateRefinements(tp: Type): Type = tp match
+        case RefinedType(tp1, rname, rinfo) =>
+          try separateRefinements(tp1)
+          finally
+            parentRefinements(rname) = parentRefinements.get(rname) match
+              case Some(tp) => tp & rinfo
+              case None => rinfo
+        case tp => tp
+
+      /** Add all parent refinements to the result type of the `info` of
+       *  the class constructor. Parent refinements refer to parameter accessors
+       *  in the current class. These have to be mapped to the paramRefs of the
+       *  constructor info.
+       *  @param info           The (remaining part) of the constructor info
+       *  @param nameToParamRef The map from parameter names to paramRefs of
+       *                        previously encountered parts of `info`.
+       */
+      def integrateParentRefinements(info: Type, nameToParamRef: Map[Name, Type]): Type = info match
+        case info: MethodOrPoly =>
+          info.derivedLambdaType(resType =
+            integrateParentRefinements(info.resType,
+              nameToParamRef ++ info.paramNames.zip(info.paramRefs)))
+        case _ =>
+          val mapParams = new TypeMap:
+            def apply(t: Type) = t match
+              case t: TermRef if t.symbol.is(ParamAccessor) && t.symbol.owner == cls =>
+                nameToParamRef(t.name)
+              case _ =>
+                mapOver(t)
+          parentRefinements.foldLeft(info): (info, refinement) =>
+            val (rname, rinfo) = refinement
+            RefinedType(info, rname, mapParams(rinfo))
+
+      val parentTypes =
+        defn.adjustForTuple(cls, cls.typeParams,
+          defn.adjustForBoxedUnit(cls,
+            addUsingTraits(
+              ensureFirstIsClass(cls, parents.map(checkedParentType(_)))
+        ))).map(separateRefinements)
+
+      typr.println(i"completing $denot, parents = $parents%, %, stripped parent types = $parentTypes%, %")
+      typr.println(i"constr type = ${cls.primaryConstructor.infoOrCompleter}, refinements = ${parentRefinements.toList}")
 
       if (impl.derived.nonEmpty) {
         val (derivingClass, derivePos) = original.removeAttachment(desugar.DerivingCompanion) match {
@@ -1627,6 +1670,10 @@ class Namer { typer: Typer =>
       denot.info = tempInfo.nn.finalized(parentTypes)
       tempInfo = null // The temporary info can now be garbage-collected
 
+      if parentRefinements.nonEmpty then
+        val constr = cls.primaryConstructor
+        constr.info = integrateParentRefinements(constr.info, Map())
+        cls.setFlag(Dependent)
       Checking.checkWellFormed(cls)
       if (isDerivedValueClass(cls)) cls.setFlag(Final)
       cls.info = avoidPrivateLeaks(cls)

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

@@ -4360,7 +4360,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           cpy.Ident(qual)(qual.symbol.name.sourceModuleName.toTypeName)
         case _ =>
           errorTree(tree, em"cannot convert from $tree to an instance creation expression")
-      val tycon = tree.tpe.widen.finalResultType.underlyingClassRef(refinementOK = false)
+      val tycon = tree.tpe.widen.finalResultType.underlyingClassRef(refinementOK = true)
       typed(
         untpd.Select(
           untpd.New(untpd.TypedSplice(tpt.withType(tycon))),

tests/neg/i3964.scala

@@ -10,23 +10,3 @@ object Test1:
   trait Foo { val x: Animal }
   val foo: Foo { val x: Cat } = new Foo { val x = new Cat }  // error, but should work
 
-object Test2:
-  abstract class Bar(tracked val x: Animal)
-  val b = new Bar(new Cat)
-  val bar: Bar { val x: Cat } = new Bar(new Cat)  // ok
-
-  trait Foo(tracked val x: Animal)
-  val foo: Foo { val x: Cat } = new Foo(new Cat)  // ok
-
-object Test3:
-  trait Vec(tracked val size: Int)
-  class Vec8 extends Vec(8)
-
-  abstract class Lst(tracked val size: Int)
-  class Lst8 extends Lst(8)
-
-  val v8a: Vec { val size: 8 } = new Vec8        // error, but should work
-  val v8b: Vec { val size: 8 } = new Vec(8)      // ok
-
-  val l8a: Lst { val size: 8 } = new Lst8        // error, but should work
-  val l8b: Lst { val size: 8 } = new Lst(8)      // ok

tests/pos/i3964.scala

@@ -0,0 +1,31 @@
+trait Animal
+class Dog extends Animal
+class Cat extends Animal
+
+object Test2:
+  class Bar(tracked val x: Animal)
+  val b = new Bar(new Cat)
+  val bar: Bar { val x: Cat } = new Bar(new Cat)  // ok
+
+  trait Foo(tracked val x: Animal)
+  val foo: Foo { val x: Cat } = new Foo(new Cat) {} // ok
+
+object Test3:
+  trait Vec(tracked val size: Int)
+  class Vec8 extends Vec(8)
+
+  abstract class Lst(tracked val size: Int)
+  class Lst8 extends Lst(8)
+
+  val v8a: Vec { val size: 8 } = new Vec8
+  val v8b: Vec { val size: 8 } = new Vec(8) {}
+
+  val l8a: Lst { val size: 8 } = new Lst8
+  val l8b: Lst { val size: 8 } = new Lst(8) {}
+
+  class VecN(tracked val n: Int) extends Vec(n)
+  class Vec9 extends VecN(9)
+  val v9a = VecN(9)
+  val _: Vec { val size: 9 } = v9a
+  val v9b = Vec9()
+  val _: Vec { val size: 9 } = v9b