opal 0.4.3 → 0.4.4

data/spec/opal/native/method_missing_spec.rb

@@ -0,0 +1,39 @@
+describe "Native#method_missing" do
+  it "should return values" do
+    Native(`{ a: 23 }`).a.should == 23
+    Native(`{ a: { b: 42 } }`).a.b.should == 42
+  end
+
+  it "should call functions" do
+    Native(`{ a: function() { return 42 } }`).a.should == 42
+  end
+
+  it "should pass the proper this to functions" do
+    %x{
+      function foo() {
+        this.baz = 42;
+      }
+
+      foo.prototype.bar = function () {
+        return this.baz;
+      }
+    }
+
+    obj = `new foo()`
+    Native(obj).bar.should == 42
+    Native(obj).baz = 23
+    Native(obj).bar.should == 23
+  end
+
+  it "should set values" do
+    var = `{}`
+
+    Native(var).a = 42
+    `#{var}.a`.should == 42
+    Native(var).a.should == 42
+  end
+
+  it "should pass the block as function" do
+    Native(`{ a: function(func) { return func(); } }`).a { 42 }.should == 42
+  end
+end

data/spec/opal/native/new_spec.rb

@@ -0,0 +1,19 @@
+describe "Native.new" do
+  it "fails when trying to instantiate a non derived class" do
+    lambda {
+      Native.new
+    }.should raise_error ArgumentError
+  end
+
+  it "should pass all arguments to derived classes" do
+    Class.new(Native) {
+      def initialize(a, b, &c)
+        @a, @b, @c = a, b, c
+      end
+
+      def proper?
+        not (@a.nil? || @b.nil? || @c.nil?)
+      end
+    }.new(1, 2) { }.proper?.should be_true
+  end
+end

data/spec/opal/native/nil_spec.rb

@@ -0,0 +1,14 @@
+describe "Native#nil?" do
+  it "returns true for wrapped null" do
+    Native(`null`).nil?.should be_true
+  end
+
+  it "returns true for wrapped undefined" do
+    Native(`undefined`).nil?.should be_true
+  end
+
+  it "returns false for everything else" do
+    Native(`false`).nil?.should be_false
+    Native(`{}`).nil?.should be_false
+  end
+end

data/spec/opal/runtime2/class_hierarchy_spec.rb

@@ -3,7 +3,7 @@ describe "Class Hierarchy" do
     BasicObject.superclass.should == nil
     Object.superclass.should == BasicObject
     Module.superclass.should == Object
-    Class.superclass.should == Object
+    Class.superclass.should == Module
   end
 
   it "should have the right classes" do
@@ -18,4 +18,4 @@ describe "Class Hierarchy" do
     Class.new.class.should == Class
     Module.new.class.should == Module
   end
-end
+end

data/spec/opal/source_map_spec.rb

@@ -4,13 +4,9 @@ require 'opal-source-maps'
 describe Opal::SourceMap do
   before do
     pathname = 'foo.rb'
-    @source = Opal.parse('1 + 1', pathname)
-    @map    = Opal::SourceMap.new(@source, pathname)
-  end
-
-  it 'source has the magic comments' do
-    Opal::SourceMap::FILE_REGEXP.should =~ @source
-    Opal::SourceMap::LINE_REGEXP.should =~ @source
+    parser   = Opal::Parser.new
+    @source  = parser.parse("1 + 1", pathname)
+    @map     = Opal::SourceMap.new(parser.fragments, pathname)
   end
 
   it 'does not blow while generating the map' do

data/spec/ospec/main.rb.erb

@@ -1,10 +1,7 @@
-<% require_asset 'opal' %>
-<% require_asset 'opal-parser' %>
-<% require_asset 'mspec' %>
-<% require_asset 'ospec/runner' %>
+<% require_asset 'spec_helper' %>
 
 # Load all opal filters
