natalie_parser 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '048e048ede42652f8a81298a3310313f8bf9929ba5cd952a89d3269d8333b363'
-  data.tar.gz: 5c2388c8125b1444c454c0ee3a0d4a07f305cc3fd668d8e03dbc4404201a50f7
+  metadata.gz: 00b7efc8434fd5d0ade0fe162d09284e3db60417fd0d2beb8a0526df7d52d903
+  data.tar.gz: 749a3d63bfdcb53e4273afe4a0601eb353e9337ba66d4c1f321661bb3f83135e
 SHA512:
-  metadata.gz: 55932c3dc24ceeeab109a4a980ddf96babf276ced15dffb68d7c013ca5cc246d2551b59acc94f82c1ec5c0073859267ace3a264a3d8b9470465672ea5aebb59d
-  data.tar.gz: bcbaaad396877bcbf6453e8d55ad3f46dcb68ba09bcfe2f6cf0f1fa6d96966c646f530e3872d77736ef40b5818feed888d69fe33e62beeb95dcfd1c6f5115203
+  metadata.gz: e975dbfc660b163bf235c8efb4cc2e0c2e9b7924c4a7ed92382a594fdb4443bcf75f967b09fc0fe8af1eafaa4482793c04c07bc5605128fddfe3a8be24174b73
+  data.tar.gz: 121523ba176eec494681009e3863f80f09691234bcc294c26257b5e86544890787c5a40adc4665c9a2c59de37667596957745bc88293b4d8bfc96ccec26e20b0

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.1.0 (2022-06-04)
+
+- CHORE: Add ccache and compiledb for the ext/natalie_parser directory
+- CHORE: Add tests for numbered block arg shorthand
+- FEAT Parse arg forwarding (...) shorthand
+- FEAT: Parse complex and rational numbers
+- FIX: Fix panic when closing word array delimiter is not found
+- FIX: Fix precedence bug with op assign operators (+= et al)
+
 ## 1.0.0 (2022-06-03)
 
 ### Summary

data/README.md

@@ -25,14 +25,21 @@ production applications.**
 - [ ] Support different source encodings
 - [ ] Support more of the Ruby 3.0 syntax
   - [x] "Endless" method definition (`def foo = bar`)
-  - [ ] Argument forwarding (`...`)
-  - [ ] Pattern matching
-  - [ ] Numbered block parameters (`_1`, `_2`, etc.)
+  - [x] Argument forwarding (`...`)
+  - [x] Numbered block parameters (`_1`, `_2`, etc.)
+  - [x] Rational and Complex literals (`1r` and `2i`)
   - [ ] Non-ASCII identifiers
-  - [ ] Rational and Complex literals (`1r` and `2i`)
+  - [ ] Pattern matching
 
 ## Development
 
