rubinius-ast 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2cda7718a6f58243f0f865ec0120f5e9971b3cb5
-  data.tar.gz: a630561d268b422713f711d7885c921cd003c3a3
+  metadata.gz: 91409a26aa4135352fb1e50a67a5952c7e8bfcca
+  data.tar.gz: 8d5c8f3ea2def5e0c6214e0678d9aac81a205ff5
 SHA512:
-  metadata.gz: 0d188bcf3227a86c2ddffd829a4d4078a774a326ed85e6d4df19296d25983e9a4c7bd8feeabcd42725f9c171b09d573e6f3b7a32252e56e0e23f89e9eb13a769
-  data.tar.gz: 8a7afeb5cbec85d572c3613a5d3a1b1d5a8e0a6d5ea657c96da90952a6fe452ab120bfc1a4d8bd70fa55636c2b87f53c55ae20b1c36aa09dc2ff33707ae64baa
+  metadata.gz: b33a2f0f6358b5e87808135050401046843999e168b4e35115d3a9d0cd3853b86c0e99615032002548f555d0cead76f2d140755bebbd2a358233287808372241
+  data.tar.gz: 5a2d6b73f476c7337b31406bd9999d6402378937ff713a2748b31c089076d2c66d618ba125cdfc078b1f0bcb35dbc6714a27213f1cff218e9649b7a28ea57690

data/lib/rubinius/ast/operators.rb

@@ -233,7 +233,6 @@ module Rubinius::ToolSets.current::ToolSet
 
           fin.set!
         else
-          fin = g.new_label
           assign = g.new_label
 
           old_break = g.break
@@ -281,7 +280,6 @@ module Rubinius::ToolSets.current::ToolSet
             g.send :[]=, @arguments.size + 1
           end
 
-          fin.set!
           g.pop
         end
       end

data/lib/rubinius/ast/values.rb

@@ -12,7 +12,83 @@ module Rubinius::ToolSets.current::ToolSet
 
       def bytecode(g)
         @value.bytecode(g)
-        g.cast_array unless @value.kind_of? ArrayLiteral
+        return if @value.kind_of? ArrayLiteral
+
+        convert_to_ary(g)
+      end
+
+      def convert_to_ary(g)
+        done = g.new_label
+        coerce = g.new_label
+        coerce_method = :to_ary
+
+        kind_of_array(g, done)
+
+        check_respond_to = g.new_label
+
+        g.dup
+        g.push :nil
+        g.swap
+        g.send :equal?, 1, true
+        g.gif check_respond_to
+
+        g.make_array 1
+        g.goto done
+
+        check_respond_to.set!
+        g.dup
+        g.push_literal :to_ary
+        g.send :respond_to?, 1, true
+        g.git coerce
+
+        discard = g.new_label
+        check_array = g.new_label
+
+        make_array = g.new_label
+        make_array.set!
+        g.dup
+        g.send :to_a, 0, true
+        coerce_method = :to_a
+        g.goto check_array
+
+        coerce.set!
+        g.dup
+        g.send :to_ary, 0, true
+
+        g.dup
+        g.push :nil
+        g.send :equal?, 1, true
+        coerce_method = :to_ary
+        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 coerce_method
+        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
@@ -37,7 +113,7 @@ module Rubinius::ToolSets.current::ToolSet
         if @array
           @array.bytecode(g)
           @rest.bytecode(g)
-          g.cast_array
+          convert_to_ary(g)
           g.send :+, 1
         else
           @rest.bytecode(g)
@@ -45,6 +121,69 @@ module Rubinius::ToolSets.current::ToolSet
         end
       end
 
+      # TODO: de-dup
+      def convert_to_ary(g)
+        done = g.new_label
+        coerce = g.new_label
+        make_array = g.new_label
+        coerce_method = :to_ary
+
+        kind_of_array(g, done)
+
+        g.dup
+        g.push_literal :to_ary
+        g.send :respond_to?, 1, true
+        g.git coerce
+
+        discard = g.new_label
+        check_array = g.new_label
+
+        make_array.set!
+        g.dup
+        g.send :to_a, 0, true
+        coerce_method = :to_a
+        g.goto check_array
+
+        coerce.set!
+        g.dup
+        g.send :to_ary, 0, true
+
+        g.dup
+        g.push :nil
+        g.send :equal?, 1, true
+        coerce_method = :to_ary
+        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_ary
+        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
       # that could construct the left side of a concatination.
       # This is used to minimize the splat doing a send.
@@ -142,8 +281,49 @@ module Rubinius::ToolSets.current::ToolSet
       def bytecode(g)
         pos(g)
 
+        done = g.new_label
+        coerce = g.new_label
+
         @value.bytecode(g)
-        g.cast_multi_value
+        kind_of_array(g, done)
+
+        g.dup
+        g.push_literal :to_ary
+        g.send :respond_to?, 1, true
+        g.git coerce
+
+        g.make_array 1
+        g.goto done
+
+        coerce.set!
+        g.dup
+        g.send :to_ary, 0, true
+
+        discard = g.new_label
+        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

data/lib/rubinius/ast/variables.rb

@@ -541,7 +541,7 @@ module Rubinius::ToolSets.current::ToolSet
     end
 
     class MultipleAssignment < Node
-      attr_accessor :left, :right, :splat, :block, :post
+      attr_accessor :left, :right, :splat, :block
 
       def initialize(line, left, right, splat)
         @line = line
