graphql 2.6.12 → 2.6.13

data/lib/graphql/language/nodes.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   module Language
     module Nodes
       NONE = GraphQL::EmptyObjects::EMPTY_ARRAY
-      # {AbstractNode} is the base class for all nodes in a GraphQL AST.
+      # [AbstractNode](rdoc-ref:GraphQL::Language::Nodes::AbstractNode) is the base class for all nodes in a GraphQL AST.
       #
       # It provides some APIs for working with ASTs:
       # - `children` returns all AST nodes attached to this one. Used for tree traversal.
@@ -12,8 +13,12 @@ module GraphQL
       class AbstractNode
 
         module DefinitionNode
-          # This AST node's {#line} returns the first line, which may be the description.
-          # @return [Integer] The first line of the definition (not the description)
+          # This AST node's [line](rdoc-ref:GraphQL::Language::Nodes::AbstractNode#line) returns the first line, which may be the description.
+          #
+          # **Returns**
+          #
+          # - `Integer` — The first line of the definition (not the description)
+          #: Integer?
           attr_reader :definition_line
 
           def initialize(definition_line: nil, **_rest)
@@ -31,22 +36,32 @@ module GraphQL
           end
         end
 
+        #: String?
         attr_reader :filename
 
+        #: -> Integer?
         def line
           @line ||= @source&.line_at(@pos)
         end
 
+        #: -> Integer?
         def col
           @col ||= @source&.column_at(@pos)
         end
 
+        #: -> Integer?
         def definition_line
           @definition_line ||= (@source && @definition_pos) ? @source.line_at(@definition_pos) : nil
         end
 
         # Value equality
-        # @return [Boolean] True if `self` is equivalent to `other`
+        #
+        # **Returns**
+        #
+        # - `Boolean` — True if `self` is equivalent to `other`
+        #
+        # :call-seq:
+        #   ==(other) -> bool
         def ==(other)
           return true if equal?(other)
           other.kind_of?(self.class) &&
@@ -56,12 +71,24 @@ module GraphQL
 
         NO_CHILDREN = GraphQL::EmptyObjects::EMPTY_ARRAY
 
-        # @return [Array<GraphQL::Language::Nodes::AbstractNode>] all nodes in the tree below this one
+        # **Returns**
+        #
+        # - `Array<GraphQL::Language::Nodes::AbstractNode>` — all nodes in the tree below this one
+        #
+        # :call-seq:
+        #   children() -> Array[GraphQL::Language::Nodes::AbstractNode]
+        #: -> Array[AbstractNode]
         def children
           NO_CHILDREN
         end
 
-        # @return [Array<Integer, Float, String, Boolean, Array>] Scalar values attached to this node
+        # **Returns**
+        #
+        # - `Array<Integer, Float, String, Boolean, Array>` — Scalar values attached to this node
+        #
+        # :call-seq:
+        #   scalars() -> Array[Integer | Float | String | bool | Array]
+        #: -> Array[untyped]
         def scalars
           NO_CHILDREN
         end
@@ -77,10 +104,24 @@ module GraphQL
           self.class.children_method_name
         end
 
+        # Built-in node classes override this with a literal Symbol.
+        #
+        # **Returns**
+        #
+        # - `Symbol` — the method that GraphQL::Language::Visitor calls for this node
+        #
+        # :call-seq:
+        #   visit_method() -> Symbol
+        def visit_method
+          self.class.visit_method
+        end
+
+        #: -> [Integer?, Integer?]
         def position
           [line, col]
         end
 
+        #: (?printer: untyped) -> String
         def to_query_string(printer: GraphQL::Language::Printer.new)
           if printer.is_a?(GraphQL::Language::Printer)
             if frozen?
@@ -94,8 +135,17 @@ module GraphQL
         end
 
         # This creates a copy of `self`, with `new_options` applied.
-        # @param new_options [Hash]
-        # @return [AbstractNode] a shallow copy of `self`
+        #
+        # **Parameters**
+        #
+        # - `new_options` (`Hash`)
+        #
+        # **Returns**
+        #
+        # - `AbstractNode` — a shallow copy of `self`
+        #
+        # :call-seq:
+        #   merge(Hash new_options) -> AbstractNode
         def merge(new_options)
           dup.merge!(new_options)
         end
@@ -110,7 +160,7 @@ module GraphQL
             # Copy that list, and replace `previous_child` with `new_child`
             # in the list.
             new_children = prev_children.dup
-            prev_idx = new_children.index(previous_child)
+            prev_idx = new_children.index(previous_child) #: as Integer
             new_children[prev_idx] = new_child
           else
             # Use the new value for the given attribute
@@ -145,9 +195,15 @@ module GraphQL
         end
 
         class << self
-          # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+          # **Returns**
+          #
+          # - `Symbol` — the method that GraphQL::Language::Visitor calls for this kind of node
+          #: Symbol?
+          attr_reader :visit_method
 
-          # Add a default `#visit_method` and `#children_method_name` using the class name
+          attr_accessor :children_method_name
+
+          # Add a default `.visit_method` and `.children_method_name` using the class name
           def inherited(child_class)
             super
             name_underscored = child_class.name
@@ -155,227 +211,157 @@ module GraphQL
               .gsub(/([a-z])([A-Z])/,'\1_\2') # insert underscores
               .downcase # remove caps
 
-            child_class.module_eval <<-RUBY, __FILE__, __LINE__
-              def visit_method
-                :on_#{name_underscored}
-              end
-
-              class << self
-                attr_accessor :children_method_name
-
-                def visit_method
-                  :on_#{name_underscored}
-                end
-              end
-              self.children_method_name = :#{name_underscored}s
-            RUBY
+            child_class.instance_variable_set(:@visit_method, :"on_#{name_underscored}")
+            child_class.children_method_name = :"#{name_underscored}s"
           end
 
+          # **Returns**
+          #
+          # - `Hash{Symbol => Class, nil}, nil` — child reader methods and the kind of node each one returns, if known
+          #
+          # :call-seq:
+          #   children_of_type() -> Hash[Symbol, Class | nil] | nil
           def children_of_type
             @children_methods
           end
+        end
+      end
 
-          private
+      # Base class for non-null type names and list type names
+      class WrapperType < AbstractNode
+        def visit_method
+          :on_wrapper_type
+        end
 
-          # Name accessors which return lists of nodes,
-          # along with the kind of node they return, if possible.
-          # - Add a reader for these children
-          # - Add a persistent update method to add a child
-          # - Generate a `#children` method
-          def children_methods(children_of_type)
-            if defined?(@children_methods)
-              raise "Can't re-call .children_methods for #{self} (already have: #{@children_methods})"
-            else
-              @children_methods = children_of_type
-            end
+        #: TypeName | ListType | NonNullType
+        attr_reader :of_type
 
-            if children_of_type == false
-              @children_methods = {}
-              # skip
-            else
+        def scalars
+          @scalars ||= [@of_type].freeze
+        end
 
