clang/test/SemaTemplate/attributes.cpp

   1 // RUN: %clang_cc1 -std=gnu++11 -fsyntax-only -verify %s
   2 // RUN: not %clang_cc1 -std=gnu++11 -ast-dump %s | FileCheck %s
   3
   4 namespace attribute_aligned {
   5   template<int N>
   6   struct X {
   7     char c[1] __attribute__((__aligned__((N)))); // expected-error {{alignment is not a power of 2}}
   8   };
   9
  10   template <bool X> struct check {
  11     int check_failed[X ? 1 : -1]; // expected-error {{array with a negative size}}
  12   };
  13
  14   template <int N> struct check_alignment {
  15     typedef check<N == sizeof(X<N>)> t; // expected-note {{in instantiation}}
  16   };
  17
  18   check_alignment<1>::t c1;
  19   check_alignment<2>::t c2;
  20   check_alignment<3>::t c3; // expected-note 2 {{in instantiation}}
  21   check_alignment<4>::t c4;
  22
  23   template<unsigned Size, unsigned Align>
  24   class my_aligned_storage
  25   {
  26     __attribute__((aligned(Align))) char storage[Size];
  27   };
  28
  29   template<typename T>
  30   class C {
  31   public:
  32     C() {
  33       static_assert(sizeof(t) == sizeof(T), "my_aligned_storage size wrong");
  34       static_assert(alignof(t) == alignof(T), "my_aligned_storage align wrong"); // expected-warning{{'alignof' applied to an expression is a GNU extension}}
  35     }
  36
  37   private:
  38     my_aligned_storage<sizeof(T), alignof(T)> t;
  39   };
  40
  41   C<double> cd;
  42 }
  43
  44 namespace PR9049 {
  45   extern const void *CFRetain(const void *ref);
  46
  47   template<typename T> __attribute__((cf_returns_retained))
  48   inline T WBCFRetain(T aValue) { return aValue ? (T)CFRetain(aValue) : (T)0; }
  49
  50
  51   extern void CFRelease(const void *ref);
  52
  53   template<typename T>
  54   inline void WBCFRelease(__attribute__((cf_consumed)) T aValue) { if(aValue) CFRelease(aValue); }
  55 }
  56
  57 namespace attribute_annotate {
  58 // CHECK: FunctionTemplateDecl {{.*}} HasAnnotations
  59 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_FOO"
  60 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_BAR"
  61 // CHECK: FunctionDecl {{.*}} HasAnnotations
  62 // CHECK:   TemplateArgument type 'int'
  63 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_FOO"
  64 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_BAR"
  65 template<typename T> [[clang::annotate("ANNOTATE_FOO"), clang::annotate("ANNOTATE_BAR")]] void HasAnnotations();
  66 void UseAnnotations() { HasAnnotations<int>(); }
  67
  68 // CHECK: FunctionTemplateDecl {{.*}} HasStmtAnnotations
  69 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_BAZ"
  70 // CHECK: FunctionDecl {{.*}} HasStmtAnnotations
  71 // CHECK:   TemplateArgument type 'int'
  72 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_BAZ"
  73 template<typename T> void HasStmtAnnotations() {
  74   int x = 0;
  75   [[clang::annotate("ANNOTATE_BAZ")]] x++;
  76 }
  77 void UseStmtAnnotations() { HasStmtAnnotations<int>(); }
  78
  79 // CHECK:      FunctionTemplateDecl {{.*}} HasPackAnnotations
  80 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
  81 // CHECK-NEXT:   FunctionDecl {{.*}} HasPackAnnotations 'void ()'
  82 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BAZ"
  83 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
  84 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
  85 // CHECK-NEXT:   FunctionDecl {{.*}} used HasPackAnnotations 'void ()'
  86 // CHECK-NEXT:     TemplateArgument{{.*}} pack
  87 // CHECK-NEXT:       TemplateArgument{{.*}} integral '1'
  88 // CHECK-NEXT:       TemplateArgument{{.*}} integral '2'
  89 // CHECK-NEXT:       TemplateArgument{{.*}} integral '3'
  90 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BAZ"
  91 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
  92 // CHECK-NEXT:         value: Int 1
  93 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
  94 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
  95 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 1
  96 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
  97 // CHECK-NEXT:         value: Int 2
  98 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
  99 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 100 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 2
 101 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 102 // CHECK-NEXT:         value: Int 3
 103 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 104 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 105 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 3
 106 template <int... Is> [[clang::annotate("ANNOTATE_BAZ", Is...)]] void HasPackAnnotations();
 107 void UsePackAnnotations() { HasPackAnnotations<1, 2, 3>(); }
 108
 109 // CHECK:      FunctionTemplateDecl {{.*}} HasStmtPackAnnotations
 110 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 111 // CHECK-NEXT:   FunctionDecl {{.*}} HasStmtPackAnnotations 'void ()'
 112 // CHECK:          AttributedStmt {{.*}}
 113 // CHECK-NEXT:       AnnotateAttr {{.*}} "ANNOTATE_QUUX"
 114 // CHECK-NEXT:         PackExpansionExpr {{.*}} '<dependent type>'
 115 // CHECK-NEXT:           DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 116 // CHECK:        FunctionDecl {{.*}} used HasStmtPackAnnotations 'void ()'
 117 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 118 // CHECK-NEXT:       TemplateArgument{{.*}} integral '1'
 119 // CHECK-NEXT:       TemplateArgument{{.*}} integral '2'
 120 // CHECK-NEXT:       TemplateArgument{{.*}} integral '3'
 121 // CHECK:          AttributedStmt {{.*}}
 122 // CHECK-NEXT:       AnnotateAttr {{.*}} "ANNOTATE_QUUX"
 123 // CHECK-NEXT:         PackExpansionExpr {{.*}}
 124 // CHECK-NEXT:         SubstNonTypeTemplateParmPackExpr {{.*}}
 125 // CHECK-NEXT:         NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 126 // CHECK-NEXT:           TemplateArgument pack '<1, 2, 3>'
 127 // CHECK-NEXT:             TemplateArgument integral '1'
 128 // CHECK-NEXT:             TemplateArgument integral '2'
 129 // CHECK-NEXT:             TemplateArgument integral '3'
 130 template <int... Is> void HasStmtPackAnnotations() {
 131   int x = 0;
 132   [[clang::annotate("ANNOTATE_QUUX", Is...)]] x++;
 133 }
 134 void UseStmtPackAnnotations() { HasStmtPackAnnotations<1, 2, 3>(); }
 135
 136 template <int... Is> [[clang::annotate(Is...)]] void HasOnlyPackAnnotation() {} // expected-error {{expected string literal as argument of 'annotate' attribute}}
 137
 138 void UseOnlyPackAnnotations() {
 139   HasOnlyPackAnnotation<>();
 140   HasOnlyPackAnnotation<1>();
 141 }
 142
 143 // CHECK:      ClassTemplateDecl {{.*}} AnnotatedPackTemplateStruct
 144 // CHECK-NEXT:   TemplateTypeParmDecl {{.*}} typename depth 0 index 0 T
 145 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 1 ... Is
 146 // CHECK-NEXT:   CXXRecordDecl {{.*}} struct AnnotatedPackTemplateStruct definition
 147 // CHECK-NEXT:     DefinitionData
 148 // CHECK-NEXT:       DefaultConstructor
 149 // CHECK-NEXT:       CopyConstructor
 150 // CHECK-NEXT:       MoveConstructor
 151 // CHECK-NEXT:       CopyAssignment
 152 // CHECK-NEXT:       MoveAssignment
 153 // CHECK-NEXT:       Destructor
 154 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FOZ"
 155 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
 156 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 157 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
 158 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
 159 // CHECK-NEXT:     DefinitionData
 160 // CHECK-NEXT:       DefaultConstructor
 161 // CHECK-NEXT:       CopyConstructor
 162 // CHECK-NEXT:       MoveConstructor
 163 // CHECK-NEXT:       CopyAssignment
 164 // CHECK-NEXT:       MoveAssignment
 165 // CHECK-NEXT:       Destructor
 166 // CHECK-NEXT:     TemplateArgument{{.*}} type 'int'
 167 // CHECK-NEXT:       BuiltinType {{.*}} 'int'
 168 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 169 // CHECK-NEXT:       TemplateArgument{{.*}} integral '1'
 170 // CHECK-NEXT:       TemplateArgument{{.*}} integral '2'
 171 // CHECK-NEXT:       TemplateArgument{{.*}} integral '3'
 172 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BOO"
 173 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 174 // CHECK-NEXT:         value: Int 1
 175 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 176 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 177 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 1
 178 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 179 // CHECK-NEXT:         value: Int 2
 180 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 181 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 182 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 2
 183 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 184 // CHECK-NEXT:         value: Int 3
 185 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 186 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 187 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 3
 188 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
 189 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
 190 // CHECK-NEXT:     DefinitionData
 191 // CHECK-NEXT:       DefaultConstructor
 192 // CHECK-NEXT:       CopyConstructor
 193 // CHECK-NEXT:       MoveConstructor
 194 // CHECK-NEXT:       CopyAssignment
 195 // CHECK-NEXT:       MoveAssignment
 196 // CHECK-NEXT:       Destructor
 197 // CHECK-NEXT:     TemplateArgument type 'float'
 198 // CHECK-NEXT:       BuiltinType {{.*}} 'float'
 199 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 200 // CHECK-NEXT:       TemplateArgument{{.*}} integral '3'
 201 // CHECK-NEXT:       TemplateArgument{{.*}} integral '2'
 202 // CHECK-NEXT:       TemplateArgument{{.*}} integral '1'
 203 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FOZ"
 204 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 205 // CHECK-NEXT:         value: Int 4
 206 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 4
 207 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 208 // CHECK-NEXT:         value: Int 5
 209 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 5
 210 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 211 // CHECK-NEXT:         value: Int 6
 212 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 6
 213 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
 214 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
 215 // CHECK-NEXT:     DefinitionData
 216 // CHECK-NEXT:       DefaultConstructor
 217 // CHECK-NEXT:       CopyConstructor
 218 // CHECK-NEXT:       MoveConstructor
 219 // CHECK-NEXT:       CopyAssignment
 220 // CHECK-NEXT:       MoveAssignment
 221 // CHECK-NEXT:       Destructor
 222 // CHECK-NEXT:     TemplateArgument type 'bool'
 223 // CHECK-NEXT:       BuiltinType {{.*}} 'bool'
 224 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 225 // CHECK-NEXT:       TemplateArgument{{.*}} integral '7'
 226 // CHECK-NEXT:       TemplateArgument{{.*}} integral '8'
 227 // CHECK-NEXT:       TemplateArgument{{.*}} integral '9'
 228 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FOZ"
 229 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 230 // CHECK-NEXT:         value: Int 7
 231 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 232 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 1 ... Is
 233 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 7
 234 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 235 // CHECK-NEXT:         value: Int 8
 236 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 237 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 1 ... Is
 238 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 8
 239 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 240 // CHECK-NEXT:         value: Int 9
 241 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 242 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 1 ... Is
 243 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 9
 244 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
 245 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
 246 // CHECK-NEXT:     DefinitionData
 247 // CHECK-NEXT:       DefaultConstructor
 248 // CHECK-NEXT:       CopyConstructor
 249 // CHECK-NEXT:       MoveConstructor
 250 // CHECK-NEXT:       CopyAssignment
 251 // CHECK-NEXT:       MoveAssignment
 252 // CHECK-NEXT:       Destructor
 253 // CHECK-NEXT:     TemplateArgument type 'char'
 254 // CHECK-NEXT:       BuiltinType {{.*}} 'char'
 255 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 256 // CHECK-NEXT:       TemplateArgument{{.*}} integral '1'
 257 // CHECK-NEXT:       TemplateArgument{{.*}} integral '2'
 258 // CHECK-NEXT:       TemplateArgument{{.*}} integral '3'
 259 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
 260 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
 261 // CHECK-NEXT:     DefinitionData
 262 // CHECK-NEXT:       DefaultConstructor
 263 // CHECK-NEXT:       CopyConstructor
 264 // CHECK-NEXT:       MoveConstructor
 265 // CHECK-NEXT:       CopyAssignment
 266 // CHECK-NEXT:       MoveAssignment
 267 // CHECK-NEXT:       Destructor
 268 // CHECK-NEXT:     TemplateArgument{{.*}} type 'char'
 269 // CHECK-NEXT:       BuiltinType {{.*}} 'char'
 270 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 271 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
 272 // CHECK-NEXT: ClassTemplatePartialSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
 273 // CHECK-NEXT:   DefinitionData
 274 // CHECK-NEXT:     DefaultConstructor
 275 // CHECK-NEXT:     CopyConstructor
 276 // CHECK-NEXT:     MoveConstructor
 277 // CHECK-NEXT:     CopyAssignment
 278 // CHECK-NEXT:     MoveAssignment
 279 // CHECK-NEXT:     Destructor
 280 // CHECK-NEXT:   TemplateArgument{{.*}} type 'int'
 281 // CHECK-NEXT:     BuiltinType {{.*}} 'int'
 282 // CHECK-NEXT:   TemplateArgument{{.*}} pack
 283 // CHECK-NEXT:     TemplateArgument{{.*}} expr
 284 // CHECK-NEXT:       PackExpansionExpr {{.*}} 'int'
 285 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 286 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 287 // CHECK-NEXT:   AnnotateAttr {{.*}} "ANNOTATE_BOO"
 288 // CHECK-NEXT:     PackExpansionExpr {{.*}} '<dependent type>'
 289 // CHECK-NEXT:       DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 290 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
 291 // CHECK-NEXT: ClassTemplatePartialSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
 292 // CHECK-NEXT:   DefinitionData
 293 // CHECK-NEXT:     DefaultConstructor
 294 // CHECK-NEXT:     CopyConstructor
 295 // CHECK-NEXT:     MoveConstructor
 296 // CHECK-NEXT:     CopyAssignment
 297 // CHECK-NEXT:     MoveAssignment
 298 // CHECK-NEXT:     Destructor
 299 // CHECK-NEXT:   TemplateArgument{{.*}} type 'float'
 300 // CHECK-NEXT:     BuiltinType {{.*}} 'float'
 301 // CHECK-NEXT:   TemplateArgument{{.*}} pack
 302 // CHECK-NEXT:     TemplateArgument{{.*}} expr
 303 // CHECK-NEXT:       PackExpansionExpr {{.*}} 'int'
 304 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 305 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 306 // CHECK-NEXT:   AnnotateAttr {{.*}} "ANNOTATE_FOZ"
 307 // CHECK-NEXT:     ConstantExpr {{.*}} 'int'
 308 // CHECK-NEXT:       value: Int 4
 309 // CHECK-NEXT:       IntegerLiteral {{.*}} 'int' 4
 310 // CHECK-NEXT:     ConstantExpr {{.*}} 'int'
 311 // CHECK-NEXT:       value: Int 5
 312 // CHECK-NEXT:       IntegerLiteral {{.*}} 'int' 5
 313 // CHECK-NEXT:     ConstantExpr {{.*}} 'int'
 314 // CHECK-NEXT:       value: Int 6
 315 // CHECK-NEXT:       IntegerLiteral {{.*}} 'int' 6
 316 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
 317 template <typename T, int... Is> struct [[clang::annotate("ANNOTATE_FOZ", Is...)]] AnnotatedPackTemplateStruct{};
 318 template <int... Is> struct [[clang::annotate("ANNOTATE_BOO", Is...)]] AnnotatedPackTemplateStruct<int, Is...>{};
 319 template <int... Is> struct [[clang::annotate("ANNOTATE_FOZ", 4, 5, 6)]] AnnotatedPackTemplateStruct<float, Is...>{};
 320 template <int... Is> struct [[clang::annotate(Is...)]] AnnotatedPackTemplateStruct<char, Is...>{}; // expected-error {{expected string literal as argument of 'annotate' attribute}}
 321 void UseAnnotatedPackTemplateStructSpecializations() {
 322   AnnotatedPackTemplateStruct<int, 1, 2, 3> Instance1{};
 323   AnnotatedPackTemplateStruct<float, 3, 2, 1> Instance2{};
 324   AnnotatedPackTemplateStruct<bool, 7, 8, 9> Instance3{};
 325   AnnotatedPackTemplateStruct<char, 1, 2, 3> Instance4{};
 326   AnnotatedPackTemplateStruct<char> Instance5{};
 327 }
 328
 329 // CHECK:      ClassTemplateDecl {{.*}} InvalidAnnotatedPackTemplateStruct
 330 // CHECK-NEXT:   TemplateTypeParmDecl {{.*}} typename depth 0 index 0 T
 331 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} 'int' depth 0 index 1 ... Is
 332 // CHECK-NEXT:   CXXRecordDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
 333 // CHECK-NEXT:     DefinitionData
 334 // CHECK-NEXT:       DefaultConstructor
 335 // CHECK-NEXT:       CopyConstructor
 336 // CHECK-NEXT:       MoveConstructor
 337 // CHECK-NEXT:       CopyAssignment
 338 // CHECK-NEXT:       MoveAssignment
 339 // CHECK-NEXT:       Destructor
 340 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
 341 // CHECK-NEXT:   ClassTemplateSpecialization {{.*}} 'InvalidAnnotatedPackTemplateStruct'
 342 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
 343 // CHECK-NEXT:     DefinitionData
 344 // CHECK-NEXT:       DefaultConstructor
 345 // CHECK-NEXT:       CopyConstructor
 346 // CHECK-NEXT:       MoveConstructor
 347 // CHECK-NEXT:       CopyAssignment
 348 // CHECK-NEXT:       MoveAssignment
 349 // CHECK-NEXT:       Destructor
 350 // CHECK-NEXT:     TemplateArgument{{.*}} type 'int'
 351 // CHECK-NEXT:       BuiltinType {{.*}} 'int'
 352 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 353 // CHECK-NEXT:       TemplateArgument{{.*}} integral '1'
 354 // CHECK-NEXT:       TemplateArgument{{.*}} integral '2'
 355 // CHECK-NEXT:       TemplateArgument{{.*}} integral '3'
 356 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BIR"
 357 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 358 // CHECK-NEXT:         value: Int 1
 359 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 360 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 361 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 1
 362 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 363 // CHECK-NEXT:         value: Int 2
 364 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 365 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 366 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 2
 367 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 368 // CHECK-NEXT:         value: Int 3
 369 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 370 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 371 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 3
 372 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
 373 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
 374 // CHECK-NEXT:     DefinitionData
 375 // CHECK-NEXT:       DefaultConstructor
 376 // CHECK-NEXT:       CopyConstructor
 377 // CHECK-NEXT:       MoveConstructor
 378 // CHECK-NEXT:       CopyAssignment
 379 // CHECK-NEXT:       MoveAssignment
 380 // CHECK-NEXT:       Destructor
 381 // CHECK-NEXT:     TemplateArgument{{.*}} type 'float'
 382 // CHECK-NEXT:       BuiltinType {{.*}} 'float'
 383 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 384 // CHECK-NEXT:       TemplateArgument{{.*}} integral '3'
 385 // CHECK-NEXT:       TemplateArgument{{.*}} integral '2'
 386 // CHECK-NEXT:       TemplateArgument{{.*}} integral '1'
 387 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
 388 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
 389 // CHECK-NEXT:     DefinitionData
 390 // CHECK-NEXT:       DefaultConstructor
 391 // CHECK-NEXT:       CopyConstructor
 392 // CHECK-NEXT:       MoveConstructor
 393 // CHECK-NEXT:       CopyAssignment
 394 // CHECK-NEXT:       MoveAssignment
 395 // CHECK-NEXT:       Destructor
 396 // CHECK-NEXT:     TemplateArgument{{.*}} type 'bool'
 397 // CHECK-NEXT:       BuiltinType {{.*}} 'bool'
 398 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 399 // CHECK-NEXT:       TemplateArgument{{.*}} integral '7'
 400 // CHECK-NEXT:       TemplateArgument{{.*}} integral '8'
 401 // CHECK-NEXT:       TemplateArgument{{.*}} integral '9'
 402 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
 403 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
 404 // CHECK-NEXT:     DefinitionData
 405 // CHECK-NEXT:       DefaultConstructor
 406 // CHECK-NEXT:       CopyConstructor
 407 // CHECK-NEXT:       MoveConstructor
 408 // CHECK-NEXT:       CopyAssignment
 409 // CHECK-NEXT:       MoveAssignment
 410 // CHECK-NEXT:       Destructor
 411 // CHECK-NEXT:     TemplateArgument{{.*}} type 'bool'
 412 // CHECK-NEXT:       BuiltinType {{.*}} 'bool'
 413 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 414 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
 415 // CHECK-NEXT: ClassTemplatePartialSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
 416 // CHECK-NEXT:   DefinitionData
 417 // CHECK-NEXT:     DefaultConstructor
 418 // CHECK-NEXT:     CopyConstructor
 419 // CHECK-NEXT:     MoveConstructor
 420 // CHECK-NEXT:     CopyAssignment
 421 // CHECK-NEXT:     MoveAssignment
 422 // CHECK-NEXT:     Destructor
 423 // CHECK-NEXT:   TemplateArgument{{.*}} type 'int'
 424 // CHECK-NEXT:     BuiltinType {{.*}} 'int'
 425 // CHECK-NEXT:   TemplateArgument{{.*}} pack
 426 // CHECK-NEXT:     TemplateArgument{{.*}} expr
 427 // CHECK-NEXT:       PackExpansionExpr {{.*}} 'int'
 428 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 429 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 430 // CHECK-NEXT:   AnnotateAttr {{.*}} "ANNOTATE_BIR"
 431 // CHECK-NEXT:     PackExpansionExpr {{.*}} '<dependent type>'
 432 // CHECK-NEXT:       DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 433 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
 434 // CHECK-NEXT: ClassTemplatePartialSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
 435 // CHECK-NEXT:   DefinitionData
 436 // CHECK-NEXT:     DefaultConstructor
 437 // CHECK-NEXT:     CopyConstructor
 438 // CHECK-NEXT:     MoveConstructor
 439 // CHECK-NEXT:     CopyAssignment
 440 // CHECK-NEXT:     MoveAssignment
 441 // CHECK-NEXT:     Destructor
 442 // CHECK-NEXT:   TemplateArgument{{.*}} type 'float'
 443 // CHECK-NEXT:     BuiltinType {{.*}} 'float'
 444 // CHECK-NEXT:   TemplateArgument{{.*}} pack
 445 // CHECK-NEXT:     TemplateArgument{{.*}} expr
 446 // CHECK-NEXT:       PackExpansionExpr {{.*}} 'int'
 447 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 448 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 449 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
 450 // CHECK-NEXT: ClassTemplateSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
 451 // CHECK-NEXT:   DefinitionData
 452 // CHECK-NEXT:     DefaultConstructor
 453 // CHECK-NEXT:     CopyConstructor
 454 // CHECK-NEXT:     MoveConstructor
 455 // CHECK-NEXT:     CopyAssignment
 456 // CHECK-NEXT:     MoveAssignment
 457 // CHECK-NEXT:     Destructor
 458 // CHECK-NEXT:   TemplateArgument{{.*}} type 'char'
 459 // CHECK-NEXT:     BuiltinType {{.*}} 'char'
 460 // CHECK-NEXT:   TemplateArgument{{.*}} pack
 461 // CHECK-NEXT:     TemplateArgument{{.*}} integral '5'
 462 // CHECK-NEXT:     TemplateArgument{{.*}} integral '6'
 463 // CHECK-NEXT:     TemplateArgument{{.*}} integral '7'
 464 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
 465 template <typename T, int... Is> struct InvalidAnnotatedPackTemplateStruct{};
 466 template <int... Is> struct [[clang::annotate("ANNOTATE_BIR", Is...)]] InvalidAnnotatedPackTemplateStruct<int, Is...>{};
 467 template <int... Is> struct InvalidAnnotatedPackTemplateStruct<float, Is...> {};
 468 template <> struct InvalidAnnotatedPackTemplateStruct<char, 5, 6, 7> {};
 469 void UseInvalidAnnotatedPackTemplateStruct() {
 470   InvalidAnnotatedPackTemplateStruct<int, 1, 2, 3> Instance1{};
 471   InvalidAnnotatedPackTemplateStruct<float, 3, 2, 1> Instance2{};
 472   InvalidAnnotatedPackTemplateStruct<char, 5, 6, 7> Instance3{};
 473   InvalidAnnotatedPackTemplateStruct<bool, 7, 8, 9> Instance4{};
 474   InvalidAnnotatedPackTemplateStruct<bool> Instance5{};
 475 }
 476
 477 // CHECK:      FunctionTemplateDecl {{.*}} RedeclaredAnnotatedFunc
 478 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 479 // CHECK-NEXT:   FunctionDecl {{.*}} RedeclaredAnnotatedFunc 'void ()'
 480 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FAR"
 481 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
 482 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 483 // CHECK-NEXT:   FunctionDecl {{.*}} used RedeclaredAnnotatedFunc 'void ()'
 484 // CHECK-NEXT:     TemplateArgument{{.*}} pack
 485 // CHECK-NEXT:       TemplateArgument{{.*}} integral '1'
 486 // CHECK-NEXT:       TemplateArgument{{.*}} integral '2'
 487 // CHECK-NEXT:       TemplateArgument{{.*}} integral '3'
 488 // CHECK-NEXT:     CompoundStmt
 489 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FAR"
 490 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 491 // CHECK-NEXT:         value: Int 1
 492 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 493 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 494 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 1
 495 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 496 // CHECK-NEXT:         value: Int 2
 497 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 498 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 499 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 2
 500 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 501 // CHECK-NEXT:         value: Int 3
 502 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
 503 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 504 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 3
 505 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FIZ"
 506 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 507 // CHECK-NEXT:         value: Int 4
 508 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 4
 509 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 510 // CHECK-NEXT:         value: Int 5
 511 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 5
 512 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BOZ"
 513 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 514 // CHECK-NEXT:         value: Int 6
 515 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 6
 516 // CHECK-NEXT: FunctionTemplateDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc
 517 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
 518 // CHECK-NEXT:   FunctionDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc 'void ()'
 519 // CHECK-NEXT:     AnnotateAttr {{.*}} Inherited "ANNOTATE_FAR"
 520 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
 521 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 522 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BOZ"
 523 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
 524 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 525 // CHECK-NEXT:   Function {{.*}} 'RedeclaredAnnotatedFunc' 'void ()'
 526 // CHECK-NEXT: FunctionTemplateDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc
 527 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} 'int' depth 0 index 0 ... Is
 528 // CHECK-NEXT:   FunctionDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc 'void ()'
 529 // CHECK-NEXT:     AnnotateAttr {{.*}} Inherited "ANNOTATE_FAR"
 530 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
 531 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 532 // CHECK-NEXT:     AnnotateAttr {{.*}} Inherited "ANNOTATE_BOZ"
 533 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
 534 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 535 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FIZ"
 536 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 537 // CHECK-NEXT:         value: Int 4
 538 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 4
 539 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 540 // CHECK-NEXT:         value: Int 5
 541 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 5
 542 // CHECK-NEXT:   Function {{.*}} 'RedeclaredAnnotatedFunc' 'void ()'
 543 // CHECK-NEXT: FunctionTemplateDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc
 544 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} 'int' depth 0 index 0 ... Is
 545 // CHECK-NEXT:   FunctionDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc 'void ()'
 546 // CHECK-NEXT:     CompoundStmt
 547 // CHECK-NEXT:     AnnotateAttr {{.*}} Inherited "ANNOTATE_FAR"
 548 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
 549 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
 550 // CHECK-NEXT:     AnnotateAttr {{.*}} Inherited "ANNOTATE_FIZ"
 551 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 552 // CHECK-NEXT:         value: Int 4
 553 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 4
 554 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 555 // CHECK-NEXT:         value: Int 5
 556 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 5
 557 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BOZ"
 558 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
 559 // CHECK-NEXT:         value: Int 6
 560 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 6
 561 // CHECK-NEXT:   Function {{.*}} 'RedeclaredAnnotatedFunc' 'void ()'
 562 // CHECK-NEXT: EmptyDecl
 563 template <int... Is> [[clang::annotate("ANNOTATE_FAR", Is...)]] void RedeclaredAnnotatedFunc();
 564 template <int... Is> [[clang::annotate("ANNOTATE_BOZ", Is...)]] void RedeclaredAnnotatedFunc();
 565 template <int... Is> [[clang::annotate("ANNOTATE_FIZ", 4, 5)]] void RedeclaredAnnotatedFunc();
 566 template <int... Is> [[clang::annotate("ANNOTATE_BOZ", 6)]] void RedeclaredAnnotatedFunc(){};
 567 void UseRedeclaredAnnotatedFunc() {
 568   RedeclaredAnnotatedFunc<1, 2, 3>();
 569 }
 570
 571 } // namespace attribute_annotate
 572
 573 namespace preferred_name {
 574   int x [[clang::preferred_name("frank")]]; // expected-error {{expected a type}}
 575   int y [[clang::preferred_name(int)]]; // expected-warning {{'preferred_name' attribute only applies to class templates}}
 576   struct [[clang::preferred_name(int)]] A; // expected-warning {{'preferred_name' attribute only applies to class templates}}
 577   template<typename T> struct [[clang::preferred_name(int)]] B; // expected-error {{argument 'int' to 'preferred_name' attribute is not a typedef for a specialization of 'B'}}
 578   template<typename T> struct C;
 579   using X = C<int>; // expected-note {{'X' declared here}}
 580   typedef C<float> Y;
 581   using Z = const C<double>; // expected-note {{'Z' declared here}}
 582   template<typename T> struct [[clang::preferred_name(C<int>)]] C; // expected-error {{argument 'C<int>' to 'preferred_name' attribute is not a typedef for a specialization of 'C'}}
 583   template<typename T> struct [[clang::preferred_name(X), clang::preferred_name(Y)]] C;
 584   template<typename T> struct [[clang::preferred_name(const X)]] C; // expected-error {{argument 'const X'}}
 585   template<typename T> struct [[clang::preferred_name(Z)]] C; // expected-error {{argument 'Z' (aka 'const C<double>')}}
 586   template<typename T> struct C {};
 587
 588   // CHECK: ClassTemplateDecl {{.*}} <line:[[@LINE-10]]:{{.*}} C
 589   // CHECK:   ClassTemplateSpecializationDecl {{.*}} struct C definition
 590   // CHECK:     TemplateArgument type 'int'
 591   // CHECK-NOT: PreferredNameAttr
 592   // CHECK:     PreferredNameAttr {{.*}} X
 593   // CHECK-NOT: PreferredNameAttr
 594   // CHECK:     CXXRecordDecl
 595   // CHECK:   ClassTemplateSpecializationDecl {{.*}} struct C definition
 596   // CHECK:     TemplateArgument type 'float'
 597   // CHECK-NOT: PreferredNameAttr
 598   // CHECK:     PreferredNameAttr {{.*}} Y
 599   // CHECK-NOT: PreferredNameAttr
 600   // CHECK:     CXXRecordDecl
 601   // CHECK:   ClassTemplateSpecializationDecl {{.*}} struct C definition
 602   // CHECK:     TemplateArgument type 'double'
 603   // CHECK-NOT: PreferredNameAttr
 604   // CHECK:     CXXRecordDecl
 605
 606   // Check this doesn't cause us to instantiate the same attribute multiple times.
 607   C<float> *cf1;
 608   C<float> *cf2;
 609
 610   void f(C<int> a, C<float> b, C<double> c) {
 611     auto p = a;
 612     auto q = b;
 613     auto r = c;
 614     p.f(); // expected-error {{no member named 'f' in 'preferred_name::X'}}
 615     q.f(); // expected-error {{no member named 'f' in 'preferred_name::Y'}}
 616     r.f(); // expected-error {{no member named 'f' in 'preferred_name::C<double>'}}
 617   }
 618
 619   template<typename T> struct D;
 620   using DInt = D<int>;
 621   template<typename T> struct __attribute__((__preferred_name__(DInt))) D {};
 622   template struct D<int>;
 623   int use_dint = D<int>().get(); // expected-error {{no member named 'get' in 'preferred_name::DInt'}}
 624
 625   template<typename T> struct MemberTemplate {
 626     template<typename U> struct Iter;
 627     using iterator = Iter<T>;
 628     using const_iterator = Iter<const T>;
 629     template<typename U>
 630     struct [[clang::preferred_name(iterator),
 631              clang::preferred_name(const_iterator)]] Iter {};
 632   };
 633   template<typename T> T desugar(T);
 634   auto it = desugar(MemberTemplate<int>::Iter<const int>());
 635   int n = it; // expected-error {{no viable conversion from 'preferred_name::MemberTemplate<int>::const_iterator' to 'int'}}
 636
 637   template<int A, int B, typename ...T> struct Foo;
 638   template<typename ...T> using Bar = Foo<1, 2, T...>;
 639   template<int A, int B, typename ...T> struct [[clang::preferred_name(::preferred_name::Bar<T...>)]] Foo {};
 640   Foo<1, 2, int, float>::nosuch x; // expected-error {{no type named 'nosuch' in 'preferred_name::Bar<int, float>'}}
 641 }
 642 ::preferred_name::Foo<1, 2, int, float>::nosuch x; // expected-error {{no type named 'nosuch' in 'preferred_name::Bar<int, float>'}}