refactor(fe): avoid boolean parameter allow_in_operator; use precedence::in_operator

We pass the allow_in_operator boolean around in a few spots. Boolean
parameters are a bit ugly, and also I need other parts of 'precedence'
for a future patch.

Refactor several parsing functions to accept a precedence object instead
of one boolean extracted from the precedence.

Author: strager

src/quick-lint-js/fe/parse-expression.cpp

@@ -685,8 +685,7 @@ expression* parser::parse_primary_expression(parse_visitor_base& v,
     expression* arrow_function = this->parse_arrow_function_body(
         v, function_attributes::normal,
         /*parameter_list_begin=*/arrow_span.begin(),
-        /*allow_in_operator=*/prec.in_operator,
-        expression_arena::array_ptr<expression*>(),
+        /*prec=*/prec, expression_arena::array_ptr<expression*>(),
         /*return_type_visits=*/nullptr);
     return arrow_function;
   }
@@ -747,17 +746,16 @@ expression* parser::parse_primary_expression(parse_visitor_base& v,
 expression* parser::parse_async_expression(parse_visitor_base& v,
                                            const token& async_token,
                                            precedence prec) {
-  expression* ast = this->parse_async_expression_only(
-      v, async_token, /*allow_in_operator=*/prec.in_operator);
+  expression* ast =
+      this->parse_async_expression_only(v, async_token, /*prec=*/prec);
   if (!prec.binary_operators) {
     return ast;
   }
   return this->parse_expression_remainder(v, ast, prec);
 }
 
 expression* parser::parse_async_expression_only(
-    parse_visitor_base& v, const token& async_or_await_token,
-    bool allow_in_operator) {
+    parse_visitor_base& v, const token& async_or_await_token, precedence prec) {
   bool is_async = async_or_await_token.type == token_type::kw_async;
   bool is_await = async_or_await_token.type == token_type::kw_await;
   QLJS_ASSERT(is_async || is_await);
@@ -786,8 +784,7 @@ expression* parser::parse_async_expression_only(
         }
         expression* ast = this->parse_arrow_function_body_no_scope(
             v, function_attributes::async, async_begin,
-            /*allow_in_operator=*/allow_in_operator,
-            this->expressions_.make_array(std::move(parameters)),
+            /*prec=*/prec, this->expressions_.make_array(std::move(parameters)),
             /*return_type_visits=*/return_type_visits);
         v.visit_exit_function_scope();
         return ast;
@@ -1251,8 +1248,7 @@ expression* parser::parse_await_expression(parse_visitor_base& v,
     return this->make_expression<expression::variable>(
         await_token.identifier_name(), await_token.type);
   } else {
-    return this->parse_async_expression_only(
-        v, await_token, /*allow_in_operator=*/prec.in_operator);
+    return this->parse_async_expression_only(v, await_token, /*prec=*/prec);
   }
 }
 
@@ -1490,7 +1486,7 @@ expression* parser::parse_expression_remainder(parse_visitor_base& v,
         expression* arrow_function = this->parse_arrow_function_body(
             v, /*attributes=*/function_attributes::async,
             /*parameter_list_begin=*/call->left_paren_span().begin(),
-            /*allow_in_operator=*/prec.in_operator,
+            /*prec=*/prec,
             /*parameters=*/
             expression_arena::array_ptr<expression*>(
                 call->children_.begin() + 1,  // Drop the callee.
@@ -1911,7 +1907,7 @@ expression* parser::parse_expression_remainder(parse_visitor_base& v,
     binary_builder.replace_last(this->parse_arrow_function_expression_remainder(
         v, /*generic_parameter_visits=*/nullptr, lhs,
         /*return_type_visits=*/return_type_visits,
-        /*allow_in_operator=*/prec.in_operator));
+        /*prec=*/prec));
     goto next;
   }
 
@@ -1976,7 +1972,7 @@ expression* parser::parse_expression_remainder(parse_visitor_base& v,
               /*generic_parameter_visits=*/nullptr,
               binary_builder.last_expression(),
               /*return_type_visits=*/nullptr,
-              /*allow_in_operator=*/prec.in_operator));
+              /*prec=*/prec));
     }
     break;
   }
