herb 0.11.1 → 0.11.2

data/src/analyze/analyzed_ruby.c

@@ -1,18 +1,20 @@
 #include "../include/analyze/analyzed_ruby.h"
 #include "../include/lib/hb_string.h"
+#include "../include/prism/prism_helpers.h"
 
 #include <prism.h>
 #include <string.h>
 
-analyzed_ruby_T* init_analyzed_ruby(hb_string_T source) {
+analyzed_ruby_T* init_analyzed_ruby(hb_string_T source, const parser_options_T* options) {
   analyzed_ruby_T* analyzed = malloc(sizeof(analyzed_ruby_T));
 
   if (!analyzed) { return NULL; }
 
-  pm_parser_init(&analyzed->parser, (const uint8_t*) source.data, source.length, NULL);
+  analyzed->arena = pm_arena_new();
+  analyzed->parser = herb_prism_parser_new(analyzed->arena, (const uint8_t*) source.data, source.length, options);
 
-  analyzed->root = pm_parse(&analyzed->parser);
-  analyzed->valid = (analyzed->parser.error_list.size == 0);
+  analyzed->root = pm_parse(analyzed->parser);
+  analyzed->valid = (pm_parser_errors_size(analyzed->parser) == 0);
   analyzed->parsed = true;
   analyzed->if_node_count = 0;
   analyzed->elsif_node_count = 0;
@@ -43,9 +45,8 @@ analyzed_ruby_T* init_analyzed_ruby(hb_string_T source) {
 void free_analyzed_ruby(analyzed_ruby_T* analyzed) {
   if (!analyzed) { return; }
 
-  if (analyzed->parsed && analyzed->root != NULL) { pm_node_destroy(&analyzed->parser, analyzed->root); }
-
-  pm_parser_free(&analyzed->parser);
+  pm_parser_free(analyzed->parser);
+  pm_arena_free(analyzed->arena);
 
   free(analyzed);
 }

data/src/analyze/control_type.c

@@ -6,6 +6,8 @@
 #include "../include/errors.h"
 #include "../include/lib/hb_array.h"
 
+#include "../include/prism/prism_helpers.h"
+
 #include <prism.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -29,8 +31,8 @@ static bool control_type_is_yield(control_type_t type) {
   return type == CONTROL_TYPE_YIELD;
 }
 
-static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* data) {
-  if (!node) { return true; }
+static pm_visit_result_t find_earliest_control_keyword_walker(const pm_node_t* node, void* data) {
+  if (!node) { return PM_VISIT_DESCEND; }
 
   location_walker_context_T* context = (location_walker_context_T*) data;
   earliest_control_keyword_T* result = context->result;
@@ -41,50 +43,52 @@ static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* da
   switch (node->type) {
     case PM_IF_NODE: {
       pm_if_node_t* if_node = (pm_if_node_t*) node;
+      if (!herb_prism_location_assigned(if_node->if_keyword_loc)) { break; }
+
       current_type = CONTROL_TYPE_IF;
-      keyword_offset = (uint32_t) (if_node->if_keyword_loc.start - context->source_start);
+      keyword_offset = if_node->if_keyword_loc.start;
       break;
     }
 
     case PM_UNLESS_NODE: {
       pm_unless_node_t* unless_node = (pm_unless_node_t*) node;
       current_type = CONTROL_TYPE_UNLESS;
-      keyword_offset = (uint32_t) (unless_node->keyword_loc.start - context->source_start);
+      keyword_offset = unless_node->unless_keyword_loc.start;
       break;
     }
 
     case PM_CASE_NODE: {
       pm_case_node_t* case_node = (pm_case_node_t*) node;
       current_type = CONTROL_TYPE_CASE;
-      keyword_offset = (uint32_t) (case_node->case_keyword_loc.start - context->source_start);
+      keyword_offset = case_node->case_keyword_loc.start;
       break;
     }
 
     case PM_CASE_MATCH_NODE: {
       pm_case_match_node_t* case_match_node = (pm_case_match_node_t*) node;
       current_type = CONTROL_TYPE_CASE_MATCH;
-      keyword_offset = (uint32_t) (case_match_node->case_keyword_loc.start - context->source_start);
+      keyword_offset = case_match_node->case_keyword_loc.start;
       break;
     }
 
     case PM_WHILE_NODE: {
       pm_while_node_t* while_node = (pm_while_node_t*) node;
       current_type = CONTROL_TYPE_WHILE;
-      keyword_offset = (uint32_t) (while_node->keyword_loc.start - context->source_start);
+      keyword_offset = while_node->while_keyword_loc.start;
       break;
     }
 
     case PM_UNTIL_NODE: {
       pm_until_node_t* until_node = (pm_until_node_t*) node;
       current_type = CONTROL_TYPE_UNTIL;
-      keyword_offset = (uint32_t) (until_node->keyword_loc.start - context->source_start);
+      keyword_offset = until_node->until_keyword_loc.start;
       break;
     }
 
     case PM_FOR_NODE: {
       pm_for_node_t* for_node = (pm_for_node_t*) node;
       current_type = CONTROL_TYPE_FOR;
-      keyword_offset = (uint32_t) (for_node->for_keyword_loc.start - context->source_start);
+      keyword_offset = for_node->for_keyword_loc.start;
       break;
     }
 
@@ -92,17 +96,17 @@ static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* da
       pm_begin_node_t* begin_node = (pm_begin_node_t*) node;
       current_type = CONTROL_TYPE_BEGIN;
 
-      if (begin_node->begin_keyword_loc.start != NULL) {
-        keyword_offset = (uint32_t) (begin_node->begin_keyword_loc.start - context->source_start);
+      if (herb_prism_location_assigned(begin_node->begin_keyword_loc)) {
+        keyword_offset = begin_node->begin_keyword_loc.start;
       } else {
-        keyword_offset = (uint32_t) (node->location.start - context->source_start);
+        keyword_offset = node->location.start;
       }
       break;
     }
 
     case PM_YIELD_NODE: {
       current_type = CONTROL_TYPE_YIELD;
-      keyword_offset = (uint32_t) (node->location.start - context->source_start);
+      keyword_offset = node->location.start;
       break;
     }
 
@@ -112,12 +116,14 @@ static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* da
       if (call->block != NULL && call->block->type == PM_BLOCK_NODE) {
         pm_block_node_t* block_node = (pm_block_node_t*) call->block;
 
-        bool has_opening = is_do_block(block_node->opening_loc) || is_brace_block(block_node->opening_loc);
-        bool is_unclosed = !has_valid_block_closing(block_node->opening_loc, block_node->closing_loc);
+        bool has_opening = is_do_block(context->source_start, block_node->opening_loc)
+                        || is_brace_block(context->source_start, block_node->opening_loc);
+        bool is_unclosed =
+          !has_valid_block_closing(context->source_start, block_node->opening_loc, block_node->closing_loc);
 
         if (has_opening && is_unclosed) {
           current_type = CONTROL_TYPE_BLOCK;
-          keyword_offset = (uint32_t) (node->location.start - context->source_start);
+          keyword_offset = node->location.start;
         }
       }
       break;
@@ -126,12 +132,13 @@ static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* da
     case PM_LAMBDA_NODE: {
       pm_lambda_node_t* lambda = (pm_lambda_node_t*) node;
 
-      bool has_opening = is_do_block(lambda->opening_loc) || is_brace_block(lambda->opening_loc);
-      bool is_unclosed = !has_valid_block_closing(lambda->opening_loc, lambda->closing_loc);
+      bool has_opening = is_do_block(context->source_start, lambda->opening_loc)
+                      || is_brace_block(context->source_start, lambda->opening_loc);
+      bool is_unclosed = !has_valid_block_closing(context->source_start, lambda->opening_loc, lambda->closing_loc);
 
       if (has_opening && is_unclosed) {
         current_type = CONTROL_TYPE_BLOCK;
-        keyword_offset = (uint32_t) (node->location.start - context->source_start);
+        keyword_offset = node->location.start;
       }
 
       break;
@@ -141,7 +148,7 @@ static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* da
     case PM_BREAK_NODE:
     case PM_RETURN_NODE: {
       current_type = CONTROL_TYPE_UNKNOWN;
-      keyword_offset = (uint32_t) (node->location.start - context->source_start);
+      keyword_offset = node->location.start;
       break;
     }
 
@@ -166,7 +173,7 @@ static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* da
     }
   }
 
-  return true;
+  return PM_VISIT_DESCEND;
 }
 
 static control_type_t find_earliest_control_keyword(pm_node_t* root, const uint8_t* source_start) {
@@ -210,7 +217,7 @@ static control_type_t detect_analyzed_control_type(analyzed_ruby_T* ruby) {
 
   if (ruby->unclosed_control_flow_count == 0 && !has_yield_node(ruby)) { return CONTROL_TYPE_UNKNOWN; }
 
-  return find_earliest_control_keyword(root, ruby->parser.start);
+  return find_earliest_control_keyword(root, pm_parser_start(ruby->parser));
 }
 
 control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {

data/src/analyze/herb_directives.c

@@ -17,6 +17,7 @@
 #include "../include/prism/prism_helpers.h"
 
 #include <prism.h>
+#include <prism/internal/diagnostic.h>
 #include <stdbool.h>
 #include <string.h>
 
@@ -152,14 +153,11 @@ hb_string_T herb_directive_kind_for_prism_node(const pm_node_t* node) {
 }
 
 typedef struct {
-  const uint8_t* synthetic_start;
   size_t signature_start;
   size_t prefix_length;
 } synthetic_mapping_T;
 
-static size_t synthetic_to_content_offset(const synthetic_mapping_T* mapping, const uint8_t* pointer) {
-  size_t offset = (size_t) (pointer - mapping->synthetic_start);
-
+static size_t synthetic_to_content_offset(const synthetic_mapping_T* mapping, uint32_t offset) {
   if (offset < mapping->prefix_length) { return mapping->signature_start; }
 
   return mapping->signature_start + offset - mapping->prefix_length;
@@ -172,7 +170,7 @@ static AST_RUBY_LITERAL_NODE_T* create_default_value_node(
   hb_allocator_T* allocator
 ) {
   size_t start = synthetic_to_content_offset(mapping, value->location.start);
-  size_t end = synthetic_to_content_offset(mapping, value->location.end);
+  size_t end = synthetic_to_content_offset(mapping, herb_prism_location_end(value->location));
 
   char* source = hb_allocator_strndup(allocator, content->bytes + start, end - start);
 
@@ -212,12 +210,12 @@ static void append_state_declaration(
   }
 
   size_t name_start = synthetic_to_content_offset(mapping, name_location.start);
-  size_t name_end = synthetic_to_content_offset(mapping, name_location.end);
+  size_t name_end = synthetic_to_content_offset(mapping, herb_prism_location_end(name_location));
 
   if (name_end > name_start && content->bytes[name_end - 1] == ':') { name_end--; }
 
   size_t declaration_start = synthetic_to_content_offset(mapping, keyword->location.start);
-  size_t declaration_end = synthetic_to_content_offset(mapping, keyword->location.end);
+  size_t declaration_end = synthetic_to_content_offset(mapping, herb_prism_location_end(keyword->location));
 
   if (!value) {
     append_herb_state_invalid_parameter_error(
@@ -257,7 +255,7 @@ static void append_invalid_parameter_error(
   if (!parameter) { return; }
 
   size_t start = synthetic_to_content_offset(mapping, parameter->location.start);
-  size_t end = synthetic_to_content_offset(mapping, parameter->location.end);
+  size_t end = synthetic_to_content_offset(mapping, herb_prism_location_end(parameter->location));
 
   append_herb_state_invalid_parameter_error(
     content_slice(content, start, end),
@@ -560,29 +558,28 @@ static AST_NODE_T* create_herb_state_directive_node(
   hb_buffer_append_with_length(&synthetic, content->bytes + signature_start, signature_length);
   hb_buffer_append(&synthetic, SYNTHETIC_SUFFIX);
 
-  pm_parser_t parser;
-  pm_options_t prism_options = { 0 };
-
-  pm_parser_init(&parser, (const uint8_t*) hb_buffer_value(&synthetic), hb_buffer_length(&synthetic), &prism_options);
+  pm_arena_t* arena = pm_arena_new();
+  pm_parser_t* parser =
+    herb_prism_parser_new(arena, (const uint8_t*) hb_buffer_value(&synthetic), hb_buffer_length(&synthetic), options);
 
-  pm_node_t* root = pm_parse(&parser);
+  pm_node_t* root = pm_parse(parser);
 
   synthetic_mapping_T mapping = {
-    .synthetic_start = parser.start,
     .signature_start = signature_start,
     .prefix_length = strlen(SYNTHETIC_PREFIX),
   };
 
   bool parsed = true;
 
-  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; }
 
     parsed = false;
 
     position_T error_start = content_position(content, synthetic_to_content_offset(&mapping, error->location.start));
-    position_T error_end = content_position(content, synthetic_to_content_offset(&mapping, error->location.end));
+    position_T error_end =
+      content_position(content, synthetic_to_content_offset(&mapping, herb_prism_location_end(error->location)));
 
     hb_array_append(errors, ruby_parse_error_from_prism_error_with_positions(error, error_start, error_end, allocator));
   }
@@ -591,9 +588,8 @@ static AST_NODE_T* create_herb_state_directive_node(
     parsed ? extract_state_declarations(find_parameters_node(root), content, &mapping, &errors, allocator, options)
            : hb_array_init(0, allocator);
 
-  pm_node_destroy(&parser, root);
-  pm_parser_free(&parser);
-  pm_options_free(&prism_options);
+  pm_parser_free(parser);
+  pm_arena_free(arena);
   hb_buffer_free(&synthetic);
 
   return (AST_NODE_T*) ast_herb_state_directive_node_init(

data/src/analyze/iteration_nodes.c

@@ -6,6 +6,7 @@
 #include "../include/lib/hb_allocator.h"
 #include "../include/lib/hb_array.h"
 #include "../include/lib/hb_string.h"
+#include "../include/prism/prism_helpers.h"
 #include "../include/visitor.h"
 
 #include <prism.h>
@@ -20,14 +21,13 @@ static token_T* create_token_from_prism_location(
   const uint8_t* erb_content_source,
   hb_allocator_T* allocator
 ) {
-  if (location.start == NULL || location.end == NULL) { return NULL; }
+  if (!herb_prism_location_assigned(location)) { return NULL; }
   if (!source || !erb_content_source) { return NULL; }
 
-  size_t length = (size_t) (location.end - location.start);
-  char* value = hb_allocator_strndup(allocator, (const char*) location.start, length);
+  char* value = hb_allocator_strndup(allocator, (const char*) (erb_content_source + location.start), location.length);
 
-  size_t total_start = erb_content_offset + (size_t) (location.start - erb_content_source);
-  size_t total_end = erb_content_offset + (size_t) (location.end - erb_content_source);
+  size_t total_start = erb_content_offset + location.start;
+  size_t total_end = erb_content_offset + herb_prism_location_end(location);
 
   position_T start = byte_offset_to_position(source, total_start);
   position_T end = byte_offset_to_position(source, total_end);
@@ -59,15 +59,18 @@ static hb_array_T* extract_call_arguments(
     const pm_node_t* argument = call->arguments->arguments.nodes[index];
     if (!argument) { continue; }
 
-    size_t length = (size_t) (argument->location.end - argument->location.start);
-    char* value = hb_allocator_strndup(allocator, (const char*) argument->location.start, length);
+    char* value = hb_allocator_strndup(
+      allocator,
+      (const char*) (erb_content_source + argument->location.start),
+      argument->location.length
+    );
 
     position_T start = { .line = 1, .column = 1 };
     position_T end = { .line = 1, .column = 1 };
 
     if (source && erb_content_source) {
-      size_t total_start = erb_content_offset + (size_t) (argument->location.start - erb_content_source);
-      size_t total_end = erb_content_offset + (size_t) (argument->location.end - erb_content_source);
+      size_t total_start = erb_content_offset + argument->location.start;
+      size_t total_end = erb_content_offset + herb_prism_location_end(argument->location);
 
       start = byte_offset_to_position(source, total_start);
       end = byte_offset_to_position(source, total_end);
@@ -106,30 +109,72 @@ static const char* ITERATION_METHODS[] = {
   "cycle",
 };
 
-static bool is_iteration_method(const pm_constant_t* constant) {
-  size_t count = sizeof(ITERATION_METHODS) / sizeof(ITERATION_METHODS[0]);
+static const char* ARGUMENTLESS_ITERATION_METHODS[] = {
+  "times", "each_pair", "map", "flat_map", "select", "filter", "reject", "filter_map",
+};
 
+static const char* TAG_BUILDER_ELEMENTS[] = {
+  "map",
+  "select",
+  "filter",
+};
+
+static bool constant_matches_any(const pm_constant_t* constant, const char** names, size_t count) {
   for (size_t index = 0; index < count; index++) {
-    const char* name = ITERATION_METHODS[index];
+    const char* name = names[index];
     size_t length = strlen(name);
 
-    if (constant->length == length && memcmp(constant->start, name, length) == 0) { return true; }
+    if (pm_constant_length(constant) == length && memcmp(pm_constant_start(constant), name, length) == 0) {
+      return true;
+    }
   }
 
   return false;
 }
 
+static bool is_iteration_method(const pm_constant_t* constant) {
+  return constant_matches_any(constant, ITERATION_METHODS, sizeof(ITERATION_METHODS) / sizeof(ITERATION_METHODS[0]));
+}
+
+static bool rejects_call_arguments(const pm_constant_t* constant) {
+  return constant_matches_any(
+    constant,
+    ARGUMENTLESS_ITERATION_METHODS,
+    sizeof(ARGUMENTLESS_ITERATION_METHODS) / sizeof(ARGUMENTLESS_ITERATION_METHODS[0])
+  );
+}
+
+static bool is_tag_builder_element(const pm_constant_t* constant) {
+  return constant_matches_any(
+    constant,
+    TAG_BUILDER_ELEMENTS,
+    sizeof(TAG_BUILDER_ELEMENTS) / sizeof(TAG_BUILDER_ELEMENTS[0])
+  );
+}
+
+static bool has_tag_builder_receiver(const pm_call_node_t* call, const pm_parser_t* parser) {
+  if (call->receiver->type != PM_CALL_NODE) { return false; }
+
+  const pm_call_node_t* receiver = (const pm_call_node_t*) call->receiver;
+  const pm_constant_t* constant = pm_parser_constant(parser, receiver->name);
+
+  return constant && pm_constant_length(constant) == 3 && memcmp(pm_constant_start(constant), "tag", 3) == 0;
+}
+
 static bool is_iteration_call(const pm_call_node_t* call, const pm_parser_t* parser) {
   if (!call) { return false; }
   if (call->receiver == NULL) { return false; }
   if (call->block == NULL || call->block->type != PM_BLOCK_NODE) { return false; }
 
   pm_constant_id_t name_id = call->name;
-  const pm_constant_t* constant = pm_constant_pool_id_to_constant(&((pm_parser_t*) parser)->constant_pool, name_id);
+  const pm_constant_t* constant = pm_parser_constant(parser, name_id);
 
   if (!constant) { return false; }
+  if (!is_iteration_method(constant)) { return false; }
+  if (call->arguments != NULL && rejects_call_arguments(constant)) { return false; }
+  if (is_tag_builder_element(constant) && has_tag_builder_receiver(call, parser)) { return false; }
 
-  return is_iteration_method(constant);
+  return true;
 }
 
 static pm_call_node_t* find_iteration_call(pm_node_t* node, const pm_parser_t* parser) {
@@ -173,15 +218,15 @@ static AST_ERB_ITERATION_BLOCK_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* iteration_call = find_iteration_call(root, &parser);
+  pm_call_node_t* iteration_call = find_iteration_call(root, parser);
 
   if (!iteration_call) {
-    pm_node_destroy(&parser, root);
-    pm_parser_free(&parser);
+    pm_parser_free(parser);
+    pm_arena_free(arena);
 
     return NULL;
   }
@@ -192,7 +237,7 @@ static AST_ERB_ITERATION_BLOCK_NODE_T* try_transform_block_node(
     erb_content_offset = calculate_byte_offset_from_position(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);
 
   token_T* receiver = create_token_from_prism_location(
     iteration_call->receiver->location,
@@ -260,8 +305,8 @@ static AST_ERB_ITERATION_BLOCK_NODE_T* try_transform_block_node(
     allocator
   );
 
-  pm_node_destroy(&parser, root);
-  pm_parser_free(&parser);
+  pm_parser_free(parser);
+  pm_arena_free(arena);
 
   return iteration_block_node;
 }

data/src/analyze/parse_errors.c

@@ -9,6 +9,7 @@
 #include "../include/prism/prism_helpers.h"
 
 #include <prism.h>
+#include <prism/internal/diagnostic.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -43,7 +44,12 @@ static bool should_skip_forwarding_error(
   return has_anonymous_keyword_rest;
 }
 
-static void parse_erb_content_errors(AST_NODE_T* erb_node, const char* source, hb_allocator_T* allocator) {
+static void parse_erb_content_errors(
+  AST_NODE_T* erb_node,
+  const char* source,
+  const parser_options_T* parser_options,
+  hb_allocator_T* allocator
+) {
   if (!erb_node || erb_node->type != AST_ERB_CONTENT_NODE) { return; }
   AST_ERB_CONTENT_NODE_T* content_node = (AST_ERB_CONTENT_NODE_T*) erb_node;
 
@@ -52,13 +58,15 @@ static void parse_erb_content_errors(AST_NODE_T* erb_node, const char* source, h
   char* content = hb_string_to_c_string_using_malloc(content_node->content->value);
   if (!content) { return; }
 
-  pm_parser_t parser;
-  pm_options_t options = { 0, .partial_script = true };
-  pm_parser_init(&parser, (const uint8_t*) content, strlen(content), &options);
+  pm_arena_t* arena = pm_arena_new();
+  pm_options_t* options = pm_options_new();
+  pm_options_partial_script_set(options, true);
+  herb_prism_options_set_ruby_version(options, parser_options);
+  pm_parser_t* parser = pm_parser_new(arena, (const uint8_t*) content, strlen(content), options);
 
-  pm_node_t* root = pm_parse(&parser);
+  pm_parse(parser);
 
-  const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser.error_list.head;
+  const pm_diagnostic_t* error = pm_parser_errors_first(parser);
 
   if (error != NULL) {
     RUBY_PARSE_ERROR_T* parse_error = ruby_parse_error_from_prism_error_with_positions(
@@ -71,9 +79,9 @@ static void parse_erb_content_errors(AST_NODE_T* erb_node, const char* source, h
     hb_array_append_lazy(&erb_node->errors, parse_error, allocator);
   }
 
-  pm_node_destroy(&parser, root);
-  pm_parser_free(&parser);
-  pm_options_free(&options);
+  pm_parser_free(parser);
+  pm_arena_free(arena);
+  pm_options_free(options);
   free(content);
 }
 
@@ -95,24 +103,26 @@ void herb_analyze_parse_errors(
   bool strict_locals_enabled = parser_options && parser_options->strict_locals;
   bool has_anonymous_keyword_rest = strict_locals_enabled && document_has_anonymous_keyword_rest(document);
 
-  pm_parser_t parser;
-  pm_options_t options = { 0, .partial_script = true };
-  pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), &options);
+  pm_arena_t* arena = pm_arena_new();
+  pm_options_t* options = pm_options_new();
+  pm_options_partial_script_set(options, true);
+  herb_prism_options_set_ruby_version(options, parser_options);
+  pm_parser_t* parser = pm_parser_new(arena, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), options);
 
-  pm_node_t* root = pm_parse(&parser);
+  pm_parse(parser);
 
-  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 (should_skip_forwarding_error(error, strict_locals_enabled, has_anonymous_keyword_rest)) { continue; }
 
-    size_t error_offset = (size_t) (error->location.start - parser.start);
+    size_t error_offset = error->location.start;
 
-    if (strstr(error->message, "unexpected ';'") != NULL) {
+    if (strstr(pm_diagnostic_message(error), "unexpected ';'") != NULL) {
       if (error_offset < strlen(extracted_ruby) && extracted_ruby[error_offset] == ';') {
         if (error_offset >= strlen(source) || source[error_offset] != ';') {
           AST_NODE_T* erb_node = find_erb_content_at_offset(document, source, error_offset);
 
-          if (erb_node) { parse_erb_content_errors(erb_node, source, allocator); }
+          if (erb_node) { parse_erb_content_errors(erb_node, source, parser_options, allocator); }
 
           continue;
         }
@@ -120,12 +130,12 @@ void herb_analyze_parse_errors(
     }
 
     RUBY_PARSE_ERROR_T* parse_error =
-      ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser, allocator);
+      ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, parser, allocator);
     hb_array_append_lazy(&document->base.errors, parse_error, allocator);
   }
 
-  pm_node_destroy(&parser, root);
-  pm_parser_free(&parser);
-  pm_options_free(&options);
+  pm_parser_free(parser);
+  pm_arena_free(arena);
+  pm_options_free(options);
   hb_allocator_dealloc(allocator, extracted_ruby);
 }