parser 2.3.0.pre.2 → 2.3.0.pre.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 14dd2ca8115c4ab1497d4dfaf8673ab57ed5fb06
-  data.tar.gz: 6bc8d4ec18bad73f47efe573b605bfe5a97d2c74
+  metadata.gz: 374ddf2bd2cca89254c973f71c865f131ef55f17
+  data.tar.gz: 212ddd9876be32894d1523b25d3415087a09ee42
 SHA512:
-  metadata.gz: a1b6d7835452acf9714b9351780ebefe92d636744141db3a2c06a872571918dffab06019d807bf402ffff70466771a6caf50eab3b7eaebb1032b044c2d3cebcd
-  data.tar.gz: 9fdc0e9e46f95acd62904467a2e3d0cb077845b5d840a526756738fdeda3e8542a132af9a4826d44853ac538a661e5d600fae08239103a6c37aa76686c4d99ab
+  metadata.gz: b8fa11379a34cce56319589a6e8159919edf5583d41a602e5fdbfe6e4ddb7ae58ff3292552e4dd247ecf535387e58dc0d80695e4cebc422506ffc3d8ec1378e8
+  data.tar.gz: 764f0680aa9fdd6cf7dcf53b47cccea3f847e7f40930a2ce7d8a8b1ae835a54140a28e5f33ec31b5802a612cac909c02ed8bd8182c28c1c26f74042e8d99504c

data/.gitignore

@@ -22,5 +22,6 @@ lib/parser/ruby19.rb
 lib/parser/ruby20.rb
 lib/parser/ruby21.rb
 lib/parser/ruby22.rb
+lib/parser/ruby23.rb
 lib/parser/macruby.rb
 lib/parser/rubymotion.rb

data/.travis.yml

@@ -12,7 +12,7 @@ rvm:
  - rbx-2
 matrix:
  allow_failures:
-  - rvm: rbx-2
+  - rvm: ruby-head
 before_install:
  - gem update bundler
  - bundle --version

data/CHANGELOG.md

@@ -1,6 +1,40 @@
 Changelog
 =========
 
