prism 0.19.0 → 0.20.0

data/sig/prism.rbs

@@ -12,19 +12,19 @@ module Prism
     attr_reader old_name: Node
     attr_reader keyword_loc: Location
 
-    def initialize: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node new_name, Node old_name, Location keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> AliasGlobalVariableNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { new_name: Node, old_name: Node, keyword_loc: Location, location: Location }
 
     def keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `alias` keyword to alias a method.
   #
@@ -35,19 +35,19 @@ module Prism
     attr_reader old_name: Node
     attr_reader keyword_loc: Location
 
-    def initialize: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node new_name, Node old_name, Location keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> AliasMethodNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { new_name: Node, old_name: Node, keyword_loc: Location, location: Location }
 
     def keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an alternation pattern in pattern matching.
   #
@@ -58,19 +58,19 @@ module Prism
     attr_reader right: Node
     attr_reader operator_loc: Location
 
-    def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node left, Node right, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> AlternationPatternNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { left: Node, right: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `&&` operator or the `and` keyword.
   #
@@ -81,62 +81,61 @@ module Prism
     attr_reader right: Node
     attr_reader operator_loc: Location
 
-    def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node left, Node right, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> AndNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { left: Node, right: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a set of arguments to a method or a keyword.
   #
   #     return foo, bar, baz
   #            ^^^^^^^^^^^^^
   class ArgumentsNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader arguments: Array[Node]
 
-    def initialize: (flags: Integer, arguments: Array[Node], location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Array[Node] arguments, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ArgumentsNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, arguments: Array[Node], location: Location }
 
     def contains_keyword_splat?: () -> bool
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents an array literal. This can be a regular array using brackets or
-  # a special array using % like %w or %i.
+  # Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
   #
   #     [1, 2, 3]
   #     ^^^^^^^^^
   class ArrayNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader elements: Array[Node]
     attr_reader opening_loc: Location?
     attr_reader closing_loc: Location?
 
-    def initialize: (flags: Integer, elements: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Array[Node] elements, Location? opening_loc, Location? closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ArrayNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, elements: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location }
 
     def contains_splat?: () -> bool
 
@@ -144,7 +143,7 @@ module Prism
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an array pattern in pattern matching.
   #
@@ -170,21 +169,21 @@ module Prism
     attr_reader opening_loc: Location?
     attr_reader closing_loc: Location?
 
-    def initialize: (constant: Node?, requireds: Array[Node], rest: Node?, posts: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node? constant, Array[Node] requireds, Node? rest, Array[Node] posts, Location? opening_loc, Location? closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ArrayPatternNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { constant: Node?, requireds: Array[Node], rest: Node?, posts: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location }
 
     def opening: () -> String?
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a hash key/value pair.
   #
@@ -192,22 +191,22 @@ module Prism
   #       ^^^^^^
   class AssocNode < Node
     attr_reader key: Node
-    attr_reader value: Node?
+    attr_reader value: Node
     attr_reader operator_loc: Location?
 
-    def initialize: (key: Node, value: Node?, operator_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node key, Node value, Location? operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> AssocNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { key: Node, value: Node, operator_loc: Location?, location: Location }
 
     def operator: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a splat in a hash literal.
   #
@@ -217,19 +216,19 @@ module Prism
     attr_reader value: Node?
     attr_reader operator_loc: Location
 
-    def initialize: (value: Node?, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node? value, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> AssocSplatNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Node?, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents reading a reference to a field in the previous match.
   #
@@ -238,17 +237,17 @@ module Prism
   class BackReferenceReadNode < Node
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> BackReferenceReadNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a begin statement.
   #
@@ -264,21 +263,21 @@ module Prism
     attr_reader ensure_clause: EnsureNode?
     attr_reader end_keyword_loc: Location?
 
-    def initialize: (begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location? begin_keyword_loc, StatementsNode? statements, RescueNode? rescue_clause, ElseNode? else_clause, EnsureNode? ensure_clause, Location? end_keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> BeginNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location }
 
     def begin_keyword: () -> String?
 
     def end_keyword: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents block method arguments.
   #
@@ -288,66 +287,68 @@ module Prism
     attr_reader expression: Node?
     attr_reader operator_loc: Location
 
-    def initialize: (expression: Node?, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node? expression, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> BlockArgumentNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { expression: Node?, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a block local variable.
   #
   #     a { |; b| }
   #            ^
   class BlockLocalVariableNode < Node
+    private attr_reader flags: Integer
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> BlockLocalVariableNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, location: Location }
+
+    def repeated_parameter?: () -> bool
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a block of ruby code.
   #
-  # [1, 2, 3].each { |i| puts x }
-  #                ^^^^^^^^^^^^^^
+  #     [1, 2, 3].each { |i| puts x }
+  #                    ^^^^^^^^^^^^^^
   class BlockNode < Node
     attr_reader locals: Array[Symbol]
-    attr_reader locals_body_index: Integer
     attr_reader parameters: Node?
     attr_reader body: Node?
     attr_reader opening_loc: Location
     attr_reader closing_loc: Location
 
-    def initialize: (locals: Array[Symbol], locals_body_index: Integer, parameters: Node?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Symbol] locals, Node? parameters, Node? body, Location opening_loc, Location closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> BlockNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], parameters: Node?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location }
 
     def opening: () -> String
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a block parameter to a method, block, or lambda definition.
   #
@@ -355,23 +356,26 @@ module Prism
   #           ^^
   #     end
   class BlockParameterNode < Node
+    private attr_reader flags: Integer
     attr_reader name: Symbol?
     attr_reader name_loc: Location?
     attr_reader operator_loc: Location
 
-    def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> BlockParameterNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
+
+    def repeated_parameter?: () -> bool
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a block's parameters declaration.
   #
@@ -387,21 +391,21 @@ module Prism
     attr_reader opening_loc: Location?
     attr_reader closing_loc: Location?
 
-    def initialize: (parameters: ParametersNode?, locals: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (ParametersNode? parameters, Array[Node] locals, Location? opening_loc, Location? closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> BlockParametersNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { parameters: ParametersNode?, locals: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location }
 
     def opening: () -> String?
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `break` keyword.
   #
@@ -411,26 +415,26 @@ module Prism
     attr_reader arguments: ArgumentsNode?
     attr_reader keyword_loc: Location
 
-    def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (ArgumentsNode? arguments, Location keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> BreakNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { arguments: ArgumentsNode?, keyword_loc: Location, location: Location }
 
     def keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `&&=` operator on a call.
   #
   #     foo.bar &&= value
   #     ^^^^^^^^^^^^^^^^^
   class CallAndWriteNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader receiver: Node?
     attr_reader call_operator_loc: Location?
     attr_reader message_loc: Location?
@@ -439,15 +443,15 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> CallAndWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location }
 
     def safe_navigation?: () -> bool
 
@@ -455,13 +459,15 @@ module Prism
 
     def attribute_write?: () -> bool
 
+    def ignore_visibility?: () -> bool
+
     def call_operator: () -> String?
 
     def message: () -> String?
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a method call, in all of the various forms that can take.
   #
@@ -483,7 +489,7 @@ module Prism
   #     foo&.bar
   #     ^^^^^^^^
   class CallNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader receiver: Node?
     attr_reader call_operator_loc: Location?
     attr_reader name: Symbol
@@ -493,15 +499,15 @@ module Prism
     attr_reader closing_loc: Location?
     attr_reader block: Node?
 
-    def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Symbol name, Location? message_loc, Location? opening_loc, ArgumentsNode? arguments, Location? closing_loc, Node? block, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> CallNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, location: Location }
 
     def safe_navigation?: () -> bool
 
@@ -509,6 +515,8 @@ module Prism
 
     def attribute_write?: () -> bool
 
+    def ignore_visibility?: () -> bool
+
     def call_operator: () -> String?
 
     def message: () -> String?
@@ -517,14 +525,14 @@ module Prism
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of an assignment operator on a call.
   #
   #     foo.bar += baz
   #     ^^^^^^^^^^^^^^
   class CallOperatorWriteNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader receiver: Node?
     attr_reader call_operator_loc: Location?
     attr_reader message_loc: Location?
@@ -534,15 +542,15 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Symbol operator, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> CallOperatorWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location }
 
     def safe_navigation?: () -> bool
 
@@ -550,18 +558,20 @@ module Prism
 
     def attribute_write?: () -> bool
 
+    def ignore_visibility?: () -> bool
+
     def call_operator: () -> String?
 
     def message: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `||=` operator on a call.
   #
   #     foo.bar ||= value
   #     ^^^^^^^^^^^^^^^^^
   class CallOrWriteNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader receiver: Node?
     attr_reader call_operator_loc: Location?
     attr_reader message_loc: Location?
@@ -570,15 +580,15 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> CallOrWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location }
 
     def safe_navigation?: () -> bool
 
@@ -586,13 +596,15 @@ module Prism
 
     def attribute_write?: () -> bool
 
+    def ignore_visibility?: () -> bool
+
     def call_operator: () -> String?
 
     def message: () -> String?
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents assigning to a method call.
   #
@@ -607,21 +619,21 @@ module Prism
   #     for foo.bar in baz do end
   #         ^^^^^^^
   class CallTargetNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader receiver: Node
     attr_reader call_operator_loc: Location
     attr_reader name: Symbol
     attr_reader message_loc: Location
 
-    def initialize: (flags: Integer, receiver: Node, call_operator_loc: Location, name: Symbol, message_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node receiver, Location call_operator_loc, Symbol name, Location message_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> CallTargetNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node, call_operator_loc: Location, name: Symbol, message_loc: Location, location: Location }
 
     def safe_navigation?: () -> bool
 
@@ -629,11 +641,13 @@ module Prism
 
     def attribute_write?: () -> bool
 
+    def ignore_visibility?: () -> bool
+
     def call_operator: () -> String
 
     def message: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents assigning to a local variable in pattern matching.
   #
@@ -644,19 +658,19 @@ module Prism
     attr_reader target: Node
     attr_reader operator_loc: Location
 
-    def initialize: (value: Node, target: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node value, Node target, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> CapturePatternNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Node, target: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of a case statement for pattern matching.
   #
@@ -671,21 +685,21 @@ module Prism
     attr_reader case_keyword_loc: Location
     attr_reader end_keyword_loc: Location
 
-    def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node? predicate, Array[Node] conditions, ElseNode? consequent, Location case_keyword_loc, Location end_keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> CaseMatchNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location }
 
     def case_keyword: () -> String
 
     def end_keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of a case statement.
   #
@@ -700,21 +714,21 @@ module Prism
     attr_reader case_keyword_loc: Location
     attr_reader end_keyword_loc: Location
 
-    def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node? predicate, Array[Node] conditions, ElseNode? consequent, Location case_keyword_loc, Location end_keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> CaseNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location }
 
     def case_keyword: () -> String
 
     def end_keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a class declaration involving the `class` keyword.
   #
@@ -730,15 +744,15 @@ module Prism
     attr_reader end_keyword_loc: Location
     attr_reader name: Symbol
 
-    def initialize: (locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Symbol] locals, Location class_keyword_loc, Node constant_path, Location? inheritance_operator_loc, Node? superclass, Node? body, Location end_keyword_loc, Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ClassNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location }
 
     def class_keyword: () -> String
 
@@ -746,7 +760,7 @@ module Prism
 
     def end_keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `&&=` operator for assignment to a class variable.
   #
@@ -758,19 +772,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ClassVariableAndWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents assigning to a class variable using an operator that isn't `=`.
   #
@@ -783,17 +797,17 @@ module Prism
     attr_reader value: Node
     attr_reader operator: Symbol
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Symbol operator, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ClassVariableOperatorWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `||=` operator for assignment to a class variable.
   #
@@ -805,19 +819,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ClassVariableOrWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents referencing a class variable.
   #
@@ -826,17 +840,17 @@ module Prism
   class ClassVariableReadNode < Node
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ClassVariableReadNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to a class variable in a context that doesn't have an explicit value.
   #
@@ -845,17 +859,17 @@ module Prism
   class ClassVariableTargetNode < Node
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ClassVariableTargetNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to a class variable.
   #
@@ -867,19 +881,19 @@ module Prism
     attr_reader value: Node
     attr_reader operator_loc: Location?
 
-    def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Node value, Location? operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ClassVariableWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Node, operator_loc: Location?, location: Location }
 
     def operator: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `&&=` operator for assignment to a constant.
   #