@@ -549,7 +549,6 @@ module Rubinius::ToolSets.current::ToolSet
         @right = right
         @splat = nil
         @block = nil # support for |&b|
-        @post = nil # in `a,*b,c`, c is in post.
 
         @fixed = right.kind_of?(ArrayLiteral) ? true : false
 
@@ -574,44 +573,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
@@ -640,83 +601,233 @@ 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)
-        end
-
         declare_local_scope(g.state.scope)
 
-        if @fixed
-          pad_short(g) if @left and !@splat
-          @right.body.each { |x| x.bytecode(g) }
+        case @right
+        when ArrayLiteral, ConcatArgs
+          @right.bytecode(g)
+        when SplatValue
+          @right.bytecode(g)
+          convert_to_ary(g)
+        when ToArray
+          @right.bytecode(g)
+        when nil
+          convert_to_ary(g)
+        else
+          @right.bytecode(g)
+          convert_to_a(g)
+        end
 
-          if @left
-            make_retval(g)
+        size = g.new_stack_local
+        g.dup
+        g.send :size, 0, true
+        g.set_stack_local size
+        g.pop
 
-            if @splat
-              pad_short(g)
-              make_array(g)
-            end
+        index = g.new_stack_local
+        g.push 0
+        g.set_stack_local index
+        g.pop
 
-            rotate(g)
+        g.state.push_masgn
 
-            g.state.push_masgn
-            @left.body.each do |x|
-              x.bytecode(g)
-              g.pop
-            end
-            g.state.pop_masgn
+        if @left
+          @left.body.each do |x|
+            convert_to_ary(g) if x.kind_of? MultipleAssignment
 
-            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
+            get_element(g, index)
 
-            g.cast_array unless @right.kind_of? ToArray
-            g.dup # Use the array as the return value
+            x.bytecode(g)
+            g.pop
           end
+        end
 
-          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
+        if @splat
+          g.dup
 
-          if @post
-            g.state.push_masgn
-            @post.body.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
+          convert_to_ary(g) if @splat.kind_of? SplatValue
+
+          g.push_stack_local index
+
+          check_count = g.new_label
+
+          g.push_stack_local size
+          g.push_stack_local index
+          g.send :-, 1, true
+
+          g.goto check_count
+
+          underflow = g.new_label
+          assign_splat = g.new_label
+
+          underflow.set!
+          g.pop_many 3
+          g.make_array 0
+
+          g.goto assign_splat
+
+          check_count.set!
+          g.dup
+          g.push 0
+          g.send :<, 1, true
+          g.git underflow
+
+          g.dup
+          g.push_stack_local index
+          g.send :+, 1, true
+          g.set_stack_local index
+          g.pop
+
+          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
 
-        if @splat
-          g.state.push_masgn
-          @splat.bytecode(g)
+        g.state.pop_masgn
+      end
 
-          # Use the array as the return value
-          g.dup if @fixed and !@left
+      def convert_to_a(g)
+        done = g.new_label
+        check_array = g.new_label
 
-          g.state.pop_masgn
-        end
+        kind_of_array(g, done)
+
+        wrap_tuple = g.new_label
+        kind_of_tuple(g, wrap_tuple)
+
+        g.dup
+        g.send :to_a, 0, true
+        g.goto check_array
+
+        wrap_tuple.set!
+        g.dup
+        g.make_array 0
+        g.dup
+        g.move_down 2
+        g.swap
+        g.push_literal :@tuple
+        g.swap
+        g.invoke_primitive :object_set_ivar, 3
+        g.send :size, 0, true
+        g.push_literal :@total
+        g.swap
+        g.invoke_primitive :object_set_ivar, 3
+        g.pop
+        g.goto done
+
+        discard = g.new_label
+
+        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 convert_to_ary(g)
+        done = g.new_label
+        coerce = g.new_label
+        make_array = g.new_label
+        coerce_method = :to_ary
+
+        kind_of_array(g, done)
+
+        g.dup
+        g.push_literal :to_ary
+        g.send :respond_to?, 1, true
+        g.git coerce
+
+        discard = g.new_label
+        check_array = g.new_label
+
+        make_array.set!
+        g.dup
+        g.send :to_a, 0, true
+        coerce_method = :to_a
+        g.goto check_array
+
+        coerce.set!
+        g.dup
+        g.send :to_ary, 0, true
+
+        g.dup
+        g.push :nil
+        g.send :equal?, 1, true
+        coerce_method = :to_ary
+        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 coerce_method
+        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 kind_of_tuple(g, label)
+        g.dup
+        g.push_rubinius
+        g.find_const :Tuple
+        g.swap
+        g.kind_of
+        g.git label
+      end
+
+      def get_element(g, index)
+        g.dup
+        g.push_stack_local index
+
+        g.dup
+        g.push 1
+        g.send :+, 1, true
+        g.set_stack_local index
+        g.pop
 
-        g.pop if @right and (!@fixed or @splat)
+        g.send :[], 1, true
       end
 
       def defined(g)

data/lib/rubinius/ast/version.rb

@@ -1,5 +1,5 @@
 module Rubinius::ToolSets.current::ToolSet
   module AST
-    VERSION = "1.2.0"
+    VERSION = "1.2.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubinius-ast
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Brian Shirai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-20 00:00:00.000000000 Z
+date: 2014-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler