rubinius-ast 2.1.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc9ddee64cf9f30bf0458c2cdee3f81c509c7062
-  data.tar.gz: 126e405ea53fa96cf9d9eac72c48931f8244a7de
+  metadata.gz: 446fcd824eee49fa15042e4aa39a3e802b49a4bb
+  data.tar.gz: b89a58a16a0ccacf3ac5e638fd29b2cefc2d5472
 SHA512:
-  metadata.gz: 38d4c5b5fa58fa3bc5c77acb2a5db91b08ff21ac8adf95b0f93cd6756aa1510da999e56ce723e941a30bc68f4961c36b762874ee7f8485479b77e42ccef031aa
-  data.tar.gz: 8d7e5e6b3358850059b2f338c29a8eb3fbf8bc12783e0d0a6c3246f0b2dc1bfdb494d204280bb13dd119b6b0c581dc7edb5b0d108b3311b0930bf6e0b94c044d
+  metadata.gz: 625a245f3487f621f66419640e446a00e4046318ec505a123c80ee27186b803f1d01f5635ae7884134cba19625e3d36468bd87348ab930fb69820706031a725d
+  data.tar.gz: 9ad09df099f4f9bc70476b71d144972186b0fcf8a194cb092b4af4c956609321fd3be6ca55d398a93f79e84dc289cf688efee67d33cf9cdfbed03020e4d38f7a

data/lib/rubinius/ast/constants.rb

@@ -1,6 +1,6 @@
 # -*- encoding: us-ascii -*-
 
-module Rubinius::ToolSets.current::ToolSet
+module CodeTools
   module AST
 
     class TypeConstant < Node
@@ -204,7 +204,8 @@ module Rubinius::ToolSets.current::ToolSet
         pos(g)
 
         if g.state.op_asgn?
-          g.push_literal Compiler::Runtime
+          g.push_rubinius
+          g.find_const :Runtime
           g.push_literal @name
           g.push_scope
           g.send :find_constant_for_op_asign_or, 2

data/lib/rubinius/ast/control_flow.rb

@@ -1,6 +1,6 @@
 # -*- encoding: us-ascii -*-
 
-module Rubinius::ToolSets.current::ToolSet
+module CodeTools
   module AST
     class Case < Node
       attr_accessor :whens, :else
@@ -209,7 +209,8 @@ module Rubinius::ToolSets.current::ToolSet
         g.dup
         @condition.bytecode(g)
         g.cast_array
-        g.push_literal Compiler::Runtime
+        g.push_rubinius
+        g.find_const :Runtime
         g.rotate(3)
         g.send :matches_when, 2
         g.git body
@@ -271,14 +272,16 @@ module Rubinius::ToolSets.current::ToolSet
       end
 
       def get_flip_flop(g, index)
-        g.push_literal Compiler::Runtime
+        g.push_rubinius
+        g.find_const :Runtime
         g.push_scope
         g.push_literal index
         g.send(:get_flip_flop, 2)
       end
 
       def set_flip_flop(g, index, value)
-        g.push_literal Compiler::Runtime
+        g.push_rubinius
+        g.find_const :Runtime
         g.push_scope
         g.push_literal index
         g.push_literal value

data/lib/rubinius/ast/data.rb

@@ -1,6 +1,6 @@
 # -*- encoding: us-ascii -*-
 
-module Rubinius::ToolSets.current::ToolSet
+module CodeTools
   module AST
     class EndData < Node
       attr_accessor :data

data/lib/rubinius/ast/definitions.rb

@@ -1,6 +1,6 @@
 # -*- encoding: us-ascii -*-
 
-module Rubinius::ToolSets.current::ToolSet
+module CodeTools
   module AST
     class Alias < Node
       attr_accessor :to, :from
@@ -79,8 +79,8 @@ module Rubinius::ToolSets.current::ToolSet
         @locals = nil
       end
 
-      def strip_arguments
-        if @array.first.kind_of? FormalArguments
+      def extract_parameters
+        if @array.first.kind_of? Parameters
           node = @array.shift
           if @array.first.kind_of? BlockArgument
             node.block_arg = @array.shift
@@ -191,7 +191,7 @@ module Rubinius::ToolSets.current::ToolSet
       def initialize(line, name, block)
         @line = line
         @name = name
-        @arguments = block.strip_arguments
+        @arguments = block.extract_parameters
         block.array << NilLiteral.new(line) if block.array.empty?
         @body = block
       end
