Replace erased class modifiers with Erased base traits (#23447)

Based on #23419 Fixes #23406

Author: odersky

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

@@ -590,9 +590,13 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
  case New(_) | Closure(_, _, _) =>
  Pure
  case TypeApply(fn, _) =>
+ val sym = fn.symbol
  if tree.tpe.isInstanceOf[MethodOrPoly] then exprPurity(fn)
- else if fn.symbol == defn.QuotedTypeModule_of || fn.symbol == defn.Predef_classOf then Pure
- else if fn.symbol == defn.Compiletime_erasedValue && tree.tpe.dealias.isInstanceOf[ConstantType] then Pure
+ else if sym == defn.QuotedTypeModule_of
+ || sym == defn.Predef_classOf
+ || sym == defn.Compiletime_erasedValue && tree.tpe.dealias.isInstanceOf[ConstantType]
+ || defn.capsErasedValueMethods.contains(sym)
+ then Pure
  else Impure
  case Apply(fn, args) =>
  val factorPurity = minOf(exprPurity(fn), args.map(exprPurity))
@@ -636,6 +640,15 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
  def isPureBinding(tree: Tree)(using Context): Boolean = statPurity(tree) >= Pure
 
+ def isPureSyntheticCaseApply(sym: Symbol)(using Context): Boolean =
+ sym.isAllOf(SyntheticMethod)
+ && sym.name == nme.apply
+ && sym.owner.is(Module)
+ && {
+ val cls = sym.owner.companionClass
+ cls.is(Case) && cls.isNoInitsRealClass
+ }
+
  /** Is the application `tree` with function part `fn` known to be pure?
  * Function value and arguments can still be impure.
  */
@@ -647,6 +660,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
  tree.tpe.isInstanceOf[ConstantType] && tree.symbol != NoSymbol && isKnownPureOp(tree.symbol) // A constant expression with pure arguments is pure.
  || fn.symbol.isStableMember && fn.symbol.isConstructor // constructors of no-inits classes are stable
+ || isPureSyntheticCaseApply(fn.symbol)
 
  /** The purity level of this reference.
  * @return
@@ -655,8 +669,6 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
  * or its type is a constant type
  * IdempotentPath if reference is lazy and stable
  * Impure otherwise
- * @DarkDimius: need to make sure that lazy accessor methods have Lazy and Stable
- * flags set.
  */
  def refPurity(tree: Tree)(using Context): PurityLevel = {
  val sym = tree.symbol

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

@@ -301,7 +301,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
  assert(vparams.hasSameLengthAs(tp.paramNames) && vparams.head.isTerm)
  (vparams.asInstanceOf[List[TermSymbol]], remaining1)
  case nil =>
- (tp.paramNames.lazyZip(tp.paramInfos).lazyZip(tp.erasedParams).map(valueParam), Nil)
+ (tp.paramNames.lazyZip(tp.paramInfos).lazyZip(tp.paramErasureStatuses).map(valueParam), Nil)
  val (rtp, paramss) = recur(tp.instantiate(vparams.map(_.termRef)), remaining1)
  (rtp, vparams :: paramss)
  case _ =>

compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

@@ -495,15 +495,13 @@ extension (sym: Symbol)
 
  /** Does this symbol allow results carrying the universal capability?
  * Currently this is true only for function type applies (since their
- * results are unboxed) and `erasedValue` since this function is magic in
- * that is allows to conjure global capabilies from nothing (aside: can we find a
- * more controlled way to achieve this?).
+ * results are unboxed) and `caps.{$internal,unsafe}.erasedValue` since
+ * these function are magic in that they allow to conjure global capabilies from nothing.
  * But it could be generalized to other functions that so that they can take capability
  * classes as arguments.
  */
  def allowsRootCapture(using Context): Boolean =
- sym == defn.Compiletime_erasedValue
- || defn.isFunctionClass(sym.maybeOwner)
+ defn.capsErasedValueMethods.contains(sym) || defn.isFunctionClass(sym.maybeOwner)
 
  /** When applying `sym`, would the result type be unboxed?
  * This is the case if the result type contains a top-level reference to an enclosing

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -576,7 +576,7 @@ class CheckCaptures extends Recheck, SymTransformer:
  * @param args the type arguments
  */
  def disallowCapInTypeArgs(fn: Tree, sym: Symbol, args: List[Tree])(using Context): Unit =
- def isExempt = sym.isTypeTestOrCast || sym == defn.Compiletime_erasedValue
+ def isExempt = sym.isTypeTestOrCast || defn.capsErasedValueMethods.contains(sym)
  if !isExempt then
  val paramNames = atPhase(thisPhase.prev):
  fn.tpe.widenDealias match

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

@@ -48,8 +48,6 @@ object CheckRealizable {
 
  def boundsRealizability(tp: Type)(using Context): Realizability =
  new CheckRealizable().boundsRealizability(tp)
-
- private val LateInitializedFlags = Lazy | Erased
 }
 
 /** Compute realizability status.
@@ -72,7 +70,7 @@ class CheckRealizable(using Context) {
  /** Is symbol's definitition a lazy or erased val?
  * (note we exclude modules here, because their realizability is ensured separately)
  */
- private def isLateInitialized(sym: Symbol) = sym.isOneOf(LateInitializedFlags, butNot = Module)
+ private def isLateInitialized(sym: Symbol) = sym.is(Lazy, butNot = Module)
 
  /** The realizability status of given type `tp`*/
  def realizability(tp: Type): Realizability = tp.dealias match {
@@ -184,7 +182,7 @@ class CheckRealizable(using Context) {
  private def memberRealizability(tp: Type) = {
  def checkField(sofar: Realizability, fld: SingleDenotation): Realizability =
  sofar andAlso {
- if (checkedFields.contains(fld.symbol) || fld.symbol.isOneOf(Private | Mutable | LateInitializedFlags))
+ if (checkedFields.contains(fld.symbol) || fld.symbol.isOneOf(Private | Mutable | Lazy))
  // if field is private it cannot be part of a visible path
  // if field is mutable it cannot be part of a path
  // if field is lazy or erased it does not need to be initialized when the owning object is

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

@@ -266,6 +266,7 @@ class Definitions {
  @tu lazy val CompiletimeOpsDoubleModuleClass: Symbol = requiredModule("scala.compiletime.ops.double").moduleClass
  @tu lazy val CompiletimeOpsStringModuleClass: Symbol = requiredModule("scala.compiletime.ops.string").moduleClass
  @tu lazy val CompiletimeOpsBooleanModuleClass: Symbol = requiredModule("scala.compiletime.ops.boolean").moduleClass
+ @tu lazy val ErasedClass: ClassSymbol = requiredClass("scala.compiletime.Erased")
 
  /** Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter)
  * because after erasure the Any and AnyVal references get remapped to the Object methods
@@ -543,7 +544,7 @@ class Definitions {
  // needed as a synthetic class because Scala 2.x refers to it in classfiles
  // but does not define it as an explicit class.
  val cls = enterCompleteClassSymbol(
- ScalaPackageClass, tpnme.Singleton, PureInterfaceCreationFlags | Final | Erased,
+ ScalaPackageClass, tpnme.Singleton, PureInterfaceCreationFlags | Final,
  List(AnyType))
  enterTypeField(cls, tpnme.Self, Deferred, cls.info.decls.openForMutations)
  cls
@@ -1004,16 +1005,18 @@ class Definitions {
  @tu lazy val Caps_Capability: ClassSymbol = requiredClass("scala.caps.Capability")
  @tu lazy val Caps_CapSet: ClassSymbol = requiredClass("scala.caps.CapSet")
  @tu lazy val CapsInternalModule: Symbol = requiredModule("scala.caps.internal")
+ @tu lazy val Caps_erasedValue: Symbol = CapsInternalModule.requiredMethod("erasedValue")
  @tu lazy val CapsUnsafeModule: Symbol = requiredModule("scala.caps.unsafe")
  @tu lazy val Caps_unsafeAssumePure: Symbol = CapsUnsafeModule.requiredMethod("unsafeAssumePure")
  @tu lazy val Caps_unsafeAssumeSeparate: Symbol = CapsUnsafeModule.requiredMethod("unsafeAssumeSeparate")
+ @tu lazy val Caps_unsafeErasedValue: Symbol = CapsUnsafeModule.requiredMethod("unsafeErasedValue")
  @tu lazy val Caps_ContainsTrait: TypeSymbol = CapsModule.requiredType("Contains")
  @tu lazy val Caps_ContainsModule: Symbol = requiredModule("scala.caps.Contains")
  @tu lazy val Caps_containsImpl: TermSymbol = Caps_ContainsModule.requiredMethod("containsImpl")
  @tu lazy val Caps_Mutable: ClassSymbol = requiredClass("scala.caps.Mutable")
  @tu lazy val Caps_SharedCapability: ClassSymbol = requiredClass("scala.caps.SharedCapability")
 
- @tu lazy val PureClass: Symbol = requiredClass("scala.Pure")
+ @tu lazy val PureClass: ClassSymbol = requiredClass("scala.Pure")
 
  // Annotation base classes
  @tu lazy val AnnotationClass: ClassSymbol = requiredClass("scala.annotation.Annotation")
@@ -1563,6 +1566,11 @@ class Definitions {
  @tu lazy val pureSimpleClasses =
  Set(StringClass, NothingClass, NullClass) ++ ScalaValueClasses()
 
+ @tu lazy val capsErasedValueMethods =
+ Set(Caps_erasedValue, Caps_unsafeErasedValue)
+ @tu lazy val erasedValueMethods =
+ capsErasedValueMethods + Compiletime_erasedValue
+
  @tu lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0).asInstanceOf[Array[TypeRef]]
  val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(AbstractFunctionType.map(_.symbol.asClass))
  def AbstractFunctionClass(n: Int)(using Context): Symbol = AbstractFunctionClassPerRun()(using ctx)(n)
@@ -2006,7 +2014,9 @@ class Definitions {
 
  /** A allowlist of Scala-2 classes that are known to be pure */
  def isAssuredNoInits(sym: Symbol): Boolean =
- (sym `eq` SomeClass) || isTupleClass(sym)
+ (sym `eq` SomeClass)
+ || isTupleClass(sym)
+ || sym.is(Module) && isAssuredNoInits(sym.companionClass)
 
  /** If `cls` is Tuple1..Tuple22, add the corresponding *: type as last parent to `parents` */
  def adjustForTuple(cls: ClassSymbol, tparams: List[TypeSymbol], parents: List[Type]): List[Type] = {

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

@@ -529,18 +529,18 @@ object Flags {
  val RetainedModuleValAndClassFlags: FlagSet =
  AccessFlags | Package | Case |
  Synthetic | JavaDefined | JavaStatic | Artifact |
- Lifted | MixedIn | Specialized | PhantomSymbol | Invisible | Erased
+ Lifted | MixedIn | Specialized | PhantomSymbol | Invisible
 
  /** Flags that can apply to a module val */
  val RetainedModuleValFlags: FlagSet = RetainedModuleValAndClassFlags |
- Override | Final | Method | Implicit | Given | Lazy |
+ Override | Final | Method | Implicit | Given | Lazy | Erased |
  Accessor | AbsOverride | StableRealizable | Captured | Synchronized | Transparent
 
  /** Flags that can apply to a module class */
  val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | Enum
 
  /** Flags retained in term export forwarders */
- val RetainedExportTermFlags = Infix | Given | Implicit | Inline | Transparent | Erased | HasDefaultParams | NoDefaultParams | ExtensionMethod
+ val RetainedExportTermFlags = Infix | Given | Implicit | Inline | Transparent | HasDefaultParams | NoDefaultParams | ExtensionMethod
 
  /** Flags retained in parameters of term export forwarders */
  val RetainedExportTermParamFlags = Given | Implicit | Erased | HasDefault | Inline
@@ -569,7 +569,6 @@ object Flags {
  val EnumCase: FlagSet = Case | Enum
  val CovariantLocal: FlagSet = Covariant | Local // A covariant type parameter
  val ContravariantLocal: FlagSet = Contravariant | Local // A contravariant type parameter
- val EffectivelyErased = PhantomSymbol | Erased
  val ConstructorProxyModule: FlagSet = PhantomSymbol | Module
  val CaptureParam: FlagSet = PhantomSymbol | StableRealizable | Synthetic
  val DefaultParameter: FlagSet = HasDefault | Param // A Scala 2x default parameter

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

@@ -1051,8 +1051,13 @@ object SymDenotations {
  && owner.ne(defn.StringContextClass)
 
  /** An erased value or an erased inline method or field */
+ def isErased(using Context): Boolean =
+ is(Erased) || defn.erasedValueMethods.contains(symbol)
+
+ /** An erased value, a phantom symbol or an erased inline method or field */
  def isEffectivelyErased(using Context): Boolean =
- isOneOf(EffectivelyErased)
+ isErased
+ || is(PhantomSymbol)
  || is(Inline) && !isRetainedInline && !hasAnnotation(defn.ScalaStaticAnnot)
 
  /** Is this a member that will become public in the generated binary */

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

@@ -2387,7 +2387,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
  formals2.isEmpty
  }
  // If methods have erased parameters, then the erased parameters must match
- val erasedValid = (!tp1.hasErasedParams && !tp2.hasErasedParams) || (tp1.erasedParams == tp2.erasedParams)
+ val erasedValid = (!tp1.hasErasedParams && !tp2.hasErasedParams) || (tp1.paramErasureStatuses == tp2.paramErasureStatuses)
 
  erasedValid && loop(tp1.paramInfos, tp2.paramInfos)
  }

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

@@ -697,7 +697,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
  val (names, formals0) = if tp.hasErasedParams then
  tp.paramNames
  .zip(tp.paramInfos)
- .zip(tp.erasedParams)
+ .zip(tp.paramErasureStatuses)
  .collect{ case (param, isErased) if !isErased => param }
  .unzip
  else (tp.paramNames, tp.paramInfos)