Fix StaleSymbol for path dependent result type in macro context

The reason for the stale symbols was the fact that they were derived
from the previous (suspended) run (by calling a method from that run),
and path depended types seem to use an optimized path utilizing initial
designator, unlike the other kinds of types, which seem to either not
need calculating denotation or the denotation there is able to update
it's own validity.

Since that is impossible to do for those path dependent types, if they
are invalid in the run recaluclate the Symbol, otherwise use
`currentSymbol` as before.

Author: jchyb

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

@@ -2677,7 +2677,10 @@ object Types {
       else {
         if (isType) {
           val res =
-            if (currentSymbol.isAllOf(ClassTypeParam)) argForParam(prefix)
+            val sym =
+              if (currentSymbol.isValidInCurrentRun) currentSymbol
+              else computeSymbol
+            if (sym.isAllOf(ClassTypeParam)) argForParam(prefix)
             else prefix.lookupRefined(name)
           if (res.exists) return res
           if (Config.splitProjections)

Diff for: tests/neg-macros/i17152/DFBits.scala

@@ -0,0 +1,82 @@
+// nopos-error
+package crash
+
+import scala.quoted.*
+
+class IRDFType
+class IRDFBoolOrBit extends IRDFType
+class IRDFDecimal extends IRDFType
+class IRDFBits extends IRDFType
+
+final class DFType[+T <: IRDFType, +A]
+type DFTypeAny = DFType[IRDFType, Any]
+
+trait Baz
+
+trait Width[T]:
+  type Out <: Int
+object Width:
+  given fromDFBoolOrBit[T <: DFBoolOrBit]: Width[T] with
+    type Out = 1
+  transparent inline given [T]: Width[T] = ${ getWidthMacro[T] }
+  def getWidthMacro[T](using Quotes, Type[T]): Expr[Width[T]] =
+    '{
+      new Width[T]:
+        type Out = 1
+    }
+end Width
+
+extension [T](t: T)(using baz: Baz) def width: 1 = ???
+
+trait Check[T1 <: Int, T2 <: Int]
+
+type DFBits[W <: Int] = DFType[IRDFBits, Tuple1[W]]
+
+private object CompanionsDFBits:
+  object Val:
+    trait Candidate[R]:
+      type OutW <: Int
+      def apply(value: R): DFValOf[DFBits[OutW]]
+    object Candidate:
+      given fromDFUInt[W <: Int, R <: DFValOf[DFDecimal]]: Candidate[R] with
+        type OutW = W
+        def apply(value: R): DFValOf[DFBits[W]] =
+          import DFVal.Ops.bits
+          value.bits
+          ???
+    end Candidate
+
+    object TC:
+      import DFVal.TC
+      given DFBitsFromCandidate[
+          LW <: Int,
+          V
+      ](using candidate: Candidate[V])(using
+          check: Check[LW, candidate.OutW]
+      ): TC[DFBits[LW], V] with
+        def conv(dfType: DFBits[LW], value: V): DFValOf[DFBits[LW]] =
+          val dfVal = candidate(value)
+          ???
+    end TC
+  end Val
+
+end CompanionsDFBits
+
+type DFBoolOrBit = DFType[IRDFBoolOrBit, Any]
+type DFDecimal = DFType[IRDFDecimal, Any]
+object DFDecimal:
+  def foo(arg1: Int, arg2: Int): Unit = ???
+
+  object Val:
+    object TC:
+      import DFVal.TC
+      given [R]: TC[DFDecimal, R] = ???
+      def apply(
+          dfType: DFDecimal,
+          dfVal: DFValOf[DFDecimal]
+      ): DFValOf[DFDecimal] =
+        foo(dfType.width, dfVal.width)
+        dfVal
+    end TC
+  end Val
+end DFDecimal

Diff for: tests/neg-macros/i17152/DFVal.scala

@@ -0,0 +1,25 @@
+package crash
+
+trait TCConv[T <: DFTypeAny, V, O]:
+  type Out <: O
+  def conv(dfType: T, value: V): Out
+
+class DFVal[+T <: DFTypeAny]
+type DFValAny = DFVal[DFTypeAny]
+type DFValOf[+T <: DFTypeAny] = DFVal[T]
+
+object DFVal:
+  trait TC[T <: DFTypeAny, R] extends TCConv[T, R, DFValAny]:
+    type Out = DFValOf[T]
+    final def apply(dfType: T, value: R): Out = ???
+
+  object TC:
+    export CompanionsDFBits.Val.TC.given
+  end TC
+
+  object Ops:
+    extension [T <: DFTypeAny, A, C, I](dfVal: DFVal[T])
+      def bits(using w: Width[T]): DFValOf[DFBits[w.Out]] = ???
+    end extension
+  end Ops
+end DFVal

Diff for: tests/neg-macros/i17294/DFVal.scala

@@ -0,0 +1,3 @@
+package crash
+
+def bits[T](t: T)(using w: Width[T]): w.Out = ???

Diff for: tests/neg-macros/i17294/Width.scala

@@ -0,0 +1,12 @@
+// nopos-error
+package crash
+import scala.quoted.*
+
+trait Width[T]:
+  type Out
+object Width:
+  transparent inline given [T]: Width[T] = ${ getWidthMacro[T] }
+  def getWidthMacro[T](using Quotes, Type[T]): Expr[Width[T]] = '{ new Width[T] {} }
+end Width
+
+val x = bits(1)