+You'll need:
+
+- gcc or clang
+- ruby-dev (dev headers)
+- ccache (optional)
+- compiledb (optional)
+
 ```sh
 rake
 ruby -I lib:ext -r natalie_parser -e "p NatalieParser.parse('1 + 2')"

data/Rakefile

@@ -127,6 +127,7 @@ if system('which compiledb 2>&1 >/dev/null')
     if $compiledb_out.any?
       File.write('build/build.log', $compiledb_out.join("\n"))
       sh 'compiledb < build/build.log'
+      sh 'cd ext/natalie_parser && compiledb < build.log'
     end
   end
 else
@@ -172,13 +173,11 @@ file "ext/natalie_parser/natalie_parser.#{so_ext}" => [
   'ext/natalie_parser/mri_creator.hpp',
 ] + SOURCES + HEADERS do |t|
   build_dir = File.expand_path('ext/natalie_parser', __dir__)
+  log_file = File.join(build_dir, 'build.log')
   Rake::FileList['ext/natalie_parser/*.o'].each { |path| rm path }
   rm_rf 'ext/natalie_parser/natalie_parser.so'
-  sh <<-SH
-    cd #{build_dir} && \
-    ruby extconf.rb && \
-    make -j
-  SH
+  sh "cd #{build_dir} && ruby extconf.rb"
+  sh "CC=#{cc.inspect} CXX=#{cxx.inspect} make -C #{build_dir} -j -e V=1 2>&1 | tee #{log_file}"
 end
 
   file 'build/fragments.hpp' => ['test/parser_test.rb', 'test/support/extract_parser_test_fragments.rb'] do

data/ext/natalie_parser/mri_creator.hpp

@@ -61,17 +61,20 @@ public:
         rb_ary_push(m_sexp, Qfalse);
     }
 
-    virtual void append_float(double number) override {
-        rb_ary_push(m_sexp, rb_float_new(number));
+    virtual void append_bignum(TM::String &number) override {
+        auto string_obj = rb_utf8_str_new(number.c_str(), number.length());
+        auto num = rb_Integer(string_obj);
+        rb_ary_push(m_sexp, num);
     }
 
-    virtual void append_integer(long long number) override {
-        rb_ary_push(m_sexp, rb_int_new(number));
+    virtual void append_fixnum(long long number) override {
+        auto num = rb_int_new(number);
+        rb_ary_push(m_sexp, num);
     }
 
-    virtual void append_integer(TM::String &number) override {
-        auto string_obj = rb_utf8_str_new(number.c_str(), number.length());
-        rb_ary_push(m_sexp, rb_Integer(string_obj));
+    virtual void append_float(double number) override {
+        auto num = rb_float_new(number);
+        rb_ary_push(m_sexp, num);
     }
 
     virtual void append_nil() override {
@@ -109,6 +112,21 @@ public:
         rb_ary_push(m_sexp, Qtrue);
     }
 
+    virtual void make_complex_number() override {
+        auto num = rb_ary_pop(m_sexp);
+        num = rb_Complex(INT2FIX(0), num);
+        rb_ary_push(m_sexp, num);
+    }
+
+    virtual void make_rational_number() override {
+        auto num = rb_ary_pop(m_sexp);
+        if (TYPE(num) == T_FLOAT)
+            num = rb_flt_rationalize(num);
+        else
+            num = rb_Rational(num, INT2FIX(1));
+        rb_ary_push(m_sexp, num);
+    }
+
     virtual void wrap(const char *type) override {
         auto inner = m_sexp;
         reset_sexp();

data/include/natalie_parser/creator/debug_creator.hpp

@@ -42,15 +42,15 @@ public:
         m_nodes.push("false");
     }
 
-    virtual void append_float(double number) override {
+    virtual void append_bignum(TM::String &number) override {
         m_nodes.push(String(number));
     }
 
-    virtual void append_integer(long long number) override {
+    virtual void append_fixnum(long long number) override {
         m_nodes.push(String(number));
     }
 
-    virtual void append_integer(TM::String &number) override {
+    virtual void append_float(double number) override {
         m_nodes.push(String(number));
     }
 
@@ -89,6 +89,16 @@ public:
         m_nodes.push("true");
     }
 
+    virtual void make_complex_number() override {
+        auto num = m_nodes.pop();
+        m_nodes.push(String::format("Complex(0, {})", num));
+    }
+
+    virtual void make_rational_number() override {
+        auto num = m_nodes.pop();
+        m_nodes.push(String::format("Rational({}, 1)", num));
+    }
+
     virtual void wrap(const char *type) override {
         auto inner = to_string();
         m_nodes.clear();

data/include/natalie_parser/creator.hpp

@@ -27,9 +27,9 @@ public:
     virtual void append_array(const TM::SharedPtr<ArrayNode> array) { append_array(*array); }
     virtual void append_array(const ArrayNode &array) = 0;
     virtual void append_false() = 0;
+    virtual void append_bignum(TM::String &number) = 0;
+    virtual void append_fixnum(long long number) = 0;
     virtual void append_float(double number) = 0;
-    virtual void append_integer(long long number) = 0;
-    virtual void append_integer(TM::String &number) = 0;
     virtual void append_nil() = 0;
     virtual void append_range(long long first, long long last, bool exclude_end) = 0;
     virtual void append_regexp(TM::String &pattern, int options) = 0;
@@ -37,6 +37,8 @@ public:
     virtual void append_string(TM::String &string) = 0;
     virtual void append_symbol(TM::String &symbol) = 0;
     virtual void append_true() = 0;
+    virtual void make_complex_number() = 0;
+    virtual void make_rational_number() = 0;
     virtual void wrap(const char *type) = 0;
 
     virtual ~Creator() { }

data/include/natalie_parser/node/bignum_node.hpp

@@ -23,7 +23,7 @@ public:
 
     virtual void transform(Creator *creator) const override {
         creator->set_type("lit");
-        creator->append_integer(*m_number);
+        creator->append_bignum(*m_number);
     }
 
     void negate() {

data/include/natalie_parser/node/complex_node.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "natalie_parser/node/bignum_node.hpp"
+#include "natalie_parser/node/fixnum_node.hpp"
+#include "natalie_parser/node/float_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/rational_node.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class ComplexNode : public Node {
+public:
+    ComplexNode(const Token &token, SharedPtr<Node> value)
+        : Node { token }
+        , m_value { value } { }
+
+    virtual Type type() const override { return Type::Complex; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("lit");
+        transform_number(creator);
+        creator->make_complex_number();
+    }
+
+    void transform_number(Creator *creator) const {
+        switch (m_value->type()) {
+        case Node::Type::Bignum:
+            creator->append_bignum(m_value.static_cast_as<BignumNode>()->number().ref());
+            break;
+        case Node::Type::Fixnum:
+            creator->append_fixnum(m_value.static_cast_as<FixnumNode>()->number());
+            break;
+        case Node::Type::Float:
+            creator->append_float(m_value.static_cast_as<FloatNode>()->number());
+            break;
+        case Node::Type::Rational:
+            m_value.static_cast_as<RationalNode>()->transform_number(creator);
+            break;
+        default:
+            TM_UNREACHABLE();
+        }
+    }
+
+protected:
+    SharedPtr<Node> m_value;
+};
+}

data/include/natalie_parser/node/fixnum_node.hpp

@@ -23,7 +23,7 @@ public:
 
     virtual void transform(Creator *creator) const override {
         creator->set_type("lit");
-        creator->append_integer(m_number);
+        creator->append_fixnum(m_number);
     }
 
     void negate() {

data/include/natalie_parser/node/forward_args_node.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "natalie_parser/node/node.hpp"
+#include "tm/hashmap.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class ForwardArgsNode : public Node {
+public:
+    ForwardArgsNode(const Token &token)
+        : Node { token } { }
+
+    virtual Type type() const override { return Type::ForwardArgs; }
+
+    void add_to_locals(TM::Hashmap<TM::String> &locals) {
+        locals.set("...");
+    }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("forward_args");
+    }
+};
+
+}

data/include/natalie_parser/node/iter_node.hpp

@@ -32,7 +32,7 @@ public:
         if (m_has_args)
             append_method_or_block_args(creator);
         else
-            creator->append_integer(0);
+            creator->append_fixnum(0);
         if (!m_body->is_empty())
             creator->append(m_body->without_unnecessary_nesting());
     }

data/include/natalie_parser/node/node.hpp

@@ -33,6 +33,7 @@ public:
         Class,
         Colon2,
         Colon3,
+        Complex,
         Constant,
         Def,
         Defined,
@@ -42,6 +43,7 @@ public:
         False,
         Fixnum,
         Float,
+        ForwardArgs,
         Hash,
         HashPattern,
         Identifier,
@@ -73,6 +75,7 @@ public:
         OpAssignOr,
         Pin,
         Range,
+        Rational,
         Redo,
         Regexp,
         Retry,
@@ -122,7 +125,7 @@ public:
 
     virtual void transform(Creator *creator) const {
         creator->set_type("NOT_YET_IMPLEMENTED");
-        creator->append_integer((int)type());
+        creator->append_fixnum((int)type());
     }
 
     SharedPtr<String> file() const { return m_token.file(); }

data/include/natalie_parser/node/nth_ref_node.hpp

@@ -18,7 +18,7 @@ public:
 
     virtual void transform(Creator *creator) const override {
         creator->set_type("nth_ref");
-        creator->append_integer(m_num);
+        creator->append_fixnum(m_num);
     }
 
 protected:

data/include/natalie_parser/node/rational_node.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "natalie_parser/node/bignum_node.hpp"
+#include "natalie_parser/node/fixnum_node.hpp"
+#include "natalie_parser/node/float_node.hpp"
+#include "natalie_parser/node/node.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class RationalNode : public Node {
+public:
+    RationalNode(const Token &token, SharedPtr<Node> value)
+        : Node { token }
+        , m_value { value } { }
+
+    virtual Type type() const override { return Type::Rational; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("lit");
+        transform_number(creator);
+        creator->make_rational_number();
+    }
+
+    void transform_number(Creator *creator) const {
+        switch (m_value->type()) {
+        case Node::Type::Bignum:
+            creator->append_bignum(m_value.static_cast_as<BignumNode>()->number().ref());
+            break;
+        case Node::Type::Fixnum:
+            creator->append_fixnum(m_value.static_cast_as<FixnumNode>()->number());
+            break;
+        case Node::Type::Float:
+            creator->append_float(m_value.static_cast_as<FloatNode>()->number());
+            break;
+        default:
+            TM_UNREACHABLE();
+        }
+    }
+
+protected:
+    SharedPtr<Node> m_value;
+};
+}

data/include/natalie_parser/node.hpp

@@ -21,6 +21,7 @@
 #include "natalie_parser/node/class_node.hpp"
 #include "natalie_parser/node/colon2_node.hpp"
 #include "natalie_parser/node/colon3_node.hpp"
+#include "natalie_parser/node/complex_node.hpp"
 #include "natalie_parser/node/constant_node.hpp"
 #include "natalie_parser/node/def_node.hpp"
 #include "natalie_parser/node/defined_node.hpp"
@@ -30,6 +31,7 @@
 #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/forward_args_node.hpp"
 #include "natalie_parser/node/hash_node.hpp"
 #include "natalie_parser/node/hash_pattern_node.hpp"
 #include "natalie_parser/node/identifier_node.hpp"
@@ -63,6 +65,7 @@
 #include "natalie_parser/node/op_assign_or_node.hpp"
 #include "natalie_parser/node/pin_node.hpp"
 #include "natalie_parser/node/range_node.hpp"
+#include "natalie_parser/node/rational_node.hpp"
 #include "natalie_parser/node/redo_node.hpp"
 #include "natalie_parser/node/regexp_node.hpp"
 #include "natalie_parser/node/retry_node.hpp"

data/include/natalie_parser/parser.hpp

@@ -87,11 +87,19 @@ private:
     SharedPtr<Node> parse_constant(LocalsHashmap &);
     SharedPtr<Node> parse_def(LocalsHashmap &);
     SharedPtr<Node> parse_defined(LocalsHashmap &);
+
     void parse_def_args(Vector<SharedPtr<Node>> &, LocalsHashmap &);
-    void parse_def_single_arg(Vector<SharedPtr<Node>> &, LocalsHashmap &);
+    enum class ArgsContext {
+        Block,
+        Method,
+        Proc,
+    };
+    void parse_def_single_arg(Vector<SharedPtr<Node>> &, LocalsHashmap &, ArgsContext);
+
     SharedPtr<Node> parse_encoding(LocalsHashmap &);
     SharedPtr<Node> parse_end_block(LocalsHashmap &);
     SharedPtr<Node> parse_file_constant(LocalsHashmap &);
+    SharedPtr<Node> parse_forward_args(LocalsHashmap &);
     SharedPtr<Node> parse_group(LocalsHashmap &);
     SharedPtr<Node> parse_hash(LocalsHashmap &);
     SharedPtr<Node> parse_hash_inner(LocalsHashmap &, Precedence, Token::Type, SharedPtr<Node> = {});
@@ -128,6 +136,7 @@ private:
     SharedPtr<Node> parse_symbol_key(LocalsHashmap &);
     SharedPtr<Node> parse_statement_keyword(LocalsHashmap &);
     SharedPtr<Node> parse_top_level_constant(LocalsHashmap &);
+    SharedPtr<Node> parse_triple_dot(LocalsHashmap &);
     SharedPtr<Node> parse_unary_operator(LocalsHashmap &);
     SharedPtr<Node> parse_undef(LocalsHashmap &);
     SharedPtr<Node> parse_unless(LocalsHashmap &);
@@ -195,6 +204,7 @@ private:
     void skip_newlines();
 
     void expect(Token::Type, const char *);
+    [[noreturn]] void throw_error(const Token &, const char *);
     [[noreturn]] void throw_unexpected(const Token &, const char *, const char * = nullptr);
     [[noreturn]] void throw_unexpected(const char *);
     [[noreturn]] void throw_unterminated_thing(Token, Token = {});

data/include/natalie_parser/token.hpp

@@ -36,6 +36,7 @@ public:
         Comma,
         Comment,
         Comparison,
+        Complex,
         Constant,
         ConstantResolution,
         DefinedKeyword,
@@ -115,6 +116,8 @@ public:
         PipePipeEqual,
         Plus,
         PlusEqual,
+        Rational,
+        RationalComplex,
         RCurlyBrace,
         RBracket,
         RedoKeyword,
@@ -286,6 +289,8 @@ public:
             return "comment";
         case Type::Comparison:
             return "<=>";
+        case Type::Complex:
+            return "complex";
         case Type::ConstantResolution:
             return "::";
         case Type::Constant:
@@ -446,6 +451,10 @@ public:
             return "+=";
         case Type::Plus:
             return "+";
+        case Type::Rational:
+            return "rational";
+        case Type::RationalComplex:
+            return "rational_complex";
         case Type::RCurlyBrace:
             return "}";
         case Type::RBracket:
@@ -804,6 +813,17 @@ public:
         }
     }
 
+    bool can_be_complex_or_rational() const {
+        switch (m_type) {
+        case Type::Bignum:
+        case Type::Fixnum:
+        case Type::Float:
+            return true;
+        default:
+            return false;
+        }
+    }
+
     void set_literal(const char *literal) { m_literal = new String(literal); }
     void set_literal(SharedPtr<String> literal) { m_literal = literal; }
     void set_literal(String literal) { m_literal = new String(literal); }

data/lib/natalie_parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class NatalieParser
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/src/lexer.cpp

@@ -842,6 +842,23 @@ Token Lexer::build_next_token() {
         auto token = consume_numeric();
         return token;
     }
+    case 'i':
+        if (m_last_token.can_be_complex_or_rational() && !isalnum(peek())) {
+            advance();
+            return Token { Token::Type::Complex, m_file, m_token_line, m_token_column };
+        }
+        break;
+    case 'r':
+        if (m_last_token.can_be_complex_or_rational()) {
+            if (peek() == 'i') {
+                advance(2);
+                return Token { Token::Type::RationalComplex, m_file, m_token_line, m_token_column };
+            } else if (!isalnum(peek())) {
+                advance();
+                return Token { Token::Type::Rational, m_file, m_token_line, m_token_column };
+            }
+        }
+        break;
     };
 
     Token keyword_token;
@@ -1322,7 +1339,25 @@ Token Lexer::consume_heredoc() {
 
 Token Lexer::consume_numeric() {
     SharedPtr<String> chars = new String;
+
+    auto consume_decimal_digits_and_build_token = [&]() {
+        char c = current_char();
+        do {
+            chars->append_char(c);
+            c = next();
+            if (c == '_')
+                c = next();
+        } while (isdigit(c));
+        if ((c == '.' && isdigit(peek())) || (c == 'e' || c == 'E'))
+            return consume_numeric_as_float(chars);
+        else
+            return chars_to_fixnum_or_bignum_token(chars, 10, 0);
+    };
+
+    Token token;
+
     if (current_char() == '0') {
+        // special-prefixed literals 0d, 0x, etc.
         switch (peek()) {
         case 'd':
         case 'D': {
@@ -1336,7 +1371,8 @@ Token Lexer::consume_numeric() {
                 if (c == '_')
                     c = next();
             } while (isdigit(c));
-            return chars_to_fixnum_or_bignum_token(chars, 10, 0);
+            token = chars_to_fixnum_or_bignum_token(chars, 10, 0);
+            break;
         }
         case 'o':
         case 'O': {
@@ -1352,7 +1388,8 @@ Token Lexer::consume_numeric() {
                 if (c == '_')
                     c = next();
             } while (c >= '0' && c <= '7');
-            return chars_to_fixnum_or_bignum_token(chars, 8, 2);
+            token = chars_to_fixnum_or_bignum_token(chars, 8, 2);
+            break;
         }
         case 'x':
         case 'X': {
@@ -1368,7 +1405,8 @@ Token Lexer::consume_numeric() {
                 if (c == '_')
                     c = next();
             } while (isxdigit(c));
-            return chars_to_fixnum_or_bignum_token(chars, 16, 2);
+            token = chars_to_fixnum_or_bignum_token(chars, 16, 2);
+            break;
         }
         case 'b':
         case 'B': {
@@ -1384,21 +1422,17 @@ Token Lexer::consume_numeric() {
                 if (c == '_')
                     c = next();
             } while (c == '0' || c == '1');
-            return chars_to_fixnum_or_bignum_token(chars, 2, 2);
+            token = chars_to_fixnum_or_bignum_token(chars, 2, 2);
+            break;
         }
+        default:
+            token = consume_decimal_digits_and_build_token();
         }
+    } else {
+        token = consume_decimal_digits_and_build_token();
     }
-    char c = current_char();
-    do {
-        chars->append_char(c);
-        c = next();
-        if (c == '_')
-            c = next();
-    } while (isdigit(c));
-    if ((c == '.' && isdigit(peek())) || (c == 'e' || c == 'E'))
-        return consume_numeric_as_float(chars);
-    else
-        return chars_to_fixnum_or_bignum_token(chars, 10, 0);
+
+    return token;
 }
 
 const long long max_fixnum = std::numeric_limits<long long>::max() / 2; // 63 bits for MRI

data/src/node/interpolated_regexp_node.cpp

@@ -13,7 +13,7 @@ void InterpolatedRegexpNode::transform(Creator *creator) const {
             creator->append(node);
     }
     if (m_options != 0)
-        creator->append_integer(m_options);
+        creator->append_fixnum(m_options);
 }
 
 }

data/src/node/node_with_args.cpp

@@ -17,6 +17,7 @@ void NodeWithArgs::append_method_or_block_args(Creator *creator) const {
                     arg.static_cast_as<ArgNode>()->append_name(c);
                 break;
             }
+            case Node::Type::ForwardArgs:
             case Node::Type::KeywordArg:
             case Node::Type::MultipleAssignmentArg:
             case Node::Type::ShadowArg:

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:
@@ -979,28 +980,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 +1027,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 +1085,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 +1165,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 +1514,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 +1649,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);
@@ -2101,7 +2145,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 +2153,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);
@@ -2156,7 +2200,7 @@ 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");
     }
 }
 
@@ -2381,7 +2425,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) {
@@ -2536,6 +2580,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 +2653,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:
@@ -2826,6 +2876,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 +2935,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:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: natalie_parser
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Tim Morgan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-03 00:00:00.000000000 Z
+date: 2022-06-04 00:00:00.000000000 Z
 dependencies: []
 description: NatalieParser is a zero-dependency, from-scratch, hand-written recursive
   descent parser for the Ruby Programming Language.
@@ -55,6 +55,7 @@ files:
 - include/natalie_parser/node/class_node.hpp
 - include/natalie_parser/node/colon2_node.hpp
 - include/natalie_parser/node/colon3_node.hpp
+- include/natalie_parser/node/complex_node.hpp
 - include/natalie_parser/node/constant_node.hpp
 - include/natalie_parser/node/def_node.hpp
 - include/natalie_parser/node/defined_node.hpp
@@ -64,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/forward_args_node.hpp
 - include/natalie_parser/node/hash_node.hpp
 - include/natalie_parser/node/hash_pattern_node.hpp
 - include/natalie_parser/node/identifier_node.hpp
@@ -98,6 +100,7 @@ files:
 - include/natalie_parser/node/op_assign_or_node.hpp
 - include/natalie_parser/node/pin_node.hpp
 - include/natalie_parser/node/range_node.hpp
+- include/natalie_parser/node/rational_node.hpp
 - include/natalie_parser/node/redo_node.hpp
 - include/natalie_parser/node/regexp_node.hpp
 - include/natalie_parser/node/retry_node.hpp