graphql 2.6.12 → 2.6.14

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: true
 module GraphQL
   module Execution
     class FieldResolveStep
@@ -25,6 +26,8 @@ module GraphQL
         @finish_extension_idx = nil
         @was_scoped = nil
         @pending_steps = nil
+        @field_authorization_objects = @field_authorization_results = @field_authorization_errors = nil
+        @field_authorization_next_idx = @field_authorization_pending = nil
         @arguments_without_loads = @post_processors = @directive_finalizers = nil
       end
 
@@ -93,6 +96,12 @@ module GraphQL
           finish_extensions
         elsif @field_results
           build_results
+        elsif @field_authorization_results
+          if @field_authorization_next_idx < @field_authorization_objects.size
+            authorize_next_field_object
+          else
+            finish_field_authorizations
+          end
         elsif @arguments
           execute_field
         else
@@ -117,7 +126,7 @@ module GraphQL
         @runner.add_finalizer(@selections_step.query, result, key, err)
         if !err.is_a?(GraphQL::Execution::Skip)
           field_type = return_type
-          should_propagate_null = field_type.non_null?
+          should_propagate_null = field_type.non_null? #: bool
           while (should_propagate_null == false && field_type.kind.wraps?)
             field_type = field_type.of_type
             should_propagate_null = field_type.non_null?
@@ -130,10 +139,10 @@ module GraphQL
       end
 
       def propagate_nulls
-        propagating_null = true
+        propagating_null = true #: bool
         highest_nulled_depth = path.size
-        highest_list_depth = nil
-        current_field_step = self
+        highest_list_depth = nil #: Integer?
+        current_field_step = self #: FieldResolveStep?
         while current_field_step && current_field_step.field_definition
           return_type = current_field_step.field_definition.type
           if propagating_null && return_type.non_null?
@@ -150,7 +159,7 @@ module GraphQL
         end
 
         if highest_list_depth.nil? || highest_nulled_depth <= highest_list_depth
-          kill_field_step = self
+          kill_field_step = self #: FieldResolveStep?
           while kill_field_step && kill_field_step.field_definition && highest_nulled_depth <= kill_field_step.path.size
             kill_field_step.selections_step.killed = true
             kill_field_step = kill_field_step.selections_step.field_resolve_step
@@ -242,153 +251,30 @@ module GraphQL
         end
 
         if @runner.authorizes?(@field_definition, ctx)
-          authorized_objects = []
-          authorized_results = []
-          l = objects.size
-          i = 0
-          while i < l
-            o = objects[i]
-            err = nil
-            begin
-              field_authed = @field_definition.authorized?(o, @arguments, ctx)
-              if @runner.resolves_lazies && @runner.lazy?(field_authed)
-                # TODO batch this properly...
-                field_authed = sync(field_authed)
-              end
-            rescue GraphQL::UnauthorizedFieldError => field_auth_err
-              err = field_auth_err
-              err.field ||= @field_definition
-              field_authed = false
-            end
-
-            if field_authed
-              authorized_results << @results[i]
-              authorized_objects << o
-            else
-              begin
-                err ||= GraphQL::UnauthorizedFieldError.new(object: o, type: @parent_type, context: ctx, field: @field_definition)
-                new_obj = query.schema.unauthorized_field(err)
-                if !new_obj.nil?
-                  authorized_objects << new_obj
-                  authorized_results << @results[i]
-                end
-              rescue GraphQL::ExecutionError => exec_err
-                add_graphql_error(@results[i], key, exec_err)
-              end
-            end
-            i += 1
-          end
-
-          if authorized_objects.size == 0
+          @field_authorization_objects = objects
+          @field_authorization_results = Array.new(objects.size)
+          @field_authorization_next_idx = 0
+          if objects.size > 1 && !@runner.dataloader.is_a?(GraphQL::Dataloader::NullDataloader)
+            # Enqueue this step once per object, so Dataloader sources loaded by `authorized?` batch across objects.
+            # Each call authorizes the next object; see `authorize_next_field_object`.
+            @field_authorization_pending = objects.size
+            objects.size.times { @runner.dataloader.append_job(self) }
             return
           end
-          @results = authorized_results
+          objects.size.times { |idx| authorize_field_at(idx, ctx) }
+          authorized_objects = collect_field_authorizations
+          return if authorized_objects.nil?
         else
           authorized_objects = objects
         end
 
