class Prism::DotVisitor

This visitor provides the ability to call Node#to_dot, which converts a subtree into a graphviz dot graph.

Attributes

digraph[R]

The digraph that is being built.

Public Class Methods

new() click to toggle source

Initialize a new dot visitor.

# File lib/prism/dot_visitor.rb, line 106
def initialize
  @digraph = Digraph.new
end

Public Instance Methods

to_dot() click to toggle source

Convert this visitor into a graphviz dot graph string.

# File lib/prism/dot_visitor.rb, line 111
def to_dot
  digraph.to_dot
end
visit_alias_global_variable_node(node) click to toggle source

Visit a AliasGlobalVariableNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 116
    def visit_alias_global_variable_node(node)
      table = Table.new("AliasGlobalVariableNode")
      id = node_id(node)

      # new_name
      table.field("new_name", port: true)
      digraph.edge("#{id}:new_name -> #{node_id(node.new_name)};")

      # old_name
      table.field("old_name", port: true)
      digraph.edge("#{id}:old_name -> #{node_id(node.old_name)};")

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_alias_method_node(node) click to toggle source

Visit a AliasMethodNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 141
    def visit_alias_method_node(node)
      table = Table.new("AliasMethodNode")
      id = node_id(node)

      # new_name
      table.field("new_name", port: true)
      digraph.edge("#{id}:new_name -> #{node_id(node.new_name)};")

      # old_name
      table.field("old_name", port: true)
      digraph.edge("#{id}:old_name -> #{node_id(node.old_name)};")

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_alternation_pattern_node(node) click to toggle source

