herb 0.8.10-arm-linux-gnu → 0.9.1-arm-linux-gnu

data/src/analyze/action_view/attribute_extraction_helpers.c

@@ -0,0 +1,303 @@
+#include "../../include/analyze/action_view/attribute_extraction_helpers.h"
+#include "../../include/analyze/action_view/tag_helper_node_builders.h"
+#include "../../include/util.h"
+#include "../../include/util/hb_allocator.h"
+#include "../../include/util/hb_array.h"
+#include "../../include/util/hb_string.h"
+
+#include <prism.h>
+#include <stdlib.h>
+#include <string.h>
+
+static char* extract_string_from_prism_node(pm_node_t* node, hb_allocator_T* allocator) {
+  const uint8_t* source = NULL;
+  size_t length = 0;
+
+  if (node->type == PM_SYMBOL_NODE) {
+    pm_symbol_node_t* symbol = (pm_symbol_node_t*) node;
+    source = pm_string_source(&symbol->unescaped);
+    length = pm_string_length(&symbol->unescaped);
+  } else if (node->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) node;
+    source = pm_string_source(&string_node->unescaped);
+    length = pm_string_length(&string_node->unescaped);
+  } else {
+    return NULL;
+  }
+
+  return hb_allocator_strndup(allocator, (const char*) source, length);
+}
+
+static char* build_prefixed_key(const char* prefix, const char* raw_key, hb_allocator_T* allocator) {
+  char* dashed_key = convert_underscores_to_dashes(raw_key);
+  const char* key = dashed_key ? dashed_key : raw_key;
+  size_t prefix_len = strlen(prefix);
+  size_t key_len = strlen(key);
+  size_t total = prefix_len + 1 + key_len + 1;
+  char* result = hb_allocator_alloc(allocator, total);
+
+  if (result) { snprintf(result, total, "%s-%s", prefix, key); }
+  if (dashed_key) { free(dashed_key); }
+
+  return result;
+}
+
+static AST_HTML_ATTRIBUTE_NODE_T* create_attribute_from_value(
+  const char* name_string,
+  pm_node_t* value_node,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+) {
+  if (value_node->type == PM_SYMBOL_NODE || value_node->type == PM_STRING_NODE) {
+    char* value_string = extract_string_from_prism_node(value_node, allocator);
+    if (!value_string) { return NULL; }
+
+    AST_HTML_ATTRIBUTE_NODE_T* attribute =
+      create_html_attribute_node(name_string, value_string, start_position, end_position, allocator);
+    hb_allocator_dealloc(allocator, value_string);
+
+    return attribute;
+  } else if (value_node->type == PM_INTERPOLATED_STRING_NODE) {
+    return create_html_attribute_with_interpolated_value(
+      name_string,
+      (pm_interpolated_string_node_t*) value_node,
+      start_position,
+      end_position,
+      allocator
+    );
+  } else {
+    size_t value_length = value_node->location.end - value_node->location.start;
+    char* ruby_content = hb_allocator_strndup(allocator, (const char*) value_node->location.start, value_length);
+
+    if (ruby_content && value_node->location.start) {
+      AST_HTML_ATTRIBUTE_NODE_T* attribute =
+        create_html_attribute_with_ruby_literal(name_string, ruby_content, start_position, end_position, allocator);
+      hb_allocator_dealloc(allocator, ruby_content);
+      return attribute;
+    }
+
+    return NULL;
+  }
+}
+
+AST_HTML_ATTRIBUTE_NODE_T* extract_html_attribute_from_assoc(
+  pm_assoc_node_t* assoc,
+  const uint8_t* source,
+  const char* original_source,
+  size_t erb_content_offset,
+  hb_allocator_T* allocator
+) {
+  if (!assoc) { return NULL; }
+
+  char* name_string = extract_string_from_prism_node(assoc->key, allocator);
+  if (!name_string) { return NULL; }
+
+  position_T start_position =
+    prism_location_to_position_with_offset(&assoc->key->location, original_source, erb_content_offset, source);
+  position_T end_position =
+    prism_location_to_position_with_offset(&assoc->value->location, original_source, erb_content_offset, source);
+
+  // Rails converts `method:` and `remote:` to `data-*` attributes
+  if (strcmp(name_string, "method") == 0 || strcmp(name_string, "remote") == 0) {
+    size_t name_len = strlen(name_string);
+    size_t prefixed_len = 5 + name_len + 1;
+    char* prefixed = hb_allocator_alloc(allocator, prefixed_len);
+    snprintf(prefixed, prefixed_len, "data-%s", name_string);
+    hb_allocator_dealloc(allocator, name_string);
+    name_string = prefixed;
+  }
+
+  if ((strcmp(name_string, "data") == 0 || strcmp(name_string, "aria") == 0) && assoc->value->type == PM_HASH_NODE) {
+    hb_allocator_dealloc(allocator, name_string);
+    return NULL;
+  }
+
+  char* dashed_name = convert_underscores_to_dashes(name_string);
+  AST_HTML_ATTRIBUTE_NODE_T* attribute_node = create_attribute_from_value(
+    dashed_name ? dashed_name : name_string,
+    assoc->value,
+    start_position,
+    end_position,
+    allocator
+  );
+
+  if (dashed_name) { free(dashed_name); }
+  hb_allocator_dealloc(allocator, name_string);
+
+  return attribute_node;
+}
+
+hb_array_T* extract_html_attributes_from_keyword_hash(
+  pm_keyword_hash_node_t* kw_hash,
+  const uint8_t* source,
+  const char* original_source,
+  size_t erb_content_offset,
+  hb_allocator_T* allocator
+) {
+  if (!kw_hash) { return NULL; }
+
+  hb_array_T* attributes = hb_array_init(8, allocator);
+  if (!attributes) { return NULL; }
+
+  for (size_t i = 0; i < kw_hash->elements.size; i++) {
+    pm_node_t* element = kw_hash->elements.nodes[i];
+
+    if (element->type == PM_ASSOC_SPLAT_NODE) {
+      pm_assoc_splat_node_t* splat = (pm_assoc_splat_node_t*) element;
+      size_t splat_length = splat->base.location.end - splat->base.location.start;
+      char* splat_content = hb_allocator_strndup(allocator, (const char*) splat->base.location.start, splat_length);
+
+      if (splat_content) {
+        position_T splat_start =
+          prism_location_to_position_with_offset(&splat->base.location, original_source, erb_content_offset, source);
+
+        AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE_T* splat_node = ast_ruby_html_attributes_splat_node_init(
+          hb_string_from_c_string(splat_content),
+          HB_STRING_EMPTY,
+          splat_start,
+          splat_start,
+          hb_array_init(0, allocator),
+          allocator
+        );
+
+        if (splat_node) { hb_array_append(attributes, (AST_NODE_T*) splat_node); }
+
+        hb_allocator_dealloc(allocator, splat_content);
+      }
+    } else if (element->type == PM_ASSOC_NODE) {
+      pm_assoc_node_t* assoc = (pm_assoc_node_t*) element;
+
+      char* key_string = extract_string_from_prism_node(assoc->key, allocator);
+
+      if (key_string && (strcmp(key_string, "data") == 0 || strcmp(key_string, "aria") == 0)
+          && assoc->value->type == PM_HASH_NODE) {
+        pm_hash_node_t* hash = (pm_hash_node_t*) assoc->value;
+
+        for (size_t j = 0; j < hash->elements.size; j++) {
+          pm_node_t* hash_element = hash->elements.nodes[j];
+
+          if (hash_element->type == PM_ASSOC_SPLAT_NODE) {
+            pm_assoc_splat_node_t* splat = (pm_assoc_splat_node_t*) hash_element;
+            size_t splat_length = splat->base.location.end - splat->base.location.start;
+            char* splat_content =
+              hb_allocator_strndup(allocator, (const char*) splat->base.location.start, splat_length);
+
+            if (splat_content) {
+              position_T splat_start = prism_location_to_position_with_offset(
+                &splat->base.location,
+                original_source,
+                erb_content_offset,
+                source
+              );
+
+              AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE_T* splat_node = ast_ruby_html_attributes_splat_node_init(
+                hb_string_from_c_string(splat_content),
+                hb_string_from_c_string(key_string),
+                splat_start,
+                splat_start,
+                hb_array_init(0, allocator),
+                allocator
+              );
+
+              if (splat_node) { hb_array_append(attributes, (AST_NODE_T*) splat_node); }
+
+              hb_allocator_dealloc(allocator, splat_content);
+            }
+
+            continue;
+          }
+
+          if (hash_element->type != PM_ASSOC_NODE) { continue; }
+
+          pm_assoc_node_t* hash_assoc = (pm_assoc_node_t*) hash_element;
+          char* raw_key = extract_string_from_prism_node(hash_assoc->key, allocator);
+          if (!raw_key) { continue; }
+
+          char* attribute_key_string = build_prefixed_key(key_string, raw_key, allocator);
+          hb_allocator_dealloc(allocator, raw_key);
+
+          if (attribute_key_string) {
+            position_T attribute_start = prism_location_to_position_with_offset(
+              &hash_assoc->key->location,
+              original_source,
+              erb_content_offset,
+              source
+            );
+            position_T attribute_end = prism_location_to_position_with_offset(
+              &hash_assoc->value->location,
+              original_source,
+              erb_content_offset,
+              source
+            );
+
+            AST_HTML_ATTRIBUTE_NODE_T* attribute = create_attribute_from_value(
+              attribute_key_string,
+              hash_assoc->value,
+              attribute_start,
+              attribute_end,
+              allocator
+            );
+
+            if (attribute) { hb_array_append(attributes, attribute); }
+            hb_allocator_dealloc(allocator, attribute_key_string);
+          }
+        }
+      } else {
+        AST_HTML_ATTRIBUTE_NODE_T* attribute =
+          extract_html_attribute_from_assoc(assoc, source, original_source, erb_content_offset, allocator);
+
+        if (attribute) { hb_array_append(attributes, attribute); }
+      }
+
+      if (key_string) { hb_allocator_dealloc(allocator, key_string); }
+    }
+  }
+
+  return attributes;
+}
+
+bool has_html_attributes_in_call(pm_call_node_t* call_node) {
+  if (!call_node || !call_node->arguments) { return false; }
+
+  pm_arguments_node_t* arguments = call_node->arguments;
+  if (arguments->arguments.size == 0) { return false; }
+
+  pm_node_t* last_argument = arguments->arguments.nodes[arguments->arguments.size - 1];
+
+  return last_argument && (last_argument->type == PM_KEYWORD_HASH_NODE || last_argument->type == PM_HASH_NODE);
+}
+
+hb_array_T* extract_html_attributes_from_call_node(
+  pm_call_node_t* call_node,
+  const uint8_t* source,
+  const char* original_source,
+  size_t erb_content_offset,
+  hb_allocator_T* allocator
+) {
+  if (!has_html_attributes_in_call(call_node)) { return NULL; }
+
+  pm_arguments_node_t* arguments = call_node->arguments;
+  pm_node_t* last_argument = arguments->arguments.nodes[arguments->arguments.size - 1];
+
+  if (last_argument->type == PM_HASH_NODE) {
+    pm_hash_node_t* hash_node = (pm_hash_node_t*) last_argument;
+    pm_keyword_hash_node_t synthetic = { .base = hash_node->base, .elements = hash_node->elements };
+
+    return extract_html_attributes_from_keyword_hash(
+      &synthetic,
+      source,
+      original_source,
+      erb_content_offset,
+      allocator
+    );
+  }
+
+  return extract_html_attributes_from_keyword_hash(
+    (pm_keyword_hash_node_t*) last_argument,
+    source,
+    original_source,
+    erb_content_offset,
+    allocator
+  );
+}

