herb 0.9.2-arm-linux-gnu → 0.9.4-arm-linux-gnu

data/src/include/util/ruby_util.h

@@ -0,0 +1,9 @@
+#ifndef HERB_RUBY_UTIL_H
+#define HERB_RUBY_UTIL_H
+
+#include "../lib/hb_string.h"
+#include <stdbool.h>
+
+bool is_ruby_introspection_method(hb_string_T method_name);
+
+#endif

data/src/include/{utf8.h → util/utf8.h}

@@ -1,7 +1,7 @@
 #ifndef HERB_UTF8_H
 #define HERB_UTF8_H
 
-#include "util/hb_string.h"
+#include "../lib/hb_string.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>

data/src/include/{util.h → util/util.h}

@@ -1,7 +1,7 @@
 #ifndef HERB_UTIL_H
 #define HERB_UTIL_H
 
-#include "util/hb_string.h"
+#include "../lib/hb_string.h"
 #include <stdbool.h>
 #include <stdlib.h>
 

data/src/include/version.h

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

data/src/include/visitor.h

@@ -1,9 +1,9 @@
 #ifndef HERB_VISITOR_H
 #define HERB_VISITOR_H
 
-#include "ast_node.h"
-#include "ast_nodes.h"
-#include "util/hb_array.h"
+#include "ast/ast_node.h"
+#include "ast/ast_nodes.h"
+#include "lib/hb_array.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data);
 void herb_visit_child_nodes(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T* node, void* data), void* data);

data/src/{lexer_peek_helpers.c → lexer/lexer_peek_helpers.c}

@@ -1,6 +1,6 @@
-#include "include/lexer_peek_helpers.h"
-#include "include/lexer.h"
-#include "include/token.h"
+#include "../include/lexer/lexer_peek_helpers.h"
+#include "../include/lexer/lexer.h"
+#include "../include/lexer/token.h"
 
 #include <ctype.h>
 

data/src/{token.c → lexer/token.c}

@@ -1,11 +1,11 @@
-#include "include/token.h"
-#include "include/position.h"
-#include "include/range.h"
-#include "include/token_struct.h"
-#include "include/util.h"
-#include "include/util/hb_allocator.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/hb_string.h"
+#include "../include/lexer/token.h"
+#include "../include/lexer/token_struct.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_buffer.h"
+#include "../include/lib/hb_string.h"
+#include "../include/location/position.h"
+#include "../include/location/range.h"
+#include "../include/util/util.h"
 
 #include <stdarg.h>
 #include <stdbool.h>

data/src/{token_matchers.c → lexer/token_matchers.c}

@@ -1,5 +1,5 @@
-#include "include/token_matchers.h"
-#include "include/parser.h"
+#include "../include/lexer/token_matchers.h"
+#include "../include/parser/parser.h"
 
 #include <stdarg.h>
 #include <stdbool.h>

data/src/lexer.c

@@ -1,9 +1,9 @@
-#include "include/lexer_peek_helpers.h"
+#include "include/lexer/lexer_peek_helpers.h"
+#include "include/lexer/token.h"
+#include "include/lib/hb_string.h"
 #include "include/macros.h"
-#include "include/token.h"
-#include "include/utf8.h"
-#include "include/util.h"
-#include "include/util/hb_string.h"
+#include "include/util/utf8.h"
+#include "include/util/util.h"
 
 #include <ctype.h>
 #include <stdint.h>