@@ -277,153 +277,53 @@ module Rubinius::ToolSets.current::ToolSet
       end
     end
 
-    class FormalArguments < Node
-      attr_accessor :names, :required, :optional, :defaults, :splat
-      attr_reader :block_arg, :block_index
+    class Lambda < Node
+      attr_accessor :arguments, :body
 
-      def initialize(line, args, defaults, splat)
+      def initialize(line, arguments, body)
         @line = line
-        @defaults = nil
-        @block_arg = nil
-        @block_index = nil
-
-        if defaults
-          defaults = DefaultArguments.new line, defaults
-          @defaults = defaults
-          @optional = defaults.names
-
-          stop = defaults.names.first
-          last = args.each_with_index { |a, i| break i if a == stop }
-          @required = args[0, last]
-        else
-          @required = args.dup
-          @optional = []
-        end
-
-        if splat.kind_of? Symbol
-          args << splat
-        elsif splat
-          splat = :*
-          args << splat
-        end
-        @names = args
-        @splat = splat
-      end
-
-      def block_arg=(node)
-        @names << node.name
-
-        @block_index = @names.length - 1
-        @block_arg = node
+        @arguments = arguments
+        @body = Iter.new line, arguments, body
       end
 
       def bytecode(g)
-        g.state.check_for_locals = false
-        map_arguments g.state.scope
-
-        @defaults.bytecode(g) if @defaults
-        @block_arg.bytecode(g) if @block_arg
-        g.state.check_for_locals = true
-      end
-
-      def required_args
-        @required.size
-      end
-
-      alias_method :arity, :required_args
-
-      def post_args
-        0
-      end
-
-      def total_args
-        @required.size + @optional.size
-      end
-
-      def splat_index
-        if @splat
-          index = @names.size
-          index -= 1 if @block_arg
-          index -= 1 if @splat.kind_of? Symbol
-          index
-        end
-      end
-
-      def map_arguments(scope)
-        @required.each { |arg| scope.new_local arg }
-        @defaults.map_arguments scope if @defaults
-        scope.new_local @splat if @splat.kind_of? Symbol
-        scope.assign_local_reference @block_arg if @block_arg
-      end
-
-      def to_actual(line)
-        arguments = ActualArguments.new line
-
-        last = -1
-        last -= 1 if @block_arg and @block_arg.name == names[last]
-        last -= 1 if @splat == names[last]
-
-        arguments.array = @names[0..last].map { |name| LocalVariableAccess.new line, name }
-
-        if @splat.kind_of? Symbol
-          arguments.splat = SplatValue.new(line, LocalVariableAccess.new(line, @splat))
-        end
+        pos(g)
 
-        arguments
+        g.push_rubinius
+        @body.bytecode(g)
+        g.send_with_block :lambda, 0, false
       end
 
       def to_sexp
-        sexp = [:args]
-
-        @required.each { |x| sexp << x }
-        sexp += @defaults.names if @defaults
-
-        if @splat == :*
-          sexp << :*
-        elsif @splat
-          sexp << :"*#{@splat}"
-        end
-
-        sexp += @post if @post
-
-        sexp << :"&#{@block_arg.name}" if @block_arg
-
-        sexp << [:block] + @defaults.to_sexp if @defaults
-
-        sexp
+        [:lambda, @arguments.to_sexp, [:scope, @body.body.to_sexp]]
       end
     end
 
-    class FormalArguments19 < FormalArguments
-      attr_accessor :post
+    class Parameters < Node
+      attr_accessor :names, :required, :optional, :defaults, :splat,
+                    :post, :keywords, :kwrest
+      attr_reader :block_arg, :block_index
 
-      def initialize(line, required, optional, splat, post, block)
+      def initialize(line, required=nil, optional=nil, splat=nil,
+                     post=nil, kwargs=nil, kwrest=nil, block=nil)
         @line = line
         @defaults = nil
+        @keywords = nil
         @block_arg = nil
         @splat_index = nil
         @block_index = nil
+        @locals = []
+        @local_index = 0
 
-        @required = []
         names = []
 
-        if required
-          required.each do |arg|
-            case arg
-            when Symbol
-              names << arg
-              @required << arg
-            when MultipleAssignment
-              @required << PatternArguments.from_masgn(arg)
-              @splat_index = -4 if @required.size == 1
-            end
-          end
-        end
+        process_fixed_arguments Array(required), @required = [], names
 
         if optional
           @defaults = DefaultArguments.new line, optional
           @optional = @defaults.names
           names.concat @optional