data/src/analyze/action_view/content_tag.c

@@ -0,0 +1,78 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool detect_content_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
+  if (!call_node || !call_node->name) { return false; }
+
+  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  return constant && constant->length == 11 && strncmp((const char*) constant->start, "content_tag", 11) == 0;
+}
+
+char* extract_content_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) parser;
+
+  if (!call_node || !call_node->arguments) { return NULL; }
+
+  pm_arguments_node_t* arguments = call_node->arguments;
+  if (!arguments->arguments.size) { return NULL; }
+
+  pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+  if (first_argument->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
+    size_t length = pm_string_length(&string_node->unescaped);
+    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+  } else if (first_argument->type == PM_SYMBOL_NODE) {
+    pm_symbol_node_t* symbol_node = (pm_symbol_node_t*) first_argument;
+    size_t length = pm_string_length(&symbol_node->unescaped);
+    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&symbol_node->unescaped), length);
+  }
+
+  return NULL;
+}
+
+char* extract_content_tag_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) parser;
+
+  if (!call_node) { return NULL; }
+
+  char* block_content = extract_inline_block_content(call_node, allocator);
+  if (block_content) { return block_content; }
+
+  if (call_node->arguments) {
+    pm_arguments_node_t* arguments = call_node->arguments;
+
+    if (arguments->arguments.size >= 2) {
+      pm_node_t* second_argument = arguments->arguments.nodes[1];
+
+      if (second_argument->type != PM_KEYWORD_HASH_NODE) {
+        if (second_argument->type == PM_STRING_NODE) {
+          pm_string_node_t* string_node = (pm_string_node_t*) second_argument;
+          size_t length = pm_string_length(&string_node->unescaped);
+          return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+        }
+
+        size_t source_length = second_argument->location.end - second_argument->location.start;
+        return hb_allocator_strndup(allocator, (const char*) second_argument->location.start, source_length);
+      }
+    }
+  }
+
+  return NULL;
+}
+
+bool content_tag_supports_block(void) {
+  return true;
+}
+
+const tag_helper_handler_T content_tag_handler = { .name = "content_tag",
+                                                   .source =
+                                                     HB_STRING_LITERAL("ActionView::Helpers::TagHelper#content_tag"),
+                                                   .detect = detect_content_tag,
+                                                   .extract_tag_name = extract_content_tag_name,
+                                                   .extract_content = extract_content_tag_content,
+                                                   .supports_block = content_tag_supports_block };

