mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
718d82f5c9
a let/var pattern. Now any identifier in one of these is a variable binding, not sometimes a value references (depending on contextual syntax). This isn't expected to have a widespread effect on existing real world code: - No impact on the stdlib. - It does fix two validation crash tests, but possibly because the original issue is hidden by a different diagnostic path in the compiler. - This needed two tests to be tweaked to undistribute "let". On the positive side, this means that "case let x?:" now works properly, woo. Swift SVN r26000
103 lines
2.4 KiB
Swift
103 lines
2.4 KiB
Swift
// RUN: rm -rf %t && mkdir -p %t
|
|
// RUN: cp %s %t/main.swift
|
|
// RUN: %target-swift-frontend -parse -verify -primary-file %t/main.swift %S/Inputs/enum_equatable_hashable_other.swift
|
|
|
|
enum Foo {
|
|
case A, B
|
|
}
|
|
|
|
if Foo.A == .B { }
|
|
var aHash: Int = Foo.A.hashValue
|
|
|
|
enum Generic<T> {
|
|
case A, B
|
|
|
|
func method() -> Int {
|
|
if A == B { }
|
|
return A.hashValue
|
|
}
|
|
}
|
|
|
|
if Generic<Foo>.A == .B { }
|
|
var gaHash: Int = Generic<Foo>.A.hashValue
|
|
|
|
func localEnum() -> Bool {
|
|
enum Local {
|
|
case A, B
|
|
}
|
|
|
|
return Local.A == .B
|
|
}
|
|
|
|
enum CustomHashable {
|
|
case A, B
|
|
|
|
var hashValue: Int { return 0 }
|
|
}
|
|
func ==(x: CustomHashable, y: CustomHashable) -> Bool {
|
|
return true
|
|
}
|
|
|
|
if CustomHashable.A == .B { }
|
|
var custHash: Int = CustomHashable.A.hashValue
|
|
|
|
// We still synthesize conforming overloads of '==' and 'hashValue' if
|
|
// explicit definitions don't satisfy the protocol requirements. Probably
|
|
// not what we actually want.
|
|
enum InvalidCustomHashable {
|
|
case A, B
|
|
|
|
var hashValue: String { return "" } // expected-note{{previously declared here}}
|
|
}
|
|
func ==(x: InvalidCustomHashable, y: InvalidCustomHashable) -> String {
|
|
return ""
|
|
}
|
|
if InvalidCustomHashable.A == .B { }
|
|
var s: String = InvalidCustomHashable.A == .B
|
|
s = InvalidCustomHashable.A.hashValue
|
|
var i: Int = InvalidCustomHashable.A.hashValue // expected-error{{'String' is not convertible to 'Int'}}
|
|
|
|
|
|
// Check use of an enum's synthesized members before the enum is actually declared.
|
|
struct UseEnumBeforeDeclaration {
|
|
let eqValue = EnumToUseBeforeDeclaration.A == .A
|
|
let hashValue = EnumToUseBeforeDeclaration.A.hashValue
|
|
}
|
|
enum EnumToUseBeforeDeclaration {
|
|
case A
|
|
}
|
|
|
|
// Check enums from another file in the same module.
|
|
if FromOtherFile.A == .A {}
|
|
let _: Int = FromOtherFile.A.hashValue
|
|
|
|
func getFromOtherFile() -> AlsoFromOtherFile { return .A }
|
|
if .A == getFromOtherFile() {}
|
|
|
|
// FIXME: This should work.
|
|
func overloadFromOtherFile() -> YetAnotherFromOtherFile { return .A }
|
|
func overloadFromOtherFile() -> Bool { return false }
|
|
if .A == overloadFromOtherFile() {} // expected-error {{could not find member 'A'}}
|
|
|
|
|
|
// Complex enums are not implicitly Equatable or Hashable.
|
|
enum Complex {
|
|
case A(Int)
|
|
case B
|
|
}
|
|
|
|
if Complex.A(1) == .B { } // expected-error{{could not find member 'B'}}
|
|
|
|
|
|
// rdar://19773050
|
|
private enum Bar<T> {
|
|
case E(Unknown<T>) // expected-error {{use of undeclared type 'Unknown'}}
|
|
|
|
mutating func value() -> T {
|
|
switch self {
|
|
case E(let x):
|
|
return x.value
|
|
}
|
|
}
|
|
}
|