Fix callTrace if inlined methods

We need to keep the reference to the called method, not only the symbol
of the to level class. This is important for the traces of the `assert`
method that is defined in a different file. This might also be useful
for macro annotations.

This is also a solution to the awkward Select vs. Ident distinction to
identify macros in `YCheckPositions`.

Ww use `-Ycompile-scala3-library` to avoid the `stdLibPatches` patches in the
community build test for `stdLib213` the same way we do in
`scala-library-bootstrapped`.

Author: nicolasstucki

community-build/src/scala/dotty/communitybuild/projects.scala

@@ -363,6 +363,7 @@ object projects:
     extraSbtArgs  = List("-Dscala.build.compileWithDotty=true"),
     sbtTestCommand   = """set Global / fatalWarnings := false; library/compile""",
     sbtPublishCommand = """set Global / fatalWarnings := false; set library/Compile/packageDoc/publishArtifact := false; library/publishLocal""",
+    scalacOptions = "-Ycompile-scala3-library" :: SbtCommunityProject.scalacOptions
     // sbtDocCommand = "library/doc" // Does no compile? No idea :/
   )
 

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -31,7 +31,7 @@ object Trees {
 
   /** Property key for backquoted identifiers and definitions */
   val Backquoted: Property.StickyKey[Unit] = Property.StickyKey()
-  
+
   val SyntheticUnit: Property.StickyKey[Unit] = Property.StickyKey()
 
   /** Trees take a parameter indicating what the type of their `tpe` field
@@ -661,7 +661,8 @@ object Trees {
    *
    *  @param  call      Info about the original call that was inlined
    *                    Until PostTyper, this is the full call, afterwards only
-   *                    a reference to the toplevel class from which the call was inlined.
+   *                    a reference to the method or the top-level class from
+   *                    which the call was inlined.
    *  @param  bindings  Bindings for proxies to be used in the inlined code
    *  @param  expansion The inlined tree, minus bindings.
    *

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

@@ -396,6 +396,7 @@ private sealed trait YSettings:
   val YnoExperimental: Setting[Boolean] = BooleanSetting("-Yno-experimental", "Disable experimental language features.")
   val YlegacyLazyVals: Setting[Boolean] = BooleanSetting("-Ylegacy-lazy-vals", "Use legacy (pre 3.3.0) implementation of lazy vals.")
   val YcompileScala2Library: Setting[Boolean] = BooleanSetting("-Ycompile-scala2-library", "Used when compiling the Scala 2 standard library.")
+  val YcompileScala3Library: Setting[Boolean] = BooleanSetting("-Ycompile-scala3-library", "Used when compiling the Scala 3 standard library, including the Scala 2 library sources.")
   val YoutputOnlyTasty: Setting[Boolean] = BooleanSetting("-Youtput-only-tasty", "Used to only generate the TASTy file without the classfiles")
 
   val YprofileEnabled: Setting[Boolean] = BooleanSetting("-Yprofile-enabled", "Enable profiling.")

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -299,20 +299,6 @@ object Inlines:
     (new Reposition).transform(tree)
   end reposition
 
-  /** Leave only a call trace consisting of
-   *  - a reference to the top-level class from which the call was inlined,
-   *  - the call's position
-   *  in the call field of an Inlined node.
-   *  The trace has enough info to completely reconstruct positions.
-   *  Note: For macros it returns a Select and for other inline methods it returns an Ident (this distinction is only temporary to be able to run YCheckPositions)
-   */
-  def inlineCallTrace(callSym: Symbol, pos: SourcePosition)(using Context): Tree = {
-    assert(ctx.source == pos.source)
-    val topLevelCls = callSym.topLevelClass
-    if (callSym.is(Macro)) ref(topLevelCls.owner).select(topLevelCls.name)(using ctx.withOwner(topLevelCls.owner)).withSpan(pos.span)
-    else Ident(topLevelCls.typeRef).withSpan(pos.span)
-  }
-
   private object Intrinsics:
     import dotty.tools.dotc.reporting.Diagnostic.Error
     private enum ErrorKind:

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

@@ -304,7 +304,7 @@ object PickleQuotes {
     def pickleAsTasty() = {
       val body1 =
         if body.isType then body
-        else Inlined(Inlines.inlineCallTrace(ctx.owner, quote.sourcePos), Nil, body)
+        else Inlined(ref(ctx.owner.topLevelClass.typeRef).withSpan(quote.span), Nil, body)
       val pickleQuote = PickledQuotes.pickleQuote(body1)
       val pickledQuoteStrings = pickleQuote match
         case x :: Nil => Literal(Constant(x))

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

@@ -367,7 +367,18 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           val pos = call.sourcePos
           CrossVersionChecks.checkExperimentalRef(call.symbol, pos)
           withMode(Mode.InlinedCall)(transform(call))
-          val callTrace = Inlines.inlineCallTrace(call.symbol, pos)(using ctx.withSource(pos.source))
+          val traceSym =
+            if ctx.settings.YcompileScala3Library.value && call.symbol.owner == defn.ScalaPredefModuleClass then
+              // These are inline method overrides that come from `scala.runtime.stdLibPatches.Predef`.
+              // References to these members can cause conflicts when compiling the standard library.
+              // FIXME: remove this workaround. Ideally we should not patch Predef when we compile the library to
+              // avoid the `assert` overrides, but we also need the patches to make `summon` and other new features
+              // work within the Scala 3 library sources. Note that currently compiling Predef.scala with
+              // `-Ycompile-scala3-library` or without does not Ycheck. It does with `-Ycompile-scala2-library`,
+              // because we do not apply the patches.
+              call.symbol.topLevelClass
+            else call.symbol
+          val callTrace = ref(traceSym)(using ctx.withSource(pos.source)).withSpan(pos.span)
           cpy.Inlined(tree)(callTrace, transformSub(bindings), transform(expansion)(using inlineContext(tree)))
         case templ: Template =>
           withNoCheckNews(templ.parents.flatMap(newPart)) {

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

@@ -35,7 +35,7 @@ class YCheckPositions extends Phase {
                 val currentSource = sources.head
                 assert(tree.source == currentSource, i"wrong source set for $tree # ${tree.uniqueId} of ${tree.getClass}, set to ${tree.source} but context had $currentSource\n ${tree.symbol.flagsString}")
 
-            // Recursivlely check children while keeping track of current source
+            // Recursively check children while keeping track of current source
             reporting.trace(i"check pos ${tree.getClass} ${tree.source} ${sources.head} $tree") {
               tree match {
                 case tree @ Inlined(_, bindings, expansion) if tree.inlinedFromOuterScope =>
@@ -46,7 +46,7 @@ class YCheckPositions extends Phase {
                   sources = old
                 case tree @ Inlined(call, bindings, expansion) =>
                   // bindings.foreach(traverse(_)) // TODO check inline proxies (see tests/tun/lst)
-                  sources = call.symbol.topLevelClass.source :: sources
+                  sources = call.symbol.source :: sources
                   if (!isMacro(call)) // FIXME macro implementations can drop Inlined nodes. We should reinsert them after macro expansion based on the positions of the trees
                     traverse(expansion)(using inlineContext(tree).withSource(sources.head))
                   sources = sources.tail
@@ -61,10 +61,10 @@ class YCheckPositions extends Phase {
 
   private def isMacro(call: Tree)(using Context) =
     call.symbol.is(Macro) ||
-    (call.symbol.isClass && call.tpe.derivesFrom(defn.MacroAnnotationClass)) ||
-    // The call of a macro after typer is encoded as a Select while other inlines are Ident
-    // TODO remove this distinction once Inline nodes of expanded macros can be trusted (also in Inliner.inlineCallTrace)
-    (!(ctx.phase <= postTyperPhase) && call.isInstanceOf[Select])
+        (call.symbol.isClass && call.tpe.derivesFrom(defn.MacroAnnotationClass)) ||
+    // In 3.0-3.3, the call of a macro after typer is encoded as a Select while other inlines are Ident.
+    // In those versions we kept the reference to the top-level class instead of the methods.
+    (!(ctx.phase <= postTyperPhase) && call.symbol.isClass && call.isInstanceOf[Select])
 
 }