Change opaque scope

The scope where an opaque alias is transparent is now the enclosing
class of the opaque definition. The notion of opaque companion object
has been dropped.

Author: odersky

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

@@ -817,48 +817,6 @@ object desugar {
     }
   }
 
-  /** Expand
-   *
-   *    <mods> opaque type T = [Xs] =>> R
-   *
-   *  to
-   *
-   *    <mods> opaque type T = T.T
-   *    synthetic object T {
-   *      synthetic opaque type T >: [Xs] =>> R
-   *    }
-   *
-   *  The generated companion object will later (in Namer) be merged with the user-defined
-   *  companion object, and the synthetic opaque type member will go into the self type.
-   */
-  def opaqueAlias(tdef: TypeDef)(implicit ctx: Context): Tree =
-    if (lacksDefinition(tdef)) {
-      ctx.error(em"opaque type ${tdef.name} must be an alias type", tdef.sourcePos)
-      tdef.withFlags(tdef.mods.flags &~ Opaque)
-    }
-    else {
-      def completeForwarder(fwd: Tree) = tdef.rhs match {
-        case LambdaTypeTree(tparams, tpt) =>
-          val tparams1 =
-            for (tparam <- tparams)
-            yield tparam.withMods(tparam.mods | Synthetic)
-          lambdaAbstract(tparams1,
-            AppliedTypeTree(fwd, tparams.map(tparam => Ident(tparam.name))))
-        case _ =>
-          fwd
-      }
-      val moduleName = tdef.name.toTermName
-      val localRef = Select(Ident(moduleName), tdef.name)
-      localRef.pushAttachment(SuppressAccessCheck, ())
-      val aliasType = cpy.TypeDef(tdef)(rhs = completeForwarder(localRef)).withSpan(tdef.span.startPos)
-      val localType = tdef.withMods(Modifiers(Synthetic | Opaque).withPrivateWithin(tdef.name))
-
-      val companions = moduleDef(ModuleDef(
-        moduleName, Template(emptyConstructor, Nil, Nil, EmptyValDef, localType :: Nil))
-          .withFlags(Synthetic | Opaque))
-      Thicket(aliasType :: companions.toList)
-    }
-
   /** The normalized name of `mdef`. This means
    *   1. Check that the name does not redefine a Scala core class.
    *      If it does redefine, issue an error and return a mangled name instead of the original one.

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

@@ -194,6 +194,11 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       if (this.flags == flags) this
       else copy(flags = flags)
 
+    def withoutFlags(flags: FlagSet): Modifiers =
+      if (this.is(flags))
+        Modifiers(this.flags &~ flags, this.privateWithin, this.annotations, this.mods.filterNot(_.flags.is(flags)))
+      else this
+
     def withAddedMod(mod: Mod): Modifiers =
       if (mods.exists(_ eq mod)) this
       else withMods(mods :+ mod)

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

@@ -145,25 +145,16 @@ class CheckRealizable(implicit ctx: Context) {
    */
   private def boundsRealizability(tp: Type) = {
 
-    def isOpaqueCompanionThis = tp match {
-      case tp: ThisType => tp.cls.isOpaqueCompanion
-      case _ => false
-    }
-
     val memberProblems =
-      for {
-        mbr <- tp.nonClassTypeMembers
-        if !(mbr.info.loBound <:< mbr.info.hiBound) && !mbr.symbol.isOpaqueHelper
-      }
+      for mbr <- tp.nonClassTypeMembers if !(mbr.info.loBound <:< mbr.info.hiBound)
       yield new HasProblemBounds(mbr.name, mbr.info)
 
     val refinementProblems =
-      for {
+      for
         name <- refinedNames(tp)
         if (name.isTypeName)
         mbr <- tp.member(name).alternatives
-        if !(mbr.info.loBound <:< mbr.info.hiBound) && !isOpaqueCompanionThis
-      }
+        if !(mbr.info.loBound <:< mbr.info.hiBound)
       yield new HasProblemBounds(name, mbr.info)
 
     def baseTypeProblems(base: Type) = base match {

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

@@ -265,7 +265,7 @@ object Flags {
   /** A mutable var */
   final val Mutable: FlagSet = termFlag(12, "mutable")
 
-  /** An opqaue type */
+  /** An opaque type or a class containing one */
   final val Opaque: FlagSet = typeFlag(12, "opaque")
 
   final val MutableOrOpaque: FlagSet = Mutable.toCommonFlags
@@ -547,13 +547,7 @@ object Flags {
     Accessor | AbsOverride | StableRealizable | Captured | Synchronized | Erased
 
   /** Flags that can apply to a module class */
-  final val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags |
-    Enum | Opaque
-
-  /** Flags that are copied from a synthetic companion to a user-defined one
-   *  when the two are merged. See: Namer.mergeCompanionDefs
-   */
-  final val RetainedSyntheticCompanionFlags: FlagSet = Opaque
+  final val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | Enum
 
   /** Packages and package classes always have these flags set */
   final val PackageCreationFlags: FlagSet =
@@ -678,9 +672,6 @@ object Flags {
   /** A Java companion object */
   final val JavaModule: FlagConjunction = allOf(JavaDefined, Module)
 
-  /** An opaque companion object */
-  final val OpaqueModule: FlagConjunction = allOf(Opaque, Module)
-
   /** A Java companion object */
   final val JavaProtected: FlagConjunction = allOf(JavaDefined, Protected)
 
@@ -730,7 +721,6 @@ object Flags {
   final val SyntheticTermParam: FlagConjunction = allOf(Synthetic, TermParam)
   final val SyntheticTypeParam: FlagConjunction = allOf(Synthetic, TypeParam)
   final val SyntheticCase: FlagConjunction = allOf(Synthetic, Case)
-  final val SyntheticOpaque: FlagConjunction = allOf(Synthetic, Opaque)
 
   implicit def conjToFlagSet(conj: FlagConjunction): FlagSet =
     FlagSet(conj.bits)

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

@@ -370,17 +370,30 @@ object SymDenotations {
       case _ => unforcedDecls.openForMutations
     }
 
-    /** If this is a synthetic opaque type alias, mark it as Deferred with empty bounds
+    /** If this is a synthetic opaque type alias, mark it as Deferred with empty bounds.
+     *  At the same time, integrate the original alias as a refinement of the
+     *  self type of the enclosing class.
      */
     final def normalizeOpaque()(implicit ctx: Context) = {
       def abstractRHS(tp: Type): Type = tp match {
         case tp: HKTypeLambda => tp.derivedLambdaType(resType = abstractRHS(tp.resType))
         case _ => defn.AnyType
       }
-      if (isOpaqueHelper) {
+      if (isOpaqueAlias) {
         info match {
           case TypeAlias(alias) =>
             info = TypeBounds(defn.NothingType, abstractRHS(alias))
+
+            def refineSelfType(selfType: Type) =
+              RefinedType(selfType, name, TypeAlias(alias))
+            val enclClassInfo = owner.asClass.classInfo
+            enclClassInfo.selfInfo match {
+              case self: Type =>
+                owner.info = enclClassInfo.derivedClassInfo(selfInfo = refineSelfType(self))
+              case self: Symbol =>
+                self.info = refineSelfType(self.info)
+            }
+
             setFlag(Deferred)
           case _ =>
         }
@@ -539,18 +552,14 @@ object SymDenotations {
     final def isAbstractOrParamType(implicit ctx: Context): Boolean = this is DeferredOrTypeParam
 
     /** Is this symbol a user-defined opaque alias type? */
-    def isOpaqueAlias(implicit ctx: Context): Boolean = is(Opaque, butNot = Synthetic)
+    def isOpaqueAlias(implicit ctx: Context): Boolean = is(Opaque) && !isClass
 
-    /** Is this symbol the companion of an opaque alias type? */
-    def isOpaqueCompanion(implicit ctx: Context): Boolean = is(OpaqueModule)
+    /** Is this symbol a module that contains of an opaque aliases? */
+    def containsOpaques(implicit ctx: Context): Boolean = is(Opaque) && isClass
 
-    /** Is this symbol a synthetic opaque type inside an opaque companion object? */
-    def isOpaqueHelper(implicit ctx: Context): Boolean = is(SyntheticOpaque, butNot = Module)
-
-    /** Can this symbol have a companion module?
-     *  This is the case if it is a class or an opaque type alias.
-     */
-    final def canHaveCompanion(implicit ctx: Context) = isClass || isOpaqueAlias
+    def seesOpaques(implicit ctx: Context): Boolean =
+      containsOpaques ||
+      is(Module, butNot = Package) && owner.containsOpaques
 
     /** Is this the denotation of a self symbol of some class?
      *  This is the case if one of two conditions holds:
@@ -775,7 +784,7 @@ object SymDenotations {
      */
     def membersNeedAsSeenFrom(pre: Type)(implicit ctx: Context): Boolean =
       !(  this.isTerm
-       || this.isStaticOwner && !this.isOpaqueCompanion
+       || this.isStaticOwner && !this.seesOpaques
        || ctx.erasedTypes
        || (pre eq NoPrefix)
        || (pre eq thisType)
@@ -1015,16 +1024,6 @@ object SymDenotations {
      */
     final def companionModule(implicit ctx: Context): Symbol =
       if (is(Module)) sourceModule
-      else if (isOpaqueAlias) {
-        def reference(tp: Type): Symbol = tp match {
-          case TypeRef(prefix: TermRef, _) => prefix.termSymbol
-          case tp: HKTypeLambda => reference(tp.resType)
-          case tp: AppliedType => reference(tp.tycon)
-          case tp: ErrorType => registeredCompanion.sourceModule
-        }
-        val TypeAlias(alias) = info
-        reference(alias)
-      }
       else registeredCompanion.sourceModule
 
     private def companionType(implicit ctx: Context): Symbol =
@@ -1039,13 +1038,6 @@ object SymDenotations {
     final def companionClass(implicit ctx: Context): Symbol =
       companionType.suchThat(_.isClass).symbol
 
-    /** The opaque type with the same (type-) name as this module or module class,
-     *  and which is also defined in the same scope and compilation unit.
-     *  NoSymbol if this type does not exist.
-     */
-    final def companionOpaqueType(implicit ctx: Context): Symbol =
-      companionType.suchThat(_.isOpaqueAlias).symbol
-
     final def scalacLinkedClass(implicit ctx: Context): Symbol =
       if (this is ModuleClass) companionNamed(effectiveName.toTypeName)
       else if (this.isClass) companionNamed(effectiveName.moduleClassName).sourceModule.moduleClass
@@ -1095,15 +1087,17 @@ object SymDenotations {
     final def enclosingSubClass(implicit ctx: Context): Symbol =
       ctx.owner.ownersIterator.findSymbol(_.isSubClass(symbol))
 
-    /** The alias of a synthetic opaque type that's stored in the self type of the
+    /** The alias of an opaque type alias that's stored in the self type of the
      *  containing object.
      */
     def opaqueAlias(implicit ctx: Context): Type = {
-      if (isOpaqueHelper)
-        owner.asClass.classInfo.selfType match {
-          case RefinedType(_, _, bounds) => bounds.extractOpaqueAlias
-        }
-      else NoType
+      def recur(tp: Type): Type = tp match {
+        case RefinedType(parent, rname, TypeAlias(alias)) =>
+          if (rname == name) alias else recur(parent)
+        case _ =>
+          NoType
+      }
+      recur(owner.asClass.classInfo.selfType)
     }
 
     /** The non-private symbol whose name and type matches the type of this symbol
@@ -1960,7 +1954,7 @@ object SymDenotations {
 
     /** Register companion class */
     override def registerCompanion(companion: Symbol)(implicit ctx: Context) =
-      if (companion.canHaveCompanion && !unforcedIsAbsent && !companion.unforcedIsAbsent)
+      if (companion.isClass && !unforcedIsAbsent && !companion.unforcedIsAbsent)
         myCompanion = companion
 
     override def registeredCompanion(implicit ctx: Context) = { ensureCompleted(); myCompanion }

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

@@ -219,7 +219,7 @@ object TypeErasure {
    *  erased to `Object` instead of `Object[]`.
    */
   def isUnboundedGeneric(tp: Type)(implicit ctx: Context): Boolean = tp.dealias match {
-    case tp: TypeRef if !tp.symbol.isOpaqueHelper =>
+    case tp: TypeRef if !tp.symbol.isOpaqueAlias =>
       !tp.symbol.isClass &&
       !classify(tp).derivesFrom(defn.ObjectClass) &&
       !tp.symbol.is(JavaDefined)
@@ -236,7 +236,7 @@ object TypeErasure {
 
   /** Is `tp` an abstract type or polymorphic type parameter, or another unbounded generic type? */
   def isGeneric(tp: Type)(implicit ctx: Context): Boolean = tp.dealias match {
-    case tp: TypeRef if !tp.symbol.isOpaqueHelper => !tp.symbol.isClass
+    case tp: TypeRef if !tp.symbol.isOpaqueAlias => !tp.symbol.isClass
     case tp: TypeParamRef => true
     case tp: TypeProxy => isGeneric(tp.translucentSuperType)
     case tp: AndType => isGeneric(tp.tp1) || isGeneric(tp.tp2)
@@ -348,7 +348,7 @@ object TypeErasure {
    *  possible instantiations?
    */
   def hasStableErasure(tp: Type)(implicit ctx: Context): Boolean = tp match {
-    case tp: TypeRef if !tp.symbol.isOpaqueHelper =>
+    case tp: TypeRef if !tp.symbol.isOpaqueAlias =>
       tp.info match {
         case TypeAlias(alias) => hasStableErasure(alias)
         case _: ClassInfo => true

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

@@ -95,7 +95,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         tp match {
           case tp: NamedType =>
             val sym = tp.symbol
-            if (sym.isStatic && !sym.maybeOwner.isOpaqueCompanion || (tp.prefix `eq` NoPrefix)) tp
+            if (sym.isStatic && !sym.maybeOwner.seesOpaques || (tp.prefix `eq` NoPrefix)) tp
             else derivedSelect(tp, atVariance(variance max 0)(this(tp.prefix)))
           case tp: ThisType =>
             toPrefix(pre, cls, tp.cls)

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

@@ -1139,18 +1139,6 @@ object Types {
     /** Like `dealiasKeepAnnots`, but keeps only refining annotations */
     final def dealiasKeepRefiningAnnots(implicit ctx: Context): Type = dealias1(keepIfRefining)
 
-    /** If this is a synthetic opaque type seen from inside the opaque companion object,
-     *  its opaque alias, otherwise the type itself.
-     */
-    final def followSyntheticOpaque(implicit ctx: Context): Type = this match {
-      case tp: TypeProxy if tp.typeSymbol.is(SyntheticOpaque) =>
-        tp.superType match {
-          case AndType(alias, _) => alias   // in this case we are inside the companion object
-          case _ => this
-        }
-      case _ => this
-    }
-
     /** The result of normalization using `tryNormalize`, or the type itself if
      *  tryNormlize yields NoType
      */
@@ -2322,7 +2310,7 @@ object Types {
     override def translucentSuperType(implicit ctx: Context) = info match {
       case TypeAlias(aliased) => aliased
       case TypeBounds(_, hi) =>
-        if (symbol.isOpaqueHelper) symbol.opaqueAlias.asSeenFrom(prefix, symbol.owner)
+        if (symbol.isOpaqueAlias) symbol.opaqueAlias.asSeenFrom(prefix, symbol.owner)
         else hi
       case _ => underlying
     }
@@ -3519,7 +3507,7 @@ object Types {
     }
 
     override def translucentSuperType(implicit ctx: Context): Type = tycon match {
-      case tycon: TypeRef if tycon.symbol.isOpaqueHelper =>
+      case tycon: TypeRef if tycon.symbol.isOpaqueAlias =>
         tycon.translucentSuperType.applyIfParameterized(args)
       case _ =>
         superType

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

@@ -420,7 +420,8 @@ class TreeUnpickler(reader: TastyReader,
       val prefix = readType()
       val res = NamedType(prefix, sym)
       prefix match {
-        case prefix: ThisType if prefix.cls eq sym.owner => res.withDenot(sym.denot)
+        case prefix: ThisType if (prefix.cls eq sym.owner) && !sym.is(Opaque) =>
+          res.withDenot(sym.denot)
           // without this precaution we get an infinite cycle when unpickling pos/extmethods.scala
           // the problem arises when a self type of a trait is a type parameter of the same trait.
         case _ => res

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

@@ -31,20 +31,21 @@ class ElimOpaque extends MiniPhase with DenotTransformer {
   def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = {
     val sym = ref.symbol
     ref match {
-      case ref: SymDenotation if sym.isOpaqueHelper =>
+      case ref: SymDenotation if sym.isOpaqueAlias =>
         ref.copySymDenotation(
           info = TypeAlias(ref.opaqueAlias),
           initFlags = ref.flags &~ (Opaque | Deferred))
-      case ref: SymDenotation if sym.isOpaqueCompanion =>
+      case ref: SymDenotation if sym.containsOpaques =>
+        def stripOpaqueRefinements(tp: Type): Type = tp match {
+          case RefinedType(parent, rname, TypeAlias(_))
+          if ref.info.decl(rname).symbol.isOpaqueAlias => stripOpaqueRefinements(parent)
+          case _ => tp
+        }
         val cinfo = sym.asClass.classInfo
-        val RefinedType(sourceRef, _, _) = cinfo.selfInfo
-        val ref1 = ref.copySymDenotation(
-          info = cinfo.derivedClassInfo(selfInfo = sourceRef),
+        val strippedSelfType = stripOpaqueRefinements(cinfo.selfType)
+        ref.copySymDenotation(
+          info = cinfo.derivedClassInfo(selfInfo = strippedSelfType),
           initFlags = ref.flags &~ Opaque)
-        ref1.registeredCompanion = NoSymbol
-        ref1
-      case _ if sym.isOpaqueHelper =>
-        ref.derivedSingleDenotation(sym, TypeAlias(ref.info.extractOpaqueAlias))
       case _ =>
         ref
     }

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

@@ -51,17 +51,5 @@ object TypeUtils {
     /** The `*:` equivalent of an instance of a Tuple class */
     def toNestedPairs(implicit ctx: Context): Type =
       TypeOps.nestedPairs(tupleElementTypes)
-
-    /** Extract opaque alias from TypeBounds type that combines it with the reference
-     *  to the opaque type itself
-     */
-    def extractOpaqueAlias(implicit ctx: Context): Type = self match {
-      case TypeBounds(lo, _) =>
-        def extractAlias(tp: Type): Type = tp match {
-          case OrType(alias, _) => alias
-          case self: HKTypeLambda => self.derivedLambdaType(resType = extractAlias(self.resType))
-        }
-        extractAlias(lo)
-    }
   }
 }