parser 2.6.5.0 → 2.7.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c12b17e36f142aa8aacc1aae95cd464ea9239cf526d973b7b1ed3f0825fc7698
-  data.tar.gz: 49948dbdc512a19d0b02d5edea2e12ff4eed8c89a2827728e5f0f9a618109b44
+  metadata.gz: eb64651ef64daa71d4c55d8ab253c90ce470eaf85f3b0ce98dfe5f171a681c80
+  data.tar.gz: a875a3b5c4a92b7fae3a58c379c300519e7c328641a7cb8d8a65e3f131118eed
 SHA512:
-  metadata.gz: 67bbf82221c9795d5a892f51ccb3c51835657448842a078bbcee88b8b1ef649643600d01d2c1c0b2e59982a774803a3a780538c433e8cc3a4fdfe8168838a697
-  data.tar.gz: 9d7053f65800e04f8f2c0b1f344d9f83efd1282744aba49c02b384ea4242a3bcc5b65b7ac3eca4c4d0c34317ed70393a1eb26e146b34517ad75810b9498eb0a7
+  metadata.gz: 8bd9f983ef31671217011a895e07b466f5327578f1dbc2288e5bcd08e367d038e0ee53c35ee1851323c8b04ab20e3fd27c1347a7615c869a99ebcebc8a949baf
+  data.tar.gz: cab52019893fb86e6fe66aaa9391d9d6cd721daac62550f7a0d2303bafbcc6deac349c4366315f8bc4ba15f6309b7ead3f30e3ff8fcd0e15a394c63c86071db7

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,52 @@
 Changelog
 =========
 
+Not released (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

@@ -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,322 @@ 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
+~~~
+
+### 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)
+~~~