natalie_parser 2.0.0 → 2.2.0

data/src/parser.cpp

@@ -46,7 +46,7 @@ enum class Parser::Precedence {
     REF, // foo[1] / foo[1] = 2
 };
 
-bool Parser::higher_precedence(Token &token, SharedPtr<Node> left, Precedence current_precedence) {
+bool Parser::higher_precedence(Token &token, SharedPtr<Node> left, Precedence current_precedence, IterAllow iter_allow) {
     auto next_precedence = get_precedence(token, left);
 
     // printf("token %d, left %d, current_precedence %d, next_precedence %d\n", (int)token.type(), (int)left->type(), (int)current_precedence, (int)next_precedence);
@@ -83,11 +83,11 @@ bool Parser::higher_precedence(Token &token, SharedPtr<Node> left, Precedence cu
         // NOTE: `m_call_depth` should probably be called
         // `m_call_that_can_accept_a_block_depth`, but that's a bit long.
         //
-        return m_call_depth.last() == 0;
+        return iter_allow == IterAllow::CURLY_AND_BLOCK && m_call_depth.last() == 0;
     }
 
     if (next_precedence == Precedence::ITER_CURLY)
-        return left->is_callable();
+        return iter_allow >= IterAllow::CURLY_ONLY && left->is_callable();
 
     return next_precedence > current_precedence;
 }
@@ -198,7 +198,7 @@ Parser::Precedence Parser::get_precedence(Token &token, SharedPtr<Node> left) {
     return Precedence::LOWEST;
 }
 
-SharedPtr<Node> Parser::parse_expression(Parser::Precedence precedence, LocalsHashmap &locals) {
+SharedPtr<Node> Parser::parse_expression(Parser::Precedence precedence, LocalsHashmap &locals, IterAllow iter_allow) {
     skip_newlines();
 
     m_precedence_stack.push(precedence);
@@ -211,7 +211,7 @@ SharedPtr<Node> Parser::parse_expression(Parser::Precedence precedence, LocalsHa
 
     while (current_token().is_valid()) {
         auto token = current_token();
-        if (!higher_precedence(token, left, precedence))
+        if (!higher_precedence(token, left, precedence, iter_allow))
             break;
         auto left_fn = left_denotation(token, left, precedence);
         if (!left_fn)
@@ -278,44 +278,47 @@ SharedPtr<BlockNode> Parser::parse_def_body(LocalsHashmap &locals) {
     return parse_body(locals, Precedence::LOWEST, Token::Type::EndKeyword, true);
 }
 
+void Parser::reinsert_collapsed_newline() {
+    auto token = previous_token();
+    if (token.can_precede_collapsible_newline()) {
+        // Some operators at the end of a line cause the newlines to be collapsed:
+        //
+        //     foo <<
+        //       bar
+        //
+        // ...but in this case (an alias), collapsing the newline was a mistake:
+        //
+        //     alias foo <<
+        //     def bar; end
+        //
+        // So, we'll put the newline back.
+        m_tokens->insert(m_index, Token { Token::Type::Newline, token.file(), token.line(), token.column(), token.whitespace_precedes() });
+    }
+}
+
 SharedPtr<Node> Parser::parse_alias(LocalsHashmap &locals) {
     auto token = current_token();
     advance();
-    SharedPtr<SymbolNode> new_name = parse_alias_arg(locals, "alias new name (first argument)", false);
-    auto existing_name = parse_alias_arg(locals, "alias existing name (second argument)", true);
+    auto new_name = parse_alias_arg(locals, "alias new name (first argument)");
+    auto existing_name = parse_alias_arg(locals, "alias existing name (second argument)");
+    reinsert_collapsed_newline();
     return new AliasNode { token, new_name, existing_name };
 }
 
-SharedPtr<SymbolNode> Parser::parse_alias_arg(LocalsHashmap &locals, const char *expected_message, bool reinsert_collapsed_newline) {
+SharedPtr<SymbolNode> Parser::parse_alias_arg(LocalsHashmap &locals, const char *expected_message) {
     auto token = current_token();
     switch (token.type()) {
-        // TODO: handle Constant too
-    case Token::Type::BareName: {
-        advance();
-        return new SymbolNode { token, token.literal_string() };
-    }
+    case Token::Type::BareName:
+    case Token::Type::Constant:
+    case Token::Type::OperatorName:
+        return new SymbolNode { token, parse_method_name(locals) };
     case Token::Type::Symbol:
         return parse_symbol(locals).static_cast_as<SymbolNode>();
     case Token::Type::InterpolatedSymbolBegin:
         return parse_interpolated_symbol(locals).static_cast_as<SymbolNode>();
     default:
         if (token.is_operator() || token.is_keyword()) {
-            advance();
-            if (token.can_precede_collapsible_newline() && reinsert_collapsed_newline) {
-                // Some operators at the end of a line cause the newlines to be collapsed:
-                //
-                //     foo <<
-                //       bar
-                //
-                // ...but in this case (an alias), collapsing the newline was a mistake:
-                //
-                //     alias foo <<
-                //     def bar; end
-                //
-                // So, we'll put the newline back.
-                m_tokens->insert(m_index, Token { Token::Type::Newline, token.file(), token.line(), token.column(), token.whitespace_precedes() });
-            }
-            return new SymbolNode { token, new String(token.type_value()) };
+            return new SymbolNode { token, parse_method_name(locals) };
         } else {
             throw_unexpected(expected_message);
         }
@@ -354,11 +357,17 @@ SharedPtr<Node> Parser::parse_array(LocalsHashmap &locals) {
         return {};
     };
     auto ret = add_node();
-    if (ret) return ret;
+    if (ret) {
+        m_call_depth.pop();
+        return ret;
+    }
     while (current_token().is_comma()) {
         advance();
         ret = add_node();
-        if (ret) return ret;
+        if (ret) {
+            m_call_depth.pop();
+            return ret;
+        }
     }
     expect(Token::Type::RBracket, "array closing bracket");
     advance(); // ]
@@ -495,7 +504,7 @@ SharedPtr<Node> Parser::parse_beginless_range(LocalsHashmap &locals) {
 SharedPtr<Node> Parser::parse_block_pass(LocalsHashmap &locals) {
     auto token = current_token();
     advance();
-    auto value = parse_expression(Precedence::UNARY_PLUS, locals);
+    auto value = parse_expression(Precedence::LOWEST, locals);
     return new BlockPassNode { token, value };
 }
 
@@ -859,15 +868,19 @@ SharedPtr<BlockNode> Parser::parse_case_when_body(LocalsHashmap &locals) {
 }
 
 SharedPtr<Node> Parser::parse_class_or_module_name(LocalsHashmap &locals) {
-    Token name_token;
-    if (current_token().type() == Token::Type::ConstantResolution) {
-        name_token = peek_token();
-    } else {
-        name_token = current_token();
-    }
-    if (name_token.type() != Token::Type::Constant)
+    auto name_token = current_token();
+    auto exp = parse_expression(Precedence::LESS_GREATER, locals);
+    switch (exp->type()) {
+    case Node::Type::Colon2:
+    case Node::Type::Colon3:
+        return exp;
+    case Node::Type::Identifier:
+        if (name_token.type() == Token::Type::Constant)
+            return exp;
+        [[fallthrough]];
+    default:
         throw SyntaxError { "class/module name must be CONSTANT" };
-    return parse_expression(Precedence::LESS_GREATER, locals);
+    }
 }
 
 SharedPtr<Node> Parser::parse_class(LocalsHashmap &locals) {
@@ -985,21 +998,24 @@ SharedPtr<Node> Parser::parse_def(LocalsHashmap &locals) {
     auto token = current_token();
     switch (token.type()) {
     case Token::Type::BareName:
-        if (peek_token().type() == Token::Type::Dot) {
+        if (peek_token().is_dot() || peek_token().is_constant_resolution()) {
             self_node = parse_identifier(locals);
             advance(); // dot
         }
         name = parse_method_name(locals);
         break;
     case Token::Type::Constant:
-        if (peek_token().type() == Token::Type::Dot) {
+        if (peek_token().is_dot() || peek_token().is_constant_resolution()) {
             self_node = parse_constant(locals);
             advance(); // dot
         }
         name = parse_method_name(locals);
         break;
+    case Token::Type::OperatorName:
+        name = parse_method_name(locals);
+        break;
     case Token::Type::SelfKeyword:
-        if (peek_token().type() == Token::Type::Dot) {
+        if (peek_token().is_dot() || peek_token().is_constant_resolution()) {
             self_node = new SelfNode { current_token() };
             advance(); // self
             advance(); // dot
@@ -1017,10 +1033,6 @@ SharedPtr<Node> Parser::parse_def(LocalsHashmap &locals) {
         }
     }
     }
-    if (current_token().is_equal() && !current_token().whitespace_precedes()) {
-        advance();
-        name->append_char('=');
-    }
     auto args = Vector<SharedPtr<Node>> {};
     if (current_token().is_lparen()) {
         advance();
@@ -1031,7 +1043,7 @@ SharedPtr<Node> Parser::parse_def(LocalsHashmap &locals) {
             expect(Token::Type::RParen, "args closing paren");
             advance();
         }
-    } else if (current_token().is_bare_name() || current_token().is_splat() || current_token().is_symbol_key()) {
+    } else if (current_token().can_be_first_arg_of_def()) {
         parse_def_args(args, our_locals);
     }
     SharedPtr<BlockNode> body;
@@ -1058,7 +1070,16 @@ SharedPtr<Node> Parser::parse_def(LocalsHashmap &locals) {
 SharedPtr<Node> Parser::parse_defined(LocalsHashmap &locals) {
     auto token = current_token();
     advance();
-    auto arg = parse_expression(Precedence::BARE_CALL_ARG, locals);
+    bool bare = true;
+    if (current_token().is_lparen()) {
+        advance();
+        bare = false;
+    }
+    auto arg = parse_expression(bare ? Precedence::BARE_CALL_ARG : Precedence::CALL_ARG, locals);
+    if (!bare) {
+        expect(Token::Type::RParen, "defined? closing paren");
+        advance();
+    }
     return new DefinedNode { token, arg };
 }
 
@@ -1070,7 +1091,21 @@ void Parser::parse_def_args(Vector<SharedPtr<Node>> &args, LocalsHashmap &locals
     }
 }
 
-void Parser::parse_def_single_arg(Vector<SharedPtr<Node>> &args, LocalsHashmap &locals, ArgsContext context) {
+SharedPtr<Node> Parser::parse_arg_default_value(LocalsHashmap &locals, IterAllow iter_allow) {
+    auto token = current_token();
+    if (token.is_bare_name() && peek_token().is_equal()) {
+        SharedPtr<ArgNode> arg = new ArgNode { token, token.literal_string() };
+        advance();
+        advance(); // =
+        arg->add_to_locals(locals);
+        arg->set_value(parse_arg_default_value(locals, iter_allow));
+        return arg.static_cast_as<Node>();
+    } else {
+        return parse_expression(Precedence::DEF_ARG, locals, iter_allow);
+    }
+}
+
+void Parser::parse_def_single_arg(Vector<SharedPtr<Node>> &args, LocalsHashmap &locals, ArgsContext context, IterAllow iter_allow) {
     auto args_have_any_splat = [&]() { return !args.is_empty() && args.last()->type() == Node::Type::Arg && args.last().static_cast_as<ArgNode>()->splat_or_kwsplat(); };
     auto args_have_keyword = [&]() { return !args.is_empty() && args.last()->type() == Node::Type::KeywordArg; };
 
@@ -1090,7 +1125,7 @@ void Parser::parse_def_single_arg(Vector<SharedPtr<Node>> &args, LocalsHashmap &
             if (args_have_any_splat())
                 throw_error(token, "default value after splat");
             advance(); // =
-            arg->set_value(parse_expression(Precedence::DEF_ARG, locals));
+            arg->set_value(parse_arg_default_value(locals, iter_allow));
         }
         args.push(arg.static_cast_as<Node>());
         return;
@@ -1161,8 +1196,12 @@ void Parser::parse_def_single_arg(Vector<SharedPtr<Node>> &args, LocalsHashmap &
         case Token::Type::RParen:
         case Token::Type::Semicolon:
             break;
+        case Token::Type::LCurlyBrace:
+            if (iter_allow < IterAllow::CURLY_ONLY)
+                break;
+            [[fallthrough]];
         default:
-            arg->set_value(parse_expression(Precedence::DEF_ARG, locals));
+            arg->set_value(parse_expression(Precedence::DEF_ARG, locals, iter_allow));
         }
         arg->add_to_locals(locals);
         args.push(arg.static_cast_as<Node>());
@@ -1248,6 +1287,31 @@ SharedPtr<Node> Parser::parse_file_constant(LocalsHashmap &) {
     return new StringNode { token, token.file() };
 }
 
+SharedPtr<Node> Parser::parse_line_constant(LocalsHashmap &) {
+    auto token = current_token();
+    advance();
+    return new FixnumNode { token, static_cast<long long>(token.line() + 1) };
+}
+
+SharedPtr<Node> Parser::parse_for(LocalsHashmap &locals) {
+    auto token = current_token();
+    advance();
+    auto vars = parse_assignment_identifier(false, locals);
+    if (current_token().type() == Token::Type::Comma) {
+        vars = parse_multiple_assignment_expression(vars, locals);
+    }
+    expect(Token::Type::InKeyword, "for in");
+    advance();
+    auto expr = parse_expression(Precedence::LOWEST, locals, IterAllow::CURLY_ONLY);
+    if (current_token().type() == Token::Type::DoKeyword) {
+        advance();
+    }
+    auto body = parse_body(locals, Precedence::LOWEST);
+    expect(Token::Type::EndKeyword, "for end");
+    advance();
+    return new ForNode { token, expr, vars, body };
+}
+
 SharedPtr<Node> Parser::parse_forward_args(LocalsHashmap &locals) {
     auto token = current_token();
     if (!locals.get("..."))
@@ -1310,28 +1374,35 @@ SharedPtr<Node> Parser::parse_hash(LocalsHashmap &locals) {
 SharedPtr<Node> Parser::parse_hash_inner(LocalsHashmap &locals, Precedence precedence, Token::Type closing_token_type, bool bare, SharedPtr<Node> first_key) {
     auto token = current_token();
     SharedPtr<HashNode> hash = new HashNode { token, bare };
+
+    auto add_value = [&](SharedPtr<Node> key) {
+        if (key->is_symbol_key()) {
+            hash->add_node(parse_expression(precedence, locals));
+        } else if (key->type() == Node::Type::KeywordSplat) {
+            // kwsplat already added
+        } else {
+            expect(Token::Type::HashRocket, "hash rocket");
+            advance(); // =>
+            hash->add_node(parse_expression(precedence, locals));
+        }
+    };
+
     if (!first_key)
         first_key = parse_expression(precedence, locals);
     hash->add_node(first_key);
-    if (!first_key->is_symbol_key()) {
-        expect(Token::Type::HashRocket, "hash rocket");
-        advance();
-    }
-    hash->add_node(parse_expression(precedence, locals));
+    add_value(first_key);
+
     while (current_token().is_comma()) {
         advance();
         if (current_token().type() == closing_token_type)
             break;
-        if (current_token().type() == Token::Type::StarStar) // **kwsplat
+        if (current_token().type() == Token::Type::Ampersand) // &block
             break;
         auto key = parse_expression(precedence, locals);
         hash->add_node(key);
-        if (!key->is_symbol_key()) {
-            expect(Token::Type::HashRocket, "hash rocket");
-            advance();
-        }
-        hash->add_node(parse_expression(precedence, locals));
+        add_value(key);
     }
+
     return hash.static_cast_as<Node>();
 }
 
@@ -1345,9 +1416,16 @@ SharedPtr<Node> Parser::parse_identifier(LocalsHashmap &locals) {
 };
 
 SharedPtr<Node> Parser::parse_if(LocalsHashmap &locals) {
+    return parse_if_branch(locals, true);
+}
+
+SharedPtr<Node> Parser::parse_if_branch(LocalsHashmap &locals, bool parse_match_condition) {
     auto token = current_token();
     advance();
     SharedPtr<Node> condition = parse_expression(Precedence::LOWEST, locals);
+    if (parse_match_condition && condition->type() == Node::Type::Regexp) {
+        condition = new MatchNode { condition->token(), condition.static_cast_as<RegexpNode>() };
+    }
     if (current_token().type() == Token::Type::ThenKeyword) {
         advance(); // then
     } else {
@@ -1356,7 +1434,7 @@ SharedPtr<Node> Parser::parse_if(LocalsHashmap &locals) {
     SharedPtr<Node> true_expr = parse_if_body(locals);
     SharedPtr<Node> false_expr;
     if (current_token().is_elsif_keyword()) {
-        false_expr = parse_if(locals);
+        false_expr = parse_if_branch(locals, false);
         return new IfNode { current_token(), condition, true_expr, false_expr };
     } else {
         if (current_token().is_else_keyword()) {
@@ -1639,25 +1717,21 @@ SharedPtr<Node> Parser::parse_keyword_splat(LocalsHashmap &locals) {
     return new KeywordSplatNode { token, parse_expression(Precedence::SPLAT, locals) };
 }
 
-SharedPtr<Node> Parser::parse_keyword_splat_wrapped_in_hash(LocalsHashmap &locals) {
-    SharedPtr<HashNode> hash = new HashNode { current_token(), true };
-    hash->add_node(parse_keyword_splat(locals));
-    return hash.static_cast_as<Node>();
-}
-
 SharedPtr<String> Parser::parse_method_name(LocalsHashmap &) {
     SharedPtr<String> name = new String("");
     auto token = current_token();
     switch (token.type()) {
     case Token::Type::BareName:
     case Token::Type::Constant:
+    case Token::Type::OperatorName:
         name = current_token().literal_string();
         break;
     default:
-        if (token.is_operator() || token.is_keyword())
+        if (token.is_operator() || token.is_keyword()) {
             name = new String(current_token().type_value());
-        else
+        } else {
             throw_unexpected("method name");
+        }
     }
     advance();
     return name;
@@ -1727,15 +1801,15 @@ SharedPtr<Node> Parser::parse_nth_ref(LocalsHashmap &) {
     return new NthRefNode { token, token.get_fixnum() };
 }
 
-void Parser::parse_proc_args(Vector<SharedPtr<Node>> &args, LocalsHashmap &locals) {
+void Parser::parse_proc_args(Vector<SharedPtr<Node>> &args, LocalsHashmap &locals, IterAllow iter_allow) {
     if (current_token().is_semicolon()) {
         parse_shadow_variables_in_args(args, locals);
         return;
     }
-    parse_def_single_arg(args, locals, ArgsContext::Proc);
+    parse_def_single_arg(args, locals, ArgsContext::Proc, iter_allow);
     while (current_token().is_comma()) {
         advance();
-        parse_def_single_arg(args, locals, ArgsContext::Proc);
+        parse_def_single_arg(args, locals, ArgsContext::Proc, iter_allow);
     }
     if (current_token().is_semicolon()) {
         parse_shadow_variables_in_args(args, locals);
@@ -1848,13 +1922,13 @@ SharedPtr<Node> Parser::parse_stabby_proc(LocalsHashmap &locals) {
         if (current_token().is_rparen()) {
             advance(); // )
         } else {
-            parse_proc_args(args, locals);
+            parse_proc_args(args, locals, IterAllow::CURLY_AND_BLOCK);
             expect(Token::Type::RParen, "proc args closing paren");
             advance(); // )
         }
-    } else if (current_token().is_bare_name() || current_token().type() == Token::Type::Star) {
+    } else if (current_token().can_be_first_arg_of_def()) {
         has_args = true;
-        parse_proc_args(args, locals);
+        parse_proc_args(args, locals, IterAllow::NONE);
     }
     if (current_token().type() != Token::Type::DoKeyword && current_token().type() != Token::Type::LCurlyBrace)
         throw_unexpected("block");
@@ -2026,36 +2100,23 @@ SharedPtr<Node> Parser::parse_unary_operator(LocalsHashmap &locals) {
 SharedPtr<Node> Parser::parse_undef(LocalsHashmap &locals) {
     auto undef_token = current_token();
     advance();
-    auto symbol_from_token = [&](Token &token) -> SharedPtr<Node> {
-        switch (token.type()) {
-        case Token::Type::BareName:
-        case Token::Type::Constant:
-            advance();
-            return new SymbolNode { token, token.literal_string() };
-        case Token::Type::Symbol:
-            return parse_symbol(locals);
-        case Token::Type::InterpolatedSymbolBegin: {
-            return parse_interpolated_symbol(locals);
-        }
-        default:
-            throw_unexpected("method name for undef");
-        }
-    };
     SharedPtr<UndefNode> undef_node = new UndefNode { undef_token };
-    auto token = current_token();
-    undef_node->add_arg(symbol_from_token(token));
+    auto arg = parse_alias_arg(locals, "method name for undef");
+    undef_node->add_arg(arg.static_cast_as<Node>());
     if (current_token().is_comma()) {
         SharedPtr<BlockNode> block = new BlockNode { undef_token };
         block->add_node(undef_node.static_cast_as<Node>());
         while (current_token().is_comma()) {
             advance();
-            token = current_token();
             SharedPtr<UndefNode> undef_node = new UndefNode { undef_token };
-            undef_node->add_arg(symbol_from_token(token));
+            auto arg = parse_alias_arg(locals, "method name for undef");
+            undef_node->add_arg(arg.static_cast_as<Node>());
             block->add_node(undef_node.static_cast_as<Node>());
         }
+        reinsert_collapsed_newline();
         return block.static_cast_as<Node>();
     }
+    reinsert_collapsed_newline();
     return undef_node.static_cast_as<Node>();
 };
 
@@ -2313,7 +2374,7 @@ void Parser::parse_call_args(NodeWithArgs &node, LocalsHashmap &locals, bool bar
     if (bare && node.can_accept_a_block())
         m_call_depth.last()++;
     auto arg = parse_expression(bare ? Precedence::BARE_CALL_ARG : Precedence::CALL_ARG, locals);
-    if (current_token().is_hash_rocket() || arg->is_symbol_key()) {
+    if (current_token().is_hash_rocket() || arg->is_symbol_key() || arg->type() == Node::Type::KeywordSplat) {
         node.add_arg(parse_call_hash_args(locals, bare, closing_token_type, arg));
     } else {
         node.add_arg(arg);
@@ -2325,7 +2386,7 @@ void Parser::parse_call_args(NodeWithArgs &node, LocalsHashmap &locals, bool bar
                 break;
             }
             arg = parse_expression(bare ? Precedence::BARE_CALL_ARG : Precedence::CALL_ARG, locals);
-            if (current_token().is_hash_rocket() || arg->is_symbol_key()) {
+            if (current_token().is_hash_rocket() || arg->is_symbol_key() || arg->type() == Node::Type::KeywordSplat) {
                 node.add_arg(parse_call_hash_args(locals, bare, closing_token_type, arg));
                 break;
             } else {
@@ -2333,6 +2394,9 @@ void Parser::parse_call_args(NodeWithArgs &node, LocalsHashmap &locals, bool bar
             }
         }
     }
+    if (current_token().type() == Token::Type::Ampersand) {
+        node.add_arg(parse_block_pass(locals));
+    }
     if (bare && node.can_accept_a_block())
         m_call_depth.last()--;
 }
@@ -2374,6 +2438,7 @@ SharedPtr<Node> Parser::parse_constant_resolution_expression(SharedPtr<Node> lef
     SharedPtr<Node> node;
     switch (name_token.type()) {
     case Token::Type::BareName:
+    case Token::Type::OperatorName:
         advance();
         node = new CallNode { name_token, left, name_token.literal_string() };
         break;
@@ -2392,7 +2457,12 @@ SharedPtr<Node> Parser::parse_constant_resolution_expression(SharedPtr<Node> lef
         break;
     }
     default:
-        throw_unexpected(name_token, ":: identifier name");
+        if (name_token.is_operator() || name_token.is_keyword()) {
+            advance();
+            node = new CallNode { name_token, left, new String(name_token.type_value()) };
+        } else {
+            throw_unexpected(name_token, ":: identifier name");
+        }
     }
     return node;
 }
@@ -2635,6 +2705,7 @@ SharedPtr<Node> Parser::parse_safe_send_expression(SharedPtr<Node> left, LocalsH
         break;
     case Token::Type::BareName:
     case Token::Type::Constant:
+    case Token::Type::OperatorName:
         name = name_token.literal_string();
         advance();
         break;
@@ -2661,6 +2732,7 @@ SharedPtr<Node> Parser::parse_send_expression(SharedPtr<Node> left, LocalsHashma
     switch (name_token.type()) {
     case Token::Type::BareName:
     case Token::Type::Constant:
+    case Token::Type::OperatorName:
         name = name_token.literal_string();
         advance();
         break;
@@ -2700,7 +2772,14 @@ SharedPtr<Node> Parser::parse_unless(LocalsHashmap &locals) {
     auto token = current_token();
     advance();
     SharedPtr<Node> condition = parse_expression(Precedence::LOWEST, locals);
-    next_expression();
+    if (condition->type() == Node::Type::Regexp) {
+        condition = new MatchNode { condition->token(), condition.static_cast_as<RegexpNode>() };
+    }
+    if (current_token().type() == Token::Type::ThenKeyword) {
+        advance(); // then
+    } else {
+        next_expression();
+    }
     SharedPtr<Node> false_expr = parse_if_body(locals);
     SharedPtr<Node> true_expr;
     if (current_token().is_else_keyword()) {
@@ -2717,8 +2796,15 @@ SharedPtr<Node> Parser::parse_unless(LocalsHashmap &locals) {
 SharedPtr<Node> Parser::parse_while(LocalsHashmap &locals) {
     auto token = current_token();
     advance();
-    SharedPtr<Node> condition = parse_expression(Precedence::LOWEST, locals);
-    next_expression();
+    SharedPtr<Node> condition = parse_expression(Precedence::LOWEST, locals, IterAllow::CURLY_ONLY);
+    if (condition->type() == Node::Type::Regexp) {
+        condition = new MatchNode { condition->token(), condition.static_cast_as<RegexpNode>() };
+    }
+    if (current_token().type() == Token::Type::DoKeyword) {
+        advance();
+    } else {
+        next_expression();
+    }
     SharedPtr<BlockNode> body = parse_body(locals, Precedence::LOWEST);
     expect(Token::Type::EndKeyword, "while end");
     advance();
@@ -2770,10 +2856,14 @@ Parser::parse_null_fn Parser::null_denotation(Token::Type type) {
         return &Parser::parse_end_block;
     case Type::FILEKeyword:
         return &Parser::parse_file_constant;
+    case Type::ForKeyword:
+        return &Parser::parse_for;
     case Type::LParen:
         return &Parser::parse_group;
     case Type::LCurlyBrace:
         return &Parser::parse_hash;
+    case Type::LINEKeyword:
+        return &Parser::parse_line_constant;
     case Type::BareName:
     case Type::ClassVariable:
     case Type::Constant:
@@ -2791,7 +2881,7 @@ Parser::parse_null_fn Parser::null_denotation(Token::Type type) {
     case Type::InterpolatedSymbolBegin:
         return &Parser::parse_interpolated_symbol;
     case Type::StarStar:
-        return &Parser::parse_keyword_splat_wrapped_in_hash;
+        return &Parser::parse_keyword_splat;
     case Type::Bignum:
     case Type::Fixnum:
     case Type::Float:
@@ -2857,7 +2947,7 @@ Parser::parse_left_fn Parser::left_denotation(Token &token, SharedPtr<Node> left
     using Type = Token::Type;
     switch (token.type()) {
     case Type::Equal:
-        if (precedence == Precedence::ARRAY || precedence == Precedence::BARE_CALL_ARG || precedence == Precedence::CALL_ARG)
+        if (precedence == Precedence::ARRAY || precedence == Precedence::HASH || precedence == Precedence::BARE_CALL_ARG || precedence == Precedence::CALL_ARG)
             return &Parser::parse_assignment_expression_without_multiple_values;
         else
             return &Parser::parse_assignment_expression;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: natalie_parser
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Tim Morgan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-24 00:00:00.000000000 Z
+date: 2022-10-25 00:00:00.000000000 Z
 dependencies: []
 description: NatalieParser is a zero-dependency, from-scratch, hand-written recursive
   descent parser for the Ruby Programming Language.
@@ -65,6 +65,7 @@ files:
 - include/natalie_parser/node/false_node.hpp
 - include/natalie_parser/node/fixnum_node.hpp
 - include/natalie_parser/node/float_node.hpp
+- include/natalie_parser/node/for_node.hpp
 - include/natalie_parser/node/forward_args_node.hpp
 - include/natalie_parser/node/hash_node.hpp
 - include/natalie_parser/node/hash_pattern_node.hpp