rubinius-ast 2.1.3 → 2.2.0

data/lib/rubinius/ast/transforms.rb

@@ -1,6 +1,6 @@
 # -*- encoding: us-ascii -*-
 
-module Rubinius::ToolSets.current::ToolSet
+module CodeTools
   module AST
     module Transforms
       def self.register(category, name, klass)

data/lib/rubinius/ast/values.rb

@@ -1,6 +1,6 @@
 # -*- encoding: us-ascii -*-
 
-module Rubinius::ToolSets.current::ToolSet
+module CodeTools
   module AST
     class SplatValue < Node
       attr_accessor :value
@@ -11,8 +11,63 @@ module Rubinius::ToolSets.current::ToolSet
       end
 
       def bytecode(g)
+        done = g.new_label
+        coerce = g.new_label
+        make_array = g.new_label
+
         @value.bytecode(g)
-        g.cast_array unless @value.kind_of? ArrayLiteral
+        kind_of_array(g, done)
+
+        g.dup
+        g.push_literal :to_a
+        g.push :true
+        g.send :respond_to?, 2, true
+        g.git coerce
+
+        make_array.set!
+        g.make_array 1
+        g.goto done
+
+        coerce.set!
+        g.dup
+        g.send :to_a, 0, true
+
+        discard = g.new_label
+        check_array = g.new_label
+
+        g.dup
+        g.push :nil
+        g.send :equal?, 1, true
+        g.gif check_array
+
+        g.pop
+        g.goto make_array
+
+        check_array.set!
+        kind_of_array(g, discard)
+
+        g.push_type
+        g.move_down 2
+        g.push_literal :to_a
+        g.push_cpath_top
+        g.find_const :Array
+        g.send :coerce_to_type_error, 4, true
+        g.goto done
+
+        discard.set!
+        g.swap
+        g.pop
+
+        done.set!
+      end
+
+      def kind_of_array(g, label)
+        g.dup
+        g.push_cpath_top
+        g.find_const :Array
+        g.swap
+        g.kind_of
+        g.git label
       end
 
       def to_sexp
@@ -34,15 +89,72 @@ module Rubinius::ToolSets.current::ToolSet
       end
 
       def bytecode(g)
-        if @array
-          @array.bytecode(g)
-          @rest.bytecode(g)
-          g.cast_array
-          g.send :+, 1
-        else
-          @rest.bytecode(g)
-          g.cast_array
-        end
+        @array.bytecode(g) if @array
+
+        @rest.bytecode(g)
+        convert_to_a(g)
+
+        g.send :+, 1, true if @array
+      end
+
+      # TODO: de-dup
+      def convert_to_a(g)
+        done = g.new_label
+        coerce = g.new_label
+        make_array = g.new_label
+
+        kind_of_array(g, done)
+
+        g.dup
+        g.push_literal :to_a
+        g.push :true
+        g.send :respond_to?, 2, true
+        g.git coerce
+
+        make_array.set!
+        g.make_array 1
+        g.goto done
+
+        coerce.set!
+        g.dup
+        g.send :to_a, 0, true
+
+        discard = g.new_label
+        check_array = g.new_label
+
+        g.dup
+        g.push :nil
+        g.send :equal?, 1, true
+        g.gif check_array
+
+        g.pop
+        g.goto make_array
+
+        check_array.set!
+        kind_of_array(g, discard)
+
+        g.push_type
+        g.move_down 2
+        g.push_literal :to_a
+        g.push_cpath_top
+        g.find_const :Array
+        g.send :coerce_to_type_error, 4, true
+        g.goto done
+
+        discard.set!
+        g.swap
+        g.pop
+
+        done.set!
+      end
+
+      def kind_of_array(g, label)
+        g.dup
+        g.push_cpath_top
+        g.find_const :Array
+        g.swap
+        g.kind_of
+        g.git label
       end
 
       # Dive down and try to find an array of regular values

data/lib/rubinius/ast/variables.rb

@@ -1,6 +1,6 @@
 # -*- encoding: us-ascii -*-
 
-module Rubinius::ToolSets.current::ToolSet
+module CodeTools
   module AST
     class BackRef < Node
       attr_accessor :kind
@@ -502,7 +502,7 @@ module Rubinius::ToolSets.current::ToolSet
     class LocalVariableAssignment < VariableAssignment
       include LocalVariable
 
-      def initialize(line, name, value)
+      def initialize(line, name, value=nil)
         @line = line
         @name = name
         @value = value
@@ -582,44 +582,6 @@ module Rubinius::ToolSets.current::ToolSet
         end
       end
 
