herb 0.9.1-arm-linux-gnu → 0.9.3-arm-linux-gnu

data/src/include/{utf8.h → util/utf8.h}

@@ -1,7 +1,7 @@
 #ifndef HERB_UTF8_H
 #define HERB_UTF8_H
 
-#include "util/hb_string.h"
+#include "../lib/hb_string.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>

data/src/include/{util.h → util/util.h}

@@ -1,7 +1,7 @@
 #ifndef HERB_UTIL_H
 #define HERB_UTIL_H
 
-#include "util/hb_string.h"
+#include "../lib/hb_string.h"
 #include <stdbool.h>
 #include <stdlib.h>
 

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.9.1"
+#define HERB_VERSION "0.9.3"
 
 #endif

data/src/include/visitor.h

@@ -1,9 +1,9 @@
 #ifndef HERB_VISITOR_H
 #define HERB_VISITOR_H
 
-#include "ast_node.h"
-#include "ast_nodes.h"
-#include "util/hb_array.h"
+#include "ast/ast_node.h"
+#include "ast/ast_nodes.h"
+#include "lib/hb_array.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data);
 void herb_visit_child_nodes(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T* node, void* data), void* data);

data/src/{lexer_peek_helpers.c → lexer/lexer_peek_helpers.c}

@@ -1,6 +1,6 @@
-#include "include/lexer_peek_helpers.h"
-#include "include/lexer.h"
-#include "include/token.h"
+#include "../include/lexer/lexer_peek_helpers.h"
+#include "../include/lexer/lexer.h"
+#include "../include/lexer/token.h"
 
 #include <ctype.h>
 

data/src/{token.c → lexer/token.c}

@@ -1,11 +1,11 @@
-#include "include/token.h"
-#include "include/position.h"
-#include "include/range.h"
-#include "include/token_struct.h"
-#include "include/util.h"
-#include "include/util/hb_allocator.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/hb_string.h"
+#include "../include/lexer/token.h"
+#include "../include/lexer/token_struct.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_buffer.h"
+#include "../include/lib/hb_string.h"
+#include "../include/location/position.h"
+#include "../include/location/range.h"
+#include "../include/util/util.h"
 
 #include <stdarg.h>
 #include <stdbool.h>

data/src/{token_matchers.c → lexer/token_matchers.c}

@@ -1,5 +1,5 @@
-#include "include/token_matchers.h"
-#include "include/parser.h"
+#include "../include/lexer/token_matchers.h"
+#include "../include/parser/parser.h"
 
 #include <stdarg.h>
 #include <stdbool.h>

data/src/lexer.c

@@ -1,9 +1,9 @@
-#include "include/lexer_peek_helpers.h"
+#include "include/lexer/lexer_peek_helpers.h"
+#include "include/lexer/token.h"
+#include "include/lib/hb_string.h"
 #include "include/macros.h"
-#include "include/token.h"
-#include "include/utf8.h"
-#include "include/util.h"
-#include "include/util/hb_string.h"
+#include "include/util/utf8.h"
+#include "include/util/util.h"
 
 #include <ctype.h>
 #include <stdint.h>
