parser 2.0.0.beta5 → 2.0.0.beta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef56ab825b77544fdfbc486ccb592cede5bd7da3
-  data.tar.gz: 30dcf6e9bd3566babf73ba48b026cd7521f32f07
+  metadata.gz: ff9e3b7f7bacab0b950939c52f7df525def64ecc
+  data.tar.gz: 79f7bfdc451009618f190696b9d01ab9fb2a66d4
 SHA512:
-  metadata.gz: 4274e893bce829d8736cb57659eae865c76b520903c3175d2b24475e90a2219596572972c179591677d37801b978fd855189df7e4405a30020e6cfa1d74e6193
-  data.tar.gz: c79fdcbe3ab0b0927773111ee0b5699bf337eb53fd4aad3911bcd1ca2801cd6f8d7d2cbdcc846031dd115bd24c910b383a92ca21c5395d85f8354f6d4c8109a6
+  metadata.gz: 20a42c7ac8a381a0eff6cdd2cca9a9dc74e1b8eea8463e8b12fa910c97e5d666402db364cd9cdd1d57c7ddb17ef148dc38d171a6be5d078f62acaa78a777ba21
+  data.tar.gz: 975bf3b4ebe25e4d34e2a6b5a28cd4447ec91b1b4f5b29bed0b025a29e5a5a42b15c72d73b0b54aeeaffabdcc0357d8edd8091ce4093f8b40be616a0851a317e

data/CHANGELOG.md

@@ -1,6 +1,26 @@
 Changelog
 =========
 
