mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
69531fd8f8
1. We have complex logic in stdlib/public/core/FixedPoint.swift.gyb that emits
or hides certain initializers on integer types based on the bit width
combination. We check that those APIs are indeed present or absent in cases we
expect.
All of [U]Int{8,16,32,64,} initializers, labelled and unlabelled.
(swift) UInt16(-10 as Int32)
<REPL Input>:1:1: error: integer overflows when converted from 'Int32' to 'UInt16'
UInt16(-10 as Int32)
(swift) UInt16(truncatingBitPattern: -10 as Int32)
// r3 : UInt16 = 65526
(swift) UInt16(truncatingBitPattern: -10 as Int16)
<REPL Input>:1:1: error: cannot invoke initializer for type 'UInt16' with an argument list of type '(truncatingBitPattern: Int16)'
UInt16(truncatingBitPattern: -10 as Int16)
<REPL Input>:1:1: note: overloads for 'UInt16' exist with these partially matching parameter lists: (Int16), (bitPattern: Int16)
A slight change in the type combination dramatically changes the available
overload set. You can’t check this with one or two tests and be confident that
every source/destination combination is correct.
2. We check that the APIs above are present or absent regardless of the target
platform so that the code is portable (for example, because Int64 -> Int is a
truncating operation on at least one platform, the corresponding “truncating”
initializer is available for portability on 64-bit platforms, even though it is
not actually truncating there.)
3. We rely on ambiguity in the overload set of “+“ and “-“ for certain
combinations of arguments to disallow mixed-sign arithmetic. Again, these
ambiguities rely on a tricky combination of protocols, associated types, the
way those associated types are defined by our integer types, and overload
resolution rules in the type checker.
4. The test also checks migration facilities for Word and UWord.
Swift SVN r30655
139 lines
6.5 KiB
Plaintext
139 lines
6.5 KiB
Plaintext
// RUN: rm -rf %t && mkdir -p %t && %S/../../utils/gyb %s -o %t/main.swift
|
|
// RUN: %S/../../utils/line-directive %t/main.swift -- %target-swift-frontend -parse -verify %t/main.swift
|
|
|
|
// Pending a fix for <rdar://problem/19434979>, remove exact diagnostic strings.
|
|
|
|
func testUnaryMinusInUnsigned() {
|
|
var a: UInt8 = -(1) // expected-error {{}} expected-note * {{}}
|
|
|
|
var b: UInt16 = -(1) // expected-error {{}} expected-note * {{}}
|
|
|
|
var c: UInt32 = -(1) // expected-error {{}} expected-note * {{}}
|
|
|
|
var d: UInt64 = -(1) // expected-error {{}} expected-note * {{}}
|
|
}
|
|
|
|
// Int and UInt are not identical to any fixed-size integer type
|
|
var i : Int = 0
|
|
var i64 : Int64 = i // expected-error {{'Int' is not convertible to 'Int64'}}
|
|
var i32 : Int32 = i // expected-error {{'Int' is not convertible to 'Int32'}}
|
|
var i16 : Int16 = i // expected-error {{'Int' is not convertible to 'Int16'}}
|
|
var i8 : Int8 = i // expected-error {{'Int' is not convertible to 'Int8'}}
|
|
|
|
var u : UInt = 0
|
|
var u64 : UInt64 = u // expected-error {{'UInt' is not convertible to 'UInt64'}}
|
|
var u32 : UInt32 = u // expected-error {{'UInt' is not convertible to 'UInt32'}}
|
|
var u16 : UInt16 = u // expected-error {{'UInt' is not convertible to 'UInt16'}}
|
|
var u8 : UInt8 = u // expected-error {{'UInt' is not convertible to 'UInt8'}}
|
|
|
|
func expectSameType<T>(_: T.Type, _: T.Type) {}
|
|
|
|
func test_truncatingBitPatternAPIIsStableAcrossPlatforms() {
|
|
// Audit and update this test when adding new integer types.
|
|
expectSameType(Int64.self, IntMax.self)
|
|
expectSameType(UInt64.self, UIntMax.self)
|
|
|
|
_ = UInt8(truncatingBitPattern: UInt(0))
|
|
_ = UInt16(truncatingBitPattern: UInt(0))
|
|
_ = UInt32(truncatingBitPattern: UInt(0))
|
|
UInt64(truncatingBitPattern: UInt(0)) // expected-error {{extraneous argument label 'truncatingBitPattern:' in call}}
|
|
UInt(truncatingBitPattern: UInt(0)) // expected-error {{}} expected-note * {{}}
|
|
|
|
_ = Int8(truncatingBitPattern: UInt(0))
|
|
_ = Int16(truncatingBitPattern: UInt(0))
|
|
_ = Int32(truncatingBitPattern: UInt(0))
|
|
Int64(truncatingBitPattern: UInt(0)) // expected-error {{extraneous argument label 'truncatingBitPattern:' in call}}
|
|
Int(truncatingBitPattern: UInt(0)) // expected-error {{}} expected-note * {{}}
|
|
|
|
_ = UInt8(truncatingBitPattern: Int(0))
|
|
_ = UInt16(truncatingBitPattern: Int(0))
|
|
_ = UInt32(truncatingBitPattern: Int(0))
|
|
UInt64(truncatingBitPattern: Int(0)) // expected-error {{extraneous argument label 'truncatingBitPattern:' in call}}
|
|
UInt(truncatingBitPattern: Int(0)) // expected-error {{}} expected-note * {{}}
|
|
|
|
_ = Int8(truncatingBitPattern: Int(0))
|
|
_ = Int16(truncatingBitPattern: Int(0))
|
|
_ = Int32(truncatingBitPattern: Int(0))
|
|
Int64(truncatingBitPattern: Int(0)) // expected-error {{}} expected-note * {{}}
|
|
Int(truncatingBitPattern: Int(0)) // expected-error {{}} expected-note * {{}}
|
|
|
|
UInt(truncatingBitPattern: UInt8(0)) // expected-error {{}} expected-note * {{}}
|
|
UInt(truncatingBitPattern: UInt16(0)) // expected-error {{}} expected-note * {{}}
|
|
UInt(truncatingBitPattern: UInt32(0)) // expected-error {{}} expected-note * {{}}
|
|
_ = UInt(truncatingBitPattern: UInt64(0))
|
|
|
|
Int(truncatingBitPattern: UInt8(0)) // expected-error {{}} expected-note * {{}}
|
|
Int(truncatingBitPattern: UInt16(0)) // expected-error {{}} expected-note * {{}}
|
|
Int(truncatingBitPattern: UInt32(0)) // expected-error {{}} expected-note * {{}}
|
|
_ = Int(truncatingBitPattern: UInt64(0))
|
|
|
|
UInt(truncatingBitPattern: Int8(0)) // expected-error {{}} expected-note * {{}}
|
|
UInt(truncatingBitPattern: Int16(0)) // expected-error {{}} expected-note * {{}}
|
|
UInt(truncatingBitPattern: Int32(0)) // expected-error {{}} expected-note * {{}}
|
|
_ = UInt(truncatingBitPattern: Int64(0))
|
|
|
|
Int(truncatingBitPattern: Int8(0)) // expected-error {{}} expected-note * {{}}
|
|
Int(truncatingBitPattern: Int16(0)) // expected-error {{}} expected-note * {{}}
|
|
Int(truncatingBitPattern: Int32(0)) // expected-error {{}} expected-note * {{}}
|
|
_ = Int(truncatingBitPattern: Int64(0))
|
|
}
|
|
|
|
func testMixedSignArithmetic() {
|
|
// Ensure that the generic arithmetic operators for Strideable don't
|
|
// allow mixed-sign arithmetic to compile. We create a deliberate
|
|
// ambiguity in these cases.
|
|
% for T in "UInt UInt64 UInt32 UInt16 UInt8".split():
|
|
if true {
|
|
typealias Stride = ${T}.Stride
|
|
${T}(1) + 0 // OK
|
|
0 + ${T}(1) // OK
|
|
${T}(1) + Stride(0) // expected-error {{ambiguous use of operator '+'}}
|
|
Stride(1) + ${T}(0) // expected-error {{ambiguous use of operator '+'}}
|
|
${T}(1) - Stride(0) // expected-error {{ambiguous use of operator '-'}}
|
|
var x: ${T} = 0
|
|
x += 1 // OK
|
|
x += Stride(1) // expected-error {{ambiguous use of operator '+='}}
|
|
x -= Stride(1) // expected-error {{ambiguous use of operator '-='}}
|
|
|
|
(x - x) as Stride // expected-error {{ambiguous use of operator '-'}}
|
|
|
|
//===------------------------------------------------------------------===//
|
|
// The following errors are different because they're not being
|
|
// disabled by the ambiguity trick.
|
|
//===------------------------------------------------------------------===//
|
|
|
|
(x + x) as Stride // expected-error {{is not convertible to 'Stride'}}
|
|
Stride(1) - ${T}(0) // expected-error {{binary operator '-' cannot be applied to operands of type 'Stride' (aka 'Int') and '${T}'}} expected-note {{overloads for '-' exist with these partially matching parameter lists:}}
|
|
|
|
// These tests are expected to start failing when we get improved diagnostics.
|
|
var y: Stride = 0
|
|
y += ${T}(1) // expected-error {{binary operator '+=' cannot be applied to operands of type 'Stride' (aka 'Int') and '${T}'}} expected-note {{expected an argument list of type}}
|
|
y -= ${T}(1) // expected-error {{binary operator '-=' cannot be applied to operands of type 'Stride' (aka 'Int') and '${T}'}} expected-note {{expected an argument list of type}}
|
|
}
|
|
% end
|
|
}
|
|
|
|
func testOps<T : IntegerArithmeticType>(x: T, _ y: T) -> T {
|
|
let a = x + y
|
|
let s = x - y
|
|
let m = x * y
|
|
let d = x / y
|
|
let r = x % y
|
|
return a + s + m + d + r
|
|
}
|
|
|
|
let s_ops: Int = testOps(5, 2)
|
|
let u_ops: UInt = testOps(5, 2)
|
|
let s8_ops: Int8 = testOps(5, 2)
|
|
let u8_ops: UInt8 = testOps(5, 2)
|
|
let s16_ops: Int16 = testOps(5, 2)
|
|
let u16_ops: UInt16 = testOps(5, 2)
|
|
let s32_ops: Int32 = testOps(5, 2)
|
|
let u32_ops: UInt32 = testOps(5, 2)
|
|
let s64_ops: Int64 = testOps(5, 2)
|
|
let u64_ops: UInt64 = testOps(5, 2)
|
|
|
|
func useWord(w: Word) {} // expected-error {{'Word' has been renamed to 'Int'}}
|
|
func useUWord(w: UWord) {} // expected-error {{'UWord' has been renamed to 'UInt'}}
|
|
|