prism 1.0.0 → 1.1.0

data/rbi/prism/node.rbi

@@ -152,6 +152,9 @@ end
 #            ^^^^^^^^^^^^^
 class Prism::ArgumentsNode < Prism::Node
 
+  sig { returns(T::Boolean) }
+  def contains_forwarding?; end
+
   sig { returns(T::Boolean) }
   def contains_keywords?; end
 
@@ -161,6 +164,9 @@ class Prism::ArgumentsNode < Prism::Node
   sig { returns(T::Boolean) }
   def contains_splat?; end
 
+  sig { returns(T::Boolean) }
+  def contains_multiple_splats?; end
+
   sig { returns(T::Array[Prism::Node]) }
   def arguments; end
 
@@ -656,10 +662,10 @@ class Prism::CallNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def closing_loc; end
 
-  sig { returns(T.nilable(Prism::Node)) }
+  sig { returns(T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))) }
   def block; end
 
-  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), name: Symbol, message_loc: T.nilable(Prism::Location), opening_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), closing_loc: T.nilable(Prism::Location), block: T.nilable(Prism::Node)).void }
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), name: Symbol, message_loc: T.nilable(Prism::Location), opening_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), closing_loc: T.nilable(Prism::Location), block: T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))).void }
   def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
@@ -677,7 +683,7 @@ class Prism::CallNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), name: Symbol, message_loc: T.nilable(Prism::Location), opening_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), closing_loc: T.nilable(Prism::Location), block: T.nilable(Prism::Node)).returns(Prism::CallNode) }
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), name: Symbol, message_loc: T.nilable(Prism::Location), opening_loc: T.nilable(Prism::Location), arguments: T.nilable(Prism::ArgumentsNode), closing_loc: T.nilable(Prism::Location), block: T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))).returns(Prism::CallNode) }
   def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
@@ -1851,7 +1857,7 @@ class Prism::IndexAndWriteNode < Prism::Node
   sig { returns(Prism::Location) }
   def closing_loc; end
 
-  sig { returns(T.nilable(Prism::Node)) }
+  sig { returns(T.nilable(Prism::BlockArgumentNode)) }
   def block; end
 
   sig { returns(Prism::Location) }
@@ -1860,7 +1866,7 @@ class Prism::IndexAndWriteNode < Prism::Node
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator_loc: Prism::Location, value: Prism::Node).void }
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::BlockArgumentNode), operator_loc: Prism::Location, value: Prism::Node).void }
   def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
@@ -1878,7 +1884,7 @@ class Prism::IndexAndWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator_loc: Prism::Location, value: Prism::Node).returns(Prism::IndexAndWriteNode) }
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::BlockArgumentNode), operator_loc: Prism::Location, value: Prism::Node).returns(Prism::IndexAndWriteNode) }
   def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block, operator_loc: self.operator_loc, value: self.value); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
@@ -1939,7 +1945,7 @@ class Prism::IndexOperatorWriteNode < Prism::Node
   sig { returns(Prism::Location) }
   def closing_loc; end
 
-  sig { returns(T.nilable(Prism::Node)) }
+  sig { returns(T.nilable(Prism::BlockArgumentNode)) }
   def block; end
 
   sig { returns(Symbol) }
@@ -1951,7 +1957,7 @@ class Prism::IndexOperatorWriteNode < Prism::Node
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), binary_operator: Symbol, binary_operator_loc: Prism::Location, value: Prism::Node).void }
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::BlockArgumentNode), binary_operator: Symbol, binary_operator_loc: Prism::Location, value: Prism::Node).void }
   def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
@@ -1969,7 +1975,7 @@ class Prism::IndexOperatorWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), binary_operator: Symbol, binary_operator_loc: Prism::Location, value: Prism::Node).returns(Prism::IndexOperatorWriteNode) }
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::BlockArgumentNode), binary_operator: Symbol, binary_operator_loc: Prism::Location, value: Prism::Node).returns(Prism::IndexOperatorWriteNode) }
   def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block, binary_operator: self.binary_operator, binary_operator_loc: self.binary_operator_loc, value: self.value); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
@@ -2027,7 +2033,7 @@ class Prism::IndexOrWriteNode < Prism::Node
   sig { returns(Prism::Location) }
   def closing_loc; end
 
