parser 2.6.5.0 → 2.7.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c12b17e36f142aa8aacc1aae95cd464ea9239cf526d973b7b1ed3f0825fc7698
-  data.tar.gz: 49948dbdc512a19d0b02d5edea2e12ff4eed8c89a2827728e5f0f9a618109b44
+  metadata.gz: 13d527f63ead893a2e151944c1bcdd8b42b7e62b59619c52c5173782d1121964
+  data.tar.gz: 741979c7e6c252b0ddd18c69b79738cc01771d2bed73ec15c30cb3b2cccd9631
 SHA512:
-  metadata.gz: 67bbf82221c9795d5a892f51ccb3c51835657448842a078bbcee88b8b1ef649643600d01d2c1c0b2e59982a774803a3a780538c433e8cc3a4fdfe8168838a697
-  data.tar.gz: 9d7053f65800e04f8f2c0b1f344d9f83efd1282744aba49c02b384ea4242a3bcc5b65b7ac3eca4c4d0c34317ed70393a1eb26e146b34517ad75810b9498eb0a7
+  metadata.gz: 53f345d27c23b86ef7fe55bcbfdbab9605f313e721c8ae75aebfa6d84073d3e738e42fbffeced65463ea1ad1233dc0297c55ad04187c36eb3c1878d36caac4dd
+  data.tar.gz: 6035992372bdc46cfd086508cfecaf3d24f014317681e45c4190b18d5fbe126fad3bf399b98ae465ab46d1827d88b7c0241998c0d4723ae780e05250b8168ad7

data/.travis.yml

@@ -20,6 +20,9 @@ matrix:
     - name: 2.6.5 / Parser tests
       rvm: 2.6.5
       script: bundle exec rake test_cov
+    - name: 2.7.0 / Parser tests
+      rvm: 2.7.0
+      script: bundle exec rake test_cov
     - name: ruby-head / Parser tests
       rvm: ruby-head
       script: bundle exec rake test_cov
@@ -35,6 +38,9 @@ matrix:
     - name: 2.6.5 / Rubocop tests
       rvm: 2.6.5
       script: ./ci/run_rubocop_specs
+    - name: 2.7.0 / Rubocop tests
+      rvm: 2.7.0
+      script: ./ci/run_rubocop_specs
   allow_failures:
     - rvm: ruby-head
     - rvm: rbx-2

data/CHANGELOG.md

@@ -1,6 +1,58 @@
 Changelog
 =========
 
