| // RUN: %target-swift-frontend -typecheck %s -module-name themodule -enable-source-import -I %S/../decl/enum -sdk "" -verify -show-diagnostics-after-fatal -verify-ignore-unknown |
| |
| // -verify-ignore-unknown is for |
| // <unknown>:0: error: unexpected note produced: did you forget to set an SDK using -sdk or SDKROOT? |
| // <unknown>:0: error: unexpected note produced: use "xcrun swiftc" to select the default macOS SDK installed with Xcode |
| |
| import Swift |
| import nonexistentimport // expected-error {{no such module 'nonexistentimport'}} |
| |
| //===----------------------------------------------------------------------===// |
| // Test imported names |
| //===----------------------------------------------------------------------===// |
| |
| // Imported from swift stdlib. |
| var importedtype : Int |
| |
| // Imported from enumtest module. |
| import enum enumtest.unionSearchFlags |
| var importedunion: unionSearchFlags = .backwards |
| |
| |
| // This shouldn't be imported from data. |
| var notimported : MaybeInt // expected-error {{use of undeclared type 'MaybeInt'}} |
| |
| //===----------------------------------------------------------------------===// |
| // Name binding stress test |
| //===----------------------------------------------------------------------===// |
| |
| var callee1 : () -> (Int,Int,Int) // Takes nothing, returns tuple. |
| |
| func test_shadowing() { |
| // Shadow Int. |
| enum Int { case xyz; case abc } |
| // We get the shadowed version of Int. |
| var _ : Int = .abc |
| } |
| |
| func unknown_member() { |
| var error = Swift.nonexistent_member // expected-error {{module 'Swift' has no member named 'nonexistent_member'}} |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // varname Processing |
| //===----------------------------------------------------------------------===// |
| |
| var varname1 : (a : Int, b : Int) |
| |
| // Not very useful, but it is allowed. |
| var (varname2_a, varname2_b) : (a : Int, b : Int) = varname1 |
| |
| |
| func test_varname_binding() { |
| var c = (4, 5) |
| var (d, e) = (c.1, c.0) |
| var ((), (g1, g2), h) = ((), (e, d), e) |
| var (j, k, l) = callee1() |
| var (m, n) = callee1() // expected-error{{'(Int, Int, Int)' is not convertible to '(_, _)', tuples have a different number of elements}} |
| var (o, p, q, r) = callee1() // expected-error{{'(Int, Int, Int)' is not convertible to '(_, _, _, _)', tuples have a different number of elements}} |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // ForwardIndex referencing of types. |
| //===----------------------------------------------------------------------===// |
| |
| // We don't allow namebinding to look forward past a var declaration in the |
| // main module |
| var x : x_ty // expected-error {{use of undeclared type 'x_ty'}} |
| typealias x_ty = Int |
| |
| // We allow namebinding to look forward past a function declaration (and other |
| // declarations which never have side-effects) in the main module |
| func fy() -> y_ty { return 1 } |
| typealias y_ty = Int |
| |
| // FIXME: Should reject this! |
| //typealias x = x |
| |
| // FIXME: Should reject this (has infinite size or is tautological depend on |
| // how you look at it). |
| enum y { |
| case y |
| case Int |
| } |
| |
| // We don't have a typeof, but this would also be an error somehow. |
| //var x : typeof(x) |
| |
| |
| //===----------------------------------------------------------------------===// |
| // ForwardIndex referencing of values. |
| //===----------------------------------------------------------------------===// |
| |
| func func2() { |
| func3() |
| } |
| |
| func func3() { |
| undefined_func() // expected-error {{use of unresolved identifier 'undefined_func'}} |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Overloading |
| //===----------------------------------------------------------------------===// |
| |
| struct a_struct { var x : Int } |
| |
| infix operator *** : Starry |
| precedencegroup Starry { |
| associativity: left |
| higherThan: AssignmentPrecedence |
| lowerThan: TernaryPrecedence |
| } |
| |
| func ***(lhs: Int, rhs: Int) -> Int { |
| return 4 |
| } |
| func ***(lhs: a_struct, rhs: a_struct) {} |
| func ***(lhs: a_struct, rhs: (Int) -> Int) {} |
| |
| |
| func ov_fn_result() -> Int {} |
| func ov_fn_result() -> Double {} |
| |
| func ov_fn_result2() -> (Int) -> (Int) -> Int {} |
| func ov_fn_result2() -> (Int) -> (a_struct) -> Int {} |
| |
| func overloadtest(x: Int) { |
| var _ : Int = ((ov_fn_result))() |
| var _ : Double = ((ov_fn_result))() |
| |
| // Test overloaded operators. |
| let s : a_struct |
| _ = 4 *** 17 // Resolved to the *** operator that takes ints. |
| s *** s // Resolved to the *** operator that takes a_struct. |
| s *** {$0 + 4} // Closure obviously not a struct. |
| |
| _ = ov_fn_result2()(4)(4) // picks the ov_fn_result2 taking an Int. |
| _ = ov_fn_result2()(4)(s) // picks the ov_fn_result2 taking a_struct. |
| } |
| |
| func localtest() { |
| func shadowbug() { |
| var Foo = 10 |
| func g() { |
| struct S { |
| // FIXME: Swap these two lines to crash our broken lookup. |
| typealias Foo = Int |
| var x : Foo |
| } |
| } |
| } |
| func scopebug() { |
| var Foo = 10 |
| struct S { |
| typealias Foo = Int |
| } |
| Foo = 17 |
| _ = Foo |
| } |
| func scopebug2() { |
| struct S1 {} |
| struct S2 { |
| var x : S1 |
| } |
| } |
| } |
| |
| func f0() -> ThisTypeDoesNotExist { return 1 } // expected-error {{use of undeclared type 'ThisTypeDoesNotExist'}} |
| |
| for _ in [1] { } |
| |
| //===----------------------------------------------------------------------===// |
| // Accessing names from our own module |
| //===----------------------------------------------------------------------===// |
| var qualifiedvalue : Int = themodule.importedtype |
| var qualifiedtype : themodule.x_ty = 5 |
| |
| |
| prefix operator +++ |
| postfix operator +++ |
| |
| prefix operator ++ |
| postfix operator ++ |
| |
| prefix func +++(a: inout Int) { a += 2 } |
| postfix func +++(a: inout Int) { a += 2 } |
| |
| var test = 0 |
| +++test |
| test+++ |
| |
| |
| //===----------------------------------------------------------------------===// |
| // Forward references to local variables. |
| //===----------------------------------------------------------------------===// |
| |
| func forwardReference() { |
| v = 0 // expected-error{{use of local variable 'v' before its declaration}} |
| var v: Float = 0.0 // expected-note{{'v' declared here}} |
| } |
| |
| class ForwardReference { |
| var x: Int = 0 |
| |
| func test() { |
| x = 0 |
| var x: Float = 0.0 // expected-warning{{variable 'x' was never used; consider replacing with '_' or removing it}} |
| } |
| } |
| |
| func questionablyValidForwardReference() { print(qvfrVar, terminator: ""); }; var qvfrVar: Int = 0 |
| |
| // FIXME: This should warn too. |
| print(forwardReferenceVar, terminator: ""); var forwardReferenceVar: Int = 0 |
| |
| |
| |
| // <rdar://problem/23248290> Name lookup: "Cannot convert type 'Int' to expected argument type 'Int'" while trying to initialize ivar of generic type in class scope |
| // https://gist.github.com/erynofwales/61768899502b7ac83c6e |
| struct Matrix4<T: FloatingPoint> { |
| static func size() -> Int {} |
| |
| private var data: Int = Matrix4.size() // Ok: Matrix4<T> |
| |
| init() { |
| data = Matrix4.size() // Ok: Matrix4<T> |
| } |
| } |
| |
| // <rdar://problem/19558785> for-in collection/where expressions are parsed with pattern variables in scope |
| func r19558785() { |
| let b = 10 |
| for b in 0...b { |
| _ = b |
| } |
| } |
| |