graphql 2.6.12 → 2.6.13

data/lib/graphql/schema/validator/required_validator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
@@ -8,44 +9,57 @@ module GraphQL
       #
       # (This is for specifying mutually exclusive sets of arguments.)
       #
-      # If you use {GraphQL::Schema::Visibility} to hide all the arguments in a `one_of: [..]` set,
-      # then a developer-facing {GraphQL::Error} will be raised during execution. Pass `allow_all_hidden: true` to
+      # If you use [GraphQL::Schema::Visibility](rdoc-ref:GraphQL::Schema::Visibility) to hide all the arguments in a `one_of: [..]` set,
+      # then a developer-facing [GraphQL::Error](rdoc-ref:GraphQL::Error) will be raised during execution. Pass `allow_all_hidden: true` to
       # skip validation in this case instead.
       #
       # This validator also implements `argument ... required: :nullable`. If an argument has `required: :nullable`
-      # but it's hidden with {GraphQL::Schema::Visibility}, then this validator doesn't run.
+      # but it's hidden with [GraphQL::Schema::Visibility](rdoc-ref:GraphQL::Schema::Visibility), then this validator doesn't run.
       #
-      # @example Require exactly one of these arguments
+      # **Examples**
       #
-      #   field :update_amount, IngredientAmount, null: false do
-      #     argument :ingredient_id, ID, required: true
-      #     argument :cups, Integer, required: false
-      #     argument :tablespoons, Integer, required: false
-      #     argument :teaspoons, Integer, required: false
-      #     validates required: { one_of: [:cups, :tablespoons, :teaspoons] }
-      #   end
+      # **Example: Require exactly one of these arguments**
       #
-      # @example Require one of these _sets_ of arguments
+      # ```ruby
+      # field :update_amount, IngredientAmount, null: false do
+      #   argument :ingredient_id, ID, required: true
+      #   argument :cups, Integer, required: false
+      #   argument :tablespoons, Integer, required: false
+      #   argument :teaspoons, Integer, required: false
+      #   validates required: { one_of: [:cups, :tablespoons, :teaspoons] }
+      # end
+      # ```
       #
-      #  field :find_object, Node, null: true do
-      #    argument :node_id, ID, required: false
-      #    argument :object_type, String, required: false
-      #    argument :object_id, Integer, required: false
-      #    # either a global `node_id` or an `object_type`/`object_id` pair is required:
-      #    validates required: { one_of: [:node_id, [:object_type, :object_id]] }
-      #  end
+      # **Example: Require one of these _sets_ of arguments**
       #
-      # @example require _some_ value for an argument, even if it's null
-      #   field :update_settings, AccountSettings do
-      #     # `required: :nullable` means this argument must be given, but may be `null`
-      #     argument :age, Integer, required: :nullable
-      #   end
+      # ```ruby
+      # field :find_object, Node, null: true do
+      #   argument :node_id, ID, required: false
+      #   argument :object_type, String, required: false
+      #   argument :object_id, Integer, required: false
+      #   # either a global `node_id` or an `object_type`/`object_id` pair is required:
+      #   validates required: { one_of: [:node_id, [:object_type, :object_id]] }
+      # end
+      # ```
       #
+      # **Example: require _some_ value for an argument, even if it's null**
+      #
+      # ```ruby
+      # field :update_settings, AccountSettings do
+      #   # `required: :nullable` means this argument must be given, but may be `null`
+      #   argument :age, Integer, required: :nullable
+      # end
+      # ```
       class RequiredValidator < Validator
-        # @param one_of [Array<Symbol>] A list of arguments, exactly one of which is required for this field
-        # @param argument [Symbol] An argument that is required for this field
-        # @param allow_all_hidden [Boolean] If `true`, then this validator won't run if all the `one_of: ...` arguments have been hidden
-        # @param message [String]
+        # **Parameters**
+        #
+        # - `one_of` (`Array<Symbol>`) — A list of arguments, exactly one of which is required for this field
+        # - `argument` (`Symbol`) — An argument that is required for this field
+        # - `allow_all_hidden` (`Boolean`) — If `true`, then this validator won't run if all the `one_of: ...` arguments have been hidden
+        # - `message` (`String`)
+        #
+        # :call-seq:
+        #   initialize(Array[Symbol] one_of:, Symbol argument:, bool allow_all_hidden:, String message:, **default_options)
         def initialize(one_of: nil, argument: nil, allow_all_hidden: nil, message: nil, **default_options)
           @one_of = if one_of
             one_of
