graphql 2.6.12 → 2.6.13

data/lib/graphql/dig.rb

@@ -1,13 +1,22 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Dig
     # implemented using the old activesupport #dig instead of the ruby built-in
     # so we can use some of the magic in Schema::InputObject and Interpreter::Arguments
     # to handle stringified/symbolized keys.
     #
-    # @param own_key [String, Symbol] A key to retrieve
-    # @param rest_keys [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly
-    # @return [Object]
+    # **Parameters**
+    #
+    # - `own_key` (`String, Symbol`) — A key to retrieve
+    # - `rest_keys` (`Array<[String, Symbol]>`) — Keys to use for retrieving nested values
+    #
+    # **Returns**
+    #
+    # - `Object`
+    #
+    # :call-seq:
+    #   dig(String | Symbol own_key, Array[[String, Symbol]] *rest_keys) -> Object
     def dig(own_key, *rest_keys)
       val = self[own_key]
       if val.nil? || rest_keys.empty?

data/lib/graphql/duration_encoding_error.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   # This error is raised when `Types::ISO8601Duration` is asked to return a value
   # that cannot be parsed as an ISO8601-formatted duration by ActiveSupport::Duration.
   #
-  # @see GraphQL::Types::ISO8601Duration which raises this error
+  # See [GraphQL::Types::ISO8601Duration](rdoc-ref:GraphQL::Types::ISO8601Duration) which raises this error
   class DurationEncodingError < GraphQL::RuntimeTypeError
     # The value which couldn't be encoded
     attr_reader :duration_value

data/lib/graphql/execution/directive_checks.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Execution
     # Boolean checks for how an AST node's directives should
     # influence its execution
-    # @api private
-    module DirectiveChecks
+    module DirectiveChecks # :nodoc:
       SKIP = "skip"
       INCLUDE = "include"
 
       module_function
 
-      # @return [Boolean] Should this node be included in the query?
+      # **Returns**
+      #
+      # - `Boolean` — Should this node be included in the query?
+      #
+      # :call-seq:
+      #   include?(directive_ast_nodes, query) -> bool
       def include?(directive_ast_nodes, query)
         directive_ast_nodes.each do |directive_ast_node|
           name = directive_ast_node.name

data/lib/graphql/execution/errors.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
@@ -6,10 +7,18 @@ module GraphQL
       # Register this handler, updating the
       # internal handler index to maintain least-to-most specific.
       #
-      # @param error_class [Class<Exception>]
-      # @param error_handlers [Hash]
-      # @param error_handler [Proc]
-      # @return [void]
+      # **Parameters**
+      #
+      # - `error_class` (`Class<Exception>`)
+      # - `error_handlers` (`Hash`)
+      # - `error_handler` (`Proc`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   register_rescue_from(Class[Exception] error_class, Hash error_handlers, Proc error_handler) -> void
       def self.register_rescue_from(error_class, error_handlers, error_handler)
         subclasses_handlers = {}
         this_level_subclasses = []
@@ -52,10 +61,15 @@ module GraphQL
         nil
       end
 
-      # @return [Proc, nil] The handler for `error_class`, if one was registered on this schema or inherited
+      # **Returns**
+      #
+      # - `Proc, nil` — The handler for `error_class`, if one was registered on this schema or inherited
+      #
+      # :call-seq:
+      #   find_handler_for(schema, error_class) -> Proc | nil
       def self.find_handler_for(schema, error_class)
         handlers = schema.error_handlers[:subclass_handlers]
-        handler = nil
+        handler = nil #: untyped
         while (handlers) do
           _err_class, next_handler = handlers.find { |err_class, handler| error_class <= err_class }
           if next_handler

data/lib/graphql/execution/field_resolve_step.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: false
 module GraphQL
   module Execution
     class FieldResolveStep
@@ -418,11 +419,15 @@ module GraphQL
           case ext
           when Schema::Field::ConnectionExtension
             conns = ctx.schema.connections
