Detect and stop parsing on JSX

When quick-lint-js is run on code containing JSX, the parser and linter
barf horribly all over the code.

It'll take us a while to implement a full JSX parser. When JSX syntax is
detected, emit a friendly diagnostic and stop parsing to avoid
diagnostic spew.

For valid JavaScript code, this commit should not change behavior.

Author: strager

docs/CHANGELOG.md

@@ -44,6 +44,8 @@ Beta release.
 * The npm package and the manual builds are now much smaller and faster. (They
   were previously compiled in debug, unoptimized mode.)
 * `delete x` no longer reports a warning if `x` is a global variable.
+* JSX: Instead of reporting a bunch of errors, quick-lint-js now tells you that
+  JSX syntax is not yet supported.
 
 ## 0.5.0 (2021-10-12)
 

docs/errors/E177.md

@@ -0,0 +1,27 @@
+# E177: React/JSX is not yet implemented
+
+```config-for-examples
+{
+  "globals": {
+    "React": true,
+    "ReactDOM": true
+  }
+}
+```
+
+quick-lint-js does not yet support JSX syntax (used in React code):
+
+```javascript-ignoring-extra-errors
+ReactDOM.render(
+  <h1>Hello, world!</h1>,
+  document.getElementById('root')
+);
+```
+
+To fix this issue, stop using quick-lint-js for your code. Alternative, use
+`React.createElement` instead of JSX:
+
+    ReactDOM.render(
+      React.createElement('h1', null, 'Hello, world!'),
+      document.getElementById('root')
+    );

src/parse.cpp

@@ -464,8 +464,20 @@ expression* parser::parse_primary_expression(precedence prec) {
     expression* ast =
         this->make_expression<expression::_invalid>(this->peek().span());
     if (prec.binary_operators) {
-      this->error_reporter_->report(
-          error_missing_operand_for_operator{this->peek().span()});
+      if (this->peek().type == token_type::less) {
+        // <MyComponent /> (JSX)
+        this->error_reporter_->report(
+            error_jsx_not_yet_implemented{.jsx_start = this->peek().span()});
+#if QLJS_HAVE_SETJMP
+        if (this->have_fatal_parse_error_jmp_buf_) {
+          std::longjmp(this->fatal_parse_error_jmp_buf_, 1);
+          QLJS_UNREACHABLE();
+        }
+#endif
+      } else {
+        this->error_reporter_->report(
+            error_missing_operand_for_operator{this->peek().span()});
+      }
     }
     return ast;
   }

src/quick-lint-js/error.h

@@ -596,6 +596,10 @@
       error_invalid_utf_8_sequence, "E022", { source_code_span sequence; },    \
       ERROR(QLJS_TRANSLATABLE("invalid UTF-8 sequence"), sequence))            \
                                                                                \