@@ -64,7 +78,7 @@ module GraphQL
           partially_matched_conditions = 0
 
           visible_keywords = context.types.arguments(@validated).map(&:keyword)
-          no_visible_conditions = true
+          no_visible_conditions = true #: bool
 
           if !value.nil?
             validation_parameter(@one_of).each do |one_of_condition|
@@ -79,8 +93,8 @@ module GraphQL
                   fully_matched_conditions += 1
                 end
               when Array
-                any_match = false
-                full_match = true
+                any_match = false #: bool
+                full_match = true #: bool
 
                 one_of_condition.each do |k|
                   if no_visible_conditions && visible_keywords.include?(k)

data/lib/graphql/schema/validator.rb

@@ -1,25 +1,42 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
     class Validator
       # The thing being validated
-      # @return [GraphQL::Schema::Argument, GraphQL::Schema::Field, GraphQL::Schema::Resolver, Class<GraphQL::Schema::InputObject>]
+      #
+      # **Returns**
+      #
+      # - `GraphQL::Schema::Argument, GraphQL::Schema::Field, GraphQL::Schema::Resolver, Class<GraphQL::Schema::InputObject>`
       attr_reader :validated
 
-      # @param validated [GraphQL::Schema::Argument, GraphQL::Schema::Field, GraphQL::Schema::Resolver, Class<GraphQL::Schema::InputObject>] The argument or argument owner this validator is attached to
-      # @param allow_blank [Boolean] if `true`, then objects that respond to `.blank?` and return true for `.blank?` will skip this validation
-      # @param allow_null [Boolean] if `true`, then incoming `null`s will skip this validation
+      # **Parameters**
+      #
+      # - `validated` (`GraphQL::Schema::Argument, GraphQL::Schema::Field, GraphQL::Schema::Resolver, Class<GraphQL::Schema::InputObject>`) — The argument or argument owner this validator is attached to
+      # - `allow_blank` (`Boolean`) — if `true`, then objects that respond to `.blank?` and return true for `.blank?` will skip this validation
+      # - `allow_null` (`Boolean`) — if `true`, then incoming `null`s will skip this validation
+      #
+      # :call-seq:
+      #   initialize(GraphQL::Schema::Argument | GraphQL::Schema::Field | GraphQL::Schema::Resolver | Class[GraphQL::Schema::InputObject] validated:, bool allow_blank:, bool allow_null:)
       def initialize(validated:, allow_blank: false, allow_null: false)
         @validated = validated
         @allow_blank = allow_blank
         @allow_null = allow_null
       end
 
-      # @param object [Object] The application object that this argument's field is being resolved for
-      # @param context [GraphQL::Query::Context]
-      # @param value [Object] The client-provided value for this argument (after parsing and coercing by the input type)
-      # @return [nil, Array<String>, String] Error message or messages to add
+      # **Parameters**
+      #
+      # - `object` (`Object`) — The application object that this argument's field is being resolved for
+      # - `context` (`GraphQL::Query::Context`)
+      # - `value` (`Object`) — The client-provided value for this argument (after parsing and coercing by the input type)
+      #
+      # **Returns**
+      #
+      # - `nil, Array<String>, String` — Error message or messages to add
+      #
+      # :call-seq:
+      #   validate(Object object, GraphQL::Query::Context context, Object value) -> nil | Array[String] | String
       def validate(object, context, value)
         raise GraphQL::RequiredImplementationMissingError, "Validator classes should implement #validate"
       end
@@ -34,7 +51,12 @@ module GraphQL
         string
       end
 
-      # @return [Object] The current value to use for validation, based on `config_value` from configuration time. If a Proc is given, this calls it and returns it.
+      # **Returns**
+      #
+      # - `Object` — The current value to use for validation, based on `config_value` from configuration time. If a Proc is given, this calls it and returns it.
+      #
+      # :call-seq:
+      #   validation_parameter(config_value) -> Object
       def validation_parameter(config_value)
         if config_value.is_a?(Proc)
           config_value.call
@@ -43,15 +65,28 @@ module GraphQL
         end
       end
 