-        if @parent_type.default_relay? && SCOPED_RELAY_FIELD_NAMES.include?(@field_definition.original_name) && authorized_objects.all? { |o| o.respond_to?(:was_authorized_by_scope_items?) && o.was_authorized_by_scope_items? }
-          @was_scoped = true
-        end
-
-        query.current_trace.begin_execute_field(@field_definition, authorized_objects, @arguments, query)
-
-        if @runner.uses_runtime_directives
-          if @ast_nodes.nil? || @ast_nodes.size == 1
-            directives = if !@ast_node.directives.empty?
-              @ast_node.directives
-            else
-              nil
-            end
-          else
-            directives = nil
-            @ast_nodes.each do |n|
-              if (d = n.directives).any? # rubocop:disable Development/NoneWithoutBlockCop
-                directives ||= []
-                directives.concat(d)
-              end
-            end
-          end
-
-          if directives
-            directives.each do |dir_node|
-              if (dir_defn = @runner.runtime_directives[dir_node.name])
-                dir_args, errors = @runner.input_values[query].argument_values(dir_defn, dir_node.arguments, self)  # rubocop:disable Development/ContextIsPassedCop
-                if errors
-                  @results.each { |r| r.delete(@key) }
-                  errors.each { |e| e.ast_node = dir_node }
-                  build_errors_result(errors, nil)
-                  return
-                else
-                  begin
-                    dir_defn.validate!(dir_args, query.context)
-                    if !(result = dir_defn.resolve_field(ast_nodes, @parent_type, field_definition, authorized_objects, dir_args, ctx)).nil?
-                      if result.is_a?(Finalizer)
-                        result.path = path
-                        @directive_finalizers ||= []
-                        @directive_finalizers << result
-                      end
-
-                      if result.is_a?(PostProcessor)
-                        @post_processors ||= []
-                        @post_processors << result
-                      end
-
-                      if result.is_a?(HaltExecution)
-                        @directive_finalizers&.each { |f|
-                          @selections_step.results.each { |r|  @runner.add_finalizer(query, r, key, f) }
-                        }
-                        return
-                      end
-                    end
-                  rescue GraphQL::RuntimeError => err
-                    err.ast_node = dir_node
-                    raise
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        has_extensions = @field_definition.extensions.size > 0
-        if has_extensions
-          @extended = GraphQL::Schema::Field::ExtendedState.new(@arguments, authorized_objects)
-          @field_results = @field_definition.run_next_extensions_before_resolve(authorized_objects, @arguments, ctx, @extended) do |objs, args|
-            if (added_extras = @extended.added_extras)
-              args = args.dup
-              added_extras.each { |e| args.delete(e) }
-            end
-            resolve_batch(objs, ctx, args)
-          end
-          @finish_extension_idx = 0
-        else
-          @field_results = resolve_batch(authorized_objects, ctx, @arguments)
-        end
-
-        query.current_trace.end_execute_field(@field_definition, authorized_objects, @arguments, query, @field_results)
-
-        if any_lazy_results?
-          @runner.dataloader.lazy_at_depth(path.size, self)
-        elsif @pending_steps.nil? || @pending_steps.empty?
-          if has_extensions
-            finish_extensions
-          else
-            build_results
-          end
-        end
-      rescue GraphQL::ExecutionError => err
-        build_errors_result(nil, err)
-      rescue StandardError => stderr
-        begin
-          @selections_step.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
-        rescue GraphQL::ExecutionError => err
-          add_graphql_error(@results[0], key, err)
-        end
+        execute_authorized_field(authorized_objects)
+      rescue StandardError => err
+        handle_execute_field_error(err)
       end
 
       def any_lazy_results?
-        lazies = false
+        lazies = false #: bool
         if @runner.resolves_lazies # TODO extract this
           @field_results.each do |field_result|
             if @runner.lazy?(field_result)
