[WIP] fixing some of the integer related test failures

Author: Max Moiseev

stdlib/public/core/CTypes.swift

@@ -205,7 +205,6 @@ func _memcpy(
   let dest = destination._rawValue
   let src = src._rawValue
   let size = UInt64(size)._value
-  let zero: Int32 = 0
   Builtin.int_memcpy_RawPointer_RawPointer_Int64(
     dest, src, size,
     /*alignment:*/ Int32()._value,
@@ -224,7 +223,6 @@ func _memmove(
   let dest = destination._rawValue
   let src = src._rawValue
   let size = UInt64(size)._value
-  let zero: Int32 = 0
   Builtin.int_memmove_RawPointer_RawPointer_Int64(
     dest, src, size,
     /*alignment:*/ Int32()._value,

stdlib/public/core/Integers.swift.gyb

@@ -1008,6 +1008,7 @@ extension ${Protocol} {
 %   for x in binaryArithmetic[Protocol]:
 %     callLabel = x.firstArg + ': ' if not x.firstArg == '_' else ''
 ${operationComment(x.operator)}
+  @_transparent
   public func ${x.name}(${x.firstArg} rhs: Self) -> Self {
     var lhs = self
     lhs.${x.mutatingName}(${callLabel}rhs)
@@ -2049,7 +2050,7 @@ extension FixedWidthInteger {
   public mutating func ${x.mutatingName}(${x.firstArg} other: Self) {
     let (result, overflow) = self.${x.name}WithOverflow(${callLabel}other)
     // FIXME(integers): uncomment the check
-    //_precondition(overflow != .none, "Overflow in ${x.mutatingName}")
+    _precondition(overflow != .none, "Overflow in ${x.mutatingName}")
     self = result
   }
 
@@ -2178,19 +2179,19 @@ extension UnsignedInteger where Self : FixedWidthInteger {
   @_transparent
   public init<T : BinaryInteger>(_ source: T) {
     // FIXME(integers): uncomment checks
-    //_precondition(source >= 0,
-      //"Negative value is not representable")
-    //let requiredBits = source.minimumSignedRepresentationBitWidth - 1
-    //_precondition(requiredBits <= Self.bitWidth,
-      //"Not enough bits to represent an unsigned value")
+    _precondition(source >= 0,
+      "negative value is not representable")
+    let requiredBits = source.minimumSignedRepresentationBitWidth - 1
+    _precondition(requiredBits <= Self.bitWidth,
+      "Not enough bits to represent an unsigned value")
     self.init(extendingOrTruncating: source)
   }
 
   @_transparent
   public init?<T : BinaryInteger>(exactly source: T) {
     // FIXME(integers): uncomment the check
-    //_precondition(source >= 0,
-      //"Negative value is not representable")
+    _precondition(source >= 0,
+      "Negative value is not representable")
     let requiredBits = source.minimumSignedRepresentationBitWidth - 1
     if requiredBits > Self.bitWidth {
       return nil

test/Constraints/closures.swift

@@ -261,7 +261,7 @@ func someGeneric19997471<T>(_ x: T) {
 func f20371273() {
   let x: [Int] = [1, 2, 3, 4]
   let y: UInt = 4
-  x.filter { $0 == y }  // expected-error {{binary operator '==' cannot be applied to operands of type 'Int' and 'UInt'}}
+  _ = x.filter { $0 == y }  // expected-error {{binary operator '==' cannot be applied to operands of type 'Int' and 'UInt'}}
   // expected-note @-1 {{overloads for '==' exist with these partially matching parameter lists: (UInt, UInt), (Int, Int)}}
 }
 

test/expr/expressions.swift

@@ -754,12 +754,12 @@ func testOptionalTypeParsing(_ a : AnyObject) -> String {
 func testParenExprInTheWay() {
   let x = 42
 
-  if x & 4.0 {}  // expected-error {{binary operator '&' cannot be applied to operands of type 'Int' and 'Double'}} expected-note {{expected an argument list of type '(Int, Int)'}}
+  if x & 4.0 {}  // expected-error {{binary operator '&' cannot be applied to operands of type 'Int' and 'Double'}} expected-note {{expected an argument list of type '(Self, Self)'}}
 
-  if (x & 4.0) {}   // expected-error {{binary operator '&' cannot be applied to operands of type 'Int' and 'Double'}} expected-note {{expected an argument list of type '(Int, Int)'}}
+  if (x & 4.0) {}   // expected-error {{binary operator '&' cannot be applied to operands of type 'Int' and 'Double'}} expected-note {{expected an argument list of type '(Self, Self)'}}
 
   if !(x & 4.0) {}  // expected-error {{no '&' candidates produce the expected contextual result type 'Bool'}}
-  //expected-note @-1 {{overloads for '&' exist with these result types: UInt8, Int8, UInt16, Int16, UInt32, Int32, UInt64, Int64, UInt, Int, T, Self}}
+  //expected-note @-1 {{produces result of type 'Self'}}
 
 
   if x & x {} // expected-error {{'Int' is not convertible to 'Bool'}}
@@ -791,7 +791,7 @@ func inoutTests(_ arr: inout Int) {
   inoutTests(&x)
 
   // <rdar://problem/17489894> inout not rejected as operand to assignment operator
-  &x += y  // expected-error {{'&' can only appear immediately in a call argument list}}
+  &x += y  // expected-error {{cannot pass immutable value of type 'inout Int' as inout argument}}}
 
   // <rdar://problem/23249098>
   func takeAny(_ x: Any) {}
@@ -843,25 +843,6 @@ func r22913570() {
 }
 
 
-// <rdar://problem/23708702> Emit deprecation warnings for ++/-- in Swift 2.2
-func swift22_deprecation_increment_decrement() {
-  var i = 0
-  var f = 1.0
-
-  i++     // expected-error {{'++' is unavailable}} {{4-6= += 1}}
-  --i     // expected-error {{'--' is unavailable}} {{3-5=}} {{6-6= -= 1}}
-  _ = i++ // expected-error {{'++' is unavailable}}
-
-  ++f     // expected-error {{'++' is unavailable}} {{3-5=}} {{6-6= += 1}}
-  f--     // expected-error {{'--' is unavailable}} {{4-6= -= 1}}
-  _ = f-- // expected-error {{'--' is unavailable}} {{none}}
-
-  // <rdar://problem/24530312> Swift ++fix-it produces bad code in nested expressions
-  // This should not get a fixit hint.
-  var j = 2
-  i = ++j   // expected-error {{'++' is unavailable}} {{none}}
-}
-
 // SR-628 mixing lvalues and rvalues in tuple expression
 var x = 0
 var y = 1

test/stdlib/Renames.swift

@@ -179,17 +179,6 @@ func _Filter<C>(c: LazyFilterCollection<C>) {
 }
 
 func _FixedPoint() {
-  var i: Int = 0
-  var u: UInt = 0
-  i++ // expected-error {{'++' is unavailable: it has been removed in Swift 3}} {{4-6= += 1}} {{none}}
-  ++i // expected-error {{'++' is unavailable: it has been removed in Swift 3}} {{3-5=}} {{6-6= += 1}} {{none}}
-  i-- // expected-error {{'--' is unavailable: it has been removed in Swift 3}} {{4-6= -= 1}} {{none}}
-  --i // expected-error {{'--' is unavailable: it has been removed in Swift 3}} {{3-5=}} {{6-6= -= 1}} {{none}}
-  u++ // expected-error {{'++' is unavailable: it has been removed in Swift 3}} {{4-6= += 1}} {{none}}
-  ++u // expected-error {{'++' is unavailable: it has been removed in Swift 3}} {{3-5=}} {{6-6= += 1}} {{none}}
-  u-- // expected-error {{'--' is unavailable: it has been removed in Swift 3}} {{4-6= -= 1}} {{none}}
-  --u // expected-error {{'--' is unavailable: it has been removed in Swift 3}} {{3-5=}} {{6-6= -= 1}} {{none}}
-
   func fn1<T: IntegerType>(i: T) {} // expected-error {{'IntegerType' has been renamed to 'FixedWidthInteger'}} {{15-26=FixedWidthInteger}} {{none}}
   func fn2<T: SignedIntegerType>(i: T) {} // expected-error {{'SignedIntegerType' has been renamed to 'SignedInteger'}} {{15-32=SignedInteger}} {{none}}
   func fn3<T: UnsignedIntegerType>(i: T) {} // expected-error {{'UnsignedIntegerType' has been renamed to 'UnsignedInteger'}} {{15-34=UnsignedInteger}} {{none}}

validation-test/stdlib/FixedPoint.swift.gyb

@@ -292,7 +292,9 @@ _UnimplementedError()
 // Misc tests that should be expanded to cover all types (FIXME)
 //===----------------------------------------------------------------------===//
 
-func testBitwiseOperationsImpl<T : UnsignedInteger>(_: T.Type) {
+func testBitwiseOperationsImpl<
+  T : FixedWidthInteger & UnsignedInteger
+>(_: T.Type) {
   let x = numericCast(0b11_1010_00) as T
   let y = numericCast(0b10_1100_10) as T
 
@@ -301,7 +303,7 @@ func testBitwiseOperationsImpl<T : UnsignedInteger>(_: T.Type) {
   expectEqual(0b01_0110_10, x ^ y)
   expectEqual(0b00_0101_11, (~x) & 0xff)
 
-  let z = T.allZeros
+  let z: T = 0
   expectEqual(x, x | z)
   expectEqual(x, x ^ z)
   expectEqual(z, x & z)
@@ -325,9 +327,12 @@ FixedPoint.test("BitwiseOperations/UInt64") {
 }
 
 FixedPoint.test("OverflowCheck") {
-  expectEqual(Int8.addWithOverflow(4, 5), (9, false))
-  expectEqual(Int8.addWithOverflow(1, 127), (-128, true))
-  expectEqual(UInt8.multiplyWithOverflow(2,128), (0, true))
+  expectEqual((partialValue: 9, overflow: .none),
+    (4 as Int8).addingWithOverflow(5))
+  expectEqual((partialValue: -128, overflow: .overflow),
+    (1 as Int8).addingWithOverflow(127))
+  expectEqual((partialValue: 0, overflow: .overflow),
+    (2 as UInt8).multipliedWithOverflow(by: 128))
 }
 
 FixedPoint.test("String.init") {

validation-test/stdlib/SipHash.swift

@@ -214,23 +214,23 @@ func loadUnalignedUInt64LE(
 ) -> UInt64 {
   return
     UInt64(p.load(fromByteOffset: 0, as: UInt8.self)) |
-    (UInt64(p.load(fromByteOffset: 1, as: UInt8.self)) << 8) |
-    (UInt64(p.load(fromByteOffset: 2, as: UInt8.self)) << 16) |
-    (UInt64(p.load(fromByteOffset: 3, as: UInt8.self)) << 24) |
-    (UInt64(p.load(fromByteOffset: 4, as: UInt8.self)) << 32) |
-    (UInt64(p.load(fromByteOffset: 5, as: UInt8.self)) << 40) |
-    (UInt64(p.load(fromByteOffset: 6, as: UInt8.self)) << 48) |
-    (UInt64(p.load(fromByteOffset: 7, as: UInt8.self)) << 56)
+    (UInt64(p.load(fromByteOffset: 1, as: UInt8.self)) &<<  8 as UInt64) |
+    (UInt64(p.load(fromByteOffset: 2, as: UInt8.self)) &<< 16 as UInt64) |
+    (UInt64(p.load(fromByteOffset: 3, as: UInt8.self)) &<< 24 as UInt64) |
+    (UInt64(p.load(fromByteOffset: 4, as: UInt8.self)) &<< 32 as UInt64) |
+    (UInt64(p.load(fromByteOffset: 5, as: UInt8.self)) &<< 40 as UInt64) |
+    (UInt64(p.load(fromByteOffset: 6, as: UInt8.self)) &<< 48 as UInt64) |
+    (UInt64(p.load(fromByteOffset: 7, as: UInt8.self)) &<< 56 as UInt64)
 }
 
 func loadUnalignedUInt32LE(
   from p: UnsafeRawPointer
 ) -> UInt32 {
   return
     UInt32(p.load(fromByteOffset: 0, as: UInt8.self)) |
-    (UInt32(p.load(fromByteOffset: 1, as: UInt8.self)) << 8) |
-    (UInt32(p.load(fromByteOffset: 2, as: UInt8.self)) << 16) |
-    (UInt32(p.load(fromByteOffset: 3, as: UInt8.self)) << 24)
+    (UInt32(p.load(fromByteOffset: 1, as: UInt8.self)) &<<  8 as UInt32) |
+    (UInt32(p.load(fromByteOffset: 2, as: UInt8.self)) &<< 16 as UInt32) |
+    (UInt32(p.load(fromByteOffset: 3, as: UInt8.self)) &<< 24 as UInt32)
 }
 
 func loadUnalignedUIntLE(