prism 0.17.1 → 0.18.0

data/rbi/prism.rbi

@@ -1025,6 +1025,56 @@ class Prism::CapturePatternNode < Prism::Node
   def inspect(inspector); end
 end
 
+# Represents the use of a case statement for pattern matching.
+#
+#     case true
+#     in false
+#     end
+#     ^^^^^^^^^
+class Prism::CaseMatchNode < Prism::Node
+  sig { returns(T.nilable(Prism::Node)) }
+  def predicate; end
+
+  sig { returns(T::Array[Prism::Node]) }
+  def conditions; end
+
+  sig { returns(T.nilable(Prism::ElseNode)) }
+  def consequent; end
+
+  sig { returns(Prism::Location) }
+  def case_keyword_loc; end
+
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  sig { params(predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::Node], consequent: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location, location: Prism::Location).void }
+  def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
+
+  sig { params(visitor: Prism::Visitor).void }
+  def accept(visitor); end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  sig { params(params: T.untyped).returns(Prism::CaseMatchNode) }
+  def copy(**params); end
+
+  sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
+  def deconstruct_keys(keys); end
+
+  sig { returns(String) }
+  def case_keyword; end
+
+  sig { returns(String) }
+  def end_keyword; end
+
+  sig { params(inspector: Prism::NodeInspector).returns(String) }
+  def inspect(inspector); end
+end
+
 # Represents the use of a case statement.
 #
 #     case true
@@ -2765,6 +2815,9 @@ class Prism::IfNode < Prism::Node
   sig { returns(Prism::Node) }
   def predicate; end
 
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_keyword_loc; end
+
   sig { returns(T.nilable(Prism::StatementsNode)) }
   def statements; end
 
@@ -2774,8 +2827,8 @@ class Prism::IfNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def end_keyword_loc; end
 
-  sig { params(if_keyword_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::Node), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void }
-  def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end
+  sig { params(if_keyword_loc: T.nilable(Prism::Location), predicate: Prism::Node, then_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::Node), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void }
+  def initialize(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -2797,6 +2850,9 @@ class Prism::IfNode < Prism::Node
   sig { returns(T.nilable(String)) }
   def if_keyword; end
 
+  sig { returns(T.nilable(String)) }
+  def then_keyword; end
+
   sig { returns(T.nilable(String)) }
   def end_keyword; end
 
@@ -4211,11 +4267,11 @@ class Prism::MatchWriteNode < Prism::Node
   sig { returns(Prism::CallNode) }
   def call; end
 
-  sig { returns(T::Array[Symbol]) }
-  def locals; end
+  sig { returns(T::Array[Prism::Node]) }
+  def targets; end
 
-  sig { params(call: Prism::CallNode, locals: T::Array[Symbol], location: Prism::Location).void }
-  def initialize(call, locals, location); end
+  sig { params(call: Prism::CallNode, targets: T::Array[Prism::Node], location: Prism::Location).void }
+  def initialize(call, targets, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -5651,39 +5707,6 @@ class Prism::StatementsNode < Prism::Node
   def inspect(inspector); end
 end
 
-# Represents the use of compile-time string concatenation.
-#
-#     "foo" "bar"
-#     ^^^^^^^^^^^
-class Prism::StringConcatNode < Prism::Node
-  sig { returns(Prism::Node) }
-  def left; end
-
-  sig { returns(Prism::Node) }
-  def right; end
-
-  sig { params(left: Prism::Node, right: Prism::Node, location: Prism::Location).void }
-  def initialize(left, right, location); end
-
-  sig { params(visitor: Prism::Visitor).void }
-  def accept(visitor); end
-
-  sig { returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  sig { returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  sig { params(params: T.untyped).returns(Prism::StringConcatNode) }
-  def copy(**params); end
-
-  sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))]) }
-  def deconstruct_keys(keys); end
-
-  sig { params(inspector: Prism::NodeInspector).returns(String) }
-  def inspect(inspector); end
-end
-
 # Represents a string literal, a string contained within a `%w` list, or
 # plain string content within an interpolated string.
 #