+v2.0.0.beta6 (2013-06-17)
+-------------------------
+
+API modifications:
+ * Get rid of "synthesized (nil)". If it's not in source, it's not in AST (fixes #71). (Peter Zotov)
+ * lexer.rl, ruby{18,19,20,21}.y: source maps for interpolation (fixes #27). (Peter Zotov)
+
+Features implemented:
+ * ruby{18,19,20,21}.y, builders/default: lvar-injecting match (closes #69). (Peter Zotov)
+ * builders/default: implicit matches (refs #69). (Peter Zotov)
+ * builders/default: flip-flops (refs #69). (Peter Zotov)
+
+Bugs fixed:
+ * lexer.rl: fix an off-by-1 error in heredoc parsing. (Peter Zotov)
+ * lexer.rl: don't fail on "alias $a $b\n# comment\nalias $c $d". (Peter Zotov)
+ * builders/default: fix treatment of masgn in &&/|| (refs #69). (Peter Zotov)
+ * ruby-parse: make -L command line option work again. (Peter Zotov)
+ * ruby{18,19,20,21}.y: begin source map for "if foo\nthen bar end" (fixes #68). (Peter Zotov)
+ * Source::Comment::Associator: gracefully terminate when out of comments (fixes #67). (Peter Zotov)
+
 v2.0.0.beta5 (2013-06-08)
 -------------------------
 

data/README.md

@@ -31,14 +31,14 @@ p Parser::CurrentRuby.parse("2 + 2")
 Access the AST's source map:
 
 ~~~ ruby
-p Parser::CurrentRuby.parse("2 + 2").src
+p Parser::CurrentRuby.parse("2 + 2").loc
 # #<Parser::Source::Map::Send:0x007fe0ca8a69b8
 #   @begin=nil,
 #   @end=nil,
 #   @expression=#<Source::Range (string) 0...5>,
 #   @selector=#<Source::Range (string) 2...3>>
 
-p Parser::CurrentRuby.parse("2 + 2").src.selector.to_source
+p Parser::CurrentRuby.parse("2 + 2").loc.selector.to_source
 # "+"
 ~~~
 
@@ -104,7 +104,6 @@ $ ruby-parse -E -e "2+2"
  * Improved [clang-like][] diagnostic messages with location information.
  * Written in pure Ruby, runs on MRI 1.8.7 or >=1.9.2, JRuby and Rubinius in 1.8 and 1.9 mode.
  * Only two runtime dependencies: the gems [ast][] and [slop][].
- * RubyParser compatibility (WIP, no, not really yet).
  * [Insane][insane-lexer] Ruby lexer rewritten from scratch in Ragel.
  * 100% test coverage for Bison grammars (except error recovery).
  * Readable, commented source code.
@@ -128,7 +127,7 @@ Documentation for parser is available online on [rdoc.info](http://rdoc.info/git
 
 ## Acknowledgements
 
-The lexer testsuite and ruby_parser compatibility testsuite are derived from [ruby_parser](http://github.com/seattlerb/ruby_parser).
+The lexer testsuite is derived from [ruby_parser](http://github.com/seattlerb/ruby_parser).
 
 The Bison parser rules are derived from [Ruby MRI](http://github.com/ruby/ruby) parse.y.
 

data/doc/AST_FORMAT.md

@@ -1,14 +1,6 @@
 AST and Source Location RFC
 ===========================
 
-## Open questions:
-
- * Should we handle these cases at all? They do not have special syntax associated.
-   1. How to handle lvar-injecting match (`if /(?<a>foo)/ =~ bar`)?
-   1. How to handle magic match (`foo if /bar/`)?
-   1. How to handle sed-like flip-flop?
-   1. How to handle awk-like flip-flop?
-
 ## Literals
 
 ### Singletons
@@ -1441,3 +1433,40 @@ Format:
  ~~~~~~~~~~~~~~~~~~ expression
 ~~~
 
+## Miscellanea
+
+### Flip-flops
+
+Format:
+
+~~~
+(iflipflop (lvar :a) (lvar :b))
+"if a..b; end"
+     ~~ operator
+    ~~~~ expression
+
+(eflipflop (lvar :a) (lvar :b))
+"if a...b; end"
+     ~~~ operator
+    ~~~~~ expression
+~~~
+
+### Implicit matches
+
+Format:
+
+~~~
+(match-current-line (regexp (str "a") (regopt)))
+"if /a/; end"
+~~~
+
+### Local variable injecting matches
+
+Format:
+
+~~~
+(match-with-lvasgn (regexp (str "(?<match>bar)") (regopt)) (lvar :baz))
+"/(?<match>bar)/ =~ baz"
+                 ~~ selector
+ ~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~

data/lib/parser/ast/processor.rb

@@ -20,7 +20,7 @@ module Parser
       def on_var(node)
         name, = *node
 
-        node.updated
+        node
       end
 
       def process_variable_node(node)
@@ -37,8 +37,9 @@ module Parser
       def on_vasgn(node)
         name, value_node = *node
 
-        value_node = process(value_node) if value_node
-        node.updated(nil, [ name, value_node ])
+        node.updated(nil, [
+          name, process(value_node)
+        ])
       end
 
       def process_var_asgn_node(node)
@@ -67,16 +68,17 @@ module Parser
       def on_const(node)
         scope_node, name = *node
 
-        scope_node = process(scope_node) if scope_node
-        node.updated(nil, [ scope_node, name ])
+        node.updated(nil, [
+          process(scope_node), name
+        ])
       end
 
       def on_casgn(node)
         scope_node, name, value_node = *node
 
-        scope_node = process(scope_node) if scope_node
-        value_node = process(value_node) if value_node
-        node.updated(nil, [ scope_node, name, value_node ])
+        node.updated(nil, [
+          process(scope_node), name, process(value_node)
+        ])
       end
 
       alias on_args     process_regular_node
@@ -84,8 +86,9 @@ module Parser
       def on_argument(node)
         arg_name, value_node = *node
 
-        value_node = process(value_node) if value_node
-        node.updated(nil, [ arg_name, value_node ])
+        node.updated(nil, [
+          arg_name, process(value_node)
+        ])
       end
 
       def process_argument_node(node)
@@ -104,18 +107,9 @@ module Parser
       alias on_restarg_expr   process_regular_node
       alias on_blockarg_expr  process_regular_node
 
-      alias on_module   process_regular_node
-
-      def on_class(node)
-        name_node, superclass_node, body_node = *node
-
-        superclass_node = process(superclass_node) if superclass_node
-        node.updated(nil, [
-          name_node, superclass_node, process(body_node)
-        ])
-      end
-
-      alias on_sclass   process_regular_node
+      alias on_module         process_regular_node
+      alias on_class          process_regular_node
+      alias on_sclass         process_regular_node
 
       def on_def(node)
         name, args_node, body_node = *node
@@ -166,55 +160,13 @@ module Parser
       alias on_and      process_regular_node
       alias on_or       process_regular_node
 
-      def on_if(node)
-        cond_node, if_true_node, if_false_node = *node
-
-        if_true_node  = process(if_true_node)  if if_true_node
-        if_false_node = process(if_false_node) if if_false_node
-
-        node.updated(nil, [
-          process(cond_node),
-          if_true_node, if_false_node
-        ])
-      end
+      alias on_if       process_regular_node
 
       alias on_when     process_regular_node
+      alias on_case     process_regular_node
 
-      def on_case(node)
-        cond_node, *bodies = *node
-        when_nodes, else_node = bodies[0..-2], bodies[-1]
-
-        cond_node = process(cond_node) if cond_node
-        else_node = process(else_node) if else_node
-        node.updated(nil, [
-          cond_node,
-          *(process_all(when_nodes) << else_node)
-        ])
-      end
-
-      def on_resbody(node)
-        exc_list_node, exc_var_node, body_node = *node
-
-        exc_list_node = process(exc_list_node) if exc_list_node
-        exc_var_node  = process(exc_var_node)  if exc_var_node
-
-        node.updated(nil, [
-          exc_list_node, exc_var_node,
-          process(body_node)
-        ])
-      end
-
-      def on_rescue(node)
-        body_node, *handlers = *node
-        handler_nodes, else_node = handlers[0..-2], handlers[-1]
-
-        else_node = process(else_node) if else_node
-        node.updated(nil, [
-          process(body_node),
-          *(process_all(handler_nodes) << else_node)
-        ])
-      end
-
+      alias on_resbody  process_regular_node
+      alias on_rescue   process_regular_node
       alias on_ensure   process_regular_node
 
       alias on_begin    process_regular_node

data/lib/parser/builders/default.rb

@@ -616,6 +616,28 @@ module Parser
         source_map)
     end
 
+    def match_op(receiver, match_t, arg)
+      source_map = send_binary_op_map(receiver, match_t, arg)
+
+      if receiver.type == :regexp &&
+            receiver.children.count == 2 &&
+            receiver.children.first.type == :str
+
+        regexp_str, _regopt = *receiver
+        regexp_body, = *regexp_str
+
+        Regexp.new(regexp_body).names.each do |name|
+          @parser.static_env.declare(name)
+        end
+
+        n(:match_with_lvasgn, [ receiver, arg ],
+          source_map)
+      else
+        n(:send, [ receiver, :=~, arg ],
+          source_map)
+      end
+    end
+
     def unary_op(op_t, receiver)
       case value(op_t)
       when '+', '-'
@@ -628,14 +650,17 @@ module Parser
         send_unary_op_map(op_t, receiver))
     end
 
-    def not_op(not_t, receiver=nil)
+    def not_op(not_t, begin_t=nil, receiver=nil, end_t=nil)
       if @parser.version == 18
         n(:not, [ receiver ],
           unary_op_map(not_t, receiver))
       else
         if receiver.nil?
-          n(:send, [ n0(:nil, nil), :'!' ],
-            send_unary_op_map(not_t, nil))
+          nil_node = n0(:begin, collection_map(begin_t, nil, end_t))
+
+          n(:send, [
+            nil_node, :'!'
+          ], send_unary_op_map(not_t, nil_node))
         else
           n(:send, [ receiver, :'!' ],
             send_unary_op_map(not_t, receiver))
@@ -650,7 +675,7 @@ module Parser
     # Logical operations: and, or
 
     def logical_op(type, lhs, op_t, rhs)
-      n(type, [ check_condition(lhs), check_condition(rhs) ],
+      n(type, [ lhs, rhs ],
         binary_op_map(lhs, op_t, rhs))
     end
 
@@ -765,10 +790,10 @@ module Parser
 
     def compstmt(statements)
       case
+      when statements.none?
+        nil
       when statements.one?
         statements.first
-      when statements.none?
-        n0(:nil, expr_map(nil))
       else
         n(:begin, statements,
           collection_map(nil, statements, nil))
@@ -776,11 +801,10 @@ module Parser
     end
 
     def begin(begin_t, body, end_t)
-      if body.nil? || synthesized_nil?(body)
-        # A nil expression, or a synthesized (nil) from compstmt
-        # without any inner statements.
-        n0(:nil,
-          expr_map(loc(begin_t).join(loc(end_t))))
+      if body.nil?
+        # A nil expression: `()' or `begin end'.
+        n0(:begin,
+          collection_map(begin_t, nil, end_t))
       elsif body.type == :mlhs  ||
            (body.type == :begin &&
             body.loc.begin.nil? && body.loc.end.nil?)
@@ -794,6 +818,8 @@ module Parser
       end
     end
 
+    alias :begin_keyword :begin
+
     private
 
     #
@@ -801,14 +827,37 @@ module Parser
     #
 
     def check_condition(cond)
-      if cond.type == :masgn
+      case cond.type
+      when :masgn
         diagnostic :error, ERRORS[:masgn_as_condition],
                    cond.loc.expression
-      elsif cond.type == :begin
-        check_condition(cond.children.last)
-      end
 
-      cond
+      when :begin
+        if cond.children.count == 1
+          check_condition(cond.children.last)
+        else
+          cond
+        end
+
+      when :and, :or, :irange, :erange
+        lhs, rhs = *cond
+
+        type = case cond.type
+        when :irange; :iflipflop
+        when :erange; :eflipflop
+        end
+
+        cond.updated(type, [
+          check_condition(lhs),
+          check_condition(rhs)
+        ])
+
+      when :regexp
+        n(:match_current_line, [ cond ], nil)
+
+      else
+        cond
+      end
     end
 
     def check_duplicate_args(args, map={})
@@ -1074,7 +1123,7 @@ module Parser
 
       if end_t
         end_l = loc(end_t)
-      elsif args.any? && !synthesized_nil?(args.last)
+      elsif args.any? && !args.last.nil?
         end_l = args.last.loc.expression
       elsif args.any? && args.count > 1
         end_l = args[-2].loc.expression
@@ -1098,7 +1147,7 @@ module Parser
         end_l = else_e.loc.expression
       elsif loc(else_t)
         end_l = loc(else_t)
-      elsif body_e.loc.expression
+      elsif body_e && body_e.loc.expression
         end_l = body_e.loc.expression
       elsif loc(begin_t)
         end_l = loc(begin_t)
@@ -1125,7 +1174,8 @@ module Parser
     def rescue_body_map(keyword_t, exc_list_e, assoc_t,
                         exc_var_e, then_t,
                         compstmt_e)
-      end_l = compstmt_e.loc.expression || loc(then_t)
+      end_l = compstmt_e.loc.expression if compstmt_e
+      end_l = loc(then_t)               if end_l.nil? && then_t
       end_l = exc_var_e.loc.expression  if end_l.nil? && exc_var_e
       end_l = exc_list_e.loc.expression if end_l.nil? && exc_list_e
       end_l = loc(keyword_t)            if end_l.nil?
@@ -1136,7 +1186,7 @@ module Parser
 
     def eh_keyword_map(compstmt_e, keyword_t, body_es,
                        else_t, else_e)
-      if synthesized_nil?(compstmt_e)
+      if compstmt_e.nil?
         if keyword_t.nil?
           begin_l = body_es.first.loc.expression
         else
@@ -1148,7 +1198,7 @@ module Parser
 
       if else_t
         end_l = else_e.loc.expression
-      elsif !synthesized_nil?(body_es.last)
+      elsif !body_es.last.nil?
         end_l = body_es.last.loc.expression
       else
         end_l = loc(keyword_t)
@@ -1167,10 +1217,6 @@ module Parser
           [:str, :dstr].include?(parts.first.type)
     end
 
-    def synthesized_nil?(node)
-      node.type == :nil && node.loc.expression.nil?
-    end
-
     def value(token)
       token[0]
     end