prism 0.16.0 → 0.17.0

data/rbi/prism.rbi

@@ -1030,10 +1030,10 @@ module Prism
 
   # Represents the use of a case statement.
   #
-  # case true
-  # ^^^^^^^^^
-  # when false
-  # end
+  #     case true
+  #     when false
+  #     end
+  #     ^^^^^^^^^^
   class CaseNode < Node
     sig { returns(T.nilable(Node)) }
     attr_reader :predicate
@@ -1141,7 +1141,7 @@ module Prism
   # Represents the use of the `&&=` operator for assignment to a class variable.
   #
   #     @@target &&= value
-  #     ^^^^^^^^^^^^^^^^
+  #     ^^^^^^^^^^^^^^^^^^
   class ClassVariableAndWriteNode < Node
     sig { returns(Symbol) }
     attr_reader :name
@@ -2160,13 +2160,13 @@ module Prism
   # Represents a find pattern in pattern matching.
   #
   #     foo in *bar, baz, *qux
-  #     ^^^^^^^^^^^^^^^^^^^^^^
+  #            ^^^^^^^^^^^^^^^
   #
   #     foo in [*bar, baz, *qux]
-  #     ^^^^^^^^^^^^^^^^^^^^^^^^
+  #            ^^^^^^^^^^^^^^^^^
   #
   #     foo in Foo(*bar, baz, *qux)
-  #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  #            ^^^^^^^^^^^^^^^^^^^^
   class FindPatternNode < Node
     sig { returns(T.nilable(Node)) }
     attr_reader :constant
@@ -2350,7 +2350,7 @@ module Prism
   #
   #     def foo(...)
   #       bar(...)
-  #       ^^^^^^^^
+  #           ^^^
   #     end
   class ForwardingArgumentsNode < Node
     sig { params(location: Location).void }
@@ -3708,47 +3708,6 @@ module Prism
     def inspect(inspector); end
   end
 
-  # Represents a keyword parameter to a method, block, or lambda definition.
-  #
-  #     def a(b:)
-  #           ^^
-  #     end
-  #
-  #     def a(b: 1)
-  #           ^^^^
-  #     end
-  class KeywordParameterNode < Node
-    sig { returns(Symbol) }
-    attr_reader :name
-
-    sig { returns(Location) }
-    attr_reader :name_loc
-
-    sig { returns(T.nilable(Node)) }
-    attr_reader :value
-
-    sig { params(name: Symbol, name_loc: Location, value: T.nilable(Node), location: Location).void }
-    def initialize(name, name_loc, value, location); end
-
-    sig { params(visitor: Visitor).void }
-    def accept(visitor); end
-
-    sig { returns(T::Array[T.nilable(Node)]) }
-    def child_nodes; end
-
-    sig { returns(T::Array[T.nilable(Node)]) }
-    def deconstruct; end
-
-    sig { params(params: T.untyped).returns(KeywordParameterNode) }
-    def copy(**params); end
-
-    sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) }
-    def deconstruct_keys(keys); end
-
-    sig { params(inspector: NodeInspector).returns(String) }
-    def inspect(inspector); end
-  end
-
   # Represents a keyword rest parameter to a method, block, or lambda definition.
   #
   #     def a(**b)
@@ -4594,6 +4553,43 @@ module Prism
     def inspect(inspector); end
   end
 
+  # Represents an optional keyword parameter to a method, block, or lambda definition.
+  #
+  #     def a(b: 1)
+  #           ^^^^
+  #     end
+  class OptionalKeywordParameterNode < Node
+    sig { returns(Symbol) }
+    attr_reader :name
+
+    sig { returns(Location) }
+    attr_reader :name_loc
+
+    sig { returns(Node) }
+    attr_reader :value
+
+    sig { params(name: Symbol, name_loc: Location, value: Node, location: Location).void }
+    def initialize(name, name_loc, value, location); end
+
+    sig { params(visitor: Visitor).void }
+    def accept(visitor); end
+
+    sig { returns(T::Array[T.nilable(Node)]) }
+    def child_nodes; end
+
+    sig { returns(T::Array[T.nilable(Node)]) }
+    def deconstruct; end
+
+    sig { params(params: T.untyped).returns(OptionalKeywordParameterNode) }
+    def copy(**params); end
+
+    sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) }
+    def deconstruct_keys(keys); end
+
+    sig { params(inspector: NodeInspector).returns(String) }
+    def inspect(inspector); end
+  end
+
   # Represents an optional parameter to a method, block, or lambda definition.
   #
   #     def a(b = 1)