Visit a AlternationPatternNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 166
    def visit_alternation_pattern_node(node)
      table = Table.new("AlternationPatternNode")
      id = node_id(node)

      # left
      table.field("left", port: true)
      digraph.edge("#{id}:left -> #{node_id(node.left)};")

      # right
      table.field("right", port: true)
      digraph.edge("#{id}:right -> #{node_id(node.right)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_and_node(node) click to toggle source

Visit a AndNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 191
    def visit_and_node(node)
      table = Table.new("AndNode")
      id = node_id(node)

      # left
      table.field("left", port: true)
      digraph.edge("#{id}:left -> #{node_id(node.left)};")

      # right
      table.field("right", port: true)
      digraph.edge("#{id}:right -> #{node_id(node.right)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_arguments_node(node) click to toggle source

Visit a ArgumentsNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 216
    def visit_arguments_node(node)
      table = Table.new("ArgumentsNode")
      id = node_id(node)

      # flags
      table.field("flags", arguments_node_flags_inspect(node))

      # arguments
      if node.arguments.any?
        table.field("arguments", port: true)

        waypoint = "#{id}_arguments"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:arguments -> #{waypoint};")
        node.arguments.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("arguments", "[]")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_array_node(node) click to toggle source

Visit a ArrayNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 246
    def visit_array_node(node)
      table = Table.new("ArrayNode")
      id = node_id(node)

      # flags
      table.field("flags", array_node_flags_inspect(node))

      # elements
      if node.elements.any?
        table.field("elements", port: true)

        waypoint = "#{id}_elements"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:elements -> #{waypoint};")
        node.elements.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("elements", "[]")
      end

      # opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_array_pattern_node(node) click to toggle source

Visit a ArrayPatternNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 286
    def visit_array_pattern_node(node)
      table = Table.new("ArrayPatternNode")
      id = node_id(node)

      # constant
      unless (constant = node.constant).nil?
        table.field("constant", port: true)
        digraph.edge("#{id}:constant -> #{node_id(constant)};")
      end

      # requireds
      if node.requireds.any?
        table.field("requireds", port: true)

        waypoint = "#{id}_requireds"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:requireds -> #{waypoint};")
        node.requireds.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("requireds", "[]")
      end

      # rest
      unless (rest = node.rest).nil?
        table.field("rest", port: true)
        digraph.edge("#{id}:rest -> #{node_id(rest)};")
      end

      # posts
      if node.posts.any?
        table.field("posts", port: true)

        waypoint = "#{id}_posts"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:posts -> #{waypoint};")
        node.posts.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("posts", "[]")
      end

      # opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_assoc_node(node) click to toggle source

Visit a AssocNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 348
    def visit_assoc_node(node)
      table = Table.new("AssocNode")
      id = node_id(node)

      # key
      table.field("key", port: true)
      digraph.edge("#{id}:key -> #{node_id(node.key)};")

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # operator_loc
      unless (operator_loc = node.operator_loc).nil?
        table.field("operator_loc", location_inspect(operator_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_assoc_splat_node(node) click to toggle source

Visit a AssocSplatNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 375
    def visit_assoc_splat_node(node)
      table = Table.new("AssocSplatNode")
      id = node_id(node)

      # value
      unless (value = node.value).nil?
        table.field("value", port: true)
        digraph.edge("#{id}:value -> #{node_id(value)};")
      end

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_back_reference_read_node(node) click to toggle source

Visit a BackReferenceReadNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 398
    def visit_back_reference_read_node(node)
      table = Table.new("BackReferenceReadNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_begin_node(node) click to toggle source

Visit a BeginNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 415
    def visit_begin_node(node)
      table = Table.new("BeginNode")
      id = node_id(node)

      # begin_keyword_loc
      unless (begin_keyword_loc = node.begin_keyword_loc).nil?
        table.field("begin_keyword_loc", location_inspect(begin_keyword_loc))
      end

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # rescue_clause
      unless (rescue_clause = node.rescue_clause).nil?
        table.field("rescue_clause", port: true)
        digraph.edge("#{id}:rescue_clause -> #{node_id(rescue_clause)};")
      end

      # else_clause
      unless (else_clause = node.else_clause).nil?
        table.field("else_clause", port: true)
        digraph.edge("#{id}:else_clause -> #{node_id(else_clause)};")
      end

      # ensure_clause
      unless (ensure_clause = node.ensure_clause).nil?
        table.field("ensure_clause", port: true)
        digraph.edge("#{id}:ensure_clause -> #{node_id(ensure_clause)};")
      end

      # end_keyword_loc
      unless (end_keyword_loc = node.end_keyword_loc).nil?
        table.field("end_keyword_loc", location_inspect(end_keyword_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_block_argument_node(node) click to toggle source

Visit a BlockArgumentNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 463
    def visit_block_argument_node(node)
      table = Table.new("BlockArgumentNode")
      id = node_id(node)

      # expression
      unless (expression = node.expression).nil?
        table.field("expression", port: true)
        digraph.edge("#{id}:expression -> #{node_id(expression)};")
      end

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_block_local_variable_node(node) click to toggle source

Visit a BlockLocalVariableNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 486
    def visit_block_local_variable_node(node)
      table = Table.new("BlockLocalVariableNode")
      id = node_id(node)

      # flags
      table.field("flags", parameter_flags_inspect(node))

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_block_node(node) click to toggle source

Visit a BlockNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 506
    def visit_block_node(node)
      table = Table.new("BlockNode")
      id = node_id(node)

      # locals
      table.field("locals", node.locals.inspect)

      # parameters
      unless (parameters = node.parameters).nil?
        table.field("parameters", port: true)
        digraph.edge("#{id}:parameters -> #{node_id(parameters)};")
      end

      # body
      unless (body = node.body).nil?
        table.field("body", port: true)
        digraph.edge("#{id}:body -> #{node_id(body)};")
      end

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_block_parameter_node(node) click to toggle source

Visit a BlockParameterNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 541
    def visit_block_parameter_node(node)
      table = Table.new("BlockParameterNode")
      id = node_id(node)

      # flags
      table.field("flags", parameter_flags_inspect(node))

      # name
      table.field("name", node.name.inspect)

      # name_loc
      unless (name_loc = node.name_loc).nil?
        table.field("name_loc", location_inspect(name_loc))
      end

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_block_parameters_node(node) click to toggle source

Visit a BlockParametersNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 569
    def visit_block_parameters_node(node)
      table = Table.new("BlockParametersNode")
      id = node_id(node)

      # parameters
      unless (parameters = node.parameters).nil?
        table.field("parameters", port: true)
        digraph.edge("#{id}:parameters -> #{node_id(parameters)};")
      end

      # locals
      if node.locals.any?
        table.field("locals", port: true)

        waypoint = "#{id}_locals"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:locals -> #{waypoint};")
        node.locals.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("locals", "[]")
      end

      # opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_break_node(node) click to toggle source

Visit a BreakNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 612
    def visit_break_node(node)
      table = Table.new("BreakNode")
      id = node_id(node)

      # arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_call_and_write_node(node) click to toggle source

Visit a CallAndWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 635
    def visit_call_and_write_node(node)
      table = Table.new("CallAndWriteNode")
      id = node_id(node)

      # flags
      table.field("flags", call_node_flags_inspect(node))

      # receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

      # call_operator_loc
      unless (call_operator_loc = node.call_operator_loc).nil?
        table.field("call_operator_loc", location_inspect(call_operator_loc))
      end

      # message_loc
      unless (message_loc = node.message_loc).nil?
        table.field("message_loc", location_inspect(message_loc))
      end

      # read_name
      table.field("read_name", node.read_name.inspect)

      # write_name
      table.field("write_name", node.write_name.inspect)

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_call_node(node) click to toggle source

Visit a CallNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 681
    def visit_call_node(node)
      table = Table.new("CallNode")
      id = node_id(node)

      # flags
      table.field("flags", call_node_flags_inspect(node))

      # receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

      # call_operator_loc
      unless (call_operator_loc = node.call_operator_loc).nil?
        table.field("call_operator_loc", location_inspect(call_operator_loc))
      end

      # name
      table.field("name", node.name.inspect)

      # message_loc
      unless (message_loc = node.message_loc).nil?
        table.field("message_loc", location_inspect(message_loc))
      end

      # opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

      # arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      # block
      unless (block = node.block).nil?
        table.field("block", port: true)
        digraph.edge("#{id}:block -> #{node_id(block)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_call_operator_write_node(node) click to toggle source

Visit a CallOperatorWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 739
    def visit_call_operator_write_node(node)
      table = Table.new("CallOperatorWriteNode")
      id = node_id(node)

      # flags
      table.field("flags", call_node_flags_inspect(node))

      # receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

      # call_operator_loc
      unless (call_operator_loc = node.call_operator_loc).nil?
        table.field("call_operator_loc", location_inspect(call_operator_loc))
      end

      # message_loc
      unless (message_loc = node.message_loc).nil?
        table.field("message_loc", location_inspect(message_loc))
      end

      # read_name
      table.field("read_name", node.read_name.inspect)

      # write_name
      table.field("write_name", node.write_name.inspect)

      # binary_operator
      table.field("binary_operator", node.binary_operator.inspect)

      # binary_operator_loc
      table.field("binary_operator_loc", location_inspect(node.binary_operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_call_or_write_node(node) click to toggle source

Visit a CallOrWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 788
    def visit_call_or_write_node(node)
      table = Table.new("CallOrWriteNode")
      id = node_id(node)

      # flags
      table.field("flags", call_node_flags_inspect(node))

      # receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

      # call_operator_loc
      unless (call_operator_loc = node.call_operator_loc).nil?
        table.field("call_operator_loc", location_inspect(call_operator_loc))
      end

      # message_loc
      unless (message_loc = node.message_loc).nil?
        table.field("message_loc", location_inspect(message_loc))
      end

      # read_name
      table.field("read_name", node.read_name.inspect)

      # write_name
      table.field("write_name", node.write_name.inspect)

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_call_target_node(node) click to toggle source

Visit a CallTargetNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 834
    def visit_call_target_node(node)
      table = Table.new("CallTargetNode")
      id = node_id(node)

      # flags
      table.field("flags", call_node_flags_inspect(node))

      # receiver
      table.field("receiver", port: true)
      digraph.edge("#{id}:receiver -> #{node_id(node.receiver)};")

      # call_operator_loc
      table.field("call_operator_loc", location_inspect(node.call_operator_loc))

      # name
      table.field("name", node.name.inspect)

      # message_loc
      table.field("message_loc", location_inspect(node.message_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_capture_pattern_node(node) click to toggle source

Visit a CapturePatternNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 864
    def visit_capture_pattern_node(node)
      table = Table.new("CapturePatternNode")
      id = node_id(node)

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # target
      table.field("target", port: true)
      digraph.edge("#{id}:target -> #{node_id(node.target)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_case_match_node(node) click to toggle source

Visit a CaseMatchNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 889
    def visit_case_match_node(node)
      table = Table.new("CaseMatchNode")
      id = node_id(node)

      # predicate
      unless (predicate = node.predicate).nil?
        table.field("predicate", port: true)
        digraph.edge("#{id}:predicate -> #{node_id(predicate)};")
      end

      # conditions
      if node.conditions.any?
        table.field("conditions", port: true)

        waypoint = "#{id}_conditions"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:conditions -> #{waypoint};")
        node.conditions.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("conditions", "[]")
      end

      # else_clause
      unless (else_clause = node.else_clause).nil?
        table.field("else_clause", port: true)
        digraph.edge("#{id}:else_clause -> #{node_id(else_clause)};")
      end

      # case_keyword_loc
      table.field("case_keyword_loc", location_inspect(node.case_keyword_loc))

      # end_keyword_loc
      table.field("end_keyword_loc", location_inspect(node.end_keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_case_node(node) click to toggle source

Visit a CaseNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 934
    def visit_case_node(node)
      table = Table.new("CaseNode")
      id = node_id(node)

      # predicate
      unless (predicate = node.predicate).nil?
        table.field("predicate", port: true)
        digraph.edge("#{id}:predicate -> #{node_id(predicate)};")
      end

      # conditions
      if node.conditions.any?
        table.field("conditions", port: true)

        waypoint = "#{id}_conditions"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:conditions -> #{waypoint};")
        node.conditions.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("conditions", "[]")
      end

      # else_clause
      unless (else_clause = node.else_clause).nil?
        table.field("else_clause", port: true)
        digraph.edge("#{id}:else_clause -> #{node_id(else_clause)};")
      end

      # case_keyword_loc
      table.field("case_keyword_loc", location_inspect(node.case_keyword_loc))

      # end_keyword_loc
      table.field("end_keyword_loc", location_inspect(node.end_keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_class_node(node) click to toggle source

Visit a ClassNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 979
    def visit_class_node(node)
      table = Table.new("ClassNode")
      id = node_id(node)

      # locals
      table.field("locals", node.locals.inspect)

      # class_keyword_loc
      table.field("class_keyword_loc", location_inspect(node.class_keyword_loc))

      # constant_path
      table.field("constant_path", port: true)
      digraph.edge("#{id}:constant_path -> #{node_id(node.constant_path)};")

      # inheritance_operator_loc
      unless (inheritance_operator_loc = node.inheritance_operator_loc).nil?
        table.field("inheritance_operator_loc", location_inspect(inheritance_operator_loc))
      end

      # superclass
      unless (superclass = node.superclass).nil?
        table.field("superclass", port: true)
        digraph.edge("#{id}:superclass -> #{node_id(superclass)};")
      end

      # body
      unless (body = node.body).nil?
        table.field("body", port: true)
        digraph.edge("#{id}:body -> #{node_id(body)};")
      end

      # end_keyword_loc
      table.field("end_keyword_loc", location_inspect(node.end_keyword_loc))

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_class_variable_and_write_node(node) click to toggle source

Visit a ClassVariableAndWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1026
    def visit_class_variable_and_write_node(node)
      table = Table.new("ClassVariableAndWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_class_variable_operator_write_node(node) click to toggle source

Visit a ClassVariableOperatorWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1053
    def visit_class_variable_operator_write_node(node)
      table = Table.new("ClassVariableOperatorWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # binary_operator_loc
      table.field("binary_operator_loc", location_inspect(node.binary_operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # binary_operator
      table.field("binary_operator", node.binary_operator.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_class_variable_or_write_node(node) click to toggle source

Visit a ClassVariableOrWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1083
    def visit_class_variable_or_write_node(node)
      table = Table.new("ClassVariableOrWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_class_variable_read_node(node) click to toggle source

Visit a ClassVariableReadNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1110
    def visit_class_variable_read_node(node)
      table = Table.new("ClassVariableReadNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_class_variable_target_node(node) click to toggle source

Visit a ClassVariableTargetNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1127
    def visit_class_variable_target_node(node)
      table = Table.new("ClassVariableTargetNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_class_variable_write_node(node) click to toggle source

Visit a ClassVariableWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1144
    def visit_class_variable_write_node(node)
      table = Table.new("ClassVariableWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_and_write_node(node) click to toggle source

Visit a ConstantAndWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1171
    def visit_constant_and_write_node(node)
      table = Table.new("ConstantAndWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_operator_write_node(node) click to toggle source

Visit a ConstantOperatorWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1198
    def visit_constant_operator_write_node(node)
      table = Table.new("ConstantOperatorWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # binary_operator_loc
      table.field("binary_operator_loc", location_inspect(node.binary_operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # binary_operator
      table.field("binary_operator", node.binary_operator.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_or_write_node(node) click to toggle source

Visit a ConstantOrWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1228
    def visit_constant_or_write_node(node)
      table = Table.new("ConstantOrWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_path_and_write_node(node) click to toggle source

Visit a ConstantPathAndWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1255
    def visit_constant_path_and_write_node(node)
      table = Table.new("ConstantPathAndWriteNode")
      id = node_id(node)

      # target
      table.field("target", port: true)
      digraph.edge("#{id}:target -> #{node_id(node.target)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_path_node(node) click to toggle source

Visit a ConstantPathNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1280
    def visit_constant_path_node(node)
      table = Table.new("ConstantPathNode")
      id = node_id(node)

      # parent
      unless (parent = node.parent).nil?
        table.field("parent", port: true)
        digraph.edge("#{id}:parent -> #{node_id(parent)};")
      end

      # name
      table.field("name", node.name.inspect)

      # delimiter_loc
      table.field("delimiter_loc", location_inspect(node.delimiter_loc))

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_path_operator_write_node(node) click to toggle source

Visit a ConstantPathOperatorWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1309
    def visit_constant_path_operator_write_node(node)
      table = Table.new("ConstantPathOperatorWriteNode")
      id = node_id(node)

      # target
      table.field("target", port: true)
      digraph.edge("#{id}:target -> #{node_id(node.target)};")

      # binary_operator_loc
      table.field("binary_operator_loc", location_inspect(node.binary_operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # binary_operator
      table.field("binary_operator", node.binary_operator.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_path_or_write_node(node) click to toggle source

Visit a ConstantPathOrWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1337
    def visit_constant_path_or_write_node(node)
      table = Table.new("ConstantPathOrWriteNode")
      id = node_id(node)

      # target
      table.field("target", port: true)
      digraph.edge("#{id}:target -> #{node_id(node.target)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_path_target_node(node) click to toggle source

Visit a ConstantPathTargetNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1362
    def visit_constant_path_target_node(node)
      table = Table.new("ConstantPathTargetNode")
      id = node_id(node)

      # parent
      unless (parent = node.parent).nil?
        table.field("parent", port: true)
        digraph.edge("#{id}:parent -> #{node_id(parent)};")
      end

      # name
      table.field("name", node.name.inspect)

      # delimiter_loc
      table.field("delimiter_loc", location_inspect(node.delimiter_loc))

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_path_write_node(node) click to toggle source

Visit a ConstantPathWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1391
    def visit_constant_path_write_node(node)
      table = Table.new("ConstantPathWriteNode")
      id = node_id(node)

      # target
      table.field("target", port: true)
      digraph.edge("#{id}:target -> #{node_id(node.target)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_read_node(node) click to toggle source

Visit a ConstantReadNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1416
    def visit_constant_read_node(node)
      table = Table.new("ConstantReadNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_target_node(node) click to toggle source

Visit a ConstantTargetNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1433
    def visit_constant_target_node(node)
      table = Table.new("ConstantTargetNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_constant_write_node(node) click to toggle source

Visit a ConstantWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1450
    def visit_constant_write_node(node)
      table = Table.new("ConstantWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_def_node(node) click to toggle source

Visit a DefNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1477
    def visit_def_node(node)
      table = Table.new("DefNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

      # parameters
      unless (parameters = node.parameters).nil?
        table.field("parameters", port: true)
        digraph.edge("#{id}:parameters -> #{node_id(parameters)};")
      end

      # body
      unless (body = node.body).nil?
        table.field("body", port: true)
        digraph.edge("#{id}:body -> #{node_id(body)};")
      end

      # locals
      table.field("locals", node.locals.inspect)

      # def_keyword_loc
      table.field("def_keyword_loc", location_inspect(node.def_keyword_loc))

      # operator_loc
      unless (operator_loc = node.operator_loc).nil?
        table.field("operator_loc", location_inspect(operator_loc))
      end

      # lparen_loc
      unless (lparen_loc = node.lparen_loc).nil?
        table.field("lparen_loc", location_inspect(lparen_loc))
      end

      # rparen_loc
      unless (rparen_loc = node.rparen_loc).nil?
        table.field("rparen_loc", location_inspect(rparen_loc))
      end

      # equal_loc
      unless (equal_loc = node.equal_loc).nil?
        table.field("equal_loc", location_inspect(equal_loc))
      end

      # end_keyword_loc
      unless (end_keyword_loc = node.end_keyword_loc).nil?
        table.field("end_keyword_loc", location_inspect(end_keyword_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_defined_node(node) click to toggle source

Visit a DefinedNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1546
    def visit_defined_node(node)
      table = Table.new("DefinedNode")
      id = node_id(node)

      # lparen_loc
      unless (lparen_loc = node.lparen_loc).nil?
        table.field("lparen_loc", location_inspect(lparen_loc))
      end

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # rparen_loc
      unless (rparen_loc = node.rparen_loc).nil?
        table.field("rparen_loc", location_inspect(rparen_loc))
      end

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_else_node(node) click to toggle source

Visit a ElseNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1577
    def visit_else_node(node)
      table = Table.new("ElseNode")
      id = node_id(node)

      # else_keyword_loc
      table.field("else_keyword_loc", location_inspect(node.else_keyword_loc))

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # end_keyword_loc
      unless (end_keyword_loc = node.end_keyword_loc).nil?
        table.field("end_keyword_loc", location_inspect(end_keyword_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_embedded_statements_node(node) click to toggle source

Visit a EmbeddedStatementsNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1605
    def visit_embedded_statements_node(node)
      table = Table.new("EmbeddedStatementsNode")
      id = node_id(node)

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_embedded_variable_node(node) click to toggle source

Visit a EmbeddedVariableNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1631
    def visit_embedded_variable_node(node)
      table = Table.new("EmbeddedVariableNode")
      id = node_id(node)

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # variable
      table.field("variable", port: true)
      digraph.edge("#{id}:variable -> #{node_id(node.variable)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_ensure_node(node) click to toggle source

Visit a EnsureNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1652
    def visit_ensure_node(node)
      table = Table.new("EnsureNode")
      id = node_id(node)

      # ensure_keyword_loc
      table.field("ensure_keyword_loc", location_inspect(node.ensure_keyword_loc))

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # end_keyword_loc
      table.field("end_keyword_loc", location_inspect(node.end_keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_false_node(node) click to toggle source

Visit a FalseNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1678
    def visit_false_node(node)
      table = Table.new("FalseNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_find_pattern_node(node) click to toggle source

Visit a FindPatternNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1692
    def visit_find_pattern_node(node)
      table = Table.new("FindPatternNode")
      id = node_id(node)

      # constant
      unless (constant = node.constant).nil?
        table.field("constant", port: true)
        digraph.edge("#{id}:constant -> #{node_id(constant)};")
      end

      # left
      table.field("left", port: true)
      digraph.edge("#{id}:left -> #{node_id(node.left)};")

      # requireds
      if node.requireds.any?
        table.field("requireds", port: true)

        waypoint = "#{id}_requireds"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:requireds -> #{waypoint};")
        node.requireds.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("requireds", "[]")
      end

      # right
      table.field("right", port: true)
      digraph.edge("#{id}:right -> #{node_id(node.right)};")

      # opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_flip_flop_node(node) click to toggle source

Visit a FlipFlopNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1743
    def visit_flip_flop_node(node)
      table = Table.new("FlipFlopNode")
      id = node_id(node)

      # flags
      table.field("flags", range_flags_inspect(node))

      # left
      unless (left = node.left).nil?
        table.field("left", port: true)
        digraph.edge("#{id}:left -> #{node_id(left)};")
      end

      # right
      unless (right = node.right).nil?
        table.field("right", port: true)
        digraph.edge("#{id}:right -> #{node_id(right)};")
      end

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_float_node(node) click to toggle source

Visit a FloatNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1775
    def visit_float_node(node)
      table = Table.new("FloatNode")
      id = node_id(node)

      # value
      table.field("value", node.value.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_for_node(node) click to toggle source

Visit a ForNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1792
    def visit_for_node(node)
      table = Table.new("ForNode")
      id = node_id(node)

      # index
      table.field("index", port: true)
      digraph.edge("#{id}:index -> #{node_id(node.index)};")

      # collection
      table.field("collection", port: true)
      digraph.edge("#{id}:collection -> #{node_id(node.collection)};")

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # for_keyword_loc
      table.field("for_keyword_loc", location_inspect(node.for_keyword_loc))

      # in_keyword_loc
      table.field("in_keyword_loc", location_inspect(node.in_keyword_loc))

      # do_keyword_loc
      unless (do_keyword_loc = node.do_keyword_loc).nil?
        table.field("do_keyword_loc", location_inspect(do_keyword_loc))
      end

      # end_keyword_loc
      table.field("end_keyword_loc", location_inspect(node.end_keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_forwarding_arguments_node(node) click to toggle source

Visit a ForwardingArgumentsNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1834
    def visit_forwarding_arguments_node(node)
      table = Table.new("ForwardingArgumentsNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_forwarding_parameter_node(node) click to toggle source

Visit a ForwardingParameterNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1848
    def visit_forwarding_parameter_node(node)
      table = Table.new("ForwardingParameterNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_forwarding_super_node(node) click to toggle source

Visit a ForwardingSuperNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1862
    def visit_forwarding_super_node(node)
      table = Table.new("ForwardingSuperNode")
      id = node_id(node)

      # block
      unless (block = node.block).nil?
        table.field("block", port: true)
        digraph.edge("#{id}:block -> #{node_id(block)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_global_variable_and_write_node(node) click to toggle source

Visit a GlobalVariableAndWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1882
    def visit_global_variable_and_write_node(node)
      table = Table.new("GlobalVariableAndWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_global_variable_operator_write_node(node) click to toggle source

Visit a GlobalVariableOperatorWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1909
    def visit_global_variable_operator_write_node(node)
      table = Table.new("GlobalVariableOperatorWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # binary_operator_loc
      table.field("binary_operator_loc", location_inspect(node.binary_operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # binary_operator
      table.field("binary_operator", node.binary_operator.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_global_variable_or_write_node(node) click to toggle source

Visit a GlobalVariableOrWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1939
    def visit_global_variable_or_write_node(node)
      table = Table.new("GlobalVariableOrWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_global_variable_read_node(node) click to toggle source

Visit a GlobalVariableReadNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1966
    def visit_global_variable_read_node(node)
      table = Table.new("GlobalVariableReadNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_global_variable_target_node(node) click to toggle source

Visit a GlobalVariableTargetNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 1983
    def visit_global_variable_target_node(node)
      table = Table.new("GlobalVariableTargetNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_global_variable_write_node(node) click to toggle source

Visit a GlobalVariableWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2000
    def visit_global_variable_write_node(node)
      table = Table.new("GlobalVariableWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_hash_node(node) click to toggle source

Visit a HashNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2027
    def visit_hash_node(node)
      table = Table.new("HashNode")
      id = node_id(node)

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # elements
      if node.elements.any?
        table.field("elements", port: true)

        waypoint = "#{id}_elements"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:elements -> #{waypoint};")
        node.elements.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("elements", "[]")
      end

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_hash_pattern_node(node) click to toggle source

Visit a HashPatternNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2060
    def visit_hash_pattern_node(node)
      table = Table.new("HashPatternNode")
      id = node_id(node)

      # constant
      unless (constant = node.constant).nil?
        table.field("constant", port: true)
        digraph.edge("#{id}:constant -> #{node_id(constant)};")
      end

      # elements
      if node.elements.any?
        table.field("elements", port: true)

        waypoint = "#{id}_elements"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:elements -> #{waypoint};")
        node.elements.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("elements", "[]")
      end

      # rest
      unless (rest = node.rest).nil?
        table.field("rest", port: true)
        digraph.edge("#{id}:rest -> #{node_id(rest)};")
      end

      # opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_if_node(node) click to toggle source

Visit a IfNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2109
    def visit_if_node(node)
      table = Table.new("IfNode")
      id = node_id(node)

      # if_keyword_loc
      unless (if_keyword_loc = node.if_keyword_loc).nil?
        table.field("if_keyword_loc", location_inspect(if_keyword_loc))
      end

      # predicate
      table.field("predicate", port: true)
      digraph.edge("#{id}:predicate -> #{node_id(node.predicate)};")

      # then_keyword_loc
      unless (then_keyword_loc = node.then_keyword_loc).nil?
        table.field("then_keyword_loc", location_inspect(then_keyword_loc))
      end

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # subsequent
      unless (subsequent = node.subsequent).nil?
        table.field("subsequent", port: true)
        digraph.edge("#{id}:subsequent -> #{node_id(subsequent)};")
      end

      # end_keyword_loc
      unless (end_keyword_loc = node.end_keyword_loc).nil?
        table.field("end_keyword_loc", location_inspect(end_keyword_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_imaginary_node(node) click to toggle source

Visit a ImaginaryNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2154
    def visit_imaginary_node(node)
      table = Table.new("ImaginaryNode")
      id = node_id(node)

      # numeric
      table.field("numeric", port: true)
      digraph.edge("#{id}:numeric -> #{node_id(node.numeric)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_implicit_node(node) click to toggle source

Visit a ImplicitNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2172
    def visit_implicit_node(node)
      table = Table.new("ImplicitNode")
      id = node_id(node)

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_implicit_rest_node(node) click to toggle source

Visit a ImplicitRestNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2190
    def visit_implicit_rest_node(node)
      table = Table.new("ImplicitRestNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_in_node(node) click to toggle source

Visit a InNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2204
    def visit_in_node(node)
      table = Table.new("InNode")
      id = node_id(node)

      # pattern
      table.field("pattern", port: true)
      digraph.edge("#{id}:pattern -> #{node_id(node.pattern)};")

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # in_loc
      table.field("in_loc", location_inspect(node.in_loc))

      # then_loc
      unless (then_loc = node.then_loc).nil?
        table.field("then_loc", location_inspect(then_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_index_and_write_node(node) click to toggle source

Visit a IndexAndWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2236
    def visit_index_and_write_node(node)
      table = Table.new("IndexAndWriteNode")
      id = node_id(node)

      # flags
      table.field("flags", call_node_flags_inspect(node))

      # receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

      # call_operator_loc
      unless (call_operator_loc = node.call_operator_loc).nil?
        table.field("call_operator_loc", location_inspect(call_operator_loc))
      end

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      # block
      unless (block = node.block).nil?
        table.field("block", port: true)
        digraph.edge("#{id}:block -> #{node_id(block)};")
      end

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_index_operator_write_node(node) click to toggle source

Visit a IndexOperatorWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2289
    def visit_index_operator_write_node(node)
      table = Table.new("IndexOperatorWriteNode")
      id = node_id(node)

      # flags
      table.field("flags", call_node_flags_inspect(node))

      # receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

      # call_operator_loc
      unless (call_operator_loc = node.call_operator_loc).nil?
        table.field("call_operator_loc", location_inspect(call_operator_loc))
      end

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      # block
      unless (block = node.block).nil?
        table.field("block", port: true)
        digraph.edge("#{id}:block -> #{node_id(block)};")
      end

      # binary_operator
      table.field("binary_operator", node.binary_operator.inspect)

      # binary_operator_loc
      table.field("binary_operator_loc", location_inspect(node.binary_operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_index_or_write_node(node) click to toggle source

Visit a IndexOrWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2345
    def visit_index_or_write_node(node)
      table = Table.new("IndexOrWriteNode")
      id = node_id(node)

      # flags
      table.field("flags", call_node_flags_inspect(node))

      # receiver
      unless (receiver = node.receiver).nil?
        table.field("receiver", port: true)
        digraph.edge("#{id}:receiver -> #{node_id(receiver)};")
      end

      # call_operator_loc
      unless (call_operator_loc = node.call_operator_loc).nil?
        table.field("call_operator_loc", location_inspect(call_operator_loc))
      end

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      # block
      unless (block = node.block).nil?
        table.field("block", port: true)
        digraph.edge("#{id}:block -> #{node_id(block)};")
      end

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_index_target_node(node) click to toggle source

Visit a IndexTargetNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2398
    def visit_index_target_node(node)
      table = Table.new("IndexTargetNode")
      id = node_id(node)

      # flags
      table.field("flags", call_node_flags_inspect(node))

      # receiver
      table.field("receiver", port: true)
      digraph.edge("#{id}:receiver -> #{node_id(node.receiver)};")

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      # block
      unless (block = node.block).nil?
        table.field("block", port: true)
        digraph.edge("#{id}:block -> #{node_id(block)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_instance_variable_and_write_node(node) click to toggle source

Visit a InstanceVariableAndWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2437
    def visit_instance_variable_and_write_node(node)
      table = Table.new("InstanceVariableAndWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_instance_variable_operator_write_node(node) click to toggle source

Visit a InstanceVariableOperatorWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2464
    def visit_instance_variable_operator_write_node(node)
      table = Table.new("InstanceVariableOperatorWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # binary_operator_loc
      table.field("binary_operator_loc", location_inspect(node.binary_operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # binary_operator
      table.field("binary_operator", node.binary_operator.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_instance_variable_or_write_node(node) click to toggle source

Visit a InstanceVariableOrWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2494
    def visit_instance_variable_or_write_node(node)
      table = Table.new("InstanceVariableOrWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_instance_variable_read_node(node) click to toggle source

Visit a InstanceVariableReadNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2521
    def visit_instance_variable_read_node(node)
      table = Table.new("InstanceVariableReadNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_instance_variable_target_node(node) click to toggle source

Visit a InstanceVariableTargetNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2538
    def visit_instance_variable_target_node(node)
      table = Table.new("InstanceVariableTargetNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_instance_variable_write_node(node) click to toggle source

Visit a InstanceVariableWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2555
    def visit_instance_variable_write_node(node)
      table = Table.new("InstanceVariableWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_integer_node(node) click to toggle source

Visit a IntegerNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2582
    def visit_integer_node(node)
      table = Table.new("IntegerNode")
      id = node_id(node)

      # flags
      table.field("flags", integer_base_flags_inspect(node))

      # value
      table.field("value", node.value.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_interpolated_match_last_line_node(node) click to toggle source

Visit a InterpolatedMatchLastLineNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2602
    def visit_interpolated_match_last_line_node(node)
      table = Table.new("InterpolatedMatchLastLineNode")
      id = node_id(node)

      # flags
      table.field("flags", regular_expression_flags_inspect(node))

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # parts
      if node.parts.any?
        table.field("parts", port: true)

        waypoint = "#{id}_parts"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:parts -> #{waypoint};")
        node.parts.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("parts", "[]")
      end

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_interpolated_regular_expression_node(node) click to toggle source

Visit a InterpolatedRegularExpressionNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2638
    def visit_interpolated_regular_expression_node(node)
      table = Table.new("InterpolatedRegularExpressionNode")
      id = node_id(node)

      # flags
      table.field("flags", regular_expression_flags_inspect(node))

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # parts
      if node.parts.any?
        table.field("parts", port: true)

        waypoint = "#{id}_parts"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:parts -> #{waypoint};")
        node.parts.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("parts", "[]")
      end

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_interpolated_string_node(node) click to toggle source

Visit a InterpolatedStringNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2674
    def visit_interpolated_string_node(node)
      table = Table.new("InterpolatedStringNode")
      id = node_id(node)

      # flags
      table.field("flags", interpolated_string_node_flags_inspect(node))

      # opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

      # parts
      if node.parts.any?
        table.field("parts", port: true)

        waypoint = "#{id}_parts"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:parts -> #{waypoint};")
        node.parts.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("parts", "[]")
      end

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_interpolated_symbol_node(node) click to toggle source

Visit a InterpolatedSymbolNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2714
    def visit_interpolated_symbol_node(node)
      table = Table.new("InterpolatedSymbolNode")
      id = node_id(node)

      # opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

      # parts
      if node.parts.any?
        table.field("parts", port: true)

        waypoint = "#{id}_parts"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:parts -> #{waypoint};")
        node.parts.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("parts", "[]")
      end

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_interpolated_x_string_node(node) click to toggle source

Visit a InterpolatedXStringNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2751
    def visit_interpolated_x_string_node(node)
      table = Table.new("InterpolatedXStringNode")
      id = node_id(node)

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # parts
      if node.parts.any?
        table.field("parts", port: true)

        waypoint = "#{id}_parts"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:parts -> #{waypoint};")
        node.parts.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("parts", "[]")
      end

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_it_local_variable_read_node(node) click to toggle source

Visit a ItLocalVariableReadNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2784
    def visit_it_local_variable_read_node(node)
      table = Table.new("ItLocalVariableReadNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_it_parameters_node(node) click to toggle source

Visit a ItParametersNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2798
    def visit_it_parameters_node(node)
      table = Table.new("ItParametersNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_keyword_hash_node(node) click to toggle source

Visit a KeywordHashNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2812
    def visit_keyword_hash_node(node)
      table = Table.new("KeywordHashNode")
      id = node_id(node)

      # flags
      table.field("flags", keyword_hash_node_flags_inspect(node))

      # elements
      if node.elements.any?
        table.field("elements", port: true)

        waypoint = "#{id}_elements"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:elements -> #{waypoint};")
        node.elements.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("elements", "[]")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_keyword_rest_parameter_node(node) click to toggle source

Visit a KeywordRestParameterNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2842
    def visit_keyword_rest_parameter_node(node)
      table = Table.new("KeywordRestParameterNode")
      id = node_id(node)

      # flags
      table.field("flags", parameter_flags_inspect(node))

      # name
      table.field("name", node.name.inspect)

      # name_loc
      unless (name_loc = node.name_loc).nil?
        table.field("name_loc", location_inspect(name_loc))
      end

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_lambda_node(node) click to toggle source

Visit a LambdaNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2870
    def visit_lambda_node(node)
      table = Table.new("LambdaNode")
      id = node_id(node)

      # locals
      table.field("locals", node.locals.inspect)

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      # parameters
      unless (parameters = node.parameters).nil?
        table.field("parameters", port: true)
        digraph.edge("#{id}:parameters -> #{node_id(parameters)};")
      end

      # body
      unless (body = node.body).nil?
        table.field("body", port: true)
        digraph.edge("#{id}:body -> #{node_id(body)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_local_variable_and_write_node(node) click to toggle source

Visit a LocalVariableAndWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2908
    def visit_local_variable_and_write_node(node)
      table = Table.new("LocalVariableAndWriteNode")
      id = node_id(node)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # name
      table.field("name", node.name.inspect)

      # depth
      table.field("depth", node.depth.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_local_variable_operator_write_node(node) click to toggle source

Visit a LocalVariableOperatorWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2938
    def visit_local_variable_operator_write_node(node)
      table = Table.new("LocalVariableOperatorWriteNode")
      id = node_id(node)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # binary_operator_loc
      table.field("binary_operator_loc", location_inspect(node.binary_operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # name
      table.field("name", node.name.inspect)

      # binary_operator
      table.field("binary_operator", node.binary_operator.inspect)

      # depth
      table.field("depth", node.depth.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_local_variable_or_write_node(node) click to toggle source

Visit a LocalVariableOrWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 2971
    def visit_local_variable_or_write_node(node)
      table = Table.new("LocalVariableOrWriteNode")
      id = node_id(node)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # name
      table.field("name", node.name.inspect)

      # depth
      table.field("depth", node.depth.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_local_variable_read_node(node) click to toggle source

Visit a LocalVariableReadNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3001
    def visit_local_variable_read_node(node)
      table = Table.new("LocalVariableReadNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # depth
      table.field("depth", node.depth.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_local_variable_target_node(node) click to toggle source

Visit a LocalVariableTargetNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3021
    def visit_local_variable_target_node(node)
      table = Table.new("LocalVariableTargetNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # depth
      table.field("depth", node.depth.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_local_variable_write_node(node) click to toggle source

Visit a LocalVariableWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3041
    def visit_local_variable_write_node(node)
      table = Table.new("LocalVariableWriteNode")
      id = node_id(node)

      # name
      table.field("name", node.name.inspect)

      # depth
      table.field("depth", node.depth.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_match_last_line_node(node) click to toggle source

Visit a MatchLastLineNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3071
    def visit_match_last_line_node(node)
      table = Table.new("MatchLastLineNode")
      id = node_id(node)

      # flags
      table.field("flags", regular_expression_flags_inspect(node))

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # content_loc
      table.field("content_loc", location_inspect(node.content_loc))

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      # unescaped
      table.field("unescaped", node.unescaped.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_match_predicate_node(node) click to toggle source

Visit a MatchPredicateNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3100
    def visit_match_predicate_node(node)
      table = Table.new("MatchPredicateNode")
      id = node_id(node)

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # pattern
      table.field("pattern", port: true)
      digraph.edge("#{id}:pattern -> #{node_id(node.pattern)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_match_required_node(node) click to toggle source

Visit a MatchRequiredNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3125
    def visit_match_required_node(node)
      table = Table.new("MatchRequiredNode")
      id = node_id(node)

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      # pattern
      table.field("pattern", port: true)
      digraph.edge("#{id}:pattern -> #{node_id(node.pattern)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_match_write_node(node) click to toggle source

Visit a MatchWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3150
    def visit_match_write_node(node)
      table = Table.new("MatchWriteNode")
      id = node_id(node)

      # call
      table.field("call", port: true)
      digraph.edge("#{id}:call -> #{node_id(node.call)};")

      # targets
      if node.targets.any?
        table.field("targets", port: true)

        waypoint = "#{id}_targets"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:targets -> #{waypoint};")
        node.targets.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("targets", "[]")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_missing_node(node) click to toggle source

Visit a MissingNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3181
    def visit_missing_node(node)
      table = Table.new("MissingNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_module_node(node) click to toggle source

Visit a ModuleNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3195
    def visit_module_node(node)
      table = Table.new("ModuleNode")
      id = node_id(node)

      # locals
      table.field("locals", node.locals.inspect)

      # module_keyword_loc
      table.field("module_keyword_loc", location_inspect(node.module_keyword_loc))

      # constant_path
      table.field("constant_path", port: true)
      digraph.edge("#{id}:constant_path -> #{node_id(node.constant_path)};")

      # body
      unless (body = node.body).nil?
        table.field("body", port: true)
        digraph.edge("#{id}:body -> #{node_id(body)};")
      end

      # end_keyword_loc
      table.field("end_keyword_loc", location_inspect(node.end_keyword_loc))

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_multi_target_node(node) click to toggle source

Visit a MultiTargetNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3231
    def visit_multi_target_node(node)
      table = Table.new("MultiTargetNode")
      id = node_id(node)

      # lefts
      if node.lefts.any?
        table.field("lefts", port: true)

        waypoint = "#{id}_lefts"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:lefts -> #{waypoint};")
        node.lefts.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("lefts", "[]")
      end

      # rest
      unless (rest = node.rest).nil?
        table.field("rest", port: true)
        digraph.edge("#{id}:rest -> #{node_id(rest)};")
      end

      # rights
      if node.rights.any?
        table.field("rights", port: true)

        waypoint = "#{id}_rights"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:rights -> #{waypoint};")
        node.rights.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("rights", "[]")
      end

      # lparen_loc
      unless (lparen_loc = node.lparen_loc).nil?
        table.field("lparen_loc", location_inspect(lparen_loc))
      end

      # rparen_loc
      unless (rparen_loc = node.rparen_loc).nil?
        table.field("rparen_loc", location_inspect(rparen_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_multi_write_node(node) click to toggle source

Visit a MultiWriteNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3287
    def visit_multi_write_node(node)
      table = Table.new("MultiWriteNode")
      id = node_id(node)

      # lefts
      if node.lefts.any?
        table.field("lefts", port: true)

        waypoint = "#{id}_lefts"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:lefts -> #{waypoint};")
        node.lefts.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("lefts", "[]")
      end

      # rest
      unless (rest = node.rest).nil?
        table.field("rest", port: true)
        digraph.edge("#{id}:rest -> #{node_id(rest)};")
      end

      # rights
      if node.rights.any?
        table.field("rights", port: true)

        waypoint = "#{id}_rights"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:rights -> #{waypoint};")
        node.rights.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("rights", "[]")
      end

      # lparen_loc
      unless (lparen_loc = node.lparen_loc).nil?
        table.field("lparen_loc", location_inspect(lparen_loc))
      end

      # rparen_loc
      unless (rparen_loc = node.rparen_loc).nil?
        table.field("rparen_loc", location_inspect(rparen_loc))
      end

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_next_node(node) click to toggle source

Visit a NextNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3350
    def visit_next_node(node)
      table = Table.new("NextNode")
      id = node_id(node)

      # arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_nil_node(node) click to toggle source

Visit a NilNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3373
    def visit_nil_node(node)
      table = Table.new("NilNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_no_keywords_parameter_node(node) click to toggle source

Visit a NoKeywordsParameterNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3387
    def visit_no_keywords_parameter_node(node)
      table = Table.new("NoKeywordsParameterNode")
      id = node_id(node)

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_numbered_parameters_node(node) click to toggle source

Visit a NumberedParametersNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3407
    def visit_numbered_parameters_node(node)
      table = Table.new("NumberedParametersNode")
      id = node_id(node)

      # maximum
      table.field("maximum", node.maximum.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_numbered_reference_read_node(node) click to toggle source

Visit a NumberedReferenceReadNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3424
    def visit_numbered_reference_read_node(node)
      table = Table.new("NumberedReferenceReadNode")
      id = node_id(node)

      # number
      table.field("number", node.number.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_optional_keyword_parameter_node(node) click to toggle source

Visit a OptionalKeywordParameterNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3441
    def visit_optional_keyword_parameter_node(node)
      table = Table.new("OptionalKeywordParameterNode")
      id = node_id(node)

      # flags
      table.field("flags", parameter_flags_inspect(node))

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_optional_parameter_node(node) click to toggle source

Visit a OptionalParameterNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3468
    def visit_optional_parameter_node(node)
      table = Table.new("OptionalParameterNode")
      id = node_id(node)

      # flags
      table.field("flags", parameter_flags_inspect(node))

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # value
      table.field("value", port: true)
      digraph.edge("#{id}:value -> #{node_id(node.value)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_or_node(node) click to toggle source

Visit a OrNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3498
    def visit_or_node(node)
      table = Table.new("OrNode")
      id = node_id(node)

      # left
      table.field("left", port: true)
      digraph.edge("#{id}:left -> #{node_id(node.left)};")

      # right
      table.field("right", port: true)
      digraph.edge("#{id}:right -> #{node_id(node.right)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_parameters_node(node) click to toggle source

Visit a ParametersNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3523
    def visit_parameters_node(node)
      table = Table.new("ParametersNode")
      id = node_id(node)

      # requireds
      if node.requireds.any?
        table.field("requireds", port: true)

        waypoint = "#{id}_requireds"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:requireds -> #{waypoint};")
        node.requireds.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("requireds", "[]")
      end

      # optionals
      if node.optionals.any?
        table.field("optionals", port: true)

        waypoint = "#{id}_optionals"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:optionals -> #{waypoint};")
        node.optionals.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("optionals", "[]")
      end

      # rest
      unless (rest = node.rest).nil?
        table.field("rest", port: true)
        digraph.edge("#{id}:rest -> #{node_id(rest)};")
      end

      # posts
      if node.posts.any?
        table.field("posts", port: true)

        waypoint = "#{id}_posts"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:posts -> #{waypoint};")
        node.posts.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("posts", "[]")
      end

      # keywords
      if node.keywords.any?
        table.field("keywords", port: true)

        waypoint = "#{id}_keywords"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:keywords -> #{waypoint};")
        node.keywords.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("keywords", "[]")
      end

      # keyword_rest
      unless (keyword_rest = node.keyword_rest).nil?
        table.field("keyword_rest", port: true)
        digraph.edge("#{id}:keyword_rest -> #{node_id(keyword_rest)};")
      end

      # block
      unless (block = node.block).nil?
        table.field("block", port: true)
        digraph.edge("#{id}:block -> #{node_id(block)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_parentheses_node(node) click to toggle source

Visit a ParenthesesNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3607
    def visit_parentheses_node(node)
      table = Table.new("ParenthesesNode")
      id = node_id(node)

      # body
      unless (body = node.body).nil?
        table.field("body", port: true)
        digraph.edge("#{id}:body -> #{node_id(body)};")
      end

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_pinned_expression_node(node) click to toggle source

Visit a PinnedExpressionNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3633
    def visit_pinned_expression_node(node)
      table = Table.new("PinnedExpressionNode")
      id = node_id(node)

      # expression
      table.field("expression", port: true)
      digraph.edge("#{id}:expression -> #{node_id(node.expression)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # lparen_loc
      table.field("lparen_loc", location_inspect(node.lparen_loc))

      # rparen_loc
      table.field("rparen_loc", location_inspect(node.rparen_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_pinned_variable_node(node) click to toggle source

Visit a PinnedVariableNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3660
    def visit_pinned_variable_node(node)
      table = Table.new("PinnedVariableNode")
      id = node_id(node)

      # variable
      table.field("variable", port: true)
      digraph.edge("#{id}:variable -> #{node_id(node.variable)};")

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_post_execution_node(node) click to toggle source

Visit a PostExecutionNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3681
    def visit_post_execution_node(node)
      table = Table.new("PostExecutionNode")
      id = node_id(node)

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_pre_execution_node(node) click to toggle source

Visit a PreExecutionNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3710
    def visit_pre_execution_node(node)
      table = Table.new("PreExecutionNode")
      id = node_id(node)

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_program_node(node) click to toggle source

Visit a ProgramNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3739
    def visit_program_node(node)
      table = Table.new("ProgramNode")
      id = node_id(node)

      # locals
      table.field("locals", node.locals.inspect)

      # statements
      table.field("statements", port: true)
      digraph.edge("#{id}:statements -> #{node_id(node.statements)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_range_node(node) click to toggle source

Visit a RangeNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3760
    def visit_range_node(node)
      table = Table.new("RangeNode")
      id = node_id(node)

      # flags
      table.field("flags", range_flags_inspect(node))

      # left
      unless (left = node.left).nil?
        table.field("left", port: true)
        digraph.edge("#{id}:left -> #{node_id(left)};")
      end

      # right
      unless (right = node.right).nil?
        table.field("right", port: true)
        digraph.edge("#{id}:right -> #{node_id(right)};")
      end

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_rational_node(node) click to toggle source

Visit a RationalNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3792
    def visit_rational_node(node)
      table = Table.new("RationalNode")
      id = node_id(node)

      # flags
      table.field("flags", integer_base_flags_inspect(node))

      # numerator
      table.field("numerator", node.numerator.inspect)

      # denominator
      table.field("denominator", node.denominator.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_redo_node(node) click to toggle source

Visit a RedoNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3815
    def visit_redo_node(node)
      table = Table.new("RedoNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_regular_expression_node(node) click to toggle source

Visit a RegularExpressionNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3829
    def visit_regular_expression_node(node)
      table = Table.new("RegularExpressionNode")
      id = node_id(node)

      # flags
      table.field("flags", regular_expression_flags_inspect(node))

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # content_loc
      table.field("content_loc", location_inspect(node.content_loc))

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      # unescaped
      table.field("unescaped", node.unescaped.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_required_keyword_parameter_node(node) click to toggle source

Visit a RequiredKeywordParameterNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3858
    def visit_required_keyword_parameter_node(node)
      table = Table.new("RequiredKeywordParameterNode")
      id = node_id(node)

      # flags
      table.field("flags", parameter_flags_inspect(node))

      # name
      table.field("name", node.name.inspect)

      # name_loc
      table.field("name_loc", location_inspect(node.name_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_required_parameter_node(node) click to toggle source

Visit a RequiredParameterNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3881
    def visit_required_parameter_node(node)
      table = Table.new("RequiredParameterNode")
      id = node_id(node)

      # flags
      table.field("flags", parameter_flags_inspect(node))

      # name
      table.field("name", node.name.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_rescue_modifier_node(node) click to toggle source

Visit a RescueModifierNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3901
    def visit_rescue_modifier_node(node)
      table = Table.new("RescueModifierNode")
      id = node_id(node)

      # expression
      table.field("expression", port: true)
      digraph.edge("#{id}:expression -> #{node_id(node.expression)};")

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # rescue_expression
      table.field("rescue_expression", port: true)
      digraph.edge("#{id}:rescue_expression -> #{node_id(node.rescue_expression)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_rescue_node(node) click to toggle source

Visit a RescueNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3926
    def visit_rescue_node(node)
      table = Table.new("RescueNode")
      id = node_id(node)

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # exceptions
      if node.exceptions.any?
        table.field("exceptions", port: true)

        waypoint = "#{id}_exceptions"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:exceptions -> #{waypoint};")
        node.exceptions.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("exceptions", "[]")
      end

      # operator_loc
      unless (operator_loc = node.operator_loc).nil?
        table.field("operator_loc", location_inspect(operator_loc))
      end

      # reference
      unless (reference = node.reference).nil?
        table.field("reference", port: true)
        digraph.edge("#{id}:reference -> #{node_id(reference)};")
      end

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # subsequent
      unless (subsequent = node.subsequent).nil?
        table.field("subsequent", port: true)
        digraph.edge("#{id}:subsequent -> #{node_id(subsequent)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_rest_parameter_node(node) click to toggle source

Visit a RestParameterNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 3979
    def visit_rest_parameter_node(node)
      table = Table.new("RestParameterNode")
      id = node_id(node)

      # flags
      table.field("flags", parameter_flags_inspect(node))

      # name
      table.field("name", node.name.inspect)

      # name_loc
      unless (name_loc = node.name_loc).nil?
        table.field("name_loc", location_inspect(name_loc))
      end

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_retry_node(node) click to toggle source

Visit a RetryNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4007
    def visit_retry_node(node)
      table = Table.new("RetryNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_return_node(node) click to toggle source

Visit a ReturnNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4021
    def visit_return_node(node)
      table = Table.new("ReturnNode")
      id = node_id(node)

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_self_node(node) click to toggle source

Visit a SelfNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4044
    def visit_self_node(node)
      table = Table.new("SelfNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_shareable_constant_node(node) click to toggle source

Visit a ShareableConstantNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4058
    def visit_shareable_constant_node(node)
      table = Table.new("ShareableConstantNode")
      id = node_id(node)

      # flags
      table.field("flags", shareable_constant_node_flags_inspect(node))

      # write
      table.field("write", port: true)
      digraph.edge("#{id}:write -> #{node_id(node.write)};")

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_singleton_class_node(node) click to toggle source

Visit a SingletonClassNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4079
    def visit_singleton_class_node(node)
      table = Table.new("SingletonClassNode")
      id = node_id(node)

      # locals
      table.field("locals", node.locals.inspect)

      # class_keyword_loc
      table.field("class_keyword_loc", location_inspect(node.class_keyword_loc))

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # expression
      table.field("expression", port: true)
      digraph.edge("#{id}:expression -> #{node_id(node.expression)};")

      # body
      unless (body = node.body).nil?
        table.field("body", port: true)
        digraph.edge("#{id}:body -> #{node_id(body)};")
      end

      # end_keyword_loc
      table.field("end_keyword_loc", location_inspect(node.end_keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_source_encoding_node(node) click to toggle source

Visit a SourceEncodingNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4115
    def visit_source_encoding_node(node)
      table = Table.new("SourceEncodingNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_source_file_node(node) click to toggle source

Visit a SourceFileNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4129
    def visit_source_file_node(node)
      table = Table.new("SourceFileNode")
      id = node_id(node)

      # flags
      table.field("flags", string_flags_inspect(node))

      # filepath
      table.field("filepath", node.filepath.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_source_line_node(node) click to toggle source

Visit a SourceLineNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4149
    def visit_source_line_node(node)
      table = Table.new("SourceLineNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_splat_node(node) click to toggle source

Visit a SplatNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4163
    def visit_splat_node(node)
      table = Table.new("SplatNode")
      id = node_id(node)

      # operator_loc
      table.field("operator_loc", location_inspect(node.operator_loc))

      # expression
      unless (expression = node.expression).nil?
        table.field("expression", port: true)
        digraph.edge("#{id}:expression -> #{node_id(expression)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_statements_node(node) click to toggle source

Visit a StatementsNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4186
    def visit_statements_node(node)
      table = Table.new("StatementsNode")
      id = node_id(node)

      # body
      if node.body.any?
        table.field("body", port: true)

        waypoint = "#{id}_body"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:body -> #{waypoint};")
        node.body.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("body", "[]")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_string_node(node) click to toggle source

Visit a StringNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4213
    def visit_string_node(node)
      table = Table.new("StringNode")
      id = node_id(node)

      # flags
      table.field("flags", string_flags_inspect(node))

      # opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

      # content_loc
      table.field("content_loc", location_inspect(node.content_loc))

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      # unescaped
      table.field("unescaped", node.unescaped.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_super_node(node) click to toggle source

Visit a SuperNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4246
    def visit_super_node(node)
      table = Table.new("SuperNode")
      id = node_id(node)

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # lparen_loc
      unless (lparen_loc = node.lparen_loc).nil?
        table.field("lparen_loc", location_inspect(lparen_loc))
      end

      # arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

      # rparen_loc
      unless (rparen_loc = node.rparen_loc).nil?
        table.field("rparen_loc", location_inspect(rparen_loc))
      end

      # block
      unless (block = node.block).nil?
        table.field("block", port: true)
        digraph.edge("#{id}:block -> #{node_id(block)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_symbol_node(node) click to toggle source

Visit a SymbolNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4285
    def visit_symbol_node(node)
      table = Table.new("SymbolNode")
      id = node_id(node)

      # flags
      table.field("flags", symbol_flags_inspect(node))

      # opening_loc
      unless (opening_loc = node.opening_loc).nil?
        table.field("opening_loc", location_inspect(opening_loc))
      end

      # value_loc
      unless (value_loc = node.value_loc).nil?
        table.field("value_loc", location_inspect(value_loc))
      end

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      # unescaped
      table.field("unescaped", node.unescaped.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_true_node(node) click to toggle source

Visit a TrueNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4320
    def visit_true_node(node)
      table = Table.new("TrueNode")
      id = node_id(node)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_undef_node(node) click to toggle source

Visit a UndefNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4334
    def visit_undef_node(node)
      table = Table.new("UndefNode")
      id = node_id(node)

      # names
      if node.names.any?
        table.field("names", port: true)

        waypoint = "#{id}_names"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:names -> #{waypoint};")
        node.names.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("names", "[]")
      end

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_unless_node(node) click to toggle source

Visit a UnlessNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4364
    def visit_unless_node(node)
      table = Table.new("UnlessNode")
      id = node_id(node)

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # predicate
      table.field("predicate", port: true)
      digraph.edge("#{id}:predicate -> #{node_id(node.predicate)};")

      # then_keyword_loc
      unless (then_keyword_loc = node.then_keyword_loc).nil?
        table.field("then_keyword_loc", location_inspect(then_keyword_loc))
      end

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      # else_clause
      unless (else_clause = node.else_clause).nil?
        table.field("else_clause", port: true)
        digraph.edge("#{id}:else_clause -> #{node_id(else_clause)};")
      end

      # end_keyword_loc
      unless (end_keyword_loc = node.end_keyword_loc).nil?
        table.field("end_keyword_loc", location_inspect(end_keyword_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_until_node(node) click to toggle source

Visit a UntilNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4407
    def visit_until_node(node)
      table = Table.new("UntilNode")
      id = node_id(node)

      # flags
      table.field("flags", loop_flags_inspect(node))

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      # predicate
      table.field("predicate", port: true)
      digraph.edge("#{id}:predicate -> #{node_id(node.predicate)};")

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_when_node(node) click to toggle source

Visit a WhenNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4442
    def visit_when_node(node)
      table = Table.new("WhenNode")
      id = node_id(node)

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # conditions
      if node.conditions.any?
        table.field("conditions", port: true)

        waypoint = "#{id}_conditions"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:conditions -> #{waypoint};")
        node.conditions.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("conditions", "[]")
      end

      # then_keyword_loc
      unless (then_keyword_loc = node.then_keyword_loc).nil?
        table.field("then_keyword_loc", location_inspect(then_keyword_loc))
      end

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_while_node(node) click to toggle source

Visit a WhileNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4483
    def visit_while_node(node)
      table = Table.new("WhileNode")
      id = node_id(node)

      # flags
      table.field("flags", loop_flags_inspect(node))

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # closing_loc
      unless (closing_loc = node.closing_loc).nil?
        table.field("closing_loc", location_inspect(closing_loc))
      end

      # predicate
      table.field("predicate", port: true)
      digraph.edge("#{id}:predicate -> #{node_id(node.predicate)};")

      # statements
      unless (statements = node.statements).nil?
        table.field("statements", port: true)
        digraph.edge("#{id}:statements -> #{node_id(statements)};")
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_x_string_node(node) click to toggle source

Visit a XStringNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4518
    def visit_x_string_node(node)
      table = Table.new("XStringNode")
      id = node_id(node)

      # flags
      table.field("flags", encoding_flags_inspect(node))

      # opening_loc
      table.field("opening_loc", location_inspect(node.opening_loc))

      # content_loc
      table.field("content_loc", location_inspect(node.content_loc))

      # closing_loc
      table.field("closing_loc", location_inspect(node.closing_loc))

      # unescaped
      table.field("unescaped", node.unescaped.inspect)

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
visit_yield_node(node) click to toggle source

Visit a YieldNode node.

Calls superclass method
# File lib/prism/dot_visitor.rb, line 4547
    def visit_yield_node(node)
      table = Table.new("YieldNode")
      id = node_id(node)

      # keyword_loc
      table.field("keyword_loc", location_inspect(node.keyword_loc))

      # lparen_loc
      unless (lparen_loc = node.lparen_loc).nil?
        table.field("lparen_loc", location_inspect(lparen_loc))
      end

      # arguments
      unless (arguments = node.arguments).nil?
        table.field("arguments", port: true)
        digraph.edge("#{id}:arguments -> #{node_id(arguments)};")
      end

      # rparen_loc
      unless (rparen_loc = node.rparen_loc).nil?
        table.field("rparen_loc", location_inspect(rparen_loc))
      end

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end

Private Instance Methods

arguments_node_flags_inspect(node) click to toggle source

Inspect a node that has arguments_node_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4593
def arguments_node_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "contains_forwarding" if node.contains_forwarding?
  flags << "contains_keywords" if node.contains_keywords?
  flags << "contains_keyword_splat" if node.contains_keyword_splat?
  flags << "contains_splat" if node.contains_splat?
  flags << "contains_multiple_splats" if node.contains_multiple_splats?
  flags.join(", ")
end
array_node_flags_inspect(node) click to toggle source

Inspect a node that has array_node_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4605
def array_node_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "contains_splat" if node.contains_splat?
  flags.join(", ")
end
call_node_flags_inspect(node) click to toggle source

Inspect a node that has call_node_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4613
def call_node_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "safe_navigation" if node.safe_navigation?
  flags << "variable_call" if node.variable_call?
  flags << "attribute_write" if node.attribute_write?
  flags << "ignore_visibility" if node.ignore_visibility?
  flags.join(", ")
end
encoding_flags_inspect(node) click to toggle source

Inspect a node that has encoding_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4624
def encoding_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "forced_utf8_encoding" if node.forced_utf8_encoding?
  flags << "forced_binary_encoding" if node.forced_binary_encoding?
  flags.join(", ")
end
integer_base_flags_inspect(node) click to toggle source

Inspect a node that has integer_base_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4633
def integer_base_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "binary" if node.binary?
  flags << "decimal" if node.decimal?
  flags << "octal" if node.octal?
  flags << "hexadecimal" if node.hexadecimal?
  flags.join(", ")
end
interpolated_string_node_flags_inspect(node) click to toggle source

Inspect a node that has interpolated_string_node_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4644
def interpolated_string_node_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "frozen" if node.frozen?
  flags << "mutable" if node.mutable?
  flags.join(", ")
end
keyword_hash_node_flags_inspect(node) click to toggle source

Inspect a node that has keyword_hash_node_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4653
def keyword_hash_node_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "symbol_keys" if node.symbol_keys?
  flags.join(", ")
end
location_inspect(location) click to toggle source

Inspect a location to display the start and end line and column numbers.

# File lib/prism/dot_visitor.rb, line 4587
def location_inspect(location)
  "(#{location.start_line},#{location.start_column})-(#{location.end_line},#{location.end_column})"
end
loop_flags_inspect(node) click to toggle source

Inspect a node that has loop_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4661
def loop_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "begin_modifier" if node.begin_modifier?
  flags.join(", ")
end
node_id(node) click to toggle source

Generate a unique node ID for a node throughout the digraph.

# File lib/prism/dot_visitor.rb, line 4582
def node_id(node)
  "Node_#{node.object_id}"
end
parameter_flags_inspect(node) click to toggle source

Inspect a node that has parameter_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4669
def parameter_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "repeated_parameter" if node.repeated_parameter?
  flags.join(", ")
end
range_flags_inspect(node) click to toggle source

Inspect a node that has range_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4677
def range_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "exclude_end" if node.exclude_end?
  flags.join(", ")
end
regular_expression_flags_inspect(node) click to toggle source

Inspect a node that has regular_expression_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4685
def regular_expression_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "ignore_case" if node.ignore_case?
  flags << "extended" if node.extended?
  flags << "multi_line" if node.multi_line?
  flags << "once" if node.once?
  flags << "euc_jp" if node.euc_jp?
  flags << "ascii_8bit" if node.ascii_8bit?
  flags << "windows_31j" if node.windows_31j?
  flags << "utf_8" if node.utf_8?
  flags << "forced_utf8_encoding" if node.forced_utf8_encoding?
  flags << "forced_binary_encoding" if node.forced_binary_encoding?
  flags << "forced_us_ascii_encoding" if node.forced_us_ascii_encoding?
  flags.join(", ")
end
shareable_constant_node_flags_inspect(node) click to toggle source

Inspect a node that has shareable_constant_node_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4703
def shareable_constant_node_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "literal" if node.literal?
  flags << "experimental_everything" if node.experimental_everything?
  flags << "experimental_copy" if node.experimental_copy?
  flags.join(", ")
end
string_flags_inspect(node) click to toggle source

Inspect a node that has string_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4713
def string_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "forced_utf8_encoding" if node.forced_utf8_encoding?
  flags << "forced_binary_encoding" if node.forced_binary_encoding?
  flags << "frozen" if node.frozen?
  flags << "mutable" if node.mutable?
  flags.join(", ")
end
symbol_flags_inspect(node) click to toggle source

Inspect a node that has symbol_flags flags to display the flags as a comma-separated list.

# File lib/prism/dot_visitor.rb, line 4724
def symbol_flags_inspect(node)
  flags = [] #: Array[String]
  flags << "forced_utf8_encoding" if node.forced_utf8_encoding?
  flags << "forced_binary_encoding" if node.forced_binary_encoding?
  flags << "forced_us_ascii_encoding" if node.forced_us_ascii_encoding?
  flags.join(", ")
end