prism 2.0.0.rc2-x86_64-linux-gnu → 2.1.0-x86_64-linux-gnu

data/sig/generated/prism/serialize.rbs

@@ -152,9 +152,6 @@ module Prism
       # : () -> Integer
       def load_uint64: () -> Integer
 
-      # : (ConstantPool constant_pool, Encoding encoding, bool freeze) -> node?
-      def load_optional_node: (ConstantPool constant_pool, Encoding encoding, bool freeze) -> node?
-
       # : (Encoding encoding) -> String
       def load_string: (Encoding encoding) -> String
 
@@ -184,8 +181,13 @@ module Prism
       # : (ConstantPool constant_pool, Encoding encoding) -> Symbol?
       def load_optional_constant: (ConstantPool constant_pool, Encoding encoding) -> Symbol?
 
-      # : (ConstantPool constant_pool, Encoding encoding, bool freeze) -> node
-      def load_node: (ConstantPool constant_pool, Encoding encoding, bool freeze) -> node
+      # Load the nodes that are serialized before the given offset and return
+      # the root. Nodes are serialized in post-order, so the children of each
+      # node are the topmost values on the stack, in field order, by the time
+      # its record is read.
+      #
+      # : (ConstantPool constant_pool, Encoding encoding, bool freeze, Integer finish) -> node
+      def load_nodes: (ConstantPool constant_pool, Encoding encoding, bool freeze, Integer finish) -> node
 
       @load_node_lambdas: Array[Proc]
 

data/src/arena.c

@@ -12,8 +12,13 @@
  */
 #define PM_ARENA_BLOCK_SIZE(data_size) (offsetof(pm_arena_block_t, data) + (data_size))
 
-/** Initial block data size: 8 KB. */
+/**
+ * Initial block data size: 8 KB. An embedder on a small heap can define a
+ * smaller one; a parse of a short program then takes blocks of that size.
+ */
+#ifndef PM_ARENA_INITIAL_SIZE
 #define PM_ARENA_INITIAL_SIZE 8192
+#endif
 
 /** Double the block size every this many blocks. */
 #define PM_ARENA_GROWTH_INTERVAL 8

data/src/comments.c