+          @locals.concat @defaults.arguments
         else
           @optional = []
         end
@@ -431,35 +331,84 @@ module Rubinius::ToolSets.current::ToolSet
         case splat
         when Symbol
           names << splat
+          @locals << splat
         when true
           splat = :*
-          names << splat
+          @locals << splat
         when false
-          @splat_index = -3
           splat = nil
+          @splat_index = -3
+        end
+
+        @splat = splat
+
+        process_fixed_arguments post, @post = [], names
+
+        if kwargs
+          @keywords = KeywordParameters.new line, kwargs, kwrest
+          names.concat @keywords.names
+        elsif kwrest
+          @keywords = KeywordParameters.new line, nil, kwrest
+        end
+
+        if @keywords
+          var = local_placeholder
+          @keywords.value = LocalVariableAccess.new line, var
+          @locals << var
         end
 
-        @post = []
-        if post
-          post.each do |arg|
+        @names = names
+
+        self.block_arg = block
+      end
+
+      def process_fixed_arguments(array, arguments, names)
+        if array
+          array.each do |arg|
             case arg
-            when MultipleAssignment
-              @post << PatternArguments.from_masgn(arg)
+            when :_
+              var = names.include?(:_) ? local_placeholder : arg
+              names << arg
             when Symbol
-              @post << arg
+              var = arg
               names << arg
+            when MultipleAssignment
+              var = arg
+              var.right = LocalVariableAccess.new line, local_placeholder
+            when VariableAssignment
+              var = arg
+              names << var.name
             end
+
+            arguments << var
+            @locals << var
           end
         end
+      end
 
-        if block
-          @block_arg = BlockArgument.new line, block
-          names << block
-          @block_index = names.length - 1
+      def local_placeholder
+        :"_:#{@local_index += 1}"
+      end
+
+      def block_arg=(block)
+        case block
+        when BlockArgument
+          @block_arg = block
+        when nil
+          return
+        else
+          @block_arg = BlockArgument.new @line, block
         end
 
-        @splat = splat
-        @names = names
+        if @locals.last.kind_of? BlockArgument
+          @block_index -= 1
+          @locals.pop
+        end
+        @names.pop if @names.last.kind_of? BlockArgument
+
+        @block_index = @locals.size
+        @locals << @block_arg
+        @names << @block_arg.name
       end
 
       def required_args
@@ -471,153 +420,126 @@ module Rubinius::ToolSets.current::ToolSet
       end
 
       def total_args
-        @required.size + @optional.size + @post.size
+        args = @required.size + @optional.size + @post.size
+        args += 1 if @keywords
+        args
       end
 
       def splat_index
         return @splat_index if @splat_index
 
-        if @splat
-          index = @names.size
-          index -= 1 if @block_arg
-          index -= 1 if @splat.kind_of? Symbol
-          index -= @post.size
-          index
-        end
+        return @required.size + @optional.size if @splat
       end
 
-      def map_arguments(scope)
-        @required.each_with_index do |arg, index|
-          case arg
-          when PatternArguments
-            arg.map_arguments scope
-          when Symbol
-            @required[index] = arg = :"_#{index}" if arg == :_ and index > 0
-            scope.new_local arg
-          end
+      def arity
+        arity = required_args
+
+        if @keywords and @keywords.required?
+          arity += 1
+        end
+
+        if @splat or not @optional.empty? or
+            (@keywords and not @keywords.required?)
+          arity += 1
         end
 
-        @defaults.map_arguments scope if @defaults
-        scope.new_local @splat if @splat.kind_of? Symbol
+        if @splat or not @optional.empty? or
+            (@keywords and not @keywords.required?)
+          arity = -arity
+        end
 
-        @post.each do |arg|
-          case arg
-          when PatternArguments
-            arg.map_arguments scope
+        arity
+      end
+
+      def map_arguments(scope)
+        @locals.map do |v|
+          case v
           when Symbol
-            scope.new_local arg
+            scope.new_local v
+          when MultipleAssignment
+            scope.assign_local_reference v.right
+          when LocalVariable
+            scope.assign_local_reference v
+          when nil
+            STDERR.puts @locals.inspect, self.inspect
           end
         end
 
-        scope.assign_local_reference @block_arg if @block_arg
-
+        @keywords.map_arguments(scope) if @keywords
       end
 
       def bytecode(g)
         g.state.check_for_locals = false
         map_arguments g.state.scope
 
