herb 0.11.1 → 0.11.2

data/src/analyze/postfix_conditionals.c

@@ -9,6 +9,7 @@
 #include "../include/lib/hb_array.h"
 #include "../include/lib/hb_string.h"
 #include "../include/prism/herb_prism_node.h"
+#include "../include/prism/prism_helpers.h"
 #include "../include/visitor.h"
 
 #include <prism.h>
@@ -27,11 +28,17 @@ static pm_node_t* find_postfix_conditional_statement(analyzed_ruby_T* analyzed)
   if (statement->type == PM_IF_NODE) {
     pm_if_node_t* if_node = (pm_if_node_t*) statement;
 
-    if (if_node->if_keyword_loc.start != NULL && if_node->end_keyword_loc.start == NULL) { return statement; }
+    if (herb_prism_location_assigned(if_node->if_keyword_loc)
+        && !herb_prism_location_assigned(if_node->end_keyword_loc)) {
+      return statement;
+    }
   } else if (statement->type == PM_UNLESS_NODE) {
     pm_unless_node_t* unless_node = (pm_unless_node_t*) statement;
 
-    if (unless_node->keyword_loc.start != NULL && unless_node->end_keyword_loc.start == NULL) { return statement; }
+    if (herb_prism_location_assigned(unless_node->unless_keyword_loc)
+        && !herb_prism_location_assigned(unless_node->end_keyword_loc)) {
+      return statement;
+    }
   }
 
   return NULL;
@@ -55,11 +62,11 @@ static body_info_T extract_statements_body_info(
   pm_node_t* first = statements->body.nodes[0];
   pm_node_t* last = statements->body.nodes[statements->body.size - 1];
 
-  const uint8_t* start = first->location.start;
-  const uint8_t* end = last->location.end;
+  const uint8_t* parser_start = pm_parser_start(analyzed->parser);
+  size_t source_length = (size_t) (pm_parser_end(analyzed->parser) - parser_start);
 
-  const uint8_t* parser_start = analyzed->parser.start;
-  size_t source_length = (size_t) (analyzed->parser.end - parser_start);
+  const uint8_t* start = herb_prism_location_start_pointer(parser_start, first->location);
+  const uint8_t* end = herb_prism_location_end_pointer(parser_start, last->location);
 
   if (start < parser_start || end > parser_start + source_length) { return info; }
 
@@ -98,13 +105,13 @@ static body_info_T extract_body_info(
 
     hb_allocator_dealloc(allocator, (void*) info.source);
 
-    info.source = hb_allocator_strndup(allocator, (const char*) analyzed->parser.start, info.length);
+    info.source = hb_allocator_strndup(allocator, (const char*) pm_parser_start(analyzed->parser), info.length);
   }
 
   return info;
 }
 