-      def pad_short(g)
-        short = @left.body.size - @right.body.size
-        if short > 0
-          short.times { g.push :nil }
-          g.make_array 0 if @splat
-        end
-      end
-
-      def pop_excess(g)
-        excess = @right.body.size - @left.body.size
-        excess.times { g.pop } if excess > 0
-      end
-
-      def make_array(g)
-        size = @right.body.size - @left.body.size
-        g.make_array size if size >= 0
-      end
-
-      def make_retval(g)
-        size = @right.body.size
-        if @left and !@splat
-          lhs = @left.body.size
-          size = lhs if lhs > size
-        end
-        g.dup_many @right.body.size
-        g.make_array @right.body.size
-        g.move_down size
-      end
-
-      def rotate(g)
-        if @splat
-          size = @left.body.size + 1
-        else
-          size = @right.body.size
-        end
-        g.rotate size
-      end
-
       def iter_arguments
         @iter_arguments = true
       end
@@ -648,208 +610,205 @@ module Rubinius::ToolSets.current::ToolSet
       end
 
       def bytecode(g, array_on_stack=false)
-        unless array_on_stack
-          g.cast_array unless @right or (@splat and not @left)
+        declare_local_scope(g.state.scope)
+
+        case @right
+        when ArrayLiteral, SplatValue
+          @right.bytecode(g)
+          g.dup
+        when ToArray
+          @right.value.bytecode(g)
+          g.dup
+          convert_to_ary(g)
+        when nil
+          convert_to_ary(g)
+        else
+          @right.bytecode(g)
+          g.dup
+          convert_to_ary(g)
         end
 
-        declare_local_scope(g.state.scope)
+        size = g.new_stack_local
+        g.dup
+        g.send :size, 0, true
+        g.set_stack_local size
+        g.pop
 
-        if @fixed
-          pad_short(g) if @left and !@splat
-          @right.body.each { |x| x.bytecode(g) }
+        index = g.new_stack_local
+        g.push 0
+        g.set_stack_local index
+        g.pop
 
-          if @left
-            make_retval(g)
+        g.state.push_masgn
 
-            if @splat
-              pad_short(g)
-              make_array(g)
-            end
+        assign_values g, @left, index if @left
 
-            rotate(g)
+        if @splat
+          g.dup
+          g.push_stack_local index
 
-            g.state.push_masgn
-            @left.body.each do |x|
-              x.bytecode(g)
-              g.pop
-            end
-            g.state.pop_masgn
+          check_count = g.new_label
 
-            pop_excess(g) unless @splat
-          end
-        else
-          if @right
-            if @right.kind_of? ArrayLiteral and @right.body.size == 1
-              @right.body.first.bytecode(g)
-              g.cast_multi_value
-            else
-              @right.bytecode(g)
-            end
+          if @post
+            g.push_stack_local size
+            g.push @post.body.size
+            g.send :-, 1, true
 
-            g.cast_array unless @right.kind_of? ToArray
-            g.dup # Use the array as the return value
-          end
+            g.push_stack_local index
+            g.send :-, 1, true
 
-          if @left
-            g.state.push_masgn
-            @left.body.each do |x|
-              g.shift_array
-              g.cast_array if x.kind_of? MultipleAssignment and x.left
-              x.bytecode(g)
-              g.pop
-            end
-            g.state.pop_masgn
-          end
+            g.goto check_count
+          else
+            g.push_stack_local size
+            g.push_stack_local index
+            g.send :-, 1, true
 
-          if @post
-            g.state.push_masgn
-            @post.body.reverse_each do |x|
-              g.dup
-              g.send :pop, 0
-              g.cast_array if x.kind_of? MultipleAssignment and x.left
-              x.bytecode(g)
-              g.pop
-            end
-            g.state.pop_masgn
+            g.goto check_count
           end
-        end
 
-        if @splat
-          g.state.push_masgn
-          @splat.bytecode(g)
+          underflow = g.new_label
+          assign_splat = g.new_label
 
-          # Use the array as the return value
-          g.dup if @fixed and !@left
+          underflow.set!
+          g.pop_many 3
+          g.make_array 0
 
-          g.state.pop_masgn
-        end
+          g.goto assign_splat
 
-        g.pop if @right and (!@fixed or @splat)
-      end
+          check_count.set!
+          g.dup
+          g.push 0
+          g.send :<, 1, true
+          g.git underflow
 
-      def defined(g)
-        g.push_literal "assignment"
-      end
+          g.dup
+          g.push_stack_local index
+          g.send :+, 1, true
+          g.set_stack_local index
+          g.pop
 
