Merge remote-tracking branch 'upstream/master'

Author: noti0na1

community-build/community-projects/intent

@@ -483,7 +483,7 @@ object desugar {
       if (isEnum) {
         val (enumCases, enumStats) = stats.partition(DesugarEnums.isEnumCase)
         if (enumCases.isEmpty)
-          ctx.error("Enumerations must constain at least one case", namePos)
+          ctx.error("Enumerations must contain at least one case", namePos)
         val enumCompanionRef = TermRefTree()
         val enumImport =
           Import(enumCompanionRef, enumCases.flatMap(caseIds).map(ImportSelector(_)))

compiler/src/dotty/tools/dotc/ast/Desugar.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/ast/untpd.scala

@@ -43,10 +43,10 @@ class Definitions {
     ctx.newSymbol(owner, name, flags | Permanent, info)
 
   private def newClassSymbol(owner: Symbol, name: TypeName, flags: FlagSet, infoFn: ClassSymbol => Type) =
-    ctx.newClassSymbol(owner, name, flags | Permanent | NoInits, infoFn)
+    ctx.newClassSymbol(owner, name, flags | Permanent | NoInits | Open, infoFn)
 
   private def enterCompleteClassSymbol(owner: Symbol, name: TypeName, flags: FlagSet, parents: List[TypeRef], decls: Scope = newScope) =
-    ctx.newCompleteClassSymbol(owner, name, flags | Permanent | NoInits, parents, decls).entered
+    ctx.newCompleteClassSymbol(owner, name, flags | Permanent | NoInits | Open, parents, decls).entered
 
   private def enterTypeField(cls: ClassSymbol, name: TypeName, flags: FlagSet, scope: MutableScope) =
     scope.enter(newSymbol(cls, name, flags, TypeBounds.empty))
@@ -279,7 +279,7 @@ class Definitions {
     val cls = ctx.requiredClass("java.lang.Object")
     assert(!cls.isCompleted, "race for completing java.lang.Object")
     cls.info = ClassInfo(cls.owner.thisType, cls, AnyClass.typeRef :: Nil, newScope)
-    cls.setFlag(NoInits)
+    cls.setFlag(NoInits | JavaDefined)
 
     // The companion object doesn't really exist, so it needs to be marked as
     // absent. Here we need to set it before completing attempt to load Object's

compiler/src/dotty/tools/dotc/core/Definitions.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,12 +509,16 @@ object Flags {
   /** Flags retained in export forwarders */
   val RetainedExportFlags = Given | Implicit | Extension
 
+  /** Flags that apply only to classes */
+  val ClassOnlyFlags = Sealed | Open | Abstract.toTypeFlags
+
 // ------- Other flag sets -------------------------------------
 
   val AbstractFinal: FlagSet                 = Abstract | Final
   val AbstractOverride: FlagSet              = Abstract | Override
   val AbstractSealed: FlagSet                = Abstract | Sealed
   val AbstractOrTrait: FlagSet               = Abstract | Trait
+  val EffectivelyOpenFlags                   = Abstract | JavaDefined | Open | Scala2x | Trait
   val PrivateAccessor: FlagSet               = Accessor | Private
   val AccessorOrSynthetic: FlagSet           = Accessor | Synthetic
   val EnumCase: FlagSet                      = Case | Enum

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

@@ -367,8 +367,8 @@ object StdNames {
     val TypeApply: N            = "TypeApply"
     val TypeRef: N              = "TypeRef"
     val UNIT : N                = "UNIT"
-    val add_ : N                = "add"
     val acc: N                  = "acc"
+    val adhocExtensions: N      = "adhocExtensions"
     val annotation: N           = "annotation"
     val any2stringadd: N        = "any2stringadd"
     val anyHash: N              = "anyHash"
@@ -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/StdNames.scala

@@ -1064,6 +1064,12 @@ object SymDenotations {
     final def isEffectivelyFinal(implicit ctx: Context): Boolean =
       isOneOf(EffectivelyFinalFlags) || !owner.isClass || owner.isOneOf(FinalOrModuleClass) || owner.isAnonymousClass
 
+    /** A class is effectively sealed if has the `final` or `sealed` modifier, or it
+     *  is defined in Scala 3 and is neither abstract nor open.
+     */
+    final def isEffectivelySealed(given Context): Boolean =
+      isOneOf(FinalOrSealed) || isClass && !isOneOf(EffectivelyOpenFlags)
+
     /** The class containing this denotation which has the given effective name. */
     final def enclosingClassNamed(name: Name)(implicit ctx: Context): Symbol = {
       val cls = enclosingClass
@@ -1362,16 +1368,16 @@ object SymDenotations {
      */
     def typeParamCreationFlags: FlagSet = TypeParam
 
-    override def toString: String = {
-      val kindString =
-        if (myFlags.is(ModuleClass)) "module class"
-        else if (isClass) "class"
-        else if (isType) "type"
-        else if (myFlags.is(Module)) "module"
-        else if (myFlags.is(Method)) "method"
-        else "val"
-      s"$kindString $name"
-    }
+    def kindString: String =
+      if myFlags.is(ModuleClass) then "module class"
+      else if myFlags.is(Trait)  then "trait"
+      else if isClass            then "class"
+      else if isType             then "type"
+      else if myFlags.is(Module) then "module"
+      else if myFlags.is(Method) then "method"
+      else                            "val"
+
+    override def toString: String = s"$kindString $name"
 
     // ----- Sanity checks and debugging */
 

compiler/src/dotty/tools/dotc/core/SymDenotations.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/TastyFormat.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/TreePickler.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/core/tasty/TreeUnpickler.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/Parsers.scala

@@ -1068,7 +1068,7 @@ object Scanners {
         }
       else if (ch == '$') {
         nextRawChar()
-        if (ch == '$') {
+        if (ch == '$' || ch == '"') {
           putChar(ch)
           nextRawChar()
           getStringPart(multiLine)
@@ -1089,7 +1089,7 @@ object Scanners {
           finishNamed(target = next)
         }
         else
-          error("invalid string interpolation: `$$', `$'ident or `$'BlockExpr expected")
+          error("invalid string interpolation: `$$', `$\"`, `$'ident or `$'BlockExpr expected")
       }
       else {
         val isUnclosedLiteral = !isUnicodeEscape && (ch == SU || (!multiLine && (ch == CR || ch == LF)))

compiler/src/dotty/tools/dotc/parsing/Scanners.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/parsing/Tokens.scala

@@ -108,13 +108,13 @@ trait Reporting { this: Context =>
       else {
         reporter.reportNewFeatureUseSite(featureUseSite)
         s"""
-           |This can be achieved by adding the import clause 'import $fqname'
-           |or by setting the compiler option -language:$feature.
            |See the Scala docs for value $fqname for a discussion
            |why the feature $req be explicitly enabled.""".stripMargin
       }
 
-    val msg = s"$featureDescription $req be enabled\nby making the implicit value $fqname visible.$explain"
+    val msg = s"""$featureDescription $req be enabled
+                 |by adding the import clause 'import $fqname'
+                 |or by setting the compiler option -language:$feature.$explain""".stripMargin
     if (required) error(msg, pos)
     else reportWarning(new FeatureWarning(msg, pos))
   }

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -1790,13 +1790,10 @@ object messages {
     extends Message(ClassAndCompanionNameClashID) {
     val kind: String = "Naming"
     val msg: String = em"Name clash: both ${cls.owner} and its companion object defines ${cls.name.stripModuleClassSuffix}"
-    val explanation: String = {
-      val kind = if (cls.owner.is(Flags.Trait)) "trait" else "class"
-
-      em"""|A $kind and its companion object cannot both define a ${hl("class")}, ${hl("trait")} or ${hl("object")} with the same name:
+    val explanation: String =
+      em"""|A ${cls.kindString} and its companion object cannot both define a ${hl("class")}, ${hl("trait")} or ${hl("object")} with the same name:
            |  - ${cls.owner} defines ${cls}
            |  - ${other.owner} defines ${other}"""
-      }
   }
 
   case class TailrecNotApplicable(symbol: Symbol)(implicit ctx: Context)

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1544,6 +1544,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Flags_Private: Flags = core.Flags.Private
   def Flags_Protected: Flags = core.Flags.Protected
   def Flags_Abstract: Flags = core.Flags.Abstract
+  def Flags_Open: Flags = core.Flags.Open
   def Flags_Final: Flags = core.Flags.Final
   def Flags_Sealed: Flags = core.Flags.Sealed
   def Flags_Case: Flags = core.Flags.Case

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -92,7 +92,7 @@ class SymUtils(val self: Symbol) extends AnyVal {
    */
   def whyNotGenericSum(implicit ctx: Context): String =
     if (!self.is(Sealed))
-      s"it is not a sealed ${if (self.is(Trait)) "trait" else "class"}"
+      s"it is not a sealed ${self.kindString}"
     else {
       val children = self.children
       val companion = self.linkedClass
@@ -175,12 +175,18 @@ class SymUtils(val self: Symbol) extends AnyVal {
   def isEnumAnonymClass(implicit ctx: Context): Boolean =
     self.isAnonymousClass && (self.owner.name.eq(nme.DOLLAR_NEW) || self.owner.is(CaseVal))
 
-  /** Is this symbol defined locally (i.e. at some level owned by a term) and
-   *  defined in a different toplevel class than its supposed parent class `cls`?
-   *  Such children are not pickled, and have to be reconstituted manually.
+  /** Is this symbol defined locally (i.e. at some level owned by a term) so that
+   *  it cannot be seen from parent class `cls`?
    */
-  def isInaccessibleChildOf(cls: Symbol)(implicit ctx: Context): Boolean =
-    self.isLocal && !cls.topLevelClass.isLinkedWith(self.topLevelClass)
+  def isInaccessibleChildOf(cls: Symbol)(given Context): Boolean =
+    def isAccessible(sym: Symbol, cls: Symbol): Boolean =
+      if cls.isType && !cls.is(Package) then
+        isAccessible(sym, cls.owner)
+      else
+        sym == cls
+        || sym.is(Package)
+        || sym.isType && isAccessible(sym.owner, cls)
+    !isAccessible(self.owner, cls)
 
   /** If this is a sealed class, its known children in the order of textual occurrence */
   def children(implicit ctx: Context): List[Symbol] = {

compiler/src/dotty/tools/dotc/transform/SymUtils.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)

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

@@ -197,16 +197,14 @@ object Inliner {
     /** Expand call to scala.compiletime.testing.typeChecks */
     def typeChecks(tree: Tree)(implicit ctx: Context): Tree = {
       assert(tree.symbol == defn.CompiletimeTesting_typeChecks)
-      def getCodeArgValue(t: Tree): Option[String] = t match {
-        case Literal(Constant(code: String)) => Some(code)
-        case Typed(t2, _) => getCodeArgValue(t2)
-        case Inlined(_, Nil, t2) => getCodeArgValue(t2)
-        case Block(Nil, t2) => getCodeArgValue(t2)
-        case _ => None
+      def stripTyped(t: Tree): Tree = t match {
+        case Typed(t2, _) => stripTyped(t2)
+        case _ => t
       }
+
       val Apply(_, codeArg :: Nil) = tree
-      getCodeArgValue(codeArg.underlyingArgument) match {
-        case Some(code) =>
+      ConstFold(stripTyped(codeArg.underlyingArgument)).tpe.widenTermRefExpr match {
+        case ConstantType(Constant(code: String)) =>
           val ctx2 = ctx.fresh.setNewTyperState().setTyper(new Typer)
           val tree2 = new Parser(SourceFile.virtual("tasty-reflect", code))(ctx2).block()
           val res =
@@ -216,7 +214,8 @@ object Inliner {
               !ctx2.reporter.hasErrors
             }
           Literal(Constant(res))
-        case _ =>
+        case t =>
+          assert(ctx.reporter.hasErrors) // at least: argument to inline parameter must be a known value
           EmptyTree
       }
     }