[GR-45201] Raise ArgumentError when Time.new is called with argument that doesn't fit in Java Integer

PullRequest: truffleruby/3769

Author: andrykonchin

lib/truffle/stringio.rb

@@ -143,7 +143,7 @@ def initialize(string = nil, mode = nil, **options)
       warn 'StringIO::new() does not take block; use StringIO::open() instead'
     end
 
-    mode, _binary, _external, _internal, _autoclose, _perm = IO.normalize_options(mode, nil, options)
+    mode, _binary, _external, _internal, _autoclose, _perm = Truffle::IOOperations.normalize_options(mode, nil, options)
 
     if Primitive.nil?(string)
       mode ||= IO::RDWR

src/main/java/org/truffleruby/core/CoreLibrary.java

@@ -1001,6 +1001,7 @@ public boolean isTruffleBootMainMethod(SharedMethodInfo info) {
             "/core/truffle/stat_operations.rb",
             "/core/truffle/string_operations.rb",
             "/core/truffle/backward.rb",
+            "/core/truffle/time_operations.rb",
             "/core/truffle/truffleruby.rb",
             "/core/splitter.rb",
             "/core/stat.rb",

src/main/java/org/truffleruby/core/time/TimeNodes.java

@@ -511,6 +511,7 @@ public abstract static class TimeSFromArrayPrimitiveNode extends PrimitiveArrayA
         @Child private TruffleString.FromJavaStringNode fromJavaStringNode;
 
         @Specialization(guards = "(isutc || !isRubyDynamicObject(utcoffset)) || isNil(utcoffset)")
+        @TruffleBoundary
         protected RubyTime timeSFromArray(
                 RubyClass timeClass,
                 int sec,
@@ -524,29 +525,7 @@ protected RubyTime timeSFromArray(
                 boolean isutc,
                 Object utcoffset) {
             final RubyLanguage language = getLanguage();
-            return buildTime(language, timeClass, sec, min, hour, mday, month, year, nsec, isdst, isutc, utcoffset);
-        }
 
-        @Specialization(guards = "!isInteger(sec) || !isInteger(nsec)")
-        protected Object timeSFromArrayFallback(
-                RubyClass timeClass,
-                Object sec,
-                int min,
-                int hour,
-                int mday,
-                int month,
-                int year,
-                Object nsec,
-                int isdst,
-                boolean isutc,
-                Object utcoffset) {
-            return FAILURE;
-        }
-
-        @TruffleBoundary
-        private RubyTime buildTime(RubyLanguage language, RubyClass timeClass, int sec, int min, int hour, int mday,
-                int month,
-                int year, int nsec, int isdst, boolean isutc, Object utcoffset) {
             if (nsec < 0 || nsec > 999999999 ||
                     sec < 0 || sec > 60 || // MRI accepts sec=60, whether it is a leap second or not
                     min < 0 || min > 59 ||

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

@@ -1164,7 +1164,7 @@ def initialize(path_or_fd, mode = nil, perm = nil, **options)
       @path = nil
     else
       path = Truffle::Type.coerce_to_path path_or_fd
-      nmode, _binary, _external, _internal, _autoclose, perm = IO.normalize_options(mode, perm, options)
+      nmode, _binary, _external, _internal, _autoclose, perm = Truffle::IOOperations.normalize_options(mode, perm, options)
       fd = IO.sysopen(path, nmode, perm)
 
       @path = path

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

@@ -337,7 +337,7 @@ def self.binwrite(file, string, offset = nil, **options)
     default_mode = File::CREAT | File::RDWR | File::BINARY
     default_mode |= File::TRUNC unless offset
 
-    mode, _binary, external, _internal, _autoclose, perm = IO.normalize_options(nil, nil, options, default_mode)
+    mode, _binary, external, _internal, _autoclose, perm = Truffle::IOOperations.normalize_options(nil, nil, options, default_mode)
 
     File.open(file, mode, encoding: (external || 'ASCII-8BIT'), perm: perm) do |f|
       f.seek(offset) if offset
@@ -502,7 +502,7 @@ def self.write(file, string, offset = nil, **options)
       default_mode = File::CREAT | File::WRONLY
       default_mode |= File::TRUNC unless offset
 
-      mode, _binary, external, _internal, _autoclose, perm = IO.normalize_options(nil, nil, options, default_mode)
+      mode, _binary, external, _internal, _autoclose, perm = Truffle::IOOperations.normalize_options(nil, nil, options, default_mode)
 
       open_args = [mode]
       open_kw = { encoding: (external || 'ASCII-8BIT'), perm: perm }
@@ -569,99 +569,6 @@ def self.try_convert(obj)
     Truffle::Type.rb_check_convert_type obj, IO, :to_io
   end
 
-  def self.normalize_options(mode, perm, options, default_mode = nil)
-    autoclose = true
-
-    if mode
-      mode = (Truffle::Type.try_convert(mode, Integer, :to_int) or
-              Truffle::Type.coerce_to(mode, String, :to_str))
-    end
-
-    if options
-      if optmode = options[:mode]
-        optmode = (Truffle::Type.try_convert(optmode, Integer, :to_int) or
-                   Truffle::Type.coerce_to(optmode, String, :to_str))
-      end
-
-      if mode && optmode
-        raise ArgumentError, 'mode specified twice'
-      end
-
-      mode ||= optmode
-      mode ||= default_mode
-
-      if flags = options[:flags]
-        flags = Truffle::Type.rb_convert_type(flags, Integer, :to_int)
-
-        if Primitive.nil?(mode)
-          mode = flags
-        elsif Primitive.is_a?(mode, Integer)
-          mode |= flags
-        else # it's a String
-          mode = Truffle::IOOperations.parse_mode(mode)
-          mode |= flags
-        end
-      end
-
-      if optperm = options[:perm]
-        optperm = Truffle::Type.try_convert(optperm, Integer, :to_int)
-      end
-
-      if perm
-        raise ArgumentError, 'perm specified twice' if optperm
-      else
-        perm = optperm
-      end
-
-      autoclose = Primitive.as_boolean(options[:autoclose]) if options.key?(:autoclose)
-    end
-
-    mode ||= default_mode
-
-    if Primitive.is_a?(mode, String)
-      mode, external, internal = mode.split(':', 3)
-      raise ArgumentError, 'invalid access mode' unless mode
-
-      binary = true  if mode.include?(?b)
-      binary = false if mode.include?(?t)
-    elsif mode
-      binary = true  if (mode & BINARY) != 0
-    end
-
-    if options
-      if options[:textmode] and options[:binmode]
-        raise ArgumentError, 'both textmode and binmode specified'
-      end
-
-      if Primitive.nil? binary
-        binary = options[:binmode]
-      elsif options.key?(:textmode) or options.key?(:binmode)
-        raise ArgumentError, 'text/binary mode specified twice'
-      end
-
-      if !external and !internal
-        external = options[:external_encoding]
-        internal = options[:internal_encoding]
-      elsif options[:external_encoding] or options[:internal_encoding] or options[:encoding]
-        raise ArgumentError, 'encoding specified twice'
-      end
-
-      if !external and !internal
-        encoding = options[:encoding]
-
-        if Primitive.is_a?(encoding, Encoding)
-          external = encoding
-        elsif !Primitive.nil?(encoding)
-          encoding = StringValue(encoding)
-          external, internal = encoding.split(':', 2)
-        end
-      end
-    end
-    external = Encoding::BINARY if binary and !external and !internal
-    perm ||= 0666
-    [mode, binary, external, internal, autoclose, perm]
-  end
-
   def self.open(*args, **options)
     io = new(*args, **options)
 
@@ -720,7 +627,7 @@ def self.popen(*args)
       end
     end
 
-    mode, binary, external, internal, _autoclose, _perm = IO.normalize_options(mode, nil, io_options)
+    mode, binary, external, internal, _autoclose, _perm = Truffle::IOOperations.normalize_options(mode, nil, io_options)
     mode_int = Truffle::IOOperations.parse_mode mode
 
     readable = false
@@ -941,7 +848,7 @@ def initialize(fd, mode = nil, **options)
     @external = nil
     @pid = nil
 
-    mode, binary, external, internal, autoclose_tmp, _perm = IO.normalize_options(mode, nil, options)
+    mode, binary, external, internal, autoclose_tmp, _perm = Truffle::IOOperations.normalize_options(mode, nil, options)
 
     fd = Truffle::Type.coerce_to(fd, Integer, :to_int)
     sync = fd == 2 # stderr is always unbuffered, see setvbuf(3)

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

@@ -37,11 +37,6 @@
 class Time
   include Comparable
 
-  MonthValue = {
-    'JAN' => 1, 'FEB' => 2, 'MAR' => 3, 'APR' => 4, 'MAY' => 5, 'JUN' => 6,
-    'JUL' => 7, 'AUG' => 8, 'SEP' => 9, 'OCT' =>10, 'NOV' =>11, 'DEC' =>12
-  }
-
   def inspect
     str = strftime('%Y-%m-%d %H:%M:%S')
 
@@ -371,99 +366,6 @@ def at(sec, sub_sec = undefined, unit = undefined, **kwargs)
       time
     end
 
-    def from_array(sec, min, hour, mday, month, year, nsec, is_dst, is_utc, utc_offset)
-      time = Primitive.time_s_from_array(self, sec, min, hour, mday, month, year, nsec, is_dst, is_utc, utc_offset)
-      return time unless Primitive.undefined?(time)
-
-      if Primitive.is_a?(sec, String)
-        sec = sec.to_i
-      elsif nsec
-        sec = Truffle::Type.coerce_to(sec || 0, Integer, :to_int)
-      else
-        s = Truffle::Type.coerce_to_exact_num(sec || 0)
-
-        sec       = s.to_i
-        nsec_frac = s % 1.0
-
-        if s < 0 && nsec_frac > 0
-          sec -= 1
-        end
-
-        nsec = (nsec_frac * 1_000_000_000 + 0.5).to_i
-      end
-
-      nsec ||= 0
-      sec += nsec / 1_000_000_000
-      nsec %= 1_000_000_000
-
-      from_array(sec, min, hour, mday, month, year, nsec, is_dst, is_utc, utc_offset)
-    end
-    private :from_array
-
-    def compose(offset, p1, p2 = nil, p3 = nil, p4 = nil, p5 = nil, p6 = nil, p7 = nil,
-                yday = undefined, is_dst = undefined, tz = undefined)
-      if Primitive.undefined?(tz)
-        unless Primitive.undefined?(is_dst)
-          raise ArgumentError, 'wrong number of arguments (9 for 1..8)'
-        end
-
-        y = p1
-        m = p2
-        d = p3
-        hr = p4
-        min = p5
-        sec = p6
-        usec = p7
-        is_dst = -1
-      else
-        y = p6
-        m = p5
-        d = p4
-        hr = p3
-        min = p2
-        sec = p1
-        usec = 0
-        is_dst = is_dst ? 1 : 0
-      end
-
-      if Primitive.is_a?(m, String) or m.respond_to?(:to_str)
-        m = StringValue(m)
-        m = MonthValue[m.upcase] || m.to_i
-
-        raise ArgumentError, 'month argument out of range' unless m
-      else
-        m = Truffle::Type.coerce_to(m || 1, Integer, :to_int)
-      end
-
-      y   = Primitive.is_a?(y, String)   ? y.to_i   : Truffle::Type.coerce_to(y,        Integer, :to_int)
-      d   = Primitive.is_a?(d, String)   ? d.to_i   : Truffle::Type.coerce_to(d   || 1, Integer, :to_int)
-      hr  = Primitive.is_a?(hr, String)  ? hr.to_i  : Truffle::Type.coerce_to(hr  || 0, Integer, :to_int)
-      min = Primitive.is_a?(min, String) ? min.to_i : Truffle::Type.coerce_to(min || 0, Integer, :to_int)
-
-      nsec = nil
-      if Primitive.is_a?(usec, String)
-        nsec = usec.to_i * 1000
-      elsif usec
-        nsec = (usec * 1000).to_i
-      end
-
-      case offset
-      when :utc
-        is_dst = -1
-        is_utc = true
-        offset = nil
-      when :local
-        is_utc = false
-        offset = nil
-      else
-        is_dst = -1
-        is_utc = false
-      end
-
-      from_array(sec, min, hr, d, m, y, nsec, is_dst, is_utc, offset)
-    end
-    private :compose
-
     def new(year = undefined, month = nil, day = nil, hour = nil, minute = nil, second = nil, utc_offset = nil, **options)
       if utc_offset && options[:in]
         raise ArgumentError, 'timezone argument given as positional and keyword arguments'
@@ -474,18 +376,18 @@ def new(year = undefined, month = nil, day = nil, hour = nil, minute = nil, seco
       if Primitive.undefined?(year)
         utc_offset ? self.now.getlocal(utc_offset) : self.now
       elsif Primitive.nil? utc_offset
-        compose(:local, year, month, day, hour, minute, second)
+        Truffle::TimeOperations.compose(self, :local, year, month, day, hour, minute, second)
       elsif utc_offset == :std
-        compose(:local, second, minute, hour, day, month, year, nil, nil, false, nil)
+        Truffle::TimeOperations.compose(self, :local, second, minute, hour, day, month, year, nil, nil, false, nil)
       elsif utc_offset == :dst
-        compose(:local, second, minute, hour, day, month, year, nil, nil, true, nil)
+        Truffle::TimeOperations.compose(self, :local, second, minute, hour, day, month, year, nil, nil, true, nil)
       else
         if utc_offset_in_utc?(utc_offset)
           utc_offset = :utc
         else
           utc_offset = Truffle::Type.coerce_to_utc_offset(utc_offset)
         end
-        compose(utc_offset, year, month, day, hour, minute, second)
+        Truffle::TimeOperations.compose(self, utc_offset, year, month, day, hour, minute, second)
       end
     end
 
@@ -508,12 +410,12 @@ def now(**options)
     end
 
     def local(*args)
-      compose(:local, *args)
+      Truffle::TimeOperations.compose(self, :local, *args)
     end
     alias_method :mktime, :local
 
     def gm(*args)
-      compose(:utc, *args)
+      Truffle::TimeOperations.compose(self, :utc, *args)
     end
     alias_method :utc, :gm
   end