Parse operator calls as normal method calls

adambeynon · adambeynon · commit aa4f272d600f · 2013-07-30T21:31:47.000+01:00
diff --git a/corelib/opal/array.rb b/corelib/opal/array.rb
@@ -231,7 +231,7 @@ def ==(other)
           }
         }
 
-        if (!#{`#{self}[i]` == `other[i]`}) {
+        if (!(#{`#{self}[i]` == `other[i]`})) {
           return false;
         }
 
diff --git a/lib/opal/grammar.rb b/lib/opal/grammar.rb
diff --git a/lib/opal/grammar.y b/lib/opal/grammar.y
@@ -450,19 +450,19 @@ arg:
     }
   | arg '+' arg
     {
-      result = s(:operator, :"+", val[0], val[2])
+      result = new_call val[0], :"+", s(:arglist, val[2])
     }
   | arg '-' arg
     {
-      result = s(:operator, :"-", val[0], val[2])
+      result = new_call val[0], :"-", s(:arglist, val[2])
     }
   | arg '*' arg
     {
-      result = s(:operator, :"*", val[0], val[2])
+      result = new_call val[0], :"*", s(:arglist, val[2])
     }
   | arg '/' arg
     {
-      result = s(:operator, :"/", val[0], val[2])
+      result = new_call val[0], :"/", s(:arglist, val[2])
     }
   | arg '%' arg
     {
diff --git a/lib/opal/parser.rb b/lib/opal/parser.rb
@@ -69,7 +69,6 @@ def parse(source, options = {})
       @source_file              =  options[:source_file] || @file
       @method_missing           = (options[:method_missing] != false)
       @stub_methods             = (options[:stub_methods] != true)
-      @optimized_operators      = (options[:optimized_operators] == false)
       @arity_check              =  options[:arity_check]
       @const_missing            = (options[:const_missing] != false)
       @irb_vars                 = (options[:irb] == true)
@@ -536,32 +535,6 @@ def process_js_tmp(sexp, level)
       fragment(sexp.shift.to_s, sexp)
     end
 
-    def process_operator(sexp, level)
-      meth, recv, arg = sexp
-      mid = mid_to_jsid meth.to_s
-      result = []
-
-      if @optimized_operators
-        with_temp do |a|
-          with_temp do |b|
-            l = process recv, :expr
-            r = process arg, :expr
-
-            result << fragment("(#{a} = ", sexp)
-            result << l
-            result << fragment(", #{b} = ", sexp)
-            result << r
-            result << fragment(", typeof(#{a}) === 'number' ? #{a} #{meth} #{b} ", sexp)
-            result << fragment(": #{a}#{mid}(#{b}))", sexp)
-          end
-        end
-      else
-        result = [process(recv, :recv), fragment("#{mid}(", sexp), process(arg, :expr), fragment(")", sexp)]
-      end
-
-      result
-    end
-
     def js_block_given(sexp, level)
       @scope.uses_block!
       if @scope.block_name
diff --git a/spec/parser/call_spec.rb b/spec/parser/call_spec.rb
@@ -26,13 +26,6 @@
 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]]
-  end
-
   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]]]
@@ -67,17 +60,17 @@
 
 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, [:call, nil, :x, [:arglist]], :-, [:arglist, [:lit, 1]]]
     opal_parse("x -1").should == [:call, nil, :x, [:arglist, [:lit, -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, [:call, nil, :x, [:arglist]], :+, [:arglist, [:lit, 1]]]
     opal_parse("x +1").should == [:call, nil, :x, [:arglist, [:lit, 1]]]
   end
 
   it "should correctly parse / and regexps" do
-    opal_parse("x / 500").should == [:operator, :/, [:call, nil, :x, [:arglist]], [:lit, 500]]
+    opal_parse("x / 500").should == [:call, [:call, nil, :x, [:arglist]], :/, [:arglist, [:lit, 500]]]
     opal_parse("x /foo/").should == [:call, nil, :x, [:arglist, [:lit, /foo/]]]
   end
 
@@ -89,21 +82,25 @@
 
 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, [:lit, 1], :+, [:arglist, [:lit, 2]]],
+                                               :+,
+                                               [:arglist, [:call, [:lit, 3], :-, [:arglist, [:lit, 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, [:lit, 1], :+, [:arglist, [:lit, 2]]],
+                                               :-,
+                                               [:arglist, [:call, [:lit, 3], :-, [:arglist, [:lit, 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, [:lit, 1], :+, [:arglist, [:lit, 2]]],
+                                               :*,
+                                               [:arglist, [:call, [:lit, 3], :-, [:arglist, [:lit, 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, [:lit, 1], :+, [:arglist, [:lit, 2]]],
+                                               :/,
+                                               [:arglist, [:call, [:lit, 3], :-, [:arglist, [:lit, 4]]]],
                                               ]
   end
 end

Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ def ==(other)`
`231`	`231`	`}`
`232`	`232`	`}`
`233`	`233`
`234`		- if (!#{`#{self}[i]` == `other[i]`}) {
	`234`	+ if (!(#{`#{self}[i]` == `other[i]`})) {
`235`	`235`	`return false;`
`236`	`236`	`}`
`237`	`237`
Original file line number	Diff line number	Diff line change
`@@ -450,19 +450,19 @@ arg:`
`450`	`450`	`}`
`451`	`451`	`\| arg '+' arg`
`452`	`452`	`{`
`453`		`- result = s(:operator, :"+", val[0], val[2])`
	`453`	`+ result = new_call val[0], :"+", s(:arglist, val[2])`
`454`	`454`	`}`
`455`	`455`	`\| arg '-' arg`
`456`	`456`	`{`
`457`		`- result = s(:operator, :"-", val[0], val[2])`
	`457`	`+ result = new_call val[0], :"-", s(:arglist, val[2])`
`458`	`458`	`}`
`459`	`459`	`\| arg '*' arg`
`460`	`460`	`{`
`461`		`- result = s(:operator, :"*", val[0], val[2])`
	`461`	`+ result = new_call val[0], :"*", s(:arglist, val[2])`
`462`	`462`	`}`
`463`	`463`	`\| arg '/' arg`
`464`	`464`	`{`
`465`		`- result = s(:operator, :"/", val[0], val[2])`
	`465`	`+ result = new_call val[0], :"/", s(:arglist, val[2])`
`466`	`466`	`}`
`467`	`467`	`\| arg '%' arg`
`468`	`468`	`{`