Prism nodes which share the same node.location

result.rb

$ ruby same_location_nodes.rb
Prism::ProgramNode -> Prism::StatementsNode
x do
  it
end

-> { it }

Prism::LambdaNode -> Prism::ItParametersNode
-> { it }

Prism::BlockNode -> Prism::ItParametersNode
do
  it
end

Prism::ParametersNode -> Prism::OptionalParameterNode
bar = bar

Prism::ParametersNode -> Prism::OptionalKeywordParameterNode
bar: bar

Prism::ParametersNode -> Prism::RequiredParameterNode
x

Prism::DefNode -> Prism::BeginNode
def f(*); rescue => a[*]; end

Prism::KeywordHashNode -> Prism::AssocNode
a: [:b, :c]

Prism::KeywordHashNode -> Prism::AssocSplatNode
**{}

Prism::ParametersNode -> Prism::RestParameterNode
*

Prism::BlockNode -> Prism::BeginNode
do
rescue
end

Prism::BlockNode -> Prism::NumberedParametersNode
do
  case 1
  in ^_1
  end
end

Prism::AssocNode -> Prism::SymbolNode
message:

Prism::AssocNode -> Prism::ImplicitNode
message:

Prism::ImplicitNode -> Prism::CallNode
message:

Prism::ClassNode -> Prism::BeginNode
class A; ensure; end

Prism::SingletonClassNode -> Prism::BeginNode
class << self; ensure; end

Prism::ImplicitNode -> Prism::LocalVariableReadNode
a:

Prism::ImplicitNode -> Prism::ConstantReadNode
D:

Prism::BlockParametersNode -> Prism::ParametersNode
foo = bar

Prism::ParametersNode -> Prism::RequiredKeywordParameterNode
a:

Prism::ParametersNode -> Prism::MultiTargetNode
(bar, baz)

Prism::ParametersNode -> Prism::ForwardingParameterNode
...

Prism::ParametersNode -> Prism::KeywordRestParameterNode
**b

Prism::ParametersNode -> Prism::BlockParameterNode
&b

Prism::ModuleNode -> Prism::BeginNode
module A
 x = 1; rescue; end

Prism::ArrayPatternNode -> Prism::SplatNode
*bar

Prism::ImplicitNode -> Prism::LocalVariableTargetNode
x

Prism::MatchWriteNode -> Prism::CallNode
/(?<a\
b>)/ =~ ""

Prism::ParametersNode -> Prism::NoKeywordsParameterNode
**nil

Prism::HashPatternNode -> Prism::AssocNode
"b":

Prism::HashPatternNode -> Prism::NoKeywordsParameterNode
**nil

Prism::HashPatternNode -> Prism::AssocSplatNode
**rest

Prism::InterpolatedStringNode -> Prism::EmbeddedStatementsNode
#{<<A}

Prism::InterpolatedSymbolNode -> Prism::EmbeddedStatementsNode
#{a}

Prism::InterpolatedSymbolNode -> Prism::StringNode
n\

Prism::LambdaNode -> Prism::NumberedParametersNode
-> {
  _1 + _2
}

Prism::ArrayNode -> Prism::SplatNode
*bar

{Prism::StatementsNode => :*,
 Prism::ArgumentsNode => :*,
 Prism::ProgramNode => Set[Prism::StatementsNode],
 Prism::LambdaNode => Set[Prism::ItParametersNode, Prism::NumberedParametersNode],
 Prism::BlockNode => Set[Prism::ItParametersNode, Prism::BeginNode, Prism::NumberedParametersNode],
 Prism::ParametersNode =>
  Set[Prism::OptionalParameterNode,
   Prism::OptionalKeywordParameterNode,
   Prism::RequiredParameterNode,
   Prism::RestParameterNode,
   Prism::RequiredKeywordParameterNode,
   Prism::MultiTargetNode,
   Prism::ForwardingParameterNode,
   Prism::KeywordRestParameterNode,
   Prism::BlockParameterNode,
   Prism::NoKeywordsParameterNode],
 Prism::DefNode => Set[Prism::BeginNode],
 Prism::KeywordHashNode => Set[Prism::AssocNode, Prism::AssocSplatNode],
 Prism::AssocNode => Set[Prism::SymbolNode, Prism::ImplicitNode],
 Prism::ImplicitNode =>
  Set[Prism::CallNode, Prism::LocalVariableReadNode, Prism::ConstantReadNode, Prism::LocalVariableTargetNode],
 Prism::ClassNode => Set[Prism::BeginNode],
 Prism::SingletonClassNode => Set[Prism::BeginNode],
 Prism::BlockParametersNode => Set[Prism::ParametersNode],
 Prism::ModuleNode => Set[Prism::BeginNode],
 Prism::ArrayPatternNode => Set[Prism::SplatNode],
 Prism::MatchWriteNode => Set[Prism::CallNode],
 Prism::HashPatternNode => Set[Prism::AssocNode, Prism::NoKeywordsParameterNode, Prism::AssocSplatNode],
 Prism::InterpolatedStringNode => Set[Prism::EmbeddedStatementsNode],
 Prism::InterpolatedSymbolNode => Set[Prism::EmbeddedStatementsNode, Prism::StringNode],
 Prism::ArrayNode => Set[Prism::SplatNode]}

same_location_nodes.rb

require 'prism'

same_loc_nodes = Hash.new { |h, k| h[k] = Set.new }
same_loc_nodes[Prism::StatementsNode] = :*
same_loc_nodes[Prism::ArgumentsNode] = :*

Dir['test/prism/fixtures/**/*.txt'].each do |path|
  # p path
  result = Prism.parse_file(path)
  next unless result.success?
  result.value.breadth_first_search { |parent|
    parent.compact_child_nodes.each { |child|
      if parent.location == child.location
        set = same_loc_nodes[parent.class]
        unless set == :* or set.include? child.class
          puts "#{parent.class} -> #{child.class}", parent.slice, nil
          set << child.class
        end
      end
    }
    false
  }
end

pp same_loc_nodes