+  QLJS_ERROR_TYPE(                                                             \
+      error_jsx_not_yet_implemented, "E177", { source_code_span jsx_start; },  \
+      ERROR(QLJS_TRANSLATABLE("React/JSX is not yet implemented"), jsx_start)) \
+                                                                               \
   QLJS_ERROR_TYPE(                                                             \
       error_keywords_cannot_contain_escape_sequences, "E023",                  \
       { source_code_span escape_sequence; },                                   \

test/CMakeLists.txt

@@ -70,6 +70,7 @@ quick_lint_js_add_executable(
   test-parse-expression-statement.cpp
   test-parse-expression.cpp
   test-parse-function.cpp
+  test-parse-jsx.cpp
   test-parse-loop.cpp
   test-parse-module.cpp
   test-parse-statement.cpp

test/test-parse-expression-statement.cpp

@@ -235,11 +235,12 @@ TEST(test_parse, stray_right_parenthesis) {
 }
 
 TEST(test_parse, statement_starting_with_binary_only_operator) {
+  // '<' omitted. It is used for JSX.
   for (string8_view op : {
-           u8"!=", u8"!==", u8"%",  u8"&",          u8"&&", u8"*",
-           u8"**", u8",",   u8"<",  u8"<<",         u8"<=", u8"=",
-           u8"==", u8"===", u8">",  u8">=",         u8">>", u8">>>",
-           u8"??", u8"^",   u8"in", u8"instanceof", u8"|",
+           u8"!=",  u8"!==", u8"%",          u8"&",  u8"&&",  u8"*",
+           u8"**",  u8",",   u8"<<",         u8"<=", u8"=",   u8"==",
+           u8"===", u8">",   u8">=",         u8">>", u8">>>", u8"??",
+           u8"^",   u8"in",  u8"instanceof", u8"|",
        }) {
     padded_string code(string8(op) + u8" x");
     SCOPED_TRACE(code);

test/test-parse-expression.cpp

@@ -3291,6 +3291,21 @@ TEST_F(test_parse_expression, generator_misplaced_star) {
   EXPECT_EQ(p.range(ast).end_offset(), 16);
 }
 
+TEST_F(test_parse_expression, jsx_is_not_supported) {
+  // If parsing was not started with
+  // parse_and_visit_module_catching_fatal_parse_errors, then we can't halt
+  // parsing at the '<'. For error recovery, treat '<' as if it was a binary
+  // operator.
+  test_parser p(u8"<MyComponent attr={value}>hello</MyComponent>"_sv);
+  expression* ast = p.parse_expression();
+  EXPECT_THAT(p.errors(), ElementsAre(ERROR_TYPE_FIELD(
+                              error_jsx_not_yet_implemented, jsx_start,
+                              offsets_matcher(p.code(), 0, u8"<"))));
+  EXPECT_EQ(p.range(ast).begin_offset(), 0);
+  EXPECT_EQ(p.range(ast).end_offset(), strlen(u8"<MyComponent"));
+  EXPECT_EQ(summarize(ast), "binary(?, var MyComponent)");
+}
+
 std::string summarize(const expression& expression) {
   auto children = [&] {
     std::string result;

test/test-parse-jsx.cpp

@@ -0,0 +1,70 @@
+// Copyright (C) 2020  Matthew "strager" Glazar
+// See end of file for extended copyright information.
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <quick-lint-js/array.h>
+#include <quick-lint-js/char8.h>
+#include <quick-lint-js/cli-location.h>
+#include <quick-lint-js/error-collector.h>
+#include <quick-lint-js/error-matcher.h>
+#include <quick-lint-js/error.h>
+#include <quick-lint-js/language.h>
+#include <quick-lint-js/padded-string.h>
+#include <quick-lint-js/parse-support.h>
+#include <quick-lint-js/parse.h>
+#include <quick-lint-js/spy-visitor.h>
+#include <string>
+#include <string_view>
+#include <vector>
+
+using ::testing::Contains;
+using ::testing::ElementsAre;
+
+namespace quick_lint_js {
+namespace {
+TEST(test_parse, jsx_is_not_supported) {
+  // If parsing was not started with
+  // parse_and_visit_module_catching_fatal_parse_errors, then we can't halt
+  // parsing at the '<'. Error recovery will do a bad job.
+  padded_string code(u8"<MyComponent attr={value}>hello</MyComponent>"_sv);
+  spy_visitor v;
+  parser p(&code, &v);
+  p.parse_and_visit_module(v);
+  EXPECT_THAT(v.errors, Contains(ERROR_TYPE_FIELD(
+                            error_jsx_not_yet_implemented, jsx_start,
+                            offsets_matcher(&code, 0, u8"<"))));
+}
+
+#if QLJS_HAVE_SETJMP
+TEST(test_parse, parsing_stops_on_jsx) {
+  padded_string code(u8"<MyComponent attr={value}>hello</MyComponent>"_sv);
+  spy_visitor v;
+  parser p(&code, &v);
+  bool ok = p.parse_and_visit_module_catching_fatal_parse_errors(v);
+  EXPECT_FALSE(ok);
+  EXPECT_THAT(v.errors, ElementsAre(ERROR_TYPE_FIELD(
+                            error_jsx_not_yet_implemented, jsx_start,
+                            offsets_matcher(&code, 0, u8"<"))));
+}
+#endif
+}
+}
+
+// quick-lint-js finds bugs in JavaScript programs.
+// Copyright (C) 2020  Matthew "strager" Glazar
+//
+// This file is part of quick-lint-js.
+//
+// quick-lint-js is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// quick-lint-js is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with quick-lint-js.  If not, see <https://www.gnu.org/licenses/>.