natalie_parser 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '048e048ede42652f8a81298a3310313f8bf9929ba5cd952a89d3269d8333b363'
-  data.tar.gz: 5c2388c8125b1444c454c0ee3a0d4a07f305cc3fd668d8e03dbc4404201a50f7
+  metadata.gz: db5a804188bcf10ccfbadada61b82e266f227650c5a0b53929f719975d967999
+  data.tar.gz: b14cc0efffacc5219f7bcd5174116d0f302f7d56c4c69bfc13214b7b653adbb7
 SHA512:
-  metadata.gz: 55932c3dc24ceeeab109a4a980ddf96babf276ced15dffb68d7c013ca5cc246d2551b59acc94f82c1ec5c0073859267ace3a264a3d8b9470465672ea5aebb59d
-  data.tar.gz: bcbaaad396877bcbf6453e8d55ad3f46dcb68ba09bcfe2f6cf0f1fa6d96966c646f530e3872d77736ef40b5818feed888d69fe33e62beeb95dcfd1c6f5115203
+  metadata.gz: fb144d0f89276c280a3e7500f765cf98df9cffd4cfa8f0d0ed8d4a6d3a0d98f21b6b27d9d32b6b053a89edc0c092921e7d1215a546b7322162bd5bab7c37cf25
+  data.tar.gz: b467baf8f5619ea58d6ce8fb2802d63509b51b020459de8b2c8a53ed7af8927b45f3191ddda1429456d875f892be0ffc79f426915395f968210b90a030aab8f6

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 1.2.0 (2022-06-16)
+
+- CHORE: Enable true random fuzzing
+- FEAT: Add Node::debug() function to help with debugging
+- FEAT: Parse more pattern matching cases
+- FIX: Don't error if ext/natalie_parser/build.log isn't written yet
+- FIX: Fix block association inside call with parentheses
+- FIX: Fix bug negating an already-negative number
+- FIX: Fix bug parsing unary operator as an infix operation
+- FIX: Fix method definition with lonely ensure
+- FIX: Fix parsing endless ranges inside case/when and other odd places
+- FIX: Make sure every token knows if it has preceding whitespace
+- FIX: Parse method calls with constant receiver
+
+## 1.1.1 (2022-06-04)
+
+- FIX: Workaround for clang declspec bug
+
+## 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,9 @@ 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'
+      if File.exist?('ext/natalie_parser/build.log')
+        sh 'cd ext/natalie_parser && compiledb < build.log'
+      end
     end
   end
 else
@@ -172,13 +175,17 @@ 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"
+  if `#{cxx} -v 2>&1` =~ /clang/
+    # workaround for clang bug: https://bugs.ruby-lang.org/issues/18616
+    cxx_hacky = "#{cxx} -fdeclspec"
+  else
+    cxx_hacky = cxx
+  end
+  sh "CC=#{cc.inspect} CXX=#{cxx_hacky.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/array_pattern_node.hpp

@@ -3,6 +3,8 @@
 #include "natalie_parser/node/array_node.hpp"
 #include "natalie_parser/node/node.hpp"
 #include "natalie_parser/node/node_with_args.hpp"
+#include "natalie_parser/node/splat_node.hpp"
+#include "natalie_parser/node/symbol_node.hpp"
 #include "tm/hashmap.hpp"
 #include "tm/string.hpp"
 
@@ -15,14 +17,30 @@ public:
     ArrayPatternNode(const Token &token)
         : ArrayNode { token } { }
 
+    ArrayPatternNode(const Token &token, SharedPtr<Node> node)
+        : ArrayNode { token } {
+        m_nodes.push(node);
+    }
+
     virtual Type type() const override { return Type::ArrayPattern; }
 
     virtual void transform(Creator *creator) const override {
         creator->set_type("array_pat");
         if (!m_nodes.is_empty())
             creator->append_nil(); // NOTE: I don't know what this nil is for
-        for (auto node : m_nodes)
-            creator->append(node);
+        for (auto node : m_nodes) {
+            if (node->type() == Node::Type::Splat) {
+                auto splat_node = node.static_cast_as<SplatNode>();
+                auto name = String("*");
+                if (splat_node->node()) {
+                    assert(splat_node->node()->type() == Node::Type::Symbol);
+                    name.append(splat_node->node().static_cast_as<SymbolNode>()->name().ref());
+                }
+                creator->append_symbol(name);
+            } else {
+                creator->append(node);
+            }
+        }
     }
 };
 }

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() {
@@ -31,6 +31,10 @@ public:
         m_number->prepend_char('-');
     }
 
+    bool negative() const {
+        return m_number->at(0) == '-';
+    }
+
 protected:
     SharedPtr<String> m_number;
 };

data/include/natalie_parser/node/case_in_node.hpp