-      # @return [Boolean] `true` if `value` is `nil` and this validator has `allow_null: true` or if value is `.blank?` and this validator has `allow_blank: true`
+      # **Returns**
+      #
+      # - `Boolean` — `true` if `value` is `nil` and this validator has `allow_null: true` or if value is `.blank?` and this validator has `allow_blank: true`
+      #
+      # :call-seq:
+      #   permitted_empty_value?(value) -> bool
       def permitted_empty_value?(value)
         (value.nil? && @allow_null) ||
           (@allow_blank && value.respond_to?(:blank?) && value.blank?)
       end
 
-      # @param schema_member [GraphQL::Schema::Field, GraphQL::Schema::Argument, Class<GraphQL::Schema::InputObject>]
-      # @param validates_hash [Hash{Symbol => Hash}, Hash{Class => Hash} nil] A configuration passed as `validates:`
-      # @return [Array<Validator>]
+      # **Parameters**
+      #
+      # - `schema_member` (`GraphQL::Schema::Field, GraphQL::Schema::Argument, Class<GraphQL::Schema::InputObject>`)
+      # - `validates_hash` (`Hash{Symbol => Hash}, Hash{Class => Hash} nil`) — A configuration passed as `validates:`
+      #
+      # **Returns**
+      #
+      # - `Array<Validator>`
+      #
+      # :call-seq:
+      #   from_config(GraphQL::Schema::Field | GraphQL::Schema::Argument | Class[GraphQL::Schema::InputObject] schema_member, Hash[Symbol, Hash] | Hash[Class, Hash] nil validates_hash) -> Array[Validator]
       def self.from_config(schema_member, validates_hash)
         if validates_hash.nil? || validates_hash.empty?
           EMPTY_ARRAY
@@ -89,17 +124,35 @@ module GraphQL
 
       # Add `validator_class` to be initialized when `validates:` is given `name`.
       # (It's initialized with whatever options are given by the key `name`).
-      # @param name [Symbol]
-      # @param validator_class [Class]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `name` (`Symbol`)
+      # - `validator_class` (`Class`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   install(Symbol name, Class validator_class) -> void
       def self.install(name, validator_class)
         all_validators[name] = validator_class
         nil
       end
 
-      # Remove whatever validator class is {.install}ed at `name`, if there is one
-      # @param name [Symbol]
-      # @return [void]
+      # Remove whatever validator class is [.install](rdoc-ref:.install)ed at `name`, if there is one
+      #
+      # **Parameters**
+      #
+      # - `name` (`Symbol`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   uninstall(Symbol name) -> void
       def self.uninstall(name)
         all_validators.delete(name)
         nil
@@ -122,12 +175,23 @@ module GraphQL
         end
       end
 
-      # @param validators [Array<Validator>]
-      # @param object [Object]
-      # @param context [Query::Context]
-      # @param value [Object]
-      # @return [void]
-      # @raises [ValidationFailedError]
+      # **Parameters**
+      #
+      # - `validators` (`Array<Validator>`)
+      # - `object` (`Object`)
+      # - `context` (`Query::Context`)
+      # - `value` (`Object`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # **Raises**
+      #
+      # - `ValidationFailedError`
+      #
+      # :call-seq:
+      #   validate!(Array[Validator] validators, Object object, Query::Context context, Object value, as:) -> void | ValidationFailedError
       def self.validate!(validators, object, context, value, as: nil)
         # Assuming the default case is no errors, reduce allocations in that case.
         # This will be replaced with a mutable array if we actually get any errors.

data/lib/graphql/schema/visibility/migration.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class Schema
     class Visibility
-      # You can use this to see how {GraphQL::Schema::Warden} and {GraphQL::Schema::Visibility::Profile}
+      # You can use this to see how [GraphQL::Schema::Warden](rdoc-ref:GraphQL::Schema::Warden) and [GraphQL::Schema::Visibility::Profile](rdoc-ref:GraphQL::Schema::Visibility::Profile)
       # handle `.visible?` differently in your schema.
       #
       # It runs the same method on both implementations and raises an error when the results diverge.
@@ -15,17 +16,20 @@ module GraphQL
       # This plugin adds two keys to `context` when running:
       #
       # - `visibility_migration_running: true`
-      # - For the {Schema::Warden} which it instantiates, it adds `visibility_migration_warden_running: true`.
+      # - For the [Schema::Warden](rdoc-ref:Schema::Warden) which it instantiates, it adds `visibility_migration_warden_running: true`.
       #
       # Use those keys to modify your `visible?` behavior as needed.
       #
       # Also, in a pinch, you can set `skip_visibility_migration_error: true` in context to turn off this behavior per-query.
-      # (In that case, it uses {Profile} directly.)
+      # (In that case, it uses [Profile](rdoc-ref:Profile) directly.)
       #
-      # @example Adding this plugin
+      # **Examples**
       #
-      #   use GraphQL::Schema::Visibility, migration_errors: true
+      # **Example: Adding this plugin**
       #
+      # ```ruby
+      # use GraphQL::Schema::Visibility, migration_errors: true
+      # ```
       class Migration < GraphQL::Schema::Visibility::Profile
         class RuntimeTypesMismatchError < GraphQL::Error
           def initialize(method_called, warden_result, profile_result, method_args)
@@ -46,7 +50,7 @@ module GraphQL
               all_results = warden_result | profile_result
               all_results.sort_by!(&:graphql_name)
 
-              entries_text = all_results.map { |entry| "#{entry.graphql_name} (#{entry})"}
+              entries_text = all_results.map { |entry| "#{entry.graphql_name} (#{entry})"} #: untyped
               width = entries_text.map(&:size).max
               yes = "    ✔   "
               no =  "        "
@@ -66,6 +70,7 @@ module GraphQL
               "#{val.size}: #{val.map { |v| humanize(v) }.sort.inspect}"
             when Module
               if val.respond_to?(:graphql_name)
+                val = val #: as GraphQL::Schema::Member::type_definition
                 "#{val.graphql_name} (#{val.inspect})"
               else
                 val.inspect
@@ -87,7 +92,7 @@ module GraphQL
             if schema.const_defined?(:WardenCompatSchema, false) # don't use a defn from a superclass
               warden_schema = schema.const_get(:WardenCompatSchema, false)
             else
-              warden_schema = Class.new(schema)
+              warden_schema = Class.new(schema) #: as singleton(GraphQL::Schema)
               warden_schema.use_visibility_profile = false
               # TODO public API
               warden_schema.send(:add_type_and_traverse, [warden_schema.query, warden_schema.mutation, warden_schema.subscription].compact, root: true)
@@ -129,6 +134,7 @@ module GraphQL
 
         PUBLIC_PROFILE_METHODS.each do |profile_method|
           define_method(profile_method) do |*args|
+            #: self as GraphQL::Schema::Visibility::Migration
             call_method_and_compare(profile_method, args)
           end
         end
@@ -173,6 +179,7 @@ module GraphQL
               member1 == member2
             end
           when Module
+            member1 = member1 #: as GraphQL::Schema::Member::type_definition
             if member1.introspection? && member2.introspection?
               member1.graphql_name == member2.graphql_name
             else

data/lib/graphql/schema/visibility/profile.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Schema
@@ -6,14 +7,19 @@ module GraphQL
       # This class filters the types, fields, arguments, enum values, and directives in a schema
       # based on the given `context`.
       #
-      # It's like {Warden}, but has some differences:
+      # It's like `Warden`, but has some differences:
       #
-      # - It doesn't use {Schema}'s top-level caches (eg {Schema.references_to}, {Schema.possible_types}, {Schema.types})
+      # - It doesn't use [Schema](rdoc-ref:GraphQL::Schema)'s top-level caches (eg [Schema.references_to](rdoc-ref:GraphQL::Schema.references_to), [Schema.possible_types](rdoc-ref:GraphQL::Schema.possible_types), [Schema.types](rdoc-ref:GraphQL::Schema.types))
       # - It doesn't hide Interface or Union types when all their possible types are hidden. (Instead, those types should implement `.visible?` to hide in that case.)
       # - It checks `.visible?` on root introspection types
       # - It can be used to cache profiles by name for re-use across queries
       class Profile
-        # @return [Schema::Visibility::Profile]
+        # **Returns**
+        #
+        # - `Schema::Visibility::Profile`
+        #
+        # :call-seq:
+        #   from_context(ctx, schema) -> Schema::Visibility::Profile
         def self.from_context(ctx, schema)
           if ctx.respond_to?(:types) && (types = ctx.types).is_a?(self)
             types
@@ -22,13 +28,9 @@ module GraphQL
           end
         end
 
-        def self.null_profile(context:, schema:)
-          profile = self.new(name: "NullProfile", context: context, schema: schema)
-          profile.instance_variable_set(:@cached_visible, Hash.new { |k, v| k[v] = true }.compare_by_identity)
-          profile
-        end
-
-        # @return [Symbol, nil]
+        # **Returns**
+        #
+        # - `Symbol, nil`
         attr_reader :name
 
         def freeze
@@ -158,8 +160,8 @@ module GraphQL
           ints = owner.interface_type_memberships.map(&:abstract_type)
           field_name = field.graphql_name
           filtered_ints = interfaces(owner)
-          any_interface_has_field = false
-          any_interface_has_visible_field = false
+          any_interface_has_field = false #: bool
+          any_interface_has_visible_field = false #: bool
           ints.each do |int_t|
             if (_int_f_defn = @cached_parent_fields[int_t][field_name])
               any_interface_has_field = true
@@ -197,7 +199,7 @@ module GraphQL
         def argument(owner, arg_name)
           arg = @cached_parent_arguments[owner][arg_name]
           if arg.is_a?(Array)
-            visible_arg = nil
+            visible_arg = nil #: untyped
             arg.each do |arg_defn|
               if @cached_visible_arguments[owner][arg_defn]
                 if visible_arg.nil?
@@ -363,7 +365,7 @@ module GraphQL
           t = @visibility.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
           if t
             if t.is_a?(Array)
-              vis_t = nil
+              vis_t = nil #: untyped
               t.each do |t_defn|
                 if @cached_visible[t_defn] && referenced?(t_defn)
                   if vis_t.nil?
@@ -375,7 +377,7 @@ module GraphQL
               end
               vis_t
             else
-              if t && @cached_visible[t] && referenced?(t)
+              if @cached_visible[t] && referenced?(t)
                 t
               else
                 nil
@@ -395,7 +397,7 @@ module GraphQL
             nil
           end
           if f.is_a?(Array)
-            visible_f = nil
+            visible_f = nil #: untyped
             f.each do |f_defn|
               if @cached_visible_fields[owner][f_defn]
                 if visible_f.nil?
@@ -438,7 +440,8 @@ module GraphQL
           visit = Visibility::Visit.new(@schema) do |member|
             if member.is_a?(Module) && member.respond_to?(:kind)
               if @cached_visible[member] && referenced?(member)
-                type_name = member.graphql_name
+                type_name = member #: as untyped
+                  .graphql_name
                 if (prev_t = @all_types[type_name]) && !prev_t.equal?(member)
                   raise_duplicate_definition(member, prev_t)
                 end

data/lib/graphql/schema/visibility/visit.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class Schema
     class Visibility
@@ -42,7 +43,8 @@ module GraphQL
                 case type.kind.name
                 when "OBJECT", "INTERFACE"
                   type.interface_type_memberships.each do |itm|
-                    append_unvisited_type(type, itm.abstract_type)
+                    # Late-bound interfaces are stored as a String or LateBoundType instead of a TypeMembership
+                    append_unvisited_type(type, itm.respond_to?(:abstract_type) ? itm.abstract_type : itm)
                   end
                   if type.kind.interface?
                     type.orphan_types.each do |orphan_type|
@@ -135,11 +137,14 @@ module GraphQL
         def update_type_owner(owner, type)
           case owner
           when Module
+            owner = owner #: as GraphQL::Schema::Member::type_definition
             if owner.kind.union?
-              owner.assign_type_membership_object_type(type)
+              union_type = owner #: as singleton(GraphQL::Schema::Union)
+              union_type.assign_type_membership_object_type(type)
             elsif type.kind.interface?
+              implementing_type = owner #: as GraphQL::Schema::Member::HasInterfaces
               new_interfaces = []
-              owner.interfaces.each do |int_t|
+              implementing_type.interfaces.each do |int_t|
                 if int_t.is_a?(String) && int_t == type.graphql_name
                   new_interfaces << type
                 elsif int_t.is_a?(LateBoundType) && int_t.graphql_name == type.graphql_name
@@ -149,15 +154,12 @@ module GraphQL
                   # they were probably already added, maybe with options.
                 end
               end
-              owner.implements(*new_interfaces)
+              implementing_type.implements(*new_interfaces)
               new_interfaces.each do |int|
-                pt = @possible_types[int] ||= []
-                if !pt.include?(owner) && owner.is_a?(Class)
-                  pt << owner
-                end
                 int.interfaces.each do |indirect_int|
