Desugaring and basic infrastructure for opaque types

Desugaring, entering in Namer, and basic navigation operations
for opaque types. Establishes opaque companions.

Author: odersky

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

@@ -674,6 +674,46 @@ 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 (tdef.rhs.isInstanceOf[TypeBoundsTree]) {
+      ctx.error(em"opaque type ${tdef.name} must be an alias type", tdef.pos)
+      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 aliasType = cpy.TypeDef(tdef)(
+        rhs = completeForwarder(Select(Ident(moduleName), tdef.name)))
+      val localType = tdef.withFlags(Synthetic | Opaque)
+      val companions = moduleDef(ModuleDef(
+        moduleName, Template(emptyConstructor, Nil, EmptyValDef, localType :: Nil))
+          .withFlags(Synthetic | Opaque))
+      Thicket(aliasType :: companions.toList)
+    }
+
   /** The name of `mdef`, after checking that it does not redefine a Scala core class.
    *  If it does redefine, issue an error and return a mangled name instead of the original one.
    */
@@ -769,7 +809,10 @@ object desugar {
 
   def defTree(tree: Tree)(implicit ctx: Context): Tree = tree match {
     case tree: ValDef => valDef(tree)
-    case tree: TypeDef => if (tree.isClassDef) classDef(tree) else tree
+    case tree: TypeDef =>
+      if (tree.isClassDef) classDef(tree)
+      else if (tree.mods.is(Opaque, butNot = Synthetic)) opaqueAlias(tree)
+      else tree
     case tree: DefDef =>
       if (tree.name.isConstructorName) tree // was already handled by enclosing classDef
       else defDef(tree)

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

@@ -350,7 +350,8 @@ object Trees {
       asInstanceOf[ThisTree[Untyped]]
     }
 
-    protected def setMods(mods: untpd.Modifiers): Unit = myMods = mods
+    /** Destructively update modifiers. To be used with care. */
+    def setMods(mods: untpd.Modifiers): Unit = myMods = mods
 
     /** The position of the name defined by this definition.
      *  This is a point position if the definition is synthetic, or a range position

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

@@ -1102,9 +1102,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   private val InlinedCalls = new Property.Key[List[Tree]]
 
   /** Record an enclosing inlined call.
-    * EmptyTree calls (for parameters) cancel the next-enclosing call in the list instead of being added to it.
-    * We assume parameters are never nested inside parameters.
-    */
+   *  EmptyTree calls (for parameters) cancel the next-enclosing call in the list instead of being added to it.
+   *  We assume parameters are never nested inside parameters.
+   */
   override def inlineContext(call: Tree)(implicit ctx: Context): Context = {
     // We assume enclosingInlineds is already normalized, and only process the new call with the head.
     val oldIC = enclosingInlineds
@@ -1118,7 +1118,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   }
 
   /** All enclosing calls that are currently inlined, from innermost to outermost.
-    */
+   */
   def enclosingInlineds(implicit ctx: Context): List[Tree] =
     ctx.property(InlinedCalls).getOrElse(Nil)
 

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

@@ -526,7 +526,13 @@ object Flags {
     Accessor | AbsOverride | Stable | Captured | Synchronized | Erased
 
   /** Flags that can apply to a module class */
-  final val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | ImplClass | Enum
+  final val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags |
+    ImplClass | 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
 
   /** Packages and package classes always have these flags set */
   final val PackageCreationFlags: FlagSet =
@@ -639,6 +645,9 @@ 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)
 
@@ -675,15 +684,18 @@ object Flags {
   /** Java symbol which is `protected` and `static` */
   final val StaticProtected: FlagConjunction = allOf(JavaDefined, Protected, JavaStatic)
 
+  final val Scala2Trait: FlagConjunction = allOf(Scala2x, Trait)
+
   final val AbstractFinal: FlagConjunction = allOf(Abstract, Final)
   final val AbstractSealed: FlagConjunction = allOf(Abstract, Sealed)
+  final val AbstractAndOverride: FlagConjunction = allOf(Abstract, Override)
+
   final val SyntheticArtifact: FlagConjunction = allOf(Synthetic, Artifact)
   final val SyntheticModule: FlagConjunction = allOf(Synthetic, Module)
   final val SyntheticTermParam: FlagConjunction = allOf(Synthetic, TermParam)
   final val SyntheticTypeParam: FlagConjunction = allOf(Synthetic, TypeParam)
   final val SyntheticCase: FlagConjunction = allOf(Synthetic, Case)
-  final val AbstractAndOverride: FlagConjunction = allOf(Abstract, Override)
-  final val Scala2Trait: FlagConjunction = allOf(Scala2x, Trait)
+  final val SyntheticOpaque: FlagConjunction = allOf(Synthetic, Opaque)
 
   implicit def conjToFlagSet(conj: FlagConjunction): FlagSet =
     FlagSet(conj.bits)

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

@@ -365,6 +365,23 @@ object SymDenotations {
       case _ => unforcedDecls.openForMutations
     }
 
+    /** If this is a synthetic opaque type alias, mark it as Deferred with empty bounds
+     */
+    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) {
+        info match {
+          case TypeAlias(alias) =>
+            info = TypeBounds(defn.NothingType, abstractRHS(alias))
+            setFlag(Deferred)
+          case _ =>
+        }
+      }
+    }
+
     // ------ Names ----------------------------------------------
 
     /** The expanded name of this denotation. */
@@ -517,10 +534,19 @@ object SymDenotations {
     /** Is this symbol an abstract type or type parameter? */
     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)
+
+    /** Is this symbol the companion of an opaque alias type? */
+    def isOpaqueCompanion(implicit ctx: Context): Boolean = is(OpaqueModule)
+
+    /** 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
+    final def canHaveCompanion(implicit ctx: Context) = isClass || isOpaqueAlias
 
     /** Is this the denotation of a self symbol of some class?
      *  This is the case if one of two conditions holds:
@@ -830,10 +856,12 @@ object SymDenotations {
     /** The module implemented by this module class, NoSymbol if not applicable. */
     final def sourceModule(implicit ctx: Context): Symbol = myInfo match {
       case ClassInfo(_, _, _, _, selfType) if this is ModuleClass =>
-        selfType match {
-          case selfType: TermRef => selfType.symbol
-          case selfType: Symbol => selfType.info.asInstanceOf[TermRef].symbol
+        def sourceOfSelf(tp: Any): Symbol = tp match {
+          case tp: TermRef => tp.symbol
+          case tp: Symbol => sourceOfSelf(tp.info)
+          case tp: RefinedType => sourceOfSelf(tp.parent)
         }
+        sourceOfSelf(selfType)
       case info: LazyType =>
         info.sourceModule
       case _ =>
@@ -954,6 +982,10 @@ object SymDenotations {
      */
     final def companionModule(implicit ctx: Context): Symbol =
       if (is(Module)) sourceModule
+      else if (isOpaqueAlias)
+        info match {
+          case TypeAlias(TypeRef(TermRef(prefix, _), _)) => prefix.termSymbol
+        }
       else registeredCompanion.sourceModule
 
     private def companionType(implicit ctx: Context): Symbol =
@@ -968,6 +1000,13 @@ 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
@@ -1017,6 +1056,24 @@ 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
+     *  containing object.
+     */
+    def opaqueAlias(implicit ctx: Context): Type = {
+      if (isOpaqueHelper) {
+        owner.asClass.classInfo.selfType match {
+          case RefinedType(_, _, TypeBounds(lo, _)) =>
+            def extractAlias(tp: Type): Type = tp match {
+              case OrType(alias, _) => alias
+              case HKTypeLambda(tparams, tp) =>
+                HKTypeLambda(tparams.map(_.paramInfo), extractAlias(tp))
+            }
+            extractAlias(lo)
+        }
+      }
+      else NoType
+    }
+
     /** The non-private symbol whose name and type matches the type of this symbol
      *  in the given class.
      *  @param inClass   The class containing the result symbol's definition
@@ -1653,15 +1710,16 @@ object SymDenotations {
 
             def computeTypeRef = {
               btrCache.put(tp, NoPrefix)
-              tp.symbol.denot match {
+              val tpSym = tp.symbol
+              tpSym.denot match {
                 case clsd: ClassDenotation =>
                   def isOwnThis = prefix match {
                     case prefix: ThisType => prefix.cls `eq` clsd.owner
                     case NoPrefix => true
                     case _ => false
                   }
                   val baseTp =
-                    if (tp.symbol eq symbol)
+                    if (tpSym eq symbol)
                       tp
                     else if (isOwnThis)
                       if (clsd.baseClassSet.contains(symbol))

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

@@ -3870,7 +3870,7 @@ object Types {
   extends CachedClassInfo(prefix, cls, Nil, decls, selfInfo) {
 
     /** Install classinfo with known parents in `denot` s */
-    def finalize(denot: SymDenotation, parents: List[Type])(implicit ctx: Context): Unit =
+    def finalize(denot: SymDenotation, parents: List[Type], selfInfo: TypeOrSymbol)(implicit ctx: Context): Unit =
       denot.info = ClassInfo(prefix, cls, parents, decls, selfInfo)
 
     override def derivedClassInfo(prefix: Type)(implicit ctx: Context): ClassInfo =

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

@@ -813,6 +813,7 @@ class TreeUnpickler(reader: TastyReader,
               case _ => rhs.tpe.toBounds
             }
             sym.resetFlag(Provisional)
+            sym.normalizeOpaque()
             TypeDef(rhs)
           }
         case PARAM =>

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -128,7 +128,7 @@ object Scala2Unpickler {
     else
       registerCompanionPair(scalacCompanion, denot.classSymbol)
 
-    tempInfo.finalize(denot, normalizedParents) // install final info, except possibly for typeparams ordering
+    tempInfo.finalize(denot, normalizedParents, ost) // install final info, except possibly for typeparams ordering
     denot.ensureTypeParamsInCorrectOrder()
   }
 }

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

@@ -412,6 +412,7 @@ object Checking {
     checkNoConflict(Lazy, ParamAccessor, s"parameter may not be `lazy`")
     if (sym.is(Inline)) checkApplicable(Inline, sym.isTerm && !sym.is(Mutable | Module))
     if (sym.is(Lazy)) checkApplicable(Lazy, !sym.is(Method | Mutable))
+    if (sym.is(Opaque, butNot = (Synthetic | Module))) checkApplicable(Opaque, sym.isAliasType)
     if (sym.isType && !sym.is(Deferred))
       for (cls <- sym.allOverriddenSymbols.filter(_.isClass)) {
         fail(CannotHaveSameNameAs(sym, cls, CannotHaveSameNameAs.CannotBeOverridden))

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

@@ -502,7 +502,6 @@ class Namer { typer: Typer =>
     case _ =>
   }
 
-
   def setDocstring(sym: Symbol, tree: Tree)(implicit ctx: Context): Unit = tree match {
     case t: MemberDef if t.rawComment.isDefined =>
       ctx.docCtx.foreach(_.addDocstring(sym, t.rawComment))
@@ -558,6 +557,7 @@ class Namer { typer: Typer =>
       if (fromCls.mods.is(Synthetic) && !toCls.mods.is(Synthetic)) {
         removeInExpanded(fromStat, fromCls)
         val mcls = mergeModuleClass(toStat, toCls, fromCls.rhs.asInstanceOf[Template].body)
+        mcls.setMods(toCls.mods | (fromCls.mods.flags & RetainedSyntheticCompanionFlags))
         moduleClsDef(fromCls.name) = (toStat, mcls)
       }
 
@@ -617,12 +617,11 @@ class Namer { typer: Typer =>
       val classDef  = mutable.Map[TypeName, TypeDef]()
       val moduleDef = mutable.Map[TypeName, TypeDef]()
 
-      def updateCache(cdef: TypeDef): Unit = {
-        if (!cdef.isClassDef || cdef.mods.is(Package)) return
-
-        if (cdef.mods.is(ModuleClass)) moduleDef(cdef.name) = cdef
-        else classDef(cdef.name) = cdef
-      }
+      def updateCache(cdef: TypeDef): Unit =
+        if (cdef.isClassDef && !cdef.mods.is(Package) || cdef.mods.is(Opaque, butNot = Synthetic)) {
+          if (cdef.mods.is(ModuleClass)) moduleDef(cdef.name) = cdef
+          else classDef(cdef.name) = cdef
+        }
 
       for (stat <- stats)
         expanded(stat) match {
@@ -909,7 +908,7 @@ class Namer { typer: Typer =>
 
       addAnnotations(denot.symbol)
 
-      val selfInfo =
+      val selfInfo: TypeOrSymbol =
         if (self.isEmpty) NoType
         else if (cls.is(Module)) {
           val moduleType = cls.owner.thisType select sourceModule
@@ -937,7 +936,35 @@ class Namer { typer: Typer =>
         ensureFirstIsClass(parents.map(checkedParentType(_)), cls.pos))
       typr.println(i"completing $denot, parents = $parents%, %, parentTypes = $parentTypes%, %")
 
-      tempInfo.finalize(denot, parentTypes)
+      val finalSelfInfo: TypeOrSymbol =
+        if (cls.isOpaqueCompanion) {
+          // The self type of an opaque companion is refined with the type-alias of the original opaque type
+          def refineOpaqueCompanionSelfType(mt: Type, stats: List[Tree]): RefinedType = (stats: @unchecked) match {
+            case (td @ TypeDef(localName, rhs)) :: _
+            if td.mods.is(SyntheticOpaque) && localName == name.stripModuleClassSuffix =>
+              // create a context owned by the current opaque helper symbol,
+              // but otherwise corresponding to the context enclosing the opaque
+              // companion object, since that's where the rhs was defined.
+              val aliasCtx = ctx.outer.fresh.setOwner(symbolOfTree(td))
+              val alias = typedAheadType(rhs)(aliasCtx).tpe
+              val original = cls.companionOpaqueType.typeRef
+              val cmp = ctx.typeComparer
+              val bounds = TypeBounds(cmp.orType(alias, original), cmp.andType(alias, original))
+              RefinedType(mt, localName, bounds)
+            case _ :: stats1 =>
+              refineOpaqueCompanionSelfType(mt, stats1)
+          }
+          selfInfo match {
+            case self: Type =>
+              refineOpaqueCompanionSelfType(self, rest)
+            case self: Symbol =>
+              self.info = refineOpaqueCompanionSelfType(self.info, rest)
+              self
+          }
+        }
+        else selfInfo
+
+      tempInfo.finalize(denot, parentTypes, finalSelfInfo)
 
       Checking.checkWellFormed(cls)
       if (isDerivedValueClass(cls)) cls.setFlag(Final)
@@ -1236,6 +1263,7 @@ class Namer { typer: Typer =>
         tref.recomputeDenot()
       case _ =>
     }
+    sym.normalizeOpaque()
     ensureUpToDate(sym.typeRef, dummyInfo)
     ensureUpToDate(sym.typeRef.appliedTo(tparamSyms.map(_.typeRef)), TypeBounds.empty)
     sym.info