@@ -29,8 +29,11 @@ public:
     virtual void transform(Creator *creator) const override {
         creator->set_type("in");
         creator->append(m_pattern.ref());
-        for (auto node : m_body->nodes())
-            creator->append(node);
+        if (!m_body->is_empty())
+            for (auto node : m_body->nodes())
+                creator->append(node);
+        else
+            creator->append_nil();
     }
 
 protected:

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,13 +23,17 @@ public:
 
     virtual void transform(Creator *creator) const override {
         creator->set_type("lit");
-        creator->append_integer(m_number);
+        creator->append_fixnum(m_number);
     }
 
     void negate() {
         m_number *= -1;
     }
 
+    bool negative() const {
+        return m_number < 0;
+    }
+
 protected:
     long long m_number;
 };

data/include/natalie_parser/node/float_node.hpp

@@ -30,6 +30,10 @@ public:
         m_number *= -1;
     }
 
+    bool negative() const {
+        return m_number < 0.0;
+    }
+
 protected:
     double m_number;
 };

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/hash_pattern_node.hpp

@@ -3,6 +3,7 @@
 #include "natalie_parser/node/hash_node.hpp"
 #include "natalie_parser/node/node.hpp"
 #include "natalie_parser/node/node_with_args.hpp"
+#include "natalie_parser/node/symbol_key_node.hpp"
 #include "tm/hashmap.hpp"
 #include "tm/string.hpp"
 

data/include/natalie_parser/node/infix_op_node.hpp

@@ -22,7 +22,7 @@ public:
 
     virtual Type type() const override { return Type::InfixOp; }
 
-    virtual bool is_callable() const override { return true; }
+    virtual bool is_callable() const override { return false; }
     virtual bool can_accept_a_block() const override { return false; }
 
     const SharedPtr<Node> left() const { return m_left; }

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/keyword_rest_pattern_node.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "natalie_parser/node/array_node.hpp"
+#include "natalie_parser/node/node.hpp"
+#include "natalie_parser/node/node_with_args.hpp"
+#include "natalie_parser/node/splat_node.hpp"
+#include "natalie_parser/node/symbol_node.hpp"
+#include "tm/hashmap.hpp"
+#include "tm/string.hpp"
+
+namespace NatalieParser {
+
+using namespace TM;
+
+class KeywordRestPatternNode : public Node {
+public:
+    KeywordRestPatternNode(const Token &token)
+        : Node { token } { }
+
+    KeywordRestPatternNode(const Token &token, String name)
+        : Node { token }
+        , m_name { new String(name) } { }
+
+    KeywordRestPatternNode(const Token &token, SharedPtr<String> name)
+        : Node { token }
+        , m_name { name } { }
+
+    virtual Type type() const override { return Type::KeywordRestPattern; }
+
+    const SharedPtr<String> name() const { return m_name; }
+
+    virtual void transform(Creator *creator) const override {
+        creator->set_type("kwrest");
+        auto name = String("**");
+        if (m_name)
+            name.append(m_name.ref());
+        creator->append_symbol(name);
+    }
+
+private:
+    SharedPtr<String> m_name;
+};
+}

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,
@@ -54,6 +56,7 @@ public:
         InterpolatedSymbol,
         InterpolatedSymbolKey,
         KeywordArg,
+        KeywordRestPattern,
         KeywordSplat,
         LogicalAnd,
         LogicalOr,
@@ -73,6 +76,7 @@ public:
         OpAssignOr,
         Pin,
         Range,
+        Rational,
         Redo,
         Regexp,
         Retry,
@@ -122,7 +126,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(); }
@@ -147,6 +151,8 @@ public:
         return type() != Type::Invalid;
     }
 
+    void debug();
+
 protected:
     static inline SharedPtr<Node> s_invalid {};
     Token m_token {};

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"
@@ -43,6 +45,7 @@
 #include "natalie_parser/node/interpolated_symbol_node.hpp"
 #include "natalie_parser/node/iter_node.hpp"
 #include "natalie_parser/node/keyword_arg_node.hpp"
+#include "natalie_parser/node/keyword_rest_pattern_node.hpp"
 #include "natalie_parser/node/keyword_splat_node.hpp"
 #include "natalie_parser/node/logical_and_node.hpp"
 #include "natalie_parser/node/logical_or_node.hpp"
@@ -63,6 +66,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

@@ -82,16 +82,26 @@ private:
     SharedPtr<Node> parse_class_or_module_name(LocalsHashmap &);
     SharedPtr<Node> parse_case(LocalsHashmap &);
     SharedPtr<Node> parse_case_in_pattern(LocalsHashmap &);
+    SharedPtr<Node> parse_case_in_pattern_alternation(LocalsHashmap &);
+    SharedPtr<Node> parse_case_in_pattern_hash_symbol_key(LocalsHashmap &);
     SharedPtr<Node> parse_case_in_patterns(LocalsHashmap &);
     void parse_comma_separated_expressions(ArrayNode &, LocalsHashmap &);
     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 +138,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 &);
@@ -188,6 +199,7 @@ private:
 
     SharedPtr<NodeWithArgs> to_node_with_args(SharedPtr<Node> node);
 
+    Token &previous_token() const;
     Token &current_token() const;
     Token &peek_token() const;
 
@@ -195,6 +207,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 = {});