Explicit excluded and required flags

som-snytt · som-snytt · commit 23a43f2b8790 · 2025-05-11T11:50:04.000-07:00
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
@@ -842,7 +842,10 @@ abstract class BCodeHelpers extends BCodeIdiomatic {
       // * Using `exitingUncurry` (not `enteringErasure`) because erasure enters bridges in traversal,
       //   not in the InfoTransform, so it actually modifies the type from the previous phase.
       //   Uncurry adds java varargs, which need to be included in the mirror class.
-      val members = exitingUncurry(moduleClass.info.membersBasedOnFlags(BCodeHelpers.ExcludedForwarderFlags, symtab.Flags.METHOD))
+      val members = exitingUncurry {
+        moduleClass.info
+          .membersBasedOnFlags(excluded = BCodeHelpers.ExcludedForwarderFlags, required = symtab.Flags.METHOD)
+      }
       for (m <- members) {
         val excl = m.isDeferred || m.isConstructor || m.hasAccessBoundary ||
           { val o = m.owner; (o eq ObjectClass) || (o eq AnyRefClass) || (o eq AnyClass) } ||
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -1054,7 +1054,7 @@ trait Definitions extends api.StandardDefinitions {
             //    Scopes()
             // must filter out "universal" members (getClass is deferred for some reason)
             val deferredMembers =
-              tpSym.info.membersBasedOnFlags(excludedFlags = BridgeAndPrivateFlags, requiredFlags = METHOD)
+              tpSym.info.membersBasedOnFlags(excluded = BridgeAndPrivateFlags, required = METHOD)
               .toList
               .filter(mem => mem.isDeferred && !isUniversalMember(mem))
 
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -3569,7 +3569,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def implicitMembers: Scope = {
       val tp = info
       if ((implicitMembersCacheKey1 ne tp) || (implicitMembersCacheKey2 ne tp.decls.elems)) {
-        implicitMembersCacheValue = tp.membersBasedOnFlags(BridgeFlags, IMPLICIT)
+        implicitMembersCacheValue = tp.membersBasedOnFlags(excluded = BridgeFlags, required = IMPLICIT)
         implicitMembersCacheKey1 = tp
         implicitMembersCacheKey2 = tp.decls.elems
       }
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
@@ -593,26 +593,27 @@ trait Types
      *  Members appear in linearization order of their owners.
      *  Members with the same owner appear in reverse order of their declarations.
      */
-    def members: Scope = membersBasedOnFlags(0, 0)
+    def members: Scope = membersBasedOnFlags(excluded = 0, required = 0)
 
     /** A list of all non-private members of this type (defined or inherited) */
-    def nonPrivateMembers: Scope = membersBasedOnFlags(BridgeAndPrivateFlags, 0)
+    def nonPrivateMembers: Scope = membersBasedOnFlags(excluded = BridgeAndPrivateFlags, required = 0)
 
     /** A list of all non-private members of this type  (defined or inherited),
      *  admitting members with given flags `admit`
      */
-    def nonPrivateMembersAdmitting(admit: Long): Scope = membersBasedOnFlags(BridgeAndPrivateFlags & ~admit, 0)
+    def nonPrivateMembersAdmitting(admit: Long): Scope =
+      membersBasedOnFlags(excluded = BridgeAndPrivateFlags & ~admit, required = 0)
 
     /** A list of all implicit symbols of this type  (defined or inherited) */
     def implicitMembers: Scope = {
       typeSymbolDirect match {
         case sym: ModuleClassSymbol => sym.implicitMembers
-        case _ => membersBasedOnFlags(BridgeFlags, IMPLICIT)
+        case _ => membersBasedOnFlags(excluded = BridgeFlags, required = IMPLICIT)
       }
     }
 
     /** A list of all deferred symbols of this type  (defined or inherited) */
-    def deferredMembers: Scope = membersBasedOnFlags(BridgeFlags, DEFERRED)
+    def deferredMembers: Scope = membersBasedOnFlags(excluded = BridgeFlags, required = DEFERRED)
 
     /** The member with given name,
      *  an OverloadedSymbol if several exist, NoSymbol if none exist */
@@ -649,8 +650,8 @@ trait Types
     /** Members excluding and requiring the given flags.
      *  Note: unfortunately it doesn't work to exclude DEFERRED this way.
      */
-    def membersBasedOnFlags(excludedFlags: Long, requiredFlags: Long): Scope =
-      findMembers(excludedFlags, requiredFlags)
+    def membersBasedOnFlags(excluded: Long, required: Long): Scope =
+      findMembers(excludedFlags = excluded, requiredFlags = required)
 
     def memberBasedOnName(name: Name, excludedFlags: Long): Symbol =
       findMember(name, excludedFlags, 0, stableOnly = false)

Original file line number	Diff line number	Diff line change
`@@ -3569,7 +3569,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>`
`3569`	`3569`	`def implicitMembers: Scope = {`
`3570`	`3570`	`val tp = info`
`3571`	`3571`	`if ((implicitMembersCacheKey1 ne tp) \|\| (implicitMembersCacheKey2 ne tp.decls.elems)) {`
`3572`		`- implicitMembersCacheValue = tp.membersBasedOnFlags(BridgeFlags, IMPLICIT)`
	`3572`	`+ implicitMembersCacheValue = tp.membersBasedOnFlags(excluded = BridgeFlags, required = IMPLICIT)`
`3573`	`3573`	`implicitMembersCacheKey1 = tp`
`3574`	`3574`	`implicitMembersCacheKey2 = tp.decls.elems`
`3575`	`3575`	`}`