-        @required.each do |arg|
-          if arg.kind_of? PatternArguments
-            arg.argument.position_bytecode(g)
+        @required.each_with_index do |arg, index|
+          if arg.kind_of? MultipleAssignment
+            g.push_local index
             arg.bytecode(g)
             g.pop
           end
         end
+
         @defaults.bytecode(g) if @defaults
-        @block_arg.bytecode(g) if @block_arg
+
+        index = @required.size + @optional.size
+        index += 1 if @splat_index
+
         @post.each do |arg|
-          if arg.kind_of? PatternArguments
-            arg.argument.position_bytecode(g)
+          if arg.kind_of? MultipleAssignment
+            g.push_local index
+            index += 1
             arg.bytecode(g)
             g.pop
           end
         end
+
+        @keywords.bytecode(g) if @keywords
+
+        @block_arg.bytecode(g) if @block_arg
+
         g.state.check_for_locals = true
       end
-    end
 
-    class PatternArguments < Node
-      attr_accessor :arguments, :argument
+      def to_sexp
+        sexp = [:args]
 
-      def self.from_masgn(node)
-        array = []
-        size = 0
-        if node.left
-          size += node.left.body.size
-          node.left.body.map do |n|
-            case n
-            when MultipleAssignment
-              array << PatternArguments.from_masgn(n)
-            when LocalVariable
-              array << LeftPatternVariable.new(n.line, n.name)
-            end
+        @required.each do |a|
+          case a
+          when Symbol
+            sexp << a
+          when Node
+            sexp << a.to_sexp
           end
         end
 
-        if node.post
-          idx = 0
-          post_args = []
-          node.post.body.map do |n|
-            case n
-            when MultipleAssignment
-              post_args << PatternArguments.from_masgn(n)
-            when LocalVariable
-              post_args << PostPatternVariable.new(n.line, n.name, idx)
-            end
-            idx += 1
-          end
-          array.concat(post_args.reverse)
+        sexp += @defaults.names if @defaults
+
+        if @splat == :*
+          sexp << :*
+        elsif @splat
+          sexp << :"*#{@splat}"
         end
 
-        if node.splat
-          n = node.splat
-          case n
-          when EmptySplat
-            array << SplatPatternVariable.new(n.line, :*)
-          when SplatAssignment, SplatWrapped, SplatArray
-            array << SplatPatternVariable.new(n.value.line, n.value.name)
+        if @post
+          @post.each do |a|
+            case a
+            when Symbol
+              sexp << a
+            when Node
+              sexp << a.to_sexp
+            end
           end
         end
 
-        PatternArguments.new node.line, ArrayLiteral.new(node.line, array)
-      end
+        sexp += @keywords.names if @keywords
 
-      def initialize(line, arguments)
-        @line = line
-        @arguments = arguments
-        @argument = nil
-      end
+        sexp << :"&#{@block_arg.name}" if @block_arg
 
-      # Assign the left-most, depth-first PatternVariable so that this local
-      # will be assigned the passed argument at that position. The rest of the
-      # pattern will be destructured from the value of this assignment.
-      def map_arguments(scope)
-        arguments = @arguments.body
-        while arguments
-          node = arguments.first
-          case node
-          when LeftPatternVariable, PostPatternVariable, SplatPatternVariable
-            @argument = node
-            scope.new_local node.name
-            scope.assign_local_reference node
-            return
-          end
-          arguments = node.arguments.body
-        end
-      end
+        sexp << [:block] + @defaults.to_sexp if @defaults
+        sexp << @keywords.to_sexp if @keywords
 
-      def bytecode(g)
-        @arguments.body.each do |arg|
-          if arg.kind_of? PatternArguments
-            g.shift_array
-            g.cast_array
-            arg.bytecode(g)
-            g.pop
-          else
-            arg.bytecode(g)
-          end
-        end
+        sexp
       end
     end
 
@@ -653,6 +575,218 @@ module Rubinius::ToolSets.current::ToolSet
       end
     end
 
