parser 2.7.1.3 → 2.7.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bab855c4abc633b9ba13f855d816f20948ee539f27bea7878b574f4d0b3232f7
-  data.tar.gz: 929aa201a2c06738c6202c8efb2afd2dda77e630805738007c39f3b8274fa717
+  metadata.gz: c4dbd5dfd3a249d65b4d2b20c54b668749b3d5360e7feef7772924c135b78d86
+  data.tar.gz: ca30aca7f92a24fb96ef74c1a21149d9d43fb541d86bdae0b113f5ea5e267137
 SHA512:
-  metadata.gz: 78e2e37d1ef61d2c125c1462ecb2e48ab8f76a06fd97bcba28ea4acd5fa60f77a296f859fd6ad67a787027b7a9e62d0fc34bedc8c23522bce21213d1ca49d780
-  data.tar.gz: 07fa5ad8fe63b8503ced8fa0143062385f1d2f99e542f80cc32375269a9ad75f07cc2b0e00838232a71a9e797ba5cab28b661d8a58765f558e29353462641f06
+  metadata.gz: deb6edb6b828f309ebc6eb58e19613fe13c490e780895dfad01aceeeb0111781bc9e90b81bf6be35069afed44bd5f683c8120f134abd3d6aa7546a15fb370c19
+  data.tar.gz: 0c5a25dade42d9c74bc115aa8ecfd8dbfbcdeadc0fee6e994f44532ed994ac0c47aeccccc5405ddc9b5bd3804e4c47874163e6d468e47cb14ddd647ffb2c118c

data/.travis.yml

@@ -1,7 +1,13 @@
 dist: trusty
 language: ruby
-matrix:
+jobs:
   include:
+    - name: jruby-9.1.15.0 / Parser tests
+      rvm: jruby-9.1.15.0
+      script: bundle exec rake test
+    - name: truffleruby / Parser tests
+      rvm: truffleruby
+      script: TRUFFLERUBYOPT=--engine.Mode=latency bundle exec rake test
     - name: 2.4.10 / Parser tests
       rvm: 2.4.10
       script: bundle exec rake test_cov
@@ -17,12 +23,6 @@ matrix:
     - name: ruby-head / Parser tests
       rvm: ruby-head
       script: bundle exec rake test_cov
-    - name: jruby-9.1.15.0 / Parser tests
-      rvm: jruby-9.1.15.0
-      script: bundle exec rake test
-    - name: truffleruby / Parser tests
-      rvm: truffleruby
-      script: bundle exec rake test
     - name: 2.5.8 / Rubocop tests
       rvm: 2.5.8
       script: ./ci/run_rubocop_specs

data/CHANGELOG.md

@@ -1,9 +1,24 @@
 Changelog
 =========
 
-Not released (2020-05-26)
+Not released (2020-06-19)
 -------------------------
 