-              children_of_type.each do |method_name, node_type|
-                module_eval <<-RUBY, __FILE__, __LINE__
-                  # A reader for these children
-                  attr_reader :#{method_name}
-                RUBY
-
-                if node_type
-                  # Only generate a method if we know what kind of node to make
-                  module_eval <<-RUBY, __FILE__, __LINE__
-                    # Singular method: create a node with these options
-                    # and return a new `self` which includes that node in this list.
-                    def merge_#{method_name.to_s.sub(/s$/, "")}(**node_opts)
-                      merge(#{method_name}: #{method_name} + [#{node_type.name}.new(**node_opts)])
-                    end
-                  RUBY
-                end
-              end
-
-              if children_of_type.size == 1
-                module_eval <<-RUBY, __FILE__, __LINE__
-                  alias :children #{children_of_type.keys.first}
-                RUBY
-              else
-                module_eval <<-RUBY, __FILE__, __LINE__
-                  def children
-                    @children ||= begin
-                      if #{children_of_type.keys.map { |k| "@#{k}.any?" }.join(" || ")}
-                        new_children = []
-                        #{children_of_type.keys.map { |k| "new_children.concat(@#{k})" }.join("; ")}
-                        new_children.freeze
-                        new_children
-                      else
-                        NO_CHILDREN
-                      end
-                    end
-                  end
-                RUBY
-              end
-            end
+        #: (?of_type: untyped, ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(of_type: nil, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @of_type = of_type
+        end
 
-            if defined?(@scalar_methods)
-              if !@initialize_was_generated
-                @initialize_was_generated = true
-                generate_initialize
-              else
-                # This method was defined manually
-              end
-            else
-              raise "Can't generate_initialize because scalar_methods wasn't called; call it before children_methods"
-            end
-          end
+        def self.from_a(filename, line, col, of_type, comment: nil)
+          self.new(filename: filename, line: line, col: col, of_type: of_type)
+        end
 
-          # These methods return a plain Ruby value, not another node
-          # - Add reader methods
-          # - Add a `#scalars` method
-          def scalar_methods(*method_names)
-            if defined?(@scalar_methods)
-              raise "Can't re-call .scalar_methods for #{self} (already have: #{@scalar_methods})"
-            else
-              @scalar_methods = method_names
-            end
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @of_type,
+          ]
+        end
 