@@ -891,19 +905,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantAndWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents assigning to a constant using an operator that isn't `=`.
   #
@@ -916,17 +930,17 @@ module Prism
     attr_reader value: Node
     attr_reader operator: Symbol
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Symbol operator, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantOperatorWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `||=` operator for assignment to a constant.
   #
@@ -938,19 +952,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantOrWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `&&=` operator for assignment to a constant path.
   #
@@ -961,19 +975,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (ConstantPathNode target, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantPathAndWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents accessing a constant through a path of `::` operators.
   #
@@ -984,19 +998,19 @@ module Prism
     attr_reader child: Node
     attr_reader delimiter_loc: Location
 
-    def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node? parent, Node child, Location delimiter_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantPathNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { parent: Node?, child: Node, delimiter_loc: Location, location: Location }
 
     def delimiter: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents assigning to a constant path using an operator that isn't `=`.
   #
@@ -1008,17 +1022,17 @@ module Prism
     attr_reader value: Node
     attr_reader operator: Symbol
 
-    def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (ConstantPathNode target, Location operator_loc, Node value, Symbol operator, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantPathOperatorWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `||=` operator for assignment to a constant path.
   #
@@ -1029,19 +1043,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (ConstantPathNode target, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantPathOrWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to a constant path in a context that doesn't have an explicit value.
   #
@@ -1052,19 +1066,19 @@ module Prism
     attr_reader child: Node
     attr_reader delimiter_loc: Location
 
-    def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node? parent, Node child, Location delimiter_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantPathTargetNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { parent: Node?, child: Node, delimiter_loc: Location, location: Location }
 
     def delimiter: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to a constant path.
   #
@@ -1081,19 +1095,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (ConstantPathNode target, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantPathWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents referencing a constant.
   #
@@ -1102,17 +1116,17 @@ module Prism
   class ConstantReadNode < Node
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantReadNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to a constant in a context that doesn't have an explicit value.
   #
@@ -1121,17 +1135,17 @@ module Prism
   class ConstantTargetNode < Node
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantTargetNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to a constant.
   #
@@ -1143,19 +1157,19 @@ module Prism
     attr_reader value: Node
     attr_reader operator_loc: Location
 
-    def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Node value, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ConstantWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a method definition.
   #
@@ -1169,7 +1183,6 @@ module Prism
     attr_reader parameters: ParametersNode?
     attr_reader body: Node?
     attr_reader locals: Array[Symbol]
-    attr_reader locals_body_index: Integer
     attr_reader def_keyword_loc: Location
     attr_reader operator_loc: Location?
     attr_reader lparen_loc: Location?
@@ -1177,15 +1190,15 @@ module Prism
     attr_reader equal_loc: Location?
     attr_reader end_keyword_loc: Location?
 
-    def initialize: (name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], locals_body_index: Integer, def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Node? receiver, ParametersNode? parameters, Node? body, Array[Symbol] locals, Location def_keyword_loc, Location? operator_loc, Location? lparen_loc, Location? rparen_loc, Location? equal_loc, Location? end_keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> DefNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location }
 
     def def_keyword: () -> String
 
@@ -1199,7 +1212,7 @@ module Prism
 
     def end_keyword: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `defined?` keyword.
   #
@@ -1211,15 +1224,15 @@ module Prism
     attr_reader rparen_loc: Location?
     attr_reader keyword_loc: Location
 
-    def initialize: (lparen_loc: Location?, value: Node, rparen_loc: Location?, keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location? lparen_loc, Node value, Location? rparen_loc, Location keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> DefinedNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { lparen_loc: Location?, value: Node, rparen_loc: Location?, keyword_loc: Location, location: Location }
 
     def lparen: () -> String?
 
@@ -1227,7 +1240,7 @@ module Prism
 
     def keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an `else` clause in a `case`, `if`, or `unless` statement.
   #
@@ -1238,21 +1251,21 @@ module Prism
     attr_reader statements: StatementsNode?
     attr_reader end_keyword_loc: Location?
 
-    def initialize: (else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location else_keyword_loc, StatementsNode? statements, Location? end_keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ElseNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location }
 
     def else_keyword: () -> String
 
     def end_keyword: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an interpolated set of statements.
   #
@@ -1263,21 +1276,21 @@ module Prism
     attr_reader statements: StatementsNode?
     attr_reader closing_loc: Location
 
-    def initialize: (opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location opening_loc, StatementsNode? statements, Location closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> EmbeddedStatementsNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location }
 
     def opening: () -> String
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an interpolated variable.
   #
@@ -1287,19 +1300,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader variable: Node
 
-    def initialize: (operator_loc: Location, variable: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location operator_loc, Node variable, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> EmbeddedVariableNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, variable: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an `ensure` clause in a `begin` statement.
   #
@@ -1314,21 +1327,21 @@ module Prism
     attr_reader statements: StatementsNode?
     attr_reader end_keyword_loc: Location
 
-    def initialize: (ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location ensure_keyword_loc, StatementsNode? statements, Location end_keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> EnsureNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location }
 
     def ensure_keyword: () -> String
 
     def end_keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the literal `false` keyword.
   #
@@ -1336,17 +1349,17 @@ module Prism
   #     ^^^^^
   class FalseNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> FalseNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a find pattern in pattern matching.
   #
@@ -1366,47 +1379,47 @@ module Prism
     attr_reader opening_loc: Location?
     attr_reader closing_loc: Location?
 
-    def initialize: (constant: Node?, left: Node, requireds: Array[Node], right: Node, opening_loc: Location?, closing_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node? constant, Node left, Array[Node] requireds, Node right, Location? opening_loc, Location? closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> FindPatternNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { constant: Node?, left: Node, requireds: Array[Node], right: Node, opening_loc: Location?, closing_loc: Location?, location: Location }
 
     def opening: () -> String?
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `..` or `...` operators to create flip flops.
   #
   #     baz if foo .. bar
   #            ^^^^^^^^^^
   class FlipFlopNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader left: Node?
     attr_reader right: Node?
     attr_reader operator_loc: Location
 
-    def initialize: (flags: Integer, left: Node?, right: Node?, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node? left, Node? right, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> FlipFlopNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, left: Node?, right: Node?, operator_loc: Location, location: Location }
 
     def exclude_end?: () -> bool
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a floating point number literal.
   #
@@ -1414,17 +1427,17 @@ module Prism
   #     ^^^
   class FloatNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> FloatNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `for` keyword.
   #
@@ -1439,15 +1452,15 @@ module Prism
     attr_reader do_keyword_loc: Location?
     attr_reader end_keyword_loc: Location
 
-    def initialize: (index: Node, collection: Node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node index, Node collection, StatementsNode? statements, Location for_keyword_loc, Location in_keyword_loc, Location? do_keyword_loc, Location end_keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ForNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { index: Node, collection: Node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location }
 
     def for_keyword: () -> String
 
@@ -1457,7 +1470,7 @@ module Prism
 
     def end_keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents forwarding all arguments to this method to another method.
   #
@@ -1467,17 +1480,17 @@ module Prism
   #     end
   class ForwardingArgumentsNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ForwardingArgumentsNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the forwarding parameter in a method, block, or lambda declaration.
   #
@@ -1486,17 +1499,17 @@ module Prism
   #     end
   class ForwardingParameterNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ForwardingParameterNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `super` keyword without parentheses or arguments.
   #
@@ -1505,17 +1518,17 @@ module Prism
   class ForwardingSuperNode < Node
     attr_reader block: BlockNode?
 
-    def initialize: (block: BlockNode?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (BlockNode? block, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ForwardingSuperNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { block: BlockNode?, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `&&=` operator for assignment to a global variable.
   #
@@ -1527,19 +1540,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> GlobalVariableAndWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents assigning to a global variable using an operator that isn't `=`.
   #
@@ -1552,17 +1565,17 @@ module Prism
     attr_reader value: Node
     attr_reader operator: Symbol
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Symbol operator, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> GlobalVariableOperatorWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `||=` operator for assignment to a global variable.
   #
@@ -1574,19 +1587,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> GlobalVariableOrWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents referencing a global variable.
   #
@@ -1595,17 +1608,17 @@ module Prism
   class GlobalVariableReadNode < Node
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> GlobalVariableReadNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to a global variable in a context that doesn't have an explicit value.
   #
@@ -1614,17 +1627,17 @@ module Prism
   class GlobalVariableTargetNode < Node
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> GlobalVariableTargetNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to a global variable.
   #
@@ -1636,19 +1649,19 @@ module Prism
     attr_reader value: Node
     attr_reader operator_loc: Location
 
-    def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Node value, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> GlobalVariableWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a hash literal.
   #
@@ -1659,21 +1672,21 @@ module Prism
     attr_reader elements: Array[Node]
     attr_reader closing_loc: Location
 
-    def initialize: (opening_loc: Location, elements: Array[Node], closing_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location opening_loc, Array[Node] elements, Location closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> HashNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, elements: Array[Node], closing_loc: Location, location: Location }
 
     def opening: () -> String
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a hash pattern in pattern matching.
   #
@@ -1689,21 +1702,21 @@ module Prism
     attr_reader opening_loc: Location?
     attr_reader closing_loc: Location?
 
-    def initialize: (constant: Node?, elements: Array[Node], rest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node? constant, Array[Node] elements, Node? rest, Location? opening_loc, Location? closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> HashPatternNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { constant: Node?, elements: Array[Node], rest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location }
 
     def opening: () -> String?
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `if` keyword, either in the block form or the modifier form.
   #
@@ -1720,15 +1733,15 @@ module Prism
     attr_reader consequent: Node?
     attr_reader end_keyword_loc: Location?
 
-    def initialize: (if_keyword_loc: Location?, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location? if_keyword_loc, Node predicate, Location? then_keyword_loc, StatementsNode? statements, Node? consequent, Location? end_keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> IfNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { if_keyword_loc: Location?, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location }
 
     def if_keyword: () -> String?
 
@@ -1736,7 +1749,7 @@ module Prism
 
     def end_keyword: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an imaginary number literal.
   #
@@ -1745,40 +1758,42 @@ module Prism
   class ImaginaryNode < Node
     attr_reader numeric: Node
 
-    def initialize: (numeric: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node numeric, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ImaginaryNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { numeric: Node, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents a node that is implicitly being added to the tree but doesn't
-  # correspond directly to a node in the source.
+  # Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
   #
   #     { foo: }
   #       ^^^^
   #
   #     { Foo: }
   #       ^^^^
+  #
+  #     foo in { bar: }
+  #              ^^^^
   class ImplicitNode < Node
     attr_reader value: Node
 
-    def initialize: (value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ImplicitNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Node, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents using a trailing comma to indicate an implicit rest parameter.
   #
@@ -1795,17 +1810,17 @@ module Prism
   #        ^
   class ImplicitRestNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ImplicitRestNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `in` keyword in a case statement.
   #
@@ -1817,28 +1832,28 @@ module Prism
     attr_reader in_loc: Location
     attr_reader then_loc: Location?
 
-    def initialize: (pattern: Node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node pattern, StatementsNode? statements, Location in_loc, Location? then_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { pattern: Node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location }
 
     def in: () -> String
 
     def then: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `&&=` operator on a call to the `[]` method.
   #
   #     foo.bar[baz] &&= value
   #     ^^^^^^^^^^^^^^^^^^^^^^
   class IndexAndWriteNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader receiver: Node?
     attr_reader call_operator_loc: Location?
     attr_reader opening_loc: Location
@@ -1848,15 +1863,15 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Node? block, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> IndexAndWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator_loc: Location, value: Node, location: Location }
 
     def safe_navigation?: () -> bool
 
@@ -1864,6 +1879,8 @@ module Prism
 
     def attribute_write?: () -> bool
 
+    def ignore_visibility?: () -> bool
+
     def call_operator: () -> String?
 
     def opening: () -> String
@@ -1872,14 +1889,14 @@ module Prism
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of an assignment operator on a call to `[]`.
   #
   #     foo.bar[baz] += value
   #     ^^^^^^^^^^^^^^^^^^^^^
   class IndexOperatorWriteNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader receiver: Node?
     attr_reader call_operator_loc: Location?
     attr_reader opening_loc: Location
@@ -1890,15 +1907,15 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Node? block, Symbol operator, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> IndexOperatorWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator: Symbol, operator_loc: Location, value: Node, location: Location }
 
     def safe_navigation?: () -> bool
 
@@ -1906,20 +1923,22 @@ module Prism
 
     def attribute_write?: () -> bool
 
+    def ignore_visibility?: () -> bool
+
     def call_operator: () -> String?
 
     def opening: () -> String
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `||=` operator on a call to `[]`.
   #
   #     foo.bar[baz] ||= value
   #     ^^^^^^^^^^^^^^^^^^^^^^
   class IndexOrWriteNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader receiver: Node?
     attr_reader call_operator_loc: Location?
     attr_reader opening_loc: Location
@@ -1929,15 +1948,15 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Node? block, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> IndexOrWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator_loc: Location, value: Node, location: Location }
 
     def safe_navigation?: () -> bool
 
@@ -1945,6 +1964,8 @@ module Prism
 
     def attribute_write?: () -> bool
 
+    def ignore_visibility?: () -> bool
+
     def call_operator: () -> String?
 
     def opening: () -> String
@@ -1953,7 +1974,7 @@ module Prism
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents assigning to an index.
   #
@@ -1968,22 +1989,22 @@ module Prism
   #     for foo[bar] in baz do end
   #         ^^^^^^^^
   class IndexTargetNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader receiver: Node
     attr_reader opening_loc: Location
     attr_reader arguments: ArgumentsNode?
     attr_reader closing_loc: Location
     attr_reader block: Node?
 
-    def initialize: (flags: Integer, receiver: Node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node receiver, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Node? block, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> IndexTargetNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, location: Location }
 
     def safe_navigation?: () -> bool
 
@@ -1991,11 +2012,13 @@ module Prism
 
     def attribute_write?: () -> bool
 
+    def ignore_visibility?: () -> bool
+
     def opening: () -> String
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `&&=` operator for assignment to an instance variable.
   #
@@ -2007,19 +2030,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InstanceVariableAndWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents assigning to an instance variable using an operator that isn't `=`.
   #
@@ -2032,17 +2055,17 @@ module Prism
     attr_reader value: Node
     attr_reader operator: Symbol
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Symbol operator, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InstanceVariableOperatorWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `||=` operator for assignment to an instance variable.
   #
@@ -2054,19 +2077,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InstanceVariableOrWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents referencing an instance variable.
   #
@@ -2075,17 +2098,17 @@ module Prism
   class InstanceVariableReadNode < Node
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InstanceVariableReadNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to an instance variable in a context that doesn't have an explicit value.
   #
@@ -2094,17 +2117,17 @@ module Prism
   class InstanceVariableTargetNode < Node
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InstanceVariableTargetNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to an instance variable.
   #
@@ -2116,36 +2139,36 @@ module Prism
     attr_reader value: Node
     attr_reader operator_loc: Location
 
-    def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Location name_loc, Node value, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InstanceVariableWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an integer number literal.
   #
   #     1
   #     ^
   class IntegerNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
 
-    def initialize: (flags: Integer, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> IntegerNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, location: Location }
 
     def binary?: () -> bool
 
@@ -2155,29 +2178,27 @@ module Prism
 
     def hexadecimal?: () -> bool
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents a regular expression literal that contains interpolation that
-  # is being used in the predicate of a conditional to implicitly match
-  # against the last line read by an IO object.
+  # Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
   #
   #     if /foo #{bar} baz/ then end
   #        ^^^^^^^^^^^^^^^^
   class InterpolatedMatchLastLineNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader opening_loc: Location
     attr_reader parts: Array[Node]
     attr_reader closing_loc: Location
 
-    def initialize: (flags: Integer, opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Location opening_loc, Array[Node] parts, Location closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InterpolatedMatchLastLineNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location }
 
     def ignore_case?: () -> bool
 
@@ -2205,27 +2226,27 @@ module Prism
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a regular expression literal that contains interpolation.
   #
   #     /foo #{bar} baz/
   #     ^^^^^^^^^^^^^^^^
   class InterpolatedRegularExpressionNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader opening_loc: Location
     attr_reader parts: Array[Node]
     attr_reader closing_loc: Location
 
-    def initialize: (flags: Integer, opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Location opening_loc, Array[Node] parts, Location closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InterpolatedRegularExpressionNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location }
 
     def ignore_case?: () -> bool
 
@@ -2253,7 +2274,7 @@ module Prism
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a string literal that contains interpolation.
   #
@@ -2264,21 +2285,21 @@ module Prism
     attr_reader parts: Array[Node]
     attr_reader closing_loc: Location?
 
-    def initialize: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location? opening_loc, Array[Node] parts, Location? closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InterpolatedStringNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location }
 
     def opening: () -> String?
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a symbol literal that contains interpolation.
   #
@@ -2289,21 +2310,21 @@ module Prism
     attr_reader parts: Array[Node]
     attr_reader closing_loc: Location?
 
-    def initialize: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location? opening_loc, Array[Node] parts, Location? closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InterpolatedSymbolNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location }
 
     def opening: () -> String?
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an xstring literal that contains interpolation.
   #
@@ -2314,43 +2335,43 @@ module Prism
     attr_reader parts: Array[Node]
     attr_reader closing_loc: Location
 
-    def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location opening_loc, Array[Node] parts, Location closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> InterpolatedXStringNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location }
 
     def opening: () -> String
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a hash literal without opening and closing braces.
   #
   #     foo(a: b)
   #         ^^^^
   class KeywordHashNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader elements: Array[Node]
 
-    def initialize: (flags: Integer, elements: Array[Node], location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Array[Node] elements, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> KeywordHashNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, elements: Array[Node], location: Location }
 
-    def static_keys?: () -> bool
+    def symbol_keys?: () -> bool
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a keyword rest parameter to a method, block, or lambda definition.
   #
@@ -2358,23 +2379,26 @@ module Prism
   #           ^^^
   #     end
   class KeywordRestParameterNode < Node
+    private attr_reader flags: Integer
     attr_reader name: Symbol?
     attr_reader name_loc: Location?
     attr_reader operator_loc: Location
 
-    def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> KeywordRestParameterNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
+
+    def repeated_parameter?: () -> bool
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents using a lambda literal (not the lambda method call).
   #
@@ -2382,22 +2406,21 @@ module Prism
   #     ^^^^^^^^^^^^^^^^^^^^^^^
   class LambdaNode < Node
     attr_reader locals: Array[Symbol]
-    attr_reader locals_body_index: Integer
     attr_reader operator_loc: Location
     attr_reader opening_loc: Location
     attr_reader closing_loc: Location
     attr_reader parameters: Node?
     attr_reader body: Node?
 
-    def initialize: (locals: Array[Symbol], locals_body_index: Integer, operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Node?, body: Node?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Symbol] locals, Location operator_loc, Location opening_loc, Location closing_loc, Node? parameters, Node? body, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> LambdaNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Node?, body: Node?, location: Location }
 
     def operator: () -> String
 
@@ -2405,7 +2428,7 @@ module Prism
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `&&=` operator for assignment to a local variable.
   #
@@ -2418,19 +2441,19 @@ module Prism
     attr_reader name: Symbol
     attr_reader depth: Integer
 
-    def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location name_loc, Location operator_loc, Node value, Symbol name, Integer depth, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> LocalVariableAndWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents assigning to a local variable using an operator that isn't `=`.
   #
@@ -2444,17 +2467,17 @@ module Prism
     attr_reader operator: Symbol
     attr_reader depth: Integer
 
-    def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location name_loc, Location operator_loc, Node value, Symbol name, Symbol operator, Integer depth, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> LocalVariableOperatorWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `||=` operator for assignment to a local variable.
   #
@@ -2467,23 +2490,21 @@ module Prism
     attr_reader name: Symbol
     attr_reader depth: Integer
 
-    def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location name_loc, Location operator_loc, Node value, Symbol name, Integer depth, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> LocalVariableOrWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents reading a local variable. Note that this requires that a local
-  # variable of the same name has already been written to in the same scope,
-  # otherwise it is parsed as a method call.
+  # Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
   #
   #     foo
   #     ^^^
@@ -2491,17 +2512,17 @@ module Prism
     attr_reader name: Symbol
     attr_reader depth: Integer
 
-    def initialize: (name: Symbol, depth: Integer, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Integer depth, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> LocalVariableReadNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to a local variable in a context that doesn't have an explicit value.
   #
@@ -2511,17 +2532,17 @@ module Prism
     attr_reader name: Symbol
     attr_reader depth: Integer
 
-    def initialize: (name: Symbol, depth: Integer, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Integer depth, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> LocalVariableTargetNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents writing to a local variable.
   #
@@ -2534,42 +2555,40 @@ module Prism
     attr_reader value: Node
     attr_reader operator_loc: Location
 
-    def initialize: (name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Symbol name, Integer depth, Location name_loc, Node value, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> LocalVariableWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents a regular expression literal used in the predicate of a
-  # conditional to implicitly match against the last line read by an IO
-  # object.
+  # Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
   #
   #     if /foo/i then end
   #        ^^^^^^
   class MatchLastLineNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader opening_loc: Location
     attr_reader content_loc: Location
     attr_reader closing_loc: Location
     attr_reader unescaped: String
 
-    def initialize: (flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> MatchLastLineNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
 
     def ignore_case?: () -> bool
 
@@ -2599,7 +2618,7 @@ module Prism
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the modifier `in` operator.
   #
@@ -2610,19 +2629,19 @@ module Prism
     attr_reader pattern: Node
     attr_reader operator_loc: Location
 
-    def initialize: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node value, Node pattern, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> MatchPredicateNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Node, pattern: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `=>` operator.
   #
@@ -2633,22 +2652,21 @@ module Prism
     attr_reader pattern: Node
     attr_reader operator_loc: Location
 
-    def initialize: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node value, Node pattern, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> MatchRequiredNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Node, pattern: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents writing local variables using a regular expression match with
-  # named capture groups.
+  # Represents writing local variables using a regular expression match with named capture groups.
   #
   #     /(?<foo>bar)/ =~ baz
   #     ^^^^^^^^^^^^^^^^^^^^
@@ -2656,33 +2674,32 @@ module Prism
     attr_reader call: CallNode
     attr_reader targets: Array[Node]
 
-    def initialize: (call: CallNode, targets: Array[Node], location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (CallNode call, Array[Node] targets, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> MatchWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { call: CallNode, targets: Array[Node], location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents a node that is missing from the source and results in a syntax
-  # error.
+  # Represents a node that is missing from the source and results in a syntax error.
   class MissingNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> MissingNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a module declaration involving the `module` keyword.
   #
@@ -2696,21 +2713,21 @@ module Prism
     attr_reader end_keyword_loc: Location
     attr_reader name: Symbol
 
-    def initialize: (locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Symbol] locals, Location module_keyword_loc, Node constant_path, Node? body, Location end_keyword_loc, Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ModuleNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location }
 
     def module_keyword: () -> String
 
     def end_keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a multi-target expression.
   #
@@ -2723,21 +2740,21 @@ module Prism
     attr_reader lparen_loc: Location?
     attr_reader rparen_loc: Location?
 
-    def initialize: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Node] lefts, Node? rest, Array[Node] rights, Location? lparen_loc, Location? rparen_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> MultiTargetNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location }
 
     def lparen: () -> String?
 
     def rparen: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a write to a multi-target expression.
   #
@@ -2752,15 +2769,15 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Node] lefts, Node? rest, Array[Node] rights, Location? lparen_loc, Location? rparen_loc, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> MultiWriteNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location }
 
     def lparen: () -> String?
 
@@ -2768,7 +2785,7 @@ module Prism
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `next` keyword.
   #
@@ -2778,19 +2795,19 @@ module Prism
     attr_reader arguments: ArgumentsNode?
     attr_reader keyword_loc: Location
 
-    def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (ArgumentsNode? arguments, Location keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> NextNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { arguments: ArgumentsNode?, keyword_loc: Location, location: Location }
 
     def keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `nil` keyword.
   #
@@ -2798,17 +2815,17 @@ module Prism
   #     ^^^
   class NilNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> NilNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of `**nil` inside method arguments.
   #
@@ -2819,41 +2836,40 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader keyword_loc: Location
 
-    def initialize: (operator_loc: Location, keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location operator_loc, Location keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> NoKeywordsParameterNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, keyword_loc: Location, location: Location }
 
     def operator: () -> String
 
     def keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents an implicit set of parameters through the use of numbered
-  # parameters within a block or lambda.
+  # Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
   #
   #     -> { _1 + _2 }
   #     ^^^^^^^^^^^^^^
   class NumberedParametersNode < Node
     attr_reader maximum: Integer
 
-    def initialize: (maximum: Integer, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer maximum, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> NumberedParametersNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { maximum: Integer, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents reading a numbered reference to a capture in the previous match.
   #
@@ -2862,17 +2878,17 @@ module Prism
   class NumberedReferenceReadNode < Node
     attr_reader number: Integer
 
-    def initialize: (number: Integer, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer number, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> NumberedReferenceReadNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { number: Integer, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an optional keyword parameter to a method, block, or lambda definition.
   #
@@ -2880,21 +2896,24 @@ module Prism
   #           ^^^^
   #     end
   class OptionalKeywordParameterNode < Node
+    private attr_reader flags: Integer
     attr_reader name: Symbol
     attr_reader name_loc: Location
     attr_reader value: Node
 
-    def initialize: (name: Symbol, name_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Symbol name, Location name_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> OptionalKeywordParameterNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, value: Node, location: Location }
+
+    def repeated_parameter?: () -> bool
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an optional parameter to a method, block, or lambda definition.
   #
@@ -2902,24 +2921,27 @@ module Prism
   #           ^^^^^
   #     end
   class OptionalParameterNode < Node
+    private attr_reader flags: Integer
     attr_reader name: Symbol
     attr_reader name_loc: Location
     attr_reader operator_loc: Location
     attr_reader value: Node
 
-    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> OptionalParameterNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
+
+    def repeated_parameter?: () -> bool
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `||` operator or the `or` keyword.
   #
@@ -2930,19 +2952,19 @@ module Prism
     attr_reader right: Node
     attr_reader operator_loc: Location
 
-    def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node left, Node right, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> OrNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { left: Node, right: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the list of parameters on a method, block, or lambda definition.
   #
@@ -2958,17 +2980,17 @@ module Prism
     attr_reader keyword_rest: Node?
     attr_reader block: BlockParameterNode?
 
-    def initialize: (requireds: Array[Node], optionals: Array[Node], rest: Node?, posts: Array[Node], keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Node] requireds, Array[Node] optionals, Node? rest, Array[Node] posts, Array[Node] keywords, Node? keyword_rest, BlockParameterNode? block, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ParametersNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { requireds: Array[Node], optionals: Array[Node], rest: Node?, posts: Array[Node], keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a parenthesized expression
   #
@@ -2979,24 +3001,23 @@ module Prism
     attr_reader opening_loc: Location
     attr_reader closing_loc: Location
 
-    def initialize: (body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node? body, Location opening_loc, Location closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ParenthesesNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { body: Node?, opening_loc: Location, closing_loc: Location, location: Location }
 
     def opening: () -> String
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents the use of the `^` operator for pinning an expression in a
-  # pattern matching expression.
+  # Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
   #
   #     foo in ^(bar)
   #            ^^^^^^
@@ -3006,15 +3027,15 @@ module Prism
     attr_reader lparen_loc: Location
     attr_reader rparen_loc: Location
 
-    def initialize: (expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node expression, Location operator_loc, Location lparen_loc, Location rparen_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> PinnedExpressionNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location }
 
     def operator: () -> String
 
@@ -3022,10 +3043,9 @@ module Prism
 
     def rparen: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents the use of the `^` operator for pinning a variable in a pattern
-  # matching expression.
+  # Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
   #
   #     foo in ^bar
   #            ^^^^
@@ -3033,19 +3053,19 @@ module Prism
     attr_reader variable: Node
     attr_reader operator_loc: Location
 
-    def initialize: (variable: Node, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node variable, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> PinnedVariableNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { variable: Node, operator_loc: Location, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `END` keyword.
   #
@@ -3057,15 +3077,15 @@ module Prism
     attr_reader opening_loc: Location
     attr_reader closing_loc: Location
 
-    def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> PostExecutionNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location }
 
     def keyword: () -> String
 
@@ -3073,7 +3093,7 @@ module Prism
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `BEGIN` keyword.
   #
@@ -3085,15 +3105,15 @@ module Prism
     attr_reader opening_loc: Location
     attr_reader closing_loc: Location
 
-    def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> PreExecutionNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location }
 
     def keyword: () -> String
 
@@ -3101,24 +3121,24 @@ module Prism
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # The top level node of any parse tree.
   class ProgramNode < Node
     attr_reader locals: Array[Symbol]
     attr_reader statements: StatementsNode
 
-    def initialize: (locals: Array[Symbol], statements: StatementsNode, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Symbol] locals, StatementsNode statements, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ProgramNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], statements: StatementsNode, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `..` or `...` operators.
   #
@@ -3128,26 +3148,26 @@ module Prism
   #     c if a =~ /left/ ... b =~ /right/
   #          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   class RangeNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader left: Node?
     attr_reader right: Node?
     attr_reader operator_loc: Location
 
-    def initialize: (flags: Integer, left: Node?, right: Node?, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Node? left, Node? right, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> RangeNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, left: Node?, right: Node?, operator_loc: Location, location: Location }
 
     def exclude_end?: () -> bool
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a rational number literal.
   #
@@ -3156,17 +3176,17 @@ module Prism
   class RationalNode < Node
     attr_reader numeric: Node
 
-    def initialize: (numeric: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node numeric, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> RationalNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { numeric: Node, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `redo` keyword.
   #
@@ -3174,38 +3194,38 @@ module Prism
   #     ^^^^
   class RedoNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> RedoNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a regular expression literal with no interpolation.
   #
   #     /foo/i
   #     ^^^^^^
   class RegularExpressionNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader opening_loc: Location
     attr_reader content_loc: Location
     attr_reader closing_loc: Location
     attr_reader unescaped: String
 
-    def initialize: (flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> RegularExpressionNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
 
     def ignore_case?: () -> bool
 
@@ -3235,7 +3255,7 @@ module Prism
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a required keyword parameter to a method, block, or lambda definition.
   #
@@ -3243,20 +3263,23 @@ module Prism
   #           ^^
   #     end
   class RequiredKeywordParameterNode < Node
+    private attr_reader flags: Integer
     attr_reader name: Symbol
     attr_reader name_loc: Location
 
-    def initialize: (name: Symbol, name_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Symbol name, Location name_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> RequiredKeywordParameterNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def repeated_parameter?: () -> bool
+
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a required parameter to a method, block, or lambda definition.
   #
@@ -3264,19 +3287,22 @@ module Prism
   #           ^
   #     end
   class RequiredParameterNode < Node
+    private attr_reader flags: Integer
     attr_reader name: Symbol
 
-    def initialize: (name: Symbol, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Symbol name, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> RequiredParameterNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, location: Location }
+
+    def repeated_parameter?: () -> bool
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an expression modified with a rescue.
   #
@@ -3287,19 +3313,19 @@ module Prism
     attr_reader keyword_loc: Location
     attr_reader rescue_expression: Node
 
-    def initialize: (expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Node expression, Location keyword_loc, Node rescue_expression, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> RescueModifierNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location }
 
     def keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a rescue statement.
   #
@@ -3309,8 +3335,7 @@ module Prism
   #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   #     end
   #
-  # `Foo, *splat, Bar` are in the `exceptions` field.
-  # `ex` is in the `exception` field.
+  # `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `exception` field.
   class RescueNode < Node
     attr_reader keyword_loc: Location
     attr_reader exceptions: Array[Node]
@@ -3319,21 +3344,21 @@ module Prism
     attr_reader statements: StatementsNode?
     attr_reader consequent: RescueNode?
 
-    def initialize: (keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: StatementsNode?, consequent: RescueNode?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location keyword_loc, Array[Node] exceptions, Location? operator_loc, Node? reference, StatementsNode? statements, RescueNode? consequent, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> RescueNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: StatementsNode?, consequent: RescueNode?, location: Location }
 
     def keyword: () -> String
 
     def operator: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a rest parameter to a method, block, or lambda definition.
   #
@@ -3341,23 +3366,26 @@ module Prism
   #           ^^
   #     end
   class RestParameterNode < Node
+    private attr_reader flags: Integer
     attr_reader name: Symbol?
     attr_reader name_loc: Location?
     attr_reader operator_loc: Location
 
-    def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> RestParameterNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
+
+    def repeated_parameter?: () -> bool
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `retry` keyword.
   #
@@ -3365,17 +3393,17 @@ module Prism
   #     ^^^^^
   class RetryNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> RetryNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `return` keyword.
   #
@@ -3385,19 +3413,19 @@ module Prism
     attr_reader keyword_loc: Location
     attr_reader arguments: ArgumentsNode?
 
-    def initialize: (keyword_loc: Location, arguments: ArgumentsNode?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location keyword_loc, ArgumentsNode? arguments, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> ReturnNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, arguments: ArgumentsNode?, location: Location }
 
     def keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the `self` keyword.
   #
@@ -3405,17 +3433,17 @@ module Prism
   #     ^^^^
   class SelfNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> SelfNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a singleton class declaration involving the `class` keyword.
   #
@@ -3429,15 +3457,15 @@ module Prism
     attr_reader body: Node?
     attr_reader end_keyword_loc: Location
 
-    def initialize: (locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: Node?, end_keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Symbol] locals, Location class_keyword_loc, Location operator_loc, Node expression, Node? body, Location end_keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> SingletonClassNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: Node?, end_keyword_loc: Location, location: Location }
 
     def class_keyword: () -> String
 
@@ -3445,7 +3473,7 @@ module Prism
 
     def end_keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `__ENCODING__` keyword.
   #
@@ -3453,17 +3481,17 @@ module Prism
   #     ^^^^^^^^^^^^
   class SourceEncodingNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> SourceEncodingNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `__FILE__` keyword.
   #
@@ -3472,17 +3500,17 @@ module Prism
   class SourceFileNode < Node
     attr_reader filepath: String
 
-    def initialize: (filepath: String, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (String filepath, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> SourceFileNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { filepath: String, location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `__LINE__` keyword.
   #
@@ -3490,17 +3518,17 @@ module Prism
   #     ^^^^^^^^
   class SourceLineNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> SourceLineNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the splat operator.
   #
@@ -3510,19 +3538,19 @@ module Prism
     attr_reader operator_loc: Location
     attr_reader expression: Node?
 
-    def initialize: (operator_loc: Location, expression: Node?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location operator_loc, Node? expression, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> SplatNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, expression: Node?, location: Location }
 
     def operator: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a set of statements contained within some scope.
   #
@@ -3531,20 +3559,19 @@ module Prism
   class StatementsNode < Node
     attr_reader body: Array[Node]
 
-    def initialize: (body: Array[Node], location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Node] body, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> StatementsNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { body: Array[Node], location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
-  # Represents a string literal, a string contained within a `%w` list, or
-  # plain string content within an interpolated string.
+  # Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
   #
   #     "foo"
   #     ^^^^^
@@ -3555,21 +3582,21 @@ module Prism
   #     "foo #{bar} baz"
   #      ^^^^      ^^^^
   class StringNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader opening_loc: Location?
     attr_reader content_loc: Location
     attr_reader closing_loc: Location?
     attr_reader unescaped: String
 
-    def initialize: (flags: Integer, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Location? opening_loc, Location content_loc, Location? closing_loc, String unescaped, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> StringNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location }
 
     def forced_utf8_encoding?: () -> bool
 
@@ -3583,7 +3610,7 @@ module Prism
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `super` keyword with parentheses or arguments.
   #
@@ -3599,15 +3626,15 @@ module Prism
     attr_reader rparen_loc: Location?
     attr_reader block: Node?
 
-    def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: Node?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, Node? block, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> SuperNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: Node?, location: Location }
 
     def keyword: () -> String
 
@@ -3615,7 +3642,7 @@ module Prism
 
     def rparen: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents a symbol literal or a symbol contained within a `%i` list.
   #
@@ -3625,21 +3652,21 @@ module Prism
   #     %i[foo]
   #        ^^^
   class SymbolNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader opening_loc: Location?
     attr_reader value_loc: Location?
     attr_reader closing_loc: Location?
     attr_reader unescaped: String
 
-    def initialize: (flags: Integer, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Location? opening_loc, Location? value_loc, Location? closing_loc, String unescaped, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> SymbolNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location }
 
     def forced_utf8_encoding?: () -> bool
 
@@ -3653,7 +3680,7 @@ module Prism
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the literal `true` keyword.
   #
@@ -3661,17 +3688,17 @@ module Prism
   #     ^^^^
   class TrueNode < Node
 
-    def initialize: (location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> TrueNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `undef` keyword.
   #
@@ -3681,19 +3708,19 @@ module Prism
     attr_reader names: Array[Node]
     attr_reader keyword_loc: Location
 
-    def initialize: (names: Array[Node], keyword_loc: Location, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Array[Node] names, Location keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> UndefNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { names: Array[Node], keyword_loc: Location, location: Location }
 
     def keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `unless` keyword, either in the block form or the modifier form.
   #
@@ -3710,15 +3737,15 @@ module Prism
     attr_reader consequent: ElseNode?
     attr_reader end_keyword_loc: Location?
 
-    def initialize: (keyword_loc: Location, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location keyword_loc, Node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode? consequent, Location? end_keyword_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> UnlessNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location }
 
     def keyword: () -> String
 
@@ -3726,7 +3753,7 @@ module Prism
 
     def end_keyword: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `until` keyword, either in the block form or the modifier form.
   #
@@ -3736,21 +3763,21 @@ module Prism
   #     until foo do bar end
   #     ^^^^^^^^^^^^^^^^^^^^
   class UntilNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader keyword_loc: Location
     attr_reader closing_loc: Location?
     attr_reader predicate: Node
     attr_reader statements: StatementsNode?
 
-    def initialize: (flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Location keyword_loc, Location? closing_loc, Node predicate, StatementsNode? statements, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> UntilNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, location: Location }
 
     def begin_modifier?: () -> bool
 
@@ -3758,7 +3785,7 @@ module Prism
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `when` keyword within a case statement.
   #
@@ -3771,19 +3798,19 @@ module Prism
     attr_reader conditions: Array[Node]
     attr_reader statements: StatementsNode?
 
-    def initialize: (keyword_loc: Location, conditions: Array[Node], statements: StatementsNode?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location keyword_loc, Array[Node] conditions, StatementsNode? statements, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> WhenNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, conditions: Array[Node], statements: StatementsNode?, location: Location }
 
     def keyword: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `while` keyword, either in the block form or the modifier form.
   #
@@ -3793,21 +3820,21 @@ module Prism
   #     while foo do bar end
   #     ^^^^^^^^^^^^^^^^^^^^
   class WhileNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader keyword_loc: Location
     attr_reader closing_loc: Location?
     attr_reader predicate: Node
     attr_reader statements: StatementsNode?
 
-    def initialize: (flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Location keyword_loc, Location? closing_loc, Node predicate, StatementsNode? statements, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> WhileNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, location: Location }
 
     def begin_modifier?: () -> bool
 
@@ -3815,28 +3842,28 @@ module Prism
 
     def closing: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents an xstring literal with no interpolation.
   #
   #     `foo`
   #     ^^^^^
   class XStringNode < Node
-    attr_reader flags: Integer
+    private attr_reader flags: Integer
     attr_reader opening_loc: Location
     attr_reader content_loc: Location
     attr_reader closing_loc: Location
     attr_reader unescaped: String
 
-    def initialize: (flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> XStringNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
 
     def forced_utf8_encoding?: () -> bool
 
@@ -3848,7 +3875,7 @@ module Prism
 
     def closing: () -> String
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
   # Represents the use of the `yield` keyword.
   #
@@ -3860,15 +3887,15 @@ module Prism
     attr_reader arguments: ArgumentsNode?
     attr_reader rparen_loc: Location?
 
-    def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location) -> void
-    def accept: (visitor: Visitor) -> void
-    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def initialize: (Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, Location location) -> void
+    def accept: (Visitor visitor) -> void
+    def set_newline_flag: (Array[bool] newline_marked) -> void
     def child_nodes: () -> Array[Node?]
     def deconstruct: () -> Array[Node?]
 
     def copy: (**untyped) -> YieldNode
 
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location }
 
     def keyword: () -> String
 
@@ -3876,7 +3903,7 @@ module Prism
 
     def rparen: () -> String?
 
-    def inspect: (inspector: NodeInspector) -> String
+    def inspect: (?NodeInspector inspector) -> String
   end
 
   # Flags for arguments nodes.
@@ -3899,6 +3926,8 @@ module Prism
     VARIABLE_CALL: Integer
     # a call that is an attribute write, so the value being written should be returned
     ATTRIBUTE_WRITE: Integer
+    # a call that ignores method visibility
+    IGNORE_VISIBILITY: Integer
   end
 
   # Flags for nodes that have unescaped content.
@@ -3923,8 +3952,8 @@ module Prism
 
   # Flags for keyword hash nodes.
   module KeywordHashNodeFlags
-    # a keyword hash which only has `AssocNode` elements all with static literal keys, which means the elements can be treated as keyword arguments
-    STATIC_KEYS: Integer
+    # a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments
+    SYMBOL_KEYS: Integer
   end
 
   # Flags for while and until loop nodes.
@@ -3933,6 +3962,12 @@ module Prism
     BEGIN_MODIFIER: Integer
   end
 
+  # Flags for parameter nodes.
+  module ParameterFlags
+    # a parameter name that has been repeated in the method signature
+    REPEATED_PARAMETER: Integer
+  end
+
   # Flags for range and flip-flop nodes.
   module RangeFlags
     # ... operator
@@ -3988,455 +4023,455 @@ module Prism
 
   class Visitor < BasicVisitor
     # Visit a AliasGlobalVariableNode node
-    def visit_alias_global_variable_node: (node: AliasGlobalVariableNode) -> void
+    def visit_alias_global_variable_node: (AliasGlobalVariableNode node) -> void
     
     # Visit a AliasMethodNode node
-    def visit_alias_method_node: (node: AliasMethodNode) -> void
+    def visit_alias_method_node: (AliasMethodNode node) -> void
     
     # Visit a AlternationPatternNode node
-    def visit_alternation_pattern_node: (node: AlternationPatternNode) -> void
+    def visit_alternation_pattern_node: (AlternationPatternNode node) -> void
     
     # Visit a AndNode node
-    def visit_and_node: (node: AndNode) -> void
+    def visit_and_node: (AndNode node) -> void
     
     # Visit a ArgumentsNode node
-    def visit_arguments_node: (node: ArgumentsNode) -> void
+    def visit_arguments_node: (ArgumentsNode node) -> void
     
     # Visit a ArrayNode node
-    def visit_array_node: (node: ArrayNode) -> void
+    def visit_array_node: (ArrayNode node) -> void
     
     # Visit a ArrayPatternNode node
-    def visit_array_pattern_node: (node: ArrayPatternNode) -> void
+    def visit_array_pattern_node: (ArrayPatternNode node) -> void
     
     # Visit a AssocNode node
-    def visit_assoc_node: (node: AssocNode) -> void
+    def visit_assoc_node: (AssocNode node) -> void
     
     # Visit a AssocSplatNode node
-    def visit_assoc_splat_node: (node: AssocSplatNode) -> void
+    def visit_assoc_splat_node: (AssocSplatNode node) -> void
     
     # Visit a BackReferenceReadNode node
-    def visit_back_reference_read_node: (node: BackReferenceReadNode) -> void
+    def visit_back_reference_read_node: (BackReferenceReadNode node) -> void
     
     # Visit a BeginNode node
-    def visit_begin_node: (node: BeginNode) -> void
+    def visit_begin_node: (BeginNode node) -> void
     
     # Visit a BlockArgumentNode node
-    def visit_block_argument_node: (node: BlockArgumentNode) -> void
+    def visit_block_argument_node: (BlockArgumentNode node) -> void
     
     # Visit a BlockLocalVariableNode node
-    def visit_block_local_variable_node: (node: BlockLocalVariableNode) -> void
+    def visit_block_local_variable_node: (BlockLocalVariableNode node) -> void
     
     # Visit a BlockNode node
-    def visit_block_node: (node: BlockNode) -> void
+    def visit_block_node: (BlockNode node) -> void
     
     # Visit a BlockParameterNode node
-    def visit_block_parameter_node: (node: BlockParameterNode) -> void
+    def visit_block_parameter_node: (BlockParameterNode node) -> void
     
     # Visit a BlockParametersNode node
-    def visit_block_parameters_node: (node: BlockParametersNode) -> void
+    def visit_block_parameters_node: (BlockParametersNode node) -> void
     
     # Visit a BreakNode node
-    def visit_break_node: (node: BreakNode) -> void
+    def visit_break_node: (BreakNode node) -> void
     
     # Visit a CallAndWriteNode node
-    def visit_call_and_write_node: (node: CallAndWriteNode) -> void
+    def visit_call_and_write_node: (CallAndWriteNode node) -> void
     
     # Visit a CallNode node
-    def visit_call_node: (node: CallNode) -> void
+    def visit_call_node: (CallNode node) -> void
     
     # Visit a CallOperatorWriteNode node
-    def visit_call_operator_write_node: (node: CallOperatorWriteNode) -> void
+    def visit_call_operator_write_node: (CallOperatorWriteNode node) -> void
     
     # Visit a CallOrWriteNode node
-    def visit_call_or_write_node: (node: CallOrWriteNode) -> void
+    def visit_call_or_write_node: (CallOrWriteNode node) -> void
     
     # Visit a CallTargetNode node
-    def visit_call_target_node: (node: CallTargetNode) -> void
+    def visit_call_target_node: (CallTargetNode node) -> void
     
     # Visit a CapturePatternNode node
-    def visit_capture_pattern_node: (node: CapturePatternNode) -> void
+    def visit_capture_pattern_node: (CapturePatternNode node) -> void
     
     # Visit a CaseMatchNode node
-    def visit_case_match_node: (node: CaseMatchNode) -> void
+    def visit_case_match_node: (CaseMatchNode node) -> void
     
     # Visit a CaseNode node
-    def visit_case_node: (node: CaseNode) -> void
+    def visit_case_node: (CaseNode node) -> void
     
     # Visit a ClassNode node
-    def visit_class_node: (node: ClassNode) -> void
+    def visit_class_node: (ClassNode node) -> void
     
     # Visit a ClassVariableAndWriteNode node
-    def visit_class_variable_and_write_node: (node: ClassVariableAndWriteNode) -> void
+    def visit_class_variable_and_write_node: (ClassVariableAndWriteNode node) -> void
     
     # Visit a ClassVariableOperatorWriteNode node
-    def visit_class_variable_operator_write_node: (node: ClassVariableOperatorWriteNode) -> void
+    def visit_class_variable_operator_write_node: (ClassVariableOperatorWriteNode node) -> void
     
     # Visit a ClassVariableOrWriteNode node
-    def visit_class_variable_or_write_node: (node: ClassVariableOrWriteNode) -> void
+    def visit_class_variable_or_write_node: (ClassVariableOrWriteNode node) -> void
     
     # Visit a ClassVariableReadNode node
-    def visit_class_variable_read_node: (node: ClassVariableReadNode) -> void
+    def visit_class_variable_read_node: (ClassVariableReadNode node) -> void
     
     # Visit a ClassVariableTargetNode node
-    def visit_class_variable_target_node: (node: ClassVariableTargetNode) -> void
+    def visit_class_variable_target_node: (ClassVariableTargetNode node) -> void
     
     # Visit a ClassVariableWriteNode node
-    def visit_class_variable_write_node: (node: ClassVariableWriteNode) -> void
+    def visit_class_variable_write_node: (ClassVariableWriteNode node) -> void
     
     # Visit a ConstantAndWriteNode node
-    def visit_constant_and_write_node: (node: ConstantAndWriteNode) -> void
+    def visit_constant_and_write_node: (ConstantAndWriteNode node) -> void
     
     # Visit a ConstantOperatorWriteNode node
-    def visit_constant_operator_write_node: (node: ConstantOperatorWriteNode) -> void
+    def visit_constant_operator_write_node: (ConstantOperatorWriteNode node) -> void
     
     # Visit a ConstantOrWriteNode node
-    def visit_constant_or_write_node: (node: ConstantOrWriteNode) -> void
+    def visit_constant_or_write_node: (ConstantOrWriteNode node) -> void
     
     # Visit a ConstantPathAndWriteNode node
-    def visit_constant_path_and_write_node: (node: ConstantPathAndWriteNode) -> void
+    def visit_constant_path_and_write_node: (ConstantPathAndWriteNode node) -> void
     
     # Visit a ConstantPathNode node
-    def visit_constant_path_node: (node: ConstantPathNode) -> void
+    def visit_constant_path_node: (ConstantPathNode node) -> void
     
     # Visit a ConstantPathOperatorWriteNode node
-    def visit_constant_path_operator_write_node: (node: ConstantPathOperatorWriteNode) -> void
+    def visit_constant_path_operator_write_node: (ConstantPathOperatorWriteNode node) -> void
     
     # Visit a ConstantPathOrWriteNode node
-    def visit_constant_path_or_write_node: (node: ConstantPathOrWriteNode) -> void
+    def visit_constant_path_or_write_node: (ConstantPathOrWriteNode node) -> void
     
     # Visit a ConstantPathTargetNode node
-    def visit_constant_path_target_node: (node: ConstantPathTargetNode) -> void
+    def visit_constant_path_target_node: (ConstantPathTargetNode node) -> void
     
     # Visit a ConstantPathWriteNode node
-    def visit_constant_path_write_node: (node: ConstantPathWriteNode) -> void
+    def visit_constant_path_write_node: (ConstantPathWriteNode node) -> void
     
     # Visit a ConstantReadNode node
-    def visit_constant_read_node: (node: ConstantReadNode) -> void
+    def visit_constant_read_node: (ConstantReadNode node) -> void
     
     # Visit a ConstantTargetNode node
-    def visit_constant_target_node: (node: ConstantTargetNode) -> void
+    def visit_constant_target_node: (ConstantTargetNode node) -> void
     
     # Visit a ConstantWriteNode node
-    def visit_constant_write_node: (node: ConstantWriteNode) -> void
+    def visit_constant_write_node: (ConstantWriteNode node) -> void
     
     # Visit a DefNode node
-    def visit_def_node: (node: DefNode) -> void
+    def visit_def_node: (DefNode node) -> void
     
     # Visit a DefinedNode node
-    def visit_defined_node: (node: DefinedNode) -> void
+    def visit_defined_node: (DefinedNode node) -> void
     
     # Visit a ElseNode node
-    def visit_else_node: (node: ElseNode) -> void
+    def visit_else_node: (ElseNode node) -> void
     
     # Visit a EmbeddedStatementsNode node
-    def visit_embedded_statements_node: (node: EmbeddedStatementsNode) -> void
+    def visit_embedded_statements_node: (EmbeddedStatementsNode node) -> void
     
     # Visit a EmbeddedVariableNode node
-    def visit_embedded_variable_node: (node: EmbeddedVariableNode) -> void
+    def visit_embedded_variable_node: (EmbeddedVariableNode node) -> void
     
     # Visit a EnsureNode node
-    def visit_ensure_node: (node: EnsureNode) -> void
+    def visit_ensure_node: (EnsureNode node) -> void
     
     # Visit a FalseNode node
-    def visit_false_node: (node: FalseNode) -> void
+    def visit_false_node: (FalseNode node) -> void
     
     # Visit a FindPatternNode node
-    def visit_find_pattern_node: (node: FindPatternNode) -> void
+    def visit_find_pattern_node: (FindPatternNode node) -> void
     
     # Visit a FlipFlopNode node
-    def visit_flip_flop_node: (node: FlipFlopNode) -> void
+    def visit_flip_flop_node: (FlipFlopNode node) -> void
     
     # Visit a FloatNode node
-    def visit_float_node: (node: FloatNode) -> void
+    def visit_float_node: (FloatNode node) -> void
     
     # Visit a ForNode node
-    def visit_for_node: (node: ForNode) -> void
+    def visit_for_node: (ForNode node) -> void
     
     # Visit a ForwardingArgumentsNode node
-    def visit_forwarding_arguments_node: (node: ForwardingArgumentsNode) -> void
+    def visit_forwarding_arguments_node: (ForwardingArgumentsNode node) -> void
     
     # Visit a ForwardingParameterNode node
-    def visit_forwarding_parameter_node: (node: ForwardingParameterNode) -> void
+    def visit_forwarding_parameter_node: (ForwardingParameterNode node) -> void
     
     # Visit a ForwardingSuperNode node
-    def visit_forwarding_super_node: (node: ForwardingSuperNode) -> void
+    def visit_forwarding_super_node: (ForwardingSuperNode node) -> void
     
     # Visit a GlobalVariableAndWriteNode node
-    def visit_global_variable_and_write_node: (node: GlobalVariableAndWriteNode) -> void
+    def visit_global_variable_and_write_node: (GlobalVariableAndWriteNode node) -> void
     
     # Visit a GlobalVariableOperatorWriteNode node
-    def visit_global_variable_operator_write_node: (node: GlobalVariableOperatorWriteNode) -> void
+    def visit_global_variable_operator_write_node: (GlobalVariableOperatorWriteNode node) -> void
     
     # Visit a GlobalVariableOrWriteNode node
-    def visit_global_variable_or_write_node: (node: GlobalVariableOrWriteNode) -> void
+    def visit_global_variable_or_write_node: (GlobalVariableOrWriteNode node) -> void
     
     # Visit a GlobalVariableReadNode node
-    def visit_global_variable_read_node: (node: GlobalVariableReadNode) -> void
+    def visit_global_variable_read_node: (GlobalVariableReadNode node) -> void
     
     # Visit a GlobalVariableTargetNode node
-    def visit_global_variable_target_node: (node: GlobalVariableTargetNode) -> void
+    def visit_global_variable_target_node: (GlobalVariableTargetNode node) -> void
     
     # Visit a GlobalVariableWriteNode node
-    def visit_global_variable_write_node: (node: GlobalVariableWriteNode) -> void
+    def visit_global_variable_write_node: (GlobalVariableWriteNode node) -> void
     
     # Visit a HashNode node
-    def visit_hash_node: (node: HashNode) -> void
+    def visit_hash_node: (HashNode node) -> void
     
     # Visit a HashPatternNode node
-    def visit_hash_pattern_node: (node: HashPatternNode) -> void
+    def visit_hash_pattern_node: (HashPatternNode node) -> void
     
     # Visit a IfNode node
-    def visit_if_node: (node: IfNode) -> void
+    def visit_if_node: (IfNode node) -> void
     
     # Visit a ImaginaryNode node
-    def visit_imaginary_node: (node: ImaginaryNode) -> void
+    def visit_imaginary_node: (ImaginaryNode node) -> void
     
     # Visit a ImplicitNode node
-    def visit_implicit_node: (node: ImplicitNode) -> void
+    def visit_implicit_node: (ImplicitNode node) -> void
     
     # Visit a ImplicitRestNode node
-    def visit_implicit_rest_node: (node: ImplicitRestNode) -> void
+    def visit_implicit_rest_node: (ImplicitRestNode node) -> void
     
     # Visit a InNode node
-    def visit_in_node: (node: InNode) -> void
+    def visit_in_node: (InNode node) -> void
     
     # Visit a IndexAndWriteNode node
-    def visit_index_and_write_node: (node: IndexAndWriteNode) -> void
+    def visit_index_and_write_node: (IndexAndWriteNode node) -> void
     
     # Visit a IndexOperatorWriteNode node
-    def visit_index_operator_write_node: (node: IndexOperatorWriteNode) -> void
+    def visit_index_operator_write_node: (IndexOperatorWriteNode node) -> void
     
     # Visit a IndexOrWriteNode node
-    def visit_index_or_write_node: (node: IndexOrWriteNode) -> void
+    def visit_index_or_write_node: (IndexOrWriteNode node) -> void
     
     # Visit a IndexTargetNode node
-    def visit_index_target_node: (node: IndexTargetNode) -> void
+    def visit_index_target_node: (IndexTargetNode node) -> void
     
     # Visit a InstanceVariableAndWriteNode node
-    def visit_instance_variable_and_write_node: (node: InstanceVariableAndWriteNode) -> void
+    def visit_instance_variable_and_write_node: (InstanceVariableAndWriteNode node) -> void
     
     # Visit a InstanceVariableOperatorWriteNode node
-    def visit_instance_variable_operator_write_node: (node: InstanceVariableOperatorWriteNode) -> void
+    def visit_instance_variable_operator_write_node: (InstanceVariableOperatorWriteNode node) -> void
     
     # Visit a InstanceVariableOrWriteNode node
-    def visit_instance_variable_or_write_node: (node: InstanceVariableOrWriteNode) -> void
+    def visit_instance_variable_or_write_node: (InstanceVariableOrWriteNode node) -> void
     
     # Visit a InstanceVariableReadNode node
-    def visit_instance_variable_read_node: (node: InstanceVariableReadNode) -> void
+    def visit_instance_variable_read_node: (InstanceVariableReadNode node) -> void
     
     # Visit a InstanceVariableTargetNode node
-    def visit_instance_variable_target_node: (node: InstanceVariableTargetNode) -> void
+    def visit_instance_variable_target_node: (InstanceVariableTargetNode node) -> void
     
     # Visit a InstanceVariableWriteNode node
-    def visit_instance_variable_write_node: (node: InstanceVariableWriteNode) -> void
+    def visit_instance_variable_write_node: (InstanceVariableWriteNode node) -> void
     
     # Visit a IntegerNode node
-    def visit_integer_node: (node: IntegerNode) -> void
+    def visit_integer_node: (IntegerNode node) -> void
     
     # Visit a InterpolatedMatchLastLineNode node
-    def visit_interpolated_match_last_line_node: (node: InterpolatedMatchLastLineNode) -> void
+    def visit_interpolated_match_last_line_node: (InterpolatedMatchLastLineNode node) -> void
     
     # Visit a InterpolatedRegularExpressionNode node
-    def visit_interpolated_regular_expression_node: (node: InterpolatedRegularExpressionNode) -> void
+    def visit_interpolated_regular_expression_node: (InterpolatedRegularExpressionNode node) -> void
     
     # Visit a InterpolatedStringNode node
-    def visit_interpolated_string_node: (node: InterpolatedStringNode) -> void
+    def visit_interpolated_string_node: (InterpolatedStringNode node) -> void
     
     # Visit a InterpolatedSymbolNode node
-    def visit_interpolated_symbol_node: (node: InterpolatedSymbolNode) -> void
+    def visit_interpolated_symbol_node: (InterpolatedSymbolNode node) -> void
     
     # Visit a InterpolatedXStringNode node
-    def visit_interpolated_x_string_node: (node: InterpolatedXStringNode) -> void
+    def visit_interpolated_x_string_node: (InterpolatedXStringNode node) -> void
     
     # Visit a KeywordHashNode node
-    def visit_keyword_hash_node: (node: KeywordHashNode) -> void
+    def visit_keyword_hash_node: (KeywordHashNode node) -> void
     
     # Visit a KeywordRestParameterNode node
-    def visit_keyword_rest_parameter_node: (node: KeywordRestParameterNode) -> void
+    def visit_keyword_rest_parameter_node: (KeywordRestParameterNode node) -> void
     
     # Visit a LambdaNode node
-    def visit_lambda_node: (node: LambdaNode) -> void
+    def visit_lambda_node: (LambdaNode node) -> void
     
     # Visit a LocalVariableAndWriteNode node
-    def visit_local_variable_and_write_node: (node: LocalVariableAndWriteNode) -> void
+    def visit_local_variable_and_write_node: (LocalVariableAndWriteNode node) -> void
     
     # Visit a LocalVariableOperatorWriteNode node
-    def visit_local_variable_operator_write_node: (node: LocalVariableOperatorWriteNode) -> void
+    def visit_local_variable_operator_write_node: (LocalVariableOperatorWriteNode node) -> void
     
     # Visit a LocalVariableOrWriteNode node
-    def visit_local_variable_or_write_node: (node: LocalVariableOrWriteNode) -> void
+    def visit_local_variable_or_write_node: (LocalVariableOrWriteNode node) -> void
     
     # Visit a LocalVariableReadNode node
-    def visit_local_variable_read_node: (node: LocalVariableReadNode) -> void
+    def visit_local_variable_read_node: (LocalVariableReadNode node) -> void
     
     # Visit a LocalVariableTargetNode node
-    def visit_local_variable_target_node: (node: LocalVariableTargetNode) -> void
+    def visit_local_variable_target_node: (LocalVariableTargetNode node) -> void
     
     # Visit a LocalVariableWriteNode node
-    def visit_local_variable_write_node: (node: LocalVariableWriteNode) -> void
+    def visit_local_variable_write_node: (LocalVariableWriteNode node) -> void
     
     # Visit a MatchLastLineNode node
-    def visit_match_last_line_node: (node: MatchLastLineNode) -> void
+    def visit_match_last_line_node: (MatchLastLineNode node) -> void
     
     # Visit a MatchPredicateNode node
-    def visit_match_predicate_node: (node: MatchPredicateNode) -> void
+    def visit_match_predicate_node: (MatchPredicateNode node) -> void
     
     # Visit a MatchRequiredNode node
-    def visit_match_required_node: (node: MatchRequiredNode) -> void
+    def visit_match_required_node: (MatchRequiredNode node) -> void
     
     # Visit a MatchWriteNode node
-    def visit_match_write_node: (node: MatchWriteNode) -> void
+    def visit_match_write_node: (MatchWriteNode node) -> void
     
     # Visit a MissingNode node
-    def visit_missing_node: (node: MissingNode) -> void
+    def visit_missing_node: (MissingNode node) -> void
     
     # Visit a ModuleNode node
-    def visit_module_node: (node: ModuleNode) -> void
+    def visit_module_node: (ModuleNode node) -> void
     
     # Visit a MultiTargetNode node
-    def visit_multi_target_node: (node: MultiTargetNode) -> void
+    def visit_multi_target_node: (MultiTargetNode node) -> void
     
     # Visit a MultiWriteNode node
-    def visit_multi_write_node: (node: MultiWriteNode) -> void
+    def visit_multi_write_node: (MultiWriteNode node) -> void
     
     # Visit a NextNode node
-    def visit_next_node: (node: NextNode) -> void
+    def visit_next_node: (NextNode node) -> void
     
     # Visit a NilNode node
-    def visit_nil_node: (node: NilNode) -> void
+    def visit_nil_node: (NilNode node) -> void
     
     # Visit a NoKeywordsParameterNode node
-    def visit_no_keywords_parameter_node: (node: NoKeywordsParameterNode) -> void
+    def visit_no_keywords_parameter_node: (NoKeywordsParameterNode node) -> void
     
     # Visit a NumberedParametersNode node
-    def visit_numbered_parameters_node: (node: NumberedParametersNode) -> void
+    def visit_numbered_parameters_node: (NumberedParametersNode node) -> void
     
     # Visit a NumberedReferenceReadNode node
-    def visit_numbered_reference_read_node: (node: NumberedReferenceReadNode) -> void
+    def visit_numbered_reference_read_node: (NumberedReferenceReadNode node) -> void
     
     # Visit a OptionalKeywordParameterNode node
-    def visit_optional_keyword_parameter_node: (node: OptionalKeywordParameterNode) -> void
+    def visit_optional_keyword_parameter_node: (OptionalKeywordParameterNode node) -> void
     
     # Visit a OptionalParameterNode node
-    def visit_optional_parameter_node: (node: OptionalParameterNode) -> void
+    def visit_optional_parameter_node: (OptionalParameterNode node) -> void
     
     # Visit a OrNode node
-    def visit_or_node: (node: OrNode) -> void
+    def visit_or_node: (OrNode node) -> void
     
     # Visit a ParametersNode node
-    def visit_parameters_node: (node: ParametersNode) -> void
+    def visit_parameters_node: (ParametersNode node) -> void
     
     # Visit a ParenthesesNode node
-    def visit_parentheses_node: (node: ParenthesesNode) -> void
+    def visit_parentheses_node: (ParenthesesNode node) -> void
     
     # Visit a PinnedExpressionNode node
-    def visit_pinned_expression_node: (node: PinnedExpressionNode) -> void
+    def visit_pinned_expression_node: (PinnedExpressionNode node) -> void
     
     # Visit a PinnedVariableNode node
-    def visit_pinned_variable_node: (node: PinnedVariableNode) -> void
+    def visit_pinned_variable_node: (PinnedVariableNode node) -> void
     
     # Visit a PostExecutionNode node
-    def visit_post_execution_node: (node: PostExecutionNode) -> void
+    def visit_post_execution_node: (PostExecutionNode node) -> void
     
     # Visit a PreExecutionNode node
-    def visit_pre_execution_node: (node: PreExecutionNode) -> void
+    def visit_pre_execution_node: (PreExecutionNode node) -> void
     
     # Visit a ProgramNode node
-    def visit_program_node: (node: ProgramNode) -> void
+    def visit_program_node: (ProgramNode node) -> void
     
     # Visit a RangeNode node
-    def visit_range_node: (node: RangeNode) -> void
+    def visit_range_node: (RangeNode node) -> void
     
     # Visit a RationalNode node
-    def visit_rational_node: (node: RationalNode) -> void
+    def visit_rational_node: (RationalNode node) -> void
     
     # Visit a RedoNode node
-    def visit_redo_node: (node: RedoNode) -> void
+    def visit_redo_node: (RedoNode node) -> void
     
     # Visit a RegularExpressionNode node
-    def visit_regular_expression_node: (node: RegularExpressionNode) -> void
+    def visit_regular_expression_node: (RegularExpressionNode node) -> void
     
     # Visit a RequiredKeywordParameterNode node
-    def visit_required_keyword_parameter_node: (node: RequiredKeywordParameterNode) -> void
+    def visit_required_keyword_parameter_node: (RequiredKeywordParameterNode node) -> void
     
     # Visit a RequiredParameterNode node
-    def visit_required_parameter_node: (node: RequiredParameterNode) -> void
+    def visit_required_parameter_node: (RequiredParameterNode node) -> void
     
     # Visit a RescueModifierNode node
-    def visit_rescue_modifier_node: (node: RescueModifierNode) -> void
+    def visit_rescue_modifier_node: (RescueModifierNode node) -> void
     
     # Visit a RescueNode node
-    def visit_rescue_node: (node: RescueNode) -> void
+    def visit_rescue_node: (RescueNode node) -> void
     
     # Visit a RestParameterNode node
-    def visit_rest_parameter_node: (node: RestParameterNode) -> void
+    def visit_rest_parameter_node: (RestParameterNode node) -> void
     
     # Visit a RetryNode node
-    def visit_retry_node: (node: RetryNode) -> void
+    def visit_retry_node: (RetryNode node) -> void
     
     # Visit a ReturnNode node
-    def visit_return_node: (node: ReturnNode) -> void
+    def visit_return_node: (ReturnNode node) -> void
     
     # Visit a SelfNode node
-    def visit_self_node: (node: SelfNode) -> void
+    def visit_self_node: (SelfNode node) -> void
     
     # Visit a SingletonClassNode node
-    def visit_singleton_class_node: (node: SingletonClassNode) -> void
+    def visit_singleton_class_node: (SingletonClassNode node) -> void
     
     # Visit a SourceEncodingNode node
-    def visit_source_encoding_node: (node: SourceEncodingNode) -> void
+    def visit_source_encoding_node: (SourceEncodingNode node) -> void
     
     # Visit a SourceFileNode node
-    def visit_source_file_node: (node: SourceFileNode) -> void
+    def visit_source_file_node: (SourceFileNode node) -> void
     
     # Visit a SourceLineNode node
-    def visit_source_line_node: (node: SourceLineNode) -> void
+    def visit_source_line_node: (SourceLineNode node) -> void
     
     # Visit a SplatNode node
-    def visit_splat_node: (node: SplatNode) -> void
+    def visit_splat_node: (SplatNode node) -> void
     
     # Visit a StatementsNode node
-    def visit_statements_node: (node: StatementsNode) -> void
+    def visit_statements_node: (StatementsNode node) -> void
     
     # Visit a StringNode node
-    def visit_string_node: (node: StringNode) -> void
+    def visit_string_node: (StringNode node) -> void
     
     # Visit a SuperNode node
-    def visit_super_node: (node: SuperNode) -> void
+    def visit_super_node: (SuperNode node) -> void
     
     # Visit a SymbolNode node
-    def visit_symbol_node: (node: SymbolNode) -> void
+    def visit_symbol_node: (SymbolNode node) -> void
     
     # Visit a TrueNode node
-    def visit_true_node: (node: TrueNode) -> void
+    def visit_true_node: (TrueNode node) -> void
     
     # Visit a UndefNode node
-    def visit_undef_node: (node: UndefNode) -> void
+    def visit_undef_node: (UndefNode node) -> void
     
     # Visit a UnlessNode node
-    def visit_unless_node: (node: UnlessNode) -> void
+    def visit_unless_node: (UnlessNode node) -> void
     
     # Visit a UntilNode node
-    def visit_until_node: (node: UntilNode) -> void
+    def visit_until_node: (UntilNode node) -> void
     
     # Visit a WhenNode node
-    def visit_when_node: (node: WhenNode) -> void
+    def visit_when_node: (WhenNode node) -> void
     
     # Visit a WhileNode node
-    def visit_while_node: (node: WhileNode) -> void
+    def visit_while_node: (WhileNode node) -> void
     
     # Visit a XStringNode node
-    def visit_x_string_node: (node: XStringNode) -> void
+    def visit_x_string_node: (XStringNode node) -> void
     
     # Visit a YieldNode node
-    def visit_yield_node: (node: YieldNode) -> void
+    def visit_yield_node: (YieldNode node) -> void
       end
 
   module DSL
     private
 
     # Create a new Location object
-    def Location: (source: Source?, start_offset: Integer, length: Integer) -> Location
+    def Location: (?Source? source, ?Integer start_offset, ?Integer length) -> Location
 
     # Create a new AliasGlobalVariableNode node
     def AliasGlobalVariableNode: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> AliasGlobalVariableNode
@@ -4453,7 +4488,7 @@ module Prism
     # Create a new ArrayPatternNode node
     def ArrayPatternNode: (constant: Node?, requireds: Array[Node], rest: Node?, posts: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> ArrayPatternNode
     # Create a new AssocNode node
-    def AssocNode: (key: Node, value: Node?, operator_loc: Location?, location: Location) -> AssocNode
+    def AssocNode: (key: Node, value: Node, operator_loc: Location?, location: Location) -> AssocNode
     # Create a new AssocSplatNode node
     def AssocSplatNode: (value: Node?, operator_loc: Location, location: Location) -> AssocSplatNode
     # Create a new BackReferenceReadNode node
@@ -4463,11 +4498,11 @@ module Prism
     # Create a new BlockArgumentNode node
     def BlockArgumentNode: (expression: Node?, operator_loc: Location, location: Location) -> BlockArgumentNode
     # Create a new BlockLocalVariableNode node
-    def BlockLocalVariableNode: (name: Symbol, location: Location) -> BlockLocalVariableNode
+    def BlockLocalVariableNode: (flags: Integer, name: Symbol, location: Location) -> BlockLocalVariableNode
     # Create a new BlockNode node
-    def BlockNode: (locals: Array[Symbol], locals_body_index: Integer, parameters: Node?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> BlockNode
+    def BlockNode: (locals: Array[Symbol], parameters: Node?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> BlockNode
     # Create a new BlockParameterNode node
-    def BlockParameterNode: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> BlockParameterNode
+    def BlockParameterNode: (flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> BlockParameterNode
     # Create a new BlockParametersNode node
     def BlockParametersNode: (parameters: ParametersNode?, locals: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> BlockParametersNode
     # Create a new BreakNode node
@@ -4527,7 +4562,7 @@ module Prism
     # Create a new ConstantWriteNode node
     def ConstantWriteNode: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> ConstantWriteNode
     # Create a new DefNode node
-    def DefNode: (name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], locals_body_index: Integer, def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> DefNode
+    def DefNode: (name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> DefNode
     # Create a new DefinedNode node
     def DefinedNode: (lparen_loc: Location?, value: Node, rparen_loc: Location?, keyword_loc: Location, location: Location) -> DefinedNode
     # Create a new ElseNode node
@@ -4615,9 +4650,9 @@ module Prism
     # Create a new KeywordHashNode node
     def KeywordHashNode: (flags: Integer, elements: Array[Node], location: Location) -> KeywordHashNode
     # Create a new KeywordRestParameterNode node
-    def KeywordRestParameterNode: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> KeywordRestParameterNode
+    def KeywordRestParameterNode: (flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> KeywordRestParameterNode
     # Create a new LambdaNode node
-    def LambdaNode: (locals: Array[Symbol], locals_body_index: Integer, operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Node?, body: Node?, location: Location) -> LambdaNode
+    def LambdaNode: (locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Node?, body: Node?, location: Location) -> LambdaNode
     # Create a new LocalVariableAndWriteNode node
     def LocalVariableAndWriteNode: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> LocalVariableAndWriteNode
     # Create a new LocalVariableOperatorWriteNode node
@@ -4657,9 +4692,9 @@ module Prism
     # Create a new NumberedReferenceReadNode node
     def NumberedReferenceReadNode: (number: Integer, location: Location) -> NumberedReferenceReadNode
     # Create a new OptionalKeywordParameterNode node
-    def OptionalKeywordParameterNode: (name: Symbol, name_loc: Location, value: Node, location: Location) -> OptionalKeywordParameterNode
+    def OptionalKeywordParameterNode: (flags: Integer, name: Symbol, name_loc: Location, value: Node, location: Location) -> OptionalKeywordParameterNode
     # Create a new OptionalParameterNode node
-    def OptionalParameterNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> OptionalParameterNode
+    def OptionalParameterNode: (flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> OptionalParameterNode
     # Create a new OrNode node
     def OrNode: (left: Node, right: Node, operator_loc: Location, location: Location) -> OrNode
     # Create a new ParametersNode node
@@ -4685,15 +4720,15 @@ module Prism
     # Create a new RegularExpressionNode node
     def RegularExpressionNode: (flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> RegularExpressionNode
     # Create a new RequiredKeywordParameterNode node
-    def RequiredKeywordParameterNode: (name: Symbol, name_loc: Location, location: Location) -> RequiredKeywordParameterNode
+    def RequiredKeywordParameterNode: (flags: Integer, name: Symbol, name_loc: Location, location: Location) -> RequiredKeywordParameterNode
     # Create a new RequiredParameterNode node
-    def RequiredParameterNode: (name: Symbol, location: Location) -> RequiredParameterNode
+    def RequiredParameterNode: (flags: Integer, name: Symbol, location: Location) -> RequiredParameterNode
     # Create a new RescueModifierNode node
     def RescueModifierNode: (expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location) -> RescueModifierNode
     # Create a new RescueNode node
     def RescueNode: (keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: StatementsNode?, consequent: RescueNode?, location: Location) -> RescueNode
     # Create a new RestParameterNode node
-    def RestParameterNode: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> RestParameterNode
+    def RestParameterNode: (flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> RestParameterNode
     # Create a new RetryNode node
     def RetryNode: (location: Location) -> RetryNode
     # Create a new ReturnNode node