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/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/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,7 @@ 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))
 
 }