-            if method_names == [false]
-              @scalar_methods = []
-              # skip it
-            else
-              module_eval <<-RUBY, __FILE__, __LINE__
-                # add readers for each scalar
-                attr_reader #{method_names.map { |m| ":#{m}"}.join(", ")}
-
-                def scalars
-                  @scalars ||= [#{method_names.map { |k| "@#{k}" }.join(", ")}].freeze
-                end
-              RUBY
-            end
-          end
+        def marshal_load(values)
+          @line, @col, @filename, @of_type = values
+        end
 
-          DEFAULT_INITIALIZE_OPTIONS = [
-            "line: nil",
-            "col: nil",
-            "pos: nil",
-            "filename: nil",
-            "source: nil"
-          ]
+        @children_methods = {}.freeze
+      end
 
-          IGNORED_MARSHALLING_KEYWORDS = [:comment]
+      # Base class for nodes whose only value is a name (no child nodes or other scalars)
+      class NameOnlyNode < AbstractNode
+        def visit_method
+          :on_name_only_node
+        end
 
-          def generate_initialize
-            return if method_defined?(:marshal_load, false) # checking for `:initialize` doesn't work right
+        #: String
+        attr_reader :name
 
-            scalar_method_names = @scalar_methods
-            # TODO: These probably should be scalar methods, but `types` returns an array
-            [:types, :description, :comment].each do |extra_method|
-              if method_defined?(extra_method)
-                scalar_method_names += [extra_method]
-              end
-            end
+        def scalars
+          @scalars ||= [@name].freeze
+        end
 
-            children_method_names = @children_methods.keys
+        #: (?name: untyped, ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(name: nil, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+        end
 
-            all_method_names = scalar_method_names + children_method_names
-            if all_method_names.include?(:alias)
-              # Rather than complicating this special case,
-              # let it be overridden (in field)
-              return
-            else
-              arguments = scalar_method_names.map { |m| "#{m}: nil"} +
-                children_method_names.map { |m| "#{m}: NO_CHILDREN" } +
-                DEFAULT_INITIALIZE_OPTIONS
-
-              # Intern descriptions so identical strings across SDL documents share one frozen object.
-              assignments = scalar_method_names.map { |m| m == :description ? "@#{m} = #{m} && -#{m}" : "@#{m} = #{m}" } +
-                children_method_names.map { |m| "@#{m} = #{m}.freeze" }
-
-              if name.end_with?("Definition") && name != "FragmentDefinition"
-                arguments << "definition_pos: nil"
-                assignments << "@definition_pos = definition_pos"
-              end
-
-              keywords = scalar_method_names.map { |m| "#{m}: #{m}"} +
-                children_method_names.map { |m| "#{m}: #{m}" }
-
-              ignored_keywords = IGNORED_MARSHALLING_KEYWORDS.map do |keyword|
-                "#{keyword.to_s}: nil"
-              end
-
-              marshalling_method_names = all_method_names - IGNORED_MARSHALLING_KEYWORDS
-
-              module_eval <<-RUBY, __FILE__, __LINE__
-                def initialize(#{arguments.join(", ")})
-                  @line = line
-                  @col = col
-                  @pos = pos
-                  @filename = filename
-                  @source = source
-                  #{assignments.join("\n")}
-                end
-
-                def self.from_a(filename, line, col, #{marshalling_method_names.join(", ")}, #{ignored_keywords.join(", ")})
-                  self.new(filename: filename, line: line, col: col, #{keywords.join(", ")})
-                end
-
-                def marshal_dump
-                  [
-                    line, col, # use methods here to force them to be calculated
-                    @filename,
-                    #{marshalling_method_names.map { |n| "@#{n}," }.join}
-                  ]
-                end
-
-                def marshal_load(values)
-                  @line, @col, @filename #{marshalling_method_names.map { |n| ", @#{n}"}.join} = values
-                end
-              RUBY
-            end
-          end
-          # rubocop:enable Development/NoEvalCop
+        def self.from_a(filename, line, col, name, comment: nil)
+          self.new(filename: filename, line: line, col: col, name: name)
         end
-      end
 
-      # Base class for non-null type names and list type names
-      class WrapperType < AbstractNode
-        scalar_methods :of_type
-        children_methods(false)
-      end
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+          ]
+        end
 
-      # Base class for nodes whose only value is a name (no child nodes or other scalars)
-      class NameOnlyNode < AbstractNode
-        scalar_methods :name
-        children_methods(false)
+        def marshal_load(values)
+          @line, @col, @filename, @name = values
+        end
+
+        @children_methods = {}.freeze
       end
 
       # A key-value pair for a field's inputs
       class Argument < AbstractNode
-        scalar_methods :name, :value
-        children_methods(false)
+        def visit_method
+          :on_argument
+        end
+
+        # **Returns**
+        #
+        # - `String` — the key for this argument
+        #: String
+        attr_reader :name
+
+        # **Returns**
+        #
+        # - `String, Float, Integer, Boolean, Array, InputObject, VariableIdentifier, Enum, NullValue` — The value passed for this key
+        #: untyped
+        attr_reader :value
+
+        def scalars
+          @scalars ||= [@name, @value].freeze
+        end
+
+        #: (?name: untyped, ?value: untyped, ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(name: nil, value: nil, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @value = value
+        end
 
-        # @!attribute name
-        #   @return [String] the key for this argument
+        def self.from_a(filename, line, col, name, value, comment: nil)
+          self.new(filename: filename, line: line, col: col, name: name, value: value)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @value,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @value = values
+        end
 
-        # @!attribute value
-        #   @return [String, Float, Integer, Boolean, Array, InputObject, VariableIdentifier] The value passed for this key
+        @children_methods = {}.freeze
 
         def children
           @children ||= Array(value).flatten.tap { _1.select! { |v| v.is_a?(AbstractNode) } }
@@ -383,33 +369,171 @@ module GraphQL
       end
 
       class Directive < AbstractNode
-        scalar_methods :name
-        children_methods(arguments: GraphQL::Language::Nodes::Argument)
+        def visit_method
+          :on_directive
+        end
+
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[Argument]
+        attr_reader :arguments
+
+        def merge_argument(**node_opts)
+          merge(arguments: arguments + [GraphQL::Language::Nodes::Argument.new(**node_opts)])
+        end
+
+        alias :children arguments
+
+        #: (?name: untyped, ?arguments: Array[Argument], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(name: nil, arguments: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @arguments = arguments.freeze
+        end
+
+        def self.from_a(filename, line, col, name, arguments, comment: nil)
+          self.new(filename: filename, line: line, col: col, name: name, arguments: arguments)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @arguments,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @arguments = values
+        end
+
+        @children_methods = {
+          arguments: GraphQL::Language::Nodes::Argument,
+        }.freeze
       end
 
       class DirectiveLocation < NameOnlyNode
+        def visit_method
+          :on_directive_location
+        end
       end
 
       class DirectiveDefinition < AbstractNode
+        def visit_method
+          :on_directive_definition
+        end
+
+        #: String?
         attr_reader :description
-        scalar_methods :name, :repeatable
-        children_methods(
-          arguments: Nodes::Argument,
-          locations: Nodes::DirectiveLocation,
-        )
+        #: String
+        attr_reader :name
+        #: bool
+        attr_reader :repeatable
+
+        def scalars
+          @scalars ||= [@name, @repeatable].freeze
+        end
+
+        #: Array[InputValueDefinition]
+        attr_reader :arguments
+        #: Array[DirectiveLocation]
+        attr_reader :locations
+
+        def merge_argument(**node_opts)
+          merge(arguments: arguments + [GraphQL::Language::Nodes::Argument.new(**node_opts)])
+        end
+
+        def merge_location(**node_opts)
+          merge(locations: locations + [GraphQL::Language::Nodes::DirectiveLocation.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@arguments.empty? || !@locations.empty?
+              new_children = []
+              new_children.concat(@arguments)
+              new_children.concat(@locations)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?name: untyped, ?repeatable: untyped, ?description: untyped, ?arguments: Array[InputValueDefinition], ?locations: Array[DirectiveLocation], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, repeatable: nil, description: nil, arguments: NO_CHILDREN, locations: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @repeatable = repeatable
+          @description = description && -description
+          @arguments = arguments.freeze
+          @locations = locations.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, repeatable, description, arguments, locations, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, repeatable: repeatable, description: description, arguments: arguments, locations: locations)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @repeatable,
+            @description,
+            @arguments,
+            @locations,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @repeatable, @description, @arguments, @locations = values
+        end
+
+        @children_methods = {
+          arguments: GraphQL::Language::Nodes::Argument,
+          locations: GraphQL::Language::Nodes::DirectiveLocation,
+        }.freeze
         self.children_method_name = :definitions
       end
 
-      # An enum value. The string is available as {#name}.
+      # An enum value. The string is available as `name`.
       class Enum < NameOnlyNode
+        def visit_method
+          :on_enum
+        end
       end
 
       # A null value literal.
       class NullValue < NameOnlyNode
+        def visit_method
+          :on_null_value
+        end
       end
 
       # A single selection in a GraphQL query.
       class Field < AbstractNode
+        def visit_method
+          :on_field
+        end
+
+        #: (?name: untyped, ?arguments: Array[Argument]?, ?directives: Array[Directive]?, ?selections: (Array[Field | FragmentSpread | InlineFragment])?, ?field_alias: String?, ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
         def initialize(name: nil, arguments: NONE, directives: NONE, selections: NONE, field_alias: nil, line: nil, col: nil, pos: nil, filename: nil, source: nil)
           @name = name
           @arguments = arguments || NONE
@@ -436,12 +560,54 @@ module GraphQL
           @line, @col, @filename, @name, @arguments, @directives, @selections, @alias = values
         end
 
-        scalar_methods :name, :alias
-        children_methods({
+        #: String
+        attr_reader :name
+        #: String?
+        attr_reader :alias
+
+        def scalars
+          @scalars ||= [@name, @alias].freeze
+        end
+
+        #: Array[Argument]
+        attr_reader :arguments
+        #: Array[Field | FragmentSpread | InlineFragment]
+        attr_reader :selections
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_argument(**node_opts)
+          merge(arguments: arguments + [GraphQL::Language::Nodes::Argument.new(**node_opts)])
+        end
+
+        def merge_selection(**node_opts)
+          merge(selections: selections + [GraphQL::Language::Nodes::Field.new(**node_opts)])
+        end
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@arguments.empty? || !@selections.empty? || !@directives.empty?
+              new_children = []
+              new_children.concat(@arguments)
+              new_children.concat(@selections)
+              new_children.concat(@directives)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        @children_methods = {
           arguments: GraphQL::Language::Nodes::Argument,
           selections: GraphQL::Language::Nodes::Field,
           directives: GraphQL::Language::Nodes::Directive,
-        })
+        }.freeze
 
         # Override this because default is `:fields`
         self.children_method_name = :selections
@@ -449,6 +615,11 @@ module GraphQL
 
       # A reusable fragment, defined at document-level.
       class FragmentDefinition < AbstractNode
+        def visit_method
+          :on_fragment_definition
+        end
+
+        #: (?name: untyped, ?type: untyped, ?directives: Array[Directive], ?selections: Array[Field | FragmentSpread | InlineFragment], ?filename: String?, ?pos: Integer?, ?source: untyped, ?line: Integer?, ?col: Integer?) -> void
         def initialize(name: nil, type: nil, directives: NONE, selections: NONE, filename: nil, pos: nil, source: nil, line: nil, col: nil)
           @name = name
           @type = type
@@ -473,99 +644,362 @@ module GraphQL
           @line, @col, @filename, @name, @type, @directives, @selections = values
         end
 
-        scalar_methods :name, :type
-        children_methods({
+        #: String
+        attr_reader :name
+        #: TypeName
+        attr_reader :type
+
+        def scalars
+          @scalars ||= [@name, @type].freeze
+        end
+
+        #: Array[Field | FragmentSpread | InlineFragment]
+        attr_reader :selections
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_selection(**node_opts)
+          merge(selections: selections + [GraphQL::Language::Nodes::Field.new(**node_opts)])
+        end
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@selections.empty? || !@directives.empty?
+              new_children = []
+              new_children.concat(@selections)
+              new_children.concat(@directives)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        @children_methods = {
           selections: GraphQL::Language::Nodes::Field,
           directives: GraphQL::Language::Nodes::Directive,
-        })
+        }.freeze
 
         self.children_method_name = :definitions
       end
 
       # Application of a named fragment in a selection
       class FragmentSpread < AbstractNode
-        scalar_methods :name
-        children_methods(directives: GraphQL::Language::Nodes::Directive)
+        def visit_method
+          :on_fragment_spread
+        end
 
-        self.children_method_name = :selections
+        # **Returns**
+        #
+        # - `String` — The identifier of the fragment to apply, corresponds with [FragmentDefinition#name](rdoc-ref:FragmentDefinition#name)
+        #: String
+        attr_reader :name
 
-        # @!attribute name
-        #   @return [String] The identifier of the fragment to apply, corresponds with {FragmentDefinition#name}
-      end
+        def scalars
+          @scalars ||= [@name].freeze
+        end
 
-      # An unnamed fragment, defined directly in the query with `... {  }`
-      class InlineFragment < AbstractNode
-        scalar_methods :type
-        children_methods({
-          directives: GraphQL::Language::Nodes::Directive,
-          selections: GraphQL::Language::Nodes::Field,
-        })
+        #: Array[Directive]
+        attr_reader :directives
 
-        self.children_method_name = :selections
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
 
-        # @!attribute type
-        #   @return [String, nil] Name of the type this fragment applies to, or `nil` if this fragment applies to any type
-      end
+        alias :children directives
 
-      # A collection of key-value inputs which may be a field argument
-      class InputObject < AbstractNode
-        scalar_methods(false)
-        children_methods(arguments: GraphQL::Language::Nodes::Argument)
+        #: (?name: untyped, ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(name: nil, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @directives = directives.freeze
+        end
 
-        # @!attribute arguments
-        #   @return [Array<Nodes::Argument>] A list of key-value pairs inside this input object
+        def self.from_a(filename, line, col, name, directives, comment: nil)
+          self.new(filename: filename, line: line, col: col, name: name, directives: directives)
+        end
 
-        # @return [Hash<String, Any>] Recursively turn this input object into a Ruby Hash
-        def to_h(options={})
-          arguments.inject({}) do |memo, pair|
-            v = pair.value
-            memo[pair.name] = serialize_value_for_hash v
-            memo
-          end
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @directives,
+          ]
         end
 
-        self.children_method_name = :value
+        def marshal_load(values)
+          @line, @col, @filename, @name, @directives = values
+        end
 
-        private
+        @children_methods = {
+          directives: GraphQL::Language::Nodes::Directive,
+        }.freeze
 
-        def serialize_value_for_hash(value)
-          case value
-          when InputObject
-            value.to_h
-          when Array
-            value.map do |v|
-              serialize_value_for_hash v
-            end
-          when Enum
-            value.name
-          when NullValue
-            nil
-          else
-            value
-          end
-        end
+        self.children_method_name = :selections
       end
 
-      # A list type definition, denoted with `[...]` (used for variable type definitions)
-      class ListType < WrapperType
-      end
+      # An unnamed fragment, defined directly in the query with `... {  }`
+      class InlineFragment < AbstractNode
+        def visit_method
+          :on_inline_fragment
+        end
 
-      # A non-null type definition, denoted with `...!` (used for variable type definitions)
-      class NonNullType < WrapperType
-      end
+        # **Returns**
+        #
+        # - `TypeName, nil` — Name of the type this fragment applies to, or `nil` if this fragment applies to any type
+        #: TypeName?
+        attr_reader :type
 
-      # An operation-level query variable
-      class VariableDefinition < AbstractNode
-        scalar_methods :name, :type, :default_value
-        children_methods(directives: Directive)
-        # @!attribute default_value
-        #   @return [String, Integer, Float, Boolean, Array, NullValue] A Ruby value to use if no other value is provided
+        def scalars
+          @scalars ||= [@type].freeze
+        end
 
-        # @!attribute type
-        #   @return [TypeName, NonNullType, ListType] The expected type of this value
+        #: Array[Directive]
+        attr_reader :directives
+        #: Array[Field | FragmentSpread | InlineFragment]
+        attr_reader :selections
 
-        # @!attribute name
-        #   @return [String] The identifier for this variable, _without_ `$`
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def merge_selection(**node_opts)
+          merge(selections: selections + [GraphQL::Language::Nodes::Field.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@directives.empty? || !@selections.empty?
+              new_children = []
+              new_children.concat(@directives)
+              new_children.concat(@selections)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?type: untyped, ?directives: Array[Directive], ?selections: Array[Field | FragmentSpread | InlineFragment], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(type: nil, directives: NO_CHILDREN, selections: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @type = type
+          @directives = directives.freeze
+          @selections = selections.freeze
+        end
+
+        def self.from_a(filename, line, col, type, directives, selections, comment: nil)
+          self.new(filename: filename, line: line, col: col, type: type, directives: directives, selections: selections)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @type,
+            @directives,
+            @selections,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @type, @directives, @selections = values
+        end
+
+        @children_methods = {
+          directives: GraphQL::Language::Nodes::Directive,
+          selections: GraphQL::Language::Nodes::Field,
+        }.freeze
+
+        self.children_method_name = :selections
+      end
+
+      # A collection of key-value inputs which may be a field argument
+      class InputObject < AbstractNode
+        def visit_method
+          :on_input_object
+        end
+
+        # **Returns**
+        #
+        # - `Array<Nodes::Argument>` — A list of key-value pairs inside this input object
+        #: Array[Argument]
+        attr_reader :arguments
+
+        def merge_argument(**node_opts)
+          merge(arguments: arguments + [GraphQL::Language::Nodes::Argument.new(**node_opts)])
+        end
+
+        alias :children arguments
+
+        #: (?arguments: Array[Argument], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(arguments: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @arguments = arguments.freeze
+        end
+
+        def self.from_a(filename, line, col, arguments, comment: nil)
+          self.new(filename: filename, line: line, col: col, arguments: arguments)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @arguments,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @arguments = values
+        end
+
+        @children_methods = {
+          arguments: GraphQL::Language::Nodes::Argument,
+        }.freeze
+
+        # **Returns**
+        #
+        # - `Hash<String, Any>` — Recursively turn this input object into a Ruby Hash
+        #
+        # :call-seq:
+        #   to_h(options=) -> Hash[String, Any]
+        def to_h(options={})
+          arguments.inject({}) do |memo, pair|
+            v = pair.value
+            memo[pair.name] = serialize_value_for_hash v
+            memo
+          end
+        end
+
+        self.children_method_name = :value
+
+        private
+
+        def serialize_value_for_hash(value)
+          case value
+          when InputObject
+            value.to_h
+          when Array
+            value.map do |v|
+              serialize_value_for_hash v
+            end
+          when Enum
+            value.name
+          when NullValue
+            nil
+          else
+            value
+          end
+        end
+      end
+
+      # A list type definition, denoted with `[...]` (used for variable type definitions)
+      class ListType < WrapperType
+        def visit_method
+          :on_list_type
+        end
+      end
+
+      # A non-null type definition, denoted with `...!` (used for variable type definitions)
+      class NonNullType < WrapperType
+        def visit_method
+          :on_non_null_type
+        end
+      end
+
+      # An operation-level query variable
+      class VariableDefinition < AbstractNode
+        def visit_method
+          :on_variable_definition
+        end
+
+        # **Returns**
+        #
+        # - `String` — The identifier for this variable, _without_ `$`
+        #: String
+        attr_reader :name
+
+        # **Returns**
+        #
+        # - `TypeName, NonNullType, ListType` — The expected type of this value
+        #: TypeName | ListType | NonNullType
+        attr_reader :type
+
+        # **Returns**
+        #
+        # - `String, Integer, Float, Boolean, Array, NullValue` — A Ruby value to use if no other value is provided
+        #: untyped
+        attr_reader :default_value
+
+        def scalars
+          @scalars ||= [@name, @type, @default_value].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        alias :children directives
+
+        #: (?name: untyped, ?type: untyped, ?default_value: untyped, ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, type: nil, default_value: nil, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @type = type
+          @default_value = default_value
+          @directives = directives.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, type, default_value, directives, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, type: type, default_value: default_value, directives: directives)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @type,
+            @default_value,
+            @directives,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @type, @default_value, @directives = values
+        end
+
+        @children_methods = {
+          directives: GraphQL::Language::Nodes::Directive,
+        }.freeze
 
         self.children_method_name = :variables
       end
@@ -574,51 +1008,181 @@ module GraphQL
       # May be anonymous or named.
       # May be explicitly typed (eg `mutation { ... }`) or implicitly a query (eg `{ ... }`).
       class OperationDefinition < AbstractNode
-        scalar_methods :operation_type, :name
-        children_methods({
-          variables: GraphQL::Language::Nodes::VariableDefinition,
-          directives: GraphQL::Language::Nodes::Directive,
-          selections: GraphQL::Language::Nodes::Field,
-        })
+        def visit_method
+          :on_operation_definition
+        end
+
+        # **Returns**
+        #
+        # - `String` — The root type for this operation: `"query"` (including implicit queries), `"mutation"` or `"subscription"`
+        #: String
+        attr_reader :operation_type
+
+        # **Returns**
+        #
+        # - `String, nil` — The name for this operation, or `nil` if unnamed
+        #: String?
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@operation_type, @name].freeze
+        end
+
+        # **Returns**
+        #
+        # - `Array<VariableDefinition>` — Variable $definitions for this operation
+        #: Array[VariableDefinition]
+        attr_reader :variables
+        #: Array[Directive]
+        attr_reader :directives
+
+        # **Returns**
+        #
+        # - `Array<Field, FragmentSpread, InlineFragment>` — Root-level fields on this operation
+        #: Array[Field | FragmentSpread | InlineFragment]
+        attr_reader :selections
+
+        def merge_variable(**node_opts)
+          merge(variables: variables + [GraphQL::Language::Nodes::VariableDefinition.new(**node_opts)])
+        end
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def merge_selection(**node_opts)
+          merge(selections: selections + [GraphQL::Language::Nodes::Field.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@variables.empty? || !@directives.empty? || !@selections.empty?
+              new_children = []
+              new_children.concat(@variables)
+              new_children.concat(@directives)
+              new_children.concat(@selections)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?operation_type: untyped, ?name: untyped, ?variables: Array[VariableDefinition], ?directives: Array[Directive], ?selections: Array[Field | FragmentSpread | InlineFragment], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(operation_type: nil, name: nil, variables: NO_CHILDREN, directives: NO_CHILDREN, selections: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @operation_type = operation_type
+          @name = name
+          @variables = variables.freeze
+          @directives = directives.freeze
+          @selections = selections.freeze
+          @definition_pos = definition_pos
+        end
 
-        # @!attribute variables
-        #   @return [Array<VariableDefinition>] Variable $definitions for this operation
+        def self.from_a(filename, line, col, operation_type, name, variables, directives, selections, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, operation_type: operation_type, name: name, variables: variables, directives: directives, selections: selections)
+        end
 
-        # @!attribute selections
-        #   @return [Array<Field>] Root-level fields on this operation
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @operation_type,
+            @name,
+            @variables,
+            @directives,
+            @selections,
+          ]
+        end
 
-        # @!attribute operation_type
-        #   @return [String, nil] The root type for this operation, or `nil` for implicit `"query"`
+        def marshal_load(values)
+          @line, @col, @filename, @operation_type, @name, @variables, @directives, @selections = values
+        end
 
-        # @!attribute name
-        #   @return [String, nil] The name for this operation, or `nil` if unnamed
+        @children_methods = {
+          variables: GraphQL::Language::Nodes::VariableDefinition,
+          directives: GraphQL::Language::Nodes::Directive,
+          selections: GraphQL::Language::Nodes::Field,
+        }.freeze
 
         self.children_method_name = :definitions
       end
 
       # This is the AST root for normal queries
       #
-      # @example Deriving a document by parsing a string
-      #   document = GraphQL.parse(query_string)
+      # **Examples**
       #
-      # @example Creating a string from a document
-      #   document.to_query_string
-      #   # { ... }
+      # **Example: Deriving a document by parsing a string**
       #
-      # @example Creating a custom string from a document
-      #  class VariableScrubber < GraphQL::Language::Printer
-      #    def print_argument(arg)
-      #      print_string("#{arg.name}: <HIDDEN>")
-      #    end
-      #  end
+      # ```ruby
+      # document = GraphQL.parse(query_string)
+      # ```
       #
-      #  document.to_query_string(printer: VariableScrubber.new)
+      # **Example: Creating a string from a document**
       #
+      # ```ruby
+      # document.to_query_string
+      # # { ... }
+      # ```
+      #
+      # **Example: Creating a custom string from a document**
+      #
+      # ```ruby
+      # class VariableScrubber < GraphQL::Language::Printer
+      #   def print_argument(arg)
+      #     print_string("#{arg.name}: <HIDDEN>")
+      #   end
+      # end
+      #
+      # document.to_query_string(printer: VariableScrubber.new)
+      # ```
       class Document < AbstractNode
-        scalar_methods false
-        children_methods(definitions: nil)
-        # @!attribute definitions
-        #   @return [Array<OperationDefinition, FragmentDefinition>] top-level GraphQL units: operations or fragments
+        def visit_method
+          :on_document
+        end
+
+        # **Returns**
+        #
+        # - `Array<OperationDefinition, FragmentDefinition, AbstractNode>` — top-level GraphQL units: operations or fragments
+        #: Array[AbstractNode]
+        attr_reader :definitions
+
+        alias :children definitions
+
+        #: (?definitions: Array[AbstractNode], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(definitions: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @definitions = definitions.freeze
+        end
+
+        def self.from_a(filename, line, col, definitions, comment: nil)
+          self.new(filename: filename, line: line, col: col, definitions: definitions)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @definitions,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @definitions = values
+        end
+
+        @children_methods = {
+          definitions: nil,
+        }.freeze
 
         def slice_definition(name)
           GraphQL::Language::DefinitionSlice.slice(self, name)
@@ -627,177 +1191,1288 @@ module GraphQL
 
       # A type name, used for variable definitions
       class TypeName < NameOnlyNode
+        def visit_method
+          :on_type_name
+        end
       end
 
       # Usage of a variable in a query. Name does _not_ include `$`.
       class VariableIdentifier < NameOnlyNode
+        def visit_method
+          :on_variable_identifier
+        end
+
         self.children_method_name = :value
       end
 
       class SchemaDefinition < AbstractNode
-        scalar_methods :query, :mutation, :subscription
-        children_methods({
-          directives: GraphQL::Language::Nodes::Directive,
-        })
-        self.children_method_name = :definitions
-      end
+        def visit_method
+          :on_schema_definition
+        end
 
-      class SchemaExtension < AbstractNode
-        scalar_methods :query, :mutation, :subscription
-        children_methods({
-          directives: GraphQL::Language::Nodes::Directive,
-        })
-        self.children_method_name = :definitions
-      end
+        #: String?
+        attr_reader :query
+        #: String?
+        attr_reader :mutation
+        #: String?
+        attr_reader :subscription
 
-      class ScalarTypeDefinition < AbstractNode
-        attr_reader :description, :comment
-        scalar_methods :name
-        children_methods({
-          directives: GraphQL::Language::Nodes::Directive,
-        })
-        self.children_method_name = :definitions
-      end
+        def scalars
+          @scalars ||= [@query, @mutation, @subscription].freeze
+        end
 
-      class ScalarTypeExtension < AbstractNode
-        scalar_methods :name
-        children_methods({
-          directives: GraphQL::Language::Nodes::Directive,
-        })
-        self.children_method_name = :definitions
-      end
+        #: Array[Directive]
+        attr_reader :directives
 
-      class InputValueDefinition < AbstractNode
-        attr_reader :description, :comment
-        scalar_methods :name, :type, :default_value
-        children_methods({
-          directives: GraphQL::Language::Nodes::Directive,
-        })
-        self.children_method_name = :fields
-      end
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
 
-      class FieldDefinition < AbstractNode
-        attr_reader :description, :comment
-        scalar_methods :name, :type
-        children_methods({
-          arguments: GraphQL::Language::Nodes::InputValueDefinition,
-          directives: GraphQL::Language::Nodes::Directive,
-        })
-        self.children_method_name = :fields
+        alias :children directives
 
-        # this is so that `children_method_name` of `InputValueDefinition` works properly
-        # with `#replace_child`
-        alias :fields :arguments
-        def merge(new_options)
-          if (f = new_options.delete(:fields))
-            new_options[:arguments] = f
-          end
-          super
+        #: (?query: untyped, ?mutation: untyped, ?subscription: untyped, ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(query: nil, mutation: nil, subscription: nil, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @query = query
+          @mutation = mutation
+          @subscription = subscription
+          @directives = directives.freeze
+          @definition_pos = definition_pos
         end
-      end
 
-      class ObjectTypeDefinition < AbstractNode
-        attr_reader :description, :comment
-        scalar_methods :name, :interfaces
-        children_methods({
-          directives: GraphQL::Language::Nodes::Directive,
-          fields: GraphQL::Language::Nodes::FieldDefinition,
-        })
-        self.children_method_name = :definitions
-      end
+        def self.from_a(filename, line, col, query, mutation, subscription, directives, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, query: query, mutation: mutation, subscription: subscription, directives: directives)
+        end
 
-      class ObjectTypeExtension < AbstractNode
-        scalar_methods :name, :interfaces
-        children_methods({
-          directives: GraphQL::Language::Nodes::Directive,
-          fields: GraphQL::Language::Nodes::FieldDefinition,
-        })
-        self.children_method_name = :definitions
-      end
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @query,
+            @mutation,
+            @subscription,
+            @directives,
+          ]
+        end
 
-      class InterfaceTypeDefinition < AbstractNode
-        attr_reader :description, :comment
-        scalar_methods :name
-        children_methods({
-          interfaces: GraphQL::Language::Nodes::TypeName,
+        def marshal_load(values)
+          @line, @col, @filename, @query, @mutation, @subscription, @directives = values
+        end
+
+        @children_methods = {
           directives: GraphQL::Language::Nodes::Directive,
-          fields: GraphQL::Language::Nodes::FieldDefinition,
-        })
+        }.freeze
         self.children_method_name = :definitions
       end
 
-      class InterfaceTypeExtension < AbstractNode
-        scalar_methods :name
-        children_methods({
+      class SchemaExtension < AbstractNode
+        def visit_method
+          :on_schema_extension
+        end
+
+        #: String?
+        attr_reader :query
+        #: String?
+        attr_reader :mutation
+        #: String?
+        attr_reader :subscription
+
+        def scalars
+          @scalars ||= [@query, @mutation, @subscription].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        alias :children directives
+
+        #: (?query: untyped, ?mutation: untyped, ?subscription: untyped, ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(query: nil, mutation: nil, subscription: nil, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @query = query
+          @mutation = mutation
+          @subscription = subscription
+          @directives = directives.freeze
+        end
+
+        def self.from_a(filename, line, col, query, mutation, subscription, directives, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, query: query, mutation: mutation, subscription: subscription, directives: directives)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @query,
+            @mutation,
+            @subscription,
+            @directives,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @query, @mutation, @subscription, @directives = values
+        end
+
+        @children_methods = {
+          directives: GraphQL::Language::Nodes::Directive,
+        }.freeze
+        self.children_method_name = :definitions
+      end
+
+      class ScalarTypeDefinition < AbstractNode
+        def visit_method
+          :on_scalar_type_definition
+        end
+
+        #: String?
+        attr_reader :description
+        #: String?
+        attr_reader :comment
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        alias :children directives
+
+        #: (?name: untyped, ?description: untyped, ?comment: untyped, ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, description: nil, comment: nil, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @description = description && -description
+          @comment = comment
+          @directives = directives.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, description, directives, comment: nil)
+          self.new(filename: filename, line: line, col: col, name: name, description: description, comment: comment, directives: directives)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @description,
+            @directives,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @description, @directives = values
+        end
+
+        @children_methods = {
+          directives: GraphQL::Language::Nodes::Directive,
+        }.freeze
+        self.children_method_name = :definitions
+      end
+
+      class ScalarTypeExtension < AbstractNode
+        def visit_method
+          :on_scalar_type_extension
+        end
+
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        alias :children directives
+
+        #: (?name: untyped, ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(name: nil, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @directives = directives.freeze
+        end
+
+        def self.from_a(filename, line, col, name, directives, comment: nil)
+          self.new(filename: filename, line: line, col: col, name: name, directives: directives)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @directives,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @directives = values
+        end
+
+        @children_methods = {
+          directives: GraphQL::Language::Nodes::Directive,
+        }.freeze
+        self.children_method_name = :definitions
+      end
+
+      class InputValueDefinition < AbstractNode
+        def visit_method
+          :on_input_value_definition
+        end
+
+        #: String?
+        attr_reader :description
+        #: String?
+        attr_reader :comment
+        #: String
+        attr_reader :name
+        #: TypeName | ListType | NonNullType
+        attr_reader :type
+        #: untyped
+        attr_reader :default_value
+
+        def scalars
+          @scalars ||= [@name, @type, @default_value].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        alias :children directives
+
+        #: (?name: untyped, ?type: untyped, ?default_value: untyped, ?description: untyped, ?comment: untyped, ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, type: nil, default_value: nil, description: nil, comment: nil, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @type = type
+          @default_value = default_value
+          @description = description && -description
+          @comment = comment
+          @directives = directives.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, type, default_value, description, directives, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, type: type, default_value: default_value, description: description, comment: comment, directives: directives)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @type,
+            @default_value,
+            @description,
+            @directives,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @type, @default_value, @description, @directives = values
+        end
+
+        @children_methods = {
+          directives: GraphQL::Language::Nodes::Directive,
+        }.freeze
+        self.children_method_name = :fields
+      end
+
+      class FieldDefinition < AbstractNode
+        def visit_method
+          :on_field_definition
+        end
+
+        #: String?
+        attr_reader :description
+        #: String?
+        attr_reader :comment
+        #: String
+        attr_reader :name
+        #: TypeName | ListType | NonNullType
+        attr_reader :type
+
+        def scalars
+          @scalars ||= [@name, @type].freeze
+        end
+
+        #: Array[InputValueDefinition]
+        attr_reader :arguments
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_argument(**node_opts)
+          merge(arguments: arguments + [GraphQL::Language::Nodes::InputValueDefinition.new(**node_opts)])
+        end
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@arguments.empty? || !@directives.empty?
+              new_children = []
+              new_children.concat(@arguments)
+              new_children.concat(@directives)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?name: untyped, ?type: untyped, ?description: untyped, ?comment: untyped, ?arguments: Array[InputValueDefinition], ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, type: nil, description: nil, comment: nil, arguments: NO_CHILDREN, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @type = type
+          @description = description && -description
+          @comment = comment
+          @arguments = arguments.freeze
+          @directives = directives.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, type, description, arguments, directives, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, type: type, description: description, comment: comment, arguments: arguments, directives: directives)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @type,
+            @description,
+            @arguments,
+            @directives,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @type, @description, @arguments, @directives = values
+        end
+
+        @children_methods = {
+          arguments: GraphQL::Language::Nodes::InputValueDefinition,
+          directives: GraphQL::Language::Nodes::Directive,
+        }.freeze
+        self.children_method_name = :fields
+
+        # this is so that `children_method_name` of `InputValueDefinition` works properly
+        # with `#replace_child`
+        alias :fields :arguments
+        def merge(new_options)
+          if (f = new_options.delete(:fields))
+            new_options[:arguments] = f
+          end
+          super
+        end
+      end
+
+      class ObjectTypeDefinition < AbstractNode
+        def visit_method
+          :on_object_type_definition
+        end
+
+        #: String?
+        attr_reader :description
+        #: String?
+        attr_reader :comment
+        #: String
+        attr_reader :name
+        #: Array[TypeName]
+        attr_reader :interfaces
+
+        def scalars
+          @scalars ||= [@name, @interfaces].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+        #: Array[FieldDefinition]
+        attr_reader :fields
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def merge_field(**node_opts)
+          merge(fields: fields + [GraphQL::Language::Nodes::FieldDefinition.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@directives.empty? || !@fields.empty?
+              new_children = []
+              new_children.concat(@directives)
+              new_children.concat(@fields)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?name: untyped, ?interfaces: untyped, ?description: untyped, ?comment: untyped, ?directives: Array[Directive], ?fields: Array[FieldDefinition], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, interfaces: nil, description: nil, comment: nil, directives: NO_CHILDREN, fields: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @interfaces = interfaces
+          @description = description && -description
+          @comment = comment
+          @directives = directives.freeze
+          @fields = fields.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, interfaces, description, directives, fields, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, interfaces: interfaces, description: description, comment: comment, directives: directives, fields: fields)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @interfaces,
+            @description,
+            @directives,
+            @fields,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @interfaces, @description, @directives, @fields = values
+        end
+
+        @children_methods = {
+          directives: GraphQL::Language::Nodes::Directive,
+          fields: GraphQL::Language::Nodes::FieldDefinition,
+        }.freeze
+        self.children_method_name = :definitions
+      end
+
+      class ObjectTypeExtension < AbstractNode
+        def visit_method
+          :on_object_type_extension
+        end
+
+        #: String
+        attr_reader :name
+        #: Array[TypeName]
+        attr_reader :interfaces
+
+        def scalars
+          @scalars ||= [@name, @interfaces].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+        #: Array[FieldDefinition]
+        attr_reader :fields
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def merge_field(**node_opts)
+          merge(fields: fields + [GraphQL::Language::Nodes::FieldDefinition.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@directives.empty? || !@fields.empty?
+              new_children = []
+              new_children.concat(@directives)
+              new_children.concat(@fields)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?name: untyped, ?interfaces: untyped, ?directives: Array[Directive], ?fields: Array[FieldDefinition], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(name: nil, interfaces: nil, directives: NO_CHILDREN, fields: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @interfaces = interfaces
+          @directives = directives.freeze
+          @fields = fields.freeze
+        end
+
+        def self.from_a(filename, line, col, name, interfaces, directives, fields, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, interfaces: interfaces, directives: directives, fields: fields)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @interfaces,
+            @directives,
+            @fields,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @interfaces, @directives, @fields = values
+        end
+
+        @children_methods = {
+          directives: GraphQL::Language::Nodes::Directive,
+          fields: GraphQL::Language::Nodes::FieldDefinition,
+        }.freeze
+        self.children_method_name = :definitions
+      end
+
+      class InterfaceTypeDefinition < AbstractNode
+        def visit_method
+          :on_interface_type_definition
+        end
+
+        #: String?
+        attr_reader :description
+        #: String?
+        attr_reader :comment
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[TypeName]
+        attr_reader :interfaces
+        #: Array[Directive]
+        attr_reader :directives
+        #: Array[FieldDefinition]
+        attr_reader :fields
+
+        def merge_interface(**node_opts)
+          merge(interfaces: interfaces + [GraphQL::Language::Nodes::TypeName.new(**node_opts)])
+        end
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def merge_field(**node_opts)
+          merge(fields: fields + [GraphQL::Language::Nodes::FieldDefinition.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@interfaces.empty? || !@directives.empty? || !@fields.empty?
+              new_children = []
+              new_children.concat(@interfaces)
+              new_children.concat(@directives)
+              new_children.concat(@fields)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?name: untyped, ?description: untyped, ?comment: untyped, ?interfaces: Array[TypeName], ?directives: Array[Directive], ?fields: Array[FieldDefinition], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, description: nil, comment: nil, interfaces: NO_CHILDREN, directives: NO_CHILDREN, fields: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @description = description && -description
+          @comment = comment
+          @interfaces = interfaces.freeze
+          @directives = directives.freeze
+          @fields = fields.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, description, interfaces, directives, fields, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, description: description, comment: comment, interfaces: interfaces, directives: directives, fields: fields)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @description,
+            @interfaces,
+            @directives,
+            @fields,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @description, @interfaces, @directives, @fields = values
+        end
+
+        @children_methods = {
+          interfaces: GraphQL::Language::Nodes::TypeName,
+          directives: GraphQL::Language::Nodes::Directive,
+          fields: GraphQL::Language::Nodes::FieldDefinition,
+        }.freeze
+        self.children_method_name = :definitions
+      end
+
+      class InterfaceTypeExtension < AbstractNode
+        def visit_method
+          :on_interface_type_extension
+        end
+
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[TypeName]
+        attr_reader :interfaces
+        #: Array[Directive]
+        attr_reader :directives
+        #: Array[FieldDefinition]
+        attr_reader :fields
+
+        def merge_interface(**node_opts)
+          merge(interfaces: interfaces + [GraphQL::Language::Nodes::TypeName.new(**node_opts)])
+        end
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def merge_field(**node_opts)
+          merge(fields: fields + [GraphQL::Language::Nodes::FieldDefinition.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@interfaces.empty? || !@directives.empty? || !@fields.empty?
+              new_children = []
+              new_children.concat(@interfaces)
+              new_children.concat(@directives)
+              new_children.concat(@fields)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?name: untyped, ?interfaces: Array[TypeName], ?directives: Array[Directive], ?fields: Array[FieldDefinition], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(name: nil, interfaces: NO_CHILDREN, directives: NO_CHILDREN, fields: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @interfaces = interfaces.freeze
+          @directives = directives.freeze
+          @fields = fields.freeze
+        end
+
+        def self.from_a(filename, line, col, name, interfaces, directives, fields, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, interfaces: interfaces, directives: directives, fields: fields)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @interfaces,
+            @directives,
+            @fields,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @interfaces, @directives, @fields = values
+        end
+
+        @children_methods = {
           interfaces: GraphQL::Language::Nodes::TypeName,
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::FieldDefinition,
-        })
+        }.freeze
         self.children_method_name = :definitions
       end
 
       class UnionTypeDefinition < AbstractNode
-        attr_reader :description, :comment, :types
-        scalar_methods :name
-        children_methods({
+        def visit_method
+          :on_union_type_definition
+        end
+
+        #: String?
+        attr_reader :description
+        #: String?
+        attr_reader :comment
+        #: Array[TypeName]
+        attr_reader :types
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        alias :children directives
+
+        #: (?name: untyped, ?types: untyped, ?description: untyped, ?comment: untyped, ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, types: nil, description: nil, comment: nil, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @types = types
+          @description = description && -description
+          @comment = comment
+          @directives = directives.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, types, description, directives, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, types: types, description: description, comment: comment, directives: directives)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @types,
+            @description,
+            @directives,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @types, @description, @directives = values
+        end
+
+        @children_methods = {
           directives: GraphQL::Language::Nodes::Directive,
-        })
+        }.freeze
         self.children_method_name = :definitions
       end
 
       class UnionTypeExtension < AbstractNode
+        def visit_method
+          :on_union_type_extension
+        end
+
+        #: Array[TypeName]
         attr_reader :types
-        scalar_methods :name
-        children_methods({
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        alias :children directives
+
+        #: (?name: untyped, ?types: untyped, ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(name: nil, types: nil, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @types = types
+          @directives = directives.freeze
+        end
+
+        def self.from_a(filename, line, col, name, types, directives, comment: nil)
+          self.new(filename: filename, line: line, col: col, name: name, types: types, directives: directives)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @types,
+            @directives,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @types, @directives = values
+        end
+
+        @children_methods = {
           directives: GraphQL::Language::Nodes::Directive,
-        })
+        }.freeze
         self.children_method_name = :definitions
       end
 
       class EnumValueDefinition < AbstractNode
-        attr_reader :description, :comment
-        scalar_methods :name
-        children_methods({
+        def visit_method
+          :on_enum_value_definition
+        end
+
+        #: String?
+        attr_reader :description
+        #: String?
+        attr_reader :comment
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        alias :children directives
+
+        #: (?name: untyped, ?description: untyped, ?comment: untyped, ?directives: Array[Directive], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, description: nil, comment: nil, directives: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @description = description && -description
+          @comment = comment
+          @directives = directives.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, description, directives, comment: nil)
+          self.new(filename: filename, line: line, col: col, name: name, description: description, comment: comment, directives: directives)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @description,
+            @directives,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @description, @directives = values
+        end
+
+        @children_methods = {
           directives: GraphQL::Language::Nodes::Directive,
-        })
+        }.freeze
         self.children_method_name = :values
       end
 
       class EnumTypeDefinition < AbstractNode
-        attr_reader :description, :comment
-        scalar_methods :name
-        children_methods({
+        def visit_method
+          :on_enum_type_definition
+        end
+
+        #: String?
+        attr_reader :description
+        #: String?
+        attr_reader :comment
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+        #: Array[EnumValueDefinition]
+        attr_reader :values
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def merge_value(**node_opts)
+          merge(values: values + [GraphQL::Language::Nodes::EnumValueDefinition.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@directives.empty? || !@values.empty?
+              new_children = []
+              new_children.concat(@directives)
+              new_children.concat(@values)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?name: untyped, ?description: untyped, ?comment: untyped, ?directives: Array[Directive], ?values: Array[EnumValueDefinition], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, description: nil, comment: nil, directives: NO_CHILDREN, values: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @description = description && -description
+          @comment = comment
+          @directives = directives.freeze
+          @values = values.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, description, directives, values, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, description: description, comment: comment, directives: directives, values: values)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @description,
+            @directives,
+            @values,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @description, @directives, @values = values
+        end
+
+        @children_methods = {
           directives: GraphQL::Language::Nodes::Directive,
           values: GraphQL::Language::Nodes::EnumValueDefinition,
-        })
+        }.freeze
         self.children_method_name = :definitions
       end
 
       class EnumTypeExtension < AbstractNode
-        scalar_methods :name
-        children_methods({
+        def visit_method
+          :on_enum_type_extension
+        end
+
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+        #: Array[EnumValueDefinition]
+        attr_reader :values
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def merge_value(**node_opts)
+          merge(values: values + [GraphQL::Language::Nodes::EnumValueDefinition.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@directives.empty? || !@values.empty?
+              new_children = []
+              new_children.concat(@directives)
+              new_children.concat(@values)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?name: untyped, ?directives: Array[Directive], ?values: Array[EnumValueDefinition], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(name: nil, directives: NO_CHILDREN, values: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @directives = directives.freeze
+          @values = values.freeze
+        end
+
+        def self.from_a(filename, line, col, name, directives, values, comment: nil)
+          self.new(filename: filename, line: line, col: col, name: name, directives: directives, values: values)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @directives,
+            @values,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @directives, @values = values
+        end
+
+        @children_methods = {
           directives: GraphQL::Language::Nodes::Directive,
           values: GraphQL::Language::Nodes::EnumValueDefinition,
-        })
+        }.freeze
         self.children_method_name = :definitions
       end
 
       class InputObjectTypeDefinition < AbstractNode
-        attr_reader :description, :comment
-        scalar_methods :name
-        children_methods({
+        def visit_method
+          :on_input_object_type_definition
+        end
+
+        #: String?
+        attr_reader :description
+        #: String?
+        attr_reader :comment
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+        #: Array[InputValueDefinition]
+        attr_reader :fields
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def merge_field(**node_opts)
+          merge(fields: fields + [GraphQL::Language::Nodes::InputValueDefinition.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@directives.empty? || !@fields.empty?
+              new_children = []
+              new_children.concat(@directives)
+              new_children.concat(@fields)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?name: untyped, ?description: untyped, ?comment: untyped, ?directives: Array[Directive], ?fields: Array[InputValueDefinition], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped, ?definition_pos: Integer?) -> void
+        def initialize(name: nil, description: nil, comment: nil, directives: NO_CHILDREN, fields: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil, definition_pos: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @description = description && -description
+          @comment = comment
+          @directives = directives.freeze
+          @fields = fields.freeze
+          @definition_pos = definition_pos
+        end
+
+        def self.from_a(filename, line, col, name, description, directives, fields, comment: nil) # rubocop:disable Metrics/ParameterLists
+          self.new(filename: filename, line: line, col: col, name: name, description: description, comment: comment, directives: directives, fields: fields)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @description,
+            @directives,
+            @fields,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @description, @directives, @fields = values
+        end
+
+        @children_methods = {
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::InputValueDefinition,
-        })
+        }.freeze
         self.children_method_name = :definitions
       end
 
       class InputObjectTypeExtension < AbstractNode
-        scalar_methods :name
-        children_methods({
+        def visit_method
+          :on_input_object_type_extension
+        end
+
+        #: String
+        attr_reader :name
+
+        def scalars
+          @scalars ||= [@name].freeze
+        end
+
+        #: Array[Directive]
+        attr_reader :directives
+        #: Array[InputValueDefinition]
+        attr_reader :fields
+
+        def merge_directive(**node_opts)
+          merge(directives: directives + [GraphQL::Language::Nodes::Directive.new(**node_opts)])
+        end
+
+        def merge_field(**node_opts)
+          merge(fields: fields + [GraphQL::Language::Nodes::InputValueDefinition.new(**node_opts)])
+        end
+
+        def children
+          @children ||= begin
+            if !@directives.empty? || !@fields.empty?
+              new_children = []
+              new_children.concat(@directives)
+              new_children.concat(@fields)
+              new_children.freeze
+              new_children
+            else
+              NO_CHILDREN
+            end
+          end
+        end
+
+        #: (?name: untyped, ?directives: Array[Directive], ?fields: Array[InputValueDefinition], ?line: Integer?, ?col: Integer?, ?pos: Integer?, ?filename: String?, ?source: untyped) -> void
+        def initialize(name: nil, directives: NO_CHILDREN, fields: NO_CHILDREN, line: nil, col: nil, pos: nil, filename: nil, source: nil)
+          @line = line
+          @col = col
+          @pos = pos
+          @filename = filename
+          @source = source
+          @name = name
+          @directives = directives.freeze
+          @fields = fields.freeze
+        end
+
+        def self.from_a(filename, line, col, name, directives, fields, comment: nil)
+          self.new(filename: filename, line: line, col: col, name: name, directives: directives, fields: fields)
+        end
+
+        def marshal_dump
+          [
+            line, col, # use methods here to force them to be calculated
+            @filename,
+            @name,
+            @directives,
+            @fields,
+          ]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @directives, @fields = values
+        end
+
+        @children_methods = {
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::InputValueDefinition,
-        })
+        }.freeze
         self.children_method_name = :definitions
       end
     end