@@ -5161,6 +5157,40 @@ module Prism
     def inspect(inspector); end
   end
 
+  # Represents a required keyword parameter to a method, block, or lambda definition.
+  #
+  #     def a(b: )
+  #           ^^
+  #     end
+  class RequiredKeywordParameterNode < Node
+    sig { returns(Symbol) }
+    attr_reader :name
+
+    sig { returns(Location) }
+    attr_reader :name_loc
+
+    sig { params(name: Symbol, name_loc: Location, location: Location).void }
+    def initialize(name, name_loc, location); end
+
+    sig { params(visitor: Visitor).void }
+    def accept(visitor); end
+
+    sig { returns(T::Array[T.nilable(Node)]) }
+    def child_nodes; end
+
+    sig { returns(T::Array[T.nilable(Node)]) }
+    def deconstruct; end
+
+    sig { params(params: T.untyped).returns(RequiredKeywordParameterNode) }
+    def copy(**params); end
+
+    sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) }
+    def deconstruct_keys(keys); end
+
+    sig { params(inspector: NodeInspector).returns(String) }
+    def inspect(inspector); end
+  end
+
   # Represents a required parameter to a method, block, or lambda definition.
   #
   #     def a(b)
@@ -5194,8 +5224,8 @@ module Prism
 
   # Represents an expression modified with a rescue.
   #
-  #   foo rescue nil
-  #   ^^^^^^^^^^^^^^
+  #     foo rescue nil
+  #     ^^^^^^^^^^^^^^
   class RescueModifierNode < Node
     sig { returns(Node) }
     attr_reader :expression
@@ -5237,8 +5267,8 @@ module Prism
   #
   #     begin
   #     rescue Foo, *splat, Bar => ex
-  #     ^^^^^^
   #       foo
+  #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   #     end
   #
   # `Foo, *splat, Bar` are in the `exceptions` field.
@@ -6189,11 +6219,13 @@ module Prism
   end
 
 
+  # Flags for arguments nodes.
   module ArgumentsNodeFlags
     # if arguments contain keyword splat
     KEYWORD_SPLAT = T.let(1 << 0, Integer)
   end
 
+  # Flags for call nodes.
   module CallNodeFlags
     # &. operator
     SAFE_NAVIGATION = T.let(1 << 0, Integer)
@@ -6201,6 +6233,7 @@ module Prism
     VARIABLE_CALL = T.let(1 << 1, Integer)
   end
 
+  # Flags for integer nodes that correspond to the base of the integer.
   module IntegerBaseFlags
     # 0b prefix
     BINARY = T.let(1 << 0, Integer)
@@ -6212,16 +6245,19 @@ module Prism
     HEXADECIMAL = T.let(1 << 3, Integer)
   end
 
+  # Flags for while and until loop nodes.
   module LoopFlags
     # a loop after a begin statement, so the body is executed first before the condition
     BEGIN_MODIFIER = T.let(1 << 0, Integer)
   end
 
+  # Flags for range and flip-flop nodes.
   module RangeFlags
     # ... operator
     EXCLUDE_END = T.let(1 << 0, Integer)
   end
 
+  # Flags for regular expression and match last line nodes.
   module RegularExpressionFlags
     # i - ignores the case of characters when matching
     IGNORE_CASE = T.let(1 << 0, Integer)
@@ -6241,6 +6277,7 @@ module Prism
     UTF_8 = T.let(1 << 7, Integer)
   end
 
+  # Flags for string nodes.
   module StringFlags
     # frozen by virtue of a `frozen_string_literal` comment
     FROZEN = T.let(1 << 0, Integer)
@@ -6584,10 +6621,6 @@ module Prism
     sig { params(node: KeywordHashNode).void }
     def visit_keyword_hash_node(node); end
     
-    # Visit a KeywordParameterNode node
-    sig { params(node: KeywordParameterNode).void }
-    def visit_keyword_parameter_node(node); end
-    
     # Visit a KeywordRestParameterNode node
     sig { params(node: KeywordRestParameterNode).void }
     def visit_keyword_rest_parameter_node(node); end
@@ -6668,6 +6701,10 @@ module Prism
     sig { params(node: NumberedReferenceReadNode).void }
     def visit_numbered_reference_read_node(node); end
     
