Skip to content

[stdlib] Make default implementations of bitwise operators as obsoleted #14761

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Feb 21, 2018
+99 −33
Merged

[stdlib] Make default implementations of bitwise operators as obsoleted #14761

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
71 changes: 38 additions & 33 deletions stdlib/public/core/Policy.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -474,39 +474,44 @@ public protocol _BitwiseOperations {
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
}

/// 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 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
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)
@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)
@available(swift, obsoleted: 4.1)
public static func ^= (lhs: inout Self, rhs: Self) {
lhs = lhs ^ rhs
}
}

//===----------------------------------------------------------------------===//
Expand Down
61 changes: 61 additions & 0 deletions test/stdlib/BinaryIntegerRequirements.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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() }
}