Drop scalaShadowing after bootstrap

Instead, patch the `scala.language` object in the same way we patch `scala.Predef`.
We leave a dummy file in scalaShadowing, since the build requires the package to exist.
When we have a new bootstrap compiler, we should drop `scalaShadowing` entirely.

Author: odersky

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

@@ -191,6 +191,7 @@ class Definitions {
    */
   def patchSource(sym: Symbol): SourceFile =
     if sym == ScalaPredefModuleClass then ScalaPredefModuleClassPatch.source
+    else if sym == LanguageModuleClass then LanguageModuleClassPatch.source
     else NoSource
 
   @tu lazy val RootClass: ClassSymbol = newPackageSymbol(
@@ -259,9 +260,18 @@ class Definitions {
    *  or classes with the same name. But their binary artifacts are
    *  in `scalaShadowing` so they don't clash with the same-named `scala`
    *  members at runtime.
+   *  It is used only for non-bootstrapped code
    */
   @tu lazy val ScalaShadowingPackage: TermSymbol = requiredPackage(nme.scalaShadowing)
 
+  /** The `scala.runtime.stdLibPacthes` package is contains objects
+   *  that contain defnitions that get added as members to standard library
+   *  objects with the same name.
+   */
+  @tu lazy val StdLibPatchesPackage: TermSymbol = requiredPackage("scala.runtime.stdLibPatches")
+  @tu lazy val ScalaPredefModuleClassPatch: Symbol = getModuleIfDefined("scala.runtime.stdLibPatches.Predef").moduleClass
+  @tu lazy val LanguageModuleClassPatch: Symbol = getModuleIfDefined("scala.runtime.stdLibPatches.language").moduleClass
+
   /** 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
    *  which would result in a double binding assertion failure.
@@ -493,10 +503,7 @@ class Definitions {
     @tu lazy val Predef_classOf  : Symbol = ScalaPredefModule.requiredMethod(nme.classOf)
     @tu lazy val Predef_identity : Symbol = ScalaPredefModule.requiredMethod(nme.identity)
     @tu lazy val Predef_undefined: Symbol = ScalaPredefModule.requiredMethod(nme.???)
-
   @tu lazy val ScalaPredefModuleClass: ClassSymbol = ScalaPredefModule.moduleClass.asClass
-  @tu lazy val ScalaPredefModuleClassPatch: Symbol =
-    getModuleIfDefined("scala.runtime.stdLibPatches.Predef").moduleClass
 
   @tu lazy val SubTypeClass: ClassSymbol = requiredClass("scala.<:<")
   @tu lazy val SubType_refl: Symbol = SubTypeClass.companionModule.requiredMethod(nme.refl)

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -112,8 +112,9 @@ object Scala2Unpickler {
     denot.info = tempInfo.finalized(normalizedParents)
     denot.ensureTypeParamsInCorrectOrder()
     if denot.name == tpnme.Predef.moduleClassName && denot.symbol == defn.ScalaPredefModuleClass then
-      denot.sourceModule.info = denot.typeRef // we run into a cyclic reference when patching if this line is omitted
       patchStdLibClass(denot, defn.ScalaPredefModuleClassPatch)
+    else if denot.name == tpnme.language.moduleClassName && denot.symbol == defn.LanguageModuleClass then
+      patchStdLibClass(denot, defn.LanguageModuleClassPatch)
   }
 
   /** A finalizer that patches standard library classes.
@@ -126,6 +127,7 @@ object Scala2Unpickler {
    *  is read from a classfile.
    */
   private def patchStdLibClass(denot: ClassDenotation, patchCls: Symbol)(using Context): Unit =
+    denot.sourceModule.info = denot.typeRef // we run into a cyclic reference when patching if this line is omitted
     val scope = denot.info.decls.openForMutations
     if patchCls.exists then
       val patches = patchCls.info.decls.filter(patch =>

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -417,13 +417,6 @@ class TreeChecker extends Phase with SymTransformer {
       assert(tree.qual.tpe.isInstanceOf[ThisType], i"expect prefix of Super to be This, actual = ${tree.qual}")
       super.typedSuper(tree, pt)
 
-    /** Definition of `sym` should be excluded from checks.
-     *  We need to do that for stdlib patch classes, since their symbols have been
-     *  appropriated by other stdlib classes.
-     */
-    private def exclude(sym: Symbol)(using Context): Boolean =
-      sym == defn.ScalaPredefModuleClassPatch
-
     private def checkOwner(tree: untpd.Tree)(using Context): Unit = {
       def ownerMatches(symOwner: Symbol, ctxOwner: Symbol): Boolean =
         symOwner == ctxOwner ||
@@ -452,14 +445,12 @@ class TreeChecker extends Phase with SymTransformer {
 
       val symbolsNotDefined = decls -- defined - constr.symbol
 
-      if exclude(cls) then
-        promote(cdef)
-      else
-        assert(symbolsNotDefined.isEmpty,
-          i" $cls tree does not define members: ${symbolsNotDefined.toList}%, %\n" +
-          i"expected: ${decls.toList}%, %\n" +
-          i"defined: ${defined}%, %")
-        super.typedClassDef(cdef, cls)
+      assert(symbolsNotDefined.isEmpty,
+        i" $cls tree does not define members: ${symbolsNotDefined.toList}%, %\n" +
+        i"expected: ${decls.toList}%, %\n" +
+        i"defined: ${defined}%, %")
+
+      super.typedClassDef(cdef, cls)
     }
 
     override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree =
@@ -549,6 +540,12 @@ class TreeChecker extends Phase with SymTransformer {
       super.typedWhileDo(tree)
     }
 
+    override def typedPackageDef(tree: untpd.PackageDef)(using Context): Tree =
+      if tree.symbol == defn.StdLibPatchesPackage then
+        promote(tree) // don't check stdlib patches, since their symbols were highjacked by stdlib classes
+      else
+        super.typedPackageDef(tree)
+
     override def ensureNoLocalRefs(tree: Tree, pt: Type, localSyms: => List[Symbol])(using Context): Tree =
       tree
 

library/src-bootstrapped/scalaShadowing/D_u_m_m_y.scala

@@ -0,0 +1,3 @@
+package scalaShadowing
+
+class D_u_m_m_y

library/src/scalaShadowing/language.scala renamed to library/src-non-bootstrapped/scalaShadowing/language.scala

@@ -1,6 +1,6 @@
 package scala.runtime.stdLibPatches
 
-/** Scala 3 additions to the `scala.language` object.
+/** Scala 3 additions and replacements to the `scala.language` object.
  */
 object language:
 
@@ -18,6 +18,23 @@ object language:
    */
   object experimental:
 
+    /** Where enabled, Scala 2 macro definitions are allowed. Scala 2 macro implementations and
+     *  macro applications are unaffected; they can be used anywhere. A Scala 2 macro definition
+     *  must be accompanied by a Scala 3 macro definition with the same signature.
+     *
+     *  '''Why introduce the feature?''' Scala 2 macros promise to make the language more regular,
+     *  replacing ad-hoc language constructs with a general powerful abstraction
+     *  capability that can express them. Macros are also a more disciplined and
+     *  powerful replacement for compiler plugins.
+     *
+     *  '''Why control it?''' For their very power, macros can lead to code that is hard
+     *  to debug and understand.
+     *
+     *  This is not required by Scala 3 macros as `inline` controls the basic generative macros.
+     *  More add-hoc macros must contain the import of reflection in thier code, making this import redundant.
+     */
+    implicit lazy val macros: languageFeature.experimental.macros = languageFeature.experimental.macros
+
     /** Experimental support for richer dependent types */
     object dependent