Fix #8745: Match Ident prefixes to find potential holes

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -306,6 +306,9 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
       case _ => None
   }
 
+  def Ref_term(tp: TermRef)(using ctx: Context): Ref =
+    withDefaultPos(tpd.ref(tp).asInstanceOf[tpd.RefTree])
+
   def Ref_apply(sym: Symbol)(using ctx: Context): Ref = {
     assert(sym.isTerm)
     withDefaultPos(tpd.ref(sym).asInstanceOf[tpd.RefTree])

library/src/scala/internal/quoted/Matcher.scala

@@ -271,10 +271,14 @@ private[quoted] object Matcher {
           case (scrutinee, Typed(expr2, _)) =>
             scrutinee =?= expr2
 
-
           /* Match selection */
-          case (Select(qual1, _), Select(qual2, _)) if scrutinee.symbol == pattern.symbol =>
-            qual1 =?= qual2
+          case (ref: Ref, Select(qual2, _)) if scrutinee.symbol == pattern.symbol =>
+            ref match
+              case ref: Select => ref.qualifier =?= qual2
+              case _ =>
+                ref.tpe match
+                  case TermRef(qual: TermRef, _) => Ref.term(qual) =?= qual2
+                  case _ => matched
 
           /* Match reference */
           case (_: Ref, _: Ref) if scrutinee.symbol == pattern.symbol || summon[Env].get(scrutinee.symbol).contains(pattern.symbol) =>

library/src/scala/tasty/Reflection.scala

@@ -673,6 +673,10 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
 
   object Ref {
 
+    /** A tree representing the same reference as the given type */
+    def term(tp: TermRef)(using ctx: Context): Ref =
+      internal.Ref_term(tp)
+
     /** Create a reference tree from a symbol
      *
      *  If `sym` refers to a class member `foo` in class `C`,

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -319,6 +319,9 @@ trait CompilerInterface {
 
   def isInstanceOfRef(using ctx: Context): IsInstanceOf[Ref]
 
+  /** A tree representing the same reference as the given type */
+  def Ref_term(tp: TermRef)(using ctx: Context): Ref
+
   def Ref_apply(sym: Symbol)(using ctx: Context): Ref
 
   /** Tree representing a reference to definition with a given name */

tests/run-macros/i8745/Macro_1.scala

@@ -0,0 +1,16 @@
+import scala.quoted._
+
+object Companion extends Trait
+trait Trait {
+  def fun(first: String): String = "anything"
+}
+
+object Macro {
+  inline def mac(inline tree: String): String = ${ macImpl('tree) }
+  def macImpl(tree: Expr[String])(using qctx: QuoteContext): Expr[String] = {
+    tree match {
+        case vv @ '{ ($s: Trait).fun($arg) } => arg
+        case _ => Expr("not matched")
+    }
+  }
+}

tests/run-macros/i8745/Test_2.scala

@@ -0,0 +1,6 @@
+import Macro._
+
+@main def Test() = { //hello
+  import Companion._
+  mac(fun("blah"))
+}