prism 0.29.0 → 0.30.0

data/rbi/prism/node.rbi

@@ -5103,6 +5103,45 @@ class Prism::InterpolatedXStringNode < Prism::Node
   def type; end
 end
 
+# Represents reading from the implicit `it` local variable.
+#
+#     -> { it }
+#          ^^
+class Prism::ItLocalVariableReadNode < Prism::Node
+  sig { params(source: Prism::Source, location: Prism::Location).void }
+  def initialize(source, location); end
+
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  sig { params(location: Prism::Location).returns(Prism::ItLocalVariableReadNode) }
+  def copy(location: self.location); end
+
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  sig { override.returns(String) }
+  def inspect; end
+
+  sig { override.returns(Symbol) }
+  def type; end
+end
+
 # Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
 #
 #     -> { it + it }
@@ -6943,11 +6982,17 @@ end
 #     1.0r
 #     ^^^^
 class Prism::RationalNode < Prism::Node
-  sig { returns(Prism::Node) }
-  def numeric; end
+  sig { returns(Integer) }
+  def flags; end
 
-  sig { params(source: Prism::Source, numeric: Prism::Node, location: Prism::Location).void }
-  def initialize(source, numeric, location); end
+  sig { returns(Integer) }
+  def numerator; end
+
+  sig { returns(Integer) }
+  def denominator; end
+
+  sig { params(source: Prism::Source, flags: Integer, numerator: Integer, denominator: Integer, location: Prism::Location).void }
+  def initialize(source, flags, numerator, denominator, location); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -6964,12 +7009,24 @@ class Prism::RationalNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(numeric: Prism::Node, location: Prism::Location).returns(Prism::RationalNode) }
-  def copy(numeric: self.numeric, location: self.location); end
+  sig { params(flags: Integer, numerator: Integer, denominator: Integer, location: Prism::Location).returns(Prism::RationalNode) }
+  def copy(flags: self.flags, numerator: self.numerator, denominator: self.denominator, location: self.location); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
 
+  sig { returns(T::Boolean) }
+  def binary?; end
+
+  sig { returns(T::Boolean) }
+  def decimal?; end
+
+  sig { returns(T::Boolean) }
+  def octal?; end
+
+  sig { returns(T::Boolean) }
+  def hexadecimal?; end
+
   sig { override.returns(T::Array[Prism::Reflection::Field]) }
   def fields; end
 

data/rbi/prism/visitor.rbi

@@ -279,6 +279,9 @@ class Prism::Visitor < Prism::BasicVisitor
   sig { params(node: Prism::InterpolatedXStringNode).void }
   def visit_interpolated_x_string_node(node); end
 
+  sig { params(node: Prism::ItLocalVariableReadNode).void }
+  def visit_it_local_variable_read_node(node); end
+
   sig { params(node: Prism::ItParametersNode).void }
   def visit_it_parameters_node(node); end
 

data/rbi/prism.rbi

