clang  6.0.0svn
ASTStructuralEquivalence.cpp
Go to the documentation of this file.
1 //===--- ASTStructuralEquivalence.cpp - -------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implement StructuralEquivalenceContext class and helper functions
11 // for layout matching.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/ASTImporter.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/DeclVisitor.h"
22 #include "clang/AST/StmtVisitor.h"
23 #include "clang/AST/TypeVisitor.h"
25 
26 namespace {
27 
28 using namespace clang;
29 
30 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
31  QualType T1, QualType T2);
32 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
33  Decl *D1, Decl *D2);
34 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
35  const TemplateArgument &Arg1,
36  const TemplateArgument &Arg2);
37 
38 /// Determine structural equivalence of two expressions.
39 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
40  Expr *E1, Expr *E2) {
41  if (!E1 || !E2)
42  return E1 == E2;
43 
44  // FIXME: Actually perform a structural comparison!
45  return true;
46 }
47 
48 /// Determine whether two identifiers are equivalent.
49 static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
50  const IdentifierInfo *Name2) {
51  if (!Name1 || !Name2)
52  return Name1 == Name2;
53 
54  return Name1->getName() == Name2->getName();
55 }
56 
57 /// Determine whether two nested-name-specifiers are equivalent.
58 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
59  NestedNameSpecifier *NNS1,
60  NestedNameSpecifier *NNS2) {
61  if (NNS1->getKind() != NNS2->getKind())
62  return false;
63 
64  NestedNameSpecifier *Prefix1 = NNS1->getPrefix(),
65  *Prefix2 = NNS2->getPrefix();
66  if ((bool)Prefix1 != (bool)Prefix2)
67  return false;
68 
69  if (Prefix1)
70  if (!IsStructurallyEquivalent(Context, Prefix1, Prefix2))
71  return false;
72 
73  switch (NNS1->getKind()) {
74  case NestedNameSpecifier::Identifier:
75  return IsStructurallyEquivalent(NNS1->getAsIdentifier(),
76  NNS2->getAsIdentifier());
77  case NestedNameSpecifier::Namespace:
78  return IsStructurallyEquivalent(Context, NNS1->getAsNamespace(),
79  NNS2->getAsNamespace());
80  case NestedNameSpecifier::NamespaceAlias:
81  return IsStructurallyEquivalent(Context, NNS1->getAsNamespaceAlias(),
82  NNS2->getAsNamespaceAlias());
83  case NestedNameSpecifier::TypeSpec:
84  case NestedNameSpecifier::TypeSpecWithTemplate:
85  return IsStructurallyEquivalent(Context, QualType(NNS1->getAsType(), 0),
86  QualType(NNS2->getAsType(), 0));
87  case NestedNameSpecifier::Global:
88  return true;
89  case NestedNameSpecifier::Super:
90  return IsStructurallyEquivalent(Context, NNS1->getAsRecordDecl(),
91  NNS2->getAsRecordDecl());
92  }
93  return false;
94 }
95 
96 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
97  const TemplateName &N1,
98  const TemplateName &N2) {
99  if (N1.getKind() != N2.getKind())
100  return false;
101  switch (N1.getKind()) {
102  case TemplateName::Template:
103  return IsStructurallyEquivalent(Context, N1.getAsTemplateDecl(),
104  N2.getAsTemplateDecl());
105 
106  case TemplateName::OverloadedTemplate: {
108  *OS2 = N2.getAsOverloadedTemplate();
109  OverloadedTemplateStorage::iterator I1 = OS1->begin(), I2 = OS2->begin(),
110  E1 = OS1->end(), E2 = OS2->end();
111  for (; I1 != E1 && I2 != E2; ++I1, ++I2)
112  if (!IsStructurallyEquivalent(Context, *I1, *I2))
113  return false;
114  return I1 == E1 && I2 == E2;
115  }
116 
117  case TemplateName::QualifiedTemplate: {
119  *QN2 = N2.getAsQualifiedTemplateName();
120  return IsStructurallyEquivalent(Context, QN1->getDecl(), QN2->getDecl()) &&
121  IsStructurallyEquivalent(Context, QN1->getQualifier(),
122  QN2->getQualifier());
123  }
124 
125  case TemplateName::DependentTemplate: {
127  *DN2 = N2.getAsDependentTemplateName();
128  if (!IsStructurallyEquivalent(Context, DN1->getQualifier(),
129  DN2->getQualifier()))
130  return false;
131  if (DN1->isIdentifier() && DN2->isIdentifier())
132  return IsStructurallyEquivalent(DN1->getIdentifier(),
133  DN2->getIdentifier());
134  else if (DN1->isOverloadedOperator() && DN2->isOverloadedOperator())
135  return DN1->getOperator() == DN2->getOperator();
136  return false;
137  }
138 
139  case TemplateName::SubstTemplateTemplateParm: {
141  *TS2 = N2.getAsSubstTemplateTemplateParm();
142  return IsStructurallyEquivalent(Context, TS1->getParameter(),
143  TS2->getParameter()) &&
144  IsStructurallyEquivalent(Context, TS1->getReplacement(),
145  TS2->getReplacement());
146  }
147  case TemplateName::SubstTemplateTemplateParmPack: {
151  return IsStructurallyEquivalent(Context, P1->getArgumentPack(),
152  P2->getArgumentPack()) &&
153  IsStructurallyEquivalent(Context, P1->getParameterPack(),
154  P2->getParameterPack());
155  }
156  }
157  return false;
158 }
159 
160 /// Determine whether two template arguments are equivalent.
161 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
162  const TemplateArgument &Arg1,
163  const TemplateArgument &Arg2) {
164  if (Arg1.getKind() != Arg2.getKind())
165  return false;
166 
167  switch (Arg1.getKind()) {
168  case TemplateArgument::Null:
169  return true;
170 
171  case TemplateArgument::Type:
172  return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
173 
174  case TemplateArgument::Integral:
175  if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
176  Arg2.getIntegralType()))
177  return false;
178 
179  return llvm::APSInt::isSameValue(Arg1.getAsIntegral(),
180  Arg2.getAsIntegral());
181 
182  case TemplateArgument::Declaration:
183  return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
184 
185  case TemplateArgument::NullPtr:
186  return true; // FIXME: Is this correct?
187 
188  case TemplateArgument::Template:
189  return IsStructurallyEquivalent(Context, Arg1.getAsTemplate(),
190  Arg2.getAsTemplate());
191 
192  case TemplateArgument::TemplateExpansion:
193  return IsStructurallyEquivalent(Context,
196 
197  case TemplateArgument::Expression:
198  return IsStructurallyEquivalent(Context, Arg1.getAsExpr(),
199  Arg2.getAsExpr());
200 
201  case TemplateArgument::Pack:
202  if (Arg1.pack_size() != Arg2.pack_size())
203  return false;
204 
205  for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
206  if (!IsStructurallyEquivalent(Context, Arg1.pack_begin()[I],
207  Arg2.pack_begin()[I]))
208  return false;
209 
210  return true;
211  }
212 
213  llvm_unreachable("Invalid template argument kind");
214 }
215 
216 /// Determine structural equivalence for the common part of array
217 /// types.
218 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
219  const ArrayType *Array1,
220  const ArrayType *Array2) {
221  if (!IsStructurallyEquivalent(Context, Array1->getElementType(),
222  Array2->getElementType()))
223  return false;
224  if (Array1->getSizeModifier() != Array2->getSizeModifier())
225  return false;
226  if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
227  return false;
228 
229  return true;
230 }
231 
232 /// Determine structural equivalence of two types.
233 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
234  QualType T1, QualType T2) {
235  if (T1.isNull() || T2.isNull())
236  return T1.isNull() && T2.isNull();
237 
238  if (!Context.StrictTypeSpelling) {
239  // We aren't being strict about token-to-token equivalence of types,
240  // so map down to the canonical type.
241  T1 = Context.FromCtx.getCanonicalType(T1);
242  T2 = Context.ToCtx.getCanonicalType(T2);
243  }
244 
245  if (T1.getQualifiers() != T2.getQualifiers())
246  return false;
247 
248  Type::TypeClass TC = T1->getTypeClass();
249 
250  if (T1->getTypeClass() != T2->getTypeClass()) {
251  // Compare function types with prototypes vs. without prototypes as if
252  // both did not have prototypes.
253  if (T1->getTypeClass() == Type::FunctionProto &&
254  T2->getTypeClass() == Type::FunctionNoProto)
255  TC = Type::FunctionNoProto;
256  else if (T1->getTypeClass() == Type::FunctionNoProto &&
257  T2->getTypeClass() == Type::FunctionProto)
258  TC = Type::FunctionNoProto;
259  else
260  return false;
261  }
262 
263  switch (TC) {
264  case Type::Builtin:
265  // FIXME: Deal with Char_S/Char_U.
266  if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
267  return false;
268  break;
269 
270  case Type::Complex:
271  if (!IsStructurallyEquivalent(Context,
272  cast<ComplexType>(T1)->getElementType(),
273  cast<ComplexType>(T2)->getElementType()))
274  return false;
275  break;
276 
277  case Type::Adjusted:
278  case Type::Decayed:
279  if (!IsStructurallyEquivalent(Context,
280  cast<AdjustedType>(T1)->getOriginalType(),
281  cast<AdjustedType>(T2)->getOriginalType()))
282  return false;
283  break;
284 
285  case Type::Pointer:
286  if (!IsStructurallyEquivalent(Context,
287  cast<PointerType>(T1)->getPointeeType(),
288  cast<PointerType>(T2)->getPointeeType()))
289  return false;
290  break;
291 
292  case Type::BlockPointer:
293  if (!IsStructurallyEquivalent(Context,
294  cast<BlockPointerType>(T1)->getPointeeType(),
295  cast<BlockPointerType>(T2)->getPointeeType()))
296  return false;
297  break;
298 
299  case Type::LValueReference:
300  case Type::RValueReference: {
301  const ReferenceType *Ref1 = cast<ReferenceType>(T1);
302  const ReferenceType *Ref2 = cast<ReferenceType>(T2);
303  if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
304  return false;
305  if (Ref1->isInnerRef() != Ref2->isInnerRef())
306  return false;
307  if (!IsStructurallyEquivalent(Context, Ref1->getPointeeTypeAsWritten(),
308  Ref2->getPointeeTypeAsWritten()))
309  return false;
310  break;
311  }
312 
313  case Type::MemberPointer: {
314  const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
315  const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
316  if (!IsStructurallyEquivalent(Context, MemPtr1->getPointeeType(),
317  MemPtr2->getPointeeType()))
318  return false;
319  if (!IsStructurallyEquivalent(Context, QualType(MemPtr1->getClass(), 0),
320  QualType(MemPtr2->getClass(), 0)))
321  return false;
322  break;
323  }
324 
325  case Type::ConstantArray: {
326  const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
327  const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
328  if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
329  return false;
330 
331  if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
332  return false;
333  break;
334  }
335 
336  case Type::IncompleteArray:
337  if (!IsArrayStructurallyEquivalent(Context, cast<ArrayType>(T1),
338  cast<ArrayType>(T2)))
339  return false;
340  break;
341 
342  case Type::VariableArray: {
343  const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
344  const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
345  if (!IsStructurallyEquivalent(Context, Array1->getSizeExpr(),
346  Array2->getSizeExpr()))
347  return false;
348 
349  if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
350  return false;
351 
352  break;
353  }
354 
355  case Type::DependentSizedArray: {
356  const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
357  const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
358  if (!IsStructurallyEquivalent(Context, Array1->getSizeExpr(),
359  Array2->getSizeExpr()))
360  return false;
361 
362  if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
363  return false;
364 
365  break;
366  }
367 
368  case Type::DependentAddressSpace: {
369  const DependentAddressSpaceType *DepAddressSpace1 =
370  cast<DependentAddressSpaceType>(T1);
371  const DependentAddressSpaceType *DepAddressSpace2 =
372  cast<DependentAddressSpaceType>(T2);
373  if (!IsStructurallyEquivalent(Context, DepAddressSpace1->getAddrSpaceExpr(),
374  DepAddressSpace2->getAddrSpaceExpr()))
375  return false;
376  if (!IsStructurallyEquivalent(Context, DepAddressSpace1->getPointeeType(),
377  DepAddressSpace2->getPointeeType()))
378  return false;
379 
380  break;
381  }
382 
383  case Type::DependentSizedExtVector: {
384  const DependentSizedExtVectorType *Vec1 =
385  cast<DependentSizedExtVectorType>(T1);
386  const DependentSizedExtVectorType *Vec2 =
387  cast<DependentSizedExtVectorType>(T2);
388  if (!IsStructurallyEquivalent(Context, Vec1->getSizeExpr(),
389  Vec2->getSizeExpr()))
390  return false;
391  if (!IsStructurallyEquivalent(Context, Vec1->getElementType(),
392  Vec2->getElementType()))
393  return false;
394  break;
395  }
396 
397  case Type::Vector:
398  case Type::ExtVector: {
399  const VectorType *Vec1 = cast<VectorType>(T1);
400  const VectorType *Vec2 = cast<VectorType>(T2);
401  if (!IsStructurallyEquivalent(Context, Vec1->getElementType(),
402  Vec2->getElementType()))
403  return false;
404  if (Vec1->getNumElements() != Vec2->getNumElements())
405  return false;
406  if (Vec1->getVectorKind() != Vec2->getVectorKind())
407  return false;
408  break;
409  }
410 
411  case Type::FunctionProto: {
412  const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
413  const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
414  if (Proto1->getNumParams() != Proto2->getNumParams())
415  return false;
416  for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
417  if (!IsStructurallyEquivalent(Context, Proto1->getParamType(I),
418  Proto2->getParamType(I)))
419  return false;
420  }
421  if (Proto1->isVariadic() != Proto2->isVariadic())
422  return false;
423  if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
424  return false;
425  if (Proto1->getExceptionSpecType() == EST_Dynamic) {
426  if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
427  return false;
428  for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
429  if (!IsStructurallyEquivalent(Context, Proto1->getExceptionType(I),
430  Proto2->getExceptionType(I)))
431  return false;
432  }
433  } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
434  if (!IsStructurallyEquivalent(Context, Proto1->getNoexceptExpr(),
435  Proto2->getNoexceptExpr()))
436  return false;
437  }
438  if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
439  return false;
440 
441  // Fall through to check the bits common with FunctionNoProtoType.
442  LLVM_FALLTHROUGH;
443  }
444 
445  case Type::FunctionNoProto: {
446  const FunctionType *Function1 = cast<FunctionType>(T1);
447  const FunctionType *Function2 = cast<FunctionType>(T2);
448  if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
449  Function2->getReturnType()))
450  return false;
451  if (Function1->getExtInfo() != Function2->getExtInfo())
452  return false;
453  break;
454  }
455 
456  case Type::UnresolvedUsing:
457  if (!IsStructurallyEquivalent(Context,
458  cast<UnresolvedUsingType>(T1)->getDecl(),
459  cast<UnresolvedUsingType>(T2)->getDecl()))
460  return false;
461 
462  break;
463 
464  case Type::Attributed:
465  if (!IsStructurallyEquivalent(Context,
466  cast<AttributedType>(T1)->getModifiedType(),
467  cast<AttributedType>(T2)->getModifiedType()))
468  return false;
469  if (!IsStructurallyEquivalent(
470  Context, cast<AttributedType>(T1)->getEquivalentType(),
471  cast<AttributedType>(T2)->getEquivalentType()))
472  return false;
473  break;
474 
475  case Type::Paren:
476  if (!IsStructurallyEquivalent(Context, cast<ParenType>(T1)->getInnerType(),
477  cast<ParenType>(T2)->getInnerType()))
478  return false;
479  break;
480 
481  case Type::Typedef:
482  if (!IsStructurallyEquivalent(Context, cast<TypedefType>(T1)->getDecl(),
483  cast<TypedefType>(T2)->getDecl()))
484  return false;
485  break;
486 
487  case Type::TypeOfExpr:
488  if (!IsStructurallyEquivalent(
489  Context, cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
490  cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
491  return false;
492  break;
493 
494  case Type::TypeOf:
495  if (!IsStructurallyEquivalent(Context,
496  cast<TypeOfType>(T1)->getUnderlyingType(),
497  cast<TypeOfType>(T2)->getUnderlyingType()))
498  return false;
499  break;
500 
501  case Type::UnaryTransform:
502  if (!IsStructurallyEquivalent(
503  Context, cast<UnaryTransformType>(T1)->getUnderlyingType(),
504  cast<UnaryTransformType>(T1)->getUnderlyingType()))
505  return false;
506  break;
507 
508  case Type::Decltype:
509  if (!IsStructurallyEquivalent(Context,
510  cast<DecltypeType>(T1)->getUnderlyingExpr(),
511  cast<DecltypeType>(T2)->getUnderlyingExpr()))
512  return false;
513  break;
514 
515  case Type::Auto:
516  if (!IsStructurallyEquivalent(Context, cast<AutoType>(T1)->getDeducedType(),
517  cast<AutoType>(T2)->getDeducedType()))
518  return false;
519  break;
520 
521  case Type::DeducedTemplateSpecialization: {
522  auto *DT1 = cast<DeducedTemplateSpecializationType>(T1);
523  auto *DT2 = cast<DeducedTemplateSpecializationType>(T2);
524  if (!IsStructurallyEquivalent(Context, DT1->getTemplateName(),
525  DT2->getTemplateName()))
526  return false;
527  if (!IsStructurallyEquivalent(Context, DT1->getDeducedType(),
528  DT2->getDeducedType()))
529  return false;
530  break;
531  }
532 
533  case Type::Record:
534  case Type::Enum:
535  if (!IsStructurallyEquivalent(Context, cast<TagType>(T1)->getDecl(),
536  cast<TagType>(T2)->getDecl()))
537  return false;
538  break;
539 
540  case Type::TemplateTypeParm: {
541  const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
542  const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
543  if (Parm1->getDepth() != Parm2->getDepth())
544  return false;
545  if (Parm1->getIndex() != Parm2->getIndex())
546  return false;
547  if (Parm1->isParameterPack() != Parm2->isParameterPack())
548  return false;
549 
550  // Names of template type parameters are never significant.
551  break;
552  }
553 
554  case Type::SubstTemplateTypeParm: {
555  const SubstTemplateTypeParmType *Subst1 =
556  cast<SubstTemplateTypeParmType>(T1);
557  const SubstTemplateTypeParmType *Subst2 =
558  cast<SubstTemplateTypeParmType>(T2);
559  if (!IsStructurallyEquivalent(Context,
560  QualType(Subst1->getReplacedParameter(), 0),
561  QualType(Subst2->getReplacedParameter(), 0)))
562  return false;
563  if (!IsStructurallyEquivalent(Context, Subst1->getReplacementType(),
564  Subst2->getReplacementType()))
565  return false;
566  break;
567  }
568 
569  case Type::SubstTemplateTypeParmPack: {
570  const SubstTemplateTypeParmPackType *Subst1 =
571  cast<SubstTemplateTypeParmPackType>(T1);
572  const SubstTemplateTypeParmPackType *Subst2 =
573  cast<SubstTemplateTypeParmPackType>(T2);
574  if (!IsStructurallyEquivalent(Context,
575  QualType(Subst1->getReplacedParameter(), 0),
576  QualType(Subst2->getReplacedParameter(), 0)))
577  return false;
578  if (!IsStructurallyEquivalent(Context, Subst1->getArgumentPack(),
579  Subst2->getArgumentPack()))
580  return false;
581  break;
582  }
583  case Type::TemplateSpecialization: {
584  const TemplateSpecializationType *Spec1 =
585  cast<TemplateSpecializationType>(T1);
586  const TemplateSpecializationType *Spec2 =
587  cast<TemplateSpecializationType>(T2);
588  if (!IsStructurallyEquivalent(Context, Spec1->getTemplateName(),
589  Spec2->getTemplateName()))
590  return false;
591  if (Spec1->getNumArgs() != Spec2->getNumArgs())
592  return false;
593  for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
594  if (!IsStructurallyEquivalent(Context, Spec1->getArg(I),
595  Spec2->getArg(I)))
596  return false;
597  }
598  break;
599  }
600 
601  case Type::Elaborated: {
602  const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
603  const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
604  // CHECKME: what if a keyword is ETK_None or ETK_typename ?
605  if (Elab1->getKeyword() != Elab2->getKeyword())
606  return false;
607  if (!IsStructurallyEquivalent(Context, Elab1->getQualifier(),
608  Elab2->getQualifier()))
609  return false;
610  if (!IsStructurallyEquivalent(Context, Elab1->getNamedType(),
611  Elab2->getNamedType()))
612  return false;
613  break;
614  }
615 
616  case Type::InjectedClassName: {
617  const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
618  const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
619  if (!IsStructurallyEquivalent(Context,
621  Inj2->getInjectedSpecializationType()))
622  return false;
623  break;
624  }
625 
626  case Type::DependentName: {
627  const DependentNameType *Typename1 = cast<DependentNameType>(T1);
628  const DependentNameType *Typename2 = cast<DependentNameType>(T2);
629  if (!IsStructurallyEquivalent(Context, Typename1->getQualifier(),
630  Typename2->getQualifier()))
631  return false;
632  if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
633  Typename2->getIdentifier()))
634  return false;
635 
636  break;
637  }
638 
639  case Type::DependentTemplateSpecialization: {
641  cast<DependentTemplateSpecializationType>(T1);
643  cast<DependentTemplateSpecializationType>(T2);
644  if (!IsStructurallyEquivalent(Context, Spec1->getQualifier(),
645  Spec2->getQualifier()))
646  return false;
647  if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
648  Spec2->getIdentifier()))
649  return false;
650  if (Spec1->getNumArgs() != Spec2->getNumArgs())
651  return false;
652  for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
653  if (!IsStructurallyEquivalent(Context, Spec1->getArg(I),
654  Spec2->getArg(I)))
655  return false;
656  }
657  break;
658  }
659 
660  case Type::PackExpansion:
661  if (!IsStructurallyEquivalent(Context,
662  cast<PackExpansionType>(T1)->getPattern(),
663  cast<PackExpansionType>(T2)->getPattern()))
664  return false;
665  break;
666 
667  case Type::ObjCInterface: {
668  const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
669  const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
670  if (!IsStructurallyEquivalent(Context, Iface1->getDecl(),
671  Iface2->getDecl()))
672  return false;
673  break;
674  }
675 
676  case Type::ObjCTypeParam: {
677  const ObjCTypeParamType *Obj1 = cast<ObjCTypeParamType>(T1);
678  const ObjCTypeParamType *Obj2 = cast<ObjCTypeParamType>(T2);
679  if (!IsStructurallyEquivalent(Context, Obj1->getDecl(), Obj2->getDecl()))
680  return false;
681 
682  if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
683  return false;
684  for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
685  if (!IsStructurallyEquivalent(Context, Obj1->getProtocol(I),
686  Obj2->getProtocol(I)))
687  return false;
688  }
689  break;
690  }
691  case Type::ObjCObject: {
692  const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
693  const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
694  if (!IsStructurallyEquivalent(Context, Obj1->getBaseType(),
695  Obj2->getBaseType()))
696  return false;
697  if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
698  return false;
699  for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
700  if (!IsStructurallyEquivalent(Context, Obj1->getProtocol(I),
701  Obj2->getProtocol(I)))
702  return false;
703  }
704  break;
705  }
706 
707  case Type::ObjCObjectPointer: {
708  const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
709  const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
710  if (!IsStructurallyEquivalent(Context, Ptr1->getPointeeType(),
711  Ptr2->getPointeeType()))
712  return false;
713  break;
714  }
715 
716  case Type::Atomic: {
717  if (!IsStructurallyEquivalent(Context, cast<AtomicType>(T1)->getValueType(),
718  cast<AtomicType>(T2)->getValueType()))
719  return false;
720  break;
721  }
722 
723  case Type::Pipe: {
724  if (!IsStructurallyEquivalent(Context, cast<PipeType>(T1)->getElementType(),
725  cast<PipeType>(T2)->getElementType()))
726  return false;
727  break;
728  }
729 
730  } // end switch
731 
732  return true;
733 }
734 
735 /// Determine structural equivalence of two fields.
736 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
737  FieldDecl *Field1, FieldDecl *Field2) {
738  RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
739 
740  // For anonymous structs/unions, match up the anonymous struct/union type
741  // declarations directly, so that we don't go off searching for anonymous
742  // types
743  if (Field1->isAnonymousStructOrUnion() &&
744  Field2->isAnonymousStructOrUnion()) {
745  RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
746  RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
747  return IsStructurallyEquivalent(Context, D1, D2);
748  }
749 
750  // Check for equivalent field names.
751  IdentifierInfo *Name1 = Field1->getIdentifier();
752  IdentifierInfo *Name2 = Field2->getIdentifier();
753  if (!::IsStructurallyEquivalent(Name1, Name2)) {
754  if (Context.Complain) {
755  Context.Diag2(Owner2->getLocation(),
756  Context.ErrorOnTagTypeMismatch
757  ? diag::err_odr_tag_type_inconsistent
758  : diag::warn_odr_tag_type_inconsistent)
759  << Context.ToCtx.getTypeDeclType(Owner2);
760  Context.Diag2(Field2->getLocation(), diag::note_odr_field_name)
761  << Field2->getDeclName();
762  Context.Diag1(Field1->getLocation(), diag::note_odr_field_name)
763  << Field1->getDeclName();
764  }
765  return false;
766  }
767 
768  if (!IsStructurallyEquivalent(Context, Field1->getType(),
769  Field2->getType())) {
770  if (Context.Complain) {
771  Context.Diag2(Owner2->getLocation(),
772  Context.ErrorOnTagTypeMismatch
773  ? diag::err_odr_tag_type_inconsistent
774  : diag::warn_odr_tag_type_inconsistent)
775  << Context.ToCtx.getTypeDeclType(Owner2);
776  Context.Diag2(Field2->getLocation(), diag::note_odr_field)
777  << Field2->getDeclName() << Field2->getType();
778  Context.Diag1(Field1->getLocation(), diag::note_odr_field)
779  << Field1->getDeclName() << Field1->getType();
780  }
781  return false;
782  }
783 
784  if (Field1->isBitField() != Field2->isBitField()) {
785  if (Context.Complain) {
786  Context.Diag2(Owner2->getLocation(),
787  Context.ErrorOnTagTypeMismatch
788  ? diag::err_odr_tag_type_inconsistent
789  : diag::warn_odr_tag_type_inconsistent)
790  << Context.ToCtx.getTypeDeclType(Owner2);
791  if (Field1->isBitField()) {
792  Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
793  << Field1->getDeclName() << Field1->getType()
794  << Field1->getBitWidthValue(Context.FromCtx);
795  Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
796  << Field2->getDeclName();
797  } else {
798  Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
799  << Field2->getDeclName() << Field2->getType()
800  << Field2->getBitWidthValue(Context.ToCtx);
801  Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
802  << Field1->getDeclName();
803  }
804  }
805  return false;
806  }
807 
808  if (Field1->isBitField()) {
809  // Make sure that the bit-fields are the same length.
810  unsigned Bits1 = Field1->getBitWidthValue(Context.FromCtx);
811  unsigned Bits2 = Field2->getBitWidthValue(Context.ToCtx);
812 
813  if (Bits1 != Bits2) {
814  if (Context.Complain) {
815  Context.Diag2(Owner2->getLocation(),
816  Context.ErrorOnTagTypeMismatch
817  ? diag::err_odr_tag_type_inconsistent
818  : diag::warn_odr_tag_type_inconsistent)
819  << Context.ToCtx.getTypeDeclType(Owner2);
820  Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
821  << Field2->getDeclName() << Field2->getType() << Bits2;
822  Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
823  << Field1->getDeclName() << Field1->getType() << Bits1;
824  }
825  return false;
826  }
827  }
828 
829  return true;
830 }
831 
832 /// Determine structural equivalence of two records.
833 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
834  RecordDecl *D1, RecordDecl *D2) {
835  if (D1->isUnion() != D2->isUnion()) {
836  if (Context.Complain) {
837  Context.Diag2(D2->getLocation(),
838  Context.ErrorOnTagTypeMismatch
839  ? diag::err_odr_tag_type_inconsistent
840  : diag::warn_odr_tag_type_inconsistent)
841  << Context.ToCtx.getTypeDeclType(D2);
842  Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
843  << D1->getDeclName() << (unsigned)D1->getTagKind();
844  }
845  return false;
846  }
847 
849  // If both anonymous structs/unions are in a record context, make sure
850  // they occur in the same location in the context records.
851  if (Optional<unsigned> Index1 =
852  StructuralEquivalenceContext::findUntaggedStructOrUnionIndex(D1)) {
853  if (Optional<unsigned> Index2 =
854  StructuralEquivalenceContext::findUntaggedStructOrUnionIndex(
855  D2)) {
856  if (*Index1 != *Index2)
857  return false;
858  }
859  }
860  }
861 
862  // If both declarations are class template specializations, we know
863  // the ODR applies, so check the template and template arguments.
865  dyn_cast<ClassTemplateSpecializationDecl>(D1);
867  dyn_cast<ClassTemplateSpecializationDecl>(D2);
868  if (Spec1 && Spec2) {
869  // Check that the specialized templates are the same.
870  if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
871  Spec2->getSpecializedTemplate()))
872  return false;
873 
874  // Check that the template arguments are the same.
875  if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
876  return false;
877 
878  for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
879  if (!IsStructurallyEquivalent(Context, Spec1->getTemplateArgs().get(I),
880  Spec2->getTemplateArgs().get(I)))
881  return false;
882  }
883  // If one is a class template specialization and the other is not, these
884  // structures are different.
885  else if (Spec1 || Spec2)
886  return false;
887 
888  // Compare the definitions of these two records. If either or both are
889  // incomplete, we assume that they are equivalent.
890  D1 = D1->getDefinition();
891  D2 = D2->getDefinition();
892  if (!D1 || !D2)
893  return true;
894 
895  if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
896  if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
897  if (D1CXX->hasExternalLexicalStorage() &&
898  !D1CXX->isCompleteDefinition()) {
899  D1CXX->getASTContext().getExternalSource()->CompleteType(D1CXX);
900  }
901 
902  if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
903  if (Context.Complain) {
904  Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
905  << Context.ToCtx.getTypeDeclType(D2);
906  Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
907  << D2CXX->getNumBases();
908  Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
909  << D1CXX->getNumBases();
910  }
911  return false;
912  }
913 
914  // Check the base classes.
915  for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
916  BaseEnd1 = D1CXX->bases_end(),
917  Base2 = D2CXX->bases_begin();
918  Base1 != BaseEnd1; ++Base1, ++Base2) {
919  if (!IsStructurallyEquivalent(Context, Base1->getType(),
920  Base2->getType())) {
921  if (Context.Complain) {
922  Context.Diag2(D2->getLocation(),
923  diag::warn_odr_tag_type_inconsistent)
924  << Context.ToCtx.getTypeDeclType(D2);
925  Context.Diag2(Base2->getLocStart(), diag::note_odr_base)
926  << Base2->getType() << Base2->getSourceRange();
927  Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
928  << Base1->getType() << Base1->getSourceRange();
929  }
930  return false;
931  }
932 
933  // Check virtual vs. non-virtual inheritance mismatch.
934  if (Base1->isVirtual() != Base2->isVirtual()) {
935  if (Context.Complain) {
936  Context.Diag2(D2->getLocation(),
937  diag::warn_odr_tag_type_inconsistent)
938  << Context.ToCtx.getTypeDeclType(D2);
939  Context.Diag2(Base2->getLocStart(), diag::note_odr_virtual_base)
940  << Base2->isVirtual() << Base2->getSourceRange();
941  Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
942  << Base1->isVirtual() << Base1->getSourceRange();
943  }
944  return false;
945  }
946  }
947  } else if (D1CXX->getNumBases() > 0) {
948  if (Context.Complain) {
949  Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
950  << Context.ToCtx.getTypeDeclType(D2);
951  const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
952  Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
953  << Base1->getType() << Base1->getSourceRange();
954  Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
955  }
956  return false;
957  }
958  }
959 
960  // Check the fields for consistency.
962  Field2End = D2->field_end();
963  for (RecordDecl::field_iterator Field1 = D1->field_begin(),
964  Field1End = D1->field_end();
965  Field1 != Field1End; ++Field1, ++Field2) {
966  if (Field2 == Field2End) {
967  if (Context.Complain) {
968  Context.Diag2(D2->getLocation(),
969  Context.ErrorOnTagTypeMismatch
970  ? diag::err_odr_tag_type_inconsistent
971  : diag::warn_odr_tag_type_inconsistent)
972  << Context.ToCtx.getTypeDeclType(D2);
973  Context.Diag1(Field1->getLocation(), diag::note_odr_field)
974  << Field1->getDeclName() << Field1->getType();
975  Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
976  }
977  return false;
978  }
979 
980  if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
981  return false;
982  }
983 
984  if (Field2 != Field2End) {
985  if (Context.Complain) {
986  Context.Diag2(D2->getLocation(),
987  Context.ErrorOnTagTypeMismatch
988  ? diag::err_odr_tag_type_inconsistent
989  : diag::warn_odr_tag_type_inconsistent)
990  << Context.ToCtx.getTypeDeclType(D2);
991  Context.Diag2(Field2->getLocation(), diag::note_odr_field)
992  << Field2->getDeclName() << Field2->getType();
993  Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
994  }
995  return false;
996  }
997 
998  return true;
999 }
1000 
1001 /// Determine structural equivalence of two enums.
1002 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1003  EnumDecl *D1, EnumDecl *D2) {
1005  EC2End = D2->enumerator_end();
1007  EC1End = D1->enumerator_end();
1008  EC1 != EC1End; ++EC1, ++EC2) {
1009  if (EC2 == EC2End) {
1010  if (Context.Complain) {
1011  Context.Diag2(D2->getLocation(),
1012  Context.ErrorOnTagTypeMismatch
1013  ? diag::err_odr_tag_type_inconsistent
1014  : diag::warn_odr_tag_type_inconsistent)
1015  << Context.ToCtx.getTypeDeclType(D2);
1016  Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1017  << EC1->getDeclName() << EC1->getInitVal().toString(10);
1018  Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
1019  }
1020  return false;
1021  }
1022 
1023  llvm::APSInt Val1 = EC1->getInitVal();
1024  llvm::APSInt Val2 = EC2->getInitVal();
1025  if (!llvm::APSInt::isSameValue(Val1, Val2) ||
1026  !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
1027  if (Context.Complain) {
1028  Context.Diag2(D2->getLocation(),
1029  Context.ErrorOnTagTypeMismatch
1030  ? diag::err_odr_tag_type_inconsistent
1031  : diag::warn_odr_tag_type_inconsistent)
1032  << Context.ToCtx.getTypeDeclType(D2);
1033  Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1034  << EC2->getDeclName() << EC2->getInitVal().toString(10);
1035  Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1036  << EC1->getDeclName() << EC1->getInitVal().toString(10);
1037  }
1038  return false;
1039  }
1040  }
1041 
1042  if (EC2 != EC2End) {
1043  if (Context.Complain) {
1044  Context.Diag2(D2->getLocation(),
1045  Context.ErrorOnTagTypeMismatch
1046  ? diag::err_odr_tag_type_inconsistent
1047  : diag::warn_odr_tag_type_inconsistent)
1048  << Context.ToCtx.getTypeDeclType(D2);
1049  Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1050  << EC2->getDeclName() << EC2->getInitVal().toString(10);
1051  Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
1052  }
1053  return false;
1054  }
1055 
1056  return true;
1057 }
1058 
1059 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1060  TemplateParameterList *Params1,
1061  TemplateParameterList *Params2) {
1062  if (Params1->size() != Params2->size()) {
1063  if (Context.Complain) {
1064  Context.Diag2(Params2->getTemplateLoc(),
1065  diag::err_odr_different_num_template_parameters)
1066  << Params1->size() << Params2->size();
1067  Context.Diag1(Params1->getTemplateLoc(),
1068  diag::note_odr_template_parameter_list);
1069  }
1070  return false;
1071  }
1072 
1073  for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
1074  if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
1075  if (Context.Complain) {
1076  Context.Diag2(Params2->getParam(I)->getLocation(),
1077  diag::err_odr_different_template_parameter_kind);
1078  Context.Diag1(Params1->getParam(I)->getLocation(),
1079  diag::note_odr_template_parameter_here);
1080  }
1081  return false;
1082  }
1083 
1084  if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
1085  Params2->getParam(I))) {
1086 
1087  return false;
1088  }
1089  }
1090 
1091  return true;
1092 }
1093 
1094 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1096  TemplateTypeParmDecl *D2) {
1097  if (D1->isParameterPack() != D2->isParameterPack()) {
1098  if (Context.Complain) {
1099  Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1100  << D2->isParameterPack();
1101  Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1102  << D1->isParameterPack();
1103  }
1104  return false;
1105  }
1106 
1107  return true;
1108 }
1109 
1110 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1113  if (D1->isParameterPack() != D2->isParameterPack()) {
1114  if (Context.Complain) {
1115  Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1116  << D2->isParameterPack();
1117  Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1118  << D1->isParameterPack();
1119  }
1120  return false;
1121  }
1122 
1123  // Check types.
1124  if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
1125  if (Context.Complain) {
1126  Context.Diag2(D2->getLocation(),
1127  diag::err_odr_non_type_parameter_type_inconsistent)
1128  << D2->getType() << D1->getType();
1129  Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
1130  << D1->getType();
1131  }
1132  return false;
1133  }
1134 
1135  return true;
1136 }
1137 
1138 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1141  if (D1->isParameterPack() != D2->isParameterPack()) {
1142  if (Context.Complain) {
1143  Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1144  << D2->isParameterPack();
1145  Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1146  << D1->isParameterPack();
1147  }
1148  return false;
1149  }
1150 
1151  // Check template parameter lists.
1152  return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1153  D2->getTemplateParameters());
1154 }
1155 
1156 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1157  ClassTemplateDecl *D1,
1158  ClassTemplateDecl *D2) {
1159  // Check template parameters.
1160  if (!IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1161  D2->getTemplateParameters()))
1162  return false;
1163 
1164  // Check the templated declaration.
1165  return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
1166  D2->getTemplatedDecl());
1167 }
1168 
1169 /// Determine structural equivalence of two declarations.
1170 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1171  Decl *D1, Decl *D2) {
1172  // FIXME: Check for known structural equivalences via a callback of some sort.
1173 
1174  // Check whether we already know that these two declarations are not
1175  // structurally equivalent.
1176  if (Context.NonEquivalentDecls.count(
1177  std::make_pair(D1->getCanonicalDecl(), D2->getCanonicalDecl())))
1178  return false;
1179 
1180  // Determine whether we've already produced a tentative equivalence for D1.
1181  Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
1182  if (EquivToD1)
1183  return EquivToD1 == D2->getCanonicalDecl();
1184 
1185  // Produce a tentative equivalence D1 <-> D2, which will be checked later.
1186  EquivToD1 = D2->getCanonicalDecl();
1187  Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
1188  return true;
1189 }
1190 } // namespace
1191 
1192 namespace clang {
1193 
1194 DiagnosticBuilder StructuralEquivalenceContext::Diag1(SourceLocation Loc,
1195  unsigned DiagID) {
1196  assert(Complain && "Not allowed to complain");
1197  if (LastDiagFromC2)
1198  FromCtx.getDiagnostics().notePriorDiagnosticFrom(ToCtx.getDiagnostics());
1199  LastDiagFromC2 = false;
1200  return FromCtx.getDiagnostics().Report(Loc, DiagID);
1201 }
1202 
1203 DiagnosticBuilder StructuralEquivalenceContext::Diag2(SourceLocation Loc,
1204  unsigned DiagID) {
1205  assert(Complain && "Not allowed to complain");
1206  if (!LastDiagFromC2)
1207  ToCtx.getDiagnostics().notePriorDiagnosticFrom(FromCtx.getDiagnostics());
1208  LastDiagFromC2 = true;
1209  return ToCtx.getDiagnostics().Report(Loc, DiagID);
1210 }
1211 
1213 StructuralEquivalenceContext::findUntaggedStructOrUnionIndex(RecordDecl *Anon) {
1214  ASTContext &Context = Anon->getASTContext();
1215  QualType AnonTy = Context.getRecordType(Anon);
1216 
1217  RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
1218  if (!Owner)
1219  return None;
1220 
1221  unsigned Index = 0;
1222  for (const auto *D : Owner->noload_decls()) {
1223  const auto *F = dyn_cast<FieldDecl>(D);
1224  if (!F)
1225  continue;
1226 
1227  if (F->isAnonymousStructOrUnion()) {
1228  if (Context.hasSameType(F->getType(), AnonTy))
1229  break;
1230  ++Index;
1231  continue;
1232  }
1233 
1234  // If the field looks like this:
1235  // struct { ... } A;
1236  QualType FieldType = F->getType();
1237  if (const auto *RecType = dyn_cast<RecordType>(FieldType)) {
1238  const RecordDecl *RecDecl = RecType->getDecl();
1239  if (RecDecl->getDeclContext() == Owner && !RecDecl->getIdentifier()) {
1240  if (Context.hasSameType(FieldType, AnonTy))
1241  break;
1242  ++Index;
1243  continue;
1244  }
1245  }
1246  }
1247 
1248  return Index;
1249 }
1250 
1251 bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
1252  Decl *D2) {
1253  if (!::IsStructurallyEquivalent(*this, D1, D2))
1254  return false;
1255 
1256  return !Finish();
1257 }
1258 
1259 bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
1260  QualType T2) {
1261  if (!::IsStructurallyEquivalent(*this, T1, T2))
1262  return false;
1263 
1264  return !Finish();
1265 }
1266 
1267 bool StructuralEquivalenceContext::Finish() {
1268  while (!DeclsToCheck.empty()) {
1269  // Check the next declaration.
1270  Decl *D1 = DeclsToCheck.front();
1271  DeclsToCheck.pop_front();
1272 
1273  Decl *D2 = TentativeEquivalences[D1];
1274  assert(D2 && "Unrecorded tentative equivalence?");
1275 
1276  bool Equivalent = true;
1277 
1278  // FIXME: Switch on all declaration kinds. For now, we're just going to
1279  // check the obvious ones.
1280  if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
1281  if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
1282  // Check for equivalent structure names.
1283  IdentifierInfo *Name1 = Record1->getIdentifier();
1284  if (!Name1 && Record1->getTypedefNameForAnonDecl())
1285  Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
1286  IdentifierInfo *Name2 = Record2->getIdentifier();
1287  if (!Name2 && Record2->getTypedefNameForAnonDecl())
1288  Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
1289  if (!::IsStructurallyEquivalent(Name1, Name2) ||
1290  !::IsStructurallyEquivalent(*this, Record1, Record2))
1291  Equivalent = false;
1292  } else {
1293  // Record/non-record mismatch.
1294  Equivalent = false;
1295  }
1296  } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
1297  if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
1298  // Check for equivalent enum names.
1299  IdentifierInfo *Name1 = Enum1->getIdentifier();
1300  if (!Name1 && Enum1->getTypedefNameForAnonDecl())
1301  Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
1302  IdentifierInfo *Name2 = Enum2->getIdentifier();
1303  if (!Name2 && Enum2->getTypedefNameForAnonDecl())
1304  Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
1305  if (!::IsStructurallyEquivalent(Name1, Name2) ||
1306  !::IsStructurallyEquivalent(*this, Enum1, Enum2))
1307  Equivalent = false;
1308  } else {
1309  // Enum/non-enum mismatch
1310  Equivalent = false;
1311  }
1312  } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
1313  if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
1314  if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
1315  Typedef2->getIdentifier()) ||
1316  !::IsStructurallyEquivalent(*this, Typedef1->getUnderlyingType(),
1317  Typedef2->getUnderlyingType()))
1318  Equivalent = false;
1319  } else {
1320  // Typedef/non-typedef mismatch.
1321  Equivalent = false;
1322  }
1323  } else if (ClassTemplateDecl *ClassTemplate1 =
1324  dyn_cast<ClassTemplateDecl>(D1)) {
1325  if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
1326  if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
1327  ClassTemplate2->getIdentifier()) ||
1328  !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
1329  Equivalent = false;
1330  } else {
1331  // Class template/non-class-template mismatch.
1332  Equivalent = false;
1333  }
1334  } else if (TemplateTypeParmDecl *TTP1 =
1335  dyn_cast<TemplateTypeParmDecl>(D1)) {
1336  if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
1337  if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1338  Equivalent = false;
1339  } else {
1340  // Kind mismatch.
1341  Equivalent = false;
1342  }
1343  } else if (NonTypeTemplateParmDecl *NTTP1 =
1344  dyn_cast<NonTypeTemplateParmDecl>(D1)) {
1345  if (NonTypeTemplateParmDecl *NTTP2 =
1346  dyn_cast<NonTypeTemplateParmDecl>(D2)) {
1347  if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
1348  Equivalent = false;
1349  } else {
1350  // Kind mismatch.
1351  Equivalent = false;
1352  }
1353  } else if (TemplateTemplateParmDecl *TTP1 =
1354  dyn_cast<TemplateTemplateParmDecl>(D1)) {
1355  if (TemplateTemplateParmDecl *TTP2 =
1356  dyn_cast<TemplateTemplateParmDecl>(D2)) {
1357  if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1358  Equivalent = false;
1359  } else {
1360  // Kind mismatch.
1361  Equivalent = false;
1362  }
1363  }
1364 
1365  if (!Equivalent) {
1366  // Note that these two declarations are not equivalent (and we already
1367  // know about it).
1368  NonEquivalentDecls.insert(
1369  std::make_pair(D1->getCanonicalDecl(), D2->getCanonicalDecl()));
1370  return true;
1371  }
1372  // FIXME: Check other declaration kinds!
1373  }
1374 
1375  return false;
1376 }
1377 } // namespace clang
TemplateTemplateParmDecl * getParameterPack() const
Retrieve the template template parameter pack being substituted.
Definition: TemplateName.h:135
Defines the clang::ASTContext interface.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:4786
enumerator_iterator enumerator_end() const
Definition: Decl.h:3341
A (possibly-)qualified type.
Definition: Type.h:653
OverloadedOperatorKind getOperator() const
Return the overloaded operator to which this template name refers.
Definition: TemplateName.h:494
QualType getInjectedSpecializationType() const
Definition: Type.h:4667
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:478
unsigned getNumExceptions() const
Definition: Type.h:3572
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3058
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:456
Defines the SourceManager interface.
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:4851
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:270
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:4870
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
bool isVariadic() const
Definition: Type.h:3617
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2560
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:133
ObjCProtocolDecl * getProtocol(unsigned I) const
Fetch a protocol by index.
Definition: Type.h:5099
QualType getElementType() const
Definition: Type.h:2595
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Definition: TemplateName.h:484
unsigned getNumParams() const
Definition: Type.h:3491
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
ASTContext & FromCtx
AST contexts for which we are checking structural equivalence.
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4258
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:315
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Determines whether this field is a representative for an anonymous struct ...
Definition: Decl.cpp:3623
SubstTemplateTemplateParmStorage * getAsSubstTemplateTemplateParm() const
Retrieve the substituted template template parameter, if known.
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:265
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3482
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:291
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
Definition: DeclTemplate.h:255
Represents a class type in Objective C.
Definition: Type.h:5186
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:330
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:422
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3603
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclCXX.h:235
bool isSpelledAsLValue() const
Definition: Type.h:2437
bool ErrorOnTagTypeMismatch
Whether warn or error on tag type mismatches.
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2461
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:4565
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4314
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:172
unsigned getTypeQuals() const
Definition: Type.h:3629
bool StrictTypeSpelling
Whether we&#39;re being strict about the spelling of types when unifying two types.
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2539
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
TagKind getTagKind() const
Definition: Decl.h:3150
QualType getExceptionType(unsigned i) const
Definition: Type.h:3573
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
const TemplateArgument & getArg(unsigned Idx) const
Definition: TemplateBase.h:688
const Type * getClass() const
Definition: Type.h:2538
Expr * getSizeExpr() const
Definition: Type.h:2739
field_iterator field_begin() const
Definition: Decl.cpp:3937
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3633
TemplateTemplateParmDecl * getParameter() const
Definition: TemplateName.h:338
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
Expr * getSizeExpr() const
Definition: Type.h:2796
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2440
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:865
unsigned getNumProtocols() const
Return the number of qualifying protocols in this type, or 0 if there are none.
Definition: Type.h:5094
QualType getElementType() const
Definition: Type.h:2892
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Whether this is an anonymous struct or union.
Definition: Decl.h:3550
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:2876
bool IsStructurallyEquivalent(Decl *D1, Decl *D2)
Determine whether the two declarations are structurally equivalent.
Expr * getAddrSpaceExpr() const
Definition: Type.h:2847
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:5249
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:955
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3270
bool isInnerRef() const
Definition: Type.h:2438
decl_range noload_decls() const
noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...
Definition: DeclBase.h:1584
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
ObjCTypeParamDecl * getDecl() const
Definition: Type.h:5155
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:264
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:2774
DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID)
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4942
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
Expr - This represents one expression.
Definition: Expr.h:106
Declaration of a template type parameter.
unsigned getIndex() const
Definition: Type.h:4221
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6370
field_iterator field_end() const
Definition: Decl.h:3616
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID)
DeclContext * getDeclContext()
Definition: DeclBase.h:425
A structure for storing the information associated with a substituted template template parameter...
Definition: TemplateName.h:325
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
Definition: Type.h:4877
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
bool isIdentifier() const
Determine whether this template name refers to an identifier.
Definition: TemplateName.h:481
enumerator_iterator enumerator_begin() const
Definition: Decl.h:3334
QualType getRecordType(const RecordDecl *Decl) const
Represents a GCC generic vector type.
Definition: Type.h:2916
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2597
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1347
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:388
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template.
ElaboratedTypeKeyword getKeyword() const
Definition: Type.h:4747
bool isParameterPack() const
Returns whether this is a parameter pack.
Encodes a location in the source.
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5399
QualType getReturnType() const
Definition: Type.h:3203
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5386
A structure for storing an already-substituted template template parameter pack.
Definition: TemplateName.h:121
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3175
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:365
QualType getElementType() const
Definition: Type.h:2951
static QualType getUnderlyingType(const SubRegion *R)
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isParameterPack() const
Definition: Type.h:4222
bool isOverloadedOperator() const
Determine whether this template name refers to an overloaded operator.
Definition: TemplateName.h:491
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:360
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4335
Expr * getNoexceptExpr() const
Definition: Type.h:3577
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:4812
Qualifiers getIndexTypeQualifiers() const
Definition: Type.h:2601
TypeClass getTypeClass() const
Definition: Type.h:1615
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
Definition: TemplateBase.h:301
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3526
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4635
QualType getPointeeType() const
Definition: Type.h:2848
StringRef getName() const
Return the actual identifier string.
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2796
Represents a template argument.
Definition: TemplateBase.h:51
Represents a template name that was expressed as a qualified name.
Definition: TemplateName.h:366
Dataflow Directional Tag Classes.
ExtInfo getExtInfo() const
Definition: Type.h:3214
NestedNameSpecifier * getQualifier() const
Definition: Type.h:4933
VectorKind getVectorKind() const
Definition: Type.h:2961
Kind getKind() const
Definition: DeclBase.h:419
EnumDecl - Represents an enum.
Definition: Decl.h:3233
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2504
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1048
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:340
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4273
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:1596
Represents a pointer to an Objective C object.
Definition: Type.h:5442
llvm::DenseSet< std::pair< Decl *, Decl * > > & NonEquivalentDecls
Declaration (from, to) pairs that are known not to be equivalent (which we have already complained ab...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3978
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4573
const TemplateArgument & getArg(unsigned Idx) const
Retrieve a specific template argument as a type.
Definition: TemplateBase.h:682
const llvm::APInt & getSize() const
Definition: Type.h:2638
virtual void CompleteType(TagDecl *Tag)
Gives the external AST source an opportunity to complete an incomplete type.
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2421
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2190
Represents a base class of a C++ class.
Definition: DeclCXX.h:191
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2174
llvm::DenseMap< Decl *, Decl * > TentativeEquivalences
The set of "tentative" equivalences between two canonical declarations, mapping from a declaration in...
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:235
unsigned getDepth() const
Definition: Type.h:4220
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
QualType getParamType(unsigned i) const
Definition: Type.h:3493
Represents a type parameter type in Objective C.
Definition: Type.h:5112
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4903
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5747
QualType getNamedType() const
Retrieve the type named by the qualified-id.
Definition: Type.h:4815
A structure for storing the information associated with an overloaded template name.
Definition: TemplateName.h:95
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4279
std::deque< Decl * > DeclsToCheck
Queue of declarations in the first context whose equivalence with a declaration in the second context...
Declaration of a class template.
NameKind getKind() const
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:915
unsigned getNumElements() const
Definition: Type.h:2952
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:257
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:2834
bool isUnion() const
Definition: Decl.h:3159
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4495
TemplateDecl * getDecl() const
The template declaration that this qualified name refers to.
Definition: TemplateName.h:396
bool Complain
Whether to complain about failures.
QualType getType() const
Definition: Decl.h:639
TemplateArgument getArgumentPack() const
Retrieve the template template argument pack with which this parameter was substituted.
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2719
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Definition: DeclCXX.h:234
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:281
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
Definition: TemplateBase.h:288
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2620
SourceLocation getLocation() const
Definition: DeclBase.h:416
QualType getPointeeType() const
Definition: Type.h:2524
const IdentifierInfo * getIdentifier() const
Definition: Type.h:4934
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5458
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:290