Switch to new scheme for handling opaques in frontend

Author: odersky

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -2,6 +2,8 @@ package dotty.tools.dotc.config
 
 object Config {
 
+  val newScheme = true
+
   final val cacheMembersNamed = true
   final val cacheAsSeenFrom = true
   final val cacheMemberNames = true

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

@@ -1165,30 +1165,8 @@ object Denotations {
           info.asSeenFrom(pre, owner),
           if (symbol.is(Opaque) || this.prefix != NoPrefix) pre else this.prefix)
 
-      pre match {
-        case pre: ThisType if symbol.isOpaqueAlias && pre.cls == owner =>
-          // This code is necessary to compensate for a "window of vulnerability" with
-          // opaque types. The problematic sequence is as follows.
-          //  1. Type a selection  `m.this.T` where `T` is an opaque type alias in `m`
-          //     and this is the first access
-          //  2. `T` will normalize to an abstract type on completion.
-          //  3. At that time, the default logic in the second case is wrong: `T`'s new info
-          //     is now an abstract type and running it through an asSeenFrom gives nothing.
-          //  We fix this as follows:
-          //  1. Force opaque normalization as first step
-          //  2. Read the info from the enclosing object's refinement
-          symbol.normalizeOpaque()
-          def findRefined(tp: Type, name: Name): Type = tp match {
-            case RefinedType(parent, rname, rinfo) =>
-              if (rname == name) rinfo else findRefined(parent, name)
-            case _ =>
-              symbol.info
-          }
-          derived(findRefined(pre.underlying, symbol.name))
-        case _ =>
-          if (!owner.membersNeedAsSeenFrom(pre) || symbol.is(NonMember)) this
-          else derived(symbol.info)
-      }
+      if (!owner.membersNeedAsSeenFrom(pre) || symbol.is(NonMember)) this
+      else derived(symbol.info)
     }
 
     /** Does this denotation have all the `required` flags but none of the `excluded` flags?

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

@@ -463,6 +463,40 @@ object SymDenotations {
         }
     }
 
+    /** If this is an opaque alias, replace the right hand side `info`
+     *  by appropriate bounds and store `info` in the refinement of the
+     *  self type of the enclosing class.
+     *  Otherwise return `info`
+     *
+     *  @param info   Is assumed to be a (lambda-abstracted) right hand side TypeAlias
+     *                of the opaque type definition.
+     */
+    def opaqueToBounds(info: Type)(given Context): Type =
+
+      def setAlias(tp: Type) =
+        def recur(self: Type): Unit = self match
+          case RefinedType(parent, name, rinfo) => rinfo match
+            case TypeAlias(lzy: LazyRef) if name == this.name =>
+              lzy.update(tp)
+            case _ =>
+              recur(parent)
+        recur(owner.asClass.givenSelfType)
+      end setAlias
+
+      info match
+        case TypeAlias(alias) if isOpaqueAlias && owner.isClass =>
+          val bounds = alias match
+            case AnnotatedType(alias1, Annotation.WithBounds(bounds)) =>
+              setAlias(alias1)
+              bounds
+            case _ =>
+              setAlias(alias)
+              TypeBounds.empty
+          HKTypeLambda.boundsFromParams(alias.typeParams, bounds)
+        case _ =>
+          info
+    end opaqueToBounds
+
     // ------ Names ----------------------------------------------
 
     /** The expanded name of this denotation. */