@@ -28,6 +28,12 @@ module Prism
   sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, 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(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)).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(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, 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(stream: T.any(IO, StringIO), 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(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
 

data/sig/prism/dsl.rbs

@@ -270,6 +270,9 @@ module Prism
     # Create a new InterpolatedXStringNode node
     def InterpolatedXStringNode: (Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc, ?Source source, ?Location location) -> InterpolatedXStringNode
 
+    # Create a new ItLocalVariableReadNode node
+    def ItLocalVariableReadNode: (?Source source, ?Location location) -> ItLocalVariableReadNode
+
     # Create a new ItParametersNode node
     def ItParametersNode: (?Source source, ?Location location) -> ItParametersNode
 
@@ -373,7 +376,7 @@ module Prism
     def RangeNode: (Integer flags, Prism::node? left, Prism::node? right, Location operator_loc, ?Source source, ?Location location) -> RangeNode
 
     # Create a new RationalNode node
-    def RationalNode: (Prism::node numeric, ?Source source, ?Location location) -> RationalNode
+    def RationalNode: (Integer flags, Integer numerator, Integer denominator, ?Source source, ?Location location) -> RationalNode
 
     # Create a new RedoNode node
     def RedoNode: (?Source source, ?Location location) -> RedoNode

data/sig/prism/mutation_compiler.rbs

@@ -91,6 +91,7 @@ module Prism
     def visit_interpolated_string_node: (InterpolatedStringNode) -> node?
     def visit_interpolated_symbol_node: (InterpolatedSymbolNode) -> node?
     def visit_interpolated_x_string_node: (InterpolatedXStringNode) -> node?
+    def visit_it_local_variable_read_node: (ItLocalVariableReadNode) -> node?
     def visit_it_parameters_node: (ItParametersNode) -> node?
     def visit_keyword_hash_node: (KeywordHashNode) -> node?
     def visit_keyword_rest_parameter_node: (KeywordRestParameterNode) -> node?

data/sig/prism/node.rbs

@@ -23,6 +23,8 @@ module Prism
     def pretty_print: (untyped q) -> untyped
     def to_dot: () -> String
     def tunnel: (Integer line, Integer column) -> Array[Prism::node]
+    def deprecated: (*String) -> void
+    def newline!: (Array[untyped]) -> void
   end
 
   type node_singleton = singleton(Node) & _NodeSingleton
@@ -2047,6 +2049,22 @@ module Prism
     def self.type: () -> :interpolated_x_string_node
   end
 
+  # Represents reading from the implicit `it` local variable.
+  #
+  #     -> { it }
+  #          ^^
+  class ItLocalVariableReadNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> ItLocalVariableReadNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :it_local_variable_read_node
+            | ...
+    def self.type: () -> :it_local_variable_read_node
+  end
+
   # Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
   #
   #     -> { it + it }
@@ -2769,11 +2787,17 @@ module Prism
   class RationalNode < Node
     include _Node
 
-    attr_reader numeric: Prism::node
+    attr_reader flags: Integer
+    attr_reader numerator: Integer
+    attr_reader denominator: Integer
 
-    def initialize: (Source source, Prism::node numeric, Location location) -> void
-    def copy: (?numeric: Prism::node, ?location: Location) -> RationalNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { numeric: Prism::node, location: Location }
+    def initialize: (Source source, Integer flags, Integer numerator, Integer denominator, Location location) -> void
+    def copy: (?flags: Integer, ?numerator: Integer, ?denominator: Integer, ?location: Location) -> RationalNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, numerator: Integer, denominator: Integer, location: Location }
+    def binary?: () -> bool
+    def decimal?: () -> bool
+    def octal?: () -> bool
+    def hexadecimal?: () -> bool
     def type: () -> :rational_node
             | ...
     def self.type: () -> :rational_node

data/sig/prism/visitor.rbs

@@ -97,6 +97,7 @@ module Prism
     def visit_interpolated_string_node: (InterpolatedStringNode) -> void
     def visit_interpolated_symbol_node: (InterpolatedSymbolNode) -> void
     def visit_interpolated_x_string_node: (InterpolatedXStringNode) -> void
+    def visit_it_local_variable_read_node: (ItLocalVariableReadNode) -> void
     def visit_it_parameters_node: (ItParametersNode) -> void
     def visit_keyword_hash_node: (KeywordHashNode) -> void
     def visit_keyword_rest_parameter_node: (KeywordRestParameterNode) -> void

data/sig/prism.rbs

@@ -19,6 +19,17 @@ module Prism
     ?scopes: Array[Array[Symbol]]
   ) -> ParseResult
 
+  def self.profile: (
+    String source,
+    ?filepath: String,
+    ?line: Integer,
+    ?offset: Integer,
+    ?encoding: Encoding,
+    ?frozen_string_literal: bool,
+    ?verbose: bool,
+    ?scopes: Array[Array[Symbol]]
+  ) -> nil
+
   def self.lex: (
     String source,
     ?filepath: String,
@@ -117,6 +128,16 @@ module Prism
     ?scopes: Array[Array[Symbol]]
   ) -> ParseResult
 
+  def self.profile_file: (
+    String filepath,
+    ?line: Integer,
+    ?offset: Integer,
+    ?encoding: Encoding,
+    ?frozen_string_literal: bool,
+    ?verbose: bool,
+    ?scopes: Array[Array[Symbol]]
+  ) -> nil
+
   def self.lex_file: (
     String filepath,
     ?line: Integer,

data/src/diagnostic.c

@@ -8,7 +8,7 @@
 
 #include "prism/diagnostic.h"
 
-#define PM_DIAGNOSTIC_ID_MAX 301
+#define PM_DIAGNOSTIC_ID_MAX 306
 
 /** This struct holds the data for each diagnostic. */
 typedef struct {
@@ -120,7 +120,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_ARRAY_ELEMENT]                      = { "expected an element for the array", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARRAY_EXPRESSION]                   = { "expected an expression for the array element", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARRAY_EXPRESSION_AFTER_STAR]        = { "expected an expression after `*` in the array", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ARRAY_SEPARATOR]                    = { "expected a `,` separator for the array elements", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ARRAY_SEPARATOR]                    = { "unexpected %s; expected a `,` separator for the array elements", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARRAY_TERM]                         = { "expected a `]` to close the array", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_BEGIN_LONELY_ELSE]                  = { "unexpected `else` in `begin` block; else without rescue is useless", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_BEGIN_TERM]                         = { "expected an `end` to close the `begin` statement", PM_ERROR_LEVEL_SYNTAX },
@@ -166,16 +166,16 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_EMBVAR_INVALID]                     = { "invalid embedded variable", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_END_UPCASE_BRACE]                   = { "expected a `{` after `END`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_END_UPCASE_TERM]                    = { "expected a `}` to close the `END` statement", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ESCAPE_INVALID_CONTROL]             = { "invalid control escape sequence", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ESCAPE_INVALID_CONTROL]             = { "Invalid escape character syntax", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_CONTROL_REPEAT]      = { "invalid control escape sequence; control cannot be repeated", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_HEXADECIMAL]         = { "invalid hex escape sequence", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ESCAPE_INVALID_META]                = { "invalid meta escape sequence", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ESCAPE_INVALID_META]                = { "Invalid escape character syntax", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_META_REPEAT]         = { "invalid meta escape sequence; meta cannot be repeated", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE]             = { "invalid Unicode escape sequence", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE_CM_FLAGS]    = { "invalid Unicode escape sequence; Unicode cannot be combined with control or meta flags", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE_LITERAL]     = { "invalid Unicode escape sequence; Multiple codepoints at single character literal are disallowed", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE_LONG]        = { "invalid Unicode escape sequence; maximum length is 6 digits", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ESCAPE_INVALID_UNICODE_TERM]        = { "invalid Unicode escape sequence; needs closing `}`", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ESCAPE_INVALID_UNICODE_TERM]        = { "unterminated Unicode escape", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_ARGUMENT]                    = { "expected an argument", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_EOL_AFTER_STATEMENT]         = { "unexpected %s, expecting end-of-input", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ]   = { "expected an expression after `&&=`", PM_ERROR_LEVEL_SYNTAX },
@@ -205,6 +205,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_EXPRESSION_NOT_WRITABLE_FILE]       = { "Can't assign to __FILE__", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPRESSION_NOT_WRITABLE_LINE]       = { "Can't assign to __LINE__", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPRESSION_NOT_WRITABLE_NIL]        = { "Can't assign to nil", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED]   = { "Can't assign to numbered parameter %.2s", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPRESSION_NOT_WRITABLE_SELF]       = { "Can't change the value of self", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPRESSION_NOT_WRITABLE_TRUE]       = { "Can't assign to true", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_FLOAT_PARSE]                        = { "could not parse the float '%.*s'", PM_ERROR_LEVEL_SYNTAX },
@@ -238,12 +239,13 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_INVALID_NUMBER_OCTAL]               = { "invalid octal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER]    = { "invalid underscore placement in number", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_NUMBER_UNDERSCORE_TRAILING] = { "trailing '_' in number", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INVALID_CHARACTER]                  = { "invalid character 0x%X", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_CHARACTER]                  = { "Invalid char '\\x%02X' in expression", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_MULTIBYTE_CHAR]             = { "invalid multibyte char (%s)", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_MULTIBYTE_CHARACTER]        = { "invalid multibyte character 0x%X", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_MULTIBYTE_ESCAPE]           = { "invalid multibyte escape: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_PRINTABLE_CHARACTER]        = { "invalid character `%c`", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INVALID_PERCENT]                    = { "invalid `%` token", PM_ERROR_LEVEL_SYNTAX }, // TODO WHAT?
+    [PM_ERR_INVALID_PERCENT]                    = { "unknown type of %string", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_PERCENT_EOF]                = { "unterminated quoted string meets end of file", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_AFTER_ELSE]           = { "Invalid retry after else", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_AFTER_ENSURE]         = { "Invalid retry after ensure", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_WITHOUT_RESCUE]       = { "Invalid retry without rescue", PM_ERROR_LEVEL_SYNTAX },
@@ -251,7 +253,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_INVALID_VARIABLE_GLOBAL_3_3]        = { "`%.*s' is not allowed as a global variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_VARIABLE_GLOBAL]            = { "'%.*s' is not allowed as a global variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_YIELD]                      = { "Invalid yield", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_IT_NOT_ALLOWED_NUMBERED]            = { "`it` is not allowed when an numbered parameter is defined", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_IT_NOT_ALLOWED_NUMBERED]            = { "`it` is not allowed when a numbered parameter is already used", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_IT_NOT_ALLOWED_ORDINARY]            = { "`it` is not allowed when an ordinary parameter is defined", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_LAMBDA_OPEN]                        = { "expected a `do` keyword or a `{` to open the lambda block", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_LAMBDA_TERM_BRACE]                  = { "expected a lambda block beginning with `{` to end with `}`", PM_ERROR_LEVEL_SYNTAX },
@@ -274,9 +276,10 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_NOT_EXPRESSION]                     = { "expected an expression after `not`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NO_LOCAL_VARIABLE]                  = { "%.*s: no such local variable", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NUMBER_LITERAL_UNDERSCORE]          = { "number literal ending with a `_`", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_NUMBERED_PARAMETER_IT]              = { "numbered parameters are not allowed when an 'it' parameter is defined", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK]     = { "numbered parameter is already used in inner block", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_NUMBERED_PARAMETER_IT]              = { "numbered parameters are not allowed when 'it' is already used", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NUMBERED_PARAMETER_ORDINARY]        = { "numbered parameters are not allowed when an ordinary parameter is defined", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_NUMBERED_PARAMETER_OUTER_SCOPE]     = { "numbered parameter is already used in outer scope", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK]     = { "numbered parameter is already used in outer block", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_OPERATOR_MULTI_ASSIGN]              = { "unexpected operator for a multiple assignment", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_OPERATOR_WRITE_ARGUMENTS]           = { "unexpected operator after a call with arguments", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_OPERATOR_WRITE_BLOCK]               = { "unexpected operator after a call with a block", PM_ERROR_LEVEL_SYNTAX },
@@ -323,6 +326,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_REGEXP_INCOMPAT_CHAR_ENCODING]      = { "incompatible character encoding: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_REGEXP_NON_ESCAPED_MBC]             = { "/.../n has a non escaped non ASCII character in non ASCII-8BIT script: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_REGEXP_INVALID_UNICODE_RANGE]       = { "invalid Unicode range: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_REGEXP_PARSE_ERROR]                 = { "%s", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_REGEXP_UNKNOWN_OPTIONS]             = { "unknown regexp %s: %.*s", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_REGEXP_TERM]                        = { "unterminated regexp meets end of file; expected a closing delimiter", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_REGEXP_UTF8_CHAR_NON_UTF8_REGEXP]   = { "UTF-8 character in non UTF-8 regexp: /%s/", PM_ERROR_LEVEL_SYNTAX },
@@ -337,20 +341,20 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_STATEMENT_PREEXE_BEGIN]             = { "unexpected a `BEGIN` at a non-statement position", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_STATEMENT_UNDEF]                    = { "unexpected an `undef` at a non-statement position", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_STRING_CONCATENATION]               = { "expected a string for concatenation", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_STRING_INTERPOLATED_TERM]           = { "expected a closing delimiter for the interpolated string", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_STRING_INTERPOLATED_TERM]           = { "unterminated string; expected a closing delimiter for the interpolated string", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_STRING_LITERAL_EOF]                 = { "unterminated string meets end of file", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_STRING_LITERAL_TERM]                = { "unexpected %s, expected a string literal terminator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_SYMBOL_INVALID]                     = { "invalid symbol", PM_ERROR_LEVEL_SYNTAX }, // TODO expected symbol? prism.c ~9719
     [PM_ERR_SYMBOL_TERM_DYNAMIC]                = { "unterminated quoted string; expected a closing delimiter for the dynamic symbol", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_SYMBOL_TERM_INTERPOLATED]           = { "expected a closing delimiter for the interpolated symbol", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_SYMBOL_TERM_INTERPOLATED]           = { "unterminated symbol; expected a closing delimiter for the interpolated symbol", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_TERNARY_COLON]                      = { "expected a `:` after the true expression of a ternary operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_TERNARY_EXPRESSION_FALSE]           = { "expected an expression after `:` in the ternary operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_TERNARY_EXPRESSION_TRUE]            = { "expected an expression after `?` in the ternary operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNDEF_ARGUMENT]                     = { "invalid argument being passed to `undef`; expected a bare word, constant, or symbol argument", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNARY_RECEIVER]                     = { "unexpected %s, expected a receiver for unary `%c`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_BLOCK_ARGUMENT]          = { "block argument should not be given", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_UNEXPECTED_INDEX_BLOCK]             = { "unexpected block arg given in index; blocks are not allowed in index expressions", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_UNEXPECTED_INDEX_KEYWORDS]          = { "unexpected keyword arg given in index; keywords are not allowed in index expressions", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_UNEXPECTED_INDEX_BLOCK]             = { "unexpected block arg given in index assignment; blocks are not allowed in index assignment expressions", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_UNEXPECTED_INDEX_KEYWORDS]          = { "unexpected keyword arg given in index assignment; keywords are not allowed in index assignment expressions", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_SAFE_NAVIGATION]         = { "&. inside multiple assignment destination", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT]     = { "unexpected %s, assuming it is closing the parent %s", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_TOKEN_IGNORE]            = { "unexpected %s, ignoring it", PM_ERROR_LEVEL_SYNTAX },
@@ -363,6 +367,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_XSTRING_TERM]                       = { "expected a closing delimiter for the `%x` or backtick string", PM_ERROR_LEVEL_SYNTAX },
 
     // Warnings
