herb 0.9.4-aarch64-linux-gnu → 0.9.5-aarch64-linux-gnu

data/src/ast/ast_nodes.c

@@ -376,7 +376,7 @@ AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content,
   return erb_if_node;
 }
 
-AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, hb_array_T* body, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, hb_array_T* body, hb_array_T* block_arguments, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
   AST_ERB_BLOCK_NODE_T* erb_block_node = hb_allocator_alloc(allocator, sizeof(AST_ERB_BLOCK_NODE_T));
 
   if (!erb_block_node) { return NULL; }
@@ -388,6 +388,7 @@ AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* con
   erb_block_node->tag_closing = token_copy(tag_closing, allocator);
   erb_block_node->prism_node = prism_node;
   erb_block_node->body = body;
+  erb_block_node->block_arguments = block_arguments;
   erb_block_node->rescue_clause = rescue_clause;
   erb_block_node->else_clause = else_clause;
   erb_block_node->ensure_clause = ensure_clause;
@@ -584,7 +585,36 @@ AST_RUBY_RENDER_LOCAL_NODE_T* ast_ruby_render_local_node_init(token_T* name, str
   return ruby_render_local_node;
 }
 
-AST_ERB_RENDER_NODE_T* ast_erb_render_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, herb_prism_node_T prism_node, token_T* partial, token_T* template_path, token_T* layout, token_T* file, token_T* inline_template, token_T* body, token_T* plain, token_T* html, token_T* renderable, token_T* collection, token_T* object, token_T* as_name, token_T* spacer_template, token_T* formats, token_T* variants, token_T* handlers, token_T* content_type, hb_array_T* locals, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+AST_RUBY_RENDER_KEYWORDS_NODE_T* ast_ruby_render_keywords_node_init(token_T* partial, token_T* template_path, token_T* layout, token_T* file, token_T* inline_template, token_T* body, token_T* plain, token_T* html, token_T* renderable, token_T* collection, token_T* object, token_T* as_name, token_T* spacer_template, token_T* formats, token_T* variants, token_T* handlers, token_T* content_type, hb_array_T* locals, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+  AST_RUBY_RENDER_KEYWORDS_NODE_T* ruby_render_keywords_node = hb_allocator_alloc(allocator, sizeof(AST_RUBY_RENDER_KEYWORDS_NODE_T));
+
+  if (!ruby_render_keywords_node) { return NULL; }
+
+  ast_node_init(&ruby_render_keywords_node->base, AST_RUBY_RENDER_KEYWORDS_NODE, start_position, end_position, errors, allocator);
+
+  ruby_render_keywords_node->partial = token_copy(partial, allocator);
+  ruby_render_keywords_node->template_path = token_copy(template_path, allocator);
+  ruby_render_keywords_node->layout = token_copy(layout, allocator);
+  ruby_render_keywords_node->file = token_copy(file, allocator);
+  ruby_render_keywords_node->inline_template = token_copy(inline_template, allocator);
+  ruby_render_keywords_node->body = token_copy(body, allocator);
+  ruby_render_keywords_node->plain = token_copy(plain, allocator);
+  ruby_render_keywords_node->html = token_copy(html, allocator);
+  ruby_render_keywords_node->renderable = token_copy(renderable, allocator);
+  ruby_render_keywords_node->collection = token_copy(collection, allocator);
+  ruby_render_keywords_node->object = token_copy(object, allocator);
+  ruby_render_keywords_node->as_name = token_copy(as_name, allocator);
+  ruby_render_keywords_node->spacer_template = token_copy(spacer_template, allocator);
+  ruby_render_keywords_node->formats = token_copy(formats, allocator);
+  ruby_render_keywords_node->variants = token_copy(variants, allocator);
+  ruby_render_keywords_node->handlers = token_copy(handlers, allocator);
+  ruby_render_keywords_node->content_type = token_copy(content_type, allocator);
+  ruby_render_keywords_node->locals = locals;
+
+  return ruby_render_keywords_node;
+}
+
+AST_ERB_RENDER_NODE_T* ast_erb_render_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, herb_prism_node_T prism_node, struct AST_RUBY_RENDER_KEYWORDS_NODE_STRUCT* keywords, hb_array_T* body, hb_array_T* block_arguments, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
   AST_ERB_RENDER_NODE_T* erb_render_node = hb_allocator_alloc(allocator, sizeof(AST_ERB_RENDER_NODE_T));
 
   if (!erb_render_node) { return NULL; }
