prism 0.16.0 → 0.17.1

data/rbi/prism_static.rbi

@@ -1,182 +1,192 @@
-# typed: true
+class Prism::ParseResult
+  sig { returns(Prism::ProgramNode) }
+  def value; end
 
-module Prism
-  class ParseResult
-    sig { returns(ProgramNode) }
-    def value; end
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; end
 
-    sig { returns(T::Array[Comment]) }
-    def comments; end
+  sig { returns(T::Array[Prism::ParseError]) }
+  def errors; end
 
-    sig { returns(T::Array[ParseError]) }
-    def errors; end
+  sig { returns(T::Array[Prism::ParseWarning]) }
+  def warnings; end
 
-    sig { returns(T::Array[ParseWarning]) }
-    def warnings; end
+  sig { returns(Prism::Source) }
+  def source; end
+end
 
-    sig { returns(Source) }
-    def source; end
-  end
+class Prism::ParseError
+  sig { returns(String) }
+  def message; end
 
-  class ParseError
-    sig { returns(String) }
-    def message; end
+  sig { returns(Prism::Location) }
+  def location; end
+end
 
-    sig { returns(Location) }
-    def location; end
-  end
+class Prism::ParseWarning
+  sig { returns(String) }
+  def message; end
 
-  class ParseWarning
-    sig { returns(String) }
-    def message; end
+  sig { returns(Prism::Location) }
+  def location; end
+end
 
-    sig { returns(Location) }
-    def location; end
-  end
+class Prism::Node
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
 
-  class Node
-    sig { returns(T::Array[T.nilable(Node)]) }
-    def child_nodes; end
+  sig { returns(Prism::Location) }
+  def location; end
 
-    sig { returns(Location) }
-    def location; end
+  sig { returns(String) }
+  def slice; end
+end
 
-    sig { returns(String) }
-    def slice; end
-  end
+class Prism::Comment
+  sig { returns(Prism::Location) }
+  def location; end
 
-  class Comment
-    sig { returns(Location) }
-    def location; end
-  end
+  sig { returns(T::Boolean) }
+  def trailing?; end
+end
 
-  class Location
-    sig { params(source: Source, start_offset: Integer, length: Integer).void }
-    def initialize(source, start_offset, length); end
+class Prism::InlineComment < Prism::Comment
+  sig { override.returns(T::Boolean) }
+  def trailing?; end
+end
 
-    sig { returns(String) }
-    def slice; end
+class Prism::EmbDocComment < Prism::Comment
+end
 
-    sig { returns(T::Array[Comment]) }
-    def comments; end
+class Prism::DATAComment < Prism::Comment
+end
 
-    sig { params(options: T.untyped).returns(Location) }
-    def copy(**options); end
+class Prism::Location
+  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
+  def initialize(source, start_offset, length); end
 
-    sig { returns(Integer) }
-    def start_offset; end
+  sig { returns(String) }
+  def slice; end
 
-    sig { returns(Integer) }
-    def end_offset; end
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; end
 
-    sig { returns(Integer) }
-    def start_line; end
+  sig { params(options: T.untyped).returns(Prism::Location) }
+  def copy(**options); end
 
-    sig { returns(Integer) }
-    def end_line; end
+  sig { returns(Integer) }
+  def start_offset; end
 
-    sig { returns(Integer) }
-    def start_column; end
+  sig { returns(Integer) }
+  def end_offset; end
 
-    sig { returns(Integer) }
-    def end_column; end
-  end
+  sig { returns(Integer) }
+  def start_line; end
 
-  class Source
-    sig { params(source: String, offsets: T::Array[Integer]).void }
-    def initialize(source, offsets); end
+  sig { returns(Integer) }
+  def end_line; end
 
-    sig { params(offset: Integer, length: Integer).returns(String) }
-    def slice(offset, length); end
+  sig { returns(Integer) }
+  def start_column; end
 
-    sig { params(value: Integer).returns(Integer) }
-    def line(value); end
+  sig { returns(Integer) }
+  def end_column; end
+end
+
+class Prism::Source
+  sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
+  def initialize(source, start_line, offsets); end
 
-    sig { params(value: Integer).returns(Integer) }
-    def line_offset(value); end
+  sig { params(offset: Integer, length: Integer).returns(String) }
+  def slice(offset, length); end
 
-    sig { params(value: Integer).returns(Integer) }
-    def column(value); end
+  sig { params(value: Integer).returns(Integer) }
+  def line(value); end
 
-    sig { returns(String) }
-    def source; end
+  sig { params(value: Integer).returns(Integer) }
+  def line_offset(value); end
 