+Not released (2020-03-02)
+-------------------------
+
+Bugs fixed:
+ * lexer.rl: allow spaces before comments-before-leading-dot. (#654) (Ilya Bylich)
+
+v2.7.0.2 (2020-01-08)
+---------------------
+
+Bugs fixed:
+ * lexer.rl: fix paren_nest for curly braces (#646) (Ilya Bylich)
+
+v2.7.0.1 (2019-12-30)
+---------------------
+
+Bugs fixed:
+ * dedenter.rb: prevent `ArgumentError` when processing binary en… (#642) (Koichi ITO)
+
+v2.7.0.0 (2019-12-26)
+---------------------
+
+API modifications:
+ * README.md: documented compatibility issue with EOF chars after… (#637) (Ilya Bylich)
+ * ruby27.y: refactor logic around 'circular argument reference'(#628) (Ilya Bylich)
+
+Features implemented:
+ * ruby27.y: added pattern matching (#574) (Ilya Bylich)
+ * lexer.rl: parse embedded ivars/cvars starting with digit as str (#639) (Ilya Bylich)
+ * lexer.rl: warn on `...` at EOL. (#636) (Ilya Bylich)
+ * ruby27.y: removed opt_block_args_tail: tOROP rule. (#635) (Ilya Bylich)
+ * ruby27.y: reverted method reference operator (added in #634) (Ilya Bylich)
+ * ruby27.y: treat numparams as locals outside numblock. (#633) (Ilya Bylich)
+
+Bugs fixed:
+ * dedenter.rb: fixed over-dedenting of squiggly heredocs (#641) (Ilya Bylich)
+ * ruby27.y: added "arguments forwarding" (#625) (Ilya Bylich)
+ * ruby27.y: reject circular argument reference. (#622) (Ilya Bylich)
+ * ruby27.y: changed prefix of numparams to "_" (#620) (Ilya Bylich)
+
+v2.6.5.0 (2019-10-03)
+---------------------
+
+API modifications:
+ * Bump ruby versions to 2.4.9, 2.5.7 and 2.6.5. (#619) (Ilya Bylich)
+
+Features implemented:
+ * lexer.rl: changed max numparam to `@9` (#617) (Ilya Bylich)
+ * lexer.rl: support comments before leading dot in 27 mode. (#613) (Ilya Bylich)
+
+Bugs fixed:
+ * lexer.rl: emit tMETHREF as tDOT+tCOLON for rubies \< 27. (#614) (Ilya Bylich)
+
 v2.6.4.1 (2019-09-12)
 ---------------------
 

data/README.md

@@ -234,7 +234,7 @@ Parser implements the MacRuby 0.12 and RubyMotion mid-2015 parsers precisely. Ho
 
 ## Known issues
 
-Adding support for the following Ruby MRI features in Parser would needlessly complicate it, and as they all are very specific and rarely occuring corner cases, this is not done.
+Adding support for the following Ruby MRI features in Parser would needlessly complicate it, and as they all are very specific and rarely occurring corner cases, this is not done.
 
 Parser has been extensively tested; in particular, it parses almost entire [Rubygems][rg] corpus. For every issue, a breakdown of affected gems is offered.
 
@@ -269,6 +269,13 @@ follows 2.1 behavior.
 
 No known code is affected by this issue.
 
+### EOF characters after embedded documents before 2.7
+
+Code like `"=begin\n""=end\0"` is invalid for all versions of Ruby before 2.7. Ruby 2.7 and later parses it
+normally. Parser follows 2.7 behavior.
+
+It is unknown whether any gems are affected by this issue.
+
 ## Contributors
 
 * [whitequark][]

data/doc/AST_FORMAT.md

@@ -602,18 +602,6 @@ Format:
  ~~~~~~~~~~~~~ expression
 ~~~
 
-### Method reference operator
-
-Format:
-
-~~~
-(meth-ref (self) :foo)
-"self.:foo"
-     ^^ dot
-       ^^^ selector
- ^^^^^^^^^ expression
-~~~
-
 ### Multiple assignment
 
 #### Multiple left hand side
@@ -1118,22 +1106,41 @@ Format:
 s(:numblock,
   s(:send, nil, :proc), 3,
   s(:send,
-    s(:numparam, 1), :+,
-    s(:numparam, 3)))
-"proc { @1 + @3 }"
+    s(:lvar, :_1), :+,
+    s(:lvar, :_3)))
+"proc { _1 + _3 }"
       ~ begin   ~ end
  ~~~~~~~~~~~~~~~~ expression
 ~~~
 
-### Numbered parameter
+## Forward arguments
+
+### Method definition accepting 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:
 
 ~~~
-(numparam 10)
-"@10"
- ~~~ name
- ~~~ expression
+(def :foo
+  (forward-args) nil)
+"def foo(...); end"
+            ~ end
+        ~ begin
+        ~~~~~ expression
+~~~
+
+### Method call taking arguments of the currently forwarding method
+
+Format:
+
+~~~
+(send nil :foo
+  (forwarded-args))
+"foo(...)"
+     ~~~ expression
 ~~~
 
 ## Send
@@ -1814,3 +1821,360 @@ Format:
 "__ENCODING__"
  ~~~~~~~~~~~~ expression
 ~~~
+
+## Pattern matching
+
+### Using `in` modifier
+
+Format:
+
+~~~
+(in-match
+  (int 1)
+  (match-var :a))
+"1 in a"
+   ~~ operator
+ ~~~~~~ expression
+~~~
+
+### Case with pattern matching
+
+#### Without else
+
+Format:
+
+~~~
+(case-match
+  (str "str")
+  (in-pattern
+    (match-var :foo)
+    (lvar :bar)) nil)
+"case "str"; in foo; bar; end"
+ ~~~~ keyword             ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+#### With else
+
+Format:
+
+~~~
+(case-match,
+  (str "str")
+  (in-pattern
+    (match-var :foo)
+    (lvar :bar))
+  (lvar :baz))
+"case "str"; in foo; bar; else; baz; end"
+ ~~~~ keyword             ~~~~ else  ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+#### With empty else
+
+Empty `else` differs from the missing (or _implicit_) `else` for pattern matching, since
+the latter one raises a `NoMatchingPattern` exception. Thus, we need a way to distinguish this
+two cases in the resulting AST.
+
+Format:
+
+~~~
+(case-match,
+  (str "str")
+  (in-pattern
+    (match-var :foo)
+    (lvar :bar))
+  (empty-else))
+"case "str"; in foo; bar; else; end"
+ ~~~~ keyword             ~~~~ else
+                                ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+### In clause
+
+Format:
+
+~~~
+(in-pattern
+  (match-var :foo)
+  (lvar :bar))
+"in foo then bar"
+ ~~ keyword
+        ~~~~ begin
+ ~~~~~~~~~~~~~~~ expression
+~~~
+
+### If guard
+
+This guard runs after matching, so it's not an `if` modifier.
+
+Format:
+
+~~~
+(in-pattern
+  (match-var :foo)
+  (if-guard
+    (lvar :bar)) nil)
+"in foo if bar"
+        ~~ keyword
+        ~~~~~~ expression
+~~~
+
+### Unless guard
+
+This guard runs after matching, so it's not an `unless` modifier.
+
+Format:
+
+~~~
+(in-pattern
+  (match-var :foo)
+  (unless-guard
+    (lvar :bar)) nil)
+"in foo unless bar"
+        ~~~~~~ keyword
+        ~~~~~~~~~~ expression
+~~~
+
+### Match variable
+
+Format:
+
+~~~
+(match-var :foo)
+"in foo"
+    ~~~ name
+    ~~~ expression
+~~~
+
+### Match rest
+
+#### With name
+
+Format:
+
+~~~
+(match-rest
+  (match-var :foo))
+"in *foo"
+    ~ operator
+    ~~~~ expression
+~~~
+
+#### Without name
+
+Format:
+
+~~~
+(match-rest)
+"in *"
+    ~ operator
+    ~ expression
+~~~
+
+### Pin operator
+
+Format:
+
+~~~
+(pin
+  (lvar :foo))
+"in ^foo"
+    ~ selector
+    ~~~~ expression
+~~~
+
+### Match alternative
+
+Format:
+
+~~~
+(match-alt
+  (pin
+    (lvar :foo))
+  (int 1))
+"in ^foo | 1"
+         ~ operator
+    ~~~~~~~~ expression
+~~~
+
+### Match with alias
+
+Format:
+
+~~~
+(match-as
+  (int 1)
+  (match-var :foo))
+"in 1 => foo"
+      ~~ operator
+    ~~~~~~~~ expression
+~~~
+
+### Match using array pattern
+
+#### Explicit
+
+Format:
+
+~~~
+(array-pattern
+  (pin
+    (lvar :foo))
+  (match-var :bar))
+"in [^foo, bar]"
+    ~ begin   ~ end
+    ~~~~~~~~~~~ expression
+~~~
+
+#### Explicit with tail
+
+Adding a trailing comma in the end works as `, *`
+
+Format:
+
+~~~
+(array-pattern-with-tail
+  (pin
+    (lvar :foo))
+  (match-var :bar))
+"in [^foo, bar,]"
+    ~ begin    ~ end
+    ~~~~~~~~~~~~ expression
+~~~
+
+#### Implicit
+
+Format:
+
+~~~
+(array-pattern
+  (pin
+    (lvar :foo))
+  (match-var :bar))
+"in ^foo, bar"
+    ~~~~~~~~~ expression
+~~~
+
+#### Implicit with tail
+
+Format:
+
+Adding a trailing comma in the end works as `, *`,
+so a single item match with comma gets interpreted as an array.
+
+~~~
+(array-pattern-with-tail
+  (match-var :foo))
+"in foo,"
+    ~~~ expression
+~~~
+
+### Matching using hash pattern
+
+#### Explicit
+
+Format:
+
+~~~
+(hash-pattern
+  (pair
+    (sym :a)
+    (int 10)))
+"in { a: 10 }"
+    ~ begin ~ end
+    ~~~~~~~~~ expression
+~~~
+
+#### Implicit
+
+Format:
+
+~~~
+(hash-pattern
+  (pair
+    (sym :a)
+    (int 10)))
+"in a: 10"
+    ~~~~~ expression
+~~~
+
+#### Assignment using hash pattern
+
+Format:
+
+~~~
+(hash-pattern
+  (match-var :a))
+"in a:"
+    ~ name (match-var)
+    ~~ expression (match-var)
+~~~
+
+#### Nil hash pattern
+
+Format:
+~~~
+(hash-pattern
+  (match-nil-pattern))
+"in **nil"
+    ~~~~~ expression (match-nil-pattern)
+      ~~~ name (match-nil-pattern)
+~~~
+
+### Matching using const pattern
+
+#### With array pattern
+
+Format:
+
+~~~
+(const-pattern
+  (const nil :X)
+  (array-pattern
+    (pin
+      (lvar :foo))
+    (match-var :bar)))
+"in X[^foo bar]"
+     ~ begin (const-pattern)
+               ~ end (const-pattern)
+     ~~~~~~~~~~~ expression (const-pattern)
+    ~ name (const-pattern.const)
+    ~ expression (const-pattern.const)
+~~~
+
+#### With hash pattern
+
+Format:
+
+~~~
+(const-pattern
+  (const nil :X)
+  (hash-pattern
+    (match-var :foo)
+    (match-var :bar)))
+"in X[foo:, bar:]"
+     ~ begin (const-pattern)
+                ~ end (const-pattern)
+     ~~~~~~~~~~~~ expression (const-pattern)
+    ~ name (const-pattern.const)
+    ~ expression (const-pattern.const)
+~~~
+
+#### With array pattern without elements
+
+Format:
+
+~~~
+(const-pattern
+  (const nil :X)
+  (array-pattern))
+"in X[]"
+     ~ begin (const-pattern)
+      ~ end (const-pattern)
+     ~~ expression (const-pattern)
+    ~ name (const-pattern.const)
+    ~ expression (const-pattern.const)
+     ~~ expression (const-pattern.array_pattern)
+~~~