natalie_parser 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88d3e8539a0c9f60203b9d0c914091e0ea4f436629b26b1dca6926edf0488e0a
-  data.tar.gz: 0d165c15a569ec4c76c8cb8de2b2aae13fa502956ff1a38adafd358b7cdecea0
+  metadata.gz: b35f9b98f6bbe4ec3bf8d5d9bce2c7e082504db23f442964f2a58e1ac9e11dc7
+  data.tar.gz: 1fbf06aa6fae8400855ea0d363d77a1b27d78869266bfb17b0f45cf9b8a30d41
 SHA512:
-  metadata.gz: 9f7f6fad13b1c17cf5efde219fc13ce4dd70e47448f65ea13b0e92f98587acec95355bea454c37de60b5bf9a367862cb8611f6a2fa60a3adb7d4fc9e31e62d2c
-  data.tar.gz: 682ad83ec17e2e1077e4ec826aed547a781a89a4fadccd00c34613e20d945b0795396cb7efbd356430002792e1fea0099dcf3ec72a2cb174a3a5e28adb4290d0
+  metadata.gz: 936ec0ef70541afd5839dbe4450401d7e8713499c3536d9ac7e53eb5617671dd308eee8e4f458188a9b0890f5a7ed5d855b3011c5539b64eb31639b4140e07fc
+  data.tar.gz: f6deb35c75e17e5c9fb49c6092e48453e904e7c7d4b515e2c7b5fe7fe69dc656da2faa6096b665b6021557ae8c47844ec65a9e8aca1933712f35d72f4db47c50

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 2.0.0 (2022-06-24)
+
+- FEAT: Differentiate between bare/implicit hash and explicit one
+- FIX: Fix calling colon2
+- FIX: Parse implicit method calls with nth ref argument
+
 ## 1.2.1 (2022-06-16)
 
 - FIX: Fix regression with unary/infix operators (+/-)

data/include/natalie_parser/node/colon2_node.hpp

@@ -23,6 +23,7 @@ public:
     virtual Type type() const override { return Type::Colon2; }
 
     virtual bool is_assignable() const override { return true; }
+    virtual bool is_callable() const override { return true; }
 
     const SharedPtr<Node> left() const { return m_left; }
     SharedPtr<String> name() const { return m_name; }

data/include/natalie_parser/node/hash_node.hpp

@@ -11,8 +11,9 @@ using namespace TM;
 
 class HashNode : public Node {
 public:
-    HashNode(const Token &token)
-        : Node { token } { }
+    HashNode(const Token &token, bool bare)
+        : Node { token }
+        , m_bare { bare } { }
 
     virtual Type type() const override { return Type::Hash; }
 
@@ -23,12 +24,16 @@ public:
     const Vector<SharedPtr<Node>> &nodes() const { return m_nodes; }
 
     virtual void transform(Creator *creator) const override {
-        creator->set_type("hash");
+        if (m_bare)
+            creator->set_type("bare_hash");
+        else
+            creator->set_type("hash");
         for (auto node : m_nodes)
             creator->append(node);
     }
 
 protected:
     Vector<SharedPtr<Node>> m_nodes {};
+    bool m_bare { false };
 };
 }

data/include/natalie_parser/node/hash_pattern_node.hpp

@@ -14,7 +14,7 @@ using namespace TM;
 class HashPatternNode : public HashNode {
 public:
     HashPatternNode(const Token &token)
-        : HashNode { token } { }
+        : HashNode { token, true } { }
 
     virtual Type type() const override { return Type::HashPattern; }
 

data/include/natalie_parser/parser.hpp

@@ -104,7 +104,7 @@ private:
     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> = {});
+    SharedPtr<Node> parse_hash_inner(LocalsHashmap &, Precedence, Token::Type, bool, SharedPtr<Node> = {});
     SharedPtr<Node> parse_identifier(LocalsHashmap &);
     SharedPtr<Node> parse_if(LocalsHashmap &);
     void parse_interpolated_body(LocalsHashmap &, InterpolatedNode &, Token::Type);

data/include/natalie_parser/token.hpp

@@ -775,6 +775,7 @@ public:
         case Token::Type::NilKeyword:
         case Token::Type::Not:
         case Token::Type::NotKeyword:
+        case Token::Type::NthRef:
         case Token::Type::PercentLowerI:
         case Token::Type::PercentLowerW:
         case Token::Type::PercentUpperI:

data/lib/natalie_parser/version.rb

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

