herb 0.11.1 → 0.11.2

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;
 

data/src/include/analyze/analyzed_ruby.h

@@ -3,6 +3,7 @@
 
 #include "../lib/hb_array.h"
 #include "../lib/hb_string.h"
+#include "../parser/parser_options.h"
 
 #include <prism.h>
 #include <stdbool.h>
@@ -30,7 +31,8 @@ typedef enum {
 } control_type_t;
 
 typedef struct ANALYZED_RUBY_STRUCT {
-  pm_parser_t parser;
+  pm_arena_t* arena;
+  pm_parser_t* parser;
   pm_node_t* root;
   bool valid;
   bool parsed;
@@ -58,7 +60,7 @@ typedef struct ANALYZED_RUBY_STRUCT {
   bool control_type_detected;
 } analyzed_ruby_T;
 
-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);
 void free_analyzed_ruby(analyzed_ruby_T* analyzed);
 hb_string_T erb_keyword_from_analyzed_ruby(const analyzed_ruby_T* analyzed);
 

data/src/include/analyze/helpers.h

@@ -37,13 +37,13 @@ bool control_role_split_offset(const analyzed_ruby_T* analyzed, uint32_t* offset
 
 bool has_error_message(analyzed_ruby_T* anlayzed, const char* message);
 
-bool is_do_block(pm_location_t opening_location);
-bool is_brace_block(pm_location_t opening_location);
-bool is_closing_brace(pm_location_t location);
-bool has_valid_block_closing(pm_location_t opening_loc, pm_location_t closing_loc);
+bool is_do_block(const uint8_t* source, pm_location_t opening_location);
+bool is_brace_block(const uint8_t* source, pm_location_t opening_location);
+bool is_closing_brace(const uint8_t* source, pm_location_t location);
+bool has_valid_block_closing(const uint8_t* source, pm_location_t opening_loc, pm_location_t closing_loc);
 
-bool search_control_flow_nodes(const pm_node_t* node, void* data);
-bool search_unclosed_control_flows(const pm_node_t* node, void* data);
+pm_visit_result_t search_control_flow_nodes(const pm_node_t* node, void* data);
+pm_visit_result_t search_unclosed_control_flows(const pm_node_t* node, void* data);
 void search_unexpected_keyword_errors(analyzed_ruby_T* analyzed);
 
 void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator, const parser_options_T* options);

data/src/include/herb.h

@@ -36,9 +36,10 @@ HERB_EXPORTED_FUNCTION const char* herb_version(void);
 HERB_EXPORTED_FUNCTION const char* herb_prism_version(void);
 
 typedef struct {
-  pm_parser_t parser;
+  pm_arena_t* arena;
+  pm_parser_t* parser;
   pm_node_t* root;
-  pm_options_t options;
+  pm_options_t* options;
 } herb_ruby_parse_result_T;
 
 HERB_EXPORTED_FUNCTION herb_ruby_parse_result_T* herb_parse_ruby(const char* source, size_t length);

data/src/include/parser/parser_options.h