@@ -75,7 +75,7 @@ token_T* lexer_error(lexer_T* lexer, const char* message) {
   size_t length = strlen(buffer);
   char* error_message = hb_allocator_strndup(lexer->allocator, buffer, length);
 
-  return token_init((hb_string_T) { .data = error_message, .length = (uint32_t) length }, TOKEN_ERROR, lexer);
+  return token_init(hb_string_from_data(error_message, length), TOKEN_ERROR, lexer);
 }
 
 static void lexer_advance(lexer_T* lexer) {

data/src/{util → lib}/hb_allocator.c

@@ -1,5 +1,5 @@
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_arena.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_arena.h"
 
 #include <stdio.h>
 #include <stdlib.h>

data/src/{util → lib}/hb_arena.c

@@ -1,4 +1,4 @@
-#include "../include/util/hb_arena.h"
+#include "../include/lib/hb_arena.h"
 #include "../include/macros.h"
 
 #include <assert.h>

data/src/{util → lib}/hb_arena_debug.c

@@ -2,8 +2,8 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "../include/util/hb_arena.h"
-#include "../include/util/hb_arena_debug.h"
+#include "../include/lib/hb_arena.h"
+#include "../include/lib/hb_arena_debug.h"
 
 #define ANSI_COLOR_GREEN "\033[32m"
 #define ANSI_COLOR_YELLOW "\033[33m"

data/src/{util → lib}/hb_array.c

@@ -1,9 +1,9 @@
 #include <stdint.h>
 #include <stdio.h>
 
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_array.h"
 #include "../include/macros.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_array.h"
 
 size_t hb_array_sizeof(void) {
   return sizeof(hb_array_T);

data/src/{util → lib}/hb_buffer.c

@@ -2,9 +2,9 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_buffer.h"
 #include "../include/macros.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_buffer.h"
 
 static bool hb_buffer_has_capacity(hb_buffer_T* buffer, const size_t required_length) {
   return (buffer->length + required_length <= buffer->capacity);

data/src/{util → lib}/hb_narray.c

@@ -1,4 +1,4 @@
-#include "../include/util/hb_narray.h"
+#include "../include/lib/hb_narray.h"
 
 #include <assert.h>
 #include <stdbool.h>

data/src/{util → lib}/hb_string.c

@@ -1,6 +1,6 @@
-#include "../include/util/hb_string.h"
+#include "../include/lib/hb_string.h"
 #include "../include/macros.h"
-#include "../include/util.h"
+#include "../include/util/util.h"
 
 #include <stdlib.h>
 #include <string.h>

data/src/{location.c → location/location.c}

@@ -1,5 +1,5 @@
-#include "include/location.h"
-#include "include/position.h"
+#include "../include/location/location.h"
+#include "../include/location/position.h"
 
 void location_from(
   location_T* location,

data/src/{position.c → location/position.c}

@@ -1,5 +1,5 @@
-#include "include/position.h"
-#include "include/util.h"
+#include "../include/location/position.h"
+#include "../include/util/util.h"
 
 position_T position_from_source_with_offset(const char* source, size_t offset) {
   position_T position = { .line = 1, .column = 0 };

data/src/{range.c → location/range.c}

@@ -1,4 +1,4 @@
-#include "include/range.h"
+#include "../include/location/range.h"
 
 uint32_t range_length(range_T range) {
   return range.to - range.from;

data/src/main.c

@@ -1,23 +1,23 @@
 #define _POSIX_C_SOURCE 199309L // Enables `clock_gettime()`
 
-#include "include/ast_node.h"
-#include "include/ast_nodes.h"
+#include "include/ast/ast_node.h"
+#include "include/ast/ast_nodes.h"
 
 #ifndef HERB_EXCLUDE_PRETTYPRINT
-#  include "include/ast_pretty_print.h"
+#  include "include/ast/ast_pretty_print.h"
 #endif
 
 #include "include/extract.h"
 #include "include/herb.h"
-#include "include/io.h"
-#include "include/lex_helpers.h"
+#include "include/lexer/lex_helpers.h"
+#include "include/lib/hb_allocator.h"
+#include "include/lib/hb_arena.h"
+#include "include/lib/hb_arena_debug.h"
+#include "include/lib/hb_buffer.h"
+#include "include/lib/string.h"
 #include "include/macros.h"
-#include "include/ruby_parser.h"
-#include "include/util/hb_allocator.h"
-#include "include/util/hb_arena.h"
-#include "include/util/hb_arena_debug.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/string.h"
+#include "include/prism/ruby_parser.h"
+#include "include/util/io.h"
 
 #include <stdio.h>
 #include <stdlib.h>

data/src/parser/dot_notation.c

@@ -0,0 +1,100 @@
+#include "../include/parser/dot_notation.h"
+#include "../include/errors.h"
+#include "../include/lexer/lexer.h"
+#include "../include/lexer/token.h"
+#include "../include/parser/parser_helpers.h"
+
+#include <ctype.h>
+
+static bool token_is_dot(token_T* token) {
+  return token->type == TOKEN_CHARACTER && token->value.length == 1 && token->value.data[0] == '.';
+}
+
+static bool current_token_is_dot(parser_T* parser) {
+  return token_is_dot(parser->current_token);
+}
+
+static void consume_dot_notation_loop(parser_T* parser, token_T* tag_name, hb_array_T* errors) {
+  while (current_token_is_dot(parser)) {
+    token_T* dot = parser_advance(parser);
+    token_T* segment = parser_consume_expected(parser, TOKEN_IDENTIFIER, errors);
+
+    if (segment == NULL || segment->value.length == 0) {
+      if (segment) { token_free(segment, parser->allocator); }
+      token_free(dot, parser->allocator);
+      break;
+    }
+
+    uint32_t new_length = (uint32_t) (segment->value.data + segment->value.length - tag_name->value.data);
+    tag_name->value.length = new_length;
+    tag_name->location.end = segment->location.end;
+    tag_name->range.to = segment->range.to;
+
+    token_free(segment, parser->allocator);
+    token_free(dot, parser->allocator);
+  }
+}
+
+bool parser_lookahead_is_valid_dot_notation_open_tag(parser_T* parser) {
+  lexer_T lexer_copy = *parser->lexer;
+  token_T* name = lexer_next_token(&lexer_copy);
+
+  if (name == NULL || name->type != TOKEN_IDENTIFIER) {
+    if (name) { token_free(name, parser->allocator); }
+    return false;
+  }
+
+  bool first_is_upper = name->value.length > 0 && isupper((unsigned char) name->value.data[0]);
+  token_free(name, parser->allocator);
+  token_T* next = lexer_next_token(&lexer_copy);
+
+  if (next == NULL) { return true; }
+
+  bool is_dot = token_is_dot(next);
+  token_free(next, parser->allocator);
+
+  if (!is_dot) { return true; }
+  if (!parser->options.dot_notation_tags) { return true; }
+  if (!first_is_upper) { return true; }
+
+  next = lexer_next_token(&lexer_copy);
+
+  while (next != NULL) {
+    if (next->type != TOKEN_IDENTIFIER || next->value.length == 0) {
+      token_free(next, parser->allocator);
+      return true;
+    }
+
+    token_free(next, parser->allocator);
+    next = lexer_next_token(&lexer_copy);
+
+    if (next == NULL) { return true; }
+
+    is_dot = token_is_dot(next);
+    token_free(next, parser->allocator);
+
+    if (!is_dot) { return true; }
+
+    next = lexer_next_token(&lexer_copy);
+  }
+
+  return true;
+}
+
+void parser_consume_dot_notation_segments(parser_T* parser, token_T* tag_name, hb_array_T* errors) {
+  if (!parser->options.dot_notation_tags) { return; }
+  if (tag_name == NULL || tag_name->value.length == 0) { return; }
+  if (!current_token_is_dot(parser)) { return; }
+
+  if (!isupper((unsigned char) tag_name->value.data[0])) {
+    append_dot_notation_casing_error(
+      tag_name,
+      tag_name->location.start,
+      tag_name->location.end,
+      parser->allocator,
+      errors
+    );
+  }
+
+  consume_dot_notation_loop(parser, tag_name, errors);
+}

data/src/{parser_match_tags.c → parser/match_tags.c}

@@ -1,10 +1,10 @@
 // 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/parser_match_tags.c.erb
+// be modified manually. See /home/runner/work/herb/herb/templates/src/parser/match_tags.c.erb
 
-#include "include/parser.h"
-#include "include/ast_nodes.h"
-#include "include/util/hb_array.h"
-#include "include/visitor.h"
+#include "../include/parser/parser.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/lib/hb_array.h"
+#include "../include/visitor.h"
 
 bool match_tags_visitor(const AST_NODE_T* node, void* data) {
   match_tags_context_T* context = (match_tags_context_T*) data;
@@ -205,6 +205,15 @@ bool match_tags_visitor(const AST_NODE_T* node, void* data) {
       if (erb_block_node->body != NULL) {
         match_tags_in_node_array(erb_block_node->body, context->errors, context->options, context->allocator);
       }
+      if (erb_block_node->rescue_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_block_node->rescue_clause, match_tags_visitor, context);
+      }
+      if (erb_block_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_block_node->else_clause, match_tags_visitor, context);
+      }
+      if (erb_block_node->ensure_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_block_node->ensure_clause, match_tags_visitor, context);
+      }
       if (erb_block_node->end_node != NULL) {
         herb_visit_node((AST_NODE_T*) erb_block_node->end_node, match_tags_visitor, context);
       }
@@ -380,6 +389,26 @@ bool match_tags_visitor(const AST_NODE_T* node, void* data) {
 
 
 
+    case AST_RUBY_STRICT_LOCAL_NODE: {
+      const AST_RUBY_STRICT_LOCAL_NODE_T* ruby_strict_local_node = (const AST_RUBY_STRICT_LOCAL_NODE_T*) node;
+
+      if (ruby_strict_local_node->default_value != NULL) {
+        herb_visit_node((AST_NODE_T*) ruby_strict_local_node->default_value, match_tags_visitor, context);
+      }
+    } 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;
+
+      if (erb_strict_locals_node->locals != NULL) {
+        match_tags_in_node_array(erb_strict_locals_node->locals, context->errors, context->options, context->allocator);
+      }
+    } break;
+
+
+
 
 
     case AST_ERB_IN_NODE: {

data/src/{parser_helpers.c → parser/parser_helpers.c}

@@ -1,12 +1,12 @@
-#include "include/parser_helpers.h"
-#include "include/ast_nodes.h"
-#include "include/errors.h"
-#include "include/lexer.h"
-#include "include/parser.h"
-#include "include/token.h"
-#include "include/util/hb_array.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/hb_string.h"
+#include "../include/parser/parser_helpers.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/errors.h"
+#include "../include/lexer/lexer.h"
+#include "../include/lexer/token.h"
+#include "../include/lib/hb_array.h"
+#include "../include/lib/hb_buffer.h"
+#include "../include/lib/hb_string.h"
+#include "../include/parser/parser.h"
 
 #include <stdarg.h>
 #include <stdio.h>
@@ -219,7 +219,7 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
     body,
     NULL,
     false,
-    ELEMENT_SOURCE_HTML,
+    hb_string("HTML"),
     open_tag->base.location.start,
     open_tag->base.location.end,
     errors,

data/src/parser.c

@@ -1,18 +1,19 @@
-#include "include/parser.h"
-#include "include/ast_node.h"
-#include "include/ast_nodes.h"
+#include "include/parser/parser.h"
+#include "include/ast/ast_node.h"
+#include "include/ast/ast_nodes.h"
 #include "include/errors.h"
-#include "include/html_util.h"
-#include "include/lexer.h"
-#include "include/lexer_peek_helpers.h"
-#include "include/parser_helpers.h"
-#include "include/token.h"
-#include "include/token_matchers.h"
-#include "include/util.h"
-#include "include/util/hb_array.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/hb_string.h"
-#include "include/util/string.h"
+#include "include/lexer/lexer.h"
+#include "include/lexer/lexer_peek_helpers.h"
+#include "include/lexer/token.h"
+#include "include/lexer/token_matchers.h"
+#include "include/lib/hb_array.h"
+#include "include/lib/hb_buffer.h"
+#include "include/lib/hb_string.h"
+#include "include/lib/string.h"
+#include "include/parser/dot_notation.h"
+#include "include/parser/parser_helpers.h"
+#include "include/util/html_util.h"
+#include "include/util/util.h"
 #include "include/visitor.h"
 
 #include <stdio.h>
@@ -38,9 +39,14 @@ const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { .track_whitespace = false
                                                        .strict = true,
                                                        .action_view_helpers = false,
                                                        .render_nodes = false,
+                                                       .strict_locals = false,
                                                        .prism_nodes_deep = false,
                                                        .prism_nodes = false,
-                                                       .prism_program = false };
+                                                       .prism_program = false,
+                                                       .dot_notation_tags = false,
+                                                       .html = true,
+                                                       .start_line = 0,
+                                                       .start_column = 0 };
 
 size_t parser_sizeof(void) {
   return sizeof(struct PARSER_STRUCT);
@@ -473,7 +479,9 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 
       if (equals_token && equals_token->type == TOKEN_EQUALS) {
         token_T* after_equals = lexer_next_token(parser->lexer);
-        looks_like_new_attribute = (after_equals && after_equals->type == TOKEN_QUOTE);
+        looks_like_new_attribute =
+          (after_equals && after_equals->type == TOKEN_QUOTE && opening_quote != NULL
+           && hb_string_equals(after_equals->value, opening_quote->value));
 
         if (after_equals) { token_free(after_equals, parser->allocator); }
       }
@@ -767,7 +775,7 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
       equals_with_whitespace->type = TOKEN_EQUALS;
 
       char* arena_copy = hb_allocator_strndup(parser->allocator, equals_buffer.value, equals_buffer.length);
-      equals_with_whitespace->value = (hb_string_T) { .data = arena_copy, .length = (uint32_t) equals_buffer.length };
+      equals_with_whitespace->value = hb_string_from_data(arena_copy, equals_buffer.length);
 
       hb_buffer_free(&equals_buffer);
 
@@ -884,7 +892,7 @@ static void parser_skip_erb_content(lexer_T* lexer) {
   do {
     token = lexer_next_token(lexer);
 
-    if (token->type == TOKEN_ERB_END) {
+    if (token->type == TOKEN_ERB_END || token->type == TOKEN_EOF) {
       token_free(token, lexer->allocator);
       break;
     }
@@ -899,6 +907,11 @@ static bool parser_lookahead_erb_is_attribute(lexer_T* lexer) {
   do {
     after = lexer_next_token(lexer);
 
+    if (after->type == TOKEN_EOF) {
+      token_free(after, lexer->allocator);
+      return false;
+    }
+
     if (after->type == TOKEN_EQUALS) {
       token_free(after, lexer->allocator);
       return true;
@@ -929,14 +942,30 @@ static bool parser_lookahead_erb_is_attribute(lexer_T* lexer) {
 
 static bool starts_with_keyword(hb_string_T string, const char* keyword) {
   hb_string_T prefix = hb_string(keyword);
+
   if (string.length < prefix.length) { return false; }
   if (strncmp(string.data, prefix.data, prefix.length) != 0) { return false; }
-
   if (string.length == prefix.length) { return true; }
 
   return is_whitespace(string.data[prefix.length]);
 }
 
+static AST_HTML_TEXT_NODE_T* parser_advance_as_text(parser_T* parser) {
+  token_T* token = parser_advance(parser);
+
+  AST_HTML_TEXT_NODE_T* text = ast_html_text_node_init(
+    token->value,
+    token->location.start,
+    token->location.end,
+    hb_array_init(0, parser->allocator),
+    parser->allocator
+  );
+
+  token_free(token, parser->allocator);
+
+  return text;
+}
+
 // TODO: ideally we could avoid basing this off of strings, and use the step in analyze.c
 static bool parser_lookahead_erb_is_control_flow(parser_T* parser) {
   lexer_T lexer_copy = *parser->lexer;
@@ -1005,6 +1034,8 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
   token_T* tag_start = parser_consume_expected(parser, TOKEN_HTML_TAG_START, errors);
   token_T* tag_name = parser_consume_expected(parser, TOKEN_IDENTIFIER, errors);
 
+  parser_consume_dot_notation_segments(parser, tag_name, errors);
+
   while (token_is_none_of(parser, TOKEN_HTML_TAG_END, TOKEN_HTML_TAG_SELF_CLOSE, TOKEN_EOF)) {
     if (token_is_any_of(parser, TOKEN_HTML_TAG_START, TOKEN_HTML_TAG_START_CLOSE)) {
       append_unclosed_open_tag_error(
@@ -1182,6 +1213,8 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
 
   token_T* tag_name = parser_consume_expected(parser, TOKEN_IDENTIFIER, errors);
 
+  parser_consume_dot_notation_segments(parser, tag_name, errors);
+
   parser_consume_whitespace(parser, children);
 
   token_T* tag_closing = parser_consume_if_present(parser, TOKEN_HTML_TAG_END);
@@ -1246,7 +1279,7 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_self_closing_element(
     NULL,
     NULL,
     true,
-    ELEMENT_SOURCE_HTML,
+    hb_string("HTML"),
     open_tag->base.location.start,
     open_tag->base.location.end,
     NULL,
@@ -1318,7 +1351,7 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
     body,
     (AST_NODE_T*) close_tag,
     false,
-    ELEMENT_SOURCE_HTML,
+    hb_string("HTML"),
     open_tag->base.location.start,
     close_tag->base.location.end,
     errors,
@@ -1408,13 +1441,7 @@ static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children,
   hb_buffer_init(&content, 1024, parser->allocator);
   position_T start = parser->current_token->location.start;
   hb_string_T expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
-
-  if (hb_string_is_empty(expected_closing_tag)) {
-    parser_exit_foreign_content(parser);
-    hb_buffer_free(&content);
-
-    return;
-  }
+  bool has_closing_tag = !hb_string_is_empty(expected_closing_tag);
 
   while (!token_is(parser, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
@@ -1428,7 +1455,7 @@ static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children,
       continue;
     }
 
-    if (token_is(parser, TOKEN_HTML_TAG_START_CLOSE)) {
+    if (has_closing_tag && token_is(parser, TOKEN_HTML_TAG_START_CLOSE)) {
       lexer_state_snapshot_T saved_state = lexer_save_state(parser->lexer);
 
       token_T* next_token = lexer_next_token(parser->lexer);
@@ -1463,6 +1490,11 @@ static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children,
 }
 
 static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, hb_array_T* errors) {
+  if (!parser->options.html) {
+    parser_parse_foreign_content(parser, children, errors);
+    return;
+  }
+
   while (token_is_not(parser, TOKEN_EOF)) {
 
     if (token_is(parser, TOKEN_ERB_START)) {
@@ -1496,7 +1528,11 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
     }
 
     if (token_is(parser, TOKEN_HTML_TAG_START)) {
-      hb_array_append(children, parser_parse_html_element(parser));
+      if (parser_lookahead_is_valid_dot_notation_open_tag(parser)) {
+        hb_array_append(children, parser_parse_html_element(parser));
+      } else {
+        hb_array_append(children, parser_advance_as_text(parser));
+      }
       parser->consecutive_error_count = 0;
       continue;
     }
@@ -1683,7 +1719,7 @@ static hb_array_T* parser_build_elements_from_tags(
             processed_body,
             (AST_NODE_T*) omitted_close_tag,
             false,
-            ELEMENT_SOURCE_HTML,
+            hb_string("HTML"),
             open_tag->base.location.start,
             end_position,
             element_errors,
@@ -1726,7 +1762,7 @@ static hb_array_T* parser_build_elements_from_tags(
           processed_body,
           (AST_NODE_T*) close_tag,
           false,
-          ELEMENT_SOURCE_HTML,
+          hb_string("HTML"),
           open_tag->base.location.start,
           close_tag->base.location.end,
           element_errors,