Properly handle self-types in reflection member lookup

The type on which we lookup things needs to be the this-type of the
class, otherwise it will not include members that only appear in the
self-type, since these members can appear in the types of members of the
current class, this could lead to a MissingType exception being thrown.

Fixes #12081.

Author: smarter

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2485,13 +2485,13 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
         def memberField(name: String): Symbol = fieldMember(name)
         def fieldMember(name: String): Symbol =
-          appliedTypeRef(self).allMembers.iterator.map(_.symbol).find {
+          self.thisType.allMembers.iterator.map(_.symbol).find {
             sym => isField(sym) && sym.name.toString == name
           }.getOrElse(dotc.core.Symbols.NoSymbol)
 
         def memberFields: List[Symbol] = fieldMembers
         def fieldMembers: List[Symbol] =
-          appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect {
+          self.thisType.allMembers.iterator.map(_.symbol).collect {
             case sym if isField(sym) => sym.asTerm
           }.toList
 
@@ -2507,13 +2507,13 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
         def memberMethod(name: String): List[Symbol] = methodMember(name)
         def methodMember(name: String): List[Symbol] =
-          appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect {
+          self.thisType.allMembers.iterator.map(_.symbol).collect {
             case sym if isMethod(sym) && sym.name.toString == name => sym.asTerm
           }.toList
 
         def memberMethods: List[Symbol] = methodMembers
         def methodMembers: List[Symbol] =
-          appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect {
+          self.thisType.allMembers.iterator.map(_.symbol).collect {
             case sym if isMethod(sym) => sym.asTerm
           }.toList
 

scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala

@@ -74,7 +74,7 @@ object SyntheticsSupport:
     import dotty.tools.dotc
     given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
     val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol]
-    sym.typeRef.appliedTo(sym.typeParams.map(_.typeRef)).allMembers.iterator.map(_.symbol)
+    dotc.core.Types.ThisType.raw(sym.typeRef).allMembers.iterator.map(_.symbol)
       .collect {
          case sym if
           (!sym.is(dotc.core.Flags.ModuleVal) || sym.is(dotc.core.Flags.Given)) &&

tests/run-macros/self.check

@@ -0,0 +1,2 @@
+MethodType(List(x), List(TypeRef(TermRef(TermRef(ThisType(TypeRef(NoPrefix,module class <root>)),object scala),Predef),String)), TypeRef(TypeRef(ThisType(TypeRef(ThisType(TypeRef(NoPrefix,module class <root>)),module class <empty>)),B),X))
+MethodType(List(x), List(TypeRef(TermRef(ThisType(TypeRef(NoPrefix,module class <root>)),object scala),Int)), TypeRef(TypeRef(ThisType(TypeRef(ThisType(TypeRef(NoPrefix,module class <root>)),module class <empty>)),B),X))

tests/run-macros/self/Macro_1.scala

@@ -0,0 +1,24 @@
+import scala.quoted.*
+
+trait A {
+  type X
+}
+trait B { self: A =>
+  def foo(x: Int): X
+  def foo(x: String): X
+}
+
+object Macros {
+
+  inline def test(): String = ${ testImpl }
+
+  private def testImpl(using Quotes) : Expr[String] = {
+    import quotes.reflect.*
+    val classTpe = TypeRepr.of[B]
+    val classSym = classTpe.classSymbol.get
+    val methSyms = classSym.methodMember("foo") // Used to throw a MissingType exception
+    val methTpes = methSyms.map(classTpe.memberType)
+    Expr(methTpes.map(_.toString).sorted.mkString("\n"))
+  }
+
+}

tests/run-macros/self/Test_2.scala

@@ -0,0 +1,8 @@
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    println(Macros.test())
+  }
+
+}