prism 2.0.0.rc1 → 2.0.0

data/src/options.c

@@ -17,6 +17,8 @@ pm_options_t *
 pm_options_new(void) {
     pm_options_t *options = xcalloc(1, sizeof(pm_options_t));
     if (options == NULL) abort();
+
+    options->line = 1;
     return options;
 }
 
@@ -25,16 +27,8 @@ pm_options_new(void) {
  */
 void
 pm_options_cleanup(pm_options_t *options) {
-    pm_string_cleanup(&options->filepath);
-    pm_string_cleanup(&options->encoding);
-
     for (size_t scope_index = 0; scope_index < options->scopes_count; scope_index++) {
         pm_options_scope_t *scope = &options->scopes[scope_index];
-
-        for (size_t local_index = 0; local_index < scope->locals_count; local_index++) {
-            pm_string_cleanup(&scope->locals[local_index]);
-        }
-
         xfree_sized(scope->locals, scope->locals_count * sizeof(pm_string_t));
     }
 
@@ -74,7 +68,7 @@ pm_options_filepath(const pm_options_t *options) {
  */
 void
 pm_options_filepath_set(pm_options_t *options, const char *filepath) {
-    pm_string_constant_init(&options->filepath, filepath, strlen(filepath));
+    pm_string_init(&options->filepath, (const uint8_t *) filepath, strlen(filepath));
 }
 
 /**
@@ -82,7 +76,7 @@ pm_options_filepath_set(pm_options_t *options, const char *filepath) {
  */
 void
 pm_options_encoding_set(pm_options_t *options, const char *encoding) {
-    pm_string_constant_init(&options->encoding, encoding, strlen(encoding));
+    pm_string_init(&options->encoding, (const uint8_t *) encoding, strlen(encoding));
 }
 
 /**
@@ -395,7 +389,7 @@ pm_options_read(pm_options_t *options, const char *data) {
     data += 4;
 
     if (filepath_length > 0) {
-        pm_string_constant_init(&options->filepath, data, filepath_length);
+        pm_string_init(&options->filepath, (const uint8_t *) data, filepath_length);
         data += filepath_length;
     }
 
@@ -406,7 +400,7 @@ pm_options_read(pm_options_t *options, const char *data) {
     data += 4;
 
     if (encoding_length > 0) {
-        pm_string_constant_init(&options->encoding, data, encoding_length);
+        pm_string_init(&options->encoding, (const uint8_t *) data, encoding_length);
         data += encoding_length;
     }
 
@@ -439,7 +433,7 @@ pm_options_read(pm_options_t *options, const char *data) {
                 uint32_t local_length = pm_options_read_u32(data);
                 data += 4;
 
-                pm_string_constant_init(&scope->locals[local_index], data, local_length);
+                pm_string_init(&scope->locals[local_index], (const uint8_t *) data, local_length);
                 data += local_length;
             }
         }

data/src/parser.c

@@ -5,8 +5,11 @@
 #include "prism/internal/diagnostic.h"
 #include "prism/internal/encoding.h"
 #include "prism/internal/magic_comments.h"
+#include "prism/internal/xxh3.h"
 
+#include <assert.h>
 #include <stdlib.h>
+#include <string.h>
 
 /**
  * Register a callback that will be called whenever prism changes the encoding
@@ -103,6 +106,19 @@ pm_parser_constant_find(const pm_parser_t *parser, const uint8_t *start, size_t
     return pm_constant_pool_find(&parser->constant_pool, start, length);
 }
 
+/**
+ * Add a constant to the parser's constant pool, copying its bytes into the
+ * parser's arena only if the constant is not already there.
+ */
+pm_constant_id_t
+pm_parser_constant_insert(pm_parser_t *parser, const uint8_t *start, size_t length) {
+    pm_constant_id_t id = pm_constant_pool_find(&parser->constant_pool, start, length);
+    if (id != PM_CONSTANT_ID_UNSET) return id;
+
+    const uint8_t *copy = (const uint8_t *) pm_arena_memdup(&parser->metadata_arena, start, length, PRISM_ALIGNOF(uint8_t));
+    return pm_constant_pool_insert_constant(&parser->metadata_arena, &parser->constant_pool, copy, length);
+}
+
 /**
  * Returns the frozen string literal value of the parser.
  */
@@ -131,6 +147,22 @@ pm_parser_data_loc(const pm_parser_t *parser) {
     return &parser->data_loc;
 }
 
+/**
+ * Returns the checksum of the source code that was parsed.
+ */
+uint64_t
+pm_parser_checksum(const pm_parser_t *parser) {
+    const uint8_t *end = parser->end;
+
+    if (parser->data_loc.length != 0) {
+        const uint8_t *cursor = parser->start + parser->data_loc.start;
+        const uint8_t *newline = memchr(cursor, '\n', (size_t) (end - cursor));
+        if (newline != NULL) end = newline + 1;
+    }
+
+    return pm_xxh3(parser->start, (size_t) (end - parser->start));
+}
+
 /**
  * Returns whether the given parser is continuable, meaning that it could become
  * valid if more input were appended, as opposed to being definitively invalid.
@@ -167,6 +199,14 @@ pm_comment_type(const pm_comment_t *comment) {
     return comment->type;
 }
 
+/**
+ * Returns the comment that follows the given comment.
+ */
+const pm_comment_t *
+pm_comment_next(const pm_comment_t *comment) {
+    return (const pm_comment_t *) comment->node.next;
+}
+
 /**
  * Returns the number of comments associated with the given parser.
  */
@@ -176,17 +216,11 @@ pm_parser_comments_size(const pm_parser_t *parser) {
 }
 
 /**
- * Iterates over the comments associated with the given parser and calls the
- * given callback for each comment.
+ * Returns the first comment associated with the given parser.
  */
-void
-pm_parser_comments_each(const pm_parser_t *parser, pm_comment_callback_t callback, void *data) {
-    const pm_list_node_t *current = parser->comment_list.head;
-    while (current != NULL) {
-        const pm_comment_t *comment = (const pm_comment_t *) current;
-        callback(comment, data);
-        current = current->next;
-    }
+const pm_comment_t *
+pm_parser_comments_first(const pm_parser_t *parser) {
+    return (const pm_comment_t *) parser->comment_list.head;
 }
 
 /**
@@ -252,6 +286,14 @@ pm_magic_comment_value(const pm_magic_comment_t *magic_comment) {
     return magic_comment->value;
 }
 
+/**
+ * Returns the magic comment that follows the given magic comment.
+ */
+const pm_magic_comment_t *
+pm_magic_comment_next(const pm_magic_comment_t *magic_comment) {
+    return (const pm_magic_comment_t *) magic_comment->node.next;
+}
+
 /**
  * Returns the number of magic comments associated with the given parser.
  */
@@ -261,17 +303,11 @@ pm_parser_magic_comments_size(const pm_parser_t *parser) {
 }
 
 /**
- * Iterates over the magic comments associated with the given parser and calls
- * the given callback for each magic comment.
+ * Returns the first magic comment associated with the given parser.
  */
-void
-pm_parser_magic_comments_each(const pm_parser_t *parser, pm_magic_comment_callback_t callback, void *data) {
-    const pm_list_node_t *current = parser->magic_comment_list.head;
-    while (current != NULL) {
-        const pm_magic_comment_t *magic_comment = (const pm_magic_comment_t *) current;
-        callback(magic_comment, data);
-        current = current->next;
-    }
+const pm_magic_comment_t *
+pm_parser_magic_comments_first(const pm_parser_t *parser) {
+    return (const pm_magic_comment_t *) parser->magic_comment_list.head;
 }
 
 /**
@@ -290,32 +326,20 @@ pm_parser_warnings_size(const pm_parser_t *parser) {
     return parser->warning_list.size;
 }
 
-static inline void
-pm_parser_diagnostics_each(const pm_list_t *list, pm_diagnostic_callback_t callback, void *data) {
-    const pm_list_node_t *current = list->head;
-    while (current != NULL) {
-        const pm_diagnostic_t *diagnostic = (const pm_diagnostic_t *) current;
-        callback(diagnostic, data);
-        current = current->next;
-    }
-}
-
 /**
- * Iterates over the errors associated with the given parser and calls the
- * given callback for each error.
+ * Returns the first error associated with the given parser.
  */
-void
-pm_parser_errors_each(const pm_parser_t *parser, pm_diagnostic_callback_t callback, void *data) {
-    pm_parser_diagnostics_each(&parser->error_list, callback, data);
+const pm_diagnostic_t *
+pm_parser_errors_first(const pm_parser_t *parser) {
+    return (const pm_diagnostic_t *) parser->error_list.head;
 }
 
 /**
- * Iterates over the warnings associated with the given parser and calls the
- * given callback for each warning.
+ * Returns the first warning associated with the given parser.
  */
-void
-pm_parser_warnings_each(const pm_parser_t *parser, pm_diagnostic_callback_t callback, void *data) {
-    pm_parser_diagnostics_each(&parser->warning_list, callback, data);
+const pm_diagnostic_t *
+pm_parser_warnings_first(const pm_parser_t *parser) {
+    return (const pm_diagnostic_t *) parser->warning_list.head;
 }
 
 /**
@@ -328,15 +352,13 @@ pm_parser_constants_size(const pm_parser_t *parser) {
 }
 
 /**
- * Iterates over the constants in the constant pool associated with the given
- * parser and calls the given callback for each constant.
+ * Returns the constant at the given index in the constant pool associated with
+ * the given parser.
  */
-void
-pm_parser_constants_each(const pm_parser_t *parser, pm_constant_callback_t callback, void *data) {
-    for (uint32_t index = 0; index < parser->constant_pool.size; index++) {
-        const pm_constant_t *constant = &parser->constant_pool.constants[index];
-        callback(constant, data);
-    }
+const pm_constant_t *
+pm_parser_constant_at(const pm_parser_t *parser, size_t index) {
+    assert(index < parser->constant_pool.size);
+    return &parser->constant_pool.constants[index];
 }
 
 /**