parser 2.7.1.0 → 2.7.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46184af7a1e0d843e62e720cd7795bb196972603e588eed69f47791b3c799288
-  data.tar.gz: 1a9d809fc7443fb09deb3a36ea19ad418ff56119040b14a292c9ed8d112d1f29
+  metadata.gz: 58735baf961ddf249964c59136cdfc0c5abbb15f09e2d09c591442cad5e559fb
+  data.tar.gz: f77b0c5380882d193b3e20f383eecaa92fd9a3807ca8b85154138677a493b02f
 SHA512:
-  metadata.gz: 9a91995ac131a4048976358a7bce1bd09b09893bb0b13fa39f2128c47fb0b1179f830a4adbb766df768bfbd2f89a1c5a5ee437dc1433ccaf5ad2307ff7c09d77
-  data.tar.gz: 4fe835bc9fe1ff030d57e9a4d9a4657a0d244db23bac3c117e8f78bfc51d9dc330f51257e04c8ba5ef737d3feab11152db2e1ecde1e8b136d4fcc4f253ed549d
+  metadata.gz: 702a6fe61f52f33fcbd3324a347fa4ffa5f3677503b53324637502db1d762c8007f2e45fdf57745f520d48e2ec1f48913f31ad1b1e5f360115d0fc4634532bb7
+  data.tar.gz: eb549a8defabd4dccd7ee746b32b59886b12380d370a5293dcc3f3ab3cad39b959d65e7cc2c72a8e366fb67102930eaf84cf104ff8361b95a97939eb39c1dc71

data/.travis.yml

@@ -1,9 +1,15 @@
 dist: trusty
 language: ruby
-matrix:
+jobs:
   include:
-    - name: 2.4.9 / Parser tests
-      rvm: 2.4.9
+    - 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
     - name: 2.5.8 / Parser tests
       rvm: 2.5.8
@@ -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_cov
-    - name: rbx-2 / Parser tests
-      rvm: rbx-2
-      script: bundle exec rake test_cov
     - name: 2.5.8 / Rubocop tests
       rvm: 2.5.8
       script: ./ci/run_rubocop_specs
@@ -34,9 +34,8 @@ matrix:
       script: ./ci/run_rubocop_specs
   allow_failures:
     - rvm: ruby-head
-    - rvm: rbx-2
+    - rvm: truffleruby
     - script: ./ci/run_rubocop_specs
 before_install:
-  - gem install bundler -v '< 2'
   - bundle --version
   - gem --version

data/CHANGELOG.md

@@ -1,9 +1,78 @@
 Changelog
 =========
 
-Not released (2020-04-03)
+Not released (2020-09-24)
 -------------------------
 
