herb 0.11.0-aarch64-linux-gnu → 0.11.2-aarch64-linux-gnu

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/ast/ast_nodes.c

@@ -712,7 +712,7 @@ AST_ERB_STRICT_LOCALS_NODE_T* ast_erb_strict_locals_node_init(token_T* tag_openi
   return erb_strict_locals_node;
 }
 
-AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
   AST_ERB_YIELD_NODE_T* erb_yield_node = hb_allocator_alloc(allocator, sizeof(AST_ERB_YIELD_NODE_T));
 
   if (!erb_yield_node) { return NULL; }
@@ -722,6 +722,7 @@ AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* con
   erb_yield_node->tag_opening = tag_opening;
   erb_yield_node->content = content;
   erb_yield_node->tag_closing = tag_closing;
+  erb_yield_node->prism_node = prism_node;
 
   return erb_yield_node;
 }
@@ -1628,6 +1629,7 @@ static void ast_free_erb_yield_node(AST_ERB_YIELD_NODE_T* erb_yield_node, hb_all
   if (erb_yield_node->tag_opening != NULL) { token_free(erb_yield_node->tag_opening, allocator); }
   if (erb_yield_node->content != NULL) { token_free(erb_yield_node->content, allocator); }
   if (erb_yield_node->tag_closing != NULL) { token_free(erb_yield_node->tag_closing, allocator); }
+  /* prism_node is a borrowed reference into the prism context, not freed here */
 
   ast_free_base_node(&erb_yield_node->base, allocator);
 }

data/src/ast/ast_pretty_print.c

