Retain overflow checks when compiled with `-Ounchecked`

[tera]

@wadetregaskis

Right, but the ergonomics of those are pretty terrible.

1. They're way more verbose, so any non-trivial mathematical expression becomes completely unreadable once translated to them.
2. They don't use the standard error handling mechanism (try / throw), you have to manually check their return value. So they don't scale well w.r.t. how many operations you're doing. You don't get any of the luxuries of proper error handling, like separating the happy path from the failure paths.

"Unchecked exceptions" to the rescue? While we do not have them in the language / standard library (yet? ever?), here's a recent attempt to implement them manually.

@wadetregaskis

Even considering them, as far as I can tell there's no equivalents for things like exponentiation (e.g. pow(_:_:)?

Yeah, maybe not pow specifically but abs, negate or something similar.

It's not hard to implement those missing bits

extension FixedWidthInteger {
    mutating func negateReportingOverflow() -> /*overflow*/ Bool {
        let result = negativeReportingOverflow
        if result.overflow { return true }
        self = result.partialValue
        return false
    }
    var negativeReportingOverflow: (partialValue: Self, overflow: Bool) {
        let result = Self.zero.subtractingReportingOverflow(self)
        if result.overflow { return (self, true) }
        return result
    }
}

func absReportingOverflow<T: FixedWidthInteger>(_ x: T) -> (partialValue: T, overflow: Bool) {
    if x >= 0 { return (x, false) }
    return x.negativeReportingOverflow
}

though it would be better to have those available out of the box.