+    [PM_WARN_AMBIGUOUS_BINARY_OPERATOR]         = { "'%s' after local variable or literal is interpreted as binary operator even though it seems like %s", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_MINUS]    = { "ambiguous first argument; put parentheses or a space even after `-` operator", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_PLUS]     = { "ambiguous first argument; put parentheses or a space even after `+` operator", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_AMBIGUOUS_PREFIX_AMPERSAND]        = { "ambiguous `&` has been interpreted as an argument prefix", PM_WARNING_LEVEL_VERBOSE },
@@ -372,7 +377,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_WARN_COMPARISON_AFTER_COMPARISON]       = { "comparison '%.*s' after comparison", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_DOT_DOT_DOT_EOL]                   = { "... at EOL, should be parenthesized?", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_DUPLICATED_HASH_KEY]               = { "key %.*s is duplicated and overwritten on line %" PRIi32, PM_WARNING_LEVEL_DEFAULT },
-    [PM_WARN_DUPLICATED_WHEN_CLAUSE]            = { "duplicated 'when' clause with line %" PRIi32 " is ignored", PM_WARNING_LEVEL_VERBOSE },
+    [PM_WARN_DUPLICATED_WHEN_CLAUSE]            = { "'when' clause on line %" PRIi32 " duplicates 'when' clause on line %" PRIi32 " and is ignored", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_EQUAL_IN_CONDITIONAL_3_3]          = { "found `= literal' in conditional, should be ==", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_EQUAL_IN_CONDITIONAL]              = { "found '= literal' in conditional, should be ==", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_END_IN_METHOD]                     = { "END in method; use at_exit", PM_WARNING_LEVEL_DEFAULT },
@@ -514,6 +519,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_EXPRESSION_NOT_WRITABLE_FILE: return "expression_not_writable_file";
         case PM_ERR_EXPRESSION_NOT_WRITABLE_LINE: return "expression_not_writable_line";
         case PM_ERR_EXPRESSION_NOT_WRITABLE_NIL: return "expression_not_writable_nil";
