herb 0.7.2-arm-linux-gnu → 0.7.4-arm-linux-gnu

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

@@ -0,0 +1,17 @@
+#ifndef HERB_EXTENSION_NODES_H
+#define HERB_EXTENSION_NODES_H
+
+#include <node_api.h>
+
+extern "C" {
+#include "../extension/libherb/include/herb.h"
+}
+
+napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);
+napi_value NodesArrayFromCArray(napi_env env, array_T* array);
+
+<%- nodes.each do |node| -%>
+napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>);
+<%- end -%>
+
+#endif

data/templates/lib/herb/ast/nodes.rb.erb

@@ -0,0 +1,117 @@
+module Herb
+  module AST
+    <%- nodes.each do |node| -%>
+    class <%= node.name -%> < Node
+      <%- node.fields.each do |field| -%>
+      attr_reader :<%= field.name %> #: <%= field.ruby_type %>
+      <%- end -%>
+
+      #: (<%= ["String", "Location", "Array[Herb::Errors::Error]", *node.fields.map(&:ruby_type)].join(", ") %>) -> void
+      def initialize(<%= ["type", "location", "errors", *node.fields.map(&:name)].join(", ") %>)
+        super(type, location, errors)
+        <%- node.fields.each do |field| -%>
+        <%- if field.is_a?(Herb::Template::StringField) -%>
+        @<%= field.name %> = <%= field.name %>.force_encoding("utf-8")
+        <%- else -%>
+        @<%= field.name %> = <%= field.name %>
+        <%- end -%>
+        <%- end -%>
+      end
+
+      #: () -> serialized_<%= node.human %>
+      def to_hash
+        super.merge({
+          <%- node.fields.each do |field| -%>
+          <%= field.name %>: <%= field.name %>,
+          <%- end -%>
+        }) #: Herb::serialized_<%= node.human %>
+      end
+
+      #: (Visitor) -> void
+      def accept(visitor)
+        visitor.visit_<%= node.human %>(self)
+      end
+
+      #: () -> Array[Herb::AST::Node?]
+      def child_nodes
+        [<%= node.fields.map { |field|
+          if field.is_a?(Herb::Template::NodeField)
+            field.name
+          elsif field.is_a?(Herb::Template::ArrayField) && field.specific_kind.end_with?("Node")
+            "*#{field.name}"
+          else
+            nil
+          end
+        }.compact.join(", ") %>]
+      end
+
+      #: () -> Array[Herb::AST::Node]
+      def compact_child_nodes
+        child_nodes.compact
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: (?Integer) -> String
+      def tree_inspect(indent = 0)
+        output = +""
+
+        output += "@ #{node_name} "
+        output += location.tree_inspect
+        output += "\n"
+
+        output += inspect_errors(prefix: "<%= node.fields.any? ? "│   " : "    " %>")
+
+        <%- node.fields.each do |field| -%>
+        <%- symbol = node.fields.last == field ? "└──" : "├──" -%>
+        <%- name = "#{symbol} #{field.name}: " -%>
+        <%- case field -%>
+        <%- when Herb::Template::StringField -%>
+        output += %(<%= name %>#{<%= field.name %>.inspect}\n)
+        <%- when Herb::Template::TokenField -%>
+        output += "<%= name %>"
+        output += <%= field.name %> ? <%= field.name %>.tree_inspect : "∅"
+        output += "\n"
+        <%- when Herb::Template::BooleanField -%>
+        output += "<%= name %>"
+        output += [true, false].include?(<%= field.name %>) ? <%= field.name %>.to_s : "∅"
+        output += "\n"
+        <%- when Herb::Template::ElementSourceField -%>
+        output += %(<%= name %>#{<%= field.name %>.inspect}\n)
+        <%- when Herb::Template::PrismNodeField -%>
+        # no-op for <%= field.name %>
+        <%- when Herb::Template::AnalyzedRubyField -%>
+        # no-op for <%= field.name %>
+        <%- when Herb::Template::NodeField -%>
+        output += "<%= name %>"
+        if <%= field.name %>
+          <%- prefix = (node.fields.last == field) ? "    " : "│   " -%>
+          output += "\n"
+          <%- if (node.fields.last == field) -%>
+          output += "    └── "
+          <%- else -%>
+          output += "│   └── "
+          <%- end -%>
+          output += <%= field.name %>.tree_inspect(indent).gsub(/^/, "    " * (indent + 1)).lstrip.gsub(/^/, "<%= prefix %>").delete_prefix("<%= prefix %>")
+        else
+          output += "∅\n"
+        end
+        <%- when Herb::Template::ArrayField -%>
+        output += "<%= name %>"
+        output += inspect_array(<%= field.name %>, prefix: "<%= (node.fields.last == field) ? "    " : "│   " %>")
+        <%- else -%>
+        <%- raise "Unhandled type: #{field.class}" -%>
+        <%- end -%>
+        <%- end -%>
+        output += "\n"
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    <%- end -%>
+  end
+end

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

@@ -0,0 +1,106 @@
+<%- base_arguments = [["type", "String"], ["location", "Location"], ["message", "String"]] -%>
+module Herb
+  module Errors
+    class Error
+      <%- base_arguments.each do |argument, type| -%>
+      attr_reader :<%= argument %> #: <%= type %>
+      <%- end -%>
+
+      #: (<%= base_arguments.map { |_argument, type| type }.join(", ") %>) -> void
+      def initialize(<%= base_arguments.map(&:first).join(", ") %>)
+        <%- base_arguments.each do |argument, _type| -%>
+        @<%= argument %> = <%= argument %>
+        <%- end -%>
+      end
+
+      #: () -> serialized_error
+      def to_hash
+        {
+          type: type,
+          location: location&.to_hash,
+          message: message,
+        }
+      end
+
+      #: () -> String
+      def class_name
+        self.class.name || "Error"
+      end
+
+      #: () -> String
+      def error_name
+        class_name.split("::").last || "Error"
+      end
+
+      #: (?untyped) -> String
+      def to_json(state = nil)
+        to_hash.to_json(state)
+      end
+
+      #: (?Integer) -> String
+      def tree_inspect(_indent = 0)
+        raise NotImplementedError
+      end
+    end
+
+    <%- errors.each do |error| -%>
+    class <%= error.name -%> < Error
+      <%- error.fields.each do |field| -%>
+      attr_reader :<%= field.name %> #: <%= field.ruby_type %>
+      <%- end -%>
+
+      #: (<%= [*base_arguments.map(&:last), *error.fields.map(&:ruby_type)].join(", ") %>) -> void
+      def initialize(<%= [*base_arguments.map(&:first), *error.fields.map(&:name)].join(", ") %>)
+        super(<%= base_arguments.map(&:first).join(", ") %>)
+
+        <%- error.fields.each do |field| -%>
+        @<%= field.name %> = <%= field.name %>
+        <%- end -%>
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_<%= error.human %>
+      def to_hash
+        super.merge({
+          <%- error.fields.each do |field| -%>
+          <%= field.name %>: <%= field.name %>,
+          <%- end -%>
+        }) #: Herb::serialized_<%= error.human %>
+      end
+
+      #: (?Integer) -> String
+      def tree_inspect(indent = 0)
+        output = +""
+
+        output += %(@ #{error_name} #{location.tree_inspect}\n)
+        <%- symbol = error.fields.none? ? "└──" : "├──" -%>
+        output += %(<%= symbol %> message: #{message.inspect}\n)
+        <%- error.fields.each do |field| -%>
+        <%- symbol = error.fields.last == field ? "└──" : "├──" -%>
+        <%- name = "#{symbol} #{field.name}: " -%>
+        <%- case field -%>
+        <%- when Herb::Template::PositionField -%>
+        output += %(<%= name %>#{<%= field.name %> ? <%= field.name %>.tree_inspect : "∅"}\n)
+        <%- when Herb::Template::TokenField -%>
+        output += %(<%= name %>#{<%= field.name %> ? <%= field.name %>.tree_inspect : "∅"}\n)
+        <%- when Herb::Template::TokenTypeField -%>
+        output += %(<%= name %>#{<%= field.name %>.inspect}\n)
+        <%- when Herb::Template::StringField -%>
+        output += %(<%= name %>#{<%= field.name %>.inspect}\n)
+        <%- else -%>
+        output += "<%= name %>'#{<%= field.name %>.class}'\n"
+        <%- end -%>
+        <%- end -%>
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    <%- end -%>
+  end
+end

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

@@ -0,0 +1,28 @@
+module Herb
+  class Visitor
+    include AST::Helpers
+
+    #: (Herb::AST::Node) -> void
+    def visit(node)
+      node&.accept(self)
+    end
+
+    #: (Array[Herb::AST::Node]) -> void
+    def visit_all(nodes)
+      nodes.each { |node| node&.accept(self) }
+    end
+
+    #: (Herb::AST::Node) -> void
+    def visit_child_nodes(node)
+      node.compact_child_nodes.each { |node| node.accept(self) }
+    end
+
+    <%- nodes.each do |node| -%>
+    #: (Herb::AST::<%= node.name %>) -> void
+    def visit_<%= node.human %>(node)
+      visit_child_nodes(node)
+    end
+
+    <%- end -%>
+  end
+end

data/templates/sig/serialized_ast_errors.rbs.erb

@@ -0,0 +1,10 @@
+module Herb
+  <%- errors.each do |error| -%>
+  type serialized_<%= error.human %> = serialized_error & {
+    <%- error.fields.each do |field| -%>
+    <%= field.name %>: <%= field.ruby_type %>,
+    <%- end -%>
+  }
+
+  <%- end -%>
+end

data/templates/sig/serialized_ast_nodes.rbs.erb

@@ -0,0 +1,10 @@
+module Herb
+  <%- nodes.each do |node| -%>
+  type serialized_<%= node.human %> = serialized_node & {
+    <%- node.fields.each do |field| -%>
+    <%= field.name %>: <%= field.ruby_type %>,
+    <%- end -%>
+  }
+
+  <%- end -%>
+end

data/templates/src/ast_nodes.c.erb

@@ -0,0 +1,145 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+#include <prism.h>
+
+#include "include/analyzed_ruby.h"
+#include "include/array.h"
+#include "include/ast_node.h"
+#include "include/ast_nodes.h"
+#include "include/errors.h"
+#include "include/token.h"
+#include "include/util.h"
+
+<%- nodes.each do |node| -%>
+<%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
+<%- arguments = node_arguments + ["position_T* start_position", "position_T* end_position", "array_T* errors"] -%>
+
+<%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>) {
+  <%= node.struct_type %>* <%= node.human %> = malloc(sizeof(<%= node.struct_type %>));
+
+  ast_node_init(&<%= node.human %>->base, <%= node.type %>, start_position, end_position, errors);
+
+  <%- node.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::TokenField -%>
+  <%= node.human %>-><%= field.name %> = token_copy(<%= field.name %>);
+  <%- when Herb::Template::NodeField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::ArrayField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::BooleanField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::ElementSourceField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::PrismNodeField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::StringField -%>
+  <%= node.human %>-><%= field.name %> = herb_strdup(<%= field.name %>);
+  <%- when Herb::Template::AnalyzedRubyField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::VoidPointerField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- else -%>
+  <%= field.inspect %>
+  <%- end -%>
+  <%- end -%>
+
+  return <%= node.human %>;
+}
+<%- end -%>
+
+const char* ast_node_type_to_string(AST_NODE_T* node) {
+  switch (node->type) {
+    <%- nodes.each do |node| -%>
+    case <%= node.type %>: return "<%= node.type %>";
+    <%- end -%>
+  }
+
+  return "Unknown ast_node_type_T";
+}
+
+const char* ast_node_human_type(AST_NODE_T* node) {
+  switch (node->type) {
+    <%- nodes.each do |node| -%>
+    case <%= node.type %>: return "<%= node.name %>";
+    <%- end -%>
+  }
+
+  return "Unknown ast_node_type_T";
+}
+
+void ast_free_base_node(AST_NODE_T* node) {
+  if (node == NULL) { return; }
+
+  if (node->errors) {
+    for (size_t i = 0; i < array_size(node->errors); i++) {
+      ERROR_T* child = array_get(node->errors, i);
+      if (child != NULL) { error_free(child); }
+    }
+
+    array_free(&node->errors);
+  }
+
+  if (node->location) { location_free(node->location); }
+
+  free(node);
+}
+
+<%- nodes.each do |node| -%>
+<%- arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join }.join(", ") : "void" -%>
+
+static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %>) {
+  <%- if node.fields.none? -%>
+  /* no <%= node.struct_type %> specific fields to free up */
+  <%- end -%>
+  <%- node.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::TokenField -%>
+  if (<%= node.human %>-><%= field.name %> != NULL) { token_free(<%= node.human %>-><%= field.name %>); }
+  <%- when Herb::Template::NodeField -%>
+  ast_node_free((AST_NODE_T*) <%= node.human %>-><%= field.name %>);
+  <%- when Herb::Template::ArrayField -%>
+  if (<%= node.human %>-><%= field.name %> != NULL) {
+    for (size_t i = 0; i < array_size(<%= node.human %>-><%= field.name %>); i++) {
+      AST_NODE_T* child = array_get(<%= node.human %>-><%= field.name %>, i);
+      if (child) { ast_node_free(child); }
+    }
+
+    array_free(&<%= node.human %>-><%= field.name %>);
+  }
+  <%- when Herb::Template::StringField -%>
+  if (<%= node.human %>-><%= field.name %> != NULL) { free((char*) <%= node.human %>-><%= field.name %>); }
+  <%- when Herb::Template::PrismNodeField -%>
+  if (<%= node.human %>-><%= field.name %> != NULL) {
+    // The first argument to `pm_node_destroy` is a `pm_parser_t`, but it's currently unused:
+    // See: https://github.com/ruby/ruby/blob/efb2d4363709b36a205791787f6812259027c6e1/prism/templates/src/node.c.erb#L100-L104
+    //
+    pm_node_destroy(NULL, <%= node.human %>-><%= field.name %>);
+  }
+  <%- when Herb::Template::AnalyzedRubyField -%>
+  if (<%= node.human %>-><%= field.name %> != NULL) {
+    free_analyzed_ruby(<%= node.human %>-><%= field.name %>);
+  }
+  <%- when Herb::Template::VoidPointerField -%>
+  free(<%= node.human %>-><%= field.name %>);
+  <%- when Herb::Template::BooleanField -%>
+  <%- when Herb::Template::ElementSourceField -%>
+  <%- else -%>
+  <%= field.inspect %>
+  <%- end -%>
+  <%- end -%>
+
+  ast_free_base_node(&<%= node.human %>->base);
+}
+<%- end -%>
+
+void ast_node_free(AST_NODE_T* node) {
+  if (!node) { return; }
+
+  switch (node->type) {
+    <%- nodes.each do |node| -%>
+    case <%= node.type %>: ast_free_<%= node.human %>((<%= node.struct_type %>*) node); break;
+    <%- end -%>
+  }
+}

data/templates/src/ast_pretty_print.c.erb

@@ -0,0 +1,97 @@
+#include "include/ast_node.h"
+#include "include/ast_nodes.h"
+#include "include/buffer.h"
+#include "include/errors.h"
+#include "include/pretty_print.h"
+#include "include/token_struct.h"
+#include "include/util.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+  if (!node) { return; }
+
+  bool print_location = true;
+
+  buffer_append(buffer, "@ ");
+  buffer_append(buffer, ast_node_human_type(node));
+  buffer_append(buffer, " ");
+
+  if (print_location) { pretty_print_location(node->location, buffer); }
+
+  buffer_append(buffer, "\n");
+
+  switch (node->type) {
+    <%- nodes.each do |node| -%>
+    case <%= node.type %>: {
+      const <%= node.struct_type %>* <%= node.human %> = (<%= node.struct_type %>*) node;
+
+      pretty_print_errors(node, indent, relative_indent, <%= node.fields.none? %>, buffer);
+      <%- node.fields.each_with_index do |field, index| -%>
+      <%- last = index == node.fields.length - 1 -%>
+      <%- case field -%>
+      <%- when Herb::Template::TokenField -%>
+      pretty_print_token_property(<%= node.human %>-><%= field.name %>, "<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+      <%- when Herb::Template::ArrayField -%>
+      pretty_print_array("<%= field.name %>", <%= node.human %>-><%= field.name %>, indent, relative_indent, <%= last %>, buffer);
+      <%- when Herb::Template::BooleanField -%>
+      pretty_print_boolean_property("<%= field.name %>", <%= node.human %>-><%= field.name %>, indent, relative_indent, <%= last %>, buffer);
+      <%- when Herb::Template::ElementSourceField -%>
+      pretty_print_string_property(element_source_to_string(<%= node.human %>-><%= field.name %>), "<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+      <%- when Herb::Template::StringField -%>
+      pretty_print_string_property(<%= node.human %>-><%= field.name %>, "<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+      <%- when Herb::Template::PrismNodeField -%>
+      pretty_print_string_property("<%= field.name %>", "<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+      <%- when Herb::Template::NodeField -%>
+
+      pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+
+      if (<%= node.human %>-><%= field.name %>) {
+        buffer_append(buffer, "\n");
+        pretty_print_indent(buffer, indent);
+        pretty_print_indent(buffer, relative_indent + 1);
+
+        buffer_append(buffer, "└── ");
+        ast_pretty_print_node((AST_NODE_T*) <%= node.human %>-><%= field.name %>, indent, relative_indent + 2, buffer);
+      } else {
+        buffer_append(buffer, " ∅\n");
+      }
+      buffer_append(buffer, "\n");
+
+      <%- when Herb::Template::AnalyzedRubyField -%>
+      if (<%= node.human %>-><%= field.name %>) {
+        pretty_print_boolean_property("if_node", <%= node.human %>-><%= field.name %>->has_if_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("elsif_node", <%= node.human %>-><%= field.name %>->has_elsif_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("else_node", <%= node.human %>-><%= field.name %>->has_else_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("end", <%= node.human %>-><%= field.name %>->has_end, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("block_node", <%= node.human %>-><%= field.name %>->has_block_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("block_closing", <%= node.human %>-><%= field.name %>->has_block_closing, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("case_node", <%= node.human %>-><%= field.name %>->has_case_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("when_node", <%= node.human %>-><%= field.name %>->has_when_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("for_node", <%= node.human %>-><%= field.name %>->has_for_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("while_node", <%= node.human %>-><%= field.name %>->has_while_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("until_node", <%= node.human %>-><%= field.name %>->has_until_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("begin_node", <%= node.human %>-><%= field.name %>->has_begin_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("rescue_node", <%= node.human %>-><%= field.name %>->has_rescue_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property("ensure_node", <%= node.human %>-><%= field.name %>->has_ensure_node, indent, relative_indent,  <%= last %>, buffer);
+        pretty_print_boolean_property("unless_node", <%= node.human %>-><%= field.name %>->has_unless_node, indent, relative_indent,  <%= last %>, buffer);
+      } else {
+      pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+        buffer_append(buffer, " ∅\n");
+      }
+
+      <%- when Herb::Template::VoidPointerField -%>
+      pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+      buffer_append(buffer, " ?\n");
+
+      <%- else -%>
+      <%= field.inspect %>
+      <%- end -%>
+      <%- end -%>
+    } break;
+
+    <%- end -%>
+  }
+}