herb 0.7.4-aarch64-linux-gnu → 0.8.0-aarch64-linux-gnu

data/templates/src/errors.c.erb

@@ -1,10 +1,10 @@
-#include "include/array.h"
 #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_array.h"
 
 #include <stdio.h>
 #include <stdbool.h>
@@ -17,15 +17,16 @@ size_t error_sizeof(void) {
   return sizeof(struct ERROR_STRUCT);
 }
 
-void error_init(ERROR_T* error, const error_type_T type, position_T* start, position_T* end) {
+void error_init(ERROR_T* error, const error_type_T type, position_T start, position_T end) {
   if (!error) { return; }
 
   error->type = type;
-  error->location = location_init(position_copy(start), position_copy(end));
+  error->location.start = start;
+  error->location.end = end;
 }
 <%- errors.each do |error| -%>
 <%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = error_arguments + ["position_T* start", "position_T* end"] -%>
+<%- arguments = error_arguments + ["position_T start", "position_T end"] -%>
 
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>) {
   <%= error.struct_type %>* <%= error.human %> = malloc(sizeof(<%= error.struct_type %>));
@@ -72,7 +73,7 @@ void error_init(ERROR_T* error, const error_type_T type, position_T* start, posi
   <%- error.fields.each do |field| -%>
   <%- case field -%>
   <%- when Herb::Template::PositionField -%>
-  <%= error.human %>-><%= field.name %> = position_copy(<%= field.name %>);
+  <%= error.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::TokenField -%>
   <%= error.human %>-><%= field.name %> = token_copy(<%= field.name %>);
   <%- when Herb::Template::TokenTypeField -%>
@@ -88,8 +89,8 @@ void error_init(ERROR_T* error, const error_type_T type, position_T* start, posi
   return <%= error.human %>;
 }
 
-void append_<%= error.human %>(<%= (arguments + ["array_T* errors"]).join(", ") %>) {
-  array_append(errors, <%= error.human %>_init(<%= arguments.map { |argument| argument.split(" ").last.strip }.join(", ") %>));
+void append_<%= error.human %>(<%= (arguments + ["hb_array_T* errors"]).join(", ") %>) {
+  hb_array_append(errors, <%= error.human %>_init(<%= arguments.map { |argument| argument.split(" ").last.strip }.join(", ") %>));
 }
 <%- end -%>
 
@@ -116,7 +117,6 @@ const char* error_human_type(ERROR_T* error) {
 void error_free_base_error(ERROR_T* error) {
   if (error == NULL) { return; }
 
-  if (error->location != NULL) { location_free(error->location); }
   if (error->message != NULL) { free(error->message); }
 
   free(error);
@@ -130,8 +130,6 @@ static void error_free_<%= error.human %>(<%= error.struct_type %>* <%= error.hu
   <%- end -%>
   <%- error.fields.each do |field| -%>
   <%- case field -%>
-  <%- when Herb::Template::PositionField -%>
-  if (<%= error.human %>-><%= field.name %> != NULL) { position_free(<%= error.human %>-><%= field.name %>); }
   <%- when Herb::Template::TokenField -%>
   if (<%= error.human %>-><%= field.name %> != NULL) { token_free(<%= error.human %>-><%= field.name %>); }
   <%- when Herb::Template::TokenTypeField -%>
@@ -160,73 +158,73 @@ void error_free(ERROR_T* error) {
 }
 
 void error_pretty_print_array(
-  const char* name, array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
-  buffer_T* buffer
+  const char* name, hb_array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
+  hb_buffer_T* buffer
 ) {
   if (array == NULL) {
-    pretty_print_property(name, "∅", indent, relative_indent, last_property, buffer);
+    pretty_print_property(hb_string(name), hb_string("∅"), indent, relative_indent, last_property, buffer);
 
     return;
   }
 
-  if (array_size(array) == 0) {
-    pretty_print_property(name, "[]", indent, relative_indent, last_property, buffer);
+  if (hb_array_size(array) == 0) {
+    pretty_print_property(hb_string(name), hb_string("[]"), indent, relative_indent, last_property, buffer);
 
     return;
   }
 
-  pretty_print_label(name, indent, relative_indent, last_property, buffer);
+  pretty_print_label(hb_string(name), indent, relative_indent, last_property, buffer);
 
-  buffer_append(buffer, "(");
+  hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", array_size(array));
-  buffer_append(buffer, count);
-  buffer_append(buffer, ")\n");
+  sprintf(count, "%zu", hb_array_size(array));
+  hb_buffer_append(buffer, count);
+  hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* child = array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == array_size(array) - 1) {
-        buffer_append(buffer, "└── ");
+      if (i == hb_array_size(array) - 1) {
+        hb_buffer_append(buffer, "└── ");
       } else {
-        buffer_append(buffer, "├── ");
+        hb_buffer_append(buffer, "├── ");
       }
 
       error_pretty_print(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
 }
 
 <%- errors.each do |error| -%>
-static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, <%= error.fields.none? %>, buffer);
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, <%= error.fields.none? %>, buffer);
   <%- error.fields.each_with_index do |field, index| -%>
   <%- case field -%>
   <%- when Herb::Template::PositionField -%>
-  pretty_print_position_property(error-><%= field.name %>, "<%= field.name %>", indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  pretty_print_position_property(hb_string(error-><%= field.name %>), hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
   <%- when Herb::Template::TokenField -%>
-  pretty_print_token_property(error-><%= field.name %>, "<%= field.name %>", indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  pretty_print_token_property(error-><%= field.name %>, hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
   <%- when Herb::Template::TokenTypeField -%>
-  pretty_print_property(token_type_to_string(error-><%= field.name %>), "<%= field.name %>", indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  pretty_print_property(hb_string(token_type_to_string(error-><%= field.name %>)), hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
   <%- when Herb::Template::SizeTField -%>
-  pretty_print_size_t_property(error-><%= field.name %>, "<%= field.name %>", indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  pretty_print_size_t_property(hb_string(error-><%= field.name %>), hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
   <%- when Herb::Template::StringField -%>
-  pretty_print_quoted_property("<%= field.name %>", error-><%= field.name %>, indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  pretty_print_quoted_property(hb_string("<%= field.name %>"), hb_string(error-><%= field.name %>), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
   <%- else -%>
   <%= field.inspect %>
   <%- end -%>
@@ -234,7 +232,7 @@ static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* erro
 }
 
 <%- end -%>
-void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   switch (error->type) {

data/templates/src/include/ast_nodes.h.erb

@@ -4,13 +4,14 @@
 #include <stdbool.h>
 #include <prism.h>
 
-#include "array.h"
-#include "buffer.h"
-#include "position.h"
-#include "location.h"
-#include "token_struct.h"
 #include "analyzed_ruby.h"
 #include "element_source.h"
+#include "location.h"
+#include "position.h"
+#include "token_struct.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
+#include "util/hb_string.h"
 
 typedef enum {
 <%- nodes.each do |node| -%>
@@ -20,9 +21,9 @@ typedef enum {
 
 typedef struct AST_NODE_STRUCT {
   ast_node_type_T type;
-  location_T* location;
+  location_T location;
   // maybe a range too?
-  array_T* errors;
+  hb_array_T* errors;
 } AST_NODE_T;
 
 <%- nodes.each do |node| -%>
@@ -36,11 +37,11 @@ typedef struct <%= node.struct_name %> {
 
 <%- 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"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "hb_array_T* errors"] -%>
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>);
 <%- end -%>
 
-const char* ast_node_type_to_string(AST_NODE_T* node);
-const char* ast_node_human_type(AST_NODE_T* node);
+hb_string_T ast_node_type_to_string(AST_NODE_T* node);
+hb_string_T ast_node_human_type(AST_NODE_T* node);
 
 #endif

data/templates/src/include/ast_pretty_print.h.erb

@@ -2,13 +2,13 @@
 #define HERB_AST_PRETTY_PRINT_H
 
 #include "ast_nodes.h"
-#include "buffer.h"
+#include "util/hb_buffer.h"
 
 void ast_pretty_print_node(
   AST_NODE_T* node,
   size_t indent,
   size_t relative_indent,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 #endif

data/templates/src/include/errors.h.erb

@@ -1,12 +1,12 @@
 #ifndef HERB_ERRORS_H
 #define HERB_ERRORS_H
 
-#include "array.h"
-#include "buffer.h"
 #include "errors.h"
 #include "location.h"
 #include "position.h"
 #include "token.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
 <%- errors.each do |error| -%>
@@ -16,7 +16,7 @@ typedef enum {
 
 typedef struct ERROR_STRUCT {
   error_type_T type;
-  location_T* location;
+  location_T location;
   char* message;
 } ERROR_T;
 
@@ -31,12 +31,12 @@ typedef struct {
 
 <%- errors.each do |error| -%>
 <%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = error_arguments + ["position_T* start", "position_T* end"] -%>
+<%- arguments = error_arguments + ["position_T start", "position_T end"] -%>
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>);
-void append_<%= error.human %>(<%= (arguments << "array_T* errors").join(", ") %>);
+void append_<%= error.human %>(<%= (arguments << "hb_array_T* errors").join(", ") %>);
 <%- end -%>
 
-void error_init(ERROR_T* error, error_type_T type, position_T* start, position_T* end);
+void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 
 size_t error_sizeof(void);
 error_type_T error_type(ERROR_T* error);
@@ -48,11 +48,11 @@ const char* error_human_type(ERROR_T* error);
 
 void error_free(ERROR_T* error);
 
-void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, buffer_T* buffer);
+void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, hb_buffer_T* buffer);
 
 void error_pretty_print_array(
-  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property,
-  buffer_T* buffer
+  const char* name, hb_array_T* array, size_t indent, size_t relative_indent, bool last_property,
+  hb_buffer_T* buffer
 );
 
 #endif

data/templates/src/parser_match_tags.c.erb

@@ -0,0 +1,38 @@
+#include "include/parser.h"
+#include "include/ast_nodes.h"
+#include "include/util/hb_array.h"
+#include "include/visitor.h"
+
+bool match_tags_visitor(const AST_NODE_T* node, void* data) {
+  hb_array_T* errors = (hb_array_T*) data;
+
+  if (node == NULL) { return false; }
+
+  switch (node->type) {
+    <%- nodes.each do |node| -%>
+    <%- array_fields = node.fields.select { |f| f.is_a?(Herb::Template::ArrayField) && f.name != "errors" } -%>
+    <%- single_node_fields = node.fields.select { |f| f.is_a?(Herb::Template::NodeField) } -%>
+
+    <%- if array_fields.any? || single_node_fields.any? -%>
+    case <%= node.type %>: {
+      const <%= node.struct_type %>* <%= node.human %> = (const <%= node.struct_type %>*) node;
+
+      <%- array_fields.each do |field| -%>
+      if (<%= node.human %>-><%= field.name %> != NULL) {
+        match_tags_in_node_array(<%= node.human %>-><%= field.name %>, errors);
+      }
+      <%- end -%>
+      <%- single_node_fields.each do |field| -%>
+      if (<%= node.human %>-><%= field.name %> != NULL) {
+        herb_visit_node((AST_NODE_T*) <%= node.human %>-><%= field.name %>, match_tags_visitor, errors);
+      }
+      <%- end -%>
+    } break;
+
+    <%- end -%>
+    <%- end -%>
+    default: break;
+  }
+
+  return false;
+}

data/templates/src/visitor.c.erb

@@ -1,9 +1,9 @@
 #include <stdio.h>
 
-#include "include/array.h"
-#include "include/visitor.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
+#include "include/util/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) {
   if (visitor(node, data) && node != NULL) {
@@ -31,8 +31,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
       <%- when Herb::Template::ArrayField -%>
       if (<%= node.human %>-><%= field.name %> != NULL) {
-        for (size_t index = 0; index < array_size(<%= node.human %>-><%= field.name %>); index++) {
-          herb_visit_node(array_get(<%= node.human %>-><%= field.name %>, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(<%= node.human %>-><%= field.name %>); index++) {
+          herb_visit_node(hb_array_get(<%= node.human %>-><%= field.name %>, index), visitor, data);
         }
       }
 

data/templates/template.rb

@@ -30,7 +30,7 @@ module Herb
       end
 
       def c_type
-        "array_T*"
+        "hb_array_T*"
       end
 
       def c_item_type
@@ -245,6 +245,10 @@ module Herb
           type.new(name: field_name, kind: kind)
         end
       end
+
+      def c_type
+        @struct_type
+      end
     end
 
     class NodeType
@@ -268,6 +272,10 @@ module Herb
           type.new(name: field_name, kind: kind)
         end
       end
+
+      def c_type
+        @struct_type
+      end
     end
 
     class PrintfMessageTemplate
@@ -331,6 +339,8 @@ module Herb
     end
 
     def self.render(template_file)
+      template_file_display = template_file.delete_prefix("#{File.expand_path("../", __dir__)}/")
+
       name = Pathname.new(template_file)
       name = if name.absolute?
                template_file.gsub(
@@ -351,8 +361,6 @@ module Herb
                       )
                     end
 
-      puts "Rendering #{template_file.delete_prefix("#{File.expand_path("../", __dir__)}/")} → #{destination}"
-
       template_file = Pathname.new(template_file)
       template_path = if template_file.absolute?
                         template_file
@@ -367,6 +375,17 @@ module Herb
 
       check_gitignore(name)
 
+      if File.exist?(destination)
+        existing_content = File.read(destination, encoding: Encoding::UTF_8)
+
+        if existing_content == content
+          puts "[unchanged] #{destination}"
+          return
+        end
+      end
+
+      puts "Rendering #{template_file_display} → #{destination}"
+
       FileUtils.mkdir_p(File.dirname(destination))
       File.write(destination, content)
     rescue SyntaxError => e

data/templates/wasm/error_helpers.cpp.erb

@@ -8,12 +8,12 @@
 #include "extension_helpers.h"
 
 extern "C" {
-#include "../src/include/herb.h"
-#include "../src/include/token.h"
-#include "../src/include/array.h"
-#include "../src/include/errors.h"
 #include "../src/include/ast_node.h"
 #include "../src/include/ast_nodes.h"
+#include "../src/include/errors.h"
+#include "../src/include/herb.h"
+#include "../src/include/token.h"
+#include "../src/include/util/hb_array.h"
 }
 
 using namespace emscripten;
@@ -21,9 +21,9 @@ using namespace emscripten;
 val CreateLocation(location_T* location);
 val CreateToken(token_T* token);
 val NodeFromCStruct(AST_NODE_T* node);
-val NodesArrayFromCArray(array_T* array);
+val NodesArrayFromCArray(hb_array_T* array);
 val ErrorFromCStruct(ERROR_T* error);
-val ErrorsArrayFromCArray(array_T* array);
+val ErrorsArrayFromCArray(hb_array_T* array);
 
 <%- errors.each do |error| -%>
 val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>) {
@@ -61,13 +61,13 @@ val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>) {
 
 <%- end -%>
 
-val ErrorsArrayFromCArray(array_T* array) {
+val ErrorsArrayFromCArray(hb_array_T* array) {
   val Array = val::global("Array");
   val result = Array.new_();
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* error = (ERROR_T*)array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* error = (ERROR_T*)hb_array_get(array, i);
       if (error) {
         result.call<void>("push", ErrorFromCStruct(error));
       }

data/templates/wasm/error_helpers.h.erb

@@ -6,7 +6,7 @@ extern "C" {
 }
 
 emscripten::val ErrorFromCStruct(ERROR_T* error);
-emscripten::val ErrorsArrayFromCArray(array_T* array);
+emscripten::val ErrorsArrayFromCArray(hb_array_T* array);
 
 <%- errors.each do |error| -%>
 emscripten::val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>);

data/templates/wasm/nodes.cpp.erb

@@ -4,24 +4,24 @@
 #include "error_helpers.h"
 #include "extension_helpers.h"
 
-#include "../src/include/herb.h"
-#include "../src/include/token.h"
-#include "../src/include/array.h"
 #include "../src/include/ast_node.h"
 #include "../src/include/ast_nodes.h"
+#include "../src/include/herb.h"
 #include "../src/include/location.h"
+#include "../src/include/token.h"
+#include "../src/include/util/hb_array.h"
 
 using namespace emscripten;
 
 val NodeFromCStruct(AST_NODE_T* node);
-val NodesArrayFromCArray(array_T* array);
+val NodesArrayFromCArray(hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 val <%= node.name %>FromCStruct(<%= node.struct_type %>* <%= node.human %>) {
   if (!<%= node.human %>) return val::null();
 
   val result = val::object();
-  result.set("type", CreateString(ast_node_type_to_string(&<%= node.human %>->base)));
+  result.set("type", CreateStringFromHbString(ast_node_type_to_string(&<%= node.human %>->base)));
   result.set("location", CreateLocation(<%= node.human %>->base.location));
   result.set("errors", ErrorsArrayFromCArray(<%= node.human %>->base.errors));
 
@@ -38,7 +38,7 @@ val <%= node.name %>FromCStruct(<%= node.struct_type %>* <%= node.human %>) {
   <%- when Herb::Template::ArrayField -%>
   result.set("<%= field.name %>", NodesArrayFromCArray(<%= node.human %>-><%= field.name %>));
   <%- when Herb::Template::ElementSourceField -%>
-  result.set("<%= field.name %>", CreateString(element_source_to_string(<%= node.human %>-><%= field.name %>)));
+  result.set("<%= field.name %>", CreateStringFromHbString(element_source_to_string(<%= node.human %>-><%= field.name %>)));
   <%- else -%>
   result.set("<%= field.name %>", val::null());
   <%- end -%>
@@ -62,13 +62,13 @@ val NodeFromCStruct(AST_NODE_T* node) {
   }
 }
 
-val NodesArrayFromCArray(array_T* array) {
+val NodesArrayFromCArray(hb_array_T* array) {
   if (!array) return val::null();
 
   val jsArray = val::array();
 
-  for (size_t i = 0; i < array_size(array); i++) {
-    AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+  for (size_t i = 0; i < hb_array_size(array); i++) {
+    AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
     if (child_node) {
       jsArray.set(i, NodeFromCStruct(child_node));

data/templates/wasm/nodes.h.erb

@@ -6,7 +6,7 @@ extern "C" {
 }
 
 emscripten::val NodeFromCStruct(AST_NODE_T* node);
-emscripten::val NodesArrayFromCArray(array_T* array);
+emscripten::val NodesArrayFromCArray(hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 emscripten::val <%= node.human %>NodeFromCStruct(<%= node.struct_type %>* <%= node.human %>);

data/vendor/prism/Rakefile

@@ -11,7 +11,10 @@ desc "Generate all ERB template based files"
 task templates: Prism::Template::TEMPLATES
 
 make = RUBY_PLATFORM.match?(/openbsd|freebsd/) ? "gmake" : "make"
-task(make: :templates) { sh(make) }
+task(make: :templates) {
+  ENV["MAKEFLAGS"] ||= "-j"
+  sh(make)
+}
 task(make_no_debug: :templates) { sh("#{make} all-no-debug") }
 task(make_minimal: :templates) { sh("#{make} minimal") }
 

data/vendor/prism/config.yml

@@ -60,6 +60,7 @@ errors:
   - CONDITIONAL_WHILE_PREDICATE
   - CONSTANT_PATH_COLON_COLON_CONSTANT
   - DEF_ENDLESS
+  - DEF_ENDLESS_PARAMETERS
   - DEF_ENDLESS_SETTER
   - DEF_NAME
   - DEF_PARAMS_TERM
@@ -1800,7 +1801,7 @@ nodes:
           Represents the predicate of the case statement. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
 
               case true; when false; end
-              ^^^^
+                   ^^^^
       - name: conditions
         type: node[]
         kind: WhenNode