@@ -10,6 +10,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#define HERB_PARSER_OPTIONS_STRING_CAPACITY 16
+
 typedef struct PARSER_OPTIONS_STRUCT {
   bool action_view_helpers;
   bool analyze;
@@ -24,6 +26,7 @@ typedef struct PARSER_OPTIONS_STRUCT {
   bool prism_nodes_deep;
   bool prism_program;
   bool render_nodes;
+  char ruby_version[HERB_PARSER_OPTIONS_STRING_CAPACITY];
   bool strict;
   bool strict_locals;
   uint32_t timeout_ms;
@@ -38,4 +41,6 @@ typedef struct PARSER_OPTIONS_STRUCT {
 
 extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
 
+bool herb_ruby_version_supported(const char* value, size_t length);
+
 #endif

data/src/include/prism/prism_context.h

@@ -7,14 +7,16 @@
 #include <stdbool.h>
 
 typedef struct {
-  pm_parser_t parser;
-  pm_options_t pm_opts;
+  pm_arena_t* arena;
+  pm_parser_t* parser;
+  pm_options_t* pm_opts;
   pm_node_t* root;
   hb_buffer_T ruby_buf;
 
   bool has_structural;
-  pm_parser_t structural_parser;
-  pm_options_t structural_pm_opts;
+  pm_arena_t* structural_arena;
+  pm_parser_t* structural_parser;
+  pm_options_t* structural_pm_opts;
   pm_node_t* structural_root;
   hb_buffer_T structural_buf;
 
@@ -24,17 +26,15 @@ typedef struct {
 static inline void herb_prism_context_free(herb_prism_context_T* context) {
   if (!context) { return; }
 
-  if (context->root) { pm_node_destroy(&context->parser, context->root); }
-
-  pm_parser_free(&context->parser);
-  pm_options_free(&context->pm_opts);
+  if (context->parser) { pm_parser_free(context->parser); }
+  if (context->arena) { pm_arena_free(context->arena); }
+  if (context->pm_opts) { pm_options_free(context->pm_opts); }
   hb_buffer_free(&context->ruby_buf);
 
   if (context->has_structural) {
-    if (context->structural_root) { pm_node_destroy(&context->structural_parser, context->structural_root); }
-
-    pm_parser_free(&context->structural_parser);
-    pm_options_free(&context->structural_pm_opts);
+    if (context->structural_parser) { pm_parser_free(context->structural_parser); }
+    if (context->structural_arena) { pm_arena_free(context->structural_arena); }
+    if (context->structural_pm_opts) { pm_options_free(context->structural_pm_opts); }
 
     if (context->structural_buf.value) { hb_buffer_free(&context->structural_buf); }
   }

data/src/include/prism/prism_helpers.h

@@ -7,9 +7,39 @@
 #include "../lib/hb_allocator.h"
 #include "../location/location.h"
 #include "../location/position.h"
+#include "../parser/parser_options.h"
 
 #include <prism.h>
 
+static inline bool herb_prism_location_present(pm_location_t location) {
+  return location.length > 0;
+}
+
+static inline bool herb_prism_location_assigned(pm_location_t location) {
+  return location.start != 0 || location.length != 0;
+}
+
+static inline uint32_t herb_prism_location_end(pm_location_t location) {
+  return location.start + location.length;
+}
+
+static inline const uint8_t* herb_prism_location_start_pointer(const uint8_t* base, pm_location_t location) {
+  return base + location.start;
+}
+
+static inline const uint8_t* herb_prism_location_end_pointer(const uint8_t* base, pm_location_t location) {
+  return base + location.start + location.length;
+}
+
+void herb_prism_options_set_ruby_version(pm_options_t* options, const parser_options_T* parser_options);
+
+pm_parser_t* herb_prism_parser_new(
+  pm_arena_t* arena,
+  const uint8_t* source,
+  size_t length,
+  const parser_options_T* parser_options
+);
+
 hb_string_T pm_error_level_to_string(pm_error_level_t level);
 
 RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(

data/src/include/prism_version.h

@@ -0,0 +1,11 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See templates/src/include/prism_version.h.erb
+
+#ifndef HERB_PRISM_VERSION_H
+#define HERB_PRISM_VERSION_H
+
+#include <prism/version.h>
+
+#define HERB_PRISM_VERSION PRISM_VERSION "+4691667"
+
+#endif

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.11.1"
+#define HERB_VERSION "0.11.2"
 
 #endif

data/src/parser/parser_helpers.c

@@ -195,8 +195,7 @@ void parser_append_literal_node_from_buffer(
 
   if (children != NULL) { hb_array_append(children, literal); }
 
-  hb_buffer_free(buffer);
-  hb_buffer_init(buffer, 128, parser->allocator);
+  hb_buffer_clear(buffer);
 }
 
 token_T* parser_advance(parser_T* parser) {

data/src/parser.c

@@ -139,7 +139,7 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
   position_T start = parser->current_token->location.start;
 
   hb_buffer_T comment;
-  hb_buffer_init(&comment, 512, parser->allocator);
+  hb_buffer_init(&comment, 64, parser->allocator);
 
   token_T* comment_end = NULL;
 
@@ -376,7 +376,7 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, hb_arra
   position_T start = parser->current_token->location.start;
 
   hb_buffer_T content;
-  hb_buffer_init(&content, 2048, parser->allocator);
+  hb_buffer_init(&content, 64, parser->allocator);
 
   while (token_is_none_of(
     parser,
@@ -553,7 +553,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
   hb_array_T** errors
 ) {
   hb_buffer_T buffer;
-  hb_buffer_init(&buffer, 512, parser->allocator);
+  hb_buffer_init(&buffer, 64, parser->allocator);
   token_T* opening_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
   position_T start = parser->current_token->location.start;
 
@@ -816,7 +816,7 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
 
     if (has_equals) {
       hb_buffer_T equals_buffer;
-      hb_buffer_init(&equals_buffer, 256, parser->allocator);
+      hb_buffer_init(&equals_buffer, 16, parser->allocator);
       position_T equals_start = { 0 };
       position_T equals_end = { 0 };
       uint32_t range_start = 0;
@@ -1640,13 +1640,12 @@ static void parser_append_foreign_content_from_buffer(
     ast_html_text_node_init(content, start, parser->current_token->location.start, NULL, parser->allocator)
   );
 
-  hb_buffer_free(buffer);
-  hb_buffer_init(buffer, 128, parser->allocator);
+  hb_buffer_clear(buffer);
 }
 
 static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children, hb_array_T** errors) {
   hb_buffer_T content;
-  hb_buffer_init(&content, 1024, parser->allocator);
+  hb_buffer_init(&content, 64, parser->allocator);
   position_T start = parser->current_token->location.start;
   bool has_closing_tag = !hb_string_is_empty(parser->foreign_content_tag_name);
 

data/src/parser_options_defaults.c

@@ -18,6 +18,7 @@ const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { .action_view_helpers = fa
                                                        .prism_nodes_deep = false,
                                                        .prism_program = false,
                                                        .render_nodes = false,
+                                                       .ruby_version = "4.0",
                                                        .strict = true,
                                                        .strict_locals = false,
                                                        .timeout_ms = 1000,

data/src/prism/prism_helpers.c

@@ -7,9 +7,47 @@
 #include "../include/location/position.h"
 
 #include <prism.h>
+#include <prism/internal/comments.h>
+#include <prism/internal/parser.h>
 #include <stdlib.h>
 #include <string.h>
 
+bool herb_ruby_version_supported(const char* value, size_t length) {
+  if (value == NULL || length == 0 || length >= HERB_PARSER_OPTIONS_STRING_CAPACITY) { return false; }
+
+  pm_options_t* options = pm_options_new();
+  bool supported = pm_options_version_set(options, value, length);
+  pm_options_free(options);
+
+  return supported;
+}
+
+void herb_prism_options_set_ruby_version(pm_options_t* options, const parser_options_T* parser_options) {
+  if (options == NULL || parser_options == NULL || parser_options->ruby_version[0] == '\0') { return; }
+
+  const char* version = parser_options->ruby_version;
+  pm_options_version_set(options, version, strnlen(version, HERB_PARSER_OPTIONS_STRING_CAPACITY));
+}
+
+pm_parser_t* herb_prism_parser_new(
+  pm_arena_t* arena,
+  const uint8_t* source,
+  size_t length,
+  const parser_options_T* parser_options
+) {
+  if (parser_options == NULL || parser_options->ruby_version[0] == '\0') {
+    return pm_parser_new(arena, source, length, NULL);
+  }
+
+  pm_options_t* options = pm_options_new();
+  herb_prism_options_set_ruby_version(options, parser_options);
+
+  pm_parser_t* parser = pm_parser_new(arena, source, length, options);
+  pm_options_free(options);
+
+  return parser;
+}
+
 hb_string_T pm_error_level_to_string(pm_error_level_t level) {
   switch (level) {
     case PM_ERROR_LEVEL_SYNTAX: return hb_string("syntax");
@@ -25,16 +63,17 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   pm_parser_t* parser,
   hb_allocator_T* allocator
 ) {
-  size_t start_offset = (size_t) (error->location.start - parser->start);
-  size_t end_offset = (size_t) (error->location.end - parser->start);
+  (void) parser;
 
-  position_T start = position_from_source_with_offset(source, start_offset);
-  position_T end = position_from_source_with_offset(source, end_offset);
+  pm_location_t location = pm_diagnostic_location(error);
+
+  position_T start = position_from_source_with_offset(source, location.start);
+  position_T end = position_from_source_with_offset(source, herb_prism_location_end(location));
 
   return ruby_parse_error_init(
-    hb_string(error->message),
-    hb_string(pm_diagnostic_id_human(error->diag_id)),
-    pm_error_level_to_string(error->level),
+    hb_string(pm_diagnostic_message(error)),
+    hb_string(pm_diagnostic_type(error)),
+    pm_error_level_to_string(pm_diagnostic_error_level(error)),
     start,
     end,
     allocator
@@ -48,9 +87,9 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error_with_positions(
   hb_allocator_T* allocator
 ) {
   return ruby_parse_error_init(
-    hb_string(error->message),
-    hb_string(pm_diagnostic_id_human(error->diag_id)),
-    pm_error_level_to_string(error->level),
+    hb_string(pm_diagnostic_message(error)),
+    hb_string(pm_diagnostic_type(error)),
+    pm_error_level_to_string(pm_diagnostic_error_level(error)),
     start,
     end,
     allocator
@@ -62,55 +101,51 @@ typedef struct {
   bool found;
 } then_keyword_search_context_T;
 
-static bool has_pm_location(pm_location_t location) {
-  return location.start != NULL && location.end != NULL && (location.end - location.start) > 0;
-}
-
-static bool search_then_keyword_location(const pm_node_t* node, void* data) {
+static pm_visit_result_t search_then_keyword_location(const pm_node_t* node, void* data) {
   then_keyword_search_context_T* context = (then_keyword_search_context_T*) data;
 
-  if (context->found) { return false; }
+  if (context->found) { return PM_VISIT_SKIP; }
 
   switch (node->type) {
     case PM_IF_NODE: {
       const pm_if_node_t* if_node = (const pm_if_node_t*) node;
 
-      if (!has_pm_location(if_node->if_keyword_loc)) { break; }
+      if (!herb_prism_location_present(if_node->if_keyword_loc)) { break; }
 
-      if (has_pm_location(if_node->then_keyword_loc)) {
+      if (herb_prism_location_present(if_node->then_keyword_loc)) {
         context->then_keyword_loc = if_node->then_keyword_loc;
         context->found = true;
-        return false;
+        return PM_VISIT_SKIP;
       }
       break;
     }
 
     case PM_UNLESS_NODE: {
       const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
-      if (has_pm_location(unless_node->then_keyword_loc)) {
+      if (herb_prism_location_present(unless_node->then_keyword_loc)) {
         context->then_keyword_loc = unless_node->then_keyword_loc;
         context->found = true;
-        return false;
+        return PM_VISIT_SKIP;
       }
       break;
     }
 
     case PM_WHEN_NODE: {
       const pm_when_node_t* when_node = (const pm_when_node_t*) node;
-      if (has_pm_location(when_node->then_keyword_loc)) {
+      if (herb_prism_location_present(when_node->then_keyword_loc)) {
         context->then_keyword_loc = when_node->then_keyword_loc;
         context->found = true;
-        return false;
+        return PM_VISIT_SKIP;
       }
       break;
     }
 
     case PM_IN_NODE: {
       const pm_in_node_t* in_node = (const pm_in_node_t*) node;
-      if (has_pm_location(in_node->then_loc)) {
-        context->then_keyword_loc = in_node->then_loc;
+      if (herb_prism_location_present(in_node->then_keyword_loc)) {
+        context->then_keyword_loc = in_node->then_keyword_loc;
         context->found = true;
-        return false;
+        return PM_VISIT_SKIP;
       }
       break;
     }
@@ -120,23 +155,20 @@ static bool search_then_keyword_location(const pm_node_t* node, void* data) {
 
   pm_visit_child_nodes(node, search_then_keyword_location, context);
 
-  return false;
+  return PM_VISIT_SKIP;
 }
 
 location_T* get_then_keyword_location(analyzed_ruby_T* analyzed, const char* source, hb_allocator_T* allocator) {
   if (analyzed == NULL || analyzed->root == NULL || source == NULL) { return NULL; }
 
-  then_keyword_search_context_T context = { .then_keyword_loc = { .start = NULL, .end = NULL }, .found = false };
+  then_keyword_search_context_T context = { .then_keyword_loc = { .start = 0, .length = 0 }, .found = false };
 
   pm_visit_child_nodes(analyzed->root, search_then_keyword_location, &context);
 
   if (!context.found) { return NULL; }
 
-  size_t start_offset = (size_t) (context.then_keyword_loc.start - analyzed->parser.start);
-  size_t end_offset = (size_t) (context.then_keyword_loc.end - analyzed->parser.start);
-
-  position_T start_position = position_from_source_with_offset(source, start_offset);
-  position_T end_position = position_from_source_with_offset(source, end_offset);
+  position_T start_position = position_from_source_with_offset(source, context.then_keyword_loc.start);
+  position_T end_position = position_from_source_with_offset(source, herb_prism_location_end(context.then_keyword_loc));
 
   return location_create(start_position, end_position, allocator);
 }
@@ -150,25 +182,26 @@ static location_T* parse_wrapped_and_find_then_keyword(
   size_t adjustment_amount,
   hb_allocator_T* allocator
 ) {
-  pm_parser_t parser;
-  pm_parser_init(&parser, (const uint8_t*) hb_buffer_value(buffer), hb_buffer_length(buffer), NULL);
-  pm_node_t* root = pm_parse(&parser);
+  pm_arena_t* arena = pm_arena_new();
+  pm_parser_t* parser = pm_parser_new(arena, (const uint8_t*) hb_buffer_value(buffer), hb_buffer_length(buffer), NULL);
+  pm_node_t* root = pm_parse(parser);
 
   if (root == NULL) {
-    pm_parser_free(&parser);
+    pm_parser_free(parser);
+    pm_arena_free(arena);
 
     return NULL;
   }
 
-  then_keyword_search_context_T context = { .then_keyword_loc = { .start = NULL, .end = NULL }, .found = false };
+  then_keyword_search_context_T context = { .then_keyword_loc = { .start = 0, .length = 0 }, .found = false };
 
   pm_visit_child_nodes(root, search_then_keyword_location, &context);
 
   location_T* location = NULL;
 
   if (context.found) {
-    size_t start_offset = (size_t) (context.then_keyword_loc.start - parser.start);
-    size_t end_offset = (size_t) (context.then_keyword_loc.end - parser.start);
+    size_t start_offset = context.then_keyword_loc.start;
+    size_t end_offset = herb_prism_location_end(context.then_keyword_loc);
 
     if (start_offset >= prefix_length && end_offset >= prefix_length) {
       start_offset -= prefix_length;
@@ -188,8 +221,8 @@ static location_T* parse_wrapped_and_find_then_keyword(
     }
   }
 
-  pm_node_destroy(&parser, root);
-  pm_parser_free(&parser);
+  pm_parser_free(parser);
+  pm_arena_free(arena);
 
   return location;
 }
@@ -245,7 +278,7 @@ location_T* get_then_keyword_location_elsif_wrapped(const char* source, hb_alloc
   return location;
 }
 
-static size_t newline_index_for_offset(const pm_newline_list_t* newlines, size_t offset) {
+static size_t newline_index_for_offset(const pm_line_offset_list_t* newlines, size_t offset) {
   size_t low = 0;
   size_t high = newlines->size;
 
@@ -267,12 +300,12 @@ void herb_prism_node_serialize(herb_prism_node_T prism_node, pm_buffer_t* buffer
 
   pm_parser_t* parser = prism_node.parser;
 
-  if (prism_node.source_end == 0 || parser->newline_list.size == 0) {
+  if (prism_node.source_end == 0 || parser->line_offsets.size == 0) {
     pm_serialize(parser, prism_node.node, buffer);
     return;
   }
 
-  const pm_newline_list_t* newlines = &parser->newline_list;
+  const pm_line_offset_list_t* newlines = &parser->line_offsets;
   size_t first_line = newline_index_for_offset(newlines, prism_node.source_start);
   size_t last_line = newline_index_for_offset(newlines, prism_node.source_end);
   size_t line_count = last_line - first_line + 1;
@@ -281,21 +314,22 @@ void herb_prism_node_serialize(herb_prism_node_T prism_node, pm_buffer_t* buffer
 
   pm_parser_t view = *parser;
 
-  view.newline_list.offsets = newlines->offsets + first_line;
-  view.newline_list.size = line_count;
-  view.newline_list.capacity = line_count;
+  view.line_offsets.offsets = newlines->offsets + first_line;
+  view.line_offsets.size = line_count;
+  view.line_offsets.capacity = line_count;
   view.start_line = parser->start_line + (int32_t) first_line;
 
   memset(&view.magic_comment_list, 0, sizeof(pm_list_t));
   memset(&view.error_list, 0, sizeof(pm_list_t));
   memset(&view.warning_list, 0, sizeof(pm_list_t));
   memset(&view.comment_list, 0, sizeof(pm_list_t));
+  memset(&view.comment_attachments, 0, sizeof(view.comment_attachments));
 
   size_t comment_count = 0;
 
   for (pm_list_node_t* entry = parser->comment_list.head; entry; entry = entry->next) {
     pm_comment_t* comment = (pm_comment_t*) entry;
-    size_t start = (size_t) (comment->location.start - parser->start);
+    size_t start = comment->location.start;
 
     if (start >= prism_node.source_start && start < prism_node.source_end) { comment_count++; }
   }
@@ -314,7 +348,7 @@ void herb_prism_node_serialize(herb_prism_node_T prism_node, pm_buffer_t* buffer
 
     for (pm_list_node_t* entry = parser->comment_list.head; entry; entry = entry->next) {
       pm_comment_t* comment = (pm_comment_t*) entry;
-      size_t start = (size_t) (comment->location.start - parser->start);
+      size_t start = comment->location.start;
 
       if (start < prism_node.source_start || start >= prism_node.source_end) { continue; }