Don't overwrite language.experimental

Patch its members recursively instead.

Author: odersky

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

@@ -256,7 +256,6 @@ class Definitions {
    */
   @tu lazy val ScalaShadowingPackage: TermSymbol = requiredPackage(nme.scalaShadowing)
 
-
   /** 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.
@@ -1133,19 +1132,28 @@ class Definitions {
    */
   def patchStdLibClass(denot: ClassDenotation)(using Context): Unit =
 
-    def patchWith(patchCls: Symbol) =
-      denot.sourceModule.info = denot.typeRef // we run into a cyclic reference when patching if this line is omitted
+    def recurse(patch: Symbol) =
+      patch.name.toString.startsWith("experimental")
+
+    def patch2(denot: ClassDenotation, patchCls: Symbol): Unit =
       val scope = denot.info.decls.openForMutations
       if patchCls.exists then
         val patches = patchCls.info.decls.filter(patch =>
           !patch.isConstructor && !patch.isOneOf(PrivateOrSynthetic))
-        for patch <- patches do
+        for patch <- patches if !recurse(patch) do
           val e = scope.lookupEntry(patch.name)
           if e != null then scope.unlink(e)
         for patch <- patches do
           patch.ensureCompleted()
-          patch.denot = patch.denot.copySymDenotation(owner = denot.symbol)
-          scope.enter(patch)
+          if !recurse(patch) then
+            patch.denot = patch.denot.copySymDenotation(owner = denot.symbol)
+            scope.enter(patch)
+          else if patch.isClass then
+            patch2(scope.lookup(patch.name).asClass, patch)
+
+    def patchWith(patchCls: Symbol) =
+      denot.sourceModule.info = denot.typeRef // we run into a cyclic reference when patching if this line is omitted
+      patch2(denot, patchCls)
 
     if denot.name == tpnme.Predef.moduleClassName && denot.symbol == ScalaPredefModuleClass then
       patchWith(ScalaPredefModuleClassPatch)

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -765,7 +765,9 @@ class TreePickler(pickler: TastyPickler) {
 
   def pickle(trees: List[Tree])(using Context): Unit = {
     trees.foreach(tree => if (!tree.isEmpty) pickleTree(tree))
-    def missing = forwardSymRefs.keysIterator.map(sym => sym.showLocated + "(line " + sym.srcPos.line + ")").toList
+    def missing = forwardSymRefs.keysIterator
+      .map(sym => i"${sym.showLocated} (line ${sym.srcPos.line}) #${sym.id}")
+      .toList
     assert(forwardSymRefs.isEmpty, i"unresolved symbols: $missing%, % when pickling ${ctx.source}")
   }
 

library/src/scala/runtime/stdLibPatches/language.scala

@@ -18,23 +18,6 @@ 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