@@ -5927,6 +5950,9 @@ class Prism::UnlessNode < Prism::Node
   sig { returns(Prism::Node) }
   def predicate; end
 
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_keyword_loc; end
+
   sig { returns(T.nilable(Prism::StatementsNode)) }
   def statements; end
 
@@ -5936,8 +5962,8 @@ class Prism::UnlessNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def end_keyword_loc; end
 
-  sig { params(keyword_loc: Prism::Location, predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::ElseNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void }
-  def initialize(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end
+  sig { params(keyword_loc: Prism::Location, predicate: Prism::Node, then_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::ElseNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).void }
+  def initialize(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
 
   sig { params(visitor: Prism::Visitor).void }
   def accept(visitor); end
@@ -5959,6 +5985,9 @@ class Prism::UnlessNode < Prism::Node
   sig { returns(String) }
   def keyword; end
 
+  sig { returns(T.nilable(String)) }
+  def then_keyword; end
+
   sig { returns(T.nilable(String)) }
   def end_keyword; end
 
@@ -6370,6 +6399,10 @@ class Prism::Visitor < Prism::BasicVisitor
   sig { params(node: Prism::CapturePatternNode).void }
   def visit_capture_pattern_node(node); end
   
+  # Visit a CaseMatchNode node
+  sig { params(node: Prism::CaseMatchNode).void }
+  def visit_case_match_node(node); end
+  
   # Visit a CaseNode node
   sig { params(node: Prism::CaseNode).void }
   def visit_case_node(node); end
@@ -6810,10 +6843,6 @@ class Prism::Visitor < Prism::BasicVisitor
   sig { params(node: Prism::StatementsNode).void }
   def visit_statements_node(node); end
   
-  # Visit a StringConcatNode node
-  sig { params(node: Prism::StringConcatNode).void }
-  def visit_string_concat_node(node); end
-  
   # Visit a StringNode node
   sig { params(node: Prism::StringNode).void }
   def visit_string_node(node); end
@@ -6932,6 +6961,9 @@ module Prism::DSL
   # Create a new CapturePatternNode node
   sig { params(value: Prism::Node, target: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::CapturePatternNode) }
   def CapturePatternNode(value, target, operator_loc, location); end
+  # Create a new CaseMatchNode node
+  sig { params(predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::Node], consequent: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::CaseMatchNode) }
+  def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
   # Create a new CaseNode node
   sig { params(predicate: T.nilable(Prism::Node), conditions: T::Array[Prism::Node], consequent: T.nilable(Prism::ElseNode), case_keyword_loc: Prism::Location, end_keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::CaseNode) }
   def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
@@ -7059,8 +7091,8 @@ module Prism::DSL
   sig { params(constant: T.nilable(Prism::Node), elements: T::Array[Prism::Node], rest: T.nilable(Prism::Node), opening_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::HashPatternNode) }
   def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location); end
   # Create a new IfNode node
-  sig { params(if_keyword_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::Node), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::IfNode) }
-  def IfNode(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end
+  sig { params(if_keyword_loc: T.nilable(Prism::Location), predicate: Prism::Node, then_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::Node), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::IfNode) }
+  def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
   # Create a new ImaginaryNode node
   sig { params(numeric: Prism::Node, location: Prism::Location).returns(Prism::ImaginaryNode) }
   def ImaginaryNode(numeric, location); end
@@ -7152,8 +7184,8 @@ module Prism::DSL
   sig { params(value: Prism::Node, pattern: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).returns(Prism::MatchRequiredNode) }
   def MatchRequiredNode(value, pattern, operator_loc, location); end
   # Create a new MatchWriteNode node
-  sig { params(call: Prism::CallNode, locals: T::Array[Symbol], location: Prism::Location).returns(Prism::MatchWriteNode) }
-  def MatchWriteNode(call, locals, location); end
+  sig { params(call: Prism::CallNode, targets: T::Array[Prism::Node], location: Prism::Location).returns(Prism::MatchWriteNode) }
+  def MatchWriteNode(call, targets, location); end
   # Create a new MissingNode node
   sig { params(location: Prism::Location).returns(Prism::MissingNode) }
   def MissingNode(location); end
