1 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c++2a -ast-dump -ast-dump-decl-types -ast-dump-filter Foo %s | FileCheck -strict-whitespace %s 2 3 // Test with serialization: 4 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown -emit-pch -o %t %s 5 // RUN: %clang_cc1 -x c++ -std=c++20 -triple x86_64-unknown-unknown -include-pch %t \ 6 // RUN: -ast-dump-all -ast-dump-decl-types -ast-dump-filter Foo /dev/null \ 7 // RUN: | FileCheck --strict-whitespace %s 8 9 template <typename T> 10 concept unary_concept = true; 11 12 template <typename T, typename U> 13 concept binary_concept = true; 14 15 template <typename... Ts> 16 concept variadic_concept = true; 17 18 template <typename T> 19 struct Foo { 20 // CHECK: TemplateTypeParmDecl {{.*}} referenced Concept {{.*}} 'binary_concept' 21 // CHECK-NEXT: `-ConceptSpecializationExpr {{.*}} <col:13, col:31> 'bool' Concept {{.*}} 'binary_concept' 22 // CHECK-NEXT: |-ImplicitConceptSpecializationDecl {{.*}} <line:13:9> col:9 23 // CHECK-NEXT: | |-TemplateArgument type 'type-parameter-1-0' 24 // CHECK-NEXT: | | `-TemplateTypeParmType {{.*}} 'type-parameter-1-0' dependent {{.*}}depth 1 index 0 25 // CHECK-NEXT: | `-TemplateArgument type 'int' 26 // CHECK-NEXT: | `-BuiltinType {{.*}} 'int' 27 // CHECK-NEXT: |-TemplateArgument {{.*}} type 'R' 28 // CHECK-NEXT: | `-TemplateTypeParmType {{.*}} 'R' 29 // CHECK-NEXT: | `-TemplateTypeParm {{.*}} 'R' 30 // CHECK-NEXT: `-TemplateArgument {{.*}} type 'int' 31 // CHECK-NEXT: `-BuiltinType {{.*}} 'int' 32 template <binary_concept<int> R> 33 Foo(R); 34 35 // CHECK: TemplateTypeParmDecl {{.*}} referenced Concept {{.*}} 'unary_concept' 36 // CHECK-NEXT: `-ConceptSpecializationExpr {{.*}} <col:13> 'bool' 37 // CHECK-NEXT: |-ImplicitConceptSpecializationDecl {{.*}} <line:10:9> col:9 38 // CHECK-NEXT: | `-TemplateArgument type 'type-parameter-1-0' 39 // CHECK-NEXT: | `-TemplateTypeParmType {{.*}} 'type-parameter-1-0' dependent {{.*}}depth 1 index 0 40 template <unary_concept R> 41 Foo(R); 42 43 // CHECK: FunctionTemplateDecl {{.*}} <line:[[@LINE+1]]:3, line:[[@LINE+2]]:39> {{.*}} Foo<T> 44 template <typename R> 45 Foo(R, int) requires unary_concept<R>; 46 47 // CHECK: FunctionTemplateDecl {{.*}} <line:[[@LINE+1]]:3, line:[[@LINE+3]]:3> {{.*}} Foo<T> 48 template <typename R> 49 Foo(R, char) requires unary_concept<R> { 50 } 51 52 // CHECK: CXXFoldExpr {{.*}} <col:13, col:29> 53 template <variadic_concept... Ts> 54 Foo(); 55 56 // CHECK: CXXFoldExpr {{.*}} <col:13, col:34> 57 template <variadic_concept<int>... Ts> 58 Foo(); 59 60 // CHECK:InjectedClassNameType 61 // CHECK-NEXT: CXXRecord {{.*}} 'Foo' 62 }; 63 64 namespace GH82628 { 65 namespace ns { 66 67 template <typename T> 68 concept C = true; 69 70 } // namespace ns 71 72 using ns::C; 73 74 // CHECK: ConceptDecl {{.*}} Foo 75 // CHECK-NEXT: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 0 T 76 // CHECK-NEXT: `-ConceptSpecializationExpr {{.*}} UsingShadow {{.*}} 'C' 77 template <typename T> 78 concept Foo = C<T>; 79 80 // CHECK: TemplateTypeParmDecl {{.*}} Concept {{.*}} 'C' (UsingShadow {{.*}} 'C') 81 // CHECK: QualType 82 // CHECK-NEXT: `-BuiltinType {{.*}} 'bool' 83 template <C T> 84 constexpr bool FooVar = false; 85 86 // CHECK: ConceptSpecializationExpr {{.*}} UsingShadow {{.*}} 'C' 87 // CHECK: QualType 88 // CHECK-NEXT: `-BuiltinType {{.*}} 'bool' 89 template <typename T> requires C<T> 90 constexpr bool FooVar2 = true; 91 92 // CHECK: SimpleRequirement 93 // CHECK-NEXT: `-ConceptSpecializationExpr {{.*}} UsingShadow {{.*}} 'C' 94 // CHECK: QualType 95 // CHECK-NEXT: `-BuiltinType {{.*}} 'bool' 96 template <typename T> requires requires (T) { C<T>; } 97 constexpr bool FooVar3 = true; 98 99 // CHECK: NonTypeTemplateParmDecl 100 // CHECK-NEXT: `-ConceptSpecializationExpr {{.*}} UsingShadow {{.*}} 'C' 101 // CHECK: QualType 102 // CHECK-NEXT: `-BuiltinType {{.*}} 'bool' 103 template <C auto T> 104 constexpr bool FooVar4 = bool(T()); 105 106 // CHECK: FunctionTemplateDecl 107 // CHECK-NEXT: |-TemplateTypeParmDecl {{.*}} Concept {{.*}} 'C' (UsingShadow {{.*}} 'C') depth 0 index 0 ... T 108 // CHECK: NonTypeTemplateParmDecl {{.*}} depth 0 index 1 U 109 // CHECK-NEXT: `-ConceptSpecializationExpr {{.*}} UsingShadow {{.*}} 'C' 110 // CHECK: |-TemplateTypeParmDecl {{.*}} Concept {{.*}} 'C' (UsingShadow {{.*}} 'C') depth 0 index 2 V:auto 111 // CHECK: FunctionProtoType 112 // CHECK: `-Concept {{.*}} 'C' 113 // CHECK: `-TemplateTypeParm {{.*}} 'V:auto' 114 template <C... T, C auto U> 115 auto FooFunc(C auto V) -> C decltype(auto) { 116 // FIXME: TypeLocs inside of the function body cannot be dumped via -ast-dump for now. 117 // See clang-tools-extra/clangd/unittests/SelectionTests.cpp:SelectionTest.UsingConcepts for their checkings. 118 C auto W = V; 119 return W; 120 } 121 122 } 123 124 namespace constraint_auto_params { 125 126 template <class T, class K> 127 concept C = true; 128 129 template<class T> 130 void g(C<T> auto Foo) {} 131 132 // CHECK: TemplateTypeParmDecl {{.*}} depth 0 index 1 Foo:auto 133 // CHECK-NEXT: `-ConceptSpecializationExpr {{.*}} <col:8, col:11> 134 135 } 136