+            lookahead = @arguments[:lookahead]
+            # The memo omits the extension's extras (`:lookahead`)
+            conn_arguments = memos[@finish_extension_idx] || @arguments
             @field_results.map!.each_with_index do |value, idx|
               object = @extended.object[idx]
-              conn = conns.populate_connection(@field_definition, object, value, @arguments, ctx)
+              conn = conns.populate_connection(@field_definition, object, value, conn_arguments, ctx)
               if conn
                 conn.was_authorized_by_scope_items = @was_scoped
+                conn.lookahead ||= lookahead
               end
               conn
             rescue GraphQL::RuntimeError => err
@@ -514,7 +519,7 @@ module GraphQL
       def build_leaf_result(result_h, result_key, field_result, return_type, ctx, is_from_array)
         if field_result.nil?
           if return_type.non_null?
-            add_non_null_error(is_from_array)
+            add_non_null_error(is_from_array, return_type: return_type)
           else
             nil
           end
@@ -609,8 +614,14 @@ module GraphQL
         end
       end
 
-      def add_non_null_error(is_from_array)
-        err = @parent_type::InvalidNullError.new(@parent_type, @field_definition, ast_nodes, is_from_array: is_from_array, path: path)
+      def add_non_null_error(is_from_array, return_type: nil)
+        if is_from_array && return_type
+          list_type = @field_definition.type
+          list_type = list_type.of_type if list_type.non_null?
+          # Preserve existing messages for single-level lists.
+          element_type = return_type.of_type if list_type.of_type.list?
+        end
+        err = @parent_type::InvalidNullError.new(@parent_type, @field_definition, ast_nodes, is_from_array: is_from_array, path: path, element_type: element_type)
         nn_result = @runner.schema.type_error(err, @selections_step.query.context)
         if nn_result.nil?
           propagate_nulls
@@ -797,8 +808,13 @@ module GraphQL
           end
           results
         when :resolve_legacy_instance_method
-          @selections_step.graphql_objects.map do |obj_inst|
-            obj_inst.public_send(@field_definition.execution_mode_key, **args_hash)
+          graphql_objects = if objects.equal?(@selections_step.objects)
+            @selections_step.graphql_objects
+          else
+            objects.map { |object| @parent_type.scoped_new(object, context) }
+          end
+          graphql_objects.map do |graphql_object|
+            graphql_object.public_send(@field_definition.execution_mode_key, **args_hash)
           rescue GraphQL::ExecutionError => exec_err
             exec_err
           end

data/lib/graphql/execution/finalize.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Execution
     class Finalize
@@ -39,11 +40,16 @@ module GraphQL
                 tf[key] = err
                 @finalizers_count += 1
               elsif value_at_key.is_a?(Array)
-                value_at_key.each_with_index do |el, idx|
-                  if el.equal?(err)
-                    tf = @finalizers[value_at_key] ||= {}.compare_by_identity
-                    tf[idx] = err
-                    @finalizers_count += 1
+                pending_arrays = [value_at_key]
+                while (array = pending_arrays.pop)
+                  array.each_with_index do |el, idx|
+                    if el.equal?(err)
+                      array_tf = @finalizers[array] ||= {}.compare_by_identity
+                      array_tf[idx] = err
+                      @finalizers_count += 1
+                    elsif el.is_a?(Array)
+                      pending_arrays << el
+                    end
                   end
                 end
               end
@@ -175,7 +181,7 @@ module GraphQL
           inner_type = inner_type.of_type
         end
 
-        new_invalid_null = false
+        new_invalid_null = false #: bool
 
         if (f = finalizers(result_arr, nil))
           run_finalizers(@current_result_path.dup, f, result_arr, nil)

data/lib/graphql/execution/input_values.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Execution
     class InputValues
@@ -38,7 +39,7 @@ module GraphQL
       def argument_values(owner_defn, argument_nodes, field_resolve_step)
         arg_defns = @query.types.arguments(owner_defn)
         argument_values = {}