-                  if indirect_int.is_a?(LateBoundType) && (indirect_int_type = get_type(indirect_int.graphql_name)) # rubocop:disable Development/ContextIsPassedCop
-                    update_type_owner(owner, indirect_int_type)
+                  if indirect_int.is_a?(LateBoundType) || indirect_int.is_a?(String)
+                    # Resolve it like any other late-bound type, then add it to `owner`, too
+                    append_unvisited_type(owner, indirect_int)
                   end
                 end
               end

data/lib/graphql/schema/visibility.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "graphql/schema/visibility/profile"
 require "graphql/schema/visibility/migration"
 require "graphql/schema/visibility/visit"
@@ -14,10 +15,15 @@ module GraphQL
           super(message)
         end
       end
-      # @param schema [Class<GraphQL::Schema>]
-      # @param profiles [Hash<Symbol => Hash>] A hash of `name => context` pairs for preloading visibility profiles
-      # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?` and `Rails.env.staging?`)
-      # @param migration_errors [Boolean] if `true`, raise an error when `Visibility` and `Warden` return different results
+      # **Parameters**
+      #
+      # - `schema` (`Class<GraphQL::Schema>`)
+      # - `profiles` (`Hash<Symbol => Hash>`) — A hash of `name => context` pairs for preloading visibility profiles
+      # - `preload` (`Boolean`) — if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?` and `Rails.env.staging?`)
+      # - `migration_errors` (`Boolean`) — if `true`, raise an error when `Visibility` and `Warden` return different results
+      #
+      # :call-seq:
+      #   use(Class[GraphQL::Schema] schema, dynamic:, Hash[Symbol, Hash] profiles:, bool preload:)
       def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? (Rails.env.production? || Rails.env.staging? || nil) : false), migration_errors: false)
         profiles&.each { |name, ctx|
           ctx[:visibility_profile] = name
@@ -108,35 +114,32 @@ module GraphQL
         end
       end
 
-      # @api private
-      def query_configured(query_type)
+      def query_configured(query_type) # :nodoc:
         require_if_preloaded("a query type was", "query(...)")
       end
 
-      # @api private
-      def mutation_configured(mutation_type)
+      def mutation_configured(mutation_type) # :nodoc:
         require_if_preloaded("a mutation type was", "mutation(...)")
       end
 
-      # @api private
-      def subscription_configured(subscription_type)
+      def subscription_configured(subscription_type) # :nodoc:
         require_if_preloaded("a mutation type was", "subscription(...)")
       end
 
-      # @api private
-      def orphan_types_configured(orphan_types)
+      def orphan_types_configured(orphan_types) # :nodoc:
         require_if_preloaded("orphan types were", "orphan_types(...)")
       end
 
-      # @api private
-      def introspection_system_configured(introspection_system)
+      def introspection_system_configured(introspection_system) # :nodoc:
         require_if_preloaded("custom introspection was", "introspection(...)")
       end
 
       # Make another Visibility for `schema` based on this one
-      # @return [Visibility]
-      # @api private
-      def dup_for(other_schema)
+      #
+      # **Returns**
+      #
+      # - `Visibility`
+      def dup_for(other_schema) # :nodoc:
         self.class.new(
           other_schema,
           dynamic: @dynamic,
@@ -179,8 +182,7 @@ module GraphQL
 
       attr_reader :top_level
 
-      # @api private
-      attr_reader :unfiltered_interface_type_memberships
+      attr_reader :unfiltered_interface_type_memberships # :nodoc:
 
       def top_level_profile(refresh: false)
         if refresh
@@ -231,6 +233,7 @@ module GraphQL
           @unions_for_references = Set.new
           @visit = Visibility::Visit.new(@schema) do |member|
             if member.is_a?(Module)
+              member = member #: as GraphQL::Schema::Member::type_definition
               type_name = member.graphql_name
               if (prev_t = @types[type_name])
                 if prev_t.is_a?(Array)
@@ -245,7 +248,8 @@ module GraphQL
               if member < GraphQL::Schema::Directive
                 @directives << member
               elsif member.respond_to?(:interface_type_memberships)
-                member.interface_type_memberships.each do |itm|
+                implementing_type = member #: as GraphQL::Schema::Member::HasInterfaces
+                implementing_type.interface_type_memberships.each do |itm|
                   @all_references[itm.abstract_type] << member
                   # `itm.object_type` may not actually be `member` if this implementation
                   # is inherited from a superclass