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

data/sig/generated/prism/parse_result.rbs

@@ -30,8 +30,11 @@ module Prism
     # empty when the source is created by the parser and filled in afterward,
     # because the comments themselves refer to the source.
     #
-    # : (String source, Integer start_line, Array[Integer] offsets, ?Array[Comment] comments, ?Array[Comment] comment_attachments, ?Array[Integer?] comment_ranges) -> Source
-    def self.for: (String source, Integer start_line, Array[Integer] offsets, ?Array[Comment] comments, ?Array[Comment] comment_attachments, ?Array[Integer?] comment_ranges) -> Source
+    # The checksum parameter is the value described by the attribute of the same
+    # name. It is nil when the source is not created by the parser.
+    #
+    # : (String source, Integer start_line, Array[Integer] offsets, ?Array[Comment] comments, ?Array[Comment] comment_attachments, ?Array[Integer?] comment_ranges, ?Integer? checksum) -> Source
+    def self.for: (String source, Integer start_line, Array[Integer] offsets, ?Array[Comment] comments, ?Array[Comment] comment_attachments, ?Array[Integer?] comment_ranges, ?Integer? checksum) -> Source
 
     # The source code that this source object represents.
     attr_reader source: String
@@ -39,6 +42,10 @@ module Prism
     # The line number where this source starts.
     attr_reader start_line: Integer
 
+    # The checksum of the source code which can be used to quickly determine if
+    # the source has changed.
+    attr_reader checksum: Integer?
+
     # The list of comments that were encountered during parsing. When the source
     # is parsed with the attach_comments option, these are sorted by start
     # offset.
@@ -66,14 +73,19 @@ module Prism
     # parameter can be either an Array of Integer byte offsets or a packed
     # binary string of uint32_t values (from the C extension).
     #
-    # : (String source, Integer start_line, Array[Integer] | String offsets, ?Array[Comment] comments, ?Array[Comment] comment_attachments, ?Array[Integer?] comment_ranges) -> void
-    def initialize: (String source, Integer start_line, Array[Integer] | String offsets, ?Array[Comment] comments, ?Array[Comment] comment_attachments, ?Array[Integer?] comment_ranges) -> void
+    # : (String source, Integer start_line, Array[Integer] | String offsets, ?Array[Comment] comments, ?Array[Comment] comment_attachments, ?Array[Integer?] comment_ranges, ?Integer? checksum) -> void
+    def initialize: (String source, Integer start_line, Array[Integer] | String offsets, ?Array[Comment] comments, ?Array[Comment] comment_attachments, ?Array[Integer?] comment_ranges, ?Integer? checksum) -> void
 
     # Replace the value of start_line with the given value.
     #
     # : (Integer start_line) -> void
     def replace_start_line: (Integer start_line) -> void
 
+    # Replace the value of checksum with the given value.
+    #
+    # : (Integer checksum) -> void
+    def replace_checksum: (Integer checksum) -> void
+
     # Replace the value of offsets with the given value.
     #
     # : (Array[Integer] offsets) -> void

data/sig/generated/prism/serialize.rbs

@@ -149,8 +149,8 @@ module Prism
       # : () -> Integer
       def load_uint32: () -> Integer
 
-      # : (ConstantPool constant_pool, Encoding encoding, bool freeze) -> node?
-      def load_optional_node: (ConstantPool constant_pool, Encoding encoding, bool freeze) -> node?
+      # : () -> Integer
+      def load_uint64: () -> Integer
 
       # : (Encoding encoding) -> String
       def load_string: (Encoding encoding) -> String
@@ -181,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/sig/generated/prism/string_query.rbs

@@ -10,6 +10,8 @@ module Prism
 
     def self.method_name?: (String string) -> bool
 
+    def self.keyword?: (String string) -> bool
+
     # The string that this query is wrapping.
     attr_reader string: String
 
@@ -32,5 +34,10 @@ module Prism
     #
     # : () -> bool
     def method_name?: () -> bool
+
+    # Whether or not this string is a valid keyword.
+    #
+    # : () -> bool
+    def keyword?: () -> bool
   end
 end

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/buffer.c

@@ -186,6 +186,15 @@ pm_buffer_append_double(pm_buffer_t *buffer, double value) {
     pm_buffer_append(buffer, source, sizeof(double));
 }
 
+/**
+ * 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) {
+    const void *source = &value;
+    pm_buffer_append(buffer, source, sizeof(uint64_t));
+}
+
 /**
  * Append a unicode codepoint to the buffer.
  */

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>