Parsing and pickling of opaque types

Author: odersky

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

@@ -122,6 +122,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Sealed() extends Mod(Flags.Sealed)
 
+    case class Opaque() extends Mod(Flags.Opaque)
+
     case class Override() extends Mod(Flags.Override)
 
     case class Abstract() extends Mod(Flags.Abstract)

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

@@ -250,9 +250,14 @@ object Flags {
 
   final val AccessorOrSealed: FlagSet = Accessor.toCommonFlags
 
- /** A mutable var */
+  /** A mutable var */
   final val Mutable: FlagSet = termFlag(12, "mutable")
 
+  /** An opqaue type */
+  final val Opaque: FlagSet = typeFlag(12, "opaque")
+
+  final val MutableOrOpaque: FlagSet = Mutable.toCommonFlags
+
   /** Symbol is local to current class (i.e. private[this] or protected[this]
    *  pre: Private or Protected are also set
    */
@@ -263,7 +268,7 @@ object Flags {
    */
   final val ParamAccessor: FlagSet = termFlag(14, "<paramaccessor>")
 
-    /** A value or class implementing a module */
+  /** A value or class implementing a module */
   final val Module: FlagSet = commonFlag(15, "module")
   final val ModuleVal: FlagSet = Module.toTermFlags
   final val ModuleClass: FlagSet = Module.toTypeFlags
@@ -439,7 +444,7 @@ object Flags {
     commonFlags(Private, Protected, Final, Case, Implicit, Override, JavaStatic)
 
   final val TypeSourceModifierFlags: FlagSet =
-    CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed
+    CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque
 
   final val TermSourceModifierFlags: FlagSet =
     CommonSourceModifierFlags.toTermFlags | Inline | AbsOverride | Lazy | Erased
@@ -459,7 +464,7 @@ object Flags {
   final val FromStartFlags: FlagSet =
     Module | Package | Deferred | Method.toCommonFlags |
     HigherKinded.toCommonFlags | Param | ParamAccessor.toCommonFlags |
-    Scala2ExistentialCommon | Mutable.toCommonFlags | Touched | JavaStatic |
+    Scala2ExistentialCommon | MutableOrOpaque | Touched | JavaStatic |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessor.toCommonFlags |
     NonMember | ImplicitCommon | Permanent | Synthetic |
     SuperAccessorOrScala2x | Inline

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

@@ -183,6 +183,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   ERASED
                   LAZY
                   OVERRIDE
+                  OPAQUE
                   INLINE
                   MACRO                               // inline method containing toplevel splices
                   INLINEPROXY                         // symbol of binding representing an inline parameter
@@ -307,7 +308,8 @@ object TastyFormat {
   final val STABLE = 32
   final val MACRO = 33
   final val ERASED = 34
-  final val PARAMsetter = 35
+  final val OPAQUE = 35
+  final val PARAMsetter = 36
 
   // Cat. 2:    tag Nat
 
@@ -462,6 +464,7 @@ object TastyFormat {
        | INLINE
        | INLINEPROXY
        | MACRO
+       | OPAQUE
        | STATIC
        | OBJECT
        | TRAIT
@@ -519,6 +522,7 @@ object TastyFormat {
     case INLINE => "INLINE"
     case INLINEPROXY => "INLINEPROXY"
     case MACRO => "MACRO"
+    case OPAQUE => "OPAQUE"
     case STATIC => "STATIC"
     case OBJECT => "OBJECT"
     case TRAIT => "TRAIT"

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

@@ -646,6 +646,7 @@ class TreePickler(pickler: TastyPickler) {
       if (flags is Trait) writeByte(TRAIT)
       if (flags is Covariant) writeByte(COVARIANT)
       if (flags is Contravariant) writeByte(CONTRAVARIANT)
+      if (flags is Opaque) writeByte(OPAQUE)
     }
   }
 

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

@@ -606,6 +606,7 @@ class TreeUnpickler(reader: TastyReader,
           case INLINE => addFlag(Inline)
           case INLINEPROXY => addFlag(InlineProxy)
           case MACRO => addFlag(Macro)
+          case OPAQUE => addFlag(Opaque)
           case STATIC => addFlag(JavaStatic)
           case OBJECT => addFlag(Module)
           case TRAIT => addFlag(Trait)

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1744,6 +1744,7 @@ object Parsers {
       case PRIVATE     => Mod.Private()
       case PROTECTED   => Mod.Protected()
       case SEALED      => Mod.Sealed()
+      case OPAQUE      => Mod.Opaque()
       case IDENTIFIER if name == nme.INLINEkw => Mod.Inline()
     }
 

compiler/src/dotty/tools/dotc/parsing/Tokens.scala

@@ -93,6 +93,7 @@ abstract class TokensCommon {
   //final val FORSOME = 61;          enter(FORSOME, "forSome") // TODO: deprecate
   //final val ENUM = 62;             enter(ENUM, "enum")
   //final val ERASED = 63;           enter(ERASED, "erased")
+  //final val OPAQUE = 64;           enter(OPAQUE, "opaque")
 
   /** special symbols */
   final val COMMA = 70;            enter(COMMA, "','")
@@ -152,7 +153,7 @@ object Tokens extends TokensCommon {
 
   final val BACKQUOTED_IDENT = 13; enter(BACKQUOTED_IDENT, "identifier", "backquoted ident")
 
-  final val identifierTokens: BitSet = BitSet(IDENTIFIER, BACKQUOTED_IDENT)
+  final val identifierTokens: TokenSet = BitSet(IDENTIFIER, BACKQUOTED_IDENT)
 
   def isIdentifier(token : Int): Boolean =
     token >= IDENTIFIER && token <= BACKQUOTED_IDENT
@@ -177,6 +178,7 @@ object Tokens extends TokensCommon {
   final val FORSOME = 61;          enter(FORSOME, "forSome") // TODO: deprecate
   final val ENUM = 62;             enter(ENUM, "enum")
   final val ERASED = 63;           enter(ERASED, "erased")
+  final val OPAQUE = 64;           enter(OPAQUE, "opaque")
 
   /** special symbols */
   final val NEWLINE = 78;          enter(NEWLINE, "end of statement", "new line")
@@ -197,52 +199,52 @@ object Tokens extends TokensCommon {
   /** XML mode */
   final val XMLSTART = 96;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
 
-  final val alphaKeywords: TokenSet = tokenRange(IF, ERASED)
+  final val alphaKeywords: TokenSet = tokenRange(IF, OPAQUE)
   final val symbolicKeywords: TokenSet = tokenRange(USCORE, VIEWBOUND)
   final val symbolicTokens: TokenSet = tokenRange(COMMA, VIEWBOUND)
-  final val keywords: BitSet = alphaKeywords | symbolicKeywords
+  final val keywords: TokenSet = alphaKeywords | symbolicKeywords
 
   final val allTokens: TokenSet = tokenRange(minToken, maxToken)
 
-  final val simpleLiteralTokens: BitSet = tokenRange(CHARLIT, STRINGLIT) | BitSet(TRUE, FALSE, SYMBOLLIT)
-  final val literalTokens: BitSet = simpleLiteralTokens | BitSet(INTERPOLATIONID, NULL)
+  final val simpleLiteralTokens: TokenSet = tokenRange(CHARLIT, STRINGLIT) | BitSet(TRUE, FALSE, SYMBOLLIT)
+  final val literalTokens: TokenSet = simpleLiteralTokens | BitSet(INTERPOLATIONID, NULL)
 
-  final val atomicExprTokens: BitSet = literalTokens | identifierTokens | BitSet(
+  final val atomicExprTokens: TokenSet = literalTokens | identifierTokens | BitSet(
     USCORE, NULL, THIS, SUPER, TRUE, FALSE, RETURN, XMLSTART)
 
-  final val canStartExpressionTokens: BitSet = atomicExprTokens | BitSet(
+  final val canStartExpressionTokens: TokenSet = atomicExprTokens | BitSet(
     LBRACE, LPAREN, QBRACE, QPAREN, IF, DO, WHILE, FOR, NEW, TRY, THROW)
 
-  final val canStartTypeTokens: BitSet = literalTokens | identifierTokens | BitSet(
+  final val canStartTypeTokens: TokenSet = literalTokens | identifierTokens | BitSet(
     THIS, SUPER, USCORE, LPAREN, AT)
 
-  final val canStartBindingTokens: BitSet = identifierTokens | BitSet(USCORE, LPAREN)
+  final val canStartBindingTokens: TokenSet = identifierTokens | BitSet(USCORE, LPAREN)
 
-  final val templateIntroTokens: BitSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
+  final val templateIntroTokens: TokenSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
 
-  final val dclIntroTokens: BitSet = BitSet(DEF, VAL, VAR, TYPE)
+  final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE)
 
-  final val defIntroTokens: BitSet = templateIntroTokens | dclIntroTokens
+  final val defIntroTokens: TokenSet = templateIntroTokens | dclIntroTokens
 
-  final val localModifierTokens: BitSet = BitSet(
-    ABSTRACT, FINAL, SEALED, IMPLICIT, LAZY, ERASED)
+  final val localModifierTokens: TokenSet = BitSet(
+    ABSTRACT, FINAL, SEALED, IMPLICIT, LAZY, ERASED, OPAQUE)
 
-  final val accessModifierTokens: BitSet = BitSet(
+  final val accessModifierTokens: TokenSet = BitSet(
     PRIVATE, PROTECTED)
 
-  final val modifierTokens: BitSet = localModifierTokens | accessModifierTokens | BitSet(
+  final val modifierTokens: TokenSet = localModifierTokens | accessModifierTokens | BitSet(
     OVERRIDE)
 
-  final val modifierTokensOrCase: BitSet = modifierTokens | BitSet(CASE)
+  final val modifierTokensOrCase: TokenSet = modifierTokens | BitSet(CASE)
 
   /** Is token only legal as start of statement (eof also included)? */
-  final val mustStartStatTokens: BitSet = defIntroTokens | modifierTokens | BitSet(IMPORT, PACKAGE)
+  final val mustStartStatTokens: TokenSet = defIntroTokens | modifierTokens | BitSet(IMPORT, PACKAGE)
 
-  final val canStartStatTokens: BitSet = canStartExpressionTokens | mustStartStatTokens | BitSet(
+  final val canStartStatTokens: TokenSet = canStartExpressionTokens | mustStartStatTokens | BitSet(
     AT, CASE)
 
-  final val canEndStatTokens: BitSet = atomicExprTokens | BitSet(
+  final val canEndStatTokens: TokenSet = atomicExprTokens | BitSet(
     TYPE, RPAREN, RBRACE, RBRACKET)
 
-  final val numericLitTokens: BitSet = BitSet(INTLIT, LONGLIT, FLOATLIT, DOUBLELIT)
+  final val numericLitTokens: TokenSet = BitSet(INTLIT, LONGLIT, FLOATLIT, DOUBLELIT)
 }

docs/docs/internals/syntax.md

@@ -291,7 +291,7 @@ LocalModifier     ::=  ‘abstract’
                     |  ‘sealed’
                     |  ‘implicit’
                     |  ‘lazy’
-                    |  ‘transparent’
+                    |  ‘opaque’
                     |  ‘inline’
                     |  ‘erased’
 AccessModifier    ::=  (‘private’ | ‘protected’) [AccessQualifier]