rubinius-melbourne 2.3.1.0 → 3.0

data/spec/masgn_spec.rb

@@ -1,171 +0,0 @@
-describe "A Masgn node" do
-  parse "a = 1, 2, 3" do
-    [:lasgn, :a, [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
-  end
-
-  parse "a = *x" do
-    [:lasgn, :a, [:splat, [:call, nil, :x, [:arglist]]]]
-  end
-
-  parse "a, = []" do
-    [:masgn, [:array, [:lasgn, :a]], [:array]]
-  end
-
-  parse "a, b = b, a" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b]],
-     [:array, [:lvar, :b], [:lvar, :a]]]
-  end
-
-  parse "a, _, b, _, c, _ = x" do
-    [:masgn,
-     [:array,
-      [:lasgn, :a],
-      [:lasgn, :_],
-      [:lasgn, :b],
-      [:lasgn, :_],
-      [:lasgn, :c],
-      [:lasgn, :_]],
-     [:call, nil, :x, [:arglist]]]
-  end
-
-  parse "a.b, a.c = x" do
-    [:masgn,
-     [:array,
-      [:attrasgn, [:call, nil, :a, [:arglist]], :b=, [:arglist]],
-      [:attrasgn, [:call, nil, :a, [:arglist]], :c=, [:arglist]]],
-     [:call, nil, :x, [:arglist]]]
-  end
-
-  parse "a[0], a[1] = 1, 2" do
-    [:masgn,
-     [:array,
-      [:attrasgn, [:call, nil, :a, [:arglist]], :[]=, [:arglist, [:lit, 0]]],
-      [:attrasgn, [:call, nil, :a, [:arglist]], :[]=, [:arglist, [:lit, 1]]]],
-     [:array, [:lit, 1], [:lit, 2]]]
-  end
-
-  parse "* = *1" do
-    [:masgn, [:array, [:splat]], [:splat, [:lit, 1]]]
-  end
-
-  parse "*a = nil" do
-    [:masgn, [:array, [:splat, [:lasgn, :a]]], [:nil]]
-  end
-
-  parse "*a = x, y, z" do
-    [:masgn,
-     [:array, [:splat, [:lasgn, :a]]],
-     [:array,
-      [:call, nil, :x, [:arglist]],
-      [:call, nil, :y, [:arglist]],
-      [:call, nil, :z, [:arglist]]]]
-  end
-
-  parse "*a = x, y, *z" do
-    [:masgn,
-     [:array, [:splat, [:lasgn, :a]]],
-     [:argscat,
-      [:array, [:call, nil, :x, [:arglist]], [:call, nil, :y, [:arglist]]],
-      [:call, nil, :z, [:arglist]]]]
-  end
-
-  parse "a, *b, c = *x" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]],
-     [:lasgn, :c],
-     [:splat, [:call, nil, :x, [:arglist]]]]
-  end
-
-  parse "a, b, *c = *[]" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
-     [:splat, [:array]]]
-  end
-
-  parse "(*) = x" do
-    [:masgn, [:array, [:splat]], [:call, nil, :x, [:arglist]]]
-  end
-
-  parse "(*) = *x" do
-    [:masgn, [:array, [:splat]], [:splat, [:call, nil, :x, [:arglist]]]]
-  end
-
-  parse "(*a) = (x = 1), *[1]" do
-    [:masgn,
-     [:array, [:splat, [:lasgn, :a]]],
-     [:array, [:lasgn, :x, [:lit, 1]], [:lit, 1]]]
-  end
-
-  parse "(*a), *b, c = *x" do
-    [:masgn,
-     [:array, [:masgn, [:array, [:splat, [:lasgn, :a]]]], [:splat, [:lasgn, :b]]],
-     [:lasgn, :c],
-     [:splat, [:call, nil, :x, [:arglist]]]]
-  end
-
-  parse "(*a, b) = m x" do
-    [:masgn,
-     [:array, [:splat, [:lasgn, :a]]],
-     [:lasgn, :b],
-     [:call, nil, :m, [:arglist, [:call, nil, :x, [:arglist]]]]]
-  end
-
-  parse "(*a, b), (*c, d) = 1, 2, 3" do
-    [:masgn,
-     [:array,
-      [:masgn, [:array, [:splat, [:lasgn, :a]]], [:lasgn, :b]],
-      [:masgn, [:array, [:splat, [:lasgn, :c]]], [:lasgn, :d]]],
-     [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
-  end
-
-  parse "(a, b, *c, d), (*e, f, g), (*h) = x.y, *x.z" do
-    [:masgn,
-     [:array,
-      [:masgn,
-       [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
-       [:lasgn, :d]],
-      [:masgn, [:array, [:splat, [:lasgn, :e]]], [:lasgn, :f], [:lasgn, :g]],
-      [:masgn, [:array, [:splat, [:lasgn, :h]]]]],
-     [:argscat,
-      [:array, [:call, [:call, nil, :x, [:arglist]], :y, [:arglist]]],
-      [:call, [:call, nil, :x, [:arglist]], :z, [:arglist]]]]
-  end
-
-  parse "a, (b, (c, *d), *e) = x[0], *y[0]" do
-    [:masgn,
-     [:array,
-      [:lasgn, :a],
-      [:masgn,
-       [:array,
-        [:lasgn, :b],
-        [:masgn, [:array, [:lasgn, :c], [:splat, [:lasgn, :d]]]],
-        [:splat, [:lasgn, :e]]]]],
-     [:argscat,
-      [:array, [:call, [:call, nil, :x, [:arglist]], :[], [:arglist, [:lit, 0]]]],
-      [:call, [:call, nil, :y, [:arglist]], :[], [:arglist, [:lit, 0]]]]]
-  end
-
-  parse "a, (b, (c, *d, (e, (*f)), g), (h, (i, j), k)) = x.y(q, r)" do
-    [:masgn,
-     [:array,
-      [:lasgn, :a],
-      [:masgn,
-       [:array,
-        [:lasgn, :b],
-        [:masgn,
-         [:array, [:lasgn, :c], [:splat, [:lasgn, :d]]],
-         [:masgn,
-          [:array, [:lasgn, :e], [:masgn, [:array, [:splat, [:lasgn, :f]]]]]],
-         [:lasgn, :g]],
-        [:masgn,
-         [:array,
-          [:lasgn, :h],
-          [:masgn, [:array, [:lasgn, :i], [:lasgn, :j]]],
-          [:lasgn, :k]]]]]],
-     [:call,
-      [:call, nil, :x, [:arglist]],
-      :y,
-      [:arglist, [:call, nil, :q, [:arglist]], [:call, nil, :r, [:arglist]]]]]
-  end
-end

data/spec/match2_spec.rb

@@ -1,15 +0,0 @@
-describe "A Match2 node" do
-  parse '/x/ =~ "blah"' do
-    [:match2, [:regex, "x", 0], [:str, "blah"]]
-  end
-
-  parse <<-ruby do
-      x = "x"
-      /\#{x}/ =~ x
-    ruby
-
-    [:block,
-     [:lasgn, :x, [:str, "x"]],
-     [:match2, [:dregx, "", [:evstr, [:lvar, :x]]], [:lvar, :x]]]
-  end
-end

data/spec/match3_spec.rb

@@ -1,20 +0,0 @@
-describe "A Match3 node" do
-  parse '"blah" =~ /x/' do
-    [:match3, [:regex, "x", 0], [:str, "blah"]]
-  end
-
-  parse <<-ruby do
-      a = 'abc'
-      if a =~ /\#{a}/
-        1
-      end
-    ruby
-
-    [:block,
-     [:lasgn, :a, [:str, "abc"]],
-     [:if,
-      [:match3, [:dregx, "", [:evstr, [:lvar, :a]]], [:lvar, :a]],
-      [:lit, 1],
-      nil]]
-  end
-end

data/spec/match_spec.rb

@@ -1,5 +0,0 @@
-describe "A Match node" do
-  parse "1 if /x/" do
-    [:if, [:match, [:regex, "x", 0]], [:lit, 1], nil]
-  end
-end

data/spec/module_spec.rb

@@ -1,43 +0,0 @@
-describe "A Module node" do
-  parse <<-ruby do
-      module X
-        def y
-        end
-      end
-    ruby
-
-    [:module,
-    :X,
-    [:scope, [:block, [:defn, :y, [:args], [:scope, [:block, [:nil]]]]]]]
-  end
-
-  parse <<-ruby do
-      module ::Y
-        c
-      end
-    ruby
-
-    [:module, [:colon3, :Y], [:scope, [:block, [:call, nil, :c, [:arglist]]]]]
-  end
-
-  parse <<-ruby do
-      module X::Y
-        c
-      end
-    ruby
-
-    [:module,
-     [:colon2, [:const, :X], :Y],
-     [:scope, [:block, [:call, nil, :c, [:arglist]]]]]
-  end
-
-  parse <<-ruby do
-      "prevent the above from infecting rdoc"
-
-      module Graffle
-      end
-    ruby
-
-    [:module, :Graffle, [:scope]]
-  end
-end

data/spec/nil_spec.rb

@@ -1,5 +0,0 @@
-describe "A Nil node" do
-  parse "nil" do
-    [:nil]
-  end
-end

data/spec/not_spec.rb

@@ -1,15 +0,0 @@
-describe "A Not node" do
-  parse "(not true)" do
-    [:call, [:true], :!, [:arglist]]
-  end
-
-  parse <<-ruby do
-      a = 1
-      b = !a
-    ruby
-
-    [:block,
-     [:lasgn, :a, [:lit, 1]],
-     [:lasgn, :b, [:call, [:lvar, :a], :!, [:arglist]]]]
-  end
-end

data/spec/nth_ref_spec.rb

@@ -1,5 +0,0 @@
-describe "An Nth_ref node" do
-  parse "$1" do
-    [:nth_ref, 1]
-  end
-end

data/spec/op_asgn_spec.rb

@@ -1,206 +0,0 @@
-describe "An Op_asgn1 node" do
-  parse "a &&= 8" do
-    [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 8]]]
-  end
-
-  parse "hsh[:blah] ||= 8" do
-    [:op_asgn1,
-     [:call, nil, :hsh, [:arglist]],
-     [:arglist, [:lit, :blah]],
-     :"||",
-     [:lit, 8]]
-  end
-
-  parse <<-ruby do
-      x = 1
-      hsh[x] ||= 8
-    ruby
-
-    [:block,
-     [:lasgn, :x, [:lit, 1]],
-     [:op_asgn1,
-      [:call, nil, :hsh, [:arglist]],
-      [:arglist, [:lvar, :x]],
-      :"||",
-      [:lit, 8]]]
-  end
-
-  parse "hsh[:blah] &&= 8" do
-    [:op_asgn1,
-     [:call, nil, :hsh, [:arglist]],
-     [:arglist, [:lit, :blah]],
-     :"&&",
-     [:lit, 8]]
-  end
-
-  parse "hsh[:blah] ^= 8" do
-    [:op_asgn1,
-     [:call, nil, :hsh, [:arglist]],
-     [:arglist, [:lit, :blah]],
-     :^,
-     [:lit, 8]]
-  end
-
-  parse "ary[0,1] += [4]" do
-    [:op_asgn1,
-     [:call, nil, :ary, [:arglist]],
-     [:arglist, [:lit, 0], [:lit, 1]],
-     :+,
-     [:array, [:lit, 4]]]
-  end
-
-  parse "x.val ||= 6" do
-    [:op_asgn2, [:call, nil, :x, [:arglist]], :val=, :"||", [:lit, 6]]
-  end
-
-  parse "x.val &&= 7" do
-    [:op_asgn2, [:call, nil, :x, [:arglist]], :val=, :"&&", [:lit, 7]]
-  end
-
-  parse <<-ruby do
-      @b = []
-      @b[1] ||= 10
-      @b[2] &&= 11
-      @b[3] += 12
-    ruby
-
-    [:block,
-     [:iasgn, :@b, [:array]],
-     [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 1]], :"||", [:lit, 10]],
-     [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 2]], :"&&", [:lit, 11]],
-     [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 3]], :+, [:lit, 12]]]
-  end
-
-  parse <<-ruby do
-      b = []
-      b[1] ||= 10
-      b[2] &&= 11
-      b[3] += 12
-    ruby
-
-    [:block,
-     [:lasgn, :b, [:array]],
-     [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 1]], :"||", [:lit, 10]],
-     [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 2]], :"&&", [:lit, 11]],
-     [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 3]], :+, [:lit, 12]]]
-  end
-end
-
-describe "An Op_asgn2 node" do
-  parse "x.val ^= 8" do
-    [:op_asgn2, [:call, nil, :x, [:arglist]], :val=, :^, [:lit, 8]]
-  end
-
-  parse "self.Bag ||= Bag.new" do
-    [:op_asgn2,
-      [:self],
-      :"Bag=", :"||", [:call, [:const, :Bag], :new, [:arglist]]]
-  end
-
-  parse <<-ruby do
-      s = Struct.new(:var)
-      c = s.new(nil)
-      c.var ||= 20
-      c.var &&= 21
-      c.var += 22
-      c.d.e.f ||= 42
-    ruby
-
-    [:block,
-     [:lasgn, :s, [:call, [:const, :Struct], :new, [:arglist, [:lit, :var]]]],
-     [:lasgn, :c, [:call, [:lvar, :s], :new, [:arglist, [:nil]]]],
-     [:op_asgn2, [:lvar, :c], :var=, :"||", [:lit, 20]],
-     [:op_asgn2, [:lvar, :c], :var=, :"&&", [:lit, 21]],
-     [:op_asgn2, [:lvar, :c], :var=, :+, [:lit, 22]],
-     [:op_asgn2,
-      [:call, [:call, [:lvar, :c], :d, [:arglist]], :e, [:arglist]],
-      :f=,
-      :"||",
-      [:lit, 42]]]
-  end
-end
-
-describe "An Op_asgn_and node" do
-  parse "@fetcher &&= new(Gem.configuration[:http_proxy])" do
-    [:op_asgn_and,
-     [:ivar, :@fetcher],
-     [:iasgn,
-      :@fetcher,
-      [:call,
-       nil,
-       :new,
-       [:arglist,
-        [:call,
-         [:call, [:const, :Gem], :configuration, [:arglist]],
-         :[],
-         [:arglist, [:lit, :http_proxy]]]]]]]
-  end
-
-  parse <<-ruby do
-      a = 0
-      a &&= 2
-    ruby
-
-    [:block,
-     [:lasgn, :a, [:lit, 0]],
-     [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 2]]]]
-  end
-end
-
-describe "An Op_asgn_or node" do
-  parse "@@var ||= 3" do
-    [:op_asgn_or, [:cvar, :@@var], [:cvasgn, :@@var, [:lit, 3]]]
-  end
-
-  parse "a ||= 8" do
-    [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 8]]]
-  end
-
-  parse <<-ruby do
-      a ||= begin
-              b
-            rescue
-              c
-            end
-    ruby
-
-    [:op_asgn_or,
-     [:lvar, :a],
-     [:lasgn,
-      :a,
-      [:rescue,
-       [:call, nil, :b, [:arglist]],
-       [:resbody,
-        [:array, [:const, :StandardError]],
-        [:call, nil, :c, [:arglist]]]]]]
-  end
-
-  parse "@fetcher ||= new(Gem.configuration[:http_proxy])" do
-    [:op_asgn_or,
-     [:ivar, :@fetcher],
-     [:iasgn,
-      :@fetcher,
-      [:call,
-       nil,
-       :new,
-       [:arglist,
-        [:call,
-         [:call, [:const, :Gem], :configuration, [:arglist]],
-         :[],
-         [:arglist, [:lit, :http_proxy]]]]]]]
-  end
-
-  parse "@v ||= {  }" do
-    [:op_asgn_or, [:ivar, :@v], [:iasgn, :@v, [:hash]]]
-  end
-
-  parse <<-ruby do
-      a = 0
-      a ||= 1
-    ruby
-
-    [:block,
-     [:lasgn, :a, [:lit, 0]],
-     [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 1]]]]
-  end
-end