+    class KeywordParameters < Node
+      attr_accessor :arguments, :defaults, :names, :kwrest, :value
+
+      def initialize(line, block, kwrest)
+        @line = line
+        @kwrest = kwrest
+        @required = []
+        @defaults = []
+
+        if block
+          array = block.array
+          @names = array.map { |a| a.name }
+
+          array.each do |arg|
+            if arg.value.value == :*
+              @required << arg
+            else
+              @defaults << arg
+            end
+          end
+
+          @arguments = array
+        else
+          @arguments = []
+          @names = []
+        end
+
+        case kwrest
+        when Symbol
+          kwrest_name = :"**#{kwrest}"
+          @kwrest = LocalVariableAssignment.new line, kwrest
+        when true
+          kwrest_name = :**
+          @kwrest = true
+        end
+
+        @names << kwrest_name if kwrest_name
+      end
+
+      def required?
+        not @required.empty?
+      end
+
+      def entries
+        entries = []
+        @required.each { |arg| entries << arg.name << true }
+        @defaults.each { |arg| entries << arg.name << false }
+        entries
+      end
+
+      def map_arguments(scope)
+        @arguments.each { |var| scope.assign_local_reference var }
+
+        if @kwrest.kind_of? LocalVariableAssignment
+          scope.assign_local_reference @kwrest
+        end
+      end
+
+      def bytecode(g)
+        done = g.new_label
+        check_hash = g.new_label
+        assignments = g.new_label
+
+        @value.bytecode(g)
+
+        g.dup
+        g.push :nil
+        g.swap
+        g.send :equal?, 1, true
+        g.gif check_hash
+
+        g.pop
+        g.push_cpath_top
+        g.find_const :Hash
+        g.send :allocate, 0, true
+        g.goto assignments
+
+        check_hash.set!
+        kind_of_hash(g, assignments)
+
+        discard = g.new_label
+
+        g.dup
+        g.send :to_hash, 0, true
+        kind_of_hash(g, discard)
+
+        g.push_type
+        g.move_down 2
+        g.push_literal :to_hash
+        g.push_cpath_top
+        g.find_const :Hash
+        g.send :coerce_to_type_error, 4, true
+        g.goto done
+
+        discard.set!
+        g.swap
+        g.pop
+
+        missing_value = g.new_label
+
+        assignments.set!
+
+        @required.each do |arg|
+          g.dup
+          g.push_literal arg.name
+          g.send :find_item, 1, true
+
+          g.dup
+          g.gif missing_value
+
+          g.send :value, 0, true
+
+          arg.variable.set_bytecode(g)
+          g.pop
+        end
+
+        defaults = g.new_label
+        g.goto defaults
+
+        missing_value.set!
+        g.pop
+        g.push_rubinius
+        g.find_const :Runtime
+        g.swap
+        g.send :keywords_missing, 1, true
+        g.goto done
+
+        defaults.set!
+
+        extra_keys = g.new_label
+
+        if @defaults.empty?
+          g.dup
+          g.send :size, 0, true
+          g.push @arguments.size
+          g.swap
+          g.send :equal?, 1, true
+          g.gif extra_keys
+
+          if @kwrest.kind_of? LocalVariableAssignment
+            g.push_cpath_top
+            g.find_const :Hash
+            g.send :allocate, 0, true
+            @kwrest.variable.set_bytecode(g)
+            g.pop
+          end
+
+          g.goto done
+        else
+          @defaults.each do |arg|
+            next_value = g.new_label
+            default_value = g.new_label
+
+            g.dup
+            g.push_literal arg.name
+            g.send :find_item, 1, true
+
+            g.dup
+            g.gif default_value
+
+            g.send :value, 0, true
+            arg.variable.set_bytecode(g)
+            g.goto next_value
+
+            default_value.set!
+            g.pop
+            arg.bytecode(g)
+
+            next_value.set!
+            g.pop
+          end
+        end
+
+        extra_keys.set!
+
+        g.dup
+        g.push_rubinius
+        g.find_const :Runtime
+        g.swap
+
+        if @kwrest
+          g.push :true
+        else
+          g.push :false
+        end
+
+        g.send :keywords_extra, 2, true
+        if @kwrest.kind_of? LocalVariableAssignment
+          @kwrest.variable.set_bytecode(g)
+        end
+        g.pop
+
+        done.set!
+      end
+
+      def kind_of_hash(g, label)
+        g.dup
+        g.push_cpath_top
+        g.find_const :Hash
+        g.swap
+        g.kind_of
+        g.git label
+      end
+
+      def to_sexp
+        sexp = [:kwargs]
+        sexp << @names unless @names.empty?
+        sexp << @defaults.map { |x| x.to_sexp } unless @defaults.empty?
+        sexp
+      end
+    end
+
     module LocalVariable
       attr_accessor :variable
     end