+        case PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED: return "expression_not_writable_numbered";
         case PM_ERR_EXPRESSION_NOT_WRITABLE_SELF: return "expression_not_writable_self";
         case PM_ERR_EXPRESSION_NOT_WRITABLE_TRUE: return "expression_not_writable_true";
         case PM_ERR_FLOAT_PARSE: return "float_parse";
@@ -553,6 +559,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER: return "invalid_number_underscore_inner";
         case PM_ERR_INVALID_NUMBER_UNDERSCORE_TRAILING: return "invalid_number_underscore_trailing";
         case PM_ERR_INVALID_PERCENT: return "invalid_percent";
+        case PM_ERR_INVALID_PERCENT_EOF: return "invalid_percent_eof";
         case PM_ERR_INVALID_PRINTABLE_CHARACTER: return "invalid_printable_character";
         case PM_ERR_INVALID_RETRY_AFTER_ELSE: return "invalid_retry_after_else";
         case PM_ERR_INVALID_RETRY_AFTER_ENSURE: return "invalid_retry_after_ensure";
@@ -584,9 +591,10 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_NO_LOCAL_VARIABLE: return "no_local_variable";
         case PM_ERR_NOT_EXPRESSION: return "not_expression";
         case PM_ERR_NUMBER_LITERAL_UNDERSCORE: return "number_literal_underscore";
