Introduce open modifier on classes

Author: odersky

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

@@ -182,6 +182,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Opaque()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Opaque)
 
+    case class Open()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Open)
+
     case class Override()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Override)
 
     case class Abstract()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Abstract)

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

@@ -37,7 +37,7 @@ object Flags {
       else {
         val tbits = x.bits & y.bits & KINDFLAGS
         if (tbits == 0)
-          assert(false, s"illegal flagset combination: $x and $y")
+          assert(false, s"illegal flagset combination: ${x.flagsString} and ${y.flagsString}")
         FlagSet(tbits | ((x.bits | y.bits) & ~KINDFLAGS))
       }
 
@@ -237,8 +237,8 @@ object Flags {
   /** A value or variable accessor (getter or setter) */
   val (AccessorOrSealed @ _, Accessor @ _, Sealed @ _) = newFlags(11, "<accessor>", "sealed")
 
-  /** A mutable var */
-  val (_, Mutable @ _, _) = newFlags(12, "mutable")
+  /** A mutable var, an open class */
+  val (MutableOrOpen @ __, Mutable @ _, Open @ _) = newFlags(12, "mutable", "open")
 
   /** Symbol is local to current class (i.e. private[this] or protected[this]
    *  pre: Private or Protected are also set
@@ -422,7 +422,7 @@ object Flags {
     commonFlags(Private, Protected, Final, Case, Implicit, Given, Override, JavaStatic)
 
   val TypeSourceModifierFlags: FlagSet =
-    CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque
+    CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque | Open
 
   val TermSourceModifierFlags: FlagSet =
     CommonSourceModifierFlags.toTermFlags | Inline | AbsOverride | Lazy | Erased
@@ -439,7 +439,7 @@ object Flags {
   val FromStartFlags: FlagSet = commonFlags(
     Module, Package, Deferred, Method, Case,
     HigherKinded, Param, ParamAccessor,
-    Scala2ExistentialCommon, Mutable, Opaque, Touched, JavaStatic,
+    Scala2ExistentialCommon, MutableOrOpen, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor,
     Extension, NonMember, Implicit, Given, Permanent, Synthetic,
     SuperAccessorOrScala2x, Inline, Macro)
@@ -509,6 +509,8 @@ object Flags {
   /** Flags retained in export forwarders */
   val RetainedExportFlags = Given | Implicit | Extension
 
+  val ClassOnlyFlags = Sealed | Open | Abstract.toTypeFlags
+
 // ------- Other flag sets -------------------------------------
 
   val AbstractFinal: FlagSet                 = Abstract | Final

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

@@ -506,6 +506,7 @@ object StdNames {
     val nullExpr: N             = "nullExpr"
     val ofDim: N                = "ofDim"
     val opaque: N               = "opaque"
+    val open: N                 = "open"
     val ordinal: N              = "ordinal"
     val ordinalDollar: N        = "$ordinal"
     val ordinalDollar_ : N      = "_$ordinal"

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

@@ -211,6 +211,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   EXTENSION                                                        -- An extension method
                   PARAMsetter                                                      -- The setter part `x_=` of a var parameter `x` which itself is pickled as a PARAM
                   EXPORTED                                                         -- An export forwarder
+                  OPEN                                                             -- an open class
                   Annotation
 
   Annotation    = ANNOTATION     Length tycon_Type fullAnnotation_Term             -- An annotation, given (class) type of constructor, and full application tree
@@ -332,6 +333,7 @@ object TastyFormat {
   final val GIVEN = 37
   final val PARAMsetter = 38
   final val EXPORTED = 39
+  final val OPEN = 40
 
   // Cat. 2:    tag Nat
 
@@ -460,7 +462,7 @@ object TastyFormat {
 
   /** Useful for debugging */
   def isLegalTag(tag: Int): Boolean =
-    firstSimpleTreeTag <= tag && tag <= EXPORTED ||
+    firstSimpleTreeTag <= tag && tag <= OPEN ||
     firstNatTreeTag <= tag && tag <= RENAMED ||
     firstASTTreeTag <= tag && tag <= BOUNDED ||
     firstNatASTTreeTag <= tag && tag <= NAMEDARG ||
@@ -505,6 +507,7 @@ object TastyFormat {
        | GIVEN
        | PARAMsetter
        | EXPORTED
+       | OPEN
        | ANNOTATION
        | PRIVATEqualified
        | PROTECTEDqualified => true
@@ -565,6 +568,7 @@ object TastyFormat {
     case GIVEN => "GIVEN"
     case PARAMsetter => "PARAMsetter"
     case EXPORTED => "EXPORTED"
+    case OPEN => "OPEN"
 
     case SHAREDterm => "SHAREDterm"
     case SHAREDtype => "SHAREDtype"

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

@@ -669,6 +669,7 @@ class TreePickler(pickler: TastyPickler) {
       if (flags.is(Covariant)) writeModTag(COVARIANT)
       if (flags.is(Contravariant)) writeModTag(CONTRAVARIANT)
       if (flags.is(Opaque)) writeModTag(OPAQUE)
+      if (flags.is(Open)) writeModTag(OPEN)
     }
   }
 

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

@@ -631,6 +631,7 @@ class TreeUnpickler(reader: TastyReader,
           case GIVEN => addFlag(Given)
           case PARAMsetter => addFlag(ParamAccessor)
           case EXPORTED => addFlag(Exported)
+          case OPEN => addFlag(Open)
           case PRIVATEqualified =>
             readByte()
             privateWithin = readWithin(ctx)
@@ -890,9 +891,9 @@ class TreeUnpickler(reader: TastyReader,
           untpd.ValDef(readName(), readTpt(), EmptyTree).withType(NoType)
         }
         else EmptyValDef
+      cls.setNoInitsFlags(parentsKind(parents), bodyFlags)
       cls.info = ClassInfo(cls.owner.thisType, cls, parentTypes, cls.unforcedDecls,
         if (self.isEmpty) NoType else self.tpt.tpe)
-      cls.setNoInitsFlags(parentsKind(parents), bodyFlags)
       val constr = readIndexedDef().asInstanceOf[DefDef]
       val mappedParents = parents.map(_.changeOwner(localDummy, constr.symbol))
 

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

@@ -2590,6 +2590,7 @@ object Parsers {
         name match {
           case nme.inline => Mod.Inline()
           case nme.opaque => Mod.Opaque()
+          case nme.open => Mod.Open()
         }
     }
 
@@ -2661,7 +2662,7 @@ object Parsers {
      *                  |  AccessModifier
      *                  |  override
      *                  |  opaque
-     *  LocalModifier  ::= abstract | final | sealed | implicit | lazy | erased | inline
+     *  LocalModifier  ::= abstract | final | sealed | open | implicit | lazy | erased | inline
      */
     def modifiers(allowed: BitSet = modifierTokens, start: Modifiers = Modifiers()): Modifiers = {
       @tailrec

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

@@ -286,5 +286,5 @@ object Tokens extends TokensCommon {
 
   final val scala3keywords = BitSet(ENUM, ERASED, GIVEN)
 
-  final val softModifierNames = Set(nme.inline, nme.opaque)
+  final val softModifierNames = Set(nme.inline, nme.opaque, nme.open)
 }

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

@@ -417,6 +417,10 @@ object Checking {
     }
     if (!sym.isClass && sym.is(Abstract))
       fail(OnlyClassesCanBeAbstract(sym))
+        // note: this is not covered by the next test since terms can be abstract (which is a dual-mode flag)
+        // but they can never be one of ClassOnlyFlags
+    if !sym.isClass && sym.isOneOf(ClassOnlyFlags) then
+      fail(em"only classes can be ${(sym.flags & ClassOnlyFlags).flagsString}")
     if (sym.is(AbsOverride) && !sym.owner.is(Trait))
       fail(AbstractOverrideOnlyInTraits(sym))
     if (sym.is(Trait) && sym.is(Final))
@@ -437,6 +441,8 @@ object Checking {
     }
     if (sym.isValueClass && sym.is(Trait) && !sym.isRefinementClass)
       fail(CannotExtendAnyVal(sym))
+    checkCombination(Final, Open)
+    checkCombination(Sealed, Open)
     checkCombination(Final, Sealed)
     checkCombination(Private, Protected)
     checkCombination(Abstract, Override)

docs/docs/internals/syntax.md

@@ -103,7 +103,7 @@ yield
 ### Soft keywords
 
 ```
-as        derives   inline    opaque
+as        derives   inline    opaque    open
 ~         *         |         &         +         -
 ```
 
@@ -325,6 +325,7 @@ Modifier          ::=  LocalModifier
 LocalModifier     ::=  ‘abstract’
                     |  ‘final’
                     |  ‘sealed’
+                    |  ‘open’
                     |  ‘implicit’
                     |  ‘lazy’
                     |  ‘inline’

tests/neg/class-mods.scala

@@ -0,0 +1,11 @@
+open final class Foo1       // error
+sealed open class Foo2      // error
+
+open type T1     // error
+sealed type T2   // error
+abstract type T3 // error
+abstract open type T4 // error
+
+object foo {
+  abstract val x: Int = 1  // error
+}