@@ -1203,10 +1237,10 @@ object SymDenotations {
     def opaqueAlias(implicit ctx: Context): Type = {
       def recur(tp: Type): Type = tp match {
         case RefinedType(parent, rname, TypeAlias(alias)) =>
-          def alias1 = alias match
+          if rname == name then alias match
             case alias: LazyRef => alias.ref
             case _ => alias
-          if (rname == name) alias1 else recur(parent)
+          else recur(parent)
         case _ =>
           NoType
       }

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

@@ -2571,22 +2571,31 @@ object Types {
   case class LazyRef(private var refFn: Context => Type, reportCycles: Boolean = false) extends UncachedProxyType with ValueType {
     private var myRef: Type = null
     private var computed = false
-    def ref(implicit ctx: Context): Type = {
-      if (computed) {
-        if (myRef == null) {
+
+    def ref(implicit ctx: Context): Type =
+      if computed then
+        if myRef == null then
           // if errors were reported previously handle this by throwing a CyclicReference
           // instead of crashing immediately. A test case is neg/i6057.scala.
           assert(reportCycles || ctx.reporter.errorsReported)
           throw CyclicReference(NoDenotation)
-        }
-      }
-      else {
+      else
         computed = true
-        myRef = refFn(ctx)
+        val result = refFn(ctx)
         refFn = null
-      }
+        if result != null then myRef = result
+        else assert(myRef != null)  // must have been `update`d
       myRef
-    }
+
+    /** Update the value of the lazyref, discarding the compute function `refFn`
+     *  Can be called only as long as the ref is still undefined.
+     */
+    def update(tp: Type) =
+      assert(myRef == null)
+      myRef = tp
+      computed = true
+      refFn = null
+
     def evaluating: Boolean = computed && myRef == null
     def completed: Boolean = myRef != null
     override def underlying(implicit ctx: Context): Type = ref
@@ -4309,6 +4318,37 @@ object Types {
       if ((prefix eq this.prefix) && (classParents eq this.classParents) && (decls eq this.decls) && (selfInfo eq this.selfInfo)) this
       else newLikeThis(prefix, classParents, decls, selfInfo)
 
+    /** If this class has opqque type alias members, a new class info
+     *  with their aliases added as refinements to the self type of the class.
+     *  Otherwise, this classInfo.
+     *  If there are opaque alias members, updates `cls` to have `Opaque` flag as a side effect.
+     */
+    def integrateOpaqueMembers(given Context): ClassInfo =
+      decls.toList.foldLeft(this) { (cinfo, sym) =>
+        if sym.isOpaqueAlias then
+          cls.setFlag(Opaque)
+          def force =
+            if sym.isOpaqueAlias then // could have been reset because of a syntax error
+              sym.infoOrCompleter match
+                case completer: LazyType =>
+                  completer.complete(sym) // will update the LazyRef
+                  null                    // tells the LazyRef to use the updated value
+                case info => // can occur under cyclic references, e.g. i6225.scala
+                  defn.AnyType
+            else defn.AnyType         // dummy type in case of errors
+          def refineSelfType(selfType: Type) =
+            RefinedType(selfType, sym.name,
+              TypeAlias(LazyRef(_ => force, reportCycles = true)))
+          cinfo.selfInfo match
+            case self: Type =>
+              cinfo.derivedClassInfo(
+                selfInfo = refineSelfType(self.orElse(defn.AnyType)))
+            case self: Symbol =>
+              self.info = refineSelfType(self.info)
+              cinfo
+        else cinfo
+      }
+
     override def computeHash(bs: Binders): Int = doHash(bs, cls, prefix)
     override def hashIsStable: Boolean = prefix.hashIsStable && classParents.hashIsStable
 

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

@@ -403,7 +403,8 @@ class Namer { typer: Typer =>
                 flags |= HigherKinded
                 analyzeRHS(body)
               case _ =>
-            if tree.rhs.isEmpty then flags |= Deferred else analyzeRHS(tree.rhs)
+                if rhs.isEmpty || flags.is(Opaque) then flags |= Deferred
+            analyzeRHS(tree.rhs)
 
         // to complete a constructor, move one context further out -- this
         // is the context enclosing the class. Note that the context in which a
@@ -416,13 +417,9 @@ class Namer { typer: Typer =>
         // have no implementation.
         val cctx = if (tree.name == nme.CONSTRUCTOR && !flags.is(JavaDefined)) ctx.outer else ctx
 
-        val completer = tree match {
-          case tree: TypeDef =>
-            if (flags.is(Opaque) && ctx.owner.isClass) ctx.owner.setFlag(Opaque)
-            new TypeDefCompleter(tree)(cctx)
-          case _ =>
-            new Completer(tree)(cctx)
-        }
+        val completer = tree match
+          case tree: TypeDef => TypeDefCompleter(tree)(cctx)
+          case _ => Completer(tree)(cctx)
         val info = adjustIfModule(completer, tree)
         createOrRefine[Symbol](tree, name, flags, ctx.owner, _ => info,
           (fs, _, pwithin) => ctx.newSymbol(ctx.owner, name, fs, info, pwithin, tree.nameSpan))
@@ -939,7 +936,8 @@ class Namer { typer: Typer =>
     }
   }
 
-  class TypeDefCompleter(original: TypeDef)(ictx: Context) extends Completer(original)(ictx) with TypeParamsCompleter {
+  class TypeDefCompleter(original: TypeDef)(ictx: Context)
+  extends Completer(original)(ictx) with TypeParamsCompleter {
     private var myTypeParams: List[TypeSymbol] = null
     private var nestedCtx: Context = null
     assert(!original.isClassDef)
@@ -966,8 +964,61 @@ class Namer { typer: Typer =>
       myTypeParams
     end completerTypeParams
 
-    override protected def typeSig(sym: Symbol): Type =
-      typeDefSig(original, sym, completerTypeParams(sym)(ictx))(nestedCtx)
+    override final def typeSig(sym: Symbol): Type =
+      val tparamSyms = completerTypeParams(sym)(ictx)
+      given ctx as Context = nestedCtx
+      def abstracted(tp: TypeBounds): TypeBounds = HKTypeLambda.boundsFromParams(tparamSyms, tp)
+      val dummyInfo1 = abstracted(TypeBounds.empty)
+      sym.info = dummyInfo1
+      sym.setFlag(Provisional)
+        // Temporarily set info of defined type T to ` >: Nothing <: Any.
+        // This is done to avoid cyclic reference errors for F-bounds.
+        // This is subtle: `sym` has now an empty TypeBounds, but is not automatically
+        // made an abstract type. If it had been made an abstract type, it would count as an
+        // abstract type of its enclosing class, which might make that class an invalid
+        // prefix. I verified this would lead to an error when compiling io.ClassPath.
+        // A distilled version is in pos/prefix.scala.
+        //
+        // The scheme critically relies on an implementation detail of isRef, which
+        // inspects a TypeRef's info, instead of simply dealiasing alias types.
+
+      val isDerived = original.rhs.isInstanceOf[untpd.DerivedTypeTree]
+      val rhs = original.rhs match {
+        case LambdaTypeTree(_, body) => body
+        case rhs => rhs
+      }
+
+      // For match types: approximate with upper bound while evaluating the rhs.
+      val dummyInfo2 = rhs match {
+        case MatchTypeTree(bound, _, _) if !bound.isEmpty =>
+          abstracted(TypeBounds.upper(typedAheadType(bound).tpe))
+        case _ =>
+          dummyInfo1
+      }
+      sym.info = dummyInfo2
+
+      val rhsBodyType: TypeBounds = typedAheadType(rhs).tpe.toBounds
+      val unsafeInfo = if (isDerived) rhsBodyType else abstracted(rhsBodyType)
+      if (isDerived) sym.info = unsafeInfo
+      else {
+        sym.info = NoCompleter
+        sym.info = sym.opaqueToBounds(checkNonCyclic(sym, unsafeInfo, reportErrors = true))
+      }
+      if !Config.newScheme then sym.normalizeOpaque()
+      else if sym.isOpaqueAlias then sym.typeRef.recomputeDenot() // make sure we see the new bounds from now on
+      sym.resetFlag(Provisional)
+
+      // Here we pay the price for the cavalier setting info to TypeBounds.empty above.
+      // We need to compensate by reloading the denotation of references that might
+      // still contain the TypeBounds.empty. If we do not do this, stdlib factories
+      // fail with a bounds error in PostTyper.
+      def ensureUpToDate(tref: TypeRef, outdated: Type) =
+        if (tref.info == outdated && sym.info != outdated) tref.recomputeDenot()
+      ensureUpToDate(sym.typeRef, dummyInfo1)
+      if (dummyInfo2 `ne` dummyInfo1) ensureUpToDate(sym.typeRef, dummyInfo2)
+
+      sym.info
+    end typeSig
   }
 
   class ClassCompleter(cls: ClassSymbol, original: TypeDef)(ictx: Context) extends Completer(original)(ictx) {
@@ -1130,14 +1181,16 @@ class Namer { typer: Typer =>
 
       index(constr)
       index(rest)(localCtx)
+
       symbolOfTree(constr).info.stripPoly match // Completes constr symbol as a side effect
         case mt: MethodType if cls.is(Case) && mt.isParamDependent =>
           // See issue #8073 for background
           ctx.error(
               i"""Implementation restriction: case classes cannot have dependencies between parameters""",
               cls.sourcePos)
         case _ =>
-      tempInfo = denot.info.asInstanceOf[TempClassInfo]
+
+      tempInfo = denot.asClass.classInfo.integrateOpaqueMembers.asInstanceOf[TempClassInfo]
       denot.info = savedInfo
       tempInfo
     }
@@ -1502,57 +1555,4 @@ class Namer { typer: Typer =>
     }
     else valOrDefDefSig(ddef, sym, typeParams, termParamss, wrapMethType)
   }
-
-  def typeDefSig(tdef: TypeDef, sym: Symbol, tparamSyms: List[TypeSymbol])(implicit ctx: Context): Type = {
-    def abstracted(tp: TypeBounds): TypeBounds = HKTypeLambda.boundsFromParams(tparamSyms, tp)
-    val dummyInfo1 = abstracted(TypeBounds.empty)
-    sym.info = dummyInfo1
-    sym.setFlag(Provisional)
-      // Temporarily set info of defined type T to ` >: Nothing <: Any.
-      // This is done to avoid cyclic reference errors for F-bounds.
-      // This is subtle: `sym` has now an empty TypeBounds, but is not automatically
-      // made an abstract type. If it had been made an abstract type, it would count as an
-      // abstract type of its enclosing class, which might make that class an invalid
-      // prefix. I verified this would lead to an error when compiling io.ClassPath.
-      // A distilled version is in pos/prefix.scala.
-      //
-      // The scheme critically relies on an implementation detail of isRef, which
-      // inspects a TypeRef's info, instead of simply dealiasing alias types.
-
-    val isDerived = tdef.rhs.isInstanceOf[untpd.DerivedTypeTree]
-    val rhs = tdef.rhs match {
-      case LambdaTypeTree(_, body) => body
-      case rhs => rhs
-    }
-
-    // For match types: approximate with upper bound while evaluating the rhs.
-    val dummyInfo2 = rhs match {
-      case MatchTypeTree(bound, _, _) if !bound.isEmpty =>
-        abstracted(TypeBounds.upper(typedAheadType(bound).tpe))
-      case _ =>
-        dummyInfo1
-    }
-    sym.info = dummyInfo2
-
-    val rhsBodyType: TypeBounds = typedAheadType(rhs).tpe.toBounds
-    val unsafeInfo = if (isDerived) rhsBodyType else abstracted(rhsBodyType)
-    if (isDerived) sym.info = unsafeInfo
-    else {
-      sym.info = NoCompleter
-      sym.info = checkNonCyclic(sym, unsafeInfo, reportErrors = true)
-    }
-    sym.normalizeOpaque()
-    sym.resetFlag(Provisional)
-
-    // Here we pay the price for the cavalier setting info to TypeBounds.empty above.
-    // We need to compensate by reloading the denotation of references that might
-    // still contain the TypeBounds.empty. If we do not do this, stdlib factories
-    // fail with a bounds error in PostTyper.
-    def ensureUpToDate(tref: TypeRef, outdated: Type) =
-      if (tref.info == outdated && sym.info != outdated) tref.recomputeDenot()
-    ensureUpToDate(sym.typeRef, dummyInfo1)
-    if (dummyInfo2 `ne` dummyInfo1) ensureUpToDate(sym.typeRef, dummyInfo2)
-
-    sym.info
-  }
 }

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

@@ -1832,6 +1832,23 @@ class Typer extends Namer
         ctx.featureWarning(nme.dynamics.toString, "extension of type scala.Dynamic", cls, isRequired, cdef.sourcePos)
       }
 
+      // TODO: Drop or use
+      def simplifyOpaques(tp: Type): Type = tp match
+        case tp @ RefinedType(parent, name, alias @ TypeAlias(lzy: LazyRef)) =>
+          tp.derivedRefinedType(simplifyOpaques(parent), name,
+            alias.derivedAlias(lzy.ref))
+        case _ =>
+          tp
+
+      if false && cls.containsOpaques then
+        val cinfo = cls.classInfo
+        cinfo.selfInfo match
+          case self: Type =>
+            cls.info = cinfo.derivedClassInfo(selfInfo = simplifyOpaques(self))
+          case self: Symbol =>
+            self.info = simplifyOpaques(self.info)
+        //println(i"simplified: $cls with ${cls.classInfo.selfInfo}")
+
       checkNonCyclicInherited(cls.thisType, cls.classParents, cls.info.decls, cdef.posd)
 
       // check value class constraints

tests/neg/i6225.scala

@@ -11,7 +11,7 @@ object O2 {
 }
 
 object O3 {
-  opaque type R[X] = R[X]   // error
+  opaque type R[X] = R[X]   // error: R does not take parameters // error: cyclic
 }
 
 object O4{
@@ -20,4 +20,4 @@ object O4{
 
 object O5{
   opaque type T[X] = Nothing
-}
+}