-  sig { returns(T.nilable(Prism::Node)) }
+  sig { returns(T.nilable(Prism::BlockArgumentNode)) }
   def block; end
 
   sig { returns(Prism::Location) }
@@ -2036,7 +2042,7 @@ class Prism::IndexOrWriteNode < Prism::Node
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator_loc: Prism::Location, value: Prism::Node).void }
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::BlockArgumentNode), operator_loc: Prism::Location, value: Prism::Node).void }
   def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
@@ -2054,7 +2060,7 @@ class Prism::IndexOrWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator_loc: Prism::Location, value: Prism::Node).returns(Prism::IndexOrWriteNode) }
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::BlockArgumentNode), operator_loc: Prism::Location, value: Prism::Node).returns(Prism::IndexOrWriteNode) }
   def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block, operator_loc: self.operator_loc, value: self.value); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
@@ -2120,10 +2126,10 @@ class Prism::IndexTargetNode < Prism::Node
   sig { returns(Prism::Location) }
   def closing_loc; end
 
-  sig { returns(T.nilable(Prism::Node)) }
+  sig { returns(T.nilable(Prism::BlockArgumentNode)) }
   def block; end
 
-  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: Prism::Node, opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node)).void }
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, receiver: Prism::Node, opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::BlockArgumentNode)).void }
   def initialize(source, node_id, location, flags, receiver, opening_loc, arguments, closing_loc, block); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
@@ -2141,7 +2147,7 @@ class Prism::IndexTargetNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: Prism::Node, opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node)).returns(Prism::IndexTargetNode) }
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, receiver: Prism::Node, opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::BlockArgumentNode)).returns(Prism::IndexTargetNode) }
   def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
@@ -4461,140 +4467,144 @@ end
 
 # Flags for arguments nodes.
 module Prism::ArgumentsNodeFlags
-  # if arguments contain keywords
-  CONTAINS_KEYWORDS = T.let(1 << 0, Integer)
-  # if arguments contain keyword splat
-  CONTAINS_KEYWORD_SPLAT = T.let(1 << 1, Integer)
-  # if arguments contain splat
-  CONTAINS_SPLAT = T.let(1 << 2, Integer)
+  # if the arguments contain forwarding
+  CONTAINS_FORWARDING = T.let(1 << 2, Integer)
+  # if the arguments contain keywords
+  CONTAINS_KEYWORDS = T.let(1 << 3, Integer)
+  # if the arguments contain a keyword splat
+  CONTAINS_KEYWORD_SPLAT = T.let(1 << 4, Integer)
+  # if the arguments contain a splat
+  CONTAINS_SPLAT = T.let(1 << 5, Integer)
+  # if the arguments contain multiple splats
+  CONTAINS_MULTIPLE_SPLATS = T.let(1 << 6, Integer)
 end
 
 # Flags for array nodes.
 module Prism::ArrayNodeFlags
   # if array contains splat nodes
-  CONTAINS_SPLAT = T.let(1 << 0, Integer)
+  CONTAINS_SPLAT = T.let(1 << 2, Integer)
 end
 
 # Flags for call nodes.
 module Prism::CallNodeFlags
   # &. operator
-  SAFE_NAVIGATION = T.let(1 << 0, Integer)
+  SAFE_NAVIGATION = T.let(1 << 2, Integer)
   # a call that could have been a local variable
-  VARIABLE_CALL = T.let(1 << 1, Integer)
+  VARIABLE_CALL = T.let(1 << 3, Integer)
   # a call that is an attribute write, so the value being written should be returned
-  ATTRIBUTE_WRITE = T.let(1 << 2, Integer)
+  ATTRIBUTE_WRITE = T.let(1 << 4, Integer)
   # a call that ignores method visibility
-  IGNORE_VISIBILITY = T.let(1 << 3, Integer)
+  IGNORE_VISIBILITY = T.let(1 << 5, Integer)
 end
 
 # Flags for nodes that have unescaped content.
 module Prism::EncodingFlags
   # internal bytes forced the encoding to UTF-8
-  FORCED_UTF8_ENCODING = T.let(1 << 0, Integer)
+  FORCED_UTF8_ENCODING = T.let(1 << 2, Integer)
   # internal bytes forced the encoding to binary