-static char* extract_condition_source(pm_node_t* conditional_node, hb_allocator_T* allocator) {
+static char* extract_condition_source(const uint8_t* source, pm_node_t* conditional_node, hb_allocator_T* allocator) {
   pm_node_t* predicate = NULL;
 
   if (conditional_node->type == PM_IF_NODE) {
@@ -115,9 +122,11 @@ static char* extract_condition_source(pm_node_t* conditional_node, hb_allocator_
 
   if (!predicate) { return NULL; }
 
-  size_t length = (size_t) (predicate->location.end - predicate->location.start);
-
-  return hb_allocator_strndup(allocator, (const char*) predicate->location.start, length);
+  return hb_allocator_strndup(
+    allocator,
+    (const char*) (source + predicate->location.start),
+    predicate->location.length
+  );
 }
 
 static const char* condition_keyword(pm_node_t* conditional_node) {
@@ -150,7 +159,7 @@ static pm_if_node_t* find_nested_ternary(pm_node_t* conditional_node) {
 
   pm_if_node_t* if_node = (pm_if_node_t*) body_node;
 
-  if (if_node->if_keyword_loc.start == NULL && if_node->subsequent != NULL) { return if_node; }
+  if (!herb_prism_location_assigned(if_node->if_keyword_loc) && if_node->subsequent != NULL) { return if_node; }
 
   return NULL;
 }
@@ -215,7 +224,8 @@ static AST_NODE_T* transform_conditional(
   static_output_node_type_T static_node_type,
   hb_allocator_T* allocator
 ) {
-  char* condition_source = extract_condition_source(conditional_node, allocator);
+  char* condition_source =
+    extract_condition_source(pm_parser_start(erb_node->analyzed_ruby->parser), conditional_node, allocator);
   if (!condition_source) { return NULL; }
 
   const char* keyword = condition_keyword(conditional_node);

data/src/analyze/prism_annotate.c

@@ -8,6 +8,7 @@
 #include "../include/parser/parser.h"
 #include "../include/prism/herb_prism_node.h"
 #include "../include/prism/prism_context.h"
+#include "../include/prism/prism_helpers.h"
 #include "../include/visitor.h"
 
 #include <prism.h>
@@ -204,10 +205,10 @@ static void set_prism_node(AST_NODE_T* node, herb_prism_node_T prism_ref) {
   }
 }
 
-static size_t prism_node_start(pm_parser_t* parser, hb_narray_T* node_list, size_t index) {
+static size_t prism_node_start(hb_narray_T* node_list, size_t index) {
   pm_node_t* prism_node = *(pm_node_t**) hb_narray_get(node_list, index);
 
-  return (size_t) (prism_node->location.start - parser->start);
+  return prism_node->location.start;
 }
 
 static herb_prism_node_T find_prism_node_for_herb_node(
@@ -229,17 +230,17 @@ static herb_prism_node_T find_prism_node_for_herb_node(
   while (low < high) {
     size_t middle = low + (high - low) / 2;
 
-    if (prism_node_start(parser, node_list, middle) < content_from) {
+    if (prism_node_start(node_list, middle) < content_from) {
       low = middle + 1;
     } else {
       high = middle;
     }
   }
 
-  if (low >= hb_narray_size(node_list) || prism_node_start(parser, node_list, low) >= content_to) { return result; }
+  if (low >= hb_narray_size(node_list) || prism_node_start(node_list, low) >= content_to) { return result; }
 
   pm_node_t* prism_node = *(pm_node_t**) hb_narray_get(node_list, low);
-  size_t prism_end = (size_t) (prism_node->location.end - parser->start);
+  size_t prism_end = (size_t) prism_node->location.start + prism_node->location.length;
 
   result.node = prism_node;
   result.parser = parser;
@@ -332,23 +333,21 @@ void herb_annotate_prism_nodes(
     return;
   }
 
-  memset(&context->pm_opts, 0, sizeof(pm_options_t));
-  pm_options_line_set(&context->pm_opts, 1);
-  pm_options_partial_script_set(&context->pm_opts, true);
-  pm_parser_init(
-    &context->parser,
-    (const uint8_t*) context->ruby_buf.value,
-    context->ruby_buf.length,
-    &context->pm_opts
-  );
-  context->root = pm_parse(&context->parser);
+  context->arena = pm_arena_new();
+  context->pm_opts = pm_options_new();
+  pm_options_line_set(context->pm_opts, 1);
+  pm_options_partial_script_set(context->pm_opts, true);
+  herb_prism_options_set_ruby_version(context->pm_opts, options);
+  context->parser =
+    pm_parser_new(context->arena, (const uint8_t*) context->ruby_buf.value, context->ruby_buf.length, context->pm_opts);
+  context->root = pm_parse(context->parser);
 
   if (!context->root || context->root->type != PM_PROGRAM_NODE) {
-    pm_node_destroy(&context->parser, context->root);
     context->root = NULL;
 
-    pm_parser_free(&context->parser);
-    pm_options_free(&context->pm_opts);
+    pm_parser_free(context->parser);
+    pm_arena_free(context->arena);
+    pm_options_free(context->pm_opts);
 
     hb_buffer_free(&context->ruby_buf);
     hb_allocator_dealloc(allocator, context);
@@ -361,7 +360,7 @@ void herb_annotate_prism_nodes(
   if (prism_program) {
     herb_prism_node_T program_ref = {
       .node = context->root,
-      .parser = &context->parser,
+      .parser = context->parser,
     };
 
     document->prism_node = program_ref;
@@ -393,18 +392,20 @@ void herb_annotate_prism_nodes(
           }
         }
 
-        memset(&context->structural_pm_opts, 0, sizeof(pm_options_t));
-        pm_options_line_set(&context->structural_pm_opts, 1);
-        pm_options_partial_script_set(&context->structural_pm_opts, true);
+        context->structural_arena = pm_arena_new();
+        context->structural_pm_opts = pm_options_new();
+        pm_options_line_set(context->structural_pm_opts, 1);
+        pm_options_partial_script_set(context->structural_pm_opts, true);
+        herb_prism_options_set_ruby_version(context->structural_pm_opts, options);
 
-        pm_parser_init(
-          &context->structural_parser,
+        context->structural_parser = pm_parser_new(
+          context->structural_arena,
           (const uint8_t*) context->structural_buf.value,
           context->structural_buf.length,
-          &context->structural_pm_opts
+          context->structural_pm_opts
         );
 
-        context->structural_root = pm_parse(&context->structural_parser);
+        context->structural_root = pm_parse(context->structural_parser);
         context->has_structural = true;
 
         if (context->structural_root && context->structural_root->type == PM_PROGRAM_NODE) {
@@ -416,8 +417,8 @@ void herb_annotate_prism_nodes(
     }
 
     prism_annotate_context_T annotate_context = {
-      .parser = &context->parser,
-      .structural_parser = prism_nodes_deep ? &context->parser : &context->structural_parser,
+      .parser = context->parser,
+      .structural_parser = prism_nodes_deep ? context->parser : context->structural_parser,
       .node_list = &node_list,
       .structural_node_list = prism_nodes_deep ? &node_list : &structural_node_list,
       .prism_nodes_deep = prism_nodes_deep,

data/src/analyze/render_nodes.c

@@ -13,6 +13,8 @@
 #include "../include/lib/string.h"
 #include "../include/visitor.h"
 
+#include "../include/prism/prism_helpers.h"
+
 #include <prism.h>
 #include <stdbool.h>
 #include <string.h>
@@ -50,9 +52,10 @@ static bool is_render_call(pm_call_node_t* call_node, pm_parser_t* parser) {
   if (!call_node || !call_node->name) { return false; }
   if (call_node->receiver && call_node->receiver->type != PM_SELF_NODE) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-  return constant && constant->length == 6 && strncmp((const char*) constant->start, "render", 6) == 0;
+  return constant && pm_constant_length(constant) == 6
+      && strncmp((const char*) pm_constant_start(constant), "render", 6) == 0;
 }
 
 static pm_call_node_t* find_render_call(pm_node_t* node, pm_parser_t* parser) {
@@ -117,11 +120,14 @@ static char* extract_string_value(pm_node_t* node, hb_allocator_T* allocator) {
   return NULL;
 }
 
-static char* extract_source_expression(pm_node_t* node, hb_allocator_T* allocator) {
+static char* extract_source_expression(const uint8_t* erb_content_source, pm_node_t* node, hb_allocator_T* allocator) {
   if (!node) { return NULL; }
 
-  size_t length = node->location.end - node->location.start;
-  return hb_allocator_strndup(allocator, (const char*) node->location.start, length);
+  return hb_allocator_strndup(
+    allocator,
+    (const char*) (erb_content_source + node->location.start),
+    node->location.length
+  );
 }
 
 static token_T* create_token_from_prism_node(
@@ -137,8 +143,8 @@ static token_T* create_token_from_prism_node(
   position_T end = { .line = 1, .column = 1 };
 
   if (node && source && erb_content_source) {
-    size_t start_offset_in_erb = (size_t) (node->location.start - erb_content_source);
-    size_t end_offset_in_erb = (size_t) (node->location.end - erb_content_source);
+    size_t start_offset_in_erb = node->location.start;
+    size_t end_offset_in_erb = herb_prism_location_end(node->location);
 
     size_t total_start = erb_content_offset + start_offset_in_erb;
     size_t total_end = erb_content_offset + end_offset_in_erb;
@@ -160,6 +166,7 @@ static pm_keyword_hash_node_t* find_keyword_hash(pm_arguments_node_t* arguments)
 }
 
 static keyword_result_T find_keyword_value(
+  const uint8_t* erb_content_source,
   pm_keyword_hash_node_t* keyword_hash,
   const char* key,
   hb_allocator_T* allocator
@@ -184,7 +191,7 @@ static keyword_result_T find_keyword_value(
       if (string_value) {
         result.value = string_value;
       } else {
-        result.value = extract_source_expression(assoc->value, allocator);
+        result.value = extract_source_expression(erb_content_source, assoc->value, allocator);
       }
 
       return result;
@@ -228,11 +235,12 @@ static bool extract_assoc_parts(
   AST_RUBY_LITERAL_NODE_T** value_node
 ) {
   char* name = extract_string_value(assoc->key, allocator);
-  if (!name) { name = extract_source_expression(assoc->key, allocator); }
+  if (!name) { name = extract_source_expression(erb_content_source, assoc->key, allocator); }
   if (!name) { return false; }
 
   bool shorthand = assoc->value && assoc->value->type == PM_IMPLICIT_NODE;
-  char* value = shorthand ? hb_allocator_strdup(allocator, name) : extract_source_expression(assoc->value, allocator);
+  char* value = shorthand ? hb_allocator_strdup(allocator, name)
+                          : extract_source_expression(erb_content_source, assoc->value, allocator);
 
   if (!value) {
     hb_allocator_dealloc(allocator, name);
@@ -254,8 +262,8 @@ static bool extract_assoc_parts(
   pm_node_t* spanned = shorthand ? assoc->key : assoc->value;
 
   if (spanned && source && erb_content_source) {
-    size_t start_offset = (size_t) (spanned->location.start - erb_content_source);
-    size_t end_offset = (size_t) (spanned->location.end - erb_content_source);
+    size_t start_offset = spanned->location.start;
+    size_t end_offset = herb_prism_location_end(spanned->location);
 
     if (shorthand && end_offset > start_offset && erb_content_source[end_offset - 1] == ':') { end_offset--; }
 
@@ -348,7 +356,7 @@ static token_T* extract_keyword_token(
   const uint8_t* erb_content_source,
   hb_allocator_T* allocator
 ) {
-  keyword_result_T keyword = find_keyword_value(keyword_hash, keyword_name, allocator);
+  keyword_result_T keyword = find_keyword_value(erb_content_source, keyword_hash, keyword_name, allocator);
   if (!keyword.value) { return NULL; }
 
   token_T* token = create_token_from_prism_node(
@@ -405,7 +413,7 @@ static void append_unusable_state_entry(
   hb_allocator_T* allocator
 ) {
   pm_node_t* named = element->type == PM_ASSOC_NODE ? ((pm_assoc_node_t*) element)->key : element;
-  char* name = extract_source_expression(named, allocator);
+  char* name = extract_source_expression(erb_content_source, named, allocator);
 
   if (!name) { return; }
 
@@ -423,8 +431,8 @@ static void append_unusable_state_entry(
   position_T end = start;
 
   if (source && erb_content_source) {
-    size_t start_offset = (size_t) (element->location.start - erb_content_source);
-    size_t end_offset = (size_t) (element->location.end - erb_content_source);
+    size_t start_offset = element->location.start;
+    size_t end_offset = herb_prism_location_end(element->location);
 
     start = byte_offset_to_position(source, erb_content_offset + start_offset);
     end = byte_offset_to_position(source, erb_content_offset + end_offset);
@@ -512,8 +520,8 @@ static location_T* prism_node_location(
 ) {
   if (!node || !source || !erb_content_source) { return NULL; }
 
-  size_t start_offset = (size_t) (node->location.start - erb_content_source);
-  size_t end_offset = (size_t) (node->location.end - erb_content_source);
+  size_t start_offset = node->location.start;
+  size_t end_offset = herb_prism_location_end(node->location);
 
   return location_create(
     byte_offset_to_position(source, erb_content_offset + start_offset),
@@ -595,7 +603,7 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
         hb_allocator_dealloc(allocator, partial_string);
       }
     } else if (first_argument->type != PM_KEYWORD_HASH_NODE) {
-      char* object_string = extract_source_expression(first_argument, allocator);
+      char* object_string = extract_source_expression(erb_content_source, first_argument, allocator);
 
       if (object_string) {
         object = create_token_from_prism_node(
@@ -614,7 +622,7 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
 
   if (keyword_hash) {
     if (has_positional_partial) {
-      keyword_result_T partial_kw = find_keyword_value(keyword_hash, "partial", allocator);
+      keyword_result_T partial_kw = find_keyword_value(erb_content_source, keyword_hash, "partial", allocator);
       if (partial_kw.value) { has_keyword_partial = true; }
 
       pm_hash_node_t* locals_hash = find_locals_hash(keyword_hash, allocator);
@@ -691,7 +699,7 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
   hb_array_T* errors = NULL;
 
   if (!has_keyword_partial && partial && keyword_hash) {
-    keyword_result_T locals_keyword = find_keyword_value(keyword_hash, "locals", allocator);
+    keyword_result_T locals_keyword = find_keyword_value(erb_content_source, keyword_hash, "locals", allocator);
 
     if (locals_keyword.value) {
       hb_string_T partial_name = partial->value;
@@ -797,7 +805,7 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
   }
 
   if (has_positional_partial && has_keyword_partial && keyword_hash) {
-    keyword_result_T keyword_partial = find_keyword_value(keyword_hash, "partial", allocator);
+    keyword_result_T keyword_partial = find_keyword_value(erb_content_source, keyword_hash, "partial", allocator);
 
     append_render_conflicting_partial_error(
       partial->value,
@@ -875,7 +883,7 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
     pm_block_node_t* inline_block = find_block_on_render_call(call_node);
 
     if (inline_block) {
-      const uint8_t* content_source = erb_content_source ? erb_content_source : (const uint8_t*) parser->start;
+      const uint8_t* content_source = erb_content_source ? erb_content_source : pm_parser_start(parser);
 
       if (inline_block->parameters && inline_block->parameters->type == PM_BLOCK_PARAMETERS_NODE) {
         pm_block_parameters_node_t* block_parameters = (pm_block_parameters_node_t*) inline_block->parameters;
@@ -893,16 +901,18 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
       }
 
       if (inline_block->body) {
-        size_t body_length = (size_t) (inline_block->body->location.end - inline_block->body->location.start);
-        char* body_source =
-          hb_allocator_strndup(allocator, (const char*) inline_block->body->location.start, body_length);
+        char* body_source = hb_allocator_strndup(
+          allocator,
+          (const char*) (content_source + inline_block->body->location.start),
+          inline_block->body->location.length
+        );
 
         position_T body_start = { .line = 1, .column = 1 };
         position_T body_end = { .line = 1, .column = 1 };
 
         if (source && content_source) {
-          size_t start_offset = (size_t) (inline_block->body->location.start - content_source);
-          size_t end_offset = (size_t) (inline_block->body->location.end - content_source);
+          size_t start_offset = inline_block->body->location.start;
+          size_t end_offset = herb_prism_location_end(inline_block->body->location);
           body_start = byte_offset_to_position(source, erb_content_offset + start_offset);
           body_end = byte_offset_to_position(source, erb_content_offset + end_offset);
         }
@@ -1012,7 +1022,7 @@ static AST_ERB_RENDER_NODE_T* try_transform_content_node(
   if (is_erb_comment_tag(erb_node->tag_opening)) { return NULL; }
   if (token_is_escaped_erb_tag_opening(erb_node->tag_opening)) { return NULL; }
 
-  pm_call_node_t* render_call = find_render_call(erb_node->analyzed_ruby->root, &erb_node->analyzed_ruby->parser);
+  pm_call_node_t* render_call = find_render_call(erb_node->analyzed_ruby->root, erb_node->analyzed_ruby->parser);
   if (!render_call) { return NULL; }
 
   size_t erb_content_offset = 0;
@@ -1021,12 +1031,12 @@ static AST_ERB_RENDER_NODE_T* try_transform_content_node(
     erb_content_offset = calculate_byte_offset_from_pos(context->source, erb_node->content->location.start);
   }
 
-  const uint8_t* erb_content_source = (const uint8_t*) erb_node->analyzed_ruby->parser.start;
+  const uint8_t* erb_content_source = pm_parser_start(erb_node->analyzed_ruby->parser);
 
   return create_render_node_from_call(
     erb_node,
     render_call,
-    &erb_node->analyzed_ruby->parser,
+    erb_node->analyzed_ruby->parser,
     context->source,
     erb_content_offset,
     erb_content_source,
@@ -1046,15 +1056,15 @@ static AST_ERB_RENDER_NODE_T* try_transform_block_node(
   const char* ruby_source = block_node->content->value.data;
   size_t ruby_length = block_node->content->value.length;
 
-  pm_parser_t parser;
-  pm_parser_init(&parser, (const uint8_t*) ruby_source, ruby_length, NULL);
-  pm_node_t* root = pm_parse(&parser);
+  pm_arena_t* arena = pm_arena_new();
+  pm_parser_t* parser = herb_prism_parser_new(arena, (const uint8_t*) ruby_source, ruby_length, context->options);
+  pm_node_t* root = pm_parse(parser);
 
-  pm_call_node_t* render_call = find_render_call(root, &parser);
+  pm_call_node_t* render_call = find_render_call(root, parser);
 
   if (!render_call) {
-    pm_node_destroy(&parser, root);
-    pm_parser_free(&parser);
+    pm_parser_free(parser);
+    pm_arena_free(arena);
     return NULL;
   }
 
@@ -1075,7 +1085,7 @@ static AST_ERB_RENDER_NODE_T* try_transform_block_node(
     erb_content_offset = calculate_byte_offset_from_pos(context->source, block_node->content->location.start);
   }
 
-  const uint8_t* erb_content_source = (const uint8_t*) parser.start;
+  const uint8_t* erb_content_source = pm_parser_start(parser);
 
   render_block_fields_T block_fields = {
     .block_body = block_node->body,
@@ -1089,7 +1099,7 @@ static AST_ERB_RENDER_NODE_T* try_transform_block_node(
   AST_ERB_RENDER_NODE_T* render_node = create_render_node_from_call(
     &content_view,
     render_call,
-    &parser,
+    parser,
     context->source,
     erb_content_offset,
     erb_content_source,
@@ -1098,8 +1108,8 @@ static AST_ERB_RENDER_NODE_T* try_transform_block_node(
     context->options
   );
 
-  pm_node_destroy(&parser, root);
-  pm_parser_free(&parser);
+  pm_parser_free(parser);
+  pm_arena_free(arena);
 
   return render_node;
 }

data/src/analyze/strict_locals.c

@@ -16,6 +16,7 @@
 #include "../include/prism/prism_helpers.h"
 
 #include <prism.h>
+#include <prism/internal/diagnostic.h>
 #include <stdbool.h>
 #include <string.h>
 
@@ -211,17 +212,16 @@ static AST_ERB_STRICT_LOCALS_NODE_T* create_strict_locals_node(
   hb_buffer_T synthetic_buffer;
   if (!build_synthetic_ruby(params_open, params_length, &synthetic_buffer, allocator)) { return NULL; }
 
-  pm_parser_t parser;
-  pm_options_t options = { 0 };
-  pm_parser_init(
-    &parser,
+  pm_arena_t* arena = pm_arena_new();
+  pm_parser_t* parser = herb_prism_parser_new(
+    arena,
     (const uint8_t*) hb_buffer_value(&synthetic_buffer),
     hb_buffer_length(&synthetic_buffer),
-    &options
+    parser_options
   );
-  pm_node_t* root = pm_parse(&parser);
+  pm_node_t* root = pm_parse(parser);
 
-  const uint8_t* synthetic_start = parser.start;
+  const uint8_t* synthetic_start = pm_parser_start(parser);
 
   pm_parameters_node_t* params_node = find_parameters_node(root);
   size_t erb_content_byte_offset = calculate_byte_offset_from_position(source, erb_node->content->location.start);
@@ -230,12 +230,12 @@ static AST_ERB_STRICT_LOCALS_NODE_T* create_strict_locals_node(
   size_t params_in_content = (size_t) (params_open - content_bytes);
   size_t prefix_length = strlen(SYNTHETIC_PREFIX);
 
-  for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser.error_list.head; error != NULL;
-       error = (const pm_diagnostic_t*) error->node.next) {
+  for (const pm_diagnostic_t* error = pm_parser_errors_first(parser); error != NULL;
+       error = pm_diagnostic_next(error)) {
     if (error->diag_id == PM_ERR_DEF_TERM) { continue; }
 
-    size_t error_start_in_synthetic = (size_t) (error->location.start - synthetic_start);
-    size_t error_end_in_synthetic = (size_t) (error->location.end - synthetic_start);
+    size_t error_start_in_synthetic = error->location.start;
+    size_t error_end_in_synthetic = herb_prism_location_end(error->location);
 
     size_t error_content_start =
       params_in_content + (error_start_in_synthetic > prefix_length ? error_start_in_synthetic - prefix_length : 0);
@@ -258,7 +258,7 @@ static AST_ERB_STRICT_LOCALS_NODE_T* create_strict_locals_node(
   } else {
     locals = extract_strict_locals(
       params_node,
-      &parser,
+      parser,
       source,
       erb_content_byte_offset,
       content_bytes,
@@ -270,9 +270,8 @@ static AST_ERB_STRICT_LOCALS_NODE_T* create_strict_locals_node(
     );
   }
 
-  pm_node_destroy(&parser, root);
-  pm_parser_free(&parser);
-  pm_options_free(&options);
+  pm_parser_free(parser);
+  pm_arena_free(arena);
   hb_buffer_free(&synthetic_buffer);
 
   return ast_erb_strict_locals_node_init(

data/src/analyze/ternary_conditionals.c

@@ -8,6 +8,7 @@
 #include "../include/lib/hb_array.h"
 #include "../include/lib/hb_string.h"
 #include "../include/prism/herb_prism_node.h"
+#include "../include/prism/prism_helpers.h"
 #include "../include/visitor.h"
 
 #include <prism.h>
@@ -26,7 +27,7 @@ static pm_node_t* find_ternary_statement(analyzed_ruby_T* analyzed) {
   if (statement->type != PM_IF_NODE) { return NULL; }
   pm_if_node_t* if_node = (pm_if_node_t*) statement;
 
-  if (if_node->if_keyword_loc.start == NULL && if_node->subsequent != NULL) { return statement; }
+  if (!herb_prism_location_assigned(if_node->if_keyword_loc) && if_node->subsequent != NULL) { return statement; }
 
   return NULL;
 }
@@ -49,11 +50,11 @@ static body_info_T extract_statements_body_info(
   pm_node_t* first = statements->body.nodes[0];
   pm_node_t* last = statements->body.nodes[statements->body.size - 1];
 
-  const uint8_t* start = first->location.start;
-  const uint8_t* end = last->location.end;
+  const uint8_t* parser_start = pm_parser_start(analyzed->parser);
+  size_t source_length = (size_t) (pm_parser_end(analyzed->parser) - parser_start);
 
-  const uint8_t* parser_start = analyzed->parser.start;
-  size_t source_length = (size_t) (analyzed->parser.end - parser_start);
+  const uint8_t* start = herb_prism_location_start_pointer(parser_start, first->location);
+  const uint8_t* end = herb_prism_location_end_pointer(parser_start, last->location);
 
   if (start < parser_start || end > parser_start + source_length) { return info; }
 
@@ -83,14 +84,16 @@ static body_info_T extract_statements_body_info(
   return info;
 }
 
-static char* extract_condition_source(pm_if_node_t* if_node, hb_allocator_T* allocator) {
+static char* extract_condition_source(const uint8_t* source, pm_if_node_t* if_node, hb_allocator_T* allocator) {
   pm_node_t* predicate = if_node->predicate;
 
   if (!predicate) { return NULL; }
 
-  size_t length = (size_t) (predicate->location.end - predicate->location.start);
-
-  return hb_allocator_strndup(allocator, (const char*) predicate->location.start, length);
+  return hb_allocator_strndup(
+    allocator,
+    (const char*) (source + predicate->location.start),
+    predicate->location.length
+  );
 }
 
 static bool append_branch_statement(
@@ -156,7 +159,8 @@ AST_NODE_T* transform_ternary_expression(
   pm_else_node_t* else_node = (pm_else_node_t*) if_node->subsequent;
   if (!else_node) { return NULL; }
 
-  char* condition_source = extract_condition_source(if_node, allocator);
+  char* condition_source =
+    extract_condition_source(pm_parser_start(erb_node->analyzed_ruby->parser), if_node, allocator);
   if (!condition_source) { return NULL; }
 
   position_T start = erb_node->base.location.start;

data/src/herb.c

@@ -7,6 +7,7 @@
 #include "include/lib/hb_allocator.h"
 #include "include/lib/hb_array.h"
 #include "include/parser/parser.h"
+#include "include/prism_version.h"
 #include "include/version.h"
 #include "include/visitor.h"
 
@@ -127,7 +128,7 @@ HERB_EXPORTED_FUNCTION const char* herb_version(void) {
 }
 
 HERB_EXPORTED_FUNCTION const char* herb_prism_version(void) {
-  return PRISM_VERSION;
+  return HERB_PRISM_VERSION;
 }
 
 HERB_EXPORTED_FUNCTION herb_ruby_parse_result_T* herb_parse_ruby(const char* source, size_t length) {
@@ -136,9 +137,11 @@ HERB_EXPORTED_FUNCTION herb_ruby_parse_result_T* herb_parse_ruby(const char* sou
   herb_ruby_parse_result_T* result = malloc(sizeof(herb_ruby_parse_result_T));
   if (!result) { return NULL; }
 
-  memset(&result->options, 0, sizeof(pm_options_t));
-  pm_parser_init(&result->parser, (const uint8_t*) source, length, &result->options);
-  result->root = pm_parse(&result->parser);
+  result->arena = pm_arena_new();
+  result->options = pm_options_new();
+  pm_options_line_set(result->options, 0);
+  result->parser = pm_parser_new(result->arena, (const uint8_t*) source, length, result->options);
+  result->root = pm_parse(result->parser);
 
   return result;
 }
@@ -146,9 +149,8 @@ HERB_EXPORTED_FUNCTION herb_ruby_parse_result_T* herb_parse_ruby(const char* sou
 HERB_EXPORTED_FUNCTION void herb_free_ruby_parse_result(herb_ruby_parse_result_T* result) {
   if (!result) { return; }
 
-  if (result->root) { pm_node_destroy(&result->parser, result->root); }
-
-  pm_parser_free(&result->parser);
-  pm_options_free(&result->options);
+  pm_parser_free(result->parser);
+  pm_arena_free(result->arena);
+  pm_options_free(result->options);
   free(result);
 }