@@ -596,41 +626,30 @@ AST_ERB_RENDER_NODE_T* ast_erb_render_node_init(token_T* tag_opening, token_T* c
   erb_render_node->tag_closing = token_copy(tag_closing, allocator);
   erb_render_node->analyzed_ruby = analyzed_ruby;
   erb_render_node->prism_node = prism_node;
-  erb_render_node->partial = token_copy(partial, allocator);
-  erb_render_node->template_path = token_copy(template_path, allocator);
-  erb_render_node->layout = token_copy(layout, allocator);
-  erb_render_node->file = token_copy(file, allocator);
-  erb_render_node->inline_template = token_copy(inline_template, allocator);
-  erb_render_node->body = token_copy(body, allocator);
-  erb_render_node->plain = token_copy(plain, allocator);
-  erb_render_node->html = token_copy(html, allocator);
-  erb_render_node->renderable = token_copy(renderable, allocator);
-  erb_render_node->collection = token_copy(collection, allocator);
-  erb_render_node->object = token_copy(object, allocator);
-  erb_render_node->as_name = token_copy(as_name, allocator);
-  erb_render_node->spacer_template = token_copy(spacer_template, allocator);
-  erb_render_node->formats = token_copy(formats, allocator);
-  erb_render_node->variants = token_copy(variants, allocator);
-  erb_render_node->handlers = token_copy(handlers, allocator);
-  erb_render_node->content_type = token_copy(content_type, allocator);
-  erb_render_node->locals = locals;
+  erb_render_node->keywords = keywords;
+  erb_render_node->body = body;
+  erb_render_node->block_arguments = block_arguments;
+  erb_render_node->rescue_clause = rescue_clause;
+  erb_render_node->else_clause = else_clause;
+  erb_render_node->ensure_clause = ensure_clause;
+  erb_render_node->end_node = end_node;
 
   return erb_render_node;
 }
 
