Bring back -Yerased-terms for bootstrapping

Author: odersky

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -229,6 +229,7 @@ class ScalaSettings extends Settings.SettingGroup with CommonScalaSettings {
   val YexplicitNulls: Setting[Boolean] = BooleanSetting("-Yexplicit-nulls", "Make reference types non-nullable. Nullable types can be expressed with unions: e.g. String|Null.")
   val YcheckInit: Setting[Boolean] = BooleanSetting("-Ysafe-init", "Ensure safe initialization of objects")
   val YrequireTargetName: Setting[Boolean] = BooleanSetting("-Yrequire-targetName", "Warn if an operator is defined without a @targetName annotation")
+  val YerasedTerms: Setting[Boolean] = BooleanSetting("-Yerased-terms", "(disabled, use -language:experimental.erasedTerms instead)")
 
   /** Area-specific debug output */
   val YexplainLowlevel: Setting[Boolean] = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")

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

@@ -231,7 +231,8 @@ object Parsers {
       }
 
     extension (td: TokenData = in)
-      def isErased: Boolean = td.isIdent(nme.erased) && featureEnabled(Feature.erasedTerms)
+      def isErased: Boolean =
+        td.isIdent(nme.erased) && (featureEnabled(Feature.erasedTerms) || ctx.settings.YerasedTerms.value)
 
 /* ------------- ERROR HANDLING ------------------------------------------- */
 
@@ -2697,7 +2698,8 @@ object Parsers {
       case SEALED      => Mod.Sealed()
       case IDENTIFIER =>
         name match {
-          case nme.erased if featureEnabled(Feature.erasedTerms) => Mod.Erased()
+          case nme.erased if featureEnabled(Feature.erasedTerms) || ctx.settings.YerasedTerms.value =>
+            Mod.Erased()
           case nme.inline => Mod.Inline()
           case nme.opaque => Mod.Opaque()
           case nme.open => Mod.Open()

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

@@ -889,7 +889,7 @@ trait Implicits:
       case Select(qual, nme.apply) if defn.isFunctionType(qual.tpe.widen) =>
         val qt = qual.tpe.widen
         val qt1 = qt.dealiasKeepAnnots
-        def addendum = if (qt1 eq qt) "" else (i"\nwhich is an alias of: $qt1")
+        def addendum = if (qt1 eq qt) "" else (i"\nThe required type is an alias of: $qt1")
         em"parameter of ${qual.tpe.widen}$addendum"
       case _ =>
         em"${ if paramName.is(EvidenceParamName) then "an implicit parameter"

library/src/scala/compiletime/package.scala

@@ -2,6 +2,7 @@ package scala
 import annotation.compileTimeOnly
 
 package object compiletime {
+  import language.experimental.erasedTerms
 
   /** Use this method when you have a type, do not have a value for it but want to
    *  pattern match on it. For example, given a type `Tup <: Tuple`, one can

project/Build.scala

@@ -680,6 +680,8 @@ object Build {
       "-sourcepath", (sourceDirectories in Compile).value.map(_.getAbsolutePath).distinct.mkString(File.pathSeparator),
      // support declaration of scala.compiletime.erasedValue
       "-Yerased-terms"
+        // TODO: drop after bootstrap with erasure language import
+        // scala.compile now contains the roght language import so no global setting is needed
     ),
   )