+Features implemented:
+ * ruby28.y: add find pattern. (#714) (Ilya Bylich)
+ * lexer.rl: reject `->...` and `->(...)` with the same error. (#713) (Ilya Bylich)
+ * ruby28.y: accept leading args before forward arg. (#712) (Ilya Bylich)
+ * Added `emit_forward_arg` compatibility flag. (#710) (Ilya Bylich)
+ * ruby28.y: include entire lambda expr in lambda rule. (#708) (Ilya Bylich)
+ * ruby28.y: extracted excessed_comma rule. (#706) (Ilya Bylich)
+ * Source::TreeRewriter: Improved merging and representations (#703) (Marc-André Lafortune)
+
+Bugs fixed:
+ * ruby*.y: fixed context inside lambda args and module. (#709) (Ilya Bylich)
+
+v2.7.1.3 (2020-05-26)
+---------------------
+
 API modifications:
  * fixed all warnings. tests are running in verbose mode now. (#685) (Ilya Bylich)
 

data/README.md

@@ -29,6 +29,7 @@ below for explanation of `emit_*` calls):
     Parser::Builders::Default.emit_encoding            = true
     Parser::Builders::Default.emit_index               = true
     Parser::Builders::Default.emit_arg_inside_procarg0 = true
+    Parser::Builders::Default.emit_forward_arg         = true
 
 Parse a chunk of code:
 

data/doc/AST_FORMAT.md

@@ -1164,13 +1164,13 @@ s(:numblock,
 
 ## Forward arguments
 
-### Method definition accepting forwarding arguments
+### Method definition accepting only forwarding arguments
 
 Ruby 2.7 introduced a feature called "arguments forwarding".
 When a method takes any arguments for forwarding them in the future
 the whole `args` node gets replaced with `forward-args` node.
 
-Format:
+Format if `emit_forward_arg` compatibility flag is disabled:
 
 ~~~
 (def :foo
@@ -1181,6 +1181,25 @@ Format:
         ~~~~~ expression
 ~~~
 
+However, Ruby 2.8 added support for leading arguments before `...`, and so
+it can't be used as a replacement of the `(args)` node anymore. To solve it
+`emit_forward_arg` should be enabled.
+
+Format if `emit_forward_arg` compatibility flag is enabled:
+
+~~~
+(def :foo
+  (args
+    (forward-arg)) nil)
+"def foo(...); end"
+        ~ begin (args)
+            ~ end (args)
+        ~~~~~ expression (args)
+         ~~~ expression (forward_arg)
+~~~
+
+Note that the node is called `forward_arg` when emitted separately.
+
 ### Method call taking arguments of the currently forwarding method
 
 Format:
@@ -2172,6 +2191,24 @@ Format:
       ~~~ name (match-nil-pattern)
 ~~~
 
+### Matching using find pattern
+
+Format:
+
+~~~
+(find-pattern
+  (match-rest
+    (match-var :a))
+  (int 42)
+  (match-rest))
+"in [*, 42, *]"
+    ~ begin
+             ~ end
+    ~~~~~~~~~~ expression
+~~~
+
+Note that it can be used as a top-level pattern only when used in a `case` statement. In that case `begin` and `end` are empty.
+
 ### Matching using const pattern
 
 #### With array pattern
@@ -2227,3 +2264,20 @@ Format:
     ~ expression (const-pattern.const)
      ~~ expression (const-pattern.array_pattern)
 ~~~
+
+#### With find pattern
+
+Format:
+
+~~~
+(const-pattern
+  (const nil :X)
+  (find-pattern
+    (match-rest)
+    (int 42)
+    (match-rest)))
+"in X[*, 42, *]"
+     ~ begin
+              ~ end
+    ~~~~~~~~~~~ expression
+~~~

data/lib/parser/ast/processor.rb

@@ -127,6 +127,7 @@ module Parser
       alias on_kwarg          process_argument_node
       alias on_kwoptarg       process_argument_node
       alias on_kwrestarg      process_argument_node
+      alias on_forward_arg    process_argument_node
 
       def on_procarg0(node)
         if node.children[0].is_a?(Symbol)
@@ -257,6 +258,7 @@ module Parser
       alias on_array_pattern_with_tail process_regular_node
       alias on_hash_pattern            process_regular_node
       alias on_const_pattern           process_regular_node
+      alias on_find_pattern            process_regular_node
 
       # @private
       def process_variable_node(node)

data/lib/parser/builders/default.rb

@@ -80,6 +80,8 @@ module Parser
       attr_accessor :emit_index
     end
 
+    @emit_index = false
+
     class << self
       ##
       # AST compatibility attribute; causes a single non-mlhs
@@ -95,7 +97,36 @@ module Parser
       attr_accessor :emit_arg_inside_procarg0
     end
 
-    @emit_index = false
+    @emit_arg_inside_procarg0 = false
+
+    class << self
+      ##
+      # AST compatibility attribute; arguments forwarding initially
+      # didn't have support for leading arguments
+      # (i.e. `def m(a, ...); end` was a syntax error). However, Ruby 2.8
+      # added support for any number of arguments in front of the `...`.
+      #
+      # If set to false (the default):
+      #   1. `def m(...) end` is emitted as
+      #      s(:def, :m, s(:forward_args), nil)
+      #   2. `def m(a, b, ...) end` is emitted as
+      #      s(:def, :m,
+      #        s(:args, s(:arg, :a), s(:arg, :b), s(:forward_arg)))
+      #
+      # If set to true it uses a single format:
+      #   1. `def m(...) end` is emitted as
+      #      s(:def, :m, s(:args, s(:forward_arg)))
+      #   2. `def m(a, b, ...) end` is emitted as
+      #      s(:def, :m, s(:args, s(:arg, :a), s(:arg, :b), s(:forward_arg)))
+      #
+      # It does't matter that much on 2.7 (because there can't be any leading arguments),
+      # but on 2.8 it should be better enabled to use a single AST format.
+      #
+      # @return [Boolean]
+      attr_accessor :emit_forward_arg
+    end
+
+    @emit_forward_arg = false
 
     class << self
       ##
@@ -106,6 +137,7 @@ module Parser
         @emit_encoding = true
         @emit_index = true
         @emit_arg_inside_procarg0 = true
+        @emit_forward_arg = true
       end
     end
 
@@ -709,8 +741,18 @@ module Parser
       n(:numargs, [ max_numparam ], nil)
     end
 
-    def forward_args(begin_t, dots_t, end_t)
-      n(:forward_args, [], collection_map(begin_t, token_map(dots_t), end_t))
+    def forward_only_args(begin_t, dots_t, end_t)
+      if self.class.emit_forward_arg
+        arg = forward_arg(dots_t)
+        n(:args, [ arg ],
+          collection_map(begin_t, [ arg ], end_t))
+      else
+        n(:forward_args, [], collection_map(begin_t, token_map(dots_t), end_t))
+      end
+    end
+
+    def forward_arg(dots_t)
+      n(:forward_arg, [], token_map(dots_t))
     end
 
     def arg(name_t)
@@ -1358,6 +1400,11 @@ module Parser
         collection_map(lbrack_t, elements, rbrack_t))
     end
 
+    def find_pattern(lbrack_t, elements, rbrack_t)
+      n(:find_pattern, elements,
+        collection_map(lbrack_t, elements, rbrack_t))
+    end
+
     def match_with_trailing_comma(match, comma_t)
       n(:match_with_trailing_comma, [ match ], expr_map(match.loc.expression.join(loc(comma_t))))
     end

data/lib/parser/context.rb

@@ -5,6 +5,7 @@ module Parser
   #
   # Supported states:
   # + :class - in the class body (class A; end)
+  # + :module - in the module body (module M; end)
   # + :sclass - in the singleton class body (class << obj; end)
   # + :def - in the method body (def m; end)
   # + :defs - in the singleton method body (def self.m; end)

data/lib/parser/lexer.rl

@@ -2030,7 +2030,14 @@ class Parser::Lexer
 
       '...'
       => {
-        if @version >= 27
+        if @version >= 28
+          if @lambda_stack.any? && @lambda_stack.last + 1 == @paren_nest
+            # To reject `->(...)` like `->...`
+            emit(:tDOT3)
+          else
+            emit(:tBDOT3)
+          end
+        elsif @version >= 27
           emit(:tBDOT3)
         else
           emit(:tDOT3)

data/lib/parser/macruby.y

@@ -1042,11 +1042,15 @@ rule
                       result      = @builder.block(val[0],
                                       begin_t, args, body, end_t)
                     }
-                | tLAMBDA lambda
+                | tLAMBDA
+                    {
+                      @context.push(:lambda)
+                    }
+                  lambda
                     {
                       lambda_call = @builder.call_lambda(val[0])
 
-                      args, (begin_t, body, end_t) = val[1]
+                      args, (begin_t, body, end_t) = val[2]
                       result      = @builder.block(lambda_call,
                                       begin_t, args, body, end_t)
                     }
@@ -1160,6 +1164,7 @@ rule
                     {
                       @static_env.extend_static
                       @lexer.push_cmdarg
+                      @context.push(:module)
                     }
                     bodystmt kEND
                     {
@@ -1172,6 +1177,7 @@ rule
 
                       @lexer.pop_cmdarg
                       @static_env.unextend
+                      @context.pop
                     }
                 | kDEF fname
                     {
@@ -1453,9 +1459,13 @@ rule
           lambda:   {
                       @static_env.extend_dynamic
                     }
-                  f_larglist lambda_body
+                  f_larglist
+                    {
+                      @context.pop
+                    }
+                  lambda_body
                     {
-                      result = [ val[1], val[2] ]
+                      result = [ val[1], val[3] ]
 
                       @static_env.unextend
                     }

data/lib/parser/meta.rb

@@ -26,12 +26,12 @@ module Parser
         ident root lambda indexasgn index procarg0
         restarg_expr blockarg_expr
         objc_kwarg objc_restarg objc_varargs
-        numargs numblock forward_args forwarded_args
+        numargs numblock forward_args forwarded_args forward_arg
         case_match in_match in_pattern
         match_var pin match_alt match_as match_rest
         array_pattern match_with_trailing_comma array_pattern_with_tail
         hash_pattern const_pattern if_guard unless_guard match_nil_pattern
-        empty_else
+        empty_else find_pattern
       ).map(&:to_sym).to_set.freeze
 
   end # Meta

data/lib/parser/ruby18.y

@@ -1156,6 +1156,7 @@ rule
                 | kMODULE cpath
                     {
                       @static_env.extend_static
+                      @context.push(:module)
                     }
                     bodystmt kEND
                     {
@@ -1167,6 +1168,7 @@ rule
                                                    val[3], val[4])
 
                       @static_env.unextend
+                      @context.pop
                     }
                 | kDEF fname
                     {

data/lib/parser/ruby19.y

@@ -1009,11 +1009,15 @@ rule
                       result      = @builder.block(val[0],
                                       begin_t, args, body, end_t)
                     }
-                | tLAMBDA lambda
+                | tLAMBDA
+                    {
+                      @context.push(:lambda)
+                    }
+                  lambda
                     {
                       lambda_call = @builder.call_lambda(val[0])
 
-                      args, (begin_t, body, end_t) = val[1]
+                      args, (begin_t, body, end_t) = val[2]
                       result      = @builder.block(lambda_call,
                                       begin_t, args, body, end_t)
                     }
@@ -1127,6 +1131,7 @@ rule
                     {
                       @static_env.extend_static
                       @lexer.push_cmdarg
+                      @context.push(:module)
                     }
                     bodystmt kEND
                     {
@@ -1139,6 +1144,7 @@ rule
 
                       @lexer.pop_cmdarg
                       @static_env.unextend
+                      @context.pop
                     }
                 | kDEF fname
                     {
@@ -1433,9 +1439,13 @@ rule
           lambda:   {
                       @static_env.extend_dynamic
                     }
-                  f_larglist lambda_body
+                  f_larglist
+                    {
+                      @context.pop
+                    }
+                  lambda_body
                     {
-                      result = [ val[1], val[2] ]
+                      result = [ val[1], val[3] ]
 
                       @static_env.unextend
                     }

data/lib/parser/ruby20.y

@@ -1039,11 +1039,15 @@ rule
                       result      = @builder.block(val[0],
                                       begin_t, args, body, end_t)
                     }
-                | tLAMBDA lambda
+                | tLAMBDA
+                    {
+                      @context.push(:lambda)
+                    }
+                  lambda
                     {
                       lambda_call = @builder.call_lambda(val[0])
 
-                      args, (begin_t, body, end_t) = val[1]
+                      args, (begin_t, body, end_t) = val[2]
                       result      = @builder.block(lambda_call,
                                       begin_t, args, body, end_t)
                     }
@@ -1157,6 +1161,7 @@ rule
                     {
                       @static_env.extend_static
                       @lexer.push_cmdarg
+                      @context.push(:module)
                     }
                     bodystmt kEND
                     {
@@ -1169,6 +1174,7 @@ rule
 
                       @lexer.pop_cmdarg
                       @static_env.unextend
+                      @context.pop
                     }
                 | kDEF fname
                     {
@@ -1487,9 +1493,13 @@ opt_block_args_tail:
           lambda:   {
                       @static_env.extend_dynamic
                     }
-                  f_larglist lambda_body
+                  f_larglist
+                    {
+                      @context.pop
+                    }
+                  lambda_body
                     {
-                      result = [ val[1], val[2] ]
+                      result = [ val[1], val[3] ]
 
                       @static_env.unextend
                     }