+    # Visit a OptionalKeywordParameterNode node
+    sig { params(node: OptionalKeywordParameterNode).void }
+    def visit_optional_keyword_parameter_node(node); end
+    
     # Visit a OptionalParameterNode node
     sig { params(node: OptionalParameterNode).void }
     def visit_optional_parameter_node(node); end
@@ -6720,6 +6757,10 @@ module Prism
     sig { params(node: RegularExpressionNode).void }
     def visit_regular_expression_node(node); end
     
+    # Visit a RequiredKeywordParameterNode node
+    sig { params(node: RequiredKeywordParameterNode).void }
+    def visit_required_keyword_parameter_node(node); end
+    
     # Visit a RequiredParameterNode node
     sig { params(node: RequiredParameterNode).void }
     def visit_required_parameter_node(node); end
@@ -7080,9 +7121,6 @@ module Prism
     # Create a new KeywordHashNode node
     sig { params(elements: T::Array[Node], location: Location).returns(KeywordHashNode) }
     def KeywordHashNode(elements, location); end
-    # Create a new KeywordParameterNode node
-    sig { params(name: Symbol, name_loc: Location, value: T.nilable(Node), location: Location).returns(KeywordParameterNode) }
-    def KeywordParameterNode(name, name_loc, value, location); end
     # Create a new KeywordRestParameterNode node
     sig { params(name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location, location: Location).returns(KeywordRestParameterNode) }
     def KeywordRestParameterNode(name, name_loc, operator_loc, location); end
@@ -7143,6 +7181,9 @@ module Prism
     # Create a new NumberedReferenceReadNode node
     sig { params(number: Integer, location: Location).returns(NumberedReferenceReadNode) }
     def NumberedReferenceReadNode(number, location); end
+    # Create a new OptionalKeywordParameterNode node
+    sig { params(name: Symbol, name_loc: Location, value: Node, location: Location).returns(OptionalKeywordParameterNode) }
+    def OptionalKeywordParameterNode(name, name_loc, value, location); end
     # Create a new OptionalParameterNode node
     sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(OptionalParameterNode) }
     def OptionalParameterNode(name, name_loc, operator_loc, value, location); end
@@ -7182,6 +7223,9 @@ module Prism
     # Create a new RegularExpressionNode node
     sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location).returns(RegularExpressionNode) }
     def RegularExpressionNode(opening_loc, content_loc, closing_loc, unescaped, flags, location); end
+    # Create a new RequiredKeywordParameterNode node
+    sig { params(name: Symbol, name_loc: Location, location: Location).returns(RequiredKeywordParameterNode) }
+    def RequiredKeywordParameterNode(name, name_loc, location); end
     # Create a new RequiredParameterNode node
     sig { params(name: Symbol, location: Location).returns(RequiredParameterNode) }
     def RequiredParameterNode(name, location); end

data/rbi/prism_static.rbi

@@ -48,6 +48,20 @@ module Prism
   class Comment
     sig { returns(Location) }
     def location; end
+
+    sig { returns(T::Boolean) }
+    def trailing?; end
+  end
+
+  class InlineComment < Comment
+    sig { override.returns(T::Boolean) }
+    def trailing?; end
+  end
+
+  class EmbDocComment < Comment
+  end
+
+  class DATAComment < Comment
   end
 
   class Location
@@ -83,8 +97,8 @@ module Prism
   end
 
   class Source
-    sig { params(source: String, offsets: T::Array[Integer]).void }
-    def initialize(source, offsets); end
+    sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
+    def initialize(source, start_line, offsets); end
 
     sig { params(offset: Integer, length: Integer).returns(String) }
     def slice(offset, length); end

data/sig/prism.rbs

@@ -607,10 +607,10 @@ module Prism
   end
   # Represents the use of a case statement.
   #
-  # case true
-  # ^^^^^^^^^
-  # when false
-  # end
+  #     case true
+  #     when false
+  #     end
+  #     ^^^^^^^^^^
   class CaseNode < Node
     attr_reader predicate: Node?
     attr_reader conditions: Array[Node]
@@ -669,7 +669,7 @@ module Prism
   # Represents the use of the `&&=` operator for assignment to a class variable.
   #
   #     @@target &&= value
-  #     ^^^^^^^^^^^^^^^^
+  #     ^^^^^^^^^^^^^^^^^^
   class ClassVariableAndWriteNode < Node
     attr_reader name: Symbol
     attr_reader name_loc: Location
