herb 0.9.6-arm-linux-gnu → 0.10.0-arm-linux-gnu

data/src/diff/herb_diff_nodes.c

@@ -0,0 +1,707 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /home/runner/work/herb/herb/templates/src/diff/herb_diff_nodes.c.erb
+
+#include "../include/diff/herb_diff.h"
+#include "../include/lib/hb_string.h"
+
+static bool tokens_equal(const token_T* old_token, const token_T* new_token) {
+  if (old_token == NULL && new_token == NULL) { return true; }
+  if (old_token == NULL || new_token == NULL) { return false; }
+
+  return hb_string_equals(old_token->value, new_token->value);
+}
+
+static void diff_element_node(
+  const AST_HTML_ELEMENT_NODE_T* old_element,
+  const AST_HTML_ELEMENT_NODE_T* new_element,
+  const herb_diff_path_T path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+) {
+  if (!tokens_equal(old_element->tag_name, new_element->tag_name)) {
+    herb_diff_emit_operation(result, HERB_DIFF_TAG_NAME_CHANGED, path, (const AST_NODE_T*) old_element, (const AST_NODE_T*) new_element, 0, 0);
+  }
+
+  if (old_element->open_tag != NULL && new_element->open_tag != NULL) {
+    herb_hash_T old_open_hash = herb_hash_map_get(old_hashes, old_element->open_tag);
+    herb_hash_T new_open_hash = herb_hash_map_get(new_hashes, new_element->open_tag);
+
+    if (old_open_hash != new_open_hash) {
+      const AST_HTML_OPEN_TAG_NODE_T* old_open_tag = (const AST_HTML_OPEN_TAG_NODE_T*) old_element->open_tag;
+      const AST_HTML_OPEN_TAG_NODE_T* new_open_tag = (const AST_HTML_OPEN_TAG_NODE_T*) new_element->open_tag;
+
+      herb_diff_attributes(old_open_tag->children, new_open_tag->children, path, old_hashes, new_hashes, result);
+    }
+  }
+
+  if (old_element->body != NULL && new_element->body != NULL) {
+    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, result);
+  } else if (old_element->body == NULL && new_element->body != NULL) {
+    for (size_t index = 0; index < hb_array_size(new_element->body); index++) {
+      const AST_NODE_T* new_child = (const AST_NODE_T*) hb_array_get(new_element->body, index);
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_INSERTED, herb_diff_path_append(path, (uint32_t) index), NULL, new_child, 0, (uint32_t) index);
+    }
+  } else if (old_element->body != NULL && new_element->body == NULL) {
+    for (size_t index = 0; index < hb_array_size(old_element->body); index++) {
+      const AST_NODE_T* old_child = (const AST_NODE_T*) hb_array_get(old_element->body, index);
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_REMOVED, herb_diff_path_append(path, (uint32_t) index), old_child, NULL, (uint32_t) index, 0);
+    }
+  }
+}
+
+static void diff_conditional_element_node(
+  const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* old_element,
+  const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* new_element,
+  const herb_diff_path_T path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+) {
+  if (!tokens_equal(old_element->tag_name, new_element->tag_name)) {
+    herb_diff_emit_operation(result, HERB_DIFF_TAG_NAME_CHANGED, path, (const AST_NODE_T*) old_element, (const AST_NODE_T*) new_element, 0, 0);
+  }
+
+  if (old_element->open_tag != NULL && new_element->open_tag != NULL) {
+    herb_hash_T old_open_hash = herb_hash_map_get(old_hashes, (const AST_NODE_T*) old_element->open_tag);
+    herb_hash_T new_open_hash = herb_hash_map_get(new_hashes, (const AST_NODE_T*) new_element->open_tag);
+
+    if (old_open_hash != new_open_hash) {
+      herb_diff_attributes(old_element->open_tag->children, new_element->open_tag->children, path, old_hashes, new_hashes, result);
+    }
+  }
+
+  if (old_element->body != NULL && new_element->body != NULL) {
+    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, result);
+  }
+}
+
+static void diff_children_nullable(
+  const hb_array_T* old_children,
+  const hb_array_T* new_children,
+  const herb_diff_path_T path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+) {
+  if (old_children != NULL && new_children != NULL) {
+    herb_diff_children(old_children, new_children, path, old_hashes, new_hashes, result);
+  } else if (old_children == NULL && new_children != NULL) {
+    for (size_t index = 0; index < hb_array_size(new_children); index++) {
+      const AST_NODE_T* new_child = (const AST_NODE_T*) hb_array_get(new_children, index);
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_INSERTED, herb_diff_path_append(path, (uint32_t) index), NULL, new_child, 0, (uint32_t) index);
+    }
+  } else if (old_children != NULL && new_children == NULL) {
+    for (size_t index = 0; index < hb_array_size(old_children); index++) {
+      const AST_NODE_T* old_child = (const AST_NODE_T*) hb_array_get(old_children, index);
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_REMOVED, herb_diff_path_append(path, (uint32_t) index), old_child, NULL, (uint32_t) index, 0);
+    }
+  }
+}
+
+void herb_diff_node(
+  const AST_NODE_T* old_node,
+  const AST_NODE_T* new_node,
+  const herb_diff_path_T path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+) {
+  if (old_node == NULL && new_node == NULL) { return; }
+
+  if (old_node == NULL) {
+    herb_diff_emit_operation(result, HERB_DIFF_NODE_INSERTED, path, NULL, new_node, 0, 0);
+    return;
+  }
+
+  if (new_node == NULL) {
+    herb_diff_emit_operation(result, HERB_DIFF_NODE_REMOVED, path, old_node, NULL, 0, 0);
+    return;
+  }
+
+  herb_hash_T old_hash = herb_hash_map_get(old_hashes, old_node);
+  herb_hash_T new_hash = herb_hash_map_get(new_hashes, new_node);
+
+  if (old_hash == new_hash) { return; }
+
+  if (old_node->type != new_node->type) {
+    herb_diff_emit_operation(result, HERB_DIFF_NODE_REPLACED, path, old_node, new_node, 0, 0);
+    return;
+  }
+
+  switch (old_node->type) {
+    case AST_DOCUMENT_NODE: {
+      const AST_DOCUMENT_NODE_T* old_document_node = (const AST_DOCUMENT_NODE_T*) old_node;
+      const AST_DOCUMENT_NODE_T* new_document_node = (const AST_DOCUMENT_NODE_T*) new_node;
+
+
+
+      diff_children_nullable(old_document_node->children, new_document_node->children, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_LITERAL_NODE: {
+      const AST_LITERAL_NODE_T* old_literal_node = (const AST_LITERAL_NODE_T*) old_node;
+      const AST_LITERAL_NODE_T* new_literal_node = (const AST_LITERAL_NODE_T*) new_node;
+
+
+      if (!hb_string_equals(old_literal_node->content, new_literal_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+    } break;
+
+    case AST_HTML_OPEN_TAG_NODE: {
+      const AST_HTML_OPEN_TAG_NODE_T* old_open_tag = (const AST_HTML_OPEN_TAG_NODE_T*) old_node;
+      const AST_HTML_OPEN_TAG_NODE_T* new_open_tag = (const AST_HTML_OPEN_TAG_NODE_T*) new_node;
+
+      herb_diff_attributes(old_open_tag->children, new_open_tag->children, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_HTML_CONDITIONAL_OPEN_TAG_NODE: {
+      const AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T* old_html_conditional_open_tag_node = (const AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T*) old_node;
+      const AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T* new_html_conditional_open_tag_node = (const AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T*) new_node;
+
+
+
+
+      herb_diff_node((const AST_NODE_T*) old_html_conditional_open_tag_node->conditional, (const AST_NODE_T*) new_html_conditional_open_tag_node->conditional, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_HTML_CLOSE_TAG_NODE: {
+      const AST_HTML_CLOSE_TAG_NODE_T* old_html_close_tag_node = (const AST_HTML_CLOSE_TAG_NODE_T*) old_node;
+      const AST_HTML_CLOSE_TAG_NODE_T* new_html_close_tag_node = (const AST_HTML_CLOSE_TAG_NODE_T*) new_node;
+
+      if (!tokens_equal(old_html_close_tag_node->tag_opening, new_html_close_tag_node->tag_opening)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_html_close_tag_node->children, new_html_close_tag_node->children, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_HTML_OMITTED_CLOSE_TAG_NODE: {
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_REPLACED, path, old_node, new_node, 0, 0);
+    } break;
+
+    case AST_HTML_VIRTUAL_CLOSE_TAG_NODE: {
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_REPLACED, path, old_node, new_node, 0, 0);
+    } break;
+
+    case AST_HTML_ELEMENT_NODE: {
+      diff_element_node(
+        (const AST_HTML_ELEMENT_NODE_T*) old_node,
+        (const AST_HTML_ELEMENT_NODE_T*) new_node,
+        path, old_hashes, new_hashes, result
+      );
+    } break;
+
+    case AST_HTML_CONDITIONAL_ELEMENT_NODE: {
+      diff_conditional_element_node(
+        (const AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) old_node,
+        (const AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) new_node,
+        path, old_hashes, new_hashes, result
+      );
+    } break;
+
+    case AST_HTML_ATTRIBUTE_VALUE_NODE: {
+      const AST_HTML_ATTRIBUTE_VALUE_NODE_T* old_html_attribute_value_node = (const AST_HTML_ATTRIBUTE_VALUE_NODE_T*) old_node;
+      const AST_HTML_ATTRIBUTE_VALUE_NODE_T* new_html_attribute_value_node = (const AST_HTML_ATTRIBUTE_VALUE_NODE_T*) new_node;
+
+
+
+      diff_children_nullable(old_html_attribute_value_node->children, new_html_attribute_value_node->children, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_HTML_ATTRIBUTE_NAME_NODE: {
+      const AST_HTML_ATTRIBUTE_NAME_NODE_T* old_html_attribute_name_node = (const AST_HTML_ATTRIBUTE_NAME_NODE_T*) old_node;
+      const AST_HTML_ATTRIBUTE_NAME_NODE_T* new_html_attribute_name_node = (const AST_HTML_ATTRIBUTE_NAME_NODE_T*) new_node;
+
+
+
+      diff_children_nullable(old_html_attribute_name_node->children, new_html_attribute_name_node->children, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_HTML_ATTRIBUTE_NODE: {
+      const AST_HTML_ATTRIBUTE_NODE_T* old_attribute = (const AST_HTML_ATTRIBUTE_NODE_T*) old_node;
+      const AST_HTML_ATTRIBUTE_NODE_T* new_attribute = (const AST_HTML_ATTRIBUTE_NODE_T*) new_node;
+
+      herb_hash_T old_name_hash = herb_hash_map_get(old_hashes, (const AST_NODE_T*) old_attribute->name);
+      herb_hash_T new_name_hash = herb_hash_map_get(new_hashes, (const AST_NODE_T*) new_attribute->name);
+
+      if (old_name_hash != new_name_hash) {
+        herb_diff_emit_operation(result, HERB_DIFF_NODE_REPLACED, path, old_node, new_node, 0, 0);
+      } else {
+        herb_hash_T old_value_hash = herb_hash_map_get(old_hashes, (const AST_NODE_T*) old_attribute->value);
+        herb_hash_T new_value_hash = herb_hash_map_get(new_hashes, (const AST_NODE_T*) new_attribute->value);
+
+        if (old_value_hash != new_value_hash) {
+          herb_diff_emit_operation(result, HERB_DIFF_ATTRIBUTE_VALUE_CHANGED, path, old_node, new_node, 0, 0);
+        }
+      }
+    } break;
+
+    case AST_RUBY_LITERAL_NODE: {
+      const AST_RUBY_LITERAL_NODE_T* old_ruby_literal_node = (const AST_RUBY_LITERAL_NODE_T*) old_node;
+      const AST_RUBY_LITERAL_NODE_T* new_ruby_literal_node = (const AST_RUBY_LITERAL_NODE_T*) new_node;
+
+
+      if (!hb_string_equals(old_ruby_literal_node->content, new_ruby_literal_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+    } break;
+
+    case AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE: {
+      const AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE_T* old_ruby_html_attributes_splat_node = (const AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE_T*) old_node;
+      const AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE_T* new_ruby_html_attributes_splat_node = (const AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE_T*) new_node;
+
+
+      if (!hb_string_equals(old_ruby_html_attributes_splat_node->content, new_ruby_html_attributes_splat_node->content)
+          || !hb_string_equals(old_ruby_html_attributes_splat_node->prefix, new_ruby_html_attributes_splat_node->prefix)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+    } break;
+
+    case AST_ERB_OPEN_TAG_NODE: {
+      const AST_ERB_OPEN_TAG_NODE_T* old_erb_open_tag_node = (const AST_ERB_OPEN_TAG_NODE_T*) old_node;
+      const AST_ERB_OPEN_TAG_NODE_T* new_erb_open_tag_node = (const AST_ERB_OPEN_TAG_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_open_tag_node->tag_opening, new_erb_open_tag_node->tag_opening)
+          || !tokens_equal(old_erb_open_tag_node->content, new_erb_open_tag_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_open_tag_node->children, new_erb_open_tag_node->children, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_HTML_TEXT_NODE: {
+      const AST_HTML_TEXT_NODE_T* old_html_text_node = (const AST_HTML_TEXT_NODE_T*) old_node;
+      const AST_HTML_TEXT_NODE_T* new_html_text_node = (const AST_HTML_TEXT_NODE_T*) new_node;
+
+
+      if (!hb_string_equals(old_html_text_node->content, new_html_text_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+    } break;
+
+    case AST_HTML_COMMENT_NODE: {
+      const AST_HTML_COMMENT_NODE_T* old_html_comment_node = (const AST_HTML_COMMENT_NODE_T*) old_node;
+      const AST_HTML_COMMENT_NODE_T* new_html_comment_node = (const AST_HTML_COMMENT_NODE_T*) new_node;
+
+
+
+      diff_children_nullable(old_html_comment_node->children, new_html_comment_node->children, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_HTML_DOCTYPE_NODE: {
+      const AST_HTML_DOCTYPE_NODE_T* old_html_doctype_node = (const AST_HTML_DOCTYPE_NODE_T*) old_node;
+      const AST_HTML_DOCTYPE_NODE_T* new_html_doctype_node = (const AST_HTML_DOCTYPE_NODE_T*) new_node;
+
+      if (!tokens_equal(old_html_doctype_node->tag_opening, new_html_doctype_node->tag_opening)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_html_doctype_node->children, new_html_doctype_node->children, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_XML_DECLARATION_NODE: {
+      const AST_XML_DECLARATION_NODE_T* old_xml_declaration_node = (const AST_XML_DECLARATION_NODE_T*) old_node;
+      const AST_XML_DECLARATION_NODE_T* new_xml_declaration_node = (const AST_XML_DECLARATION_NODE_T*) new_node;
+
+      if (!tokens_equal(old_xml_declaration_node->tag_opening, new_xml_declaration_node->tag_opening)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_xml_declaration_node->children, new_xml_declaration_node->children, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_CDATA_NODE: {
+      const AST_CDATA_NODE_T* old_cdata_node = (const AST_CDATA_NODE_T*) old_node;
+      const AST_CDATA_NODE_T* new_cdata_node = (const AST_CDATA_NODE_T*) new_node;
+
+      if (!tokens_equal(old_cdata_node->tag_opening, new_cdata_node->tag_opening)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_cdata_node->children, new_cdata_node->children, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_WHITESPACE_NODE: {
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_REPLACED, path, old_node, new_node, 0, 0);
+    } break;
+
+    case AST_ERB_CONTENT_NODE: {
+      const AST_ERB_CONTENT_NODE_T* old_erb_content_node = (const AST_ERB_CONTENT_NODE_T*) old_node;
+      const AST_ERB_CONTENT_NODE_T* new_erb_content_node = (const AST_ERB_CONTENT_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_content_node->tag_opening, new_erb_content_node->tag_opening)
+          || !tokens_equal(old_erb_content_node->content, new_erb_content_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+
+    } break;
+
+    case AST_ERB_END_NODE: {
+      const AST_ERB_END_NODE_T* old_erb_end_node = (const AST_ERB_END_NODE_T*) old_node;
+      const AST_ERB_END_NODE_T* new_erb_end_node = (const AST_ERB_END_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_end_node->tag_opening, new_erb_end_node->tag_opening)
+          || !tokens_equal(old_erb_end_node->content, new_erb_end_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+
+    } break;
+
+    case AST_ERB_ELSE_NODE: {
+      const AST_ERB_ELSE_NODE_T* old_erb_else_node = (const AST_ERB_ELSE_NODE_T*) old_node;
+      const AST_ERB_ELSE_NODE_T* new_erb_else_node = (const AST_ERB_ELSE_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_else_node->tag_opening, new_erb_else_node->tag_opening)
+          || !tokens_equal(old_erb_else_node->content, new_erb_else_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_else_node->statements, new_erb_else_node->statements, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_ERB_IF_NODE: {
+      const AST_ERB_IF_NODE_T* old_erb_if_node = (const AST_ERB_IF_NODE_T*) old_node;
+      const AST_ERB_IF_NODE_T* new_erb_if_node = (const AST_ERB_IF_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_if_node->tag_opening, new_erb_if_node->tag_opening)
+          || !tokens_equal(old_erb_if_node->content, new_erb_if_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_if_node->statements, new_erb_if_node->statements, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_if_node->subsequent, (const AST_NODE_T*) new_erb_if_node->subsequent, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_if_node->end_node, (const AST_NODE_T*) new_erb_if_node->end_node, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_ERB_BLOCK_NODE: {
+      const AST_ERB_BLOCK_NODE_T* old_erb_block_node = (const AST_ERB_BLOCK_NODE_T*) old_node;
+      const AST_ERB_BLOCK_NODE_T* new_erb_block_node = (const AST_ERB_BLOCK_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_block_node->tag_opening, new_erb_block_node->tag_opening)
+          || !tokens_equal(old_erb_block_node->content, new_erb_block_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_block_node->body, new_erb_block_node->body, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_block_node->block_arguments, new_erb_block_node->block_arguments, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_block_node->rescue_clause, (const AST_NODE_T*) new_erb_block_node->rescue_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_block_node->else_clause, (const AST_NODE_T*) new_erb_block_node->else_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_block_node->ensure_clause, (const AST_NODE_T*) new_erb_block_node->ensure_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_block_node->end_node, (const AST_NODE_T*) new_erb_block_node->end_node, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_ERB_WHEN_NODE: {
+      const AST_ERB_WHEN_NODE_T* old_erb_when_node = (const AST_ERB_WHEN_NODE_T*) old_node;
+      const AST_ERB_WHEN_NODE_T* new_erb_when_node = (const AST_ERB_WHEN_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_when_node->tag_opening, new_erb_when_node->tag_opening)
+          || !tokens_equal(old_erb_when_node->content, new_erb_when_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_when_node->statements, new_erb_when_node->statements, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_ERB_CASE_NODE: {
+      const AST_ERB_CASE_NODE_T* old_erb_case_node = (const AST_ERB_CASE_NODE_T*) old_node;
+      const AST_ERB_CASE_NODE_T* new_erb_case_node = (const AST_ERB_CASE_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_case_node->tag_opening, new_erb_case_node->tag_opening)
+          || !tokens_equal(old_erb_case_node->content, new_erb_case_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_case_node->children, new_erb_case_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_case_node->conditions, new_erb_case_node->conditions, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_case_node->else_clause, (const AST_NODE_T*) new_erb_case_node->else_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_case_node->end_node, (const AST_NODE_T*) new_erb_case_node->end_node, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_ERB_CASE_MATCH_NODE: {
+      const AST_ERB_CASE_MATCH_NODE_T* old_erb_case_match_node = (const AST_ERB_CASE_MATCH_NODE_T*) old_node;
+      const AST_ERB_CASE_MATCH_NODE_T* new_erb_case_match_node = (const AST_ERB_CASE_MATCH_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_case_match_node->tag_opening, new_erb_case_match_node->tag_opening)
+          || !tokens_equal(old_erb_case_match_node->content, new_erb_case_match_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_case_match_node->children, new_erb_case_match_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_case_match_node->conditions, new_erb_case_match_node->conditions, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_case_match_node->else_clause, (const AST_NODE_T*) new_erb_case_match_node->else_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_case_match_node->end_node, (const AST_NODE_T*) new_erb_case_match_node->end_node, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_ERB_WHILE_NODE: {
+      const AST_ERB_WHILE_NODE_T* old_erb_while_node = (const AST_ERB_WHILE_NODE_T*) old_node;
+      const AST_ERB_WHILE_NODE_T* new_erb_while_node = (const AST_ERB_WHILE_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_while_node->tag_opening, new_erb_while_node->tag_opening)
+          || !tokens_equal(old_erb_while_node->content, new_erb_while_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_while_node->statements, new_erb_while_node->statements, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_while_node->end_node, (const AST_NODE_T*) new_erb_while_node->end_node, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_ERB_UNTIL_NODE: {
+      const AST_ERB_UNTIL_NODE_T* old_erb_until_node = (const AST_ERB_UNTIL_NODE_T*) old_node;
+      const AST_ERB_UNTIL_NODE_T* new_erb_until_node = (const AST_ERB_UNTIL_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_until_node->tag_opening, new_erb_until_node->tag_opening)
+          || !tokens_equal(old_erb_until_node->content, new_erb_until_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_until_node->statements, new_erb_until_node->statements, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_until_node->end_node, (const AST_NODE_T*) new_erb_until_node->end_node, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_ERB_FOR_NODE: {
+      const AST_ERB_FOR_NODE_T* old_erb_for_node = (const AST_ERB_FOR_NODE_T*) old_node;
+      const AST_ERB_FOR_NODE_T* new_erb_for_node = (const AST_ERB_FOR_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_for_node->tag_opening, new_erb_for_node->tag_opening)
+          || !tokens_equal(old_erb_for_node->content, new_erb_for_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_for_node->statements, new_erb_for_node->statements, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_for_node->end_node, (const AST_NODE_T*) new_erb_for_node->end_node, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_ERB_RESCUE_NODE: {
+      const AST_ERB_RESCUE_NODE_T* old_erb_rescue_node = (const AST_ERB_RESCUE_NODE_T*) old_node;
+      const AST_ERB_RESCUE_NODE_T* new_erb_rescue_node = (const AST_ERB_RESCUE_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_rescue_node->tag_opening, new_erb_rescue_node->tag_opening)
+          || !tokens_equal(old_erb_rescue_node->content, new_erb_rescue_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_rescue_node->statements, new_erb_rescue_node->statements, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_rescue_node->subsequent, (const AST_NODE_T*) new_erb_rescue_node->subsequent, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_ERB_ENSURE_NODE: {
+      const AST_ERB_ENSURE_NODE_T* old_erb_ensure_node = (const AST_ERB_ENSURE_NODE_T*) old_node;
+      const AST_ERB_ENSURE_NODE_T* new_erb_ensure_node = (const AST_ERB_ENSURE_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_ensure_node->tag_opening, new_erb_ensure_node->tag_opening)
+          || !tokens_equal(old_erb_ensure_node->content, new_erb_ensure_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_ensure_node->statements, new_erb_ensure_node->statements, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_ERB_BEGIN_NODE: {
+      const AST_ERB_BEGIN_NODE_T* old_erb_begin_node = (const AST_ERB_BEGIN_NODE_T*) old_node;
+      const AST_ERB_BEGIN_NODE_T* new_erb_begin_node = (const AST_ERB_BEGIN_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_begin_node->tag_opening, new_erb_begin_node->tag_opening)
+          || !tokens_equal(old_erb_begin_node->content, new_erb_begin_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_begin_node->statements, new_erb_begin_node->statements, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->rescue_clause, (const AST_NODE_T*) new_erb_begin_node->rescue_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->else_clause, (const AST_NODE_T*) new_erb_begin_node->else_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->ensure_clause, (const AST_NODE_T*) new_erb_begin_node->ensure_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->end_node, (const AST_NODE_T*) new_erb_begin_node->end_node, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_ERB_UNLESS_NODE: {
+      const AST_ERB_UNLESS_NODE_T* old_erb_unless_node = (const AST_ERB_UNLESS_NODE_T*) old_node;
+      const AST_ERB_UNLESS_NODE_T* new_erb_unless_node = (const AST_ERB_UNLESS_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_unless_node->tag_opening, new_erb_unless_node->tag_opening)
+          || !tokens_equal(old_erb_unless_node->content, new_erb_unless_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_unless_node->statements, new_erb_unless_node->statements, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_unless_node->else_clause, (const AST_NODE_T*) new_erb_unless_node->else_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_unless_node->end_node, (const AST_NODE_T*) new_erb_unless_node->end_node, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_RUBY_RENDER_LOCAL_NODE: {
+      const AST_RUBY_RENDER_LOCAL_NODE_T* old_ruby_render_local_node = (const AST_RUBY_RENDER_LOCAL_NODE_T*) old_node;
+      const AST_RUBY_RENDER_LOCAL_NODE_T* new_ruby_render_local_node = (const AST_RUBY_RENDER_LOCAL_NODE_T*) new_node;
+
+
+
+
+      herb_diff_node((const AST_NODE_T*) old_ruby_render_local_node->value, (const AST_NODE_T*) new_ruby_render_local_node->value, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_RUBY_RENDER_KEYWORDS_NODE: {
+      const AST_RUBY_RENDER_KEYWORDS_NODE_T* old_ruby_render_keywords_node = (const AST_RUBY_RENDER_KEYWORDS_NODE_T*) old_node;
+      const AST_RUBY_RENDER_KEYWORDS_NODE_T* new_ruby_render_keywords_node = (const AST_RUBY_RENDER_KEYWORDS_NODE_T*) new_node;
+
+
+
+      diff_children_nullable(old_ruby_render_keywords_node->locals, new_ruby_render_keywords_node->locals, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_ERB_RENDER_NODE: {
+      const AST_ERB_RENDER_NODE_T* old_erb_render_node = (const AST_ERB_RENDER_NODE_T*) old_node;
+      const AST_ERB_RENDER_NODE_T* new_erb_render_node = (const AST_ERB_RENDER_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_render_node->tag_opening, new_erb_render_node->tag_opening)
+          || !tokens_equal(old_erb_render_node->content, new_erb_render_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_render_node->body, new_erb_render_node->body, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_render_node->block_arguments, new_erb_render_node->block_arguments, path, old_hashes, new_hashes, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_render_node->keywords, (const AST_NODE_T*) new_erb_render_node->keywords, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_render_node->rescue_clause, (const AST_NODE_T*) new_erb_render_node->rescue_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_render_node->else_clause, (const AST_NODE_T*) new_erb_render_node->else_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_render_node->ensure_clause, (const AST_NODE_T*) new_erb_render_node->ensure_clause, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_render_node->end_node, (const AST_NODE_T*) new_erb_render_node->end_node, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_RUBY_PARAMETER_NODE: {
+      const AST_RUBY_PARAMETER_NODE_T* old_ruby_parameter_node = (const AST_RUBY_PARAMETER_NODE_T*) old_node;
+      const AST_RUBY_PARAMETER_NODE_T* new_ruby_parameter_node = (const AST_RUBY_PARAMETER_NODE_T*) new_node;
+
+
+      if (!hb_string_equals(old_ruby_parameter_node->kind, new_ruby_parameter_node->kind)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      herb_diff_node((const AST_NODE_T*) old_ruby_parameter_node->default_value, (const AST_NODE_T*) new_ruby_parameter_node->default_value, path, old_hashes, new_hashes, result);
+    } break;
+
+    case AST_ERB_STRICT_LOCALS_NODE: {
+      const AST_ERB_STRICT_LOCALS_NODE_T* old_erb_strict_locals_node = (const AST_ERB_STRICT_LOCALS_NODE_T*) old_node;
+      const AST_ERB_STRICT_LOCALS_NODE_T* new_erb_strict_locals_node = (const AST_ERB_STRICT_LOCALS_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_strict_locals_node->tag_opening, new_erb_strict_locals_node->tag_opening)
+          || !tokens_equal(old_erb_strict_locals_node->content, new_erb_strict_locals_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_strict_locals_node->locals, new_erb_strict_locals_node->locals, path, old_hashes, new_hashes, result);
+
+    } break;
+
+    case AST_ERB_YIELD_NODE: {
+      const AST_ERB_YIELD_NODE_T* old_erb_yield_node = (const AST_ERB_YIELD_NODE_T*) old_node;
+      const AST_ERB_YIELD_NODE_T* new_erb_yield_node = (const AST_ERB_YIELD_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_yield_node->tag_opening, new_erb_yield_node->tag_opening)
+          || !tokens_equal(old_erb_yield_node->content, new_erb_yield_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+
+    } break;
+
+    case AST_ERB_IN_NODE: {
+      const AST_ERB_IN_NODE_T* old_erb_in_node = (const AST_ERB_IN_NODE_T*) old_node;
+      const AST_ERB_IN_NODE_T* new_erb_in_node = (const AST_ERB_IN_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_in_node->tag_opening, new_erb_in_node->tag_opening)
+          || !tokens_equal(old_erb_in_node->content, new_erb_in_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_in_node->statements, new_erb_in_node->statements, path, old_hashes, new_hashes, result);
+
+    } break;
+
+  }
+}