-        errors = nil
+        errors = nil #: untyped
 
         arg_defns.each do |argument_definition|
           arg_ruby_key = argument_definition.keyword

data/lib/graphql/execution/interpreter/argument_value.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
     class Interpreter
       # A container for metadata regarding arguments present in a GraphQL query.
-      # @see Interpreter::Arguments#argument_values for a hash of these objects.
+      # See [Interpreter::Arguments#argument_values](rdoc-ref:Interpreter::Arguments#argument_values) for a hash of these objects.
       class ArgumentValue
         def initialize(definition:, value:, original_value:, default_used:)
           @definition = definition
@@ -13,16 +14,27 @@ module GraphQL
           @default_used = default_used
         end
 
-        # @return [Object] The Ruby-ready value for this Argument
+        # **Returns**
+        #
+        # - `Object` — The Ruby-ready value for this Argument
         attr_reader :value
 
-        # @return [Object] The value of this argument _before_ `prepare` is applied.
+        # **Returns**
+        #
+        # - `Object` — The value of this argument _before_ `prepare` is applied.
         attr_reader :original_value
 
-        # @return [GraphQL::Schema::Argument] The definition instance for this argument
+        # **Returns**
+        #
+        # - `GraphQL::Schema::Argument` — The definition instance for this argument
         attr_reader :definition
 
-        # @return [Boolean] `true` if the schema-defined `default_value:` was applied in this case. (No client-provided value was present.)
+        # **Returns**
+        #
+        # - `Boolean` — `true` if the schema-defined `default_value:` was applied in this case. (No client-provided value was present.)
+        #
+        # :call-seq:
+        #   default_used?() -> bool
         def default_used?
           @default_used
         end

data/lib/graphql/execution/interpreter/arguments.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
@@ -8,7 +9,7 @@ module GraphQL
       # This object is immutable so that the runtime code can be sure that
       # modifications don't leak from one use to another
       #
-      # @see GraphQL::Query#arguments_for to get access to these objects.
+      # See [GraphQL::Query#arguments_for](rdoc-ref:GraphQL::Query#arguments_for) to get access to these objects.
       class Arguments
         extend Forwardable
         include GraphQL::Dig
@@ -16,11 +17,18 @@ module GraphQL
         # The Ruby-style arguments hash, ready for a resolver.
         # This hash is the one used at runtime.
         #
-        # @return [Hash<Symbol, Object>]
+        # **Returns**
+        #
+        # - `Hash<Symbol, Object>`
         attr_reader :keyword_arguments
 
-        # @param argument_values [nil, Hash{Symbol => ArgumentValue}]
-        # @param keyword_arguments [nil, Hash{Symbol => Object}]
+        # **Parameters**
+        #
+        # - `argument_values` (`nil, Hash{Symbol => ArgumentValue}`)
+        # - `keyword_arguments` (`nil, Hash{Symbol => Object}`)
+        #
+        # :call-seq:
+        #   initialize(nil | Hash[Symbol, Object] keyword_arguments:, nil | Hash[Symbol, ArgumentValue] argument_values:)
         def initialize(keyword_arguments: nil, argument_values:)
           @empty = argument_values.nil? || argument_values.empty?
           # This is only present when `extras` have been merged in:
@@ -52,7 +60,9 @@ module GraphQL
           freeze
         end
 
-        # @return [Hash{Symbol => ArgumentValue}]
+        # **Returns**
+        #
+        # - `Hash{Symbol => ArgumentValue}`
         attr_reader :argument_values
 
         def empty?
@@ -70,10 +80,15 @@ module GraphQL
         #
         # This is called by the runtime to implement field `extras: [...]`
         #
