Rename reflect.Type { memberXyz => xyzMember }

Avoid ambigouity between `Type.memberType` and `Symbol.memberType`

Changes
* `memberField` -> `fieldMember`
* `memberFields` -> `fieldMembers`
* `memberMethod` -> `methodMember`
* `memberMethods` -> `methodMembers`
* `memberType` -> `typeMember`
* `memberTypes` -> `typeMembers`

Closes #12299

Author: nicolasstucki

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

@@ -2475,12 +2475,14 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
         def declaredFields: List[Symbol] = self.unforcedDecls.filter(isField)
 
-        def memberField(name: String): Symbol =
+        def memberField(name: String): Symbol = fieldMember(name)
+        def fieldMember(name: String): Symbol =
           appliedTypeRef(self).allMembers.iterator.map(_.symbol).find {
             sym => isField(sym) && sym.name.toString == name
           }.getOrElse(dotc.core.Symbols.NoSymbol)
 
-        def memberFields: List[Symbol] =
+        def memberFields: List[Symbol] = fieldMembers
+        def fieldMembers: List[Symbol] =
           appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect {
             case sym if isField(sym) => sym.asTerm
           }.toList
@@ -2495,12 +2497,14 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
             case sym if isMethod(sym) => sym.asTerm
           }.toList
 
-        def memberMethod(name: String): List[Symbol] =
+        def memberMethod(name: String): List[Symbol] = methodMember(name)
+        def methodMember(name: String): List[Symbol] =
           appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect {
             case sym if isMethod(sym) && sym.name.toString == name => sym.asTerm
           }.toList
 
-        def memberMethods: List[Symbol] =
+        def memberMethods: List[Symbol] = methodMembers
+        def methodMembers: List[Symbol] =
           appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect {
             case sym if isMethod(sym) => sym.asTerm
           }.toList
@@ -2515,10 +2519,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
             case sym if sym.isType => sym.asType
           }.toList
 
-        def memberType(name: String): Symbol =
+        def memberType(name: String): Symbol = typeMember(name)
+        def typeMember(name: String): Symbol =
           self.unforcedDecls.find(sym => sym.name == name.toTypeName)
 
-        def memberTypes: List[Symbol] =
+        def memberTypes: List[Symbol] = typeMembers
+        def typeMembers: List[Symbol] =
           self.unforcedDecls.filter(_.isType)
 
         def declarations: List[Symbol] =

library/src/scala/quoted/Quotes.scala

@@ -3578,35 +3578,59 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         def declaredFields: List[Symbol]
 
         /** Get named non-private fields declared or inherited */
+        @deprecated("Use memberField", "3.1")
         def memberField(name: String): Symbol
 
+        /** Get named non-private fields declared or inherited */
+        def fieldMember(name: String): Symbol
+
         /** Get all non-private fields declared or inherited */
+        @deprecated("Use memberFields", "3.1")
         def memberFields: List[Symbol]
 
+        /** Get all non-private fields declared or inherited */
+        def fieldMembers: List[Symbol]
+
         /** Get non-private named methods defined directly inside the class */
         def declaredMethod(name: String): List[Symbol]
 
         /** Get all non-private methods defined directly inside the class, excluding constructors */
         def declaredMethods: List[Symbol]
 
         /** Get named non-private methods declared or inherited */
+        @deprecated("Use methodMember", "3.1")
         def memberMethod(name: String): List[Symbol]
 
+        /** Get named non-private methods declared or inherited */
+        def methodMember(name: String): List[Symbol]
+
         /** Get all non-private methods declared or inherited */
+        @deprecated("Use methodMembers", "3.1")
         def memberMethods: List[Symbol]
 
+        /** Get all non-private methods declared or inherited */
+        def methodMembers: List[Symbol]
+
         /** Get non-private named methods defined directly inside the class */
         def declaredType(name: String): List[Symbol]
 
         /** Get all non-private methods defined directly inside the class, excluding constructors */
         def declaredTypes: List[Symbol]
 
         /** Type member with the given name directly declared in the class */
+        @deprecated("Use typeMember", "3.1")
         def memberType(name: String): Symbol
 
+        /** Type member with the given name directly declared in the class */
+        def typeMember(name: String): Symbol
+
         /** Type member directly declared in the class */
+        @deprecated("Use typeMembers", "3.1")
         def memberTypes: List[Symbol]
 
+        /** Type member directly declared in the class */
+        def typeMembers: List[Symbol]
+
         /** All members directly declared in the class */
         def declarations: List[Symbol]
 

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

@@ -126,7 +126,7 @@ trait ClassLikeSupport:
         }
       // TODO check given methods?
       case dd: DefDef if !dd.symbol.isHiddenByVisibility && dd.symbol.isGiven && !dd.symbol.isArtifact =>
-        Some(dd.symbol.owner.memberType(dd.name))
+        Some(dd.symbol.owner.typeMember(dd.name))
           .filterNot(_.exists)
           .map { _ =>
             parseMethod(c, dd.symbol, specificKind =
@@ -166,7 +166,7 @@ trait ClassLikeSupport:
       case vd: ValDef if !isSyntheticField(vd.symbol) && (!vd.symbol.flags.is(Flags.Case) || !vd.symbol.flags.is(Flags.Enum)) =>
         Some(parseValDef(c, vd))
 
-      case c: ClassDef if c.symbol.owner.memberMethod(c.name).exists(_.flags.is(Flags.Given)) =>
+      case c: ClassDef if c.symbol.owner.methodMember(c.name).exists(_.flags.is(Flags.Given)) =>
         Some(parseGivenClasslike(c))
 
       case c: ClassDef if c.symbol.shouldDocumentClasslike &&  !c.symbol.isGiven =>
@@ -202,7 +202,7 @@ trait ClassLikeSupport:
     def inheritance = Some(InheritedFrom(s.symbol.owner.normalizedName, s.symbol.dri))
     processTreeOpt(s)(s match
       case c: ClassDef if c.symbol.shouldDocumentClasslike && !c.symbol.isGiven => Some(parseClasslike(c, signatureOnly = true))
-      case c: ClassDef if c.symbol.owner.memberMethod(c.name).exists(_.flags.is(Flags.Given)) => Some(parseGivenClasslike(c))
+      case c: ClassDef if c.symbol.owner.methodMember(c.name).exists(_.flags.is(Flags.Given)) => Some(parseGivenClasslike(c))
       case other => {
         val parsed = parseMember(c)(other)
         parsed.map(p =>

scaladoc/test/dotty/tools/scaladoc/tasty/comments/MemberLookupTests.scala

@@ -141,9 +141,9 @@ class LookupTestCases[Q <: Quotes](val q: Quotes) {
         if s.flags.is(q.reflect.Flags.Module) then s.moduleClass else s
       Sym(hackResolveModule(symbol.declaredField(name)))
     def fun(name: String) =
-      val List(sym) = symbol.memberMethod(name)
+      val List(sym) = symbol.methodMember(name)
       Sym(sym)
-    def tpe(name: String) = Sym(symbol.memberType(name))
+    def tpe(name: String) = Sym(symbol.typeMember(name))
   }
 
   def cls(fqn: String) = Sym(q.reflect.Symbol.classSymbol(fqn))