@@ -7262,9 +7294,6 @@ module Prism::DSL
   # Create a new StatementsNode node
   sig { params(body: T::Array[Prism::Node], location: Prism::Location).returns(Prism::StatementsNode) }
   def StatementsNode(body, location); end
-  # Create a new StringConcatNode node
-  sig { params(left: Prism::Node, right: Prism::Node, location: Prism::Location).returns(Prism::StringConcatNode) }
-  def StringConcatNode(left, right, location); end
   # Create a new StringNode node
   sig { params(flags: Integer, opening_loc: T.nilable(Prism::Location), content_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), unescaped: String, location: Prism::Location).returns(Prism::StringNode) }
   def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
@@ -7281,8 +7310,8 @@ module Prism::DSL
   sig { params(names: T::Array[Prism::Node], keyword_loc: Prism::Location, location: Prism::Location).returns(Prism::UndefNode) }
   def UndefNode(names, keyword_loc, location); end
   # Create a new UnlessNode node
-  sig { params(keyword_loc: Prism::Location, predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::ElseNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::UnlessNode) }
-  def UnlessNode(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end
+  sig { params(keyword_loc: Prism::Location, predicate: Prism::Node, then_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode), consequent: T.nilable(Prism::ElseNode), end_keyword_loc: T.nilable(Prism::Location), location: Prism::Location).returns(Prism::UnlessNode) }
+  def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
   # Create a new UntilNode node
   sig { params(keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode), flags: Integer, location: Prism::Location).returns(Prism::UntilNode) }
   def UntilNode(keyword_loc, closing_loc, predicate, statements, flags, location); end

data/sig/prism.rbs

@@ -605,6 +605,35 @@ module Prism
 
     def inspect: (inspector: NodeInspector) -> String
   end
+  # Represents the use of a case statement for pattern matching.
+  #
+  #     case true
+  #     in false
+  #     end
+  #     ^^^^^^^^^
+  class CaseMatchNode < Node
+    attr_reader predicate: Node?
+    attr_reader conditions: Array[Node]
+    attr_reader consequent: ElseNode?
+    attr_reader case_keyword_loc: Location
+    attr_reader end_keyword_loc: Location
+
+    def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> CaseMatchNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def case_keyword: () -> String
+
+    def end_keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
   # Represents the use of a case statement.
   #
   #     case true
@@ -1632,11 +1661,12 @@ module Prism
   class IfNode < Node
     attr_reader if_keyword_loc: Location?
     attr_reader predicate: Node
+    attr_reader then_keyword_loc: Location?
     attr_reader statements: StatementsNode?
     attr_reader consequent: Node?
     attr_reader end_keyword_loc: Location?
 