@@ -11,7 +11,10 @@
 
 /* The state used while walking the tree to find the owner of each comment. */
 typedef struct {
-    /* The arena for memory that is only needed during the walk. */
+    /*
+     * The arena for memory that is only needed during the walk, which is the
+     * scratch arena of the parser.
+     */
     pm_arena_t *arena;
 
     /* The start of the source that was parsed. */
@@ -223,7 +226,7 @@ pm_comments_blank_after(const pm_comments_walk_t *walk, uint32_t offset, uint32_
  * descends itself, so that it can visit children in source order and handle
  * each node after all of its descendants.
  */
-static bool
+static pm_visit_result_t
 pm_comments_push(const pm_node_t *node, void *data) {
     pm_comments_walk_t *walk = (pm_comments_walk_t *) data;
 
@@ -237,7 +240,7 @@ pm_comments_push(const pm_node_t *node, void *data) {
     }
 
     walk->stack.nodes[walk->stack.size++] = node;
-    return false;
+    return PM_VISIT_SKIP;
 }
 
 /*
@@ -389,15 +392,15 @@ pm_comments_attach(pm_parser_t *parser, const pm_node_t *root) {
     uint32_t size = (uint32_t) parser->comment_list.size;
     if (size == 0) return;
 
-    pm_arena_t arena = { 0 };
+    pm_arena_t *arena = &parser->scratch_arena;
     pm_comments_walk_t walk = {
-        .arena = &arena,
+        .arena = arena,
         .source = parser->start,
         .comments = pm_comments_sort(parser, size),
         .size = size,
-        .starts = (uint32_t *) pm_arena_alloc(&arena, sizeof(uint32_t) * size, PRISM_ALIGNOF(uint32_t)),
-        .attached = (const pm_node_t **) pm_arena_zalloc(&arena, sizeof(pm_node_t *) * size, PRISM_ALIGNOF(pm_node_t *)),
-        .unclaimed = (uint32_t *) pm_arena_alloc(&arena, sizeof(uint32_t) * (size + 1), PRISM_ALIGNOF(uint32_t))
+        .starts = (uint32_t *) pm_arena_alloc(arena, sizeof(uint32_t) * size, PRISM_ALIGNOF(uint32_t)),
+        .attached = (const pm_node_t **) pm_arena_zalloc(arena, sizeof(pm_node_t *) * size, PRISM_ALIGNOF(pm_node_t *)),
+        .unclaimed = (uint32_t *) pm_arena_alloc(arena, sizeof(uint32_t) * (size + 1), PRISM_ALIGNOF(uint32_t))
     };
 
     for (uint32_t index = 0; index < size; index++) walk.starts[index] = walk.comments[index]->location.start;
@@ -443,8 +446,6 @@ pm_comments_attach(pm_parser_t *parser, const pm_node_t *root) {
         attachments[range->index + range->length++] = index;
     }
 
-    pm_arena_cleanup(&arena);
-
     parser->comment_attachments = (pm_comment_attachments_t) {
         .comments = walk.comments,
         .attachments = attachments,

data/src/diagnostic.c

@@ -20,6 +20,7 @@
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #define PM_DIAGNOSTIC_ID_MAX 327
 
@@ -832,6 +833,14 @@ pm_diagnostic_warning_level(const pm_diagnostic_t *diagnostic) {
     return (pm_warning_level_t) pm_diagnostic_id_level(diagnostic->diag_id);
 }
 
+/**
+ * Get the diagnostic that follows the given diagnostic.
+ */
+const pm_diagnostic_t *
+pm_diagnostic_next(const pm_diagnostic_t *diagnostic) {
+    return (const pm_diagnostic_t *) diagnostic->node.next;
+}
+
 /**
  * Append an error to the given list of diagnostic.
  */
@@ -855,11 +864,16 @@ pm_diagnostic_list_append(pm_arena_t *arena, pm_list_t *list, uint32_t start, ui
  */
 void
 pm_diagnostic_list_append_format(pm_arena_t *arena, pm_list_t *list, uint32_t start, uint32_t length, pm_diagnostic_id_t diag_id, ...) {
+    /* Format the message into a buffer on the stack, which nearly every message
+     * fits in. The result is the length of the whole message whether or not it
+     * fit, so a single pass both formats the message and sizes it. */
+    char stack[256];
+
     va_list arguments;
     va_start(arguments, diag_id);
 
     const char *format = pm_diagnostic_id_message(diag_id);
-    int result = vsnprintf(NULL, 0, format, arguments);
+    int result = vsnprintf(stack, sizeof(stack), format, arguments);
     va_end(arguments);
 
     if (result < 0) {
@@ -871,9 +885,15 @@ pm_diagnostic_list_append_format(pm_arena_t *arena, pm_list_t *list, uint32_t st
     size_t message_length = (size_t) (result + 1);
     char *message = (char *) pm_arena_alloc(arena, message_length, 1);
 
-    va_start(arguments, diag_id);
-    vsnprintf(message, message_length, format, arguments);
-    va_end(arguments);
+    if (message_length <= sizeof(stack)) {
+        memcpy(message, stack, message_length);
+    } else {
+        /* The message was cut off on the stack, so format it again into an
+         * allocation of the right size. */
+        va_start(arguments, diag_id);
+        vsnprintf(message, message_length, format, arguments);
+        va_end(arguments);
+    }
 
     *diagnostic = (pm_diagnostic_t) {
         .location = { .start = start, .length = length },

data/src/integer.c

@@ -3,8 +3,13 @@
 #include "prism/internal/allocator.h"
 #include "prism/internal/buffer.h"
 
-#include <assert.h>
+/* Include sys/types.h before inttypes.h to work around an issue with certain
+ * versions of GCC and newlib which causes omission of PRIu64 and the other
+ * 64-bit macros. */
+#include <sys/types.h>
 #include <inttypes.h>
+
+#include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>