data/src/analyze/action_view/link_to.c

@@ -0,0 +1,167 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char* wrap_in_url_for(const char* source, size_t source_length, hb_allocator_T* allocator) {
+  const char* prefix = "url_for(";
+  const char* suffix = ")";
+  size_t prefix_len = strlen(prefix);
+  size_t suffix_len = strlen(suffix);
+  size_t total_length = prefix_len + source_length + suffix_len;
+  char* result = hb_allocator_alloc(allocator, total_length + 1);
+
+  memcpy(result, prefix, prefix_len);
+  memcpy(result + prefix_len, source, source_length);
+  memcpy(result + prefix_len + source_length, suffix, suffix_len);
+  result[total_length] = '\0';
+
+  return result;
+}
+
+bool detect_link_to(pm_call_node_t* call_node, pm_parser_t* parser) {
+  if (!call_node || !call_node->name) { return false; }
+
+  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+
+  return constant && constant->length == 7 && strncmp((const char*) constant->start, "link_to", 7) == 0;
+}
+
+bool is_route_helper_node(pm_node_t* node, pm_parser_t* parser) {
+  if (!node || node->type != PM_CALL_NODE) { return false; }
+
+  pm_call_node_t* call = (pm_call_node_t*) node;
+  if (!call->name) { return false; }
+
+  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call->name);
+  if (!constant || constant->length < 5) { return false; }
+
+  const char* name = (const char*) constant->start;
+  size_t length = constant->length;
+
+  return (length >= 5 && strncmp(name + length - 5, "_path", 5) == 0)
+      || (length >= 4 && strncmp(name + length - 4, "_url", 4) == 0);
+}
+
+char* extract_link_to_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) call_node;
+  (void) parser;
+
+  return hb_allocator_strdup(allocator, "a");
+}
+
+char* extract_link_to_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) parser;
+
+  if (!call_node) { return NULL; }
+
+  char* block_content = extract_inline_block_content(call_node, allocator);
+  if (block_content) { return block_content; }
+
+  if (!call_node->arguments) { return NULL; }
+
+  pm_arguments_node_t* arguments = call_node->arguments;
+  if (!arguments->arguments.size) { return NULL; }
+
+  pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+  if (first_argument->type == PM_NIL_NODE) { return NULL; }
+
+  if (first_argument->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
+    size_t length = pm_string_length(&string_node->unescaped);
+    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+  }
+
+  size_t source_length = first_argument->location.end - first_argument->location.start;
+
+  // Format: "<expression>.to_s"
+  if (arguments->arguments.size == 1) {
+    const char* suffix = ".to_s";
+    size_t suffix_len = strlen(suffix);
+    size_t total_length = source_length + suffix_len;
+    char* ruby_expression = hb_allocator_alloc(allocator, total_length + 1);
+
+    memcpy(ruby_expression, (const char*) first_argument->location.start, source_length);
+    memcpy(ruby_expression + source_length, suffix, suffix_len);
+    ruby_expression[total_length] = '\0';
+
+    return ruby_expression;
+  }
+
+  return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+}
+
+char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) parser;
+
+  if (!call_node || !call_node->arguments) { return NULL; }
+
+  pm_arguments_node_t* arguments = call_node->arguments;
+  bool has_inline_block = call_node->block && call_node->block->type == PM_BLOCK_NODE;
+
+  if (has_inline_block && arguments->arguments.size >= 1) {
+    pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+    if (first_argument->type == PM_STRING_NODE) {
+      pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
+      size_t length = pm_string_length(&string_node->unescaped);
+      return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+    }
+
+    size_t source_length = first_argument->location.end - first_argument->location.start;
+
+    if (is_route_helper_node(first_argument, parser)) {
+      return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+    }
+
+    return wrap_in_url_for((const char*) first_argument->location.start, source_length, allocator);
+  }
+
+  // Format: "url_for(<expression>)"
+  if (arguments->arguments.size == 1) {
+    pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+    if (first_argument->type == PM_STRING_NODE || first_argument->type == PM_NIL_NODE) { return NULL; }
+
+    size_t source_length = first_argument->location.end - first_argument->location.start;
+
+    if (is_route_helper_node(first_argument, parser)) {
+      return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+    }
+
+    return wrap_in_url_for((const char*) first_argument->location.start, source_length, allocator);
+  }
+
+  if (arguments->arguments.size < 2) { return NULL; }
+
+  pm_node_t* second_argument = arguments->arguments.nodes[1];
+
+  if (second_argument->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) second_argument;
+    size_t length = pm_string_length(&string_node->unescaped);
+    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+  }
+
+  size_t source_length = second_argument->location.end - second_argument->location.start;
+
+  if (!is_route_helper_node(second_argument, parser)) {
+    return wrap_in_url_for((const char*) second_argument->location.start, source_length, allocator);
+  }
+
+  return hb_allocator_strndup(allocator, (const char*) second_argument->location.start, source_length);
+}
+
+bool link_to_supports_block(void) {
+  return true;
+}
+
+const tag_helper_handler_T link_to_handler = { .name = "link_to",
+                                               .source = HB_STRING_LITERAL("ActionView::Helpers::UrlHelper#link_to"),
+                                               .detect = detect_link_to,
+                                               .extract_tag_name = extract_link_to_tag_name,
+                                               .extract_content = extract_link_to_content,
+                                               .supports_block = link_to_supports_block };