data/src/parser.cpp

@@ -337,7 +337,7 @@ SharedPtr<Node> Parser::parse_array(LocalsHashmap &locals) {
             return array.static_cast_as<Node>();
         }
         if (token.type() == Token::Type::SymbolKey) {
-            array->add_node(parse_hash_inner(locals, Precedence::HASH, Token::Type::RBracket));
+            array->add_node(parse_hash_inner(locals, Precedence::HASH, Token::Type::RBracket, true));
             expect(Token::Type::RBracket, "array closing bracket");
             advance();
             return array.static_cast_as<Node>();
@@ -345,7 +345,7 @@ SharedPtr<Node> Parser::parse_array(LocalsHashmap &locals) {
         auto value = parse_expression(Precedence::ARRAY, locals);
         token = current_token();
         if (token.is_hash_rocket()) {
-            array->add_node(parse_hash_inner(locals, Precedence::HASH, Token::Type::RBracket, value));
+            array->add_node(parse_hash_inner(locals, Precedence::HASH, Token::Type::RBracket, true, value));
             expect(Token::Type::RBracket, "array closing bracket");
             advance();
             return array.static_cast_as<Node>();
@@ -1299,17 +1299,17 @@ SharedPtr<Node> Parser::parse_hash(LocalsHashmap &locals) {
     advance();
     SharedPtr<Node> hash;
     if (current_token().type() == Token::Type::RCurlyBrace)
-        hash = new HashNode { token };
+        hash = new HashNode { token, false };
     else
-        hash = parse_hash_inner(locals, Precedence::HASH, Token::Type::RCurlyBrace);
+        hash = parse_hash_inner(locals, Precedence::HASH, Token::Type::RCurlyBrace, false);
     expect(Token::Type::RCurlyBrace, "hash closing curly brace");
     advance();
     return hash;
 }
 
-SharedPtr<Node> Parser::parse_hash_inner(LocalsHashmap &locals, Precedence precedence, Token::Type closing_token_type, SharedPtr<Node> first_key) {
+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 };
+    SharedPtr<HashNode> hash = new HashNode { token, bare };
     if (!first_key)
         first_key = parse_expression(precedence, locals);
     hash->add_node(first_key);
@@ -1640,7 +1640,7 @@ SharedPtr<Node> Parser::parse_keyword_splat(LocalsHashmap &locals) {
 }
 
 SharedPtr<Node> Parser::parse_keyword_splat_wrapped_in_hash(LocalsHashmap &locals) {
-    SharedPtr<HashNode> hash = new HashNode { current_token() };
+    SharedPtr<HashNode> hash = new HashNode { current_token(), true };
     hash->add_node(parse_keyword_splat(locals));
     return hash.static_cast_as<Node>();
 }
@@ -2337,12 +2337,13 @@ void Parser::parse_call_args(NodeWithArgs &node, LocalsHashmap &locals, bool bar
         m_call_depth.last()--;
 }
 
-SharedPtr<Node> Parser::parse_call_hash_args(LocalsHashmap &locals, bool bare, Token::Type closing_token_type, SharedPtr<Node> first_arg) {
+SharedPtr<Node> Parser::parse_call_hash_args(LocalsHashmap &locals, bool bare_call, Token::Type closing_token_type, SharedPtr<Node> first_arg) {
+    bool bare_hash = true; // we got here via foo(1, a: 'b') so it's always a "bare" hash
     SharedPtr<Node> hash;
-    if (bare)
-        hash = parse_hash_inner(locals, Precedence::BARE_CALL_ARG, closing_token_type, first_arg);
+    if (bare_call)
+        hash = parse_hash_inner(locals, Precedence::BARE_CALL_ARG, closing_token_type, bare_hash, first_arg);
     else
-        hash = parse_hash_inner(locals, Precedence::CALL_ARG, closing_token_type, first_arg);
+        hash = parse_hash_inner(locals, Precedence::CALL_ARG, closing_token_type, bare_hash, first_arg);
     if (current_token().type() == Token::Type::StarStar)
         hash.static_cast_as<HashNode>()->add_node(parse_keyword_splat(locals));
     return hash;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: natalie_parser
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Tim Morgan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-17 00:00:00.000000000 Z
+date: 2022-06-24 00:00:00.000000000 Z
 dependencies: []
 description: NatalieParser is a zero-dependency, from-scratch, hand-written recursive
   descent parser for the Ruby Programming Language.