-      def to_sexp
-        left = @left ? @left.to_sexp : [:array]
-        case @splat
-        when EmptySplat
-          left << [:splat]
-        when nil
-        else
-          left << [:splat, @splat.to_sexp]
+          g.send :[], 2, true
+
+          assign_splat.set!
+
+          # TODO: Fix nodes to work correctly.
+          case @splat
+          when EmptySplat
+            # nothing
+          when SplatArray, SplatWrapped
+            @splat.value.bytecode(g)
+          else
+            @splat.bytecode(g)
+          end
+          g.pop
         end
-        left << @block.to_sexp if @block
 
-        sexp = [:masgn, left]
-        sexp << @right.to_sexp if @right
-        sexp
+        assign_values g, @post, index if @post
+
+        g.state.pop_masgn
+        g.pop
       end
-    end
 
-    class LeftPatternVariable < Node
-      include LocalVariable
+      def convert_to_ary(g)
+        done = g.new_label
+        coerce = g.new_label
+        make_array = g.new_label
 
-      attr_accessor :name, :value
+        kind_of_array(g, done)
 
-      def initialize(line, name)
-        @line = line
-        @name = name
-        @variable = nil
-      end
+        g.dup
+        g.push_literal :to_ary
+        g.push :true
+        g.send :respond_to?, 2, true
+        g.git coerce
 
-      def position_bytecode(g)
-        @variable.get_bytecode(g)
-        g.cast_array
-      end
+        make_array.set!
+        g.make_array 1
+        g.goto done
 
-      def bytecode(g)
-        pos(g)
+        coerce.set!
+        g.dup
+        g.send :to_ary, 0, true
 
-        unless @variable
-          g.state.scope.assign_local_reference self
-        end
+        discard = g.new_label
+        check_array = g.new_label
+
+        g.dup
+        g.push :nil
+        g.send :equal?, 1, true
+        g.gif check_array
 
-        g.shift_array
-        @variable.set_bytecode(g)
         g.pop
-      end
-    end
+        g.goto make_array
 
-    class SplatPatternVariable < Node
-      include LocalVariable
+        check_array.set!
+        kind_of_array(g, discard)
 
-      attr_accessor :name, :value
+        g.push_type
+        g.move_down 2
+        g.push_literal :to_ary
+        g.push_cpath_top
+        g.find_const :Array
+        g.send :coerce_to_type_error, 4, true
+        g.goto done
 
-      def initialize(line, name)
-        @line = line
-        @name = name
-        @variable = nil
-      end
+        discard.set!
+        g.swap
+        g.pop
 
-      def position_bytecode(g)
-        @variable.get_bytecode(g)
-        g.cast_array
+        done.set!
       end
 
-      def bytecode(g)
-        pos(g)
-
-        unless @variable
-          g.state.scope.assign_local_reference self
-        end
-
+      def kind_of_array(g, label)
         g.dup
-        @variable.set_bytecode(g)
-        g.pop
+        g.push_cpath_top
+        g.find_const :Array
+        g.swap
+        g.kind_of
+        g.git label
       end
-    end
 
-    class PostPatternVariable < Node
-      include LocalVariable
+      def get_element(g, index)
+        g.dup
+        g.push_stack_local index
 
-      attr_accessor :name, :value
+        g.dup
+        g.push 1
+        g.send :+, 1, true
+        g.set_stack_local index
+        g.pop
 
-      def initialize(line, name, idx)
-        @line = line
-        @name = name
-        @pos  = idx
-        @variable = nil
+        g.send :[], 1, true
       end
 
-      def position_bytecode(g)
-        @variable.get_bytecode(g)
-        g.cast_array
+      def assign_values(g, array, index)
+        array.body.each do |x|
+          get_element(g, index)
+          g.dup if x.kind_of? MultipleAssignment
+          x.bytecode(g)
+          g.pop
+        end
       end
 
-      def bytecode(g)
-        pos(g)
+      def defined(g)
+        g.push_literal "assignment"
+      end
 
-        unless @variable
-          g.state.scope.assign_local_reference self
+      def to_sexp
+        left = @left ? @left.to_sexp : [:array]
+        case @splat
+        when EmptySplat
+          left << [:splat]
+        when nil
+        else
+          left << [:splat, @splat.to_sexp]
         end
+        left << @block.to_sexp if @block
 
-        too_big = g.new_label
-        done    = g.new_label
-
-        g.dup
-        g.send :size, 0
-        g.push_int @pos
-        g.send :>, 1
-        g.gif too_big
-        g.dup
-        g.send :pop, 0
-
-        g.goto done
-        too_big.set!
-        g.push_nil
-        @variable.set_bytecode(g)
-        g.goto done
-
-        done.set!
-        @variable.set_bytecode(g)
-        g.pop
+        sexp = [:masgn, left]
+        sexp += @post.body.map { |x| x.to_sexp } if @post
+        sexp << @right.to_sexp if @right
+        sexp
       end
     end
   end