Make bootstrapped DottyPredef an empty object

Once we have a new bootstrap compiler we can drop it entirely.

Instead of using DottyPredef, patch the Predef class when unpickling it.
The patch adds all methods from a patch class

     scala.runtime.stdLibPatches.Predef

to scala.Predef.

Author: odersky

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

@@ -9,7 +9,7 @@ import unpickleScala2.Scala2Unpickler.ensureConstructor
 import scala.collection.mutable
 import collection.mutable
 import Denotations.SingleDenotation
-import util.SimpleIdentityMap
+import util.{SimpleIdentityMap, SourceFile, NoSource}
 import typer.ImportInfo.RootRef
 
 import scala.annotation.tailrec
@@ -186,6 +186,13 @@ class Definitions {
     cls
   }
 
+  /** If `sym` is a patched library class, the source file of its patch class,
+   *  otherwise `NoSource`
+   */
+  def patchSource(sym: Symbol): SourceFile =
+    if sym == ScalaPredefModuleClass then ScalaPredefModuleClassPatch.source
+    else NoSource
+
   @tu lazy val RootClass: ClassSymbol = newPackageSymbol(
     NoSymbol, nme.ROOT, (root, rootcls) => ctx.base.rootLoader(root)).moduleClass.asClass
   @tu lazy val RootPackage: TermSymbol = newSymbol(
@@ -481,13 +488,16 @@ class Definitions {
     newPermanentSymbol(ScalaPackageClass, tpnme.IMPLICITkw, EmptyFlags, TypeBounds.empty).entered
   def ImplicitScrutineeTypeRef: TypeRef = ImplicitScrutineeTypeSym.typeRef
 
-
   @tu lazy val ScalaPredefModule: Symbol = requiredModule("scala.Predef")
     @tu lazy val Predef_conforms : Symbol = ScalaPredefModule.requiredMethod(nme.conforms_)
     @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)
 
@@ -510,7 +520,7 @@ class Definitions {
   // will return "null" when called recursively, see #1856.
   def DottyPredefModule: Symbol = {
     if (myDottyPredefModule == null) {
-      myDottyPredefModule = requiredModule("dotty.DottyPredef")
+      myDottyPredefModule = getModuleIfDefined("dotty.DottyPredef")
       assert(myDottyPredefModule != null)
     }
     myDottyPredefModule
@@ -782,6 +792,7 @@ class Definitions {
   @tu lazy val Mirror_SingletonProxyClass: ClassSymbol = requiredClass("scala.deriving.Mirror.SingletonProxy")
 
   @tu lazy val LanguageModule: Symbol = requiredModule("scala.language")
+  @tu lazy val LanguageModuleClass: Symbol = LanguageModule.moduleClass.asClass
   @tu lazy val LanguageExperimentalModule: Symbol = requiredModule("scala.language.experimental")
   @tu lazy val NonLocalReturnControlClass: ClassSymbol = requiredClass("scala.runtime.NonLocalReturnControl")
   @tu lazy val SelectableClass: ClassSymbol = requiredClass("scala.Selectable")

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

@@ -428,23 +428,21 @@ object Symbols {
     private var mySource: SourceFile = NoSource
 
     final def sourceOfClass(using Context): SourceFile = {
-      if (!mySource.exists && !denot.is(Package))
+      if !mySource.exists && !denot.is(Package) then
         // this allows sources to be added in annotations after `sourceOfClass` is first called
-        mySource = {
-          val file = associatedFile
-          if (file != null && file.extension != "class") ctx.getSource(file)
-          else {
-            def sourceFromTopLevel(using Context) =
-              denot.topLevelClass.unforcedAnnotation(defn.SourceFileAnnot) match {
-                case Some(sourceAnnot) => sourceAnnot.argumentConstant(0) match {
+        val file = associatedFile
+        if file != null && file.extension != "class" then
+          mySource = ctx.getSource(file)
+        else
+          mySource = defn.patchSource(this)
+          if !mySource.exists then
+            mySource = atPhaseNoLater(flattenPhase) {
+              denot.topLevelClass.unforcedAnnotation(defn.SourceFileAnnot) match
+                case Some(sourceAnnot) => sourceAnnot.argumentConstant(0) match
                   case Some(Constant(path: String)) => ctx.getSource(path)
                   case none => NoSource
-                }
                 case none => NoSource
-              }
-            atPhaseNoLater(flattenPhase)(sourceFromTopLevel)
-          }
-        }
+            }
       mySource
     }
 
@@ -880,6 +878,13 @@ object Symbols {
     staticRef(name).requiredSymbol("object", name)(_.is(Module)).asTerm
   }
 
+  /** Get module symbol if the module is either defined in current compilation run
+   *  or present on classpath. Returns NoSymbol otherwise.
+   */
+  def getModuleIfDefined(path: PreName)(using Context): Symbol =
+    staticRef(path.toTermName, generateStubs = false)
+      .disambiguate(_.is(Module)).symbol
+
   def requiredModuleRef(path: PreName)(using Context): TermRef = requiredModule(path).termRef
 
   def requiredMethod(path: PreName)(using Context): TermSymbol = {

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

@@ -111,7 +111,32 @@ 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)
   }
+
+  /** A finalizer that patches standard library classes.
+   *  It copies all non-private, non-synthetic definitions from `patchCls`
+   *  to `denot` while changing their owners to `denot`. Before that it deletes
+   *  any definitions of `denot` that have the same name as one of the copied
+   *  definitions.
+   *
+   *  To avpid running into cycles on bootstrap, patching happens only if `patchCls`
+   *  is read from a classfile.
+   */
+  private def patchStdLibClass(denot: ClassDenotation, patchCls: Symbol)(using Context): 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
+        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)
 }
 
 /** Unpickle symbol table information descending from a class and/or module root

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

@@ -417,6 +417,13 @@ 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 ||
@@ -445,12 +452,14 @@ class TreeChecker extends Phase with SymTransformer {
 
       val symbolsNotDefined = decls -- defined - constr.symbol
 
-      assert(symbolsNotDefined.isEmpty,
+      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)
+        super.typedClassDef(cdef, cls)
     }
 
     override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree =

library/src-bootstrapped/dotty/DottyPredef.scala

@@ -0,0 +1,3 @@
+package dotty
+
+object DottyPredef

library/src/dotty/DottyPredef.scala renamed to library/src-non-bootstrapped/dotty/DottyPredef.scala

@@ -0,0 +1,47 @@
+package scala.runtime.stdLibPatches
+
+object Predef:
+  import compiletime.summonFrom
+
+  inline def assert(inline assertion: Boolean, inline message: => Any): Unit =
+    if !assertion then scala.runtime.Scala3RunTime.assertFailed(message)
+
+  inline def assert(inline assertion: Boolean): Unit =
+    if !assertion then scala.runtime.Scala3RunTime.assertFailed()
+
+  /**
+   * Retrieve the single value of a type with a unique inhabitant.
+   *
+   * @example {{{
+   * object Foo
+   * val foo = valueOf[Foo.type]
+   * // foo is Foo.type = Foo
+   *
+   * val bar = valueOf[23]
+   * // bar is 23.type = 23
+   * }}}
+   * @group utilities
+   */
+  inline def valueOf[T]: T = summonFrom {
+    case ev: ValueOf[T] => ev.value
+  }
+
+  /** Summon a given value of type `T`. Usually, the argument is not passed explicitly.
+   *
+   *  @tparam T the type of the value to be summoned
+   *  @return the given value typed as the provided type parameter
+   */
+  inline def summon[T](using x: T): x.type = x
+
+  // Extension methods for working with explicit nulls
+
+  /** Strips away the nullability from a value.
+   *  e.g.
+   *    val s1: String|Null = "hello"
+   *    val s: String = s1.nn
+   *
+   *  Note that `.nn` performs a checked cast, so if invoked on a null value it'll throw an NPE.
+   */
+  extension [T](x: T | Null) inline def nn: x.type & T =
+    scala.runtime.Scala3RunTime.nn(x)
+end Predef

library/src/scala/runtime/stdLibPatches/Predef.scala

@@ -0,0 +1,60 @@
+package scala.runtime.stdLibPatches
+
+/** Scala 3 additions to the `scala.language` object.
+ */
+object language:
+
+  /** The experimental object contains features that have been recently added but have not
+   *  been thoroughly tested in production yet.
+   *
+   *  Experimental features '''may undergo API changes''' in future releases, so production
+   *  code should not rely on them.
+   *
+   *  Programmers are encouraged to try out experimental features and
+   *  [[http://issues.scala-lang.org report any bugs or API inconsistencies]]
+   *  they encounter so they can be improved in future releases.
+   *
+   *  @group experimental
+   */
+  object experimental:
+
+    /** Experimental support for richer dependent types */
+    object dependent
+
+    /** Experimental support for named type arguments */
+    object namedTypeArguments
+
+    /** Experimental support for generic number literals */
+    object genericNumberLiterals
+  end experimental
+
+  /** Where imported, auto-tupling is disabled */
+  object noAutoTupling
+
+  /** Where imported, loose equality using eqAny is disabled */
+  object strictEquality
+
+  /** Where imported, ad hoc extensions of non-open classes in other
+   *  compilation units are allowed.
+   *
+   *  '''Why control the feature?''' Ad-hoc extensions should usually be avoided
+   *  since they typically cannot rely on an "internal" contract between a class
+   *  and its extensions. Only open classes need to specify such a contract.
+   *  Ad-hoc extensions might break for future versions of the extended class,
+   *  since the extended class is free to change its implementation without
+   *  being constrained by an internal contract.
+   *
+   *  '''Why allow it?''' An ad-hoc extension can sometimes be necessary,
+   *  for instance when mocking a class in a testing framework, or to work
+   *  around a bug or missing feature in the original class. Nevertheless,
+   *  such extensions should be limited in scope and clearly documented.
+   *  That's why the language import is required for them.
+   */
+  object adhocExtensions
+
+  /** Source version */
+  object `3.0-migration`
+  object `3.0`
+  object `3.1-migration`
+  object `3.1`
+end language

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

@@ -2,9 +2,9 @@
 -- Error: tests/neg-macros/i9014/Test_2.scala:1:23 ---------------------------------------------------------------------
 1 |val tests = summon[Bar] // error
   |                       ^
-  |                no implicit argument of type Bar was found for parameter x of method summon in object DottyPredef.
-  |                I found:
+  |                     no implicit argument of type Bar was found for parameter x of method summon in object Predef.
+  |                     I found:
   |
-  |                    given_Bar
+  |                         given_Bar
   |
-  |                But method given_Bar does not match type Bar.
+  |                     But method given_Bar does not match type Bar.

tests/neg-macros/i9014.check

@@ -1,9 +1,9 @@
 -- Error: tests/neg/i9014.scala:4:25 -----------------------------------------------------------------------------------
 4 |  val tests = summon[Bar] // error
   |                         ^
-  |                no implicit argument of type Bar was found for parameter x of method summon in object DottyPredef.
-  |                I found:
+  |                     no implicit argument of type Bar was found for parameter x of method summon in object Predef.
+  |                     I found:
   |
-  |                    Bar.given_Bar
+  |                         Bar.given_Bar
   |
-  |                But method given_Bar in object Bar does not match type Bar.
+  |                     But method given_Bar in object Bar does not match type Bar.