prism 0.17.0 → 0.18.0

data/rbi/prism_static.rbi

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

data/sig/prism.rbs

@@ -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);
     }
 }