prism 2.0.0.rc1-arm-linux-gnu → 2.1.0-arm-linux-gnu

data/include/prism/buffer.h

@@ -12,6 +12,10 @@
 
 #include <stddef.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * A wrapper around a contiguous block of allocated memory.
  */
@@ -49,4 +53,8 @@ PRISM_EXPORTED_FUNCTION char * pm_buffer_value(const pm_buffer_t *buffer) PRISM_
  */
 PRISM_EXPORTED_FUNCTION size_t pm_buffer_length(const pm_buffer_t *buffer) PRISM_NONNULL(1);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/include/prism/buffer.hpp

@@ -0,0 +1,55 @@
+/**
+ * @file buffer.hpp
+ *
+ * Ownership of buffers from C++, and access to their contents.
+ */
+#ifndef PRISM_BUFFER_HPP
+#define PRISM_BUFFER_HPP
+
+#include "prism/compiler/cplusplus.hpp"
+#include "prism/compiler/lifetimebound.hpp"
+
+#include "prism/buffer.h"
+
+#include <memory>
+#include <string_view>
+
+namespace prism {
+
+/** Frees a buffer with pm_buffer_free. */
+struct buffer_deleter {
+    /**
+     * Frees the given buffer.
+     *
+     * @param buffer The buffer to free.
+     */
+    void operator()(pm_buffer_t *buffer) const noexcept { pm_buffer_free(buffer); }
+};
+
+/** An owned buffer. */
+using unique_buffer = std::unique_ptr<pm_buffer_t, buffer_deleter>;
+
+/**
+ * Allocate a new empty buffer. Allocation failure aborts, so this never throws.
+ *
+ * @return A unique_buffer managing the newly allocated buffer.
+ */
+[[nodiscard]] inline unique_buffer
+make_buffer() noexcept {
+    return unique_buffer(pm_buffer_new());
+}
+
+/**
+ * The bytes written to the given buffer so far.
+ *
+ * @param buffer The buffer to view.
+ * @return A string_view of the contents of the buffer.
+ */
+[[nodiscard]] inline std::string_view
+view(const pm_buffer_t *buffer PRISM_LIFETIMEBOUND) noexcept {
+    return std::string_view(pm_buffer_value(buffer), pm_buffer_length(buffer));
+}
+
+}
+
+#endif

data/include/prism/comments.h

