Handling the differences in << and >> for Swift 3 vs Swift 4

In Swift 3 shifts used to be defined on the concrete integer types, so
the right-hand-side value in the shift expression could define a type
for the result, as in `1 << i32` would have the type Int32. Swift 4
makes shift operators heterogeneous, so now `1 << i32` will result in an
Int, according to the type of the left-hand-side value, which gets a
default type for integer literals.

Author: Max Moiseev

stdlib/public/core/Integers.swift.gyb

@@ -2191,12 +2191,13 @@ extension FixedWidthInteger {
 //===----------------------------------------------------------------------===//
 
 ${operatorComment(x.nonMaskingOperator, True)}
+  @available(swift, introduced: 4)
   @_transparent
   public static func ${x.nonMaskingOperator} <
     Other : BinaryInteger
   >(lhs: Self, rhs: Other) -> Self {
     var lhs = lhs
-    lhs ${x.nonMaskingOperator}= rhs
+    ${x.helper}Generic(&lhs, rhs)
     return lhs
   }
 
@@ -2214,6 +2215,7 @@ ${operatorComment(x.nonMaskingOperator, True)}
   }
 #endif
 
+  @available(swift, introduced: 4)
   @_transparent
   public static func ${x.nonMaskingOperator}= <
     Other : BinaryInteger
@@ -3182,29 +3184,6 @@ public func _assumeNonNegative(_ x: ${Self}) -> ${Self} {
 }
 % end
 
-extension ${Self} {
-
-%   for op in maskingShifts:
-
-  public static func ${op.nonMaskingOperator}(
-    lhs: ${Self}, rhs: ${Self}
-  ) -> ${Self} {
-    var lhs = lhs
-    lhs ${op.nonMaskingOperator}= rhs
-    return lhs
-  }
-
-  public static func ${op.nonMaskingOperator}=(
-    lhs: inout ${Self}, rhs: ${Self}
-  ) {
-    ${op.helper}Generic(&lhs, rhs)
-  }
-
-%   end
-
-}
-
-
 //===--- end of FIXME(integers) -------------------------------------------===//
 
 % end # end of concrete FixedWidthInteger section
@@ -3572,6 +3551,38 @@ extension UnsignedInteger {
   }
 }
 
+// FIXME(integers): These overloads allow expressions like the following in
+// Swift 3 compatibility mode:
+//    let x = 1 << i32
+//    f(i32: x)
+// At the same time, since they are obsolete in Swift 4, this will not cause
+// `u8 << -1` to fail due to an overflow in an unsigned value.
+extension FixedWidthInteger {
+
+%   for op in maskingShifts:
+
+  @available(swift, obsoleted: 4)
+  @_transparent
+  public static func ${op.nonMaskingOperator}(
+    lhs: Self, rhs: Self
+  ) -> Self {
+    var lhs = lhs
+    ${op.helper}Generic(&lhs, rhs)
+    return lhs
+  }
+
+  @available(swift, obsoleted: 4)
+  @_transparent
+  public static func ${op.nonMaskingOperator}=(
+    lhs: inout Self, rhs: Self
+  ) {
+    ${op.helper}Generic(&lhs, rhs)
+  }
+
+%   end
+
+}
+
 // FIXME(integers): Absense of &+ causes ambiguity in the code like the
 // following:
 //    func f<T : SignedInteger>(_ x: T, _ y: T) {

test/Interpreter/bitvector.swift

@@ -8,13 +8,13 @@ struct BitVector64 {
 
   subscript (bit : Int) -> Bool {
     get {
-      if (bits & (1 << Int64(bit))) != 0 {
+      if (bits & (1 &<< Int64(bit))) != 0 {
         return true
       }
       return false
     }
     set {
-      var mask: Int64 = 1 << bit
+      var mask: Int64 = 1 &<< bit
       if newValue {
         bits = bits | mask
       } else {

test/Prototypes/BigInt.swift

@@ -10,7 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 // XFAIL: linux
-// RUN: %target-run-simple-swift
+// RUN: rm -rf %t ; mkdir -p %t
+// RUN: %target-build-swift -swift-version 4 -o %t/a.out %s
+// RUN: %target-run %t/a.out
 // REQUIRES: executable_test
 
 import StdlibUnittest