+        case PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK: return "numbered_parameter_inner_block";
         case PM_ERR_NUMBERED_PARAMETER_IT: return "numbered_parameter_it";
         case PM_ERR_NUMBERED_PARAMETER_ORDINARY: return "numbered_parameter_ordinary";
-        case PM_ERR_NUMBERED_PARAMETER_OUTER_SCOPE: return "numbered_parameter_outer_scope";
+        case PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK: return "numbered_parameter_outer_block";
         case PM_ERR_OPERATOR_MULTI_ASSIGN: return "operator_multi_assign";
         case PM_ERR_OPERATOR_WRITE_ARGUMENTS: return "operator_write_arguments";
         case PM_ERR_OPERATOR_WRITE_BLOCK: return "operator_write_block";
@@ -603,8 +611,8 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_PARAMETER_SPLAT_MULTI: return "parameter_splat_multi";
         case PM_ERR_PARAMETER_STAR: return "parameter_star";
         case PM_ERR_PARAMETER_UNEXPECTED_FWD: return "parameter_unexpected_fwd";
-        case PM_ERR_PARAMETER_WILD_LOOSE_COMMA: return "parameter_wild_loose_comma";
         case PM_ERR_PARAMETER_UNEXPECTED_NO_KW: return "parameter_unexpected_no_kw";