@@ -14,6 +14,10 @@
 
 #include <stddef.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** This is the type of a comment that we've found while parsing. */
 typedef enum {
     PM_COMMENT_INLINE,
@@ -52,4 +56,17 @@ PRISM_EXPORTED_FUNCTION pm_location_t pm_comment_location(const pm_comment_t *co
  */
 PRISM_EXPORTED_FUNCTION pm_comment_type_t pm_comment_type(const pm_comment_t *comment) PRISM_NONNULL(1);
 
+/**
+ * Returns the comment that follows the given comment among the comments
+ * associated with the parser that found it.
+ *
+ * @param comment the comment whose successor we want to get
+ * @returns the next comment, or NULL if the given comment is the last one
+ */
+PRISM_EXPORTED_FUNCTION const pm_comment_t * pm_comment_next(const pm_comment_t *comment) PRISM_NONNULL(1);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/include/prism/compiler/accel.h

@@ -4,6 +4,8 @@
 #ifndef PRISM_COMPILER_ACCEL_H
 #define PRISM_COMPILER_ACCEL_H
 
+#include "prism/compiler/endianness.h"
+
 /**
  * Platform detection for SIMD/fast-path implementations. At most one of these
  * macros is defined, selecting the best available vectorization strategy.
@@ -17,7 +19,7 @@
 #   define PRISM_HAS_NEON
 #elif (defined(__x86_64__) && defined(__SSE2__)) || (defined(_MSC_VER) && defined(_M_X64))
 #   define PRISM_HAS_SSE2
-#elif defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#elif defined(PRISM_LITTLE_ENDIAN_COMPTIME)
 #   define PRISM_HAS_SWAR
 #endif
 

data/include/prism/compiler/branch.h

@@ -0,0 +1,26 @@
+/**
+ * @file compiler/branch.h
+ */
+#ifndef PRISM_COMPILER_BRANCH_H
+#define PRISM_COMPILER_BRANCH_H
+
+/**
+ * Branch prediction hints. These tell the compiler which side of a branch to
+ * predicate the fast path through, so it can lay out instructions to favour
+ * that side and steer the static branch predictor.
+ */
+#if defined(__GNUC__) || defined(__clang__)
+    /** The compiler should predicate that this branch will be taken. */
+    #define PRISM_LIKELY(x) __builtin_expect(!!(x), 1)
+
+    /** The compiler should predicate that this branch will not be taken. */
+    #define PRISM_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+    /** Void because this platform does not support branch prediction hints. */
+    #define PRISM_LIKELY(x)   (x)
+
+    /** Void because this platform does not support branch prediction hints. */
+    #define PRISM_UNLIKELY(x) (x)
+#endif
+
+#endif

data/include/prism/compiler/bswap.h

@@ -0,0 +1,46 @@
+/**
+ * @file compiler/bswap.h
+ */
+#ifndef PRISM_COMPILER_BSWAP_H
+#define PRISM_COMPILER_BSWAP_H
+
+/**
+ * Byte swap utilities for 32-bit and 64-bit integers.
+ */
+#if defined(__GNUC__) || defined(__clang__)
+#define pm_bswap32(x_) __builtin_bswap32((x_))
+#define pm_bswap64(x_) __builtin_bswap64((x_))
+#elif defined(_MSC_VER)
+#include <stdlib.h>
+
+#define pm_bswap32(x_) _byteswap_ulong((x_))
+#define pm_bswap64(x_) _byteswap_uint64((x_))
+#else
+#include <stdint.h>
+
+static uint32_t
+pm_bswap32(uint32_t x) {
+    return (
+      ((x >> 24) & 0x000000FFUL) |
+      ((x << 24) & 0xFF000000UL) |
+      ((x >> 8)  & 0x0000FF00UL) |
+      ((x << 8)  & 0x00FF0000UL)
+    );
+}
+
+static uint64_t
+pm_bswap64(uint64_t x) {
+    return (
+      ((x >> 56) & 0x00000000000000FFULL) |
+      ((x << 56) & 0xFF00000000000000ULL) |
+      ((x >> 40) & 0x000000000000FF00ULL) |
+      ((x << 40) & 0x00FF000000000000ULL) |
+      ((x >> 24) & 0x0000000000FF0000ULL) |
+      ((x << 24) & 0x0000FF0000000000ULL) |
+      ((x >> 8)  & 0x00000000FF000000ULL) |
+      ((x << 8)  & 0x000000FF00000000ULL)
+    );
+}
+#endif
+
+#endif

data/include/prism/compiler/cplusplus.hpp

@@ -0,0 +1,16 @@
+/**
+ * @file compiler/cplusplus.hpp
+ */
+#ifndef PRISM_COMPILER_CPLUSPLUS_HPP
+#define PRISM_COMPILER_CPLUSPLUS_HPP
+
+/**
+ * The C++ interface relies on C++17 for inline variables, std::string_view,
+ * std::void_t, and std::is_invocable_r_v. MSVC reports __cplusplus as 199711L
+ * unless /Zc:__cplusplus is passed, so its own _MSVC_LANG is checked as well.
+ */
+#if !defined(__cplusplus) || ((__cplusplus < 201703L) && (!defined(_MSVC_LANG) || (_MSVC_LANG < 201703L)))
+#   error "the prism C++ interface requires C++17 or later"
+#endif
+
+#endif

data/include/prism/compiler/endianness.h

@@ -0,0 +1,34 @@
+/**
+ * @file compiler/endianness.h
+ */
+#ifndef PRISM_COMPILER_ENDIANNESS_H
+#define PRISM_COMPILER_ENDIANNESS_H
+
+/**
+ * Detect endianness at compile-time through the use of predefined macros.
+ */
+#if defined(_WIN32) || defined(__LITTLE_ENDIAN__) || (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define PRISM_LITTLE_ENDIAN_COMPTIME
+#endif
+
+/**
+ * Determine endianness at runtime, either through predefined macros or through
+ * a runtime check that is usually folded.
+ */
+#if defined(PRISM_LITTLE_ENDIAN_COMPTIME)
+#define PRISM_LITTLE_ENDIAN_RUNTIME 1
+#elif defined(__BIG_ENDIAN__) || (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define PRISM_LITTLE_ENDIAN_RUNTIME 0
+#else
+#include <stdint.h>
+
+static inline int
+pm_little_endian(void) {
+    const union { uint32_t u; uint8_t c[4]; } one = { 1 };
+    return one.c[0];
+}
+
+#define PRISM_LITTLE_ENDIAN_RUNTIME pm_little_endian()
+#endif
+
+#endif

data/include/prism/compiler/exceptions.hpp

@@ -0,0 +1,17 @@
+/**
+ * @file compiler/exceptions.hpp
+ */
+#ifndef PRISM_COMPILER_EXCEPTIONS_HPP
+#define PRISM_COMPILER_EXCEPTIONS_HPP
+
+/**
+ * Defined when C++ exceptions are enabled, so that code which catches them can
+ * still compile in builds that disable them, such as with -fno-exceptions.
+ * __cpp_exceptions is the standard feature test macro, and older versions of
+ * GCC and MSVC define __EXCEPTIONS and _CPPUNWIND instead.
+ */
+#if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)
+#   define PRISM_HAS_EXCEPTIONS
+#endif
+
+#endif

data/include/prism/compiler/format.h

@@ -4,6 +4,8 @@
 #ifndef PRISM_COMPILER_FORMAT_H
 #define PRISM_COMPILER_FORMAT_H
 
+#include <stdio.h>
+
 /**
  * Certain compilers support specifying that a function accepts variadic
  * parameters that look like printf format strings to provide a better developer

data/include/prism/compiler/lifetimebound.hpp

@@ -0,0 +1,25 @@
+/**
+ * @file compiler/lifetimebound.hpp
+ */
+#ifndef PRISM_COMPILER_LIFETIMEBOUND_HPP
+#define PRISM_COMPILER_LIFETIMEBOUND_HPP
+
+/**
+ * Mark a parameter that the return value points into, so that the compiler
+ * warns if a temporary is passed and the return value outlives it. If it is
+ * placed after the qualifiers of a member function, it marks the object
+ * instead.
+ */
+#if defined(__has_cpp_attribute)
+#   if __has_cpp_attribute(clang::lifetimebound)
+#       define PRISM_LIFETIMEBOUND [[clang::lifetimebound]]
+#   elif __has_cpp_attribute(msvc::lifetimebound)
+#       define PRISM_LIFETIMEBOUND [[msvc::lifetimebound]]
+#   endif
+#endif
+
+#ifndef PRISM_LIFETIMEBOUND
+#   define PRISM_LIFETIMEBOUND
+#endif
+
+#endif

data/include/prism/constant_pool.h

@@ -11,6 +11,7 @@
 #define PRISM_CONSTANT_POOL_H
 
 #include "prism/compiler/exported.h"
+#include "prism/compiler/inline.h"
 #include "prism/compiler/nodiscard.h"
 #include "prism/compiler/nonnull.h"
 
@@ -19,11 +20,31 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * A constant id is a unique identifier for a constant in the constant pool.
  */
 typedef uint32_t pm_constant_id_t;
 
+/**
+ * Returns the index of the constant with the given id among the constants of
+ * the parser that produced it. The indices run from 0 to one less than
+ * pm_parser_constants_size, so they can index a cache with one entry per
+ * constant that was filled using pm_parser_constant_at.
+ *
+ * @param constant_id the id of the constant. Optional constant fields on nodes
+ *     hold 0 when they are absent, which is not a valid id, so check for it
+ *     before calling this function.
+ * @returns the index of the constant
+ */
+static PRISM_INLINE size_t
+pm_constant_id_index(pm_constant_id_t constant_id) {
+    return (size_t) constant_id - 1;
+}
+
 /**
  * A list of constant IDs. Usually used to represent a set of locals.
  */
@@ -78,4 +99,8 @@ PRISM_EXPORTED_FUNCTION void pm_constant_id_list_init(pm_constant_id_list_t *lis
  */
 PRISM_EXPORTED_FUNCTION void pm_constant_id_list_append(pm_arena_t *arena, pm_constant_id_list_t *list, pm_constant_id_t id) PRISM_NONNULL(1, 2);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/include/prism/diagnostic.h

@@ -12,6 +12,10 @@
 
 #include "prism/ast.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * An opaque pointer to a diagnostic generated during parsing.
  */
@@ -90,4 +94,18 @@ PRISM_EXPORTED_FUNCTION pm_error_level_t pm_diagnostic_error_level(const pm_diag
  */
 PRISM_EXPORTED_FUNCTION pm_warning_level_t pm_diagnostic_warning_level(const pm_diagnostic_t *diagnostic) PRISM_NONNULL(1);
 
+/**
+ * Get the diagnostic that follows the given diagnostic among the errors or the
+ * warnings of the parser that produced it.
+ *
+ * @param diagnostic The diagnostic to get the successor of.
+ * @returns The next diagnostic of the same kind, or NULL if the given
+ *     diagnostic is the last one.
+ */
+PRISM_EXPORTED_FUNCTION const pm_diagnostic_t * pm_diagnostic_next(const pm_diagnostic_t *diagnostic) PRISM_NONNULL(1);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/include/prism/errors_format.h

@@ -14,6 +14,10 @@
 #include "prism/diagnostic.h"
 #include "prism/parser.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** The type of formatting to use when formatting errors. */
 typedef enum {
     /** Format errors in a plain format with no colors or styles. Typically
@@ -50,4 +54,8 @@ typedef enum {
  */
 PRISM_EXPORTED_FUNCTION pm_error_level_t pm_errors_format(const pm_parser_t *parser, pm_buffer_t *buffer, pm_errors_format_type_t format_type) PRISM_NONNULL(1, 2);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/include/prism/internal/buffer.h

@@ -52,6 +52,9 @@ void pm_buffer_append_varsint(pm_buffer_t *buffer, int32_t value);
 /* Append a double to the buffer. */
 void pm_buffer_append_double(pm_buffer_t *buffer, double value);
 
+/* Append a 64-bit unsigned integer to the buffer in native endian order. */
+void pm_buffer_append_uint64(pm_buffer_t *buffer, uint64_t value);
+
 /* Append a unicode codepoint to the buffer. */
 bool pm_buffer_append_unicode_codepoint(pm_buffer_t *buffer, uint32_t value);
 

data/include/prism/internal/comments.h

@@ -46,7 +46,8 @@ typedef struct {
 /*
  * Sort the parser's comment list in place by start offset, then assign every
  * comment to the node that owns it. This is called after parsing when the
- * attach_comments option is set.
+ * attach_comments option is set, before the parser's scratch arena is released,
+ * because the walk allocates from it.
  */
 void pm_comments_attach(pm_parser_t *parser, const pm_node_t *root);
 

data/include/prism/internal/node.h

@@ -14,14 +14,18 @@
 #define PM_LOCATION_END(location_) ((location_)->start + (location_)->length)
 
 /*
- * Slow path for pm_node_list_append: grow the list and append the node.
- * Do not call directly — use pm_node_list_append instead.
+ * Slow path for pm_node_list_append_inline: grow the list and append the node.
+ * Do not call directly — use pm_node_list_append_inline instead.
  */
 void pm_node_list_append_slow(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node);
 
-/* Append a new node onto the end of the node list. */
+/*
+ * Append a new node onto the end of the node list, handling the common case
+ * inline and growing the list through pm_node_list_append_slow. This is the
+ * version for prism's own code; others call the exported pm_node_list_append.
+ */
 static PRISM_FORCE_INLINE void
-pm_node_list_append(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node) {
+pm_node_list_append_inline(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node) {
     if (list->size < list->capacity) {
         list->nodes[list->size++] = node;
     } else {

data/include/prism/internal/parser.h

@@ -272,13 +272,6 @@ typedef struct pm_lex_mode {
     struct pm_lex_mode *prev;
 } pm_lex_mode_t;
 
-/*
- * We pre-allocate a certain number of lex states in order to avoid having to
- * call malloc too many times while parsing. You really shouldn't need more than
- * this because you only really nest deeply when doing string interpolation.
- */
-#define PM_LEX_STACK_SIZE 4
-
 /*
  * While parsing, we keep track of a stack of contexts. This is helpful for
  * error recovery so that we can pop back to a previous context when we hit a
@@ -596,9 +589,20 @@ struct pm_parser_t {
     /* The arena used for all AST-lifetime allocations. Caller-owned. */
     pm_arena_t *arena;
 
-    /* The arena used for parser metadata (comments, diagnostics, etc.). */
+    /*
+     * The arena used for parser metadata (comments, diagnostics, etc.), which
+     * lives as long as the parser.
+     */
     pm_arena_t metadata_arena;
 
+    /*
+     * The arena used for state that is only needed while parsing, such as
+     * scopes, locals, and contexts. It is released when pm_parse returns, so
+     * nothing allocated in it can be reachable from the tree or from the
+     * parser's metadata.
+     */
+    pm_arena_t scratch_arena;
+
     /*
      * The next node identifier that will be assigned. This is a unique
      * identifier used to track nodes such that the syntax tree can be dropped
@@ -648,16 +652,23 @@ struct pm_parser_t {
      */
     pm_state_stack_t accepts_block_stack;
 
-    /* A stack of lex modes. */
+    /* A stack of lex modes, linked through their prev pointers. */
     struct {
         /* The current mode of the lexer. */
         pm_lex_mode_t *current;
 
-        /* The stack of lexer modes. */
-        pm_lex_mode_t stack[PM_LEX_STACK_SIZE];
+        /*
+         * The mode at the bottom of the stack, which is never popped. Every
+         * other mode is allocated from the scratch arena.
+         */
+        pm_lex_mode_t base;
 
-        /* The current index into the lexer mode stack. */
-        size_t index;
+        /*
+         * Lex modes that have been popped, kept for reuse by the next push.
+         * They are allocated from the scratch arena, so they are never freed
+         * individually.
+         */
+        pm_lex_mode_t *free;
     } lex_modes;
 
     /* The pointer to the start of the source. */
@@ -715,9 +726,23 @@ struct pm_parser_t {
     /* The current local scope. */
     pm_scope_t *current_scope;
 
+    /*
+     * Scopes that have been popped, kept for reuse by the next push. Scopes
+     * are allocated from the scratch arena, so they are never freed
+     * individually.
+     */
+    pm_scope_t *free_scopes;
+
     /* The current parsing context. */
     pm_context_node_t *current_context;
 
+    /*
+     * Context nodes that have been popped, kept for reuse by the next push.
+     * Context nodes are allocated from the scratch arena, so they are never
+     * freed individually.
+     */
+    pm_context_node_t *free_contexts;
+
     /*
      * The encoding functions for the current file is attached to the parser as
      * it's parsing so that it can change with a magic comment.
@@ -981,4 +1006,10 @@ void pm_parser_init(pm_arena_t *arena, pm_parser_t *parser, const uint8_t *sourc
  */
 void pm_parser_cleanup(pm_parser_t *parser);
 
+/*
+ * Returns true if the bytes between start and end spell a keyword, using the
+ * same lookup that the lexer does.
+ */
+bool pm_keyword_p(const uint8_t *start, const uint8_t *end);
+
 #endif

data/include/prism/internal/static_literals.h

@@ -1,91 +1,51 @@
 #ifndef PRISM_INTERNAL_STATIC_LITERALS_H
 #define PRISM_INTERNAL_STATIC_LITERALS_H
 
-#include "prism/internal/encoding.h"
-
 #include "prism/ast.h"
 #include "prism/buffer.h"
-#include "prism/line_offset_list.h"
-
-/*
- * An internal hash table for a set of nodes.
- */
-typedef struct {
-    /* The array of nodes in the hash table. */
-    pm_node_t **nodes;
-
-    /* The size of the hash table. */
-    uint32_t size;
-
-    /* The space that has been allocated in the hash table. */
-    uint32_t capacity;
-} pm_node_hash_t;
+#include "prism/parser.h"
 
 /*
  * Certain sets of nodes (hash keys and when clauses) check for duplicate nodes
  * to alert the user of potential issues. To do this, we keep a set of the nodes
  * that have been seen so far, and compare whenever we find a new node.
- *
- * We bucket the nodes based on their type to minimize the number of comparisons
- * that need to be performed.
  */
 typedef struct {
-    /*
-     * This is the set of IntegerNode and SourceLineNode instances.
-     */
-    pm_node_hash_t integer_nodes;
+    /* The node stored in this slot, or NULL if the slot is empty. */
+    pm_node_t *node;
 
-    /*
-     * This is the set of FloatNode instances.
-     */
-    pm_node_hash_t float_nodes;
+    /* The hash of the node, kept so that it is never recomputed. */
+    uint64_t hash;
+} pm_static_literals_entry_t;
 
-    /*
-     * This is the set of RationalNode and ImaginaryNode instances.
-     */
-    pm_node_hash_t number_nodes;
-
-    /*
-     * This is the set of StringNode and SourceFileNode instances.
-     */
-    pm_node_hash_t string_nodes;
-
-    /*
-     * This is the set of RegularExpressionNode instances.
-     */
-    pm_node_hash_t regexp_nodes;
+/*
+ * The number of nodes a set holds directly before it moves them into a hash
+ * table. Most sets are this small, so they are searched linearly without
+ * hashing their nodes or allocating any memory.
+ */
+#define PM_STATIC_LITERALS_INLINE_CAPACITY 4
 
+typedef struct {
     /*
-     * This is the set of SymbolNode instances.
+     * The nodes in the set while it has no hash table. Once the set outgrows
+     * this array, its nodes move into the hash table and this is unused.
      */
-    pm_node_hash_t symbol_nodes;
+    pm_node_t *nodes[PM_STATIC_LITERALS_INLINE_CAPACITY];
 
-    /*
-     * A pointer to the last TrueNode instance that was inserted, or NULL.
-     */
-    pm_node_t *true_node;
+    /* The array of entries in the hash table, or NULL if there is none. */
+    pm_static_literals_entry_t *entries;
 
-    /*
-     * A pointer to the last FalseNode instance that was inserted, or NULL.
-     */
-    pm_node_t *false_node;
-
-    /*
-     * A pointer to the last NilNode instance that was inserted, or NULL.
-     */
-    pm_node_t *nil_node;
+    /* The number of nodes in the set. */
+    uint32_t size;
 
-    /*
-     * A pointer to the last SourceEncodingNode instance that was inserted, or
-     * NULL.
-     */
-    pm_node_t *source_encoding_node;
+    /* The number of entries allocated in the hash table, or 0 if there is none. */
+    uint32_t capacity;
 } pm_static_literals_t;
 
 /*
  * Add a node to the set of static literals.
  */
-pm_node_t * pm_static_literals_add(const pm_line_offset_list_t *line_offsets, const uint8_t *start, int32_t start_line, const pm_encoding_t *encoding, pm_static_literals_t *literals, pm_node_t *node, bool replace);
+pm_node_t * pm_static_literals_add(const pm_parser_t *parser, pm_static_literals_t *literals, pm_node_t *node, bool replace);
 
 /*
  * Free the internal memory associated with the given static literals set.
@@ -95,6 +55,6 @@ void pm_static_literals_free(pm_static_literals_t *literals);
 /*
  * Create a string-based representation of the given static literal.
  */
-void pm_static_literal_inspect(pm_buffer_t *buffer, const pm_line_offset_list_t *line_offsets, const uint8_t *start, int32_t start_line, const pm_encoding_t *encoding, const pm_node_t *node);
+void pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *node);
 
 #endif