-    def initialize: (if_keyword_loc: Location?, predicate: Node, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
+    def initialize: (if_keyword_loc: Location?, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
     def accept: (visitor: Visitor) -> void
     def set_newline_flag: (newline_marked: Array[bool]) -> void
     def child_nodes: () -> Array[Node?]
@@ -1648,6 +1678,8 @@ module Prism
 
     def if_keyword: () -> String?
 
+    def then_keyword: () -> String?
+
     def end_keyword: () -> String?
 
     def inspect: (inspector: NodeInspector) -> String
@@ -2471,9 +2503,9 @@ module Prism
   #     ^^^^^^^^^^^^^^^^^^^^
   class MatchWriteNode < Node
     attr_reader call: CallNode
-    attr_reader locals: Array[Symbol]
+    attr_reader targets: Array[Node]
 
-    def initialize: (call: CallNode, locals: Array[Symbol], location: Location) -> void
+    def initialize: (call: CallNode, targets: Array[Node], location: Location) -> void
     def accept: (visitor: Visitor) -> void
     def set_newline_flag: (newline_marked: Array[bool]) -> void
     def child_nodes: () -> Array[Node?]
@@ -3334,26 +3366,6 @@ module Prism
 
     def inspect: (inspector: NodeInspector) -> String
   end
-  # Represents the use of compile-time string concatenation.
-  #
-  #     "foo" "bar"
-  #     ^^^^^^^^^^^
-  class StringConcatNode < Node
-    attr_reader left: Node
-    attr_reader right: Node
-
-    def initialize: (left: Node, right: 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) -> StringConcatNode
-
-    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
-
-    def inspect: (inspector: NodeInspector) -> String
-  end
   # Represents a string literal, a string contained within a `%w` list, or
   # plain string content within an interpolated string.
   #
@@ -3505,11 +3517,12 @@ module Prism
   class UnlessNode < Node
     attr_reader keyword_loc: Location
     attr_reader predicate: Node
+    attr_reader then_keyword_loc: Location?
     attr_reader statements: StatementsNode?
     attr_reader consequent: ElseNode?
     attr_reader end_keyword_loc: Location?
 
-    def initialize: (keyword_loc: Location, predicate: Node, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void
+    def initialize: (keyword_loc: Location, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void
     def accept: (visitor: Visitor) -> void
     def set_newline_flag: (newline_marked: Array[bool]) -> void
     def child_nodes: () -> Array[Node?]
@@ -3521,6 +3534,8 @@ module Prism
 
     def keyword: () -> String
 
+    def then_keyword: () -> String?
+
     def end_keyword: () -> String?
 
     def inspect: (inspector: NodeInspector) -> String
@@ -3803,6 +3818,9 @@ module Prism
     # Visit a CapturePatternNode node
     def visit_capture_pattern_node: (node: CapturePatternNode) -> void
     
+    # Visit a CaseMatchNode node
+    def visit_case_match_node: (node: CaseMatchNode) -> void
+    
     # Visit a CaseNode node
     def visit_case_node: (node: CaseNode) -> void
     
@@ -4133,9 +4151,6 @@ module Prism
     # Visit a StatementsNode node
     def visit_statements_node: (node: StatementsNode) -> void
     
-    # Visit a StringConcatNode node
-    def visit_string_concat_node: (node: StringConcatNode) -> void
-    
     # Visit a StringNode node
     def visit_string_node: (node: StringNode) -> void
     
@@ -4220,6 +4235,8 @@ module Prism
     def CallOrWriteNode: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> CallOrWriteNode
     # Create a new CapturePatternNode node
     def CapturePatternNode: (value: Node, target: Node, operator_loc: Location, location: Location) -> CapturePatternNode
+    # Create a new CaseMatchNode node
+    def CaseMatchNode: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> CaseMatchNode
     # Create a new CaseNode node
     def CaseNode: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> CaseNode
     # Create a new ClassNode node
@@ -4305,7 +4322,7 @@ module Prism
     # Create a new HashPatternNode node
     def HashPatternNode: (constant: Node?, elements: Array[Node], rest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> HashPatternNode
     # Create a new IfNode node
-    def IfNode: (if_keyword_loc: Location?, predicate: Node, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> IfNode
+    def IfNode: (if_keyword_loc: Location?, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> IfNode
     # Create a new ImaginaryNode node
     def ImaginaryNode: (numeric: Node, location: Location) -> ImaginaryNode
     # Create a new ImplicitNode node
@@ -4367,7 +4384,7 @@ module Prism
     # Create a new MatchRequiredNode node
     def MatchRequiredNode: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> MatchRequiredNode
     # Create a new MatchWriteNode node
-    def MatchWriteNode: (call: CallNode, locals: Array[Symbol], location: Location) -> MatchWriteNode
+    def MatchWriteNode: (call: CallNode, targets: Array[Node], location: Location) -> MatchWriteNode
     # Create a new MissingNode node
     def MissingNode: (location: Location) -> MissingNode
     # Create a new ModuleNode node
@@ -4440,8 +4457,6 @@ module Prism
     def SplatNode: (operator_loc: Location, expression: Node?, location: Location) -> SplatNode
     # Create a new StatementsNode node
     def StatementsNode: (body: Array[Node], location: Location) -> StatementsNode
-    # Create a new StringConcatNode node
-    def StringConcatNode: (left: Node, right: Node, location: Location) -> StringConcatNode
     # Create a new StringNode node
     def StringNode: (flags: Integer, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location) -> StringNode
     # Create a new SuperNode node
@@ -4453,7 +4468,7 @@ module Prism
     # Create a new UndefNode node
     def UndefNode: (names: Array[Node], keyword_loc: Location, location: Location) -> UndefNode
     # Create a new UnlessNode node
-    def UnlessNode: (keyword_loc: Location, predicate: Node, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> UnlessNode
+    def UnlessNode: (keyword_loc: Location, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> UnlessNode
     # Create a new UntilNode node
     def UntilNode: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> UntilNode
     # Create a new WhenNode node

data/src/diagnostic.c

@@ -54,12 +54,14 @@ static const char* const diagnostic_messages[PM_DIAGNOSTIC_ID_LEN] = {
     [PM_ERR_ALIAS_ARGUMENT]                     = "Invalid argument being passed to `alias`; expected a bare word, symbol, constant, or global variable",
     [PM_ERR_AMPAMPEQ_MULTI_ASSIGN]              = "Unexpected `&&=` in a multiple assignment",
     [PM_ERR_ARGUMENT_AFTER_BLOCK]               = "Unexpected argument after a block argument",
+    [PM_ERR_ARGUMENT_AFTER_FORWARDING_ELLIPSES] = "Unexpected argument after `...`",
     [PM_ERR_ARGUMENT_BARE_HASH]                 = "Unexpected bare hash argument",
     [PM_ERR_ARGUMENT_BLOCK_MULTI]               = "Multiple block arguments; only one block is allowed",
     [PM_ERR_ARGUMENT_FORMAL_CLASS]              = "Invalid formal argument; formal argument cannot be a class variable",
     [PM_ERR_ARGUMENT_FORMAL_CONSTANT]           = "Invalid formal argument; formal argument cannot be a constant",
     [PM_ERR_ARGUMENT_FORMAL_GLOBAL]             = "Invalid formal argument; formal argument cannot be a global variable",
     [PM_ERR_ARGUMENT_FORMAL_IVAR]               = "Invalid formal argument; formal argument cannot be an instance variable",
+    [PM_ERR_ARGUMENT_FORWARDING_UNBOUND]        = "Unexpected `...` in an non-parenthesized call",
     [PM_ERR_ARGUMENT_NO_FORWARDING_AMP]         = "Unexpected `&` when the parent method is not forwarding",
     [PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES]    = "Unexpected `...` when the parent method is not forwarding",
     [PM_ERR_ARGUMENT_NO_FORWARDING_STAR]        = "Unexpected `*` when the parent method is not forwarding",
@@ -85,6 +87,7 @@ static const char* const diagnostic_messages[PM_DIAGNOSTIC_ID_LEN] = {
     [PM_ERR_CANNOT_PARSE_STRING_PART]           = "Cannot parse the string part",
     [PM_ERR_CASE_EXPRESSION_AFTER_CASE]         = "Expected an expression after `case`",
     [PM_ERR_CASE_EXPRESSION_AFTER_WHEN]         = "Expected an expression after `when`",
+    [PM_ERR_CASE_MATCH_MISSING_PREDICATE]       = "Expected a predicate for a case matching statement",
     [PM_ERR_CASE_MISSING_CONDITIONS]            = "Expected a `when` or `in` clause after `case`",
     [PM_ERR_CASE_TERM]                          = "Expected an `end` to close the `case` statement",
     [PM_ERR_CLASS_IN_METHOD]                    = "Unexpected class definition in a method body",
@@ -199,7 +202,7 @@ static const char* const diagnostic_messages[PM_DIAGNOSTIC_ID_LEN] = {
     [PM_ERR_PARAMETER_NAME_REPEAT]              = "Repeated parameter name",
     [PM_ERR_PARAMETER_NO_DEFAULT]               = "Expected a default value for the parameter",
     [PM_ERR_PARAMETER_NO_DEFAULT_KW]            = "Expected a default value for the keyword parameter",
-    [PM_ERR_PARAMETER_NUMBERED_RESERVED]        = "Token reserved for a numbered parameter",
+    [PM_ERR_PARAMETER_NUMBERED_RESERVED]        = "%.2s is reserved for a numbered parameter",
     [PM_ERR_PARAMETER_ORDER]                    = "Unexpected parameter order",
     [PM_ERR_PARAMETER_SPLAT_MULTI]              = "Unexpected multiple `*` splat parameters",
     [PM_ERR_PARAMETER_STAR]                     = "Unexpected parameter `*`",
@@ -244,6 +247,7 @@ static const char* const diagnostic_messages[PM_DIAGNOSTIC_ID_LEN] = {
     [PM_ERR_UNARY_RECEIVER_PLUS]                = "Expected a receiver for unary `+`",
     [PM_ERR_UNARY_RECEIVER_TILDE]               = "Expected a receiver for unary `~`",
     [PM_ERR_UNTIL_TERM]                         = "Expected an `end` to close the `until` statement",
+    [PM_ERR_VOID_EXPRESSION]                    = "Unexpected void value expression",
     [PM_ERR_WHILE_TERM]                         = "Expected an `end` to close the `while` statement",
     [PM_ERR_WRITE_TARGET_READONLY]              = "Immutable variable as a write target",
     [PM_ERR_WRITE_TARGET_UNEXPECTED]            = "Unexpected write target",
@@ -252,13 +256,16 @@ static const char* const diagnostic_messages[PM_DIAGNOSTIC_ID_LEN] = {
     [PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_PLUS]     = "Ambiguous first argument; put parentheses or a space even after `+` operator",
     [PM_WARN_AMBIGUOUS_PREFIX_STAR]             = "Ambiguous `*` has been interpreted as an argument prefix",
     [PM_WARN_AMBIGUOUS_SLASH]                   = "Ambiguous `/`; wrap regexp in parentheses or add a space after `/` operator",
+    [PM_WARN_END_IN_METHOD]                     = "END in method; use at_exit",
 };
 
 static const char*
 pm_diagnostic_message(pm_diagnostic_id_t diag_id) {
     assert(diag_id < PM_DIAGNOSTIC_ID_LEN);
+
     const char *message = diagnostic_messages[diag_id];
     assert(message);
+
     return message;
 }
 
@@ -270,7 +277,57 @@ pm_diagnostic_list_append(pm_list_t *list, const uint8_t *start, const uint8_t *
     pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) calloc(sizeof(pm_diagnostic_t), 1);
     if (diagnostic == NULL) return false;
 
-    *diagnostic = (pm_diagnostic_t) { .start = start, .end = end, .message = pm_diagnostic_message(diag_id) };
+    *diagnostic = (pm_diagnostic_t) {
+        .start = start,
+        .end = end,
+        .message = pm_diagnostic_message(diag_id),
+        .owned = false
+    };
+
+    pm_list_append(list, (pm_list_node_t *) diagnostic);
+    return true;
+}
+
+/**
+ * Append a diagnostic to the given list of diagnostics that is using a format
+ * string for its message.
+ */
+bool
+pm_diagnostic_list_append_format(pm_list_t *list, const uint8_t *start, const uint8_t *end, pm_diagnostic_id_t diag_id, ...) {
+    va_list arguments;
+    va_start(arguments, diag_id);
+
+    const char *format = pm_diagnostic_message(diag_id);
+    int result = vsnprintf(NULL, 0, format, arguments);
+    va_end(arguments);
+
+    if (result < 0) {
+        return false;
+    }
+
+    pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) calloc(sizeof(pm_diagnostic_t), 1);
+    if (diagnostic == NULL) {
+        return false;
+    }
+
+    size_t length = (size_t) (result + 1);
+    char *message = (char *) malloc(length);
+    if (message == NULL) {
+        free(diagnostic);
+        return false;
+    }
+
+    va_start(arguments, diag_id);
+    vsnprintf(message, length, format, arguments);
+    va_end(arguments);
+
+    *diagnostic = (pm_diagnostic_t) {
+        .start = start,
+        .end = end,
+        .message = message,
+        .owned = true
+    };
+
     pm_list_append(list, (pm_list_node_t *) diagnostic);
     return true;
 }
@@ -284,8 +341,9 @@ pm_diagnostic_list_free(pm_list_t *list) {
 
     for (node = list->head; node != NULL; node = next) {
         next = node->next;
-
         pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) node;
+
+        if (diagnostic->owned) free((void *) diagnostic->message);
         free(diagnostic);
     }
 }

data/src/enc/pm_big5.c

@@ -15,6 +15,22 @@ pm_encoding_big5_char_width(const uint8_t *b, ptrdiff_t n) {
     return 0;
 }
 
+static size_t
+pm_encoding_big5_star_char_width(const uint8_t *b, ptrdiff_t n) {
+    // These are the single byte characters.
+    if (*b < 0x80) {
+        return 1;
+    }
+
+    // These are the double byte characters.
+    if ((n > 1) && (b[0] >= 0x87 && b[0] <= 0xFE) &&
+                   ((b[1] >= 0x40 && b[1] <= 0x7E) || (b[1] >= 0xA1 && b[1] <= 0xFE))) {
+        return 2;
+    }
+
+    return 0;
+}
+
 static size_t
 pm_encoding_big5_alpha_char(const uint8_t *b, ptrdiff_t n) {
     if (pm_encoding_big5_char_width(b, n) == 1) {
@@ -24,6 +40,15 @@ pm_encoding_big5_alpha_char(const uint8_t *b, ptrdiff_t n) {
     }
 }
 
+static size_t
+pm_encoding_big5_star_alpha_char(const uint8_t *b, ptrdiff_t n) {
+    if (pm_encoding_big5_star_char_width(b, n) == 1) {
+        return pm_encoding_ascii_alpha_char(b, n);
+    } else {
+        return 0;
+    }
+}
+
 static size_t
 pm_encoding_big5_alnum_char(const uint8_t *b, ptrdiff_t n) {
     if (pm_encoding_big5_char_width(b, n) == 1) {
@@ -33,6 +58,15 @@ pm_encoding_big5_alnum_char(const uint8_t *b, ptrdiff_t n) {
     }
 }
 
+static size_t
+pm_encoding_big5_star_alnum_char(const uint8_t *b, ptrdiff_t n) {
+    if (pm_encoding_big5_star_char_width(b, n) == 1) {
+        return pm_encoding_ascii_alnum_char(b, n);
+    } else {
+        return 0;
+    }
+}
+
 static bool
 pm_encoding_big5_isupper_char(const uint8_t *b, ptrdiff_t n) {
     if (pm_encoding_big5_char_width(b, n) == 1) {
@@ -42,6 +76,15 @@ pm_encoding_big5_isupper_char(const uint8_t *b, ptrdiff_t n) {
     }
 }
 
+static bool
+pm_encoding_big5_star_isupper_char(const uint8_t *b, ptrdiff_t n) {
+    if (pm_encoding_big5_star_char_width(b, n) == 1) {
+        return pm_encoding_ascii_isupper_char(b, n);
+    } else {
+        return false;
+    }
+}
+
 /** Big5 encoding */
 pm_encoding_t pm_encoding_big5 = {
     .name = "big5",
@@ -51,3 +94,23 @@ pm_encoding_t pm_encoding_big5 = {
     .isupper_char = pm_encoding_big5_isupper_char,
     .multibyte = true
 };
+
+/** Big5-HKSCS encoding */
+pm_encoding_t pm_encoding_big5_hkscs = {
+    .name = "big5-hkscs",
+    .char_width = pm_encoding_big5_star_char_width,
+    .alnum_char = pm_encoding_big5_star_alnum_char,
+    .alpha_char = pm_encoding_big5_star_alpha_char,
+    .isupper_char = pm_encoding_big5_star_isupper_char,
+    .multibyte = true
+};
+
+/** Big5-UAO encoding */
+pm_encoding_t pm_encoding_big5_uao = {
+    .name = "big5-uao",
+    .char_width = pm_encoding_big5_star_char_width,
+    .alnum_char = pm_encoding_big5_star_alnum_char,
+    .alpha_char = pm_encoding_big5_star_alpha_char,
+    .isupper_char = pm_encoding_big5_star_isupper_char,
+    .multibyte = true
+};