+        case PM_ERR_PARAMETER_WILD_LOOSE_COMMA: return "parameter_wild_loose_comma";
         case PM_ERR_PATTERN_CAPTURE_DUPLICATE: return "pattern_capture_duplicate";
         case PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET: return "pattern_expression_after_bracket";
         case PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA: return "pattern_expression_after_comma";
@@ -633,6 +641,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_REGEXP_INCOMPAT_CHAR_ENCODING: return "regexp_incompat_char_encoding";
         case PM_ERR_REGEXP_INVALID_UNICODE_RANGE: return "regexp_invalid_unicode_range";
         case PM_ERR_REGEXP_NON_ESCAPED_MBC: return "regexp_non_escaped_mbc";
+        case PM_ERR_REGEXP_PARSE_ERROR: return "regexp_parse_error";
         case PM_ERR_REGEXP_TERM: return "regexp_term";
         case PM_ERR_REGEXP_UNKNOWN_OPTIONS: return "regexp_unknown_options";
         case PM_ERR_REGEXP_UTF8_CHAR_NON_UTF8_REGEXP: return "regexp_utf8_char_non_utf8_regexp";
@@ -672,6 +681,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_WRITE_TARGET_READONLY: return "write_target_readonly";
         case PM_ERR_WRITE_TARGET_UNEXPECTED: return "write_target_unexpected";
         case PM_ERR_XSTRING_TERM: return "xstring_term";
+        case PM_WARN_AMBIGUOUS_BINARY_OPERATOR: return "ambiguous_binary_operator";
         case PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_MINUS: return "ambiguous_first_argument_minus";
         case PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_PLUS: return "ambiguous_first_argument_plus";
         case PM_WARN_AMBIGUOUS_PREFIX_AMPERSAND: return "ambiguous_prefix_ampersand";