Replace usages of Int#/ for Int#//

spec/std/deque_spec.cr

@@ -75,21 +75,21 @@ describe "Deque" do
     it "works the same as array when inserting at 1/8 size and deleting at 3/4 size" do
       DequeTester.new.test do
         1000.times do
-          step { c.insert(c.size / 8, i) }
+          step { c.insert(c.size // 8, i) }
         end
         1000.times do
-          step { c.delete_at(c.size * 3 / 4) }
+          step { c.delete_at(c.size * 3 // 4) }
         end
       end
     end
 
     it "works the same as array when inserting at 3/4 size and deleting at 1/8 size" do
       DequeTester.new.test do
         1000.times do
-          step { c.insert(c.size * 3 / 4, i) }
+          step { c.insert(c.size * 3 // 4, i) }
         end
         1000.times do
-          step { c.delete_at(c.size / 8) }
+          step { c.delete_at(c.size // 8) }
         end
       end
     end

spec/std/enumerable_spec.cr

@@ -118,7 +118,7 @@ describe "Enumerable" do
       [1, 2].chunk { false }.to_a.should eq [{false, [1, 2]}]
       [1, 1, 2, 3, 3].chunk(&.itself).to_a.should eq [{1, [1, 1]}, {2, [2]}, {3, [3, 3]}]
       [1, 1, 2, 3, 3].chunk(&.<=(2)).to_a.should eq [{true, [1, 1, 2]}, {false, [3, 3]}]
-      (0..10).chunk(&./(3)).to_a.should eq [{0, [0, 1, 2]}, {1, [3, 4, 5]}, {2, [6, 7, 8]}, {3, [9, 10]}]
+      (0..10).chunk(&.//(3)).to_a.should eq [{0, [0, 1, 2]}, {1, [3, 4, 5]}, {2, [6, 7, 8]}, {3, [9, 10]}]
     end
 
     it "work with class" do
@@ -132,7 +132,7 @@ describe "Enumerable" do
     end
 
     it "rewind" do
-      i = (0..10).chunk(&./(3))
+      i = (0..10).chunk(&.//(3))
       i.next.should eq({0, [0, 1, 2]})
       i.next.should eq({1, [3, 4, 5]})
     end
@@ -193,15 +193,15 @@ describe "Enumerable" do
       [1, 2].chunks { false }.should eq [{false, [1, 2]}]
       [1, 1, 2, 3, 3].chunks(&.itself).should eq [{1, [1, 1]}, {2, [2]}, {3, [3, 3]}]
       [1, 1, 2, 3, 3].chunks(&.<=(2)).should eq [{true, [1, 1, 2]}, {false, [3, 3]}]
-      (0..10).chunks(&./(3)).should eq [{0, [0, 1, 2]}, {1, [3, 4, 5]}, {2, [6, 7, 8]}, {3, [9, 10]}]
+      (0..10).chunks(&.//(3)).should eq [{0, [0, 1, 2]}, {1, [3, 4, 5]}, {2, [6, 7, 8]}, {3, [9, 10]}]
     end
 
     it "work with class" do
       [1, 1, 2, 3, 3].chunks(&.class).should eq [{Int32, [1, 1, 2, 3, 3]}]
     end
 
     it "work with pure enumerable" do
-      SpecEnumerable.new.chunks(&./(2)).should eq [{0, [1]}, {1, [2, 3]}]
+      SpecEnumerable.new.chunks(&.//(2)).should eq [{0, [1]}, {1, [2, 3]}]
     end
 
     it "returns elements for which the block returns Enumerable::Chunk::Alone in separate Arrays" do

spec/std/int_spec.cr

@@ -429,7 +429,7 @@ describe "Int" do
   it "holds true that x == q*y + r" do
     [5, -5, 6, -6, 10, -10].each do |x|
       [3, -3].each do |y|
-        q = x / y
+        q = x // y
         r = x % y
         (q*y + r).should eq(x)
       end

spec/std/random/secure_spec.cr

@@ -9,7 +9,7 @@ describe "Random::Secure" do
     x.should be >= 123456
     x.should be < 654321
 
-    Random::Secure.rand(Int64::MAX / 2).should be <= (Int64::MAX / 2)
+    Random::Secure.rand(Int64::MAX // 2).should be <= (Int64::MAX // 2)
   end
 
   it "fully fills a large buffer" do

src/array.cr

@@ -1474,7 +1474,7 @@ class Array(T)
     return self if size == 0
     n %= size
     return self if n == 0
-    if n <= size / 2
+    if n <= size // 2
       tmp = self[0..n]
       @buffer.move_from(@buffer + n, size - n)
       (@buffer + size - n).copy_from(tmp.to_unsafe, n)
@@ -1946,7 +1946,7 @@ class Array(T)
   end
 
   protected def self.heap_sort!(a, n)
-    (n / 2).downto 0 do |p|
+    (n // 2).downto 0 do |p|
       heapify!(a, p, n)
     end
     while n > 1
@@ -1958,14 +1958,14 @@ class Array(T)
 
   protected def self.heapify!(a, p, n)
     v, c = a[p], p
-    while c < (n - 1) / 2
+    while c < (n - 1) // 2
       c = 2 * (c + 1)
       c -= 1 if cmp(a[c], a[c - 1]) < 0
       break unless cmp(v, a[c]) <= 0
       a[p] = a[c]
       p = c
     end
-    if n & 1 == 0 && c == n / 2 - 1
+    if n & 1 == 0 && c == n // 2 - 1
       c = 2 * c + 1
       if cmp(v, a[c]) < 0
         a[p] = a[c]
@@ -1976,7 +1976,7 @@ class Array(T)
   end
 
   protected def self.center_median!(a, n)
-    b, c = a + n / 2, a + n - 1
+    b, c = a + n // 2, a + n - 1
     if cmp(a.value, b.value) <= 0
       if cmp(b.value, c.value) <= 0
         return
@@ -1995,7 +1995,7 @@ class Array(T)
   end
 
   protected def self.partition_for_quick_sort!(a, n)
-    v, l, r = a[n / 2], a + 1, a + n - 1
+    v, l, r = a[n // 2], a + 1, a + n - 1
     loop do
       while cmp(l.value, v) < 0
         l += 1
@@ -2044,7 +2044,7 @@ class Array(T)
   end
 
   protected def self.heap_sort!(a, n, comp)
-    (n / 2).downto 0 do |p|
+    (n // 2).downto 0 do |p|
       heapify!(a, p, n, comp)
     end
     while n > 1
@@ -2056,14 +2056,14 @@ class Array(T)
 
   protected def self.heapify!(a, p, n, comp)
     v, c = a[p], p
-    while c < (n - 1) / 2
+    while c < (n - 1) // 2
       c = 2 * (c + 1)
       c -= 1 if cmp(a[c], a[c - 1], comp) < 0
       break unless cmp(v, a[c], comp) <= 0
       a[p] = a[c]
       p = c
     end
-    if n & 1 == 0 && c == n / 2 - 1
+    if n & 1 == 0 && c == n // 2 - 1
       c = 2 * c + 1
       if cmp(v, a[c], comp) < 0
         a[p] = a[c]
@@ -2074,7 +2074,7 @@ class Array(T)
   end
 
   protected def self.center_median!(a, n, comp)
-    b, c = a + n / 2, a + n - 1
+    b, c = a + n // 2, a + n - 1
     if cmp(a.value, b.value, comp) <= 0
       if cmp(b.value, c.value, comp) <= 0
         return
@@ -2093,7 +2093,7 @@ class Array(T)
   end
 
   protected def self.partition_for_quick_sort!(a, n, comp)
-    v, l, r = a[n / 2], a + 1, a + n - 1
+    v, l, r = a[n // 2], a + 1, a + n - 1
     loop do
       while l < a + n && cmp(l.value, v, comp) < 0
         l += 1

src/base64.cr

@@ -191,7 +191,7 @@ module Base64
 
   private def encode_size(str_size, new_lines = false)
     size = (str_size * 4 / 3.0).to_i + 4
-    size += size / LINE_SIZE if new_lines
+    size += size // LINE_SIZE if new_lines
     size
   end
 

src/big/big_int.cr

@@ -696,7 +696,7 @@ module Random
       needed_parts += 1
     end
 
-    limit = rand_max / max * max
+    limit = rand_max // max * max
 
     loop do
       result = BigInt.new(next_u)

src/bit_array.cr

@@ -153,7 +153,7 @@ struct BitArray
     else
       ba = BitArray.new(count)
       start_bit_index, start_sub_index = start.divmod(32)
-      end_bit_index = (start + count) / 32
+      end_bit_index = (start + count) // 32
 
       i = 0
       bits = @bits[start_bit_index]

src/compiler/crystal/codegen/debug.cr

@@ -102,7 +102,7 @@ module Crystal
           size = @program.target_machine.data_layout.size_in_bits(llvm_embedded_type(ivar_type))
 
           # FIXME structs like LibC::PthreadMutexT generate huge offset values
-          next if offset > UInt64::MAX / 8u64
+          next if offset > UInt64::MAX // 8u64
 
           member = di_builder.create_member_type(nil, name[1..-1], nil, 1, size, size, 8u64 * offset, LLVM::DIFlags::Zero, ivar_debug_type)
           element_types << member

src/compiler/crystal/compiler.cr

@@ -427,7 +427,7 @@ module Crystal
       jobs_count = 0
       wait_channel = Channel(Array(String)).new(@n_threads)
 
-      units.each_slice(Math.max(units.size / @n_threads, 1)) do |slice|
+      units.each_slice(Math.max(units.size // @n_threads, 1)) do |slice|
         jobs_count += 1
         spawn do
           # For stats output we want to count how many previous

src/compiler/crystal/tools/table_print.cr

@@ -32,7 +32,7 @@ module Crystal
         when :right
           "%+#{available_width}s" % cell.text
         when :center
-          left = " " * ((available_width - cell.text.size) / 2)
+          left = " " * ((available_width - cell.text.size) // 2)
           right = " " * (available_width - cell.text.size - left.size)
           "#{left}#{cell.text}#{right}"
         end

src/compiler/crystal/types.cr

@@ -1273,7 +1273,7 @@ module Crystal
     end
 
     def normal_rank
-      (@rank - 1) / 2
+      (@rank - 1) // 2
     end
 
     def range

src/crystal/compiler_rt.cr

@@ -26,11 +26,11 @@ fun __mulodi4(a : Int64, b : Int64, overflow : Int32*) : Int64
     return result
   end
   if sa == sb
-    if abs_a > max / abs_b
+    if abs_a > max // abs_b
       overflow.value = 1
     end
   else
-    if abs_a > min / (0i64 &- abs_b)
+    if abs_a > min // (0i64 &- abs_b)
       overflow.value = 1
     end
   end

src/crystal/event.cr

@@ -24,7 +24,7 @@ struct Crystal::Event
   def add(timeout : Time::Span)
     add LibC::Timeval.new(
       tv_sec: LibC::TimeT.new(timeout.total_seconds),
-      tv_usec: timeout.nanoseconds / 1_000
+      tv_usec: timeout.nanoseconds // 1_000
     )
   end
 

src/crystal/hasher.cr

@@ -244,7 +244,7 @@ struct Crystal::Hasher
   end
 
   private def read_u24(ptr, rest)
-    ptr[0].to_u64 | (ptr[rest/2].to_u64 << 8) | (ptr[rest - 1].to_u64 << 16)
+    ptr[0].to_u64 | (ptr[rest//2].to_u64 << 8) | (ptr[rest - 1].to_u64 << 16)
   end
 
   private def read_u32(ptr)

src/crystal/system/unix/file.cr

@@ -125,7 +125,7 @@ module Crystal::System::File
   private def self.to_timeval(time : ::Time)
     t = uninitialized LibC::Timeval
     t.tv_sec = typeof(t.tv_sec).new(time.to_unix)
-    t.tv_usec = typeof(t.tv_usec).new(time.nanosecond / ::Time::NANOSECONDS_PER_MICROSECOND)
+    t.tv_usec = typeof(t.tv_usec).new(time.nanosecond // ::Time::NANOSECONDS_PER_MICROSECOND)
     t
   end
 

src/crystal/system/unix/time.cr

@@ -28,8 +28,8 @@ module Crystal::System::Time
   def self.monotonic : {Int64, Int32}
     {% if flag?(:darwin) %}
       info = mach_timebase_info
-      total_nanoseconds = LibC.mach_absolute_time * info.numer / info.denom
-      seconds = total_nanoseconds / 1_000_000_000
+      total_nanoseconds = LibC.mach_absolute_time * info.numer // info.denom
+      seconds = total_nanoseconds // 1_000_000_000
       nanoseconds = total_nanoseconds.remainder(1_000_000_000)
       {seconds.to_i64, nanoseconds.to_i32}
     {% else %}

src/debug/dwarf/line_numbers.cr

@@ -266,7 +266,7 @@ module Debug
           registers.address += {{operation_advance}} * sequence.minimum_instruction_length
         else
           registers.address += sequence.minimum_instruction_length *
-            ((registers.op_index + operation_advance) / sequence.maximum_operations_per_instruction)
+            ((registers.op_index + operation_advance) // sequence.maximum_operations_per_instruction)
           registers.op_index = (registers.op_index + operation_advance) % sequence.maximum_operations_per_instruction
         end
       end
@@ -281,7 +281,7 @@ module Debug
           if opcode >= sequence.opcode_base
             # special opcode
             adjusted_opcode = opcode - sequence.opcode_base
-            operation_advance = adjusted_opcode / sequence.line_range
+            operation_advance = adjusted_opcode // sequence.line_range
             increment_address_and_op_index(operation_advance)
             registers.line &+= sequence.line_base + (adjusted_opcode % sequence.line_range)
             register_to_matrix(sequence, registers)
@@ -336,7 +336,7 @@ module Debug
               registers.basic_block = true
             when LNS::ConstAddPc
               adjusted_opcode = 255 - sequence.opcode_base
-              operation_advance = adjusted_opcode / sequence.line_range
+              operation_advance = adjusted_opcode // sequence.line_range
               increment_address_and_op_index(operation_advance)
             when LNS::FixedAdvancePc
               registers.address += @io.read_bytes(UInt16).not_nil!

src/deque.cr

@@ -224,7 +224,7 @@ class Deque(T)
     rindex -= @capacity if rindex >= @capacity
     value = @buffer[rindex]
 
-    if index > @size / 2
+    if index > @size // 2
       # Move following items to the left, starting with the first one
       # [56-01234] -> [6x-01235]
       dst = rindex
@@ -296,7 +296,7 @@ class Deque(T)
     rindex = @start + index
     rindex -= @capacity if rindex >= @capacity
 
-    if index > @size / 2
+    if index > @size // 2
       # Move following items to the right, starting with the last one
       # [56-01234] -> [4560123^]
       dst = @start + @size
@@ -421,7 +421,7 @@ class Deque(T)
       @start = (@start + n) % @capacity
     else
       # Turn *n* into an equivalent index in range -size/2 .. size/2
-      half = @size / 2
+      half = @size // 2
       if n.abs >= half
         n = (n + half) % @size - half
       end

src/fiber/stack_pool.cr

@@ -9,7 +9,7 @@ class Fiber
 
     # Removes and frees at most *count* stacks from the top of the pool,
     # returning memory to the operating system.
-    def collect(count = lazy_size / 2)
+    def collect(count = lazy_size // 2)
       count.times do
         if stack = @deque.shift?
           LibC.munmap(stack, STACK_SIZE)

src/float/printer/cached_powers.cr

@@ -157,7 +157,7 @@ module Float::Printer::CachedPowers
     min_exp = MIN_TARGET_EXP - (exp + DiyFP::SIGNIFICAND_SIZE)
     max_exp = MAX_TARGET_EXP - (exp + DiyFP::SIGNIFICAND_SIZE)
     k = ((min_exp + DiyFP::SIGNIFICAND_SIZE - 1) * D_1_LOG2_10).ceil
-    index = ((CACHED_POWER_OFFSET + k.to_i - 1) / CACHED_EXP_STEP) + 1
+    index = ((CACHED_POWER_OFFSET + k.to_i - 1) // CACHED_EXP_STEP) + 1
     pow = PowCache[index]
     return DiyFP.new(pow.significand, pow.binary_exp), pow.decimal_exp.to_i
   end

src/float/printer/grisu3.cr

@@ -251,7 +251,7 @@ module Float::Printer::Grisu3
     # with the divisor exponent + 1. And the divisor is the biggest power of ten
     # that is smaller than integrals.
     while kappa > 0
-      digit = integrals / divisor
+      digit = integrals // divisor
       # pp [digit, kappa]
       buffer[length] = 48_u8 + digit
       length += 1
@@ -271,7 +271,7 @@ module Float::Printer::Grisu3
         return weeded, kappa, length
       end
 
-      divisor /= 10
+      divisor //= 10
     end
 
     # The integrals have been generated. We are at the point of the decimal

src/humanize.cr

@@ -76,14 +76,14 @@ struct Number
   # Number.si_prefix(3) # => 'k'
   # ```
   def self.si_prefix(magnitude : Int, prefixes = SI_PREFIXES) : Char?
-    index = (magnitude / 3)
+    index = (magnitude // 3)
     prefixes = prefixes[magnitude < 0 ? 0 : 1]
     prefixes[index.clamp((-prefixes.size + 1)..(prefixes.size - 1))]
   end
 
   # :nodoc:
   def self.prefix_index(i, group = 3)
-    ((i - (i > 0 ? 1 : 0)) / group) * group
+    ((i - (i > 0 ? 1 : 0)) // group) * group
   end
 
   # Pretty prints this number as a `String` in a human-readable format.