+API modifications:
+ * right assignment: use existing AST node types (#738) (#739) (Marc-André Lafortune)
+ * ruby28.y -> ruby30.y (#729) (Vladimir Dementyev)
+
+Features implemented:
+ * Optimize Range#column_range (#741) (Marc-André Lafortune)
+ * ruby30.y: reject endless setter. (#736) (Ilya Bylich)
+ * ruby28.y: reject assignment to numparam. (#725) (Ilya Bylich)
+ * emit "endless method def" as `:def` node. (#716) (Ilya Bylich)
+
+Bugs fixed:
+ * rename 2.8 to 3.0 everywhere (#732) (Ilya Bylich)
+ * test_current.rb: 2.8 -> 3.0 (#731) (Vladimir Dementyev)
+ * Parser#parse returns nil instead of false if error is thrown (#722) (Marc-André Lafortune)
+ * unify locations for normal and endless method definition (#718) (Marc-André Lafortune)
+ * ruby27.y: accept const names as hash keys for pattern matching (#717) (Koichi ITO)
+ * Fix locations for alias / undef nodes with internal symbols (#715) (Marc-André Lafortune)
+
+v2.7.1.4 (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)
+
+Features implemented:
+ * ruby-[parse, rewrite]: add legacy switches (#699) (Marc-André Lafortune)
+ * Added Parser::Source::Range#to_range. (#697) (Ilya Bylich)
+ * ruby28.y: support rescue modifier in endless method definition. (#696) (Ilya Bylich)
+ * ruby28.y: unify kwrest and no-kwrest rules. (#694) (Ilya Bylich)
+ * ruby28.y: add right hand assignment (#682) (Vladimir Dementyev)
+
+Bugs fixed:
+ * fix Comment.associate for postfix conditions/loops (#688) (Marc-André Lafortune)
+
+v2.7.1.2 (2020-04-30)
+---------------------
+
+Features implemented:
+ * ruby28.y: endless method definition (#676) (Vladimir Dementyev)
+ * ruby28.y: branch parser (#677) (Vladimir Dementyev)
+
+Bugs fixed:
+ * ruby27.y: reject invalid lvar in pattern matching (#680) (Vladimir Dementyev)
+
+v2.7.1.1 (2020-04-15)
+---------------------
+
+Features implemented:
+ * Add Source::Range#eql? and hash (#675) (Marc-André Lafortune)
+ * Source::TreeRewriter: Add #merge, #merge! and #empty? (#674) (Marc-André Lafortune)
+
+v2.7.1.0 (2020-04-03)
+---------------------
+
 API modifications:
  * Bump ruby versions to 2.4.10, 2.5.8, 2.6.6, 2.7.1. (#665) (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:
 
@@ -59,8 +60,7 @@ Parse a chunk of code and display all diagnostics:
       puts diag.render
     end
 
-    buffer = Parser::Source::Buffer.new('(string)')
-    buffer.source = "foo *bar"
+    buffer = Parser::Source::Buffer.new('(string)', source: "foo *bar")
 
     p parser.parse(buffer)
     # (string):1:5: warning: `*' interpreted as argument prefix

data/Rakefile

@@ -11,7 +11,7 @@ task :default => [:test]
 Rake::TestTask.new do |t|
   t.libs       = %w(test/ lib/)
   t.test_files = FileList["test/**/test_*.rb"]
-  t.warning    = false
+  t.warning    = true
 end
 
 task :test_cov do
@@ -32,6 +32,7 @@ GENERATED_FILES = %w(lib/parser/lexer.rb
                      lib/parser/ruby25.rb
                      lib/parser/ruby26.rb
                      lib/parser/ruby27.rb
+                     lib/parser/ruby30.rb
                      lib/parser/macruby.rb
                      lib/parser/rubymotion.rb)
 

data/doc/AST_FORMAT.md

@@ -637,7 +637,7 @@ Format:
 (masgn (mlhs (ivasgn :@a) (cvasgn :@@b)) (array (splat (lvar :c))))
 "@a, @@b = *c"
 
-(masgn (mlhs (mlhs (lvasgn :a) (lvasgn :b)) (lvasgn :c)) (lvar :d))
+(masgn (mlhs (lvasgn :a) (mlhs (lvasgn :b)) (lvasgn :c)) (lvar :d))
 "a, (b, c) = d"
 
 (masgn (mlhs (send (self) :a=) (send (self) :[]= (int 1))) (lvar :a))
@@ -730,6 +730,29 @@ Format:
 
 ~~~
 
+### Right-hand assignment
+
+Format:
+
+~~~
+(lvasgn :a (int 1))
+"1 => a"
+ ~~~~~~ expression
+      ~ name
+   ~~ operator
+~~~
+
+#### Multiple right-hand assignment
+
+Format:
+
+~~~
+(masgn (mlhs (lvasgn :a) (lvasgn :b)) (send (int 13) :divmod (int 5)))
+"13.divmod(5) => a,b"
+ ~~~~~~~~~~~~~~~~~~~ expression
+              ^^ operator
+~~~
+
 ## Class and module definition
 
 ### Module
@@ -802,6 +825,33 @@ Format:
  ~~~~~~~~~~~~~~~~~ expression
 ~~~
 
+### "Endless" method
+
+Format:
+
+~~~
+(def :foo (args) (int 42))
+"def foo() = 42"
+ ~~~ keyword
+     ~~~ name
+           ^ assignment
+ ~~~~~~~~~~~~~~ expression
+~~~
+
+
+### "Endless" singleton method
+
+Format:
+
+~~~
+(defs (self) :foo (args) (int 42))
+"def self.foo() = 42"
+ ~~~ keyword
+          ~~~ name
+                ^ assignment
+ ~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
 ### Undefinition
 
 Format:
@@ -1115,13 +1165,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
@@ -1132,6 +1182,25 @@ Format:
         ~~~~~ expression
 ~~~
 
+However, Ruby 3.0 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:
@@ -2123,6 +2192,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
@@ -2178,3 +2265,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.rb

@@ -46,6 +46,7 @@ module Parser
     require 'parser/source/map/variable'
     require 'parser/source/map/keyword'
     require 'parser/source/map/definition'
+    require 'parser/source/map/method_definition'
     require 'parser/source/map/send'
     require 'parser/source/map/index'
     require 'parser/source/map/condition'

data/lib/parser/all.rb

@@ -10,3 +10,4 @@ require 'parser/ruby24'
 require 'parser/ruby25'
 require 'parser/ruby26'
 require 'parser/ruby27'
+require 'parser/ruby30'

data/lib/parser/ast/processor.rb

@@ -124,6 +124,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)
@@ -250,6 +251,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/base.rb

@@ -177,16 +177,16 @@ module Parser
     end
 
     ##
-    # Parses a source buffer and returns the AST.
+    # Parses a source buffer and returns the AST, or `nil` in case of a non fatal error.
     #
     # @param [Parser::Source::Buffer] source_buffer The source buffer to parse.
-    # @return [Parser::AST::Node]
+    # @return [Parser::AST::Node, nil]
     #
     def parse(source_buffer)
       @lexer.source_buffer = source_buffer
       @source_buffer       = source_buffer
 
-      do_parse
+      do_parse || nil # Force `false` to `nil`, see https://github.com/ruby/racc/pull/136
     ensure
       # Don't keep references to the source file.
       @source_buffer       = nil
@@ -210,8 +210,9 @@ module Parser
 
     ##
     # Parses a source buffer and returns the AST, the source code comments,
-    # and the tokens emitted by the lexer. If `recover` is true and a fatal
-    # {SyntaxError} is encountered, `nil` is returned instead of the AST, and
+    # and the tokens emitted by the lexer. In case of a fatal error, a {SyntaxError}
+    # is raised, unless `recover` is true. In case of an error
+    # (non-fatal or recovered), `nil` is returned instead of the AST, and
     # comments as well as tokens are only returned up to the location of
     # the error.
     #

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 3.0
+      # 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 3.0 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
 
@@ -557,7 +589,11 @@ module Parser
       when :ident
         name, = *node
 
-        check_assignment_to_numparam(node)
+        var_name = node.children[0].to_s
+        name_loc = node.loc.expression
+
+        check_assignment_to_numparam(var_name, name_loc)
+        check_reserved_for_numparam(var_name, name_loc)
 
         @parser.static_env.declare(name)
 
@@ -619,6 +655,14 @@ module Parser
         binary_op_map(lhs, eql_t, rhs))
     end
 
+    def rassign(lhs, assoc_t, rhs)
+      assign(rhs, assoc_t, lhs)
+    end
+
+    def multi_rassign(lhs, assoc_t, rhs)
+      multi_assign(rhs, assoc_t, lhs)
+    end
+
     #
     # Class and module definition
     #
@@ -648,23 +692,38 @@ module Parser
 
     def def_method(def_t, name_t, args,
                    body, end_t)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:def, [ value(name_t).to_sym, args, body ],
         definition_map(def_t, nil, name_t, end_t))
     end
 
+    def def_endless_method(def_t, name_t, args,
+                           assignment_t, body)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
+      n(:def, [ value(name_t).to_sym, args, body ],
+        endless_definition_map(def_t, nil, name_t, assignment_t, body))
+    end
+
     def def_singleton(def_t, definee, dot_t,
                       name_t, args,
                       body, end_t)
-      case definee.type
-      when :int, :str, :dstr, :sym, :dsym,
-           :regexp, :array, :hash
+      validate_definee(definee)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
 
-        diagnostic :error, :singleton_literal, nil, definee.loc.expression
+      n(:defs, [ definee, value(name_t).to_sym, args, body ],
+        definition_map(def_t, dot_t, name_t, end_t))
+    end
 
-      else
-        n(:defs, [ definee, value(name_t).to_sym, args, body ],
-          definition_map(def_t, dot_t, name_t, end_t))
-      end
+    def def_endless_singleton(def_t, definee, dot_t,
+                              name_t, args,
+                              assignment_t, body)
+      validate_definee(definee)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
+      n(:defs, [ definee, value(name_t).to_sym, args, body ],
+        endless_definition_map(def_t, dot_t, name_t, assignment_t, body))
     end
 
     def undef_method(undef_t, names)
@@ -691,16 +750,30 @@ 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)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:arg, [ value(name_t).to_sym ],
         variable_map(name_t))
     end
 
     def optarg(name_t, eql_t, value)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:optarg, [ value(name_t).to_sym, value ],
         variable_map(name_t).
           with_operator(loc(eql_t)).
@@ -709,6 +782,7 @@ module Parser
 
     def restarg(star_t, name_t=nil)
       if name_t
+        check_reserved_for_numparam(value(name_t), loc(name_t))
         n(:restarg, [ value(name_t).to_sym ],
           arg_prefix_map(star_t, name_t))
       else
@@ -718,17 +792,23 @@ module Parser
     end
 
     def kwarg(name_t)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:kwarg, [ value(name_t).to_sym ],
         kwarg_map(name_t))
     end
 
     def kwoptarg(name_t, value)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:kwoptarg, [ value(name_t).to_sym, value ],
         kwarg_map(name_t, value))
     end
 
     def kwrestarg(dstar_t, name_t=nil)
       if name_t
+        check_reserved_for_numparam(value(name_t), loc(name_t))
+
         n(:kwrestarg, [ value(name_t).to_sym ],
           arg_prefix_map(dstar_t, name_t))
       else
@@ -743,11 +823,15 @@ module Parser
     end
 
     def shadowarg(name_t)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:shadowarg, [ value(name_t).to_sym ],
         variable_map(name_t))
     end
 
     def blockarg(amper_t, name_t)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:blockarg, [ value(name_t).to_sym ],
         arg_prefix_map(amper_t, name_t))
     end
@@ -1239,8 +1323,10 @@ module Parser
 
     def match_var(name_t)
       name = value(name_t).to_sym
+      name_l = loc(name_t)
 
-      check_duplicate_pattern_variable(name, loc(name_t))
+      check_lvar_name(name, name_l)
+      check_duplicate_pattern_variable(name, name_l)
       @parser.static_env.declare(name)
 
       n(:match_var, [ name ],
@@ -1253,6 +1339,7 @@ module Parser
       expr_l = loc(name_t)
       name_l = expr_l.adjust(end_pos: -1)
 
+      check_lvar_name(name, name_l)
       check_duplicate_pattern_variable(name, name_l)
       @parser.static_env.declare(name)
 
@@ -1293,6 +1380,9 @@ module Parser
           Source::Map::Variable.new(name_l, expr_l))
       when :begin
         match_hash_var_from_str(begin_t, string.children, end_t)
+      else
+        # we only can get here if there is an interpolation, e.g., ``in "#{ a }":`
+        diagnostic :error, :pm_interp_in_var_name, nil, loc(begin_t).join(loc(end_t))
       end
     end
 
@@ -1334,6 +1424,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
@@ -1489,8 +1584,10 @@ module Parser
       end
     end
 
-    def check_assignment_to_numparam(node)
-      name = node.children[0].to_s
+    def check_assignment_to_numparam(name, loc)
+      # MRI < 2.7 treats numbered parameters as regular variables
+      # and so it's allowed to perform assignments like `_1 = 42`.
+      return if @parser.version < 27
 
       assigning_to_numparam =
         @parser.context.in_dynamic_block? &&
@@ -1498,7 +1595,17 @@ module Parser
         @parser.max_numparam_stack.has_numparams?
 
       if assigning_to_numparam
-        diagnostic :error, :cant_assign_to_numparam, { :name => name }, node.loc.expression
+        diagnostic :error, :cant_assign_to_numparam, { :name => name }, loc
+      end
+    end
+
+    def check_reserved_for_numparam(name, loc)
+      # MRI < 3.0 accepts assignemnt to variables like _1
+      # if it's not a numbererd parameter. MRI 3.0 and newer throws an error.
+      return if @parser.version < 30
+
+      if name =~ /\A_([1-9])\z/
+        diagnostic :error, :reserved_for_numparam, { :name => name }, loc
       end
     end
 
@@ -1732,9 +1839,17 @@ module Parser
     end
 
     def definition_map(keyword_t, operator_t, name_t, end_t)
-      Source::Map::Definition.new(loc(keyword_t),
-                                  loc(operator_t), loc(name_t),
-                                  loc(end_t))
+      Source::Map::MethodDefinition.new(loc(keyword_t),
+                                        loc(operator_t), loc(name_t),
+                                        loc(end_t), nil, nil)
+    end
+
+    def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e)
+      body_l = body_e.loc.expression
+
+      Source::Map::MethodDefinition.new(loc(keyword_t),
+                                        loc(operator_t), loc(name_t), nil,
+                                        loc(assignment_t), body_l)
     end
 
     def send_map(receiver_e, dot_t, selector_t, begin_t=nil, args=[], end_t=nil)
@@ -1979,6 +2094,18 @@ module Parser
         @parser.send :yyerror
       end
     end
+
+    def validate_definee(definee)
+      case definee.type
+      when :int, :str, :dstr, :sym, :dsym,
+           :regexp, :array, :hash
+
+        diagnostic :error, :singleton_literal, nil, definee.loc.expression
+        false
+      else
+        true
+      end
+    end
   end
 
 end