-  FORCED_BINARY_ENCODING = T.let(1 << 1, Integer)
+  FORCED_BINARY_ENCODING = T.let(1 << 3, Integer)
 end
 
 # Flags for integer nodes that correspond to the base of the integer.
 module Prism::IntegerBaseFlags
   # 0b prefix
-  BINARY = T.let(1 << 0, Integer)
+  BINARY = T.let(1 << 2, Integer)
   # 0d or no prefix
-  DECIMAL = T.let(1 << 1, Integer)
+  DECIMAL = T.let(1 << 3, Integer)
   # 0o or 0 prefix
-  OCTAL = T.let(1 << 2, Integer)
+  OCTAL = T.let(1 << 4, Integer)
   # 0x prefix
-  HEXADECIMAL = T.let(1 << 3, Integer)
+  HEXADECIMAL = T.let(1 << 5, Integer)
 end
 
 # Flags for interpolated string nodes that indicated mutability if they are also marked as literals.
 module Prism::InterpolatedStringNodeFlags
   # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'`
-  FROZEN = T.let(1 << 0, Integer)
+  FROZEN = T.let(1 << 2, Integer)
   # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'`
-  MUTABLE = T.let(1 << 1, Integer)
+  MUTABLE = T.let(1 << 3, Integer)
 end
 
 # Flags for keyword hash nodes.
 module Prism::KeywordHashNodeFlags
   # a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments
-  SYMBOL_KEYS = T.let(1 << 0, Integer)
+  SYMBOL_KEYS = T.let(1 << 2, Integer)
 end
 
 # Flags for while and until loop nodes.
 module Prism::LoopFlags
   # a loop after a begin statement, so the body is executed first before the condition
-  BEGIN_MODIFIER = T.let(1 << 0, Integer)
+  BEGIN_MODIFIER = T.let(1 << 2, Integer)
 end
 
 # Flags for parameter nodes.
 module Prism::ParameterFlags
   # a parameter name that has been repeated in the method signature
-  REPEATED_PARAMETER = T.let(1 << 0, Integer)
+  REPEATED_PARAMETER = T.let(1 << 2, Integer)
 end
 
 # Flags for range and flip-flop nodes.
 module Prism::RangeFlags
   # ... operator
-  EXCLUDE_END = T.let(1 << 0, Integer)
+  EXCLUDE_END = T.let(1 << 2, Integer)
 end
 
 # Flags for regular expression and match last line nodes.
 module Prism::RegularExpressionFlags
   # i - ignores the case of characters when matching
-  IGNORE_CASE = T.let(1 << 0, Integer)
+  IGNORE_CASE = T.let(1 << 2, Integer)
   # x - ignores whitespace and allows comments in regular expressions
-  EXTENDED = T.let(1 << 1, Integer)
+  EXTENDED = T.let(1 << 3, Integer)
   # m - allows $ to match the end of lines within strings
-  MULTI_LINE = T.let(1 << 2, Integer)
+  MULTI_LINE = T.let(1 << 4, Integer)
   # o - only interpolates values into the regular expression once
-  ONCE = T.let(1 << 3, Integer)
+  ONCE = T.let(1 << 5, Integer)
   # e - forces the EUC-JP encoding
-  EUC_JP = T.let(1 << 4, Integer)
+  EUC_JP = T.let(1 << 6, Integer)
   # n - forces the ASCII-8BIT encoding
-  ASCII_8BIT = T.let(1 << 5, Integer)
+  ASCII_8BIT = T.let(1 << 7, Integer)
   # s - forces the Windows-31J encoding
-  WINDOWS_31J = T.let(1 << 6, Integer)
+  WINDOWS_31J = T.let(1 << 8, Integer)
   # u - forces the UTF-8 encoding
-  UTF_8 = T.let(1 << 7, Integer)
+  UTF_8 = T.let(1 << 9, Integer)
   # internal bytes forced the encoding to UTF-8
-  FORCED_UTF8_ENCODING = T.let(1 << 8, Integer)
+  FORCED_UTF8_ENCODING = T.let(1 << 10, Integer)
   # internal bytes forced the encoding to binary