@@ -1268,13 +1268,13 @@ module Prism
   # Represents a find pattern in pattern matching.
   #
   #     foo in *bar, baz, *qux
-  #     ^^^^^^^^^^^^^^^^^^^^^^
+  #            ^^^^^^^^^^^^^^^
   #
   #     foo in [*bar, baz, *qux]
-  #     ^^^^^^^^^^^^^^^^^^^^^^^^
+  #            ^^^^^^^^^^^^^^^^^
   #
   #     foo in Foo(*bar, baz, *qux)
-  #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  #            ^^^^^^^^^^^^^^^^^^^^
   class FindPatternNode < Node
     attr_reader constant: Node?
     attr_reader left: Node
@@ -1380,7 +1380,7 @@ module Prism
   #
   #     def foo(...)
   #       bar(...)
-  #       ^^^^^^^^
+  #           ^^^
   #     end
   class ForwardingArgumentsNode < Node
 
@@ -2176,32 +2176,6 @@ module Prism
 
     def inspect: (inspector: NodeInspector) -> String
   end
-  # Represents a keyword parameter to a method, block, or lambda definition.
-  #
-  #     def a(b:)
-  #           ^^
-  #     end
-  #
-  #     def a(b: 1)
-  #           ^^^^
-  #     end
-  class KeywordParameterNode < Node
-    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 child_nodes: () -> Array[Node?]
-    def deconstruct: () -> Array[Node?]
-
-    def copy: (**untyped) -> KeywordParameterNode
-
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
-
-    def inspect: (inspector: NodeInspector) -> String
-  end
   # Represents a keyword rest parameter to a method, block, or lambda definition.
   #
   #     def a(**b)
@@ -2697,6 +2671,28 @@ module Prism
 
     def inspect: (inspector: NodeInspector) -> String
   end
+  # Represents an optional keyword parameter to a method, block, or lambda definition.
+  #
+  #     def a(b: 1)
+  #           ^^^^
+  #     end
+  class OptionalKeywordParameterNode < Node
+    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 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 inspect: (inspector: NodeInspector) -> String
+  end
   # Represents an optional parameter to a method, block, or lambda definition.
   #
   #     def a(b = 1)
@@ -3032,6 +3028,27 @@ module Prism
 
     def inspect: (inspector: NodeInspector) -> String
   end
+  # Represents a required keyword parameter to a method, block, or lambda definition.
+  #
+  #     def a(b: )
+  #           ^^
+  #     end
+  class RequiredKeywordParameterNode < Node
+    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 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 inspect: (inspector: NodeInspector) -> String
+  end
   # Represents a required parameter to a method, block, or lambda definition.
   #
   #     def a(b)
@@ -3054,8 +3071,8 @@ module Prism
   end
   # Represents an expression modified with a rescue.
   #
-  #   foo rescue nil
-  #   ^^^^^^^^^^^^^^
+  #     foo rescue nil
+  #     ^^^^^^^^^^^^^^
   class RescueModifierNode < Node
     attr_reader expression: Node
     attr_reader keyword_loc: Location
@@ -3079,8 +3096,8 @@ module Prism
   #
   #     begin
   #     rescue Foo, *splat, Bar => ex
-  #     ^^^^^^
   #       foo
+  #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   #     end
   #
   # `Foo, *splat, Bar` are in the `exceptions` field.
@@ -3654,11 +3671,13 @@ module Prism
     def inspect: (inspector: NodeInspector) -> String
   end
 
+  # Flags for arguments nodes.
   module ArgumentsNodeFlags
     # if arguments contain keyword splat
     KEYWORD_SPLAT: Integer
   end
 
+  # Flags for call nodes.
   module CallNodeFlags
     # &. operator
     SAFE_NAVIGATION: Integer
@@ -3666,6 +3685,7 @@ module Prism
     VARIABLE_CALL: Integer
   end
 
+  # Flags for integer nodes that correspond to the base of the integer.
   module IntegerBaseFlags
     # 0b prefix
     BINARY: Integer
@@ -3677,16 +3697,19 @@ module Prism
     HEXADECIMAL: Integer
   end
 
+  # Flags for while and until loop nodes.
   module LoopFlags
     # a loop after a begin statement, so the body is executed first before the condition
     BEGIN_MODIFIER: Integer
   end
 