@@ -1228,7 +1228,11 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_errors(node, indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_yield_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_yield_node->content, hb_string("content"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_yield_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, true, buffer);
+      pretty_print_token_property(erb_yield_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      if (erb_yield_node->prism_node.node != NULL) {
+        pretty_print_label(hb_string("prism_node"), indent, relative_indent, true, buffer);
+        hb_buffer_append(buffer, " (pm_node_t*)\n");
+      }
     } break;
 
     case AST_ERB_IN_NODE: {

data/src/extract.c

@@ -1,9 +1,12 @@
 #include "include/herb.h"
+#include "include/lexer/lexer.h"
+#include "include/lexer/token.h"
 #include "include/lib/hb_allocator.h"
 #include "include/lib/hb_array.h"
 #include "include/lib/hb_buffer.h"
 #include "include/lib/hb_string.h"
 #include "include/lib/string.h"
+#include "include/util/util.h"
 
 #include <assert.h>
 #include <stdlib.h>
@@ -16,192 +19,250 @@ const herb_extract_ruby_options_T HERB_EXTRACT_RUBY_DEFAULT_OPTIONS = { .semicol
                                                                         .erb_openers = NULL,
                                                                         .erb_opener_count = 0 };
 
-void herb_extract_ruby_to_buffer_with_options(
-  const char* source,
-  hb_buffer_T* output,
-  const herb_extract_ruby_options_T* options,
-  hb_allocator_T* allocator
-) {
-  herb_extract_ruby_options_T extract_options = options ? *options : HERB_EXTRACT_RUBY_DEFAULT_OPTIONS;
+typedef struct {
+  herb_extract_ruby_options_T options;
+  hb_buffer_T* output;
+  bool skip_erb_content;
+  bool is_comment_tag;
+  bool is_erb_comment_tag;
+  bool need_newline;
+} extract_ruby_state_T;
 
-  parser_options_T lex_options = HERB_DEFAULT_PARSER_OPTIONS;
-  lex_options.erb_openers = extract_options.erb_openers;
-  lex_options.erb_opener_count = extract_options.erb_opener_count;
+static void extract_ruby_data(extract_ruby_state_T* state, const char* data, uint32_t from, uint32_t to) {
+  uint32_t run_start = from;
 
-  hb_array_T* tokens = herb_lex_with_options(source, &lex_options, allocator);
-  bool skip_erb_content = false;
-  bool is_comment_tag = false;
-  bool is_erb_comment_tag = false;
-  bool need_newline = false;
+  for (uint32_t position = from; position < to; position++) {
+    if (!is_newline(data[position])) { continue; }
 
-  for (size_t i = 0; i < hb_array_size(tokens); i++) {
-    const token_T* token = hb_array_get(tokens, i);
+    if (state->options.preserve_positions) { hb_buffer_append_whitespace(state->output, position - run_start); }
 
-    switch (token->type) {
-      case TOKEN_NEWLINE: {
-        hb_buffer_append_string(output, token->value);
-        need_newline = false;
-        break;
-      }
+    hb_buffer_append_char(state->output, data[position]);
+    state->need_newline = false;
+    run_start = position + 1;
+  }
 
-      case TOKEN_ERB_START: {
-        is_erb_comment_tag = hb_string_equals(token->value, hb_string("<%#"));
+  if (state->options.preserve_positions) { hb_buffer_append_whitespace(state->output, to - run_start); }
+}
 
-        if (is_erb_comment_tag) {
-          if (extract_options.comments) {
-            skip_erb_content = false;
-            is_comment_tag = false;
+static void extract_ruby_token(extract_ruby_state_T* state, const token_T* token, const token_T* next) {
+  switch (token->type) {
+    case TOKEN_NEWLINE: {
+      hb_buffer_append_string(state->output, token->value);
+      state->need_newline = false;
+      break;
+    }
 
-            if (extract_options.preserve_positions) {
-              bool is_multiline = false;
+    case TOKEN_ERB_START: {
+      state->is_erb_comment_tag = hb_string_equals(token->value, hb_string("<%#"));
 
-              if (i + 1 < hb_array_size(tokens)) {
-                const token_T* next = hb_array_get(tokens, i + 1);
+      if (state->is_erb_comment_tag) {
+        if (state->options.comments) {
+          state->skip_erb_content = false;
+          state->is_comment_tag = false;
 
-                if (next->type == TOKEN_ERB_CONTENT && !hb_string_is_null(next->value)
-                    && memchr(next->value.data, '\n', next->value.length) != NULL) {
-                  is_multiline = true;
-                }
-              }
+          if (state->options.preserve_positions) {
+            bool is_multiline = false;
 
-              if (is_multiline) {
-                hb_buffer_append_char(output, '#');
-                hb_buffer_append_whitespace(output, 2);
-              } else {
-                hb_buffer_append_whitespace(output, 2);
-                hb_buffer_append_char(output, '#');
-              }
+            if (next && next->type == TOKEN_ERB_CONTENT && !hb_string_is_null(next->value)
+                && memchr(next->value.data, '\n', next->value.length) != NULL) {
+              is_multiline = true;
+            }
+
+            if (is_multiline) {
+              hb_buffer_append_char(state->output, '#');
+              hb_buffer_append_whitespace(state->output, 2);
             } else {
-              if (need_newline) { hb_buffer_append_char(output, '\n'); }
-              hb_buffer_append_char(output, '#');
-              need_newline = true;
+              hb_buffer_append_whitespace(state->output, 2);
+              hb_buffer_append_char(state->output, '#');
             }
           } else {
-            skip_erb_content = true;
-            is_comment_tag = true;
-            if (extract_options.preserve_positions) { hb_buffer_append_whitespace(output, range_length(token->range)); }
+            if (state->need_newline) { hb_buffer_append_char(state->output, '\n'); }
+            hb_buffer_append_char(state->output, '#');
+            state->need_newline = true;
           }
-        } else if (hb_string_equals(token->value, hb_string("<%%")) || hb_string_equals(token->value, hb_string("<%%="))
-                   || (erb_opening_is_custom(token->value) && !extract_options.custom_tags)) {
-          skip_erb_content = true;
-          is_comment_tag = false;
-          if (extract_options.preserve_positions) { hb_buffer_append_whitespace(output, range_length(token->range)); }
         } else {
-          skip_erb_content = false;
-          is_comment_tag = false;
-
-          if (extract_options.preserve_positions) {
-            hb_buffer_append_whitespace(output, range_length(token->range));
-          } else if (need_newline) {
-            hb_buffer_append_char(output, '\n');
-            need_newline = false;
+          state->skip_erb_content = true;
+          state->is_comment_tag = true;
+          if (state->options.preserve_positions) {
+            hb_buffer_append_whitespace(state->output, range_length(token->range));
           }
         }
-
-        break;
+      } else if (hb_string_equals(token->value, hb_string("<%%")) || hb_string_equals(token->value, hb_string("<%%="))
+                 || (erb_opening_is_custom(token->value) && !state->options.custom_tags)) {
+        state->skip_erb_content = true;
+        state->is_comment_tag = false;
+        if (state->options.preserve_positions) {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        }
+      } else {
+        state->skip_erb_content = false;
+        state->is_comment_tag = false;
+
+        if (state->options.preserve_positions) {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        } else if (state->need_newline) {
+          hb_buffer_append_char(state->output, '\n');
+          state->need_newline = false;
+        }
       }
 
-      case TOKEN_ERB_CONTENT: {
-        if (skip_erb_content == false) {
-          bool is_inline_comment = false;
+      break;
+    }
 
-          if (!extract_options.comments && !is_comment_tag && !hb_string_is_empty(token->value)) {
-            hb_string_T trimmed = hb_string_trim_start(token->value);
+    case TOKEN_ERB_CONTENT: {
+      if (state->skip_erb_content == false) {
+        bool is_inline_comment = false;
 
-            if (!hb_string_is_empty(trimmed) && trimmed.data[0] == '#'
-                && token->location.start.line == token->location.end.line) {
-              is_comment_tag = true;
-              is_inline_comment = true;
-            }
-          }
+        if (!state->options.comments && !state->is_comment_tag && !hb_string_is_empty(token->value)) {
+          hb_string_T trimmed = hb_string_trim_start(token->value);
 
-          if (is_inline_comment) {
-            if (extract_options.preserve_positions) { hb_buffer_append_whitespace(output, range_length(token->range)); }
-          } else if (is_erb_comment_tag && !hb_string_is_null(token->value)) {
-            const char* content = token->value.data;
-            size_t content_remaining = token->value.length;
+          if (!hb_string_is_empty(trimmed) && trimmed.data[0] == '#'
+              && token->location.start.line == token->location.end.line) {
+            state->is_comment_tag = true;
+            is_inline_comment = true;
+          }
+        }
 
-            while (content_remaining > 0) {
-              if (*content == '\n') {
-                hb_buffer_append_char(output, '\n');
-                content++;
-                content_remaining--;
+        if (is_inline_comment) {
+          if (state->options.preserve_positions) {
+            hb_buffer_append_whitespace(state->output, range_length(token->range));
+          }
+        } else if (state->is_erb_comment_tag && !hb_string_is_null(token->value)) {
+          const char* content = token->value.data;
+          size_t content_remaining = token->value.length;
 
-                if (content_remaining > 0 && extract_options.preserve_positions && *content == ' ') {
-                  content++;
-                  content_remaining--;
-                }
+          while (content_remaining > 0) {
+            if (*content == '\n') {
+              hb_buffer_append_char(state->output, '\n');
+              content++;
+              content_remaining--;
 
-                hb_buffer_append_char(output, '#');
-              } else {
-                hb_buffer_append_char(output, *content);
+              if (content_remaining > 0 && state->options.preserve_positions && *content == ' ') {
                 content++;
                 content_remaining--;
               }
-            }
-
-            if (!extract_options.preserve_positions) { need_newline = true; }
-          } else {
-            hb_buffer_append_string(output, token->value);
-
-            if (!extract_options.preserve_positions) { need_newline = true; }
-          }
-        } else {
-          if (is_erb_comment_tag && extract_options.preserve_positions && !hb_string_is_null(token->value)) {
-            const char* content = token->value.data;
-            size_t content_remaining = token->value.length;
-
-            while (content_remaining > 0) {
-              if (*content == '\n') {
-                hb_buffer_append_char(output, '\n');
-              } else {
-                hb_buffer_append_char(output, ' ');
-              }
 
+              hb_buffer_append_char(state->output, '#');
+            } else {
+              hb_buffer_append_char(state->output, *content);
               content++;
               content_remaining--;
             }
-          } else if (extract_options.preserve_positions) {
-            hb_buffer_append_whitespace(output, range_length(token->range));
           }
-        }
 
-        break;
-      }
+          if (!state->options.preserve_positions) { state->need_newline = true; }
+        } else {
+          hb_buffer_append_string(state->output, token->value);
 
-      case TOKEN_ERB_END: {
-        bool was_comment = is_comment_tag;
-        bool was_erb_comment = is_erb_comment_tag;
-        skip_erb_content = false;
-        is_comment_tag = false;
-        is_erb_comment_tag = false;
-
-        if (extract_options.preserve_positions) {
-          if (was_comment) {
-            hb_buffer_append_whitespace(output, range_length(token->range));
-          } else if (was_erb_comment && extract_options.comments) {
-            hb_buffer_append_whitespace(output, range_length(token->range));
-          } else if (extract_options.semicolons) {
-            size_t length = range_length(token->range);
-
-            if (length >= 2) { hb_buffer_append_char(output, ' '); }
-            if (length >= 1) { hb_buffer_append_char(output, ';'); }
-            if (length >= 2) { hb_buffer_append_whitespace(output, length - 2); }
-          } else {
-            hb_buffer_append_whitespace(output, range_length(token->range));
-          }
+          if (!state->options.preserve_positions) { state->need_newline = true; }
         }
+      } else {
+        if (state->is_erb_comment_tag && state->options.preserve_positions && !hb_string_is_null(token->value)) {
+          const char* content = token->value.data;
+          size_t content_remaining = token->value.length;
+
+          while (content_remaining > 0) {
+            if (*content == '\n') {
+              hb_buffer_append_char(state->output, '\n');
+            } else {
+              hb_buffer_append_char(state->output, ' ');
+            }
 
-        break;
+            content++;
+            content_remaining--;
+          }
+        } else if (state->options.preserve_positions) {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        }
       }
 
-      default: {
-        if (extract_options.preserve_positions) { hb_buffer_append_whitespace(output, range_length(token->range)); }
+      break;
+    }
+
+    case TOKEN_ERB_END: {
+      bool was_comment = state->is_comment_tag;
+      bool was_erb_comment = state->is_erb_comment_tag;
+      state->skip_erb_content = false;
+      state->is_comment_tag = false;
+      state->is_erb_comment_tag = false;
+
+      if (state->options.preserve_positions) {
+        if (was_comment) {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        } else if (was_erb_comment && state->options.comments) {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        } else if (state->options.semicolons) {
+          size_t length = range_length(token->range);
+
+          if (length >= 2) { hb_buffer_append_char(state->output, ' '); }
+          if (length >= 1) { hb_buffer_append_char(state->output, ';'); }
+          if (length >= 2) { hb_buffer_append_whitespace(state->output, length - 2); }
+        } else {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        }
       }
+
+      break;
+    }
+
+    default: {
+      if (state->options.preserve_positions) { hb_buffer_append_whitespace(state->output, range_length(token->range)); }
     }
   }
+}
 
-  herb_free_tokens(&tokens, allocator);
+void herb_extract_ruby_to_buffer_with_options(
+  const char* source,
+  hb_buffer_T* output,
+  const herb_extract_ruby_options_T* options,
+  hb_allocator_T* allocator
+) {
+  extract_ruby_state_T state = {
+    .options = options ? *options : HERB_EXTRACT_RUBY_DEFAULT_OPTIONS,
+    .output = output,
+    .skip_erb_content = false,
+    .is_comment_tag = false,
+    .is_erb_comment_tag = false,
+    .need_newline = false,
+  };
+
+  parser_options_T lex_options = HERB_DEFAULT_PARSER_OPTIONS;
+  lex_options.erb_openers = state.options.erb_openers;
+  lex_options.erb_opener_count = state.options.erb_opener_count;
+
+  lexer_T lexer = { 0 };
+  lexer_init(&lexer, source ? source : "", allocator);
+  lexer_apply_erb_openers(&lexer, &lex_options);
+
+  const char* data = lexer.source.data;
+  uint32_t length = (uint32_t) lexer.source.length;
+  token_T* pending = NULL;
+
+  while (true) {
+    if (!pending && lexer.state == STATE_DATA) {
+      uint32_t position = lexer.current_position;
+
+      while (position < length && !(data[position] == '<' && data[position + 1] == '%')) {
+        position++;
+      }
+
+      extract_ruby_data(&state, data, lexer.current_position, position);
+      lexer_skip_data_to(&lexer, position);
+    }
+
+    token_T* token = pending ? pending : lexer_next_token(&lexer);
+    pending = NULL;
+
+    if (token->type == TOKEN_EOF) {
+      token_free(token, allocator);
+      break;
+    }
+
+    if (token->type == TOKEN_ERB_START) { pending = lexer_next_token(&lexer); }
+
+    extract_ruby_token(&state, token, pending);
+    token_free(token, allocator);
+  }
 }
 
 void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output, hb_allocator_T* allocator) {

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);
 }

data/src/include/analyze/action_view/tag_helper_handler.h

@@ -38,7 +38,7 @@ void tag_helper_info_free(tag_helper_info_T** info);
 const tag_helper_handler_T* const* get_tag_helper_handlers(void);
 size_t get_tag_helper_handlers_count(void);
 
-char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* allocator);
+char* extract_inline_block_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator);
 
 struct AST_NODE_STRUCT;
 bool wrap_javascript_tag_body_visitor(const struct AST_NODE_STRUCT* node, void* data);

data/src/include/analyze/action_view/tag_helper_node_builders.h

@@ -58,6 +58,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal(
 AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_interpolated_value(
   const char* name_string,
   pm_interpolated_string_node_t* interpolated_node,
+  const uint8_t* source,
   position_T start_position,
   position_T end_position,
   hb_allocator_T* allocator

data/src/include/analyze/action_view/tag_helpers.h

@@ -19,7 +19,7 @@ typedef struct {
   bool found;
 } tag_helper_search_data_T;
 
-bool search_tag_helper_node(const pm_node_t* node, void* data);
+pm_visit_result_t search_tag_helper_node(const pm_node_t* node, void* data);
 
 position_T prism_location_to_position_with_offset(
   const pm_location_t* pm_location,

data/src/include/analyze/analyze.h

@@ -10,8 +10,9 @@
 
 typedef struct TAG_HELPER_SCOPE_STRUCT {
   hb_buffer_T buffer;
-  pm_options_t options;
-  pm_parser_t parser;
+  pm_arena_t* arena;
+  pm_options_t* options;
+  pm_parser_t* parser;
   pm_node_t* root;
 } tag_helper_scope_T;
 
@@ -26,28 +27,6 @@ typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
   const parser_options_T* options;
 } analyze_ruby_context_T;
 
-typedef enum {
-  CONTROL_TYPE_IF,
-  CONTROL_TYPE_ELSIF,
-  CONTROL_TYPE_ELSE,
-  CONTROL_TYPE_END,
-  CONTROL_TYPE_CASE,
-  CONTROL_TYPE_CASE_MATCH,
-  CONTROL_TYPE_WHEN,
-  CONTROL_TYPE_IN,
-  CONTROL_TYPE_BEGIN,
-  CONTROL_TYPE_RESCUE,
-  CONTROL_TYPE_ENSURE,
-  CONTROL_TYPE_UNLESS,
-  CONTROL_TYPE_WHILE,
-  CONTROL_TYPE_UNTIL,
-  CONTROL_TYPE_FOR,
-  CONTROL_TYPE_BLOCK,
-  CONTROL_TYPE_BLOCK_CLOSE,
-  CONTROL_TYPE_YIELD,
-  CONTROL_TYPE_UNKNOWN
-} control_type_t;
-
 typedef struct {
   int loop_depth;
   int rescue_depth;