Avoid using the current denotation in NamedType.disambiguate

While recalculating denotation in NamedType we might call
NamedType.disambiguate which uses a denotation to decide about
the correct overloaded method. Using current denotation here might cause
stale symbol errors, so instead we use the lastKnownDenotation,
which should be enough for the use case here, as targetName should not
change between phases/runs.

Later in the denotation recalculation a similar thing happens with
SourceLanguage.apply, where we also now avoid using currentDenotation,
as whether the symbol comes from java or Scala 2 should
also not change between phases/runs.

Author: jchyb

Diff for: compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -961,7 +961,7 @@ object Denotations {
     }
 
     def staleSymbolError(using Context): Nothing =
-      if symbol.isPackageObject && ctx.run != null && ctx.run.nn.isCompilingSuspended
+      if symbol.lastKnownDenotation.isPackageObject && ctx.run != null && ctx.run.nn.isCompilingSuspended
       then throw StaleSymbolTypeError(symbol)
       else throw StaleSymbolException(staleSymbolMsg)
 

Diff for: compiler/src/dotty/tools/dotc/core/TypeErasure.scala

@@ -24,11 +24,16 @@ enum SourceLanguage:
 object SourceLanguage:
   /** The language in which `sym` was defined. */
   def apply(sym: Symbol)(using Context): SourceLanguage =
-    if sym.is(JavaDefined) then
+    // We might be using this method while recalculating the denotation,
+    // so let's use `lastKnownDenotation`.
+    // This is ok as the source of the symbol and whether it is inline should
+    // not change between runs/phases.
+    val denot = sym.lastKnownDenotation
+    if denot.is(JavaDefined) then
       SourceLanguage.Java
     // Scala 2 methods don't have Inline set, except for the ones injected with `patchStdlibClass`
     // which are really Scala 3 methods.
-    else if sym.isClass && sym.is(Scala2x) || (sym.maybeOwner.is(Scala2x) && !sym.is(Inline)) then
+    else if denot.isClass && denot.is(Scala2x) || (denot.maybeOwner.lastKnownDenotation.is(Scala2x) && !denot.is(Inline)) then
       SourceLanguage.Scala2
     else
       SourceLanguage.Scala3

Diff for: compiler/src/dotty/tools/dotc/core/Types.scala

@@ -2491,7 +2491,10 @@ object Types extends TypeUtils {
     }
 
     private def disambiguate(d: Denotation)(using Context): Denotation =
-      disambiguate(d, currentSignature, currentSymbol.targetName)
+      // this method might be triggered while the denotation is already being recomputed
+      // in NamedType, so it's better to use lastKnownDenotation instead, as targetName
+      // should not change between phases/runs
+      disambiguate(d, currentSignature, currentSymbol.lastKnownDenotation.targetName)
 
     private def disambiguate(d: Denotation, sig: Signature | Null, target: Name)(using Context): Denotation =
       if (sig != null)

Diff for: tests/pos-macros/i20574/Exports.scala

@@ -0,0 +1,3 @@
+object Exports{
+  export OverloadedInline.*
+}

Diff for: tests/pos-macros/i20574/Macros.scala

@@ -0,0 +1,20 @@
+import scala.quoted.*
+
+object Macros{
+
+  inline def A() : String = {
+     ${ A_impl }
+  }
+
+  def A_impl(using Quotes): Expr[String] = {
+    Expr("Whatever")
+  }
+
+  inline def B[T]: Int = {
+    ${ B_Impl[T] }
+  }
+
+  def B_Impl[T](using Quotes): Expr[Int] = {
+    Expr(0)
+  }
+}

Diff for: tests/pos-macros/i20574/OverloadedInline.scala

@@ -0,0 +1,13 @@
+import Macros.*
+
+object OverloadedInline{
+
+    A()
+    inline def overloaded_inline[T]: Unit = {
+        overloaded_inline[T](0)
+    }
+
+    inline def overloaded_inline[T](dummy: Int): Unit = {
+        val crash = B[T]
+    }
+}

Diff for: tests/pos-macros/i20574/Test.scala

@@ -0,0 +1,5 @@
+import Exports.*
+
+object Test {
+   overloaded_inline[Unit]
+}