-<% Dir.glob('spec/rubyspec/filters/**/*.rb').each do |s| %>
+<% Dir.glob('spec/filters/**/*.rb').each do |s| %>
   <% require_asset s.sub(/^spec\//, '').sub(/\.rb$/, '') %>
 <% end %>
 

data/spec/parser/alias_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe "The alias keyword" do
   describe "with fitem" do
-    it "should return an s(:alias) with s(:lit)" do
-      opal_parse("alias a b").should == [:alias, [:lit, :a], [:lit, :b]]
-      opal_parse("alias == equals").should == [:alias, [:lit, :==], [:lit, :equals]]
+    it "should return an s(:alias) with s(:sym)" do
+      opal_parse("alias a b").should == [:alias, [:sym, :a], [:sym, :b]]
+      opal_parse("alias == equals").should == [:alias, [:sym, :==], [:sym, :equals]]
     end
 
     it "should accept symbols as names" do
-      opal_parse("alias :foo :bar").should == [:alias, [:lit, :foo], [:lit, :bar]]
+      opal_parse("alias :foo :bar").should == [:alias, [:sym, :foo], [:sym, :bar]]
     end
   end
 

data/spec/parser/and_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe "The and statement" do
   it "should always return s(:and)" do
-    opal_parse("1 and 2").should == [:and, [:lit, 1], [:lit, 2]]
+    opal_parse("1 and 2").should == [:and, [:int, 1], [:int, 2]]
   end
 end
 
 describe "The && expression" do
   it "should always return s(:and)" do
-    opal_parse("1 && 2").should == [:and, [:lit, 1], [:lit, 2]]
+    opal_parse("1 && 2").should == [:and, [:int, 1], [:int, 2]]
   end
 end

data/spec/parser/array_spec.rb

@@ -6,17 +6,17 @@ describe "Arrays" do
   end
 
   it "should append regular args onto end of array sexp" do
-    opal_parse("[1]").should == [:array, [:lit, 1]]
-    opal_parse("[1, 2]").should == [:array, [:lit, 1], [:lit, 2]]
-    opal_parse("[1, 2, 3]").should == [:array, [:lit, 1], [:lit, 2], [:lit, 3]]
+    opal_parse("[1]").should == [:array, [:int, 1]]
+    opal_parse("[1, 2]").should == [:array, [:int, 1], [:int, 2]]
+    opal_parse("[1, 2, 3]").should == [:array, [:int, 1], [:int, 2], [:int, 3]]
   end
 
   it "should return a single item s(:array) with given splat if no norm args" do
-    opal_parse("[*1]").should == [:array, [:splat, [:lit, 1]]]
+    opal_parse("[*1]").should == [:array, [:splat, [:int, 1]]]
   end
 
   it "should allow splats combined with any number of norm args" do
-    opal_parse("[1, *2]").should == [:array, [:lit, 1], [:splat, [:lit, 2]]]
-    opal_parse("[1, 2, *3]").should == [:array, [:lit, 1], [:lit, 2], [:splat, [:lit, 3]]]
+    opal_parse("[1, *2]").should == [:array, [:int, 1], [:splat, [:int, 2]]]
+    opal_parse("[1, 2, *3]").should == [:array, [:int, 1], [:int, 2], [:splat, [:int, 3]]]
   end
 end

data/spec/parser/attrasgn_spec.rb

@@ -2,27 +2,27 @@ require 'spec_helper'
 
 describe "Attribute assignments" do
   it "should return a s(:attrasgn) for simple assignments" do
-    opal_parse('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:lit, 1]]]
-    opal_parse('bar.foo = 1').should == [:attrasgn, [:call, nil, :bar, [:arglist]], :foo=, [:arglist, [:lit, 1]]]
-    opal_parse('@bar.foo = 1').should == [:attrasgn, [:ivar, :@bar], :foo=, [:arglist, [:lit, 1]]]
+    opal_parse('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
+    opal_parse('bar.foo = 1').should == [:attrasgn, [:call, nil, :bar, [:arglist]], :foo=, [:arglist, [:int, 1]]]
+    opal_parse('@bar.foo = 1').should == [:attrasgn, [:ivar, :@bar], :foo=, [:arglist, [:int, 1]]]
   end
 
   it "accepts both '.' and '::' for method call operators" do
-    opal_parse('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:lit, 1]]]
-    opal_parse('self::foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:lit, 1]]]
+    opal_parse('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
+    opal_parse('self::foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
   end
 
   it "can accept a constant as assignable name when using '.'" do
-    opal_parse('self.FOO = 1').should == [:attrasgn, [:self], :FOO=, [:arglist, [:lit, 1]]]
+    opal_parse('self.FOO = 1').should == [:attrasgn, [:self], :FOO=, [:arglist, [:int, 1]]]
   end
 
   describe "when setting element reference" do
     it "uses []= as the method call" do
-      opal_parse('self[1] = 2').should == [:attrasgn, [:self], :[]=, [:arglist, [:lit, 1], [:lit, 2]]]
+      opal_parse('self[1] = 2').should == [:attrasgn, [:self], :[]=, [:arglist, [:int, 1], [:int, 2]]]
     end
 
     it "supports multiple arguments inside brackets" do
-      opal_parse('self[1, 2] = 3').should == [:attrasgn, [:self], :[]=, [:arglist, [:lit, 1], [:lit, 2], [:lit, 3]]]
+      opal_parse('self[1, 2] = 3').should == [:attrasgn, [:self], :[]=, [:arglist, [:int, 1], [:int, 2], [:int, 3]]]
     end
   end
 end

data/spec/parser/begin_spec.rb

@@ -2,41 +2,41 @@ require 'spec_helper'
 
 describe "The begin keyword" do
   it "should be removed when used without a resuce or enusre body" do
-    opal_parse('begin; 1; end').should == [:lit, 1]
-    opal_parse('begin; 1; 2; end').should == [:block, [:lit, 1], [:lit, 2]]
+    opal_parse('begin; 1; end').should == [:int, 1]
+    opal_parse('begin; 1; 2; end').should == [:block, [:int, 1], [:int, 2]]
   end
 
   describe "with 'rescue' bodies" do
     it "should create a s(:rescue) sexp" do
-      opal_parse('begin; 1; rescue; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array], [:lit, 2]]]
+      opal_parse('begin; 1; rescue; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]]]
     end
 
     it "allows multiple rescue bodies" do
-      opal_parse('begin 1; rescue; 2; rescue; 3; end').should == [:rescue, [:lit, 1], [:resbody, [:array], [:lit, 2]], [:resbody, [:array], [:lit, 3]]]
+      opal_parse('begin 1; rescue; 2; rescue; 3; end').should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]], [:resbody, [:array], [:int, 3]]]
     end
 
     it "accepts a list of classes used to match against the exception" do
-      opal_parse('begin 1; rescue Klass; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array, [:const, :Klass]], [:lit, 2]]]
+      opal_parse('begin 1; rescue Klass; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass]], [:int, 2]]]
     end
 
     it "accepts an identifier to assign exception to" do
-      opal_parse('begin 1; rescue => a; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array, [:lasgn, :a, [:gvar, :$!]]], [:lit, 2]]]
-      opal_parse('begin 1; rescue Klass => a; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array, [:const, :Klass],[:lasgn, :a, [:gvar, :$!]]], [:lit, 2]]]
+      opal_parse('begin 1; rescue => a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:lasgn, :a, [:gvar, :$!]]], [:int, 2]]]
+      opal_parse('begin 1; rescue Klass => a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass],[:lasgn, :a, [:gvar, :$!]]], [:int, 2]]]
     end
 
     it "accepts an ivar to assign exception to" do
-      opal_parse('begin 1; rescue => @a; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array, [:iasgn, :@a, [:gvar, :$!]]], [:lit, 2]]]
-      opal_parse('begin 1; rescue Klass => @a; 2; end').should == [:rescue, [:lit, 1], [:resbody, [:array, [:const, :Klass],[:iasgn, :@a, [:gvar, :$!]]], [:lit, 2]]]
+      opal_parse('begin 1; rescue => @a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:iasgn, :@a, [:gvar, :$!]]], [:int, 2]]]
+      opal_parse('begin 1; rescue Klass => @a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass],[:iasgn, :@a, [:gvar, :$!]]], [:int, 2]]]
     end
 
     it "should parse newline right after rescue" do
-      opal_parse("begin; 1; rescue\n 2; end").should == [:rescue, [:lit, 1], [:resbody, [:array], [:lit, 2]]]
+      opal_parse("begin; 1; rescue\n 2; end").should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]]]
     end
   end
 
   describe "with an 'ensure' block" do
     it "should propagate into single s(:ensure) statement when no rescue block given" do
-      opal_parse('begin; 1; ensure; 2; end').should == [:ensure, [:lit, 1], [:lit, 2]]
+      opal_parse('begin; 1; ensure; 2; end').should == [:ensure, [:int, 1], [:int, 2]]
     end
   end
 end

data/spec/parser/block_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe "Block statements" do
   it "should return the direct expression if only one expresssion in block" do
-    opal_parse("42").should == [:lit, 42]
+    opal_parse("42").should == [:int, 42]
   end
 
   it "should return an s(:block) with all expressions appended for > 1 expression" do
-    opal_parse("42; 43").should == [:block, [:lit, 42], [:lit, 43]]
-    opal_parse("42; 43\n44").should == [:block, [:lit, 42], [:lit, 43], [:lit, 44]]
+    opal_parse("42; 43").should == [:block, [:int, 42], [:int, 43]]
+    opal_parse("42; 43\n44").should == [:block, [:int, 42], [:int, 43], [:int, 44]]
   end
 end

data/spec/parser/break_spec.rb

@@ -6,12 +6,12 @@ describe "The break keyword" do
   end
 
   it "returns s(:break) with a single arg not wrapped in s(:array)" do
-    opal_parse("break 1").should == [:break, [:lit, 1]]
-    opal_parse("break *1").should == [:break, [:splat, [:lit, 1]]]
+    opal_parse("break 1").should == [:break, [:int, 1]]
+    opal_parse("break *1").should == [:break, [:splat, [:int, 1]]]
   end
 
   it "returns s(:break) with an s(:array) for args size > 1" do
-    opal_parse("break 1, 2").should == [:break, [:array, [:lit, 1], [:lit, 2]]]
-    opal_parse("break 1, *2").should == [:break, [:array, [:lit, 1], [:splat, [:lit, 2]]]]
+    opal_parse("break 1, 2").should == [:break, [:array, [:int, 1], [:int, 2]]]
+    opal_parse("break 1, *2").should == [:break, [:array, [:int, 1], [:splat, [:int, 2]]]]
   end
 end

data/spec/parser/call_spec.rb

@@ -14,91 +14,93 @@ describe "Method calls" do
   end
 
   it "appends all arguments onto arglist" do
-    opal_parse("foo 1").should == [:call, nil, :foo, [:arglist, [:lit, 1]]]
-    opal_parse("foo 1, 2").should == [:call, nil, :foo, [:arglist, [:lit, 1], [:lit, 2]]]
-    opal_parse("foo 1, *2").should == [:call, nil, :foo, [:arglist, [:lit, 1], [:splat, [:lit, 2]]]]
+    opal_parse("foo 1").should == [:call, nil, :foo, [:arglist, [:int, 1]]]
+    opal_parse("foo 1, 2").should == [:call, nil, :foo, [:arglist, [:int, 1], [:int, 2]]]
+    opal_parse("foo 1, *2").should == [:call, nil, :foo, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
   end
-end
 
-describe "Operator calls" do
-  it "should optimize math ops into operator calls" do
-    opal_parse("1 + 2").should == [:operator, :+, [:lit, 1], [:lit, 2]]
-    opal_parse("1 - 2").should == [:operator, :-, [:lit, 1], [:lit, 2]]
-    opal_parse("1 / 2").should == [:operator, :/, [:lit, 1], [:lit, 2]]
-    opal_parse("1 * 2").should == [:operator, :*, [:lit, 1], [:lit, 2]]
+  it "supports leading dots on newline" do
+    opal_parse("foo\n.bar").should == [:call, [:call, nil, :foo, [:arglist]], :bar, [:arglist]]
+    lambda { opal_parse("foo\n..bar") }.should raise_error(Exception)
   end
+end
 
+describe "Operator calls" do
   it "should parse all other operators into method calls" do
-    opal_parse("1 % 2").should == [:call, [:lit, 1], :%, [:arglist, [:lit, 2]]]
-    opal_parse("1 ** 2").should == [:call, [:lit, 1], :**, [:arglist, [:lit, 2]]]
+    opal_parse("1 % 2").should == [:call, [:int, 1], :%, [:arglist, [:int, 2]]]
+    opal_parse("1 ** 2").should == [:call, [:int, 1], :**, [:arglist, [:int, 2]]]
 
     opal_parse("+self").should == [:call, [:self], :+@, [:arglist]]
     opal_parse("-self").should == [:call, [:self], :-@, [:arglist]]
 
-    opal_parse("1 | 2").should == [:call, [:lit, 1], :|, [:arglist, [:lit, 2]]]
-    opal_parse("1 ^ 2").should == [:call, [:lit, 1], :^, [:arglist, [:lit, 2]]]
-    opal_parse("1 & 2").should == [:call, [:lit, 1], :&, [:arglist, [:lit, 2]]]
-    opal_parse("1 <=> 2").should == [:call, [:lit, 1], :<=>, [:arglist, [:lit, 2]]]
+    opal_parse("1 | 2").should == [:call, [:int, 1], :|, [:arglist, [:int, 2]]]
+    opal_parse("1 ^ 2").should == [:call, [:int, 1], :^, [:arglist, [:int, 2]]]
+    opal_parse("1 & 2").should == [:call, [:int, 1], :&, [:arglist, [:int, 2]]]
+    opal_parse("1 <=> 2").should == [:call, [:int, 1], :<=>, [:arglist, [:int, 2]]]
 
-    opal_parse("1 < 2").should == [:call, [:lit, 1], :<, [:arglist, [:lit, 2]]]
-    opal_parse("1 <= 2").should == [:call, [:lit, 1], :<=, [:arglist, [:lit, 2]]]
-    opal_parse("1 > 2").should == [:call, [:lit, 1], :>, [:arglist, [:lit, 2]]]
-    opal_parse("1 >= 2").should == [:call, [:lit, 1], :>=, [:arglist, [:lit, 2]]]
+    opal_parse("1 < 2").should == [:call, [:int, 1], :<, [:arglist, [:int, 2]]]
+    opal_parse("1 <= 2").should == [:call, [:int, 1], :<=, [:arglist, [:int, 2]]]
+    opal_parse("1 > 2").should == [:call, [:int, 1], :>, [:arglist, [:int, 2]]]
+    opal_parse("1 >= 2").should == [:call, [:int, 1], :>=, [:arglist, [:int, 2]]]
 
-    opal_parse("1 == 2").should == [:call, [:lit, 1], :==, [:arglist, [:lit, 2]]]
-    opal_parse("1 === 2").should == [:call, [:lit, 1], :===, [:arglist, [:lit, 2]]]
-    opal_parse("1 =~ 2").should == [:call, [:lit, 1], :=~, [:arglist, [:lit, 2]]]
+    opal_parse("1 == 2").should == [:call, [:int, 1], :==, [:arglist, [:int, 2]]]
+    opal_parse("1 === 2").should == [:call, [:int, 1], :===, [:arglist, [:int, 2]]]
+    opal_parse("1 =~ 2").should == [:call, [:int, 1], :=~, [:arglist, [:int, 2]]]
 
-    opal_parse("~1").should == [:call, [:lit, 1], :~, [:arglist]]
-    opal_parse("1 << 2").should == [:call, [:lit, 1], :<<, [:arglist, [:lit, 2]]]
-    opal_parse("1 >> 2").should == [:call, [:lit, 1], :>>, [:arglist, [:lit, 2]]]
+    opal_parse("~1").should == [:call, [:int, 1], :~, [:arglist]]
+    opal_parse("1 << 2").should == [:call, [:int, 1], :<<, [:arglist, [:int, 2]]]
+    opal_parse("1 >> 2").should == [:call, [:int, 1], :>>, [:arglist, [:int, 2]]]
   end
 
   it "optimizes +@ and -@ on numerics" do
-    opal_parse("+1").should == [:lit, 1]
-    opal_parse("-1").should == [:lit, -1]
+    opal_parse("+1").should == [:int, 1]
+    opal_parse("-1").should == [:int, -1]
   end
 end
 
 describe "Optional paren calls" do
   it "should correctly parse - and -@" do
-    opal_parse("x - 1").should == [:operator, :-, [:call, nil, :x, [:arglist]], [:lit, 1]]
-    opal_parse("x -1").should == [:call, nil, :x, [:arglist, [:lit, -1]]]
+    opal_parse("x - 1").should == [:call, [:call, nil, :x, [:arglist]], :-, [:arglist, [:int, 1]]]
+    opal_parse("x -1").should == [:call, nil, :x, [:arglist, [:int, -1]]]
   end
 
   it "should correctly parse + and +@" do
-    opal_parse("x + 1").should == [:operator, :+, [:call, nil, :x, [:arglist]], [:lit, 1]]
-    opal_parse("x +1").should == [:call, nil, :x, [:arglist, [:lit, 1]]]
+    opal_parse("x + 1").should == [:call, [:call, nil, :x, [:arglist]], :+, [:arglist, [:int, 1]]]
+    opal_parse("x +1").should == [:call, nil, :x, [:arglist, [:int, 1]]]
   end
 
   it "should correctly parse / and regexps" do
-    opal_parse("x / 500").should == [:operator, :/, [:call, nil, :x, [:arglist]], [:lit, 500]]
-    opal_parse("x /foo/").should == [:call, nil, :x, [:arglist, [:lit, /foo/]]]
+    opal_parse("x / 500").should == [:call, [:call, nil, :x, [:arglist]], :/, [:arglist, [:int, 500]]]
+    opal_parse("x /foo/").should == [:call, nil, :x, [:arglist, [:regexp, /foo/]]]
   end
 
   it "should parse LPAREN_ARG correctly" do
-    opal_parse("x (1).y").should == [:call, nil, :x, [:arglist, [:call, [:lit, 1], :y, [:arglist]]]]
-    opal_parse("x(1).y").should == [:call, [:call, nil, :x, [:arglist, [:lit, 1]]], :y, [:arglist]]
+    opal_parse("x (1).y").should == [:call, nil, :x, [:arglist, [:call, [:int, 1], :y, [:arglist]]]]
+    opal_parse("x(1).y").should == [:call, [:call, nil, :x, [:arglist, [:int, 1]]], :y, [:arglist]]
   end
 end
 
 describe "Operator precedence" do
   it "should be raised with parentheses" do
-   opal_parse("(1 + 2) + (3 - 4)").should == [:operator, :+,
-                                               [:operator, :+, [:lit, 1], [:lit, 2]],
-                                               [:operator, :-, [:lit, 3], [:lit, 4]],
+   opal_parse("(1 + 2) + (3 - 4)").should == [:call,
+                                               [:call, [:int, 1], :+, [:arglist, [:int, 2]]],
+                                               :+,
+                                               [:arglist, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]],
                                               ]
-   opal_parse("(1 + 2) - (3 - 4)").should == [:operator, :-,
-                                               [:operator, :+, [:lit, 1], [:lit, 2]],
-                                               [:operator, :-, [:lit, 3], [:lit, 4]],
+   opal_parse("(1 + 2) - (3 - 4)").should == [:call,
+                                               [:call, [:int, 1], :+, [:arglist, [:int, 2]]],
+                                               :-,
+                                               [:arglist, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]],
                                               ]
-   opal_parse("(1 + 2) * (3 - 4)").should == [:operator, :*,
-                                               [:operator, :+, [:lit, 1], [:lit, 2]],
-                                               [:operator, :-, [:lit, 3], [:lit, 4]],
+   opal_parse("(1 + 2) * (3 - 4)").should == [:call,
+                                               [:call, [:int, 1], :+, [:arglist, [:int, 2]]],
+                                               :*,
+                                               [:arglist, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]],
                                               ]
-   opal_parse("(1 + 2) / (3 - 4)").should == [:operator, :/,
-                                               [:operator, :+, [:lit, 1], [:lit, 2]],
-                                               [:operator, :-, [:lit, 3], [:lit, 4]],
+   opal_parse("(1 + 2) / (3 - 4)").should == [:call,
+                                               [:call, [:int, 1], :+, [:arglist, [:int, 2]]],
+                                               :/,
+                                               [:arglist, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]],
                                               ]
   end
 end