averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

Rework ASTDumper (#68438)

Browse Source 
This PR refactors the ASTDumper to make it more structured, less mistake-prone, and more amenable to future changes. For example:

```cpp
  // Before:
  void visitUnresolvedDotExpr(UnresolvedDotExpr *E) {
    printCommon(E, "unresolved_dot_expr")
      << " field '" << E->getName() << "'";
    PrintWithColorRAII(OS, ExprModifierColor)
      << " function_ref=" << getFunctionRefKindStr(E->getFunctionRefKind());
    if (E->getBase()) {
      OS << '\n';
      printRec(E->getBase());
    }
    PrintWithColorRAII(OS, ParenthesisColor) << ')';
  }

  // After:
  void visitUnresolvedDotExpr(UnresolvedDotExpr *E, StringRef label) {
    printCommon(E, "unresolved_dot_expr", label);

    printFieldQuoted(E->getName(), "field");
    printField(E->getFunctionRefKind(), "function_ref", ExprModifierColor);

    if (E->getBase()) {
      printRec(E->getBase());
    }

    printFoot();
  }
```

* Values are printed through calls to base class methods, rather than direct access to the underlying `raw_ostream`.
    * These methods tend to reduce the chances of bugs like missing/extra spaces or newlines, too much/too little indentation, etc.
    * More values are quoted, and unprintable/non-ASCII characters in quoted values are escaped before printing.
* Infrastructure to label child nodes now exists.
    * Some weird breaks from the normal "style", like `PatternBindingDecl`'s original and processed initializers, have been brought into line.
* Some types that previously used ad-hoc dumping functions, like conformances and substitution maps, are now structured similarly to the dumper classes.
* I've fixed the odd dumping bug along the way. For example, distributed actors were only marked `actor`, not `distributed actor`.

This PR doesn't change the overall style of AST dumps; they're still pseudo-S-expressions. But the logic that implements this style is now isolated into a relatively small base class, making it feasible to introduce e.g. JSON dumping in the future.
This commit is contained in:
Becca Royal-Gordon
2023-09-11 23:56:38 -07:00
committed by GitHub
parent 51c676c614
commit 8770c7f826
50 changed files with 3102 additions and 3100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/swift/AST/Expr.h
View File

@@ -1118,6 +1118,9 @@ public:
#include "swift/AST/TokenKinds.def" #include "swift/AST/TokenKinds.def"
}; };
static StringRef
getLiteralKindPlainName(ObjectLiteralExpr::LiteralKind kind);
private: private:
ArgumentList *ArgList; ArgumentList *ArgList;
SourceLoc PoundLoc; SourceLoc PoundLoc;

6
include/swift/AST/StorageImpl.h
View File