@@ -418,11 +304,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 +404,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 +499,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.const_get(: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
@@ -624,6 +520,207 @@ module GraphQL
 
       private
 
+      def execute_authorized_field(authorized_objects)
+        query = @selections_step.query
+        ctx = query.context
+
+        if @parent_type.default_relay? && SCOPED_RELAY_FIELD_NAMES.include?(@field_definition.original_name) && authorized_objects.all? { |o| o.respond_to?(:was_authorized_by_scope_items?) && o.was_authorized_by_scope_items? }
+          @was_scoped = true
+        end
+
+        query.current_trace.begin_execute_field(@field_definition, authorized_objects, @arguments, query)
+
+        if @runner.uses_runtime_directives
+          if @ast_nodes.nil? || @ast_nodes.size == 1
+            directives = if !@ast_node.directives.empty?
+              @ast_node.directives
+            else
+              nil
+            end
+          else
+            directives = nil #: Array[untyped]?
+            @ast_nodes.each do |n|
+              if (d = n.directives).any? # rubocop:disable Development/NoneWithoutBlockCop
+                directives ||= []
+                directives.concat(d)
+              end
+            end
+          end
+
+          if directives
+            directives.each do |dir_node|
+              if (dir_defn = @runner.runtime_directives[dir_node.name])
+                dir_args, errors = @runner.input_values[query].argument_values(dir_defn, dir_node.arguments, self)  # rubocop:disable Development/ContextIsPassedCop
+                if errors
+                  @results.each { |r| r.delete(@key) }
+                  errors.each { |e| e.ast_node = dir_node }
+                  build_errors_result(errors, nil)
+                  return
+                else
+                  begin
+                    dir_defn.validate!(dir_args, query.context)
+                    if !(result = dir_defn.resolve_field(ast_nodes, @parent_type, field_definition, authorized_objects, dir_args, ctx)).nil?
+                      if result.is_a?(Finalizer)
+                        result.path = path
+                        @directive_finalizers ||= []
+                        @directive_finalizers << result
+                      end
+
+                      if result.is_a?(PostProcessor)
+                        @post_processors ||= []
+                        @post_processors << result
+                      end
+
+                      if result.is_a?(HaltExecution)
+                        @directive_finalizers&.each { |f|
+                          @selections_step.results.each { |r|  @runner.add_finalizer(query, r, key, f) }
+                        }
+                        return
+                      end
+                    end
+                  rescue GraphQL::RuntimeError => err
+                    err.ast_node = dir_node
+                    raise
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        has_extensions = @field_definition.extensions.size > 0
+        if has_extensions
+          @extended = GraphQL::Schema::Field::ExtendedState.new(@arguments, authorized_objects)
+          @field_results = @field_definition.run_next_extensions_before_resolve(authorized_objects, @arguments, ctx, @extended) do |objs, args|
+            if (added_extras = @extended.added_extras)
+              args = args.dup
+              added_extras.each { |e| args.delete(e) }
+            end
+            resolve_batch(objs, ctx, args)
+          end
+          @finish_extension_idx = 0
+        else
+          @field_results = resolve_batch(authorized_objects, ctx, @arguments)
+        end
+
+        query.current_trace.end_execute_field(@field_definition, authorized_objects, @arguments, query, @field_results)
+
+        if any_lazy_results?
+          @runner.dataloader.lazy_at_depth(path.size, self)
+        elsif @pending_steps.nil? || @pending_steps.empty?
+          if has_extensions
+            finish_extensions
+          else
+            build_results
+          end
+        end
+      rescue StandardError => err
+        handle_execute_field_error(err)
+      end
+
+      def handle_execute_field_error(err)
+        if @field_authorization_objects
+          clear_field_authorizations
+        end
+        if err.is_a?(GraphQL::ExecutionError)
+          build_errors_result(nil, err)
+        else
+          begin
+            @selections_step.query.handle_or_reraise(err, field: @field_definition, arguments: @arguments, object: nil)
+          rescue GraphQL::ExecutionError => exec_err
+            add_graphql_error(@results[0], key, exec_err)
+          end
+        end
+      end
+
+      # Stores the (possibly synced) +authorized?+ result for the object at +idx+.
+      # A GraphQL::UnauthorizedFieldError raised by +authorized?+ is stored in +@field_authorization_errors+.
+      def authorize_field_at(idx, ctx)
+        field_authed = @field_definition.authorized?(@field_authorization_objects[idx], @arguments, ctx)
+        if @runner.resolves_lazies && @runner.lazy?(field_authed)
+          field_authed = sync(field_authed)
+        end
+        @field_authorization_results[idx] = field_authed
+      rescue GraphQL::UnauthorizedFieldError => field_auth_err
+        field_auth_err.field ||= @field_definition
+        (@field_authorization_errors ||= {})[idx] = field_auth_err
+      end
+
+      # Runs once for each time this step was enqueued for field authorization.
+      # The index is taken before +authorized?+ runs, so it's still correct if this Fiber pauses.
+      # When the last object is done, the step is enqueued again to call +finish_field_authorizations+.
+      def authorize_next_field_object
+        idx = @field_authorization_next_idx
+        @field_authorization_next_idx += 1
+        begin
+          authorize_field_at(idx, @selections_step.query.context)
+        rescue StandardError => err
+          (@field_authorization_errors ||= {})[idx] = err
+        end
+        @field_authorization_pending -= 1
+        if @field_authorization_pending == 0
+          @runner.add_step(self)
+        end
+      end
+
+      def finish_field_authorizations
+        if (errors = @field_authorization_errors)
+          @field_authorization_objects.size.times do |idx|
+            err = errors[idx]
+            if err && !err.is_a?(GraphQL::UnauthorizedFieldError)
+              raise err
+            end
+          end
+        end
+        authorized_objects = collect_field_authorizations
+        if authorized_objects
+          execute_authorized_field(authorized_objects)
+        end
+      rescue StandardError => err
+        handle_execute_field_error(err)
+      end
+
+      def clear_field_authorizations
+        @field_authorization_objects = @field_authorization_results = @field_authorization_errors = nil
+        @field_authorization_next_idx = @field_authorization_pending = nil
+      end
+
+      # Applies +unauthorized_field+ for denied objects, in object order.
+      # Returns the objects to resolve, or +nil+ if none are left.
+      def collect_field_authorizations
+        objects = @field_authorization_objects
+        auth_results = @field_authorization_results
+        errors = @field_authorization_errors
+        clear_field_authorizations
+        ctx = @selections_step.query.context
+        authorized_objects = []
+        authorized_results = []
+        objects.each_with_index do |o, i|
+          err = errors && errors[i]
+          if !err && auth_results[i]
+            authorized_results << @results[i]
+            authorized_objects << o
+          else
+            begin
+              err ||= GraphQL::UnauthorizedFieldError.new(object: o, type: @parent_type, context: ctx, field: @field_definition)
+              new_obj = ctx.schema.unauthorized_field(err)
+              if !new_obj.nil?
+                authorized_objects << new_obj
+                authorized_results << @results[i]
+              end
+            rescue GraphQL::ExecutionError => exec_err
+              add_graphql_error(@results[i], key, exec_err)
+            end
+          end
+        end
+
+        if authorized_objects.size == 0
+          return nil
+        end
+        @results = authorized_results
+        authorized_objects
+      end
+
       def build_graphql_result(graphql_result, key, field_result, return_type, is_nn, is_list, is_from_array) # rubocop:disable Metrics/ParameterLists
         if field_result.nil?
           if is_nn
@@ -701,25 +798,25 @@ module GraphQL
         when :resolve_batch
           begin
             method_receiver.public_send(@field_definition.execution_mode_key, objects, context, **args_hash)
-          rescue GraphQL::ExecutionError => exec_err
-            error_instance_array(objects.size, exec_err)
-          rescue StandardError => stderr
+          rescue GraphQL::ExecutionError => batch_err
+            error_instance_array(objects.size, batch_err)
+          rescue StandardError => batch_stderr
             begin
-              context.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
-            rescue GraphQL::ExecutionError => exec_err
-              error_instance_array(objects.size, exec_err)
+              context.query.handle_or_reraise(batch_stderr, field: @field_definition, arguments: @arguments, object: nil)
+            rescue GraphQL::ExecutionError => batch_err
+              error_instance_array(objects.size, batch_err)
             end
           end
         when :resolve_static
           result = begin
             method_receiver.public_send(@field_definition.execution_mode_key, context, **args_hash)
-          rescue GraphQL::ExecutionError => err
-            err
-          rescue StandardError => stderr
+          rescue GraphQL::ExecutionError => static_err
+            static_err
+          rescue StandardError => static_stderr
             begin
-              context.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
-            rescue GraphQL::ExecutionError => err
-              err
+              context.query.handle_or_reraise(static_stderr, field: @field_definition, arguments: @arguments, object: nil)
+            rescue GraphQL::ExecutionError => static_err
+              static_err
             end
           end
           Array.new(objects.size, result)
@@ -797,8 +894,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)