natalie_parser 1.0.0 → 1.2.0

data/src/parser.cpp

@@ -16,7 +16,7 @@ enum class Parser::Precedence {
     INLINE_RESCUE, // foo rescue 2
     ITER_BLOCK, // do |n| ... end
     BARE_CALL_ARG, // foo (_), b
-    OP_ASSIGNMENT, // += -= *= **= /= %= |= &= ^= >>= <<= ||= &&=
+    OP_ASSIGNMENT_RHS, // x += (_)
     TERNARY_TRUE, // _ ? (_) : _
     CALL_ARG, // foo( (_), b )
     TERNARY_QUESTION, // (_) ? _ : _
@@ -28,6 +28,7 @@ enum class Parser::Precedence {
     LOGICAL_NOT, // not
     EQUALITY, // <=> == === != =~ !~
     LESS_GREATER, // <= < > >=
+    OP_ASSIGNMENT_LHS, // (_) += 1
     BITWISE_OR, // ^ |
     BITWISE_AND, // &
     BITWISE_SHIFT, // << >>
@@ -112,7 +113,7 @@ Parser::Precedence Parser::get_precedence(Token &token, SharedPtr<Node> left) {
     case Token::Type::SlashEqual:
     case Token::Type::StarEqual:
     case Token::Type::StarStarEqual:
-        return Precedence::OP_ASSIGNMENT;
+        return Precedence::OP_ASSIGNMENT_LHS;
     case Token::Type::Ampersand:
         return Precedence::BITWISE_AND;
     case Token::Type::Caret:
@@ -248,7 +249,7 @@ SharedPtr<BlockNode> Parser::parse_body(LocalsHashmap &locals, Precedence preced
     validate_current_token();
     skip_newlines();
     while (!current_token().is_eof() && !is_end(current_token().type())) {
-        if (allow_rescue && current_token().type() == Token::Type::RescueKeyword) {
+        if (allow_rescue && (current_token().is_rescue() || current_token().is_ensure())) {
             auto token = body->token();
             SharedPtr<BeginNode> begin_node = new BeginNode { body->token(), body };
             parse_rest_of_begin(begin_node.ref(), locals);
@@ -312,7 +313,7 @@ SharedPtr<SymbolNode> Parser::parse_alias_arg(LocalsHashmap &locals, const char
                 //     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() });
+                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()) };
         } else {
@@ -623,6 +624,11 @@ SharedPtr<Node> Parser::parse_case_in_pattern(LocalsHashmap &locals) {
         advance();
         node = new IdentifierNode { token, true };
         break;
+    case Token::Type::Bignum:
+    case Token::Type::Fixnum:
+    case Token::Type::Float:
+        node = parse_lit(locals);
+        break;
     case Token::Type::Caret:
         advance();
         expect(Token::Type::BareName, "pinned variable name");
@@ -632,12 +638,18 @@ SharedPtr<Node> Parser::parse_case_in_pattern(LocalsHashmap &locals) {
     case Token::Type::Constant:
         node = parse_constant(locals);
         break;
+    case Token::Type::DotDot:
+    case Token::Type::DotDotDot:
+        node = parse_beginless_range(locals);
+        break;
     case Token::Type::LBracketRBracket:
         advance();
         node = new ArrayPatternNode { token };
         break;
+    case Token::Type::InterpolatedStringBegin:
+        node = parse_interpolated_string(locals);
+        break;
     case Token::Type::LBracket: {
-        // TODO: might need to keep track of and pass along precedence value?
         advance();
         SharedPtr<ArrayPatternNode> array = new ArrayPatternNode { token };
         if (current_token().is_rbracket()) {
@@ -648,7 +660,10 @@ SharedPtr<Node> Parser::parse_case_in_pattern(LocalsHashmap &locals) {
         array->add_node(parse_case_in_pattern(locals));
         while (current_token().is_comma()) {
             advance();
-            array->add_node(parse_case_in_pattern(locals));
+            if (current_token().is_rbracket())
+                array->add_node(new SplatNode { current_token() });
+            else
+                array->add_node(parse_case_in_pattern(locals));
         }
         expect(Token::Type::RBracket, "array pattern closing bracket");
         advance();
@@ -658,47 +673,71 @@ SharedPtr<Node> Parser::parse_case_in_pattern(LocalsHashmap &locals) {
     case Token::Type::LCurlyBrace: {
         advance();
         SharedPtr<HashPatternNode> hash = new HashPatternNode { token };
+        node = hash.static_cast_as<Node>();
         if (current_token().type() == Token::Type::RCurlyBrace) {
             advance();
             node = hash.static_cast_as<Node>();
             break;
         }
-        expect(Token::Type::SymbolKey, "hash pattern symbol key");
-        hash->add_node(parse_symbol(locals));
-        hash->add_node(parse_case_in_pattern(locals));
+
+        auto add_pair = [&]() {
+            auto key = parse_case_in_pattern_hash_symbol_key(locals);
+            hash->add_node(key);
+            if (key->type() == Node::Type::KeywordRestPattern) {
+                // nothing else to do
+            } else if (current_token().type() == Token::Type::RCurlyBrace || current_token().type() == Token::Type::Comma) {
+                if (key->type() == Node::Type::SymbolKey)
+                    locals.set(key.static_cast_as<SymbolKeyNode>()->name().ref());
+                hash->add_node(new NilNode { current_token() });
+            } else {
+                hash->add_node(parse_case_in_pattern(locals));
+            }
+        };
+
+        add_pair();
+
         while (current_token().is_comma()) {
             advance(); // ,
-            expect(Token::Type::Symbol, "hash pattern symbol");
-            hash->add_node(parse_symbol(locals));
-            hash->add_node(parse_case_in_pattern(locals));
+            add_pair();
         }
+
         expect(Token::Type::RCurlyBrace, "hash pattern closing brace");
         advance();
-        node = hash.static_cast_as<Node>();
         break;
     }
-    case Token::Type::Bignum:
-    case Token::Type::Fixnum:
-    case Token::Type::Float:
-        node = parse_lit(locals);
+    case Token::Type::LParen:
+        advance(); // (
+        node = parse_case_in_pattern(locals);
+        expect(Token::Type::RParen, "closing paren for pattern");
+        advance();
+        break;
+    case Token::Type::Minus:
+        node = parse_unary_operator(locals);
+        break;
+    case Token::Type::NilKeyword:
+        node = parse_nil(locals);
         break;
     case Token::Type::Star: {
-        auto splat_token = current_token();
-        advance();
-        SharedPtr<ArrayPatternNode> array = new ArrayPatternNode { token };
+        advance(); // *
         switch (current_token().type()) {
         case Token::Type::BareName:
         case Token::Type::Constant: {
-            auto name = new IdentifierNode { current_token(), true };
-            name->prepend_to_name('*');
-            array->add_node(name);
+            SharedPtr<String> name = current_token().literal_string();
+            auto symbol = new SymbolNode { current_token(), name };
+            node = new SplatNode { symbol->token(), symbol };
             advance();
             break;
         }
         default:
-            array->add_node(new SplatNode { splat_token });
+            node = new SplatNode { current_token() };
         }
-        node = array.static_cast_as<Node>();
+        break;
+    }
+    case Token::Type::StarStar: {
+        SharedPtr<HashPatternNode> hash = new HashPatternNode { token };
+        auto key = parse_case_in_pattern_hash_symbol_key(locals);
+        hash->add_node(key);
+        node = hash.static_cast_as<Node>();
         break;
     }
     case Token::Type::String:
@@ -710,6 +749,11 @@ SharedPtr<Node> Parser::parse_case_in_pattern(LocalsHashmap &locals) {
     default:
         throw_unexpected("case in pattern");
     }
+
+    if (current_token().type() == Token::Type::DotDot || current_token().type() == Token::Type::DotDotDot) {
+        node = parse_range_expression(node, locals);
+    }
+
     token = current_token();
     if (token.is_hash_rocket()) {
         advance();
@@ -722,26 +766,67 @@ SharedPtr<Node> Parser::parse_case_in_pattern(LocalsHashmap &locals) {
     return node;
 }
 
+SharedPtr<Node> Parser::parse_case_in_pattern_alternation(LocalsHashmap &locals) {
+    SharedPtr<ArrayPatternNode> array_pattern = new ArrayPatternNode { current_token() };
+    array_pattern->add_node(parse_case_in_pattern(locals));
+    while (current_token().is_comma()) {
+        advance();
+        array_pattern->add_node(parse_case_in_pattern(locals));
+    }
+    if (array_pattern->nodes().size() == 1)
+        return array_pattern->nodes().first();
+    return array_pattern.static_cast_as<Node>();
+}
+
+SharedPtr<Node> Parser::parse_case_in_pattern_hash_symbol_key(LocalsHashmap &locals) {
+    auto token = current_token();
+    SharedPtr<Node> node;
+    switch (token.type()) {
+    case Token::Type::InterpolatedStringBegin:
+        node = parse_interpolated_string(locals);
+        if (node->type() != Node::Type::SymbolKey)
+            throw_unexpected(token, "hash pattern symbol key");
+        break;
+    case Token::Type::StarStar:
+        advance(); // **
+        switch (current_token().type()) {
+        case Token::Type::NilKeyword:
+            node = new KeywordRestPatternNode { token, current_token().type_value() };
+            advance();
+            break;
+        case Token::Type::BareName: {
+            auto name = current_token().literal_string();
+            node = new KeywordRestPatternNode { token, name };
+            locals.set(name.ref());
+            advance();
+            break;
+        }
+        default:
+            node = new KeywordRestPatternNode { token };
+            break;
+        }
+        break;
+    case Token::Type::SymbolKey:
+        node = parse_symbol_key(locals);
+        break;
+    default:
+        throw_unexpected("hash pattern symbol key");
+    }
+    return node;
+}
+
 SharedPtr<Node> Parser::parse_case_in_patterns(LocalsHashmap &locals) {
     Vector<SharedPtr<Node>> patterns;
-    patterns.push(parse_case_in_pattern(locals));
+    auto pattern = parse_case_in_pattern_alternation(locals);
+    if (pattern->type() == Node::Type::Splat)
+        pattern = new ArrayPatternNode { pattern->token(), pattern };
+    patterns.push(pattern);
     while (current_token().type() == Token::Type::Pipe) {
         advance();
-        patterns.push(parse_case_in_pattern(locals));
-    }
-    while (current_token().is_comma()) {
-        advance();
-        auto last_pattern = patterns.last();
-        auto next_pattern = parse_case_in_pattern(locals);
-        if (last_pattern->type() == Node::Type::ArrayPattern) {
-            last_pattern.static_cast_as<ArrayPatternNode>()->add_node(next_pattern);
-        } else {
-            patterns.pop();
-            auto array_pattern = new ArrayPatternNode { last_pattern->token() };
-            array_pattern->add_node(last_pattern);
-            array_pattern->add_node(next_pattern);
-            patterns.push(array_pattern);
-        }
+        auto pattern = parse_case_in_pattern_alternation(locals);
+        if (pattern->type() == Node::Type::Splat)
+            pattern = new ArrayPatternNode { pattern->token(), pattern };
+        patterns.push(pattern);
     }
     assert(patterns.size() > 0);
     if (patterns.size() == 1) {
@@ -848,13 +933,12 @@ SharedPtr<Node> Parser::parse_assignment_identifier(bool allow_splat, LocalsHash
     case Token::Type::Star: {
         if (!allow_splat)
             expect(Token::Type::BareName, "assignment identifier");
-        auto splat_token = current_token();
         advance();
         if (current_token().is_assignable()) {
             auto id = parse_assignment_identifier(false, locals);
-            node = new SplatNode { splat_token, id };
+            node = new SplatNode { token, id };
         } else {
-            node = new SplatNode { splat_token };
+            node = new SplatNode { token };
         }
         break;
     }
@@ -979,28 +1063,32 @@ SharedPtr<Node> Parser::parse_defined(LocalsHashmap &locals) {
 }
 
 void Parser::parse_def_args(Vector<SharedPtr<Node>> &args, LocalsHashmap &locals) {
-    parse_def_single_arg(args, locals);
+    parse_def_single_arg(args, locals, ArgsContext::Method);
     while (current_token().is_comma()) {
         advance();
-        parse_def_single_arg(args, locals);
+        parse_def_single_arg(args, locals, ArgsContext::Method);
     }
 }
 
-void Parser::parse_def_single_arg(Vector<SharedPtr<Node>> &args, LocalsHashmap &locals) {
+void Parser::parse_def_single_arg(Vector<SharedPtr<Node>> &args, LocalsHashmap &locals, ArgsContext context) {
     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; };
 
     auto token = current_token();
+
+    if (!args.is_empty() && args.last()->type() == Node::Type::ForwardArgs)
+        throw_error(token, "anything after arg forwarding (...) shorthand");
+
     switch (token.type()) {
     case Token::Type::BareName: {
         if (args_have_keyword())
-            throw_unexpected(token, nullptr, "normal arg after keyword arg");
+            throw_error(token, "normal arg after keyword arg");
         SharedPtr<ArgNode> arg = new ArgNode { token, token.literal_string() };
         advance();
         arg->add_to_locals(locals);
         if (current_token().is_equal()) {
             if (args_have_any_splat())
-                throw_unexpected(token, nullptr, "default value after splat");
+                throw_error(token, "default value after splat");
             advance(); // =
             arg->set_value(parse_expression(Precedence::DEF_ARG, locals));
         }
@@ -1022,7 +1110,7 @@ void Parser::parse_def_single_arg(Vector<SharedPtr<Node>> &args, LocalsHashmap &
     }
     case Token::Type::Star: {
         if (args_have_any_splat())
-            throw_unexpected(token, nullptr, "splat after keyword splat");
+            throw_error(token, "splat after keyword splat");
         advance();
         SharedPtr<ArgNode> arg;
         if (current_token().is_bare_name()) {
@@ -1080,6 +1168,15 @@ void Parser::parse_def_single_arg(Vector<SharedPtr<Node>> &args, LocalsHashmap &
         args.push(arg.static_cast_as<Node>());
         return;
     }
+    case Token::Type::DotDotDot: {
+        if (context == ArgsContext::Block)
+            throw_error(token, "arg forwarding (...) shorthand not allowed in block");
+        SharedPtr<ForwardArgsNode> arg = new ForwardArgsNode { token };
+        advance();
+        arg->add_to_locals(locals);
+        args.push(arg.static_cast_as<Node>());
+        return;
+    }
     default:
         throw_unexpected("argument");
     }
@@ -1151,6 +1248,15 @@ SharedPtr<Node> Parser::parse_file_constant(LocalsHashmap &) {
     return new StringNode { token, token.file() };
 }
 
+SharedPtr<Node> Parser::parse_forward_args(LocalsHashmap &locals) {
+    auto token = current_token();
+    if (!locals.get("..."))
+        throw_error(token, "forwarding args without ... shorthand in method definition");
+    advance(); // ...
+    SharedPtr<ForwardArgsNode> node = new ForwardArgsNode { token };
+    return node.static_cast_as<Node>();
+}
+
 SharedPtr<Node> Parser::parse_group(LocalsHashmap &locals) {
     auto token = current_token();
     advance(); // (
@@ -1491,19 +1597,40 @@ SharedPtr<Node> Parser::parse_interpolated_symbol(LocalsHashmap &locals) {
 
 SharedPtr<Node> Parser::parse_lit(LocalsHashmap &) {
     auto token = current_token();
+    SharedPtr<Node> node;
     switch (token.type()) {
     case Token::Type::Bignum:
         advance();
-        return new BignumNode { token, token.literal_string() };
+        node = new BignumNode { token, token.literal_string() };
+        break;
     case Token::Type::Fixnum:
         advance();
-        return new FixnumNode { token, token.get_fixnum() };
+        node = new FixnumNode { token, token.get_fixnum() };
+        break;
     case Token::Type::Float:
         advance();
-        return new FloatNode { token, token.get_double() };
+        node = new FloatNode { token, token.get_double() };
+        break;
     default:
         TM_UNREACHABLE();
     }
+    switch (current_token().type()) {
+    case Token::Type::Complex:
+        advance();
+        node = new ComplexNode { token, node };
+        break;
+    case Token::Type::Rational:
+        advance();
+        node = new RationalNode { token, node };
+        break;
+    case Token::Type::RationalComplex:
+        advance();
+        node = new ComplexNode { token, new RationalNode { token, node } };
+        break;
+    default:
+        break;
+    }
+    return node;
 };
 
 SharedPtr<Node> Parser::parse_keyword_splat(LocalsHashmap &locals) {
@@ -1605,10 +1732,10 @@ void Parser::parse_proc_args(Vector<SharedPtr<Node>> &args, LocalsHashmap &local
         parse_shadow_variables_in_args(args, locals);
         return;
     }
-    parse_def_single_arg(args, locals);
+    parse_def_single_arg(args, locals, ArgsContext::Proc);
     while (current_token().is_comma()) {
         advance();
-        parse_def_single_arg(args, locals);
+        parse_def_single_arg(args, locals, ArgsContext::Proc);
     }
     if (current_token().is_semicolon()) {
         parse_shadow_variables_in_args(args, locals);
@@ -1842,11 +1969,14 @@ SharedPtr<Node> Parser::parse_unary_operator(LocalsHashmap &locals) {
     advance();
     auto precedence = get_precedence(token);
     auto receiver = parse_expression(precedence, locals);
+
     if ((token.type() == Token::Type::Minus || token.type() == Token::Type::Plus) && receiver->is_numeric()) {
         switch (receiver->type()) {
         case Node::Type::Bignum: {
             if (token.type() == Token::Type::Minus) {
                 auto num = receiver.static_cast_as<BignumNode>();
+                if (num->negative())
+                    break;
                 num->negate();
                 return num.static_cast_as<Node>();
             }
@@ -1855,6 +1985,8 @@ SharedPtr<Node> Parser::parse_unary_operator(LocalsHashmap &locals) {
         case Node::Type::Fixnum: {
             if (token.type() == Token::Type::Minus) {
                 auto num = receiver.static_cast_as<FixnumNode>();
+                if (num->negative())
+                    break;
                 num->negate();
                 return num.static_cast_as<Node>();
             }
@@ -1863,6 +1995,8 @@ SharedPtr<Node> Parser::parse_unary_operator(LocalsHashmap &locals) {
         case Node::Type::Float: {
             if (token.type() == Token::Type::Minus) {
                 auto num = receiver.static_cast_as<FloatNode>();
+                if (num->negative())
+                    break;
                 num->negate();
                 return num.static_cast_as<Node>();
             }
@@ -2056,6 +2190,12 @@ SharedPtr<Node> Parser::parse_iter_expression(SharedPtr<Node> left, LocalsHashma
     bool curly_brace = current_token().type() == Token::Type::LCurlyBrace;
     bool has_args = false;
     auto args = Vector<SharedPtr<Node>> {};
+
+    if (curly_brace) {
+        if (left->type() == Node::Type::Call && !left.static_cast_as<CallNode>()->args().is_empty() && !previous_token().is_rparen())
+            throw_unexpected("nearest object cannot accept a { ... } block");
+    }
+
     if (left->type() == Node::Type::StabbyProc) {
         advance(); // { or do
         auto stabby_proc_node = left.static_cast_as<StabbyProcNode>();
@@ -2101,7 +2241,7 @@ void Parser::parse_iter_args(Vector<SharedPtr<Node>> &args, LocalsHashmap &local
         parse_shadow_variables_in_args(args, locals);
         return;
     }
-    parse_def_single_arg(args, locals);
+    parse_def_single_arg(args, locals, ArgsContext::Block);
     while (current_token().is_comma()) {
         advance();
         if (current_token().is_block_arg_delimiter()) {
@@ -2109,7 +2249,7 @@ void Parser::parse_iter_args(Vector<SharedPtr<Node>> &args, LocalsHashmap &local
             args.push(new NilNode { current_token() });
             break;
         }
-        parse_def_single_arg(args, locals);
+        parse_def_single_arg(args, locals, ArgsContext::Block);
     }
     if (current_token().is_semicolon()) {
         parse_shadow_variables_in_args(args, locals);
@@ -2149,6 +2289,15 @@ SharedPtr<NodeWithArgs> Parser::to_node_with_args(SharedPtr<Node> node) {
         };
         return call_node;
     }
+    case Node::Type::Colon2: {
+        auto colon2 = node.static_cast_as<Colon2Node>();
+        auto call_node = new CallNode {
+            colon2->token(),
+            colon2->left(),
+            colon2->name(),
+        };
+        return call_node;
+    }
     case Node::Type::Call:
     case Node::Type::SafeCall:
     case Node::Type::Super:
@@ -2156,12 +2305,12 @@ SharedPtr<NodeWithArgs> Parser::to_node_with_args(SharedPtr<Node> node) {
     case Node::Type::Yield:
         return node.static_cast_as<NodeWithArgs>();
     default:
-        throw_unexpected(current_token(), nullptr, "left-hand-side is not callable");
+        throw_error(current_token(), "left-hand-side is not callable");
     }
 }
 
 void Parser::parse_call_args(NodeWithArgs &node, LocalsHashmap &locals, bool bare, Token::Type closing_token_type) {
-    if (node.can_accept_a_block())
+    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()) {
@@ -2184,7 +2333,7 @@ void Parser::parse_call_args(NodeWithArgs &node, LocalsHashmap &locals, bool bar
             }
         }
     }
-    if (node.can_accept_a_block())
+    if (bare && node.can_accept_a_block())
         m_call_depth.last()--;
 }
 
@@ -2381,7 +2530,7 @@ SharedPtr<Node> Parser::parse_op_attr_assign_expression(SharedPtr<Node> left, Lo
     auto left_call = left.static_cast_as<CallNode>();
     auto token = current_token();
     advance();
-    auto value = parse_expression(Precedence::OP_ASSIGNMENT, locals);
+    auto value = parse_expression(Precedence::OP_ASSIGNMENT_RHS, locals);
 
     if (*left_call->message() != "[]") {
         if (token.type() == Token::Type::AmpersandAmpersandEqual) {
@@ -2428,15 +2577,19 @@ SharedPtr<Node> Parser::parse_proc_call_expression(SharedPtr<Node> left, LocalsH
 
 SharedPtr<Node> Parser::parse_range_expression(SharedPtr<Node> left, LocalsHashmap &locals) {
     auto token = current_token();
-    advance();
+    advance(); // .. or ...
+    skip_newlines();
     SharedPtr<Node> right;
-    try {
+    if (current_token().can_be_range_arg_token()) {
         right = parse_expression(Precedence::RANGE, locals);
-    } catch (SyntaxError &e) {
-        // NOTE: I'm not sure if this is the "right" way to handle an endless range,
-        // but it seems to be effective for the tests I threw at it. ¯\_(ツ)_/¯
+    } else {
+        // endless range
         right = new NilNode { token };
+        // HACK: insert a newline here so subsequent expressions parse ok
+        if (!current_token().can_follow_collapsible_newline())
+            m_tokens->insert(m_index, Token { Token::Type::Newline, current_token().file(), current_token().line(), current_token().column(), current_token().whitespace_precedes() });
     }
+
     return new RangeNode { token, left, right, token.type() == Token::Type::DotDotDot };
 }
 
@@ -2536,6 +2689,12 @@ SharedPtr<Node> Parser::parse_ternary_expression(SharedPtr<Node> left, LocalsHas
     return new IfNode { token, left, true_expr, false_expr };
 }
 
+SharedPtr<Node> Parser::parse_triple_dot(LocalsHashmap &locals) {
+    if (peek_token().is_rparen())
+        return parse_forward_args(locals);
+    return parse_beginless_range(locals);
+}
+
 SharedPtr<Node> Parser::parse_unless(LocalsHashmap &locals) {
     auto token = current_token();
     advance();
@@ -2603,7 +2762,7 @@ Parser::parse_null_fn Parser::null_denotation(Token::Type type) {
         return &Parser::parse_defined;
     case Type::DotDot:
     case Type::DotDotDot:
-        return &Parser::parse_beginless_range;
+        return &Parser::parse_triple_dot;
     case Type::ENCODINGKeyword:
         return &Parser::parse_encoding;
     case Type::ENDKeyword:
@@ -2717,16 +2876,19 @@ Parser::parse_left_fn Parser::left_denotation(Token &token, SharedPtr<Node> left
     case Type::LeftShift:
     case Type::LessThan:
     case Type::LessThanOrEqual:
-    case Type::Minus:
     case Type::NotEqual:
     case Type::Percent:
     case Type::Pipe:
-    case Type::Plus:
     case Type::RightShift:
     case Type::Slash:
     case Type::Star:
     case Type::StarStar:
         return &Parser::parse_infix_expression;
+    case Type::Minus:
+    case Type::Plus:
+        if (peek_token().whitespace_precedes() || !left->is_callable())
+            return &Parser::parse_infix_expression;
+        break;
     case Type::DoKeyword:
     case Type::LCurlyBrace:
         return &Parser::parse_iter_expression;
@@ -2793,20 +2955,22 @@ bool Parser::is_first_arg_of_call_without_parens(SharedPtr<Node> left, Token &to
     return left->is_callable() && token.can_be_first_arg_of_implicit_call();
 }
 
+Token &Parser::previous_token() const {
+    if (m_index > 0)
+        return (*m_tokens)[m_index - 1];
+    return Token::invalid();
+}
+
 Token &Parser::current_token() const {
-    if (m_index < m_tokens->size()) {
+    if (m_index < m_tokens->size())
         return m_tokens->at(m_index);
-    } else {
-        return Token::invalid();
-    }
+    return Token::invalid();
 }
 
 Token &Parser::peek_token() const {
-    if (m_index + 1 < m_tokens->size()) {
+    if (m_index + 1 < m_tokens->size())
         return (*m_tokens)[m_index + 1];
-    } else {
-        return Token::invalid();
-    }
+    return Token::invalid();
 }
 
 void Parser::next_expression() {
@@ -2826,6 +2990,10 @@ void Parser::expect(Token::Type type, const char *expected) {
         throw_unexpected(expected);
 }
 
+void Parser::throw_error(const Token &token, const char *error) {
+    throw_unexpected(token, nullptr, error);
+}
+
 void Parser::throw_unexpected(const Token &token, const char *expected, const char *error) {
     auto file = token.file() ? String(*token.file()) : String("(unknown)");
     auto line = token.line() + 1;
@@ -2881,20 +3049,22 @@ void Parser::throw_unterminated_thing(Token token, Token start_token) {
     auto indent = String { start_token.column(), ' ' };
     String expected;
     const char *lit = start_token.literal();
-    assert(lit);
-    if (strcmp(lit, "(") == 0)
-        expected = "')'";
-    else if (strcmp(lit, "[") == 0)
-        expected = "']'";
-    else if (strcmp(lit, "{") == 0)
-        expected = "'}'";
-    else if (strcmp(lit, "<") == 0)
-        expected = "'>'";
-    else if (strcmp(lit, "'") == 0)
-        expected = "\"'\"";
-    else
-        expected = String::format("'{}'", lit);
-    assert(!expected.is_empty());
+    if (lit) {
+        if (strcmp(lit, "(") == 0)
+            expected = "')'";
+        else if (strcmp(lit, "[") == 0)
+            expected = "']'";
+        else if (strcmp(lit, "{") == 0)
+            expected = "'}'";
+        else if (strcmp(lit, "<") == 0)
+            expected = "'>'";
+        else if (strcmp(lit, "'") == 0)
+            expected = "\"'\"";
+        else
+            expected = String::format("'{}'", lit);
+    } else {
+        expected = "delimiter"; // FIXME: why do we not know what this delimiter is?
+    }
     const char *thing = nullptr;
     switch (token.type()) {
     case Token::Type::InterpolatedRegexpBegin: