Replace symbol travelsal with tree traversal when finding top level e…

…xperimentals

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -804,20 +804,23 @@ object Checking {
    *
    */
   def checkAndAdaptExperimentalImports(trees: List[Tree])(using Context): Unit =
-    def nonExperimentalTopLevelDefs(pack: Symbol): Iterator[Symbol] =
-      def isNonExperimentalTopLevelDefinition(sym: Symbol) =
-        sym.isDefinedInCurrentRun
-        && sym.source == ctx.compilationUnit.source
-        && !sym.isConstructor // not constructor of package object
-        && !sym.is(Package) && !sym.name.isPackageObjectName
-        && !sym.isExperimental
-
-      pack.info.decls.toList.iterator.flatMap: sym =>
-        if sym.isClass && (sym.is(Package) || sym.isPackageObject) then
-          nonExperimentalTopLevelDefs(sym)
-        else if isNonExperimentalTopLevelDefinition(sym) then
-          sym :: Nil
-        else Nil
+    def nonExperimentalTopLevelDefs(): Iterator[Symbol] =
+      new TreeAccumulator[List[Symbol]] {
+        override def apply(x: List[Symbol], tree: tpd.Tree)(using Context): List[Symbol] =
+        def addIfExperimental(sym: Symbol) =
+          if !sym.isExperimental then sym :: x
+          else x
+        tree match {
+          case tpd.PackageDef(_, contents) =>
+            super.apply(x, contents)
+          case defdef: tpd.DefDef => addIfExperimental(defdef.symbol)
+          case valdef: tpd.ValDef => addIfExperimental(valdef.symbol)
+          case typeDef @ tpd.TypeDef(_, temp: Template) if typeDef.symbol.isPackageObject =>
+            super.apply(x, temp.body)
+          case typeDef @ tpd.TypeDef(_, Template(_, _, _, _)) => addIfExperimental(typeDef.symbol)
+          case _ => x
+        }
+      }.apply(Nil, ctx.compilationUnit.tpdTree).iterator
 
     def unitExperimentalLanguageImports =
       def isAllowedImport(sel: untpd.ImportSelector) =
@@ -835,7 +838,7 @@ object Checking {
 
     if ctx.owner.is(Package) || ctx.owner.name.startsWith(str.REPL_SESSION_LINE) then
       def markTopLevelDefsAsExperimental(why: String): Unit =
-        for sym <- nonExperimentalTopLevelDefs(ctx.owner) do
+        for sym <- nonExperimentalTopLevelDefs() do
           sym.addAnnotation(ExperimentalAnnotation(s"Added by $why", sym.span))
 
       unitExperimentalLanguageImports match

tests/pos-macros/i21802/Macro.scala

@@ -0,0 +1,15 @@
+class MetricsGroup[A]
+object MetricsGroup:
+  import scala.quoted.*
+
+  transparent inline final def refine[A]: MetricsGroup[A] =
+    ${ refineImpl[A] }
+
+  private def refineImpl[A](using qctx: Quotes, tpe: Type[A]): Expr[MetricsGroup[A]] =
+    import qctx.reflect.*
+
+    val mt = MethodType(Nil)(_ => Nil, _ => TypeRepr.of[A])
+    val tpe = Refinement(TypeRepr.of[MetricsGroup[A]], "apply", mt).asType
+    tpe match
+      case '[tpe] =>
+        '{ MetricsGroup[A]().asInstanceOf[MetricsGroup[A] & tpe] }

tests/pos-macros/i21802/Test.scala

@@ -0,0 +1,13 @@
+//> using options -experimental -Ydebug
+
+class ProbeFailedException(cause: Exception) extends Exception(cause)
+trait Probing:
+  self: Metrics =>
+    val probeFailureCounter: MetricsGroup[Counter] =
+      counters("ustats_probe_failures_count").labelled
+
+
+trait Counter
+class Metrics:
+  class counters(name: String):
+    transparent inline final def labelled: MetricsGroup[Counter] = MetricsGroup.refine[Counter]