-  FORCED_BINARY_ENCODING = T.let(1 << 9, Integer)
+  FORCED_BINARY_ENCODING = T.let(1 << 11, Integer)
   # internal bytes forced the encoding to US-ASCII
-  FORCED_US_ASCII_ENCODING = T.let(1 << 10, Integer)
+  FORCED_US_ASCII_ENCODING = T.let(1 << 12, Integer)
 end
 
 # Flags for shareable constant nodes.
 module Prism::ShareableConstantNodeFlags
   # constant writes that should be modified with shareable constant value literal
-  LITERAL = T.let(1 << 0, Integer)
+  LITERAL = T.let(1 << 2, Integer)
   # constant writes that should be modified with shareable constant value experimental everything
-  EXPERIMENTAL_EVERYTHING = T.let(1 << 1, Integer)
+  EXPERIMENTAL_EVERYTHING = T.let(1 << 3, Integer)
   # constant writes that should be modified with shareable constant value experimental copy
-  EXPERIMENTAL_COPY = T.let(1 << 2, Integer)
+  EXPERIMENTAL_COPY = T.let(1 << 4, Integer)
 end
 
 # Flags for string nodes.
 module Prism::StringFlags
   # internal bytes forced the encoding to UTF-8
-  FORCED_UTF8_ENCODING = T.let(1 << 0, Integer)
+  FORCED_UTF8_ENCODING = T.let(1 << 2, Integer)
   # internal bytes forced the encoding to binary
-  FORCED_BINARY_ENCODING = T.let(1 << 1, Integer)
+  FORCED_BINARY_ENCODING = T.let(1 << 3, Integer)
   # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`
-  FROZEN = T.let(1 << 2, Integer)
+  FROZEN = T.let(1 << 4, Integer)
   # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`
-  MUTABLE = T.let(1 << 3, Integer)
+  MUTABLE = T.let(1 << 5, Integer)
 end
 
 # Flags for symbol nodes.
 module Prism::SymbolFlags
   # internal bytes forced the encoding to UTF-8
-  FORCED_UTF8_ENCODING = T.let(1 << 0, Integer)
+  FORCED_UTF8_ENCODING = T.let(1 << 2, Integer)
   # internal bytes forced the encoding to binary
-  FORCED_BINARY_ENCODING = T.let(1 << 1, Integer)
+  FORCED_BINARY_ENCODING = T.let(1 << 3, Integer)
   # internal bytes forced the encoding to US-ASCII
-  FORCED_US_ASCII_ENCODING = T.let(1 << 2, Integer)
+  FORCED_US_ASCII_ENCODING = T.let(1 << 4, Integer)
 end
 
 # The flags that are common to all nodes.

data/rbi/prism.rbi

@@ -1,17 +1,17 @@
 # typed: strict
 
 module Prism
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(String) }
-  def self.dump(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(String) }
+  def self.dump(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(String) }
-  def self.dump_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(String) }
+  def self.dump_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
-  def self.lex(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
+  def self.lex(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
-  def self.lex_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
+  def self.lex_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
   sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) }
   def self.lex_compat(source, **options); end
@@ -22,42 +22,42 @@ module Prism
   sig { params(source: String, serialized: String).returns(Prism::ParseResult) }
   def self.load(source, serialized); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
-  def self.parse(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
+  def self.parse(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
-  def self.parse_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
+  def self.parse_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).void }
-  def self.profile(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).void }
+  def self.profile(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).void }
-  def self.profile_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).void }
+  def self.profile_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(stream: T.any(IO, StringIO), command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
-  def self.parse_stream(stream, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(stream: T.any(IO, StringIO), command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
+  def self.parse_stream(stream, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
-  def self.parse_comments(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
+  def self.parse_comments(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
-  def self.parse_file_comments(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
+  def self.parse_file_comments(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
-  def self.parse_lex(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
+  def self.parse_lex(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
-  def self.parse_lex_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
+  def self.parse_lex_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
-  def self.parse_success?(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
+  def self.parse_success?(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
-  def self.parse_failure?(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
+  def self.parse_failure?(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
-  def self.parse_file_success?(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
+  def self.parse_file_success?(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
-  def self.parse_file_failure?(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
+  def self.parse_file_failure?(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, main_script: nil, scopes: nil, version: nil); end
 end