@herb-tools/node 0.7.4 → 0.8.0

package/extension/libherb/analyze.h

@@ -2,13 +2,13 @@
 #define HERB_ANALYZE_H
 
 #include "analyzed_ruby.h"
-#include "array.h"
 #include "ast_nodes.h"
+#include "util/hb_array.h"
 
 typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
   AST_DOCUMENT_NODE_T* document;
   AST_NODE_T* parent;
-  array_T* ruby_context_stack;
+  hb_array_T* ruby_context_stack;
 } analyze_ruby_context_T;
 
 typedef enum {
@@ -33,7 +33,15 @@ typedef enum {
   CONTROL_TYPE_UNKNOWN
 } control_type_t;
 
+typedef struct {
+  int loop_depth;
+  int rescue_depth;
+} invalid_erb_context_T;
+
 void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source);
 void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source);
 
+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);
+
 #endif

package/extension/libherb/analyze_helpers.c

@@ -238,6 +238,11 @@ bool search_else_nodes(analyzed_ruby_T* analyzed) {
 
 bool search_end_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'end', ignoring it")) {
+    if (has_error_message(analyzed, "unexpected '=', ignoring it")) {
+      // `=end`
+      return false;
+    }
+
     analyzed->has_end = true;
     return true;
   }

package/extension/libherb/analyze_helpers.h

@@ -5,6 +5,7 @@
 #include <stdbool.h>
 
 #include "analyzed_ruby.h"
+#include "ast_node.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed);
 bool has_elsif_node(analyzed_ruby_T* analyzed);
@@ -46,4 +47,6 @@ bool search_rescue_nodes(analyzed_ruby_T* analyzed);
 bool search_ensure_nodes(analyzed_ruby_T* analyzed);
 bool search_yield_nodes(const pm_node_t* node, void* data);
 
+void check_erb_node_for_missing_end(const AST_NODE_T* node);
+
 #endif

package/extension/libherb/analyze_missing_end.c