@@ -203,8 +203,6 @@ enum class ReadImplKind {
}; };
enum { NumReadImplKindBits = 4 }; enum { NumReadImplKindBits = 4 };
StringRef getReadImplKindName(ReadImplKind kind);
/// How are simple write accesses implemented? /// How are simple write accesses implemented?
enum class WriteImplKind { enum class WriteImplKind {
/// It's immutable. /// It's immutable.
@@ -231,8 +229,6 @@ enum class WriteImplKind {
}; };
enum { NumWriteImplKindBits = 4 }; enum { NumWriteImplKindBits = 4 };
StringRef getWriteImplKindName(WriteImplKind kind);
/// How are read-write accesses implemented? /// How are read-write accesses implemented?
enum class ReadWriteImplKind { enum class ReadWriteImplKind {
/// It's immutable. /// It's immutable.
@@ -258,8 +254,6 @@ enum class ReadWriteImplKind {
}; };
enum { NumReadWriteImplKindBits = 4 }; enum { NumReadWriteImplKindBits = 4 };
StringRef getReadWriteImplKindName(ReadWriteImplKind kind);
class StorageImplInfo { class StorageImplInfo {
using IntType = uint16_t; using IntType = uint16_t;
static_assert(NumReadImplKindBits + NumWriteImplKindBits static_assert(NumReadImplKindBits + NumWriteImplKindBits

1
include/swift/AST/TypeRepr.h
View File

@@ -189,6 +189,7 @@ public:
void print(raw_ostream &OS, const PrintOptions &Opts = PrintOptions()) const; void print(raw_ostream &OS, const PrintOptions &Opts = PrintOptions()) const;
void print(ASTPrinter &Printer, const PrintOptions &Opts) const; void print(ASTPrinter &Printer, const PrintOptions &Opts) const;
SWIFT_DEBUG_DUMP; SWIFT_DEBUG_DUMP;
void dump(raw_ostream &OS, unsigned indent = 0) const;
}; };
/// A TypeRepr for a type with a syntax error. Can be used both as a /// A TypeRepr for a type with a syntax error. Can be used both as a

5117
lib/AST/ASTDumper.cpp
View File

File diff suppressed because it is too large Load Diff

9
lib/AST/Expr.cpp
View File

@@ -1222,14 +1222,19 @@ StringRef ObjectLiteralExpr::getLiteralKindRawName() const {
llvm_unreachable("unspecified literal"); llvm_unreachable("unspecified literal");
} }
StringRef ObjectLiteralExpr::getLiteralKindPlainName() const { StringRef ObjectLiteralExpr::
switch (getLiteralKind()) { getLiteralKindPlainName(ObjectLiteralExpr::LiteralKind kind) {
switch (kind) {
#define POUND_OBJECT_LITERAL(Name, Desc, Proto) case Name: return Desc; #define POUND_OBJECT_LITERAL(Name, Desc, Proto) case Name: return Desc;
#include "swift/AST/TokenKinds.def" #include "swift/AST/TokenKinds.def"
} }
llvm_unreachable("unspecified literal"); llvm_unreachable("unspecified literal");
} }
StringRef ObjectLiteralExpr::getLiteralKindPlainName() const {
return ObjectLiteralExpr::getLiteralKindPlainName(getLiteralKind());
}
ConstructorDecl *OtherConstructorDeclRefExpr::getDecl() const { ConstructorDecl *OtherConstructorDeclRefExpr::getDecl() const {
return cast_or_null<ConstructorDecl>(Ctor.getDecl()); return cast_or_null<ConstructorDecl>(Ctor.getDecl());
} }

74
test/AutoDiff/Parse/differentiable_func_type.swift
View File

@@ -2,37 +2,37 @@
// expected-warning @+1 {{'@differentiable' has been renamed to '@differentiable(reverse)'}} {{23-23=(reverse)}} // expected-warning @+1 {{'@differentiable' has been renamed to '@differentiable(reverse)'}} {{23-23=(reverse)}}
let a: @differentiable (Float) -> Float // okay let a: @differentiable (Float) -> Float // okay
// CHECK: (pattern_named 'a' // CHECK: (pattern_named "a"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let b: @differentiable(reverse) (Float) -> Float // okay let b: @differentiable(reverse) (Float) -> Float // okay
// CHECK: (pattern_named 'b' // CHECK: (pattern_named "b"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let c: @differentiable(reverse) (Float, @noDerivative Float) -> Float // okay let c: @differentiable(reverse) (Float, @noDerivative Float) -> Float // okay
// CHECK: (pattern_named 'c' // CHECK: (pattern_named "c"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
// CHECK-NEXT: (type_function // CHECK-NEXT: (type_function
// CHECK-NEXT: (type_tuple // CHECK-NEXT: (type_tuple
// CHECK-NEXT: (type_ident id='Float' bind=none) // CHECK-NEXT: (type_ident id="Float" unbound)
// CHECK-NEXT: (type_attributed attrs=@noDerivative // CHECK-NEXT: (type_attributed attrs="@noDerivative "
// CHECK-NEXT: (type_ident id='Float' bind=none)) // CHECK-NEXT: (type_ident id="Float" unbound))
// CHECK-NEXT: (type_ident id='Float' bind=none)))) // CHECK-NEXT: (type_ident id="Float" unbound))))
let d: @differentiable(reverse) (Float) throws -> Float // okay let d: @differentiable(reverse) (Float) throws -> Float // okay
// CHECK: (pattern_named 'd' // CHECK: (pattern_named "d"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let e: @differentiable(reverse) (Float) throws -> Float // okay let e: @differentiable(reverse) (Float) throws -> Float // okay
// CHECK: (pattern_named 'e' // CHECK: (pattern_named "e"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
// Generic type test. // Generic type test.
struct A<T> { struct A<T> {
func foo() { func foo() {
let local: @differentiable(reverse) (T) -> T // okay let local: @differentiable(reverse) (T) -> T // okay
// CHECK: (pattern_named 'local' // CHECK: (pattern_named "local"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
} }
} }
@@ -49,29 +49,29 @@ let d: @differentiable(notValidArg) (Float) -> Float
struct B { struct B {
struct linear {} struct linear {}
let propertyB1: @differentiable(reverse) (linear) -> Float // okay let propertyB1: @differentiable(reverse) (linear) -> Float // okay
// CHECK: (pattern_named 'propertyB1' // CHECK: (pattern_named "propertyB1"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let propertyB2: @differentiable(reverse) (linear) -> linear // okay let propertyB2: @differentiable(reverse) (linear) -> linear // okay
// CHECK: (pattern_named 'propertyB2' // CHECK: (pattern_named "propertyB2"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let propertyB3: @differentiable(reverse) (linear, linear) -> linear // okay let propertyB3: @differentiable(reverse) (linear, linear) -> linear // okay
// CHECK: (pattern_named 'propertyB3' // CHECK: (pattern_named "propertyB3"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let propertyB4: @differentiable(reverse) (linear, Float) -> linear // okay let propertyB4: @differentiable(reverse) (linear, Float) -> linear // okay
// CHECK: (pattern_named 'propertyB4' // CHECK: (pattern_named "propertyB4"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let propertyB5: @differentiable(reverse) (Float, linear) -> linear // okay let propertyB5: @differentiable(reverse) (Float, linear) -> linear // okay
// CHECK: (pattern_named 'propertyB5' // CHECK: (pattern_named "propertyB5"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let propertyB6: @differentiable(reverse) (linear, linear, Float, linear) let propertyB6: @differentiable(reverse) (linear, linear, Float, linear)
-> Float // okay -> Float // okay
// CHECK: (pattern_named 'propertyB6' // CHECK: (pattern_named "propertyB6"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
// expected-error @+1 {{expected ')' in '@differentiable' attribute}} // expected-error @+1 {{expected ')' in '@differentiable' attribute}}
let propertyB7: @differentiable(reverse (linear) -> Float let propertyB7: @differentiable(reverse (linear) -> Float
@@ -81,21 +81,21 @@ struct B {
struct C { struct C {
typealias reverse = (C) -> C typealias reverse = (C) -> C
let propertyC1: @differentiable(reverse) (reverse) -> Float // okay let propertyC1: @differentiable(reverse) (reverse) -> Float // okay
// CHECK: (pattern_named 'propertyC1' // CHECK: (pattern_named "propertyC1"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let propertyC2: @differentiable(reverse) (reverse) -> reverse // okay let propertyC2: @differentiable(reverse) (reverse) -> reverse // okay
// CHECK: (pattern_named 'propertyC2' // CHECK: (pattern_named "propertyC2"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let propertyC3: @differentiable(reverse) reverse // okay let propertyC3: @differentiable(reverse) reverse // okay
// CHECK: (pattern_named 'propertyC3' // CHECK: (pattern_named "propertyC3"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
let propertyC4: reverse // okay let propertyC4: reverse // okay
// CHECK: (pattern_named 'propertyC4' // CHECK: (pattern_named "propertyC4"
let propertyC6: @differentiable(reverse) @convention(c) reverse // okay let propertyC6: @differentiable(reverse) @convention(c) reverse // okay
// CHECK: (pattern_named 'propertyC6' // CHECK: (pattern_named "propertyC6"
// CHECK-NEXT: (type_attributed attrs=@differentiable(reverse) // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) @convention(c) "
} }

12
test/Concurrency/async_main_resolution.swift
View File

@@ -62,13 +62,13 @@ extension MainProtocol {
@main struct MyMain : AsyncMainProtocol {} @main struct MyMain : AsyncMainProtocol {}
#endif #endif
// CHECK-IS-SYNC-LABEL: "MyMain" interface type='MyMain.Type' // CHECK-IS-SYNC-LABEL: "MyMain" interface type="MyMain.Type"
// CHECK-IS-SYNC: (func_decl implicit "$main()" interface type='(MyMain.Type) -> () -> ()' // CHECK-IS-SYNC: (func_decl implicit "$main()" interface type="(MyMain.Type) -> () -> ()"
// CHECK-IS-SYNC: (declref_expr implicit type='(MyMain.Type) -> () -> ()' // CHECK-IS-SYNC: (declref_expr implicit type="(MyMain.Type) -> () -> ()"
// CHECK-IS-ASYNC-LABEL: "MyMain" interface type='MyMain.Type' // CHECK-IS-ASYNC-LABEL: "MyMain" interface type="MyMain.Type"
// CHECK-IS-ASYNC: (func_decl implicit "$main()" interface type='(MyMain.Type) -> () async -> ()' // CHECK-IS-ASYNC: (func_decl implicit "$main()" interface type="(MyMain.Type) -> () async -> ()"
// CHECK-IS-ASYNC: (declref_expr implicit type='(MyMain.Type) -> () async -> ()' // CHECK-IS-ASYNC: (declref_expr implicit type="(MyMain.Type) -> () async -> ()"
// CHECK-IS-ERROR1: error: 'MyMain' is annotated with @main and must provide a main static function of type {{\(\) -> Void or \(\) throws -> Void|\(\) -> Void, \(\) throws -> Void, \(\) async -> Void, or \(\) async throws -> Void}} // CHECK-IS-ERROR1: error: 'MyMain' is annotated with @main and must provide a main static function of type {{\(\) -> Void or \(\) throws -> Void|\(\) -> Void, \(\) throws -> Void, \(\) async -> Void, or \(\) async throws -> Void}}
// CHECK-IS-ERROR2: error: ambiguous use of 'main' // CHECK-IS-ERROR2: error: ambiguous use of 'main'

20
test/Concurrency/closure_isolation.swift
View File

@@ -18,32 +18,32 @@ extension MyActor {
func testClosureIsolation() async { func testClosureIsolation() async {
// CHECK: acceptClosure // CHECK: acceptClosure
// CHECK: closure_expr // CHECK: closure_expr
// CHECK: actor-isolated // CHECK: actor_isolated
acceptClosure { self.syncMethod() } acceptClosure { self.syncMethod() }
// CHECK: acceptSendableClosure // CHECK: acceptSendableClosure
// CHECK: closure_expr // CHECK: closure_expr
// CHECK-NOT: actor-isolated // CHECK-NOT: actor_isolated
acceptSendableClosure { print(self) } acceptSendableClosure { print(self) }
// CHECK: acceptAsyncClosure // CHECK: acceptAsyncClosure
// CHECK: closure_expr // CHECK: closure_expr
// CHECK-SAME: actor-isolated=closure_isolation.(file).MyActor extension.testClosureIsolation().self // CHECK-SAME: actor_isolated="closure_isolation.(file).MyActor extension.testClosureIsolation().self@
acceptAsyncClosure { await method() } acceptAsyncClosure { await method() }
// CHECK: acceptAsyncClosure // CHECK: acceptAsyncClosure
// CHECK: closure_expr // CHECK: closure_expr
// CHECK-NOT: actor-isolated // CHECK-NOT: actor_isolated
acceptAsyncClosure { () async in print() } acceptAsyncClosure { () async in print() }
// CHECK: acceptEscapingAsyncClosure // CHECK: acceptEscapingAsyncClosure
// CHECK: closure_expr // CHECK: closure_expr
// CHECK: actor-isolated // CHECK: actor_isolated
acceptEscapingAsyncClosure { self.syncMethod() } acceptEscapingAsyncClosure { self.syncMethod() }
// CHECK: acceptEscapingAsyncClosure // CHECK: acceptEscapingAsyncClosure
// CHECK: closure_expr // CHECK: closure_expr
// CHECK: actor-isolated // CHECK: actor_isolated
acceptEscapingAsyncClosure { () async in print(self) } acceptEscapingAsyncClosure { () async in print(self) }
} }
} }
@@ -63,21 +63,21 @@ func someAsyncFunc() async { }
@SomeGlobalActor func someGlobalActorFunc() async { @SomeGlobalActor func someGlobalActorFunc() async {
// CHECK: acceptAsyncClosure // CHECK: acceptAsyncClosure
// CHECK: closure_expr // CHECK: closure_expr
// CHECK-SAME: global-actor-isolated=SomeGlobalActor // CHECK-SAME: global_actor_isolated="SomeGlobalActor"
acceptAsyncClosure { await someAsyncFunc() } acceptAsyncClosure { await someAsyncFunc() }
// CHECK: acceptAsyncClosure // CHECK: acceptAsyncClosure
// CHECK: closure_expr // CHECK: closure_expr
// CHECK-SAME: global-actor-isolated=SomeGlobalActor // CHECK-SAME: global_actor_isolated="SomeGlobalActor"
acceptAsyncClosure { () async in print("hello") } acceptAsyncClosure { () async in print("hello") }
// CHECK: acceptEscapingAsyncClosure // CHECK: acceptEscapingAsyncClosure
// CHECK: closure_expr // CHECK: closure_expr
// CHECK: actor-isolated // CHECK: actor_isolated
acceptEscapingAsyncClosure { await someAsyncFunc() } acceptEscapingAsyncClosure { await someAsyncFunc() }
// CHECK: acceptEscapingAsyncClosure // CHECK: acceptEscapingAsyncClosure
// CHECK: closure_expr // CHECK: closure_expr
// CHECK: actor-isolated // CHECK: actor_isolated
acceptEscapingAsyncClosure { () async in print("hello") } acceptEscapingAsyncClosure { () async in print("hello") }
} }

14
test/Concurrency/where_clause_main_resolution.swift
View File

@@ -16,28 +16,28 @@ protocol App {
// Load in the source file name and grab line numbers for default main funcs // Load in the source file name and grab line numbers for default main funcs
// CHECK: (source_file "[[SOURCE_FILE:[^"]+]]" // CHECK: (source_file "[[SOURCE_FILE:[^"]+]]"
// CHECK: (extension_decl range={{\[}}[[SOURCE_FILE]]:{{[0-9]+}}:{{[0-9]+}} - line:{{[0-9]+}}:{{[0-9]+}}{{\]}} App where // CHECK: (extension_decl range={{\[}}[[SOURCE_FILE]]:{{[0-9]+}}:{{[0-9]+}} - line:{{[0-9]+}}:{{[0-9]+}}{{\]}} "App" where
// CHECK: (extension_decl range={{\[}}[[SOURCE_FILE]]:{{[0-9]+}}:{{[0-9]+}} - line:{{[0-9]+}}:{{[0-9]+}}{{\]}} App where // CHECK: (extension_decl range={{\[}}[[SOURCE_FILE]]:{{[0-9]+}}:{{[0-9]+}} - line:{{[0-9]+}}:{{[0-9]+}}{{\]}} "App" where
// CHECK: (extension_decl range={{\[}}[[SOURCE_FILE]]:{{[0-9]+}}:{{[0-9]+}} - line:{{[0-9]+}}:{{[0-9]+}}{{\]}} App where // CHECK: (extension_decl range={{\[}}[[SOURCE_FILE]]:{{[0-9]+}}:{{[0-9]+}} - line:{{[0-9]+}}:{{[0-9]+}}{{\]}} "App" where
// CHECK: (extension_decl range={{\[}}[[SOURCE_FILE]]:{{[0-9]+}}:{{[0-9]+}} - line:{{[0-9]+}}:{{[0-9]+}}{{\]}} // CHECK: (extension_decl range={{\[}}[[SOURCE_FILE]]:{{[0-9]+}}:{{[0-9]+}} - line:{{[0-9]+}}:{{[0-9]+}}{{\]}}
// CHECK-NOT: where // CHECK-NOT: where
// CHECK-NEXT: (func_decl range={{\[}}[[SOURCE_FILE]]:[[DEFAULT_ASYNCHRONOUS_MAIN_LINE:[0-9]+]]:{{[0-9]+}} - line:{{[0-9]+}}:{{[0-9]+}}{{\]}} "main()" // CHECK-NEXT: (func_decl range={{\[}}[[SOURCE_FILE]]:[[DEFAULT_ASYNCHRONOUS_MAIN_LINE:[0-9]+]]:{{[0-9]+}} - line:{{[0-9]+}}:{{[0-9]+}}{{\]}} "main()"
// CHECK-SAME: interface type='<Self where Self : App> (Self.Type) -> () async -> ()' // CHECK-SAME: interface type="<Self where Self : App> (Self.Type) -> () async -> ()"
extension App where Configuration == Config1 { extension App where Configuration == Config1 {
// CHECK-CONFIG1: (func_decl implicit "$main()" interface type='(MainType.Type) -> () -> ()' // CHECK-CONFIG1: (func_decl implicit "$main()" interface type="(MainType.Type) -> () -> ()"
// CHECK-CONFIG1: [[SOURCE_FILE]]:[[# @LINE+1 ]] // CHECK-CONFIG1: [[SOURCE_FILE]]:[[# @LINE+1 ]]
static func main() { } static func main() { }
} }
extension App where Configuration == Config2 { extension App where Configuration == Config2 {
// CHECK-CONFIG2: (func_decl implicit "$main()" interface type='(MainType.Type) -> () async -> ()' // CHECK-CONFIG2: (func_decl implicit "$main()" interface type="(MainType.Type) -> () async -> ()"
// CHECK-CONFIG2: [[SOURCE_FILE]]:[[# @LINE+1 ]] // CHECK-CONFIG2: [[SOURCE_FILE]]:[[# @LINE+1 ]]
static func main() async { } static func main() async { }
} }
extension App where Configuration == Config3 { extension App where Configuration == Config3 {
// CHECK-CONFIG3-ASYNC: (func_decl implicit "$main()" interface type='(MainType.Type) -> () async -> ()' // CHECK-CONFIG3-ASYNC: (func_decl implicit "$main()" interface type="(MainType.Type) -> () async -> ()"
// CHECK-CONFIG3-ASYNC: [[SOURCE_FILE]]:[[DEFAULT_ASYNCHRONOUS_MAIN_LINE]] // CHECK-CONFIG3-ASYNC: [[SOURCE_FILE]]:[[DEFAULT_ASYNCHRONOUS_MAIN_LINE]]
} }

6
test/Constraints/init_literal_via_coercion.swift
View File

@@ -5,15 +5,15 @@
// `0 as <#Type#>` should get literal bound early via equality constraint. // `0 as <#Type#>` should get literal bound early via equality constraint.
// CHECK: ---Constraint solving at [{{.*}}:12:1 - line:12:13]--- // CHECK: ---Constraint solving at [{{.*}}:12:1 - line:12:13]---
// CHECK: (integer_literal_expr type='[[LITERAL_VAR:\$T[0-9]+]]' {{.*}} // CHECK: (integer_literal_expr type="[[LITERAL_VAR:\$T[0-9]+]]" {{.*}}
// CHECK: Type Variables: // CHECK: Type Variables:
// CHECK: [[LITERAL_VAR]] as UInt32 {{.*}} // CHECK: [[LITERAL_VAR]] as UInt32 {{.*}}
// CHECK-NOT: disjunction (remembered) \[\[locator@{{.*}} [Coerce@{{.*}}\]\]]: // CHECK-NOT: disjunction (remembered) \[\[locator@{{.*}} [Coerce@{{.*}}\]\]]:
_ = UInt32(0) _ = UInt32(0)
// CHECK: ---Constraint solving at [{{.*}}22:1 - line:22:13]--- // CHECK: ---Constraint solving at [{{.*}}22:1 - line:22:13]---
// CHECK: (coerce_expr implicit type='[[CAST_TYPE:\$T[0-9]+]]' {{.*}} // CHECK: (coerce_expr implicit type="[[CAST_TYPE:\$T[0-9]+]]" {{.*}}
// CHECK-NEXT: (nil_literal_expr type='[[LITERAL_VAR:\$T[0-9]+]]' {{.*}} // CHECK-NEXT: (nil_literal_expr type="[[LITERAL_VAR:\$T[0-9]+]]" {{.*}}
// CHECK: Type Variables: // CHECK: Type Variables:
// CHECK: [[LITERAL_VAR]] as Int? {{.*}} // CHECK: [[LITERAL_VAR]] as Int? {{.*}}
// CHECK: disjunction (remembered) {{.*}} // CHECK: disjunction (remembered) {{.*}}

4
test/Constraints/invalid_decl_ref.swift
View File

@@ -4,6 +4,6 @@
import Foundation import Foundation
// CHECK: declref_expr type='module<SomeModule>' // CHECK: declref_expr type="module<SomeModule>"
// CHECK-NEXT: type_expr type='Data.Type' // CHECK-NEXT: type_expr type="Data.Type"
let type = SomeModule.Data.self let type = SomeModule.Data.self

6
test/Constraints/issue-58019.swift
View File

@@ -3,9 +3,9 @@
// https://github.com/apple/swift/issues/58019 // https://github.com/apple/swift/issues/58019
func fetch() { func fetch() {
// CHECK: open_existential_expr implicit type='Void' // CHECK: open_existential_expr implicit type="Void"
// CHECK: opaque_value_expr implicit type='any MyError' // CHECK: opaque_value_expr implicit type="any MyError"
// CHECK-NOT: type='SryMap<$T{{.*}}>.Failure' // CHECK-NOT: type="SryMap<$T{{.*}}>.Failure"
sryMap { return "" } sryMap { return "" }
.napError{ $0.abc() } .napError{ $0.abc() }
} }

4
test/Constraints/issue-60806.swift
View File

@@ -18,8 +18,8 @@ enum NonBarBaz {
let _: Foo<Bar> = Foo<Bar> { (a: Bar) -> Void in let _: Foo<Bar> = Foo<Bar> { (a: Bar) -> Void in
switch a { switch a {
// CHECK: (pattern_is type='any Bar' value_cast Baz // CHECK: (pattern_is type="any Bar" cast_kind=value_cast cast_to="Baz"
// CHECK-NEXT: (pattern_enum_element type='Baz' Baz.someCase // CHECK-NEXT: (pattern_enum_element type="Baz" element="Baz.someCase"
case let .someCase(value) as Baz: case let .someCase(value) as Baz:
print(value) print(value)
// expected-warning@-1 {{cast from 'any Bar' to unrelated type 'NonBarBaz' always fails}} // expected-warning@-1 {{cast from 'any Bar' to unrelated type 'NonBarBaz' always fails}}

4
test/Constraints/nil-coalescing-favoring.swift
View File

@@ -6,9 +6,9 @@ struct B {
struct A { struct A {
init(_ other: B) {} init(_ other: B) {}
// CHECK: constructor_decl{{.*}}interface type='(A.Type) -> (B?) -> A' // CHECK: constructor_decl{{.*}}interface type="(A.Type) -> (B?) -> A"
init(_ other: B?) { init(_ other: B?) {
// CHECK: dot_syntax_call_expr type='(B) -> A' // CHECK: dot_syntax_call_expr type="(B) -> A"
self.init(other ?? ._none) self.init(other ?? ._none)
} }
} }

8
test/Constraints/result_builder_conjunction_selection.swift
View File

@@ -32,7 +32,7 @@ do {
func test<T, U>(_: T, @Builder _: () -> some P<U>) {} func test<T, U>(_: T, @Builder _: () -> some P<U>) {}
// CHECK: ---Initial constraints for the given expression--- // CHECK: ---Initial constraints for the given expression---
// CHECK: (integer_literal_expr type='[[LITERAL_VAR:\$T[0-9]+]]' {{.*}} // CHECK: (integer_literal_expr type="[[LITERAL_VAR:\$T[0-9]+]]" {{.*}}
// CHECK: (attempting type variable binding [[CLOSURE:\$T[0-9]+]] := () -> {{.*}} // CHECK: (attempting type variable binding [[CLOSURE:\$T[0-9]+]] := () -> {{.*}}
// CHECK-NOT: (attempting type variable binding [[LITERAL_VAR]] := {{.*}} // CHECK-NOT: (attempting type variable binding [[LITERAL_VAR]] := {{.*}}
// CHECK: (attempting conjunction element pattern binding element @ 0 // CHECK: (attempting conjunction element pattern binding element @ 0
@@ -48,7 +48,7 @@ do {
func test<T, U>(_: T, @Builder _: (T) -> some P<U>) {} func test<T, U>(_: T, @Builder _: (T) -> some P<U>) {}
// CHECK: ---Initial constraints for the given expression--- // CHECK: ---Initial constraints for the given expression---
// CHECK: (integer_literal_expr type='[[LITERAL_VAR:\$T[0-9]+]]' {{.*}} // CHECK: (integer_literal_expr type="[[LITERAL_VAR:\$T[0-9]+]]" {{.*}}
// CHECK: (attempting type variable binding [[LITERAL_VAR]] := Int // CHECK: (attempting type variable binding [[LITERAL_VAR]] := Int
// CHECK: (attempting conjunction element pattern binding element @ 0 // CHECK: (attempting conjunction element pattern binding element @ 0
test(42) { v in test(42) { v in
@@ -63,12 +63,12 @@ do {
// CHECK: ---Initial constraints for the given expression--- // CHECK: ---Initial constraints for the given expression---
// CHECK: (attempting type variable {{.*}} := () -> {{.*}} // CHECK: (attempting type variable {{.*}} := () -> {{.*}}
// CHECK: (attempting conjunction element pattern binding element @ 0 : // CHECK: (attempting conjunction element pattern binding element @ 0 :
// CHECK-NEXT: (pattern_named 'x') // CHECK-NEXT: (pattern_named "x")
// CHECK: (attempting conjunction element syntactic element // CHECK: (attempting conjunction element syntactic element
// CHECK-NEXT: (call_expr {{.*}} // CHECK-NEXT: (call_expr {{.*}}
// CHECK: (attempting type variable {{.*}} := (Bool) -> {{.*}} // CHECK: (attempting type variable {{.*}} := (Bool) -> {{.*}}
// CHECK: (attempting conjunction element pattern binding element @ 0 // CHECK: (attempting conjunction element pattern binding element @ 0
// CHECK: (pattern_named implicit '$__builder{{.*}}') // CHECK: (pattern_named implicit "$__builder{{.*}}")
// CHECK: (applying conjunction result to outer context // CHECK: (applying conjunction result to outer context
// CHECK: (attempting type variable {{.*}} := (Int?) -> {{.*}} // CHECK: (attempting type variable {{.*}} := (Int?) -> {{.*}}
// CHECK: (attempting disjunction choice {{.*}} bound to decl {{.*}}.Int.init(_:) // CHECK: (attempting disjunction choice {{.*}} bound to decl {{.*}}.Int.init(_:)

16
test/Constraints/result_builder_generic_infer.swift
View File

@@ -22,34 +22,34 @@ struct ProtocolSubstitution: P {
typealias A = Int typealias A = Int
// CHECK: var_decl{{.*}}x1 // CHECK: var_decl{{.*}}x1
// CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature=<T> (substitution T -> Int)) // CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature='<T>' 'T -> Int')
var x1: [S] { S() } var x1: [S] { S() }
// CHECK: var_decl{{.*}}x2 // CHECK: var_decl{{.*}}x2
// CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature=<T> (substitution T -> ProtocolSubstitution)) // CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature='<T>' 'T -> ProtocolSubstitution')
var x2: [S] { S() } var x2: [S] { S() }
} }
// CHECK: struct_decl{{.*}}ArchetypeSubstitution // CHECK: struct_decl{{.*}}ArchetypeSubstitution
struct ArchetypeSubstitution<A>: P { struct ArchetypeSubstitution<A>: P {
// CHECK: var_decl{{.*}}x1 // CHECK: var_decl{{.*}}x1
// CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature=<T> (substitution T -> A)) // CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature='<T>' 'T -> A')
var x1: [S] { S() } var x1: [S] { S() }
// CHECK: var_decl{{.*}}x2 // CHECK: var_decl{{.*}}x2
// CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature=<T> (substitution T -> ArchetypeSubstitution<A>)) // CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature='<T>' 'T -> ArchetypeSubstitution<A>')
var x2: [S] { S() } var x2: [S] { S() }
} }
// CHECK-LABEL: struct_decl{{.*}}ExplicitGenericAttribute // CHECK-LABEL: struct_decl{{.*}}ExplicitGenericAttribute
struct ExplicitGenericAttribute<T: P> { struct ExplicitGenericAttribute<T: P> {
// CHECK: var_decl{{.*}}x1 // CHECK: var_decl{{.*}}x1
// CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature=<T> (substitution T -> T)) // CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature='<T>' 'T -> T')
@Builder<T> @Builder<T>
var x1: [S] { S() } var x1: [S] { S() }
// CHECK: var_decl{{.*}}x2 // CHECK: var_decl{{.*}}x2
// CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature=<T> (substitution T -> T.A)) // CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature='<T>' 'T -> T.A')
@Builder<T.A> @Builder<T.A>
var x2: [S] { S() } var x2: [S] { S() }
} }
@@ -61,10 +61,10 @@ extension ConcreteTypeSubstitution: P where Value == Int {
typealias A = Value typealias A = Value
// CHECK: var_decl{{.*}}x1 // CHECK: var_decl{{.*}}x1
// CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature=<T> (substitution T -> Int)) // CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature='<T>' 'T -> Int')
var x1: [S] { S() } var x1: [S] { S() }
// CHECK: var_decl{{.*}}x2 // CHECK: var_decl{{.*}}x2
// CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature=<T> (substitution T -> ConcreteTypeSubstitution<Int>)) // CHECK: Builder.buildBlock{{.*}}(substitution_map generic_signature='<T>' 'T -> ConcreteTypeSubstitution<Int>')
var x2: [S] { S() } var x2: [S] { S() }
} }

14
test/Constraints/result_builder_switch_with_vars.swift
View File

@@ -49,8 +49,8 @@ func tuplify<T>(@TupleBuilder body: (E) throws -> T) rethrows {
tuplify { tuplify {
switch $0 { switch $0 {
// CHECK: (case_body_variables // CHECK: (case_body_variables
// CHECK-NEXT: (var_decl implicit {{.*}} "a" interface type='String' let readImpl=stored immutable) // CHECK-NEXT: (var_decl implicit {{.*}} "a" interface type="String" let readImpl=stored immutable)
// CHECK-NEXT: (var_decl implicit {{.*}} "b" interface type='Int' let readImpl=stored immutable) // CHECK-NEXT: (var_decl implicit {{.*}} "b" interface type="Int" let readImpl=stored immutable)
case let .test(a, b): case let .test(a, b):
a a
b b
@@ -58,8 +58,8 @@ tuplify {
switch $0 { switch $0 {
// CHECK: (case_body_variables // CHECK: (case_body_variables
// CHECK-NEXT: (var_decl implicit {{.*}} "a" interface type='String' let readImpl=stored immutable) // CHECK-NEXT: (var_decl implicit {{.*}} "a" interface type="String" let readImpl=stored immutable)
// CHECK-NEXT: (var_decl implicit {{.*}} "b" interface type='Int' let readImpl=stored immutable) // CHECK-NEXT: (var_decl implicit {{.*}} "b" interface type="Int" let readImpl=stored immutable)
case .test(let a, let b): case .test(let a, let b):
a a
b b
@@ -67,21 +67,21 @@ tuplify {
switch $0 { switch $0 {
// CHECK: (case_body_variables // CHECK: (case_body_variables
// CHECK-NEXT: (var_decl implicit {{.*}} "value" interface type='(a: String, b: Int)' let readImpl=stored immutable) // CHECK-NEXT: (var_decl implicit {{.*}} "value" interface type="(a: String, b: Int)" let readImpl=stored immutable)
case let .test((value)): case let .test((value)):
value.a value.a
} }
switch $0 { switch $0 {
// CHECK: (case_body_variables // CHECK: (case_body_variables
// CHECK-NEXT: (var_decl implicit {{.*}} "value" interface type='(a: String, b: Int)' let readImpl=stored immutable) // CHECK-NEXT: (var_decl implicit {{.*}} "value" interface type="(a: String, b: Int)" let readImpl=stored immutable)
case let .test(value): case let .test(value):
value.a value.a
} }
switch $0 { switch $0 {
// CHECK: (case_body_variables // CHECK: (case_body_variables
// CHECK-NEXT: (var_decl implicit {{.*}} "value" interface type='(a: String, b: Int)' let readImpl=stored immutable) // CHECK-NEXT: (var_decl implicit {{.*}} "value" interface type="(a: String, b: Int)" let readImpl=stored immutable)
case .test(let value): case .test(let value):
value.a value.a
} }

6
test/DWARFImporter/basic.swift
View File

@@ -23,10 +23,10 @@ import ObjCModule
let pureSwift = Int32(42) let pureSwift = Int32(42)
// FAIL-NOT: var_decl // FAIL-NOT: var_decl
// CHECK: var_decl "pureSwift" {{.*}} type='Int32' // CHECK: var_decl "pureSwift" {{.*}} type="Int32"
// SWIFTONLY: var_decl "pureSwift" {{.*}} type='Int32' // SWIFTONLY: var_decl "pureSwift" {{.*}} type="Int32"
let point = Point(x: 1, y: 2) let point = Point(x: 1, y: 2)
// CHECK: var_decl "point" {{.*}} type='Point' // CHECK: var_decl "point" {{.*}} type="Point"
// SWIFTONLY-NOT: var_decl "point" // SWIFTONLY-NOT: var_decl "point"

16
test/Distributed/distributed_actor_executor_ast.swift
View File

@@ -25,21 +25,21 @@ distributed actor DefaultWorker {
} }
// Check DefaultWorker, the DefaultActor version of the synthesis: // Check DefaultWorker, the DefaultActor version of the synthesis:
// CHECK: (class_decl range=[{{.*}}] "DefaultWorker" interface type='DefaultWorker.Type' access=internal non-resilient actor // CHECK: (class_decl range=[{{.*}}] "DefaultWorker" interface type="DefaultWorker.Type" access=internal non_resilient distributed actor
// The unowned executor property: // The unowned executor property:
// CHECK: (var_decl implicit "unownedExecutor" interface type='UnownedSerialExecutor' access=internal final readImpl=getter immutable // CHECK: (var_decl implicit "unownedExecutor" interface type="UnownedSerialExecutor" access=internal final readImpl=getter immutable
// We guard the rest of the body; we only return a default executor if the actor is local: // We guard the rest of the body; we only return a default executor if the actor is local:
// CHECK: (guard_stmt implicit // CHECK: (guard_stmt implicit
// CHECK: (call_expr implicit type='Bool' nothrow // CHECK: (call_expr implicit type="Bool" nothrow
// CHECK: (declref_expr implicit type='@_NO_EXTINFO (AnyObject) -> Bool' decl=Distributed.(file).__isLocalActor function_ref=unapplied) // CHECK: (declref_expr implicit type="@_NO_EXTINFO (AnyObject) -> Bool" decl="Distributed.(file).__isLocalActor" function_ref=unapplied)
// Check that we create the "remote reference" executor: // Check that we create the "remote reference" executor:
// CHECK: (return_stmt implicit // CHECK: (return_stmt implicit
// CHECK: (call_expr implicit type='UnownedSerialExecutor' nothrow // CHECK: (call_expr implicit type="UnownedSerialExecutor" nothrow
// CHECK: (declref_expr implicit type='(DefaultWorker) -> UnownedSerialExecutor' decl=Distributed.(file).buildDefaultDistributedRemoteActorExecutor [with (substitution_map generic_signature=<Act where Act : DistributedActor> (substitution Act -> DefaultWorker))] // CHECK: (declref_expr implicit type="(DefaultWorker) -> UnownedSerialExecutor" decl="Distributed.(file).buildDefaultDistributedRemoteActorExecutor [with (substitution_map generic_signature='<Act where Act : DistributedActor>' 'Act -> DefaultWorker')]"
// Check the default executor synthesis for local actor otherwise: // Check the default executor synthesis for local actor otherwise:
// CHECK: (return_stmt implicit // CHECK: (return_stmt implicit
// CHECK: (call_expr implicit type='Builtin.Executor' nothrow // CHECK: (call_expr implicit type="Builtin.Executor" nothrow
// CHECK: (declref_expr implicit type='(DefaultWorker) -> Builtin.Executor' decl=Builtin.(file).buildDefaultActorExecutorRef [with (substitution_map generic_signature=<T where T : AnyObject> (substitution T -> DefaultWorker))] function_ref=unapplied) // CHECK: (declref_expr implicit type="(DefaultWorker) -> Builtin.Executor" decl="Builtin.(file).buildDefaultActorExecutorRef [with (substitution_map generic_signature='<T where T : AnyObject>' 'T -> DefaultWorker')]" function_ref=unapplied)

132
test/Frontend/debug-generic-signatures.swift
View File

@@ -32,9 +32,9 @@ protocol P3 {
} }
// CHECK-LABEL: StructDecl name=Basic // CHECK-LABEL: StructDecl name=Basic
// CHECK: (normal_conformance type=Basic protocol=P1 // CHECK: (normal_conformance type="Basic" protocol="P1"
// CHECK-NEXT: (assoc_type req=A type=Int) // CHECK-NEXT: (assoc_type req="A" type="Int")
// CHECK-NEXT: (value req=f() witness=main.(file).Basic.f()@{{.*}})) // CHECK-NEXT: (value req="f()" witness="main.(file).Basic.f()@{{.*}}"))
struct Basic: P1 { struct Basic: P1 {
typealias A = Int typealias A = Int
func f() -> Int { fatalError() } func f() -> Int { fatalError() }
@@ -43,11 +43,11 @@ struct Basic: P1 {
// Recursive conformances should have finite output. // Recursive conformances should have finite output.
// CHECK-LABEL: StructDecl name=Recur // CHECK-LABEL: StructDecl name=Recur
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2"
// CHECK-NEXT: (assoc_type req=A type=Recur) // CHECK-NEXT: (assoc_type req="A" type="Recur")
// CHECK-NEXT: (assoc_type req=B type=Recur) // CHECK-NEXT: (assoc_type req="B" type="Recur")
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 (details printed above)) // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2" <details printed above>)
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 (details printed above))) // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2" <details printed above>))
struct Recur: P2 { struct Recur: P2 {
typealias A = Recur typealias A = Recur
typealias B = Recur typealias B = Recur
@@ -56,15 +56,15 @@ struct Recur: P2 {
// The full information about a conformance doesn't need to be printed twice. // The full information about a conformance doesn't need to be printed twice.
// CHECK-LABEL: StructDecl name=NonRecur // CHECK-LABEL: StructDecl name=NonRecur
// CHECK-NEXT: (normal_conformance type=NonRecur protocol=P2 // CHECK-NEXT: (normal_conformance type="NonRecur" protocol="P2"
// CHECK-NEXT: (assoc_type req=A type=Recur) // CHECK-NEXT: (assoc_type req="A" type="Recur")
// CHECK-NEXT: (assoc_type req=B type=Recur) // CHECK-NEXT: (assoc_type req="B" type="Recur")
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2"
// CHECK-NEXT: (assoc_type req=A type=Recur) // CHECK-NEXT: (assoc_type req="A" type="Recur")
// CHECK-NEXT: (assoc_type req=B type=Recur) // CHECK-NEXT: (assoc_type req="B" type="Recur")
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 (details printed above)) // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2" <details printed above>)
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 (details printed above))) // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2" <details printed above>))
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 (details printed above))) // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2" <details printed above>))
struct NonRecur: P2 { struct NonRecur: P2 {
typealias A = Recur typealias A = Recur
typealias B = Recur typealias B = Recur
@@ -77,10 +77,10 @@ struct NonRecur: P2 {
// CHECK-LABEL: ExtensionDecl line={{.*}} base=Generic // CHECK-LABEL: ExtensionDecl line={{.*}} base=Generic
struct Generic<T> {} struct Generic<T> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=Generic // CHECK-LABEL: ExtensionDecl line={{.*}} base=Generic
// CHECK-NEXT: (normal_conformance type=Generic<T> protocol=P1 // CHECK-NEXT: (normal_conformance type="Generic<T>" protocol="P1"
// CHECK-NEXT: (assoc_type req=A type=T) // CHECK-NEXT: (assoc_type req="A" type="T")
// CHECK-NEXT: (value req=f() witness=main.(file).Generic extension.f()@{{.*}}) // CHECK-NEXT: (value req="f()" witness="main.(file).Generic extension.f()@{{.*}}")
// CHECK-NEXT: conforms_to: T P1) // CHECK-NEXT: (requirement "T" conforms_to "P1")
extension Generic: P1 where T: P1 { extension Generic: P1 where T: P1 {
typealias A = T typealias A = T
func f() -> T { fatalError() } func f() -> T { fatalError() }
@@ -94,13 +94,13 @@ extension Generic: P1 where T: P1 {
// CHECK-LABEL: ExtensionDecl line={{.*}} base=Super // CHECK-LABEL: ExtensionDecl line={{.*}} base=Super
class Super<T, U> {} class Super<T, U> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=Super // CHECK-LABEL: ExtensionDecl line={{.*}} base=Super
// CHECK-NEXT: (normal_conformance type=Super<T, U> protocol=P2 // CHECK-NEXT: (normal_conformance type="Super<T, U>" protocol="P2"
// CHECK-NEXT: (assoc_type req=A type=T) // CHECK-NEXT: (assoc_type req="A" type="T")
// CHECK-NEXT: (assoc_type req=B type=T) // CHECK-NEXT: (assoc_type req="B" type="T")
// CHECK-NEXT: (abstract_conformance protocol=P2) // CHECK-NEXT: (abstract_conformance protocol="P2")
// CHECK-NEXT: (abstract_conformance protocol=P2) // CHECK-NEXT: (abstract_conformance protocol="P2")
// CHECK-NEXT: conforms_to: T P2 // CHECK-NEXT: (requirement "T" conforms_to "P2")
// CHECK-NEXT: conforms_to: U P2) // CHECK-NEXT: (requirement "U" conforms_to "P2"))
extension Super: P2 where T: P2, U: P2 { extension Super: P2 where T: P2, U: P2 {
typealias A = T typealias A = T
typealias B = T typealias B = T
@@ -108,55 +108,55 @@ extension Super: P2 where T: P2, U: P2 {
// Inherited/specialized conformances. // Inherited/specialized conformances.
// CHECK-LABEL: ClassDecl name=Sub // CHECK-LABEL: ClassDecl name=Sub
// CHECK-NEXT: (inherited_conformance type=Sub protocol=P2 // CHECK-NEXT: (inherited_conformance type="Sub" protocol="P2"
// CHECK-NEXT: (specialized_conformance type=Super<NonRecur, Recur> protocol=P2 // CHECK-NEXT: (specialized_conformance type="Super<NonRecur, Recur>" protocol="P2"
// CHECK-NEXT: (substitution_map generic_signature=<T, U where T : P2, U : P2> // CHECK-NEXT: (substitution_map generic_signature="<T, U where T : P2, U : P2>"
// CHECK-NEXT: (substitution T -> NonRecur) // CHECK-NEXT: (substitution "T -> NonRecur")
// CHECK-NEXT: (substitution U -> Recur) // CHECK-NEXT: (substitution "U -> Recur")
// CHECK-NEXT: (conformance type=T // CHECK-NEXT: (conformance type="T"
// CHECK-NEXT: (normal_conformance type=NonRecur protocol=P2 // CHECK-NEXT: (normal_conformance type="NonRecur" protocol="P2"
// CHECK-NEXT: (assoc_type req=A type=Recur) // CHECK-NEXT: (assoc_type req="A" type="Recur")
// CHECK-NEXT: (assoc_type req=B type=Recur) // CHECK-NEXT: (assoc_type req="B" type="Recur")
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2"
// CHECK-NEXT: (assoc_type req=A type=Recur) // CHECK-NEXT: (assoc_type req="A" type="Recur")
// CHECK-NEXT: (assoc_type req=B type=Recur) // CHECK-NEXT: (assoc_type req="B" type="Recur")
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 (details printed above)) // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2" <details printed above>)
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 (details printed above))) // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2" <details printed above>))
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 (details printed above)))) // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2" <details printed above>)))
// CHECK-NEXT: (conformance type=U // CHECK-NEXT: (conformance type="U"
// CHECK-NEXT: (normal_conformance type=Recur protocol=P2 (details printed above)))) // CHECK-NEXT: (normal_conformance type="Recur" protocol="P2" <details printed above>)))
// CHECK-NEXT: (conditional requirements unable to be computed) // CHECK-NEXT: (<conditional requirements unable to be computed>)
// CHECK-NEXT: (normal_conformance type=Super<T, U> protocol=P2 // CHECK-NEXT: (normal_conformance type="Super<T, U>" protocol="P2"
// CHECK-NEXT: (assoc_type req=A type=T) // CHECK-NEXT: (assoc_type req="A" type="T")
// CHECK-NEXT: (assoc_type req=B type=T) // CHECK-NEXT: (assoc_type req="B" type="T")
// CHECK-NEXT: (abstract_conformance protocol=P2) // CHECK-NEXT: (abstract_conformance protocol="P2")
// CHECK-NEXT: (abstract_conformance protocol=P2) // CHECK-NEXT: (abstract_conformance protocol="P2")
// CHECK-NEXT: conforms_to: T P2 // CHECK-NEXT: (requirement "T" conforms_to "P2")
// CHECK-NEXT: conforms_to: U P2))) // CHECK-NEXT: (requirement "U" conforms_to "P2"))))
class Sub: Super<NonRecur, Recur> {} class Sub: Super<NonRecur, Recur> {}
// Specialization of a recursive conformance should be okay: recursion detection // Specialization of a recursive conformance should be okay: recursion detection
// should work through SubstitutionMaps. // should work through SubstitutionMaps.
// CHECK-LABEL: StructDecl name=RecurGeneric // CHECK-LABEL: StructDecl name=RecurGeneric
// CHECK-NEXT: (normal_conformance type=RecurGeneric<T> protocol=P3 // CHECK-NEXT: (normal_conformance type="RecurGeneric<T>" protocol="P3"
// CHECK-NEXT: (assoc_type req=A type=RecurGeneric<T>) // CHECK-NEXT: (assoc_type req="A" type="RecurGeneric<T>")
// CHECK-NEXT: (normal_conformance type=RecurGeneric<T> protocol=P3 (details printed above))) // CHECK-NEXT: (normal_conformance type="RecurGeneric<T>" protocol="P3" <details printed above>))
struct RecurGeneric<T: P3>: P3 { struct RecurGeneric<T: P3>: P3 {
typealias A = RecurGeneric<T> typealias A = RecurGeneric<T>
} }
// CHECK-LABEL: StructDecl name=Specialize // CHECK-LABEL: StructDecl name=Specialize
// CHECK-NEXT: (normal_conformance type=Specialize protocol=P3 // CHECK-NEXT: (normal_conformance type="Specialize" protocol="P3"
// CHECK-NEXT: (assoc_type req=A type=RecurGeneric<Specialize>) // CHECK-NEXT: (assoc_type req="A" type="RecurGeneric<Specialize>")
// CHECK-NEXT: (specialized_conformance type=Specialize.A protocol=P3 // CHECK-NEXT: (specialized_conformance type="Specialize.A" protocol="P3"
// CHECK-NEXT: (substitution_map generic_signature=<T where T : P3> // CHECK-NEXT: (substitution_map generic_signature="<T where T : P3>"
// CHECK-NEXT: (substitution T -> Specialize) // CHECK-NEXT: (substitution "T -> Specialize")
// CHECK-NEXT: (conformance type=T // CHECK-NEXT: (conformance type="T"
// CHECK-NEXT: (normal_conformance type=Specialize protocol=P3 (details printed above)))) // CHECK-NEXT: (normal_conformance type="Specialize" protocol="P3" <details printed above>)))
// CHECK-NEXT: (normal_conformance type=RecurGeneric<T> protocol=P3 // CHECK-NEXT: (normal_conformance type="RecurGeneric<T>" protocol="P3"
// CHECK-NEXT: (assoc_type req=A type=RecurGeneric<T>) // CHECK-NEXT: (assoc_type req="A" type="RecurGeneric<T>")
// CHECK-NEXT: (normal_conformance type=RecurGeneric<T> protocol=P3 (details printed above))))) // CHECK-NEXT: (normal_conformance type="RecurGeneric<T>" protocol="P3" <details printed above>))))
struct Specialize: P3 { struct Specialize: P3 {
typealias A = RecurGeneric<Specialize> typealias A = RecurGeneric<Specialize>
} }

66
test/Frontend/dump-parse.swift
View File

@@ -6,10 +6,10 @@
func foo(_ n: Int) -> Int { func foo(_ n: Int) -> Int {
// CHECK: (brace_stmt // CHECK: (brace_stmt
// CHECK: (return_stmt // CHECK: (return_stmt
// CHECK: (integer_literal_expr type='<null>' value=42 {{.*}}))) // CHECK: (integer_literal_expr type="<null>" value="42" {{.*}})))
// CHECK-AST: (brace_stmt // CHECK-AST: (brace_stmt
// CHECK-AST: (return_stmt // CHECK-AST: (return_stmt
// CHECK-AST: (integer_literal_expr type='{{[^']+}}' {{.*}} value=42 {{.*}}) // CHECK-AST: (integer_literal_expr type="{{[^"]+}}" {{.*}} value="42" {{.*}})
return 42 return 42
} }
@@ -18,13 +18,13 @@ func foo(_ n: Int) -> Int {
// CHECK-AST-LABEL: (func_decl{{.*}}"bar()" // CHECK-AST-LABEL: (func_decl{{.*}}"bar()"
func bar() { func bar() {
// CHECK: (brace_stmt // CHECK: (brace_stmt
// CHECK-NEXT: (unresolved_decl_ref_expr type='{{[^']+}}' name=foo // CHECK-NEXT: (unresolved_decl_ref_expr type="{{[^"]+}}" name="foo"
// CHECK-NEXT: (unresolved_decl_ref_expr type='{{[^']+}}' name=foo // CHECK-NEXT: (unresolved_decl_ref_expr type="{{[^"]+}}" name="foo"
// CHECK-NEXT: (unresolved_decl_ref_expr type='{{[^']+}}' name=foo // CHECK-NEXT: (unresolved_decl_ref_expr type="{{[^"]+}}" name="foo"
// CHECK-AST: (brace_stmt // CHECK-AST: (brace_stmt
// CHECK-AST-NEXT: (declref_expr type='{{[^']+}}' {{.*}} decl=main.(file).foo // CHECK-AST-NEXT: (declref_expr type="{{[^"]+}}" {{.*}} decl="main.(file).foo@
// CHECK-AST-NEXT: (declref_expr type='{{[^']+}}' {{.*}} decl=main.(file).foo // CHECK-AST-NEXT: (declref_expr type="{{[^"]+}}" {{.*}} decl="main.(file).foo@
// CHECK-AST-NEXT: (declref_expr type='{{[^']+}}' {{.*}} decl=main.(file).foo // CHECK-AST-NEXT: (declref_expr type="{{[^"]+}}" {{.*}} decl="main.(file).foo@
foo foo foo foo foo foo
} }
@@ -38,8 +38,8 @@ enum TrailingSemi {
case A,B; case A,B;
// CHECK-LABEL: (subscript_decl{{.*}}trailing_semi // CHECK-LABEL: (subscript_decl{{.*}}trailing_semi
// CHECK-NOT: (func_decl{{.*}}trailing_semi 'anonname={{.*}}' get_for=subscript(_:) // CHECK-NOT: (func_decl{{.*}}trailing_semi <anonymous @ 0x{{[0-9a-f]+}}> get for="subscript(_:)"
// CHECK: (accessor_decl{{.*}}'anonname={{.*}}' get_for=subscript(_:) // CHECK: (accessor_decl{{.*}} <anonymous @ 0x{{[0-9a-f]+}}> get for="subscript(_:)"
subscript(x: Int) -> Int { subscript(x: Int) -> Int {
// CHECK-LABEL: (pattern_binding_decl{{.*}}trailing_semi // CHECK-LABEL: (pattern_binding_decl{{.*}}trailing_semi
// CHECK-NOT: (var_decl{{.*}}trailing_semi "y" // CHECK-NOT: (var_decl{{.*}}trailing_semi "y"
@@ -55,26 +55,26 @@ enum TrailingSemi {
}; };
// The substitution map for a declref should be relatively unobtrusive. // The substitution map for a declref should be relatively unobtrusive.
// CHECK-AST-LABEL: (func_decl{{.*}}"generic(_:)" <T : Hashable> interface type='<T where T : Hashable> (T) -> ()' access=internal captures=(<generic> ) // CHECK-AST-LABEL: (func_decl{{.*}}"generic(_:)" "<T : Hashable>" interface type="<T where T : Hashable> (T) -> ()" access=internal captures=(<generic> )
func generic<T: Hashable>(_: T) {} func generic<T: Hashable>(_: T) {}
// CHECK-AST: (pattern_binding_decl // CHECK-AST: (pattern_binding_decl
// CHECK-AST: (declref_expr type='(Int) -> ()' location={{.*}} range={{.*}} decl=main.(file).generic@{{.*}} [with (substitution_map generic_signature=<T where T : Hashable> (substitution T -> Int))] function_ref=unapplied)) // CHECK-AST: (processed_init=declref_expr type="(Int) -> ()" location={{.*}} range={{.*}} decl="main.(file).generic@{{.*}} [with (substitution_map generic_signature='<T where T : Hashable>' 'T -> Int')]" function_ref=unapplied))
let _: (Int) -> () = generic let _: (Int) -> () = generic
// Closures should be marked as escaping or not. // Closures should be marked as escaping or not.
func escaping(_: @escaping (Int) -> Int) {} func escaping(_: @escaping (Int) -> Int) {}
escaping({ $0 }) escaping({ $0 })
// CHECK-AST: (declref_expr type='(@escaping (Int) -> Int) -> ()' // CHECK-AST: (declref_expr type="(@escaping (Int) -> Int) -> ()"
// CHECK-AST-NEXT: (argument_list // CHECK-AST-NEXT: (argument_list
// CHECK-AST-NEXT: (argument // CHECK-AST-NEXT: (argument
// CHECK-AST-NEXT: (closure_expr type='(Int) -> Int' {{.*}} discriminator=0 escaping single-expression // CHECK-AST-NEXT: (closure_expr type="(Int) -> Int" {{.*}} discriminator=0 escaping single_expression
func nonescaping(_: (Int) -> Int) {} func nonescaping(_: (Int) -> Int) {}
nonescaping({ $0 }) nonescaping({ $0 })
// CHECK-AST: (declref_expr type='((Int) -> Int) -> ()' // CHECK-AST: (declref_expr type="((Int) -> Int) -> ()"
// CHECK-AST-NEXT: (argument_list // CHECK-AST-NEXT: (argument_list
// CHECK-AST-NEXT: (argument // CHECK-AST-NEXT: (argument
// CHECK-AST-NEXT: (closure_expr type='(Int) -> Int' {{.*}} discriminator=1 single-expression // CHECK-AST-NEXT: (closure_expr type="(Int) -> Int" {{.*}} discriminator=1 single_expression
// CHECK-LABEL: (struct_decl range=[{{.+}}] "MyStruct") // CHECK-LABEL: (struct_decl range=[{{.+}}] "MyStruct")
struct MyStruct {} struct MyStruct {}
@@ -85,23 +85,23 @@ enum MyEnum {
// CHECK-LABEL: (enum_case_decl range=[{{.+}}] // CHECK-LABEL: (enum_case_decl range=[{{.+}}]
// CHECK-NEXT: (enum_element_decl range=[{{.+}}] "foo(x:)" // CHECK-NEXT: (enum_element_decl range=[{{.+}}] "foo(x:)"
// CHECK-NEXT: (parameter_list range=[{{.+}}] // CHECK-NEXT: (parameter_list range=[{{.+}}]
// CHECK-NEXT: (parameter "x" apiName=x))) // CHECK-NEXT: (parameter "x" apiName="x")))
// CHECK-NEXT: (enum_element_decl range=[{{.+}}] "bar")) // CHECK-NEXT: (enum_element_decl range=[{{.+}}] "bar"))
// CHECK-NEXT: (enum_element_decl range=[{{.+}}] "foo(x:)" // CHECK-NEXT: (enum_element_decl range=[{{.+}}] "foo(x:)"
// CHECK-NEXT: (parameter_list range=[{{.+}}] // CHECK-NEXT: (parameter_list range=[{{.+}}]
// CHECK-NEXT: (parameter "x" apiName=x))) // CHECK-NEXT: (parameter "x" apiName="x")))
// CHECK-NEXT: (enum_element_decl range=[{{.+}}] "bar")) // CHECK-NEXT: (enum_element_decl range=[{{.+}}] "bar"))
case foo(x: MyStruct), bar case foo(x: MyStruct), bar
} }
// CHECK-LABEL: (top_level_code_decl range=[{{.+}}] // CHECK-LABEL: (top_level_code_decl range=[{{.+}}]
// CHECK-NEXT: (brace_stmt implicit range=[{{.+}}] // CHECK-NEXT: (brace_stmt implicit range=[{{.+}}]
// CHECK-NEXT: (sequence_expr type='<null>' // CHECK-NEXT: (sequence_expr type="<null>"
// CHECK-NEXT: (discard_assignment_expr type='<null>') // CHECK-NEXT: (discard_assignment_expr type="<null>")
// CHECK-NEXT: (assign_expr type='<null>' // CHECK-NEXT: (assign_expr type="<null>"
// CHECK-NEXT: (**NULL EXPRESSION**) // CHECK-NEXT: (<null expr>)
// CHECK-NEXT: (**NULL EXPRESSION**)) // CHECK-NEXT: (<null expr>))
// CHECK-NEXT: (closure_expr type='<null>' discriminator={{[0-9]+}} // CHECK-NEXT: (closure_expr type="<null>" discriminator={{[0-9]+}}
// CHECK-NEXT: (parameter_list range=[{{.+}}] // CHECK-NEXT: (parameter_list range=[{{.+}}]
// CHECK-NEXT: (parameter "v")) // CHECK-NEXT: (parameter "v"))
// CHECK-NEXT: (brace_stmt range=[{{.+}}]))))) // CHECK-NEXT: (brace_stmt range=[{{.+}}])))))
@@ -113,13 +113,12 @@ struct SelfParam {
// CHECK-LABEL: (func_decl range=[{{.+}}] "createOptional()" type // CHECK-LABEL: (func_decl range=[{{.+}}] "createOptional()" type
// CHECK-NEXT: (parameter "self") // CHECK-NEXT: (parameter "self")
// CHECK-NEXT: (parameter_list range=[{{.+}}]) // CHECK-NEXT: (parameter_list range=[{{.+}}])
// CHECK-NEXT: (result // CHECK-NEXT: (result=type_optional
// CHECK-NEXT: (type_optional // CHECK-NEXT: (type_ident id="SelfParam" unbound))
// CHECK-NEXT: (type_ident id='SelfParam' bind=none)))
static func createOptional() -> SelfParam? { static func createOptional() -> SelfParam? {
// CHECK-LABEL: (call_expr type='<null>' // CHECK-LABEL: (call_expr type="<null>"
// CHECK-NEXT: (unresolved_decl_ref_expr type='<null>' name=SelfParam function_ref=unapplied) // CHECK-NEXT: (unresolved_decl_ref_expr type="<null>" name="SelfParam" function_ref=unapplied)
// CHECK-NEXT: (argument_list) // CHECK-NEXT: (argument_list)
SelfParam() SelfParam()
} }
@@ -127,9 +126,8 @@ struct SelfParam {
// CHECK-LABEL: (func_decl range=[{{.+}}] "dumpMemberTypeRepr()" // CHECK-LABEL: (func_decl range=[{{.+}}] "dumpMemberTypeRepr()"
// CHECK-NEXT: (parameter_list range=[{{.+}}]) // CHECK-NEXT: (parameter_list range=[{{.+}}])
// CHECK-NEXT: (result // CHECK-NEXT: (result=type_member
// CHECK-NEXT: (type_member // CHECK-NEXT: (type_ident id="Array" unbound
// CHECK-NEXT: (type_ident id='Array' bind=none) // CHECK-NEXT: (type_ident id="Bool" unbound))
// CHECK-NEXT: (type_ident id='Bool' bind=none) // CHECK-NEXT: (type_ident id="Element" unbound))
// CHECK-NEXT: (type_ident id='Element' bind=none)))
func dumpMemberTypeRepr() -> Array<Bool>.Element { true } func dumpMemberTypeRepr() -> Array<Bool>.Element { true }

8
test/Frontend/module-alias-dump-ast.swift
View File

@@ -13,12 +13,12 @@
// RUN: %target-swift-frontend -dump-ast %t/FileLib.swift -module-alias XLogging=AppleLogging -I %t > %t/result-ast.output // RUN: %target-swift-frontend -dump-ast %t/FileLib.swift -module-alias XLogging=AppleLogging -I %t > %t/result-ast.output
// RUN: %FileCheck %s -input-file %t/result-ast.output -check-prefix CHECK-AST // RUN: %FileCheck %s -input-file %t/result-ast.output -check-prefix CHECK-AST
// CHECK-AST-NOT: bind=XLogging // CHECK-AST-NOT: bind="XLogging"
// CHECK-AST-NOT: module<XLogging> // CHECK-AST-NOT: module<XLogging>
// CHECK-AST-NOT: decl=XLogging // CHECK-AST-NOT: decl="XLogging"
// CHECK-AST: type_ident id='XLogging' bind=AppleLogging // CHECK-AST: type_ident id="XLogging" bind="AppleLogging"
// CHECK-AST: module<AppleLogging> // CHECK-AST: module<AppleLogging>
// CHECK-AST: decl=AppleLogging // CHECK-AST: decl="AppleLogging"
// BEGIN FileLogging.swift // BEGIN FileLogging.swift
public struct Logger { public struct Logger {

78
test/Generics/conditional_conformances.swift
View File

@@ -19,8 +19,8 @@ func takes_P5<X: P5>(_: X) {}
struct Free<T> {} struct Free<T> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=Free // CHECK-LABEL: ExtensionDecl line={{.*}} base=Free
// CHECK-NEXT: (normal_conformance type=Free<T> protocol=P2 // CHECK-NEXT: (normal_conformance type="Free<T>" protocol="P2"
// CHECK-NEXT: conforms_to: T P1) // CHECK-NEXT: (requirement "T" conforms_to "P1"))
extension Free: P2 where T: P1 {} extension Free: P2 where T: P1 {}
// expected-note@-1 {{requirement from conditional conformance of 'Free<U>' to 'P2'}} // expected-note@-1 {{requirement from conditional conformance of 'Free<U>' to 'P2'}}
// expected-note@-2 {{requirement from conditional conformance of 'Free<T>' to 'P2'}} // expected-note@-2 {{requirement from conditional conformance of 'Free<T>' to 'P2'}}
@@ -34,8 +34,8 @@ func free_bad<U>(_: U) {
struct Constrained<T: P1> {} struct Constrained<T: P1> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=Constrained // CHECK-LABEL: ExtensionDecl line={{.*}} base=Constrained
// CHECK-LABEL: ExtensionDecl line={{.*}} base=Constrained // CHECK-LABEL: ExtensionDecl line={{.*}} base=Constrained
// CHECK-NEXT: (normal_conformance type=Constrained<T> protocol=P2 // CHECK-NEXT: (normal_conformance type="Constrained<T>" protocol="P2"
// CHECK-NEXT: conforms_to: T P3) // CHECK-NEXT: (requirement "T" conforms_to "P3"))
extension Constrained: P2 where T: P3 {} // expected-note {{requirement from conditional conformance of 'Constrained<U>' to 'P2'}} extension Constrained: P2 where T: P3 {} // expected-note {{requirement from conditional conformance of 'Constrained<U>' to 'P2'}}
func constrained_good<U: P1 & P3>(_: U) { func constrained_good<U: P1 & P3>(_: U) {
takes_P2(Constrained<U>()) takes_P2(Constrained<U>())
@@ -47,22 +47,22 @@ func constrained_bad<U: P1>(_: U) {
struct RedundantSame<T: P1> {} struct RedundantSame<T: P1> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundantSame // CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundantSame
// CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundantSame // CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundantSame
// CHECK-NEXT: (normal_conformance type=RedundantSame<T> protocol=P2) // CHECK-NEXT: (normal_conformance type="RedundantSame<T>" protocol="P2")
extension RedundantSame: P2 where T: P1 {} extension RedundantSame: P2 where T: P1 {}
// expected-warning@-1 {{redundant conformance constraint 'T' : 'P1'}} // expected-warning@-1 {{redundant conformance constraint 'T' : 'P1'}}
struct RedundantSuper<T: P4> {} struct RedundantSuper<T: P4> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundantSuper // CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundantSuper
// CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundantSuper // CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundantSuper
// CHECK-NEXT: (normal_conformance type=RedundantSuper<T> protocol=P2) // CHECK-NEXT: (normal_conformance type="RedundantSuper<T>" protocol="P2")
extension RedundantSuper: P2 where T: P1 {} extension RedundantSuper: P2 where T: P1 {}
// expected-warning@-1 {{redundant conformance constraint 'T' : 'P1'}} // expected-warning@-1 {{redundant conformance constraint 'T' : 'P1'}}
struct OverlappingSub<T: P1> {} struct OverlappingSub<T: P1> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=OverlappingSub // CHECK-LABEL: ExtensionDecl line={{.*}} base=OverlappingSub
// CHECK-LABEL: ExtensionDecl line={{.*}} base=OverlappingSub // CHECK-LABEL: ExtensionDecl line={{.*}} base=OverlappingSub
// CHECK-NEXT: (normal_conformance type=OverlappingSub<T> protocol=P2 // CHECK-NEXT: (normal_conformance type="OverlappingSub<T>" protocol="P2"
// CHECK-NEXT: conforms_to: T P4) // CHECK-NEXT: (requirement "T" conforms_to "P4"))
extension OverlappingSub: P2 where T: P4 {} // expected-note {{requirement from conditional conformance of 'OverlappingSub<U>' to 'P2'}} extension OverlappingSub: P2 where T: P4 {} // expected-note {{requirement from conditional conformance of 'OverlappingSub<U>' to 'P2'}}
// expected-warning@-1 {{redundant conformance constraint 'T' : 'P1'}} // expected-warning@-1 {{redundant conformance constraint 'T' : 'P1'}}
func overlapping_sub_good<U: P4>(_: U) { func overlapping_sub_good<U: P4>(_: U) {
@@ -76,8 +76,8 @@ func overlapping_sub_bad<U: P1>(_: U) {
struct SameType<T> {} struct SameType<T> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=SameType // CHECK-LABEL: ExtensionDecl line={{.*}} base=SameType
// CHECK-LABEL: ExtensionDecl line={{.*}} base=SameType // CHECK-LABEL: ExtensionDecl line={{.*}} base=SameType
// CHECK-NEXT: (normal_conformance type=SameType<T> protocol=P2 // CHECK-NEXT: (normal_conformance type="SameType<T>" protocol="P2"
// CHECK-NEXT: same_type: T Int) // CHECK-NEXT: (requirement "T" same_type "Int"))
extension SameType: P2 where T == Int {} extension SameType: P2 where T == Int {}
// expected-note@-1 {{requirement from conditional conformance of 'SameType<U>' to 'P2'}} // expected-note@-1 {{requirement from conditional conformance of 'SameType<U>' to 'P2'}}
// expected-note@-2 {{requirement from conditional conformance of 'SameType<Float>' to 'P2'}} // expected-note@-2 {{requirement from conditional conformance of 'SameType<Float>' to 'P2'}}
@@ -93,8 +93,8 @@ func same_type_bad<U>(_: U) {
struct SameTypeGeneric<T, U> {} struct SameTypeGeneric<T, U> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=SameTypeGeneric // CHECK-LABEL: ExtensionDecl line={{.*}} base=SameTypeGeneric
// CHECK-LABEL: ExtensionDecl line={{.*}} base=SameTypeGeneric // CHECK-LABEL: ExtensionDecl line={{.*}} base=SameTypeGeneric
// CHECK-NEXT: (normal_conformance type=SameTypeGeneric<T, U> protocol=P2 // CHECK-NEXT: (normal_conformance type="SameTypeGeneric<T, U>" protocol="P2"
// CHECK-NEXT: same_type: T U) // CHECK-NEXT: (requirement "T" same_type "U"))
extension SameTypeGeneric: P2 where T == U {} extension SameTypeGeneric: P2 where T == U {}
// expected-note@-1 {{requirement from conditional conformance of 'SameTypeGeneric<U, Int>' to 'P2'}} // expected-note@-1 {{requirement from conditional conformance of 'SameTypeGeneric<U, Int>' to 'P2'}}
// expected-note@-2 {{requirement from conditional conformance of 'SameTypeGeneric<Int, Float>' to 'P2'}} // expected-note@-2 {{requirement from conditional conformance of 'SameTypeGeneric<Int, Float>' to 'P2'}}
@@ -119,9 +119,9 @@ func same_type_bad<U, V>(_: U, _: V) {
struct Infer<T, U> {} struct Infer<T, U> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=Infer // CHECK-LABEL: ExtensionDecl line={{.*}} base=Infer
// CHECK-LABEL: ExtensionDecl line={{.*}} base=Infer // CHECK-LABEL: ExtensionDecl line={{.*}} base=Infer
// CHECK-NEXT: (normal_conformance type=Infer<T, U> protocol=P2 // CHECK-NEXT: (normal_conformance type="Infer<T, U>" protocol="P2"
// CHECK-NEXT: same_type: T Constrained<U> // CHECK-NEXT: (requirement "T" same_type "Constrained<U>")
// CHECK-NEXT: conforms_to: U P1) // CHECK-NEXT: (requirement "U" conforms_to "P1"))
extension Infer: P2 where T == Constrained<U> {} extension Infer: P2 where T == Constrained<U> {}
// expected-note@-1 2 {{requirement from conditional conformance of 'Infer<Constrained<U>, V>' to 'P2'}} // expected-note@-1 2 {{requirement from conditional conformance of 'Infer<Constrained<U>, V>' to 'P2'}}
func infer_good<U: P1>(_: U) { func infer_good<U: P1>(_: U) {
@@ -138,8 +138,8 @@ func infer_bad<U: P1, V>(_: U, _: V) {
struct InferRedundant<T, U: P1> {} struct InferRedundant<T, U: P1> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=InferRedundant // CHECK-LABEL: ExtensionDecl line={{.*}} base=InferRedundant
// CHECK-LABEL: ExtensionDecl line={{.*}} base=InferRedundant // CHECK-LABEL: ExtensionDecl line={{.*}} base=InferRedundant
// CHECK-NEXT: (normal_conformance type=InferRedundant<T, U> protocol=P2 // CHECK-NEXT: (normal_conformance type="InferRedundant<T, U>" protocol="P2"
// CHECK-NEXT: same_type: T Constrained<U>) // CHECK-NEXT: (requirement "T" same_type "Constrained<U>"))
extension InferRedundant: P2 where T == Constrained<U> {} extension InferRedundant: P2 where T == Constrained<U> {}
func infer_redundant_good<U: P1>(_: U) { func infer_redundant_good<U: P1>(_: U) {
takes_P2(InferRedundant<Constrained<U>, U>()) takes_P2(InferRedundant<Constrained<U>, U>())
@@ -159,8 +159,8 @@ class C3: C2 {}
struct ClassFree<T> {} struct ClassFree<T> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassFree // CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassFree
// CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassFree // CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassFree
// CHECK-NEXT: (normal_conformance type=ClassFree<T> protocol=P2 // CHECK-NEXT: (normal_conformance type="ClassFree<T>" protocol="P2"
// CHECK-NEXT: superclass: T C1) // CHECK-NEXT: (requirement "T" subclass_of "C1"))
extension ClassFree: P2 where T: C1 {} // expected-note {{requirement from conditional conformance of 'ClassFree<U>' to 'P2'}} extension ClassFree: P2 where T: C1 {} // expected-note {{requirement from conditional conformance of 'ClassFree<U>' to 'P2'}}
func class_free_good<U: C1>(_: U) { func class_free_good<U: C1>(_: U) {
takes_P2(ClassFree<U>()) takes_P2(ClassFree<U>())
@@ -173,8 +173,8 @@ func class_free_bad<U>(_: U) {
struct ClassMoreSpecific<T: C1> {} struct ClassMoreSpecific<T: C1> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassMoreSpecific // CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassMoreSpecific
// CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassMoreSpecific // CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassMoreSpecific
// CHECK-NEXT: (normal_conformance type=ClassMoreSpecific<T> protocol=P2 // CHECK-NEXT: (normal_conformance type="ClassMoreSpecific<T>" protocol="P2"
// CHECK-NEXT: superclass: T C3) // CHECK-NEXT: (requirement "T" subclass_of "C3"))
extension ClassMoreSpecific: P2 where T: C3 {} // expected-note {{requirement from conditional conformance of 'ClassMoreSpecific<U>' to 'P2'}} extension ClassMoreSpecific: P2 where T: C3 {} // expected-note {{requirement from conditional conformance of 'ClassMoreSpecific<U>' to 'P2'}}
// expected-warning@-1 {{redundant superclass constraint 'T' : 'C1'}} // expected-warning@-1 {{redundant superclass constraint 'T' : 'C1'}}
func class_more_specific_good<U: C3>(_: U) { func class_more_specific_good<U: C3>(_: U) {
@@ -189,7 +189,7 @@ func class_more_specific_bad<U: C1>(_: U) {
struct ClassLessSpecific<T: C3> {} struct ClassLessSpecific<T: C3> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassLessSpecific // CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassLessSpecific
// CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassLessSpecific // CHECK-LABEL: ExtensionDecl line={{.*}} base=ClassLessSpecific
// CHECK-NEXT: (normal_conformance type=ClassLessSpecific<T> protocol=P2) // CHECK-NEXT: (normal_conformance type="ClassLessSpecific<T>" protocol="P2")
extension ClassLessSpecific: P2 where T: C1 {} extension ClassLessSpecific: P2 where T: C1 {}
// expected-warning@-1 {{redundant superclass constraint 'T' : 'C1'}} // expected-warning@-1 {{redundant superclass constraint 'T' : 'C1'}}
@@ -213,15 +213,15 @@ func subclass_bad() {
struct InheritEqual<T> {} struct InheritEqual<T> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual
// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual
// CHECK-NEXT: (normal_conformance type=InheritEqual<T> protocol=P2 // CHECK-NEXT: (normal_conformance type="InheritEqual<T>" protocol="P2"
// CHECK-NEXT: conforms_to: T P1) // CHECK-NEXT: (requirement "T" conforms_to "P1"))
extension InheritEqual: P2 where T: P1 {} // expected-note {{requirement from conditional conformance of 'InheritEqual<U>' to 'P2'}} extension InheritEqual: P2 where T: P1 {} // expected-note {{requirement from conditional conformance of 'InheritEqual<U>' to 'P2'}}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual
// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual
// CHECK-NEXT: (normal_conformance type=InheritEqual<T> protocol=P5 // CHECK-NEXT: (normal_conformance type="InheritEqual<T>" protocol="P5"
// CHECK-NEXT: (normal_conformance type=InheritEqual<T> protocol=P2 // CHECK-NEXT: (normal_conformance type="InheritEqual<T>" protocol="P2"
// CHECK-NEXT: conforms_to: T P1) // CHECK-NEXT: (requirement "T" conforms_to "P1"))
// CHECK-NEXT: conforms_to: T P1) // CHECK-NEXT: (requirement "T" conforms_to "P1"))
extension InheritEqual: P5 where T: P1 {} // expected-note {{requirement from conditional conformance of 'InheritEqual<U>' to 'P5'}} extension InheritEqual: P5 where T: P1 {} // expected-note {{requirement from conditional conformance of 'InheritEqual<U>' to 'P5'}}
func inheritequal_good<U: P1>(_: U) { func inheritequal_good<U: P1>(_: U) {
takes_P2(InheritEqual<U>()) takes_P2(InheritEqual<U>())
@@ -245,15 +245,15 @@ extension InheritLess: P5 {}
struct InheritMore<T> {} struct InheritMore<T> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore
// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore
// CHECK-NEXT: (normal_conformance type=InheritMore<T> protocol=P2 // CHECK-NEXT: (normal_conformance type="InheritMore<T>" protocol="P2"
// CHECK-NEXT: conforms_to: T P1) // CHECK-NEXT: (requirement "T" conforms_to "P1"))
extension InheritMore: P2 where T: P1 {} // expected-note {{requirement from conditional conformance of 'InheritMore<U>' to 'P2'}} extension InheritMore: P2 where T: P1 {} // expected-note {{requirement from conditional conformance of 'InheritMore<U>' to 'P2'}}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore
// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore
// CHECK-NEXT: (normal_conformance type=InheritMore<T> protocol=P5 // CHECK-NEXT: (normal_conformance type="InheritMore<T>" protocol="P5"
// CHECK-NEXT: (normal_conformance type=InheritMore<T> protocol=P2 // CHECK-NEXT: (normal_conformance type="InheritMore<T>" protocol="P2"
// CHECK-NEXT: conforms_to: T P1) // CHECK-NEXT: (requirement "T" conforms_to "P1"))
// CHECK-NEXT: conforms_to: T P4) // CHECK-NEXT: (requirement "T" conforms_to "P4"))
extension InheritMore: P5 where T: P4 {} // expected-note 2 {{requirement from conditional conformance of 'InheritMore<U>' to 'P5'}} extension InheritMore: P5 where T: P4 {} // expected-note 2 {{requirement from conditional conformance of 'InheritMore<U>' to 'P5'}}
func inheritequal_good_good<U: P4>(_: U) { func inheritequal_good_good<U: P4>(_: U) {
takes_P2(InheritMore<U>()) takes_P2(InheritMore<U>())
@@ -334,17 +334,17 @@ extension TwoDisjointConformances: P2 where T == String {}
struct RedundancyOrderDependenceGood<T: P1, U> {} struct RedundancyOrderDependenceGood<T: P1, U> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundancyOrderDependenceGood // CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundancyOrderDependenceGood
// CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundancyOrderDependenceGood // CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundancyOrderDependenceGood
// CHECK-NEXT: (normal_conformance type=RedundancyOrderDependenceGood<T, U> protocol=P2 // CHECK-NEXT: (normal_conformance type="RedundancyOrderDependenceGood<T, U>" protocol="P2"
// CHECK-NEXT: same_type: T U) // CHECK-NEXT: (requirement "T" same_type "U"))
extension RedundancyOrderDependenceGood: P2 where U: P1, T == U {} extension RedundancyOrderDependenceGood: P2 where U: P1, T == U {}
// expected-warning@-1 {{redundant conformance constraint 'U' : 'P1'}} // expected-warning@-1 {{redundant conformance constraint 'U' : 'P1'}}
struct RedundancyOrderDependenceBad<T, U: P1> {} struct RedundancyOrderDependenceBad<T, U: P1> {}
// CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundancyOrderDependenceBad // CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundancyOrderDependenceBad
// CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundancyOrderDependenceBad // CHECK-LABEL: ExtensionDecl line={{.*}} base=RedundancyOrderDependenceBad
// CHECK-NEXT: (normal_conformance type=RedundancyOrderDependenceBad<T, U> protocol=P2 // CHECK-NEXT: (normal_conformance type="RedundancyOrderDependenceBad<T, U>" protocol="P2"
// CHECK-NEXT: conforms_to: T P1 // CHECK-NEXT: (requirement "T" conforms_to "P1")
// CHECK-NEXT: same_type: T U) // CHECK-NEXT: (requirement "T" same_type "U"))
extension RedundancyOrderDependenceBad: P2 where T: P1, T == U {} // expected-warning {{redundant conformance constraint 'U' : 'P1'}} extension RedundancyOrderDependenceBad: P2 where T: P1, T == U {} // expected-warning {{redundant conformance constraint 'U' : 'P1'}}
// Checking of conditional requirements for existential conversions. // Checking of conditional requirements for existential conversions.

8
test/Generics/minimal_conformances_compare_concrete.swift
View File

@@ -14,9 +14,9 @@ struct G<X> {}
// CHECK-NEXT: Generic signature: <X where X == Derived> // CHECK-NEXT: Generic signature: <X where X == Derived>
extension G where X : Base, X : P, X == Derived {} extension G where X : Base, X : P, X == Derived {}
// RULE: + superclass: τ_0_0 Base // RULE: + (requirement "\xCF\x84_0_0" subclass_of "Base")
// RULE: + conforms_to: τ_0_0 P // RULE: + (requirement "\xCF\x84_0_0" conforms_to "P")
// RULE: + same_type: τ_0_0 Derived // RULE: + (requirement "\xCF\x84_0_0" same_type "Derived")
// RULE: Rewrite system: { // RULE: Rewrite system: {
// RULE-NEXT: - [P].[P] => [P] [permanent] // RULE-NEXT: - [P].[P] => [P] [permanent]
@@ -36,4 +36,4 @@ extension G where X : Base, X : P, X == Derived {}
// //
// - without concrete contraction, we used to hit a problem where the sort // - without concrete contraction, we used to hit a problem where the sort
// in the minimal conformances algorithm would hit the unordered concrete // in the minimal conformances algorithm would hit the unordered concrete
// conformances [concrete: Derived : P] vs [concrete: Base : P]. // conformances [concrete: Derived : P] vs [concrete: Base : P].

4
test/ImportResolution/import-resolution-overload.swift
View File

@@ -60,7 +60,7 @@ extension HasFooSub {
func testHasFooSub(_ hfs: HasFooSub) -> Int { func testHasFooSub(_ hfs: HasFooSub) -> Int {
// CHECK: return_stmt // CHECK: return_stmt
// CHECK-NOT: func_decl // CHECK-NOT: func_decl
// CHECK: member_ref_expr{{.*}}decl=overload_vars.(file).HasFoo.foo // CHECK: member_ref_expr{{.*}}decl="overload_vars.(file).HasFoo.foo
return hfs.foo return hfs.foo
} }
@@ -72,7 +72,7 @@ extension HasBar {
func testHasBar(_ hb: HasBar) -> Int { func testHasBar(_ hb: HasBar) -> Int {
// CHECK: return_stmt // CHECK: return_stmt
// CHECK-NOT: func_decl // CHECK-NOT: func_decl
// CHECK: member_ref_expr{{.*}}decl=overload_vars.(file).HasBar.bar // CHECK: member_ref_expr{{.*}}decl="overload_vars.(file).HasBar.bar
return hb.bar return hb.bar
} }

3
test/Parse/raw_string.swift
View File

@@ -71,14 +71,13 @@ _ = ##"""
// ===---------- False Multiline Delimiters --------=== // ===---------- False Multiline Delimiters --------===
/// Source code contains zero-width character in this format: `#"[U+200B]"[U+200B]"#` /// Source code contains zero-width character in this format: `#"[U+200B]"[U+200B]"#`
/// The check contains zero-width character in this format: `"[U+200B]\"[U+200B]"`
/// If this check fails after you implement `diagnoseZeroWidthMatchAndAdvance`, /// If this check fails after you implement `diagnoseZeroWidthMatchAndAdvance`,
/// then you may need to tweak how to test for single-line string literals that /// then you may need to tweak how to test for single-line string literals that
/// resemble a multiline delimiter in `advanceIfMultilineDelimiter` so that it /// resemble a multiline delimiter in `advanceIfMultilineDelimiter` so that it
/// passes again. /// passes again.
/// See https://github.com/apple/swift/issues/51192. /// See https://github.com/apple/swift/issues/51192.
_ = #"​"​"# _ = #"​"​"#
// CHECK: "​\"​" // CHECK: "\xE2\x80\x8B\"\xE2\x80\x8B"
_ = #""""# _ = #""""#
// CHECK: "\"\"" // CHECK: "\"\""

2
test/Parse/source_locs.swift
View File

@@ -7,5 +7,5 @@ func string_interpolation() {
// RUN: not %target-swift-frontend -dump-ast %/s | %FileCheck %s // RUN: not %target-swift-frontend -dump-ast %/s | %FileCheck %s
// CHECK: (interpolated_string_literal_expr {{.*}} trailing_quote_loc=SOURCE_DIR/test/Parse/source_locs.swift:4:12 {{.*}} // CHECK: (interpolated_string_literal_expr {{.*}} trailing_quote_loc=SOURCE_DIR/test/Parse/source_locs.swift:4:12 {{.*}}
// CHECK: (editor_placeholder_expr type='()' {{.*}} trailing_angle_bracket_loc=SOURCE_DIR/test/Parse/source_locs.swift:5:9 // CHECK: (editor_placeholder_expr type="()" {{.*}} trailing_angle_bracket_loc=SOURCE_DIR/test/Parse/source_locs.swift:5:9

4
test/SILOptimizer/inline_generics.sil
View File

@@ -147,9 +147,9 @@ sil_vtable MyNumber {}
// substituting we need to pick up the normal_conformance. // substituting we need to pick up the normal_conformance.
// CHECK-LABEL: sil @test_inlining : $@convention(objc_method) (@owned MyNumber) -> () { // CHECK-LABEL: sil @test_inlining : $@convention(objc_method) (@owned MyNumber) -> () {
// CHECK-NOT: Generic specialization information for call-site dootherstuff <MyNumber & SomeProto> conformances <(abstract_conformance protocol=OtherProto)> // CHECK-NOT: Generic specialization information for call-site dootherstuff <MyNumber & SomeProto> conformances <(abstract_conformance protocol="OtherProto")>
// CHECK: Generic specialization information // CHECK: Generic specialization information
// CHECK: (normal_conformance type=MyObject protocol=OtherProto) // CHECK: (normal_conformance type="MyObject" protocol="OtherProto")
// CHECK: end sil function 'test_inlining' // CHECK: end sil function 'test_inlining'
sil @test_inlining : $@convention(objc_method) (@owned MyNumber) -> () { sil @test_inlining : $@convention(objc_method) (@owned MyNumber) -> () {

4
test/SILOptimizer/sil_combine_concrete_existential.sil
View File

@@ -670,8 +670,8 @@ sil @callee2 : $@convention(thin) <τ_0_0 where τ_0_0 : SubscriptionViewControl
// CHECK: [[T5:%.*]] = function_ref @callee2 : $@convention(thin) <τ_0_0 where τ_0_0 : SubscriptionViewControllerDelegate> (@in τ_0_0, @thick SubscriptionViewControllerBuilder.Type) -> @owned SubscriptionViewControllerBuilder // CHECK: [[T5:%.*]] = function_ref @callee2 : $@convention(thin) <τ_0_0 where τ_0_0 : SubscriptionViewControllerDelegate> (@in τ_0_0, @thick SubscriptionViewControllerBuilder.Type) -> @owned SubscriptionViewControllerBuilder
// CHECK: [[T6:%.*]] = alloc_stack $@opened("E4D92D2A-8893-11EA-9C89-ACDE48001122", any ResourceKitProtocol) Self // CHECK: [[T6:%.*]] = alloc_stack $@opened("E4D92D2A-8893-11EA-9C89-ACDE48001122", any ResourceKitProtocol) Self
// CHECK: copy_addr [[T4]] to [init] [[T6]] : $*@opened("E4D92D2A-8893-11EA-9C89-ACDE48001122", any ResourceKitProtocol) Self // CHECK: copy_addr [[T4]] to [init] [[T6]] : $*@opened("E4D92D2A-8893-11EA-9C89-ACDE48001122", any ResourceKitProtocol) Self
// CHECK: Generic specialization information for call-site callee2 <any ResourceKitProtocol> conformances <(inherited_conformance type=any ResourceKitProtocol protocol=SubscriptionViewControllerDelegate // CHECK: Generic specialization information for call-site callee2 <any ResourceKitProtocol> conformances <(inherited_conformance type="any ResourceKitProtocol" protocol="SubscriptionViewControllerDelegate"
// CHECK: (normal_conformance type=MyObject protocol=SubscriptionViewControllerDelegate))>: // CHECK: (normal_conformance type="MyObject" protocol="SubscriptionViewControllerDelegate"))>:
// CHECK: apply [[T5]]<@opened("E4D92D2A-8893-11EA-9C89-ACDE48001122", any ResourceKitProtocol) Self>([[T6]], [[T1]]) // CHECK: apply [[T5]]<@opened("E4D92D2A-8893-11EA-9C89-ACDE48001122", any ResourceKitProtocol) Self>([[T6]], [[T1]])
sil @test_opend_archetype_concrete_conformance_substitution : $@convention(method) (@guaranteed ResourceKitProtocol, @guaranteed ViewController) -> () { sil @test_opend_archetype_concrete_conformance_substitution : $@convention(method) (@guaranteed ResourceKitProtocol, @guaranteed ViewController) -> () {

24
test/Sema/dynamic_self_implicit_conversions.swift
View File

@@ -19,32 +19,32 @@ class A {
class B: A { class B: A {
func test() -> Self { func test() -> Self {
// CHECK: covariant_return_conversion_expr implicit type='Self' location={{.*}}.swift:[[@LINE+1]] // CHECK: covariant_return_conversion_expr implicit type="Self" location={{.*}}.swift:[[@LINE+1]]
_ = super.method() _ = super.method()
// CHECK: covariant_function_conversion_expr implicit type='() -> Self' location={{.*}}.swift:[[@LINE+1]] // CHECK: covariant_function_conversion_expr implicit type="() -> Self" location={{.*}}.swift:[[@LINE+1]]
_ = super.method _ = super.method
// CHECK: covariant_return_conversion_expr implicit type='Self' location={{.*}}.swift:[[@LINE+1]] // CHECK: covariant_return_conversion_expr implicit type="Self" location={{.*}}.swift:[[@LINE+1]]
_ = super.property _ = super.property
// CHECK: covariant_return_conversion_expr implicit type='Self' location={{.*}}.swift:[[@LINE+1]] // CHECK: covariant_return_conversion_expr implicit type="Self" location={{.*}}.swift:[[@LINE+1]]
_ = super[] _ = super[]
return super.property return super.property
} }
static func testStatic() -> Self { static func testStatic() -> Self {
// CHECK: covariant_return_conversion_expr implicit type='Self' location={{.*}}.swift:[[@LINE+1]] // CHECK: covariant_return_conversion_expr implicit type="Self" location={{.*}}.swift:[[@LINE+1]]
_ = super.staticMethod() _ = super.staticMethod()
// CHECK: covariant_function_conversion_expr implicit type='() -> Self' location={{.*}}.swift:[[@LINE+1]] // CHECK: covariant_function_conversion_expr implicit type="() -> Self" location={{.*}}.swift:[[@LINE+1]]
_ = super.staticMethod _ = super.staticMethod
// CHECK-NOT: function_conversion_expr {{.*}} location={{.*}}.swift:[[@LINE+3]] // CHECK-NOT: function_conversion_expr {{.*}} location={{.*}}.swift:[[@LINE+3]]
// CHECK-NOT: covariant_function_conversion_expr {{.*}} location={{.*}}.swift:[[@LINE+2]] // CHECK-NOT: covariant_function_conversion_expr {{.*}} location={{.*}}.swift:[[@LINE+2]]
// CHECK: covariant_return_conversion_expr implicit type='Self' location={{.*}}.swift:[[@LINE+1]] // CHECK: covariant_return_conversion_expr implicit type="Self" location={{.*}}.swift:[[@LINE+1]]
_ = self.method _ = self.method
// CHECK: covariant_return_conversion_expr implicit type='Self' location={{.*}}.swift:[[@LINE+1]] // CHECK: covariant_return_conversion_expr implicit type="Self" location={{.*}}.swift:[[@LINE+1]]
_ = self.init() _ = self.init()
// CHECK: covariant_return_conversion_expr implicit type='Self' location={{.*}}.swift:[[@LINE+1]] // CHECK: covariant_return_conversion_expr implicit type="Self" location={{.*}}.swift:[[@LINE+1]]
_ = super.staticProperty _ = super.staticProperty
// CHECK: covariant_return_conversion_expr implicit type='Self' location={{.*}}.swift:[[@LINE+1]] // CHECK: covariant_return_conversion_expr implicit type="Self" location={{.*}}.swift:[[@LINE+1]]
_ = super[] _ = super[]
return super.staticProperty return super.staticProperty
@@ -53,8 +53,8 @@ class B: A {
func testOnExistential(arg: P & A) { func testOnExistential(arg: P & A) {
// FIXME: This could be a single conversion. // FIXME: This could be a single conversion.
// CHECK: function_conversion_expr implicit type='() -> any A & P' location={{.*}}.swift:[[@LINE+2]] // CHECK: function_conversion_expr implicit type="() -> any A & P" location={{.*}}.swift:[[@LINE+2]]
// CHECK-NEXT: covariant_function_conversion_expr implicit type='() -> any A & P' location={{.*}}.swift:[[@LINE+1]] // CHECK-NEXT: covariant_function_conversion_expr implicit type="() -> any A & P" location={{.*}}.swift:[[@LINE+1]]
_ = arg.method _ = arg.method
} }

36
test/Sema/property_wrappers.swift
View File

@@ -17,11 +17,11 @@ struct WrapperWithClosureArg<Value> {
// rdar://problem/59685601 // rdar://problem/59685601
// CHECK-LABEL: R_59685601 // CHECK-LABEL: R_59685601
struct R_59685601 { struct R_59685601 {
// CHECK: argument_list implicit labels=wrappedValue:reset: // CHECK: argument_list implicit labels="wrappedValue:reset:"
// CHECK-NEXT: argument label=wrappedValue // CHECK-NEXT: argument label="wrappedValue"
// CHECK-NEXT: property_wrapper_value_placeholder_expr implicit type='String' // CHECK-NEXT: property_wrapper_value_placeholder_expr implicit type="String"
// CHECK-NEXT: opaque_value_expr implicit type='String' // CHECK-NEXT: opaque_value_expr implicit type="String"
// CHECK-NEXT: string_literal_expr type='String' // CHECK-NEXT: string_literal_expr type="String"
@WrapperWithClosureArg(reset: { value, transaction in @WrapperWithClosureArg(reset: { value, transaction in
transaction.state = 10 transaction.state = 10
}) })
@@ -37,13 +37,13 @@ struct Wrapper<Value> {
struct TestInitSubscript { struct TestInitSubscript {
enum Color: CaseIterable { case pink } enum Color: CaseIterable { case pink }
// CHECK: argument_list labels=wrappedValue: // CHECK: argument_list labels="wrappedValue:"
// CHECK-NEXT: argument label=wrappedValue // CHECK-NEXT: argument label="wrappedValue"
// CHECK-NEXT: subscript_expr type='TestInitSubscript.Color' // CHECK-NEXT: subscript_expr type="TestInitSubscript.Color"
// CHECK: argument_list implicit // CHECK: argument_list implicit
// CHECK-NEXT: argument // CHECK-NEXT: argument
// CHECK-NOT: property_wrapper_value_placeholder_expr implicit type='Int' // CHECK-NOT: property_wrapper_value_placeholder_expr implicit type="Int"
// CHECK: integer_literal_expr type='Int' // CHECK: integer_literal_expr type="Int"
@Wrapper(wrappedValue: Color.allCases[0]) @Wrapper(wrappedValue: Color.allCases[0])
var color: Color var color: Color
} }
@@ -68,19 +68,19 @@ public class W_58201<Value> {
// CHECK-LABEL: struct_decl{{.*}}S1_58201 // CHECK-LABEL: struct_decl{{.*}}S1_58201
struct S1_58201 { struct S1_58201 {
// CHECK: argument_list implicit labels=wrappedValue: // CHECK: argument_list implicit labels="wrappedValue:"
// CHECK-NEXT: argument label=wrappedValue // CHECK-NEXT: argument label="wrappedValue"
// CHECK-NEXT: autoclosure_expr implicit type='() -> Bool?' discriminator=0 captures=(<opaque_value> ) escaping // CHECK-NEXT: autoclosure_expr implicit type="() -> Bool?" discriminator=0 captures=(<opaque_value> ) escaping
// CHECK: autoclosure_expr implicit type='() -> Bool?' discriminator=1 escaping // CHECK: autoclosure_expr implicit type="() -> Bool?" discriminator=1 escaping
@W_58201 var a: Bool? @W_58201 var a: Bool?
} }
// CHECK-LABEL: struct_decl{{.*}}S2_58201 // CHECK-LABEL: struct_decl{{.*}}S2_58201
struct S2_58201 { struct S2_58201 {
// CHECK: argument_list implicit labels=wrappedValue: // CHECK: argument_list implicit labels="wrappedValue:"
// CHECK-NEXT: argument label=wrappedValue // CHECK-NEXT: argument label="wrappedValue"
// CHECK-NEXT: autoclosure_expr implicit type='() -> Bool' location={{.*}}.swift:[[@LINE+2]]:26 range=[{{.+}}] discriminator=0 captures=(<opaque_value> ) escaping // CHECK-NEXT: autoclosure_expr implicit type="() -> Bool" location={{.*}}.swift:[[@LINE+2]]:26 range=[{{.+}}] discriminator=0 captures=(<opaque_value> ) escaping
// CHECK: autoclosure_expr implicit type='() -> Bool' location={{.*}}.swift:[[@LINE+1]]:26 range=[{{.+}}] discriminator=1 escaping // CHECK: autoclosure_expr implicit type="() -> Bool" location={{.*}}.swift:[[@LINE+1]]:26 range=[{{.+}}] discriminator=1 escaping
@W_58201 var b: Bool = false @W_58201 var b: Bool = false
} }

76
test/Sema/type_eraser.swift
View File

@@ -11,45 +11,45 @@ struct ConcreteP: P, Hashable {}
// CHECK-LABEL: testBasic // CHECK-LABEL: testBasic
dynamic func testBasic() -> some P { dynamic func testBasic() -> some P {
// CHECK: underlying_to_opaque_expr{{.*}}'some P' // CHECK: underlying_to_opaque_expr{{.*}}"some P"
// CHECK-NEXT: call_expr implicit type='AnyP' // CHECK-NEXT: call_expr implicit type="AnyP"
// CHECK: argument_list implicit labels=erasing: // CHECK: argument_list implicit labels="erasing:"
// CHECK-NEXT: argument label=erasing // CHECK-NEXT: argument label="erasing"
// CHECK-NEXT: call_expr type='ConcreteP' // CHECK-NEXT: call_expr type="ConcreteP"
ConcreteP() ConcreteP()
} }
// CHECK-LABEL: testTypeAlias // CHECK-LABEL: testTypeAlias
typealias AliasForP = P typealias AliasForP = P
dynamic func testTypeAlias() -> some AliasForP { dynamic func testTypeAlias() -> some AliasForP {
// CHECK: underlying_to_opaque_expr{{.*}}'some P' // CHECK: underlying_to_opaque_expr{{.*}}"some P"
// CHECK-NEXT: call_expr implicit type='AnyP' // CHECK-NEXT: call_expr implicit type="AnyP"
// CHECK: argument_list implicit labels=erasing: // CHECK: argument_list implicit labels="erasing:"
// CHECK-NEXT: argument label=erasing // CHECK-NEXT: argument label="erasing"
// CHECK-NEXT: call_expr type='ConcreteP' // CHECK-NEXT: call_expr type="ConcreteP"
ConcreteP() ConcreteP()
} }
// CHECK-LABEL: testNoDynamic // CHECK-LABEL: testNoDynamic
func testNoDynamic() -> some P { func testNoDynamic() -> some P {
// CHECK: underlying_to_opaque_expr{{.*}}'some P' // CHECK: underlying_to_opaque_expr{{.*}}"some P"
// CHECK-NEXT: call_expr type='ConcreteP' // CHECK-NEXT: call_expr type="ConcreteP"
ConcreteP() ConcreteP()
} }
// CHECK-LABEL: testNoOpaque // CHECK-LABEL: testNoOpaque
dynamic func testNoOpaque() -> P { dynamic func testNoOpaque() -> P {
// CHECK: erasure_expr implicit type='any P' // CHECK: erasure_expr implicit type="any P"
// CHECK-NEXT: normal_conformance type=ConcreteP protocol=P // CHECK-NEXT: normal_conformance type="ConcreteP" protocol="P"
// CHECK-NEXT: call_expr type='ConcreteP' // CHECK-NEXT: call_expr type="ConcreteP"
ConcreteP() ConcreteP()
} }
// CHECK-LABEL: testComposition // CHECK-LABEL: testComposition
typealias Composition = P & Hashable typealias Composition = P & Hashable
dynamic func testComposition() -> some Composition { dynamic func testComposition() -> some Composition {
// CHECK: underlying_to_opaque_expr{{.*}}'some Hashable & P' // CHECK: underlying_to_opaque_expr{{.*}}"some Hashable & P"
// CHECK-NEXT: call_expr type='ConcreteP' // CHECK-NEXT: call_expr type="ConcreteP"
ConcreteP() ConcreteP()
} }
@@ -66,11 +66,11 @@ class TestResultBuilder {
// CHECK-LABEL: testTransformFnBody // CHECK-LABEL: testTransformFnBody
@Builder dynamic var testTransformFnBody: some P { @Builder dynamic var testTransformFnBody: some P {
// CHECK: return_stmt // CHECK: return_stmt
// CHECK-NEXT: underlying_to_opaque_expr implicit type='some P' // CHECK-NEXT: underlying_to_opaque_expr implicit type="some P"
// CHECK-NEXT: call_expr implicit type='AnyP' // CHECK-NEXT: call_expr implicit type="AnyP"
// CHECK: argument_list implicit labels=erasing: // CHECK: argument_list implicit labels="erasing:"
// CHECK-NEXT: argument label=erasing // CHECK-NEXT: argument label="erasing"
// CHECK: declref_expr implicit type='@lvalue ConcreteP' // CHECK: declref_expr implicit type="@lvalue ConcreteP"
ConcreteP() ConcreteP()
} }
@@ -79,14 +79,14 @@ class TestResultBuilder {
// CHECK-LABEL: testClosureBuilder // CHECK-LABEL: testClosureBuilder
dynamic var testClosureBuilder: some P { dynamic var testClosureBuilder: some P {
// CHECK: underlying_to_opaque_expr implicit type='some P' // CHECK: underlying_to_opaque_expr implicit type="some P"
// CHECK-NEXT: call_expr implicit type='AnyP' // CHECK-NEXT: call_expr implicit type="AnyP"
// CHECK: argument_list implicit labels=erasing: // CHECK: argument_list implicit labels="erasing:"
// CHECK-NEXT: argument label=erasing // CHECK-NEXT: argument label="erasing"
// CHECK: closure_expr type='() -> ConcreteP' // CHECK: closure_expr type="() -> ConcreteP"
takesBuilder { takesBuilder {
// CHECK: return_stmt // CHECK: return_stmt
// CHECK-NEXT: call_expr implicit type='ConcreteP' // CHECK-NEXT: call_expr implicit type="ConcreteP"
ConcreteP() ConcreteP()
} }
} }
@@ -95,11 +95,11 @@ class TestResultBuilder {
// CHECK-LABEL: class_decl{{.*}}DynamicReplacement // CHECK-LABEL: class_decl{{.*}}DynamicReplacement
class DynamicReplacement { class DynamicReplacement {
dynamic func testDynamicReplaceable() -> some P { dynamic func testDynamicReplaceable() -> some P {
// CHECK: underlying_to_opaque_expr implicit type='some P' // CHECK: underlying_to_opaque_expr implicit type="some P"
// CHECK-NEXT: call_expr implicit type='AnyP' // CHECK-NEXT: call_expr implicit type="AnyP"
// CHECK: argument_list implicit labels=erasing: // CHECK: argument_list implicit labels="erasing:"
// CHECK-NEXT: argument label=erasing // CHECK-NEXT: argument label="erasing"
// CHECK-NEXT: call_expr type='ConcreteP' // CHECK-NEXT: call_expr type="ConcreteP"
ConcreteP() ConcreteP()
} }
} }
@@ -111,11 +111,11 @@ extension DynamicReplacement {
func testDynamicReplacement() -> some P { func testDynamicReplacement() -> some P {
print("not single expr return") print("not single expr return")
// CHECK: return_stmt // CHECK: return_stmt
// CHECK-NEXT: underlying_to_opaque_expr implicit type='some P' // CHECK-NEXT: underlying_to_opaque_expr implicit type="some P"
// CHECK-NEXT: call_expr implicit type='AnyP' // CHECK-NEXT: call_expr implicit type="AnyP"
// CHECK: argument_list implicit labels=erasing: // CHECK: argument_list implicit labels="erasing:"
// CHECK-NEXT: argument label=erasing // CHECK-NEXT: argument label="erasing"
// CHECK-NEXT: call_expr type='ConcreteP' // CHECK-NEXT: call_expr type="ConcreteP"
return ConcreteP() return ConcreteP()
} }
} }

6
test/Sema/type_eraser_experimental_flag.swift
View File

@@ -11,7 +11,7 @@ struct ConcreteP: P, Hashable {}
// CHECK-LABEL: testTypeErased // CHECK-LABEL: testTypeErased
func testTypeErased() -> some P { func testTypeErased() -> some P {
// CHECK: underlying_to_opaque_expr{{.*}}'some P' // CHECK: underlying_to_opaque_expr{{.*}}"some P"
// CHECK-NEXT: call_expr implicit type='AnyP' // CHECK-NEXT: call_expr implicit type="AnyP"
ConcreteP() ConcreteP()
} }

4
test/attr/ApplicationMain/attr_main_throws.swift
View File

@@ -7,10 +7,10 @@ struct MyBase {
} }
} }
// CHECK-AST: (func_decl implicit "$main()" interface type='(MyBase.Type) -> () throws -> ()' access=internal type // CHECK-AST: (func_decl implicit "$main()" interface type="(MyBase.Type) -> () throws -> ()" access=internal type
// CHECK-AST-NEXT: (parameter "self") // CHECK-AST-NEXT: (parameter "self")
// CHECK-AST-NEXT: (parameter_list) // CHECK-AST-NEXT: (parameter_list)
// CHECK-AST-NEXT: (brace_stmt implicit // CHECK-AST-NEXT: (brace_stmt implicit
// CHECK-AST-NEXT: (return_stmt implicit // CHECK-AST-NEXT: (return_stmt implicit
// CHECK-AST-NEXT: (try_expr implicit // CHECK-AST-NEXT: (try_expr implicit
// CHECK-AST-NEXT: (call_expr implicit type='()' // CHECK-AST-NEXT: (call_expr implicit type="()"

32
test/attr/attr_fixed_layout.swift
View File

@@ -7,21 +7,21 @@
// Public types with @frozen are always fixed layout // Public types with @frozen are always fixed layout
// //
// RESILIENCE-ON: struct_decl{{.*}}"Point" interface type='Point.Type' access=public non-resilient // RESILIENCE-ON: struct_decl{{.*}}"Point" interface type="Point.Type" access=public non_resilient
// RESILIENCE-OFF: struct_decl{{.*}}"Point" interface type='Point.Type' access=public non-resilient // RESILIENCE-OFF: struct_decl{{.*}}"Point" interface type="Point.Type" access=public non_resilient
@frozen public struct Point { @frozen public struct Point {
let x, y: Int let x, y: Int
} }
// RESILIENCE-ON: struct_decl{{.*}}"FixedPoint" interface type='FixedPoint.Type' access=public non-resilient // RESILIENCE-ON: struct_decl{{.*}}"FixedPoint" interface type="FixedPoint.Type" access=public non_resilient
// RESILIENCE-OFF: struct_decl{{.*}}"FixedPoint" interface type='FixedPoint.Type' access=public non-resilient // RESILIENCE-OFF: struct_decl{{.*}}"FixedPoint" interface type="FixedPoint.Type" access=public non_resilient
@_fixed_layout public struct FixedPoint { @_fixed_layout public struct FixedPoint {
// expected-warning@-1 {{'@frozen' attribute is now used for fixed-layout structs}} // expected-warning@-1 {{'@frozen' attribute is now used for fixed-layout structs}}
let x, y: Int let x, y: Int
} }
// RESILIENCE-ON: enum_decl{{.*}}"ChooseYourOwnAdventure" interface type='ChooseYourOwnAdventure.Type' access=public non-resilient // RESILIENCE-ON: enum_decl{{.*}}"ChooseYourOwnAdventure" interface type="ChooseYourOwnAdventure.Type" access=public non_resilient
// RESILIENCE-OFF: enum_decl{{.*}}"ChooseYourOwnAdventure" interface type='ChooseYourOwnAdventure.Type' access=public non-resilient // RESILIENCE-OFF: enum_decl{{.*}}"ChooseYourOwnAdventure" interface type="ChooseYourOwnAdventure.Type" access=public non_resilient
@frozen public enum ChooseYourOwnAdventure { @frozen public enum ChooseYourOwnAdventure {
case JumpIntoRabbitHole case JumpIntoRabbitHole
case EatMushroom case EatMushroom
@@ -31,23 +31,23 @@
// Public types are resilient when -enable-library-evolution is on // Public types are resilient when -enable-library-evolution is on
// //
// RESILIENCE-ON: struct_decl{{.*}}"Size" interface type='Size.Type' access=public resilient // RESILIENCE-ON: struct_decl{{.*}}"Size" interface type="Size.Type" access=public resilient
// RESILIENCE-OFF: struct_decl{{.*}}"Size" interface type='Size.Type' access=public non-resilient // RESILIENCE-OFF: struct_decl{{.*}}"Size" interface type="Size.Type" access=public non_resilient
public struct Size { public struct Size {
let w, h: Int let w, h: Int
} }
// RESILIENCE-ON: struct_decl{{.*}}"UsableFromInlineStruct" interface type='UsableFromInlineStruct.Type' access=internal non-resilient // RESILIENCE-ON: struct_decl{{.*}}"UsableFromInlineStruct" interface type="UsableFromInlineStruct.Type" access=internal non_resilient
// RESILIENCE-OFF: struct_decl{{.*}}"UsableFromInlineStruct" interface type='UsableFromInlineStruct.Type' access=internal non-resilient // RESILIENCE-OFF: struct_decl{{.*}}"UsableFromInlineStruct" interface type="UsableFromInlineStruct.Type" access=internal non_resilient
@frozen @usableFromInline struct UsableFromInlineStruct {} @frozen @usableFromInline struct UsableFromInlineStruct {}
// RESILIENCE-ON: struct_decl{{.*}}"UsableFromInlineFixedStruct" interface type='UsableFromInlineFixedStruct.Type' access=internal non-resilient // RESILIENCE-ON: struct_decl{{.*}}"UsableFromInlineFixedStruct" interface type="UsableFromInlineFixedStruct.Type" access=internal non_resilient
// RESILIENCE-OFF: struct_decl{{.*}}"UsableFromInlineFixedStruct" interface type='UsableFromInlineFixedStruct.Type' access=internal non-resilient // RESILIENCE-OFF: struct_decl{{.*}}"UsableFromInlineFixedStruct" interface type="UsableFromInlineFixedStruct.Type" access=internal non_resilient
@_fixed_layout @usableFromInline struct UsableFromInlineFixedStruct {} @_fixed_layout @usableFromInline struct UsableFromInlineFixedStruct {}
// expected-warning@-1 {{'@frozen' attribute is now used for fixed-layout structs}} // expected-warning@-1 {{'@frozen' attribute is now used for fixed-layout structs}}
// RESILIENCE-ON: enum_decl{{.*}}"TaxCredit" interface type='TaxCredit.Type' access=public resilient // RESILIENCE-ON: enum_decl{{.*}}"TaxCredit" interface type="TaxCredit.Type" access=public resilient
// RESILIENCE-OFF: enum_decl{{.*}}"TaxCredit" interface type='TaxCredit.Type' access=public non-resilient // RESILIENCE-OFF: enum_decl{{.*}}"TaxCredit" interface type="TaxCredit.Type" access=public non_resilient
public enum TaxCredit { public enum TaxCredit {
case EarnedIncome case EarnedIncome
case MortgageDeduction case MortgageDeduction
@@ -57,8 +57,8 @@ public enum TaxCredit {
// Internal types are always fixed layout // Internal types are always fixed layout
// //
// RESILIENCE-ON: struct_decl{{.*}}"Rectangle" interface type='Rectangle.Type' access=internal non-resilient // RESILIENCE-ON: struct_decl{{.*}}"Rectangle" interface type="Rectangle.Type" access=internal non_resilient
// RESILIENCE-OFF: struct_decl{{.*}}"Rectangle" interface type='Rectangle.Type' access=internal non-resilient // RESILIENCE-OFF: struct_decl{{.*}}"Rectangle" interface type="Rectangle.Type" access=internal non_resilient
struct Rectangle { struct Rectangle {
let topLeft: Point let topLeft: Point
let bottomRight: Size let bottomRight: Size

188
test/attr/attr_native_dynamic.swift
View File

@@ -2,30 +2,30 @@
struct Strukt { struct Strukt {
// CHECK: (struct_decl {{.*}} "Strukt" // CHECK: (struct_decl {{.*}} "Strukt"
// CHECK: (var_decl {{.*}} "dynamicStorageOnlyVar" interface type='Int' access=internal dynamic readImpl=stored writeImpl=stored readWriteImpl=stored // CHECK: (var_decl {{.*}} "dynamicStorageOnlyVar" interface type="Int" access=internal dynamic readImpl=stored writeImpl=stored readWriteImpl=stored
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=dynamicStorageOnlyVar // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="dynamicStorageOnlyVar"
// CHECK: (accessor_decl {{.*}} access=internal dynamic set_for=dynamicStorageOnlyVar // CHECK: (accessor_decl {{.*}} access=internal dynamic set for="dynamicStorageOnlyVar"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=dynamicStorageOnlyVar // CHECK: (accessor_decl {{.*}} access=internal _modify for="dynamicStorageOnlyVar"
dynamic var dynamicStorageOnlyVar : Int = 0 dynamic var dynamicStorageOnlyVar : Int = 0
// CHECK: (var_decl {{.*}} "computedVar" interface type='Int' access=internal dynamic readImpl=getter immutable // CHECK: (var_decl {{.*}} "computedVar" interface type="Int" access=internal dynamic readImpl=getter immutable
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=computedVar // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="computedVar"
dynamic var computedVar : Int { dynamic var computedVar : Int {
return 0 return 0
} }
// CHECK: (var_decl {{.*}} "computedVar2" interface type='Int' access=internal dynamic readImpl=getter immutable // CHECK: (var_decl {{.*}} "computedVar2" interface type="Int" access=internal dynamic readImpl=getter immutable
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=computedVar2 // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="computedVar2"
dynamic var computedVar2 : Int { dynamic var computedVar2 : Int {
get { get {
return 0 return 0
} }
} }
// CHECK: (var_decl {{.*}} "computedVarGetterSetter" interface type='Int' access=internal dynamic readImpl=getter writeImpl=setter readWriteImpl=materialize_to_temporary // CHECK: (var_decl {{.*}} "computedVarGetterSetter" interface type="Int" access=internal dynamic readImpl=getter writeImpl=setter readWriteImpl=materialize_to_temporary
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=computedVarGetterSetter // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="computedVarGetterSetter"
// CHECK: (accessor_decl {{.*}} access=internal dynamic set_for=computedVarGetterSetter // CHECK: (accessor_decl {{.*}} access=internal dynamic set for="computedVarGetterSetter"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=computedVarGetterSetter // CHECK: (accessor_decl {{.*}} access=internal _modify for="computedVarGetterSetter"
dynamic var computedVarGetterSetter : Int { dynamic var computedVarGetterSetter : Int {
get { get {
return 0 return 0
@@ -34,10 +34,10 @@ struct Strukt {
} }
} }
// CHECK: (var_decl {{.*}} "computedVarGetterModify" interface type='Int' access=internal dynamic readImpl=getter writeImpl=modify_coroutine readWriteImpl=modify_coroutine // CHECK: (var_decl {{.*}} "computedVarGetterModify" interface type="Int" access=internal dynamic readImpl=getter writeImpl=modify_coroutine readWriteImpl=modify_coroutine
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=computedVarGetterModify // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="computedVarGetterModify"
// CHECK: (accessor_decl {{.*}} access=internal dynamic _modify_for=computedVarGetterModify // CHECK: (accessor_decl {{.*}} access=internal dynamic _modify for="computedVarGetterModify"
// CHECK: (accessor_decl {{.*}} access=internal set_for=computedVarGetterModify // CHECK: (accessor_decl {{.*}} access=internal set for="computedVarGetterModify"
dynamic var computedVarGetterModify : Int { dynamic var computedVarGetterModify : Int {
get { get {
return 0 return 0
@@ -46,11 +46,11 @@ struct Strukt {
} }
} }
// CHECK: (var_decl {{.*}} "computedVarReadSet" interface type='Int' access=internal dynamic readImpl=read_coroutine writeImpl=setter readWriteImpl=materialize_to_temporary // CHECK: (var_decl {{.*}} "computedVarReadSet" interface type="Int" access=internal dynamic readImpl=read_coroutine writeImpl=setter readWriteImpl=materialize_to_temporary
// CHECK: (accessor_decl {{.*}} access=internal dynamic _read_for=computedVarReadSet // CHECK: (accessor_decl {{.*}} access=internal dynamic _read for="computedVarReadSet"
// CHECK: (accessor_decl {{.*}} access=internal dynamic set_for=computedVarReadSet // CHECK: (accessor_decl {{.*}} access=internal dynamic set for="computedVarReadSet"
// CHECK: (accessor_decl {{.*}} access=internal get_for=computedVarReadSet // CHECK: (accessor_decl {{.*}} access=internal get for="computedVarReadSet"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=computedVarReadSet // CHECK: (accessor_decl {{.*}} access=internal _modify for="computedVarReadSet"
dynamic var computedVarReadSet : Int { dynamic var computedVarReadSet : Int {
_read { _read {
} }
@@ -58,11 +58,11 @@ struct Strukt {
} }
} }
// CHECK: (var_decl {{.*}} "computedVarReadModify" interface type='Int' access=internal dynamic readImpl=read_coroutine writeImpl=modify_coroutine readWriteImpl=modify_coroutine // CHECK: (var_decl {{.*}} "computedVarReadModify" interface type="Int" access=internal dynamic readImpl=read_coroutine writeImpl=modify_coroutine readWriteImpl=modify_coroutine
// CHECK: (accessor_decl {{.*}} access=internal dynamic _read_for=computedVarReadModify // CHECK: (accessor_decl {{.*}} access=internal dynamic _read for="computedVarReadModify"
// CHECK: (accessor_decl {{.*}} access=internal dynamic _modify_for=computedVarReadModify // CHECK: (accessor_decl {{.*}} access=internal dynamic _modify for="computedVarReadModify"
// CHECK: (accessor_decl {{.*}} access=internal get_for=computedVarReadModify // CHECK: (accessor_decl {{.*}} access=internal get for="computedVarReadModify"
// CHECK: (accessor_decl {{.*}} access=internal set_for=computedVarReadModify // CHECK: (accessor_decl {{.*}} access=internal set for="computedVarReadModify"
dynamic var computedVarReadModify : Int { dynamic var computedVarReadModify : Int {
_read { _read {
} }
@@ -70,11 +70,11 @@ struct Strukt {
} }
} }
// CHECK: (var_decl {{.*}} "storedWithObserver" interface type='Int' access=internal dynamic readImpl=stored writeImpl=stored_with_observers readWriteImpl=stored_with_didset // CHECK: (var_decl {{.*}} "storedWithObserver" interface type="Int" access=internal dynamic readImpl=stored writeImpl=stored_with_observers readWriteImpl=stored_with_didset
// CHECK: (accessor_decl {{.*}}access=private dynamic didSet_for=storedWithObserver // CHECK: (accessor_decl {{.*}}access=private dynamic didSet for="storedWithObserver"
// CHECK: (accessor_decl {{.*}}access=internal dynamic get_for=storedWithObserver // CHECK: (accessor_decl {{.*}}access=internal dynamic get for="storedWithObserver"
// CHECK: (accessor_decl {{.*}}access=internal set_for=storedWithObserver // CHECK: (accessor_decl {{.*}}access=internal set for="storedWithObserver"
// CHECK: (accessor_decl {{.*}}access=internal _modify_for=storedWithObserver // CHECK: (accessor_decl {{.*}}access=internal _modify for="storedWithObserver"
dynamic var storedWithObserver : Int { dynamic var storedWithObserver : Int {
didSet { didSet {
} }
@@ -86,9 +86,9 @@ struct Strukt {
} }
// CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=getter writeImpl=setter readWriteImpl=materialize_to_temporary // CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=getter writeImpl=setter readWriteImpl=materialize_to_temporary
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal dynamic set_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic set for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal _modify for="subscript(_:)"
dynamic subscript(_ index: Int) -> Int { dynamic subscript(_ index: Int) -> Int {
get { get {
return 1 return 1
@@ -98,9 +98,9 @@ struct Strukt {
} }
// CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=getter writeImpl=modify_coroutine readWriteImpl=modify_coroutine // CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=getter writeImpl=modify_coroutine readWriteImpl=modify_coroutine
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal dynamic _modify_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic _modify for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal set_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal set for="subscript(_:)"
dynamic subscript(_ index: Float) -> Int { dynamic subscript(_ index: Float) -> Int {
get { get {
return 1 return 1
@@ -110,10 +110,10 @@ struct Strukt {
} }
// CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=read_coroutine writeImpl=modify_coroutine readWriteImpl=modify_coroutine // CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=read_coroutine writeImpl=modify_coroutine readWriteImpl=modify_coroutine
// CHECK: (accessor_decl {{.*}} access=internal dynamic _read_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic _read for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal dynamic _modify_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic _modify for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal get_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal get for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal set_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal set for="subscript(_:)"
dynamic subscript(_ index: Double) -> Int { dynamic subscript(_ index: Double) -> Int {
_read { _read {
} }
@@ -122,10 +122,10 @@ struct Strukt {
} }
// CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=read_coroutine writeImpl=setter readWriteImpl=materialize_to_temporary // CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=read_coroutine writeImpl=setter readWriteImpl=materialize_to_temporary
// CHECK: (accessor_decl {{.*}} access=internal dynamic _read_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic _read for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal dynamic set_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic set for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal get_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal get for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal _modify for="subscript(_:)"
dynamic subscript(_ index: Strukt) -> Int { dynamic subscript(_ index: Strukt) -> Int {
_read { _read {
} }
@@ -136,30 +136,30 @@ struct Strukt {
class Klass { class Klass {
// CHECK: (class_decl {{.*}} "Klass" // CHECK: (class_decl {{.*}} "Klass"
// CHECK: (var_decl {{.*}} "dynamicStorageOnlyVar" interface type='Int' access=internal dynamic readImpl=stored writeImpl=stored readWriteImpl=stored // CHECK: (var_decl {{.*}} "dynamicStorageOnlyVar" interface type="Int" access=internal dynamic readImpl=stored writeImpl=stored readWriteImpl=stored
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=dynamicStorageOnlyVar // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="dynamicStorageOnlyVar"
// CHECK: (accessor_decl {{.*}} access=internal dynamic set_for=dynamicStorageOnlyVar // CHECK: (accessor_decl {{.*}} access=internal dynamic set for="dynamicStorageOnlyVar"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=dynamicStorageOnlyVar // CHECK: (accessor_decl {{.*}} access=internal _modify for="dynamicStorageOnlyVar"
dynamic var dynamicStorageOnlyVar : Int = 0 dynamic var dynamicStorageOnlyVar : Int = 0
// CHECK: (var_decl {{.*}} "computedVar" interface type='Int' access=internal dynamic readImpl=getter immutable // CHECK: (var_decl {{.*}} "computedVar" interface type="Int" access=internal dynamic readImpl=getter immutable
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=computedVar // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="computedVar"
dynamic var computedVar : Int { dynamic var computedVar : Int {
return 0 return 0
} }
// CHECK: (var_decl {{.*}} "computedVar2" interface type='Int' access=internal dynamic readImpl=getter immutable // CHECK: (var_decl {{.*}} "computedVar2" interface type="Int" access=internal dynamic readImpl=getter immutable
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=computedVar2 // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="computedVar2"
dynamic var computedVar2 : Int { dynamic var computedVar2 : Int {
get { get {
return 0 return 0
} }
} }
// CHECK: (var_decl {{.*}} "computedVarGetterSetter" interface type='Int' access=internal dynamic readImpl=getter writeImpl=setter readWriteImpl=materialize_to_temporary // CHECK: (var_decl {{.*}} "computedVarGetterSetter" interface type="Int" access=internal dynamic readImpl=getter writeImpl=setter readWriteImpl=materialize_to_temporary
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=computedVarGetterSetter // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="computedVarGetterSetter"
// CHECK: (accessor_decl {{.*}} access=internal dynamic set_for=computedVarGetterSetter // CHECK: (accessor_decl {{.*}} access=internal dynamic set for="computedVarGetterSetter"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=computedVarGetterSetter // CHECK: (accessor_decl {{.*}} access=internal _modify for="computedVarGetterSetter"
dynamic var computedVarGetterSetter : Int { dynamic var computedVarGetterSetter : Int {
get { get {
return 0 return 0
@@ -168,10 +168,10 @@ class Klass {
} }
} }
// CHECK: (var_decl {{.*}} "computedVarGetterModify" interface type='Int' access=internal dynamic readImpl=getter writeImpl=modify_coroutine readWriteImpl=modify_coroutine // CHECK: (var_decl {{.*}} "computedVarGetterModify" interface type="Int" access=internal dynamic readImpl=getter writeImpl=modify_coroutine readWriteImpl=modify_coroutine
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=computedVarGetterModify // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="computedVarGetterModify"
// CHECK: (accessor_decl {{.*}} access=internal dynamic _modify_for=computedVarGetterModify // CHECK: (accessor_decl {{.*}} access=internal dynamic _modify for="computedVarGetterModify"
// CHECK: (accessor_decl {{.*}} access=internal set_for=computedVarGetterModify // CHECK: (accessor_decl {{.*}} access=internal set for="computedVarGetterModify"
dynamic var computedVarGetterModify : Int { dynamic var computedVarGetterModify : Int {
get { get {
return 0 return 0
@@ -180,11 +180,11 @@ class Klass {
} }
} }
// CHECK: (var_decl {{.*}} "computedVarReadSet" interface type='Int' access=internal dynamic readImpl=read_coroutine writeImpl=setter readWriteImpl=materialize_to_temporary // CHECK: (var_decl {{.*}} "computedVarReadSet" interface type="Int" access=internal dynamic readImpl=read_coroutine writeImpl=setter readWriteImpl=materialize_to_temporary
// CHECK: (accessor_decl {{.*}} access=internal dynamic _read_for=computedVarReadSet // CHECK: (accessor_decl {{.*}} access=internal dynamic _read for="computedVarReadSet"
// CHECK: (accessor_decl {{.*}} access=internal dynamic set_for=computedVarReadSet // CHECK: (accessor_decl {{.*}} access=internal dynamic set for="computedVarReadSet"
// CHECK: (accessor_decl {{.*}} access=internal get_for=computedVarReadSet // CHECK: (accessor_decl {{.*}} access=internal get for="computedVarReadSet"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=computedVarReadSet // CHECK: (accessor_decl {{.*}} access=internal _modify for="computedVarReadSet"
dynamic var computedVarReadSet : Int { dynamic var computedVarReadSet : Int {
_read { _read {
} }
@@ -192,11 +192,11 @@ class Klass {
} }
} }
// CHECK: (var_decl {{.*}} "computedVarReadModify" interface type='Int' access=internal dynamic readImpl=read_coroutine writeImpl=modify_coroutine readWriteImpl=modify_coroutine // CHECK: (var_decl {{.*}} "computedVarReadModify" interface type="Int" access=internal dynamic readImpl=read_coroutine writeImpl=modify_coroutine readWriteImpl=modify_coroutine
// CHECK: (accessor_decl {{.*}} access=internal dynamic _read_for=computedVarReadModify // CHECK: (accessor_decl {{.*}} access=internal dynamic _read for="computedVarReadModify"
// CHECK: (accessor_decl {{.*}} access=internal dynamic _modify_for=computedVarReadModify // CHECK: (accessor_decl {{.*}} access=internal dynamic _modify for="computedVarReadModify"
// CHECK: (accessor_decl {{.*}} access=internal get_for=computedVarReadModify // CHECK: (accessor_decl {{.*}} access=internal get for="computedVarReadModify"
// CHECK: (accessor_decl {{.*}} access=internal set_for=computedVarReadModify // CHECK: (accessor_decl {{.*}} access=internal set for="computedVarReadModify"
dynamic var computedVarReadModify : Int { dynamic var computedVarReadModify : Int {
_read { _read {
} }
@@ -214,10 +214,10 @@ class Klass {
} }
// CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=addressor writeImpl=mutable_addressor readWriteImpl=mutable_addressor // CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=addressor writeImpl=mutable_addressor readWriteImpl=mutable_addressor
// CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeAddress_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeAddress for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeMutableAddress_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeMutableAddress for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal get_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal get for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal set_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal set for="subscript(_:)"
dynamic subscript(_ index: Int) -> Int { dynamic subscript(_ index: Int) -> Int {
unsafeAddress { unsafeAddress {
fatalError() fatalError()
@@ -228,10 +228,10 @@ class Klass {
} }
// CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=getter writeImpl=mutable_addressor readWriteImpl=mutable_addressor // CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=getter writeImpl=mutable_addressor readWriteImpl=mutable_addressor
// CHECK: (accessor_decl {{.*}} access=internal dynamic get_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic get for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeMutableAddress_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeMutableAddress for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal set_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal set for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal _modify for="subscript(_:)"
dynamic subscript(_ index: Float) -> Int { dynamic subscript(_ index: Float) -> Int {
get { get {
return 1 return 1
@@ -242,11 +242,11 @@ class Klass {
} }
// CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=read_coroutine writeImpl=mutable_addressor readWriteImpl=mutable_addressor // CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=read_coroutine writeImpl=mutable_addressor readWriteImpl=mutable_addressor
// CHECK: (accessor_decl {{.*}} access=internal dynamic _read_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic _read for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeMutableAddress_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeMutableAddress for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal get_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal get for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal set_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal set for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal _modify for="subscript(_:)"
dynamic subscript(_ index: Double) -> Int { dynamic subscript(_ index: Double) -> Int {
_read { _read {
} }
@@ -256,10 +256,10 @@ class Klass {
} }
// CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=addressor writeImpl=setter readWriteImpl=materialize_to_temporary // CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=addressor writeImpl=setter readWriteImpl=materialize_to_temporary
// CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeAddress_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeAddress for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal dynamic set_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic set for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal get_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal get for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal _modify_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal _modify for="subscript(_:)"
dynamic subscript(_ index: Int8) -> Int { dynamic subscript(_ index: Int8) -> Int {
unsafeAddress { unsafeAddress {
fatalError() fatalError()
@@ -269,10 +269,10 @@ class Klass {
} }
// CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=addressor writeImpl=modify_coroutine readWriteImpl=modify_coroutine // CHECK: (subscript_decl {{.*}} "subscript(_:)" {{.*}} access=internal dynamic readImpl=addressor writeImpl=modify_coroutine readWriteImpl=modify_coroutine
// CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeAddress_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic unsafeAddress for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal dynamic _modify_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal dynamic _modify for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal get_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal get for="subscript(_:)"
// CHECK: (accessor_decl {{.*}} access=internal set_for=subscript(_:) // CHECK: (accessor_decl {{.*}} access=internal set for="subscript(_:)"
dynamic subscript(_ index: Int16) -> Int { dynamic subscript(_ index: Int16) -> Int {
unsafeAddress { unsafeAddress {
fatalError() fatalError()
@@ -285,12 +285,12 @@ class Klass {
class SubKlass : Klass { class SubKlass : Klass {
// CHECK: (class_decl {{.*}} "SubKlass" // CHECK: (class_decl {{.*}} "SubKlass"
// CHECK: (func_decl {{.*}} "aMethod(arg:)" interface type='(SubKlass) -> (Int) -> Int' access=internal {{.*}} dynamic // CHECK: (func_decl {{.*}} "aMethod(arg:)" interface type="(SubKlass) -> (Int) -> Int" access=internal {{.*}} dynamic
override dynamic func aMethod(arg: Int) -> Int { override dynamic func aMethod(arg: Int) -> Int {
return 23 return 23
} }
// CHECK: (func_decl {{.*}} "anotherMethod()" interface type='(SubKlass) -> () -> Int' access=internal {{.*}} dynamic // CHECK: (func_decl {{.*}} "anotherMethod()" interface type="(SubKlass) -> () -> Int" access=internal {{.*}} dynamic
override dynamic func anotherMethod() -> Int { override dynamic func anotherMethod() -> Int {
return 23 return 23
} }

27
test/attr/attr_objc.swift
View File

@@ -2319,11 +2319,13 @@ class ClassThrows1 {
@objc // access-note-move{{ImplicitClassThrows1}} @objc // access-note-move{{ImplicitClassThrows1}}
class ImplicitClassThrows1 { class ImplicitClassThrows1 {
// CHECK: @objc func methodReturnsVoid() throws // CHECK: @objc func methodReturnsVoid() throws
// CHECK-DUMP: func_decl{{.*}}"methodReturnsVoid()"{{.*}}foreign_error=ZeroResult,unowned,param=0,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool // CHECK-DUMP-LABEL: func_decl{{.*}}"methodReturnsVoid()"
// CHECK-DUMP: (foreign_error_convention kind=ZeroResult unowned param=0 paramtype="Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>" resulttype="ObjCBool")
func methodReturnsVoid() throws { } func methodReturnsVoid() throws { }
// CHECK: @objc func methodReturnsObjCClass() throws -> Class_ObjC1 // CHECK: @objc func methodReturnsObjCClass() throws -> Class_ObjC1
// CHECK-DUMP: func_decl{{.*}}"methodReturnsObjCClass()" {{.*}}foreign_error=NilResult,unowned,param=0,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>> // CHECK-DUMP-LABEL: func_decl{{.*}}"methodReturnsObjCClass()"
// CHECK-DUMP: (foreign_error_convention kind=NilResult unowned param=0 paramtype="Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>")
func methodReturnsObjCClass() throws -> Class_ObjC1 { func methodReturnsObjCClass() throws -> Class_ObjC1 {
return Class_ObjC1() return Class_ObjC1()
} }
@@ -2338,11 +2340,13 @@ class ImplicitClassThrows1 {
func methodReturnsOptionalObjCClass() throws -> Class_ObjC1? { return nil } func methodReturnsOptionalObjCClass() throws -> Class_ObjC1? { return nil }
// CHECK: @objc func methodWithTrailingClosures(_ s: String, fn1: @escaping ((Int) -> Int), fn2: @escaping (Int) -> Int, fn3: @escaping (Int) -> Int) // CHECK: @objc func methodWithTrailingClosures(_ s: String, fn1: @escaping ((Int) -> Int), fn2: @escaping (Int) -> Int, fn3: @escaping (Int) -> Int)
// CHECK-DUMP: func_decl{{.*}}"methodWithTrailingClosures(_:fn1:fn2:fn3:)"{{.*}}foreign_error=ZeroResult,unowned,param=1,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool // CHECK-DUMP-LABEL: func_decl{{.*}}"methodWithTrailingClosures(_:fn1:fn2:fn3:)"
// CHECK-DUMP: (foreign_error_convention kind=ZeroResult unowned param=1 paramtype="Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>" resulttype="ObjCBool")
func methodWithTrailingClosures(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int, fn3: @escaping (Int) -> Int) throws { } func methodWithTrailingClosures(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int, fn3: @escaping (Int) -> Int) throws { }
// CHECK: @objc init(degrees: Double) throws // CHECK: @objc init(degrees: Double) throws
// CHECK-DUMP: constructor_decl{{.*}}"init(degrees:)"{{.*}}foreign_error=NilResult,unowned,param=1,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>> // CHECK-DUMP-LABEL: constructor_decl{{.*}}"init(degrees:)"
// CHECK-DUMP: (foreign_error_convention kind=NilResult unowned param=1 paramtype="Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>")
init(degrees: Double) throws { } init(degrees: Double) throws { }
// CHECK: {{^}} func methodReturnsBridgedValueType() throws -> NSRange // CHECK: {{^}} func methodReturnsBridgedValueType() throws -> NSRange
@@ -2369,7 +2373,8 @@ class ImplicitClassThrows1 {
@objc // access-note-move{{SubclassImplicitClassThrows1}} @objc // access-note-move{{SubclassImplicitClassThrows1}}
class SubclassImplicitClassThrows1 : ImplicitClassThrows1 { class SubclassImplicitClassThrows1 : ImplicitClassThrows1 {
// CHECK: @objc override func methodWithTrailingClosures(_ s: String, fn1: @escaping ((Int) -> Int), fn2: @escaping ((Int) -> Int), fn3: @escaping ((Int) -> Int)) // CHECK: @objc override func methodWithTrailingClosures(_ s: String, fn1: @escaping ((Int) -> Int), fn2: @escaping ((Int) -> Int), fn3: @escaping ((Int) -> Int))
// CHECK-DUMP: func_decl{{.*}}"methodWithTrailingClosures(_:fn1:fn2:fn3:)"{{.*}}foreign_error=ZeroResult,unowned,param=1,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool // CHECK-DUMP-LABEL: func_decl{{.*}}"methodWithTrailingClosures(_:fn1:fn2:fn3:)"
// CHECK-DUMP: (foreign_error_convention kind=ZeroResult unowned param=1 paramtype="Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>" resulttype="ObjCBool")
override func methodWithTrailingClosures(_ s: String, fn1: (@escaping (Int) -> Int), fn2: (@escaping (Int) -> Int), fn3: (@escaping (Int) -> Int)) throws { } override func methodWithTrailingClosures(_ s: String, fn1: (@escaping (Int) -> Int), fn2: (@escaping (Int) -> Int), fn3: (@escaping (Int) -> Int)) throws { }
} }
@@ -2418,20 +2423,24 @@ class ThrowsObjCName {
@objc(method7) // bad-access-note-move{{ThrowsObjCName.method7(x:)}} expected-error{{'@objc' method name provides names for 0 arguments, but method has 2 parameters (including the error parameter)}} @objc(method7) // bad-access-note-move{{ThrowsObjCName.method7(x:)}} expected-error{{'@objc' method name provides names for 0 arguments, but method has 2 parameters (including the error parameter)}}
func method7(x: Int) throws { } func method7(x: Int) throws { }
// CHECK-DUMP: func_decl{{.*}}"method8(_:fn1:fn2:)"{{.*}}foreign_error=ZeroResult,unowned,param=2,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool // CHECK-DUMP-LABEL: func_decl{{.*}}"method8(_:fn1:fn2:)"
// CHECK-DUMP: (foreign_error_convention kind=ZeroResult unowned param=2 paramtype="Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>" resulttype="ObjCBool")
@objc(method8:fn1:error:fn2:) // access-note-move{{ThrowsObjCName.method8(_:fn1:fn2:)}} @objc(method8:fn1:error:fn2:) // access-note-move{{ThrowsObjCName.method8(_:fn1:fn2:)}}
func method8(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { } func method8(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { }
// CHECK-DUMP: func_decl{{.*}}"method9(_:fn1:fn2:)"{{.*}}foreign_error=ZeroResult,unowned,param=0,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool // CHECK-DUMP-LABEL: func_decl{{.*}}"method9(_:fn1:fn2:)"
// CHECK-DUMP: (foreign_error_convention kind=ZeroResult unowned param=0 paramtype="Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>" resulttype="ObjCBool")
@objc(method9AndReturnError:s:fn1:fn2:) // access-note-move{{ThrowsObjCName.method9(_:fn1:fn2:)}} @objc(method9AndReturnError:s:fn1:fn2:) // access-note-move{{ThrowsObjCName.method9(_:fn1:fn2:)}}
func method9(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { } func method9(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { }
} }
class SubclassThrowsObjCName : ThrowsObjCName { class SubclassThrowsObjCName : ThrowsObjCName {
// CHECK-DUMP: func_decl{{.*}}"method8(_:fn1:fn2:)"{{.*}}foreign_error=ZeroResult,unowned,param=2,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool // CHECK-DUMP-LABEL: func_decl{{.*}}"method8(_:fn1:fn2:)"
// CHECK-DUMP: (foreign_error_convention kind=ZeroResult unowned param=2 paramtype="Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>" resulttype="ObjCBool")
override func method8(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { } override func method8(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { }
// CHECK-DUMP: func_decl{{.*}}"method9(_:fn1:fn2:)"{{.*}}foreign_error=ZeroResult,unowned,param=0,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool // CHECK-DUMP-LABEL: func_decl{{.*}}"method9(_:fn1:fn2:)"
// CHECK-DUMP: (foreign_error_convention kind=ZeroResult unowned param=0 paramtype="Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>" resulttype="ObjCBool")
override func method9(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { } override func method9(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { }
} }

30
test/attr/attr_objc_async.swift
View File

@@ -8,13 +8,15 @@ import Foundation
// CHECK: class MyClass // CHECK: class MyClass
class MyClass { class MyClass {
// CHECK: @objc func doBigJob() async -> Int // CHECK: @objc func doBigJobClass() async -> Int
// CHECK-DUMP: func_decl{{.*}}doBigJob{{.*}}foreign_async=@convention(block) (Int) -> (),completion_handler_param=0 // CHECK-DUMP-LABEL: func_decl{{.*}}doBigJobClass{{.*}}
@objc func doBigJob() async -> Int { return 0 } // CHECK-DUMP: (foreign_async_convention completion_handler_type="@convention(block) (Int) -> ()" completion_handler_param=0)
@objc func doBigJobClass() async -> Int { return 0 }
// CHECK: @objc func doBigJobOrFail(_: Int) async throws -> (AnyObject, Int) // CHECK: @objc func doBigJobOrFailClass(_: Int) async throws -> (AnyObject, Int)
// CHECK-DUMP: func_decl{{.*}}doBigJobOrFail{{.*}}foreign_async=@convention(block) (Optional<AnyObject>, Int, Optional<any Error>) -> (),completion_handler_param=1,error_param=2 // CHECK-DUMP-LABEL: func_decl{{.*}}doBigJobOrFailClass{{.*}}
@objc func doBigJobOrFail(_: Int) async throws -> (AnyObject, Int) { return (self, 0) } // CHECK-DUMP: (foreign_async_convention completion_handler_type="@convention(block) (Optional<AnyObject>, Int, Optional<any Error>) -> ()" completion_handler_param=1 error_param=2)
@objc func doBigJobOrFailClass(_: Int) async throws -> (AnyObject, Int) { return (self, 0) }
@objc func takeAnAsync(_ fn: () async -> Int) { } // expected-error{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}} @objc func takeAnAsync(_ fn: () async -> Int) { } // expected-error{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-1{{'async' function types cannot be represented in Objective-C}} // expected-note@-1{{'async' function types cannot be represented in Objective-C}}
@@ -27,14 +29,16 @@ class MyClass {
// CHECK: actor MyActor // CHECK: actor MyActor
actor MyActor { actor MyActor {
// CHECK: @objc func doBigJob() async -> Int // CHECK: @objc func doBigJobActor() async -> Int
// CHECK-DUMP: func_decl{{.*}}doBigJob{{.*}}foreign_async=@convention(block) (Int) -> (),completion_handler_param=0 // CHECK-DUMP-LABEL: func_decl{{.*}}doBigJobActor{{.*}}
@objc func doBigJob() async -> Int { return 0 } // CHECK-DUMP: (foreign_async_convention completion_handler_type="@convention(block) (Int) -> ()" completion_handler_param=0)
@objc func doBigJobActor() async -> Int { return 0 }
// CHECK: @objc func doBigJobOrFail(_: Int) async throws -> (AnyObject, Int) // CHECK: @objc func doBigJobOrFailActor(_: Int) async throws -> (AnyObject, Int)
// CHECK-DUMP: func_decl{{.*}}doBigJobOrFail{{.*}}foreign_async=@convention(block) (Optional<AnyObject>, Int, Optional<any Error>) -> (),completion_handler_param=1,error_param=2 // CHECK-DUMP-LABEL: func_decl{{.*}}doBigJobOrFailActor{{.*}}
@objc func doBigJobOrFail(_: Int) async throws -> (AnyObject, Int) { return (self, 0) } // CHECK-DUMP: (foreign_async_convention completion_handler_type="@convention(block) (Optional<AnyObject>, Int, Optional<any Error>) -> ()" completion_handler_param=1 error_param=2)
// expected-warning@-1{{non-sendable type '(AnyObject, Int)' returned by actor-isolated '@objc' instance method 'doBigJobOrFail' cannot cross actor boundary}} @objc func doBigJobOrFailActor(_: Int) async throws -> (AnyObject, Int) { return (self, 0) }
// expected-warning@-1{{non-sendable type '(AnyObject, Int)' returned by actor-isolated '@objc' instance method 'doBigJobOrFailActor' cannot cross actor boundary}}
// Actor-isolated entities cannot be exposed to Objective-C. // Actor-isolated entities cannot be exposed to Objective-C.
@objc func synchronousBad() { } // expected-error{{actor-isolated instance method 'synchronousBad()' cannot be @objc}} @objc func synchronousBad() { } // expected-error{{actor-isolated instance method 'synchronousBad()' cannot be @objc}}

6
test/decl/protocol/associated_type_overrides.swift
View File

@@ -5,7 +5,7 @@ protocol P1 {
} }
// CHECK-LABEL: (protocol{{.*}}"P2" // CHECK-LABEL: (protocol{{.*}}"P2"
// CHECK-NEXT: (associated_type_decl{{.*}}"A" {{.*}} overridden=P1)) // CHECK-NEXT: (associated_type_decl{{.*}}"A" {{.*}} overridden="P1"))
protocol P2 : P1 { protocol P2 : P1 {
associatedtype A associatedtype A
} }
@@ -15,13 +15,13 @@ protocol P3 {
} }
// CHECK-LABEL: (protocol{{.*}}"P4" // CHECK-LABEL: (protocol{{.*}}"P4"
// CHECK-NEXT: (associated_type_decl{{.*}}"A" {{.*}} overridden=P2, P3)) // CHECK-NEXT: (associated_type_decl{{.*}}"A" {{.*}} overridden="P2, P3"))
protocol P4 : P2, P3 { protocol P4 : P2, P3 {
associatedtype A associatedtype A
} }
// CHECK-LABEL: (protocol{{.*}}"P5" // CHECK-LABEL: (protocol{{.*}}"P5"
// CHECK-NEXT: (associated_type_decl{{.*}}"A" {{.*}} overridden=P4)) // CHECK-NEXT: (associated_type_decl{{.*}}"A" {{.*}} overridden="P4"))
protocol P5 : P4, P2 { protocol P5 : P4, P2 {
associatedtype A associatedtype A
} }

12
test/decl/protocol/override.swift
View File

@@ -17,7 +17,7 @@ protocol P0 {
// CHECK: protocol{{.*}}"P1" // CHECK: protocol{{.*}}"P1"
protocol P1: P0 { protocol P1: P0 {
// CHECK: associated_type_decl // CHECK: associated_type_decl
// CHECK-SAME: overridden=P0 // CHECK-SAME: overridden="P0"
associatedtype A associatedtype A
// CHECK: func_decl{{.*}}foo(){{.*}}Self : P1{{.*}}override={{.*}}P0.foo // CHECK: func_decl{{.*}}foo(){{.*}}Self : P1{{.*}}override={{.*}}P0.foo
@@ -25,7 +25,7 @@ protocol P1: P0 {
// CHECK: var_decl // CHECK: var_decl
// CHECK-SAME: "prop" // CHECK-SAME: "prop"
// CHECK-SAME: override=override.(file).P0.prop // CHECK-SAME: override="override.(file).P0.prop
var prop: A { get } var prop: A { get }
} }
@@ -42,7 +42,7 @@ protocol P2 {
protocol P3: P1, P2 { protocol P3: P1, P2 {
// CHECK: associated_type_decl // CHECK: associated_type_decl
// CHECK-SAME: "A" // CHECK-SAME: "A"
// CHECK-SAME: override=override.(file).P1.A // CHECK-SAME: override="override.(file).P1.A
// CHECK-SAME: override.(file).P2.A // CHECK-SAME: override.(file).P2.A
associatedtype A associatedtype A
@@ -51,7 +51,7 @@ protocol P3: P1, P2 {
// CHECK: var_decl // CHECK: var_decl
// CHECK-SAME: "prop" // CHECK-SAME: "prop"
// CHECK-SAME: override=override.(file).P2.prop // CHECK-SAME: override="override.(file).P2.prop
// CHECK-SAME: override.(file).P1.prop // CHECK-SAME: override.(file).P1.prop
var prop: A { get } var prop: A { get }
} }
@@ -79,7 +79,7 @@ protocol P5: P0 where Self.A == Int {
// CHECK: var_decl // CHECK: var_decl
// CHECK-SAME: "prop" // CHECK-SAME: "prop"
// CHECK-SAME: override=override.(file).P0.prop // CHECK-SAME: override="override.(file).P0.prop
var prop: Int { get } var prop: Int { get }
} }
@@ -91,7 +91,7 @@ protocol P6: P0 {
// CHECK: var_decl // CHECK: var_decl
// CHECK-SAME: "prop" // CHECK-SAME: "prop"
// CHECK-SAME: override=override.(file).P0.prop // CHECK-SAME: override="override.(file).P0.prop
override var prop: A { get } override var prop: A { get }
} }

14
test/decl/protocol/req/existentials_covariant_erasure.swift
View File

@@ -1,6 +1,6 @@
// RUN: %target-swift-frontend -typecheck -dump-ast %s | %FileCheck %s // RUN: %target-swift-frontend -typecheck -dump-ast %s | %FileCheck %s
// Test that covariant 'Self' references get erased to the existential base type // Test that covariant "Self" references get erased to the existential base type
// when operating on existential values. // when operating on existential values.
class C {} class C {}
@@ -34,11 +34,11 @@ do {
let x5 = pc.lotsOfSelfFunc let x5 = pc.lotsOfSelfFunc
let x6 = pc.lotsOfSelfProp let x6 = pc.lotsOfSelfProp
// CHECK: (pattern_named type='((any P) -> Void, ((any P)?) -> Void, ([any P]) -> Void, ([Array<any P>?]) -> Void) -> [String : () -> any P]' 'x1') // CHECK: (pattern_named type="((any P) -> Void, ((any P)?) -> Void, ([any P]) -> Void, ([Array<any P>?]) -> Void) -> [String : () -> any P]" "x1")
// CHECK: (pattern_named type='((any P) -> Void, ((any P)?) -> Void, ([any P]) -> Void, ([Array<any P>?]) -> Void) -> [String : () -> any P]' 'x2') // CHECK: (pattern_named type="((any P) -> Void, ((any P)?) -> Void, ([any P]) -> Void, ([Array<any P>?]) -> Void) -> [String : () -> any P]" "x2")
// CHECK: (pattern_named type='((any P & Q) -> Void, ((any P & Q)?) -> Void, ([any P & Q]) -> Void, ([Array<any P & Q>?]) -> Void) -> [String : () -> any P & Q]' 'x3') // CHECK: (pattern_named type="((any P & Q) -> Void, ((any P & Q)?) -> Void, ([any P & Q]) -> Void, ([Array<any P & Q>?]) -> Void) -> [String : () -> any P & Q]" "x3")
// CHECK: (pattern_named type='((any P & Q) -> Void, ((any P & Q)?) -> Void, ([any P & Q]) -> Void, ([Array<any P & Q>?]) -> Void) -> [String : () -> any P & Q]' 'x4') // CHECK: (pattern_named type="((any P & Q) -> Void, ((any P & Q)?) -> Void, ([any P & Q]) -> Void, ([Array<any P & Q>?]) -> Void) -> [String : () -> any P & Q]" "x4")
// CHECK: (pattern_named type='((any C & P) -> Void, ((any C & P)?) -> Void, ([any C & P]) -> Void, ([Array<any C & P>?]) -> Void) -> [String : () -> any C & P]' 'x5') // CHECK: (pattern_named type="((any C & P) -> Void, ((any C & P)?) -> Void, ([any C & P]) -> Void, ([Array<any C & P>?]) -> Void) -> [String : () -> any C & P]" "x5")
// CHECK: (pattern_named type='((any C & P) -> Void, ((any C & P)?) -> Void, ([any C & P]) -> Void, ([Array<any C & P>?]) -> Void) -> [String : () -> any C & P]' 'x6') // CHECK: (pattern_named type="((any C & P) -> Void, ((any C & P)?) -> Void, ([any C & P]) -> Void, ([Array<any C & P>?]) -> Void) -> [String : () -> any C & P]" "x6")
} }
} }

20
test/decl/var/property_wrappers_synthesis.swift
View File

@@ -13,21 +13,21 @@ protocol DefaultInit {
struct UseWrapper<T: DefaultInit> { struct UseWrapper<T: DefaultInit> {
// CHECK: var_decl{{.*}}"wrapped" // CHECK: var_decl{{.*}}"wrapped"
// CHECK: accessor_decl{{.*}}get_for=wrapped // CHECK: accessor_decl{{.*}}get for="wrapped"
// CHECK: member_ref_expr{{.*}}UseWrapper._wrapped // CHECK: member_ref_expr{{.*}}UseWrapper._wrapped
// CHECK: accessor_decl{{.*}}set_for=wrapped // CHECK: accessor_decl{{.*}}set for="wrapped"
// CHECK: member_ref_expr{{.*}}UseWrapper._wrapped // CHECK: member_ref_expr{{.*}}UseWrapper._wrapped
// CHECK: accessor_decl{{.*}}_modify_for=wrapped // CHECK: accessor_decl{{.*}}_modify for="wrapped"
// CHECK: yield_stmt // CHECK: yield_stmt
// CHECK: member_ref_expr{{.*}}Wrapper.wrappedValue // CHECK: member_ref_expr{{.*}}Wrapper.wrappedValue
@Wrapper @Wrapper
var wrapped = T() var wrapped = T()
// CHECK: pattern_binding_decl implicit // CHECK: pattern_binding_decl implicit
// CHECK-NEXT: pattern_typed implicit type='Wrapper<T>' // CHECK-NEXT: pattern_typed implicit type="Wrapper<T>"
// CHECK-NEXT: pattern_named implicit type='Wrapper<T>' '_wrapped' // CHECK-NEXT: pattern_named implicit type="Wrapper<T>" "_wrapped"
// CHECK: constructor_ref_call_expr // CHECK: constructor_ref_call_expr
// CHECK-NEXT: declref_expr{{.*}}Wrapper.init(wrappedValue:) // CHECK-NEXT: declref_expr{{.*}}Wrapper.init(wrappedValue:)
init() { } init() { }
@@ -36,7 +36,7 @@ struct UseWrapper<T: DefaultInit> {
struct UseWillSetDidSet { struct UseWillSetDidSet {
// CHECK: var_decl{{.*}}"z" // CHECK: var_decl{{.*}}"z"
// CHECK: accessor_decl{{.*}}set_for=z // CHECK: accessor_decl{{.*}}set for="z"
// CHECK: member_ref_expr{{.*}}UseWillSetDidSet._z // CHECK: member_ref_expr{{.*}}UseWillSetDidSet._z
@Wrapper @Wrapper
var z: Int { var z: Int {
@@ -81,10 +81,10 @@ struct Observable<Value> {
class MyObservedType { class MyObservedType {
@Observable var observedProperty = 17 @Observable var observedProperty = 17
// CHECK: accessor_decl{{.*}}get_for=observedProperty // CHECK: accessor_decl{{.*}}get for="observedProperty"
// CHECK: subscript_expr implicit type='@lvalue Int' decl={{.*}}.Observable.subscript(_enclosingInstance:wrapped:storage:) // CHECK: subscript_expr implicit type="@lvalue Int" decl="{{.*}}.Observable.subscript(_enclosingInstance:wrapped:storage:)@
// CHECK: accessor_decl{{.*}}set_for=observedProperty // CHECK: accessor_decl{{.*}}set for="observedProperty"
// CHECK: subscript_expr implicit type='@lvalue Int' decl={{.*}}.Observable.subscript(_enclosingInstance:wrapped:storage:) // CHECK: subscript_expr implicit type="@lvalue Int" decl="{{.*}}.Observable.subscript(_enclosingInstance:wrapped:storage:)@
} }

4
test/expr/capture/dynamic_self.swift
View File

@@ -1,10 +1,10 @@
// RUN: %target-swift-frontend -dump-ast %s | %FileCheck %s // RUN: %target-swift-frontend -dump-ast %s | %FileCheck %s
// CHECK: func_decl{{.*}}"clone()" interface type='(Android) -> () -> Self' // CHECK: func_decl{{.*}}"clone()" interface type="(Android) -> () -> Self"
class Android { class Android {
func clone() -> Self { func clone() -> Self {
// CHECK: closure_expr type='() -> Self' {{.*}} discriminator=0 captures=(<dynamic_self> self<direct>) // CHECK: closure_expr type="() -> Self" {{.*}} discriminator=0 captures=(<dynamic_self> self<direct>)
let fn = { return self } let fn = { return self }
return fn() return fn()
} }

14
test/expr/capture/generic_params.swift
View File

@@ -2,33 +2,33 @@
func doSomething<T>(_ t: T) {} func doSomething<T>(_ t: T) {}
// CHECK: func_decl{{.*}}"outerGeneric(t:x:)" <T> interface type='<T> (t: T, x: AnyObject) -> ()' // CHECK: func_decl{{.*}}"outerGeneric(t:x:)" "<T>" interface type="<T> (t: T, x: AnyObject) -> ()"
func outerGeneric<T>(t: T, x: AnyObject) { func outerGeneric<T>(t: T, x: AnyObject) {
// Simple case -- closure captures outer generic parameter // Simple case -- closure captures outer generic parameter
// CHECK: closure_expr type='() -> ()' {{.*}} discriminator=0 captures=(<generic> t<direct>) escaping single-expression // CHECK: closure_expr type="() -> ()" {{.*}} discriminator=0 captures=(<generic> t<direct>) escaping single_expression
_ = { doSomething(t) } _ = { doSomething(t) }
// Special case -- closure does not capture outer generic parameters // Special case -- closure does not capture outer generic parameters
// CHECK: closure_expr type='() -> ()' {{.*}} discriminator=1 captures=(x<direct>) escaping single-expression // CHECK: closure_expr type="() -> ()" {{.*}} discriminator=1 captures=(x<direct>) escaping single_expression
_ = { doSomething(x) } _ = { doSomething(x) }
// Special case -- closure captures outer generic parameter, but it does not // Special case -- closure captures outer generic parameter, but it does not
// appear as the type of any expression // appear as the type of any expression
// CHECK: closure_expr type='() -> ()' {{.*}} discriminator=2 captures=(<generic> x<direct>) // CHECK: closure_expr type="() -> ()" {{.*}} discriminator=2 captures=(<generic> x<direct>)
_ = { if x is T {} } _ = { if x is T {} }
// Nested generic functions always capture outer generic parameters, even if // Nested generic functions always capture outer generic parameters, even if
// they're not mentioned in the function body // they're not mentioned in the function body
// CHECK: func_decl{{.*}}"innerGeneric(u:)" <U> interface type='<T, U> (u: U) -> ()' {{.*}} captures=(<generic> ) // CHECK: func_decl{{.*}}"innerGeneric(u:)" "<U>" interface type="<T, U> (u: U) -> ()" {{.*}} captures=(<generic> )
func innerGeneric<U>(u: U) {} func innerGeneric<U>(u: U) {}
// Make sure we look through typealiases // Make sure we look through typealiases
typealias TT = (a: T, b: T) typealias TT = (a: T, b: T)
// CHECK: func_decl{{.*}}"localFunction(tt:)" interface type='<T> (tt: TT) -> ()' {{.*}} captures=(<generic> ) // CHECK: func_decl{{.*}}"localFunction(tt:)" interface type="<T> (tt: TT) -> ()" {{.*}} captures=(<generic> )
func localFunction(tt: TT) {} func localFunction(tt: TT) {}
// CHECK: closure_expr type='(TT) -> ()' {{.*}} captures=(<generic> ) // CHECK: closure_expr type="(TT) -> ()" {{.*}} captures=(<generic> )
let _: (TT) -> () = { _ in } let _: (TT) -> () = { _ in }
} }

4
test/expr/capture/local_lazy.swift
View File

@@ -5,7 +5,7 @@ struct S {
func foo() -> Int { func foo() -> Int {
// Make sure the decl context for the autoclosure passed to ?? is deep // Make sure the decl context for the autoclosure passed to ?? is deep
// enough that it can 'see' the capture of $0 from the outer closure. // enough that it can 'see' the capture of $0 from the outer closure.
// CHECK-LABEL: (lazy_initializer_expr // CHECK-LABEL: (original_init=lazy_initializer_expr
// CHECK: (closure_expr // CHECK: (closure_expr
// CHECK: location={{.*}}local_lazy.swift:[[@LINE+3]] // CHECK: location={{.*}}local_lazy.swift:[[@LINE+3]]
// CHECK: (autoclosure_expr implicit // CHECK: (autoclosure_expr implicit
@@ -17,7 +17,7 @@ struct S {
extension S { extension S {
func bar() -> Int { func bar() -> Int {
// CHECK-LABEL: (lazy_initializer_expr // CHECK-LABEL: (original_init=lazy_initializer_expr
// CHECK: (closure_expr // CHECK: (closure_expr
// CHECK: location={{.*}}local_lazy.swift:[[@LINE+3]] // CHECK: location={{.*}}local_lazy.swift:[[@LINE+3]]
// CHECK: (autoclosure_expr implicit // CHECK: (autoclosure_expr implicit

4
test/expr/capture/nested.swift
View File

@@ -2,9 +2,9 @@
// CHECK: func_decl{{.*}}"foo2(_:)" // CHECK: func_decl{{.*}}"foo2(_:)"
func foo2(_ x: Int) -> (Int) -> (Int) -> Int { func foo2(_ x: Int) -> (Int) -> (Int) -> Int {
// CHECK: closure_expr type='(Int) -> (Int) -> Int' {{.*}} discriminator=0 captures=(x) // CHECK: closure_expr type="(Int) -> (Int) -> Int" {{.*}} discriminator=0 captures=(x)
return {(bar: Int) -> (Int) -> Int in return {(bar: Int) -> (Int) -> Int in
// CHECK: closure_expr type='(Int) -> Int' {{.*}} discriminator=0 captures=(x<direct>, bar<direct>) // CHECK: closure_expr type="(Int) -> Int" {{.*}} discriminator=0 captures=(x<direct>, bar<direct>)
return {(bas: Int) -> Int in return {(bas: Int) -> Int in
return x + bar + bas return x + bar + bas
} }

8
test/expr/capture/top-level-guard.swift
View File

@@ -15,12 +15,12 @@ guard let x = Optional(0) else { fatalError() }
// CHECK: (top_level_code_decl // CHECK: (top_level_code_decl
_ = 0 // intervening code _ = 0 // intervening code
// CHECK-LABEL: (func_decl{{.*}}"function()" interface type='() -> ()' access=internal captures=(x<direct>) // CHECK-LABEL: (func_decl{{.*}}"function()" interface type="() -> ()" access=internal captures=(x<direct>)
func function() { func function() {
_ = x _ = x
} }
// CHECK-LABEL: (closure_expr // CHECK-LABEL: (processed_init=closure_expr
// CHECK: location={{.*}}top-level-guard.swift:[[@LINE+3]] // CHECK: location={{.*}}top-level-guard.swift:[[@LINE+3]]
// CHECK: captures=(x<direct>) // CHECK: captures=(x<direct>)
// CHECK: (var_decl{{.*}}"closure" // CHECK: (var_decl{{.*}}"closure"
@@ -28,7 +28,7 @@ let closure: () -> Void = {
_ = x _ = x
} }
// CHECK-LABEL: (capture_list // CHECK-LABEL: (processed_init=capture_list
// CHECK: location={{.*}}top-level-guard.swift:[[@LINE+5]] // CHECK: location={{.*}}top-level-guard.swift:[[@LINE+5]]
// CHECK: (closure_expr // CHECK: (closure_expr
// CHECK: location={{.*}}top-level-guard.swift:[[@LINE+3]] // CHECK: location={{.*}}top-level-guard.swift:[[@LINE+3]]
@@ -39,7 +39,7 @@ let closureCapture: () -> Void = { [x] in
} }
// CHECK-LABEL: (defer_stmt // CHECK-LABEL: (defer_stmt
// CHECK-NEXT: (func_decl{{.*}}implicit "$defer()" interface type='() -> ()' access=fileprivate captures=(x<direct><noescape>) // CHECK-NEXT: (func_decl{{.*}}implicit "$defer()" interface type="() -> ()" access=fileprivate captures=(x<direct><noescape>)
defer { defer {
_ = x _ = x
} }

30
test/expr/cast/array_downcast_Foundation.swift
View File

@@ -35,26 +35,26 @@ func testDowncastNSArrayToArray(nsarray: NSArray) {
// CHECK-LABEL: testDowncastOptionalObject // CHECK-LABEL: testDowncastOptionalObject
func testDowncastOptionalObject(obj: AnyObject?!) -> [String]? { func testDowncastOptionalObject(obj: AnyObject?!) -> [String]? {
// CHECK: (optional_evaluation_expr implicit type='[String]?' // CHECK: (optional_evaluation_expr implicit type="[String]?"
// CHECK-NEXT: (inject_into_optional implicit type='[String]?' // CHECK-NEXT: (inject_into_optional implicit type="[String]?"
// CHECK: (forced_checked_cast_expr type='[String]'{{.*value_cast}} // CHECK: (forced_checked_cast_expr type="[String]"{{.*value_cast}}
// CHECK: (bind_optional_expr implicit type='AnyObject' // CHECK: (bind_optional_expr implicit type="AnyObject"
// CHECK-NEXT: (force_value_expr implicit type='AnyObject?' // CHECK-NEXT: (force_value_expr implicit type="AnyObject?"
// CHECK-NEXT: (declref_expr type='AnyObject??' // CHECK-NEXT: (declref_expr type="AnyObject??"
return obj as! [String]? return obj as! [String]?
} }
// CHECK-LABEL: testDowncastOptionalObjectConditional // CHECK-LABEL: testDowncastOptionalObjectConditional
func testDowncastOptionalObjectConditional(obj: AnyObject?!) -> [String]?? { func testDowncastOptionalObjectConditional(obj: AnyObject?!) -> [String]?? {
// CHECK: (optional_evaluation_expr implicit type='[String]??' // CHECK: (optional_evaluation_expr implicit type="[String]??"
// CHECK-NEXT: (inject_into_optional implicit type='[String]??' // CHECK-NEXT: (inject_into_optional implicit type="[String]??"
// CHECK-NEXT: (optional_evaluation_expr implicit type='[String]?' // CHECK-NEXT: (optional_evaluation_expr implicit type="[String]?"
// CHECK-NEXT: (inject_into_optional implicit type='[String]?' // CHECK-NEXT: (inject_into_optional implicit type="[String]?"
// CHECK-NEXT: (bind_optional_expr implicit type='[String]' // CHECK-NEXT: (bind_optional_expr implicit type="[String]"
// CHECK-NEXT: (conditional_checked_cast_expr type='[String]?' {{.*value_cast}} writtenType='[String]?' // CHECK-NEXT: (conditional_checked_cast_expr type="[String]?" {{.*value_cast}} written_type="[String]?"
// CHECK-NEXT: (bind_optional_expr implicit type='AnyObject' // CHECK-NEXT: (bind_optional_expr implicit type="AnyObject"
// CHECK-NEXT: (bind_optional_expr implicit type='AnyObject?' // CHECK-NEXT: (bind_optional_expr implicit type="AnyObject?"
// CHECK-NEXT: (declref_expr type='AnyObject??' // CHECK-NEXT: (declref_expr type="AnyObject??"
return obj as? [String]? return obj as? [String]?
} }

4
test/expr/delayed-ident/optional_overload.swift
View File

@@ -40,11 +40,11 @@ let _: S1? = .init(S1())
let _: S1? = .init(overloaded: ()) let _: S1? = .init(overloaded: ())
// If members exist on Optional and Wrapped, always choose the one on optional // If members exist on Optional and Wrapped, always choose the one on optional
// CHECK: declref_expr {{.*}} location={{.*}}optional_overload.swift:40 // CHECK: declref_expr {{.*}} location={{.*}}optional_overload.swift:40
// CHECK-SAME: decl=optional_overload.(file).Optional extension.init(overloaded:) // CHECK-SAME: decl="optional_overload.(file).Optional extension.init(overloaded:)@
let _: S1? = .member_overload let _: S1? = .member_overload
// Should choose the overload from Optional even if the Wrapped overload would otherwise have a better score // Should choose the overload from Optional even if the Wrapped overload would otherwise have a better score
// CHECK: member_ref_expr {{.*}} location={{.*}}optional_overload.swift:44 // CHECK: member_ref_expr {{.*}} location={{.*}}optional_overload.swift:44
// CHECK-SAME: decl=optional_overload.(file).Optional extension.member_overload // CHECK-SAME: decl="optional_overload.(file).Optional extension.member_overload@
let _: S1? = .init(failable: ()) let _: S1? = .init(failable: ())
let _: S1? = .member3() let _: S1? = .member3()
let _: S1? = .member4 let _: S1? = .member4

10
test/expr/primary/literal/collection_upcast_opt.swift
View File

@@ -14,10 +14,10 @@ struct TakesArray<T> {
// CHECK-LABEL: func_decl{{.*}}"arrayUpcast(_:_:)" // CHECK-LABEL: func_decl{{.*}}"arrayUpcast(_:_:)"
// CHECK: assign_expr // CHECK: assign_expr
// CHECK-NOT: collection_upcast_expr // CHECK-NOT: collection_upcast_expr
// CHECK: array_expr type='[(X) -> Void]' // CHECK: array_expr type="[(X) -> Void]"
// CHECK: function_conversion_expr implicit type='(X) -> Void' // CHECK: function_conversion_expr implicit type="(X) -> Void"
// CHECK-NEXT: {{declref_expr.*x1}} // CHECK-NEXT: {{declref_expr.*x1}}
// CHECK-NEXT: function_conversion_expr implicit type='(X) -> Void' // CHECK-NEXT: function_conversion_expr implicit type="(X) -> Void"
// CHECK-NEXT: {{declref_expr.*x2}} // CHECK-NEXT: {{declref_expr.*x2}}
func arrayUpcast(_ x1: @escaping (P) -> Void, _ x2: @escaping (P) -> Void) { func arrayUpcast(_ x1: @escaping (P) -> Void, _ x2: @escaping (P) -> Void) {
_ = TakesArray<X>([x1, x2]) _ = TakesArray<X>([x1, x2])
@@ -30,9 +30,9 @@ struct TakesDictionary<T> {
// CHECK-LABEL: func_decl{{.*}}"dictionaryUpcast(_:_:)" // CHECK-LABEL: func_decl{{.*}}"dictionaryUpcast(_:_:)"
// CHECK: assign_expr // CHECK: assign_expr
// CHECK-NOT: collection_upcast_expr // CHECK-NOT: collection_upcast_expr
// CHECK: paren_expr type='([Int : (X) -> Void])' // CHECK: paren_expr type="([Int : (X) -> Void])"
// CHECK-NOT: collection_upcast_expr // CHECK-NOT: collection_upcast_expr
// CHECK: (dictionary_expr type='[Int : (X) -> Void]' // CHECK: (dictionary_expr type="[Int : (X) -> Void]"
func dictionaryUpcast(_ x1: @escaping (P) -> Void, _ x2: @escaping (P) -> Void) { func dictionaryUpcast(_ x1: @escaping (P) -> Void, _ x2: @escaping (P) -> Void) {
_ = TakesDictionary<X>(([1: x1, 2: x2])) _ = TakesDictionary<X>(([1: x1, 2: x2]))
} }