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

@@ -1089,9 +1089,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
@@ -1105,7 +1105,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 =
@@ -642,6 +648,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)
 
@@ -678,15 +687,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:
@@ -832,10 +858,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 _ =>
@@ -956,6 +984,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 =
@@ -970,6 +1002,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
@@ -1019,6 +1058,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
@@ -1652,15 +1709,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))
@@ -1674,10 +1732,8 @@ object SymDenotations {
                 case _ =>
                   val superTp = tp.superType
                   val baseTp = recur(superTp)
-                  if (inCache(superTp) && tp.symbol.maybeOwner.isType)
-                    record(tp, baseTp)   // typeref cannot be a GADT, so cache is stable
-                  else
-                    btrCache.remove(tp)
+                  if (inCache(superTp) && tpSym.maybeOwner.isType) record(tp, baseTp)
+                  else btrCache.remove(tp)
                   baseTp
               }
             }

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

@@ -3861,7 +3861,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

@@ -807,6 +807,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))