Remove erased keyword from erasedValue

But retain erased semantics

Author: nicolasstucki

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

@@ -389,12 +389,12 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case Ident(_) =>
       refPurity(tree)
     case Select(qual, _) =>
-      if (tree.symbol.is(Erased)) Pure
+      if (tree.symbol.isErased) Pure
       else refPurity(tree) `min` exprPurity(qual)
     case New(_) | Closure(_, _, _) =>
       Pure
     case TypeApply(fn, _) =>
-      if (fn.symbol.is(Erased) || fn.symbol == defn.InternalQuoted_typeQuote) Pure else exprPurity(fn)
+      if (fn.symbol.isErased || fn.symbol == defn.InternalQuoted_typeQuote) Pure else exprPurity(fn)
     case Apply(fn, args) =>
       def isKnownPureOp(sym: Symbol) =
         sym.owner.isPrimitiveValueClass
@@ -404,7 +404,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
           || (fn.symbol.isStableMember && !fn.symbol.is(Lazy))
           || fn.symbol.isPrimaryConstructor && fn.symbol.owner.isNoInitsClass) // TODO: include in isStable?
         minOf(exprPurity(fn), args.map(exprPurity)) `min` Pure
-      else if (fn.symbol.is(Erased)) Pure
+      else if (fn.symbol.isErased) Pure
       else if (fn.symbol.isStableMember) /* && fn.symbol.is(Lazy) */
         minOf(exprPurity(fn), args.map(exprPurity)) `min` Idempotent
       else Impure

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

@@ -754,10 +754,10 @@ object SymDenotations {
       originalName.isSetterName &&
       (!isCompleted || info.firstParamTypes.nonEmpty) // to avoid being fooled by   var x_= : Unit = ...
 
-    /** is this a symbol representing an import? */
+    /** Is this a symbol representing an import? */
     final def isImport: Boolean = name == nme.IMPORT
 
-    /** is this the constructor of a class? */
+    /** Is this the constructor of a class? */
     final def isClassConstructor: Boolean = name == nme.CONSTRUCTOR
 
     /** Is this the constructor of a trait or a class */
@@ -777,6 +777,9 @@ object SymDenotations {
     /** Is this a subclass of the given class `base`? */
     def isSubClass(base: Symbol)(implicit ctx: Context): Boolean = false
 
+    /** Is this a symbol representing an erased term? */
+    def isErased(given Context): Boolean = is(Erased) || symbol == defn.Compiletime_erasedValue
+
     /** Is this a subclass of `base`,
      *  and is the denoting symbol also different from `Null` or `Nothing`?
      *  @note  erroneous classes are assumed to derive from all other classes
@@ -940,7 +943,7 @@ object SymDenotations {
     /** An erased value or an inline method.
      */
     def isEffectivelyErased(implicit ctx: Context): Boolean =
-      is(Erased) || isInlineMethod
+      isErased || isInlineMethod
 
     /** ()T and => T types should be treated as equivalent for this symbol.
      *  Note: For the moment, we treat Scala-2 compiled symbols as loose matching,

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

@@ -456,7 +456,7 @@ object Checking {
         fail(CannotHaveSameNameAs(sym, cls, CannotHaveSameNameAs.CannotBeOverridden))
         sym.setFlag(Private) // break the overriding relationship by making sym Private
       }
-    if (sym.is(Erased))
+    if (sym.isErased)
       if ctx.settings.YerasedTerms.value || sym == defn.Compiletime_erasedValue then checkApplicable(Erased, !sym.isOneOf(MutableOrLazy))
       else fail("cannot use `erased` without " + ctx.settings.YerasedTerms.name)
   }

library/src/scala/compiletime/package.scala

@@ -2,7 +2,7 @@ package scala
 
 package object compiletime {
 
-  erased def erasedValue[T]: T = ???
+  /*erased*/ def erasedValue[T]: T = ???
 
   /** The error method is used to produce user-defined compile errors during inline expansion.
    *  If an inline expansion results in a call error(msgStr) the compiler produces an error message containing the given msgStr.