herb 0.9.2-arm-linux-gnu → 0.9.4-arm-linux-gnu

data/src/errors.c

@@ -2,14 +2,14 @@
 // be modified manually. See /home/runner/work/herb/herb/templates/src/errors.c.erb
 
 #include "include/errors.h"
-#include "include/location.h"
-#include "include/position.h"
-#include "include/pretty_print.h"
-#include "include/token.h"
-#include "include/util.h"
-#include "include/util/hb_allocator.h"
-#include "include/util/hb_array.h"
-#include "include/util/hb_string.h"
+#include "include/location/location.h"
+#include "include/location/position.h"
+#include "include/ast/pretty_print.h"
+#include "include/lexer/token.h"
+#include "include/util/util.h"
+#include "include/lib/hb_allocator.h"
+#include "include/lib/hb_array.h"
+#include "include/lib/hb_string.h"
 
 #include <stdio.h>
 #include <stdbool.h>
@@ -1029,6 +1029,225 @@ void append_render_layout_without_block_error(hb_string_T layout, position_T sta
   hb_array_append(errors, render_layout_without_block_error_init(layout, start, end, allocator));
 }
 
+STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T* strict_locals_positional_argument_error_init(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator) {
+  STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T* strict_locals_positional_argument_error = hb_allocator_alloc(allocator, sizeof(STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T));
+
+  if (!strict_locals_positional_argument_error) { return NULL; }
+
+  error_init(&strict_locals_positional_argument_error->base, STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR, start, end);
+
+  const char* message_template = "Strict locals only support keyword arguments. Positional argument `%s` is not allowed. Use keyword argument format: `%s:`.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(name, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_1 = hb_string_truncate(name, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_1 = hb_string_to_c_string_using_malloc(truncated_argument_1);
+
+  char message[379];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    truncated_c_string_1 ? truncated_c_string_1 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_1) { free(truncated_c_string_1); }
+  strict_locals_positional_argument_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  strict_locals_positional_argument_error->name = hb_string_copy(name, allocator);
+  return strict_locals_positional_argument_error;
+}
+
+void append_strict_locals_positional_argument_error(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, strict_locals_positional_argument_error_init(name, start, end, allocator));
+}
+
+STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T* strict_locals_block_argument_error_init(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator) {
+  STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T* strict_locals_block_argument_error = hb_allocator_alloc(allocator, sizeof(STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T));
+
+  if (!strict_locals_block_argument_error) { return NULL; }
+
+  error_init(&strict_locals_block_argument_error->base, STRICT_LOCALS_BLOCK_ARGUMENT_ERROR, start, end);
+
+  const char* message_template = "Strict locals only support keyword arguments. Block argument `&%s` is not allowed.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(name, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[211];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  strict_locals_block_argument_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  strict_locals_block_argument_error->name = hb_string_copy(name, allocator);
+  return strict_locals_block_argument_error;
+}
+
+void append_strict_locals_block_argument_error(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, strict_locals_block_argument_error_init(name, start, end, allocator));
+}
+
+STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T* strict_locals_splat_argument_error_init(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator) {
+  STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T* strict_locals_splat_argument_error = hb_allocator_alloc(allocator, sizeof(STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T));
+
+  if (!strict_locals_splat_argument_error) { return NULL; }
+
+  error_init(&strict_locals_splat_argument_error->base, STRICT_LOCALS_SPLAT_ARGUMENT_ERROR, start, end);
+
+  const char* message_template = "Strict locals only support keyword arguments. Splat argument `*%s` is not allowed.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(name, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[211];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  strict_locals_splat_argument_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  strict_locals_splat_argument_error->name = hb_string_copy(name, allocator);
+  return strict_locals_splat_argument_error;
+}
+
+void append_strict_locals_splat_argument_error(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, strict_locals_splat_argument_error_init(name, start, end, allocator));
+}
+
+STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T* strict_locals_missing_parenthesis_error_init(hb_string_T rest, position_T start, position_T end, hb_allocator_T* allocator) {
+  STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T* strict_locals_missing_parenthesis_error = hb_allocator_alloc(allocator, sizeof(STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T));
+
+  if (!strict_locals_missing_parenthesis_error) { return NULL; }
+
+  error_init(&strict_locals_missing_parenthesis_error->base, STRICT_LOCALS_MISSING_PARENTHESIS_ERROR, start, end);
+
+  const char* message_template = "Strict locals declaration requires parentheses. Expected `locals: (...)` but got `locals: %s`.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(rest, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[223];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  strict_locals_missing_parenthesis_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  strict_locals_missing_parenthesis_error->rest = hb_string_copy(rest, allocator);
+  return strict_locals_missing_parenthesis_error;
+}
+
+void append_strict_locals_missing_parenthesis_error(hb_string_T rest, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, strict_locals_missing_parenthesis_error_init(rest, start, end, allocator));
+}
+
+STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T* strict_locals_duplicate_declaration_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
+  STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T* strict_locals_duplicate_declaration_error = hb_allocator_alloc(allocator, sizeof(STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T));
+
+  if (!strict_locals_duplicate_declaration_error) { return NULL; }
+
+  error_init(&strict_locals_duplicate_declaration_error->base, STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR, start, end);
+
+  strict_locals_duplicate_declaration_error->base.message = hb_string_copy(hb_string("Duplicate strict locals declaration. Only the first `<%# locals: (...) %>` declaration is used by Rails."), allocator);
+
+  return strict_locals_duplicate_declaration_error;
+}
+
+void append_strict_locals_duplicate_declaration_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, strict_locals_duplicate_declaration_error_init(start, end, allocator));
+}
+
+VOID_ELEMENT_CONTENT_ERROR_T* void_element_content_error_init(token_T* tag_name, hb_string_T helper_name, hb_string_T content_type, position_T start, position_T end, hb_allocator_T* allocator) {
+  VOID_ELEMENT_CONTENT_ERROR_T* void_element_content_error = hb_allocator_alloc(allocator, sizeof(VOID_ELEMENT_CONTENT_ERROR_T));
+
+  if (!void_element_content_error) { return NULL; }
+
+  error_init(&void_element_content_error->base, VOID_ELEMENT_CONTENT_ERROR, start, end);
+
+  const char* message_template = "Void element `%s` cannot have content. `%s` does not accept %s for content.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_1 = hb_string_truncate(helper_name, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_1 = hb_string_to_c_string_using_malloc(truncated_argument_1);
+
+  hb_string_T truncated_argument_2 = hb_string_truncate(content_type, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_2 = hb_string_to_c_string_using_malloc(truncated_argument_2);
+
+  char message[460];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    truncated_c_string_1 ? truncated_c_string_1 : "",
+    truncated_c_string_2 ? truncated_c_string_2 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_1) { free(truncated_c_string_1); }
+  if (truncated_c_string_2) { free(truncated_c_string_2); }
+  void_element_content_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  void_element_content_error->tag_name = token_copy(tag_name, allocator);
+  void_element_content_error->helper_name = hb_string_copy(helper_name, allocator);
+  void_element_content_error->content_type = hb_string_copy(content_type, allocator);
+  return void_element_content_error;
+}
+
+void append_void_element_content_error(token_T* tag_name, hb_string_T helper_name, hb_string_T content_type, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, void_element_content_error_init(tag_name, helper_name, content_type, start, end, allocator));
+}
+
+DOT_NOTATION_CASING_ERROR_T* dot_notation_casing_error_init(token_T* segment, position_T start, position_T end, hb_allocator_T* allocator) {
+  DOT_NOTATION_CASING_ERROR_T* dot_notation_casing_error = hb_allocator_alloc(allocator, sizeof(DOT_NOTATION_CASING_ERROR_T));
+
+  if (!dot_notation_casing_error) { return NULL; }
+
+  error_init(&dot_notation_casing_error->base, DOT_NOTATION_CASING_ERROR, start, end);
+
+  const char* message_template = "Dot-notation component tags require the first segment to start with an uppercase letter. `%s` does not start with an uppercase letter.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(segment->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[263];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  dot_notation_casing_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  dot_notation_casing_error->segment = token_copy(segment, allocator);
+  return dot_notation_casing_error;
+}
+
+void append_dot_notation_casing_error(token_T* segment, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, dot_notation_casing_error_init(segment, start, end, allocator));
+}
+
 hb_string_T error_type_to_string(ERROR_T* error) {
   switch (error->type) {
     case UNEXPECTED_ERROR: return hb_string("UNEXPECTED_ERROR");
@@ -1061,6 +1280,13 @@ hb_string_T error_type_to_string(ERROR_T* error) {
     case RENDER_INVALID_AS_OPTION_ERROR: return hb_string("RENDER_INVALID_AS_OPTION_ERROR");
     case RENDER_OBJECT_AND_COLLECTION_ERROR: return hb_string("RENDER_OBJECT_AND_COLLECTION_ERROR");
     case RENDER_LAYOUT_WITHOUT_BLOCK_ERROR: return hb_string("RENDER_LAYOUT_WITHOUT_BLOCK_ERROR");
+    case STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR: return hb_string("STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR");
+    case STRICT_LOCALS_BLOCK_ARGUMENT_ERROR: return hb_string("STRICT_LOCALS_BLOCK_ARGUMENT_ERROR");
+    case STRICT_LOCALS_SPLAT_ARGUMENT_ERROR: return hb_string("STRICT_LOCALS_SPLAT_ARGUMENT_ERROR");
+    case STRICT_LOCALS_MISSING_PARENTHESIS_ERROR: return hb_string("STRICT_LOCALS_MISSING_PARENTHESIS_ERROR");
+    case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: return hb_string("STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR");
+    case VOID_ELEMENT_CONTENT_ERROR: return hb_string("VOID_ELEMENT_CONTENT_ERROR");
+    case DOT_NOTATION_CASING_ERROR: return hb_string("DOT_NOTATION_CASING_ERROR");
   }
 
   return hb_string("Unknown error_type_T");
@@ -1098,6 +1324,13 @@ hb_string_T error_human_type(ERROR_T* error) {
     case RENDER_INVALID_AS_OPTION_ERROR: return hb_string("RenderInvalidAsOptionError");
     case RENDER_OBJECT_AND_COLLECTION_ERROR: return hb_string("RenderObjectAndCollectionError");
     case RENDER_LAYOUT_WITHOUT_BLOCK_ERROR: return hb_string("RenderLayoutWithoutBlockError");
+    case STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR: return hb_string("StrictLocalsPositionalArgumentError");
+    case STRICT_LOCALS_BLOCK_ARGUMENT_ERROR: return hb_string("StrictLocalsBlockArgumentError");
+    case STRICT_LOCALS_SPLAT_ARGUMENT_ERROR: return hb_string("StrictLocalsSplatArgumentError");
+    case STRICT_LOCALS_MISSING_PARENTHESIS_ERROR: return hb_string("StrictLocalsMissingParenthesisError");
+    case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: return hb_string("StrictLocalsDuplicateDeclarationError");
+    case VOID_ELEMENT_CONTENT_ERROR: return hb_string("VoidElementContentError");
+    case DOT_NOTATION_CASING_ERROR: return hb_string("DotNotationCasingError");
   }
 
   return hb_string("Unknown error_type_T");
@@ -1311,6 +1544,50 @@ static void error_free_render_layout_without_block_error(RENDER_LAYOUT_WITHOUT_B
   error_free_base_error(&render_layout_without_block_error->base, allocator);
 }
 
+static void error_free_strict_locals_positional_argument_error(STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T* strict_locals_positional_argument_error, hb_allocator_T* allocator) {
+  if (strict_locals_positional_argument_error->name.data != NULL) { hb_allocator_dealloc(allocator, strict_locals_positional_argument_error->name.data); }
+
+  error_free_base_error(&strict_locals_positional_argument_error->base, allocator);
+}
+
+static void error_free_strict_locals_block_argument_error(STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T* strict_locals_block_argument_error, hb_allocator_T* allocator) {
+  if (strict_locals_block_argument_error->name.data != NULL) { hb_allocator_dealloc(allocator, strict_locals_block_argument_error->name.data); }
+
+  error_free_base_error(&strict_locals_block_argument_error->base, allocator);
+}
+
+static void error_free_strict_locals_splat_argument_error(STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T* strict_locals_splat_argument_error, hb_allocator_T* allocator) {
+  if (strict_locals_splat_argument_error->name.data != NULL) { hb_allocator_dealloc(allocator, strict_locals_splat_argument_error->name.data); }
+
+  error_free_base_error(&strict_locals_splat_argument_error->base, allocator);
+}
+
+static void error_free_strict_locals_missing_parenthesis_error(STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T* strict_locals_missing_parenthesis_error, hb_allocator_T* allocator) {
+  if (strict_locals_missing_parenthesis_error->rest.data != NULL) { hb_allocator_dealloc(allocator, strict_locals_missing_parenthesis_error->rest.data); }
+
+  error_free_base_error(&strict_locals_missing_parenthesis_error->base, allocator);
+}
+
+static void error_free_strict_locals_duplicate_declaration_error(STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T* strict_locals_duplicate_declaration_error, hb_allocator_T* allocator) {
+  /* no STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T specific fields to free up */
+
+  error_free_base_error(&strict_locals_duplicate_declaration_error->base, allocator);
+}
+
+static void error_free_void_element_content_error(VOID_ELEMENT_CONTENT_ERROR_T* void_element_content_error, hb_allocator_T* allocator) {
+  if (void_element_content_error->tag_name != NULL) { token_free(void_element_content_error->tag_name, allocator); }
+  if (void_element_content_error->helper_name.data != NULL) { hb_allocator_dealloc(allocator, void_element_content_error->helper_name.data); }
+  if (void_element_content_error->content_type.data != NULL) { hb_allocator_dealloc(allocator, void_element_content_error->content_type.data); }
+
+  error_free_base_error(&void_element_content_error->base, allocator);
+}
+
+static void error_free_dot_notation_casing_error(DOT_NOTATION_CASING_ERROR_T* dot_notation_casing_error, hb_allocator_T* allocator) {
+  if (dot_notation_casing_error->segment != NULL) { token_free(dot_notation_casing_error->segment, allocator); }
+
+  error_free_base_error(&dot_notation_casing_error->base, allocator);
+}
+
 void error_free(ERROR_T* error, hb_allocator_T* allocator) {
   if (!error) { return; }
 
@@ -1345,6 +1622,13 @@ void error_free(ERROR_T* error, hb_allocator_T* allocator) {
     case RENDER_INVALID_AS_OPTION_ERROR: error_free_render_invalid_as_option_error((RENDER_INVALID_AS_OPTION_ERROR_T*) error, allocator); break;
     case RENDER_OBJECT_AND_COLLECTION_ERROR: error_free_render_object_and_collection_error((RENDER_OBJECT_AND_COLLECTION_ERROR_T*) error, allocator); break;
     case RENDER_LAYOUT_WITHOUT_BLOCK_ERROR: error_free_render_layout_without_block_error((RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T*) error, allocator); break;
+    case STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR: error_free_strict_locals_positional_argument_error((STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T*) error, allocator); break;
+    case STRICT_LOCALS_BLOCK_ARGUMENT_ERROR: error_free_strict_locals_block_argument_error((STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T*) error, allocator); break;
+    case STRICT_LOCALS_SPLAT_ARGUMENT_ERROR: error_free_strict_locals_splat_argument_error((STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T*) error, allocator); break;
+    case STRICT_LOCALS_MISSING_PARENTHESIS_ERROR: error_free_strict_locals_missing_parenthesis_error((STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T*) error, allocator); break;
+    case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: error_free_strict_locals_duplicate_declaration_error((STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T*) error, allocator); break;
+    case VOID_ELEMENT_CONTENT_ERROR: error_free_void_element_content_error((VOID_ELEMENT_CONTENT_ERROR_T*) error, allocator); break;
+    case DOT_NOTATION_CASING_ERROR: error_free_dot_notation_casing_error((DOT_NOTATION_CASING_ERROR_T*) error, allocator); break;
   }
 }
 
@@ -1829,6 +2113,105 @@ static void error_pretty_print_render_layout_without_block_error(RENDER_LAYOUT_W
   pretty_print_quoted_property(hb_string("layout"), error->layout, indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_strict_locals_positional_argument_error(STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("name"), error->name, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_strict_locals_block_argument_error(STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("name"), error->name, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_strict_locals_splat_argument_error(STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("name"), error->name, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_strict_locals_missing_parenthesis_error(STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("rest"), error->rest, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_strict_locals_duplicate_declaration_error(STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_void_element_content_error(VOID_ELEMENT_CONTENT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->tag_name, hb_string("tag_name"), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("helper_name"), error->helper_name, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("content_type"), error->content_type, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_dot_notation_casing_error(DOT_NOTATION_CASING_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->segment, hb_string("segment"), indent, relative_indent, true, buffer);
+}
+
 void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
@@ -1863,6 +2246,13 @@ void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relati
     case RENDER_INVALID_AS_OPTION_ERROR: error_pretty_print_render_invalid_as_option_error((RENDER_INVALID_AS_OPTION_ERROR_T*) error, indent, relative_indent, buffer); break;
     case RENDER_OBJECT_AND_COLLECTION_ERROR: error_pretty_print_render_object_and_collection_error((RENDER_OBJECT_AND_COLLECTION_ERROR_T*) error, indent, relative_indent, buffer); break;
     case RENDER_LAYOUT_WITHOUT_BLOCK_ERROR: error_pretty_print_render_layout_without_block_error((RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR: error_pretty_print_strict_locals_positional_argument_error((STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case STRICT_LOCALS_BLOCK_ARGUMENT_ERROR: error_pretty_print_strict_locals_block_argument_error((STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case STRICT_LOCALS_SPLAT_ARGUMENT_ERROR: error_pretty_print_strict_locals_splat_argument_error((STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case STRICT_LOCALS_MISSING_PARENTHESIS_ERROR: error_pretty_print_strict_locals_missing_parenthesis_error((STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: error_pretty_print_strict_locals_duplicate_declaration_error((STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case VOID_ELEMENT_CONTENT_ERROR: error_pretty_print_void_element_content_error((VOID_ELEMENT_CONTENT_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case DOT_NOTATION_CASING_ERROR: error_pretty_print_dot_notation_casing_error((DOT_NOTATION_CASING_ERROR_T*) error, indent, relative_indent, buffer); break;
   }
 }
 

data/src/extract.c

@@ -1,9 +1,9 @@
 #include "include/herb.h"
-#include "include/util/hb_allocator.h"
-#include "include/util/hb_array.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/hb_string.h"
-#include "include/util/string.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 <assert.h>
 #include <stdlib.h>

data/src/herb.c

@@ -1,11 +1,11 @@
 #include "include/herb.h"
 #include "include/analyze/analyze.h"
 #include "include/analyze/prism_annotate.h"
-#include "include/lexer.h"
-#include "include/parser.h"
-#include "include/token.h"
-#include "include/util/hb_allocator.h"
-#include "include/util/hb_array.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/parser/parser.h"
 #include "include/version.h"
 
 #include <prism.h>
@@ -44,6 +44,16 @@ HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(
   parser_options_T parser_options = HERB_DEFAULT_PARSER_OPTIONS;
   if (options != NULL) { parser_options = *options; }
 
+  if (parser_options.start_line > 0) {
+    lexer.current_line = parser_options.start_line;
+    lexer.previous_line = parser_options.start_line;
+  }
+
+  if (parser_options.start_column > 0) {
+    lexer.current_column = parser_options.start_column;
+    lexer.previous_column = parser_options.start_column;
+  }
+
   herb_parser_init(&parser, &lexer, parser_options);
 
   AST_DOCUMENT_NODE_T* document = herb_parser_parse(&parser);

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

@@ -1,7 +1,7 @@
 #ifndef ATTRIBUTE_EXTRACTION_HELPERS_H
 #define ATTRIBUTE_EXTRACTION_HELPERS_H
 
-#include "../../util/hb_allocator.h"
+#include "../../lib/hb_allocator.h"
 #include "tag_helper_handler.h"
 #include "tag_helpers.h"
 
@@ -23,6 +23,8 @@ hb_array_T* extract_html_attributes_from_keyword_hash(
   hb_allocator_T* allocator
 );
 
+void resolve_nonce_attribute(hb_array_T* attributes, hb_allocator_T* allocator);
+
 bool has_html_attributes_in_call(pm_call_node_t* call_node);
 
 hb_array_T* extract_html_attributes_from_call_node(

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

@@ -1,9 +1,9 @@
 #ifndef TAG_HELPER_HANDLER_H
 #define TAG_HELPER_HANDLER_H
 
-#include "../../util/hb_allocator.h"
-#include "../../util/hb_array.h"
-#include "../../util/hb_string.h"
+#include "../../lib/hb_allocator.h"
+#include "../../lib/hb_array.h"
+#include "../../lib/hb_string.h"
 #include <prism.h>
 #include <stdbool.h>
 

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

@@ -1,13 +1,28 @@
 #ifndef HERB_ANALYZE_TAG_HELPER_NODE_BUILDERS_H
 #define HERB_ANALYZE_TAG_HELPER_NODE_BUILDERS_H
 
-#include "../../ast_nodes.h"
-#include "../../position.h"
-#include "../../token_struct.h"
-#include "../../util/hb_allocator.h"
-#include "../../util/hb_array.h"
+#include "../../ast/ast_nodes.h"
+#include "../../lexer/token_struct.h"
+#include "../../lib/hb_allocator.h"
+#include "../../lib/hb_array.h"
+#include "../../location/position.h"
 
 #include <prism.h>
+#include <stdbool.h>
+
+typedef struct {
+  position_T name_start;
+  position_T name_end;
+  const char* separator_string;
+  token_type_T separator_type;
+  position_T separator_start;
+  position_T separator_end;
+  position_T value_start;
+  position_T value_end;
+  position_T content_start;
+  position_T content_end;
+  bool quoted;
+} attribute_positions_T;
 
 token_T* create_synthetic_token(
   hb_allocator_T* allocator,
@@ -48,6 +63,20 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_interpolated_value(
   hb_allocator_T* allocator
 );
 
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node_precise(
+  const char* name_string,
+  const char* value_string,
+  attribute_positions_T* positions,
+  hb_allocator_T* allocator
+);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal_precise(
+  const char* name_string,
+  const char* ruby_content,
+  attribute_positions_T* positions,
+  hb_allocator_T* allocator
+);
+
 hb_array_T* prepend_attribute(hb_array_T* attributes, AST_NODE_T* attribute, hb_allocator_T* allocator);
 
 AST_HTML_ATTRIBUTE_NODE_T* create_href_attribute(

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

@@ -1,9 +1,9 @@
 #ifndef HERB_ANALYZE_TAG_HELPERS_H
 #define HERB_ANALYZE_TAG_HELPERS_H
 
-#include "../../ast_nodes.h"
-#include "../../position.h"
-#include "../../util/hb_array.h"
+#include "../../ast/ast_nodes.h"
+#include "../../lib/hb_array.h"
+#include "../../location/position.h"
 #include "../analyze.h"
 #include "tag_helper_handler.h"
 
@@ -17,6 +17,7 @@ typedef struct {
   tag_helper_info_T* info;
   const tag_helper_handler_T* matched_handler;
   bool found;
+  const pm_node_t* postfix_conditional_node;
 } tag_helper_search_data_T;
 
 bool search_tag_helper_node(const pm_node_t* node, void* data);

data/src/include/analyze/analyze.h

@@ -1,10 +1,10 @@
 #ifndef HERB_ANALYZE_H
 #define HERB_ANALYZE_H
 
-#include "../ast_nodes.h"
-#include "../parser.h"
-#include "../util/hb_allocator.h"
-#include "../util/hb_array.h"
+#include "../ast/ast_nodes.h"
+#include "../lib/hb_allocator.h"
+#include "../lib/hb_array.h"
+#include "../parser/parser.h"
 #include "analyzed_ruby.h"
 
 typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
@@ -13,6 +13,7 @@ typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
   hb_array_T* ruby_context_stack;
   hb_allocator_T* allocator;
   const char* source;
+  bool found_strict_locals;
 } analyze_ruby_context_T;
 
 typedef enum {
@@ -43,7 +44,12 @@ typedef struct {
   hb_allocator_T* allocator;
 } invalid_erb_context_T;
 
-void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source, hb_allocator_T* allocator);
+void herb_analyze_parse_errors(
+  AST_DOCUMENT_NODE_T* document,
+  const char* source,
+  const parser_options_T* options,
+  hb_allocator_T* allocator
+);
 void herb_analyze_parse_tree(
   AST_DOCUMENT_NODE_T* document,
   const char* source,
@@ -51,6 +57,7 @@ void herb_analyze_parse_tree(
   hb_allocator_T* allocator
 );
 
+hb_array_T* get_node_children_array(const AST_NODE_T* node);
 hb_array_T* rewrite_node_array(AST_NODE_T* node, hb_array_T* array, analyze_ruby_context_T* context);
 bool transform_erb_nodes(const AST_NODE_T* node, void* data);