+  # Flags for range and flip-flop nodes.
   module RangeFlags
     # ... operator
     EXCLUDE_END: Integer
   end
 
+  # Flags for regular expression and match last line nodes.
   module RegularExpressionFlags
     # i - ignores the case of characters when matching
     IGNORE_CASE: Integer
@@ -3706,6 +3729,7 @@ module Prism
     UTF_8: Integer
   end
 
+  # Flags for string nodes.
   module StringFlags
     # frozen by virtue of a `frozen_string_literal` comment
     FROZEN: Integer
@@ -3965,9 +3989,6 @@ module Prism
     # Visit a KeywordHashNode node
     def visit_keyword_hash_node: (node: KeywordHashNode) -> void
     
-    # Visit a KeywordParameterNode node
-    def visit_keyword_parameter_node: (node: KeywordParameterNode) -> void
-    
     # Visit a KeywordRestParameterNode node
     def visit_keyword_rest_parameter_node: (node: KeywordRestParameterNode) -> void
     
@@ -4028,6 +4049,9 @@ module Prism
     # Visit a NumberedReferenceReadNode node
     def visit_numbered_reference_read_node: (node: NumberedReferenceReadNode) -> void
     
+    # Visit a OptionalKeywordParameterNode node
+    def visit_optional_keyword_parameter_node: (node: OptionalKeywordParameterNode) -> void
+    
     # Visit a OptionalParameterNode node
     def visit_optional_parameter_node: (node: OptionalParameterNode) -> void
     
@@ -4067,6 +4091,9 @@ module Prism
     # Visit a RegularExpressionNode node
     def visit_regular_expression_node: (node: RegularExpressionNode) -> void
     
+    # Visit a RequiredKeywordParameterNode node
+    def visit_required_keyword_parameter_node: (node: RequiredKeywordParameterNode) -> void
+    
     # Visit a RequiredParameterNode node
     def visit_required_parameter_node: (node: RequiredParameterNode) -> void
     
@@ -4317,8 +4344,6 @@ module Prism
     def InterpolatedXStringNode: (opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> InterpolatedXStringNode
     # Create a new KeywordHashNode node
     def KeywordHashNode: (elements: Array[Node], location: Location) -> KeywordHashNode
-    # Create a new KeywordParameterNode node
-    def KeywordParameterNode: (name: Symbol, name_loc: Location, value: Node?, location: Location) -> KeywordParameterNode
     # Create a new KeywordRestParameterNode node
     def KeywordRestParameterNode: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> KeywordRestParameterNode
     # Create a new LambdaNode node
@@ -4359,6 +4384,8 @@ module Prism
     def NoKeywordsParameterNode: (operator_loc: Location, keyword_loc: Location, location: Location) -> NoKeywordsParameterNode
     # 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
     # Create a new OptionalParameterNode node
     def OptionalParameterNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> OptionalParameterNode
     # Create a new OrNode node
@@ -4385,6 +4412,8 @@ module Prism
     def RedoNode: (location: Location) -> RedoNode
     # Create a new RegularExpressionNode node
     def RegularExpressionNode: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location) -> RegularExpressionNode
+    # Create a new RequiredKeywordParameterNode node
+    def RequiredKeywordParameterNode: (name: Symbol, name_loc: Location, location: Location) -> RequiredKeywordParameterNode
     # Create a new RequiredParameterNode node
     def RequiredParameterNode: (name: Symbol, location: Location) -> RequiredParameterNode
     # Create a new RescueModifierNode node

data/sig/prism_static.rbs

@@ -25,6 +25,17 @@ module Prism
 
   class Comment
     def location: () -> Location
+    def trailing?: () -> bool
+  end
+
+  class InlineComment < Comment
+    def trailing?: () -> bool
+  end
+
+  class EmbDocComment < Comment
+  end
+
+  class DATAComment < Comment
   end
 
   class Location
@@ -42,12 +53,14 @@ module Prism
 
   class Source
     attr_reader source: String
+    attr_reader start_line: Integer
     attr_reader offsets: Array[Integer]
 
     @source: String
+    @start_line: Integer
     @offsets: Array[Integer]
 
-    def initialize: (source: String, offsets: Array[Integer]) -> void
+    def initialize: (source: String, start_line: Integer, offsets: Array[Integer]) -> void
     def slice: (offset: Integer, length: Integer) -> String
     def line: (value: Integer) -> Integer
     def line_offset: (value: Integer) -> Integer