maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Misc/ast-dump-decl.c

169 lines
4.9 KiB
C
Raw Normal View History

[clang] Remove redundant check-prefix=CHECK from tests. NFC. Reviewers: t.p.northover, mstorsjo, rsmith, mcrosier Reviewed By: mstorsjo, mcrosier Subscribers: mcrosier, javed.absar, cfe-commits Differential Revision: https://reviews.llvm.org/D35465 llvm-svn: 308192
2017-07-18 01:31:44 +08:00
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -ast-dump -ast-dump-filter Test %s | FileCheck -strict-whitespace %s
clang/test/Misc/ast-dump-decl.c: Add triple. __thread is not supported on all targets. llvm-svn: 170645
2012-12-20 11:30:30 +08:00
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -ast-dump %s | FileCheck -check-prefix CHECK-TU -strict-whitespace %s
PR33552: Distinguish between declarations that are owned by no module and declarations that are owned but unconditionally visible. This allows us to set declarations as visible even if they have a local owning module, without losing information. In turn, that means that our Objective-C support can keep on incorrectly assuming the "hidden" bit on the declaration is the whole story with regard to name visibility. This will also be useful once we support the C++ Modules TS export semantics. Objective-C name visibility is still incorrect in any case where the "hidden" bit is not the complete story: for instance, in Objective-C++ the set of visible categories will be wrong during template instantiation, and with local submodule visibility enabled it will be wrong when building modules. Fixing that will require a major overhaul of how visibility is handled for Objective-C (and particularly for categories). llvm-svn: 306075
2017-06-23 09:04:34 +08:00
// RUN: %clang_cc1 -fmodules -fmodules-local-submodule-visibility -fmodule-name=X -triple x86_64-unknown-unknown -fmodule-map-file=%S/Inputs/module.modulemap -ast-dump -ast-dump-filter Test %s -DMODULES | FileCheck -check-prefix CHECK -check-prefix CHECK-MODULES -strict-whitespace %s
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
int TestLocation;
PR33552: Distinguish between declarations that are owned by no module and declarations that are owned but unconditionally visible. This allows us to set declarations as visible even if they have a local owning module, without losing information. In turn, that means that our Objective-C support can keep on incorrectly assuming the "hidden" bit on the declaration is the whole story with regard to name visibility. This will also be useful once we support the C++ Modules TS export semantics. Objective-C name visibility is still incorrect in any case where the "hidden" bit is not the complete story: for instance, in Objective-C++ the set of visible categories will be wrong during template instantiation, and with local submodule visibility enabled it will be wrong when building modules. Fixing that will require a major overhaul of how visibility is handled for Objective-C (and particularly for categories). llvm-svn: 306075
2017-06-23 09:04:34 +08:00
// CHECK: VarDecl 0x{{[^ ]*}} <{{.*}}:[[@LINE-1]]:1, col:5> col:5 TestLocation
#ifdef MODULES
#pragma clang module begin X
#endif
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
struct TestIndent {
int x;
};
Add indents to AST dumping and removed parenthesis from AST nodes. Indents were given the color blue when outputting with color. AST dumping now looks like this: Node |-Node | `-Node `-Node `-Node Compared to the previous: (Node (Node (Node)) (Node (Node))) llvm-svn: 174022
2013-01-31 09:44:26 +08:00
// CHECK: {{^}}RecordDecl{{.*TestIndent[^()]*$}}
// CHECK-NEXT: {{^}}`-FieldDecl{{.*x[^()]*$}}
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
struct TestChildren {
int x;
struct y {
int z;
};
};
// CHECK: RecordDecl{{.*}}TestChildren
// CHECK-NEXT: FieldDecl{{.*}}x
// CHECK-NEXT: RecordDecl{{.*}}y
// CHECK-NEXT: FieldDecl{{.*}}z
// CHECK-TU: TranslationUnitDecl
void testLabelDecl() {
__label__ TestLabelDecl;
TestLabelDecl: goto TestLabelDecl;
}
// CHECK: LabelDecl{{.*}} TestLabelDecl
typedef int TestTypedefDecl;
// CHECK: TypedefDecl{{.*}} TestTypedefDecl 'int'
__module_private__ typedef int TestTypedefDeclPrivate;
PR33552: Distinguish between declarations that are owned by no module and declarations that are owned but unconditionally visible. This allows us to set declarations as visible even if they have a local owning module, without losing information. In turn, that means that our Objective-C support can keep on incorrectly assuming the "hidden" bit on the declaration is the whole story with regard to name visibility. This will also be useful once we support the C++ Modules TS export semantics. Objective-C name visibility is still incorrect in any case where the "hidden" bit is not the complete story: for instance, in Objective-C++ the set of visible categories will be wrong during template instantiation, and with local submodule visibility enabled it will be wrong when building modules. Fixing that will require a major overhaul of how visibility is handled for Objective-C (and particularly for categories). llvm-svn: 306075
2017-06-23 09:04:34 +08:00
// CHECK-MODULE: TypedefDecl{{.*}} TestTypedefDeclPrivate 'int' __module_private__
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
enum TestEnumDecl {
testEnumDecl
};
// CHECK: EnumDecl{{.*}} TestEnumDecl
// CHECK-NEXT: EnumConstantDecl{{.*}} testEnumDecl
struct TestEnumDeclAnon {
enum {
testEnumDeclAnon
} e;
};
// CHECK: RecordDecl{{.*}} TestEnumDeclAnon
Add the location of Decls to ast dump. While investigating some debug info issues, Eric and I came across a particular template case where the location of a decl was quite different from the range of the same decl. It might've been rather helpful if the dumper had actually showed us this. llvm-svn: 205396
2014-04-02 13:48:29 +08:00
// CHECK-NEXT: EnumDecl{{.*> .*$}}
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
enum TestEnumDeclForward;
// CHECK: EnumDecl{{.*}} TestEnumDeclForward
__module_private__ enum TestEnumDeclPrivate;
PR33552: Distinguish between declarations that are owned by no module and declarations that are owned but unconditionally visible. This allows us to set declarations as visible even if they have a local owning module, without losing information. In turn, that means that our Objective-C support can keep on incorrectly assuming the "hidden" bit on the declaration is the whole story with regard to name visibility. This will also be useful once we support the C++ Modules TS export semantics. Objective-C name visibility is still incorrect in any case where the "hidden" bit is not the complete story: for instance, in Objective-C++ the set of visible categories will be wrong during template instantiation, and with local submodule visibility enabled it will be wrong when building modules. Fixing that will require a major overhaul of how visibility is handled for Objective-C (and particularly for categories). llvm-svn: 306075
2017-06-23 09:04:34 +08:00
// CHECK-MODULE: EnumDecl{{.*}} TestEnumDeclPrivate __module_private__
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
struct TestRecordDecl {
int i;
};
// CHECK: RecordDecl{{.*}} struct TestRecordDecl
// CHECK-NEXT: FieldDecl
struct TestRecordDeclEmpty {
};
// CHECK: RecordDecl{{.*}} struct TestRecordDeclEmpty
struct TestRecordDeclAnon1 {
struct {
} testRecordDeclAnon1;
};
// CHECK: RecordDecl{{.*}} struct TestRecordDeclAnon1
// CHECK-NEXT: RecordDecl{{.*}} struct
struct TestRecordDeclAnon2 {
struct {
};
};
// CHECK: RecordDecl{{.*}} struct TestRecordDeclAnon2
// CHECK-NEXT: RecordDecl{{.*}} struct
struct TestRecordDeclForward;
// CHECK: RecordDecl{{.*}} struct TestRecordDeclForward
__module_private__ struct TestRecordDeclPrivate;
PR33552: Distinguish between declarations that are owned by no module and declarations that are owned but unconditionally visible. This allows us to set declarations as visible even if they have a local owning module, without losing information. In turn, that means that our Objective-C support can keep on incorrectly assuming the "hidden" bit on the declaration is the whole story with regard to name visibility. This will also be useful once we support the C++ Modules TS export semantics. Objective-C name visibility is still incorrect in any case where the "hidden" bit is not the complete story: for instance, in Objective-C++ the set of visible categories will be wrong during template instantiation, and with local submodule visibility enabled it will be wrong when building modules. Fixing that will require a major overhaul of how visibility is handled for Objective-C (and particularly for categories). llvm-svn: 306075
2017-06-23 09:04:34 +08:00
// CHECK-MODULE: RecordDecl{{.*}} struct TestRecordDeclPrivate __module_private__
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
enum testEnumConstantDecl {
TestEnumConstantDecl,
TestEnumConstantDeclInit = 1
};
// CHECK: EnumConstantDecl{{.*}} TestEnumConstantDecl 'int'
// CHECK: EnumConstantDecl{{.*}} TestEnumConstantDeclInit 'int'
// CHECK-NEXT: IntegerLiteral
struct testIndirectFieldDecl {
struct {
int TestIndirectFieldDecl;
};
};
// CHECK: IndirectFieldDecl{{.*}} TestIndirectFieldDecl 'int'
// CHECK-NEXT: Field{{.*}} ''
// CHECK-NEXT: Field{{.*}} 'TestIndirectFieldDecl'
Store decls in prototypes on the declarator instead of in the AST This saves two pointers from FunctionDecl that were being used for some rare and questionable C-only functionality. The DeclsInPrototypeScope ArrayRef was added in r151712 in order to parse this kind of C code: enum e {x, y}; int f(enum {y, x} n) { return x; // should return 1, not 0 } The challenge is that we parse 'int f(enum {y, x} n)' it its own function prototype scope that gets popped before we build the FunctionDecl for 'f'. The original change was doing two questionable things: 1. Saving all tag decls introduced in prototype scope on a TU-global Sema variable. This is problematic when you have cases like this, where 'x' and 'y' shouldn't be visible in 'f': void f(void (*fp)(enum { x, y } e)) { /* no x */ } This patch fixes that, so now 'f' can't see 'x', which is consistent with GCC. 2. Storing the decls in FunctionDecl in ActOnFunctionDeclarator so that they could be used in ActOnStartOfFunctionDef. This is just an inefficient way to move information around. The AST lives forever, but the list of non-parameter decls in prototype scope is short lived. Moving these things to the Declarator solves both of these issues. Reviewers: rsmith Subscribers: jmolloy, cfe-commits Differential Revision: https://reviews.llvm.org/D27279 llvm-svn: 289225
2016-12-10 01:14:05 +08:00
// FIXME: It would be nice to dump the enum and its enumerators.
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
int TestFunctionDecl(int x, enum { e } y) {
return x;
}
// CHECK: FunctionDecl{{.*}} TestFunctionDecl 'int (int, enum {{.*}})'
// CHECK-NEXT: ParmVarDecl{{.*}} x
// CHECK-NEXT: ParmVarDecl{{.*}} y
// CHECK-NEXT: CompoundStmt
Store decls in prototypes on the declarator instead of in the AST This saves two pointers from FunctionDecl that were being used for some rare and questionable C-only functionality. The DeclsInPrototypeScope ArrayRef was added in r151712 in order to parse this kind of C code: enum e {x, y}; int f(enum {y, x} n) { return x; // should return 1, not 0 } The challenge is that we parse 'int f(enum {y, x} n)' it its own function prototype scope that gets popped before we build the FunctionDecl for 'f'. The original change was doing two questionable things: 1. Saving all tag decls introduced in prototype scope on a TU-global Sema variable. This is problematic when you have cases like this, where 'x' and 'y' shouldn't be visible in 'f': void f(void (*fp)(enum { x, y } e)) { /* no x */ } This patch fixes that, so now 'f' can't see 'x', which is consistent with GCC. 2. Storing the decls in FunctionDecl in ActOnFunctionDeclarator so that they could be used in ActOnStartOfFunctionDef. This is just an inefficient way to move information around. The AST lives forever, but the list of non-parameter decls in prototype scope is short lived. Moving these things to the Declarator solves both of these issues. Reviewers: rsmith Subscribers: jmolloy, cfe-commits Differential Revision: https://reviews.llvm.org/D27279 llvm-svn: 289225
2016-12-10 01:14:05 +08:00
// FIXME: It would be nice to 'Enum' and 'e'.
int TestFunctionDecl2(enum Enum { e } x) { return x; }
// CHECK: FunctionDecl{{.*}} TestFunctionDecl2 'int (enum {{.*}})'
// CHECK-NEXT: ParmVarDecl{{.*}} x
// CHECK-NEXT: CompoundStmt
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
int TestFunctionDeclProto(int x);
// CHECK: FunctionDecl{{.*}} TestFunctionDeclProto 'int (int)'
// CHECK-NEXT: ParmVarDecl{{.*}} x
extern int TestFunctionDeclSC();
// CHECK: FunctionDecl{{.*}} TestFunctionDeclSC 'int ()' extern
inline int TestFunctionDeclInline();
// CHECK: FunctionDecl{{.*}} TestFunctionDeclInline 'int ()' inline
struct testFieldDecl {
int TestFieldDecl;
int TestFieldDeclWidth : 1;
__module_private__ int TestFieldDeclPrivate;
};
// CHECK: FieldDecl{{.*}} TestFieldDecl 'int'
// CHECK: FieldDecl{{.*}} TestFieldDeclWidth 'int'
// CHECK-NEXT: IntegerLiteral
PR33552: Distinguish between declarations that are owned by no module and declarations that are owned but unconditionally visible. This allows us to set declarations as visible even if they have a local owning module, without losing information. In turn, that means that our Objective-C support can keep on incorrectly assuming the "hidden" bit on the declaration is the whole story with regard to name visibility. This will also be useful once we support the C++ Modules TS export semantics. Objective-C name visibility is still incorrect in any case where the "hidden" bit is not the complete story: for instance, in Objective-C++ the set of visible categories will be wrong during template instantiation, and with local submodule visibility enabled it will be wrong when building modules. Fixing that will require a major overhaul of how visibility is handled for Objective-C (and particularly for categories). llvm-svn: 306075
2017-06-23 09:04:34 +08:00
// CHECK-MODULE: FieldDecl{{.*}} TestFieldDeclPrivate 'int' __module_private__
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
int TestVarDecl;
// CHECK: VarDecl{{.*}} TestVarDecl 'int'
extern int TestVarDeclSC;
// CHECK: VarDecl{{.*}} TestVarDeclSC 'int' extern
__thread int TestVarDeclThread;
Annotate flavor of TLS variable (statically or dynamically initialized) onto the AST. llvm-svn: 179447
2013-04-13 10:43:54 +08:00
// CHECK: VarDecl{{.*}} TestVarDeclThread 'int' tls{{$}}
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
__module_private__ int TestVarDeclPrivate;
PR33552: Distinguish between declarations that are owned by no module and declarations that are owned but unconditionally visible. This allows us to set declarations as visible even if they have a local owning module, without losing information. In turn, that means that our Objective-C support can keep on incorrectly assuming the "hidden" bit on the declaration is the whole story with regard to name visibility. This will also be useful once we support the C++ Modules TS export semantics. Objective-C name visibility is still incorrect in any case where the "hidden" bit is not the complete story: for instance, in Objective-C++ the set of visible categories will be wrong during template instantiation, and with local submodule visibility enabled it will be wrong when building modules. Fixing that will require a major overhaul of how visibility is handled for Objective-C (and particularly for categories). llvm-svn: 306075
2017-06-23 09:04:34 +08:00
// CHECK-MODULE: VarDecl{{.*}} TestVarDeclPrivate 'int' __module_private__
Implement AST dumper for Decls. http://llvm-reviews.chandlerc.com/D52 Patch by Philip Craig! llvm-svn: 170634
2012-12-20 10:09:13 +08:00
int TestVarDeclInit = 0;
// CHECK: VarDecl{{.*}} TestVarDeclInit 'int'
// CHECK-NEXT: IntegerLiteral
void testParmVarDecl(int TestParmVarDecl);
// CHECK: ParmVarDecl{{.*}} TestParmVarDecl 'int'
PR33552: Distinguish between declarations that are owned by no module and declarations that are owned but unconditionally visible. This allows us to set declarations as visible even if they have a local owning module, without losing information. In turn, that means that our Objective-C support can keep on incorrectly assuming the "hidden" bit on the declaration is the whole story with regard to name visibility. This will also be useful once we support the C++ Modules TS export semantics. Objective-C name visibility is still incorrect in any case where the "hidden" bit is not the complete story: for instance, in Objective-C++ the set of visible categories will be wrong during template instantiation, and with local submodule visibility enabled it will be wrong when building modules. Fixing that will require a major overhaul of how visibility is handled for Objective-C (and particularly for categories). llvm-svn: 306075
2017-06-23 09:04:34 +08:00
#ifdef MODULES
#pragma clang module end
#endif