data/src/analyze/action_view/registry.c

@@ -0,0 +1,83 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/util/hb_allocator.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+extern const tag_helper_handler_T content_tag_handler;
+extern const tag_helper_handler_T tag_dot_handler;
+extern const tag_helper_handler_T link_to_handler;
+extern const tag_helper_handler_T turbo_frame_tag_handler;
+
+static size_t handlers_count = 4;
+
+tag_helper_info_T* tag_helper_info_init(hb_allocator_T* allocator) {
+  tag_helper_info_T* info = hb_allocator_alloc(allocator, sizeof(tag_helper_info_T));
+
+  if (info) {
+    info->tag_name = NULL;
+    info->call_node = NULL;
+    info->attributes = NULL;
+    info->content = NULL;
+    info->has_block = false;
+    info->allocator = allocator;
+  }
+
+  return info;
+}
+
+void tag_helper_info_free(tag_helper_info_T** info) {
+  if (!info || !*info) { return; }
+
+  hb_allocator_T* allocator = (*info)->allocator;
+
+  if ((*info)->tag_name) { hb_allocator_dealloc(allocator, (*info)->tag_name); }
+  if ((*info)->content) { hb_allocator_dealloc(allocator, (*info)->content); }
+  if ((*info)->attributes) { hb_array_free(&(*info)->attributes); }
+
+  hb_allocator_dealloc(allocator, *info);
+
+  *info = NULL;
+}
+
+tag_helper_handler_T* get_tag_helper_handlers(void) {
+  static tag_helper_handler_T static_handlers[4];
+  static bool initialized = false;
+
+  if (!initialized) {
+    static_handlers[0] = content_tag_handler;
+    static_handlers[1] = tag_dot_handler;
+    static_handlers[2] = link_to_handler;
+    static_handlers[3] = turbo_frame_tag_handler;
+    initialized = true;
+  }
+
+  return static_handlers;
+}
+
+size_t get_tag_helper_handlers_count(void) {
+  return handlers_count;
+}
+
+char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* allocator) {
+  if (!call_node || !call_node->block || call_node->block->type != PM_BLOCK_NODE) { return NULL; }
+
+  pm_block_node_t* block_node = (pm_block_node_t*) call_node->block;
+
+  if (!block_node->body || block_node->body->type != PM_STATEMENTS_NODE) { return NULL; }
+
+  pm_statements_node_t* statements = (pm_statements_node_t*) block_node->body;
+
+  if (statements->body.size != 1) { return NULL; }
+
+  pm_node_t* statement = statements->body.nodes[0];
+
+  if (statement->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) statement;
+    size_t length = pm_string_length(&string_node->unescaped);
+    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+  }
+
+  size_t source_length = statement->location.end - statement->location.start;
+  return hb_allocator_strndup(allocator, (const char*) statement->location.start, source_length);
+}