Implement AST dumper for Decls.
http://llvm-reviews.chandlerc.com/D52
Patch by Philip Craig!
llvm-svn: 170634
diff --git a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-examples.cpp b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-examples.cpp
index 08d9639..be1113d 100644
--- a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-examples.cpp
+++ b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-examples.cpp
@@ -3,10 +3,10 @@
// CHECK: example0
void example0() {
double d = 2.0;
- // CHECK: double &rd =
+ // CHECK: VarDecl{{.*}}rd 'double &'
// CHECK-NEXT: DeclRefExpr
double &rd = d;
- // CHECK: const double &rcd =
+ // CHECK: VarDecl{{.*}}rcd 'const double &'
// CHECK-NEXT: ImplicitCastExpr{{.*}}'const double' lvalue <NoOp>
const double &rcd = d;
}
@@ -16,10 +16,10 @@
// CHECK: example1
void example1() {
- // CHECK: A &ra =
+ // CHECK: VarDecl{{.*}}ra 'struct A &'
// CHECK: ImplicitCastExpr{{.*}}'struct A' lvalue <DerivedToBase (A)>
A &ra = b;
- // CHECK: const A &rca =
+ // CHECK: VarDecl{{.*}}rca 'const struct A &'
// CHECK: ImplicitCastExpr{{.*}}'const struct A' lvalue <NoOp>
// CHECK: ImplicitCastExpr{{.*}}'struct A' lvalue <DerivedToBase (A)>
const A& rca = b;
@@ -33,12 +33,12 @@
// CHECK: example2
void example2() {
- // CHECK: const A &rca =
+ // CHECK: VarDecl{{.*}}rca 'const struct A &'
// CHECK: ImplicitCastExpr{{.*}}'const struct A' <NoOp>
// CHECK: ImplicitCastExpr{{.*}}'struct A' <DerivedToBase (A)>
// CHECK: CallExpr{{.*}}B
const A &rca = f();
- // CHECK: const A &r =
+ // CHECK: VarDecl{{.*}}r 'const struct A &'
// CHECK: ImplicitCastExpr{{.*}}'const struct A' <NoOp>
// CHECK: ImplicitCastExpr{{.*}}'struct A' <DerivedToBase (A)>
// CHECK: CXXMemberCallExpr{{.*}}'struct B'
@@ -47,7 +47,7 @@
// CHECK: example3
void example3() {
- // CHECK: const double &rcd2 =
+ // CHECK: VarDecl{{.*}}rcd2 'const double &'
// CHECK: ImplicitCastExpr{{.*}} <IntegralToFloating>
const double& rcd2 = 2;
}
diff --git a/clang/test/CodeGen/bitfield-2.c b/clang/test/CodeGen/bitfield-2.c
index fc85a80..867ed8c 100644
--- a/clang/test/CodeGen/bitfield-2.c
+++ b/clang/test/CodeGen/bitfield-2.c
@@ -9,7 +9,7 @@
// PR6176
// CHECK-RECORD: *** Dumping IRgen Record Layout
-// CHECK-RECORD: Record: struct s0
+// CHECK-RECORD: Record: (RecordDecl{{.*}}s0
// CHECK-RECORD: Layout: <CGRecordLayout
// CHECK-RECORD: LLVMType:%struct.s0 = type <{ [3 x i8] }>
// CHECK-RECORD: IsZeroInitializable:1
@@ -49,7 +49,7 @@
// PR5591
// CHECK-RECORD: *** Dumping IRgen Record Layout
-// CHECK-RECORD: Record: struct s1
+// CHECK-RECORD: Record: (RecordDecl{{.*}}s1
// CHECK-RECORD: Layout: <CGRecordLayout
// CHECK-RECORD: LLVMType:%struct.s1 = type <{ [3 x i8] }>
// CHECK-RECORD: IsZeroInitializable:1
@@ -97,7 +97,7 @@
// PR5567
// CHECK-RECORD: *** Dumping IRgen Record Layout
-// CHECK-RECORD: Record: union u2
+// CHECK-RECORD: Record: (RecordDecl{{.*}}u2
// CHECK-RECORD: Layout: <CGRecordLayout
// CHECK-RECORD: LLVMType:%union.u2 = type <{ i8 }>
// CHECK-RECORD: IsZeroInitializable:1
@@ -269,7 +269,7 @@
// Check that we compute the best alignment possible for each access.
//
// CHECK-RECORD: *** Dumping IRgen Record Layout
-// CHECK-RECORD: Record: struct s7
+// CHECK-RECORD: Record: (RecordDecl{{.*}}s7
// CHECK-RECORD: Layout: <CGRecordLayout
// CHECK-RECORD: LLVMType:%struct.s7 = type { i32, i32, i32, i8, [3 x i8], [4 x i8], [12 x i8] }
// CHECK-RECORD: IsZeroInitializable:1
diff --git a/clang/test/Misc/ast-dump-decl.c b/clang/test/Misc/ast-dump-decl.c
new file mode 100644
index 0000000..4bfd188
--- /dev/null
+++ b/clang/test/Misc/ast-dump-decl.c
@@ -0,0 +1,152 @@
+// RUN: %clang_cc1 -ast-dump -ast-dump-filter Test %s | FileCheck -check-prefix CHECK -strict-whitespace %s
+// RUN: %clang_cc1 -ast-dump %s | FileCheck -check-prefix CHECK-TU -strict-whitespace %s
+
+int TestLocation;
+// CHECK: VarDecl 0x{{[^ ]*}} <{{.*}}:4:1, col:5> TestLocation
+
+struct TestIndent {
+ int x;
+};
+// CHECK: {{^\(RecordDecl.*TestIndent[^()]*$}}
+// CHECK-NEXT: {{^ \(FieldDecl.*x[^()]*\)\)$}}
+
+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;
+// CHECK: TypedefDecl{{.*}} TestTypedefDeclPrivate 'int' __module_private__
+
+enum TestEnumDecl {
+ testEnumDecl
+};
+// CHECK: EnumDecl{{.*}} TestEnumDecl
+// CHECK-NEXT: EnumConstantDecl{{.*}} testEnumDecl
+
+struct TestEnumDeclAnon {
+ enum {
+ testEnumDeclAnon
+ } e;
+};
+// CHECK: RecordDecl{{.*}} TestEnumDeclAnon
+// CHECK-NEXT: EnumDecl{{.*>$}}
+
+enum TestEnumDeclForward;
+// CHECK: EnumDecl{{.*}} TestEnumDeclForward
+
+__module_private__ enum TestEnumDeclPrivate;
+// CHECK: EnumDecl{{.*}} TestEnumDeclPrivate __module_private__
+
+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;
+// CHECK: RecordDecl{{.*}} struct TestRecordDeclPrivate __module_private__
+
+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'
+
+int TestFunctionDecl(int x, enum { e } y) {
+ return x;
+}
+// CHECK: FunctionDecl{{.*}} TestFunctionDecl 'int (int, enum {{.*}})'
+// CHECK-NEXT: EnumDecl
+// CHECK-NEXT: EnumConstantDecl{{.*}} e
+// CHECK-NEXT: ParmVarDecl{{.*}} x
+// CHECK-NEXT: ParmVarDecl{{.*}} y
+// CHECK-NEXT: CompoundStmt
+
+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
+// CHECK: FieldDecl{{.*}} TestFieldDeclPrivate 'int' __module_private__
+
+int TestVarDecl;
+// CHECK: VarDecl{{.*}} TestVarDecl 'int'
+
+extern int TestVarDeclSC;
+// CHECK: VarDecl{{.*}} TestVarDeclSC 'int' extern
+
+__thread int TestVarDeclThread;
+// CHECK: VarDecl{{.*}} TestVarDeclThread 'int' __thread
+
+__module_private__ int TestVarDeclPrivate;
+// CHECK: VarDecl{{.*}} TestVarDeclPrivate 'int' __module_private__
+
+int TestVarDeclInit = 0;
+// CHECK: VarDecl{{.*}} TestVarDeclInit 'int'
+// CHECK-NEXT: IntegerLiteral
+
+void testParmVarDecl(int TestParmVarDecl);
+// CHECK: ParmVarDecl{{.*}} TestParmVarDecl 'int'
diff --git a/clang/test/Misc/ast-dump-decl.cpp b/clang/test/Misc/ast-dump-decl.cpp
new file mode 100644
index 0000000..ab847ca
--- /dev/null
+++ b/clang/test/Misc/ast-dump-decl.cpp
@@ -0,0 +1,405 @@
+// RUN: %clang_cc1 -std=c++11 -fms-extensions -ast-dump -ast-dump-filter Test %s | FileCheck -check-prefix CHECK -strict-whitespace %s
+
+class testEnumDecl {
+ enum class TestEnumDeclScoped;
+ enum TestEnumDeclFixed : int;
+};
+// CHECK: EnumDecl{{.*}} class TestEnumDeclScoped 'int'
+// CHECK: EnumDecl{{.*}} TestEnumDeclFixed 'int'
+
+class testFieldDecl {
+ int TestFieldDeclInit = 0;
+};
+// CHECK: FieldDecl{{.*}} TestFieldDeclInit 'int'
+// CHECK-NEXT: IntegerLiteral
+
+namespace testVarDeclNRVO {
+ class A { };
+ A foo() {
+ A TestVarDeclNRVO;
+ return TestVarDeclNRVO;
+ }
+}
+// CHECK: VarDecl{{.*}} TestVarDeclNRVO 'class testVarDeclNRVO::A' nrvo
+
+void testParmVarDeclInit(int TestParmVarDeclInit = 0);
+// CHECK: ParmVarDecl{{.*}} TestParmVarDeclInit 'int'
+// CHECK-NEXT: IntegerLiteral{{.*}}
+
+namespace TestNamespaceDecl {
+ int i;
+}
+// CHECK: NamespaceDecl{{.*}} TestNamespaceDecl
+// CHECK-NEXT: VarDecl
+
+namespace TestNamespaceDecl {
+ int j;
+}
+// CHECK: NamespaceDecl{{.*}} TestNamespaceDecl
+// CHECK-NEXT: original Namespace
+// CHECK-NEXT: VarDecl
+
+inline namespace TestNamespaceDeclInline {
+}
+// CHECK: NamespaceDecl{{.*}} TestNamespaceDeclInline inline
+
+namespace testUsingDirectiveDecl {
+ namespace A {
+ }
+}
+namespace TestUsingDirectiveDecl {
+ using namespace testUsingDirectiveDecl::A;
+}
+// CHECK: NamespaceDecl{{.*}} TestUsingDirectiveDecl
+// CHECK-NEXT: UsingDirectiveDecl{{.*}} Namespace{{.*}} 'A'
+
+namespace testNamespaceAlias {
+ namespace A {
+ }
+}
+namespace TestNamespaceAlias = testNamespaceAlias::A;
+// CHECK: NamespaceAliasDecl{{.*}} TestNamespaceAlias
+// CHECK-NEXT: Namespace{{.*}} 'A'
+
+using TestTypeAliasDecl = int;
+// CHECK: TypeAliasDecl{{.*}} TestTypeAliasDecl 'int'
+
+namespace testTypeAliasTemplateDecl {
+ template<typename T> class A;
+ template<typename T> using TestTypeAliasTemplateDecl = A<T>;
+}
+// CHECK: TypeAliasTemplateDecl{{.*}} TestTypeAliasTemplateDecl
+// CHECK-NEXT: TemplateTypeParmDecl
+// CHECK-NEXT: TypeAliasDecl{{.*}} TestTypeAliasTemplateDecl 'A<T>'
+
+namespace testCXXRecordDecl {
+ class A { };
+ class B { };
+ class TestCXXRecordDecl : virtual A, public B {
+ int i;
+ };
+}
+// CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDecl
+// CHECK-NEXT: virtual private 'class testCXXRecordDecl::A'
+// CHECK-NEXT: public 'class testCXXRecordDecl::B'
+// CHECK-NEXT: CXXRecordDecl{{.*}} class TestCXXRecordDecl
+// CHECK-NEXT: FieldDecl
+
+template<class...T>
+class TestCXXRecordDeclPack : public T... {
+};
+// CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack
+// CHECK-NEXT: public 'T'...
+// CHECK-NEXT: CXXRecordDecl{{.*}} class TestCXXRecordDeclPack
+
+__module_private__ class TestCXXRecordDeclPrivate;
+// CHECK: CXXRecordDecl{{.*}} class TestCXXRecordDeclPrivate __module_private__
+
+class testCXXMethodDecl {
+ __module_private__ void TestCXXMethodDeclPrivate();
+ virtual void TestCXXMethodDeclPure() = 0;
+ void TestCXXMethodDeclDelete() = delete;
+ void TestCXXMethodDeclThrow() throw();
+ void TestCXXMethodDeclThrowType() throw(int);
+};
+// CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclPrivate 'void (void)' __module_private__
+// CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclPure 'void (void)' virtual pure
+// CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclDelete 'void (void)' delete
+// CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclThrow 'void (void) throw()'
+// CHECK: CXXMethodDecl{{.*}} TestCXXMethodDeclThrowType 'void (void) throw(int)'
+
+namespace testCXXConstructorDecl {
+ class A { };
+ class TestCXXConstructorDecl : public A {
+ int I;
+ TestCXXConstructorDecl(A &a, int i) : A(a), I(i) { }
+ };
+}
+// CHECK: CXXConstructorDecl{{.*}} TestCXXConstructorDecl 'void {{.*}}'
+// CHECK-NEXT: ParmVarDecl{{.*}} a
+// CHECK-NEXT: ParmVarDecl{{.*}} i
+// CHECK-NEXT: CXXCtorInitializer{{.*}}A
+// CHECK-NEXT: Expr
+// CHECK: CXXCtorInitializer{{.*}}I
+// CHECK-NEXT: Expr
+// CHECK: CompoundStmt
+
+class TestCXXDestructorDecl {
+ ~TestCXXDestructorDecl() { }
+};
+// CHECK: CXXDestructorDecl{{.*}} ~TestCXXDestructorDecl 'void (void) noexcept'
+// CHECK-NEXT: CompoundStmt
+
+class TestCXXConversionDecl {
+ operator int() { return 0; }
+};
+// CHECK: CXXConversionDecl{{.*}} operator int 'int (void)'
+// CHECK-NEXT: CompoundStmt
+
+namespace TestStaticAssertDecl {
+ static_assert(true, "msg");
+}
+// CHECK: NamespaceDecl{{.*}} TestStaticAssertDecl
+// CHECK-NEXT: StaticAssertDecl{{.*>$}}
+// CHECK-NEXT: CXXBoolLiteralExpr
+// CHECK-NEXT: StringLiteral
+
+namespace testFunctionTemplateDecl {
+ class A { };
+ class B { };
+ class C { };
+ class D { };
+ template<typename T> void TestFunctionTemplate(T) { }
+
+ // implicit instantiation
+ void bar(A a) { TestFunctionTemplate(a); }
+
+ // explicit specialization
+ template<> void TestFunctionTemplate(B);
+
+ // explicit instantiation declaration
+ extern template void TestFunctionTemplate(C);
+
+ // explicit instantiation definition
+ template void TestFunctionTemplate(D);
+}
+// CHECK: FunctionTemplateDecl{{.*}} TestFunctionTemplate
+// CHECK-NEXT: TemplateTypeParmDecl
+// CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate 'void (T)'
+// CHECK-NEXT: ParmVarDecl{{.*}} 'T'
+// CHECK-NEXT: CompoundStmt
+// CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}A
+// CHECK-NEXT: TemplateArgument
+// CHECK-NEXT: ParmVarDecl
+// CHECK-NEXT: CompoundStmt
+// CHECK-NEXT: Function{{.*}} 'TestFunctionTemplate' {{.*}}B
+// CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}C
+// CHECK-NEXT: TemplateArgument
+// CHECK-NEXT: ParmVarDecl
+// CHECK-NEXT: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}D
+// CHECK-NEXT: TemplateArgument
+// CHECK-NEXT: ParmVarDecl
+// CHECK-NEXT: CompoundStmt
+// CHECK: FunctionDecl{{.*}} TestFunctionTemplate {{.*}}B
+// CHECK-NEXT: TemplateArgument
+// CHECK-NEXT: ParmVarDecl
+
+namespace testClassTemplateDecl {
+ class A { };
+ class B { };
+ class C { };
+ class D { };
+
+ template<typename T> class TestClassTemplate {
+ int i;
+ };
+
+ // implicit instantiation
+ TestClassTemplate<A> a;
+
+ // explicit specialization
+ template<> class TestClassTemplate<B> {
+ int j;
+ };
+
+ // explicit instantiation declaration
+ extern template class TestClassTemplate<C>;
+
+ // explicit instantiation definition
+ template class TestClassTemplate<D>;
+
+ // partial explicit specialization
+ template<typename T1, typename T2> class TestClassTemplatePartial {
+ int i;
+ };
+ template<typename T1> class TestClassTemplatePartial<T1, A> {
+ int j;
+ };
+}
+// CHECK: ClassTemplateDecl{{.*}} TestClassTemplate
+// CHECK-NEXT: TemplateTypeParmDecl
+// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
+// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
+// CHECK-NEXT: FieldDecl{{.*}} i
+// CHECK-NEXT: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
+// CHECK-NEXT: TemplateArgument{{.*}}A
+// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
+// CHECK-NEXT: FieldDecl{{.*}} i
+// CHECK: ClassTemplateSpecialization{{.*}} 'TestClassTemplate'
+// CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate'
+// CHECK-NEXT: ClassTemplateSpecialization{{.*}} 'TestClassTemplate'
+
+// CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
+// CHECK-NEXT: TemplateArgument{{.*}}B
+// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
+// CHECK-NEXT: FieldDecl{{.*}} j
+
+// CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
+// CHECK-NEXT: TemplateArgument{{.*}}C
+// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
+// CHECK-NEXT: FieldDecl{{.*}} i
+
+// CHECK: ClassTemplateSpecializationDecl{{.*}} class TestClassTemplate
+// CHECK-NEXT: TemplateArgument{{.*}}D
+// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplate
+// CHECK-NEXT: FieldDecl{{.*}} i
+
+// CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class TestClassTemplatePartial
+// CHECK-NEXT: TemplateArgument
+// CHECK-NEXT: TemplateArgument{{.*}}A
+// CHECK-NEXT: TemplateTypeParmDecl
+// CHECK-NEXT: CXXRecordDecl{{.*}} class TestClassTemplatePartial
+// CHECK-NEXT: FieldDecl{{.*}} j
+
+template <class T>
+class TestClassScopeFunctionSpecialization {
+ template<class U> void foo(U a) { }
+ template<> void foo<int>(int a) { }
+};
+// CHECK: ClassScopeFunctionSpecializationDecl
+// CHECK-NEXT: CXXMethod{{.*}} 'foo' 'void (int)'
+// CHECK-NEXT: TemplateArgument{{.*}} 'int'
+
+namespace TestTemplateTypeParmDecl {
+ template<typename ... T, class U = int> void foo();
+}
+// CHECK: NamespaceDecl{{.*}} TestTemplateTypeParmDecl
+// CHECK-NEXT: FunctionTemplateDecl
+// CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename ... T
+// CHECK-NEXT: TemplateTypeParmDecl{{.*}} class U 'int'
+
+namespace TestNonTypeTemplateParmDecl {
+ template<int I = 1, int ... J> void foo();
+}
+// CHECK: NamespaceDecl{{.*}} TestNonTypeTemplateParmDecl
+// CHECK-NEXT: FunctionTemplateDecl
+// CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' I
+// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 1
+// CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} 'int' ... J
+
+namespace TestTemplateTemplateParmDecl {
+ template<typename T> class A;
+ template <template <typename> class T = A, template <typename> class ... U> void foo();
+}
+// CHECK: NamespaceDecl{{.*}} TestTemplateTemplateParmDecl
+// CHECK: FunctionTemplateDecl
+// CHECK-NEXT: TemplateTemplateParmDecl{{.*}} T
+// CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename
+// CHECK-NEXT: TemplateArgument{{.*}} template A
+// CHECK-NEXT: TemplateTemplateParmDecl{{.*}} ... U
+// CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename
+
+namespace TestTemplateArgument {
+ template<typename> class A { };
+ template<template<typename> class ...> class B { };
+ int foo();
+
+ template<typename> class testType { };
+ template class testType<int>;
+ // CHECK: ClassTemplateSpecializationDecl{{.*}} class testType
+ // CHECK-NEXT: TemplateArgument{{.*}} type 'int'
+
+ template<int fp(void)> class testDecl { };
+ template class testDecl<foo>;
+ // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl
+ // CHECK-NEXT: TemplateArgument{{.*}} decl
+ // CHECK-NEXT: Function{{.*}}foo
+
+ template class testDecl<nullptr>;
+ // CHECK: ClassTemplateSpecializationDecl{{.*}} class testDecl
+ // CHECK-NEXT: TemplateArgument{{.*}} nullptr
+
+ template<int> class testIntegral { };
+ template class testIntegral<1>;
+ // CHECK: ClassTemplateSpecializationDecl{{.*}} class testIntegral
+ // CHECK-NEXT: TemplateArgument{{.*}} integral 1
+
+ template<template<typename> class> class testTemplate { };
+ template class testTemplate<A>;
+ // CHECK: ClassTemplateSpecializationDecl{{.*}} class testTemplate
+ // CHECK-NEXT: TemplateArgument{{.*}} A
+
+ template<template<typename> class ...T> class C {
+ B<T...> testTemplateExpansion;
+ };
+ // FIXME: Need TemplateSpecializationType dumping to test TemplateExpansion.
+
+ template<int, int = 0> class testExpr;
+ template<int I> class testExpr<I> { };
+ // CHECK: ClassTemplatePartialSpecializationDecl{{.*}} class testExpr
+ // CHECK-NEXT: TemplateArgument{{.*}} expr
+ // CHECK-NEXT: DeclRefExpr{{.*}}I
+
+ template<int, int ...> class testPack { };
+ template class testPack<0, 1, 2>;
+ // CHECK: ClassTemplateSpecializationDecl{{.*}} class testPack
+ // CHECK-NEXT: TemplateArgument{{.*}} integral 0
+ // CHECK-NEXT: TemplateArgument{{.*}} pack
+ // CHECK-NEXT: TemplateArgument{{.*}} integral 1
+ // CHECK-NEXT: TemplateArgument{{.*}} integral 2
+}
+
+namespace testUsingDecl {
+ int i;
+}
+namespace TestUsingDecl {
+ using testUsingDecl::i;
+}
+// CHECK: NamespaceDecl{{.*}} TestUsingDecl
+// CHECK-NEXT: UsingDecl{{.*}} testUsingDecl::i
+// CHECK-NEXT: UsingShadowDecl{{.*}} Var{{.*}} 'i' 'int'
+
+namespace testUnresolvedUsing {
+ class A { };
+ template<class T> class B {
+ public:
+ A a;
+ };
+ template<class T> class TestUnresolvedUsing : public B<T> {
+ using typename B<T>::a;
+ using B<T>::a;
+ };
+}
+// CHECK: CXXRecordDecl{{.*}} TestUnresolvedUsing
+// CHECK: UnresolvedUsingTypenameDecl{{.*}} B<T>::a
+// CHECK: UnresolvedUsingValueDecl{{.*}} B<T>::a
+
+namespace TestLinkageSpecDecl {
+ extern "C" void test1();
+ extern "C++" void test2();
+}
+// CHECK: NamespaceDecl{{.*}} TestLinkageSpecDecl
+// CHECK-NEXT: LinkageSpecDecl{{.*}} C
+// CHECK-NEXT: FunctionDecl
+// CHECK-NEXT: LinkageSpecDecl{{.*}} C++
+// CHECK-NEXT: FunctionDecl
+
+class TestAccessSpecDecl {
+public:
+private:
+protected:
+};
+// CHECK: CXXRecordDecl{{.*}} class TestAccessSpecDecl
+// CHECK-NEXT: CXXRecordDecl{{.*}} class TestAccessSpecDecl
+// CHECK-NEXT: AccessSpecDecl{{.*}} public
+// CHECK-NEXT: AccessSpecDecl{{.*}} private
+// CHECK-NEXT: AccessSpecDecl{{.*}} protected
+
+template<typename T> class TestFriendDecl {
+ friend int foo();
+ friend class A;
+ friend T;
+};
+// CHECK: CXXRecord{{.*}} TestFriendDecl
+// CHECK-NEXT: CXXRecord{{.*}} TestFriendDecl
+// CHECK-NEXT: FriendDecl
+// CHECK-NEXT: FunctionDecl{{.*}} foo
+// CHECK-NEXT: FriendDecl{{.*}} 'class A':'class A'
+// CHECK-NEXT: FriendDecl{{.*}} 'T'
+
+namespace TestFileScopeAsmDecl {
+ asm("ret");
+}
+// CHECK: NamespaceDecl{{.*}} TestFileScopeAsmDecl{{$}}
+// CHECK: FileScopeAsmDecl{{.*>$}}
+// CHECK-NEXT: StringLiteral
diff --git a/clang/test/Misc/ast-dump-decl.m b/clang/test/Misc/ast-dump-decl.m
new file mode 100644
index 0000000..f8a5e5a2
--- /dev/null
+++ b/clang/test/Misc/ast-dump-decl.m
@@ -0,0 +1,136 @@
+// RUN: %clang_cc1 -Wno-unused -fblocks -ast-dump -ast-dump-filter Test %s | FileCheck -strict-whitespace %s
+
+@protocol P
+@end
+
+@interface A
+@end
+
+@interface TestObjCIvarDecl : A
+@end
+
+@implementation TestObjCIvarDecl {
+ int varDefault;
+ @private int varPrivate;
+ @protected int varProtected;
+ @public int varPublic;
+ @package int varPackage;
+}
+@end
+// CHECK: ObjCImplementationDecl{{.*}} TestObjCIvarDecl
+// CHECK-NEXT: ObjCInterface{{.*}} 'TestObjCIvarDecl'
+// CHECK-NEXT: ObjCIvarDecl{{.*}} varDefault 'int' private
+// CHECK-NEXT: ObjCIvarDecl{{.*}} varPrivate 'int' private
+// CHECK-NEXT: ObjCIvarDecl{{.*}} varProtected 'int' protected
+// CHECK-NEXT: ObjCIvarDecl{{.*}} varPublic 'int' public
+// CHECK-NEXT: ObjCIvarDecl{{.*}} varPackage 'int' package
+
+@interface testObjCMethodDecl : A {
+}
+- (int) TestObjCMethodDecl: (int)i, ...;
+// CHECK: ObjCMethodDecl{{.*}} - TestObjCMethodDecl: 'int'
+// CHECK-NEXT: ParmVarDecl{{.*}} i 'int'
+// CHECK-NEXT: ...
+@end
+
+@implementation testObjCMethodDecl
+- (int) TestObjCMethodDecl: (int)i, ... {
+ return 0;
+}
+// CHECK: ObjCMethodDecl{{.*}} - TestObjCMethodDecl: 'int'
+// CHECK-NEXT: ImplicitParamDecl{{.*}} self
+// CHECK-NEXT: ImplicitParamDecl{{.*}} _cmd
+// CHECK-NEXT: ParmVarDecl{{.*}} i 'int'
+// CHECK-NEXT: ...
+// CHECK-NEXT: CompoundStmt
+@end
+
+@protocol TestObjCProtocolDecl
+- (void) foo;
+@end
+// CHECK: ObjCProtocolDecl{{.*}} TestObjCProtocolDecl
+// CHECK-NEXT: ObjCMethodDecl{{.*}} foo
+
+@interface TestObjCClass : A <P>
+- (void) foo;
+@end
+// CHECK: ObjCInterfaceDecl{{.*}} TestObjCClass
+// CHECK-NEXT: super ObjCInterface{{.*}} 'A'
+// CHECK-NEXT: ObjCImplementation{{.*}} 'TestObjCClass'
+// CHECK-NEXT: ObjCProtocol{{.*}} 'P'
+// CHECK-NEXT: ObjCMethodDecl{{.*}} foo
+
+@implementation TestObjCClass : A {
+ int i;
+}
+- (void) foo {
+}
+@end
+// CHECK: ObjCImplementationDecl{{.*}} TestObjCClass
+// CHECK-NEXT: super ObjCInterface{{.*}} 'A'
+// CHECK-NEXT: ObjCInterface{{.*}} 'TestObjCClass'
+// CHECK-NEXT: ObjCIvarDecl{{.*}} i
+// CHECK-NEXT: ObjCMethodDecl{{.*}} foo
+
+@interface TestObjCClass (TestObjCCategoryDecl) <P>
+- (void) bar;
+@end
+// CHECK: ObjCCategoryDecl{{.*}} TestObjCCategoryDecl
+// CHECK-NEXT: ObjCInterface{{.*}} 'TestObjCClass'
+// CHECK-NEXT: ObjCCategoryImpl{{.*}} 'TestObjCClass'
+// CHECK-NEXT: ObjCProtocol{{.*}} 'P'
+// CHECK-NEXT: ObjCMethodDecl{{.*}} bar
+
+@implementation TestObjCClass (TestObjCCategoryDecl)
+- (void) bar {
+}
+@end
+// CHECK: ObjCCategoryImplDecl{{.*}} TestObjCClass
+// CHECK-NEXT: ObjCInterface{{.*}} 'TestObjCClass'
+// CHECK-NEXT: ObjCCategory{{.*}} 'TestObjCCategoryDecl'
+// CHECK-NEXT: ObjCMethodDecl{{.*}} bar
+
+@compatibility_alias TestObjCCompatibleAliasDecl A;
+// CHECK: ObjCCompatibleAliasDecl{{.*}} TestObjCCompatibleAliasDecl
+// CHECK-NEXT: ObjCInterface{{.*}} 'A'
+
+@interface TestObjCProperty: A
+@property(getter=getterFoo, setter=setterFoo:) int foo;
+@property int bar;
+@end
+// CHECK: ObjCInterfaceDecl{{.*}} TestObjCProperty
+// CHECK: ObjCPropertyDecl{{.*}} foo 'int' assign readwrite atomic unsafe_unretained
+// CHECK-NEXT: getter ObjCMethod{{.*}} 'getterFoo'
+// CHECK-NEXT: setter ObjCMethod{{.*}} 'setterFoo:'
+// CHECK-NEXT: ObjCPropertyDecl{{.*}} bar 'int' assign readwrite atomic unsafe_unretained
+// CHECK-NEXT: ObjCMethodDecl{{.*}} getterFoo
+// CHECK-NEXT: ObjCMethodDecl{{.*}} setterFoo:
+// CHECK-NEXT: ParmVarDecl{{.*}} foo
+// CHECK-NEXT: ObjCMethodDecl{{.*}} bar
+// CHECK-NEXT: ObjCMethodDecl{{.*}} setBar:
+// CHECK-NEXT: ParmVarDecl{{.*}} bar
+
+@implementation TestObjCProperty {
+ int i;
+}
+@synthesize foo=i;
+@synthesize bar;
+@end
+// CHECK: ObjCImplementationDecl{{.*}} TestObjCProperty
+// CHECK: ObjCPropertyImplDecl{{.*}} foo synthesize
+// CHECK-NEXT: ObjCProperty{{.*}} 'foo'
+// CHECK-NEXT: ObjCIvar{{.*}} 'i' 'int'
+// CHECK-NEXT: ObjCIvarDecl{{.*}} bar 'int' synthesize private
+// CHECK-NEXT: ObjCPropertyImplDecl{{.*}} bar synthesize
+// CHECK-NEXT: ObjCProperty{{.*}} 'bar'
+// CHECK-NEXT: ObjCIvar{{.*}} 'bar' 'int'
+
+void TestBlockDecl(int x) {
+ ^(int y, ...){ x; };
+}
+// CHECK: FunctionDecl{{.*}}TestBlockDecl
+// CHECK: BlockDecl
+// CHECK-NEXT: ParmVarDecl{{.*}} y 'int'
+// CHECK-NEXT: ...
+// CHECK-NEXT: capture ParmVar{{.*}} 'x' 'int'
+// CHECK-NEXT: CompoundStmt
diff --git a/clang/test/Misc/ast-dump-decl.mm b/clang/test/Misc/ast-dump-decl.mm
new file mode 100644
index 0000000..06ab515
--- /dev/null
+++ b/clang/test/Misc/ast-dump-decl.mm
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -Wno-unused -fblocks -ast-dump -ast-dump-filter Test %s | FileCheck -strict-whitespace %s
+
+@interface A
+@end
+
+@interface TestObjCImplementation : A
+@end
+
+@implementation TestObjCImplementation : A {
+ struct X {
+ int i;
+ } X;
+}
+- (void) foo {
+}
+@end
+// CHECK: ObjCImplementationDecl{{.*}} TestObjCImplementation
+// CHECK-NEXT: super ObjCInterface{{.*}} 'A'
+// CHECK-NEXT: ObjCInterface{{.*}} 'TestObjCImplementation'
+// CHECK-NEXT: CXXCtorInitializer{{.*}} 'X'
+// CHECK-NEXT: CXXConstructExpr
+// CHECK-NEXT: ObjCIvarDecl{{.*}} X
+// CHECK-NEXT: ObjCMethodDecl{{.*}} foo
diff --git a/clang/test/Misc/ast-dump-stmt.c b/clang/test/Misc/ast-dump-stmt.c
index d7fdce8..0df236e 100644
--- a/clang/test/Misc/ast-dump-stmt.c
+++ b/clang/test/Misc/ast-dump-stmt.c
@@ -1,31 +1,31 @@
// RUN: %clang_cc1 -ast-dump -ast-dump-filter Test %s | FileCheck -strict-whitespace %s
int TestLocation = 0;
-// CHECK: Dumping TestLocation
-// CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <{{.*}}:3:20> 'int' 0
+// CHECK: VarDecl{{.*}}TestLocation
+// CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:20> 'int' 0
int TestIndent = 1 + (1);
-// CHECK: Dumping TestIndent
-// CHECK-NEXT: {{\(BinaryOperator[^()]*$}}
-// CHECK-NEXT: {{^ \(IntegerLiteral.*0[^()]*\)$}}
-// CHECK-NEXT: {{^ \(ParenExpr.*0[^()]*$}}
-// CHECK-NEXT: {{^ \(IntegerLiteral.*0[^()]*\)\)\)$}}
+// CHECK: VarDecl{{.*}}TestIndent
+// CHECK-NEXT: {{^ \(BinaryOperator[^()]*$}}
+// CHECK-NEXT: {{^ \(IntegerLiteral.*0[^()]*\)$}}
+// CHECK-NEXT: {{^ \(ParenExpr.*0[^()]*$}}
+// CHECK-NEXT: {{^ \(IntegerLiteral.*0[^()]*\)\)\)\)$}}
void TestDeclStmt() {
int x = 0;
int y, z;
}
-// CHECK: Dumping TestDeclStmt
+// CHECK: FunctionDecl{{.*}}TestDeclStmt
// CHECK-NEXT: CompoundStmt
// CHECK-NEXT: DeclStmt
-// CHECK-NEXT: int x =
+// CHECK-NEXT: VarDecl{{.*}}x
// CHECK-NEXT: IntegerLiteral
// CHECK-NEXT: DeclStmt
-// CHECK-NEXT: int y
-// CHECK-NEXT: int z
+// CHECK-NEXT: VarDecl{{.*}}y
+// CHECK-NEXT: VarDecl{{.*}}z
int TestOpaqueValueExpr = 0 ?: 1;
-// CHECK: Dumping TestOpaqueValueExpr
+// CHECK: VarDecl{{.*}}TestOpaqueValueExpr
// CHECK-NEXT: BinaryConditionalOperator
// CHECK-NEXT: IntegerLiteral
// CHECK-NEXT: OpaqueValueExpr
diff --git a/clang/test/Misc/ast-dump-stmt.m b/clang/test/Misc/ast-dump-stmt.m
index 8dfee74..8c0ca89 100644
--- a/clang/test/Misc/ast-dump-stmt.m
+++ b/clang/test/Misc/ast-dump-stmt.m
@@ -3,15 +3,14 @@
void TestBlockExpr(int x) {
^{ x; };
}
-// CHECK: Dumping TestBlockExpr
-// CHECK: BlockExpr{{.*}} decl=
-// CHECK-NEXT: capture ParmVar
-// CHECK-NEXT: CompoundStmt
+// CHECK: FunctionDecl{{.*}}TestBlockExpr
+// CHECK: BlockExpr{{.*}} 'void (^)(void)'
+// CHECK-NEXT: BlockDecl
void TestExprWithCleanup(int x) {
^{ x; };
}
-// CHECK: Dumping TestExprWithCleanup
+// CHECK: FunctionDecl{{.*}}TestExprWithCleanup
// CHECK: ExprWithCleanups
// CHECK-NEXT: cleanup Block
// CHECK-NEXT: BlockExpr
@@ -26,10 +25,11 @@
} @finally {
}
}
-// CHECK: Dumping TestObjCAtCatchStmt
+// CHECK: FunctionDecl{{.*}}TestObjCAtCatchStmt
// CHECK: ObjCAtTryStmt
// CHECK-NEXT: CompoundStmt
-// CHECK-NEXT: ObjCAtCatchStmt{{.*}} catch parm = "A *a"
+// CHECK-NEXT: ObjCAtCatchStmt{{.*}}
+// CHECK-NEXT: VarDecl{{.*}}a
// CHECK-NEXT: CompoundStmt
// CHECK-NEXT: ObjCAtCatchStmt{{.*}} catch all
// CHECK-NEXT: CompoundStmt
diff --git a/clang/test/Misc/ast-dump-templates.cpp b/clang/test/Misc/ast-dump-templates.cpp
index 7d56e7b..7e28da9 100644
--- a/clang/test/Misc/ast-dump-templates.cpp
+++ b/clang/test/Misc/ast-dump-templates.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -ast-dump %s > %t
+// RUN: %clang_cc1 -ast-print %s > %t
// RUN: FileCheck < %t %s -check-prefix=CHECK1
// RUN: FileCheck < %t %s -check-prefix=CHECK2
@@ -27,8 +27,8 @@
// CHECK2: template <int X = 2, typename Y = double, int Z = 3> struct foo {
// Template definition - foo
-// CHECK1: template <int X, typename Y, int Z = (IntegerLiteral {{.*}} 'int' 5)
-// CHECK2: template <int X, typename Y, int Z = (IntegerLiteral {{.*}} 'int' 5)
+// CHECK1: template <int X, typename Y, int Z = 5> struct foo {
+// CHECK2: template <int X, typename Y, int Z = 5> struct foo {
// Template instantiation - bar
// CHECK1: template <int A = 5, typename B = int> int bar()
diff --git a/clang/test/Misc/ast-dump-wchar.cpp b/clang/test/Misc/ast-dump-wchar.cpp
index 87d962f..1dca83c 100644
--- a/clang/test/Misc/ast-dump-wchar.cpp
+++ b/clang/test/Misc/ast-dump-wchar.cpp
@@ -1,13 +1,13 @@
// RUN: %clang_cc1 -std=c++11 -ast-dump %s -triple x86_64-linux-gnu | FileCheck %s
char c8[] = u8"test\0\\\"\t\a\b\234";
-// CHECK: char c8[12] = (StringLiteral {{.*}} lvalue u8"test\000\\\"\t\a\b\234")
+// CHECK: (StringLiteral {{.*}} lvalue u8"test\000\\\"\t\a\b\234")
char16_t c16[] = u"test\0\\\"\t\a\b\234\u1234";
-// CHECK: char16_t c16[13] = (StringLiteral {{.*}} lvalue u"test\000\\\"\t\a\b\234\u1234")
+// CHECK: (StringLiteral {{.*}} lvalue u"test\000\\\"\t\a\b\234\u1234")
char32_t c32[] = U"test\0\\\"\t\a\b\234\u1234\U0010ffff"; // \
-// CHECK: char32_t c32[14] = (StringLiteral {{.*}} lvalue U"test\000\\\"\t\a\b\234\u1234\U0010FFFF")
+// CHECK: (StringLiteral {{.*}} lvalue U"test\000\\\"\t\a\b\234\u1234\U0010FFFF")
wchar_t wc[] = L"test\0\\\"\t\a\b\234\u1234\xffffffff"; // \
-// CHECK: wchar_t wc[14] = (StringLiteral {{.*}} lvalue L"test\000\\\"\t\a\b\234\x1234\xFFFFFFFF")
+// CHECK: (StringLiteral {{.*}} lvalue L"test\000\\\"\t\a\b\234\x1234\xFFFFFFFF")
diff --git a/clang/test/PCH/objc_stmts.m b/clang/test/PCH/objc_stmts.m
index b9b10c5..8deb14a 100644
--- a/clang/test/PCH/objc_stmts.m
+++ b/clang/test/PCH/objc_stmts.m
@@ -1,12 +1,12 @@
// Test this without pch.
// RUN: %clang_cc1 -include %S/objc_stmts.h -emit-llvm -fobjc-exceptions -o - %s
-// RUN: %clang_cc1 -include %S/objc_stmts.h -ast-dump -fobjc-exceptions -o - %s | FileCheck %s
+// RUN: %clang_cc1 -include %S/objc_stmts.h -ast-print -fobjc-exceptions -o - %s | FileCheck %s
// Test with pch.
// RUN: %clang_cc1 -x objective-c -emit-pch -fobjc-exceptions -o %t %S/objc_stmts.h
// RUN: %clang_cc1 -include-pch %t -emit-llvm -fobjc-exceptions -o - %s
-// RUN: %clang_cc1 -include-pch %t -ast-dump -fobjc-exceptions -o - %s | FileCheck %s
+// RUN: %clang_cc1 -include-pch %t -ast-print -fobjc-exceptions -o - %s | FileCheck %s
-// CHECK: catch parm = "A *a"
-// CHECK: catch parm = "B *b"
-// CHECK: catch all
+// CHECK: @catch(A *a)
+// CHECK: @catch(B *b)
+// CHECK: @catch()
diff --git a/clang/test/SemaTemplate/default-expr-arguments-2.cpp b/clang/test/SemaTemplate/default-expr-arguments-2.cpp
index 378999d..0379494 100644
--- a/clang/test/SemaTemplate/default-expr-arguments-2.cpp
+++ b/clang/test/SemaTemplate/default-expr-arguments-2.cpp
@@ -10,9 +10,9 @@
bar(int x = kSomeConst) {}
};
- // CHECK: void f()
+ // CHECK: FunctionDecl{{.*}}f 'void (void)'
void f() {
- // CHECK: bar<int> tmp =
+ // CHECK: VarDecl{{.*}}tmp 'bar<int>'
// CHECK: CXXDefaultArgExpr{{.*}}'int'
bar<int> tmp;
}
diff --git a/clang/test/Tooling/clang-check-ast-dump.cpp b/clang/test/Tooling/clang-check-ast-dump.cpp
index 6e03f82..90827e1 100644
--- a/clang/test/Tooling/clang-check-ast-dump.cpp
+++ b/clang/test/Tooling/clang-check-ast-dump.cpp
@@ -1,15 +1,19 @@
// RUN: clang-check -ast-dump "%s" -- 2>&1 | FileCheck %s
-// CHECK: namespace test_namespace
-// CHECK-NEXT: class TheClass
-// CHECK: int theMethod(int x) (CompoundStmt
+// CHECK: (NamespaceDecl{{.*}}test_namespace
+// CHECK-NEXT: (CXXRecordDecl{{.*}}TheClass
+// CHECK: (CXXMethodDecl{{.*}}theMethod
+// CHECK-NEXT: (ParmVarDecl{{.*}}x
+// CHECK-NEXT: (CompoundStmt
// CHECK-NEXT: (ReturnStmt
// CHECK-NEXT: (BinaryOperator
//
// RUN: clang-check -ast-dump -ast-dump-filter test_namespace::TheClass::theMethod "%s" -- 2>&1 | FileCheck -check-prefix CHECK-FILTER %s
-// CHECK-FILTER-NOT: namespace test_namespace
-// CHECK-FILTER-NOT: class TheClass
+// CHECK-FILTER-NOT: NamespaceDecl
+// CHECK-FILTER-NOT: CXXRecordDecl
// CHECK-FILTER: {{^}}Dumping test_namespace::TheClass::theMethod
-// CHECK-FILTER-NEXT: {{^}}int theMethod(int x) (CompoundStmt
+// CHECK-FILTER-NEXT: {{^}}(CXXMethodDecl{{.*}}theMethod
+// CHECK-FILTER-NEXT: (ParmVarDecl{{.*}}x
+// CHECK-FILTER-NEXT: (CompoundStmt
// CHECK-FILTER-NEXT: (ReturnStmt
// CHECK-FILTER-NEXT: (BinaryOperator
//
@@ -26,7 +30,8 @@
//
// RUN: clang-check -ast-dump -ast-dump-filter test_namespace::TheClass::n "%s" -- 2>&1 | FileCheck -check-prefix CHECK-ATTR %s
// CHECK-ATTR: test_namespace
-// CHECK-ATTR-NEXT: int n __attribute__((aligned((BinaryOperator
+// CHECK-ATTR-NEXT: (FieldDecl{{.*}}n
+// FIXME: attribute dumping not implemented yet
//
// RUN: clang-check -ast-dump -ast-dump-filter test_namespace::AfterNullNode "%s" -- 2>&1 | FileCheck -check-prefix CHECK-AFTER-NULL %s
// CHECK-AFTER-NULL: class AfterNullNode