herb 0.9.7-arm-linux-gnu → 0.10.1-arm-linux-gnu

data/src/diff/herb_hash_tree.c

@@ -0,0 +1,680 @@
+// 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_hash_tree.c.erb
+
+// Merkle tree hashing: each node's hash incorporates the hashes of its children,
+// enabling O(1) subtree equality checks during tree diffing.
+// Based on: Merkle, R. "A Digital Signature Based on a Conventional Encryption
+// Function" (1987), Advances in Cryptology - CRYPTO '87.
+// https://en.wikipedia.org/wiki/Merkle_tree
+
+#include "../include/diff/herb_diff.h"
+
+static herb_hash_T hash_token(herb_hash_T hash, const token_T* token) {
+  if (token == NULL) { return herb_hash_byte(hash, 0); }
+
+  hash = herb_hash_uint32(hash, (uint32_t) token->type);
+  hash = herb_hash_string(hash, token->value);
+
+  return hash;
+}
+
+static herb_hash_T hash_child_array(herb_hash_T hash, const hb_array_T* children, herb_hash_map_T* hash_map) {
+  if (children == NULL) { return herb_hash_byte(hash, 0); }
+
+  const size_t count = hb_array_size(children);
+  hash = herb_hash_uint64(hash, (uint64_t) count);
+
+  for (size_t index = 0; index < count; index++) {
+    const AST_NODE_T* child = (const AST_NODE_T*) hb_array_get(children, index);
+    herb_hash_T child_hash = herb_hash_tree(child, hash_map);
+    hash = herb_hash_combine(hash, child_hash);
+  }
+
+  return hash;
+}
+
+herb_hash_T herb_hash_tree(const AST_NODE_T* node, herb_hash_map_T* hash_map) {
+  if (node == NULL) { return HERB_HASH_INIT; }
+
+  if (herb_hash_map_has(hash_map, node)) { return herb_hash_map_get(hash_map, node); }
+
+  herb_hash_T hash = HERB_HASH_INIT;
+  hash = herb_hash_uint32(hash, (uint32_t) node->type);
+
+  switch (node->type) {
+    case AST_DOCUMENT_NODE: {
+      const AST_DOCUMENT_NODE_T* document_node = (const AST_DOCUMENT_NODE_T*) node;
+
+      hash = hash_child_array(hash, document_node->children, hash_map);
+    } break;
+
+    case AST_LITERAL_NODE: {
+      const AST_LITERAL_NODE_T* literal_node = (const AST_LITERAL_NODE_T*) node;
+
+      hash = herb_hash_string(hash, literal_node->content);
+    } break;
+
+    case AST_HTML_OPEN_TAG_NODE: {
+      const AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = (const AST_HTML_OPEN_TAG_NODE_T*) node;
+
+      hash = hash_token(hash, html_open_tag_node->tag_opening);
+
+      hash = hash_token(hash, html_open_tag_node->tag_name);
+
+      hash = hash_token(hash, html_open_tag_node->tag_closing);
+
+      hash = hash_child_array(hash, html_open_tag_node->children, hash_map);
+
+      hash = herb_hash_bool(hash, html_open_tag_node->is_void);
+    } break;
+
+    case AST_HTML_CONDITIONAL_OPEN_TAG_NODE: {
+      const AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T* html_conditional_open_tag_node = (const AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T*) node;
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) html_conditional_open_tag_node->conditional, hash_map));
+
+      hash = hash_token(hash, html_conditional_open_tag_node->tag_name);
+
+      hash = herb_hash_bool(hash, html_conditional_open_tag_node->is_void);
+    } break;
+
+    case AST_HTML_CLOSE_TAG_NODE: {
+      const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = (const AST_HTML_CLOSE_TAG_NODE_T*) node;
+
+      hash = hash_token(hash, html_close_tag_node->tag_opening);
+
+      hash = hash_token(hash, html_close_tag_node->tag_name);
+
+      hash = hash_child_array(hash, html_close_tag_node->children, hash_map);
+
+      hash = hash_token(hash, html_close_tag_node->tag_closing);
+    } break;
+
+    case AST_HTML_OMITTED_CLOSE_TAG_NODE: {
+      const AST_HTML_OMITTED_CLOSE_TAG_NODE_T* html_omitted_close_tag_node = (const AST_HTML_OMITTED_CLOSE_TAG_NODE_T*) node;
+
+      hash = hash_token(hash, html_omitted_close_tag_node->tag_name);
+    } break;
+
+    case AST_HTML_VIRTUAL_CLOSE_TAG_NODE: {
+      const AST_HTML_VIRTUAL_CLOSE_TAG_NODE_T* html_virtual_close_tag_node = (const AST_HTML_VIRTUAL_CLOSE_TAG_NODE_T*) node;
+
+      hash = hash_token(hash, html_virtual_close_tag_node->tag_name);
+    } break;
+
+    case AST_HTML_ELEMENT_NODE: {
+      const AST_HTML_ELEMENT_NODE_T* html_element_node = (const AST_HTML_ELEMENT_NODE_T*) node;
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) html_element_node->open_tag, hash_map));
+
+      hash = hash_token(hash, html_element_node->tag_name);
+
+      hash = hash_child_array(hash, html_element_node->body, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) html_element_node->close_tag, hash_map));
+
+      hash = herb_hash_bool(hash, html_element_node->is_void);
+
+      hash = herb_hash_string(hash, html_element_node->element_source);
+    } break;
+
+    case AST_HTML_CONDITIONAL_ELEMENT_NODE: {
+      const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* html_conditional_element_node = (const AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) node;
+
+      hash = herb_hash_string(hash, html_conditional_element_node->condition);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) html_conditional_element_node->open_conditional, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) html_conditional_element_node->open_tag, hash_map));
+
+      hash = hash_child_array(hash, html_conditional_element_node->body, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) html_conditional_element_node->close_tag, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) html_conditional_element_node->close_conditional, hash_map));
+
+      hash = hash_token(hash, html_conditional_element_node->tag_name);
+
+      hash = herb_hash_string(hash, html_conditional_element_node->element_source);
+    } break;
+
+    case AST_HTML_ATTRIBUTE_VALUE_NODE: {
+      const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = (const AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
+
+      hash = hash_token(hash, html_attribute_value_node->open_quote);
+
+      hash = hash_child_array(hash, html_attribute_value_node->children, hash_map);
+
+      hash = hash_token(hash, html_attribute_value_node->close_quote);
+
+      hash = herb_hash_bool(hash, html_attribute_value_node->quoted);
+    } break;
+
+    case AST_HTML_ATTRIBUTE_NAME_NODE: {
+      const AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = (const AST_HTML_ATTRIBUTE_NAME_NODE_T*) node;
+
+      hash = hash_child_array(hash, html_attribute_name_node->children, hash_map);
+    } break;
+
+    case AST_HTML_ATTRIBUTE_NODE: {
+      const AST_HTML_ATTRIBUTE_NODE_T* html_attribute_node = (const AST_HTML_ATTRIBUTE_NODE_T*) node;
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) html_attribute_node->name, hash_map));
+
+      hash = hash_token(hash, html_attribute_node->equals);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) html_attribute_node->value, hash_map));
+    } break;
+
+    case AST_RUBY_LITERAL_NODE: {
+      const AST_RUBY_LITERAL_NODE_T* ruby_literal_node = (const AST_RUBY_LITERAL_NODE_T*) node;
+
+      hash = herb_hash_string(hash, ruby_literal_node->content);
+    } break;
+
+    case AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE: {
+      const AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE_T* ruby_html_attributes_splat_node = (const AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE_T*) node;
+
+      hash = herb_hash_string(hash, ruby_html_attributes_splat_node->content);
+
+      hash = herb_hash_string(hash, ruby_html_attributes_splat_node->prefix);
+    } break;
+
+    case AST_ERB_OPEN_TAG_NODE: {
+      const AST_ERB_OPEN_TAG_NODE_T* erb_open_tag_node = (const AST_ERB_OPEN_TAG_NODE_T*) node;
+
+      hash = hash_token(hash, erb_open_tag_node->tag_opening);
+
+      hash = hash_token(hash, erb_open_tag_node->content);
+
+      hash = hash_token(hash, erb_open_tag_node->tag_closing);
+
+      hash = hash_token(hash, erb_open_tag_node->tag_name);
+
+      hash = hash_child_array(hash, erb_open_tag_node->children, hash_map);
+    } break;
+
+    case AST_HTML_TEXT_NODE: {
+      const AST_HTML_TEXT_NODE_T* html_text_node = (const AST_HTML_TEXT_NODE_T*) node;
+
+      hash = herb_hash_string(hash, html_text_node->content);
+    } break;
+
+    case AST_HTML_COMMENT_NODE: {
+      const AST_HTML_COMMENT_NODE_T* html_comment_node = (const AST_HTML_COMMENT_NODE_T*) node;
+
+      hash = hash_token(hash, html_comment_node->comment_start);
+
+      hash = hash_child_array(hash, html_comment_node->children, hash_map);
+
+      hash = hash_token(hash, html_comment_node->comment_end);
+    } break;
+
+    case AST_HTML_DOCTYPE_NODE: {
+      const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = (const AST_HTML_DOCTYPE_NODE_T*) node;
+
+      hash = hash_token(hash, html_doctype_node->tag_opening);
+
+      hash = hash_child_array(hash, html_doctype_node->children, hash_map);
+
+      hash = hash_token(hash, html_doctype_node->tag_closing);
+    } break;
+
+    case AST_XML_DECLARATION_NODE: {
+      const AST_XML_DECLARATION_NODE_T* xml_declaration_node = (const AST_XML_DECLARATION_NODE_T*) node;
+
+      hash = hash_token(hash, xml_declaration_node->tag_opening);
+
+      hash = hash_child_array(hash, xml_declaration_node->children, hash_map);
+
+      hash = hash_token(hash, xml_declaration_node->tag_closing);
+    } break;
+
+    case AST_CDATA_NODE: {
+      const AST_CDATA_NODE_T* cdata_node = (const AST_CDATA_NODE_T*) node;
+
+      hash = hash_token(hash, cdata_node->tag_opening);
+
+      hash = hash_child_array(hash, cdata_node->children, hash_map);
+
+      hash = hash_token(hash, cdata_node->tag_closing);
+    } break;
+
+    case AST_WHITESPACE_NODE: {
+      const AST_WHITESPACE_NODE_T* whitespace_node = (const AST_WHITESPACE_NODE_T*) node;
+
+      hash = hash_token(hash, whitespace_node->value);
+    } break;
+
+    case AST_ERB_CONTENT_NODE: {
+      const AST_ERB_CONTENT_NODE_T* erb_content_node = (const AST_ERB_CONTENT_NODE_T*) node;
+
+      hash = hash_token(hash, erb_content_node->tag_opening);
+
+      hash = hash_token(hash, erb_content_node->content);
+
+      hash = hash_token(hash, erb_content_node->tag_closing);
+
+      hash = herb_hash_bool(hash, erb_content_node->parsed);
+
+      hash = herb_hash_bool(hash, erb_content_node->valid);
+    } break;
+
+    case AST_ERB_END_NODE: {
+      const AST_ERB_END_NODE_T* erb_end_node = (const AST_ERB_END_NODE_T*) node;
+
+      hash = hash_token(hash, erb_end_node->tag_opening);
+
+      hash = hash_token(hash, erb_end_node->content);
+
+      hash = hash_token(hash, erb_end_node->tag_closing);
+    } break;
+
+    case AST_ERB_ELSE_NODE: {
+      const AST_ERB_ELSE_NODE_T* erb_else_node = (const AST_ERB_ELSE_NODE_T*) node;
+
+      hash = hash_token(hash, erb_else_node->tag_opening);
+
+      hash = hash_token(hash, erb_else_node->content);
+
+      hash = hash_token(hash, erb_else_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_else_node->statements, hash_map);
+    } break;
+
+    case AST_ERB_IF_NODE: {
+      const AST_ERB_IF_NODE_T* erb_if_node = (const AST_ERB_IF_NODE_T*) node;
+
+      hash = hash_token(hash, erb_if_node->tag_opening);
+
+      hash = hash_token(hash, erb_if_node->content);
+
+      hash = hash_token(hash, erb_if_node->tag_closing);
+
+      // skip location field: then_keyword
+
+      hash = hash_child_array(hash, erb_if_node->statements, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_if_node->subsequent, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_if_node->end_node, hash_map));
+    } break;
+
+    case AST_ERB_BLOCK_NODE: {
+      const AST_ERB_BLOCK_NODE_T* erb_block_node = (const AST_ERB_BLOCK_NODE_T*) node;
+
+      hash = hash_token(hash, erb_block_node->tag_opening);
+
+      hash = hash_token(hash, erb_block_node->content);
+
+      hash = hash_token(hash, erb_block_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_block_node->body, hash_map);
+
+      hash = hash_child_array(hash, erb_block_node->block_arguments, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_block_node->rescue_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_block_node->else_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_block_node->ensure_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_block_node->end_node, hash_map));
+    } break;
+
+    case AST_ERB_WHEN_NODE: {
+      const AST_ERB_WHEN_NODE_T* erb_when_node = (const AST_ERB_WHEN_NODE_T*) node;
+
+      hash = hash_token(hash, erb_when_node->tag_opening);
+
+      hash = hash_token(hash, erb_when_node->content);
+
+      hash = hash_token(hash, erb_when_node->tag_closing);
+
+      // skip location field: then_keyword
+
+      hash = hash_child_array(hash, erb_when_node->statements, hash_map);
+    } break;
+
+    case AST_ERB_CASE_NODE: {
+      const AST_ERB_CASE_NODE_T* erb_case_node = (const AST_ERB_CASE_NODE_T*) node;
+
+      hash = hash_token(hash, erb_case_node->tag_opening);
+
+      hash = hash_token(hash, erb_case_node->content);
+
+      hash = hash_token(hash, erb_case_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_case_node->children, hash_map);
+
+      hash = hash_child_array(hash, erb_case_node->conditions, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_case_node->else_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_case_node->end_node, hash_map));
+    } break;
+
+    case AST_ERB_CASE_MATCH_NODE: {
+      const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (const AST_ERB_CASE_MATCH_NODE_T*) node;
+
+      hash = hash_token(hash, erb_case_match_node->tag_opening);
+
+      hash = hash_token(hash, erb_case_match_node->content);
+
+      hash = hash_token(hash, erb_case_match_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_case_match_node->children, hash_map);
+
+      hash = hash_child_array(hash, erb_case_match_node->conditions, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_case_match_node->else_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_case_match_node->end_node, hash_map));
+    } break;
+
+    case AST_ERB_WHILE_NODE: {
+      const AST_ERB_WHILE_NODE_T* erb_while_node = (const AST_ERB_WHILE_NODE_T*) node;
+
+      hash = hash_token(hash, erb_while_node->tag_opening);
+
+      hash = hash_token(hash, erb_while_node->content);
+
+      hash = hash_token(hash, erb_while_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_while_node->statements, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_while_node->end_node, hash_map));
+    } break;
+
+    case AST_ERB_UNTIL_NODE: {
+      const AST_ERB_UNTIL_NODE_T* erb_until_node = (const AST_ERB_UNTIL_NODE_T*) node;
+
+      hash = hash_token(hash, erb_until_node->tag_opening);
+
+      hash = hash_token(hash, erb_until_node->content);
+
+      hash = hash_token(hash, erb_until_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_until_node->statements, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_until_node->end_node, hash_map));
+    } break;
+
+    case AST_ERB_FOR_NODE: {
+      const AST_ERB_FOR_NODE_T* erb_for_node = (const AST_ERB_FOR_NODE_T*) node;
+
+      hash = hash_token(hash, erb_for_node->tag_opening);
+
+      hash = hash_token(hash, erb_for_node->content);
+
+      hash = hash_token(hash, erb_for_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_for_node->statements, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_for_node->end_node, hash_map));
+    } break;
+
+    case AST_ERB_RESCUE_NODE: {
+      const AST_ERB_RESCUE_NODE_T* erb_rescue_node = (const AST_ERB_RESCUE_NODE_T*) node;
+
+      hash = hash_token(hash, erb_rescue_node->tag_opening);
+
+      hash = hash_token(hash, erb_rescue_node->content);
+
+      hash = hash_token(hash, erb_rescue_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_rescue_node->statements, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_rescue_node->subsequent, hash_map));
+    } break;
+
+    case AST_ERB_ENSURE_NODE: {
+      const AST_ERB_ENSURE_NODE_T* erb_ensure_node = (const AST_ERB_ENSURE_NODE_T*) node;
+
+      hash = hash_token(hash, erb_ensure_node->tag_opening);
+
+      hash = hash_token(hash, erb_ensure_node->content);
+
+      hash = hash_token(hash, erb_ensure_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_ensure_node->statements, hash_map);
+    } break;
+
+    case AST_ERB_BEGIN_NODE: {
+      const AST_ERB_BEGIN_NODE_T* erb_begin_node = (const AST_ERB_BEGIN_NODE_T*) node;
+
+      hash = hash_token(hash, erb_begin_node->tag_opening);
+
+      hash = hash_token(hash, erb_begin_node->content);
+
+      hash = hash_token(hash, erb_begin_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_begin_node->statements, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_begin_node->rescue_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_begin_node->else_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_begin_node->ensure_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_begin_node->end_node, hash_map));
+    } break;
+
+    case AST_ERB_UNLESS_NODE: {
+      const AST_ERB_UNLESS_NODE_T* erb_unless_node = (const AST_ERB_UNLESS_NODE_T*) node;
+
+      hash = hash_token(hash, erb_unless_node->tag_opening);
+
+      hash = hash_token(hash, erb_unless_node->content);
+
+      hash = hash_token(hash, erb_unless_node->tag_closing);
+
+      // skip location field: then_keyword
+
+      hash = hash_child_array(hash, erb_unless_node->statements, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_unless_node->else_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_unless_node->end_node, hash_map));
+    } break;
+
+    case AST_RUBY_RENDER_LOCAL_NODE: {
+      const AST_RUBY_RENDER_LOCAL_NODE_T* ruby_render_local_node = (const AST_RUBY_RENDER_LOCAL_NODE_T*) node;
+
+      hash = hash_token(hash, ruby_render_local_node->name);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) ruby_render_local_node->value, hash_map));
+    } break;
+
+    case AST_RUBY_RENDER_KEYWORDS_NODE: {
+      const AST_RUBY_RENDER_KEYWORDS_NODE_T* ruby_render_keywords_node = (const AST_RUBY_RENDER_KEYWORDS_NODE_T*) node;
+
+      hash = hash_token(hash, ruby_render_keywords_node->partial);
+
+      hash = hash_token(hash, ruby_render_keywords_node->template_path);
+
+      hash = hash_token(hash, ruby_render_keywords_node->layout);
+
+      hash = hash_token(hash, ruby_render_keywords_node->file);
+
+      hash = hash_token(hash, ruby_render_keywords_node->inline_template);
+
+      hash = hash_token(hash, ruby_render_keywords_node->body);
+
+      hash = hash_token(hash, ruby_render_keywords_node->plain);
+
+      hash = hash_token(hash, ruby_render_keywords_node->html);
+
+      hash = hash_token(hash, ruby_render_keywords_node->renderable);
+
+      hash = hash_token(hash, ruby_render_keywords_node->collection);
+
+      hash = hash_token(hash, ruby_render_keywords_node->object);
+
+      hash = hash_token(hash, ruby_render_keywords_node->as_name);
+
+      hash = hash_token(hash, ruby_render_keywords_node->spacer_template);
+
+      hash = hash_token(hash, ruby_render_keywords_node->formats);
+
+      hash = hash_token(hash, ruby_render_keywords_node->variants);
+
+      hash = hash_token(hash, ruby_render_keywords_node->handlers);
+
+      hash = hash_token(hash, ruby_render_keywords_node->content_type);
+
+      hash = hash_child_array(hash, ruby_render_keywords_node->locals, hash_map);
+    } break;
+
+    case AST_ERB_RENDER_NODE: {
+      const AST_ERB_RENDER_NODE_T* erb_render_node = (const AST_ERB_RENDER_NODE_T*) node;
+
+      hash = hash_token(hash, erb_render_node->tag_opening);
+
+      hash = hash_token(hash, erb_render_node->content);
+
+      hash = hash_token(hash, erb_render_node->tag_closing);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_render_node->keywords, hash_map));
+
+      hash = hash_child_array(hash, erb_render_node->body, hash_map);
+
+      hash = hash_child_array(hash, erb_render_node->block_arguments, hash_map);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_render_node->rescue_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_render_node->else_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_render_node->ensure_clause, hash_map));
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) erb_render_node->end_node, hash_map));
+    } break;
+
+    case AST_RUBY_PARAMETER_NODE: {
+      const AST_RUBY_PARAMETER_NODE_T* ruby_parameter_node = (const AST_RUBY_PARAMETER_NODE_T*) node;
+
+      hash = hash_token(hash, ruby_parameter_node->name);
+
+      hash = herb_hash_combine(hash, herb_hash_tree((const AST_NODE_T*) ruby_parameter_node->default_value, hash_map));
+
+      hash = herb_hash_string(hash, ruby_parameter_node->kind);
+
+      hash = herb_hash_bool(hash, ruby_parameter_node->required);
+    } break;
+
+    case AST_ERB_STRICT_LOCALS_NODE: {
+      const AST_ERB_STRICT_LOCALS_NODE_T* erb_strict_locals_node = (const AST_ERB_STRICT_LOCALS_NODE_T*) node;
+
+      hash = hash_token(hash, erb_strict_locals_node->tag_opening);
+
+      hash = hash_token(hash, erb_strict_locals_node->content);
+
+      hash = hash_token(hash, erb_strict_locals_node->tag_closing);
+
+      hash = hash_child_array(hash, erb_strict_locals_node->locals, hash_map);
+    } break;
+
+    case AST_ERB_YIELD_NODE: {
+      const AST_ERB_YIELD_NODE_T* erb_yield_node = (const AST_ERB_YIELD_NODE_T*) node;
+
+      hash = hash_token(hash, erb_yield_node->tag_opening);
+
+      hash = hash_token(hash, erb_yield_node->content);
+
+      hash = hash_token(hash, erb_yield_node->tag_closing);
+    } break;
+
+    case AST_ERB_IN_NODE: {
+      const AST_ERB_IN_NODE_T* erb_in_node = (const AST_ERB_IN_NODE_T*) node;
+
+      hash = hash_token(hash, erb_in_node->tag_opening);
+
+      hash = hash_token(hash, erb_in_node->content);
+
+      hash = hash_token(hash, erb_in_node->tag_closing);
+
+      // skip location field: then_keyword
+
+      hash = hash_child_array(hash, erb_in_node->statements, hash_map);
+    } break;
+
+  }
+
+  herb_hash_map_set(hash_map, node, hash);
+
+  return hash;
+}
+
+static herb_hash_T identity_hash_attributes(const hb_array_T* attributes, const herb_hash_map_T* hash_map) {
+  if (attributes == NULL) { return HERB_HASH_INIT; }
+
+  const size_t count = hb_array_size(attributes);
+  herb_hash_T combined = HERB_HASH_INIT;
+
+  for (size_t index = 0; index < count; index++) {
+    const AST_NODE_T* attribute = (const AST_NODE_T*) hb_array_get(attributes, index);
+    herb_hash_T attribute_hash = herb_hash_map_get(hash_map, attribute);
+    combined ^= attribute_hash;
+  }
+
+  return combined;
+}
+
+herb_hash_T herb_hash_node_move_identity(const AST_NODE_T* node, const herb_hash_map_T* hash_map) {
+  if (node == NULL) { return HERB_HASH_INIT; }
+
+  herb_hash_T hash = HERB_HASH_INIT;
+  hash = herb_hash_uint32(hash, (uint32_t) node->type);
+
+  switch (node->type) {
+    case AST_HTML_ELEMENT_NODE: {
+      const AST_HTML_ELEMENT_NODE_T* element = (const AST_HTML_ELEMENT_NODE_T*) node;
+      hash = hash_token(hash, element->tag_name);
+
+      if (element->open_tag != NULL) {
+        const AST_HTML_OPEN_TAG_NODE_T* open_tag = (const AST_HTML_OPEN_TAG_NODE_T*) element->open_tag;
+        hash = herb_hash_combine(hash, identity_hash_attributes(open_tag->children, hash_map));
+      }
+    } break;
+
+    case AST_HTML_CONDITIONAL_ELEMENT_NODE: {
+      const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* element = (const AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) node;
+      hash = hash_token(hash, element->tag_name);
+
+      if (element->open_tag != NULL) {
+        hash = herb_hash_combine(hash, identity_hash_attributes(element->open_tag->children, hash_map));
+      }
+    } break;
+
+    default: {
+      hash = herb_hash_map_get(hash_map, node);
+    } break;
+  }
+
+  return hash;
+}
+
+herb_hash_T herb_hash_node_identity(const AST_NODE_T* node, const herb_hash_map_T* hash_map) {
+  if (node == NULL) { return HERB_HASH_INIT; }
+
+  herb_hash_T hash = HERB_HASH_INIT;
+  hash = herb_hash_uint32(hash, (uint32_t) node->type);
+
+  switch (node->type) {
+    case AST_HTML_ELEMENT_NODE: {
+      const AST_HTML_ELEMENT_NODE_T* element = (const AST_HTML_ELEMENT_NODE_T*) node;
+      hash = hash_token(hash, element->tag_name);
+    } break;
+
+    case AST_HTML_CONDITIONAL_ELEMENT_NODE: {
+      const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* element = (const AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) node;
+      hash = hash_token(hash, element->tag_name);
+    } break;
+
+    default: {
+      hash = herb_hash_map_get(hash_map, node);
+    } break;
+  }
+
+  return hash;
+}