-AST_RUBY_STRICT_LOCAL_NODE_T* ast_ruby_strict_local_node_init(token_T* name, struct AST_RUBY_LITERAL_NODE_STRUCT* default_value, bool required, bool double_splat, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
-  AST_RUBY_STRICT_LOCAL_NODE_T* ruby_strict_local_node = hb_allocator_alloc(allocator, sizeof(AST_RUBY_STRICT_LOCAL_NODE_T));
+AST_RUBY_PARAMETER_NODE_T* ast_ruby_parameter_node_init(token_T* name, struct AST_RUBY_LITERAL_NODE_STRUCT* default_value, hb_string_T kind, bool required, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+  AST_RUBY_PARAMETER_NODE_T* ruby_parameter_node = hb_allocator_alloc(allocator, sizeof(AST_RUBY_PARAMETER_NODE_T));
 
-  if (!ruby_strict_local_node) { return NULL; }
+  if (!ruby_parameter_node) { return NULL; }
 
-  ast_node_init(&ruby_strict_local_node->base, AST_RUBY_STRICT_LOCAL_NODE, start_position, end_position, errors, allocator);
+  ast_node_init(&ruby_parameter_node->base, AST_RUBY_PARAMETER_NODE, start_position, end_position, errors, allocator);
 
-  ruby_strict_local_node->name = token_copy(name, allocator);
-  ruby_strict_local_node->default_value = default_value;
-  ruby_strict_local_node->required = required;
-  ruby_strict_local_node->double_splat = double_splat;
+  ruby_parameter_node->name = token_copy(name, allocator);
+  ruby_parameter_node->default_value = default_value;
+  ruby_parameter_node->kind = hb_string_copy(kind, allocator);
+  ruby_parameter_node->required = required;
 
-  return ruby_strict_local_node;
+  return ruby_parameter_node;
 }
 
 AST_ERB_STRICT_LOCALS_NODE_T* ast_erb_strict_locals_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, herb_prism_node_T prism_node, hb_array_T* locals, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
@@ -719,8 +738,9 @@ hb_string_T ast_node_type_to_string(AST_NODE_T* node) {
     case AST_ERB_BEGIN_NODE: return hb_string("AST_ERB_BEGIN_NODE");
     case AST_ERB_UNLESS_NODE: return hb_string("AST_ERB_UNLESS_NODE");
     case AST_RUBY_RENDER_LOCAL_NODE: return hb_string("AST_RUBY_RENDER_LOCAL_NODE");
+    case AST_RUBY_RENDER_KEYWORDS_NODE: return hb_string("AST_RUBY_RENDER_KEYWORDS_NODE");
     case AST_ERB_RENDER_NODE: return hb_string("AST_ERB_RENDER_NODE");
-    case AST_RUBY_STRICT_LOCAL_NODE: return hb_string("AST_RUBY_STRICT_LOCAL_NODE");
+    case AST_RUBY_PARAMETER_NODE: return hb_string("AST_RUBY_PARAMETER_NODE");
     case AST_ERB_STRICT_LOCALS_NODE: return hb_string("AST_ERB_STRICT_LOCALS_NODE");
     case AST_ERB_YIELD_NODE: return hb_string("AST_ERB_YIELD_NODE");
     case AST_ERB_IN_NODE: return hb_string("AST_ERB_IN_NODE");
@@ -768,8 +788,9 @@ hb_string_T ast_node_human_type(AST_NODE_T* node) {
     case AST_ERB_BEGIN_NODE: return hb_string("ERBBeginNode");
     case AST_ERB_UNLESS_NODE: return hb_string("ERBUnlessNode");
     case AST_RUBY_RENDER_LOCAL_NODE: return hb_string("RubyRenderLocalNode");
+    case AST_RUBY_RENDER_KEYWORDS_NODE: return hb_string("RubyRenderKeywordsNode");
     case AST_ERB_RENDER_NODE: return hb_string("ERBRenderNode");
-    case AST_RUBY_STRICT_LOCAL_NODE: return hb_string("RubyStrictLocalNode");
+    case AST_RUBY_PARAMETER_NODE: return hb_string("RubyParameterNode");
     case AST_ERB_STRICT_LOCALS_NODE: return hb_string("ERBStrictLocalsNode");
     case AST_ERB_YIELD_NODE: return hb_string("ERBYieldNode");
     case AST_ERB_IN_NODE: return hb_string("ERBInNode");
@@ -1108,6 +1129,14 @@ static void ast_free_erb_block_node(AST_ERB_BLOCK_NODE_T* erb_block_node, hb_all
 
     hb_array_free(&erb_block_node->body);
   }
+  if (erb_block_node->block_arguments != NULL) {
+    for (size_t i = 0; i < hb_array_size(erb_block_node->block_arguments); i++) {
+      AST_NODE_T* child = hb_array_get(erb_block_node->block_arguments, i);
+      if (child) { ast_node_free(child, allocator); }
+    }
+
+    hb_array_free(&erb_block_node->block_arguments);
+  }
   ast_node_free((AST_NODE_T*) erb_block_node->rescue_clause, allocator);
   ast_node_free((AST_NODE_T*) erb_block_node->else_clause, allocator);
   ast_node_free((AST_NODE_T*) erb_block_node->ensure_clause, allocator);
@@ -1322,6 +1351,36 @@ static void ast_free_ruby_render_local_node(AST_RUBY_RENDER_LOCAL_NODE_T* ruby_r
   ast_free_base_node(&ruby_render_local_node->base, allocator);
 }
 
+static void ast_free_ruby_render_keywords_node(AST_RUBY_RENDER_KEYWORDS_NODE_T* ruby_render_keywords_node, hb_allocator_T* allocator) {
+  if (ruby_render_keywords_node->partial != NULL) { token_free(ruby_render_keywords_node->partial, allocator); }
+  if (ruby_render_keywords_node->template_path != NULL) { token_free(ruby_render_keywords_node->template_path, allocator); }
+  if (ruby_render_keywords_node->layout != NULL) { token_free(ruby_render_keywords_node->layout, allocator); }
+  if (ruby_render_keywords_node->file != NULL) { token_free(ruby_render_keywords_node->file, allocator); }
+  if (ruby_render_keywords_node->inline_template != NULL) { token_free(ruby_render_keywords_node->inline_template, allocator); }
+  if (ruby_render_keywords_node->body != NULL) { token_free(ruby_render_keywords_node->body, allocator); }
+  if (ruby_render_keywords_node->plain != NULL) { token_free(ruby_render_keywords_node->plain, allocator); }
+  if (ruby_render_keywords_node->html != NULL) { token_free(ruby_render_keywords_node->html, allocator); }
+  if (ruby_render_keywords_node->renderable != NULL) { token_free(ruby_render_keywords_node->renderable, allocator); }
+  if (ruby_render_keywords_node->collection != NULL) { token_free(ruby_render_keywords_node->collection, allocator); }
+  if (ruby_render_keywords_node->object != NULL) { token_free(ruby_render_keywords_node->object, allocator); }
+  if (ruby_render_keywords_node->as_name != NULL) { token_free(ruby_render_keywords_node->as_name, allocator); }
+  if (ruby_render_keywords_node->spacer_template != NULL) { token_free(ruby_render_keywords_node->spacer_template, allocator); }
+  if (ruby_render_keywords_node->formats != NULL) { token_free(ruby_render_keywords_node->formats, allocator); }
+  if (ruby_render_keywords_node->variants != NULL) { token_free(ruby_render_keywords_node->variants, allocator); }
+  if (ruby_render_keywords_node->handlers != NULL) { token_free(ruby_render_keywords_node->handlers, allocator); }
+  if (ruby_render_keywords_node->content_type != NULL) { token_free(ruby_render_keywords_node->content_type, allocator); }
+  if (ruby_render_keywords_node->locals != NULL) {
+    for (size_t i = 0; i < hb_array_size(ruby_render_keywords_node->locals); i++) {
+      AST_NODE_T* child = hb_array_get(ruby_render_keywords_node->locals, i);
+      if (child) { ast_node_free(child, allocator); }
+    }
+
+    hb_array_free(&ruby_render_keywords_node->locals);
+  }
+
+  ast_free_base_node(&ruby_render_keywords_node->base, allocator);
+}
+
 static void ast_free_erb_render_node(AST_ERB_RENDER_NODE_T* erb_render_node, hb_allocator_T* allocator) {
   if (erb_render_node->tag_opening != NULL) { token_free(erb_render_node->tag_opening, allocator); }
   if (erb_render_node->content != NULL) { token_free(erb_render_node->content, allocator); }
@@ -1330,40 +1389,37 @@ static void ast_free_erb_render_node(AST_ERB_RENDER_NODE_T* erb_render_node, hb_
     free_analyzed_ruby(erb_render_node->analyzed_ruby);
   }
   /* prism_node is a borrowed reference into the prism context, not freed here */
-  if (erb_render_node->partial != NULL) { token_free(erb_render_node->partial, allocator); }
-  if (erb_render_node->template_path != NULL) { token_free(erb_render_node->template_path, allocator); }
-  if (erb_render_node->layout != NULL) { token_free(erb_render_node->layout, allocator); }
-  if (erb_render_node->file != NULL) { token_free(erb_render_node->file, allocator); }
-  if (erb_render_node->inline_template != NULL) { token_free(erb_render_node->inline_template, allocator); }
-  if (erb_render_node->body != NULL) { token_free(erb_render_node->body, allocator); }
-  if (erb_render_node->plain != NULL) { token_free(erb_render_node->plain, allocator); }
-  if (erb_render_node->html != NULL) { token_free(erb_render_node->html, allocator); }
-  if (erb_render_node->renderable != NULL) { token_free(erb_render_node->renderable, allocator); }
-  if (erb_render_node->collection != NULL) { token_free(erb_render_node->collection, allocator); }
-  if (erb_render_node->object != NULL) { token_free(erb_render_node->object, allocator); }
-  if (erb_render_node->as_name != NULL) { token_free(erb_render_node->as_name, allocator); }
-  if (erb_render_node->spacer_template != NULL) { token_free(erb_render_node->spacer_template, allocator); }
-  if (erb_render_node->formats != NULL) { token_free(erb_render_node->formats, allocator); }
-  if (erb_render_node->variants != NULL) { token_free(erb_render_node->variants, allocator); }
-  if (erb_render_node->handlers != NULL) { token_free(erb_render_node->handlers, allocator); }
-  if (erb_render_node->content_type != NULL) { token_free(erb_render_node->content_type, allocator); }
-  if (erb_render_node->locals != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_render_node->locals); i++) {
-      AST_NODE_T* child = hb_array_get(erb_render_node->locals, i);
+  ast_node_free((AST_NODE_T*) erb_render_node->keywords, allocator);
+  if (erb_render_node->body != NULL) {
+    for (size_t i = 0; i < hb_array_size(erb_render_node->body); i++) {
+      AST_NODE_T* child = hb_array_get(erb_render_node->body, i);
+      if (child) { ast_node_free(child, allocator); }
+    }
+
+    hb_array_free(&erb_render_node->body);
+  }
+  if (erb_render_node->block_arguments != NULL) {
+    for (size_t i = 0; i < hb_array_size(erb_render_node->block_arguments); i++) {
+      AST_NODE_T* child = hb_array_get(erb_render_node->block_arguments, i);
       if (child) { ast_node_free(child, allocator); }
     }
 
-    hb_array_free(&erb_render_node->locals);
+    hb_array_free(&erb_render_node->block_arguments);
   }
+  ast_node_free((AST_NODE_T*) erb_render_node->rescue_clause, allocator);
+  ast_node_free((AST_NODE_T*) erb_render_node->else_clause, allocator);
+  ast_node_free((AST_NODE_T*) erb_render_node->ensure_clause, allocator);
+  ast_node_free((AST_NODE_T*) erb_render_node->end_node, allocator);
 
   ast_free_base_node(&erb_render_node->base, allocator);
 }
 
-static void ast_free_ruby_strict_local_node(AST_RUBY_STRICT_LOCAL_NODE_T* ruby_strict_local_node, hb_allocator_T* allocator) {
-  if (ruby_strict_local_node->name != NULL) { token_free(ruby_strict_local_node->name, allocator); }
-  ast_node_free((AST_NODE_T*) ruby_strict_local_node->default_value, allocator);
+static void ast_free_ruby_parameter_node(AST_RUBY_PARAMETER_NODE_T* ruby_parameter_node, hb_allocator_T* allocator) {
+  if (ruby_parameter_node->name != NULL) { token_free(ruby_parameter_node->name, allocator); }
+  ast_node_free((AST_NODE_T*) ruby_parameter_node->default_value, allocator);
+  if (ruby_parameter_node->kind.data != NULL) { hb_allocator_dealloc(allocator, ruby_parameter_node->kind.data); }
 
-  ast_free_base_node(&ruby_strict_local_node->base, allocator);
+  ast_free_base_node(&ruby_parameter_node->base, allocator);
 }
 
 static void ast_free_erb_strict_locals_node(AST_ERB_STRICT_LOCALS_NODE_T* erb_strict_locals_node, hb_allocator_T* allocator) {
@@ -1452,8 +1508,9 @@ void ast_node_free(AST_NODE_T* node, hb_allocator_T* allocator) {
     case AST_ERB_BEGIN_NODE: ast_free_erb_begin_node((AST_ERB_BEGIN_NODE_T*) node, allocator); break;
     case AST_ERB_UNLESS_NODE: ast_free_erb_unless_node((AST_ERB_UNLESS_NODE_T*) node, allocator); break;
     case AST_RUBY_RENDER_LOCAL_NODE: ast_free_ruby_render_local_node((AST_RUBY_RENDER_LOCAL_NODE_T*) node, allocator); break;
+    case AST_RUBY_RENDER_KEYWORDS_NODE: ast_free_ruby_render_keywords_node((AST_RUBY_RENDER_KEYWORDS_NODE_T*) node, allocator); break;
     case AST_ERB_RENDER_NODE: ast_free_erb_render_node((AST_ERB_RENDER_NODE_T*) node, allocator); break;
-    case AST_RUBY_STRICT_LOCAL_NODE: ast_free_ruby_strict_local_node((AST_RUBY_STRICT_LOCAL_NODE_T*) node, allocator); break;
+    case AST_RUBY_PARAMETER_NODE: ast_free_ruby_parameter_node((AST_RUBY_PARAMETER_NODE_T*) node, allocator); break;
     case AST_ERB_STRICT_LOCALS_NODE: ast_free_erb_strict_locals_node((AST_ERB_STRICT_LOCALS_NODE_T*) node, allocator); break;
     case AST_ERB_YIELD_NODE: ast_free_erb_yield_node((AST_ERB_YIELD_NODE_T*) node, allocator); break;
     case AST_ERB_IN_NODE: ast_free_erb_in_node((AST_ERB_IN_NODE_T*) node, allocator); break;

data/src/ast/ast_pretty_print.c

@@ -473,6 +473,7 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
         hb_buffer_append(buffer, " (pm_node_t*)\n");
       }
       pretty_print_array(hb_string("body"), erb_block_node->body, indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("block_arguments"), erb_block_node->block_arguments, indent, relative_indent, false, buffer);
 
       pretty_print_label(hb_string("rescue_clause"), indent, relative_indent, false, buffer);
 
@@ -923,6 +924,30 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
 
     } break;
 
+    case AST_RUBY_RENDER_KEYWORDS_NODE: {
+      const AST_RUBY_RENDER_KEYWORDS_NODE_T* ruby_render_keywords_node = (AST_RUBY_RENDER_KEYWORDS_NODE_T*) node;
+
+      pretty_print_errors(node, indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->partial, hb_string("partial"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->template_path, hb_string("template_path"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->layout, hb_string("layout"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->file, hb_string("file"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->inline_template, hb_string("inline_template"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->body, hb_string("body"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->plain, hb_string("plain"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->html, hb_string("html"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->renderable, hb_string("renderable"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->collection, hb_string("collection"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->object, hb_string("object"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->as_name, hb_string("as_name"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->spacer_template, hb_string("spacer_template"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->formats, hb_string("formats"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->variants, hb_string("variants"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->handlers, hb_string("handlers"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_render_keywords_node->content_type, hb_string("content_type"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("locals"), ruby_render_keywords_node->locals, indent, relative_indent, true, buffer);
+    } break;
+
     case AST_ERB_RENDER_NODE: {
       const AST_ERB_RENDER_NODE_T* erb_render_node = (AST_ERB_RENDER_NODE_T*) node;
 
@@ -955,48 +980,107 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
         pretty_print_label(hb_string("prism_node"), indent, relative_indent, false, buffer);
         hb_buffer_append(buffer, " (pm_node_t*)\n");
       }
-      pretty_print_token_property(erb_render_node->partial, hb_string("partial"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->template_path, hb_string("template_path"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->layout, hb_string("layout"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->file, hb_string("file"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->inline_template, hb_string("inline_template"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->body, hb_string("body"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->plain, hb_string("plain"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->html, hb_string("html"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->renderable, hb_string("renderable"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->collection, hb_string("collection"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->object, hb_string("object"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->as_name, hb_string("as_name"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->spacer_template, hb_string("spacer_template"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->formats, hb_string("formats"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->variants, hb_string("variants"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->handlers, hb_string("handlers"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_render_node->content_type, hb_string("content_type"), indent, relative_indent, false, buffer);
-      pretty_print_array(hb_string("locals"), erb_render_node->locals, indent, relative_indent, true, buffer);
+
+      pretty_print_label(hb_string("keywords"), indent, relative_indent, false, buffer);
+
+      if (erb_render_node->keywords) {
+        hb_buffer_append(buffer, "\n");
+        pretty_print_indent(buffer, indent);
+        pretty_print_indent(buffer, relative_indent + 1);
+
+        hb_buffer_append(buffer, "└── ");
+        ast_pretty_print_node((AST_NODE_T*) erb_render_node->keywords, indent, relative_indent + 2, buffer);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+      hb_buffer_append(buffer, "\n");
+
+      pretty_print_array(hb_string("body"), erb_render_node->body, indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("block_arguments"), erb_render_node->block_arguments, indent, relative_indent, false, buffer);
+
+      pretty_print_label(hb_string("rescue_clause"), indent, relative_indent, false, buffer);
+
+      if (erb_render_node->rescue_clause) {
+        hb_buffer_append(buffer, "\n");
+        pretty_print_indent(buffer, indent);
+        pretty_print_indent(buffer, relative_indent + 1);
+
+        hb_buffer_append(buffer, "└── ");
+        ast_pretty_print_node((AST_NODE_T*) erb_render_node->rescue_clause, indent, relative_indent + 2, buffer);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+      hb_buffer_append(buffer, "\n");
+
+
+      pretty_print_label(hb_string("else_clause"), indent, relative_indent, false, buffer);
+
+      if (erb_render_node->else_clause) {
+        hb_buffer_append(buffer, "\n");
+        pretty_print_indent(buffer, indent);
+        pretty_print_indent(buffer, relative_indent + 1);
+
+        hb_buffer_append(buffer, "└── ");
+        ast_pretty_print_node((AST_NODE_T*) erb_render_node->else_clause, indent, relative_indent + 2, buffer);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+      hb_buffer_append(buffer, "\n");
+
+
+      pretty_print_label(hb_string("ensure_clause"), indent, relative_indent, false, buffer);
+
+      if (erb_render_node->ensure_clause) {
+        hb_buffer_append(buffer, "\n");
+        pretty_print_indent(buffer, indent);
+        pretty_print_indent(buffer, relative_indent + 1);
+
+        hb_buffer_append(buffer, "└── ");
+        ast_pretty_print_node((AST_NODE_T*) erb_render_node->ensure_clause, indent, relative_indent + 2, buffer);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+      hb_buffer_append(buffer, "\n");
+
+
+      pretty_print_label(hb_string("end_node"), indent, relative_indent, true, buffer);
+
+      if (erb_render_node->end_node) {
+        hb_buffer_append(buffer, "\n");
+        pretty_print_indent(buffer, indent);
+        pretty_print_indent(buffer, relative_indent + 1);
+
+        hb_buffer_append(buffer, "└── ");
+        ast_pretty_print_node((AST_NODE_T*) erb_render_node->end_node, indent, relative_indent + 2, buffer);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+      hb_buffer_append(buffer, "\n");
+
     } break;
 
-    case AST_RUBY_STRICT_LOCAL_NODE: {
-      const AST_RUBY_STRICT_LOCAL_NODE_T* ruby_strict_local_node = (AST_RUBY_STRICT_LOCAL_NODE_T*) node;
+    case AST_RUBY_PARAMETER_NODE: {
+      const AST_RUBY_PARAMETER_NODE_T* ruby_parameter_node = (AST_RUBY_PARAMETER_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(ruby_strict_local_node->name, hb_string("name"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(ruby_parameter_node->name, hb_string("name"), indent, relative_indent, false, buffer);
 
       pretty_print_label(hb_string("default_value"), indent, relative_indent, false, buffer);
 
-      if (ruby_strict_local_node->default_value) {
+      if (ruby_parameter_node->default_value) {
         hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
         hb_buffer_append(buffer, "└── ");
-        ast_pretty_print_node((AST_NODE_T*) ruby_strict_local_node->default_value, indent, relative_indent + 2, buffer);
+        ast_pretty_print_node((AST_NODE_T*) ruby_parameter_node->default_value, indent, relative_indent + 2, buffer);
       } else {
         hb_buffer_append(buffer, " ∅\n");
       }
       hb_buffer_append(buffer, "\n");
 
-      pretty_print_boolean_property(hb_string("required"), ruby_strict_local_node->required, indent, relative_indent, false, buffer);
-      pretty_print_boolean_property(hb_string("double_splat"), ruby_strict_local_node->double_splat, indent, relative_indent, true, buffer);
+      pretty_print_string_property(ruby_parameter_node->kind, hb_string("kind"), indent, relative_indent, false, buffer);
+      pretty_print_boolean_property(hb_string("required"), ruby_parameter_node->required, indent, relative_indent, true, buffer);
     } break;
 
     case AST_ERB_STRICT_LOCALS_NODE: {

data/src/include/analyze/action_view/tag_helper_handler.h

@@ -40,4 +40,7 @@ size_t get_tag_helper_handlers_count(void);
 
 char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* allocator);
 
+struct AST_NODE_STRUCT;
+bool wrap_javascript_tag_body_visitor(const struct AST_NODE_STRUCT* node, void* data);
+
 #endif

data/src/include/analyze/action_view/tag_helper_node_builders.h

@@ -87,6 +87,13 @@ AST_HTML_ATTRIBUTE_NODE_T* create_href_attribute(
   hb_allocator_T* allocator
 );
 
+AST_CDATA_NODE_T* create_javascript_cdata_node(
+  hb_array_T* children,
+  position_T start,
+  position_T end,
+  hb_allocator_T* allocator
+);
+
 void append_body_content_node(
   hb_array_T* body,
   const char* content,

data/src/include/analyze/helpers.h

@@ -5,7 +5,9 @@
 #include <stdbool.h>
 
 #include "../ast/ast_node.h"
+#include "../ast/ast_nodes.h"
 #include "../lib/hb_allocator.h"
+#include "../lib/hb_array.h"
 #include "analyzed_ruby.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed);
@@ -62,4 +64,20 @@ bool search_unexpected_when_nodes(analyzed_ruby_T* analyzed);
 
 void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator);
 
+hb_array_T* extract_parameters_from_prism(
+  pm_parameters_node_t* parameters,
+  pm_parser_t* parser,
+  const char* source,
+  size_t source_base_offset,
+  const uint8_t* prism_source_start,
+  hb_allocator_T* allocator
+);
+
+hb_array_T* extract_block_arguments_from_erb_node(
+  const AST_ERB_CONTENT_NODE_T* erb_node,
+  const char* source,
+  hb_array_T* errors,
+  hb_allocator_T* allocator
+);
+
 #endif

data/src/include/ast/ast_nodes.h

@@ -57,8 +57,9 @@ typedef enum {
   AST_ERB_BEGIN_NODE,
   AST_ERB_UNLESS_NODE,
   AST_RUBY_RENDER_LOCAL_NODE,
+  AST_RUBY_RENDER_KEYWORDS_NODE,
   AST_ERB_RENDER_NODE,
-  AST_RUBY_STRICT_LOCAL_NODE,
+  AST_RUBY_PARAMETER_NODE,
   AST_ERB_STRICT_LOCALS_NODE,
   AST_ERB_YIELD_NODE,
   AST_ERB_IN_NODE,
@@ -263,6 +264,7 @@ typedef struct AST_ERB_BLOCK_NODE_STRUCT {
   token_T* tag_closing;
   herb_prism_node_T prism_node;
   hb_array_T* body;
+  hb_array_T* block_arguments;
   struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause;
   struct AST_ERB_ELSE_NODE_STRUCT* else_clause;
   struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause;
@@ -380,13 +382,8 @@ typedef struct AST_RUBY_RENDER_LOCAL_NODE_STRUCT {
   struct AST_RUBY_LITERAL_NODE_STRUCT* value;
 } AST_RUBY_RENDER_LOCAL_NODE_T;
 
-typedef struct AST_ERB_RENDER_NODE_STRUCT {
+typedef struct AST_RUBY_RENDER_KEYWORDS_NODE_STRUCT {
   AST_NODE_T base;
-  token_T* tag_opening;
-  token_T* content;
-  token_T* tag_closing;
-  analyzed_ruby_T* analyzed_ruby;
-  herb_prism_node_T prism_node;
   token_T* partial;
   token_T* template_path;
   token_T* layout;
@@ -405,15 +402,31 @@ typedef struct AST_ERB_RENDER_NODE_STRUCT {
   token_T* handlers;
   token_T* content_type;
   hb_array_T* locals;
+} AST_RUBY_RENDER_KEYWORDS_NODE_T;
+
+typedef struct AST_ERB_RENDER_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  analyzed_ruby_T* analyzed_ruby;
+  herb_prism_node_T prism_node;
+  struct AST_RUBY_RENDER_KEYWORDS_NODE_STRUCT* keywords;
+  hb_array_T* body;
+  hb_array_T* block_arguments;
+  struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause;
+  struct AST_ERB_ELSE_NODE_STRUCT* else_clause;
+  struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
 } AST_ERB_RENDER_NODE_T;
 
-typedef struct AST_RUBY_STRICT_LOCAL_NODE_STRUCT {
+typedef struct AST_RUBY_PARAMETER_NODE_STRUCT {
   AST_NODE_T base;
   token_T* name;
   struct AST_RUBY_LITERAL_NODE_STRUCT* default_value;
+  hb_string_T kind;
   bool required;
-  bool double_splat;
-} AST_RUBY_STRICT_LOCAL_NODE_T;
+} AST_RUBY_PARAMETER_NODE_T;
 
 typedef struct AST_ERB_STRICT_LOCALS_NODE_STRUCT {
   AST_NODE_T base;
@@ -466,7 +479,7 @@ AST_ERB_CONTENT_NODE_T* ast_erb_content_node_init(token_T* tag_opening, token_T*
 AST_ERB_END_NODE_T* ast_erb_end_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_ELSE_NODE_T* ast_erb_else_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, herb_prism_node_T prism_node, hb_array_T* statements, AST_NODE_T* subsequent, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
-AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, hb_array_T* body, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
+AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, hb_array_T* body, hb_array_T* block_arguments, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_CASE_NODE_T* ast_erb_case_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* children, herb_prism_node_T prism_node, hb_array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_CASE_MATCH_NODE_T* ast_erb_case_match_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* children, herb_prism_node_T prism_node, hb_array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
@@ -478,8 +491,9 @@ AST_ERB_ENSURE_NODE_T* ast_erb_ensure_node_init(token_T* tag_opening, token_T* c
 AST_ERB_BEGIN_NODE_T* ast_erb_begin_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, hb_array_T* statements, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, herb_prism_node_T prism_node, hb_array_T* statements, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_RUBY_RENDER_LOCAL_NODE_T* ast_ruby_render_local_node_init(token_T* name, struct AST_RUBY_LITERAL_NODE_STRUCT* value, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
-AST_ERB_RENDER_NODE_T* ast_erb_render_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, herb_prism_node_T prism_node, token_T* partial, token_T* template_path, token_T* layout, token_T* file, token_T* inline_template, token_T* body, token_T* plain, token_T* html, token_T* renderable, token_T* collection, token_T* object, token_T* as_name, token_T* spacer_template, token_T* formats, token_T* variants, token_T* handlers, token_T* content_type, hb_array_T* locals, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
-AST_RUBY_STRICT_LOCAL_NODE_T* ast_ruby_strict_local_node_init(token_T* name, struct AST_RUBY_LITERAL_NODE_STRUCT* default_value, bool required, bool double_splat, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
+AST_RUBY_RENDER_KEYWORDS_NODE_T* ast_ruby_render_keywords_node_init(token_T* partial, token_T* template_path, token_T* layout, token_T* file, token_T* inline_template, token_T* body, token_T* plain, token_T* html, token_T* renderable, token_T* collection, token_T* object, token_T* as_name, token_T* spacer_template, token_T* formats, token_T* variants, token_T* handlers, token_T* content_type, hb_array_T* locals, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
+AST_ERB_RENDER_NODE_T* ast_erb_render_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, herb_prism_node_T prism_node, struct AST_RUBY_RENDER_KEYWORDS_NODE_STRUCT* keywords, hb_array_T* body, hb_array_T* block_arguments, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
+AST_RUBY_PARAMETER_NODE_T* ast_ruby_parameter_node_init(token_T* name, struct AST_RUBY_LITERAL_NODE_STRUCT* default_value, hb_string_T kind, bool required, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_STRICT_LOCALS_NODE_T* ast_erb_strict_locals_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, herb_prism_node_T prism_node, hb_array_T* locals, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.9.4"
+#define HERB_VERSION "0.9.5"
 
 #endif