Patch Predef from stdLibPatches.Predef

Definitions that should be added to predef are contained in
`stdLibPatches.Predef`. They replaace correesponding definitions in Predef.

Author: odersky

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

@@ -9,8 +9,9 @@ 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 typer.Namer
 
 import scala.annotation.tailrec
 
@@ -186,13 +187,45 @@ class Definitions {
     cls
   }
 
+  /** Run given finalizer function when `cls` is completed. The finalizer
+   *  gets the class and the current context as arguments.
+   */
   extension (cls: ClassSymbol)
     private def withFinalizer(f: ClassSymbol => Context ?=> Unit): ClassSymbol =
       cls.infoOrCompleter match
         case completer: SymbolLoader =>
           cls.info = completer.withFinalizer(d => f(d.asClass.classSymbol))
       cls
 
+  /** A finalizer that patches standard library classes.
+   *  It copies all non-private, non-synthetic definitions from `patchCls`
+   *  to `cls` while changing their owners to `cls`. Before that it deletes
+   *  any definitions of `cls` 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(cls: ClassSymbol, patchCls: Symbol)(using Context): Unit =
+    val scope = cls.info.decls.openForMutations
+    if patchCls.exists && !patchCls.infoOrCompleter.isInstanceOf[Namer#ClassCompleter] 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 = cls)
+        scope.enter(patch)
+
+  /** 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(
@@ -488,13 +521,18 @@ 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
+    .withFinalizer(patchStdLibClass(_, ScalaPredefModuleClassPatch))
+
+  @tu private 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)
 
@@ -779,6 +817,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")
@@ -1650,7 +1689,11 @@ class Definitions {
         ScalaPackageClass.enter(m)
 
       // force initialization of every symbol that is synthesized or hijacked by the compiler
-      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses() :+ JavaEnumClass
+      val forced =
+        syntheticCoreClasses
+        ++ syntheticCoreMethods
+        ++ ScalaValueClasses()
+        ++ List(JavaEnumClass, ScalaPredefModuleClass)
 
       isInitialized = true
     }

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 = {

library/src-bootstrapped/scala/runtime/stdLibPatches/Predef.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-bootstrapped/scala/runtime/stdLibPatches/language.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