@@ -2139,7 +2135,7 @@ expression* parser::parse_expression_remainder(parse_visitor_base& v,
 expression* parser::parse_arrow_function_expression_remainder(
     parse_visitor_base& v, buffering_visitor* generic_parameter_visits,
     expression* parameters_expression, buffering_visitor* return_type_visits,
-    bool allow_in_operator) {
+    precedence prec) {
   const char8* parameter_list_begin = nullptr;
   if (parameters_expression->kind() == expression_kind::paren) {
     parameter_list_begin = parameters_expression->span().begin();
@@ -2312,8 +2308,7 @@ expression* parser::parse_arrow_function_expression_remainder(
   expression* arrow_function = this->parse_arrow_function_body_no_scope(
       v, /*attributes=*/function_attributes::normal,
       /*parameter_list_begin=*/parameter_list_begin,
-      /*allow_in_operator=*/allow_in_operator,
-      this->expressions_.make_array(std::move(parameters)),
+      /*prec=*/prec, this->expressions_.make_array(std::move(parameters)),
       /*return_type_visits=*/return_type_visits);
   arrow_function = this->maybe_wrap_erroneous_arrow_function(
       arrow_function, /*parameters_expression=*/parameters_expression);
@@ -2430,20 +2425,20 @@ parser::parse_arrow_function_parameters_or_call_arguments(
 
 expression* parser::parse_arrow_function_body(
     parse_visitor_base& v, function_attributes attributes,
-    const char8* parameter_list_begin, bool allow_in_operator,
+    const char8* parameter_list_begin, precedence prec,
     expression_arena::array_ptr<expression*>&& parameters,
     buffering_visitor* return_type_visits) {
   v.visit_enter_function_scope();
   expression* arrow = this->parse_arrow_function_body_no_scope(
-      v, attributes, parameter_list_begin, allow_in_operator,
-      std::move(parameters), return_type_visits);
+      v, attributes, parameter_list_begin, prec, std::move(parameters),
+      return_type_visits);
   v.visit_exit_function_scope();
   return arrow;
 }
 
 expression* parser::parse_arrow_function_body_no_scope(
     parse_visitor_base& v, function_attributes attributes,
-    const char8* parameter_list_begin, bool allow_in_operator,
+    const char8* parameter_list_begin, precedence prec,
     expression_arena::array_ptr<expression*>&& parameters,
     buffering_visitor* return_type_visits) {
   function_guard guard = this->enter_function(attributes);
@@ -2466,9 +2461,10 @@ expression* parser::parse_arrow_function_body_no_scope(
     this->parse_and_visit_statement_block_no_scope(v);
   } else {
     this->parse_and_visit_expression(
+        // FIXME(strager): Should we inherit other things from prec?
         v, precedence{
                .commas = false,
-               .in_operator = allow_in_operator,
+               .in_operator = prec.in_operator,
                .colon_type_annotation = allow_type_annotations::never,
            });
   }
@@ -3189,9 +3185,8 @@ expression* parser::parse_jsx_or_typescript_generic_expression(
       case token_type::equal:
       case token_type::kw_extends:
         this->lexer_.roll_back_transaction(std::move(transaction));
-        return this->parse_typescript_generic_arrow_expression(
-            v,
-            /*allow_in_operator=*/prec.in_operator);
+        return this->parse_typescript_generic_arrow_expression(v,
+                                                               /*prec=*/prec);
 
       // <T>() => {}  // Generic arrow function.
       // <T>expr      // Cast.
@@ -3634,7 +3629,7 @@ expression* parser::parse_jsx_element_or_fragment(parse_visitor_base& v,
 }
 
 expression* parser::parse_typescript_generic_arrow_expression(
-    parse_visitor_base& v, bool allow_in_operator) {
+    parse_visitor_base& v, precedence prec) {
   const char8* begin = this->peek().begin;
 
   v.visit_enter_function_scope();
@@ -3661,8 +3656,7 @@ expression* parser::parse_typescript_generic_arrow_expression(
 
   expression* ast = this->parse_arrow_function_body_no_scope(
       v, function_attributes::normal, begin,
-      /*allow_in_operator=*/allow_in_operator,
-      this->expressions_.make_array(std::move(parameters)),
+      /*prec=*/prec, this->expressions_.make_array(std::move(parameters)),
       /*return_type_visits=*/&return_type_visits);
 
   v.visit_exit_function_scope();
@@ -3750,7 +3744,7 @@ expression* parser::parse_typescript_angle_type_assertion_expression(
               v,
               /*generic_parameter_visits=*/&generic_parameter_visits, ast,
               /*return_type_visits=*/&return_type_visits,
-              /*allow_in_operator=*/prec.in_operator);
+              /*prec=*/prec);
         }
       }
 

src/quick-lint-js/fe/parse.h

@@ -573,15 +573,15 @@ class parser {
   //   a unary operator or a mistyped 'async'.
   expression *parse_async_expression_only(parse_visitor_base &,
                                           const token &async_or_await_token,
-                                          bool allow_in_operator);
+                                          precedence);
   expression *parse_await_expression(parse_visitor_base &,
                                      const token &await_token, precedence prec);
   expression *parse_expression_remainder(parse_visitor_base &, expression *,
                                          precedence);
   expression *parse_arrow_function_expression_remainder(
       parse_visitor_base &, buffering_visitor *generic_parameter_visits,
       expression *parameters_expression, buffering_visitor *return_type_visits,
-      bool allow_in_operator);
+      precedence);
   expression::call *parse_call_expression_remainder(parse_visitor_base &,
                                                     expression *callee);
   expression *parse_index_expression_remainder(parse_visitor_base &,
@@ -590,12 +590,12 @@ class parser {
   parse_arrow_function_parameters_or_call_arguments(parse_visitor_base &v);
   expression *parse_arrow_function_body(
       parse_visitor_base &, function_attributes,
-      const char8 *parameter_list_begin, bool allow_in_operator,
+      const char8 *parameter_list_begin, precedence,
       expression_arena::array_ptr<expression *> &&parameters,
       buffering_visitor *return_type_visits);
   expression *parse_arrow_function_body_no_scope(
       parse_visitor_base &, function_attributes,
-      const char8 *parameter_list_begin, bool allow_in_operator,
+      const char8 *parameter_list_begin, precedence,
       expression_arena::array_ptr<expression *> &&parameters,
       buffering_visitor *return_type_visits);
   expression *parse_function_expression(parse_visitor_base &,
@@ -618,7 +618,7 @@ class parser {
                                             const char8 *less_begin);
   void check_jsx_attribute(const identifier &attribute_name);
   expression *parse_typescript_generic_arrow_expression(parse_visitor_base &,
-                                                        bool allow_in_operator);
+                                                        precedence);
   expression *parse_typescript_angle_type_assertion_expression(
       parse_visitor_base &, precedence, bool is_invalid_due_to_jsx_ambiguity);
   expression *parse_tagged_template(parse_visitor_base &, expression *tag);