-        # @param extra_args [Hash<Symbol => Object>]
-        # @return [Interpreter::Arguments]
-        # @api private
-        def merge_extras(extra_args)
+        #
+        # **Parameters**
+        #
+        # - `extra_args` (`Hash<Symbol => Object>`)
+        #
+        # **Returns**
+        #
+        # - `Interpreter::Arguments`
+        def merge_extras(extra_args) # :nodoc:
           self.class.new(
             argument_values: argument_values,
             keyword_arguments: keyword_arguments.merge(extra_args)

data/lib/graphql/execution/interpreter/arguments_cache.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
@@ -36,7 +37,7 @@ module GraphQL
           @storage[argument_owner][nil][ast_node]
         end
 
-        # @yield [Interpreter::Arguments, Lazy<Interpreter::Arguments>] The finally-loaded arguments
+        # **Yields:** [Interpreter::Arguments, Lazy<Interpreter::Arguments>] The finally-loaded arguments
         def dataload_for(ast_node, argument_owner, parent_object, &block)
           # First, normalize all AST or Ruby values to a plain Ruby hash
           arg_storage = @storage[argument_owner][parent_object]

data/lib/graphql/execution/interpreter/execution_errors.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution

data/lib/graphql/execution/interpreter/handles_raw_value.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution

data/lib/graphql/execution/interpreter/resolve.rb

@@ -1,23 +1,32 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
     class Interpreter
       module Resolve
         # Continue field results in `results` until there's nothing else to continue.
-        # @return [void]
-        # @deprecated Call `dataloader.run` instead
+        # **Deprecated:** Call `dataloader.run` instead
+        #
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   resolve_all(results, dataloader) -> void
         def self.resolve_all(results, dataloader)
-          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
+          backtrace = caller(1, 5) #: as !nil
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{backtrace.map { |l| "\n    #{l}"}.join}"
           dataloader.append_job { resolve(results, dataloader) }
           nil
         end
 
-        # @deprecated Call `dataloader.run` instead
+        # **Deprecated:** Call `dataloader.run` instead
         def self.resolve_each_depth(lazies_at_depth, dataloader)
-          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
+          backtrace = caller(1, 5) #: as !nil
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{backtrace.map { |l| "\n    #{l}"}.join}"
 
-          smallest_depth = nil
+          smallest_depth = nil #: Integer?
           lazies_at_depth.each_key do |depth_key|
             smallest_depth ||= depth_key
             if depth_key < smallest_depth
@@ -39,9 +48,10 @@ module GraphQL
           nil
         end
 
-        # @deprecated Call `dataloader.run` instead
+        # **Deprecated:** Call `dataloader.run` instead
         def self.resolve(results, dataloader)
-          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
+          backtrace = caller(1, 5) #: as !nil
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{backtrace.map { |l| "\n    #{l}"}.join}"
           # There might be pending jobs here that _will_ write lazies
           # into the result hash. We should run them out, so we
           # can be sure that all lazies will be present in the result hashes.

data/lib/graphql/execution/interpreter/runtime/graphql_result.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Execution
@@ -54,7 +55,9 @@ module GraphQL
           attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent,
             :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager, :ast_node, :graphql_arguments, :graphql_field
 
-          # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
+          # **Returns**
+          #
+          # - `Hash` — Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
           attr_accessor :graphql_result_data
         end
 

data/lib/graphql/execution/interpreter/runtime.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 require "graphql/execution/interpreter/runtime/graphql_result"
 
 module GraphQL
@@ -7,8 +8,7 @@ module GraphQL
       # I think it would be even better if we could somehow make
       # `continue_field` not recursive. "Trampolining" it somehow.
       #
-      # @api private
-      class Runtime
+      class Runtime # :nodoc:
         class CurrentState
           def initialize
             @current_field = nil
@@ -26,13 +26,19 @@ module GraphQL
             :current_arguments, :current_field, :was_authorized_by_scope_items
         end
 
-        # @return [GraphQL::Query]
+        # **Returns**
+        #
+        # - `GraphQL::Query`
         attr_reader :query
 
-        # @return [Class<GraphQL::Schema>]
+        # **Returns**
+        #
+        # - `Class<GraphQL::Schema>`
         attr_reader :schema
 
-        # @return [GraphQL::Query::Context]
+        # **Returns**
+        #
+        # - `GraphQL::Query::Context`
         attr_reader :context
 
         def initialize(query:)
@@ -63,7 +69,12 @@ module GraphQL
           "#<#{self.class.name} response=#{@response.inspect}>"
         end
 
-        # @return [void]
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   run_eager() -> void
         def run_eager
           root_type = query.root_type
           case query
@@ -138,7 +149,7 @@ module GraphQL
             else
               @response = GraphQLResultArray.new(nil, root_type, nil, nil, false, selections, false, ast_node, nil, nil)
               @response.base_path = base_path
-              idx = nil
+              idx = nil #: Integer?
               object.each do |inner_value|
                 idx ||= 0
                 this_idx = idx
@@ -209,6 +220,7 @@ module GraphQL
           end
         end
 
+        #: (untyped, untyped, untyped, untyped, Array[untyped]?, untyped, untyped) -> untyped
         def gather_selections(graphql_response, owner_object, owner_type, selections, selections_to_run, selections_by_name, ordered_result_keys)
           selections.each do |node|
             if node.is_a?(GraphQL::Language::Nodes::Field)
@@ -242,7 +254,7 @@ module GraphQL
                 if selections_to_run
                   selections_to_run << next_selections
                 else
-                  selections_to_run = []
+                  selections_to_run = [] #: Array[untyped]
                   selections_to_run << selections_by_name
                   selections_to_run << next_selections
                 end
@@ -253,7 +265,10 @@ module GraphQL
               case node
               when GraphQL::Language::Nodes::InlineFragment
                 if node.type
-                  type_defn = query.types.type(node.type.name)
+                  type_defn = query.types.type(
+                    node.type #: as !nil
+                    .name
+                  )
 
                   if query.types.possible_types(type_defn).include?(owner_type)
                     result = gather_selections(graphql_response, owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
@@ -287,7 +302,12 @@ module GraphQL
 
         NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
 
-        # @return [void]
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   evaluate_selections(gathered_selections, selections_result, target_result, runtime_state) -> void
         def evaluate_selections(gathered_selections, selections_result, target_result, runtime_state) # rubocop:disable Metrics/ParameterLists
           runtime_state ||= get_current_runtime_state
           runtime_state.current_result_name = nil
@@ -325,7 +345,12 @@ module GraphQL
           end
         end
 
-        # @return [void]
+        # **Returns**
+        #
+        # - `void`
+        #
+        # :call-seq:
+        #   evaluate_selection(result_name, field_ast_nodes_or_ast_node, selections_result) -> void
         def evaluate_selection(result_name, field_ast_nodes_or_ast_node, selections_result) # rubocop:disable Metrics/ParameterLists
           return if selections_result.graphql_dead
           # As a performance optimization, the hash key will be a `Node` if
@@ -374,6 +399,7 @@ module GraphQL
           end
         end
 
+        #: (untyped, untyped, untyped, Array[untyped]?, untyped, untyped, untyped, untyped) -> untyped
         def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)  # rubocop:disable Metrics/ParameterLists
           after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_arguments, runtime_state|
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
@@ -405,7 +431,7 @@ module GraphQL
                   extra_args[:path] = current_path
                 when :lookahead
                   if !field_ast_nodes
-                    field_ast_nodes = [ast_node]
+                    field_ast_nodes = [ast_node] #: Array[untyped]
                   end
 
                   extra_args[:lookahead] = Execution::Lookahead.new(
@@ -556,9 +582,13 @@ module GraphQL
               set_result(selection_result, result_name, nil, false, is_non_null) do
                 # When this comes from a list item, use the parent object:
                 is_from_array = selection_result.is_a?(GraphQLResultArray)
-                parent_type = is_from_array ? selection_result.graphql_parent.graphql_result_type : selection_result.graphql_result_type
+                parent_result = selection_result
+                until parent_result.is_a?(GraphQLResultHash)
+                  parent_result = parent_result.graphql_parent
+                end
+                parent_type = parent_result.graphql_result_type
                 # This block is called if `result_name` is not dead. (Maybe a previous invalid nil caused it be marked dead.)
-                err = parent_type::InvalidNullError.new(parent_type, field, ast_node, is_from_array: is_from_array)
+                err = parent_type.const_get(:InvalidNullError).new(parent_type, field, ast_node, is_from_array: is_from_array)
                 schema.type_error(err, context)
               end
             else
@@ -657,7 +687,12 @@ module GraphQL
         #
         # Location information from `path` and `ast_node`.
         #
-        # @return [Lazy, Array, Hash, Object] Lazy, Array, and Hash are all traversed to resolve lazy values later
+        # **Returns**
+        #
+        # - `Lazy, Array, Hash, Object` — Lazy, Array, and Hash are all traversed to resolve lazy values later
+        #
+        # :call-seq:
+        #   continue_field(value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped, runtime_state) -> Lazy | Array | Hash | Object
         def continue_field(value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
           if current_type.non_null?
             current_type = current_type.of_type
@@ -702,7 +737,7 @@ module GraphQL
               possible_types = query.types.possible_types(current_type)
               if !possible_types.include?(resolved_type)
                 parent_type = field.owner_type
-                err_class = current_type::UnresolvedTypeError
+                err_class = current_type.const_get(:UnresolvedTypeError)
                 type_error = err_class.new(resolved_value, field, parent_type, resolved_type, possible_types)
                 schema.type_error(type_error, context)
                 set_result(selection_result, result_name, nil, false, is_non_null)
@@ -749,7 +784,7 @@ module GraphQL
             inner_type_non_null = inner_type.non_null?
             response_list = GraphQLResultArray.new(result_name, current_type, owner_object, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
             set_result(selection_result, result_name, response_list, true, is_non_null)
-            idx = nil
+            idx = nil #: Integer?
             list_value = begin
               begin
                 value.each do |inner_value|
@@ -853,7 +888,7 @@ module GraphQL
           end
         end
 
-        # Check {Schema::Directive.include?} for each directive that's present
+        # Check [Schema::Directive.include?](rdoc-ref:Schema::Directive.include?) for each directive that's present
         def directives_include?(node, graphql_object, parent_type, selection_result, extra_path_part)
           node.directives.each do |dir_node|
             dir_defn = @schema_directives.fetch(dir_node.name)
@@ -902,11 +937,19 @@ module GraphQL
           end
         end
 
-        # @param obj [Object] Some user-returned value that may want to be batched
-        # @param field [GraphQL::Schema::Field]
-        # @param eager [Boolean] Set to `true` for mutation root fields only
-        # @param trace [Boolean] If `false`, don't wrap this with field tracing
-        # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
+        # **Parameters**
+        #
+        # - `obj` (`Object`) — Some user-returned value that may want to be batched
+        # - `field` (`GraphQL::Schema::Field`)
+        # - `eager` (`Boolean`) — Set to `true` for mutation root fields only
+        # - `trace` (`Boolean`) — If `false`, don't wrap this with field tracing
+        #
+        # **Returns**
+        #
+        # - `GraphQL::Execution::Lazy, Object` — If loading `object` will be deferred, it's a wrapper over it.
+        #
+        # :call-seq:
+        #   after_lazy(lazy_obj, GraphQL::Schema::Field field:, owner_object:, arguments:, ast_node:, result:, result_name:, bool eager:, runtime_state:, bool trace:, &block) -> GraphQL::Execution::Lazy | Object
         def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, runtime_state:, trace: true, &block)
           if lazy?(lazy_obj)
             was_authorized_by_scope_items = runtime_state.was_authorized_by_scope_items