mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
8770c7f826
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.
134 lines
5.5 KiB
Swift
134 lines
5.5 KiB
Swift
// RUN: not %target-swift-frontend -dump-parse %s | %FileCheck %s
|
|
// RUN: not %target-swift-frontend -dump-ast %s | %FileCheck %s -check-prefix=CHECK-AST
|
|
|
|
// CHECK-LABEL: (func_decl{{.*}}"foo(_:)"
|
|
// CHECK-AST-LABEL: (func_decl{{.*}}"foo(_:)"
|
|
func foo(_ n: Int) -> Int {
|
|
// CHECK: (brace_stmt
|
|
// CHECK: (return_stmt
|
|
// CHECK: (integer_literal_expr type="<null>" value="42" {{.*}})))
|
|
// CHECK-AST: (brace_stmt
|
|
// CHECK-AST: (return_stmt
|
|
// CHECK-AST: (integer_literal_expr type="{{[^"]+}}" {{.*}} value="42" {{.*}})
|
|
return 42
|
|
}
|
|
|
|
// -dump-parse should print an AST even though this code is invalid.
|
|
// CHECK-LABEL: (func_decl{{.*}}"bar()"
|
|
// CHECK-AST-LABEL: (func_decl{{.*}}"bar()"
|
|
func bar() {
|
|
// 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-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@
|
|
foo foo foo
|
|
}
|
|
|
|
// CHECK-LABEL: (enum_decl{{.*}}trailing_semi "TrailingSemi"
|
|
enum TrailingSemi {
|
|
|
|
// CHECK-LABEL: (enum_case_decl{{.*}}trailing_semi
|
|
// CHECK-NOT: (enum_element_decl{{.*}}trailing_semi
|
|
// CHECK: (enum_element_decl{{.*}}"A")
|
|
// CHECK: (enum_element_decl{{.*}}"B")
|
|
case A,B;
|
|
|
|
// CHECK-LABEL: (subscript_decl{{.*}}trailing_semi
|
|
// CHECK-NOT: (func_decl{{.*}}trailing_semi <anonymous @ 0x{{[0-9a-f]+}}> get for="subscript(_:)"
|
|
// CHECK: (accessor_decl{{.*}} <anonymous @ 0x{{[0-9a-f]+}}> get for="subscript(_:)"
|
|
subscript(x: Int) -> Int {
|
|
// CHECK-LABEL: (pattern_binding_decl{{.*}}trailing_semi
|
|
// CHECK-NOT: (var_decl{{.*}}trailing_semi "y"
|
|
// CHECK: (var_decl{{.*}}"y"
|
|
var y = 1;
|
|
|
|
// CHECK-LABEL: (sequence_expr {{.*}} trailing_semi
|
|
y += 1;
|
|
|
|
// CHECK-LABEL: (return_stmt{{.*}}trailing_semi
|
|
return y;
|
|
};
|
|
};
|
|
|
|
// 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> )
|
|
func generic<T: Hashable>(_: T) {}
|
|
// CHECK-AST: (pattern_binding_decl
|
|
// 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
|
|
|
|
// Closures should be marked as escaping or not.
|
|
func escaping(_: @escaping (Int) -> Int) {}
|
|
escaping({ $0 })
|
|
// CHECK-AST: (declref_expr type="(@escaping (Int) -> Int) -> ()"
|
|
// CHECK-AST-NEXT: (argument_list
|
|
// CHECK-AST-NEXT: (argument
|
|
// CHECK-AST-NEXT: (closure_expr type="(Int) -> Int" {{.*}} discriminator=0 escaping single_expression
|
|
|
|
func nonescaping(_: (Int) -> Int) {}
|
|
nonescaping({ $0 })
|
|
// CHECK-AST: (declref_expr type="((Int) -> Int) -> ()"
|
|
// CHECK-AST-NEXT: (argument_list
|
|
// CHECK-AST-NEXT: (argument
|
|
// CHECK-AST-NEXT: (closure_expr type="(Int) -> Int" {{.*}} discriminator=1 single_expression
|
|
|
|
// CHECK-LABEL: (struct_decl range=[{{.+}}] "MyStruct")
|
|
struct MyStruct {}
|
|
|
|
// CHECK-LABEL: (enum_decl range=[{{.+}}] "MyEnum"
|
|
enum MyEnum {
|
|
|
|
// CHECK-LABEL: (enum_case_decl range=[{{.+}}]
|
|
// CHECK-NEXT: (enum_element_decl range=[{{.+}}] "foo(x:)"
|
|
// CHECK-NEXT: (parameter_list range=[{{.+}}]
|
|
// CHECK-NEXT: (parameter "x" apiName="x")))
|
|
// CHECK-NEXT: (enum_element_decl range=[{{.+}}] "bar"))
|
|
// CHECK-NEXT: (enum_element_decl range=[{{.+}}] "foo(x:)"
|
|
// CHECK-NEXT: (parameter_list range=[{{.+}}]
|
|
// CHECK-NEXT: (parameter "x" apiName="x")))
|
|
// CHECK-NEXT: (enum_element_decl range=[{{.+}}] "bar"))
|
|
case foo(x: MyStruct), bar
|
|
}
|
|
|
|
// CHECK-LABEL: (top_level_code_decl range=[{{.+}}]
|
|
// CHECK-NEXT: (brace_stmt implicit range=[{{.+}}]
|
|
// CHECK-NEXT: (sequence_expr type="<null>"
|
|
// CHECK-NEXT: (discard_assignment_expr type="<null>")
|
|
// CHECK-NEXT: (assign_expr type="<null>"
|
|
// CHECK-NEXT: (<null expr>)
|
|
// CHECK-NEXT: (<null expr>))
|
|
// CHECK-NEXT: (closure_expr type="<null>" discriminator={{[0-9]+}}
|
|
// CHECK-NEXT: (parameter_list range=[{{.+}}]
|
|
// CHECK-NEXT: (parameter "v"))
|
|
// CHECK-NEXT: (brace_stmt range=[{{.+}}])))))
|
|
_ = { (v: MyEnum) in }
|
|
|
|
// CHECK-LABEL: (struct_decl range=[{{.+}}] "SelfParam"
|
|
struct SelfParam {
|
|
|
|
// CHECK-LABEL: (func_decl range=[{{.+}}] "createOptional()" type
|
|
// CHECK-NEXT: (parameter "self")
|
|
// CHECK-NEXT: (parameter_list range=[{{.+}}])
|
|
// CHECK-NEXT: (result=type_optional
|
|
// CHECK-NEXT: (type_ident id="SelfParam" unbound))
|
|
static func createOptional() -> SelfParam? {
|
|
|
|
// CHECK-LABEL: (call_expr type="<null>"
|
|
// CHECK-NEXT: (unresolved_decl_ref_expr type="<null>" name="SelfParam" function_ref=unapplied)
|
|
// CHECK-NEXT: (argument_list)
|
|
SelfParam()
|
|
}
|
|
}
|
|
|
|
// CHECK-LABEL: (func_decl range=[{{.+}}] "dumpMemberTypeRepr()"
|
|
// CHECK-NEXT: (parameter_list range=[{{.+}}])
|
|
// CHECK-NEXT: (result=type_member
|
|
// CHECK-NEXT: (type_ident id="Array" unbound
|
|
// CHECK-NEXT: (type_ident id="Bool" unbound))
|
|
// CHECK-NEXT: (type_ident id="Element" unbound))
|
|
func dumpMemberTypeRepr() -> Array<Bool>.Element { true }
|