-    sig { returns(T::Array[Integer]) }
-    def offsets; end
-  end
+  sig { params(value: Integer).returns(Integer) }
+  def column(value); end
 
-  class Token
-    sig { params(type: T.untyped, value: String, location: Location).void }
-    def initialize(type, value, location); end
+  sig { returns(String) }
+  def source; end
 
-    sig { params(keys: T.untyped).returns(T.untyped) }
-    def deconstruct_keys(keys); end
+  sig { returns(T::Array[Integer]) }
+  def offsets; end
+end
 
-    sig { params(q: T.untyped).returns(T.untyped) }
-    def pretty_print(q); end
+class Prism::Token
+  sig { params(type: T.untyped, value: String, location: Prism::Location).void }
+  def initialize(type, value, location); end
 
-    sig { params(other: T.untyped).returns(T::Boolean) }
-    def ==(other); end
+  sig { params(keys: T.untyped).returns(T.untyped) }
+  def deconstruct_keys(keys); end
 
-    sig { returns(T.untyped) }
-    def type; end
+  sig { params(q: T.untyped).returns(T.untyped) }
+  def pretty_print(q); end
 
-    sig { returns(String) }
-    def value; end
+  sig { params(other: T.untyped).returns(T::Boolean) }
+  def ==(other); end
 
-    sig { returns(Location) }
-    def location; end
-  end
+  sig { returns(T.untyped) }
+  def type; end
 
-  class NodeInspector
-    sig { params(prefix: String).void }
-    def initialize(prefix); end
+  sig { returns(String) }
+  def value; end
 
-    sig { returns(String) }
-    def prefix; end
+  sig { returns(Prism::Location) }
+  def location; end
+end
 
-    sig { returns(String) }
-    def output; end
+class Prism::NodeInspector
+  sig { params(prefix: String).void }
+  def initialize(prefix); end
 
-    # Appends a line to the output with the current prefix.
-    sig { params(line: String).void }
-    def <<(line); end
+  sig { returns(String) }
+  def prefix; end
 
-    # This generates a string that is used as the header of the inspect output
-    # for any given node.
-    sig { params(node: Node).returns(String) }
-    def header(node); end
+  sig { returns(String) }
+  def output; end
 
-    # Generates a string that represents a list of nodes. It handles properly
-    # using the box drawing characters to make the output look nice.
-    sig { params(prefix: String, nodes: T::Array[Node]).returns(String) }
-    def list(prefix, nodes); end
+  # Appends a line to the output with the current prefix.
+  sig { params(line: String).void }
+  def <<(line); end
 
-    # Generates a string that represents a location field on a node.
-    sig { params(value: Location).returns(String) }
-    def location(value); end
+  # This generates a string that is used as the header of the inspect output
+  # for any given node.
+  sig { params(node: Prism::Node).returns(String) }
+  def header(node); end
 
-    # Generates a string that represents a child node.
-    sig { params(node: Node, append: String).returns(String) }
-    def child_node(node, append); end
+  # Generates a string that represents a list of nodes. It handles properly
+  # using the box drawing characters to make the output look nice.
+  sig { params(prefix: String, nodes: T::Array[Prism::Node]).returns(String) }
+  def list(prefix, nodes); end
 
-    # Returns a new inspector that can be used to inspect a child node.
-    sig { params(append: String).returns(NodeInspector) }
-    def child_inspector(append); end
+  # Generates a string that represents a location field on a node.
+  sig { params(value: Prism::Location).returns(String) }
+  def location(value); end
 
-    # Returns the output as a string.
-    sig { returns(String) }
-    def to_str; end
-  end
+  # Generates a string that represents a child node.
+  sig { params(node: Prism::Node, append: String).returns(String) }
+  def child_node(node, append); end
+
+  # Returns a new inspector that can be used to inspect a child node.
+  sig { params(append: String).returns(Prism::NodeInspector) }
+  def child_inspector(append); end
+
+  # Returns the output as a string.
+  sig { returns(String) }
+  def to_str; end
+end
 
-  class BasicVisitor
-    sig { params(node: T.nilable(Node)).void }
-    def visit(node); end
+class Prism::BasicVisitor
+  sig { params(node: T.nilable(Prism::Node)).void }
+  def visit(node); end
 
-    sig { params(nodes: T::Array[T.nilable(Node)]).void }
-    def visit_all(nodes); end
+  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).void }
+  def visit_all(nodes); end
 
-    sig { params(node: Node).void }
-    def visit_child_nodes(node); end
-  end
+  sig { params(node: Prism::Node).void }
+  def visit_child_nodes(node); end
 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