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

data/src/parser.c

@@ -1,18 +1,19 @@
-#include "include/parser.h"
-#include "include/ast_node.h"
-#include "include/ast_nodes.h"
+#include "include/parser/parser.h"
+#include "include/ast/ast_node.h"
+#include "include/ast/ast_nodes.h"
 #include "include/errors.h"
-#include "include/html_util.h"
-#include "include/lexer.h"
-#include "include/lexer_peek_helpers.h"
-#include "include/parser_helpers.h"
-#include "include/token.h"
-#include "include/token_matchers.h"
-#include "include/util.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/lexer/lexer.h"
+#include "include/lexer/lexer_peek_helpers.h"
+#include "include/lexer/token.h"
+#include "include/lexer/token_matchers.h"
+#include "include/lib/hb_array.h"
+#include "include/lib/hb_buffer.h"
+#include "include/lib/hb_string.h"
+#include "include/lib/string.h"
+#include "include/parser/dot_notation.h"
+#include "include/parser/parser_helpers.h"
+#include "include/util/html_util.h"
+#include "include/util/util.h"
 #include "include/visitor.h"
 
 #include <stdio.h>
@@ -38,9 +39,14 @@ const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { .track_whitespace = false
                                                        .strict = true,
                                                        .action_view_helpers = false,
                                                        .render_nodes = false,
+                                                       .strict_locals = false,
                                                        .prism_nodes_deep = false,
                                                        .prism_nodes = false,
-                                                       .prism_program = false };
+                                                       .prism_program = false,
+                                                       .dot_notation_tags = false,
+                                                       .html = true,
+                                                       .start_line = 0,
+                                                       .start_column = 0 };
 
 size_t parser_sizeof(void) {
   return sizeof(struct PARSER_STRUCT);
@@ -473,7 +479,9 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 
       if (equals_token && equals_token->type == TOKEN_EQUALS) {
         token_T* after_equals = lexer_next_token(parser->lexer);
-        looks_like_new_attribute = (after_equals && after_equals->type == TOKEN_QUOTE);
+        looks_like_new_attribute =
+          (after_equals && after_equals->type == TOKEN_QUOTE && opening_quote != NULL
+           && hb_string_equals(after_equals->value, opening_quote->value));
 
         if (after_equals) { token_free(after_equals, parser->allocator); }
       }
@@ -767,7 +775,7 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
       equals_with_whitespace->type = TOKEN_EQUALS;
 
       char* arena_copy = hb_allocator_strndup(parser->allocator, equals_buffer.value, equals_buffer.length);
-      equals_with_whitespace->value = (hb_string_T) { .data = arena_copy, .length = (uint32_t) equals_buffer.length };
+      equals_with_whitespace->value = hb_string_from_data(arena_copy, equals_buffer.length);
 
       hb_buffer_free(&equals_buffer);
 
@@ -884,7 +892,7 @@ static void parser_skip_erb_content(lexer_T* lexer) {
   do {
     token = lexer_next_token(lexer);
 
-    if (token->type == TOKEN_ERB_END) {
+    if (token->type == TOKEN_ERB_END || token->type == TOKEN_EOF) {
       token_free(token, lexer->allocator);
       break;
     }
@@ -899,6 +907,11 @@ static bool parser_lookahead_erb_is_attribute(lexer_T* lexer) {
   do {
     after = lexer_next_token(lexer);
 
+    if (after->type == TOKEN_EOF) {
+      token_free(after, lexer->allocator);
+      return false;
+    }
+
     if (after->type == TOKEN_EQUALS) {
       token_free(after, lexer->allocator);
       return true;
@@ -929,14 +942,30 @@ static bool parser_lookahead_erb_is_attribute(lexer_T* lexer) {
 
 static bool starts_with_keyword(hb_string_T string, const char* keyword) {
   hb_string_T prefix = hb_string(keyword);
+
   if (string.length < prefix.length) { return false; }
   if (strncmp(string.data, prefix.data, prefix.length) != 0) { return false; }
-
   if (string.length == prefix.length) { return true; }
 
   return is_whitespace(string.data[prefix.length]);
 }
 
+static AST_HTML_TEXT_NODE_T* parser_advance_as_text(parser_T* parser) {
+  token_T* token = parser_advance(parser);
+
+  AST_HTML_TEXT_NODE_T* text = ast_html_text_node_init(
+    token->value,
+    token->location.start,
+    token->location.end,
+    hb_array_init(0, parser->allocator),
+    parser->allocator
+  );
+
+  token_free(token, parser->allocator);
+
+  return text;
+}
+
 // TODO: ideally we could avoid basing this off of strings, and use the step in analyze.c
 static bool parser_lookahead_erb_is_control_flow(parser_T* parser) {
   lexer_T lexer_copy = *parser->lexer;
@@ -1005,6 +1034,8 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
   token_T* tag_start = parser_consume_expected(parser, TOKEN_HTML_TAG_START, errors);
   token_T* tag_name = parser_consume_expected(parser, TOKEN_IDENTIFIER, errors);
 
+  parser_consume_dot_notation_segments(parser, tag_name, errors);
+
   while (token_is_none_of(parser, TOKEN_HTML_TAG_END, TOKEN_HTML_TAG_SELF_CLOSE, TOKEN_EOF)) {
     if (token_is_any_of(parser, TOKEN_HTML_TAG_START, TOKEN_HTML_TAG_START_CLOSE)) {
       append_unclosed_open_tag_error(
@@ -1182,6 +1213,8 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
 
   token_T* tag_name = parser_consume_expected(parser, TOKEN_IDENTIFIER, errors);
 
+  parser_consume_dot_notation_segments(parser, tag_name, errors);
+
   parser_consume_whitespace(parser, children);
 
   token_T* tag_closing = parser_consume_if_present(parser, TOKEN_HTML_TAG_END);
@@ -1246,7 +1279,7 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_self_closing_element(
     NULL,
     NULL,
     true,
-    ELEMENT_SOURCE_HTML,
+    hb_string("HTML"),
     open_tag->base.location.start,
     open_tag->base.location.end,
     NULL,
@@ -1318,7 +1351,7 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
     body,
     (AST_NODE_T*) close_tag,
     false,
-    ELEMENT_SOURCE_HTML,
+    hb_string("HTML"),
     open_tag->base.location.start,
     close_tag->base.location.end,
     errors,
@@ -1408,13 +1441,7 @@ static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children,
   hb_buffer_init(&content, 1024, parser->allocator);
   position_T start = parser->current_token->location.start;
   hb_string_T expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
-
-  if (hb_string_is_empty(expected_closing_tag)) {
-    parser_exit_foreign_content(parser);
-    hb_buffer_free(&content);
-
-    return;
-  }
+  bool has_closing_tag = !hb_string_is_empty(expected_closing_tag);
 
   while (!token_is(parser, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
@@ -1428,7 +1455,7 @@ static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children,
       continue;
     }
 
-    if (token_is(parser, TOKEN_HTML_TAG_START_CLOSE)) {
+    if (has_closing_tag && token_is(parser, TOKEN_HTML_TAG_START_CLOSE)) {
       lexer_state_snapshot_T saved_state = lexer_save_state(parser->lexer);
 
       token_T* next_token = lexer_next_token(parser->lexer);
@@ -1463,6 +1490,11 @@ static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children,
 }
 
 static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, hb_array_T* errors) {
+  if (!parser->options.html) {
+    parser_parse_foreign_content(parser, children, errors);
+    return;
+  }
+
   while (token_is_not(parser, TOKEN_EOF)) {
 
     if (token_is(parser, TOKEN_ERB_START)) {
@@ -1496,7 +1528,11 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
     }
 
     if (token_is(parser, TOKEN_HTML_TAG_START)) {
-      hb_array_append(children, parser_parse_html_element(parser));
+      if (parser_lookahead_is_valid_dot_notation_open_tag(parser)) {
+        hb_array_append(children, parser_parse_html_element(parser));
+      } else {
+        hb_array_append(children, parser_advance_as_text(parser));
+      }
       parser->consecutive_error_count = 0;
       continue;
     }
@@ -1683,7 +1719,7 @@ static hb_array_T* parser_build_elements_from_tags(
             processed_body,
             (AST_NODE_T*) omitted_close_tag,
             false,
-            ELEMENT_SOURCE_HTML,
+            hb_string("HTML"),
             open_tag->base.location.start,
             end_position,
             element_errors,
@@ -1726,7 +1762,7 @@ static hb_array_T* parser_build_elements_from_tags(
           processed_body,
           (AST_NODE_T*) close_tag,
           false,
-          ELEMENT_SOURCE_HTML,
+          hb_string("HTML"),
           open_tag->base.location.start,
           close_tag->base.location.end,
           element_errors,

data/src/{prism_helpers.c → prism/prism_helpers.c}

@@ -1,10 +1,10 @@
-#include "include/prism_helpers.h"
-#include "include/ast_nodes.h"
-#include "include/errors.h"
-#include "include/location.h"
-#include "include/position.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/hb_string.h"
+#include "../include/prism/prism_helpers.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/errors.h"
+#include "../include/lib/hb_buffer.h"
+#include "../include/lib/hb_string.h"
+#include "../include/location/location.h"
+#include "../include/location/position.h"
 
 #include <prism.h>
 #include <stdlib.h>

data/src/{ruby_parser.c → prism/ruby_parser.c}

@@ -1,4 +1,4 @@
-#include "include/ruby_parser.h"
+#include "../include/prism/ruby_parser.h"
 
 #include <prism.h>
 #include <stdbool.h>

data/src/{html_util.c → util/html_util.c}

@@ -1,7 +1,7 @@
-#include "include/html_util.h"
-#include "include/util/hb_allocator.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/hb_string.h"
+#include "../include/util/html_util.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_buffer.h"
+#include "../include/lib/hb_string.h"
 
 #include <ctype.h>
 #include <stdbool.h>
@@ -27,6 +27,46 @@ static hb_string_T void_tags[] = HB_STRING_LIST(
   "wbr"
 );
 
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes
+static hb_string_T boolean_attributes[] = HB_STRING_LIST(
+  "allowfullscreen",
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "compact",
+  "controls",
+  "declare",
+  "default",
+  "defer",
+  "disabled",
+  "formnovalidate",
+  "hidden",
+  "inert",
+  "ismap",
+  "itemscope",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "nohref",
+  "noresize",
+  "noshade",
+  "novalidate",
+  "nowrap",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "scoped",
+  "seamless",
+  "selected",
+  "sortable",
+  "truespeed",
+  "typemustmatch"
+);
+
 // https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
 static hb_string_T optional_end_tags[] = HB_STRING_LIST(
   "li",
@@ -112,6 +152,16 @@ bool is_void_element(hb_string_T tag_name) {
   return false;
 }
 
+bool is_boolean_attribute(hb_string_T attribute_name) {
+  if (hb_string_is_empty(attribute_name)) { return false; }
+
+  for (size_t i = 0; i < sizeof(boolean_attributes) / sizeof(boolean_attributes[0]); i++) {
+    if (hb_string_equals_case_insensitive(attribute_name, boolean_attributes[i])) { return true; }
+  }
+
+  return false;
+}
+
 bool has_optional_end_tag(hb_string_T tag_name) {
   if (hb_string_is_empty(tag_name)) { return false; }
 

data/src/{io.c → util/io.c}

@@ -1,6 +1,6 @@
-#include "include/io.h"
-#include "include/util/hb_allocator.h"
-#include "include/util/hb_buffer.h"
+#include "../include/util/io.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_buffer.h"
 
 #include <errno.h>
 #include <stdio.h>

data/src/util/ruby_util.c

@@ -0,0 +1,42 @@
+#include "../include/util/ruby_util.h"
+#include "../include/lib/hb_string.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+static hb_string_T ruby_introspection_methods[] = HB_STRING_LIST(
+  "send",
+  "public_send",
+  "__send__",
+  "try",
+  "try!",
+  "method",
+  "class",
+  "inspect",
+  "to_s",
+  "object_id",
+  "__id__",
+  "dup",
+  "clone",
+  "freeze",
+  "frozen",
+  "tap",
+  "then",
+  "yield_self"
+);
+
+bool is_ruby_introspection_method(hb_string_T method_name) {
+  size_t count = sizeof(ruby_introspection_methods) / sizeof(ruby_introspection_methods[0]);
+
+  for (size_t index = 0; index < count; index++) {
+    if (hb_string_equals(method_name, ruby_introspection_methods[index])) { return true; }
+  }
+
+  if (method_name.length > 0) {
+    char last_char = method_name.data[method_name.length - 1];
+
+    if (last_char == '?' || last_char == '!') { return true; }
+  }
+
+  return false;
+}

data/src/{utf8.c → util/utf8.c}

@@ -1,5 +1,5 @@
-#include "include/utf8.h"
-#include "include/util/hb_string.h"
+#include "../include/util/utf8.h"
+#include "../include/lib/hb_string.h"
 #include <stdint.h>
 
 // UTF-8 byte patterns:

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

@@ -1,7 +1,7 @@
-#include "include/util.h"
-#include "include/util/hb_allocator.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/hb_string.h"
+#include "../include/util/util.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_buffer.h"
+#include "../include/lib/hb_string.h"
 
 #include <stdio.h>
 #include <stdlib.h>

data/src/visitor.c

@@ -3,9 +3,9 @@
 
 #include <stdio.h>
 
-#include "include/ast_node.h"
-#include "include/ast_nodes.h"
-#include "include/util/hb_array.h"
+#include "include/ast/ast_node.h"
+#include "include/ast/ast_nodes.h"
+#include "include/lib/hb_array.h"
 #include "include/visitor.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data) {
@@ -237,6 +237,18 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
         }
       }
 
+      if (erb_block_node->rescue_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_block_node->rescue_clause, visitor, data);
+      }
+
+      if (erb_block_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_block_node->else_clause, visitor, data);
+      }
+
+      if (erb_block_node->ensure_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_block_node->ensure_clause, visitor, data);
+      }
+
       if (erb_block_node->end_node != NULL) {
         herb_visit_node((AST_NODE_T *) erb_block_node->end_node, visitor, data);
       }
@@ -441,6 +453,26 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    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, visitor, data);
+      }
+
+    } 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) {
+        for (size_t index = 0; index < hb_array_size(erb_strict_locals_node->locals); index++) {
+          herb_visit_node(hb_array_get(erb_strict_locals_node->locals, index), visitor, data);
+        }
+      }
+
+    } break;
+
     case AST_ERB_IN_NODE: {
       const AST_ERB_IN_NODE_T* erb_in_node = ((const AST_ERB_IN_NODE_T *) node);
 

data/templates/ext/herb/error_helpers.c.erb

@@ -6,8 +6,8 @@
 
 #include "../../src/include/errors.h"
 #include "../../src/include/herb.h"
-#include "../../src/include/token.h"
-#include "../../src/include/util/hb_string.h"
+#include "../../src/include/lexer/token.h"
+#include "../../src/include/lib/hb_string.h"
 
 VALUE rb_error_from_c_struct(ERROR_T* error);
 

data/templates/ext/herb/nodes.c.erb

@@ -7,7 +7,7 @@
 #include "nodes.h"
 
 #include "../../src/include/herb.h"
-#include "../../src/include/token.h"
+#include "../../src/include/lexer/token.h"
 
 VALUE rb_node_from_c_struct(AST_NODE_T* node);
 static VALUE rb_nodes_array_from_c_array(hb_array_T* array);

data/templates/java/error_helpers.c.erb

@@ -1,7 +1,7 @@
 #include "error_helpers.h"
 #include "extension_helpers.h"
 
-#include "../../src/include/ast_node.h"
+#include "../../src/include/ast/ast_node.h"
 #include "../../src/include/errors.h"
 
 #include <stdlib.h>

data/templates/java/error_helpers.h.erb

@@ -3,8 +3,8 @@
 
 #include <jni.h>
 
-#include "../../src/include/ast_node.h"
-#include "../../src/include/util/hb_array.h"
+#include "../../src/include/ast/ast_node.h"
+#include "../../src/include/lib/hb_array.h"
 
 #ifdef __cplusplus
 extern "C" {

data/templates/java/nodes.c.erb

@@ -2,10 +2,10 @@
 #include "extension_helpers.h"
 #include "error_helpers.h"
 
-#include "../../src/include/ast_node.h"
-#include "../../src/include/ast_nodes.h"
-#include "../../src/include/location.h"
-#include "../../src/include/util/hb_array.h"
+#include "../../src/include/ast/ast_node.h"
+#include "../../src/include/ast/ast_nodes.h"
+#include "../../src/include/location/location.h"
+#include "../../src/include/lib/hb_array.h"
 
 #include <stdlib.h>
 

data/templates/java/nodes.h.erb

@@ -3,7 +3,7 @@
 
 #include <jni.h>
 
-#include "../../src/include/ast_nodes.h"
+#include "../../src/include/ast/ast_nodes.h"
 
 #ifdef __cplusplus
 extern "C" {

data/templates/javascript/packages/node/extension/error_helpers.cpp.erb

@@ -4,12 +4,12 @@
 #include "nodes.h"
 
 extern "C" {
-#include "../extension/libherb/include/ast_node.h"
-#include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/ast/ast_node.h"
+#include "../extension/libherb/include/ast/ast_nodes.h"
 #include "../extension/libherb/include/errors.h"
 #include "../extension/libherb/include/herb.h"
-#include "../extension/libherb/include/token.h"
-#include "../extension/libherb/include/util/hb_array.h"
+#include "../extension/libherb/include/lexer/token.h"
+#include "../extension/libherb/include/lib/hb_array.h"
 }
 
 napi_value ErrorFromCStruct(napi_env env, ERROR_T* error);

data/templates/javascript/packages/node/extension/nodes.cpp.erb

@@ -4,11 +4,11 @@
 #include "nodes.h"
 
 extern "C" {
-#include "../extension/libherb/include/ast_node.h"
-#include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/ast/ast_node.h"
+#include "../extension/libherb/include/ast/ast_nodes.h"
 #include "../extension/libherb/include/herb.h"
-#include "../extension/libherb/include/token.h"
-#include "../extension/libherb/include/util/hb_array.h"
+#include "../extension/libherb/include/lexer/token.h"
+#include "../extension/libherb/include/lib/hb_array.h"
 }
 
 napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);

data/templates/lib/herb/visitor.rb.erb

@@ -17,9 +17,23 @@ module Herb
       node.compact_child_nodes.each { |node| node.accept(self) }
     end
 
+    #: (Herb::AST::Node) -> void
+    def visit_node(node)
+      # Default implementation does nothing
+    end
+
+    #: (Herb::AST::Node) -> void
+    def visit_erb_node(node)
+      # Default implementation does nothing
+    end
+
     <%- nodes.each do |node| -%>
     #: (Herb::AST::<%= node.name %>) -> void
     def visit_<%= node.human %>(node)
+      visit_node(node)
+      <%- if node.name.start_with?("ERB") -%>
+      visit_erb_node(node)
+      <%- end -%>
       visit_child_nodes(node)
     end
 

data/templates/src/analyze/missing_end.c.erb

@@ -1,7 +1,7 @@
 #include "../include/analyze/helpers.h"
 #include "../include/errors.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_string.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_string.h"
 
 <%-
   nodes_with_end_node = nodes.select do |node|

data/templates/src/{ast_nodes.c.erb → ast/ast_nodes.c.erb}

@@ -3,15 +3,15 @@
 
 #include <prism.h>
 
-#include "include/analyze/analyzed_ruby.h"
-#include "include/ast_node.h"
-#include "include/ast_nodes.h"
-#include "include/errors.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/analyze/analyzed_ruby.h"
+#include "../include/ast/ast_node.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/errors.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"
 
 <%- nodes.each do |node| -%>
 <%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>

data/templates/src/{ast_pretty_print.c.erb → ast/ast_pretty_print.c.erb}

@@ -2,14 +2,14 @@
   // Pretty print support excluded
 #else
 
-#include "include/analyze/helpers.h"
-#include "include/ast_node.h"
-#include "include/ast_nodes.h"
-#include "include/errors.h"
-#include "include/pretty_print.h"
-#include "include/token_struct.h"
-#include "include/util.h"
-#include "include/util/hb_buffer.h"
+#include "../include/analyze/helpers.h"
+#include "../include/ast/ast_node.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/errors.h"
+#include "../include/ast/pretty_print.h"
+#include "../include/lexer/token_struct.h"
+#include "../include/util/util.h"
+#include "../include/lib/hb_buffer.h"
 
 #include <stdio.h>
 #include <stdlib.h>