@@ -75,7 +75,7 @@ token_T* lexer_error(lexer_T* lexer, const char* message) {
   size_t length = strlen(buffer);
   char* error_message = hb_allocator_strndup(lexer->allocator, buffer, length);
 
-  return token_init((hb_string_T) { .data = error_message, .length = (uint32_t) length }, TOKEN_ERROR, lexer);
+  return token_init(hb_string_from_data(error_message, length), TOKEN_ERROR, lexer);
 }
 
 static void lexer_advance(lexer_T* lexer) {

data/src/{util → lib}/hb_allocator.c

@@ -1,5 +1,5 @@
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_arena.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_arena.h"
 
 #include <stdio.h>
 #include <stdlib.h>

data/src/{util → lib}/hb_arena.c

@@ -1,4 +1,4 @@
-#include "../include/util/hb_arena.h"
+#include "../include/lib/hb_arena.h"
 #include "../include/macros.h"
 
 #include <assert.h>
@@ -70,16 +70,12 @@ static bool hb_arena_append_page(hb_arena_T* allocator, size_t page_size) {
   page->position = 0;
 
   if (allocator->head == NULL) {
+    assert(allocator->tail == NULL);
+
     allocator->head = page;
     allocator->tail = page;
   } else {
-    hb_arena_page_T* last = allocator->head;
-
-    while (last->next != NULL) {
-      last = last->next;
-    }
-
-    last->next = page;
+    allocator->tail->next = page;
     allocator->tail = page;
   }
 

data/src/{util → lib}/hb_arena_debug.c

@@ -2,8 +2,8 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "../include/util/hb_arena.h"
-#include "../include/util/hb_arena_debug.h"
+#include "../include/lib/hb_arena.h"
+#include "../include/lib/hb_arena_debug.h"
 
 #define ANSI_COLOR_GREEN "\033[32m"
 #define ANSI_COLOR_YELLOW "\033[33m"

data/src/{util → lib}/hb_array.c

@@ -1,9 +1,9 @@
 #include <stdint.h>
 #include <stdio.h>
 
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_array.h"
 #include "../include/macros.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_array.h"
 
 size_t hb_array_sizeof(void) {
   return sizeof(hb_array_T);

data/src/{util → lib}/hb_buffer.c

@@ -2,9 +2,9 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_buffer.h"
 #include "../include/macros.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_buffer.h"
 
 static bool hb_buffer_has_capacity(hb_buffer_T* buffer, const size_t required_length) {
   return (buffer->length + required_length <= buffer->capacity);

data/src/{util → lib}/hb_narray.c

@@ -1,4 +1,4 @@
-#include "../include/util/hb_narray.h"
+#include "../include/lib/hb_narray.h"
 
 #include <assert.h>
 #include <stdbool.h>

data/src/{util → lib}/hb_string.c

@@ -1,6 +1,6 @@
-#include "../include/util/hb_string.h"
+#include "../include/lib/hb_string.h"
 #include "../include/macros.h"
-#include "../include/util.h"
+#include "../include/util/util.h"
 
 #include <stdlib.h>
 #include <string.h>

data/src/{location.c → location/location.c}

@@ -1,5 +1,5 @@
-#include "include/location.h"
-#include "include/position.h"
+#include "../include/location/location.h"
+#include "../include/location/position.h"
 
 void location_from(
   location_T* location,

data/src/{position.c → location/position.c}

@@ -1,5 +1,5 @@
-#include "include/position.h"
-#include "include/util.h"
+#include "../include/location/position.h"
+#include "../include/util/util.h"
 
 position_T position_from_source_with_offset(const char* source, size_t offset) {
   position_T position = { .line = 1, .column = 0 };

data/src/{range.c → location/range.c}

@@ -1,4 +1,4 @@
-#include "include/range.h"
+#include "../include/location/range.h"
 
 uint32_t range_length(range_T range) {
   return range.to - range.from;

data/src/main.c

@@ -1,23 +1,23 @@
 #define _POSIX_C_SOURCE 199309L // Enables `clock_gettime()`
 
-#include "include/ast_node.h"
-#include "include/ast_nodes.h"
+#include "include/ast/ast_node.h"
+#include "include/ast/ast_nodes.h"
 
 #ifndef HERB_EXCLUDE_PRETTYPRINT
-#  include "include/ast_pretty_print.h"
+#  include "include/ast/ast_pretty_print.h"
 #endif
 
 #include "include/extract.h"
 #include "include/herb.h"
-#include "include/io.h"
-#include "include/lex_helpers.h"
+#include "include/lexer/lex_helpers.h"
+#include "include/lib/hb_allocator.h"
+#include "include/lib/hb_arena.h"
+#include "include/lib/hb_arena_debug.h"
+#include "include/lib/hb_buffer.h"
+#include "include/lib/string.h"
 #include "include/macros.h"
-#include "include/ruby_parser.h"
-#include "include/util/hb_allocator.h"
-#include "include/util/hb_arena.h"
-#include "include/util/hb_arena_debug.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/string.h"
+#include "include/prism/ruby_parser.h"
+#include "include/util/io.h"
 
 #include <stdio.h>
 #include <stdlib.h>

data/src/parser/dot_notation.c

@@ -0,0 +1,100 @@
+#include "../include/parser/dot_notation.h"
+#include "../include/errors.h"
+#include "../include/lexer/lexer.h"
+#include "../include/lexer/token.h"
+#include "../include/parser/parser_helpers.h"
+
+#include <ctype.h>
+
+static bool token_is_dot(token_T* token) {
+  return token->type == TOKEN_CHARACTER && token->value.length == 1 && token->value.data[0] == '.';
+}
+
+static bool current_token_is_dot(parser_T* parser) {
+  return token_is_dot(parser->current_token);
+}
+
+static void consume_dot_notation_loop(parser_T* parser, token_T* tag_name, hb_array_T* errors) {
+  while (current_token_is_dot(parser)) {
+    token_T* dot = parser_advance(parser);
+    token_T* segment = parser_consume_expected(parser, TOKEN_IDENTIFIER, errors);
+
+    if (segment == NULL || segment->value.length == 0) {
+      if (segment) { token_free(segment, parser->allocator); }
+      token_free(dot, parser->allocator);
+      break;
+    }
+
+    uint32_t new_length = (uint32_t) (segment->value.data + segment->value.length - tag_name->value.data);
+    tag_name->value.length = new_length;
+    tag_name->location.end = segment->location.end;
+    tag_name->range.to = segment->range.to;
+
+    token_free(segment, parser->allocator);
+    token_free(dot, parser->allocator);
+  }
+}
+
+bool parser_lookahead_is_valid_dot_notation_open_tag(parser_T* parser) {
+  lexer_T lexer_copy = *parser->lexer;
+  token_T* name = lexer_next_token(&lexer_copy);
+
+  if (name == NULL || name->type != TOKEN_IDENTIFIER) {
+    if (name) { token_free(name, parser->allocator); }
+    return false;
+  }
+
+  bool first_is_upper = name->value.length > 0 && isupper((unsigned char) name->value.data[0]);
+  token_free(name, parser->allocator);
+  token_T* next = lexer_next_token(&lexer_copy);
+
+  if (next == NULL) { return true; }
+
+  bool is_dot = token_is_dot(next);
+  token_free(next, parser->allocator);
+
+  if (!is_dot) { return true; }
+  if (!parser->options.dot_notation_tags) { return true; }
+  if (!first_is_upper) { return true; }
+
+  next = lexer_next_token(&lexer_copy);
+
+  while (next != NULL) {
+    if (next->type != TOKEN_IDENTIFIER || next->value.length == 0) {
+      token_free(next, parser->allocator);
+      return true;
+    }
+
+    token_free(next, parser->allocator);
+    next = lexer_next_token(&lexer_copy);
+
+    if (next == NULL) { return true; }
+
+    is_dot = token_is_dot(next);
+    token_free(next, parser->allocator);
+
+    if (!is_dot) { return true; }
+
+    next = lexer_next_token(&lexer_copy);
+  }
+
+  return true;
+}
+
+void parser_consume_dot_notation_segments(parser_T* parser, token_T* tag_name, hb_array_T* errors) {
+  if (!parser->options.dot_notation_tags) { return; }
+  if (tag_name == NULL || tag_name->value.length == 0) { return; }
+  if (!current_token_is_dot(parser)) { return; }
+
+  if (!isupper((unsigned char) tag_name->value.data[0])) {
+    append_dot_notation_casing_error(
+      tag_name,
+      tag_name->location.start,
+      tag_name->location.end,
+      parser->allocator,
+      errors
+    );
+  }
+
+  consume_dot_notation_loop(parser, tag_name, errors);
+}

data/src/{parser_match_tags.c → parser/match_tags.c}

@@ -1,10 +1,10 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /home/runner/work/herb/herb/templates/src/parser_match_tags.c.erb
+// be modified manually. See /home/runner/work/herb/herb/templates/src/parser/match_tags.c.erb
 
-#include "include/parser.h"
-#include "include/ast_nodes.h"
-#include "include/util/hb_array.h"
-#include "include/visitor.h"
+#include "../include/parser/parser.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/lib/hb_array.h"
+#include "../include/visitor.h"
 
 bool match_tags_visitor(const AST_NODE_T* node, void* data) {
   match_tags_context_T* context = (match_tags_context_T*) data;
@@ -205,6 +205,15 @@ bool match_tags_visitor(const AST_NODE_T* node, void* data) {
       if (erb_block_node->body != NULL) {
         match_tags_in_node_array(erb_block_node->body, context->errors, context->options, context->allocator);
       }
+      if (erb_block_node->rescue_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_block_node->rescue_clause, match_tags_visitor, context);
+      }
+      if (erb_block_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_block_node->else_clause, match_tags_visitor, context);
+      }
+      if (erb_block_node->ensure_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_block_node->ensure_clause, match_tags_visitor, context);
+      }
       if (erb_block_node->end_node != NULL) {
         herb_visit_node((AST_NODE_T*) erb_block_node->end_node, match_tags_visitor, context);
       }
@@ -380,6 +389,26 @@ bool match_tags_visitor(const AST_NODE_T* node, void* data) {
 
 
 
+    case AST_RUBY_STRICT_LOCAL_NODE: {
+      const AST_RUBY_STRICT_LOCAL_NODE_T* ruby_strict_local_node = (const AST_RUBY_STRICT_LOCAL_NODE_T*) node;
+
+      if (ruby_strict_local_node->default_value != NULL) {
+        herb_visit_node((AST_NODE_T*) ruby_strict_local_node->default_value, match_tags_visitor, context);
+      }
+    } break;
+
+
+
+    case AST_ERB_STRICT_LOCALS_NODE: {
+      const AST_ERB_STRICT_LOCALS_NODE_T* erb_strict_locals_node = (const AST_ERB_STRICT_LOCALS_NODE_T*) node;
+
+      if (erb_strict_locals_node->locals != NULL) {
+        match_tags_in_node_array(erb_strict_locals_node->locals, context->errors, context->options, context->allocator);
+      }
+    } break;
+
+
+
 
 
     case AST_ERB_IN_NODE: {

data/src/{parser_helpers.c → parser/parser_helpers.c}

@@ -1,12 +1,12 @@
-#include "include/parser_helpers.h"
-#include "include/ast_nodes.h"
-#include "include/errors.h"
-#include "include/lexer.h"
-#include "include/parser.h"
-#include "include/token.h"
-#include "include/util/hb_array.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/hb_string.h"
+#include "../include/parser/parser_helpers.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/errors.h"
+#include "../include/lexer/lexer.h"
+#include "../include/lexer/token.h"
+#include "../include/lib/hb_array.h"
+#include "../include/lib/hb_buffer.h"
+#include "../include/lib/hb_string.h"
+#include "../include/parser/parser.h"
 
 #include <stdarg.h>
 #include <stdio.h>
@@ -219,7 +219,7 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
     body,
     NULL,
     false,
-    ELEMENT_SOURCE_HTML,
+    hb_string("HTML"),
     open_tag->base.location.start,
     open_tag->base.location.end,
     errors,