yarp 0.12.0 → 0.13.0

data/src/util/{yp_newline_list.c → pm_newline_list.c}

@@ -1,9 +1,9 @@
-#include "yarp/util/yp_newline_list.h"
+#include "prism/util/pm_newline_list.h"
 
 // Initialize a new newline list with the given capacity. Returns true if the
 // allocation of the offsets succeeds, otherwise returns false.
 bool
-yp_newline_list_init(yp_newline_list_t *list, const uint8_t *start, size_t capacity) {
+pm_newline_list_init(pm_newline_list_t *list, const uint8_t *start, size_t capacity) {
     list->offsets = (size_t *) calloc(capacity, sizeof(size_t));
     if (list->offsets == NULL) return false;
 
@@ -23,7 +23,7 @@ yp_newline_list_init(yp_newline_list_t *list, const uint8_t *start, size_t capac
 // Append a new offset to the newline list. Returns true if the reallocation of
 // the offsets succeeds (if one was necessary), otherwise returns false.
 bool
-yp_newline_list_append(yp_newline_list_t *list, const uint8_t *cursor) {
+pm_newline_list_append(pm_newline_list_t *list, const uint8_t *cursor) {
     if (list->size == list->capacity) {
         size_t *original_offsets = list->offsets;
 
@@ -46,17 +46,17 @@ yp_newline_list_append(yp_newline_list_t *list, const uint8_t *cursor) {
 
 // Conditionally append a new offset to the newline list, if the value passed in is a newline.
 bool
-yp_newline_list_check_append(yp_newline_list_t *list, const uint8_t *cursor) {
+pm_newline_list_check_append(pm_newline_list_t *list, const uint8_t *cursor) {
     if (*cursor != '\n') {
         return true;
     }
-    return yp_newline_list_append(list, cursor);
+    return pm_newline_list_append(list, cursor);
 }
 
 // Returns the line and column of the given offset, assuming we don't have any
 // information about the previous index that we found.
-static yp_line_column_t
-yp_newline_list_line_column_search(yp_newline_list_t *list, size_t offset) {
+static pm_line_column_t
+pm_newline_list_line_column_search(pm_newline_list_t *list, size_t offset) {
     size_t left = 0;
     size_t right = list->size - 1;
 
@@ -64,7 +64,7 @@ yp_newline_list_line_column_search(yp_newline_list_t *list, size_t offset) {
         size_t mid = left + (right - left) / 2;
 
         if (list->offsets[mid] == offset) {
-            return ((yp_line_column_t) { mid, 0 });
+            return ((pm_line_column_t) { mid, 0 });
         }
 
         if (list->offsets[mid] < offset) {
@@ -74,13 +74,13 @@ yp_newline_list_line_column_search(yp_newline_list_t *list, size_t offset) {
         }
     }
 
-    return ((yp_line_column_t) { left - 1, offset - list->offsets[left - 1] });
+    return ((pm_line_column_t) { left - 1, offset - list->offsets[left - 1] });
 }
 
 // Returns the line and column of the given offset, assuming we know the last
 // index that we found.
-static yp_line_column_t
-yp_newline_list_line_column_scan(yp_newline_list_t *list, size_t offset) {
+static pm_line_column_t
+pm_newline_list_line_column_scan(pm_newline_list_t *list, size_t offset) {
     if (offset > list->last_offset) {
         size_t index = list->last_index;
         while (index < list->size && list->offsets[index] < offset) {
@@ -88,10 +88,10 @@ yp_newline_list_line_column_scan(yp_newline_list_t *list, size_t offset) {
         }
 
         if (index == list->size) {
-            return ((yp_line_column_t) { index - 1, offset - list->offsets[index - 1] });
+            return ((pm_line_column_t) { index - 1, offset - list->offsets[index - 1] });
         }
 
-        return ((yp_line_column_t) { index, 0 });
+        return ((pm_line_column_t) { index, 0 });
     } else {
         size_t index = list->last_index;
         while (index > 0 && list->offsets[index] > offset) {
@@ -99,26 +99,26 @@ yp_newline_list_line_column_scan(yp_newline_list_t *list, size_t offset) {
         }
 
         if (index == 0) {
-            return ((yp_line_column_t) { 0, offset });
+            return ((pm_line_column_t) { 0, offset });
         }
 
-        return ((yp_line_column_t) { index, offset - list->offsets[index - 1] });
+        return ((pm_line_column_t) { index, offset - list->offsets[index - 1] });
     }
 }
 
 // Returns the line and column of the given offset. If the offset is not in the
 // list, the line and column of the closest offset less than the given offset
 // are returned.
-yp_line_column_t
-yp_newline_list_line_column(yp_newline_list_t *list, const uint8_t *cursor) {
+pm_line_column_t
+pm_newline_list_line_column(pm_newline_list_t *list, const uint8_t *cursor) {
     assert(cursor >= list->start);
     size_t offset = (size_t) (cursor - list->start);
-    yp_line_column_t result;
+    pm_line_column_t result;
 
     if (list->last_offset == 0) {
-        result = yp_newline_list_line_column_search(list, offset);
+        result = pm_newline_list_line_column_search(list, offset);
     } else {
-        result = yp_newline_list_line_column_scan(list, offset);
+        result = pm_newline_list_line_column_scan(list, offset);
     }
 
     list->last_index = result.line;
@@ -129,6 +129,6 @@ yp_newline_list_line_column(yp_newline_list_t *list, const uint8_t *cursor) {
 
 // Free the internal memory allocated for the newline list.
 void
-yp_newline_list_free(yp_newline_list_t *list) {
+pm_newline_list_free(pm_newline_list_t *list) {
     free(list->offsets);
 }

data/src/util/{yp_state_stack.c → pm_state_stack.c}

@@ -1,19 +1,19 @@
-#include "yarp/util/yp_state_stack.h"
+#include "prism/util/pm_state_stack.h"
 
 // Pushes a value onto the stack.
 void
-yp_state_stack_push(yp_state_stack_t *stack, bool value) {
+pm_state_stack_push(pm_state_stack_t *stack, bool value) {
     *stack = (*stack << 1) | (value & 1);
 }
 
 // Pops a value off the stack.
 void
-yp_state_stack_pop(yp_state_stack_t *stack) {
+pm_state_stack_pop(pm_state_stack_t *stack) {
     *stack >>= 1;
 }
 
 // Returns the value at the top of the stack.
 bool
-yp_state_stack_p(yp_state_stack_t *stack) {
+pm_state_stack_p(pm_state_stack_t *stack) {
     return *stack & 1;
 }

data/src/util/{yp_string.c → pm_string.c}

@@ -1,4 +1,4 @@
-#include "yarp/util/yp_string.h"
+#include "prism/util/pm_string.h"
 
 // The following headers are necessary to read files using demand paging.
 #ifdef _WIN32
@@ -12,11 +12,11 @@
 
 // Initialize a shared string that is based on initial input.
 void
-yp_string_shared_init(yp_string_t *string, const uint8_t *start, const uint8_t *end) {
+pm_string_shared_init(pm_string_t *string, const uint8_t *start, const uint8_t *end) {
     assert(start <= end);
 
-    *string = (yp_string_t) {
-        .type = YP_STRING_SHARED,
+    *string = (pm_string_t) {
+        .type = PM_STRING_SHARED,
         .source = start,
         .length = (size_t) (end - start)
     };
@@ -24,9 +24,9 @@ yp_string_shared_init(yp_string_t *string, const uint8_t *start, const uint8_t *
 
 // Initialize an owned string that is responsible for freeing allocated memory.
 void
-yp_string_owned_init(yp_string_t *string, uint8_t *source, size_t length) {
-    *string = (yp_string_t) {
-        .type = YP_STRING_OWNED,
+pm_string_owned_init(pm_string_t *string, uint8_t *source, size_t length) {
+    *string = (pm_string_t) {
+        .type = PM_STRING_OWNED,
         .source = source,
         .length = length
     };
@@ -34,18 +34,18 @@ yp_string_owned_init(yp_string_t *string, uint8_t *source, size_t length) {
 
 // Initialize a constant string that doesn't own its memory source.
 void
-yp_string_constant_init(yp_string_t *string, const char *source, size_t length) {
-    *string = (yp_string_t) {
-        .type = YP_STRING_CONSTANT,
+pm_string_constant_init(pm_string_t *string, const char *source, size_t length) {
+    *string = (pm_string_t) {
+        .type = PM_STRING_CONSTANT,
         .source = (const uint8_t *) source,
         .length = length
     };
 }
 
 static void
-yp_string_mapped_init_internal(yp_string_t *string, uint8_t *source, size_t length) {
-    *string = (yp_string_t) {
-        .type = YP_STRING_MAPPED,
+pm_string_mapped_init_internal(pm_string_t *string, uint8_t *source, size_t length) {
+    *string = (pm_string_t) {
+        .type = PM_STRING_MAPPED,
         .source = source,
         .length = length
     };
@@ -53,9 +53,9 @@ yp_string_mapped_init_internal(yp_string_t *string, uint8_t *source, size_t leng
 
 // Returns the memory size associated with the string.
 size_t
-yp_string_memsize(const yp_string_t *string) {
-    size_t size = sizeof(yp_string_t);
-    if (string->type == YP_STRING_OWNED) {
+pm_string_memsize(const pm_string_t *string) {
+    size_t size = sizeof(pm_string_t);
+    if (string->type == PM_STRING_OWNED) {
         size += string->length;
     }
     return size;
@@ -64,39 +64,39 @@ yp_string_memsize(const yp_string_t *string) {
 // Ensure the string is owned. If it is not, then reinitialize it as owned and
 // copy over the previous source.
 void
-yp_string_ensure_owned(yp_string_t *string) {
-    if (string->type == YP_STRING_OWNED) return;
+pm_string_ensure_owned(pm_string_t *string) {
+    if (string->type == PM_STRING_OWNED) return;
 
-    size_t length = yp_string_length(string);
-    const uint8_t *source = yp_string_source(string);
+    size_t length = pm_string_length(string);
+    const uint8_t *source = pm_string_source(string);
 
     uint8_t *memory = malloc(length);
     if (!memory) return;
 
-    yp_string_owned_init(string, memory, length);
+    pm_string_owned_init(string, memory, length);
     memcpy((void *) string->source, source, length);
 }
 
 // Returns the length associated with the string.
-YP_EXPORTED_FUNCTION size_t
-yp_string_length(const yp_string_t *string) {
+PRISM_EXPORTED_FUNCTION size_t
+pm_string_length(const pm_string_t *string) {
     return string->length;
 }
 
 // Returns the start pointer associated with the string.
-YP_EXPORTED_FUNCTION const uint8_t *
-yp_string_source(const yp_string_t *string) {
+PRISM_EXPORTED_FUNCTION const uint8_t *
+pm_string_source(const pm_string_t *string) {
     return string->source;
 }
 
 // Free the associated memory of the given string.
-YP_EXPORTED_FUNCTION void
-yp_string_free(yp_string_t *string) {
+PRISM_EXPORTED_FUNCTION void
+pm_string_free(pm_string_t *string) {
     void *memory = (void *) string->source;
 
-    if (string->type == YP_STRING_OWNED) {
+    if (string->type == PM_STRING_OWNED) {
         free(memory);
-    } else if (string->type == YP_STRING_MAPPED && string->length) {
+    } else if (string->type == PM_STRING_MAPPED && string->length) {
 #if defined(_WIN32)
         UnmapViewOfFile(memory);
 #else
@@ -106,7 +106,7 @@ yp_string_free(yp_string_t *string) {
 }
 
 bool
-yp_string_mapped_init(yp_string_t *string, const char *filepath) {
+pm_string_mapped_init(pm_string_t *string, const char *filepath) {
 #ifdef _WIN32
     // Open the file for reading.
     HANDLE file = CreateFile(filepath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
@@ -129,7 +129,7 @@ yp_string_mapped_init(yp_string_t *string, const char *filepath) {
     if (file_size == 0) {
         CloseHandle(file);
         uint8_t empty[] = "";
-        yp_string_mapped_init_internal(string, empty, 0);
+        pm_string_mapped_init_internal(string, empty, 0);
         return true;
     }
 
@@ -151,7 +151,7 @@ yp_string_mapped_init(yp_string_t *string, const char *filepath) {
         return false;
     }
 
-    yp_string_mapped_init_internal(string, source, (size_t) file_size);
+    pm_string_mapped_init_internal(string, source, (size_t) file_size);
     return true;
 #else
     // Open the file for reading
@@ -176,7 +176,7 @@ yp_string_mapped_init(yp_string_t *string, const char *filepath) {
     if (size == 0) {
         close(fd);
         uint8_t empty[] = "";
-        yp_string_mapped_init_internal(string, empty, 0);
+        pm_string_mapped_init_internal(string, empty, 0);
         return true;
     }
 
@@ -187,14 +187,14 @@ yp_string_mapped_init(yp_string_t *string, const char *filepath) {
     }
 
     close(fd);
-    yp_string_mapped_init_internal(string, source, size);
+    pm_string_mapped_init_internal(string, source, size);
     return true;
 #endif
 }
 
-// Returns the size of the yp_string_t struct. This is necessary to allocate the
+// Returns the size of the pm_string_t struct. This is necessary to allocate the
 // correct amount of memory in the FFI backend.
-YP_EXPORTED_FUNCTION size_t
-yp_string_sizeof(void) {
-    return sizeof(yp_string_t);
+PRISM_EXPORTED_FUNCTION size_t
+pm_string_sizeof(void) {
+    return sizeof(pm_string_t);
 }

data/src/util/pm_string_list.c

@@ -0,0 +1,29 @@
+#include "prism/util/pm_string_list.h"
+
+// Initialize a pm_string_list_t with its default values.
+void
+pm_string_list_init(pm_string_list_t *string_list) {
+    string_list->strings = (pm_string_t *) malloc(sizeof(pm_string_t));
+    string_list->length = 0;
+    string_list->capacity = 1;
+}
+
+// Append a pm_string_t to the given string list.
+void
+pm_string_list_append(pm_string_list_t *string_list, pm_string_t *string) {
+    if (string_list->length + 1 > string_list->capacity) {
+        pm_string_t *original_string = string_list->strings;
+        string_list->capacity *= 2;
+        string_list->strings = (pm_string_t *) malloc(string_list->capacity * sizeof(pm_string_t));
+        memcpy(string_list->strings, original_string, (string_list->length) * sizeof(pm_string_t));
+        free(original_string);
+    }
+
+    string_list->strings[string_list->length++] = *string;
+}
+
+// Free the memory associated with the string list.
+void
+pm_string_list_free(pm_string_list_t *string_list) {
+    free(string_list->strings);
+}

data/src/util/{yp_strncasecmp.c → pm_strncasecmp.c}

@@ -3,7 +3,7 @@
 #include <stdint.h>
 
 int
-yp_strncasecmp(const uint8_t *string1, const uint8_t *string2, size_t length) {
+pm_strncasecmp(const uint8_t *string1, const uint8_t *string2, size_t length) {
     size_t offset = 0;
     int difference = 0;
 

data/src/util/{yp_strpbrk.c → pm_strpbrk.c}

@@ -1,8 +1,8 @@
-#include "yarp/util/yp_strpbrk.h"
+#include "prism/util/pm_strpbrk.h"
 
 // This is the slow path that does care about the encoding.
 static inline const uint8_t *
-yp_strpbrk_multi_byte(yp_parser_t *parser, const uint8_t *source, const uint8_t *charset, size_t maximum) {
+pm_strpbrk_multi_byte(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, size_t maximum) {
     size_t index = 0;
 
     while (index < maximum) {
@@ -23,7 +23,7 @@ yp_strpbrk_multi_byte(yp_parser_t *parser, const uint8_t *source, const uint8_t
 
 // This is the fast path that does not care about the encoding.
 static inline const uint8_t *
-yp_strpbrk_single_byte(const uint8_t *source, const uint8_t *charset, size_t maximum) {
+pm_strpbrk_single_byte(const uint8_t *source, const uint8_t *charset, size_t maximum) {
     size_t index = 0;
 
     while (index < maximum) {
@@ -39,9 +39,9 @@ yp_strpbrk_single_byte(const uint8_t *source, const uint8_t *charset, size_t max
 
 // Here we have rolled our own version of strpbrk. The standard library strpbrk
 // has undefined behavior when the source string is not null-terminated. We want
-// to support strings that are not null-terminated because yp_parse does not
+// to support strings that are not null-terminated because pm_parse does not
 // have the contract that the string is null-terminated. (This is desirable
-// because it means the extension can call yp_parse with the result of a call to
+// because it means the extension can call pm_parse with the result of a call to
 // mmap).
 //
 // The standard library strpbrk also does not support passing a maximum length
@@ -55,12 +55,12 @@ yp_strpbrk_single_byte(const uint8_t *source, const uint8_t *charset, size_t max
 // Shift-JIS, the backslash character can be a trailing byte. In that case we
 // need to take a slower path and iterate one multi-byte character at a time.
 const uint8_t *
-yp_strpbrk(yp_parser_t *parser, const uint8_t *source, const uint8_t *charset, ptrdiff_t length) {
+pm_strpbrk(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, ptrdiff_t length) {
     if (length <= 0) {
         return NULL;
     } else if (parser->encoding_changed && parser->encoding.multibyte) {
-        return yp_strpbrk_multi_byte(parser, source, charset, (size_t) length);
+        return pm_strpbrk_multi_byte(parser, source, charset, (size_t) length);
     } else {
-        return yp_strpbrk_single_byte(source, charset, (size_t) length);
+        return pm_strpbrk_single_byte(source, charset, (size_t) length);
     }
 }

data/yarp.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |spec|
   spec.name = "yarp"
-  spec.version = "0.12.0"
+  spec.version = "0.13.0"
   spec.authors = ["Shopify"]
   spec.email = ["ruby@shopify.com"]
 
-  spec.summary = "Yet Another Ruby Parser"
-  spec.homepage = "https://github.com/ruby/yarp"
+  spec.summary = "Prism Ruby parser"
+  spec.homepage = "https://github.com/ruby/prism"
   spec.license = "MIT"
 
   spec.required_ruby_version = ">= 3.0.0"
@@ -33,51 +33,60 @@ Gem::Specification.new do |spec|
     "docs/ruby_api.md",
     "docs/serialization.md",
     "docs/testing.md",
-    "ext/yarp/api_node.c",
-    "ext/yarp/api_pack.c",
-    "ext/yarp/extension.c",
-    "ext/yarp/extension.h",
-    "include/yarp.h",
-    "include/yarp/ast.h",
-    "include/yarp/defines.h",
-    "include/yarp/diagnostic.h",
-    "include/yarp/enc/yp_encoding.h",
-    "include/yarp/node.h",
-    "include/yarp/pack.h",
-    "include/yarp/parser.h",
-    "include/yarp/regexp.h",
-    "include/yarp/unescape.h",
-    "include/yarp/util/yp_buffer.h",
-    "include/yarp/util/yp_char.h",
-    "include/yarp/util/yp_constant_pool.h",
-    "include/yarp/util/yp_list.h",
-    "include/yarp/util/yp_memchr.h",
-    "include/yarp/util/yp_newline_list.h",
-    "include/yarp/util/yp_state_stack.h",
-    "include/yarp/util/yp_string.h",
-    "include/yarp/util/yp_string_list.h",
-    "include/yarp/util/yp_strpbrk.h",
-    "include/yarp/version.h",
+    "ext/prism/api_node.c",
+    "ext/prism/api_pack.c",
+    "ext/prism/extension.c",
+    "ext/prism/extension.h",
+    "include/prism.h",
+    "include/prism/ast.h",
+    "include/prism/defines.h",
+    "include/prism/diagnostic.h",
+    "include/prism/enc/pm_encoding.h",
+    "include/prism/node.h",
+    "include/prism/pack.h",
+    "include/prism/parser.h",
+    "include/prism/regexp.h",
+    "include/prism/unescape.h",
+    "include/prism/util/pm_buffer.h",
+    "include/prism/util/pm_char.h",
+    "include/prism/util/pm_constant_pool.h",
+    "include/prism/util/pm_list.h",
+    "include/prism/util/pm_memchr.h",
+    "include/prism/util/pm_newline_list.h",
+    "include/prism/util/pm_state_stack.h",
+    "include/prism/util/pm_string.h",
+    "include/prism/util/pm_string_list.h",
+    "include/prism/util/pm_strpbrk.h",
+    "include/prism/version.h",
     "lib/yarp.rb",
-    "lib/yarp/desugar_visitor.rb",
-    "lib/yarp/ffi.rb",
-    "lib/yarp/lex_compat.rb",
-    "lib/yarp/mutation_visitor.rb",
-    "lib/yarp/node.rb",
-    "lib/yarp/pack.rb",
-    "lib/yarp/pattern.rb",
-    "lib/yarp/ripper_compat.rb",
-    "lib/yarp/serialize.rb",
-    "lib/yarp/parse_result/comments.rb",
-    "lib/yarp/parse_result/newlines.rb",
+    "lib/prism.rb",
+    "lib/prism/compiler.rb",
+    "lib/prism/debug.rb",
+    "lib/prism/desugar_compiler.rb",
+    "lib/prism/dispatcher.rb",
+    "lib/prism/dsl.rb",
+    "lib/prism/ffi.rb",
+    "lib/prism/lex_compat.rb",
+    "lib/prism/mutation_compiler.rb",
+    "lib/prism/node.rb",
+    "lib/prism/node_ext.rb",
+    "lib/prism/node_inspector.rb",
+    "lib/prism/pack.rb",
+    "lib/prism/parse_result.rb",
+    "lib/prism/pattern.rb",
+    "lib/prism/ripper_compat.rb",
+    "lib/prism/serialize.rb",
+    "lib/prism/parse_result/comments.rb",
+    "lib/prism/parse_result/newlines.rb",
+    "lib/prism/visitor.rb",
     "src/diagnostic.c",
-    "src/enc/yp_big5.c",
-    "src/enc/yp_euc_jp.c",
-    "src/enc/yp_gbk.c",
-    "src/enc/yp_shift_jis.c",
-    "src/enc/yp_tables.c",
-    "src/enc/yp_unicode.c",
-    "src/enc/yp_windows_31j.c",
+    "src/enc/pm_big5.c",
+    "src/enc/pm_euc_jp.c",
+    "src/enc/pm_gbk.c",
+    "src/enc/pm_shift_jis.c",
+    "src/enc/pm_tables.c",
+    "src/enc/pm_unicode.c",
+    "src/enc/pm_windows_31j.c",
     "src/node.c",
     "src/pack.c",
     "src/prettyprint.c",
@@ -85,21 +94,21 @@ Gem::Specification.new do |spec|
     "src/serialize.c",
     "src/token_type.c",
     "src/unescape.c",
-    "src/util/yp_buffer.c",
-    "src/util/yp_char.c",
-    "src/util/yp_constant_pool.c",
-    "src/util/yp_list.c",
-    "src/util/yp_memchr.c",
-    "src/util/yp_newline_list.c",
-    "src/util/yp_state_stack.c",
-    "src/util/yp_string.c",
-    "src/util/yp_string_list.c",
-    "src/util/yp_strncasecmp.c",
-    "src/util/yp_strpbrk.c",
-    "src/yarp.c",
+    "src/util/pm_buffer.c",
+    "src/util/pm_char.c",
+    "src/util/pm_constant_pool.c",
+    "src/util/pm_list.c",
+    "src/util/pm_memchr.c",
+    "src/util/pm_newline_list.c",
+    "src/util/pm_state_stack.c",
+    "src/util/pm_string.c",
+    "src/util/pm_string_list.c",
+    "src/util/pm_strncasecmp.c",
+    "src/util/pm_strpbrk.c",
+    "src/prism.c",
     "yarp.gemspec",
   ]
 
-  spec.extensions = ["ext/yarp/extconf.rb"]
+  spec.extensions = ["ext/prism/extconf.rb"]
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 end