Merge pull request #14761 from moiseev/bitwise-ops
[stdlib] Make default implementations of bitwise operators as obsoleted
diff --git a/stdlib/public/core/Policy.swift b/stdlib/public/core/Policy.swift
index 8128f8c..ce5db62 100644
--- a/stdlib/public/core/Policy.swift
+++ b/stdlib/public/core/Policy.swift
@@ -474,39 +474,44 @@
static var allZeros: Self { get }
}
-/// Calculates the union of bits sets in the two arguments and stores the result
-/// in the first argument.
-///
-/// - Parameters:
-/// - lhs: A value to update with the union of bits set in the two arguments.
-/// - rhs: Another value.
-@_inlineable // FIXME(sil-serialize-all)
-public func |= <T : _BitwiseOperations>(lhs: inout T, rhs: T) {
- lhs = lhs | rhs
-}
+extension _BitwiseOperations {
+ /// Calculates the union of bits sets in the two arguments and stores the result
+ /// in the first argument.
+ ///
+ /// - Parameters:
+ /// - lhs: A value to update with the union of bits set in the two arguments.
+ /// - rhs: Another value.
+ @_inlineable // FIXME(sil-serialize-all)
+ @available(swift, obsoleted: 4.1)
+ public static func |= (lhs: inout Self, rhs: Self) {
+ lhs = lhs | rhs
+ }
-/// Calculates the intersections of bits sets in the two arguments and stores
-/// the result in the first argument.
-///
-/// - Parameters:
-/// - lhs: A value to update with the intersections of bits set in the two
-/// arguments.
-/// - rhs: Another value.
-@_inlineable // FIXME(sil-serialize-all)
-public func &= <T : _BitwiseOperations>(lhs: inout T, rhs: T) {
- lhs = lhs & rhs
-}
+ /// Calculates the intersections of bits sets in the two arguments and stores
+ /// the result in the first argument.
+ ///
+ /// - Parameters:
+ /// - lhs: A value to update with the intersections of bits set in the two
+ /// arguments.
+ /// - rhs: Another value.
+ @_inlineable // FIXME(sil-serialize-all)
+ @available(swift, obsoleted: 4.1)
+ public static func &= (lhs: inout Self, rhs: Self) {
+ lhs = lhs & rhs
+ }
-/// Calculates the bits that are set in exactly one of the two arguments and
-/// stores the result in the first argument.
-///
-/// - Parameters:
-/// - lhs: A value to update with the bits that are set in exactly one of the
-/// two arguments.
-/// - rhs: Another value.
-@_inlineable // FIXME(sil-serialize-all)
-public func ^= <T : _BitwiseOperations>(lhs: inout T, rhs: T) {
- lhs = lhs ^ rhs
+ /// Calculates the bits that are set in exactly one of the two arguments and
+ /// stores the result in the first argument.
+ ///
+ /// - Parameters:
+ /// - lhs: A value to update with the bits that are set in exactly one of the
+ /// two arguments.
+ /// - rhs: Another value.
+ @_inlineable // FIXME(sil-serialize-all)
+ @available(swift, obsoleted: 4.1)
+ public static func ^= (lhs: inout Self, rhs: Self) {
+ lhs = lhs ^ rhs
+ }
}
//===----------------------------------------------------------------------===//
diff --git a/test/stdlib/BinaryIntegerRequirements.swift b/test/stdlib/BinaryIntegerRequirements.swift
new file mode 100644
index 0000000..f3c8a25
--- /dev/null
+++ b/test/stdlib/BinaryIntegerRequirements.swift
@@ -0,0 +1,61 @@
+// RUN: %swift -swift-version 4 -typecheck -verify %s
+
+struct MyInt: FixedWidthInteger { // expected-error {{type 'MyInt' does not conform to protocol 'BinaryInteger'}}
+ typealias IntegerLiteralType = Int
+ static let isSigned = false
+ init(integerLiteral value: Int) { fatalError() }
+ init(_truncatingBits bits: UInt) { fatalError() }
+ init<T : BinaryFloatingPoint>(_ source: T) { fatalError() }
+ init?<T : BinaryFloatingPoint>(exactly source: T) { fatalError() }
+ init<T : BinaryInteger>(_ source: T) { fatalError() }
+ init?<T : BinaryInteger>(exactly source: T) { fatalError() }
+ init<T : BinaryInteger>(truncatingIfNeeded source: T) { fatalError() }
+ init<T : BinaryInteger>(clamping source: T) { fatalError() }
+
+ let words = [UInt]()
+ let _lowWord: UInt = 0
+ static var bitWidth: Int { fatalError() }
+ var trailingZeroBitCount: Int { fatalError() }
+
+ static func /=(_ lhs: inout MyInt, _ rhs: MyInt) { fatalError() }
+ static func /(_ lhs: MyInt, _ rhs: MyInt) -> MyInt { fatalError() }
+ static func %=(_ lhs: inout MyInt, _ rhs: MyInt) { fatalError() }
+ static func %(_ lhs: MyInt, _ rhs: MyInt) -> MyInt { fatalError() }
+ static func +=(_ lhs: inout MyInt, _ rhs: MyInt) { fatalError() }
+ static func +(_ lhs: MyInt, _ rhs: MyInt) -> MyInt { fatalError() }
+ static func -=(_ lhs: inout MyInt, _ rhs: MyInt) { fatalError() }
+ static func -(_ lhs: MyInt, _ rhs: MyInt) -> MyInt { fatalError() }
+ static func *=(_ lhs: inout MyInt, _ rhs: MyInt) { fatalError() }
+ static func *(_ lhs: MyInt, _ rhs: MyInt) -> MyInt { fatalError() }
+
+ static func ==(_ lhs: MyInt, _ rhs: MyInt) -> Bool { fatalError() }
+ static func <(_ lhs: MyInt, _ rhs: MyInt) -> Bool { fatalError() }
+
+ static prefix func ~ (_ x: MyInt) -> MyInt { fatalError() }
+
+ static func >><RHS: BinaryInteger>(_ lhs: MyInt, _ rhs: RHS) -> MyInt { fatalError() }
+
+ static func >>=<RHS: BinaryInteger>(_ lhs: inout MyInt, _ rhs: RHS) { fatalError() }
+ static func <<<RHS: BinaryInteger>(_ lhs: MyInt, _ rhs: RHS) -> MyInt { fatalError() }
+ static func <<=<RHS: BinaryInteger>(_ lhs: inout MyInt, _ rhs: RHS) { fatalError() }
+
+ func quotientAndRemainder(dividingBy rhs: MyInt) -> (quotient: MyInt, remainder: MyInt) { fatalError() }
+ func signum() -> MyInt { fatalError() }
+
+ var hashValue: Int { fatalError() }
+ var byteSwapped: MyInt { fatalError() }
+ static var max: MyInt { fatalError() }
+ static var min: MyInt { fatalError() }
+ func addingReportingOverflow(_ rhs: MyInt) -> (partialValue: MyInt, overflow: Bool) { fatalError() }
+ func subtractingReportingOverflow(_ rhs: MyInt) -> (partialValue: MyInt, overflow: Bool) { fatalError() }
+ func multipliedReportingOverflow(by rhs: MyInt) -> (partialValue: MyInt, overflow: Bool) { fatalError() }
+ func dividedReportingOverflow(by rhs: MyInt) -> (partialValue: MyInt, overflow: Bool) { fatalError() }
+ func remainderReportingOverflow(dividingBy rhs: MyInt) -> (partialValue: MyInt, overflow: Bool) { fatalError() }
+ func multipliedFullWidth(by other: MyInt) -> (high: MyInt, low: Magnitude) { fatalError() }
+ func dividingFullWidth(_ dividend: (high: MyInt, low: Magnitude)) -> (quotient: MyInt, remainder: MyInt) { fatalError() }
+
+ var nonzeroBitCount: Int { fatalError() }
+ var leadingZeroBitCount: Int { fatalError() }
+
+ var magnitude: UInt { fatalError() }
+}