1 files changed, 57 insertions, 224 deletions

diff --git a/prism/templates/src/node.c.erb b/prism/templates/src/node.c.erb
index 2357e55200..f51aff6e53 100644
--- a/prism/templates/src/node.c.erb
+++ b/prism/templates/src/node.c.erb
@@ -1,153 +1,85 @@
 #line <%= __LINE__ + 1 %> "prism/templates/src/<%= File.basename(__FILE__) %>"
-#include "prism/node.h"
+#include "prism/internal/node.h"
+
+#include "prism/internal/arena.h"
+
+#include <stdlib.h>
 
 /**
  * Attempts to grow the node list to the next size. If there is already
- * capacity in the list, this function does nothing. Otherwise it reallocates
- * the list to be twice as large as it was before. If the reallocation fails,
- * this function returns false, otherwise it returns true.
+ * capacity in the list, this function does nothing. Otherwise it allocates a
+ * new array from the arena (abandon-and-copy strategy) and copies the existing
+ * data into it.
  */
-static bool
-pm_node_list_grow(pm_node_list_t *list, size_t size) {
+static void
+pm_node_list_grow(pm_arena_t *arena, pm_node_list_t *list, size_t size) {
     size_t requested_size = list->size + size;
 
-    // If the requested size caused overflow, return false.
-    if (requested_size < list->size) return false;
+    // Guard against overflow on the addition.
+    if (requested_size < list->size) abort();
 
-    // If the requested size is within the existing capacity, return true.
-    if (requested_size < list->capacity) return true;
+    // If the requested size is within the existing capacity, return.
+    if (requested_size <= list->capacity) return;
 
-    // Otherwise, reallocate the list to be twice as large as it was before.
+    // Otherwise, compute the next capacity by doubling.
     size_t next_capacity = list->capacity == 0 ? 4 : list->capacity * 2;
 
-    // If multiplying by 2 caused overflow, return false.
-    if (next_capacity < list->capacity) return false;
-
-    // If we didn't get enough by doubling, keep doubling until we do.
+    // Guard against overflow on the doubling.
     while (requested_size > next_capacity) {
-        size_t double_capacity = next_capacity * 2;
-
-        // Ensure we didn't overflow by multiplying by 2.
-        if (double_capacity < next_capacity) return false;
-        next_capacity = double_capacity;
+        if (next_capacity == 0) abort();
+        next_capacity *= 2;
     }
 
-    pm_node_t **nodes = (pm_node_t **) xrealloc(list->nodes, sizeof(pm_node_t *) * next_capacity);
-    if (nodes == NULL) return false;
+    // Allocate a new array from the arena (old array is abandoned).
+    pm_node_t **nodes = (pm_node_t **) pm_arena_alloc(arena, sizeof(pm_node_t *) * next_capacity, PRISM_ALIGNOF(pm_node_t *));
+
+    // Copy old data into the new array.
+    if (list->size > 0) {
+        memcpy(nodes, list->nodes, list->size * sizeof(pm_node_t *));
+    }
 
     list->nodes = nodes;
     list->capacity = next_capacity;
-    return true;
 }
 
 /**
- * Append a new node onto the end of the node list.
+ * Slow path for pm_node_list_append: grow the list and append the node.
+ * Do not call directly - use pm_node_list_append instead.
  */
 void
-pm_node_list_append(pm_node_list_t *list, pm_node_t *node) {
-    if (pm_node_list_grow(list, 1)) {
-        list->nodes[list->size++] = node;
-    }
+pm_node_list_append_slow(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node) {
+    pm_node_list_grow(arena, list, 1);
+    list->nodes[list->size++] = node;
 }
 
 /**
  * Prepend a new node onto the beginning of the node list.
  */
 void
-pm_node_list_prepend(pm_node_list_t *list, pm_node_t *node) {
-    if (pm_node_list_grow(list, 1)) {
-        memmove(list->nodes + 1, list->nodes, list->size * sizeof(pm_node_t *));
-        list->nodes[0] = node;
-        list->size++;
-    }
+pm_node_list_prepend(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node) {
+    pm_node_list_grow(arena, list, 1);
+    memmove(list->nodes + 1, list->nodes, list->size * sizeof(pm_node_t *));
+    list->nodes[0] = node;
+    list->size++;
 }
 
 /**
  * Concatenate the given node list onto the end of the other node list.
  */
 void
-pm_node_list_concat(pm_node_list_t *list, pm_node_list_t *other) {
-    if (other->size > 0 && pm_node_list_grow(list, other->size)) {
+pm_node_list_concat(pm_arena_t *arena, pm_node_list_t *list, pm_node_list_t *other) {
+    if (other->size > 0) {
+        pm_node_list_grow(arena, list, other->size);
         memcpy(list->nodes + list->size, other->nodes, other->size * sizeof(pm_node_t *));
         list->size += other->size;
     }
 }
 
 /**
- * Free the internal memory associated with the given node list.
- */
-void
-pm_node_list_free(pm_node_list_t *list) {
-    if (list->capacity > 0) {
-        xfree(list->nodes);
-        *list = (pm_node_list_t) { 0 };
-    }
-}
-
-PRISM_EXPORTED_FUNCTION void
-pm_node_destroy(pm_parser_t *parser, pm_node_t *node);
-
-/**
- * Destroy the nodes that are contained within the given node list.
- */
-static void
-pm_node_list_destroy(pm_parser_t *parser, pm_node_list_t *list) {
-    pm_node_t *node;
-    PM_NODE_LIST_FOREACH(list, index, node) pm_node_destroy(parser, node);
-    pm_node_list_free(list);
-}
-
-/**
- * Deallocate the space for a pm_node_t. Similarly to pm_node_alloc, we're not
- * using the parser argument, but it's there to allow for the future possibility
- * of pre-allocating larger memory pools.
- */
-PRISM_EXPORTED_FUNCTION void
-pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
-    switch (PM_NODE_TYPE(node)) {
-        <%- nodes.each do |node| -%>
-#line <%= __LINE__ + 1 %> "prism/templates/src/<%= File.basename(__FILE__) %>"
-        case <%= node.type %>: {
-            <%- if node.fields.any? { |field| ![Prism::Template::LocationField, Prism::Template::OptionalLocationField, Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::ConstantField, Prism::Template::OptionalConstantField, Prism::Template::DoubleField].include?(field.class) } -%>
-            pm_<%= node.human %>_t *cast = (pm_<%= node.human %>_t *) node;
-            <%- end -%>
-            <%- node.fields.each do |field| -%>
-            <%- case field -%>
-            <%- when Prism::Template::LocationField, Prism::Template::OptionalLocationField, Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::ConstantField, Prism::Template::OptionalConstantField, Prism::Template::DoubleField -%>
-            <%- when Prism::Template::NodeField -%>
-            pm_node_destroy(parser, (pm_node_t *)cast-><%= field.name %>);
-            <%- when Prism::Template::OptionalNodeField -%>
-            if (cast-><%= field.name %> != NULL) {
-                pm_node_destroy(parser, (pm_node_t *)cast-><%= field.name %>);
-            }
-            <%- when Prism::Template::StringField -%>
-            pm_string_free(&cast-><%= field.name %>);
-            <%- when Prism::Template::NodeListField -%>
-            pm_node_list_destroy(parser, &cast-><%= field.name %>);
-            <%- when Prism::Template::ConstantListField -%>
-            pm_constant_id_list_free(&cast-><%= field.name %>);
-            <%- when Prism::Template::IntegerField -%>
-            pm_integer_free(&cast-><%= field.name %>);
-            <%- else -%>
-            <%- raise -%>
-            <%- end -%>
-            <%- end -%>
-            break;
-        }
-        <%- end -%>
-#line <%= __LINE__ + 1 %> "prism/templates/src/<%= File.basename(__FILE__) %>"
-        default:
-            assert(false && "unreachable");
-            break;
-    }
-    xfree(node);
-}
-
-/**
  * Returns a string representation of the given node type.
  */
-PRISM_EXPORTED_FUNCTION const char *
-pm_node_type_to_str(pm_node_type_t node_type)
+const char *
+pm_node_type(pm_node_type_t node_type)
 {
     switch (node_type) {
 <%- nodes.each do |node| -%>
@@ -166,7 +98,7 @@ pm_node_type_to_str(pm_node_type_t node_type)
  * pointer and is passed to the visitor callback for consumers to use as they
  * see fit.
  */
-PRISM_EXPORTED_FUNCTION void
+void
 pm_visit_node(const pm_node_t *node, bool (*visitor)(const pm_node_t *node, void *data), void *data) {
     if (visitor(node, data)) pm_visit_child_nodes(node, visitor, data);
 }
@@ -176,7 +108,7 @@ pm_visit_node(const pm_node_t *node, bool (*visitor)(const pm_node_t *node, void
  * default behavior for walking the tree that is called from pm_visit_node if
  * the callback returns true.
  */
-PRISM_EXPORTED_FUNCTION void
+void
 pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *node, void *data), void *data) {
     switch (PM_NODE_TYPE(node)) {
         <%- nodes.each do |node| -%>
@@ -212,122 +144,23 @@ pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *nod
             break;
     }
 }
+<%- nodes.each do |node| -%>
 
-// We optionally support dumping to JSON. For systems that don't want or need
-// this functionality, it can be turned off with the PRISM_EXCLUDE_JSON define.
-#ifndef PRISM_EXCLUDE_JSON
-
-static void
-pm_dump_json_constant(pm_buffer_t *buffer, const pm_parser_t *parser, pm_constant_id_t constant_id) {
-    const pm_constant_t *constant = pm_constant_pool_id_to_constant(&parser->constant_pool, constant_id);
-    pm_buffer_append_byte(buffer, '"');
-    pm_buffer_append_source(buffer, constant->start, constant->length, PM_BUFFER_ESCAPING_JSON);
-    pm_buffer_append_byte(buffer, '"');
-}
-
-static void
-pm_dump_json_location(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_location_t *location) {
-    uint32_t start = (uint32_t) (location->start - parser->start);
-    uint32_t end = (uint32_t) (location->end - parser->start);
-    pm_buffer_append_format(buffer, "{\"start\":%" PRIu32 ",\"end\":%" PRIu32 "}", start, end);
-}
-
+<%- params = node.fields.map(&:c_param) -%>
 /**
- * Dump JSON to the given buffer.
+ * Allocate and initialize a new <%= node.name %> node.
  */
-PRISM_EXPORTED_FUNCTION void
-pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *node) {
-    switch (PM_NODE_TYPE(node)) {
-        <%- nodes.each do |node| -%>
-        case <%= node.type %>: {
-            pm_buffer_append_string(buffer, "{\"type\":\"<%= node.name %>\",\"location\":", <%= node.name.bytesize + 22 %>);
-
-            const pm_<%= node.human %>_t *cast = (const pm_<%= node.human %>_t *) node;
-            pm_dump_json_location(buffer, parser, &cast->base.location);
-            <%- [*node.flags, *node.fields].each_with_index do |field, index| -%>
-
-            // Dump the <%= field.name %> field
-            pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"<%= field.name %>\":", <%= field.name.bytesize + 3 %>);
-            <%- case field -%>
-            <%- when Prism::Template::NodeField -%>
-            pm_dump_json(buffer, parser, (const pm_node_t *) cast-><%= field.name %>);
-            <%- when Prism::Template::OptionalNodeField -%>
-            if (cast-><%= field.name %> != NULL) {
-                pm_dump_json(buffer, parser, (const pm_node_t *) cast-><%= field.name %>);
-            } else {
-                pm_buffer_append_string(buffer, "null", 4);
-            }
-            <%- when Prism::Template::NodeListField -%>
-            const pm_node_list_t *<%= field.name %> = &cast-><%= field.name %>;
-            pm_buffer_append_byte(buffer, '[');
-
-            for (size_t index = 0; index < <%= field.name %>->size; index++) {
-                if (index != 0) pm_buffer_append_byte(buffer, ',');
-                pm_dump_json(buffer, parser, <%= field.name %>->nodes[index]);
-            }
-            pm_buffer_append_byte(buffer, ']');
-            <%- when Prism::Template::StringField -%>
-            const pm_string_t *<%= field.name %> = &cast-><%= field.name %>;
-            pm_buffer_append_byte(buffer, '"');
-            pm_buffer_append_source(buffer, pm_string_source(<%= field.name %>), pm_string_length(<%= field.name %>), PM_BUFFER_ESCAPING_JSON);
-            pm_buffer_append_byte(buffer, '"');
-            <%- when Prism::Template::ConstantField -%>
-            pm_dump_json_constant(buffer, parser, cast-><%= field.name %>);
-            <%- when Prism::Template::OptionalConstantField -%>
-            if (cast-><%= field.name %> != PM_CONSTANT_ID_UNSET) {
-                pm_dump_json_constant(buffer, parser, cast-><%= field.name %>);
-            } else {
-                pm_buffer_append_string(buffer, "null", 4);
-            }
-            <%- when Prism::Template::ConstantListField -%>
-            const pm_constant_id_list_t *<%= field.name %> = &cast-><%= field.name %>;
-            pm_buffer_append_byte(buffer, '[');
-
-            for (size_t index = 0; index < <%= field.name %>->size; index++) {
-                if (index != 0) pm_buffer_append_byte(buffer, ',');
-                pm_dump_json_constant(buffer, parser, <%= field.name %>->ids[index]);
-            }
-            pm_buffer_append_byte(buffer, ']');
-            <%- when Prism::Template::LocationField -%>
-            pm_dump_json_location(buffer, parser, &cast-><%= field.name %>);
-            <%- when Prism::Template::OptionalLocationField -%>
-            if (cast-><%= field.name %>.start != NULL) {
-                pm_dump_json_location(buffer, parser, &cast-><%= field.name %>);
-            } else {
-                pm_buffer_append_string(buffer, "null", 4);
-            }
-            <%- when Prism::Template::UInt8Field -%>
-            pm_buffer_append_format(buffer, "%" PRIu8, cast-><%= field.name %>);
-            <%- when Prism::Template::UInt32Field -%>
-            pm_buffer_append_format(buffer, "%" PRIu32, cast-><%= field.name %>);
-            <%- when Prism::Template::Flags -%>
-            size_t flags = 0;
-            pm_buffer_append_byte(buffer, '[');
-            <%- node.flags.values.each_with_index do |value, index| -%>
-            if (PM_NODE_FLAG_P(cast, PM_<%= node.flags.human.upcase %>_<%= value.name %>)) {
-                if (flags != 0) pm_buffer_append_byte(buffer, ',');
-                pm_buffer_append_string(buffer, "\"<%= value.name %>\"", <%= value.name.bytesize + 2 %>);
-                flags++;
-            }
-            <%- end -%>
-            pm_buffer_append_byte(buffer, ']');
-            <%- when Prism::Template::IntegerField -%>
-            pm_integer_string(buffer, &cast-><%= field.name %>);
-            <%- when Prism::Template::DoubleField -%>
-            pm_buffer_append_format(buffer, "%f", cast-><%= field.name %>);
-            <%- else -%>
-            <%- raise %>
-            <%- end -%>
-            <%- end -%>
+pm_<%= node.human %>_t *
+pm_<%= node.human %>_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location<%= params.empty? ? "" : ", #{params.join(", ")}" %>) {
+    pm_<%= node.human %>_t *node = (pm_<%= node.human %>_t *) pm_arena_alloc(arena, sizeof(pm_<%= node.human %>_t), PRISM_ALIGNOF(pm_<%= node.human %>_t));
+
+    *node = (pm_<%= node.human %>_t) {
+        .base = { .type = <%= node.type %>, .flags = flags, .node_id = node_id, .location = location }<%= node.fields.empty? ? "" : "," %>
+<%- node.fields.each_with_index do |field, index| -%>
+        .<%= field.name %> = <%= field.name %><%= index < node.fields.size - 1 ? "," : "" %>
+<%- end -%>
+    };
 
-            pm_buffer_append_byte(buffer, '}');
-            break;
-        }
-        <%- end -%>
-        case PM_SCOPE_NODE:
-            break;
-    }
+    return node;
 }
-
-#endif
+<%- end -%>