+v2.3.0.pre.3 (2015-11-25)
+-------------------------
+
+API modifications:
+ * builders/default: introduce a (lambda) node (fixes #212). (whitequark)
+ * lexer.rl: do not override argument variable. (Keiji, Yoshimi)
+ * lexer.rl: rename variable names from lit to current_literal. (Keiji, Yoshimi)
+ * lexer.rl: use Regexp to match string. (Keiji, Yoshimi)
+ * lib/parser/source/buffer: reduce respond_to?(:bsearch) (Keiji, Yoshimi)
+ * lexer.rl: reduce String literal allocations (Keiji, Yoshimi)
+ * lexer.rl: reduce respond_to?(:encode) method call on #advance (Keiji, Yoshimi)
+ * lexer.rl: reduce Stirng.length method call on #advance (Keiji, Yoshimi)
+ * lexer.rl: reduce .class method call on #advance (Keiji, Yoshimi)
+
+Features implemented:
+ * lexer.rl, ruby23.y: "a&.b": implement "safe navigation operator" (fixes #209). (whitequark)
+ * ruby23.y: fork grammar. (whitequark)
+
+Bugs fixed:
+ * lexer.rl: never let EOF token location point past EOF. (whitequark)
+
+v2.2.3.0 (2015-10-08)
+---------------------
+
+Bugs fixed:
+ * lexer.rl: "-> a: {}": state after -> is ENDFN, not END (fixes #203). (whitequark)
+ * ruby{21,22}.y: "p -> { :hello }, a: 1 do end": lexpop cmdarg. (whitequark)
+
+v2.2.2.6 (2015-06-30)
+---------------------
+
+API modifications:
+ * parser/current: link to README from syntax deviation warning. (whitequark)
+
 v2.3.0.pre.2 (2015-06-15)
 -------------------------
 

data/README.md

@@ -5,8 +5,9 @@
 [![Code Climate](https://codeclimate.com/github/whitequark/parser.png)](https://codeclimate.com/github/whitequark/parser)
 [![Coverage Status](https://coveralls.io/repos/whitequark/parser/badge.png?branch=master)](https://coveralls.io/r/whitequark/parser)
 
-_Parser_ is a production-ready Ruby parser written in pure Ruby. It performs on
-par or better than Ripper, Melbourne, JRubyParser or ruby\_parser.
+_Parser_ is a production-ready Ruby parser written in pure Ruby. It recognizes as
+much or more code than Ripper, Melbourne, JRubyParser or ruby\_parser, and
+is vastly more convenient to use.
 
 You can also use [unparser](https://github.com/mbj/unparser) to produce
 equivalent source code from Parser's ASTs.
@@ -23,6 +24,7 @@ MacRuby and RubyMotion support sponsored by [CodeClimate](http://codeclimate.com
 Parse a chunk of code:
 
     require 'parser/current'
+    Parser::Builders::Default.emit_lambda = true # opt-in to most recent AST format
 
     p Parser::CurrentRuby.parse("2 + 2")
     # (send

data/Rakefile

@@ -24,6 +24,7 @@ GENERATED_FILES = %w(lib/parser/lexer.rb
                      lib/parser/ruby20.rb
                      lib/parser/ruby21.rb
                      lib/parser/ruby22.rb
+                     lib/parser/ruby23.rb
                      lib/parser/macruby.rb
                      lib/parser/rubymotion.rb)
 

data/doc/AST_FORMAT.md

@@ -540,6 +540,31 @@ Format:
  ~~~~~~~ expression
 ~~~
 
+### To attribute
+
+Format:
+
+~~~
+(send (self) :foo= (int 1))
+"self.foo = 1"
+     ^ dot
+      ~~~ selector
+          ^ operator
+ ~~~~~~~~~~~~ expression
+~~~
+
+### To attribute, using "safe navigation operator"
+
+Format:
+
+~~~
+(csend (self) :foo= (int 1))
+"self&.foo = 1"
+     ^^ dot
+       ~~~ selector
+           ^ operator
+ ~~~~~~~~~~~~~ expression
+~~~
 
 ### Multiple assignment
 
@@ -1011,9 +1036,9 @@ Format:
 ~~~
 (objc-restarg (objc-kwarg :foo))
 "(*a: b)"
-   ~ arg.keyword
-    ~ arg.operator
-      ~ arg.argument
+   ~ objc-kwarg.keyword
+    ~ objc-kwarg.operator
+      ~ objc-kwarg.argument
   ~ operator
   ~~~~~ expression
 ~~~
@@ -1053,6 +1078,7 @@ Format:
 ~~~
 (send (lvar :foo) :bar (int 1))
 "foo.bar(1)"
+    ^ dot
      ~~~ selector
         ^ begin
           ^ end
@@ -1146,6 +1172,22 @@ Used when passing expression as block `foo(&bar)`
         ~~~~ expression
 ~~~
 
+### "Stabby lambda"
+
+~~~
+(block (lambda) (args) nil)
+"-> {}"
+ ~~ lambda.expression
+~~~
+
+### "Safe navigation operator"
+
+~~~
+(csend (send nil :foo) :bar)
+"foo&.bar"
+    ~~ dot
+~~~
+
 ### Objective-C variadic send
 
 MacRuby allows to pass a variadic amount of arguments via the last

data/lib/parser/all.rb

@@ -2,3 +2,5 @@ require 'parser/ruby18'
 require 'parser/ruby19'
 require 'parser/ruby20'
 require 'parser/ruby21'
+require 'parser/ruby22'
+require 'parser/ruby23'

data/lib/parser/ast/processor.rb

@@ -24,6 +24,7 @@ module Parser
         node
       end
 
+      # @private
       def process_variable_node(node)
         on_var(node)
       end
@@ -43,6 +44,7 @@ module Parser
         ])
       end
 
+      # @private
       def process_var_asgn_node(node)
         on_vasgn(node)
       end
@@ -92,6 +94,7 @@ module Parser
         ])
       end
 
+      # @private
       def process_argument_node(node)
         on_argument(node)
       end
@@ -185,7 +188,30 @@ module Parser
 
       alias on_preexe   process_regular_node
       alias on_postexe  process_regular_node
-    end
 
+      # @private
+      def process_variable_node(node)
+        warn 'Parser::AST::Processor#process_variable_node is deprecated as a' \
+          ' public API and will be removed. Please use ' \
+          'Parser::AST::Processor#on_var instead.'
+        on_var(node)
+      end
+
+      # @private
+      def process_var_asgn_node(node)
+        warn 'Parser::AST::Processor#process_var_asgn_node is deprecated as a' \
+          ' public API and will be removed. Please use ' \
+          'Parser::AST::Processor#on_vasgn instead.'
+        on_vasgn(node)
+      end
+
+      # @private
+      def process_argument_node(node)
+        warn 'Parser::AST::Processor#process_argument_node is deprecated as a' \
+          ' public API and will be removed. Please use ' \
+          'Parser::AST::Processor#on_argument instead.'
+        on_argument(node)
+      end
+    end
   end
 end

data/lib/parser/builders/default.rb

@@ -4,6 +4,32 @@ module Parser
   # Default AST builder. Uses {AST::Node}s.
   #
   class Builders::Default
+    class << self
+      ##
+      # AST compatibility attribute; since `-> {}` is not semantically
+      # equivalent to `lambda {}`, all new code should set this attribute
+      # to true.
+      #
+      # If set to false (the default), `-> {}` is emitted as
+      # `s(:block, s(:send, nil, :lambda), s(:args), nil)`.
+      #
+      # If set to true, `-> {}` is emitted as
+      # `s(:block, s(:lambda), s(:args), nil)`.
+      #
+      # @return [Boolean]
+      attr_accessor :emit_lambda
+    end
+
+    @emit_lambda = false
+
+    class << self
+      ##
+      # @api private
+      def modernize
+        @emit_lambda = true
+      end
+    end
+
     ##
     # @api private
     attr_accessor :parser
@@ -650,20 +676,41 @@ module Parser
     # Method calls
     #
 
+    def call_type_for_dot(dot_t)
+      if !dot_t.nil? && value(dot_t) == :anddot
+        :csend
+      else
+        # This case is a bit tricky. ruby23.y returns the token tDOT with
+        # the value :dot, and the token :tANDDOT with the value :anddot.
+        #
+        # But, ruby{18..22}.y (which unconditionally expect tDOT) just
+        # return "." there, since they are to be kept close to the corresponding
+        # Ruby MRI grammars.
+        #
+        # Thankfully, we don't have to care.
+        :send
+      end
+    end
+
     def call_method(receiver, dot_t, selector_t,
                     lparen_t=nil, args=[], rparen_t=nil)
+      type = call_type_for_dot(dot_t)
       if selector_t.nil?
-        n(:send, [ receiver, :call, *args ],
+        n(type, [ receiver, :call, *args ],
           send_map(receiver, dot_t, nil, lparen_t, args, rparen_t))
       else
-        n(:send, [ receiver, value(selector_t).to_sym, *args ],
+        n(type, [ receiver, value(selector_t).to_sym, *args ],
           send_map(receiver, dot_t, selector_t, lparen_t, args, rparen_t))
       end
     end
 
     def call_lambda(lambda_t)
-      n(:send, [ nil, :lambda ],
-        send_map(nil, nil, lambda_t))
+      if self.class.emit_lambda
+        n0(:lambda, expr_map(loc(lambda_t)))
+      else
+        n(:send, [ nil, :lambda ],
+          send_map(nil, nil, lambda_t))
+      end
     end
 
     def block(method_call, begin_t, args, body, end_t)
@@ -678,7 +725,7 @@ module Parser
         diagnostic :error, :block_and_blockarg, nil, last_arg.loc.expression, [loc(begin_t)]
       end
 
-      if [:send, :super, :zsuper].include?(method_call.type)
+      if [:send, :super, :zsuper, :lambda].include?(method_call.type)
         n(:block, [ method_call, args, body ],
           block_map(method_call.loc.expression, begin_t, end_t))
       else
@@ -710,9 +757,10 @@ module Parser
 
     def attr_asgn(receiver, dot_t, selector_t)
       method_name = (value(selector_t) + '=').to_sym
+      type = call_type_for_dot(dot_t)
 
       # Incomplete method call.
-      n(:send, [ receiver, method_name ],
+      n(type, [ receiver, method_name ],
         send_map(receiver, dot_t, selector_t))
     end
 

data/lib/parser/current.rb

@@ -3,6 +3,7 @@ module Parser
     def warn_syntax_deviation(feature, version)
       warn "warning: parser/current is loading #{feature}, which recognizes"
       warn "warning: #{version}-compliant syntax, but you are running #{RUBY_VERSION}."
+      warn "warning: please see https://github.com/whitequark/parser#compatibility-with-ruby-mri."
     end
     private :warn_syntax_deviation
   end
@@ -48,6 +49,14 @@ module Parser
     require 'parser/ruby22'
     CurrentRuby = Ruby22
 
+  when /^2\.3\./
+    if RUBY_VERSION != '2.3.0'
+      warn_syntax_deviation 'parser/ruby23', '2.3.0'
+    end
+
+    require 'parser/ruby23'
+    CurrentRuby = Ruby23
+
   else # :nocov:
     # Keep this in sync with released Ruby.
     warn_syntax_deviation 'parser/ruby22', '2.2.x'

data/lib/parser/lexer.rl

@@ -87,6 +87,13 @@ class Parser::Lexer
     'v' => "\v", '\\' => "\\"
   }
 
+  BLANK_STRING = ''.freeze
+  ESCAPED_NEXT_LINE = "\\\n".freeze
+  REGEXP_META_CHARACTERS = Regexp.union(*"\\$()*+.<>?[]^{|}".chars).freeze
+  UNDERSCORE_STRING = '_'.freeze
+
+  RBRACE_OR_RPAREN = %w"} ]".freeze
+
   attr_reader   :source_buffer
   attr_reader   :encoding
 
@@ -105,6 +112,8 @@ class Parser::Lexer
     @tokens     = nil
     @comments   = nil
 
+    @has_encode = ''.respond_to?(:encode)
+
     reset
   end
 
@@ -125,6 +134,7 @@ class Parser::Lexer
     @source        = nil # source string
     @source_pts    = nil # @source as a codepoint array
     @encoding      = nil # target encoding for output strings
+    @need_encode = nil
 
     @p             = 0   # stream position (saved manually in #advance)
     @ts            = nil # token start
@@ -187,11 +197,12 @@ class Parser::Lexer
 
       if defined?(Encoding) && @source.encoding == Encoding::UTF_8
         @source_pts = @source.unpack('U*')
+        @need_encode = @has_encode && @encoding != Encoding::UTF_8
       else
         @source_pts = @source.unpack('C*')
       end
 
-      if (@source_pts.size > 1_000_000 && @source.respond_to?(:encode)) ||
+      if (@source_pts.size > 1_000_000 && @has_encode) ||
          @force_utf32
         # A heuristic: if the buffer is larger than 1M, then
         # store it in UTF-32 and convert the tokens as they're
@@ -205,6 +216,7 @@ class Parser::Lexer
         #
         # Patches accepted.
         @source = @source.encode(Encoding::UTF_32LE)
+        @need_encode = @has_encode && @encoding != Encoding::UTF_32LE
       end
 
       if @source_pts[0] == 0xfeff
@@ -270,20 +282,22 @@ class Parser::Lexer
     end
 
     # Ugly, but dependent on Ragel output. Consider refactoring it somehow.
-    _lex_trans_keys         = self.class.send :_lex_trans_keys
-    _lex_key_spans          = self.class.send :_lex_key_spans
-    _lex_index_offsets      = self.class.send :_lex_index_offsets
-    _lex_indicies           = self.class.send :_lex_indicies
-    _lex_trans_targs        = self.class.send :_lex_trans_targs
-    _lex_trans_actions      = self.class.send :_lex_trans_actions
-    _lex_to_state_actions   = self.class.send :_lex_to_state_actions
-    _lex_from_state_actions = self.class.send :_lex_from_state_actions
-    _lex_eof_trans          = self.class.send :_lex_eof_trans
-
-    p, pe, eof = @p, @source.length + 1, @source.length + 1
-
-    @command_state = (@cs == self.class.lex_en_expr_value ||
-                      @cs == self.class.lex_en_line_begin)
+    klass = self.class
+    _lex_trans_keys         = klass.send :_lex_trans_keys
+    _lex_key_spans          = klass.send :_lex_key_spans
+    _lex_index_offsets      = klass.send :_lex_index_offsets
+    _lex_indicies           = klass.send :_lex_indicies
+    _lex_trans_targs        = klass.send :_lex_trans_targs
+    _lex_trans_actions      = klass.send :_lex_trans_actions
+    _lex_to_state_actions   = klass.send :_lex_to_state_actions
+    _lex_from_state_actions = klass.send :_lex_from_state_actions
+    _lex_eof_trans          = klass.send :_lex_eof_trans
+
+    pe = @source.length + 1
+    p, eof = @p, pe
+
+    @command_state = (@cs == klass.lex_en_expr_value ||
+                      @cs == klass.lex_en_line_begin)
 
     %% write exec;
     # %
@@ -292,10 +306,11 @@ class Parser::Lexer
 
     if @token_queue.any?
       @token_queue.shift
-    elsif @cs == self.class.lex_error
+    elsif @cs == klass.lex_error
       [ false, [ '$error', range(p - 1, p) ] ]
     else
-      [ false, [ '$eof',   range(p, p)     ] ]
+      eof = @source.length
+      [ false, [ '$eof',   range(eof, eof) ] ]
     end
   end
 
@@ -320,7 +335,9 @@ class Parser::Lexer
     end
 
     def tok(s = @ts, e = @te)
-      @source[s...e].encode(@encoding)
+      source = @source[s...e]
+      return source unless @need_encode
+      source.encode(@encoding)
     end
   else
     def encode_escape(ord)
@@ -444,7 +461,7 @@ class Parser::Lexer
     '=>'  => :tASSOC,   '::'  => :tCOLON2,  '===' => :tEQQ,
     '<=>' => :tCMP,     '[]'  => :tAREF,    '[]=' => :tASET,
     '{'   => :tLCURLY,  '}'   => :tRCURLY,  '`'   => :tBACK_REF2,
-    '!@'  => :tBANG,
+    '!@'  => :tBANG,    '&.'  => :tANDDOT,
   }
 
   PUNCTUATION_BEGIN = {
@@ -828,15 +845,16 @@ class Parser::Lexer
 
   action extend_string {
     string = @source[@ts...@te]
-    string = string.encode(@encoding) if string.respond_to?(:encode)
+    string = string.encode(@encoding) if @need_encode
 
     # tLABEL_END is only possible in non-cond context on >= 2.2
     if @version >= 22 && !@cond.active?
       lookahead = @source[@te...@te+2]
-      lookahead = lookahead.encode(@encoding) if lookahead.respond_to?(:encode)
+      lookahead = lookahead.encode(@encoding) if @need_encode
     end
 
-    if !literal.heredoc? && (token = literal.nest_and_try_closing(string, @ts, @te, lookahead))
+    current_literal = literal
+    if !current_literal.heredoc? && (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
       if token[0] == :tLABEL_END
         p += 1
         pop_literal
@@ -844,14 +862,15 @@ class Parser::Lexer
       else
         fnext *pop_literal;
       end
-       fbreak;
+      fbreak;
     else
-      literal.extend_string(string, @ts, @te)
+      current_literal.extend_string(string, @ts, @te)
     end
   }
 
   action extend_string_escaped {
-    if literal.nest_and_try_closing('\\', @ts, @ts + 1)
+    current_literal = literal
+    if current_literal.nest_and_try_closing('\\', @ts, @ts + 1)
       # If the literal is actually closed by the backslash,
       # rewind the input prior to consuming the escape sequence.
       p = @escape_s - 1
@@ -860,12 +879,12 @@ class Parser::Lexer
       # Get the first character after the backslash.
       escaped_char = @source[@escape_s].chr
 
-      if literal.munge_escape? escaped_char
+      if current_literal.munge_escape? escaped_char
         # If this particular literal uses this character as an opening
         # or closing delimiter, it is an escape sequence for that
         # particular character. Write it without the backslash.
 
-        if literal.regexp? && "\\$()*+.<>?[]^{|}".include?(escaped_char)
+        if current_literal.regexp? && REGEXP_META_CHARACTERS.match(escaped_char)
           # Regular expressions should include escaped delimiters in their
           # escaped form, except when the escaped character is
           # a closing delimiter but not a regexp metacharacter.
@@ -874,9 +893,9 @@ class Parser::Lexer
           # at the same time as an escape symbol, but it is always munged,
           # so this branch also executes for the non-closing-delimiter case
           # for the backslash.
-          literal.extend_string(tok, @ts, @te)
+          current_literal.extend_string(tok, @ts, @te)
         else
-          literal.extend_string(escaped_char, @ts, @te)
+          current_literal.extend_string(escaped_char, @ts, @te)
         end
       else
         # It does not. So this is an actual escape sequence, yay!
@@ -891,12 +910,12 @@ class Parser::Lexer
 
         @escape.call if @escape.respond_to? :call
 
-        if literal.regexp?
+        if current_literal.regexp?
           # Regular expressions should include escape sequences in their
           # escaped form. On the other hand, escaped newlines are removed.
-          literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
+          current_literal.extend_string(tok.gsub(ESCAPED_NEXT_LINE, BLANK_STRING), @ts, @te)
         else
-          literal.extend_string(@escape || tok, @ts, @te)
+          current_literal.extend_string(@escape || tok, @ts, @te)
         end
       end
     end
@@ -906,27 +925,28 @@ class Parser::Lexer
   # As heredoc closing line can immediately precede EOF, this action
   # has to handle such case specially.
   action extend_string_eol {
+    current_literal = literal
     if @te == pe
       diagnostic :fatal, :string_eof, nil,
-                 range(literal.str_s, literal.str_s + 1)
+                 range(current_literal.str_s, current_literal.str_s + 1)
     end
 
-    if literal.heredoc?
-      line = tok(@herebody_s, @ts).gsub(/\r+$/, '')
+    if current_literal.heredoc?
+      line = tok(@herebody_s, @ts).gsub(/\r+$/, BLANK_STRING)
 
       if version?(18, 19, 20)
         # See ruby:c48b4209c
-        line = line.gsub(/\r.*$/, '')
+        line = line.gsub(/\r.*$/, BLANK_STRING)
       end
 
       # Try ending the heredoc with the complete most recently
       # scanned line. @herebody_s always refers to the start of such line.
-      if literal.nest_and_try_closing(line, @herebody_s, @ts)
+      if current_literal.nest_and_try_closing(line, @herebody_s, @ts)
         # Adjust @herebody_s to point to the next line.
         @herebody_s = @te
 
         # Continue regular lexing after the heredoc reference (<<END).
-        p = literal.heredoc_e - 1
+        p = current_literal.heredoc_e - 1
         fnext *pop_literal; fbreak;
       else
         # Ditto.
@@ -934,7 +954,7 @@ class Parser::Lexer
       end
     else
       # Try ending the literal with a newline.
-      if literal.nest_and_try_closing(tok, @ts, @te)
+      if current_literal.nest_and_try_closing(tok, @ts, @te)
         fnext *pop_literal; fbreak;
       end
 
@@ -952,14 +972,14 @@ class Parser::Lexer
       end
     end
 
-    if literal.words? && !eof_codepoint?(@source_pts[p])
-      literal.extend_space @ts, @te
+    if current_literal.words? && !eof_codepoint?(@source_pts[p])
+      current_literal.extend_space @ts, @te
     else
       # A literal newline is appended if the heredoc was _not_ closed
       # this time (see fbreak above). See also Literal#nest_and_try_closing
       # for rationale of calling #flush_string here.
-      literal.extend_string tok, @ts, @te
-      literal.flush_string
+      current_literal.extend_string tok, @ts, @te
+      current_literal.flush_string
     end
   }
 
@@ -977,8 +997,9 @@ class Parser::Lexer
   interp_var = '#' ( global_var | class_var_v | instance_var_v );
 
   action extend_interp_var {
-    literal.flush_string
-    literal.extend_content
+    current_literal = literal
+    current_literal.flush_string
+    current_literal.extend_content
 
     emit(:tSTRING_DVAR, nil, @ts, @ts + 1)
 
@@ -1003,22 +1024,24 @@ class Parser::Lexer
   e_lbrace = '{' % {
     @cond.push(false); @cmdarg.push(false)
 
-    if literal
-      literal.start_interp_brace
+    current_literal = literal
+    if current_literal
+      current_literal.start_interp_brace
     end
   };
 
   e_rbrace = '}' % {
-    if literal
-      if literal.end_interp_brace_and_try_closing
+    current_literal = literal
+    if current_literal
+      if current_literal.end_interp_brace_and_try_closing
         if version?(18, 19)
           emit(:tRCURLY, '}', p - 1, p)
         else
           emit(:tSTRING_DEND, '}', p - 1, p)
         end
 
-        if literal.saved_herebody_s
-          @herebody_s = literal.saved_herebody_s
+        if current_literal.saved_herebody_s
+          @herebody_s = current_literal.saved_herebody_s
         end
 
         fhold;
@@ -1029,17 +1052,18 @@ class Parser::Lexer
   };
 
   action extend_interp_code {
-    literal.flush_string
-    literal.extend_content
+    current_literal = literal
+    current_literal.flush_string
+    current_literal.extend_content
 
     emit(:tSTRING_DBEG, '#{')
 
-    if literal.heredoc?
-      literal.saved_herebody_s = @herebody_s
+    if current_literal.heredoc?
+      current_literal.saved_herebody_s = @herebody_s
       @herebody_s = nil
     end
 
-    literal.start_interp_brace
+    current_literal.start_interp_brace
     fcall expr_value;
   }
 
@@ -1891,7 +1915,7 @@ class Parser::Lexer
         emit_table(PUNCTUATION, @ts, @ts + 2)
 
         @lambda_stack.push @paren_nest
-        fbreak;
+        fnext expr_endfn; fbreak;
       };
 
       e_lbrace | 'do'
@@ -1987,8 +2011,8 @@ class Parser::Lexer
       => {
         digits = tok(@num_digits_s, @num_suffix_s)
 
-        if digits.end_with? '_'
-          diagnostic :error, :trailing_in_number, { :character => '_' },
+        if digits.end_with? UNDERSCORE_STRING
+          diagnostic :error, :trailing_in_number, { :character => UNDERSCORE_STRING },
                      range(@te - 1, @te)
         elsif digits.empty? && @num_base == 8 && version?(18)
           # 1.8 did not raise an error on 0o.
@@ -2085,7 +2109,7 @@ class Parser::Lexer
       # METHOD CALLS
       #
 
-      '.' | '::'
+      '.' | '&.' | '::'
       => { emit_table(PUNCTUATION)
            fnext expr_dot; fbreak; };
 
@@ -2121,7 +2145,7 @@ class Parser::Lexer
         emit_table(PUNCTUATION)
         @cond.lexpop; @cmdarg.lexpop
 
-        if %w"} ]".include?(tok)
+        if RBRACE_OR_RPAREN.include?(tok)
           fnext expr_endarg;
         else # )
           # fnext expr_endfn; ?
@@ -2176,9 +2200,8 @@ class Parser::Lexer
       # Insane leading dots:
       # a #comment
       #  .b: a.b
-      c_space* '.' ( c_any - '.' )
-      => { fhold; fhold;
-           fgoto expr_end; };
+      c_space* %{ tm = p } ('.' | '&.')
+      => { p = tm - 1; fgoto expr_end; };
 
       any
       => { emit(:tNL, nil, @newline_s, @newline_s + 1)