@@ -0,0 +1,147 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/src/analyze_missing_end.c.erb
+
+#include "include/analyze_helpers.h"
+#include "include/errors.h"
+
+
+void check_erb_node_for_missing_end(const AST_NODE_T* node) {
+  switch (node->type) {
+    case AST_ERB_IF_NODE: {
+      const AST_ERB_IF_NODE_T* erb_if_node = (const AST_ERB_IF_NODE_T*) node;
+
+      if (erb_if_node->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " if " "%" ">`",
+          erb_if_node->tag_opening->location.start,
+          erb_if_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    case AST_ERB_BLOCK_NODE: {
+      const AST_ERB_BLOCK_NODE_T* erb_block_node = (const AST_ERB_BLOCK_NODE_T*) node;
+
+      if (erb_block_node->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "ERB block",
+          erb_block_node->tag_opening->location.start,
+          erb_block_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    case AST_ERB_CASE_NODE: {
+      const AST_ERB_CASE_NODE_T* erb_case_node = (const AST_ERB_CASE_NODE_T*) node;
+
+      if (erb_case_node->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " case " "%" ">`",
+          erb_case_node->tag_opening->location.start,
+          erb_case_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    case AST_ERB_CASE_MATCH_NODE: {
+      const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (const AST_ERB_CASE_MATCH_NODE_T*) node;
+
+      if (erb_case_match_node->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " case " "%" ">`",
+          erb_case_match_node->tag_opening->location.start,
+          erb_case_match_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    case AST_ERB_WHILE_NODE: {
+      const AST_ERB_WHILE_NODE_T* erb_while_node = (const AST_ERB_WHILE_NODE_T*) node;
+
+      if (erb_while_node->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " while " "%" ">`",
+          erb_while_node->tag_opening->location.start,
+          erb_while_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    case AST_ERB_UNTIL_NODE: {
+      const AST_ERB_UNTIL_NODE_T* erb_until_node = (const AST_ERB_UNTIL_NODE_T*) node;
+
+      if (erb_until_node->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " until " "%" ">`",
+          erb_until_node->tag_opening->location.start,
+          erb_until_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    case AST_ERB_FOR_NODE: {
+      const AST_ERB_FOR_NODE_T* erb_for_node = (const AST_ERB_FOR_NODE_T*) node;
+
+      if (erb_for_node->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " for " "%" ">`",
+          erb_for_node->tag_opening->location.start,
+          erb_for_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    case AST_ERB_BEGIN_NODE: {
+      const AST_ERB_BEGIN_NODE_T* erb_begin_node = (const AST_ERB_BEGIN_NODE_T*) node;
+
+      if (erb_begin_node->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " begin " "%" ">`",
+          erb_begin_node->tag_opening->location.start,
+          erb_begin_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    case AST_ERB_UNLESS_NODE: {
+      const AST_ERB_UNLESS_NODE_T* erb_unless_node = (const AST_ERB_UNLESS_NODE_T*) node;
+
+      if (erb_unless_node->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " unless " "%" ">`",
+          erb_unless_node->tag_opening->location.start,
+          erb_unless_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    default: break;
+  }
+}

package/extension/libherb/analyze_transform.c

@@ -0,0 +1,196 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/src/analyze_transform.c.erb
+
+#include "include/analyze.h"
+#include "include/visitor.h"
+
+bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
+  analyze_ruby_context_T* context = (analyze_ruby_context_T*) data;
+  context->parent = (AST_NODE_T*) node;
+
+  if (node->type == AST_DOCUMENT_NODE) {
+    AST_DOCUMENT_NODE_T* document_node = (AST_DOCUMENT_NODE_T*) node;
+    hb_array_T* old_array = document_node->children;
+    document_node->children = rewrite_node_array((AST_NODE_T*) node, document_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_OPEN_TAG_NODE) {
+    AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = (AST_HTML_OPEN_TAG_NODE_T*) node;
+    hb_array_T* old_array = html_open_tag_node->children;
+    html_open_tag_node->children = rewrite_node_array((AST_NODE_T*) node, html_open_tag_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_CLOSE_TAG_NODE) {
+    AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = (AST_HTML_CLOSE_TAG_NODE_T*) node;
+    hb_array_T* old_array = html_close_tag_node->children;
+    html_close_tag_node->children = rewrite_node_array((AST_NODE_T*) node, html_close_tag_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_ELEMENT_NODE) {
+    AST_HTML_ELEMENT_NODE_T* html_element_node = (AST_HTML_ELEMENT_NODE_T*) node;
+    hb_array_T* old_array = html_element_node->body;
+    html_element_node->body = rewrite_node_array((AST_NODE_T*) node, html_element_node->body, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_ATTRIBUTE_VALUE_NODE) {
+    AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = (AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
+    hb_array_T* old_array = html_attribute_value_node->children;
+    html_attribute_value_node->children = rewrite_node_array((AST_NODE_T*) node, html_attribute_value_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_ATTRIBUTE_NAME_NODE) {
+    AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = (AST_HTML_ATTRIBUTE_NAME_NODE_T*) node;
+    hb_array_T* old_array = html_attribute_name_node->children;
+    html_attribute_name_node->children = rewrite_node_array((AST_NODE_T*) node, html_attribute_name_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_COMMENT_NODE) {
+    AST_HTML_COMMENT_NODE_T* html_comment_node = (AST_HTML_COMMENT_NODE_T*) node;
+    hb_array_T* old_array = html_comment_node->children;
+    html_comment_node->children = rewrite_node_array((AST_NODE_T*) node, html_comment_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_DOCTYPE_NODE) {
+    AST_HTML_DOCTYPE_NODE_T* html_doctype_node = (AST_HTML_DOCTYPE_NODE_T*) node;
+    hb_array_T* old_array = html_doctype_node->children;
+    html_doctype_node->children = rewrite_node_array((AST_NODE_T*) node, html_doctype_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_XML_DECLARATION_NODE) {
+    AST_XML_DECLARATION_NODE_T* xml_declaration_node = (AST_XML_DECLARATION_NODE_T*) node;
+    hb_array_T* old_array = xml_declaration_node->children;
+    xml_declaration_node->children = rewrite_node_array((AST_NODE_T*) node, xml_declaration_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_CDATA_NODE) {
+    AST_CDATA_NODE_T* cdata_node = (AST_CDATA_NODE_T*) node;
+    hb_array_T* old_array = cdata_node->children;
+    cdata_node->children = rewrite_node_array((AST_NODE_T*) node, cdata_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_ELSE_NODE) {
+    AST_ERB_ELSE_NODE_T* erb_else_node = (AST_ERB_ELSE_NODE_T*) node;
+    hb_array_T* old_array = erb_else_node->statements;
+    erb_else_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_else_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_IF_NODE) {
+    AST_ERB_IF_NODE_T* erb_if_node = (AST_ERB_IF_NODE_T*) node;
+    hb_array_T* old_array = erb_if_node->statements;
+    erb_if_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_if_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_BLOCK_NODE) {
+    AST_ERB_BLOCK_NODE_T* erb_block_node = (AST_ERB_BLOCK_NODE_T*) node;
+    hb_array_T* old_array = erb_block_node->body;
+    erb_block_node->body = rewrite_node_array((AST_NODE_T*) node, erb_block_node->body, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_WHEN_NODE) {
+    AST_ERB_WHEN_NODE_T* erb_when_node = (AST_ERB_WHEN_NODE_T*) node;
+    hb_array_T* old_array = erb_when_node->statements;
+    erb_when_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_when_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_CASE_NODE) {
+    AST_ERB_CASE_NODE_T* erb_case_node = (AST_ERB_CASE_NODE_T*) node;
+    hb_array_T* old_array = erb_case_node->children;
+    erb_case_node->children = rewrite_node_array((AST_NODE_T*) node, erb_case_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_CASE_NODE) {
+    AST_ERB_CASE_NODE_T* erb_case_node = (AST_ERB_CASE_NODE_T*) node;
+    hb_array_T* old_array = erb_case_node->conditions;
+    erb_case_node->conditions = rewrite_node_array((AST_NODE_T*) node, erb_case_node->conditions, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_CASE_MATCH_NODE) {
+    AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (AST_ERB_CASE_MATCH_NODE_T*) node;
+    hb_array_T* old_array = erb_case_match_node->children;
+    erb_case_match_node->children = rewrite_node_array((AST_NODE_T*) node, erb_case_match_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_CASE_MATCH_NODE) {
+    AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (AST_ERB_CASE_MATCH_NODE_T*) node;
+    hb_array_T* old_array = erb_case_match_node->conditions;
+    erb_case_match_node->conditions = rewrite_node_array((AST_NODE_T*) node, erb_case_match_node->conditions, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_WHILE_NODE) {
+    AST_ERB_WHILE_NODE_T* erb_while_node = (AST_ERB_WHILE_NODE_T*) node;
+    hb_array_T* old_array = erb_while_node->statements;
+    erb_while_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_while_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_UNTIL_NODE) {
+    AST_ERB_UNTIL_NODE_T* erb_until_node = (AST_ERB_UNTIL_NODE_T*) node;
+    hb_array_T* old_array = erb_until_node->statements;
+    erb_until_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_until_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_FOR_NODE) {
+    AST_ERB_FOR_NODE_T* erb_for_node = (AST_ERB_FOR_NODE_T*) node;
+    hb_array_T* old_array = erb_for_node->statements;
+    erb_for_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_for_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_RESCUE_NODE) {
+    AST_ERB_RESCUE_NODE_T* erb_rescue_node = (AST_ERB_RESCUE_NODE_T*) node;
+    hb_array_T* old_array = erb_rescue_node->statements;
+    erb_rescue_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_rescue_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_ENSURE_NODE) {
+    AST_ERB_ENSURE_NODE_T* erb_ensure_node = (AST_ERB_ENSURE_NODE_T*) node;
+    hb_array_T* old_array = erb_ensure_node->statements;
+    erb_ensure_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_ensure_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_BEGIN_NODE) {
+    AST_ERB_BEGIN_NODE_T* erb_begin_node = (AST_ERB_BEGIN_NODE_T*) node;
+    hb_array_T* old_array = erb_begin_node->statements;
+    erb_begin_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_begin_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_UNLESS_NODE) {
+    AST_ERB_UNLESS_NODE_T* erb_unless_node = (AST_ERB_UNLESS_NODE_T*) node;
+    hb_array_T* old_array = erb_unless_node->statements;
+    erb_unless_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_unless_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_IN_NODE) {
+    AST_ERB_IN_NODE_T* erb_in_node = (AST_ERB_IN_NODE_T*) node;
+    hb_array_T* old_array = erb_in_node->statements;
+    erb_in_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_in_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  herb_visit_child_nodes(node, transform_erb_nodes, data);
+
+  return false;
+}

package/extension/libherb/analyzed_ruby.c

@@ -1,12 +1,13 @@
 #include "include/analyzed_ruby.h"
+#include "include/util/hb_string.h"
 
 #include <prism.h>
 #include <string.h>
 
-analyzed_ruby_T* init_analyzed_ruby(char* source) {
+analyzed_ruby_T* init_analyzed_ruby(hb_string_T source) {
   analyzed_ruby_T* analyzed = malloc(sizeof(analyzed_ruby_T));
 
-  pm_parser_init(&analyzed->parser, (const uint8_t*) source, strlen(source), NULL);
+  pm_parser_init(&analyzed->parser, (const uint8_t*) source.data, source.length, NULL);
 
   analyzed->root = pm_parse(&analyzed->parser);
   analyzed->valid = (analyzed->parser.error_list.size == 0);
@@ -42,3 +43,23 @@ void free_analyzed_ruby(analyzed_ruby_T* analyzed) {
 
   free(analyzed);
 }
+
+const char* erb_keyword_from_analyzed_ruby(const analyzed_ruby_T* analyzed) {
+  if (analyzed->has_end) {
+    return "`<% end %>`";
+  } else if (analyzed->has_else_node) {
+    return "`<% else %>`";
+  } else if (analyzed->has_elsif_node) {
+    return "`<% elsif %>`";
+  } else if (analyzed->has_when_node) {
+    return "`<% when %>`";
+  } else if (analyzed->has_in_node) {
+    return "`<% in %>`";
+  } else if (analyzed->has_rescue_node) {
+    return "`<% rescue %>`";
+  } else if (analyzed->has_ensure_node) {
+    return "`<% ensure %>`";
+  }
+
+  return NULL;
+}

package/extension/libherb/analyzed_ruby.h

@@ -1,7 +1,8 @@
 #ifndef HERB_ANALYZED_RUBY_H
 #define HERB_ANALYZED_RUBY_H
 
-#include "array.h"
+#include "util/hb_array.h"
+#include "util/hb_string.h"
 
 #include <prism.h>
 
@@ -30,7 +31,8 @@ typedef struct ANALYZED_RUBY_STRUCT {
   bool has_yield_node;
 } analyzed_ruby_T;
 
-analyzed_ruby_T* init_analyzed_ruby(char* source);
+analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);
 void free_analyzed_ruby(analyzed_ruby_T* analyzed);
+const char* erb_keyword_from_analyzed_ruby(const analyzed_ruby_T* analyzed);
 
 #endif

package/extension/libherb/ast_node.c

@@ -12,14 +12,15 @@ size_t ast_node_sizeof(void) {
   return sizeof(struct AST_NODE_STRUCT);
 }
 
-void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T* start, position_T* end, array_T* errors) {
+void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T start, position_T end, hb_array_T* errors) {
   if (!node) { return; }
 
   node->type = type;
-  node->location = location_init(position_copy(start), position_copy(end));
+  node->location.start = start;
+  node->location.end = end;
 
   if (errors == NULL) {
-    node->errors = array_init(8);
+    node->errors = hb_array_init(8);
   } else {
     node->errors = errors;
   }
@@ -28,7 +29,7 @@ void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T* sta
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token) {
   AST_LITERAL_NODE_T* literal = malloc(sizeof(AST_LITERAL_NODE_T));
 
-  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location->start, token->location->end, NULL);
+  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location.start, token->location.end, NULL);
 
   literal->content = herb_strdup(token->value);
 
@@ -40,35 +41,31 @@ ast_node_type_T ast_node_type(const AST_NODE_T* node) {
 }
 
 size_t ast_node_errors_count(const AST_NODE_T* node) {
-  return array_size(node->errors);
+  return hb_array_size(node->errors);
 }
 
-array_T* ast_node_errors(const AST_NODE_T* node) {
+hb_array_T* ast_node_errors(const AST_NODE_T* node) {
   return node->errors;
 }
 
 void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error) {
-  array_append(node->errors, error);
+  hb_array_append(node->errors, error);
 }
 
-void ast_node_set_start(AST_NODE_T* node, position_T* position) {
-  if (node->location->start != NULL) { position_free(node->location->start); }
-
-  node->location->start = position_copy(position);
+void ast_node_set_start(AST_NODE_T* node, position_T position) {
+  node->location.start = position;
 }
 
-void ast_node_set_end(AST_NODE_T* node, position_T* position) {
-  if (node->location->end != NULL) { position_free(node->location->end); }
-
-  node->location->end = position_copy(position);
+void ast_node_set_end(AST_NODE_T* node, position_T position) {
+  node->location.end = position;
 }
 
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token) {
-  ast_node_set_start(node, token->location->start);
+  ast_node_set_start(node, token->location.start);
 }
 
 void ast_node_set_end_from_token(AST_NODE_T* node, const token_T* token) {
-  ast_node_set_end(node, token->location->end);
+  ast_node_set_end(node, token->location.end);
 }
 
 void ast_node_set_positions_from_token(AST_NODE_T* node, const token_T* token) {

package/extension/libherb/ast_node.h

@@ -6,7 +6,7 @@
 #include "position.h"
 #include "token_struct.h"
 
-void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T* start, position_T* end, array_T* errors);
+void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T start, position_T end, hb_array_T* errors);
 void ast_node_free(AST_NODE_T* node);
 
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token);
@@ -18,11 +18,11 @@ ast_node_type_T ast_node_type(const AST_NODE_T* node);
 
 char* ast_node_name(AST_NODE_T* node);
 
-void ast_node_set_start(AST_NODE_T* node, position_T* position);
-void ast_node_set_end(AST_NODE_T* node, position_T* position);
+void ast_node_set_start(AST_NODE_T* node, position_T position);
+void ast_node_set_end(AST_NODE_T* node, position_T position);
 
 size_t ast_node_errors_count(const AST_NODE_T* node);
-array_T* ast_node_errors(const AST_NODE_T* node);
+hb_array_T* ast_node_errors(const AST_NODE_T* node);
 void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error);
 
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token);