[Truffle] Fixnum#fdiv specs all passing.

Author: chrisseaton

core/src/main/java/org/jruby/truffle/nodes/core/FixnumNodes.java

@@ -640,6 +640,7 @@ public int div(@SuppressWarnings("unused") long a, @SuppressWarnings("unused") R
             // TODO(CS): not entirely sure this is correct
             return 0;
         }
+
     }
 
     @CoreMethod(names = "%", required = 1)

core/src/main/java/org/jruby/truffle/nodes/core/FloatNodes.java

@@ -17,6 +17,7 @@
 import com.oracle.truffle.api.utilities.ConditionProfile;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
+import org.jruby.truffle.runtime.DebugOperations;
 import org.jruby.truffle.runtime.RubyCallStack;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
@@ -254,6 +255,15 @@ public double div(double a, RubyBignum b) {
             return a / b.doubleValue();
         }
 
+        @Specialization(guards = {
+                "!isInteger(arguments[1])",
+                "!isLong(arguments[1])",
+                "!isDouble(arguments[1])",
+                "!isRubyBignum(arguments[1])"})
+        public Object div(double a, Object b) {
+            return DebugOperations.send(getContext(), a, "redo_coerced", null, getContext().getSymbolTable().getSymbol("/"), b);
+        }
+
     }
 
     @CoreMethod(names = "%", required = 1)

core/src/main/ruby/jruby/truffle/core/rubinius/kernel/common/fixnum.rb

@@ -33,4 +33,12 @@ def coerce(other)
     super other
   end
 
+  def fdiv(n)
+    if n.kind_of?(Fixnum)
+      to_f / n
+    else
+      redo_coerced :fdiv, n
+    end
+  end
+
 end

core/src/main/ruby/jruby/truffle/core/rubinius/kernel/common/float.rb

@@ -28,6 +28,11 @@
 
 class Float < Numeric
 
+  def coerce(other)
+    return [other, self] if other.kind_of? Float
+    [Float(other), self]
+  end
+
   def to_r
     f, e = Math.frexp self
     f = Math.ldexp(f, MANT_DIG).to_i

core/src/main/ruby/jruby/truffle/core/rubinius/kernel/common/kernel.rb

@@ -42,6 +42,16 @@ def Rational(a, b = 1)
   end
   module_function :Rational
 
+  def Float(obj)
+    case obj
+    when String
+      Rubinius::Type.coerce_string_to_float obj, true
+    else
+      Rubinius::Type.coerce_object_to_float obj
+    end
+  end
+  module_function :Float
+
   ##
   # MRI uses a macro named StringValue which has essentially the same
   # semantics as obj.coerce_to(String, :to_str), but rather than using that

core/src/main/ruby/jruby/truffle/core/rubinius/kernel/common/numeric.rb

@@ -28,6 +28,58 @@
 
 class Numeric
 
+  #--
+  # We deviate from MRI behavior here because we ensure that Fixnum op Bignum
+  # => Bignum (possibly normalized to Fixnum)
+  #
+  # Note these differences on MRI, where a is a Fixnum, b is a Bignum
+  #
+  #   a.coerce b => [Float, Float]
+  #   b.coerce a => [Bignum, Bignum]
+  #++
+
+  def coerce(other)
+    if other.instance_of? self.class
+      return [other, self]
+    end
+
+    [Float(other), Float(self)]
+  end
+
+  ##
+  # This method mimics the semantics of MRI's do_coerce function
+  # in numeric.c. Note these differences between it and #coerce:
+  #
+  #   1.2.coerce("2") => [2.0, 1.2]
+  #   1.2 + "2" => TypeError: String can't be coerced into Float
+  #
+  # See also Integer#coerce
+
+  def math_coerce(other, error=:coerce_error)
+    begin
+      values = other.coerce(self)
+    rescue
+      if error == :coerce_error
+        raise TypeError, "#{other.class} can't be coerced into #{self.class}"
+      else
+        raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+      end
+    end
+
+    unless Rubinius::Type.object_kind_of?(values, Array) && values.length == 2
+      raise TypeError, "coerce must return [x, y]"
+    end
+
+    return values[1], values[0]
+  end
+  private :math_coerce
+
+  def redo_coerced(meth, right)
+    b, a = math_coerce(right)
+    a.__send__ meth, b
+  end
+  private :redo_coerced
+
   def zero?
     self == 0
   end