Simplify and raise errors eagerly

Author: eregon

src/main/ruby/truffleruby/core/kernel.rb

@@ -492,11 +492,11 @@ def rand(limit = nil)
       Truffle::RandomOperations.rand_range(randomizer, limit)
     else
       max = Primitive.rb_to_int(limit)
-      if max != 0
-        v = Truffle::RandomOperations.rand_int(randomizer, max, false)
-        return v unless Primitive.nil?(v)
+      if max == 0
+        randomizer.random_float
+      else
+        Truffle::RandomOperations.rand_int(randomizer, max, false)
       end
-      randomizer.random_float
     end
   end
   module_function :rand

src/main/ruby/truffleruby/core/random.rb

@@ -67,8 +67,7 @@ def self.srand(seed = undefined)
   end
 
   def self.rand(limit = undefined)
-    r = Truffle::RandomOperations.random(Primitive.thread_randomizer, limit)
-    Truffle::RandomOperations.check_random_number(r, limit)
+    Truffle::RandomOperations.random(Primitive.thread_randomizer, limit)
   end
 
   def self.urandom(size)
@@ -89,8 +88,7 @@ def initialize(seed = undefined)
   end
 
   def rand(limit = undefined)
-    r = Truffle::RandomOperations.random(@randomizer, limit)
-    Truffle::RandomOperations.check_random_number(r, limit)
+    Truffle::RandomOperations.random(@randomizer, limit)
   end
 
   def seed
@@ -124,14 +122,12 @@ def random_number(limit = undefined)
                    Truffle::CustomRandomizer.new(self)
                  end
 
-    v = Truffle::RandomOperations.random(randomizer, limit, ArgumentError)
-    if v
-      v
-    elsif Primitive.nil?(v)
-      randomizer.random_float
-    else
-      Truffle::RandomOperations.invalid_argument(limit)
+    # Weird case, spec'd for SecureRandom.random_number
+    if Primitive.object_kind_of?(limit, Numeric) and limit <= 0
+      return randomizer.random_float
     end
+
+    Truffle::RandomOperations.random(randomizer, limit, ArgumentError)
   end
   alias_method :rand, :random_number
 end

src/main/ruby/truffleruby/core/truffle/random_operations.rb

@@ -17,7 +17,7 @@ def self.random(randomizer, limit, error = TypeError)
         return randomizer.random_float
       end
 
-      return nil if Primitive.nil?(limit)
+      invalid_argument(limit) if Primitive.nil?(limit)
 
       unless Primitive.object_kind_of?(limit, Float)
         if limit_int = Truffle::Type.rb_check_to_integer(limit, :to_int)
@@ -28,7 +28,7 @@ def self.random(randomizer, limit, error = TypeError)
       limit_float = Truffle::Type.rb_check_to_float(limit)
       if !Primitive.nil?(limit_float)
         if limit_float < 0.0
-          nil
+          invalid_argument(limit)
         else
           check_float(limit_float)
           r = randomizer.random_float
@@ -47,19 +47,14 @@ def self.check_float(value)
       value
     end
 
-    def self.check_random_number(value, limit)
-      invalid_argument(limit) if Primitive.nil?(value)
-      value
-    end
-
     def self.invalid_argument(limit)
       raise ArgumentError, "invalid argument - #{limit}"
     end
 
     def self.rand_int(randomizer, limit, restricted)
-      return nil if limit == 0
+      invalid_argument(limit) if limit == 0
       if limit < 0
-        return nil if restricted
+        invalid_argument(limit) if restricted
         limit = -limit
       end
       randomizer.random_integer(limit - 1)
@@ -73,8 +68,11 @@ def self.rand_range(randomizer, range)
       if !Primitive.object_kind_of?(diff, Float) &&
         !Primitive.nil?(v = Truffle::Type.rb_check_to_integer(diff, :to_int))
         max = exclude_end ? v - 1 : v
-        v = nil
-        v = randomizer.random_integer(max) if max >= 0
+        if max >= 0
+          v = randomizer.random_integer(max)
+        else
+          invalid_argument(range)
+        end
       elsif !Primitive.nil?(v = Truffle::Type.rb_check_to_float(diff))
         scale = 1
         max = v
@@ -100,7 +98,7 @@ def self.rand_range(randomizer, range)
         elsif max == 0.0 && !exclude_end
           v = 0.0
         else
-          v = nil
+          invalid_argument(range)
         end
       end
 
@@ -109,8 +107,6 @@ def self.rand_range(randomizer, range)
       end
 
       case v
-      when NilClass
-        v
       when Float
         f = Truffle::Type.rb_check_to_float(b)
         return v + f unless Primitive.nil?(f)