clang  7.0.0
ASTImporter.cpp
Go to the documentation of this file.
1 //===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===//
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 defines the ASTImporter class which imports AST nodes from one
11 // context into another context.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/AST/ASTImporter.h"
16 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/Attr.h"
20 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclBase.h"
23 #include "clang/AST/DeclCXX.h"
24 #include "clang/AST/DeclFriend.h"
25 #include "clang/AST/DeclGroup.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/AST/DeclTemplate.h"
28 #include "clang/AST/DeclVisitor.h"
30 #include "clang/AST/Expr.h"
31 #include "clang/AST/ExprCXX.h"
32 #include "clang/AST/ExprObjC.h"
37 #include "clang/AST/Stmt.h"
38 #include "clang/AST/StmtCXX.h"
39 #include "clang/AST/StmtObjC.h"
40 #include "clang/AST/StmtVisitor.h"
41 #include "clang/AST/TemplateBase.h"
42 #include "clang/AST/TemplateName.h"
43 #include "clang/AST/Type.h"
44 #include "clang/AST/TypeLoc.h"
45 #include "clang/AST/TypeVisitor.h"
50 #include "clang/Basic/LLVM.h"
54 #include "clang/Basic/Specifiers.h"
55 #include "llvm/ADT/APSInt.h"
56 #include "llvm/ADT/ArrayRef.h"
57 #include "llvm/ADT/DenseMap.h"
58 #include "llvm/ADT/None.h"
59 #include "llvm/ADT/Optional.h"
60 #include "llvm/ADT/STLExtras.h"
61 #include "llvm/ADT/SmallVector.h"
62 #include "llvm/Support/Casting.h"
63 #include "llvm/Support/ErrorHandling.h"
64 #include "llvm/Support/MemoryBuffer.h"
65 #include <algorithm>
66 #include <cassert>
67 #include <cstddef>
68 #include <memory>
69 #include <type_traits>
70 #include <utility>
71 
72 namespace clang {
73 
74  template <class T>
77  SmallVector<Decl*, 2> Redecls;
78  for (auto *R : D->getFirstDecl()->redecls()) {
79  if (R != D->getFirstDecl())
80  Redecls.push_back(R);
81  }
82  Redecls.push_back(D->getFirstDecl());
83  std::reverse(Redecls.begin(), Redecls.end());
84  return Redecls;
85  }
86 
88  // Currently only FunctionDecl is supported
89  auto FD = cast<FunctionDecl>(D);
90  return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
91  }
92 
93  void updateFlags(const Decl *From, Decl *To) {
94  // Check if some flags or attrs are new in 'From' and copy into 'To'.
95  // FIXME: Other flags or attrs?
96  if (From->isUsed(false) && !To->isUsed(false))
97  To->setIsUsed();
98  }
99 
100  class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
101  public DeclVisitor<ASTNodeImporter, Decl *>,
102  public StmtVisitor<ASTNodeImporter, Stmt *> {
103  ASTImporter &Importer;
104 
105  // Wrapper for an overload set.
106  template <typename ToDeclT> struct CallOverloadedCreateFun {
107  template <typename... Args>
108  auto operator()(Args &&... args)
109  -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
110  return ToDeclT::Create(std::forward<Args>(args)...);
111  }
112  };
113 
114  // Always use these functions to create a Decl during import. There are
115  // certain tasks which must be done after the Decl was created, e.g. we
116  // must immediately register that as an imported Decl. The parameter `ToD`
117  // will be set to the newly created Decl or if had been imported before
118  // then to the already imported Decl. Returns a bool value set to true if
119  // the `FromD` had been imported before.
120  template <typename ToDeclT, typename FromDeclT, typename... Args>
121  LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
122  Args &&... args) {
123  // There may be several overloads of ToDeclT::Create. We must make sure
124  // to call the one which would be chosen by the arguments, thus we use a
125  // wrapper for the overload set.
126  CallOverloadedCreateFun<ToDeclT> OC;
127  return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
128  std::forward<Args>(args)...);
129  }
130  // Use this overload if a special Type is needed to be created. E.g if we
131  // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
132  // then:
133  // TypedefNameDecl *ToTypedef;
134  // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
135  template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
136  typename... Args>
137  LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
138  Args &&... args) {
139  CallOverloadedCreateFun<NewDeclT> OC;
140  return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
141  std::forward<Args>(args)...);
142  }
143  // Use this version if a special create function must be
144  // used, e.g. CXXRecordDecl::CreateLambda .
145  template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
146  typename... Args>
147  LLVM_NODISCARD bool
148  GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
149  FromDeclT *FromD, Args &&... args) {
150  ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
151  if (ToD)
152  return true; // Already imported.
153  ToD = CreateFun(std::forward<Args>(args)...);
154  InitializeImportedDecl(FromD, ToD);
155  return false; // A new Decl is created.
156  }
157 
158  void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
159  Importer.MapImported(FromD, ToD);
161  if (FromD->hasAttrs())
162  for (const Attr *FromAttr : FromD->getAttrs())
163  ToD->addAttr(Importer.Import(FromAttr));
164  if (FromD->isUsed())
165  ToD->setIsUsed();
166  if (FromD->isImplicit())
167  ToD->setImplicit();
168  }
169 
170  public:
171  explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
172 
176 
177  // Importing types
178  QualType VisitType(const Type *T);
192  // FIXME: DependentSizedExtVectorType
201  // FIXME: DependentTypeOfExprType
205  QualType VisitAutoType(const AutoType *T);
207  // FIXME: DependentDecltypeType
209  QualType VisitEnumType(const EnumType *T);
222 
223  // Importing declarations
224  bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
225  DeclContext *&LexicalDC, DeclarationName &Name,
226  NamedDecl *&ToD, SourceLocation &Loc);
227  void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
229  DeclarationNameInfo& To);
230  void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
231  void ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
232 
233  bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
234 
236 
238 
240 
241  /// What we should import from the definition.
243  /// Import the default subset of the definition, which might be
244  /// nothing (if minimal import is set) or might be everything (if minimal
245  /// import is not set).
247 
248  /// Import everything.
250 
251  /// Import only the bare bones needed to establish a valid
252  /// DeclContext.
254  };
255 
257  return IDK == IDK_Everything ||
258  (IDK == IDK_Default && !Importer.isMinimalImport());
259  }
260 
261  bool ImportDefinition(RecordDecl *From, RecordDecl *To,
263  bool ImportDefinition(VarDecl *From, VarDecl *To,
265  bool ImportDefinition(EnumDecl *From, EnumDecl *To,
272  TemplateParameterList *Params);
275  const TemplateArgumentLoc &TALoc);
276  bool ImportTemplateArguments(const TemplateArgument *FromArgs,
277  unsigned NumFromArgs,
279 
280  template <typename InContainerTy>
281  bool ImportTemplateArgumentListInfo(const InContainerTy &Container,
282  TemplateArgumentListInfo &ToTAInfo);
283 
284  template<typename InContainerTy>
286  SourceLocation FromRAngleLoc,
287  const InContainerTy &Container,
289 
292  std::tuple<FunctionTemplateDecl *, OptionalTemplateArgsTy>
294  FunctionDecl *FromFD);
295 
297 
298  bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
299  bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
300  bool Complain = true);
301  bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
302  bool Complain = true);
303  bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
310  Decl *VisitDecl(Decl *D);
317  Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
347 
363 
364  // Importing statements
366 
367  Stmt *VisitStmt(Stmt *S);
376  Stmt *VisitIfStmt(IfStmt *S);
379  Stmt *VisitDoStmt(DoStmt *S);
386  // FIXME: MSAsmStmt
387  // FIXME: SEHExceptStmt
388  // FIXME: SEHFinallyStmt
389  // FIXME: SEHTryStmt
390  // FIXME: SEHLeaveStmt
391  // FIXME: CapturedStmt
395  // FIXME: MSDependentExistsStmt
403 
404  // Importing expressions
405  Expr *VisitExpr(Expr *E);
471 
472  template<typename IIter, typename OIter>
473  void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
474  using ItemT = typename std::remove_reference<decltype(*Obegin)>::type;
475 
476  ASTImporter &ImporterRef = Importer;
477  std::transform(Ibegin, Iend, Obegin,
478  [&ImporterRef](ItemT From) -> ItemT {
479  return ImporterRef.Import(From);
480  });
481  }
482 
483  template<typename IIter, typename OIter>
484  bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
486 
487  ASTImporter &ImporterRef = Importer;
488  bool Failed = false;
489  std::transform(Ibegin, Iend, Obegin,
490  [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
491  auto *To = cast_or_null<ItemT>(ImporterRef.Import(From));
492  if (!To && From)
493  Failed = true;
494  return To;
495  });
496  return Failed;
497  }
498 
499  template<typename InContainerTy, typename OutContainerTy>
500  bool ImportContainerChecked(const InContainerTy &InContainer,
501  OutContainerTy &OutContainer) {
502  return ImportArrayChecked(InContainer.begin(), InContainer.end(),
503  OutContainer.begin());
504  }
505 
506  template<typename InContainerTy, typename OIter>
507  bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
508  return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
509  }
510 
511  // Importing overrides.
512  void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod);
513 
515  };
516 
517 template <typename InContainerTy>
519  SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
520  const InContainerTy &Container, TemplateArgumentListInfo &Result) {
521  TemplateArgumentListInfo ToTAInfo(Importer.Import(FromLAngleLoc),
522  Importer.Import(FromRAngleLoc));
523  if (ImportTemplateArgumentListInfo(Container, ToTAInfo))
524  return true;
525  Result = ToTAInfo;
526  return false;
527 }
528 
529 template <>
530 bool ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
533  From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
534 }
535 
536 template <>
540  return ImportTemplateArgumentListInfo(From.LAngleLoc, From.RAngleLoc,
541  From.arguments(), Result);
542 }
543 
544 std::tuple<FunctionTemplateDecl *, ASTNodeImporter::OptionalTemplateArgsTy>
546  FunctionDecl *FromFD) {
547  assert(FromFD->getTemplatedKind() ==
549  auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
550  auto *Template = cast_or_null<FunctionTemplateDecl>(
551  Importer.Import(FTSInfo->getTemplate()));
552 
553  // Import template arguments.
554  auto TemplArgs = FTSInfo->TemplateArguments->asArray();
555  TemplateArgsTy ToTemplArgs;
556  if (ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
557  ToTemplArgs)) // Error during import.
558  return std::make_tuple(Template, OptionalTemplateArgsTy());
559 
560  return std::make_tuple(Template, ToTemplArgs);
561 }
562 
563 } // namespace clang
564 
565 //----------------------------------------------------------------------------
566 // Import Types
567 //----------------------------------------------------------------------------
568 
569 using namespace clang;
570 
572  Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
573  << T->getTypeClassName();
574  return {};
575 }
576 
578  QualType UnderlyingType = Importer.Import(T->getValueType());
579  if(UnderlyingType.isNull())
580  return {};
581 
582  return Importer.getToContext().getAtomicType(UnderlyingType);
583 }
584 
586  switch (T->getKind()) {
587 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
588  case BuiltinType::Id: \
589  return Importer.getToContext().SingletonId;
590 #include "clang/Basic/OpenCLImageTypes.def"
591 #define SHARED_SINGLETON_TYPE(Expansion)
592 #define BUILTIN_TYPE(Id, SingletonId) \
593  case BuiltinType::Id: return Importer.getToContext().SingletonId;
594 #include "clang/AST/BuiltinTypes.def"
595 
596  // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
597  // context supports C++.
598 
599  // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
600  // context supports ObjC.
601 
602  case BuiltinType::Char_U:
603  // The context we're importing from has an unsigned 'char'. If we're
604  // importing into a context with a signed 'char', translate to
605  // 'unsigned char' instead.
606  if (Importer.getToContext().getLangOpts().CharIsSigned)
607  return Importer.getToContext().UnsignedCharTy;
608 
609  return Importer.getToContext().CharTy;
610 
611  case BuiltinType::Char_S:
612  // The context we're importing from has an unsigned 'char'. If we're
613  // importing into a context with a signed 'char', translate to
614  // 'unsigned char' instead.
615  if (!Importer.getToContext().getLangOpts().CharIsSigned)
616  return Importer.getToContext().SignedCharTy;
617 
618  return Importer.getToContext().CharTy;
619 
620  case BuiltinType::WChar_S:
621  case BuiltinType::WChar_U:
622  // FIXME: If not in C++, shall we translate to the C equivalent of
623  // wchar_t?
624  return Importer.getToContext().WCharTy;
625  }
626 
627  llvm_unreachable("Invalid BuiltinType Kind!");
628 }
629 
631  QualType OrigT = Importer.Import(T->getOriginalType());
632  if (OrigT.isNull())
633  return {};
634 
635  return Importer.getToContext().getDecayedType(OrigT);
636 }
637 
639  QualType ToElementType = Importer.Import(T->getElementType());
640  if (ToElementType.isNull())
641  return {};
642 
643  return Importer.getToContext().getComplexType(ToElementType);
644 }
645 
647  QualType ToPointeeType = Importer.Import(T->getPointeeType());
648  if (ToPointeeType.isNull())
649  return {};
650 
651  return Importer.getToContext().getPointerType(ToPointeeType);
652 }
653 
655  // FIXME: Check for blocks support in "to" context.
656  QualType ToPointeeType = Importer.Import(T->getPointeeType());
657  if (ToPointeeType.isNull())
658  return {};
659 
660  return Importer.getToContext().getBlockPointerType(ToPointeeType);
661 }
662 
663 QualType
665  // FIXME: Check for C++ support in "to" context.
666  QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
667  if (ToPointeeType.isNull())
668  return {};
669 
670  return Importer.getToContext().getLValueReferenceType(ToPointeeType);
671 }
672 
673 QualType
675  // FIXME: Check for C++0x support in "to" context.
676  QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
677  if (ToPointeeType.isNull())
678  return {};
679 
680  return Importer.getToContext().getRValueReferenceType(ToPointeeType);
681 }
682 
684  // FIXME: Check for C++ support in "to" context.
685  QualType ToPointeeType = Importer.Import(T->getPointeeType());
686  if (ToPointeeType.isNull())
687  return {};
688 
689  QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
690  return Importer.getToContext().getMemberPointerType(ToPointeeType,
691  ClassType.getTypePtr());
692 }
693 
695  QualType ToElementType = Importer.Import(T->getElementType());
696  if (ToElementType.isNull())
697  return {};
698 
699  return Importer.getToContext().getConstantArrayType(ToElementType,
700  T->getSize(),
701  T->getSizeModifier(),
703 }
704 
705 QualType
707  QualType ToElementType = Importer.Import(T->getElementType());
708  if (ToElementType.isNull())
709  return {};
710 
711  return Importer.getToContext().getIncompleteArrayType(ToElementType,
712  T->getSizeModifier(),
714 }
715 
717  QualType ToElementType = Importer.Import(T->getElementType());
718  if (ToElementType.isNull())
719  return {};
720 
721  Expr *Size = Importer.Import(T->getSizeExpr());
722  if (!Size)
723  return {};
724 
725  SourceRange Brackets = Importer.Import(T->getBracketsRange());
726  return Importer.getToContext().getVariableArrayType(ToElementType, Size,
727  T->getSizeModifier(),
729  Brackets);
730 }
731 
733  const DependentSizedArrayType *T) {
734  QualType ToElementType = Importer.Import(T->getElementType());
735  if (ToElementType.isNull())
736  return {};
737 
738  // SizeExpr may be null if size is not specified directly.
739  // For example, 'int a[]'.
740  Expr *Size = Importer.Import(T->getSizeExpr());
741  if (!Size && T->getSizeExpr())
742  return {};
743 
744  SourceRange Brackets = Importer.Import(T->getBracketsRange());
745  return Importer.getToContext().getDependentSizedArrayType(
746  ToElementType, Size, T->getSizeModifier(), T->getIndexTypeCVRQualifiers(),
747  Brackets);
748 }
749 
751  QualType ToElementType = Importer.Import(T->getElementType());
752  if (ToElementType.isNull())
753  return {};
754 
755  return Importer.getToContext().getVectorType(ToElementType,
756  T->getNumElements(),
757  T->getVectorKind());
758 }
759 
761  QualType ToElementType = Importer.Import(T->getElementType());
762  if (ToElementType.isNull())
763  return {};
764 
765  return Importer.getToContext().getExtVectorType(ToElementType,
766  T->getNumElements());
767 }
768 
769 QualType
771  // FIXME: What happens if we're importing a function without a prototype
772  // into C++? Should we make it variadic?
773  QualType ToResultType = Importer.Import(T->getReturnType());
774  if (ToResultType.isNull())
775  return {};
776 
777  return Importer.getToContext().getFunctionNoProtoType(ToResultType,
778  T->getExtInfo());
779 }
780 
782  QualType ToResultType = Importer.Import(T->getReturnType());
783  if (ToResultType.isNull())
784  return {};
785 
786  // Import argument types
787  SmallVector<QualType, 4> ArgTypes;
788  for (const auto &A : T->param_types()) {
789  QualType ArgType = Importer.Import(A);
790  if (ArgType.isNull())
791  return {};
792  ArgTypes.push_back(ArgType);
793  }
794 
795  // Import exception types
796  SmallVector<QualType, 4> ExceptionTypes;
797  for (const auto &E : T->exceptions()) {
798  QualType ExceptionType = Importer.Import(E);
799  if (ExceptionType.isNull())
800  return {};
801  ExceptionTypes.push_back(ExceptionType);
802  }
803 
806 
807  ToEPI.ExtInfo = FromEPI.ExtInfo;
808  ToEPI.Variadic = FromEPI.Variadic;
809  ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
810  ToEPI.TypeQuals = FromEPI.TypeQuals;
811  ToEPI.RefQualifier = FromEPI.RefQualifier;
812  ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
813  ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
815  Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
816  ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
817  Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
818  ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
819  Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
820 
821  return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
822 }
823 
825  const UnresolvedUsingType *T) {
826  const auto *ToD =
827  cast_or_null<UnresolvedUsingTypenameDecl>(Importer.Import(T->getDecl()));
828  if (!ToD)
829  return {};
830 
831  auto *ToPrevD =
832  cast_or_null<UnresolvedUsingTypenameDecl>(
833  Importer.Import(T->getDecl()->getPreviousDecl()));
834  if (!ToPrevD && T->getDecl()->getPreviousDecl())
835  return {};
836 
837  return Importer.getToContext().getTypeDeclType(ToD, ToPrevD);
838 }
839 
841  QualType ToInnerType = Importer.Import(T->getInnerType());
842  if (ToInnerType.isNull())
843  return {};
844 
845  return Importer.getToContext().getParenType(ToInnerType);
846 }
847 
849  auto *ToDecl =
850  dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
851  if (!ToDecl)
852  return {};
853 
854  return Importer.getToContext().getTypeDeclType(ToDecl);
855 }
856 
858  Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
859  if (!ToExpr)
860  return {};
861 
862  return Importer.getToContext().getTypeOfExprType(ToExpr);
863 }
864 
866  QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
867  if (ToUnderlyingType.isNull())
868  return {};
869 
870  return Importer.getToContext().getTypeOfType(ToUnderlyingType);
871 }
872 
874  // FIXME: Make sure that the "to" context supports C++0x!
875  Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
876  if (!ToExpr)
877  return {};
878 
879  QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
880  if (UnderlyingType.isNull())
881  return {};
882 
883  return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
884 }
885 
887  QualType ToBaseType = Importer.Import(T->getBaseType());
888  QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
889  if (ToBaseType.isNull() || ToUnderlyingType.isNull())
890  return {};
891 
892  return Importer.getToContext().getUnaryTransformType(ToBaseType,
893  ToUnderlyingType,
894  T->getUTTKind());
895 }
896 
898  // FIXME: Make sure that the "to" context supports C++11!
899  QualType FromDeduced = T->getDeducedType();
900  QualType ToDeduced;
901  if (!FromDeduced.isNull()) {
902  ToDeduced = Importer.Import(FromDeduced);
903  if (ToDeduced.isNull())
904  return {};
905  }
906 
907  return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
908  /*IsDependent*/false);
909 }
910 
912  const InjectedClassNameType *T) {
913  auto *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
914  if (!D)
915  return {};
916 
917  QualType InjType = Importer.Import(T->getInjectedSpecializationType());
918  if (InjType.isNull())
919  return {};
920 
921  // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
922  // See comments in InjectedClassNameType definition for details
923  // return Importer.getToContext().getInjectedClassNameType(D, InjType);
924  enum {
927  };
928 
929  return QualType(new (Importer.getToContext(), TypeAlignment)
930  InjectedClassNameType(D, InjType), 0);
931 }
932 
934  auto *ToDecl = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
935  if (!ToDecl)
936  return {};
937 
938  return Importer.getToContext().getTagDeclType(ToDecl);
939 }
940 
942  auto *ToDecl = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
943  if (!ToDecl)
944  return {};
945 
946  return Importer.getToContext().getTagDeclType(ToDecl);
947 }
948 
950  QualType FromModifiedType = T->getModifiedType();
951  QualType FromEquivalentType = T->getEquivalentType();
952  QualType ToModifiedType;
953  QualType ToEquivalentType;
954 
955  if (!FromModifiedType.isNull()) {
956  ToModifiedType = Importer.Import(FromModifiedType);
957  if (ToModifiedType.isNull())
958  return {};
959  }
960  if (!FromEquivalentType.isNull()) {
961  ToEquivalentType = Importer.Import(FromEquivalentType);
962  if (ToEquivalentType.isNull())
963  return {};
964  }
965 
966  return Importer.getToContext().getAttributedType(T->getAttrKind(),
967  ToModifiedType, ToEquivalentType);
968 }
969 
971  const TemplateTypeParmType *T) {
972  auto *ParmDecl =
973  cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
974  if (!ParmDecl && T->getDecl())
975  return {};
976 
977  return Importer.getToContext().getTemplateTypeParmType(
978  T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
979 }
980 
982  const SubstTemplateTypeParmType *T) {
983  const auto *Replaced =
984  cast_or_null<TemplateTypeParmType>(Importer.Import(
985  QualType(T->getReplacedParameter(), 0)).getTypePtr());
986  if (!Replaced)
987  return {};
988 
989  QualType Replacement = Importer.Import(T->getReplacementType());
990  if (Replacement.isNull())
991  return {};
992  Replacement = Replacement.getCanonicalType();
993 
994  return Importer.getToContext().getSubstTemplateTypeParmType(
995  Replaced, Replacement);
996 }
997 
999  const TemplateSpecializationType *T) {
1000  TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1001  if (ToTemplate.isNull())
1002  return {};
1003 
1004  SmallVector<TemplateArgument, 2> ToTemplateArgs;
1005  if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1006  return {};
1007 
1008  QualType ToCanonType;
1009  if (!QualType(T, 0).isCanonical()) {
1010  QualType FromCanonType
1011  = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1012  ToCanonType =Importer.Import(FromCanonType);
1013  if (ToCanonType.isNull())
1014  return {};
1015  }
1016  return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1017  ToTemplateArgs,
1018  ToCanonType);
1019 }
1020 
1022  NestedNameSpecifier *ToQualifier = nullptr;
1023  // Note: the qualifier in an ElaboratedType is optional.
1024  if (T->getQualifier()) {
1025  ToQualifier = Importer.Import(T->getQualifier());
1026  if (!ToQualifier)
1027  return {};
1028  }
1029 
1030  QualType ToNamedType = Importer.Import(T->getNamedType());
1031  if (ToNamedType.isNull())
1032  return {};
1033 
1034  TagDecl *OwnedTagDecl =
1035  cast_or_null<TagDecl>(Importer.Import(T->getOwnedTagDecl()));
1036  if (!OwnedTagDecl && T->getOwnedTagDecl())
1037  return {};
1038 
1039  return Importer.getToContext().getElaboratedType(T->getKeyword(),
1040  ToQualifier, ToNamedType,
1041  OwnedTagDecl);
1042 }
1043 
1045  QualType Pattern = Importer.Import(T->getPattern());
1046  if (Pattern.isNull())
1047  return {};
1048 
1049  return Importer.getToContext().getPackExpansionType(Pattern,
1050  T->getNumExpansions());
1051 }
1052 
1055  NestedNameSpecifier *Qualifier = Importer.Import(T->getQualifier());
1056  if (!Qualifier && T->getQualifier())
1057  return {};
1058 
1059  IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1060  if (!Name && T->getIdentifier())
1061  return {};
1062 
1064  ToPack.reserve(T->getNumArgs());
1065  if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToPack))
1066  return {};
1067 
1068  return Importer.getToContext().getDependentTemplateSpecializationType(
1069  T->getKeyword(), Qualifier, Name, ToPack);
1070 }
1071 
1073  NestedNameSpecifier *NNS = Importer.Import(T->getQualifier());
1074  if (!NNS && T->getQualifier())
1075  return QualType();
1076 
1077  IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1078  if (!Name && T->getIdentifier())
1079  return QualType();
1080 
1081  QualType Canon = (T == T->getCanonicalTypeInternal().getTypePtr())
1082  ? QualType()
1083  : Importer.Import(T->getCanonicalTypeInternal());
1084  if (!Canon.isNull())
1085  Canon = Canon.getCanonicalType();
1086 
1087  return Importer.getToContext().getDependentNameType(T->getKeyword(), NNS,
1088  Name, Canon);
1089 }
1090 
1092  auto *Class =
1093  dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1094  if (!Class)
1095  return {};
1096 
1097  return Importer.getToContext().getObjCInterfaceType(Class);
1098 }
1099 
1101  QualType ToBaseType = Importer.Import(T->getBaseType());
1102  if (ToBaseType.isNull())
1103  return {};
1104 
1105  SmallVector<QualType, 4> TypeArgs;
1106  for (auto TypeArg : T->getTypeArgsAsWritten()) {
1107  QualType ImportedTypeArg = Importer.Import(TypeArg);
1108  if (ImportedTypeArg.isNull())
1109  return {};
1110 
1111  TypeArgs.push_back(ImportedTypeArg);
1112  }
1113 
1115  for (auto *P : T->quals()) {
1116  auto *Protocol = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1117  if (!Protocol)
1118  return {};
1119  Protocols.push_back(Protocol);
1120  }
1121 
1122  return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
1123  Protocols,
1124  T->isKindOfTypeAsWritten());
1125 }
1126 
1127 QualType
1129  QualType ToPointeeType = Importer.Import(T->getPointeeType());
1130  if (ToPointeeType.isNull())
1131  return {};
1132 
1133  return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1134 }
1135 
1136 //----------------------------------------------------------------------------
1137 // Import Declarations
1138 //----------------------------------------------------------------------------
1140  DeclContext *&LexicalDC,
1141  DeclarationName &Name,
1142  NamedDecl *&ToD,
1143  SourceLocation &Loc) {
1144  // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
1145  // example: int struct_in_proto(struct data_t{int a;int b;} *d);
1146  DeclContext *OrigDC = D->getDeclContext();
1147  FunctionDecl *FunDecl;
1148  if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1149  FunDecl->hasBody()) {
1150  SourceRange RecR = D->getSourceRange();
1151  SourceRange BodyR = FunDecl->getBody()->getSourceRange();
1152  // If RecordDecl is not in Body (it is a param), we bail out.
1153  if (RecR.isValid() && BodyR.isValid() &&
1154  (RecR.getBegin() < BodyR.getBegin() ||
1155  BodyR.getEnd() < RecR.getEnd())) {
1156  Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1157  << D->getDeclKindName();
1158  return true;
1159  }
1160  }
1161 
1162  // Import the context of this declaration.
1163  DC = Importer.ImportContext(OrigDC);
1164  if (!DC)
1165  return true;
1166 
1167  LexicalDC = DC;
1168  if (D->getDeclContext() != D->getLexicalDeclContext()) {
1169  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1170  if (!LexicalDC)
1171  return true;
1172  }
1173 
1174  // Import the name of this declaration.
1175  Name = Importer.Import(D->getDeclName());
1176  if (D->getDeclName() && !Name)
1177  return true;
1178 
1179  // Import the location of this declaration.
1180  Loc = Importer.Import(D->getLocation());
1181  ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1182  return false;
1183 }
1184 
1186  if (!FromD)
1187  return;
1188 
1189  if (!ToD) {
1190  ToD = Importer.Import(FromD);
1191  if (!ToD)
1192  return;
1193  }
1194 
1195  if (auto *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1196  if (auto *ToRecord = cast_or_null<RecordDecl>(ToD)) {
1197  if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
1198  ImportDefinition(FromRecord, ToRecord);
1199  }
1200  }
1201  return;
1202  }
1203 
1204  if (auto *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1205  if (auto *ToEnum = cast_or_null<EnumDecl>(ToD)) {
1206  if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1207  ImportDefinition(FromEnum, ToEnum);
1208  }
1209  }
1210  return;
1211  }
1212 }
1213 
1214 void
1216  DeclarationNameInfo& To) {
1217  // NOTE: To.Name and To.Loc are already imported.
1218  // We only have to import To.LocInfo.
1219  switch (To.getName().getNameKind()) {
1226  return;
1227 
1229  SourceRange Range = From.getCXXOperatorNameRange();
1230  To.setCXXOperatorNameRange(Importer.Import(Range));
1231  return;
1232  }
1235  To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1236  return;
1237  }
1241  TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
1242  To.setNamedTypeInfo(Importer.Import(FromTInfo));
1243  return;
1244  }
1245  }
1246  llvm_unreachable("Unknown name kind.");
1247 }
1248 
1249 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1250  if (Importer.isMinimalImport() && !ForceImport) {
1251  Importer.ImportContext(FromDC);
1252  return;
1253  }
1254 
1255  for (auto *From : FromDC->decls())
1256  Importer.Import(From);
1257 }
1258 
1260  const CXXRecordDecl *From, CXXRecordDecl *To) {
1261  assert(From->isCompleteDefinition() && To->getDefinition() == To &&
1262  "Import implicit methods to or from non-definition");
1263 
1264  for (CXXMethodDecl *FromM : From->methods())
1265  if (FromM->isImplicit())
1266  Importer.Import(FromM);
1267 }
1268 
1270  ASTImporter &Importer) {
1271  if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
1272  auto *ToTypedef =
1273  cast_or_null<TypedefNameDecl>(Importer.Import(FromTypedef));
1274  assert (ToTypedef && "Failed to import typedef of an anonymous structure");
1275 
1276  To->setTypedefNameForAnonDecl(ToTypedef);
1277  }
1278 }
1279 
1282  if (To->getDefinition() || To->isBeingDefined()) {
1283  if (Kind == IDK_Everything)
1284  ImportDeclContext(From, /*ForceImport=*/true);
1285 
1286  return false;
1287  }
1288 
1289  To->startDefinition();
1290 
1291  setTypedefNameForAnonDecl(From, To, Importer);
1292 
1293  // Add base classes.
1294  if (auto *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
1295  auto *FromCXX = cast<CXXRecordDecl>(From);
1296 
1297  struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1298  struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
1299  ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
1300  ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
1301  ToData.Aggregate = FromData.Aggregate;
1302  ToData.PlainOldData = FromData.PlainOldData;
1303  ToData.Empty = FromData.Empty;
1304  ToData.Polymorphic = FromData.Polymorphic;
1305  ToData.Abstract = FromData.Abstract;
1306  ToData.IsStandardLayout = FromData.IsStandardLayout;
1307  ToData.IsCXX11StandardLayout = FromData.IsCXX11StandardLayout;
1308  ToData.HasBasesWithFields = FromData.HasBasesWithFields;
1309  ToData.HasBasesWithNonStaticDataMembers =
1310  FromData.HasBasesWithNonStaticDataMembers;
1311  ToData.HasPrivateFields = FromData.HasPrivateFields;
1312  ToData.HasProtectedFields = FromData.HasProtectedFields;
1313  ToData.HasPublicFields = FromData.HasPublicFields;
1314  ToData.HasMutableFields = FromData.HasMutableFields;
1315  ToData.HasVariantMembers = FromData.HasVariantMembers;
1316  ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
1317  ToData.HasInClassInitializer = FromData.HasInClassInitializer;
1318  ToData.HasUninitializedReferenceMember
1319  = FromData.HasUninitializedReferenceMember;
1320  ToData.HasUninitializedFields = FromData.HasUninitializedFields;
1321  ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
1322  ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
1323  ToData.NeedOverloadResolutionForCopyConstructor
1324  = FromData.NeedOverloadResolutionForCopyConstructor;
1325  ToData.NeedOverloadResolutionForMoveConstructor
1326  = FromData.NeedOverloadResolutionForMoveConstructor;
1327  ToData.NeedOverloadResolutionForMoveAssignment
1328  = FromData.NeedOverloadResolutionForMoveAssignment;
1329  ToData.NeedOverloadResolutionForDestructor
1330  = FromData.NeedOverloadResolutionForDestructor;
1331  ToData.DefaultedCopyConstructorIsDeleted
1332  = FromData.DefaultedCopyConstructorIsDeleted;
1333  ToData.DefaultedMoveConstructorIsDeleted
1334  = FromData.DefaultedMoveConstructorIsDeleted;
1335  ToData.DefaultedMoveAssignmentIsDeleted
1336  = FromData.DefaultedMoveAssignmentIsDeleted;
1337  ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
1338  ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
1339  ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
1340  ToData.HasConstexprNonCopyMoveConstructor
1341  = FromData.HasConstexprNonCopyMoveConstructor;
1342  ToData.HasDefaultedDefaultConstructor
1343  = FromData.HasDefaultedDefaultConstructor;
1344  ToData.DefaultedDefaultConstructorIsConstexpr
1345  = FromData.DefaultedDefaultConstructorIsConstexpr;
1346  ToData.HasConstexprDefaultConstructor
1347  = FromData.HasConstexprDefaultConstructor;
1348  ToData.HasNonLiteralTypeFieldsOrBases
1349  = FromData.HasNonLiteralTypeFieldsOrBases;
1350  // ComputedVisibleConversions not imported.
1351  ToData.UserProvidedDefaultConstructor
1352  = FromData.UserProvidedDefaultConstructor;
1353  ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
1354  ToData.ImplicitCopyConstructorCanHaveConstParamForVBase
1355  = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase;
1356  ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase
1357  = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase;
1358  ToData.ImplicitCopyAssignmentHasConstParam
1359  = FromData.ImplicitCopyAssignmentHasConstParam;
1360  ToData.HasDeclaredCopyConstructorWithConstParam
1361  = FromData.HasDeclaredCopyConstructorWithConstParam;
1362  ToData.HasDeclaredCopyAssignmentWithConstParam
1363  = FromData.HasDeclaredCopyAssignmentWithConstParam;
1364 
1366  for (const auto &Base1 : FromCXX->bases()) {
1367  QualType T = Importer.Import(Base1.getType());
1368  if (T.isNull())
1369  return true;
1370 
1371  SourceLocation EllipsisLoc;
1372  if (Base1.isPackExpansion())
1373  EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
1374 
1375  // Ensure that we have a definition for the base.
1376  ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
1377 
1378  Bases.push_back(
1379  new (Importer.getToContext())
1380  CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
1381  Base1.isVirtual(),
1382  Base1.isBaseOfClass(),
1383  Base1.getAccessSpecifierAsWritten(),
1384  Importer.Import(Base1.getTypeSourceInfo()),
1385  EllipsisLoc));
1386  }
1387  if (!Bases.empty())
1388  ToCXX->setBases(Bases.data(), Bases.size());
1389  }
1390 
1391  if (shouldForceImportDeclContext(Kind))
1392  ImportDeclContext(From, /*ForceImport=*/true);
1393 
1394  To->completeDefinition();
1395  return false;
1396 }
1397 
1400  if (To->getAnyInitializer())
1401  return false;
1402 
1403  // FIXME: Can we really import any initializer? Alternatively, we could force
1404  // ourselves to import every declaration of a variable and then only use
1405  // getInit() here.
1406  To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
1407 
1408  // FIXME: Other bits to merge?
1409 
1410  return false;
1411 }
1412 
1415  if (To->getDefinition() || To->isBeingDefined()) {
1416  if (Kind == IDK_Everything)
1417  ImportDeclContext(From, /*ForceImport=*/true);
1418  return false;
1419  }
1420 
1421  To->startDefinition();
1422 
1423  setTypedefNameForAnonDecl(From, To, Importer);
1424 
1425  QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
1426  if (T.isNull())
1427  return true;
1428 
1429  QualType ToPromotionType = Importer.Import(From->getPromotionType());
1430  if (ToPromotionType.isNull())
1431  return true;
1432 
1433  if (shouldForceImportDeclContext(Kind))
1434  ImportDeclContext(From, /*ForceImport=*/true);
1435 
1436  // FIXME: we might need to merge the number of positive or negative bits
1437  // if the enumerator lists don't match.
1438  To->completeDefinition(T, ToPromotionType,
1439  From->getNumPositiveBits(),
1440  From->getNumNegativeBits());
1441  return false;
1442 }
1443 
1445  TemplateParameterList *Params) {
1446  SmallVector<NamedDecl *, 4> ToParams(Params->size());
1447  if (ImportContainerChecked(*Params, ToParams))
1448  return nullptr;
1449 
1450  Expr *ToRequiresClause;
1451  if (Expr *const R = Params->getRequiresClause()) {
1452  ToRequiresClause = Importer.Import(R);
1453  if (!ToRequiresClause)
1454  return nullptr;
1455  } else {
1456  ToRequiresClause = nullptr;
1457  }
1458 
1459  return TemplateParameterList::Create(Importer.getToContext(),
1460  Importer.Import(Params->getTemplateLoc()),
1461  Importer.Import(Params->getLAngleLoc()),
1462  ToParams,
1463  Importer.Import(Params->getRAngleLoc()),
1464  ToRequiresClause);
1465 }
1466 
1469  switch (From.getKind()) {
1471  return TemplateArgument();
1472 
1473  case TemplateArgument::Type: {
1474  QualType ToType = Importer.Import(From.getAsType());
1475  if (ToType.isNull())
1476  return {};
1477  return TemplateArgument(ToType);
1478  }
1479 
1481  QualType ToType = Importer.Import(From.getIntegralType());
1482  if (ToType.isNull())
1483  return {};
1484  return TemplateArgument(From, ToType);
1485  }
1486 
1488  auto *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
1489  QualType ToType = Importer.Import(From.getParamTypeForDecl());
1490  if (!To || ToType.isNull())
1491  return {};
1492  return TemplateArgument(To, ToType);
1493  }
1494 
1496  QualType ToType = Importer.Import(From.getNullPtrType());
1497  if (ToType.isNull())
1498  return {};
1499  return TemplateArgument(ToType, /*isNullPtr*/true);
1500  }
1501 
1503  TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
1504  if (ToTemplate.isNull())
1505  return {};
1506 
1507  return TemplateArgument(ToTemplate);
1508  }
1509 
1511  TemplateName ToTemplate
1512  = Importer.Import(From.getAsTemplateOrTemplatePattern());
1513  if (ToTemplate.isNull())
1514  return {};
1515 
1516  return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
1517  }
1518 
1520  if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
1521  return TemplateArgument(ToExpr);
1522  return TemplateArgument();
1523 
1524  case TemplateArgument::Pack: {
1526  ToPack.reserve(From.pack_size());
1527  if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
1528  return {};
1529 
1530  return TemplateArgument(
1531  llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
1532  }
1533  }
1534 
1535  llvm_unreachable("Invalid template argument kind");
1536 }
1537 
1541  TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
1542  TemplateArgumentLocInfo ToInfo;
1543  if (Arg.getKind() == TemplateArgument::Expression) {
1544  Expr *E = Importer.Import(FromInfo.getAsExpr());
1545  ToInfo = TemplateArgumentLocInfo(E);
1546  if (!E)
1547  return None;
1548  } else if (Arg.getKind() == TemplateArgument::Type) {
1549  if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo()))
1550  ToInfo = TemplateArgumentLocInfo(TSI);
1551  else
1552  return None;
1553  } else {
1554  ToInfo = TemplateArgumentLocInfo(
1555  Importer.Import(FromInfo.getTemplateQualifierLoc()),
1556  Importer.Import(FromInfo.getTemplateNameLoc()),
1557  Importer.Import(FromInfo.getTemplateEllipsisLoc()));
1558  }
1559  return TemplateArgumentLoc(Arg, ToInfo);
1560 }
1561 
1563  unsigned NumFromArgs,
1565  for (unsigned I = 0; I != NumFromArgs; ++I) {
1566  TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
1567  if (To.isNull() && !FromArgs[I].isNull())
1568  return true;
1569 
1570  ToArgs.push_back(To);
1571  }
1572 
1573  return false;
1574 }
1575 
1576 // We cannot use Optional<> pattern here and below because
1577 // TemplateArgumentListInfo's operator new is declared as deleted so it cannot
1578 // be stored in Optional.
1579 template <typename InContainerTy>
1581  const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
1582  for (const auto &FromLoc : Container) {
1583  if (auto ToLoc = ImportTemplateArgumentLoc(FromLoc))
1584  ToTAInfo.addArgument(*ToLoc);
1585  else
1586  return true;
1587  }
1588  return false;
1589 }
1590 
1595 }
1596 
1597 bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) {
1599  Importer.getFromContext(), Importer.getToContext(),
1600  Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1601  false, Complain);
1602  return Ctx.IsEquivalent(From, To);
1603 }
1604 
1606  RecordDecl *ToRecord, bool Complain) {
1607  // Eliminate a potential failure point where we attempt to re-import
1608  // something we're trying to import while completing ToRecord.
1609  Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
1610  if (ToOrigin) {
1611  auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
1612  if (ToOriginRecord)
1613  ToRecord = ToOriginRecord;
1614  }
1615 
1616  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1617  ToRecord->getASTContext(),
1618  Importer.getNonEquivalentDecls(),
1619  getStructuralEquivalenceKind(Importer),
1620  false, Complain);
1621  return Ctx.IsEquivalent(FromRecord, ToRecord);
1622 }
1623 
1625  bool Complain) {
1627  Importer.getFromContext(), Importer.getToContext(),
1628  Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1629  false, Complain);
1630  return Ctx.IsEquivalent(FromVar, ToVar);
1631 }
1632 
1635  Importer.getFromContext(), Importer.getToContext(),
1636  Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
1637  return Ctx.IsEquivalent(FromEnum, ToEnum);
1638 }
1639 
1641  FunctionTemplateDecl *To) {
1643  Importer.getFromContext(), Importer.getToContext(),
1644  Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1645  false, false);
1646  return Ctx.IsEquivalent(From, To);
1647 }
1648 
1651  Importer.getFromContext(), Importer.getToContext(),
1652  Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1653  false, false);
1654  return Ctx.IsEquivalent(From, To);
1655 }
1656 
1658  EnumConstantDecl *ToEC) {
1659  const llvm::APSInt &FromVal = FromEC->getInitVal();
1660  const llvm::APSInt &ToVal = ToEC->getInitVal();
1661 
1662  return FromVal.isSigned() == ToVal.isSigned() &&
1663  FromVal.getBitWidth() == ToVal.getBitWidth() &&
1664  FromVal == ToVal;
1665 }
1666 
1668  ClassTemplateDecl *To) {
1669  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1670  Importer.getToContext(),
1671  Importer.getNonEquivalentDecls(),
1672  getStructuralEquivalenceKind(Importer));
1673  return Ctx.IsEquivalent(From, To);
1674 }
1675 
1677  VarTemplateDecl *To) {
1678  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1679  Importer.getToContext(),
1680  Importer.getNonEquivalentDecls(),
1681  getStructuralEquivalenceKind(Importer));
1682  return Ctx.IsEquivalent(From, To);
1683 }
1684 
1686  Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1687  << D->getDeclKindName();
1688  return nullptr;
1689 }
1690 
1692  // Import the context of this declaration.
1693  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1694  if (!DC)
1695  return nullptr;
1696 
1697  DeclContext *LexicalDC = DC;
1698  if (D->getDeclContext() != D->getLexicalDeclContext()) {
1699  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1700  if (!LexicalDC)
1701  return nullptr;
1702  }
1703 
1704  // Import the location of this declaration.
1705  SourceLocation Loc = Importer.Import(D->getLocation());
1706 
1707  EmptyDecl *ToD;
1708  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, Loc))
1709  return ToD;
1710 
1711  ToD->setLexicalDeclContext(LexicalDC);
1712  LexicalDC->addDeclInternal(ToD);
1713  return ToD;
1714 }
1715 
1717  TranslationUnitDecl *ToD =
1718  Importer.getToContext().getTranslationUnitDecl();
1719 
1720  Importer.MapImported(D, ToD);
1721 
1722  return ToD;
1723 }
1724 
1726  SourceLocation Loc = Importer.Import(D->getLocation());
1727  SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
1728 
1729  // Import the context of this declaration.
1730  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1731  if (!DC)
1732  return nullptr;
1733 
1734  AccessSpecDecl *ToD;
1735  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(),
1736  DC, Loc, ColonLoc))
1737  return ToD;
1738 
1739  // Lexical DeclContext and Semantic DeclContext
1740  // is always the same for the accessSpec.
1741  ToD->setLexicalDeclContext(DC);
1742  DC->addDeclInternal(ToD);
1743 
1744  return ToD;
1745 }
1746 
1748  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1749  if (!DC)
1750  return nullptr;
1751 
1752  DeclContext *LexicalDC = DC;
1753 
1754  // Import the location of this declaration.
1755  SourceLocation Loc = Importer.Import(D->getLocation());
1756 
1757  Expr *AssertExpr = Importer.Import(D->getAssertExpr());
1758  if (!AssertExpr)
1759  return nullptr;
1760 
1761  StringLiteral *FromMsg = D->getMessage();
1762  auto *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
1763  if (!ToMsg && FromMsg)
1764  return nullptr;
1765 
1766  StaticAssertDecl *ToD;
1767  if (GetImportedOrCreateDecl(
1768  ToD, D, Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
1769  Importer.Import(D->getRParenLoc()), D->isFailed()))
1770  return ToD;
1771 
1772  ToD->setLexicalDeclContext(LexicalDC);
1773  LexicalDC->addDeclInternal(ToD);
1774  return ToD;
1775 }
1776 
1778  // Import the major distinguishing characteristics of this namespace.
1779  DeclContext *DC, *LexicalDC;
1780  DeclarationName Name;
1781  SourceLocation Loc;
1782  NamedDecl *ToD;
1783  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1784  return nullptr;
1785  if (ToD)
1786  return ToD;
1787 
1788  NamespaceDecl *MergeWithNamespace = nullptr;
1789  if (!Name) {
1790  // This is an anonymous namespace. Adopt an existing anonymous
1791  // namespace if we can.
1792  // FIXME: Not testable.
1793  if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
1794  MergeWithNamespace = TU->getAnonymousNamespace();
1795  else
1796  MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
1797  } else {
1798  SmallVector<NamedDecl *, 4> ConflictingDecls;
1799  SmallVector<NamedDecl *, 2> FoundDecls;
1800  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1801  for (auto *FoundDecl : FoundDecls) {
1803  continue;
1804 
1805  if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
1806  MergeWithNamespace = FoundNS;
1807  ConflictingDecls.clear();
1808  break;
1809  }
1810 
1811  ConflictingDecls.push_back(FoundDecl);
1812  }
1813 
1814  if (!ConflictingDecls.empty()) {
1815  Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
1816  ConflictingDecls.data(),
1817  ConflictingDecls.size());
1818  }
1819  }
1820 
1821  // Create the "to" namespace, if needed.
1822  NamespaceDecl *ToNamespace = MergeWithNamespace;
1823  if (!ToNamespace) {
1824  if (GetImportedOrCreateDecl(
1825  ToNamespace, D, Importer.getToContext(), DC, D->isInline(),
1826  Importer.Import(D->getLocStart()), Loc, Name.getAsIdentifierInfo(),
1827  /*PrevDecl=*/nullptr))
1828  return ToNamespace;
1829  ToNamespace->setLexicalDeclContext(LexicalDC);
1830  LexicalDC->addDeclInternal(ToNamespace);
1831 
1832  // If this is an anonymous namespace, register it as the anonymous
1833  // namespace within its context.
1834  if (!Name) {
1835  if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
1836  TU->setAnonymousNamespace(ToNamespace);
1837  else
1838  cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
1839  }
1840  }
1841  Importer.MapImported(D, ToNamespace);
1842 
1843  ImportDeclContext(D);
1844 
1845  return ToNamespace;
1846 }
1847 
1849  // Import the major distinguishing characteristics of this namespace.
1850  DeclContext *DC, *LexicalDC;
1851  DeclarationName Name;
1852  SourceLocation Loc;
1853  NamedDecl *LookupD;
1854  if (ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
1855  return nullptr;
1856  if (LookupD)
1857  return LookupD;
1858 
1859  // NOTE: No conflict resolution is done for namespace aliases now.
1860 
1861  auto *TargetDecl = cast_or_null<NamespaceDecl>(
1862  Importer.Import(D->getNamespace()));
1863  if (!TargetDecl)
1864  return nullptr;
1865 
1866  IdentifierInfo *ToII = Importer.Import(D->getIdentifier());
1867  if (!ToII)
1868  return nullptr;
1869 
1870  NestedNameSpecifierLoc ToQLoc = Importer.Import(D->getQualifierLoc());
1871  if (D->getQualifierLoc() && !ToQLoc)
1872  return nullptr;
1873 
1874  NamespaceAliasDecl *ToD;
1875  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC,
1876  Importer.Import(D->getNamespaceLoc()),
1877  Importer.Import(D->getAliasLoc()), ToII, ToQLoc,
1878  Importer.Import(D->getTargetNameLoc()),
1879  TargetDecl))
1880  return ToD;
1881 
1882  ToD->setLexicalDeclContext(LexicalDC);
1883  LexicalDC->addDeclInternal(ToD);
1884 
1885  return ToD;
1886 }
1887 
1889  // Import the major distinguishing characteristics of this typedef.
1890  DeclContext *DC, *LexicalDC;
1891  DeclarationName Name;
1892  SourceLocation Loc;
1893  NamedDecl *ToD;
1894  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1895  return nullptr;
1896  if (ToD)
1897  return ToD;
1898 
1899  // If this typedef is not in block scope, determine whether we've
1900  // seen a typedef with the same name (that we can merge with) or any
1901  // other entity by that name (which name lookup could conflict with).
1902  if (!DC->isFunctionOrMethod()) {
1903  SmallVector<NamedDecl *, 4> ConflictingDecls;
1904  unsigned IDNS = Decl::IDNS_Ordinary;
1905  SmallVector<NamedDecl *, 2> FoundDecls;
1906  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1907  for (auto *FoundDecl : FoundDecls) {
1908  if (!FoundDecl->isInIdentifierNamespace(IDNS))
1909  continue;
1910  if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
1911  if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
1912  FoundTypedef->getUnderlyingType()))
1913  return Importer.MapImported(D, FoundTypedef);
1914  }
1915 
1916  ConflictingDecls.push_back(FoundDecl);
1917  }
1918 
1919  if (!ConflictingDecls.empty()) {
1920  Name = Importer.HandleNameConflict(Name, DC, IDNS,
1921  ConflictingDecls.data(),
1922  ConflictingDecls.size());
1923  if (!Name)
1924  return nullptr;
1925  }
1926  }
1927 
1928  // Import the underlying type of this typedef;
1929  QualType T = Importer.Import(D->getUnderlyingType());
1930  if (T.isNull())
1931  return nullptr;
1932 
1933  // Create the new typedef node.
1934  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
1935  SourceLocation StartL = Importer.Import(D->getLocStart());
1936 
1937  TypedefNameDecl *ToTypedef;
1938  if (IsAlias) {
1939  if (GetImportedOrCreateDecl<TypeAliasDecl>(
1940  ToTypedef, D, Importer.getToContext(), DC, StartL, Loc,
1941  Name.getAsIdentifierInfo(), TInfo))
1942  return ToTypedef;
1943  } else if (GetImportedOrCreateDecl<TypedefDecl>(
1944  ToTypedef, D, Importer.getToContext(), DC, StartL, Loc,
1945  Name.getAsIdentifierInfo(), TInfo))
1946  return ToTypedef;
1947 
1948  ToTypedef->setAccess(D->getAccess());
1949  ToTypedef->setLexicalDeclContext(LexicalDC);
1950 
1951  // Templated declarations should not appear in DeclContext.
1952  TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr;
1953  if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
1954  LexicalDC->addDeclInternal(ToTypedef);
1955 
1956  return ToTypedef;
1957 }
1958 
1960  return VisitTypedefNameDecl(D, /*IsAlias=*/false);
1961 }
1962 
1964  return VisitTypedefNameDecl(D, /*IsAlias=*/true);
1965 }
1966 
1968  // Import the major distinguishing characteristics of this typedef.
1969  DeclContext *DC, *LexicalDC;
1970  DeclarationName Name;
1971  SourceLocation Loc;
1972  NamedDecl *FoundD;
1973  if (ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
1974  return nullptr;
1975  if (FoundD)
1976  return FoundD;
1977 
1978  // If this typedef is not in block scope, determine whether we've
1979  // seen a typedef with the same name (that we can merge with) or any
1980  // other entity by that name (which name lookup could conflict with).
1981  if (!DC->isFunctionOrMethod()) {
1982  SmallVector<NamedDecl *, 4> ConflictingDecls;
1983  unsigned IDNS = Decl::IDNS_Ordinary;
1984  SmallVector<NamedDecl *, 2> FoundDecls;
1985  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1986  for (auto *FoundDecl : FoundDecls) {
1987  if (!FoundDecl->isInIdentifierNamespace(IDNS))
1988  continue;
1989  if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
1990  return Importer.MapImported(D, FoundAlias);
1991  ConflictingDecls.push_back(FoundDecl);
1992  }
1993 
1994  if (!ConflictingDecls.empty()) {
1995  Name = Importer.HandleNameConflict(Name, DC, IDNS,
1996  ConflictingDecls.data(),
1997  ConflictingDecls.size());
1998  if (!Name)
1999  return nullptr;
2000  }
2001  }
2002 
2004  D->getTemplateParameters());
2005  if (!Params)
2006  return nullptr;
2007 
2008  auto *TemplDecl = cast_or_null<TypeAliasDecl>(
2009  Importer.Import(D->getTemplatedDecl()));
2010  if (!TemplDecl)
2011  return nullptr;
2012 
2013  TypeAliasTemplateDecl *ToAlias;
2014  if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc,
2015  Name, Params, TemplDecl))
2016  return ToAlias;
2017 
2018  TemplDecl->setDescribedAliasTemplate(ToAlias);
2019 
2020  ToAlias->setAccess(D->getAccess());
2021  ToAlias->setLexicalDeclContext(LexicalDC);
2022  LexicalDC->addDeclInternal(ToAlias);
2023  return ToAlias;
2024 }
2025 
2027  // Import the major distinguishing characteristics of this label.
2028  DeclContext *DC, *LexicalDC;
2029  DeclarationName Name;
2030  SourceLocation Loc;
2031  NamedDecl *ToD;
2032  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2033  return nullptr;
2034  if (ToD)
2035  return ToD;
2036 
2037  assert(LexicalDC->isFunctionOrMethod());
2038 
2039  LabelDecl *ToLabel;
2040  if (D->isGnuLocal()
2041  ? GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
2042  Importer.Import(D->getLocation()),
2043  Name.getAsIdentifierInfo(),
2044  Importer.Import(D->getLocStart()))
2045  : GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
2046  Importer.Import(D->getLocation()),
2047  Name.getAsIdentifierInfo()))
2048  return ToLabel;
2049 
2050  auto *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
2051  if (!Label)
2052  return nullptr;
2053 
2054  ToLabel->setStmt(Label);
2055  ToLabel->setLexicalDeclContext(LexicalDC);
2056  LexicalDC->addDeclInternal(ToLabel);
2057  return ToLabel;
2058 }
2059 
2061  // Import the major distinguishing characteristics of this enum.
2062  DeclContext *DC, *LexicalDC;
2063  DeclarationName Name;
2064  SourceLocation Loc;
2065  NamedDecl *ToD;
2066  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2067  return nullptr;
2068  if (ToD)
2069  return ToD;
2070 
2071  // Figure out what enum name we're looking for.
2072  unsigned IDNS = Decl::IDNS_Tag;
2073  DeclarationName SearchName = Name;
2074  if (!SearchName && D->getTypedefNameForAnonDecl()) {
2075  SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2076  IDNS = Decl::IDNS_Ordinary;
2077  } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2078  IDNS |= Decl::IDNS_Ordinary;
2079 
2080  // We may already have an enum of the same name; try to find and match it.
2081  if (!DC->isFunctionOrMethod() && SearchName) {
2082  SmallVector<NamedDecl *, 4> ConflictingDecls;
2083  SmallVector<NamedDecl *, 2> FoundDecls;
2084  DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
2085  for (auto *FoundDecl : FoundDecls) {
2086  if (!FoundDecl->isInIdentifierNamespace(IDNS))
2087  continue;
2088 
2089  Decl *Found = FoundDecl;
2090  if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2091  if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2092  Found = Tag->getDecl();
2093  }
2094 
2095  if (auto *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2096  if (IsStructuralMatch(D, FoundEnum))
2097  return Importer.MapImported(D, FoundEnum);
2098  }
2099 
2100  ConflictingDecls.push_back(FoundDecl);
2101  }
2102 
2103  if (!ConflictingDecls.empty()) {
2104  Name = Importer.HandleNameConflict(Name, DC, IDNS,
2105  ConflictingDecls.data(),
2106  ConflictingDecls.size());
2107  }
2108  }
2109 
2110  // Create the enum declaration.
2111  EnumDecl *D2;
2112  if (GetImportedOrCreateDecl(
2113  D2, D, Importer.getToContext(), DC, Importer.Import(D->getLocStart()),
2114  Loc, Name.getAsIdentifierInfo(), nullptr, D->isScoped(),
2115  D->isScopedUsingClassTag(), D->isFixed()))
2116  return D2;
2117 
2118  // Import the qualifier, if any.
2119  D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2120  D2->setAccess(D->getAccess());
2121  D2->setLexicalDeclContext(LexicalDC);
2122  LexicalDC->addDeclInternal(D2);
2123 
2124  // Import the integer type.
2125  QualType ToIntegerType = Importer.Import(D->getIntegerType());
2126  if (ToIntegerType.isNull())
2127  return nullptr;
2128  D2->setIntegerType(ToIntegerType);
2129 
2130  // Import the definition
2131  if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2132  return nullptr;
2133 
2134  return D2;
2135 }
2136 
2138  // If this record has a definition in the translation unit we're coming from,
2139  // but this particular declaration is not that definition, import the
2140  // definition and map to that.
2141  TagDecl *Definition = D->getDefinition();
2142  if (Definition && Definition != D &&
2143  // In contrast to a normal CXXRecordDecl, the implicit
2144  // CXXRecordDecl of ClassTemplateSpecializationDecl is its redeclaration.
2145  // The definition of the implicit CXXRecordDecl in this case is the
2146  // ClassTemplateSpecializationDecl itself. Thus, we start with an extra
2147  // condition in order to be able to import the implict Decl.
2148  !D->isImplicit()) {
2149  Decl *ImportedDef = Importer.Import(Definition);
2150  if (!ImportedDef)
2151  return nullptr;
2152 
2153  return Importer.MapImported(D, ImportedDef);
2154  }
2155 
2156  // Import the major distinguishing characteristics of this record.
2157  DeclContext *DC, *LexicalDC;
2158  DeclarationName Name;
2159  SourceLocation Loc;
2160  NamedDecl *ToD;
2161  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2162  return nullptr;
2163  if (ToD)
2164  return ToD;
2165 
2166  // Figure out what structure name we're looking for.
2167  unsigned IDNS = Decl::IDNS_Tag;
2168  DeclarationName SearchName = Name;
2169  if (!SearchName && D->getTypedefNameForAnonDecl()) {
2170  SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2171  IDNS = Decl::IDNS_Ordinary;
2172  } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2173  IDNS |= Decl::IDNS_Ordinary;
2174 
2175  // We may already have a record of the same name; try to find and match it.
2176  RecordDecl *AdoptDecl = nullptr;
2177  RecordDecl *PrevDecl = nullptr;
2178  if (!DC->isFunctionOrMethod()) {
2179  SmallVector<NamedDecl *, 4> ConflictingDecls;
2180  SmallVector<NamedDecl *, 2> FoundDecls;
2181  DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
2182 
2183  if (!FoundDecls.empty()) {
2184  // We're going to have to compare D against potentially conflicting Decls, so complete it.
2187  }
2188 
2189  for (auto *FoundDecl : FoundDecls) {
2190  if (!FoundDecl->isInIdentifierNamespace(IDNS))
2191  continue;
2192 
2193  Decl *Found = FoundDecl;
2194  if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2195  if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2196  Found = Tag->getDecl();
2197  }
2198 
2199  if (D->getDescribedTemplate()) {
2200  if (auto *Template = dyn_cast<ClassTemplateDecl>(Found))
2201  Found = Template->getTemplatedDecl();
2202  else
2203  continue;
2204  }
2205 
2206  if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2207  if (!SearchName) {
2208  if (!IsStructuralMatch(D, FoundRecord, false))
2209  continue;
2210  }
2211 
2212  PrevDecl = FoundRecord;
2213 
2214  if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
2215  if ((SearchName && !D->isCompleteDefinition())
2216  || (D->isCompleteDefinition() &&
2218  == FoundDef->isAnonymousStructOrUnion() &&
2219  IsStructuralMatch(D, FoundDef))) {
2220  // The record types structurally match, or the "from" translation
2221  // unit only had a forward declaration anyway; call it the same
2222  // function.
2223  // FIXME: Structural equivalence check should check for same
2224  // user-defined methods.
2225  Importer.MapImported(D, FoundDef);
2226  if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2227  auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
2228  assert(FoundCXX && "Record type mismatch");
2229 
2230  if (D->isCompleteDefinition() && !Importer.isMinimalImport())
2231  // FoundDef may not have every implicit method that D has
2232  // because implicit methods are created only if they are used.
2233  ImportImplicitMethods(DCXX, FoundCXX);
2234  }
2235  return FoundDef;
2236  }
2237  } else if (!D->isCompleteDefinition()) {
2238  // We have a forward declaration of this type, so adopt that forward
2239  // declaration rather than building a new one.
2240 
2241  // If one or both can be completed from external storage then try one
2242  // last time to complete and compare them before doing this.
2243 
2244  if (FoundRecord->hasExternalLexicalStorage() &&
2245  !FoundRecord->isCompleteDefinition())
2246  FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
2247  if (D->hasExternalLexicalStorage())
2249 
2250  if (FoundRecord->isCompleteDefinition() &&
2251  D->isCompleteDefinition() &&
2252  !IsStructuralMatch(D, FoundRecord))
2253  continue;
2254 
2255  AdoptDecl = FoundRecord;
2256  continue;
2257  } else if (!SearchName) {
2258  continue;
2259  }
2260  }
2261 
2262  ConflictingDecls.push_back(FoundDecl);
2263  }
2264 
2265  if (!ConflictingDecls.empty() && SearchName) {
2266  Name = Importer.HandleNameConflict(Name, DC, IDNS,
2267  ConflictingDecls.data(),
2268  ConflictingDecls.size());
2269  }
2270  }
2271 
2272  // Create the record declaration.
2273  RecordDecl *D2 = AdoptDecl;
2274  SourceLocation StartLoc = Importer.Import(D->getLocStart());
2275  if (!D2) {
2276  CXXRecordDecl *D2CXX = nullptr;
2277  if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2278  if (DCXX->isLambda()) {
2279  TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
2280  if (GetImportedOrCreateSpecialDecl(
2281  D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
2282  DC, TInfo, Loc, DCXX->isDependentLambda(),
2283  DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
2284  return D2CXX;
2285  Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
2286  if (DCXX->getLambdaContextDecl() && !CDecl)
2287  return nullptr;
2288  D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
2289  } else if (DCXX->isInjectedClassName()) {
2290  // We have to be careful to do a similar dance to the one in
2291  // Sema::ActOnStartCXXMemberDeclarations
2292  CXXRecordDecl *const PrevDecl = nullptr;
2293  const bool DelayTypeCreation = true;
2294  if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2295  D->getTagKind(), DC, StartLoc, Loc,
2296  Name.getAsIdentifierInfo(), PrevDecl,
2297  DelayTypeCreation))
2298  return D2CXX;
2299  Importer.getToContext().getTypeDeclType(
2300  D2CXX, dyn_cast<CXXRecordDecl>(DC));
2301  } else {
2302  if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2303  D->getTagKind(), DC, StartLoc, Loc,
2304  Name.getAsIdentifierInfo(),
2305  cast_or_null<CXXRecordDecl>(PrevDecl)))
2306  return D2CXX;
2307  }
2308 
2309  D2 = D2CXX;
2310  D2->setAccess(D->getAccess());
2311  D2->setLexicalDeclContext(LexicalDC);
2312  if (!DCXX->getDescribedClassTemplate() || DCXX->isImplicit())
2313  LexicalDC->addDeclInternal(D2);
2314 
2315  if (ClassTemplateDecl *FromDescribed =
2316  DCXX->getDescribedClassTemplate()) {
2317  auto *ToDescribed = cast_or_null<ClassTemplateDecl>(
2318  Importer.Import(FromDescribed));
2319  if (!ToDescribed)
2320  return nullptr;
2321  D2CXX->setDescribedClassTemplate(ToDescribed);
2322  if (!DCXX->isInjectedClassName()) {
2323  // In a record describing a template the type should be an
2324  // InjectedClassNameType (see Sema::CheckClassTemplate). Update the
2325  // previously set type to the correct value here (ToDescribed is not
2326  // available at record create).
2327  // FIXME: The previous type is cleared but not removed from
2328  // ASTContext's internal storage.
2329  CXXRecordDecl *Injected = nullptr;
2330  for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
2331  auto *Record = dyn_cast<CXXRecordDecl>(Found);
2332  if (Record && Record->isInjectedClassName()) {
2333  Injected = Record;
2334  break;
2335  }
2336  }
2337  D2CXX->setTypeForDecl(nullptr);
2338  Importer.getToContext().getInjectedClassNameType(D2CXX,
2339  ToDescribed->getInjectedClassNameSpecialization());
2340  if (Injected) {
2341  Injected->setTypeForDecl(nullptr);
2342  Importer.getToContext().getTypeDeclType(Injected, D2CXX);
2343  }
2344  }
2345  } else if (MemberSpecializationInfo *MemberInfo =
2346  DCXX->getMemberSpecializationInfo()) {
2348  MemberInfo->getTemplateSpecializationKind();
2349  CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
2350  auto *ToInst =
2351  cast_or_null<CXXRecordDecl>(Importer.Import(FromInst));
2352  if (FromInst && !ToInst)
2353  return nullptr;
2354  D2CXX->setInstantiationOfMemberClass(ToInst, SK);
2356  Importer.Import(MemberInfo->getPointOfInstantiation()));
2357  }
2358  } else {
2359  if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
2360  D->getTagKind(), DC, StartLoc, Loc,
2361  Name.getAsIdentifierInfo(), PrevDecl))
2362  return D2;
2363  D2->setLexicalDeclContext(LexicalDC);
2364  LexicalDC->addDeclInternal(D2);
2365  }
2366 
2367  D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2368  if (D->isAnonymousStructOrUnion())
2369  D2->setAnonymousStructOrUnion(true);
2370  }
2371 
2372  Importer.MapImported(D, D2);
2373 
2375  return nullptr;
2376 
2377  return D2;
2378 }
2379 
2381  // Import the major distinguishing characteristics of this enumerator.
2382  DeclContext *DC, *LexicalDC;
2383  DeclarationName Name;
2384  SourceLocation Loc;
2385  NamedDecl *ToD;
2386  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2387  return nullptr;
2388  if (ToD)
2389  return ToD;
2390 
2391  QualType T = Importer.Import(D->getType());
2392  if (T.isNull())
2393  return nullptr;
2394 
2395  // Determine whether there are any other declarations with the same name and
2396  // in the same context.
2397  if (!LexicalDC->isFunctionOrMethod()) {
2398  SmallVector<NamedDecl *, 4> ConflictingDecls;
2399  unsigned IDNS = Decl::IDNS_Ordinary;
2400  SmallVector<NamedDecl *, 2> FoundDecls;
2401  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2402  for (auto *FoundDecl : FoundDecls) {
2403  if (!FoundDecl->isInIdentifierNamespace(IDNS))
2404  continue;
2405 
2406  if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
2407  if (IsStructuralMatch(D, FoundEnumConstant))
2408  return Importer.MapImported(D, FoundEnumConstant);
2409  }
2410 
2411  ConflictingDecls.push_back(FoundDecl);
2412  }
2413 
2414  if (!ConflictingDecls.empty()) {
2415  Name = Importer.HandleNameConflict(Name, DC, IDNS,
2416  ConflictingDecls.data(),
2417  ConflictingDecls.size());
2418  if (!Name)
2419  return nullptr;
2420  }
2421  }
2422 
2423  Expr *Init = Importer.Import(D->getInitExpr());
2424  if (D->getInitExpr() && !Init)
2425  return nullptr;
2426 
2427  EnumConstantDecl *ToEnumerator;
2428  if (GetImportedOrCreateDecl(
2429  ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2430  Name.getAsIdentifierInfo(), T, Init, D->getInitVal()))
2431  return ToEnumerator;
2432 
2433  ToEnumerator->setAccess(D->getAccess());
2434  ToEnumerator->setLexicalDeclContext(LexicalDC);
2435  LexicalDC->addDeclInternal(ToEnumerator);
2436  return ToEnumerator;
2437 }
2438 
2440  FunctionDecl *ToFD) {
2441  switch (FromFD->getTemplatedKind()) {
2444  return false;
2445 
2447  auto *InstFD = cast_or_null<FunctionDecl>(
2448  Importer.Import(FromFD->getInstantiatedFromMemberFunction()));
2449  if (!InstFD)
2450  return true;
2451 
2453  SourceLocation POI = Importer.Import(
2455  ToFD->setInstantiationOfMemberFunction(InstFD, TSK);
2457  return false;
2458  }
2459 
2461  FunctionTemplateDecl* Template;
2462  OptionalTemplateArgsTy ToTemplArgs;
2463  std::tie(Template, ToTemplArgs) =
2465  if (!Template || !ToTemplArgs)
2466  return true;
2467 
2469  Importer.getToContext(), *ToTemplArgs);
2470 
2471  auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
2472  TemplateArgumentListInfo ToTAInfo;
2473  const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
2474  if (FromTAArgsAsWritten)
2475  if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ToTAInfo))
2476  return true;
2477 
2478  SourceLocation POI = Importer.Import(FTSInfo->getPointOfInstantiation());
2479 
2480  TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
2481  ToFD->setFunctionTemplateSpecialization(
2482  Template, ToTAList, /* InsertPos= */ nullptr,
2483  TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, POI);
2484  return false;
2485  }
2486 
2488  auto *FromInfo = FromFD->getDependentSpecializationInfo();
2489  UnresolvedSet<8> TemplDecls;
2490  unsigned NumTemplates = FromInfo->getNumTemplates();
2491  for (unsigned I = 0; I < NumTemplates; I++) {
2492  if (auto *ToFTD = cast_or_null<FunctionTemplateDecl>(
2493  Importer.Import(FromInfo->getTemplate(I))))
2494  TemplDecls.addDecl(ToFTD);
2495  else
2496  return true;
2497  }
2498 
2499  // Import TemplateArgumentListInfo.
2500  TemplateArgumentListInfo ToTAInfo;
2502  FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
2503  llvm::makeArrayRef(FromInfo->getTemplateArgs(),
2504  FromInfo->getNumTemplateArgs()),
2505  ToTAInfo))
2506  return true;
2507 
2508  ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
2509  TemplDecls, ToTAInfo);
2510  return false;
2511  }
2512  }
2513  llvm_unreachable("All cases should be covered!");
2514 }
2515 
2516 FunctionDecl *
2518  FunctionTemplateDecl* Template;
2519  OptionalTemplateArgsTy ToTemplArgs;
2520  std::tie(Template, ToTemplArgs) =
2522  if (!Template || !ToTemplArgs)
2523  return nullptr;
2524 
2525  void *InsertPos = nullptr;
2526  auto *FoundSpec = Template->findSpecialization(*ToTemplArgs, InsertPos);
2527  return FoundSpec;
2528 }
2529 
2531 
2533  auto RedeclIt = Redecls.begin();
2534  // Import the first part of the decl chain. I.e. import all previous
2535  // declarations starting from the canonical decl.
2536  for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt)
2537  if (!Importer.Import(*RedeclIt))
2538  return nullptr;
2539  assert(*RedeclIt == D);
2540 
2541  // Import the major distinguishing characteristics of this function.
2542  DeclContext *DC, *LexicalDC;
2543  DeclarationName Name;
2544  SourceLocation Loc;
2545  NamedDecl *ToD;
2546  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2547  return nullptr;
2548  if (ToD)
2549  return ToD;
2550 
2551  const FunctionDecl *FoundByLookup = nullptr;
2553 
2554  // If this is a function template specialization, then try to find the same
2555  // existing specialization in the "to" context. The localUncachedLookup
2556  // below will not find any specialization, but would find the primary
2557  // template; thus, we have to skip normal lookup in case of specializations.
2558  // FIXME handle member function templates (TK_MemberSpecialization) similarly?
2559  if (D->getTemplatedKind() ==
2561  if (FunctionDecl *FoundFunction = FindFunctionTemplateSpecialization(D)) {
2562  if (D->doesThisDeclarationHaveABody() &&
2563  FoundFunction->hasBody())
2564  return Importer.Imported(D, FoundFunction);
2565  FoundByLookup = FoundFunction;
2566  }
2567  }
2568  // Try to find a function in our own ("to") context with the same name, same
2569  // type, and in the same context as the function we're importing.
2570  else if (!LexicalDC->isFunctionOrMethod()) {
2571  SmallVector<NamedDecl *, 4> ConflictingDecls;
2573  SmallVector<NamedDecl *, 2> FoundDecls;
2574  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2575  for (auto *FoundDecl : FoundDecls) {
2576  if (!FoundDecl->isInIdentifierNamespace(IDNS))
2577  continue;
2578 
2579  // If template was found, look at the templated function.
2580  if (FromFT) {
2581  if (auto *Template = dyn_cast<FunctionTemplateDecl>(FoundDecl))
2582  FoundDecl = Template->getTemplatedDecl();
2583  else
2584  continue;
2585  }
2586 
2587  if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
2588  if (FoundFunction->hasExternalFormalLinkage() &&
2589  D->hasExternalFormalLinkage()) {
2590  if (IsStructuralMatch(D, FoundFunction)) {
2591  const FunctionDecl *Definition = nullptr;
2592  if (D->doesThisDeclarationHaveABody() &&
2593  FoundFunction->hasBody(Definition)) {
2594  return Importer.MapImported(
2595  D, const_cast<FunctionDecl *>(Definition));
2596  }
2597  FoundByLookup = FoundFunction;
2598  break;
2599  }
2600 
2601  // FIXME: Check for overloading more carefully, e.g., by boosting
2602  // Sema::IsOverload out to the AST library.
2603 
2604  // Function overloading is okay in C++.
2605  if (Importer.getToContext().getLangOpts().CPlusPlus)
2606  continue;
2607 
2608  // Complain about inconsistent function types.
2609  Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2610  << Name << D->getType() << FoundFunction->getType();
2611  Importer.ToDiag(FoundFunction->getLocation(),
2612  diag::note_odr_value_here)
2613  << FoundFunction->getType();
2614  }
2615  }
2616 
2617  ConflictingDecls.push_back(FoundDecl);
2618  }
2619 
2620  if (!ConflictingDecls.empty()) {
2621  Name = Importer.HandleNameConflict(Name, DC, IDNS,
2622  ConflictingDecls.data(),
2623  ConflictingDecls.size());
2624  if (!Name)
2625  return nullptr;
2626  }
2627  }
2628 
2629  DeclarationNameInfo NameInfo(Name, Loc);
2630  // Import additional name location/type info.
2631  ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2632 
2633  QualType FromTy = D->getType();
2634  bool usedDifferentExceptionSpec = false;
2635 
2636  if (const auto *FromFPT = D->getType()->getAs<FunctionProtoType>()) {
2637  FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2638  // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2639  // FunctionDecl that we are importing the FunctionProtoType for.
2640  // To avoid an infinite recursion when importing, create the FunctionDecl
2641  // with a simplified function type and update it afterwards.
2642  if (FromEPI.ExceptionSpec.SourceDecl ||
2643  FromEPI.ExceptionSpec.SourceTemplate ||
2644  FromEPI.ExceptionSpec.NoexceptExpr) {
2646  FromTy = Importer.getFromContext().getFunctionType(
2647  FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
2648  usedDifferentExceptionSpec = true;
2649  }
2650  }
2651 
2652  // Import the type.
2653  QualType T = Importer.Import(FromTy);
2654  if (T.isNull())
2655  return nullptr;
2656 
2657  // Import the function parameters.
2658  SmallVector<ParmVarDecl *, 8> Parameters;
2659  for (auto P : D->parameters()) {
2660  auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2661  if (!ToP)
2662  return nullptr;
2663 
2664  Parameters.push_back(ToP);
2665  }
2666 
2667  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2668  if (D->getTypeSourceInfo() && !TInfo)
2669  return nullptr;
2670 
2671  // Create the imported function.
2672  FunctionDecl *ToFunction = nullptr;
2673  SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
2674  if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
2675  if (GetImportedOrCreateDecl<CXXConstructorDecl>(
2676  ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2677  InnerLocStart, NameInfo, T, TInfo, FromConstructor->isExplicit(),
2678  D->isInlineSpecified(), D->isImplicit(), D->isConstexpr()))
2679  return ToFunction;
2680  if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
2681  SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
2682  for (auto *I : FromConstructor->inits()) {
2683  auto *ToI = cast_or_null<CXXCtorInitializer>(Importer.Import(I));
2684  if (!ToI && I)
2685  return nullptr;
2686  CtorInitializers.push_back(ToI);
2687  }
2688  auto **Memory =
2689  new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
2690  std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
2691  auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
2692  ToCtor->setCtorInitializers(Memory);
2693  ToCtor->setNumCtorInitializers(NumInitializers);
2694  }
2695  } else if (isa<CXXDestructorDecl>(D)) {
2696  if (GetImportedOrCreateDecl<CXXDestructorDecl>(
2697  ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2698  InnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
2699  D->isImplicit()))
2700  return ToFunction;
2701  } else if (CXXConversionDecl *FromConversion =
2702  dyn_cast<CXXConversionDecl>(D)) {
2703  if (GetImportedOrCreateDecl<CXXConversionDecl>(
2704  ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2705  InnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
2706  FromConversion->isExplicit(), D->isConstexpr(), SourceLocation()))
2707  return ToFunction;
2708  } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
2709  if (GetImportedOrCreateDecl<CXXMethodDecl>(
2710  ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2711  InnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
2712  Method->isInlineSpecified(), D->isConstexpr(), SourceLocation()))
2713  return ToFunction;
2714  } else {
2715  if (GetImportedOrCreateDecl(ToFunction, D, Importer.getToContext(), DC,
2716  InnerLocStart, NameInfo, T, TInfo,
2718  D->hasWrittenPrototype(), D->isConstexpr()))
2719  return ToFunction;
2720  }
2721 
2722  // Import the qualifier, if any.
2723  ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2724  ToFunction->setAccess(D->getAccess());
2725  ToFunction->setLexicalDeclContext(LexicalDC);
2726  ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
2727  ToFunction->setTrivial(D->isTrivial());
2728  ToFunction->setPure(D->isPure());
2729  ToFunction->setRangeEnd(Importer.Import(D->getLocEnd()));
2730 
2731  // Set the parameters.
2732  for (auto *Param : Parameters) {
2733  Param->setOwningFunction(ToFunction);
2734  ToFunction->addDeclInternal(Param);
2735  }
2736  ToFunction->setParams(Parameters);
2737 
2738  if (FoundByLookup) {
2739  auto *Recent = const_cast<FunctionDecl *>(
2740  FoundByLookup->getMostRecentDecl());
2741  ToFunction->setPreviousDecl(Recent);
2742  }
2743 
2744  // We need to complete creation of FunctionProtoTypeLoc manually with setting
2745  // params it refers to.
2746  if (TInfo) {
2747  if (auto ProtoLoc =
2749  for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
2750  ProtoLoc.setParam(I, Parameters[I]);
2751  }
2752  }
2753 
2754  if (usedDifferentExceptionSpec) {
2755  // Update FunctionProtoType::ExtProtoInfo.
2756  QualType T = Importer.Import(D->getType());
2757  if (T.isNull())
2758  return nullptr;
2759  ToFunction->setType(T);
2760  }
2761 
2762  // Import the describing template function, if any.
2763  if (FromFT)
2764  if (!Importer.Import(FromFT))
2765  return nullptr;
2766 
2767  if (D->doesThisDeclarationHaveABody()) {
2768  if (Stmt *FromBody = D->getBody()) {
2769  if (Stmt *ToBody = Importer.Import(FromBody)) {
2770  ToFunction->setBody(ToBody);
2771  }
2772  }
2773  }
2774 
2775  // FIXME: Other bits to merge?
2776 
2777  // If it is a template, import all related things.
2778  if (ImportTemplateInformation(D, ToFunction))
2779  return nullptr;
2780 
2782 
2783  // TODO Can we generalize this approach to other AST nodes as well?
2784  if (D->getDeclContext()->containsDeclAndLoad(D))
2785  DC->addDeclInternal(ToFunction);
2786  if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D))
2787  LexicalDC->addDeclInternal(ToFunction);
2788 
2789  // Friend declaration's lexical context is the befriending class, but the
2790  // semantic context is the enclosing scope of the befriending class.
2791  // We want the friend functions to be found in the semantic context by lookup.
2792  // FIXME should we handle this generically in VisitFriendDecl?
2793  // In Other cases when LexicalDC != DC we don't want it to be added,
2794  // e.g out-of-class definitions like void B::f() {} .
2795  if (LexicalDC != DC && IsFriend) {
2796  DC->makeDeclVisibleInContext(ToFunction);
2797  }
2798 
2799  // Import the rest of the chain. I.e. import all subsequent declarations.
2800  for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt)
2801  if (!Importer.Import(*RedeclIt))
2802  return nullptr;
2803 
2804  if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
2805  ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod);
2806 
2807  return ToFunction;
2808 }
2809 
2811  return VisitFunctionDecl(D);
2812 }
2813 
2815  return VisitCXXMethodDecl(D);
2816 }
2817 
2819  return VisitCXXMethodDecl(D);
2820 }
2821 
2823  return VisitCXXMethodDecl(D);
2824 }
2825 
2826 static unsigned getFieldIndex(Decl *F) {
2827  auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
2828  if (!Owner)
2829  return 0;
2830 
2831  unsigned Index = 1;
2832  for (const auto *D : Owner->noload_decls()) {
2833  if (D == F)
2834  return Index;
2835 
2836  if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
2837  ++Index;
2838  }
2839 
2840  return Index;
2841 }
2842 
2844  // Import the major distinguishing characteristics of a variable.
2845  DeclContext *DC, *LexicalDC;
2846  DeclarationName Name;
2847  SourceLocation Loc;
2848  NamedDecl *ToD;
2849  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2850  return nullptr;
2851  if (ToD)
2852  return ToD;
2853 
2854  // Determine whether we've already imported this field.
2855  SmallVector<NamedDecl *, 2> FoundDecls;
2856  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2857  for (auto *FoundDecl : FoundDecls) {
2858  if (auto *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
2859  // For anonymous fields, match up by index.
2860  if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2861  continue;
2862 
2863  if (Importer.IsStructurallyEquivalent(D->getType(),
2864  FoundField->getType())) {
2865  Importer.MapImported(D, FoundField);
2866  return FoundField;
2867  }
2868 
2869  Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2870  << Name << D->getType() << FoundField->getType();
2871  Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2872  << FoundField->getType();
2873  return nullptr;
2874  }
2875  }
2876 
2877  // Import the type.
2878  QualType T = Importer.Import(D->getType());
2879  if (T.isNull())
2880  return nullptr;
2881 
2882  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2883  Expr *BitWidth = Importer.Import(D->getBitWidth());
2884  if (!BitWidth && D->getBitWidth())
2885  return nullptr;
2886 
2887  FieldDecl *ToField;
2888  if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
2889  Importer.Import(D->getInnerLocStart()), Loc,
2890  Name.getAsIdentifierInfo(), T, TInfo, BitWidth,
2891  D->isMutable(), D->getInClassInitStyle()))
2892  return ToField;
2893 
2894  ToField->setAccess(D->getAccess());
2895  ToField->setLexicalDeclContext(LexicalDC);
2896  if (Expr *FromInitializer = D->getInClassInitializer()) {
2897  Expr *ToInitializer = Importer.Import(FromInitializer);
2898  if (ToInitializer)
2899  ToField->setInClassInitializer(ToInitializer);
2900  else
2901  return nullptr;
2902  }
2903  ToField->setImplicit(D->isImplicit());
2904  LexicalDC->addDeclInternal(ToField);
2905  return ToField;
2906 }
2907 
2909  // Import the major distinguishing characteristics of a variable.
2910  DeclContext *DC, *LexicalDC;
2911  DeclarationName Name;
2912  SourceLocation Loc;
2913  NamedDecl *ToD;
2914  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2915  return nullptr;
2916  if (ToD)
2917  return ToD;
2918 
2919  // Determine whether we've already imported this field.
2920  SmallVector<NamedDecl *, 2> FoundDecls;
2921  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2922  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2923  if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
2924  // For anonymous indirect fields, match up by index.
2925  if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2926  continue;
2927 
2928  if (Importer.IsStructurallyEquivalent(D->getType(),
2929  FoundField->getType(),
2930  !Name.isEmpty())) {
2931  Importer.MapImported(D, FoundField);
2932  return FoundField;
2933  }
2934 
2935  // If there are more anonymous fields to check, continue.
2936  if (!Name && I < N-1)
2937  continue;
2938 
2939  Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2940  << Name << D->getType() << FoundField->getType();
2941  Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2942  << FoundField->getType();
2943  return nullptr;
2944  }
2945  }
2946 
2947  // Import the type.
2948  QualType T = Importer.Import(D->getType());
2949  if (T.isNull())
2950  return nullptr;
2951 
2952  auto **NamedChain =
2953  new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
2954 
2955  unsigned i = 0;
2956  for (auto *PI : D->chain()) {
2957  Decl *D = Importer.Import(PI);
2958  if (!D)
2959  return nullptr;
2960  NamedChain[i++] = cast<NamedDecl>(D);
2961  }
2962 
2963  llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
2964  IndirectFieldDecl *ToIndirectField;
2965  if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC,
2966  Loc, Name.getAsIdentifierInfo(), T, CH))
2967  // FIXME here we leak `NamedChain` which is allocated before
2968  return ToIndirectField;
2969 
2970  for (const auto *A : D->attrs())
2971  ToIndirectField->addAttr(Importer.Import(A));
2972 
2973  ToIndirectField->setAccess(D->getAccess());
2974  ToIndirectField->setLexicalDeclContext(LexicalDC);
2975  LexicalDC->addDeclInternal(ToIndirectField);
2976  return ToIndirectField;
2977 }
2978 
2980  // Import the major distinguishing characteristics of a declaration.
2981  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2982  DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
2983  ? DC : Importer.ImportContext(D->getLexicalDeclContext());
2984  if (!DC || !LexicalDC)
2985  return nullptr;
2986 
2987  // Determine whether we've already imported this decl.
2988  // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
2989  auto *RD = cast<CXXRecordDecl>(DC);
2990  FriendDecl *ImportedFriend = RD->getFirstFriend();
2991 
2992  while (ImportedFriend) {
2993  if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
2994  if (IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(),
2995  /*Complain=*/false))
2996  return Importer.MapImported(D, ImportedFriend);
2997 
2998  } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
2999  if (Importer.IsStructurallyEquivalent(
3000  D->getFriendType()->getType(),
3001  ImportedFriend->getFriendType()->getType(), true))
3002  return Importer.MapImported(D, ImportedFriend);
3003  }
3004  ImportedFriend = ImportedFriend->getNextFriend();
3005  }
3006 
3007  // Not found. Create it.
3009  if (NamedDecl *FriendD = D->getFriendDecl()) {
3010  auto *ToFriendD = cast_or_null<NamedDecl>(Importer.Import(FriendD));
3011  if (ToFriendD && FriendD->getFriendObjectKind() != Decl::FOK_None &&
3012  !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
3013  ToFriendD->setObjectOfFriendDecl(false);
3014 
3015  ToFU = ToFriendD;
3016  } else // The friend is a type, not a decl.
3017  ToFU = Importer.Import(D->getFriendType());
3018  if (!ToFU)
3019  return nullptr;
3020 
3021  SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
3022  auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
3023  for (unsigned I = 0; I < D->NumTPLists; I++) {
3024  TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
3025  if (!List)
3026  return nullptr;
3027  ToTPLists[I] = List;
3028  }
3029 
3030  FriendDecl *FrD;
3031  if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
3032  Importer.Import(D->getLocation()), ToFU,
3033  Importer.Import(D->getFriendLoc()), ToTPLists))
3034  return FrD;
3035 
3036  FrD->setAccess(D->getAccess());
3037  FrD->setLexicalDeclContext(LexicalDC);
3038  LexicalDC->addDeclInternal(FrD);
3039  return FrD;
3040 }
3041 
3043  // Import the major distinguishing characteristics of an ivar.
3044  DeclContext *DC, *LexicalDC;
3045  DeclarationName Name;
3046  SourceLocation Loc;
3047  NamedDecl *ToD;
3048  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3049  return nullptr;
3050  if (ToD)
3051  return ToD;
3052 
3053  // Determine whether we've already imported this ivar
3054  SmallVector<NamedDecl *, 2> FoundDecls;
3055  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3056  for (auto *FoundDecl : FoundDecls) {
3057  if (auto *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
3058  if (Importer.IsStructurallyEquivalent(D->getType(),
3059  FoundIvar->getType())) {
3060  Importer.MapImported(D, FoundIvar);
3061  return FoundIvar;
3062  }
3063 
3064  Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3065  << Name << D->getType() << FoundIvar->getType();
3066  Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3067  << FoundIvar->getType();
3068  return nullptr;
3069  }
3070  }
3071 
3072  // Import the type.
3073  QualType T = Importer.Import(D->getType());
3074  if (T.isNull())
3075  return nullptr;
3076 
3077  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3078  Expr *BitWidth = Importer.Import(D->getBitWidth());
3079  if (!BitWidth && D->getBitWidth())
3080  return nullptr;
3081 
3082  ObjCIvarDecl *ToIvar;
3083  if (GetImportedOrCreateDecl(
3084  ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
3085  Importer.Import(D->getInnerLocStart()), Loc,
3086  Name.getAsIdentifierInfo(), T, TInfo, D->getAccessControl(), BitWidth,
3087  D->getSynthesize()))
3088  return ToIvar;
3089 
3090  ToIvar->setLexicalDeclContext(LexicalDC);
3091  LexicalDC->addDeclInternal(ToIvar);
3092  return ToIvar;
3093 }
3094 
3096  // Import the major distinguishing characteristics of a variable.
3097  DeclContext *DC, *LexicalDC;
3098  DeclarationName Name;
3099  SourceLocation Loc;
3100  NamedDecl *ToD;
3101  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3102  return nullptr;
3103  if (ToD)
3104  return ToD;
3105 
3106  // Try to find a variable in our own ("to") context with the same name and
3107  // in the same context as the variable we're importing.
3108  if (D->isFileVarDecl()) {
3109  VarDecl *MergeWithVar = nullptr;
3110  SmallVector<NamedDecl *, 4> ConflictingDecls;
3111  unsigned IDNS = Decl::IDNS_Ordinary;
3112  SmallVector<NamedDecl *, 2> FoundDecls;
3113  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3114  for (auto *FoundDecl : FoundDecls) {
3115  if (!FoundDecl->isInIdentifierNamespace(IDNS))
3116  continue;
3117 
3118  if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
3119  // We have found a variable that we may need to merge with. Check it.
3120  if (FoundVar->hasExternalFormalLinkage() &&
3121  D->hasExternalFormalLinkage()) {
3122  if (Importer.IsStructurallyEquivalent(D->getType(),
3123  FoundVar->getType())) {
3124  MergeWithVar = FoundVar;
3125  break;
3126  }
3127 
3128  const ArrayType *FoundArray
3129  = Importer.getToContext().getAsArrayType(FoundVar->getType());
3130  const ArrayType *TArray
3131  = Importer.getToContext().getAsArrayType(D->getType());
3132  if (FoundArray && TArray) {
3133  if (isa<IncompleteArrayType>(FoundArray) &&
3134  isa<ConstantArrayType>(TArray)) {
3135  // Import the type.
3136  QualType T = Importer.Import(D->getType());
3137  if (T.isNull())
3138  return nullptr;
3139 
3140  FoundVar->setType(T);
3141  MergeWithVar = FoundVar;
3142  break;
3143  } else if (isa<IncompleteArrayType>(TArray) &&
3144  isa<ConstantArrayType>(FoundArray)) {
3145  MergeWithVar = FoundVar;
3146  break;
3147  }
3148  }
3149 
3150  Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3151  << Name << D->getType() << FoundVar->getType();
3152  Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3153  << FoundVar->getType();
3154  }
3155  }
3156 
3157  ConflictingDecls.push_back(FoundDecl);
3158  }
3159 
3160  if (MergeWithVar) {
3161  // An equivalent variable with external linkage has been found. Link
3162  // the two declarations, then merge them.
3163  Importer.MapImported(D, MergeWithVar);
3164  updateFlags(D, MergeWithVar);
3165 
3166  if (VarDecl *DDef = D->getDefinition()) {
3167  if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3168  Importer.ToDiag(ExistingDef->getLocation(),
3169  diag::err_odr_variable_multiple_def)
3170  << Name;
3171  Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3172  } else {
3173  Expr *Init = Importer.Import(DDef->getInit());
3174  MergeWithVar->setInit(Init);
3175  if (DDef->isInitKnownICE()) {
3176  EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3177  Eval->CheckedICE = true;
3178  Eval->IsICE = DDef->isInitICE();
3179  }
3180  }
3181  }
3182 
3183  return MergeWithVar;
3184  }
3185 
3186  if (!ConflictingDecls.empty()) {
3187  Name = Importer.HandleNameConflict(Name, DC, IDNS,
3188  ConflictingDecls.data(),
3189  ConflictingDecls.size());
3190  if (!Name)
3191  return nullptr;
3192  }
3193  }
3194 
3195  // Import the type.
3196  QualType T = Importer.Import(D->getType());
3197  if (T.isNull())
3198  return nullptr;
3199 
3200  // Create the imported variable.
3201  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3202  VarDecl *ToVar;
3203  if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC,
3204  Importer.Import(D->getInnerLocStart()), Loc,
3205  Name.getAsIdentifierInfo(), T, TInfo,
3206  D->getStorageClass()))
3207  return ToVar;
3208 
3209  ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3210  ToVar->setAccess(D->getAccess());
3211  ToVar->setLexicalDeclContext(LexicalDC);
3212 
3213  // Templated declarations should never appear in the enclosing DeclContext.
3214  if (!D->getDescribedVarTemplate())
3215  LexicalDC->addDeclInternal(ToVar);
3216 
3217  // Merge the initializer.
3218  if (ImportDefinition(D, ToVar))
3219  return nullptr;
3220 
3221  if (D->isConstexpr())
3222  ToVar->setConstexpr(true);
3223 
3224  return ToVar;
3225 }
3226 
3228  // Parameters are created in the translation unit's context, then moved
3229  // into the function declaration's context afterward.
3230  DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3231 
3232  // Import the name of this declaration.
3233  DeclarationName Name = Importer.Import(D->getDeclName());
3234  if (D->getDeclName() && !Name)
3235  return nullptr;
3236 
3237  // Import the location of this declaration.
3238  SourceLocation Loc = Importer.Import(D->getLocation());
3239 
3240  // Import the parameter's type.
3241  QualType T = Importer.Import(D->getType());
3242  if (T.isNull())
3243  return nullptr;
3244 
3245  // Create the imported parameter.
3246  ImplicitParamDecl *ToParm = nullptr;
3247  if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC, Loc,
3248  Name.getAsIdentifierInfo(), T,
3249  D->getParameterKind()))
3250  return ToParm;
3251  return ToParm;
3252 }
3253 
3255  // Parameters are created in the translation unit's context, then moved
3256  // into the function declaration's context afterward.
3257  DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3258 
3259  // Import the name of this declaration.
3260  DeclarationName Name = Importer.Import(D->getDeclName());
3261  if (D->getDeclName() && !Name)
3262  return nullptr;
3263 
3264  // Import the location of this declaration.
3265  SourceLocation Loc = Importer.Import(D->getLocation());
3266 
3267  // Import the parameter's type.
3268  QualType T = Importer.Import(D->getType());
3269  if (T.isNull())
3270  return nullptr;
3271 
3272  // Create the imported parameter.
3273  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3274  ParmVarDecl *ToParm;
3275  if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
3276  Importer.Import(D->getInnerLocStart()), Loc,
3277  Name.getAsIdentifierInfo(), T, TInfo,
3278  D->getStorageClass(),
3279  /*DefaultArg*/ nullptr))
3280  return ToParm;
3281 
3282  // Set the default argument.
3284  ToParm->setKNRPromoted(D->isKNRPromoted());
3285 
3286  Expr *ToDefArg = nullptr;
3287  Expr *FromDefArg = nullptr;
3288  if (D->hasUninstantiatedDefaultArg()) {
3289  FromDefArg = D->getUninstantiatedDefaultArg();
3290  ToDefArg = Importer.Import(FromDefArg);
3291  ToParm->setUninstantiatedDefaultArg(ToDefArg);
3292  } else if (D->hasUnparsedDefaultArg()) {
3293  ToParm->setUnparsedDefaultArg();
3294  } else if (D->hasDefaultArg()) {
3295  FromDefArg = D->getDefaultArg();
3296  ToDefArg = Importer.Import(FromDefArg);
3297  ToParm->setDefaultArg(ToDefArg);
3298  }
3299  if (FromDefArg && !ToDefArg)
3300  return nullptr;
3301 
3302  if (D->isObjCMethodParameter()) {
3305  } else {
3306  ToParm->setScopeInfo(D->getFunctionScopeDepth(),
3307  D->getFunctionScopeIndex());
3308  }
3309 
3310  return ToParm;
3311 }
3312 
3314  // Import the major distinguishing characteristics of a method.
3315  DeclContext *DC, *LexicalDC;
3316  DeclarationName Name;
3317  SourceLocation Loc;
3318  NamedDecl *ToD;
3319  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3320  return nullptr;
3321  if (ToD)
3322  return ToD;
3323 
3324  SmallVector<NamedDecl *, 2> FoundDecls;
3325  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3326  for (auto *FoundDecl : FoundDecls) {
3327  if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
3328  if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3329  continue;
3330 
3331  // Check return types.
3332  if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3333  FoundMethod->getReturnType())) {
3334  Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3335  << D->isInstanceMethod() << Name << D->getReturnType()
3336  << FoundMethod->getReturnType();
3337  Importer.ToDiag(FoundMethod->getLocation(),
3338  diag::note_odr_objc_method_here)
3339  << D->isInstanceMethod() << Name;
3340  return nullptr;
3341  }
3342 
3343  // Check the number of parameters.
3344  if (D->param_size() != FoundMethod->param_size()) {
3345  Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3346  << D->isInstanceMethod() << Name
3347  << D->param_size() << FoundMethod->param_size();
3348  Importer.ToDiag(FoundMethod->getLocation(),
3349  diag::note_odr_objc_method_here)
3350  << D->isInstanceMethod() << Name;
3351  return nullptr;
3352  }
3353 
3354  // Check parameter types.
3356  PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3357  P != PEnd; ++P, ++FoundP) {
3358  if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3359  (*FoundP)->getType())) {
3360  Importer.FromDiag((*P)->getLocation(),
3361  diag::err_odr_objc_method_param_type_inconsistent)
3362  << D->isInstanceMethod() << Name
3363  << (*P)->getType() << (*FoundP)->getType();
3364  Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3365  << (*FoundP)->getType();
3366  return nullptr;
3367  }
3368  }
3369 
3370  // Check variadic/non-variadic.
3371  // Check the number of parameters.
3372  if (D->isVariadic() != FoundMethod->isVariadic()) {
3373  Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3374  << D->isInstanceMethod() << Name;
3375  Importer.ToDiag(FoundMethod->getLocation(),
3376  diag::note_odr_objc_method_here)
3377  << D->isInstanceMethod() << Name;
3378  return nullptr;
3379  }
3380 
3381  // FIXME: Any other bits we need to merge?
3382  return Importer.MapImported(D, FoundMethod);
3383  }
3384  }
3385 
3386  // Import the result type.
3387  QualType ResultTy = Importer.Import(D->getReturnType());
3388  if (ResultTy.isNull())
3389  return nullptr;
3390 
3391  TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3392 
3393  ObjCMethodDecl *ToMethod;
3394  if (GetImportedOrCreateDecl(
3395  ToMethod, D, Importer.getToContext(), Loc,
3396  Importer.Import(D->getLocEnd()), Name.getObjCSelector(), ResultTy,
3397  ReturnTInfo, DC, D->isInstanceMethod(), D->isVariadic(),
3398  D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3400  return ToMethod;
3401 
3402  // FIXME: When we decide to merge method definitions, we'll need to
3403  // deal with implicit parameters.
3404 
3405  // Import the parameters
3407  for (auto *FromP : D->parameters()) {
3408  auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3409  if (!ToP)
3410  return nullptr;
3411 
3412  ToParams.push_back(ToP);
3413  }
3414 
3415  // Set the parameters.
3416  for (auto *ToParam : ToParams) {
3417  ToParam->setOwningFunction(ToMethod);
3418  ToMethod->addDeclInternal(ToParam);
3419  }
3420 
3422  D->getSelectorLocs(SelLocs);
3423  for (auto &Loc : SelLocs)
3424  Loc = Importer.Import(Loc);
3425 
3426  ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3427 
3428  ToMethod->setLexicalDeclContext(LexicalDC);
3429  LexicalDC->addDeclInternal(ToMethod);
3430  return ToMethod;
3431 }
3432 
3434  // Import the major distinguishing characteristics of a category.
3435  DeclContext *DC, *LexicalDC;
3436  DeclarationName Name;
3437  SourceLocation Loc;
3438  NamedDecl *ToD;
3439  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3440  return nullptr;
3441  if (ToD)
3442  return ToD;
3443 
3444  TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
3445  if (!BoundInfo)
3446  return nullptr;
3447 
3449  if (GetImportedOrCreateDecl(
3450  Result, D, Importer.getToContext(), DC, D->getVariance(),
3451  Importer.Import(D->getVarianceLoc()), D->getIndex(),
3452  Importer.Import(D->getLocation()), Name.getAsIdentifierInfo(),
3453  Importer.Import(D->getColonLoc()), BoundInfo))
3454  return Result;
3455 
3456  Result->setLexicalDeclContext(LexicalDC);
3457  return Result;
3458 }
3459 
3461  // Import the major distinguishing characteristics of a category.
3462  DeclContext *DC, *LexicalDC;
3463  DeclarationName Name;
3464  SourceLocation Loc;
3465  NamedDecl *ToD;
3466  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3467  return nullptr;
3468  if (ToD)
3469  return ToD;
3470 
3471  auto *ToInterface =
3472  cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3473  if (!ToInterface)
3474  return nullptr;
3475 
3476  // Determine if we've already encountered this category.
3477  ObjCCategoryDecl *MergeWithCategory
3478  = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
3479  ObjCCategoryDecl *ToCategory = MergeWithCategory;
3480  if (!ToCategory) {
3481 
3482  if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
3483  Importer.Import(D->getAtStartLoc()), Loc,
3484  Importer.Import(D->getCategoryNameLoc()),
3485  Name.getAsIdentifierInfo(), ToInterface,
3486  /*TypeParamList=*/nullptr,
3487  Importer.Import(D->getIvarLBraceLoc()),
3488  Importer.Import(D->getIvarRBraceLoc())))
3489  return ToCategory;
3490 
3491  ToCategory->setLexicalDeclContext(LexicalDC);
3492  LexicalDC->addDeclInternal(ToCategory);
3493  // Import the type parameter list after calling Imported, to avoid
3494  // loops when bringing in their DeclContext.
3496  D->getTypeParamList()));
3497 
3498  // Import protocols
3500  SmallVector<SourceLocation, 4> ProtocolLocs;
3502  = D->protocol_loc_begin();
3504  FromProtoEnd = D->protocol_end();
3505  FromProto != FromProtoEnd;
3506  ++FromProto, ++FromProtoLoc) {
3507  auto *ToProto =
3508  cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3509  if (!ToProto)
3510  return nullptr;
3511  Protocols.push_back(ToProto);
3512  ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3513  }
3514 
3515  // FIXME: If we're merging, make sure that the protocol list is the same.
3516  ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
3517  ProtocolLocs.data(), Importer.getToContext());
3518  } else {
3519  Importer.MapImported(D, ToCategory);
3520  }
3521 
3522  // Import all of the members of this category.
3523  ImportDeclContext(D);
3524 
3525  // If we have an implementation, import it as well.
3526  if (D->getImplementation()) {
3527  auto *Impl =
3528  cast_or_null<ObjCCategoryImplDecl>(
3529  Importer.Import(D->getImplementation()));
3530  if (!Impl)
3531  return nullptr;
3532 
3533  ToCategory->setImplementation(Impl);
3534  }
3535 
3536  return ToCategory;
3537 }
3538 
3540  ObjCProtocolDecl *To,
3542  if (To->getDefinition()) {
3543  if (shouldForceImportDeclContext(Kind))
3544  ImportDeclContext(From);
3545  return false;
3546  }
3547 
3548  // Start the protocol definition
3549  To->startDefinition();
3550 
3551  // Import protocols
3553  SmallVector<SourceLocation, 4> ProtocolLocs;
3555  FromProtoLoc = From->protocol_loc_begin();
3556  for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
3557  FromProtoEnd = From->protocol_end();
3558  FromProto != FromProtoEnd;
3559  ++FromProto, ++FromProtoLoc) {
3560  auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3561  if (!ToProto)
3562  return true;
3563  Protocols.push_back(ToProto);
3564  ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3565  }
3566 
3567  // FIXME: If we're merging, make sure that the protocol list is the same.
3568  To->setProtocolList(Protocols.data(), Protocols.size(),
3569  ProtocolLocs.data(), Importer.getToContext());
3570 
3571  if (shouldForceImportDeclContext(Kind)) {
3572  // Import all of the members of this protocol.
3573  ImportDeclContext(From, /*ForceImport=*/true);
3574  }
3575  return false;
3576 }
3577 
3579  // If this protocol has a definition in the translation unit we're coming
3580  // from, but this particular declaration is not that definition, import the
3581  // definition and map to that.
3582  ObjCProtocolDecl *Definition = D->getDefinition();
3583  if (Definition && Definition != D) {
3584  Decl *ImportedDef = Importer.Import(Definition);
3585  if (!ImportedDef)
3586  return nullptr;
3587 
3588  return Importer.MapImported(D, ImportedDef);
3589  }
3590 
3591  // Import the major distinguishing characteristics of a protocol.
3592  DeclContext *DC, *LexicalDC;
3593  DeclarationName Name;
3594  SourceLocation Loc;
3595  NamedDecl *ToD;
3596  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3597  return nullptr;
3598  if (ToD)
3599  return ToD;
3600 
3601  ObjCProtocolDecl *MergeWithProtocol = nullptr;
3602  SmallVector<NamedDecl *, 2> FoundDecls;
3603  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3604  for (auto *FoundDecl : FoundDecls) {
3606  continue;
3607 
3608  if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
3609  break;
3610  }
3611 
3612  ObjCProtocolDecl *ToProto = MergeWithProtocol;
3613  if (!ToProto) {
3614  if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC,
3615  Name.getAsIdentifierInfo(), Loc,
3616  Importer.Import(D->getAtStartLoc()),
3617  /*PrevDecl=*/nullptr))
3618  return ToProto;
3619  ToProto->setLexicalDeclContext(LexicalDC);
3620  LexicalDC->addDeclInternal(ToProto);
3621  }
3622 
3623  Importer.MapImported(D, ToProto);
3624 
3625  if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
3626  return nullptr;
3627 
3628  return ToProto;
3629 }
3630 
3632  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3633  DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3634 
3635  SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3636  SourceLocation LangLoc = Importer.Import(D->getLocation());
3637 
3638  bool HasBraces = D->hasBraces();
3639 
3640  LinkageSpecDecl *ToLinkageSpec;
3641  if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC,
3642  ExternLoc, LangLoc, D->getLanguage(), HasBraces))
3643  return ToLinkageSpec;
3644 
3645  if (HasBraces) {
3646  SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3647  ToLinkageSpec->setRBraceLoc(RBraceLoc);
3648  }
3649 
3650  ToLinkageSpec->setLexicalDeclContext(LexicalDC);
3651  LexicalDC->addDeclInternal(ToLinkageSpec);
3652 
3653  return ToLinkageSpec;
3654 }
3655 
3657  DeclContext *DC, *LexicalDC;
3658  DeclarationName Name;
3659  SourceLocation Loc;
3660  NamedDecl *ToD = nullptr;
3661  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3662  return nullptr;
3663  if (ToD)
3664  return ToD;
3665 
3666  DeclarationNameInfo NameInfo(Name,
3667  Importer.Import(D->getNameInfo().getLoc()));
3668  ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3669 
3670  UsingDecl *ToUsing;
3671  if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
3672  Importer.Import(D->getUsingLoc()),
3673  Importer.Import(D->getQualifierLoc()), NameInfo,
3674  D->hasTypename()))
3675  return ToUsing;
3676 
3677  ToUsing->setLexicalDeclContext(LexicalDC);
3678  LexicalDC->addDeclInternal(ToUsing);
3679 
3680  if (NamedDecl *FromPattern =
3681  Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
3682  if (auto *ToPattern =
3683  dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern)))
3684  Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, ToPattern);
3685  else
3686  return nullptr;
3687  }
3688 
3689  for (auto *FromShadow : D->shadows()) {
3690  if (auto *ToShadow =
3691  dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow)))
3692  ToUsing->addShadowDecl(ToShadow);
3693  else
3694  // FIXME: We return a nullptr here but the definition is already created
3695  // and available with lookups. How to fix this?..
3696  return nullptr;
3697  }
3698  return ToUsing;
3699 }
3700 
3702  DeclContext *DC, *LexicalDC;
3703  DeclarationName Name;
3704  SourceLocation Loc;
3705  NamedDecl *ToD = nullptr;
3706  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3707  return nullptr;
3708  if (ToD)
3709  return ToD;
3710 
3711  auto *ToUsing = dyn_cast_or_null<UsingDecl>(
3712  Importer.Import(D->getUsingDecl()));
3713  if (!ToUsing)
3714  return nullptr;
3715 
3716  auto *ToTarget = dyn_cast_or_null<NamedDecl>(
3717  Importer.Import(D->getTargetDecl()));
3718  if (!ToTarget)
3719  return nullptr;
3720 
3721  UsingShadowDecl *ToShadow;
3722  if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
3723  ToUsing, ToTarget))
3724  return ToShadow;
3725 
3726  ToShadow->setLexicalDeclContext(LexicalDC);
3727  ToShadow->setAccess(D->getAccess());
3728 
3729  if (UsingShadowDecl *FromPattern =
3730  Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
3731  if (auto *ToPattern =
3732  dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern)))
3733  Importer.getToContext().setInstantiatedFromUsingShadowDecl(ToShadow,
3734  ToPattern);
3735  else
3736  // FIXME: We return a nullptr here but the definition is already created
3737  // and available with lookups. How to fix this?..
3738  return nullptr;
3739  }
3740 
3741  LexicalDC->addDeclInternal(ToShadow);
3742 
3743  return ToShadow;
3744 }
3745 
3747  DeclContext *DC, *LexicalDC;
3748  DeclarationName Name;
3749  SourceLocation Loc;
3750  NamedDecl *ToD = nullptr;
3751  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3752  return nullptr;
3753  if (ToD)
3754  return ToD;
3755 
3756  DeclContext *ToComAncestor = Importer.ImportContext(D->getCommonAncestor());
3757  if (!ToComAncestor)
3758  return nullptr;
3759 
3760  auto *ToNominated = cast_or_null<NamespaceDecl>(
3761  Importer.Import(D->getNominatedNamespace()));
3762  if (!ToNominated)
3763  return nullptr;
3764 
3765  UsingDirectiveDecl *ToUsingDir;
3766  if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
3767  Importer.Import(D->getUsingLoc()),
3768  Importer.Import(D->getNamespaceKeyLocation()),
3769  Importer.Import(D->getQualifierLoc()),
3770  Importer.Import(D->getIdentLocation()),
3771  ToNominated, ToComAncestor))
3772  return ToUsingDir;
3773 
3774  ToUsingDir->setLexicalDeclContext(LexicalDC);
3775  LexicalDC->addDeclInternal(ToUsingDir);
3776 
3777  return ToUsingDir;
3778 }
3779 
3782  DeclContext *DC, *LexicalDC;
3783  DeclarationName Name;
3784  SourceLocation Loc;
3785  NamedDecl *ToD = nullptr;
3786  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3787  return nullptr;
3788  if (ToD)
3789  return ToD;
3790 
3791  DeclarationNameInfo NameInfo(Name, Importer.Import(D->getNameInfo().getLoc()));
3792  ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3793 
3794  UnresolvedUsingValueDecl *ToUsingValue;
3795  if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
3796  Importer.Import(D->getUsingLoc()),
3797  Importer.Import(D->getQualifierLoc()), NameInfo,
3798  Importer.Import(D->getEllipsisLoc())))
3799  return ToUsingValue;
3800 
3801  ToUsingValue->setAccess(D->getAccess());
3802  ToUsingValue->setLexicalDeclContext(LexicalDC);
3803  LexicalDC->addDeclInternal(ToUsingValue);
3804 
3805  return ToUsingValue;
3806 }
3807 
3810  DeclContext *DC, *LexicalDC;
3811  DeclarationName Name;
3812  SourceLocation Loc;
3813  NamedDecl *ToD = nullptr;
3814  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3815  return nullptr;
3816  if (ToD)
3817  return ToD;
3818 
3819  UnresolvedUsingTypenameDecl *ToUsing;
3820  if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
3821  Importer.Import(D->getUsingLoc()),
3822  Importer.Import(D->getTypenameLoc()),
3823  Importer.Import(D->getQualifierLoc()), Loc, Name,
3824  Importer.Import(D->getEllipsisLoc())))
3825  return ToUsing;
3826 
3827  ToUsing->setAccess(D->getAccess());
3828  ToUsing->setLexicalDeclContext(LexicalDC);
3829  LexicalDC->addDeclInternal(ToUsing);
3830 
3831  return ToUsing;
3832 }
3833 
3835  ObjCInterfaceDecl *To,
3837  if (To->getDefinition()) {
3838  // Check consistency of superclass.
3839  ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3840  if (FromSuper) {
3841  FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3842  if (!FromSuper)
3843  return true;
3844  }
3845 
3846  ObjCInterfaceDecl *ToSuper = To->getSuperClass();
3847  if ((bool)FromSuper != (bool)ToSuper ||
3848  (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
3849  Importer.ToDiag(To->getLocation(),
3850  diag::err_odr_objc_superclass_inconsistent)
3851  << To->getDeclName();
3852  if (ToSuper)
3853  Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3854  << To->getSuperClass()->getDeclName();
3855  else
3856  Importer.ToDiag(To->getLocation(),
3857  diag::note_odr_objc_missing_superclass);
3858  if (From->getSuperClass())
3859  Importer.FromDiag(From->getSuperClassLoc(),
3860  diag::note_odr_objc_superclass)
3861  << From->getSuperClass()->getDeclName();
3862  else
3863  Importer.FromDiag(From->getLocation(),
3864  diag::note_odr_objc_missing_superclass);
3865  }
3866 
3867  if (shouldForceImportDeclContext(Kind))
3868  ImportDeclContext(From);
3869  return false;
3870  }
3871 
3872  // Start the definition.
3873  To->startDefinition();
3874 
3875  // If this class has a superclass, import it.
3876  if (From->getSuperClass()) {
3877  TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
3878  if (!SuperTInfo)
3879  return true;
3880 
3881  To->setSuperClass(SuperTInfo);
3882  }
3883 
3884  // Import protocols
3886  SmallVector<SourceLocation, 4> ProtocolLocs;
3888  FromProtoLoc = From->protocol_loc_begin();
3889 
3890  for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3891  FromProtoEnd = From->protocol_end();
3892  FromProto != FromProtoEnd;
3893  ++FromProto, ++FromProtoLoc) {
3894  auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3895  if (!ToProto)
3896  return true;
3897  Protocols.push_back(ToProto);
3898  ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3899  }
3900 
3901  // FIXME: If we're merging, make sure that the protocol list is the same.
3902  To->setProtocolList(Protocols.data(), Protocols.size(),
3903  ProtocolLocs.data(), Importer.getToContext());
3904 
3905  // Import categories. When the categories themselves are imported, they'll
3906  // hook themselves into this interface.
3907  for (auto *Cat : From->known_categories())
3908  Importer.Import(Cat);
3909 
3910  // If we have an @implementation, import it as well.
3911  if (From->getImplementation()) {
3912  auto *Impl = cast_or_null<ObjCImplementationDecl>(
3913  Importer.Import(From->getImplementation()));
3914  if (!Impl)
3915  return true;
3916 
3917  To->setImplementation(Impl);
3918  }
3919 
3920  if (shouldForceImportDeclContext(Kind)) {
3921  // Import all of the members of this class.
3922  ImportDeclContext(From, /*ForceImport=*/true);
3923  }
3924  return false;
3925 }
3926 
3929  if (!list)
3930  return nullptr;
3931 
3933  for (auto fromTypeParam : *list) {
3934  auto *toTypeParam = cast_or_null<ObjCTypeParamDecl>(
3935  Importer.Import(fromTypeParam));
3936  if (!toTypeParam)
3937  return nullptr;
3938 
3939  toTypeParams.push_back(toTypeParam);
3940  }
3941 
3942  return ObjCTypeParamList::create(Importer.getToContext(),
3943  Importer.Import(list->getLAngleLoc()),
3944  toTypeParams,
3945  Importer.Import(list->getRAngleLoc()));
3946 }
3947 
3949  // If this class has a definition in the translation unit we're coming from,
3950  // but this particular declaration is not that definition, import the
3951  // definition and map to that.
3952  ObjCInterfaceDecl *Definition = D->getDefinition();
3953  if (Definition && Definition != D) {
3954  Decl *ImportedDef = Importer.Import(Definition);
3955  if (!ImportedDef)
3956  return nullptr;
3957 
3958  return Importer.MapImported(D, ImportedDef);
3959  }
3960 
3961  // Import the major distinguishing characteristics of an @interface.
3962  DeclContext *DC, *LexicalDC;
3963  DeclarationName Name;
3964  SourceLocation Loc;
3965  NamedDecl *ToD;
3966  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3967  return nullptr;
3968  if (ToD)
3969  return ToD;
3970 
3971  // Look for an existing interface with the same name.
3972  ObjCInterfaceDecl *MergeWithIface = nullptr;
3973  SmallVector<NamedDecl *, 2> FoundDecls;
3974  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3975  for (auto *FoundDecl : FoundDecls) {
3977  continue;
3978 
3979  if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
3980  break;
3981  }
3982 
3983  // Create an interface declaration, if one does not already exist.
3984  ObjCInterfaceDecl *ToIface = MergeWithIface;
3985  if (!ToIface) {
3986  if (GetImportedOrCreateDecl(
3987  ToIface, D, Importer.getToContext(), DC,
3988  Importer.Import(D->getAtStartLoc()), Name.getAsIdentifierInfo(),
3989  /*TypeParamList=*/nullptr,
3990  /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl()))
3991  return ToIface;
3992  ToIface->setLexicalDeclContext(LexicalDC);
3993  LexicalDC->addDeclInternal(ToIface);
3994  }
3995  Importer.MapImported(D, ToIface);
3996  // Import the type parameter list after calling Imported, to avoid
3997  // loops when bringing in their DeclContext.
4000 
4001  if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
4002  return nullptr;
4003 
4004  return ToIface;
4005 }
4006 
4008  auto *Category = cast_or_null<ObjCCategoryDecl>(
4009  Importer.Import(D->getCategoryDecl()));
4010  if (!Category)
4011  return nullptr;
4012 
4013  ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4014  if (!ToImpl) {
4015  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4016  if (!DC)
4017  return nullptr;
4018 
4019  SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
4020  if (GetImportedOrCreateDecl(
4021  ToImpl, D, Importer.getToContext(), DC,
4022  Importer.Import(D->getIdentifier()), Category->getClassInterface(),
4023  Importer.Import(D->getLocation()),
4024  Importer.Import(D->getAtStartLoc()), CategoryNameLoc))
4025  return ToImpl;
4026 
4027  DeclContext *LexicalDC = DC;
4028  if (D->getDeclContext() != D->getLexicalDeclContext()) {
4029  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4030  if (!LexicalDC)
4031  return nullptr;
4032 
4033  ToImpl->setLexicalDeclContext(LexicalDC);
4034  }
4035 
4036  LexicalDC->addDeclInternal(ToImpl);
4037  Category->setImplementation(ToImpl);
4038  }
4039 
4040  Importer.MapImported(D, ToImpl);
4041  ImportDeclContext(D);
4042  return ToImpl;
4043 }
4044 
4046  // Find the corresponding interface.
4047  auto *Iface = cast_or_null<ObjCInterfaceDecl>(
4048  Importer.Import(D->getClassInterface()));
4049  if (!Iface)
4050  return nullptr;
4051 
4052  // Import the superclass, if any.
4053  ObjCInterfaceDecl *Super = nullptr;
4054  if (D->getSuperClass()) {
4055  Super = cast_or_null<ObjCInterfaceDecl>(
4056  Importer.Import(D->getSuperClass()));
4057  if (!Super)
4058  return nullptr;
4059  }
4060 
4061  ObjCImplementationDecl *Impl = Iface->getImplementation();
4062  if (!Impl) {
4063  // We haven't imported an implementation yet. Create a new @implementation
4064  // now.
4065  if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
4066  Importer.ImportContext(D->getDeclContext()),
4067  Iface, Super, Importer.Import(D->getLocation()),
4068  Importer.Import(D->getAtStartLoc()),
4069  Importer.Import(D->getSuperClassLoc()),
4070  Importer.Import(D->getIvarLBraceLoc()),
4071  Importer.Import(D->getIvarRBraceLoc())))
4072  return Impl;
4073 
4074  if (D->getDeclContext() != D->getLexicalDeclContext()) {
4075  DeclContext *LexicalDC
4076  = Importer.ImportContext(D->getLexicalDeclContext());
4077  if (!LexicalDC)
4078  return nullptr;
4079  Impl->setLexicalDeclContext(LexicalDC);
4080  }
4081 
4082  // Associate the implementation with the class it implements.
4083  Iface->setImplementation(Impl);
4084  Importer.MapImported(D, Iface->getImplementation());
4085  } else {
4086  Importer.MapImported(D, Iface->getImplementation());
4087 
4088  // Verify that the existing @implementation has the same superclass.
4089  if ((Super && !Impl->getSuperClass()) ||
4090  (!Super && Impl->getSuperClass()) ||
4091  (Super && Impl->getSuperClass() &&
4093  Impl->getSuperClass()))) {
4094  Importer.ToDiag(Impl->getLocation(),
4095  diag::err_odr_objc_superclass_inconsistent)
4096  << Iface->getDeclName();
4097  // FIXME: It would be nice to have the location of the superclass
4098  // below.
4099  if (Impl->getSuperClass())
4100  Importer.ToDiag(Impl->getLocation(),
4101  diag::note_odr_objc_superclass)
4102  << Impl->getSuperClass()->getDeclName();
4103  else
4104  Importer.ToDiag(Impl->getLocation(),
4105  diag::note_odr_objc_missing_superclass);
4106  if (D->getSuperClass())
4107  Importer.FromDiag(D->getLocation(),
4108  diag::note_odr_objc_superclass)
4109  << D->getSuperClass()->getDeclName();
4110  else
4111  Importer.FromDiag(D->getLocation(),
4112  diag::note_odr_objc_missing_superclass);
4113  return nullptr;
4114  }
4115  }
4116 
4117  // Import all of the members of this @implementation.
4118  ImportDeclContext(D);
4119 
4120  return Impl;
4121 }
4122 
4124  // Import the major distinguishing characteristics of an @property.
4125  DeclContext *DC, *LexicalDC;
4126  DeclarationName Name;
4127  SourceLocation Loc;
4128  NamedDecl *ToD;
4129  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4130  return nullptr;
4131  if (ToD)
4132  return ToD;
4133 
4134  // Check whether we have already imported this property.
4135  SmallVector<NamedDecl *, 2> FoundDecls;
4136  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4137  for (auto *FoundDecl : FoundDecls) {
4138  if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
4139  // Check property types.
4140  if (!Importer.IsStructurallyEquivalent(D->getType(),
4141  FoundProp->getType())) {
4142  Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
4143  << Name << D->getType() << FoundProp->getType();
4144  Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
4145  << FoundProp->getType();
4146  return nullptr;
4147  }
4148 
4149  // FIXME: Check property attributes, getters, setters, etc.?
4150 
4151  // Consider these properties to be equivalent.
4152  Importer.MapImported(D, FoundProp);
4153  return FoundProp;
4154  }
4155  }
4156 
4157  // Import the type.
4158  TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4159  if (!TSI)
4160  return nullptr;
4161 
4162  // Create the new property.
4163  ObjCPropertyDecl *ToProperty;
4164  if (GetImportedOrCreateDecl(
4165  ToProperty, D, Importer.getToContext(), DC, Loc,
4166  Name.getAsIdentifierInfo(), Importer.Import(D->getAtLoc()),
4167  Importer.Import(D->getLParenLoc()), Importer.Import(D->getType()),
4168  TSI, D->getPropertyImplementation()))
4169  return ToProperty;
4170 
4171  ToProperty->setLexicalDeclContext(LexicalDC);
4172  LexicalDC->addDeclInternal(ToProperty);
4173 
4174  ToProperty->setPropertyAttributes(D->getPropertyAttributes());
4175  ToProperty->setPropertyAttributesAsWritten(
4177  ToProperty->setGetterName(Importer.Import(D->getGetterName()),
4178  Importer.Import(D->getGetterNameLoc()));
4179  ToProperty->setSetterName(Importer.Import(D->getSetterName()),
4180  Importer.Import(D->getSetterNameLoc()));
4181  ToProperty->setGetterMethodDecl(
4182  cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4183  ToProperty->setSetterMethodDecl(
4184  cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4185  ToProperty->setPropertyIvarDecl(
4186  cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4187  return ToProperty;
4188 }
4189 
4191  auto *Property = cast_or_null<ObjCPropertyDecl>(
4192  Importer.Import(D->getPropertyDecl()));
4193  if (!Property)
4194  return nullptr;
4195 
4196  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4197  if (!DC)
4198  return nullptr;
4199 
4200  // Import the lexical declaration context.
4201  DeclContext *LexicalDC = DC;
4202  if (D->getDeclContext() != D->getLexicalDeclContext()) {
4203  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4204  if (!LexicalDC)
4205  return nullptr;
4206  }
4207 
4208  auto *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
4209  if (!InImpl)
4210  return nullptr;
4211 
4212  // Import the ivar (for an @synthesize).
4213  ObjCIvarDecl *Ivar = nullptr;
4214  if (D->getPropertyIvarDecl()) {
4215  Ivar = cast_or_null<ObjCIvarDecl>(
4216  Importer.Import(D->getPropertyIvarDecl()));
4217  if (!Ivar)
4218  return nullptr;
4219  }
4220 
4221  ObjCPropertyImplDecl *ToImpl
4222  = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
4223  Property->getQueryKind());
4224  if (!ToImpl) {
4225  if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
4226  Importer.Import(D->getLocStart()),
4227  Importer.Import(D->getLocation()), Property,
4228  D->getPropertyImplementation(), Ivar,
4229  Importer.Import(D->getPropertyIvarDeclLoc())))
4230  return ToImpl;
4231 
4232  ToImpl->setLexicalDeclContext(LexicalDC);
4233  LexicalDC->addDeclInternal(ToImpl);
4234  } else {
4235  // Check that we have the same kind of property implementation (@synthesize
4236  // vs. @dynamic).
4237  if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
4238  Importer.ToDiag(ToImpl->getLocation(),
4239  diag::err_odr_objc_property_impl_kind_inconsistent)
4240  << Property->getDeclName()
4241  << (ToImpl->getPropertyImplementation()
4243  Importer.FromDiag(D->getLocation(),
4244  diag::note_odr_objc_property_impl_kind)
4245  << D->getPropertyDecl()->getDeclName()
4247  return nullptr;
4248  }
4249 
4250  // For @synthesize, check that we have the same
4252  Ivar != ToImpl->getPropertyIvarDecl()) {
4253  Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4254  diag::err_odr_objc_synthesize_ivar_inconsistent)
4255  << Property->getDeclName()
4256  << ToImpl->getPropertyIvarDecl()->getDeclName()
4257  << Ivar->getDeclName();
4258  Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4259  diag::note_odr_objc_synthesize_ivar_here)
4260  << D->getPropertyIvarDecl()->getDeclName();
4261  return nullptr;
4262  }
4263 
4264  // Merge the existing implementation with the new implementation.
4265  Importer.MapImported(D, ToImpl);
4266  }
4267 
4268  return ToImpl;
4269 }
4270 
4272  // For template arguments, we adopt the translation unit as our declaration
4273  // context. This context will be fixed when the actual template declaration
4274  // is created.
4275 
4276  // FIXME: Import default argument.
4277  TemplateTypeParmDecl *ToD = nullptr;
4278  (void)GetImportedOrCreateDecl(
4279  ToD, D, Importer.getToContext(),
4280  Importer.getToContext().getTranslationUnitDecl(),
4281  Importer.Import(D->getLocStart()), Importer.Import(D->getLocation()),
4282  D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
4284  return ToD;
4285 }
4286 
4287 Decl *
4289  // Import the name of this declaration.
4290  DeclarationName Name = Importer.Import(D->getDeclName());
4291  if (D->getDeclName() && !Name)
4292  return nullptr;
4293 
4294  // Import the location of this declaration.
4295  SourceLocation Loc = Importer.Import(D->getLocation());
4296 
4297  // Import the type of this declaration.
4298  QualType T = Importer.Import(D->getType());
4299  if (T.isNull())
4300  return nullptr;
4301 
4302  // Import type-source information.
4303  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4304  if (D->getTypeSourceInfo() && !TInfo)
4305  return nullptr;
4306 
4307  // FIXME: Import default argument.
4308 
4309  NonTypeTemplateParmDecl *ToD = nullptr;
4310  (void)GetImportedOrCreateDecl(
4311  ToD, D, Importer.getToContext(),
4312  Importer.getToContext().getTranslationUnitDecl(),
4313  Importer.Import(D->getInnerLocStart()), Loc, D->getDepth(),
4314  D->getPosition(), Name.getAsIdentifierInfo(), T, D->isParameterPack(),
4315  TInfo);
4316  return ToD;
4317 }
4318 
4319 Decl *
4321  // Import the name of this declaration.
4322  DeclarationName Name = Importer.Import(D->getDeclName());
4323  if (D->getDeclName() && !Name)
4324  return nullptr;
4325 
4326  // Import the location of this declaration.
4327  SourceLocation Loc = Importer.Import(D->getLocation());
4328 
4329  // Import template parameters.
4330  TemplateParameterList *TemplateParams
4332  if (!TemplateParams)
4333  return nullptr;
4334 
4335  // FIXME: Import default argument.
4336 
4337  TemplateTemplateParmDecl *ToD = nullptr;
4338  (void)GetImportedOrCreateDecl(
4339  ToD, D, Importer.getToContext(),
4340  Importer.getToContext().getTranslationUnitDecl(), Loc, D->getDepth(),
4341  D->getPosition(), D->isParameterPack(), Name.getAsIdentifierInfo(),
4342  TemplateParams);
4343  return ToD;
4344 }
4345 
4346 // Returns the definition for a (forward) declaration of a ClassTemplateDecl, if
4347 // it has any definition in the redecl chain.
4349  CXXRecordDecl *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
4350  if (!ToTemplatedDef)
4351  return nullptr;
4352  ClassTemplateDecl *TemplateWithDef =
4353  ToTemplatedDef->getDescribedClassTemplate();
4354  return TemplateWithDef;
4355 }
4356 
4358  // If this record has a definition in the translation unit we're coming from,
4359  // but this particular declaration is not that definition, import the
4360  // definition and map to that.
4361  auto *Definition =
4362  cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
4363  if (Definition && Definition != D->getTemplatedDecl()) {
4364  Decl *ImportedDef
4365  = Importer.Import(Definition->getDescribedClassTemplate());
4366  if (!ImportedDef)
4367  return nullptr;
4368 
4369  return Importer.MapImported(D, ImportedDef);
4370  }
4371 
4372  // Import the major distinguishing characteristics of this class template.
4373  DeclContext *DC, *LexicalDC;
4374  DeclarationName Name;
4375  SourceLocation Loc;
4376  NamedDecl *ToD;
4377  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4378  return nullptr;
4379  if (ToD)
4380  return ToD;
4381 
4382  // We may already have a template of the same name; try to find and match it.
4383  if (!DC->isFunctionOrMethod()) {
4384  SmallVector<NamedDecl *, 4> ConflictingDecls;
4385  SmallVector<NamedDecl *, 2> FoundDecls;
4386  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4387  for (auto *FoundDecl : FoundDecls) {
4389  continue;
4390 
4391  Decl *Found = FoundDecl;
4392  if (auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found)) {
4393 
4394  // The class to be imported is a definition.
4395  if (D->isThisDeclarationADefinition()) {
4396  // Lookup will find the fwd decl only if that is more recent than the
4397  // definition. So, try to get the definition if that is available in
4398  // the redecl chain.
4399  ClassTemplateDecl *TemplateWithDef = getDefinition(FoundTemplate);
4400  if (!TemplateWithDef)
4401  continue;
4402  FoundTemplate = TemplateWithDef; // Continue with the definition.
4403  }
4404 
4405  if (IsStructuralMatch(D, FoundTemplate)) {
4406  // The class templates structurally match; call it the same template.
4407 
4408  Importer.MapImported(D->getTemplatedDecl(),
4409  FoundTemplate->getTemplatedDecl());
4410  return Importer.MapImported(D, FoundTemplate);
4411  }
4412  }
4413 
4414  ConflictingDecls.push_back(FoundDecl);
4415  }
4416 
4417  if (!ConflictingDecls.empty()) {
4418  Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4419  ConflictingDecls.data(),
4420  ConflictingDecls.size());
4421  }
4422 
4423  if (!Name)
4424  return nullptr;
4425  }
4426 
4427  CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
4428 
4429  // Create the declaration that is being templated.
4430  auto *ToTemplated = cast_or_null<CXXRecordDecl>(
4431  Importer.Import(FromTemplated));
4432  if (!ToTemplated)
4433  return nullptr;
4434 
4435  // Create the class template declaration itself.
4436  TemplateParameterList *TemplateParams =
4438  if (!TemplateParams)
4439  return nullptr;
4440 
4441  ClassTemplateDecl *D2;
4442  if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
4443  TemplateParams, ToTemplated))
4444  return D2;
4445 
4446  ToTemplated->setDescribedClassTemplate(D2);
4447 
4448  D2->setAccess(D->getAccess());
4449  D2->setLexicalDeclContext(LexicalDC);
4450  LexicalDC->addDeclInternal(D2);
4451 
4452  if (FromTemplated->isCompleteDefinition() &&
4453  !ToTemplated->isCompleteDefinition()) {
4454  // FIXME: Import definition!
4455  }
4456 
4457  return D2;
4458 }
4459 
4462  // If this record has a definition in the translation unit we're coming from,
4463  // but this particular declaration is not that definition, import the
4464  // definition and map to that.
4465  TagDecl *Definition = D->getDefinition();
4466  if (Definition && Definition != D) {
4467  Decl *ImportedDef = Importer.Import(Definition);
4468  if (!ImportedDef)
4469  return nullptr;
4470 
4471  return Importer.MapImported(D, ImportedDef);
4472  }
4473 
4474  auto *ClassTemplate =
4475  cast_or_null<ClassTemplateDecl>(Importer.Import(
4476  D->getSpecializedTemplate()));
4477  if (!ClassTemplate)
4478  return nullptr;
4479 
4480  // Import the context of this declaration.
4481  DeclContext *DC = ClassTemplate->getDeclContext();
4482  if (!DC)
4483  return nullptr;
4484 
4485  DeclContext *LexicalDC = DC;
4486  if (D->getDeclContext() != D->getLexicalDeclContext()) {
4487  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4488  if (!LexicalDC)
4489  return nullptr;
4490  }
4491 
4492  // Import the location of this declaration.
4493  SourceLocation StartLoc = Importer.Import(D->getLocStart());
4494  SourceLocation IdLoc = Importer.Import(D->getLocation());
4495 
4496  // Import template arguments.
4497  SmallVector<TemplateArgument, 2> TemplateArgs;
4499  D->getTemplateArgs().size(),
4500  TemplateArgs))
4501  return nullptr;
4502 
4503  // Try to find an existing specialization with these template arguments.
4504  void *InsertPos = nullptr;
4506  = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4507  if (D2) {
4508  // We already have a class template specialization with these template
4509  // arguments.
4510 
4511  // FIXME: Check for specialization vs. instantiation errors.
4512 
4513  if (RecordDecl *FoundDef = D2->getDefinition()) {
4514  if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4515  // The record types structurally match, or the "from" translation
4516  // unit only had a forward declaration anyway; call it the same
4517  // function.
4518  return Importer.MapImported(D, FoundDef);
4519  }
4520  }
4521  } else {
4522  // Create a new specialization.
4523  if (auto *PartialSpec =
4524  dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
4525  // Import TemplateArgumentListInfo
4526  TemplateArgumentListInfo ToTAInfo;
4527  const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
4528  if (ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
4529  return nullptr;
4530 
4531  QualType CanonInjType = Importer.Import(
4532  PartialSpec->getInjectedSpecializationType());
4533  if (CanonInjType.isNull())
4534  return nullptr;
4535  CanonInjType = CanonInjType.getCanonicalType();
4536 
4538  PartialSpec->getTemplateParameters());
4539  if (!ToTPList && PartialSpec->getTemplateParameters())
4540  return nullptr;
4541 
4542  if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
4543  D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
4544  IdLoc, ToTPList, ClassTemplate,
4545  llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
4546  ToTAInfo, CanonInjType, nullptr))
4547  return D2;
4548 
4549  } else {
4550  if (GetImportedOrCreateDecl(
4551  D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
4552  IdLoc, ClassTemplate, TemplateArgs, /*PrevDecl=*/nullptr))
4553  return D2;
4554  }
4555 
4557 
4558  // Add this specialization to the class template.
4559  ClassTemplate->AddSpecialization(D2, InsertPos);
4560 
4561  // Import the qualifier, if any.
4562  D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4563 
4564  if (auto *TSI = D->getTypeAsWritten()) {
4565  TypeSourceInfo *TInfo = Importer.Import(TSI);
4566  if (!TInfo)
4567  return nullptr;
4568  D2->setTypeAsWritten(TInfo);
4569  D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
4570  D2->setExternLoc(Importer.Import(D->getExternLoc()));
4571  }
4572 
4573  SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
4574  if (POI.isValid())
4575  D2->setPointOfInstantiation(POI);
4576  else if (D->getPointOfInstantiation().isValid())
4577  return nullptr;
4578 
4580 
4581  // Set the context of this specialization/instantiation.
4582  D2->setLexicalDeclContext(LexicalDC);
4583 
4584  // Add to the DC only if it was an explicit specialization/instantiation.
4586  LexicalDC->addDeclInternal(D2);
4587  }
4588  }
4589  if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4590  return nullptr;
4591 
4592  return D2;
4593 }
4594 
4596  // If this variable has a definition in the translation unit we're coming
4597  // from,
4598  // but this particular declaration is not that definition, import the
4599  // definition and map to that.
4600  auto *Definition =
4601  cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4602  if (Definition && Definition != D->getTemplatedDecl()) {
4603  Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4604  if (!ImportedDef)
4605  return nullptr;
4606 
4607  return Importer.MapImported(D, ImportedDef);
4608  }
4609 
4610  // Import the major distinguishing characteristics of this variable template.
4611  DeclContext *DC, *LexicalDC;
4612  DeclarationName Name;
4613  SourceLocation Loc;
4614  NamedDecl *ToD;
4615  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4616  return nullptr;
4617  if (ToD)
4618  return ToD;
4619 
4620  // We may already have a template of the same name; try to find and match it.
4621  assert(!DC->isFunctionOrMethod() &&
4622  "Variable templates cannot be declared at function scope");
4623  SmallVector<NamedDecl *, 4> ConflictingDecls;
4624  SmallVector<NamedDecl *, 2> FoundDecls;
4625  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4626  for (auto *FoundDecl : FoundDecls) {
4628  continue;
4629 
4630  Decl *Found = FoundDecl;
4631  if (auto *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
4632  if (IsStructuralMatch(D, FoundTemplate)) {
4633  // The variable templates structurally match; call it the same template.
4634  Importer.MapImported(D->getTemplatedDecl(),
4635  FoundTemplate->getTemplatedDecl());
4636  return Importer.MapImported(D, FoundTemplate);
4637  }
4638  }
4639 
4640  ConflictingDecls.push_back(FoundDecl);
4641  }
4642 
4643  if (!ConflictingDecls.empty()) {
4644  Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4645  ConflictingDecls.data(),
4646  ConflictingDecls.size());
4647  }
4648 
4649  if (!Name)
4650  return nullptr;
4651 
4652  VarDecl *DTemplated = D->getTemplatedDecl();
4653 
4654  // Import the type.
4655  QualType T = Importer.Import(DTemplated->getType());
4656  if (T.isNull())
4657  return nullptr;
4658 
4659  // Create the declaration that is being templated.
4660  auto *ToTemplated = dyn_cast_or_null<VarDecl>(Importer.Import(DTemplated));
4661  if (!ToTemplated)
4662  return nullptr;
4663 
4664  // Create the variable template declaration itself.
4665  TemplateParameterList *TemplateParams =
4667  if (!TemplateParams)
4668  return nullptr;
4669 
4670  VarTemplateDecl *ToVarTD;
4671  if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc,
4672  Name, TemplateParams, ToTemplated))
4673  return ToVarTD;
4674 
4675  ToTemplated->setDescribedVarTemplate(ToVarTD);
4676 
4677  ToVarTD->setAccess(D->getAccess());
4678  ToVarTD->setLexicalDeclContext(LexicalDC);
4679  LexicalDC->addDeclInternal(ToVarTD);
4680 
4681  if (DTemplated->isThisDeclarationADefinition() &&
4682  !ToTemplated->isThisDeclarationADefinition()) {
4683  // FIXME: Import definition!
4684  }
4685 
4686  return ToVarTD;
4687 }
4688 
4691  // If this record has a definition in the translation unit we're coming from,
4692  // but this particular declaration is not that definition, import the
4693  // definition and map to that.
4694  VarDecl *Definition = D->getDefinition();
4695  if (Definition && Definition != D) {
4696  Decl *ImportedDef = Importer.Import(Definition);
4697  if (!ImportedDef)
4698  return nullptr;
4699 
4700  return Importer.MapImported(D, ImportedDef);
4701  }
4702 
4703  auto *VarTemplate = cast_or_null<VarTemplateDecl>(
4704  Importer.Import(D->getSpecializedTemplate()));
4705  if (!VarTemplate)
4706  return nullptr;
4707 
4708  // Import the context of this declaration.
4709  DeclContext *DC = VarTemplate->getDeclContext();
4710  if (!DC)
4711  return nullptr;
4712 
4713  DeclContext *LexicalDC = DC;
4714  if (D->getDeclContext() != D->getLexicalDeclContext()) {
4715  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4716  if (!LexicalDC)
4717  return nullptr;
4718  }
4719 
4720  // Import the location of this declaration.
4721  SourceLocation StartLoc = Importer.Import(D->getLocStart());
4722  SourceLocation IdLoc = Importer.Import(D->getLocation());
4723 
4724  // Import template arguments.
4725  SmallVector<TemplateArgument, 2> TemplateArgs;
4727  D->getTemplateArgs().size(), TemplateArgs))
4728  return nullptr;
4729 
4730  // Try to find an existing specialization with these template arguments.
4731  void *InsertPos = nullptr;
4732  VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
4733  TemplateArgs, InsertPos);
4734  if (D2) {
4735  // We already have a variable template specialization with these template
4736  // arguments.
4737 
4738  // FIXME: Check for specialization vs. instantiation errors.
4739 
4740  if (VarDecl *FoundDef = D2->getDefinition()) {
4741  if (!D->isThisDeclarationADefinition() ||
4742  IsStructuralMatch(D, FoundDef)) {
4743  // The record types structurally match, or the "from" translation
4744  // unit only had a forward declaration anyway; call it the same
4745  // variable.
4746  return Importer.MapImported(D, FoundDef);
4747  }
4748  }
4749  } else {
4750  // Import the type.
4751  QualType T = Importer.Import(D->getType());
4752  if (T.isNull())
4753  return nullptr;
4754 
4755  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4756  if (D->getTypeSourceInfo() && !TInfo)
4757  return nullptr;
4758 
4759  TemplateArgumentListInfo ToTAInfo;
4761  return nullptr;
4762 
4763  using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
4764  // Create a new specialization.
4765  if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
4766  // Import TemplateArgumentListInfo
4767  TemplateArgumentListInfo ArgInfos;
4768  const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
4769  // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
4770  if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ArgInfos))
4771  return nullptr;
4772 
4774  FromPartial->getTemplateParameters());
4775  if (!ToTPList)
4776  return nullptr;
4777 
4778  PartVarSpecDecl *ToPartial;
4779  if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
4780  StartLoc, IdLoc, ToTPList, VarTemplate, T,
4781  TInfo, D->getStorageClass(), TemplateArgs,
4782  ArgInfos))
4783  return ToPartial;
4784 
4785  auto *FromInst = FromPartial->getInstantiatedFromMember();
4786  auto *ToInst = cast_or_null<PartVarSpecDecl>(Importer.Import(FromInst));
4787  if (FromInst && !ToInst)
4788  return nullptr;
4789 
4790  ToPartial->setInstantiatedFromMember(ToInst);
4791  if (FromPartial->isMemberSpecialization())
4792  ToPartial->setMemberSpecialization();
4793 
4794  D2 = ToPartial;
4795  } else { // Full specialization
4796  if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, StartLoc,
4797  IdLoc, VarTemplate, T, TInfo,
4798  D->getStorageClass(), TemplateArgs))
4799  return D2;
4800  }
4801 
4803  if (POI.isValid())
4804  D2->setPointOfInstantiation(Importer.Import(POI));
4805 
4807  D2->setTemplateArgsInfo(ToTAInfo);
4808 
4809  // Add this specialization to the class template.
4810  VarTemplate->AddSpecialization(D2, InsertPos);
4811 
4812  // Import the qualifier, if any.
4813  D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4814 
4815  if (D->isConstexpr())
4816  D2->setConstexpr(true);
4817 
4818  // Add the specialization to this context.
4819  D2->setLexicalDeclContext(LexicalDC);
4820  LexicalDC->addDeclInternal(D2);
4821 
4822  D2->setAccess(D->getAccess());
4823  }
4824 
4825  // NOTE: isThisDeclarationADefinition() can return DeclarationOnly even if
4826  // declaration has initializer. Should this be fixed in the AST?.. Anyway,
4827  // we have to check the declaration for initializer - otherwise, it won't be
4828  // imported.
4829  if ((D->isThisDeclarationADefinition() || D->hasInit()) &&
4830  ImportDefinition(D, D2))
4831  return nullptr;
4832 
4833  return D2;
4834 }
4835 
4837  DeclContext *DC, *LexicalDC;
4838  DeclarationName Name;
4839  SourceLocation Loc;
4840  NamedDecl *ToD;
4841 
4842  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4843  return nullptr;
4844 
4845  if (ToD)
4846  return ToD;
4847 
4848  // Try to find a function in our own ("to") context with the same name, same
4849  // type, and in the same context as the function we're importing.
4850  if (!LexicalDC->isFunctionOrMethod()) {
4851  unsigned IDNS = Decl::IDNS_Ordinary;
4852  SmallVector<NamedDecl *, 2> FoundDecls;
4853  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4854  for (auto *FoundDecl : FoundDecls) {
4855  if (!FoundDecl->isInIdentifierNamespace(IDNS))
4856  continue;
4857 
4858  if (auto *FoundFunction = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
4859  if (FoundFunction->hasExternalFormalLinkage() &&
4860  D->hasExternalFormalLinkage()) {
4861  if (IsStructuralMatch(D, FoundFunction)) {
4862  Importer.MapImported(D, FoundFunction);
4863  // FIXME: Actually try to merge the body and other attributes.
4864  return FoundFunction;
4865  }
4866  }
4867  }
4868  }
4869  }
4870 
4871  TemplateParameterList *Params =
4873  if (!Params)
4874  return nullptr;
4875 
4876  auto *TemplatedFD =
4877  cast_or_null<FunctionDecl>(Importer.Import(D->getTemplatedDecl()));
4878  if (!TemplatedFD)
4879  return nullptr;
4880 
4881  FunctionTemplateDecl *ToFunc;
4882  if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
4883  Params, TemplatedFD))
4884  return ToFunc;
4885 
4886  TemplatedFD->setDescribedFunctionTemplate(ToFunc);
4887  ToFunc->setAccess(D->getAccess());
4888  ToFunc->setLexicalDeclContext(LexicalDC);
4889 
4890  LexicalDC->addDeclInternal(ToFunc);
4891  return ToFunc;
4892 }
4893 
4894 //----------------------------------------------------------------------------
4895 // Import Statements
4896 //----------------------------------------------------------------------------
4897 
4899  if (DG.isNull())
4900  return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
4901  size_t NumDecls = DG.end() - DG.begin();
4902  SmallVector<Decl *, 1> ToDecls(NumDecls);
4903  auto &_Importer = this->Importer;
4904  std::transform(DG.begin(), DG.end(), ToDecls.begin(),
4905  [&_Importer](Decl *D) -> Decl * {
4906  return _Importer.Import(D);
4907  });
4908  return DeclGroupRef::Create(Importer.getToContext(),
4909  ToDecls.begin(),
4910  NumDecls);
4911 }
4912 
4914  Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4915  << S->getStmtClassName();
4916  return nullptr;
4917 }
4918 
4921  for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
4922  IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
4923  // ToII is nullptr when no symbolic name is given for output operand
4924  // see ParseStmtAsm::ParseAsmOperandsOpt
4925  if (!ToII && S->getOutputIdentifier(I))
4926  return nullptr;
4927  Names.push_back(ToII);
4928  }
4929  for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
4930  IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
4931  // ToII is nullptr when no symbolic name is given for input operand
4932  // see ParseStmtAsm::ParseAsmOperandsOpt
4933  if (!ToII && S->getInputIdentifier(I))
4934  return nullptr;
4935  Names.push_back(ToII);
4936  }
4937 
4939  for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
4940  auto *Clobber = cast_or_null<StringLiteral>(
4941  Importer.Import(S->getClobberStringLiteral(I)));
4942  if (!Clobber)
4943  return nullptr;
4944  Clobbers.push_back(Clobber);
4945  }
4946 
4947  SmallVector<StringLiteral *, 4> Constraints;
4948  for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
4949  auto *Output = cast_or_null<StringLiteral>(
4950  Importer.Import(S->getOutputConstraintLiteral(I)));
4951  if (!Output)
4952  return nullptr;
4953  Constraints.push_back(Output);
4954  }
4955 
4956  for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
4957  auto *Input = cast_or_null<StringLiteral>(
4958  Importer.Import(S->getInputConstraintLiteral(I)));
4959  if (!Input)
4960  return nullptr;
4961  Constraints.push_back(Input);
4962  }
4963 
4965  if (ImportContainerChecked(S->outputs(), Exprs))
4966  return nullptr;
4967 
4968  if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
4969  return nullptr;
4970 
4971  auto *AsmStr = cast_or_null<StringLiteral>(
4972  Importer.Import(S->getAsmString()));
4973  if (!AsmStr)
4974  return nullptr;
4975 
4976  return new (Importer.getToContext()) GCCAsmStmt(
4977  Importer.getToContext(),
4978  Importer.Import(S->getAsmLoc()),
4979  S->isSimple(),
4980  S->isVolatile(),
4981  S->getNumOutputs(),
4982  S->getNumInputs(),
4983  Names.data(),
4984  Constraints.data(),
4985  Exprs.data(),
4986  AsmStr,
4987  S->getNumClobbers(),
4988  Clobbers.data(),
4989  Importer.Import(S->getRParenLoc()));
4990 }
4991 
4994  for (auto *ToD : ToDG) {
4995  if (!ToD)
4996  return nullptr;
4997  }
4998  SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
4999  SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
5000  return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
5001 }
5002 
5004  SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
5005  return new (Importer.getToContext()) NullStmt(ToSemiLoc,
5006  S->hasLeadingEmptyMacro());
5007 }
5008 
5010  SmallVector<Stmt *, 8> ToStmts(S->size());
5011 
5012  if (ImportContainerChecked(S->body(), ToStmts))
5013  return nullptr;
5014 
5015  SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
5016  SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
5017  return CompoundStmt::Create(Importer.getToContext(), ToStmts, ToLBraceLoc,
5018  ToRBraceLoc);
5019 }
5020 
5022  Expr *ToLHS = Importer.Import(S->getLHS());
5023  if (!ToLHS)
5024  return nullptr;
5025  Expr *ToRHS = Importer.Import(S->getRHS());
5026  if (!ToRHS && S->getRHS())
5027  return nullptr;
5028  Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5029  if (!ToSubStmt && S->getSubStmt())
5030  return nullptr;
5031  SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
5032  SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
5033  SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5034  auto *ToStmt = new (Importer.getToContext())
5035  CaseStmt(ToLHS, ToRHS, ToCaseLoc, ToEllipsisLoc, ToColonLoc);
5036  ToStmt->setSubStmt(ToSubStmt);
5037  return ToStmt;
5038 }
5039 
5041  SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
5042  SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5043  Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5044  if (!ToSubStmt && S->getSubStmt())
5045  return nullptr;
5046  return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
5047  ToSubStmt);
5048 }
5049 
5051  SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
5052  auto *ToLabelDecl = cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
5053  if (!ToLabelDecl && S->getDecl())
5054  return nullptr;
5055  Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5056  if (!ToSubStmt && S->getSubStmt())
5057  return nullptr;
5058  return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
5059  ToSubStmt);
5060 }
5061 
5063  SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
5064  ArrayRef<const Attr*> FromAttrs(S->getAttrs());
5065  SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
5066  if (ImportContainerChecked(FromAttrs, ToAttrs))
5067  return nullptr;
5068  Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5069  if (!ToSubStmt && S->getSubStmt())
5070  return nullptr;
5071  return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
5072  ToAttrs, ToSubStmt);
5073 }
5074 
5076  SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
5077  Stmt *ToInit = Importer.Import(S->getInit());
5078  if (!ToInit && S->getInit())
5079  return nullptr;
5080  VarDecl *ToConditionVariable = nullptr;
5081  if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5082  ToConditionVariable =
5083  dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5084  if (!ToConditionVariable)
5085  return nullptr;
5086  }
5087  Expr *ToCondition = Importer.Import(S->getCond());
5088  if (!ToCondition && S->getCond())
5089  return nullptr;
5090  Stmt *ToThenStmt = Importer.Import(S->getThen());
5091  if (!ToThenStmt && S->getThen())
5092  return nullptr;
5093  SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
5094  Stmt *ToElseStmt = Importer.Import(S->getElse());
5095  if (!ToElseStmt && S->getElse())
5096  return nullptr;
5097  return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
5098  ToIfLoc, S->isConstexpr(),
5099  ToInit,
5100  ToConditionVariable,
5101  ToCondition, ToThenStmt,
5102  ToElseLoc, ToElseStmt);
5103 }
5104 
5106  Stmt *ToInit = Importer.Import(S->getInit());
5107  if (!ToInit && S->getInit())
5108  return nullptr;
5109  VarDecl *ToConditionVariable = nullptr;
5110  if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5111  ToConditionVariable =
5112  dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5113  if (!ToConditionVariable)
5114  return nullptr;
5115  }
5116  Expr *ToCondition = Importer.Import(S->getCond());
5117  if (!ToCondition && S->getCond())
5118  return nullptr;
5119  auto *ToStmt = new (Importer.getToContext()) SwitchStmt(
5120  Importer.getToContext(), ToInit,
5121  ToConditionVariable, ToCondition);
5122  Stmt *ToBody = Importer.Import(S->getBody());
5123  if (!ToBody && S->getBody())
5124  return nullptr;
5125  ToStmt->setBody(ToBody);
5126  ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
5127  // Now we have to re-chain the cases.
5128  SwitchCase *LastChainedSwitchCase = nullptr;
5129  for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
5130  SC = SC->getNextSwitchCase()) {
5131  auto *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
5132  if (!ToSC)
5133  return nullptr;
5134  if (LastChainedSwitchCase)
5135  LastChainedSwitchCase->setNextSwitchCase(ToSC);
5136  else
5137  ToStmt->setSwitchCaseList(ToSC);
5138  LastChainedSwitchCase = ToSC;
5139  }
5140  return ToStmt;
5141 }
5142 
5144  VarDecl *ToConditionVariable = nullptr;
5145  if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5146  ToConditionVariable =
5147  dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5148  if (!ToConditionVariable)
5149  return nullptr;
5150  }
5151  Expr *ToCondition = Importer.Import(S->getCond());
5152  if (!ToCondition && S->getCond())
5153  return nullptr;
5154  Stmt *ToBody = Importer.Import(S->getBody());
5155  if (!ToBody && S->getBody())
5156  return nullptr;
5157  SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5158  return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
5159  ToConditionVariable,
5160  ToCondition, ToBody,
5161  ToWhileLoc);
5162 }
5163 
5165  Stmt *ToBody = Importer.Import(S->getBody());
5166  if (!ToBody && S->getBody())
5167  return nullptr;
5168  Expr *ToCondition = Importer.Import(S->getCond());
5169  if (!ToCondition && S->getCond())
5170  return nullptr;
5171  SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
5172  SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5173  SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5174  return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
5175  ToDoLoc, ToWhileLoc,
5176  ToRParenLoc);
5177 }
5178 
5180  Stmt *ToInit = Importer.Import(S->getInit());
5181  if (!ToInit && S->getInit())
5182  return nullptr;
5183  Expr *ToCondition = Importer.Import(S->getCond());
5184  if (!ToCondition && S->getCond())
5185  return nullptr;
5186  VarDecl *ToConditionVariable = nullptr;
5187  if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5188  ToConditionVariable =
5189  dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5190  if (!ToConditionVariable)
5191  return nullptr;
5192  }
5193  Expr *ToInc = Importer.Import(S->getInc());
5194  if (!ToInc && S->getInc())
5195  return nullptr;
5196  Stmt *ToBody = Importer.Import(S->getBody());
5197  if (!ToBody && S->getBody())
5198  return nullptr;
5199  SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5200  SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
5201  SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5202  return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
5203  ToInit, ToCondition,
5204  ToConditionVariable,
5205  ToInc, ToBody,
5206  ToForLoc, ToLParenLoc,
5207  ToRParenLoc);
5208 }
5209 
5211  LabelDecl *ToLabel = nullptr;
5212  if (LabelDecl *FromLabel = S->getLabel()) {
5213  ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
5214  if (!ToLabel)
5215  return nullptr;
5216  }
5217  SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5218  SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
5219  return new (Importer.getToContext()) GotoStmt(ToLabel,
5220  ToGotoLoc, ToLabelLoc);
5221 }
5222 
5224  SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5225  SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
5226  Expr *ToTarget = Importer.Import(S->getTarget());
5227  if (!ToTarget && S->getTarget())
5228  return nullptr;
5229  return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
5230  ToTarget);
5231 }
5232 
5234  SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
5235  return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5236 }
5237 
5239  SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
5240  return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5241 }
5242 
5244  SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
5245  Expr *ToRetExpr = Importer.Import(S->getRetValue());
5246  if (!ToRetExpr && S->getRetValue())
5247  return nullptr;
5248  auto *NRVOCandidate = const_cast<VarDecl *>(S->getNRVOCandidate());
5249  auto *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
5250  if (!ToNRVOCandidate && NRVOCandidate)
5251  return nullptr;
5252  return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
5253  ToNRVOCandidate);
5254 }
5255 
5257  SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
5258  VarDecl *ToExceptionDecl = nullptr;
5259  if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
5260  ToExceptionDecl =
5261  dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5262  if (!ToExceptionDecl)
5263  return nullptr;
5264  }
5265  Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
5266  if (!ToHandlerBlock && S->getHandlerBlock())
5267  return nullptr;
5268  return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
5269  ToExceptionDecl,
5270  ToHandlerBlock);
5271 }
5272 
5274  SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
5275  Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
5276  if (!ToTryBlock && S->getTryBlock())
5277  return nullptr;
5278  SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
5279  for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
5280  CXXCatchStmt *FromHandler = S->getHandler(HI);
5281  if (Stmt *ToHandler = Importer.Import(FromHandler))
5282  ToHandlers[HI] = ToHandler;
5283  else
5284  return nullptr;
5285  }
5286  return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
5287  ToHandlers);
5288 }
5289 
5291  auto *ToRange =
5292  dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
5293  if (!ToRange && S->getRangeStmt())
5294  return nullptr;
5295  auto *ToBegin =
5296  dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
5297  if (!ToBegin && S->getBeginStmt())
5298  return nullptr;
5299  auto *ToEnd =
5300  dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
5301  if (!ToEnd && S->getEndStmt())
5302  return nullptr;
5303  Expr *ToCond = Importer.Import(S->getCond());
5304  if (!ToCond && S->getCond())
5305  return nullptr;
5306  Expr *ToInc = Importer.Import(S->getInc());
5307  if (!ToInc && S->getInc())
5308  return nullptr;
5309  auto *ToLoopVar =
5310  dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
5311  if (!ToLoopVar && S->getLoopVarStmt())
5312  return nullptr;
5313  Stmt *ToBody = Importer.Import(S->getBody());
5314  if (!ToBody && S->getBody())
5315  return nullptr;
5316  SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5317  SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
5318  SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5319  SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5320  return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
5321  ToCond, ToInc,
5322  ToLoopVar, ToBody,
5323  ToForLoc, ToCoawaitLoc,
5324  ToColonLoc, ToRParenLoc);
5325 }
5326 
5328  Stmt *ToElem = Importer.Import(S->getElement());
5329  if (!ToElem && S->getElement())
5330  return nullptr;
5331  Expr *ToCollect = Importer.Import(S->getCollection());
5332  if (!ToCollect && S->getCollection())
5333  return nullptr;
5334  Stmt *ToBody = Importer.Import(S->getBody());
5335  if (!ToBody && S->getBody())
5336  return nullptr;
5337  SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5338  SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5339  return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
5340  ToCollect,
5341  ToBody, ToForLoc,
5342  ToRParenLoc);
5343 }
5344 
5346  SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
5347  SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5348  VarDecl *ToExceptionDecl = nullptr;
5349  if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
5350  ToExceptionDecl =
5351  dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5352  if (!ToExceptionDecl)
5353  return nullptr;
5354  }
5355  Stmt *ToBody = Importer.Import(S->getCatchBody());
5356  if (!ToBody && S->getCatchBody())
5357  return nullptr;
5358  return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
5359  ToRParenLoc,
5360  ToExceptionDecl,
5361  ToBody);
5362 }
5363 
5365  SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
5366  Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
5367  if (!ToAtFinallyStmt && S->getFinallyBody())
5368  return nullptr;
5369  return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
5370  ToAtFinallyStmt);
5371 }
5372 
5374  SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
5375  Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
5376  if (!ToAtTryStmt && S->getTryBody())
5377  return nullptr;
5378  SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
5379  for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
5380  ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
5381  if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
5382  ToCatchStmts[CI] = ToCatchStmt;
5383  else
5384  return nullptr;
5385  }
5386  Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
5387  if (!ToAtFinallyStmt && S->getFinallyStmt())
5388  return nullptr;
5389  return ObjCAtTryStmt::Create(Importer.getToContext(),
5390  ToAtTryLoc, ToAtTryStmt,
5391  ToCatchStmts.begin(), ToCatchStmts.size(),
5392  ToAtFinallyStmt);
5393 }
5394 
5397  SourceLocation ToAtSynchronizedLoc =
5398  Importer.Import(S->getAtSynchronizedLoc());
5399  Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5400  if (!ToSynchExpr && S->getSynchExpr())
5401  return nullptr;
5402  Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5403  if (!ToSynchBody && S->getSynchBody())
5404  return nullptr;
5405  return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5406  ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5407 }
5408 
5410  SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5411  Expr *ToThrow = Importer.Import(S->getThrowExpr());
5412  if (!ToThrow && S->getThrowExpr())
5413  return nullptr;
5414  return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5415 }
5416 
5419  SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5420  Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5421  if (!ToSubStmt && S->getSubStmt())
5422  return nullptr;
5423  return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5424  ToSubStmt);
5425 }
5426 
5427 //----------------------------------------------------------------------------
5428 // Import Expressions
5429 //----------------------------------------------------------------------------
5431  Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5432  << E->getStmtClassName();
5433  return nullptr;
5434 }
5435 
5437  QualType T = Importer.Import(E->getType());
5438  if (T.isNull())
5439  return nullptr;
5440 
5441  Expr *SubExpr = Importer.Import(E->getSubExpr());
5442  if (!SubExpr && E->getSubExpr())
5443  return nullptr;
5444 
5445  TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
5446  if (!TInfo)
5447  return nullptr;
5448 
5449  return new (Importer.getToContext()) VAArgExpr(
5450  Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
5451  Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5452 }
5453 
5455  QualType T = Importer.Import(E->getType());
5456  if (T.isNull())
5457  return nullptr;
5458 
5459  return new (Importer.getToContext()) GNUNullExpr(
5460  T, Importer.Import(E->getLocStart()));
5461 }
5462 
5464  QualType T = Importer.Import(E->getType());
5465  if (T.isNull())
5466  return nullptr;
5467 
5468  auto *SL = cast_or_null<StringLiteral>(Importer.Import(E->getFunctionName()));
5469  if (!SL && E->getFunctionName())
5470  return nullptr;
5471 
5472  return new (Importer.getToContext()) PredefinedExpr(
5473  Importer.Import(E->getLocStart()), T, E->getIdentType(), SL);
5474 }
5475 
5477  auto *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5478  if (!ToD)
5479  return nullptr;
5480 
5481  NamedDecl *FoundD = nullptr;
5482  if (E->getDecl() != E->getFoundDecl()) {
5483  FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5484  if (!FoundD)
5485  return nullptr;
5486  }
5487 
5488  QualType T = Importer.Import(E->getType());
5489  if (T.isNull())
5490  return nullptr;
5491 
5492  TemplateArgumentListInfo ToTAInfo;
5493  TemplateArgumentListInfo *ResInfo = nullptr;
5494  if (E->hasExplicitTemplateArgs()) {
5496  return nullptr;
5497  ResInfo = &ToTAInfo;
5498  }
5499 
5500  DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5501  Importer.Import(E->getQualifierLoc()),
5502  Importer.Import(E->getTemplateKeywordLoc()),
5503  ToD,
5505  Importer.Import(E->getLocation()),
5506  T, E->getValueKind(),
5507  FoundD, ResInfo);
5508  if (E->hadMultipleCandidates())
5509  DRE->setHadMultipleCandidates(true);
5510  return DRE;
5511 }
5512 
5514  QualType T = Importer.Import(E->getType());
5515  if (T.isNull())
5516  return nullptr;
5517 
5518  return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5519 }
5520 
5523  if (D.isFieldDesignator()) {
5524  IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
5525  // Caller checks for import error
5526  return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
5527  Importer.Import(D.getFieldLoc()));
5528  }
5529  if (D.isArrayDesignator())
5530  return Designator(D.getFirstExprIndex(),
5531  Importer.Import(D.getLBracketLoc()),
5532  Importer.Import(D.getRBracketLoc()));
5533 
5534  assert(D.isArrayRangeDesignator());
5535  return Designator(D.getFirstExprIndex(),
5536  Importer.Import(D.getLBracketLoc()),
5537  Importer.Import(D.getEllipsisLoc()),
5538  Importer.Import(D.getRBracketLoc()));
5539 }
5540 
5541 
5543  auto *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
5544  if (!Init)
5545  return nullptr;
5546 
5547  SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
5548  // List elements from the second, the first is Init itself
5549  for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
5550  if (auto *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
5551  IndexExprs[I - 1] = Arg;
5552  else
5553  return nullptr;
5554  }
5555 
5556  SmallVector<Designator, 4> Designators(DIE->size());
5557  llvm::transform(DIE->designators(), Designators.begin(),
5558  [this](const Designator &D) -> Designator {
5559  return ImportDesignator(D);
5560  });
5561 
5562  for (const auto &D : DIE->designators())
5563  if (D.isFieldDesignator() && !D.getFieldName())
5564  return nullptr;
5565 
5567  Importer.getToContext(), Designators,
5568  IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
5569  DIE->usesGNUSyntax(), Init);
5570 }
5571 
5573  QualType T = Importer.Import(E->getType());
5574  if (T.isNull())
5575  return nullptr;
5576 
5577  return new (Importer.getToContext())
5578  CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5579 }
5580 
5582  QualType T = Importer.Import(E->getType());
5583  if (T.isNull())
5584  return nullptr;
5585 
5586  return IntegerLiteral::Create(Importer.getToContext(),
5587  E->getValue(), T,
5588  Importer.Import(E->getLocation()));
5589 }
5590 
5592  QualType T = Importer.Import(E->getType());
5593  if (T.isNull())
5594  return nullptr;
5595 
5596  return FloatingLiteral::Create(Importer.getToContext(),
5597  E->getValue(), E->isExact(), T,
5598  Importer.Import(E->getLocation()));
5599 }
5600 
5602  QualType T = Importer.Import(E->getType());
5603  if (T.isNull())
5604  return nullptr;
5605 
5606  return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5607  E->getKind(), T,
5608  Importer.Import(E->getLocation()));
5609 }
5610 
5612  QualType T = Importer.Import(E->getType());
5613  if (T.isNull())
5614  return nullptr;
5615 
5617  ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
5618 
5619  return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5620  E->getKind(), E->isPascal(), T,
5621  Locations.data(), Locations.size());
5622 }
5623 
5625  QualType T = Importer.Import(E->getType());
5626  if (T.isNull())
5627  return nullptr;
5628 
5629  TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5630  if (!TInfo)
5631  return nullptr;
5632 
5633  Expr *Init = Importer.Import(E->getInitializer());
5634  if (!Init)
5635  return nullptr;
5636 
5637  return new (Importer.getToContext()) CompoundLiteralExpr(
5638  Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5639  Init, E->isFileScope());
5640 }
5641 
5643  QualType T = Importer.Import(E->getType());
5644  if (T.isNull())
5645  return nullptr;
5646 
5648  if (ImportArrayChecked(
5649  E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
5650  Exprs.begin()))
5651  return nullptr;
5652 
5653  return new (Importer.getToContext()) AtomicExpr(
5654  Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5655  Importer.Import(E->getRParenLoc()));
5656 }
5657 
5659  QualType T = Importer.Import(E->getType());
5660  if (T.isNull())
5661  return nullptr;
5662 
5663  auto *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
5664  if (!ToLabel)
5665  return nullptr;
5666 
5667  return new (Importer.getToContext()) AddrLabelExpr(
5668  Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5669  ToLabel, T);
5670 }
5671 
5673  Expr *SubExpr = Importer.Import(E->getSubExpr());
5674  if (!SubExpr)
5675  return nullptr;
5676 
5677  return new (Importer.getToContext())
5678  ParenExpr(Importer.Import(E->getLParen()),
5679  Importer.Import(E->getRParen()),
5680  SubExpr);
5681 }
5682 
5684  SmallVector<Expr *, 4> Exprs(E->getNumExprs());
5685  if (ImportContainerChecked(E->exprs(), Exprs))
5686  return nullptr;
5687 
5688  return new (Importer.getToContext()) ParenListExpr(
5689  Importer.getToContext(), Importer.Import(E->getLParenLoc()),
5690  Exprs, Importer.Import(E->getLParenLoc()));
5691 }
5692 
5694  QualType T = Importer.Import(E->getType());
5695  if (T.isNull())
5696  return nullptr;
5697 
5698  auto *ToSubStmt = cast_or_null<CompoundStmt>(
5699  Importer.Import(E->getSubStmt()));
5700  if (!ToSubStmt && E->getSubStmt())
5701  return nullptr;
5702 
5703  return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
5704  Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
5705 }
5706 
5708  QualType T = Importer.Import(E->getType());
5709  if (T.isNull())
5710  return nullptr;
5711 
5712  Expr *SubExpr = Importer.Import(E->getSubExpr());
5713  if (!SubExpr)
5714  return nullptr;
5715 
5716  return new (Importer.getToContext()) UnaryOperator(
5717  SubExpr, E->getOpcode(), T, E->getValueKind(), E->getObjectKind(),
5718  Importer.Import(E->getOperatorLoc()), E->canOverflow());
5719 }
5720 
5721 Expr *
5723  QualType ResultType = Importer.Import(E->getType());
5724 
5725  if (E->isArgumentType()) {
5726  TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
5727  if (!TInfo)
5728  return nullptr;
5729 
5730  return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5731  TInfo, ResultType,
5732  Importer.Import(E->getOperatorLoc()),
5733  Importer.Import(E->getRParenLoc()));
5734  }
5735 
5736  Expr *SubExpr = Importer.Import(E->getArgumentExpr());
5737  if (!SubExpr)
5738  return nullptr;
5739 
5740  return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5741  SubExpr, ResultType,
5742  Importer.Import(E->getOperatorLoc()),
5743  Importer.Import(E->getRParenLoc()));
5744 }
5745 
5747  QualType T = Importer.Import(E->getType());
5748  if (T.isNull())
5749  return nullptr;
5750 
5751  Expr *LHS = Importer.Import(E->getLHS());
5752  if (!LHS)
5753  return nullptr;
5754 
5755  Expr *RHS = Importer.Import(E->getRHS());
5756  if (!RHS)
5757  return nullptr;
5758 
5759  return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
5760  T, E->getValueKind(),
5761  E->getObjectKind(),
5762  Importer.Import(E->getOperatorLoc()),
5763  E->getFPFeatures());
5764 }
5765 
5767  QualType T = Importer.Import(E->getType());
5768  if (T.isNull())
5769  return nullptr;
5770 
5771  Expr *ToLHS = Importer.Import(E->getLHS());
5772  if (!ToLHS)
5773  return nullptr;
5774 
5775  Expr *ToRHS = Importer.Import(E->getRHS());
5776  if (!ToRHS)
5777  return nullptr;
5778 
5779  Expr *ToCond = Importer.Import(E->getCond());
5780  if (!ToCond)
5781  return nullptr;
5782 
5783  return new (Importer.getToContext()) ConditionalOperator(
5784  ToCond, Importer.Import(E->getQuestionLoc()),
5785  ToLHS, Importer.Import(E->getColonLoc()),
5786  ToRHS, T, E->getValueKind(), E->getObjectKind());
5787 }
5788 
5791  QualType T = Importer.Import(E->getType());
5792  if (T.isNull())
5793  return nullptr;
5794 
5795  Expr *Common = Importer.Import(E->getCommon());
5796  if (!Common)
5797  return nullptr;
5798 
5799  Expr *Cond = Importer.Import(E->getCond());
5800  if (!Cond)
5801  return nullptr;
5802 
5803  auto *OpaqueValue = cast_or_null<OpaqueValueExpr>(
5804  Importer.Import(E->getOpaqueValue()));
5805  if (!OpaqueValue)
5806  return nullptr;
5807 
5808  Expr *TrueExpr = Importer.Import(E->getTrueExpr());
5809  if (!TrueExpr)
5810  return nullptr;
5811 
5812  Expr *FalseExpr = Importer.Import(E->getFalseExpr());
5813  if (!FalseExpr)
5814  return nullptr;
5815 
5816  return new (Importer.getToContext()) BinaryConditionalOperator(
5817  Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
5818  Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
5819  T, E->getValueKind(), E->getObjectKind());
5820 }
5821 
5823  QualType T = Importer.Import(E->getType());
5824  if (T.isNull())
5825  return nullptr;
5826 
5827  TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
5828  if (!ToQueried)
5829  return nullptr;
5830 
5831  Expr *Dim = Importer.Import(E->getDimensionExpression());
5832  if (!Dim && E->getDimensionExpression())
5833  return nullptr;
5834 
5835  return new (Importer.getToContext()) ArrayTypeTraitExpr(
5836  Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
5837  E->getValue(), Dim, Importer.Import(E->getLocEnd()), T);
5838 }
5839 
5841  QualType T = Importer.Import(E->getType());
5842  if (T.isNull())
5843  return nullptr;
5844 
5845  Expr *ToQueried = Importer.Import(E->getQueriedExpression());
5846  if (!ToQueried)
5847  return nullptr;
5848 
5849  return new (Importer.getToContext()) ExpressionTraitExpr(
5850  Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
5851  E->getValue(), Importer.Import(E->getLocEnd()), T);
5852 }
5853 
5855  QualType T = Importer.Import(E->getType());
5856  if (T.isNull())
5857  return nullptr;
5858 
5859  Expr *SourceExpr = Importer.Import(E->getSourceExpr());
5860  if (!SourceExpr && E->getSourceExpr())
5861  return nullptr;
5862 
5863  return new (Importer.getToContext()) OpaqueValueExpr(
5864  Importer.Import(E->getLocation()), T, E->getValueKind(),
5865  E->getObjectKind(), SourceExpr);
5866 }
5867 
5869  QualType T = Importer.Import(E->getType());
5870  if (T.isNull())
5871  return nullptr;
5872 
5873  Expr *ToLHS = Importer.Import(E->getLHS());
5874  if (!ToLHS)
5875  return nullptr;
5876 
5877  Expr *ToRHS = Importer.Import(E->getRHS());
5878  if (!ToRHS)
5879  return nullptr;
5880 
5881  return new (Importer.getToContext()) ArraySubscriptExpr(
5882  ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
5883  Importer.Import(E->getRBracketLoc()));
5884 }
5885 
5887  QualType T = Importer.Import(E->getType());
5888  if (T.isNull())
5889  return nullptr;
5890 
5891  QualType CompLHSType = Importer.Import(E->getComputationLHSType());
5892  if (CompLHSType.isNull())
5893  return nullptr;
5894 
5895  QualType CompResultType = Importer.Import(E->getComputationResultType());
5896  if (CompResultType.isNull())
5897  return nullptr;
5898 
5899  Expr *LHS = Importer.Import(E->getLHS());
5900  if (!LHS)
5901  return nullptr;
5902 
5903  Expr *RHS = Importer.Import(E->getRHS());
5904  if (!RHS)
5905  return nullptr;
5906 
5907  return new (Importer.getToContext())
5908  CompoundAssignOperator(LHS, RHS, E->getOpcode(),
5909  T, E->getValueKind(),
5910  E->getObjectKind(),
5911  CompLHSType, CompResultType,
5912  Importer.Import(E->getOperatorLoc()),
5913  E->getFPFeatures());
5914 }
5915 
5917  for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
5918  if (CXXBaseSpecifier *Spec = Importer.Import(*I))
5919  Path.push_back(Spec);
5920  else
5921  return true;
5922  }
5923  return false;
5924 }
5925 
5927  QualType T = Importer.Import(E->getType());
5928  if (T.isNull())
5929  return nullptr;
5930 
5931  Expr *SubExpr = Importer.Import(E->getSubExpr());
5932  if (!SubExpr)
5933  return nullptr;
5934 
5935  CXXCastPath BasePath;
5936  if (ImportCastPath(E, BasePath))
5937  return nullptr;
5938 
5939  return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
5940  SubExpr, &BasePath, E->getValueKind());
5941 }
5942 
5944  QualType T = Importer.Import(E->getType());
5945  if (T.isNull())
5946  return nullptr;
5947 
5948  Expr *SubExpr = Importer.Import(E->getSubExpr());
5949  if (!SubExpr)
5950  return nullptr;
5951 
5952  TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
5953  if (!TInfo && E->getTypeInfoAsWritten())
5954  return nullptr;
5955 
5956  CXXCastPath BasePath;
5957  if (ImportCastPath(E, BasePath))
5958  return nullptr;
5959 
5960  switch (E->getStmtClass()) {
5961  case Stmt::CStyleCastExprClass: {
5962  auto *CCE = cast<CStyleCastExpr>(E);
5963  return CStyleCastExpr::Create(Importer.getToContext(), T,
5964  E->getValueKind(), E->getCastKind(),
5965  SubExpr, &BasePath, TInfo,
5966  Importer.Import(CCE->getLParenLoc()),
5967  Importer.Import(CCE->getRParenLoc()));
5968  }
5969 
5970  case Stmt::CXXFunctionalCastExprClass: {
5971  auto *FCE = cast<CXXFunctionalCastExpr>(E);
5972  return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
5973  E->getValueKind(), TInfo,
5974  E->getCastKind(), SubExpr, &BasePath,
5975  Importer.Import(FCE->getLParenLoc()),
5976  Importer.Import(FCE->getRParenLoc()));
5977  }
5978 
5979  case Stmt::ObjCBridgedCastExprClass: {
5980  auto *OCE = cast<ObjCBridgedCastExpr>(E);
5981  return new (Importer.getToContext()) ObjCBridgedCastExpr(
5982  Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
5983  E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
5984  TInfo, SubExpr);
5985  }
5986  default:
5987  break; // just fall through
5988  }
5989 
5990  auto *Named = cast<CXXNamedCastExpr>(E);
5991  SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
5992  RParenLoc = Importer.Import(Named->getRParenLoc());
5993  SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
5994 
5995  switch (E->getStmtClass()) {
5996  case Stmt::CXXStaticCastExprClass:
5997  return CXXStaticCastExpr::Create(Importer.getToContext(), T,
5998  E->getValueKind(), E->getCastKind(),
5999  SubExpr, &BasePath, TInfo,
6000  ExprLoc, RParenLoc, Brackets);
6001 
6002  case Stmt::CXXDynamicCastExprClass:
6003  return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
6004  E->getValueKind(), E->getCastKind(),
6005  SubExpr, &BasePath, TInfo,
6006  ExprLoc, RParenLoc, Brackets);
6007 
6008  case Stmt::CXXReinterpretCastExprClass:
6009  return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
6010  E->getValueKind(), E->getCastKind(),
6011  SubExpr, &BasePath, TInfo,
6012  ExprLoc, RParenLoc, Brackets);
6013 
6014  case Stmt::CXXConstCastExprClass:
6015  return CXXConstCastExpr::Create(Importer.getToContext(), T,
6016  E->getValueKind(), SubExpr, TInfo, ExprLoc,
6017  RParenLoc, Brackets);
6018  default:
6019  llvm_unreachable("Cast expression of unsupported type!");
6020  return nullptr;
6021  }
6022 }
6023 
6025  QualType T = Importer.Import(OE->getType());
6026  if (T.isNull())
6027  return nullptr;
6028 
6030  for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
6031  const OffsetOfNode &Node = OE->getComponent(I);
6032 
6033  switch (Node.getKind()) {
6034  case OffsetOfNode::Array:
6035  Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()),
6036  Node.getArrayExprIndex(),
6037  Importer.Import(Node.getLocEnd())));
6038  break;
6039 
6040  case OffsetOfNode::Base: {
6041  CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
6042  if (!BS && Node.getBase())
6043  return nullptr;
6044  Nodes.push_back(OffsetOfNode(BS));
6045  break;
6046  }
6047  case OffsetOfNode::Field: {
6048  auto *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
6049  if (!FD)
6050  return nullptr;
6051  Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
6052  Importer.Import(Node.getLocEnd())));
6053  break;
6054  }
6055  case OffsetOfNode::Identifier: {
6056  IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
6057  if (!ToII)
6058  return nullptr;
6059  Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII,
6060  Importer.Import(Node.getLocEnd())));
6061  break;
6062  }
6063  }
6064  }
6065 
6067  for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) {
6068  Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I));
6069  if (!ToIndexExpr)
6070  return nullptr;
6071  Exprs[I] = ToIndexExpr;
6072  }
6073 
6074  TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo());
6075  if (!TInfo && OE->getTypeSourceInfo())
6076  return nullptr;
6077 
6078  return OffsetOfExpr::Create(Importer.getToContext(), T,
6079  Importer.Import(OE->getOperatorLoc()),
6080  TInfo, Nodes, Exprs,
6081  Importer.Import(OE->getRParenLoc()));
6082 }
6083 
6085  QualType T = Importer.Import(E->getType());
6086  if (T.isNull())
6087  return nullptr;
6088 
6089  Expr *Operand = Importer.Import(E->getOperand());
6090  if (!Operand)
6091  return nullptr;
6092 
6094  if (E->isValueDependent())
6095  CanThrow = CT_Dependent;
6096  else
6097  CanThrow = E->getValue() ? CT_Can : CT_Cannot;
6098 
6099  return new (Importer.getToContext()) CXXNoexceptExpr(
6100  T, Operand, CanThrow,
6101  Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd()));
6102 }
6103 
6105  QualType T = Importer.Import(E->getType());
6106  if (T.isNull())
6107  return nullptr;
6108 
6109  Expr *SubExpr = Importer.Import(E->getSubExpr());
6110  if (!SubExpr && E->getSubExpr())
6111  return nullptr;
6112 
6113  return new (Importer.getToContext()) CXXThrowExpr(
6114  SubExpr, T, Importer.Import(E->getThrowLoc()),
6116 }
6117 
6119  auto *Param = cast_or_null<ParmVarDecl>(Importer.Import(E->getParam()));
6120  if (!Param)
6121  return nullptr;
6122 
6124  Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
6125 }
6126 
6128  QualType T = Importer.Import(E->getType());
6129  if (T.isNull())
6130  return nullptr;
6131 
6132  TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
6133  if (!TypeInfo)
6134  return nullptr;
6135 
6136  return new (Importer.getToContext()) CXXScalarValueInitExpr(
6137  T, TypeInfo, Importer.Import(E->getRParenLoc()));
6138 }
6139 
6141  Expr *SubExpr = Importer.Import(E->getSubExpr());
6142  if (!SubExpr)
6143  return nullptr;
6144 
6145  auto *Dtor = cast_or_null<CXXDestructorDecl>(
6146  Importer.Import(const_cast<CXXDestructorDecl *>(
6147  E->getTemporary()->getDestructor())));
6148  if (!Dtor)
6149  return nullptr;
6150 
6151  ASTContext &ToCtx = Importer.getToContext();
6152  CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
6153  return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
6154 }
6155 
6157  QualType T = Importer.Import(CE->getType());
6158  if (T.isNull())
6159  return nullptr;
6160 
6161  TypeSourceInfo *TInfo = Importer.Import(CE->getTypeSourceInfo());
6162  if (!TInfo)
6163  return nullptr;
6164 
6165  SmallVector<Expr *, 8> Args(CE->getNumArgs());
6166  if (ImportContainerChecked(CE->arguments(), Args))
6167  return nullptr;
6168 
6169  auto *Ctor = cast_or_null<CXXConstructorDecl>(
6170  Importer.Import(CE->getConstructor()));
6171  if (!Ctor)
6172  return nullptr;
6173 
6174  return new (Importer.getToContext()) CXXTemporaryObjectExpr(
6175  Importer.getToContext(), Ctor, T, TInfo, Args,
6176  Importer.Import(CE->getParenOrBraceRange()), CE->hadMultipleCandidates(),
6179 }
6180 
6181 Expr *
6183  QualType T = Importer.Import(E->getType());
6184  if (T.isNull())
6185  return nullptr;
6186 
6187  Expr *TempE = Importer.Import(E->GetTemporaryExpr());
6188  if (!TempE)
6189  return nullptr;
6190 
6191  auto *ExtendedBy = cast_or_null<ValueDecl>(
6192  Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
6193  if (!ExtendedBy && E->getExtendingDecl())
6194  return nullptr;
6195 
6196  auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
6197  T, TempE, E->isBoundToLvalueReference());
6198 
6199  // FIXME: Should ManglingNumber get numbers associated with 'to' context?
6200  ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
6201  return ToMTE;
6202 }
6203 
6205  QualType T = Importer.Import(E->getType());
6206  if (T.isNull())
6207  return nullptr;
6208 
6209  Expr *Pattern = Importer.Import(E->getPattern());
6210  if (!Pattern)
6211  return nullptr;
6212 
6213  return new (Importer.getToContext()) PackExpansionExpr(
6214  T, Pattern, Importer.Import(E->getEllipsisLoc()),
6215  E->getNumExpansions());
6216 }
6217 
6219  auto *Pack = cast_or_null<NamedDecl>(Importer.Import(E->getPack()));
6220  if (!Pack)
6221  return nullptr;
6222 
6223  Optional<unsigned> Length;
6224 
6225  if (!E->isValueDependent())
6226  Length = E->getPackLength();
6227 
6228  SmallVector<TemplateArgument, 8> PartialArguments;
6229  if (E->isPartiallySubstituted()) {
6231  E->getPartialArguments().size(),
6232  PartialArguments))
6233  return nullptr;
6234  }
6235 
6236  return SizeOfPackExpr::Create(
6237  Importer.getToContext(), Importer.Import(E->getOperatorLoc()), Pack,
6238  Importer.Import(E->getPackLoc()), Importer.Import(E->getRParenLoc()),
6239  Length, PartialArguments);
6240 }
6241 
6243  QualType T = Importer.Import(CE->getType());
6244  if (T.isNull())
6245  return nullptr;
6246 
6247  SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
6248  if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
6249  return nullptr;
6250 
6251  auto *OperatorNewDecl = cast_or_null<FunctionDecl>(
6252  Importer.Import(CE->getOperatorNew()));
6253  if (!OperatorNewDecl && CE->getOperatorNew())
6254  return nullptr;
6255 
6256  auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6257  Importer.Import(CE->getOperatorDelete()));
6258  if (!OperatorDeleteDecl && CE->getOperatorDelete())
6259  return nullptr;
6260 
6261  Expr *ToInit = Importer.Import(CE->getInitializer());
6262  if (!ToInit && CE->getInitializer())
6263  return nullptr;
6264 
6265  TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
6266  if (!TInfo)
6267  return nullptr;
6268 
6269  Expr *ToArrSize = Importer.Import(CE->getArraySize());
6270  if (!ToArrSize && CE->getArraySize())
6271  return nullptr;
6272 
6273  return new (Importer.getToContext()) CXXNewExpr(
6274  Importer.getToContext(),
6275  CE->isGlobalNew(),
6276  OperatorNewDecl, OperatorDeleteDecl,
6277  CE->passAlignment(),
6279  PlacementArgs,
6280  Importer.Import(CE->getTypeIdParens()),
6281  ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
6282  Importer.Import(CE->getSourceRange()),
6283  Importer.Import(CE->getDirectInitRange()));
6284 }
6285 
6287  QualType T = Importer.Import(E->getType());
6288  if (T.isNull())
6289  return nullptr;
6290 
6291  auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6292  Importer.Import(E->getOperatorDelete()));
6293  if (!OperatorDeleteDecl && E->getOperatorDelete())
6294  return nullptr;
6295 
6296  Expr *ToArg = Importer.Import(E->getArgument());
6297  if (!ToArg && E->getArgument())
6298  return nullptr;
6299 
6300  return new (Importer.getToContext()) CXXDeleteExpr(
6301  T, E->isGlobalDelete(),
6302  E->isArrayForm(),
6303  E->isArrayFormAsWritten(),
6305  OperatorDeleteDecl,
6306  ToArg,
6307  Importer.Import(E->getLocStart()));
6308 }
6309 
6311  QualType T = Importer.Import(E->getType());
6312  if (T.isNull())
6313  return nullptr;
6314 
6315  auto *ToCCD =
6316  dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
6317  if (!ToCCD)
6318  return nullptr;
6319 
6320  SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
6321  if (ImportContainerChecked(E->arguments(), ToArgs))
6322  return nullptr;
6323 
6324  return CXXConstructExpr::Create(Importer.getToContext(), T,
6325  Importer.Import(E->getLocation()),
6326  ToCCD, E->isElidable(),
6327  ToArgs, E->hadMultipleCandidates(),
6328  E->isListInitialization(),
6331  E->getConstructionKind(),
6332  Importer.Import(E->getParenOrBraceRange()));
6333 }
6334 
6336  Expr *SubExpr = Importer.Import(EWC->getSubExpr());
6337  if (!SubExpr && EWC->getSubExpr())
6338  return nullptr;
6339 
6341  for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
6343  cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
6344  Objs[I] = Obj;
6345  else
6346  return nullptr;
6347 
6348  return ExprWithCleanups::Create(Importer.getToContext(),
6349  SubExpr, EWC->cleanupsHaveSideEffects(),
6350  Objs);
6351 }
6352 
6354  QualType T = Importer.Import(E->getType());
6355  if (T.isNull())
6356  return nullptr;
6357 
6358  Expr *ToFn = Importer.Import(E->getCallee());
6359  if (!ToFn)
6360  return nullptr;
6361 
6362  SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
6363  if (ImportContainerChecked(E->arguments(), ToArgs))
6364  return nullptr;
6365 
6366  return new (Importer.getToContext()) CXXMemberCallExpr(
6367  Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
6368  Importer.Import(E->getRParenLoc()));
6369 }
6370 
6372  QualType T = Importer.Import(E->getType());
6373  if (T.isNull())
6374  return nullptr;
6375 
6376  return new (Importer.getToContext())
6377  CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
6378 }
6379 
6381  QualType T = Importer.Import(E->getType());
6382  if (T.isNull())
6383  return nullptr;
6384 
6385  return new (Importer.getToContext())
6386  CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
6387 }
6388 
6389 
6391  QualType T = Importer.Import(E->getType());
6392  if (T.isNull())
6393  return nullptr;
6394 
6395  Expr *ToBase = Importer.Import(E->getBase());
6396  if (!ToBase && E->getBase())
6397  return nullptr;
6398 
6399  auto *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
6400  if (!ToMember && E->getMemberDecl())
6401  return nullptr;
6402 
6403  auto *ToDecl =
6404  dyn_cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl()));
6405  if (!ToDecl && E->getFoundDecl().getDecl())
6406  return nullptr;
6407 
6408  DeclAccessPair ToFoundDecl =
6410 
6411  DeclarationNameInfo ToMemberNameInfo(
6412  Importer.Import(E->getMemberNameInfo().getName()),
6413  Importer.Import(E->getMemberNameInfo().getLoc()));
6414 
6415  if (E->hasExplicitTemplateArgs()) {
6416  return nullptr; // FIXME: handle template arguments
6417  }
6418 
6419  return MemberExpr::Create(Importer.getToContext(), ToBase,
6420  E->isArrow(),
6421  Importer.Import(E->getOperatorLoc()),
6422  Importer.Import(E->getQualifierLoc()),
6423  Importer.Import(E->getTemplateKeywordLoc()),
6424  ToMember, ToFoundDecl, ToMemberNameInfo,
6425  nullptr, T, E->getValueKind(),
6426  E->getObjectKind());
6427 }
6428 
6431  Expr *BaseE = Importer.Import(E->getBase());
6432  if (!BaseE)
6433  return nullptr;
6434 
6435  TypeSourceInfo *ScopeInfo = Importer.Import(E->getScopeTypeInfo());
6436  if (!ScopeInfo && E->getScopeTypeInfo())
6437  return nullptr;
6438 
6440  if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
6441  IdentifierInfo *ToII = Importer.Import(FromII);
6442  if (!ToII)
6443  return nullptr;
6444  Storage = PseudoDestructorTypeStorage(
6445  ToII, Importer.Import(E->getDestroyedTypeLoc()));
6446  } else {
6447  TypeSourceInfo *TI = Importer.Import(E->getDestroyedTypeInfo());
6448  if (!TI)
6449  return nullptr;
6450  Storage = PseudoDestructorTypeStorage(TI);
6451  }
6452 
6453  return new (Importer.getToContext()) CXXPseudoDestructorExpr(
6454  Importer.getToContext(), BaseE, E->isArrow(),
6455  Importer.Import(E->getOperatorLoc()),
6456  Importer.Import(E->getQualifierLoc()),
6457  ScopeInfo, Importer.Import(E->getColonColonLoc()),
6458  Importer.Import(E->getTildeLoc()), Storage);
6459 }
6460 
6463  Expr *Base = nullptr;
6464  if (!E->isImplicitAccess()) {
6465  Base = Importer.Import(E->getBase());
6466  if (!Base)
6467  return nullptr;
6468  }
6469 
6470  QualType BaseType = Importer.Import(E->getBaseType());
6471  if (BaseType.isNull())
6472  return nullptr;
6473 
6474  TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
6475  if (E->hasExplicitTemplateArgs()) {
6477  E->template_arguments(), ToTAInfo))
6478  return nullptr;
6479  ResInfo = &ToTAInfo;
6480  }
6481 
6482  DeclarationName Name = Importer.Import(E->getMember());
6483  if (!E->getMember().isEmpty() && Name.isEmpty())
6484  return nullptr;
6485 
6486  DeclarationNameInfo MemberNameInfo(Name, Importer.Import(E->getMemberLoc()));
6487  // Import additional name location/type info.
6488  ImportDeclarationNameLoc(E->getMemberNameInfo(), MemberNameInfo);
6489  auto ToFQ = Importer.Import(E->getFirstQualifierFoundInScope());
6490  if (!ToFQ && E->getFirstQualifierFoundInScope())
6491  return nullptr;
6492 
6494  Importer.getToContext(), Base, BaseType, E->isArrow(),
6495  Importer.Import(E->getOperatorLoc()),
6496  Importer.Import(E->getQualifierLoc()),
6497  Importer.Import(E->getTemplateKeywordLoc()),
6498  cast_or_null<NamedDecl>(ToFQ), MemberNameInfo, ResInfo);
6499 }
6500 
6501 Expr *
6503  DeclarationName Name = Importer.Import(E->getDeclName());
6504  if (!E->getDeclName().isEmpty() && Name.isEmpty())
6505  return nullptr;
6506 
6507  DeclarationNameInfo NameInfo(Name, Importer.Import(E->getExprLoc()));
6508  ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
6509 
6510  TemplateArgumentListInfo ToTAInfo(Importer.Import(E->getLAngleLoc()),
6511  Importer.Import(E->getRAngleLoc()));
6512  TemplateArgumentListInfo *ResInfo = nullptr;
6513  if (E->hasExplicitTemplateArgs()) {
6515  return nullptr;
6516  ResInfo = &ToTAInfo;
6517  }
6518 
6520  Importer.getToContext(), Importer.Import(E->getQualifierLoc()),
6521  Importer.Import(E->getTemplateKeywordLoc()), NameInfo, ResInfo);
6522 }
6523 
6526  unsigned NumArgs = CE->arg_size();
6527 
6528  SmallVector<Expr *, 8> ToArgs(NumArgs);
6529  if (ImportArrayChecked(CE->arg_begin(), CE->arg_end(), ToArgs.begin()))
6530  return nullptr;
6531 
6533  Importer.getToContext(), Importer.Import(CE->getTypeSourceInfo()),
6534  Importer.Import(CE->getLParenLoc()), llvm::makeArrayRef(ToArgs),
6535  Importer.Import(CE->getRParenLoc()));
6536 }
6537 
6539  auto *NamingClass =
6540  cast_or_null<CXXRecordDecl>(Importer.Import(E->getNamingClass()));
6541  if (E->getNamingClass() && !NamingClass)
6542  return nullptr;
6543 
6544  DeclarationName Name = Importer.Import(E->getName());
6545  if (E->getName() && !Name)
6546  return nullptr;
6547 
6548  DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
6549  // Import additional name location/type info.
6550  ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
6551 
6552  UnresolvedSet<8> ToDecls;
6553  for (auto *D : E->decls()) {
6554  if (auto *To = cast_or_null<NamedDecl>(Importer.Import(D)))
6555  ToDecls.addDecl(To);
6556  else
6557  return nullptr;
6558  }
6559 
6560  TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
6561  if (E->hasExplicitTemplateArgs()) {
6563  E->template_arguments(), ToTAInfo))
6564  return nullptr;
6565  ResInfo = &ToTAInfo;
6566  }
6567 
6568  if (ResInfo || E->getTemplateKeywordLoc().isValid())
6570  Importer.getToContext(), NamingClass,
6571  Importer.Import(E->getQualifierLoc()),
6572  Importer.Import(E->getTemplateKeywordLoc()), NameInfo, E->requiresADL(),
6573  ResInfo, ToDecls.begin(), ToDecls.end());
6574 
6576  Importer.getToContext(), NamingClass,
6577  Importer.Import(E->getQualifierLoc()), NameInfo, E->requiresADL(),
6578  E->isOverloaded(), ToDecls.begin(), ToDecls.end());
6579 }
6580 
6582  DeclarationName Name = Importer.Import(E->getName());
6583  if (!E->getName().isEmpty() && Name.isEmpty())
6584  return nullptr;
6585  DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
6586  // Import additional name location/type info.
6587  ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
6588 
6589  QualType BaseType = Importer.Import(E->getType());
6590  if (!E->getType().isNull() && BaseType.isNull())
6591  return nullptr;
6592 
6593  UnresolvedSet<8> ToDecls;
6594  for (Decl *D : E->decls()) {
6595  if (NamedDecl *To = cast_or_null<NamedDecl>(Importer.Import(D)))
6596  ToDecls.addDecl(To);
6597  else
6598  return nullptr;
6599  }
6600 
6601  TemplateArgumentListInfo ToTAInfo;
6602  TemplateArgumentListInfo *ResInfo = nullptr;
6603  if (E->hasExplicitTemplateArgs()) {
6605  return nullptr;
6606  ResInfo = &ToTAInfo;
6607  }
6608 
6609  Expr *BaseE = E->isImplicitAccess() ? nullptr : Importer.Import(E->getBase());
6610  if (!BaseE && !E->isImplicitAccess() && E->getBase()) {
6611  return nullptr;
6612  }
6613 
6615  Importer.getToContext(), E->hasUnresolvedUsing(), BaseE, BaseType,
6616  E->isArrow(), Importer.Import(E->getOperatorLoc()),
6617  Importer.Import(E->getQualifierLoc()),
6618  Importer.Import(E->getTemplateKeywordLoc()), NameInfo, ResInfo,
6619  ToDecls.begin(), ToDecls.end());
6620 }
6621 
6623  QualType T = Importer.Import(E->getType());
6624  if (T.isNull())
6625  return nullptr;
6626 
6627  Expr *ToCallee = Importer.Import(E->getCallee());
6628  if (!ToCallee && E->getCallee())
6629  return nullptr;
6630 
6631  unsigned NumArgs = E->getNumArgs();
6632  SmallVector<Expr *, 2> ToArgs(NumArgs);
6633  if (ImportContainerChecked(E->arguments(), ToArgs))
6634  return nullptr;
6635 
6636  auto **ToArgs_Copied = new (Importer.getToContext()) Expr*[NumArgs];
6637 
6638  for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
6639  ToArgs_Copied[ai] = ToArgs[ai];
6640 
6641  if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
6642  return new (Importer.getToContext()) CXXOperatorCallExpr(
6643  Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, T,
6644  OCE->getValueKind(), Importer.Import(OCE->getRParenLoc()),
6645  OCE->getFPFeatures());
6646  }
6647 
6648  return new (Importer.getToContext())
6649  CallExpr(Importer.getToContext(), ToCallee,
6650  llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
6651  Importer.Import(E->getRParenLoc()));
6652 }
6653 
6656  VarDecl *Var = nullptr;
6657  if (From.capturesVariable()) {
6658  Var = cast_or_null<VarDecl>(Importer.Import(From.getCapturedVar()));
6659  if (!Var)
6660  return None;
6661  }
6662 
6663  return LambdaCapture(Importer.Import(From.getLocation()), From.isImplicit(),
6664  From.getCaptureKind(), Var,
6665  From.isPackExpansion()
6666  ? Importer.Import(From.getEllipsisLoc())
6667  : SourceLocation());
6668 }
6669 
6671  CXXRecordDecl *FromClass = LE->getLambdaClass();
6672  auto *ToClass = dyn_cast_or_null<CXXRecordDecl>(Importer.Import(FromClass));
6673  if (!ToClass)
6674  return nullptr;
6675 
6676  // NOTE: lambda classes are created with BeingDefined flag set up.
6677  // It means that ImportDefinition doesn't work for them and we should fill it
6678  // manually.
6679  if (ToClass->isBeingDefined()) {
6680  for (auto FromField : FromClass->fields()) {
6681  auto *ToField = cast_or_null<FieldDecl>(Importer.Import(FromField));
6682  if (!ToField)
6683  return nullptr;
6684  }
6685  }
6686 
6687  auto *ToCallOp = dyn_cast_or_null<CXXMethodDecl>(
6688  Importer.Import(LE->getCallOperator()));
6689  if (!ToCallOp)
6690  return nullptr;
6691 
6692  ToClass->completeDefinition();
6693 
6694  unsigned NumCaptures = LE->capture_size();
6696  Captures.reserve(NumCaptures);
6697  for (const auto &FromCapture : LE->captures()) {
6698  if (auto ToCapture = ImportLambdaCapture(FromCapture))
6699  Captures.push_back(*ToCapture);
6700  else
6701  return nullptr;
6702  }
6703 
6704  SmallVector<Expr *, 8> InitCaptures(NumCaptures);
6705  if (ImportContainerChecked(LE->capture_inits(), InitCaptures))
6706  return nullptr;
6707 
6708  return LambdaExpr::Create(Importer.getToContext(), ToClass,
6709  Importer.Import(LE->getIntroducerRange()),
6710  LE->getCaptureDefault(),
6711  Importer.Import(LE->getCaptureDefaultLoc()),
6712  Captures,
6713  LE->hasExplicitParameters(),
6714  LE->hasExplicitResultType(),
6715  InitCaptures,
6716  Importer.Import(LE->getLocEnd()),
6718 }
6719 
6721  QualType T = Importer.Import(ILE->getType());
6722  if (T.isNull())
6723  return nullptr;
6724 
6725  SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
6726  if (ImportContainerChecked(ILE->inits(), Exprs))
6727  return nullptr;
6728 
6729  ASTContext &ToCtx = Importer.getToContext();
6730  InitListExpr *To = new (ToCtx) InitListExpr(
6731  ToCtx, Importer.Import(ILE->getLBraceLoc()),
6732  Exprs, Importer.Import(ILE->getLBraceLoc()));
6733  To->setType(T);
6734 
6735  if (ILE->hasArrayFiller()) {
6736  Expr *Filler = Importer.Import(ILE->getArrayFiller());
6737  if (!Filler)
6738  return nullptr;
6739  To->setArrayFiller(Filler);
6740  }
6741 
6742  if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
6743  auto *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
6744  if (!ToFD)
6745  return nullptr;
6746  To->setInitializedFieldInUnion(ToFD);
6747  }
6748 
6749  if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
6750  auto *ToSyntForm = cast_or_null<InitListExpr>(Importer.Import(SyntForm));
6751  if (!ToSyntForm)
6752  return nullptr;
6753  To->setSyntacticForm(ToSyntForm);
6754  }
6755 
6757  To->setValueDependent(ILE->isValueDependent());
6759 
6760  return To;
6761 }
6762 
6765  QualType T = Importer.Import(E->getType());
6766  if (T.isNull())
6767  return nullptr;
6768 
6769  Expr *SE = Importer.Import(E->getSubExpr());
6770  if (!SE)
6771  return nullptr;
6772 
6773  return new (Importer.getToContext()) CXXStdInitializerListExpr(T, SE);
6774 }
6775 
6778  QualType T = Importer.Import(E->getType());
6779  if (T.isNull())
6780  return nullptr;
6781 
6782  auto *Ctor = cast_or_null<CXXConstructorDecl>(Importer.Import(
6783  E->getConstructor()));
6784  if (!Ctor)
6785  return nullptr;
6786 
6787  return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
6788  Importer.Import(E->getLocation()), T, Ctor,
6789  E->constructsVBase(), E->inheritedFromVBase());
6790 }
6791 
6793  QualType ToType = Importer.Import(E->getType());
6794  if (ToType.isNull())
6795  return nullptr;
6796 
6797  Expr *ToCommon = Importer.Import(E->getCommonExpr());
6798  if (!ToCommon && E->getCommonExpr())
6799  return nullptr;
6800 
6801  Expr *ToSubExpr = Importer.Import(E->getSubExpr());
6802  if (!ToSubExpr && E->getSubExpr())
6803  return nullptr;
6804 
6805  return new (Importer.getToContext())
6806  ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr);
6807 }
6808 
6810  QualType ToType = Importer.Import(E->getType());
6811  if (ToType.isNull())
6812  return nullptr;
6813  return new (Importer.getToContext()) ArrayInitIndexExpr(ToType);
6814 }
6815 
6817  auto *ToField = dyn_cast_or_null<FieldDecl>(Importer.Import(DIE->getField()));
6818  if (!ToField && DIE->getField())
6819  return nullptr;
6820 
6822  Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField);
6823 }
6824 
6826  QualType ToType = Importer.Import(E->getType());
6827  if (ToType.isNull() && !E->getType().isNull())
6828  return nullptr;
6829  ExprValueKind VK = E->getValueKind();
6830  CastKind CK = E->getCastKind();
6831  Expr *ToOp = Importer.Import(E->getSubExpr());
6832  if (!ToOp && E->getSubExpr())
6833  return nullptr;
6834  CXXCastPath BasePath;
6835  if (ImportCastPath(E, BasePath))
6836  return nullptr;
6837  TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten());
6838  SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc());
6839  SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc());
6840  SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets());
6841 
6842  if (isa<CXXStaticCastExpr>(E)) {
6844  Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6845  ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6846  } else if (isa<CXXDynamicCastExpr>(E)) {
6848  Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6849  ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6850  } else if (isa<CXXReinterpretCastExpr>(E)) {
6852  Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6853  ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6854  } else {
6855  return nullptr;
6856  }
6857 }
6858 
6861  QualType T = Importer.Import(E->getType());
6862  if (T.isNull())
6863  return nullptr;
6864 
6865  auto *Param = cast_or_null<NonTypeTemplateParmDecl>(
6866  Importer.Import(E->getParameter()));
6867  if (!Param)
6868  return nullptr;
6869 
6870  Expr *Replacement = Importer.Import(E->getReplacement());
6871  if (!Replacement)
6872  return nullptr;
6873 
6874  return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
6875  T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param,
6876  Replacement);
6877 }
6878 
6880  QualType ToType = Importer.Import(E->getType());
6881  if (ToType.isNull())
6882  return nullptr;
6883 
6885  if (ImportContainerChecked(E->getArgs(), ToArgs))
6886  return nullptr;
6887 
6888  // According to Sema::BuildTypeTrait(), if E is value-dependent,
6889  // Value is always false.
6890  bool ToValue = false;
6891  if (!E->isValueDependent())
6892  ToValue = E->getValue();
6893 
6894  return TypeTraitExpr::Create(
6895  Importer.getToContext(), ToType, Importer.Import(E->getLocStart()),
6896  E->getTrait(), ToArgs, Importer.Import(E->getLocEnd()), ToValue);
6897 }
6898 
6900  QualType ToType = Importer.Import(E->getType());
6901  if (ToType.isNull())
6902  return nullptr;
6903 
6904  if (E->isTypeOperand()) {
6905  TypeSourceInfo *TSI = Importer.Import(E->getTypeOperandSourceInfo());
6906  if (!TSI)
6907  return nullptr;
6908 
6909  return new (Importer.getToContext())
6910  CXXTypeidExpr(ToType, TSI, Importer.Import(E->getSourceRange()));
6911  }
6912 
6913  Expr *Op = Importer.Import(E->getExprOperand());
6914  if (!Op)
6915  return nullptr;
6916 
6917  return new (Importer.getToContext())
6918  CXXTypeidExpr(ToType, Op, Importer.Import(E->getSourceRange()));
6919 }
6920 
6922  CXXMethodDecl *FromMethod) {
6923  for (auto *FromOverriddenMethod : FromMethod->overridden_methods())
6924  ToMethod->addOverriddenMethod(
6925  cast<CXXMethodDecl>(Importer.Import(const_cast<CXXMethodDecl*>(
6926  FromOverriddenMethod))));
6927 }
6928 
6930  ASTContext &FromContext, FileManager &FromFileManager,
6931  bool MinimalImport)
6932  : ToContext(ToContext), FromContext(FromContext),
6933  ToFileManager(ToFileManager), FromFileManager(FromFileManager),
6934  Minimal(MinimalImport) {
6935  ImportedDecls[FromContext.getTranslationUnitDecl()]
6936  = ToContext.getTranslationUnitDecl();
6937 }
6938 
6939 ASTImporter::~ASTImporter() = default;
6940 
6942  if (FromT.isNull())
6943  return {};
6944 
6945  const Type *fromTy = FromT.getTypePtr();
6946 
6947  // Check whether we've already imported this type.
6948  llvm::DenseMap<const Type *, const Type *>::iterator Pos
6949  = ImportedTypes.find(fromTy);
6950  if (Pos != ImportedTypes.end())
6951  return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
6952 
6953  // Import the type
6954  ASTNodeImporter Importer(*this);
6955  QualType ToT = Importer.Visit(fromTy);
6956  if (ToT.isNull())
6957  return ToT;
6958 
6959  // Record the imported type.
6960  ImportedTypes[fromTy] = ToT.getTypePtr();
6961 
6962  return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
6963 }
6964 
6966  if (!FromTSI)
6967  return FromTSI;
6968 
6969  // FIXME: For now we just create a "trivial" type source info based
6970  // on the type and a single location. Implement a real version of this.
6971  QualType T = Import(FromTSI->getType());
6972  if (T.isNull())
6973  return nullptr;
6974 
6975  return ToContext.getTrivialTypeSourceInfo(T,
6976  Import(FromTSI->getTypeLoc().getLocStart()));
6977 }
6978 
6979 Attr *ASTImporter::Import(const Attr *FromAttr) {
6980  Attr *ToAttr = FromAttr->clone(ToContext);
6981  ToAttr->setRange(Import(FromAttr->getRange()));
6982  return ToAttr;
6983 }
6984 
6986  llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6987  if (Pos != ImportedDecls.end()) {
6988  Decl *ToD = Pos->second;
6989  // FIXME: move this call to ImportDeclParts().
6990  ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
6991  return ToD;
6992  } else {
6993  return nullptr;
6994  }
6995 }
6996 
6998  if (!FromD)
6999  return nullptr;
7000 
7001  ASTNodeImporter Importer(*this);
7002 
7003  // Check whether we've already imported this declaration.
7004  Decl *ToD = GetAlreadyImportedOrNull(FromD);
7005  if (ToD) {
7006  // If FromD has some updated flags after last import, apply it
7007  updateFlags(FromD, ToD);
7008  return ToD;
7009  }
7010 
7011  // Import the type.
7012  ToD = Importer.Visit(FromD);
7013  if (!ToD)
7014  return nullptr;
7015 
7016  // Notify subclasses.
7017  Imported(FromD, ToD);
7018 
7019  return ToD;
7020 }
7021 
7023  if (!FromDC)
7024  return FromDC;
7025 
7026  auto *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
7027  if (!ToDC)
7028  return nullptr;
7029 
7030  // When we're using a record/enum/Objective-C class/protocol as a context, we
7031  // need it to have a definition.
7032  if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
7033  auto *FromRecord = cast<RecordDecl>(FromDC);
7034  if (ToRecord->isCompleteDefinition()) {
7035  // Do nothing.
7036  } else if (FromRecord->isCompleteDefinition()) {
7037  ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
7039  } else {
7040  CompleteDecl(ToRecord);
7041  }
7042  } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
7043  auto *FromEnum = cast<EnumDecl>(FromDC);
7044  if (ToEnum->isCompleteDefinition()) {
7045  // Do nothing.
7046  } else if (FromEnum->isCompleteDefinition()) {
7047  ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
7049  } else {
7050  CompleteDecl(ToEnum);
7051  }
7052  } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
7053  auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
7054  if (ToClass->getDefinition()) {
7055  // Do nothing.
7056  } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
7057  ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
7059  } else {
7060  CompleteDecl(ToClass);
7061  }
7062  } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
7063  auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
7064  if (ToProto->getDefinition()) {
7065  // Do nothing.
7066  } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
7067  ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
7069  } else {
7070  CompleteDecl(ToProto);
7071  }
7072  }
7073 
7074  return ToDC;
7075 }
7076 
7078  if (!FromE)
7079  return nullptr;
7080 
7081  return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
7082 }
7083 
7085  if (!FromS)
7086  return nullptr;
7087 
7088  // Check whether we've already imported this declaration.
7089  llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
7090  if (Pos != ImportedStmts.end())
7091  return Pos->second;
7092 
7093  // Import the type
7094  ASTNodeImporter Importer(*this);
7095  Stmt *ToS = Importer.Visit(FromS);
7096  if (!ToS)
7097  return nullptr;
7098 
7099  // Record the imported declaration.
7100  ImportedStmts[FromS] = ToS;
7101  return ToS;
7102 }
7103 
7105  if (!FromNNS)
7106  return nullptr;
7107 
7108  NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
7109 
7110  switch (FromNNS->getKind()) {
7112  if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
7113  return NestedNameSpecifier::Create(ToContext, prefix, II);
7114  }
7115  return nullptr;
7116 
7118  if (auto *NS =
7119  cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
7120  return NestedNameSpecifier::Create(ToContext, prefix, NS);
7121  }
7122  return nullptr;
7123 
7125  if (auto *NSAD =
7126  cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
7127  return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
7128  }
7129  return nullptr;
7130 
7132  return NestedNameSpecifier::GlobalSpecifier(ToContext);
7133 
7135  if (auto *RD =
7136  cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
7137  return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
7138  }
7139  return nullptr;
7140 
7143  QualType T = Import(QualType(FromNNS->getAsType(), 0u));
7144  if (!T.isNull()) {
7145  bool bTemplate = FromNNS->getKind() ==
7147  return NestedNameSpecifier::Create(ToContext, prefix,
7148  bTemplate, T.getTypePtr());
7149  }
7150  }
7151  return nullptr;
7152  }
7153 
7154  llvm_unreachable("Invalid nested name specifier kind");
7155 }
7156 
7158  // Copied from NestedNameSpecifier mostly.
7160  NestedNameSpecifierLoc NNS = FromNNS;
7161 
7162  // Push each of the nested-name-specifiers's onto a stack for
7163  // serialization in reverse order.
7164  while (NNS) {
7165  NestedNames.push_back(NNS);
7166  NNS = NNS.getPrefix();
7167  }
7168 
7170 
7171  while (!NestedNames.empty()) {
7172  NNS = NestedNames.pop_back_val();
7174  if (!Spec)
7175  return NestedNameSpecifierLoc();
7176 
7178  switch (Kind) {
7180  Builder.Extend(getToContext(),
7181  Spec->getAsIdentifier(),
7182  Import(NNS.getLocalBeginLoc()),
7183  Import(NNS.getLocalEndLoc()));
7184  break;
7185 
7187  Builder.Extend(getToContext(),
7188  Spec->getAsNamespace(),
7189  Import(NNS.getLocalBeginLoc()),
7190  Import(NNS.getLocalEndLoc()));
7191  break;
7192 
7194  Builder.Extend(getToContext(),
7195  Spec->getAsNamespaceAlias(),
7196  Import(NNS.getLocalBeginLoc()),
7197  Import(NNS.getLocalEndLoc()));
7198  break;
7199 
7203  QualType(Spec->getAsType(), 0));
7204  Builder.Extend(getToContext(),
7205  Import(NNS.getLocalBeginLoc()),
7206  TSI->getTypeLoc(),
7207  Import(NNS.getLocalEndLoc()));
7208  break;
7209  }
7210 
7212  Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc()));
7213  break;
7214 
7216  SourceRange ToRange = Import(NNS.getSourceRange());
7217  Builder.MakeSuper(getToContext(),
7218  Spec->getAsRecordDecl(),
7219  ToRange.getBegin(),
7220  ToRange.getEnd());
7221  }
7222  }
7223  }
7224 
7225  return Builder.getWithLocInContext(getToContext());
7226 }
7227 
7229  switch (From.getKind()) {
7231  if (auto *ToTemplate =
7232  cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7233  return TemplateName(ToTemplate);
7234 
7235  return {};
7236 
7238  OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
7239  UnresolvedSet<2> ToTemplates;
7240  for (auto *I : *FromStorage) {
7241  if (auto *To = cast_or_null<NamedDecl>(Import(I)))
7242  ToTemplates.addDecl(To);
7243  else
7244  return {};
7245  }
7246  return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
7247  ToTemplates.end());
7248  }
7249 
7252  NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
7253  if (!Qualifier)
7254  return {};
7255 
7256  if (auto *ToTemplate =
7257  cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7258  return ToContext.getQualifiedTemplateName(Qualifier,
7259  QTN->hasTemplateKeyword(),
7260  ToTemplate);
7261 
7262  return {};
7263  }
7264 
7267  NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
7268  if (!Qualifier)
7269  return {};
7270 
7271  if (DTN->isIdentifier()) {
7272  return ToContext.getDependentTemplateName(Qualifier,
7273  Import(DTN->getIdentifier()));
7274  }
7275 
7276  return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
7277  }
7278 
7282  auto *param =
7283  cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
7284  if (!param)
7285  return {};
7286 
7287  TemplateName replacement = Import(subst->getReplacement());
7288  if (replacement.isNull())
7289  return {};
7290 
7291  return ToContext.getSubstTemplateTemplateParm(param, replacement);
7292  }
7293 
7297  auto *Param =
7298  cast_or_null<TemplateTemplateParmDecl>(
7299  Import(SubstPack->getParameterPack()));
7300  if (!Param)
7301  return {};
7302 
7303  ASTNodeImporter Importer(*this);
7304  TemplateArgument ArgPack
7305  = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
7306  if (ArgPack.isNull())
7307  return {};
7308 
7309  return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
7310  }
7311  }
7312 
7313  llvm_unreachable("Invalid template name kind");
7314 }
7315 
7317  if (FromLoc.isInvalid())
7318  return {};
7319 
7320  SourceManager &FromSM = FromContext.getSourceManager();
7321 
7322  std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
7323  FileID ToFileID = Import(Decomposed.first);
7324  if (ToFileID.isInvalid())
7325  return {};
7326  SourceManager &ToSM = ToContext.getSourceManager();
7327  return ToSM.getComposedLoc(ToFileID, Decomposed.second);
7328 }
7329 
7331  return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
7332 }
7333 
7335  llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
7336  if (Pos != ImportedFileIDs.end())
7337  return Pos->second;
7338 
7339  SourceManager &FromSM = FromContext.getSourceManager();
7340  SourceManager &ToSM = ToContext.getSourceManager();
7341  const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
7342 
7343  // Map the FromID to the "to" source manager.
7344  FileID ToID;
7345  if (FromSLoc.isExpansion()) {
7346  const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
7347  SourceLocation ToSpLoc = Import(FromEx.getSpellingLoc());
7348  SourceLocation ToExLocS = Import(FromEx.getExpansionLocStart());
7349  unsigned TokenLen = FromSM.getFileIDSize(FromID);
7350  SourceLocation MLoc;
7351  if (FromEx.isMacroArgExpansion()) {
7352  MLoc = ToSM.createMacroArgExpansionLoc(ToSpLoc, ToExLocS, TokenLen);
7353  } else {
7354  SourceLocation ToExLocE = Import(FromEx.getExpansionLocEnd());
7355  MLoc = ToSM.createExpansionLoc(ToSpLoc, ToExLocS, ToExLocE, TokenLen,
7356  FromEx.isExpansionTokenRange());
7357  }
7358  ToID = ToSM.getFileID(MLoc);
7359  } else {
7360  // Include location of this file.
7361  SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
7362 
7363  const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
7364  if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
7365  // FIXME: We probably want to use getVirtualFile(), so we don't hit the
7366  // disk again
7367  // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
7368  // than mmap the files several times.
7369  const FileEntry *Entry =
7370  ToFileManager.getFile(Cache->OrigEntry->getName());
7371  if (!Entry)
7372  return {};
7373  ToID = ToSM.createFileID(Entry, ToIncludeLoc,
7374  FromSLoc.getFile().getFileCharacteristic());
7375  } else {
7376  // FIXME: We want to re-use the existing MemoryBuffer!
7377  const llvm::MemoryBuffer *FromBuf =
7378  Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
7379  std::unique_ptr<llvm::MemoryBuffer> ToBuf =
7380  llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
7381  FromBuf->getBufferIdentifier());
7382  ToID = ToSM.createFileID(std::move(ToBuf),
7383  FromSLoc.getFile().getFileCharacteristic());
7384  }
7385  }
7386 
7387  ImportedFileIDs[FromID] = ToID;
7388  return ToID;
7389 }
7390 
7392  Expr *ToExpr = Import(From->getInit());
7393  if (!ToExpr && From->getInit())
7394  return nullptr;
7395 
7396  if (From->isBaseInitializer()) {
7397  TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7398  if (!ToTInfo && From->getTypeSourceInfo())
7399  return nullptr;
7400 
7401  return new (ToContext) CXXCtorInitializer(
7402  ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
7403  ToExpr, Import(From->getRParenLoc()),
7404  From->isPackExpansion() ? Import(From->getEllipsisLoc())
7405  : SourceLocation());
7406  } else if (From->isMemberInitializer()) {
7407  auto *ToField = cast_or_null<FieldDecl>(Import(From->getMember()));
7408  if (!ToField && From->getMember())
7409  return nullptr;
7410 
7411  return new (ToContext) CXXCtorInitializer(
7412  ToContext, ToField, Import(From->getMemberLocation()),
7413  Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7414  } else if (From->isIndirectMemberInitializer()) {
7415  auto *ToIField = cast_or_null<IndirectFieldDecl>(
7416  Import(From->getIndirectMember()));
7417  if (!ToIField && From->getIndirectMember())
7418  return nullptr;
7419 
7420  return new (ToContext) CXXCtorInitializer(
7421  ToContext, ToIField, Import(From->getMemberLocation()),
7422  Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7423  } else if (From->isDelegatingInitializer()) {
7424  TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7425  if (!ToTInfo && From->getTypeSourceInfo())
7426  return nullptr;
7427 
7428  return new (ToContext)
7429  CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
7430  ToExpr, Import(From->getRParenLoc()));
7431  } else {
7432  return nullptr;
7433  }
7434 }
7435 
7437  auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
7438  if (Pos != ImportedCXXBaseSpecifiers.end())
7439  return Pos->second;
7440 
7441  CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
7442  Import(BaseSpec->getSourceRange()),
7443  BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
7444  BaseSpec->getAccessSpecifierAsWritten(),
7445  Import(BaseSpec->getTypeSourceInfo()),
7446  Import(BaseSpec->getEllipsisLoc()));
7447  ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
7448  return Imported;
7449 }
7450 
7452  Decl *To = Import(From);
7453  if (!To)
7454  return;
7455 
7456  if (auto *FromDC = cast<DeclContext>(From)) {
7457  ASTNodeImporter Importer(*this);
7458 
7459  if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
7460  if (!ToRecord->getDefinition()) {
7461  Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
7463  return;
7464  }
7465  }
7466 
7467  if (auto *ToEnum = dyn_cast<EnumDecl>(To)) {
7468  if (!ToEnum->getDefinition()) {
7469  Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
7471  return;
7472  }
7473  }
7474 
7475  if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
7476  if (!ToIFace->getDefinition()) {
7477  Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
7479  return;
7480  }
7481  }
7482 
7483  if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
7484  if (!ToProto->getDefinition()) {
7485  Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
7487  return;
7488  }
7489  }
7490 
7491  Importer.ImportDeclContext(FromDC, true);
7492  }
7493 }
7494 
7496  if (!FromName)
7497  return {};
7498 
7499  switch (FromName.getNameKind()) {
7501  return Import(FromName.getAsIdentifierInfo());
7502 
7506  return Import(FromName.getObjCSelector());
7507 
7509  QualType T = Import(FromName.getCXXNameType());
7510  if (T.isNull())
7511  return {};
7512 
7513  return ToContext.DeclarationNames.getCXXConstructorName(
7514  ToContext.getCanonicalType(T));
7515  }
7516 
7518  QualType T = Import(FromName.getCXXNameType());
7519  if (T.isNull())
7520  return {};
7521 
7522  return ToContext.DeclarationNames.getCXXDestructorName(
7523  ToContext.getCanonicalType(T));
7524  }
7525 
7527  auto *Template = cast_or_null<TemplateDecl>(
7528  Import(FromName.getCXXDeductionGuideTemplate()));
7529  if (!Template)
7530  return {};
7531  return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
7532  }
7533 
7535  QualType T = Import(FromName.getCXXNameType());
7536  if (T.isNull())
7537  return {};
7538 
7540  ToContext.getCanonicalType(T));
7541  }
7542 
7544  return ToContext.DeclarationNames.getCXXOperatorName(
7545  FromName.getCXXOverloadedOperator());
7546 
7549  Import(FromName.getCXXLiteralIdentifier()));
7550 
7552  // FIXME: STATICS!
7554  }
7555 
7556  llvm_unreachable("Invalid DeclarationName Kind!");
7557 }
7558 
7560  if (!FromId)
7561  return nullptr;
7562 
7563  IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
7564 
7565  if (!ToId->getBuiltinID() && FromId->getBuiltinID())
7566  ToId->setBuiltinID(FromId->getBuiltinID());
7567 
7568  return ToId;
7569 }
7570 
7572  if (FromSel.isNull())
7573  return {};
7574 
7576  Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
7577  for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
7578  Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
7579  return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
7580 }
7581 
7583  DeclContext *DC,
7584  unsigned IDNS,
7585  NamedDecl **Decls,
7586  unsigned NumDecls) {
7587  return Name;
7588 }
7589 
7591  if (LastDiagFromFrom)
7593  FromContext.getDiagnostics());
7594  LastDiagFromFrom = false;
7595  return ToContext.getDiagnostics().Report(Loc, DiagID);
7596 }
7597 
7599  if (!LastDiagFromFrom)
7601  ToContext.getDiagnostics());
7602  LastDiagFromFrom = true;
7603  return FromContext.getDiagnostics().Report(Loc, DiagID);
7604 }
7605 
7607  if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
7608  if (!ID->getDefinition())
7609  ID->startDefinition();
7610  }
7611  else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
7612  if (!PD->getDefinition())
7613  PD->startDefinition();
7614  }
7615  else if (auto *TD = dyn_cast<TagDecl>(D)) {
7616  if (!TD->getDefinition() && !TD->isBeingDefined()) {
7617  TD->startDefinition();
7618  TD->setCompleteDefinition(true);
7619  }
7620  }
7621  else {
7622  assert(0 && "CompleteDecl called on a Decl that can't be completed");
7623  }
7624 }
7625 
7627  llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
7628  assert((Pos == ImportedDecls.end() || Pos->second == To) &&
7629  "Try to import an already imported Decl");
7630  if (Pos != ImportedDecls.end())
7631  return Pos->second;
7632  ImportedDecls[From] = To;
7633  return To;
7634 }
7635 
7637  bool Complain) {
7638  llvm::DenseMap<const Type *, const Type *>::iterator Pos
7639  = ImportedTypes.find(From.getTypePtr());
7640  if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
7641  return true;
7642 
7643  StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
7644  getStructuralEquivalenceKind(*this), false,
7645  Complain);
7646  return Ctx.IsEquivalent(From, To);
7647 }
SourceLocation getRParenLoc() const
Definition: Stmt.h:1235
Expr * getInc()
Definition: Stmt.h:1290
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2426
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:78
bool isBaseInitializer() const
Determine whether this initializer is initializing a base class.
Definition: DeclCXX.h:2318
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
Definition: Expr.h:4154
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
Represents a single C99 designator.
Definition: Expr.h:4361
SourceLocation getGetterNameLoc() const
Definition: DeclObjC.h:926
TemplateTemplateParmDecl * getParameterPack() const
Retrieve the template template parameter pack being substituted.
Definition: TemplateName.h:135
void setValueDependent(bool VD)
Set whether this expression is value-dependent or not.
Definition: Expr.h:152
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:5192
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
SourceLocation getRBracLoc() const
Definition: Stmt.h:709
Defines the clang::ASTContext interface.
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it&#39;s either not been deduced or was deduce...
Definition: Type.h:4548
IdentifierInfo * getInputIdentifier(unsigned i) const
Definition: Stmt.h:1797
Decl * VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D)
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:4945
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1568
TemplateParameterList * ImportTemplateParameterList(TemplateParameterList *Params)
Stmt * VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S)
Expr * VisitCXXMemberCallExpr(CXXMemberCallExpr *E)
VarDecl * getCapturedVar() const
Retrieve the declaration of the local variable being captured.
SourceLocation getRParenLoc() const
Definition: Stmt.h:1704
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:3209
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:593
const CXXDestructorDecl * getDestructor() const
Definition: ExprCXX.h:1224
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
Definition: ExprCXX.h:2766
Expr * VisitConditionalOperator(ConditionalOperator *E)
static unsigned getFieldIndex(Decl *F)
This represents a GCC inline-assembly statement extension.
Definition: Stmt.h:1683
void setImplicit(bool I=true)
Definition: DeclBase.h:555
Decl * VisitCXXMethodDecl(CXXMethodDecl *D)
Represents a function declaration or definition.
Definition: Decl.h:1716
SourceLocation getForLoc() const
Definition: StmtCXX.h:195
NamedDecl * getFoundDecl()
Get the NamedDecl through which this reference occurred.
Definition: Expr.h:1098
QualType VisitVectorType(const VectorType *T)
bool getValue() const
Definition: ExprCXX.h:2464
bool isImplicit() const
Determine whether this was an implicit capture (not written between the square brackets introducing t...
Decl * VisitEnumDecl(EnumDecl *D)
void localUncachedLookup(DeclarationName Name, SmallVectorImpl< NamedDecl *> &Results)
A simplistic name lookup mechanism that performs name lookup into this declaration context without co...
Definition: DeclBase.cpp:1638
Expr * getLHS() const
Definition: Expr.h:3474
Expr * getInit() const
Get the initializer.
Definition: DeclCXX.h:2447
bool isKindOfTypeAsWritten() const
Whether this is a "__kindof" type as written.
Definition: Type.h:5472
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
Definition: ExprCXX.h:2782
const Stmt * getElse() const
Definition: Stmt.h:1014
unsigned getNumInputs() const
Definition: Stmt.h:1599
SourceLocation getRParenLoc() const
Definition: Expr.h:2452
void setArrayFiller(Expr *filler)
Definition: Expr.cpp:1984
Stmt * VisitDoStmt(DoStmt *S)
Smart pointer class that efficiently represents Objective-C method names.
This is a discriminated union of FileInfo and ExpansionInfo.
SourceLocation getForLoc() const
Definition: Stmt.h:1303
void setAnonymousStructOrUnion(bool Anon)
Definition: Decl.h:3676
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2393
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
Definition: Type.h:5466
QualType getPointeeType() const
Definition: Type.h:2406
llvm::iterator_range< arg_iterator > placement_arguments()
Definition: ExprCXX.h:2088
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
Definition: ExprCXX.h:1131
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:3886
bool hasTemplateKeyword() const
Whether the template name was prefixed by the "template" keyword.
Definition: TemplateName.h:392
Stores the type being destroyed by a pseudo-destructor expression.
Definition: ExprCXX.h:2224
A (possibly-)qualified type.
Definition: Type.h:655
uint64_t getValue() const
Definition: ExprCXX.h:2558
QualType VisitDecltypeType(const DecltypeType *T)
Decl * VisitUsingShadowDecl(UsingShadowDecl *D)
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:3055
const char * getDeclKindName() const
Definition: DeclBase.cpp:123
StringKind getKind() const
Definition: Expr.h:1673
OverloadedOperatorKind getOperator() const
Return the overloaded operator to which this template name refers.
Definition: TemplateName.h:494
bool isThisDeclarationADefinition() const
Returns whether this template declaration defines the primary class pattern.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2596
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
unsigned param_size() const
Definition: DeclObjC.h:381
Stmt * VisitCaseStmt(CaseStmt *S)
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.h:2346
QualType getInjectedSpecializationType() const
Definition: Type.h:4826
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:478
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
SourceRange getCXXOperatorNameRange() const
getCXXOperatorNameRange - Gets the range of the operator name (without the operator keyword)...
void startDefinition()
Starts the definition of this Objective-C class, taking it from a forward declaration (@class) to a d...
Definition: DeclObjC.cpp:604
SourceLocation getSpellingLoc() const
SourceLocation getEllipsisLoc() const
Definition: Stmt.h:786
SourceLocation getLParen() const
Get the location of the left parentheses &#39;(&#39;.
Definition: Expr.h:1777
ObjCTypeParamList * ImportObjCTypeParamList(ObjCTypeParamList *list)
const Expr * getSubExpr() const
Definition: ExprCXX.h:1050
SourceLocation getEllipsisLoc() const
Get the location of the ellipsis if this is a pack expansion.
Definition: DeclCXX.h:3638
static ClassTemplateDecl * getDefinition(ClassTemplateDecl *D)
SourceLocation getLParenLoc() const
Definition: DeclCXX.h:2443
Expr * getCond()
Definition: Stmt.h:1176
inputs_range inputs()
Definition: Stmt.h:1632
QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T)
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
bool isThisDeclarationADefinition() const
Determine whether this particular declaration of this class is actually also a definition.
Definition: DeclObjC.h:1551
Defines the clang::FileManager interface and associated types.
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:2849
static CXXDependentScopeMemberExpr * Create(const ASTContext &C, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:1162
bool isObjCMethodParameter() const
Definition: Decl.h:1578
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2421
Stmt * VisitObjCAtCatchStmt(ObjCAtCatchStmt *S)
CompoundStmt * getSubStmt()
Definition: Expr.h:3670
DeclarationName getCXXConstructorName(CanQualType Ty)
getCXXConstructorName - Returns the name of a C++ constructor for the given Type. ...
Decl * VisitDecl(Decl *D)
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Definition: Decl.h:2662
Expr * getUnderlyingExpr() const
Definition: Type.h:4021
Stmt * VisitContinueStmt(ContinueStmt *S)
static UnresolvedLookupExpr * Create(const ASTContext &C, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool ADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.h:2869
SourceLocation getRParenLoc() const
Definition: StmtObjC.h:106
bool hasExplicitResultType() const
Whether this lambda had its result type explicitly specified.
Definition: ExprCXX.h:1851
bool isThrownVariableInScope() const
Determines whether the variable thrown by this expression (if any!) is within the innermost try block...
Definition: ExprCXX.h:1060
Stmt - This represents one statement.
Definition: Stmt.h:66
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2373
Expr * getDimensionExpression() const
Definition: ExprCXX.h:2560
const ObjCAtFinallyStmt * getFinallyStmt() const
Retrieve the @finally statement, if any.
Definition: StmtObjC.h:230
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:2484
Expr * getBitWidth() const
Definition: Decl.h:2623
Kind getKind() const
Definition: Type.h:2274
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:4283
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:108
bool IsICE
Whether this statement is an integral constant expression, or in C++11, whether the statement is a co...
Definition: Decl.h:803
bool isArrayFormAsWritten() const
Definition: ExprCXX.h:2187
IfStmt - This represents an if/then/else.
Definition: Stmt.h:974
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
Definition: ExprCXX.h:3015
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Definition: Expr.h:2062
SourceLocation getLocation() const
Definition: Expr.h:1509
Expr * VisitImplicitCastExpr(ImplicitCastExpr *E)
Expr * VisitExpressionTraitExpr(ExpressionTraitExpr *E)
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2741
static CXXDynamicCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Definition: ExprCXX.cpp:582
SourceLocation getSuperClassLoc() const
Retrieve the starting location of the superclass.
Definition: DeclObjC.cpp:351
Expr * VisitCXXConstructExpr(CXXConstructExpr *E)
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1019
Decl * VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D)
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
Definition: Decl.cpp:3782
Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier.
Definition: Decl.h:2974
C Language Family Type Representation.
unsigned getNumOutputs() const
Definition: Stmt.h:1577
Defines the SourceManager interface.
Microsoft&#39;s &#39;__super&#39; specifier, stored as a CXXRecordDecl* of the class it appeared in...
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2090
Expr * VisitBinaryOperator(BinaryOperator *E)
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:5020
SourceLocation getRBracketLoc() const
Definition: Expr.h:4444
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:87
Expr * getBase() const
Definition: Expr.h:2590
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:270
const StringLiteral * getAsmString() const
Definition: Stmt.h:1709
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5039
DeclarationName getCXXConversionFunctionName(CanQualType Ty)
getCXXConversionFunctionName - Returns the name of a C++ conversion function for the given Type...
TypeSourceInfo * getTypeSourceInfo() const
Definition: Expr.h:2788
iterator end()
Definition: DeclGroup.h:106
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1918
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1944
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:1197
bool hasLeadingEmptyMacro() const
Definition: Stmt.h:599
Stmt * getHandlerBlock() const
Definition: StmtCXX.h:54
DeclGroupRef ImportDeclGroup(DeclGroupRef DG)
Expr * VisitPackExpansionExpr(PackExpansionExpr *E)
llvm::APFloat getValue() const
Definition: Expr.h:1475
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition: Expr.h:4735
FunctionDecl * getOperatorNew() const
Definition: ExprCXX.h:2015
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2112
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:247
void setType(QualType t)
Definition: Expr.h:129
Selector getObjCSelector() const
getObjCSelector - Get the Objective-C selector stored in this declaration name.
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2824
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
const Expr * getSubExpr() const
Definition: Expr.h:3972
Defines the C++ template declaration subclasses.
Opcode getOpcode() const
Definition: Expr.h:3184
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4562
unsigned getNumSubExprs() const
Retrieve the total number of subexpressions in this designated initializer expression, including the actual initialized value and any expressions that occur within array and array-range designators.
Definition: Expr.h:4534
SourceLocation getIdentLoc() const
Definition: Stmt.h:891
void setPure(bool P=true)
Definition: Decl.cpp:2678
Represents an attribute applied to a statement.
Definition: Stmt.h:918
bool hasWrittenPrototype() const
Definition: Decl.h:2082
Not a friend object.
Definition: DeclBase.h:1101
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1751
known_categories_range known_categories() const
Definition: DeclObjC.h:1708
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
Definition: DeclBase.h:960
NamedDecl * getDecl() const
SourceLocation getColonLoc() const
The location of the colon following the access specifier.
Definition: DeclCXX.h:154
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.h:3935
The base class of the type hierarchy.
Definition: Type.h:1428
Represents an empty-declaration.
Definition: Decl.h:4253
Represents Objective-C&#39;s @throw statement.
Definition: StmtObjC.h:323
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called...
Definition: ExprCXX.h:1382
Each ExpansionInfo encodes the expansion location - where the token was ultimately expanded...
DiagnosticsEngine & getDiagnostics() const
QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T)
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1294
bool hasExplicitTemplateArgs() const
Determines whether this declaration reference was followed by an explicit template argument list...
Definition: Expr.h:1139
SourceLocation getLocation() const
Definition: ExprCXX.h:610
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2668
Declaration of a variable template.
SourceLocation getRParenLoc() const
Definition: Expr.h:2204
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:64
Represent a C++ namespace.
Definition: Decl.h:514
Expr * VisitOffsetOfExpr(OffsetOfExpr *OE)
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1292
RetTy Visit(const Type *T)
Performs the operation associated with this visitor object.
Definition: TypeVisitor.h:69
TypeSourceInfo * getTypeInfoAsWritten() const
getTypeInfoAsWritten - Returns the type source info for the type that this expression is casting to...
Definition: Expr.h:3057
protocol_iterator protocol_begin() const
Definition: DeclObjC.h:1391
FPOptions getFPFeatures() const
Definition: Expr.h:3317
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
Definition: ExprCXX.h:2507
void setSpecializationKind(TemplateSpecializationKind TSK)
virtual void completeDefinition()
Note that the definition of this type is now complete.
Definition: Decl.cpp:4049
Decl * VisitFieldDecl(FieldDecl *D)
A container of type source information.
Definition: Decl.h:86
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5800
bool isEmpty() const
Evaluates true when this declaration name is empty.
Decl * VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D)
static AttributedStmt * Create(const ASTContext &C, SourceLocation Loc, ArrayRef< const Attr *> Attrs, Stmt *SubStmt)
Definition: Stmt.cpp:337
Expr * VisitTypeTraitExpr(TypeTraitExpr *E)
static StringLiteral * Create(const ASTContext &C, StringRef Str, StringKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumStrs)
This is the "fully general" constructor that allows representation of strings formed from multiple co...
Definition: Expr.cpp:888
bool ImportTemplateArgumentListInfo(const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo)
QualType VisitInjectedClassNameType(const InjectedClassNameType *T)
SourceLocation getGotoLoc() const
Definition: Stmt.h:1381
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, SourceLocation LPLoc, SourceLocation RPLoc)
Definition: ExprCXX.cpp:686
SourceLocation getOperatorLoc() const
Determine the location of the &#39;sizeof&#39; keyword.
Definition: ExprCXX.h:3892
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:414
SourceLocation getRParenLoc() const
Definition: ExprCXX.h:1896
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to...
Definition: Decl.h:1209
bool isPackExpansion() const
Determine whether this capture is a pack expansion, which captures a function parameter pack...
SourceLocation getColonLoc() const
Retrieve the location of the &#39;:&#39; separating the type parameter name from the explicitly-specified bou...
Definition: DeclObjC.h:642
Decl * VisitNamespaceAliasDecl(NamespaceAliasDecl *D)
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:26
param_const_iterator param_end() const
Definition: DeclObjC.h:392
TemplateTypeParmDecl * getDecl() const
Definition: Type.h:4383
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2477
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4150
A template template parameter that has been substituted for some other template name.
Definition: TemplateName.h:206
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:2036
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
bool isPackExpansion() const
Determine whether this initializer is a pack expansion.
Definition: DeclCXX.h:2351
SourceLocation getTargetNameLoc() const
Returns the location of the identifier in the named namespace.
Definition: DeclCXX.h:3120
QualType getElementType() const
Definition: Type.h:2703
DeclarationName getCXXDeductionGuideName(TemplateDecl *TD)
Returns the name of a C++ deduction guide for the given template.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3171
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "while" statement, if any.
Definition: Stmt.cpp:901
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Definition: TemplateName.h:484
SourceLocation getCoawaitLoc() const
Definition: StmtCXX.h:196
Expr * getIndexExpr(unsigned Idx)
Definition: Expr.h:2090
bool isIndirectMemberInitializer() const
Definition: DeclCXX.h:2330
An identifier, stored as an IdentifierInfo*.
Stmt * getSubStmt()
Definition: Stmt.h:843
Expr * VisitStringLiteral(StringLiteral *E)
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprCXX.h:2126
unsigned getDepth() const
Get the nesting depth of the template parameter.
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:54
QualType VisitPointerType(const PointerType *T)
Represents a variable declaration or definition.
Definition: Decl.h:814
void setImplementation(ObjCCategoryImplDecl *ImplD)
Definition: DeclObjC.cpp:1979
const VarDecl * getNRVOCandidate() const
Retrieve the variable that might be used for the named return value optimization. ...
Definition: Stmt.h:1503
SourceLocation getLParenLoc() const
Definition: Stmt.h:1305
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2752
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprCXX.h:742
SourceLocation getOperatorLoc() const
Retrieve the location of the &#39;.&#39; or &#39;->&#39; operator.
Definition: ExprCXX.h:2341
QualType getCXXNameType() const
getCXXNameType - If this name is one of the C++ names (of a constructor, destructor, or conversion function), return the type associated with that name.
Stmt * VisitLabelStmt(LabelStmt *S)
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3504
OpaqueValueExpr * getCommonExpr() const
Get the common subexpression shared by all initializations (the source array).
Definition: Expr.h:4695
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6526
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
Definition: Decl.cpp:2587
ObjCCategoryImplDecl * getImplementation() const
Definition: DeclObjC.cpp:1974
Expr * VisitIntegerLiteral(IntegerLiteral *E)
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
Definition: ExprCXX.h:2470
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:57
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
Extra information about a function prototype.
Definition: Type.h:3551
bool hasInheritedDefaultArg() const
Definition: Decl.h:1661
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1588
SourceLocation getColonLoc() const
Definition: Expr.h:3419
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
Represents a variable template specialization, which refers to a variable template with a given set o...
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.h:1249
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
SourceLocation getLAngleLoc() const
Definition: DeclTemplate.h:173
Decl * VisitVarDecl(VarDecl *D)
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:601
A namespace, stored as a NamespaceDecl*.
DeclarationName getName() const
Gets the name looked up.
Definition: ExprCXX.h:2743
DiagnosticBuilder ToDiag(SourceLocation Loc, unsigned DiagID)
Report a diagnostic in the "to" context.
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:624
llvm::PointerUnion< NamedDecl *, TypeSourceInfo * > FriendUnion
Definition: DeclFriend.h:60
SourceLocation getIfLoc() const
Definition: Stmt.h:1021
Expr * VisitUnaryOperator(UnaryOperator *E)
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:2029
Expr * VisitAtomicExpr(AtomicExpr *E)
TypeSourceInfo * getArgumentTypeInfo() const
Definition: Expr.h:2174
bool isMemberInitializer() const
Determine whether this initializer is initializing a non-static data member.
Definition: DeclCXX.h:2324
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
Definition: ExprCXX.h:2897
TemplateName getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, TemplateName replacement) const
Defines the Objective-C statement AST node classes.
SourceLocation getEllipsisLoc() const
Definition: DeclCXX.h:2356
unsigned getNumExpressions() const
Definition: Expr.h:2105
SourceLocation getLocation() const
Retrieve the location of the literal.
Definition: Expr.h:1346
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
Expr * VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *CE)
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
Definition: ExprCXX.h:1490
QualType Import(QualType FromT)
Import the given type from the "from" context into the "to" context.
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1028
Expr * getExprOperand() const
Definition: ExprCXX.h:728
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3092
Represents a parameter to a function.
Definition: Decl.h:1535
bool ImportTemplateArguments(const TemplateArgument *FromArgs, unsigned NumFromArgs, SmallVectorImpl< TemplateArgument > &ToArgs)
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4417
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3628
Defines the clang::Expr interface and subclasses for C++ expressions.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "switch" statement, if any.
Definition: Stmt.cpp:867
SourceLocation getRParenLoc() const
Definition: DeclCXX.h:2444
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:315
BoundNodesTreeBuilder Nodes
std::tuple< FunctionTemplateDecl *, OptionalTemplateArgsTy > ImportFunctionTemplateWithTemplateArgsFromSpecialization(FunctionDecl *FromFD)
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
Definition: ExprCXX.cpp:1014
const ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.h:2710
SubstTemplateTemplateParmStorage * getAsSubstTemplateTemplateParm() const
Retrieve the substituted template template parameter, if known.
Decl * VisitStaticAssertDecl(StaticAssertDecl *D)
const Stmt * getSubStmt() const
Definition: StmtObjC.h:368
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
Definition: DeclCXX.cpp:1604
const char * getStmtClassName() const
Definition: Stmt.cpp:75
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
SourceLocation getRParenLoc() const
Retrieve the location of the closing parenthesis.
Definition: ExprCXX.h:281
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:875
SourceLocation getDotLoc() const
Definition: Expr.h:4428
Represents a struct/union/class.
Definition: Decl.h:3570
Represents a C99 designated initializer expression.
Definition: Expr.h:4286
LanguageIDs getLanguage() const
Return the language specified by this linkage specification.
Definition: DeclCXX.h:2869
SourceLocation getVarianceLoc() const
Retrieve the location of the variance keyword.
Definition: DeclObjC.h:631
Decl * VisitObjCCategoryDecl(ObjCCategoryDecl *D)
QualType VisitBlockPointerType(const BlockPointerType *T)
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
virtual DeclarationName HandleNameConflict(DeclarationName Name, DeclContext *DC, unsigned IDNS, NamedDecl **Decls, unsigned NumDecls)
Cope with a name conflict when importing a declaration into the given context.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:85
QualType getOriginalType() const
Definition: Type.h:2457
TypeSourceInfo * getScopeTypeInfo() const
Retrieve the scope type in a qualified pseudo-destructor expression.
Definition: ExprCXX.h:2352
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3552
SourceLocation getColonLoc() const
Definition: Stmt.h:849
One of these records is kept for each identifier that is lexed.
Represents a class template specialization, which refers to a class template with a given set of temp...
Stmt * getBody()
Definition: Stmt.h:1226
void setIntegerType(QualType T)
Set the underlying integer type.
Definition: Decl.h:3451
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4191
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Definition: DeclFriend.h:124
unsigned getDepth() const
Retrieve the depth of the template parameter.
SourceLocation getTildeLoc() const
Retrieve the location of the &#39;~&#39;.
Definition: ExprCXX.h:2359
Decl * VisitTypedefDecl(TypedefDecl *D)
FieldDecl * getField() const
For a field offsetof node, returns the field.
Definition: Expr.h:1985
DiagnosticBuilder FromDiag(SourceLocation Loc, unsigned DiagID)
Report a diagnostic in the "from" context.
SourceLocation getRParenLoc() const
Definition: Expr.h:5404
StringLiteral * getMessage()
Definition: DeclCXX.h:3780
bool cleanupsHaveSideEffects() const
Definition: ExprCXX.h:3135
Designator ImportDesignator(const Designator &D)
QualType getComputationResultType() const
Definition: Expr.h:3377
Decl * VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D)
Expr * VisitCompoundAssignOperator(CompoundAssignOperator *E)
SourceLocation getIvarLBraceLoc() const
Definition: DeclObjC.h:2717
Represents a class type in Objective C.
Definition: Type.h:5355
SourceLocation getRParen() const
Get the location of the right parentheses &#39;)&#39;.
Definition: Expr.h:1781
QualType getPointeeType() const
Definition: Type.h:2510
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:330
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:2576
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:150
A C++ nested-name-specifier augmented with source location information.
Expr * getInit() const
Retrieve the initializer value.
Definition: Expr.h:4522
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:575
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:422
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
bool CheckedICE
Whether we already checked whether this statement was an integral constant expression.
Definition: Decl.h:794
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Definition: DeclCXX.h:3101
bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin)
Decl * VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D)
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:72
QualType VisitMemberPointerType(const MemberPointerType *T)
bool isFileScope() const
Definition: Expr.h:2782
static CXXConstructExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr *> Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, ConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Definition: ExprCXX.cpp:806
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3776
QualType VisitDecayedType(const DecayedType *T)
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:2547
field_range fields() const
Definition: Decl.h:3786
SourceLocation getAmpAmpLoc() const
Definition: Expr.h:3622
SourceLocation getEndLoc() const
Definition: Stmt.h:529
Represents a member of a struct/union/class.
Definition: Decl.h:2534
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:4724
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
void setTypeParamList(ObjCTypeParamList *TPL)
Set the type parameters of this class.
Definition: DeclObjC.cpp:322
TypeSourceInfo * getTypeSourceInfo() const
Returns the declarator information for a base class or delegating initializer.
Definition: DeclCXX.h:2379
QualType VisitParenType(const ParenType *T)
protocol_iterator protocol_begin() const
Definition: DeclObjC.h:2154
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3607
const llvm::APSInt & getInitVal() const
Definition: Decl.h:2762
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
This declaration is a friend function.
Definition: DeclBase.h:152
NonTypeTemplateParmDecl * getParameter() const
Definition: ExprCXX.h:3982
const DeclarationNameInfo & getNameInfo() const
Gets the full name info.
Definition: ExprCXX.h:2740
static DesignatedInitExpr * Create(const ASTContext &C, llvm::ArrayRef< Designator > Designators, ArrayRef< Expr *> IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
Definition: Expr.cpp:3837
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition: Decl.h:1588
An operation on a type.
Definition: TypeVisitor.h:65
One instance of this struct is kept for every file loaded or used.
Definition: SourceManager.h:95
bool isDefined() const
Definition: DeclObjC.h:464
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
Definition: Expr.h:1979
const Expr * getRetValue() const
Definition: Stmt.cpp:928
SourceLocation getLabelLoc() const
Definition: Expr.h:3624
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3791
bool hasExplicitTemplateArgs() const
Determines whether the member name was followed by an explicit template argument list.
Definition: Expr.h:2655
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
void setSuperClass(TypeSourceInfo *superClass)
Definition: DeclObjC.h:1609
SourceLocation getOperatorLoc() const
Definition: Expr.h:2201
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition: Expr.h:3918
Optional< unsigned > getNumTemplateExpansions() const
Retrieve the number of expansions that a template template argument expansion will produce...
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:944
NamedDecl * getFriendDecl() const
If this friend declaration doesn&#39;t name a type, return the inner declaration.
Definition: DeclFriend.h:139
Expr * VisitCXXTypeidExpr(CXXTypeidExpr *E)
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:405
ObjCTypeParamList * getTypeParamListAsWritten() const
Retrieve the type parameters written on this particular declaration of the class. ...
Definition: DeclObjC.h:1332
TagDecl * getOwnedTagDecl() const
Return the (re)declaration of this type owned by this occurrence of this type, or nullptr if none...
Definition: Type.h:4988
bool isInIdentifierNamespace(unsigned NS) const
Definition: DeclBase.h:803
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
DeclarationName getCXXDestructorName(CanQualType Ty)
getCXXDestructorName - Returns the name of a C++ destructor for the given Type.
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr)
Definition: Expr.cpp:391
int Category
Definition: Format.cpp:1608
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Definition: Expr.h:936
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3539
protocol_iterator protocol_end() const
Definition: DeclObjC.h:1402
const DeclGroupRef getDeclGroup() const
Definition: Stmt.h:523
Expr * VisitExpr(Expr *E)
Decl * VisitObjCImplementationDecl(ObjCImplementationDecl *D)
Expr * getSubExpr()
Definition: Expr.h:2892
Represents an access specifier followed by colon &#39;:&#39;.
Definition: DeclCXX.h:132
void startDefinition()
Starts the definition of this Objective-C protocol.
Definition: DeclObjC.cpp:1870
SourceLocation getQuestionLoc() const
Definition: Expr.h:3418
static CXXRecordDecl * CreateLambda(const ASTContext &C, DeclContext *DC, TypeSourceInfo *Info, SourceLocation Loc, bool DependentLambda, bool IsGeneric, LambdaCaptureDefault CaptureDefault)
Definition: DeclCXX.cpp:140
bool isGnuLocal() const
Definition: Decl.h:495
Optional< LambdaCapture > ImportLambdaCapture(const LambdaCapture &From)
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:172
void setSubStmt(Stmt *S)
Definition: Stmt.h:805
QualType VisitObjCInterfaceType(const ObjCInterfaceType *T)
LambdaCaptureDefault getCaptureDefault() const
Determine the default capture kind for this lambda.
Definition: ExprCXX.h:1720
unsigned getIndex() const
Retrieve the index into its type parameter list.
Definition: DeclObjC.h:634
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:2797
QualType getParamTypeForDecl() const
Definition: TemplateBase.h:269
bool hasExplicitTemplateArgs() const
Determines whether this lookup had explicit template arguments.
Definition: ExprCXX.h:3031
IdentifierTable & Idents
Definition: ASTContext.h:545
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name...
QualType VisitComplexType(const ComplexType *T)
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:5908
bool hadArrayRangeDesignator() const
Definition: Expr.h:4218
Decl * VisitFriendDecl(FriendDecl *D)
SourceLocation getCatchLoc() const
Definition: StmtCXX.h:51
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2231
Represents Objective-C&#39;s @catch statement.
Definition: StmtObjC.h:76
SourceLocation getComposedLoc(FileID FID, unsigned Offset) const
Form a SourceLocation from a FileID and Offset pair.
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
IndirectGotoStmt - This represents an indirect goto.
Definition: Stmt.h:1365
SourceLocation getMemberLoc() const
Definition: ExprCXX.h:3436
Describes an C or C++ initializer list.
Definition: Expr.h:4050
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:671
Represents a C++ using-declaration.
Definition: DeclCXX.h:3360
QualType VisitVariableArrayType(const VariableArrayType *T)
bool isInvalid() const
Stmt * VisitBreakStmt(BreakStmt *S)
bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin)
Decl * VisitCXXConstructorDecl(CXXConstructorDecl *D)
SourceLocation getIvarRBraceLoc() const
Definition: DeclObjC.h:2719
Expr * getArraySize()
Definition: ExprCXX.h:2022
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2594
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
UnresolvedUsingTypenameDecl * getDecl() const
Definition: Type.h:3897
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
Decl * VisitUsingDecl(UsingDecl *D)
ForStmt - This represents a &#39;for (init;cond;inc)&#39; stmt.
Definition: Stmt.h:1256
A qualified template name, where the qualification is kept to describe the source code as written...
Definition: TemplateName.h:198
unsigned getFirstExprIndex() const
Definition: Expr.h:4456
QualType VisitElaboratedType(const ElaboratedType *T)
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2662
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2197
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
bool isElidable() const
Whether this construction is elidable.
Definition: ExprCXX.h:1361
Expr * getOperand() const
Definition: ExprCXX.h:3721
const Expr * getThrowExpr() const
Definition: StmtObjC.h:335
Stmt * VisitAttributedStmt(AttributedStmt *S)
bool isBaseVirtual() const
Returns whether the base is virtual or not.
Definition: DeclCXX.h:2371
DesignatedInitExpr::Designator Designator
TagKind getTagKind() const
Definition: Decl.h:3230
Namespaces, declared with &#39;namespace foo {}&#39;.
Definition: DeclBase.h:140
bool isGlobalNew() const
Definition: ExprCXX.h:2047
void setCXXOperatorNameRange(SourceRange R)
setCXXOperatorNameRange - Sets the range of the operator name (without the operator keyword)...
A convenient class for passing around template argument information.
Definition: TemplateBase.h:552
static void setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To, ASTImporter &Importer)
bool isKNRPromoted() const
True if the value passed to this parameter must undergo K&R-style default argument promotion: ...
Definition: Decl.h:1609
const FileInfo & getFile() const
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
void setRange(SourceRange R)
Definition: Attr.h:95
bool doesUsualArrayDeleteWantSize() const
Answers whether the usual array deallocation function for the allocated type expects the size of the ...
Definition: ExprCXX.h:2193
LabelDecl * getDecl() const
Definition: Stmt.h:892
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
SourceLocation getLBracLoc() const
Definition: Stmt.h:708
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3284
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclObjC.h:323
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:2802
SourceLocation getRParenLoc() const
Definition: StmtCXX.h:198
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
Definition: TemplateBase.h:275
Expr * getInitializer()
The initializer of this new-expression.
Definition: ExprCXX.h:2060
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:405
path_iterator path_begin()
Definition: Expr.h:2916
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
Definition: ExprCXX.h:2759
Stmt * getBody()
Definition: Stmt.h:1291
PropertyAttributeKind getPropertyAttributes() const
Definition: DeclObjC.h:859
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T)
Decl * VisitObjCPropertyDecl(ObjCPropertyDecl *D)
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:3941
Expr * VisitCharacterLiteral(CharacterLiteral *E)
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3143
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:754
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum...
Definition: Decl.h:3468
bool constructsVBase() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
Definition: ExprCXX.h:1494
void setLambdaMangling(unsigned ManglingNumber, Decl *ContextDecl)
Set the mangling number and context declaration for a lambda class.
Definition: DeclCXX.h:1926
tokloc_iterator tokloc_end() const
Definition: Expr.h:1727
Stmt * getInit()
Definition: Stmt.h:1270
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt *> Stmts, SourceLocation LB, SourceLocation RB)
Definition: Stmt.cpp:317
iterator begin()
Definition: DeclGroup.h:100
Decl * VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D)
SourceLocation getThrowLoc() const
Definition: ExprCXX.h:1053
const StringLiteral * getInputConstraintLiteral(unsigned i) const
Definition: Stmt.h:1810
const Type * getClass() const
Definition: Type.h:2646
CXXForRangeStmt - This represents C++0x [stmt.ranged]&#39;s ranged for statement, represented as &#39;for (ra...
Definition: StmtCXX.h:130
Stmt * VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S)
CXXRecordDecl * getDecl() const
Definition: Type.cpp:3274
bool isArrow() const
Definition: Expr.h:2695
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1383
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:3399
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
Definition: DeclObjC.h:2231
SourceLocation getEqualOrColonLoc() const
Retrieve the location of the &#39;=&#39; that precedes the initializer value itself, if present.
Definition: Expr.h:4513
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
Definition: ExprCXX.h:3454
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:3723
void setSpecializationKind(TemplateSpecializationKind TSK)
Expr * getSizeExpr() const
Definition: Type.h:2847
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5889
const TemplateArgument * getArgs() const
Retrieve the template arguments.
Definition: Type.h:4727
SourceLocation getLocalEndLoc() const
Retrieve the location of the end of this component of the nested-name-specifier.
bool isNull() const
Definition: DeclGroup.h:80
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1161
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
Definition: Decl.h:1645
Expr * getCond()
Definition: Stmt.h:1289
void setTrivial(bool IT)
Definition: Decl.h:2053
Decl * VisitObjCProtocolDecl(ObjCProtocolDecl *D)
SourceLocation getContinueLoc() const
Definition: Stmt.h:1419
const Expr * getInitExpr() const
Definition: Decl.h:2760
SourceLocation getPropertyIvarDeclLoc() const
Definition: DeclObjC.h:2852
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2827
FieldDecl * getField()
Get the field whose initializer will be used.
Definition: ExprCXX.h:1184
Helper class for OffsetOfExpr.
Definition: Expr.h:1921
SourceLocation getExternLoc() const
Definition: DeclCXX.h:2881
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2085
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1245
bool IsStructurallyEquivalent(QualType From, QualType To, bool Complain=true)
Determine whether the given types are structurally equivalent.
StringLiteral * getClobberStringLiteral(unsigned i)
Definition: Stmt.h:1844
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:828
TemplateTemplateParmDecl * getParameter() const
Definition: TemplateName.h:338
SourceLocation getBuiltinLoc() const
Definition: Expr.h:3983
CXXTemporary * getTemporary()
Definition: ExprCXX.h:1264
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1649
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:752
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name, with source-location information.
Definition: Expr.h:1080
Stmt * VisitNullStmt(NullStmt *S)
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
Definition: DeclObjC.h:2198
PropertyControl getPropertyImplementation() const
Definition: DeclObjC.h:952
Stmt * VisitCXXCatchStmt(CXXCatchStmt *S)
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
Definition: DeclTemplate.h:273
DeclarationName getDeclName() const
Retrieve the name that this expression refers to.
Definition: ExprCXX.h:2989
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization, retrieves the function from which it was instantiated.
Definition: Decl.cpp:3262
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3300
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.h:2007
Represents an ObjC class declaration.
Definition: DeclObjC.h:1193
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "for" statement, if any.
Definition: Stmt.cpp:839
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
Definition: DeclCXX.h:2385
Represents a linkage specification.
Definition: DeclCXX.h:2823
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Definition: Expr.h:1836
QualType getReturnType() const
Definition: DeclObjC.h:363
SourceLocation getIncludeLoc() const
Stmt * VisitCXXTryStmt(CXXTryStmt *S)
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3539
bool ImportDefinition(RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind=IDK_Default)
ASTImporter(ASTContext &ToContext, FileManager &ToFileManager, ASTContext &FromContext, FileManager &FromFileManager, bool MinimalImport)
Create a new AST importer.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization, retrieves the member specialization information.
Definition: Decl.cpp:3269
TypeSourceInfo * getTypeSourceInfo() const
Definition: ExprCXX.h:1892
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
Ordinary names.
Definition: DeclBase.h:144
Expr * getSizeExpr() const
Definition: Type.h:2904
Stmt * getInit()
Definition: Stmt.h:1007
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1087
Expr * VisitGNUNullExpr(GNUNullExpr *E)
void setMethodParams(ASTContext &C, ArrayRef< ParmVarDecl *> Params, ArrayRef< SourceLocation > SelLocs=llvm::None)
Sets the method&#39;s parameters and selector source locations.
Definition: DeclObjC.cpp:841
bool isExact() const
Definition: Expr.h:1501
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2548
Expr * VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E)
SourceLocation getAtStartLoc() const
Definition: DeclObjC.h:1135
Import the default subset of the definition, which might be nothing (if minimal import is set) or mig...
QualType VisitUnresolvedUsingType(const UnresolvedUsingType *T)
void addDeclInternal(Decl *D)
Add the declaration D into this context, but suppress searches for external declarations with the sam...
Definition: DeclBase.cpp:1468
Stmt * VisitDeclStmt(DeclStmt *S)
ASTContext & getToContext() const
Retrieve the context that AST nodes are being imported into.
Definition: ASTImporter.h:291
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
Definition: Decl.h:3675
NamedDecl * getFirstQualifierFoundInScope() const
Retrieve the first part of the nested-name-specifier that was found in the scope of the member access...
Definition: ExprCXX.h:3420
Represents the this expression in C++.
Definition: ExprCXX.h:986
SourceLocation getRParenLoc() const
Retrieve the location of the right parentheses (&#39;)&#39;) that follows the argument list.
Definition: ExprCXX.h:3234
TypeSourceInfo * getAllocatedTypeSourceInfo() const
Definition: ExprCXX.h:1994
NestedNameSpecifierLoc getQualifierLoc() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: Expr.h:2615
Class that aids in the construction of nested-name-specifiers along with source-location information ...
SourceLocation getRParenLoc() const
Definition: DeclCXX.h:3785
TypeSourceInfo * getQueriedTypeSourceInfo() const
Definition: ExprCXX.h:2556
void getSelectorLocs(SmallVectorImpl< SourceLocation > &SelLocs) const
Definition: DeclObjC.cpp:835
bool isArrayForm() const
Definition: ExprCXX.h:2186
const ObjCAtCatchStmt * getCatchStmt(unsigned I) const
Retrieve a @catch statement.
Definition: StmtObjC.h:212
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3397
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2780
SourceLocation getOperatorLoc() const LLVM_READONLY
Definition: Expr.h:2693
SourceLocation getEllipsisLoc() const
Definition: Expr.h:4450
Decl * MapImported(Decl *From, Decl *To)
Store and assign the imported declaration to its counterpart.
Decl * VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias)
bool hasBraces() const
Determines whether this linkage specification had braces in its syntactic form.
Definition: DeclCXX.h:2876
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
void completeDefinition(QualType NewType, QualType PromotionType, unsigned NumPositiveBits, unsigned NumNegativeBits)
When created, the EnumDecl corresponds to a forward-declared enum.
Definition: Decl.cpp:3900
Decl * VisitCXXDestructorDecl(CXXDestructorDecl *D)
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3429
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:5418
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclObjC.h:2836
QualType VisitObjCObjectType(const ObjCObjectType *T)
const ValueDecl * getExtendingDecl() const
Get the declaration which triggered the lifetime-extension of this temporary, if any.
Definition: ExprCXX.h:4213
TypeSourceInfo * getTypeSourceInfo() const
Definition: ExprCXX.h:1616
bool isStdInitListInitialization() const
Whether this constructor call was written as list-initialization, but was interpreted as forming a st...
Definition: ExprCXX.h:1377
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2275
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:2994
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1042
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:616
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3432
bool isFileVarDecl() const
Returns true for file scoped variable declaration.
Definition: Decl.h:1193
Decl * VisitRecordDecl(RecordDecl *D)
bool isMicrosoftABI() const
Returns whether this is really a Win64 ABI va_arg expression.
Definition: Expr.h:3977
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2856
Expr ** getSubExprs()
Definition: Expr.h:5380
Decl * VisitCXXConversionDecl(CXXConversionDecl *D)
This declaration is a C++ operator declared in a non-class context.
Definition: DeclBase.h:168
bool ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD)
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1355
Objective C @protocol.
Definition: DeclBase.h:147
QualType getComputationLHSType() const
Definition: Expr.h:3374
SourceLocation getTypenameLoc() const
Returns the source location of the &#39;typename&#39; keyword.
Definition: DeclCXX.h:3707
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1593
CastKind
CastKind - The kind of operation required for a conversion.
qual_range quals() const
Definition: Type.h:5255
QualType getPromotionType() const
Return the integer type that enumerators should promote to.
Definition: Decl.h:3434
bool isDelegatingInitializer() const
Determine whether this initializer is creating a delegating constructor.
Definition: DeclCXX.h:2346
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1785
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:548
A dependent template name that has not been resolved to a template (or set of templates).
Definition: TemplateName.h:202
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
Expr * VisitArrayInitLoopExpr(ArrayInitLoopExpr *E)
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:2134
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
SourceLocation getTryLoc() const
Definition: StmtCXX.h:95
bool isConstexpr() const
Definition: Stmt.h:1026
Stmt * VisitObjCForCollectionStmt(ObjCForCollectionStmt *S)
SourceLocation getLocation() const
Definition: ExprCXX.h:1357
SourceLocation getLocation() const
Definition: Expr.h:1067
void setTypeParamList(ObjCTypeParamList *TPL)
Set the type parameters of this category.
Definition: DeclObjC.cpp:1983
QualType VisitDependentSizedArrayType(const DependentSizedArrayType *T)
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl&#39;s underlying type to extract a FunctionType when possible. ...
Definition: DeclBase.cpp:933
ArrayRef< TypeSourceInfo * > getArgs() const
Retrieve the argument types.
Definition: ExprCXX.h:2479
ImportDefinitionKind
What we should import from the definition.
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param)
Definition: ExprCXX.h:1112
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:3954
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:264
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:2922
SourceLocation getLabelLoc() const
Definition: Stmt.h:1346
void setInClassInitializer(Expr *Init)
Set the C++11 in-class initializer for this member.
Definition: Decl.h:2686
SourceLocation getThrowLoc() const LLVM_READONLY
Definition: StmtObjC.h:339
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
static unsigned getNumSubExprs(AtomicOp Op)
Determine the number of arguments the specified atomic builtin should have.
Definition: Expr.cpp:4098
unsigned getValue() const
Definition: Expr.h:1442
static NestedNameSpecifier * SuperSpecifier(const ASTContext &Context, CXXRecordDecl *RD)
Returns the nested name specifier representing the __super scope for the given CXXRecordDecl.
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:2882
Expr * VisitParenExpr(ParenExpr *E)
SourceLocation getDestroyedTypeLoc() const
Retrieve the starting location of the type being destroyed.
Definition: ExprCXX.h:2383
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:1873
SourceLocation getOperatorLoc() const
Retrieve the location of the &#39;->&#39; or &#39;.&#39; operator.
Definition: ExprCXX.h:3627
Expr * getCond() const
Definition: Expr.h:3463
QualType getElementType() const
Definition: Type.h:2346
void setGetterMethodDecl(ObjCMethodDecl *gDecl)
Definition: DeclObjC.h:942
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2305
Optional< TemplateArgsTy > OptionalTemplateArgsTy
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:5111
Pepresents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3860
unsigned getFunctionScopeDepth() const
Definition: Decl.h:1582
llvm::MutableArrayRef< Designator > designators()
Definition: Expr.h:4491
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
Definition: Expr.h:2600
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
Expr - This represents one expression.
Definition: Expr.h:106
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3400
Defines the clang::LangOptions interface.
Stmt * VisitGotoStmt(GotoStmt *S)
SourceLocation getElseLoc() const
Definition: Stmt.h:1023
Decl * VisitEnumConstantDecl(EnumConstantDecl *D)
DeclStmt * getEndStmt()
Definition: StmtCXX.h:160
static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo *> Args, SourceLocation RParenLoc, bool Value)
Create a new type trait expression.
Definition: ExprCXX.cpp:1435
unsigned getChainingSize() const
Definition: Decl.h:2808
SourceLocation getAliasLoc() const
Returns the location of the alias name, i.e.
Definition: DeclCXX.h:3114
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:107
Selector getSetterName() const
Definition: DeclObjC.h:933
SourceLocation getCaptureDefaultLoc() const
Retrieve the location of this lambda&#39;s capture-default, if any.
Definition: ExprCXX.h:1725
Stmt * VisitCXXForRangeStmt(CXXForRangeStmt *S)
std::string Label
IdentifierInfo * getFieldName() const
For a field or identifier offsetof node, returns the name of the field.
Definition: Expr.cpp:1426
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
Definition: Expr.h:1995
bool isArrow() const
Determine whether this member expression used the &#39;->&#39; operator; otherwise, it used the &#39;...
Definition: ExprCXX.h:3624
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3498
Decl * VisitEmptyDecl(EmptyDecl *D)
TypeSourceInfo * getSuperClassTInfo() const
Definition: DeclObjC.h:1594
Declaration of a template type parameter.
void setSetterMethodDecl(ObjCMethodDecl *gDecl)
Definition: DeclObjC.h:945
SourceLocation getDefaultLoc() const
Definition: Stmt.h:847
unsigned getIndex() const
Definition: Type.h:4380
FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, unsigned LoadedOffset=0)
Create a new FileID that represents the specified file being #included from the specified IncludePosi...
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
Definition: ExprCXX.cpp:1257
SourceLocation getWhileLoc() const
Definition: Stmt.h:1183
TypeSourceInfo * getTypeSourceInfo() const
Definition: DeclObjC.h:846
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3407
Expr * VisitDeclRefExpr(DeclRefExpr *E)
unsigned getPackLength() const
Retrieve the length of the parameter pack.
Definition: ExprCXX.h:3907
void setSyntacticForm(InitListExpr *Init)
Definition: Expr.h:4211
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1597
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:68
const Stmt * getThen() const
Definition: Stmt.h:1012
SourceLocation getLocation() const
Definition: ExprCXX.h:1002
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:86
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2700
bool hasRelatedResultType() const
Determine whether this method has a result type that is related to the message receiver&#39;s type...
Definition: DeclObjC.h:306
static CXXUnresolvedConstructExpr * Create(const ASTContext &C, TypeSourceInfo *Type, SourceLocation LParenLoc, ArrayRef< Expr *> Args, SourceLocation RParenLoc)
Definition: ExprCXX.cpp:1107
void setInit(Expr *I)
Definition: Decl.cpp:2185
SourceLocation createMacroArgExpansionLoc(SourceLocation Loc, SourceLocation ExpansionLoc, unsigned TokLength)
Return a new SourceLocation that encodes the fact that a token from SpellingLoc should actually be re...
VarDecl * getExceptionDecl() const
Definition: StmtCXX.h:52
IdentifierInfo * getDestroyedTypeIdentifier() const
In a dependent pseudo-destructor expression for which we do not have full type information on the des...
Definition: ExprCXX.h:2375
unsigned getNumInits() const
Definition: Expr.h:4080
bool isThisDeclarationADefinition() const
Determine whether this particular declaration is also the definition.
Definition: DeclObjC.h:2242
bool isImplicitAccess() const
True if this is an implicit access, i.e.
Definition: ExprCXX.cpp:1204
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:554
Expr * getSubExpr() const
Get the initializer to use for each array element.
Definition: Expr.h:4700
const Expr * getCallee() const
Definition: Expr.h:2356
void setRBraceLoc(SourceLocation L)
Definition: DeclCXX.h:2884
const char * getTypeClassName() const
Definition: Type.cpp:2648
Stmt * VisitIfStmt(IfStmt *S)
static CXXStaticCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Definition: ExprCXX.cpp:553
Decl * VisitLinkageSpecDecl(LinkageSpecDecl *D)
bool isArrow() const
Determine whether this pseudo-destructor expression was written using an &#39;->&#39; (otherwise, it used a &#39;.
Definition: ExprCXX.h:2338
Stmt * getBody()
Definition: Stmt.h:1179
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Expr * VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E)
overridden_method_range overridden_methods() const
Definition: DeclCXX.cpp:2132
Expr * VisitAddrLabelExpr(AddrLabelExpr *E)
arg_range arguments()
Definition: ExprCXX.h:1401
const CompoundStmt * getSynchBody() const
Definition: StmtObjC.h:290
Expr * VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E)
DeclContext * getDeclContext()
Definition: DeclBase.h:428
SourceLocation getLParenLoc() const
Definition: Expr.h:4830
Decl * VisitAccessSpecDecl(AccessSpecDecl *D)
A structure for storing the information associated with a substituted template template parameter...
Definition: TemplateName.h:325
Expr * getRHS()
Definition: Stmt.h:792
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:771
QualType getBaseType() const
Definition: Type.h:4080
QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T)
lookup_result noload_lookup(DeclarationName Name)
Find the declarations with the given name that are visible within this context; don&#39;t attempt to retr...
Definition: DeclBase.cpp:1607
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
Definition: Type.h:5046
Represents Objective-C&#39;s @synchronized statement.
Definition: StmtObjC.h:270
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:331
TypeSourceInfo * getNamedTypeInfo() const
getNamedTypeInfo - Returns the source type info associated to the name.
TypeSourceInfo * getTypeSourceInfo() const
Definition: Expr.h:2069
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
static ObjCTypeParamList * create(ASTContext &ctx, SourceLocation lAngleLoc, ArrayRef< ObjCTypeParamDecl *> typeParams, SourceLocation rAngleLoc)
Create a new Objective-C type parameter list.
Definition: DeclObjC.cpp:1388
unsigned size() const
Returns the number of designators in this initializer.
Definition: Expr.h:4488
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:3830
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:67
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2301
SourceLocation getAtTryLoc() const
Retrieve the location of the @ in the @try.
Definition: StmtObjC.h:199
Expr * VisitPredefinedExpr(PredefinedExpr *E)
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Definition: Expr.h:1185
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
Definition: Expr.cpp:808
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
static DependentScopeDeclRefExpr * Create(const ASTContext &C, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:421
Represents the type decltype(expr) (C++11).
Definition: Type.h:4011
QualType VisitConstantArrayType(const ConstantArrayType *T)
ArrayTypeTrait getTrait() const
Definition: ExprCXX.h:2552
EnumDecl * getDefinition() const
Definition: Decl.h:3389
Defines the clang::TypeLoc interface and its subclasses.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
Definition: TemplateName.h:481
A namespace alias, stored as a NamespaceAliasDecl*.
ParmVarDecl *const * param_iterator
Definition: DeclObjC.h:384
protocol_loc_iterator protocol_loc_begin() const
Definition: DeclObjC.h:1420
bool containsDeclAndLoad(Decl *D) const
Checks whether a declaration is in this context.
Definition: DeclBase.cpp:1350
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
Definition: Decl.cpp:3457
unsigned size() const
Definition: Stmt.h:642
llvm::SmallVector< Decl *, 2 > getCanonicalForwardRedeclChain(Decl *D)
Definition: ASTImporter.cpp:87
ArrayRef< Expr * > inits()
Definition: Expr.h:4090
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn&#39;t a simple identifier.
void setImplementation(ObjCImplementationDecl *ImplD)
Definition: DeclObjC.cpp:1516
void setConstexpr(bool IC)
Definition: Decl.h:1386
Expr * VisitCXXDeleteExpr(CXXDeleteExpr *E)
SourceRange getAngleBrackets() const LLVM_READONLY
Definition: ExprCXX.h:287
Kind getKind() const
Determine what kind of offsetof node this is.
Definition: Expr.h:1975
Stmt * VisitObjCAtTryStmt(ObjCAtTryStmt *S)
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition: Decl.cpp:2626
FunctionDecl * FindFunctionTemplateSpecialization(FunctionDecl *FromFD)
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
QualType getType() const
Definition: Expr.h:128
bool isFunctionOrMethod() const
Definition: DeclBase.h:1392
Expr * VisitCXXThisExpr(CXXThisExpr *E)
A unary type transform, which is a type constructed from another.
Definition: Type.h:4054
Optional< TemplateArgumentLoc > ImportTemplateArgumentLoc(const TemplateArgumentLoc &TALoc)
static LambdaExpr * Create(const ASTContext &C, CXXRecordDecl *Class, SourceRange IntroducerRange, LambdaCaptureDefault CaptureDefault, SourceLocation CaptureDefaultLoc, ArrayRef< LambdaCapture > Captures, bool ExplicitParams, bool ExplicitResultType, ArrayRef< Expr *> CaptureInits, SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack)
Construct a new lambda expression.
Definition: ExprCXX.cpp:946
SourceLocation getSwitchLoc() const
Definition: Stmt.h:1105
Declaration of an alias template.
void ImportDeclarationNameLoc(const DeclarationNameInfo &From, DeclarationNameInfo &To)
LabelDecl * getLabel() const
Definition: Stmt.h:1341
const Stmt * getTryBody() const
Retrieve the @try body.
Definition: StmtObjC.h:203
Decl * GetAlreadyImportedOrNull(Decl *FromD)
Return the copy of the given declaration in the "to" context if it has already been imported from the...
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:1476
void setPointOfInstantiation(SourceLocation Loc)
SourceLocation getDoLoc() const
Definition: Stmt.h:1230
Expr * VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E)
SourceLocation getAtLoc() const
Definition: StmtObjC.h:379
SourceLocation getLBracketLoc() const
Definition: Expr.h:4438
SourceLocation getRBracketLoc() const
Definition: Expr.h:2290
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1805
bool isInstanceMethod() const
Definition: DeclObjC.h:454
Represents a GCC generic vector type.
Definition: Type.h:3024
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2705
bool usesGNUSyntax() const
Determines whether this designated initializer used the deprecated GNU syntax for designated initiali...
Definition: Expr.h:4518
static bool CanThrow(Expr *E, ASTContext &Ctx)
Definition: CFG.cpp:2396
AtomicOp getOp() const
Definition: Expr.h:5377
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization, retrieves the member specialization information.
Definition: DeclCXX.cpp:1571
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2576
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Stmt * VisitReturnStmt(ReturnStmt *S)
UTTKind getUTTKind() const
Definition: Type.h:4082
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3946
bool isBaseOfClass() const
Determine whether this base class is a base of a class declared with the &#39;class&#39; keyword (vs...
Definition: DeclCXX.h:251
const OffsetOfNode & getComponent(unsigned Idx) const
Definition: Expr.h:2076
unsigned getNumArgs() const
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression which will be evaluated if the condition evaluates to true; th...
Definition: Expr.h:3556
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
Definition: Expr.h:1114
ValueDecl * getDecl()
Definition: Expr.h:1059
void setDescribedClassTemplate(ClassTemplateDecl *Template)
Definition: DeclCXX.cpp:1589
SourceLocation getRParenLoc() const
Definition: Expr.h:3986
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2762
The result type of a method or function.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2052
SourceLocation getForLoc() const
Definition: StmtObjC.h:53
const Expr * getSubExpr() const
Definition: Expr.h:1767
const Expr * getSubExpr() const
Definition: ExprCXX.h:1268
SourceLocation getPackLoc() const
Determine the location of the parameter pack.
Definition: ExprCXX.h:3895
CXXMethodDecl * getCallOperator() const
Retrieve the function call operator associated with this lambda expression.
Definition: ExprCXX.cpp:1018
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:720
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Definition: Expr.h:2259
QualType getType() const
Definition: DeclObjC.h:848
bool getValue() const
Definition: ExprCXX.h:569
bool hadMultipleCandidates() const
Returns true if this expression refers to a function that was resolved from an overloaded set having ...
Definition: Expr.h:1173
QualType VisitDependentTemplateSpecializationType(const DependentTemplateSpecializationType *T)
virtual ~ASTImporter()
const ExpansionInfo & getExpansion() const
Expr * VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E)
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Expr * getUnderlyingExpr() const
Definition: Type.h:3950
Decl * VisitObjCMethodDecl(ObjCMethodDecl *D)
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:216
ObjCProtocolList::iterator protocol_iterator
Definition: DeclObjC.h:1384
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:412
DoStmt - This represents a &#39;do/while&#39; stmt.
Definition: Stmt.h:1205
SourceLocation getOperatorLoc() const
Retrieve the location of the &#39;->&#39; or &#39;.&#39; operator.
Definition: ExprCXX.h:3397
AttrVec & getAttrs()
Definition: DeclBase.h:480
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
bool hasAttrs() const
Definition: DeclBase.h:474
SourceLocation getLParenLoc() const
Retrieve the location of the left parentheses (&#39;(&#39;) that precedes the argument list.
Definition: ExprCXX.h:3229
QualType VisitEnumType(const EnumType *T)
TypeSourceInfo * getReturnTypeSourceInfo() const
Definition: DeclObjC.h:377
RecordDecl * getDecl() const
Definition: Type.h:4145
bool capturesVariable() const
Determine whether this capture handles a variable.
Definition: LambdaCapture.h:89
void addAttr(Attr *A)
Definition: DeclBase.h:487
SpecifierKind
The kind of specifier that completes this nested name specifier.
const DeclarationNameInfo & getNameInfo() const
Retrieve the name that this expression refers to.
Definition: ExprCXX.h:2986
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:409
Expr * getArgument()
Definition: ExprCXX.h:2199
SourceLocation getExpansionLocEnd() const
SourceLocation getUsingLoc() const
Return the location of the using keyword.
Definition: DeclCXX.h:2995
void setTypeForDecl(const Type *TD)
Definition: Decl.h:2854
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:388
Expr * VisitParenListExpr(ParenListExpr *E)
A template template parameter pack that has been substituted for a template template argument pack...
Definition: TemplateName.h:211
CanThrowResult
Possible results from evaluation of a noexcept expression.
SourceLocation getUsingLoc() const
Returns the source location of the &#39;using&#39; keyword.
Definition: DeclCXX.h:3611
bool getValue() const
Definition: ExprCXX.h:3729
IdentifierInfo * getCXXLiteralIdentifier() const
getCXXLiteralIdentifier - If this name is the name of a literal operator, retrieve the identifier ass...
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:875
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template.
Expr * VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E)
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1720
SourceLocation getLocEnd() const LLVM_READONLY
Definition: ExprCXX.h:3725
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply...
SourceLocation getLParenLoc() const
Definition: Expr.h:2785
SelectorTable & Selectors
Definition: ASTContext.h:546
static CXXConstCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Definition: ExprCXX.cpp:672
Kind
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
Definition: ExprCXX.cpp:768
A field in a dependent type, known only by its name.
Definition: Expr.h:1930
QualType getCanonicalType() const
Definition: Type.h:5928
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1455
Decl * VisitIndirectFieldDecl(IndirectFieldDecl *D)
ExpressionTrait getTrait() const
Definition: ExprCXX.h:2618
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3529
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:191
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1196
param_type_range param_types() const
Definition: Type.h:3796
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
ElaboratedTypeKeyword getKeyword() const
Definition: Type.h:4906
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3679
const ContentCache * getContentCache() const
void setKNRPromoted(bool promoted)
Definition: Decl.h:1612
Decl * VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D)
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:2613
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis for a capture that is a pack expansion.
SourceLocation getNameLoc() const
Gets the location of the name.
Definition: ExprCXX.h:2746
bool inheritedFromVBase() const
Determine whether the inherited constructor is inherited from a virtual base of the object we constru...
Definition: ExprCXX.h:1504
unsigned getNumExprs() const
Definition: Expr.h:4812
void MakeSuper(ASTContext &Context, CXXRecordDecl *RD, SourceLocation SuperLoc, SourceLocation ColonColonLoc)
Turns this (empty) nested-name-specifier into &#39;__super&#39; nested-name-specifier.
bool isParameterPack() const
Returns whether this is a parameter pack.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Encodes a location in the source.
bool getSynthesize() const
Definition: DeclObjC.h:2012
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5568
body_range body()
Definition: Stmt.h:647
Sugar for parentheses used when specifying types.
Definition: Type.h:2363
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
QualType getReturnType() const
Definition: Type.h:3365
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:2041
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4161
SourceLocation getOperatorLoc() const
Definition: Expr.h:3181
QualType VisitFunctionProtoType(const FunctionProtoType *T)
ObjCProtocolList::iterator protocol_iterator
Definition: DeclObjC.h:2374
const Stmt * getCatchBody() const
Definition: StmtObjC.h:92
unsigned getNumHandlers() const
Definition: StmtCXX.h:107
SourceLocation createExpansionLoc(SourceLocation Loc, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd, unsigned TokLength, bool ExpansionIsTokenRange=true, int LoadedID=0, unsigned LoadedOffset=0)
Return a new SourceLocation that encodes the fact that a token from SpellingLoc should actually be re...
Expr * getSubExpr() const
Definition: Expr.h:1832
SourceLocation getSuperClassLoc() const
Definition: DeclObjC.h:2712
Represents a C++ temporary.
Definition: ExprCXX.h:1213
bool hasExplicitTemplateArgs() const
Determines whether this member expression actually had a C++ template argument list explicitly specif...
Definition: ExprCXX.h:3464
Represents typeof(type), a GCC extension.
Definition: Type.h:3984
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5555
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
Definition: ExprCXX.h:3022
QualType VisitDependentNameType(const DependentNameType *T)
Attr * clone(ASTContext &C) const
NestedNameSpecifierLoc getQualifierLoc() const
Retrieves the nested-name-specifier that qualifies the type name, with source-location information...
Definition: ExprCXX.h:2327
QualType VisitBuiltinType(const BuiltinType *T)
SourceLocation getNamespaceKeyLocation() const
Returns the location of the namespace keyword.
Definition: DeclCXX.h:2999
bool hasUnresolvedUsing() const
Determine whether the lookup results contain an unresolved using declaration.
Definition: ExprCXX.h:3620
CastKind getCastKind() const
Definition: Expr.h:2886
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameter list associated with this category or extension.
Definition: DeclObjC.h:2351
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:617
Expr * getSubExpr(unsigned Idx) const
Definition: Expr.h:4536
A structure for storing an already-substituted template template parameter pack.
Definition: TemplateName.h:121
const SwitchCase * getSwitchCaseList() const
Definition: Stmt.h:1094
SourceLocation getOperatorLoc() const
Retrieve the location of the cast operator keyword, e.g., static_cast.
Definition: ExprCXX.h:278
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1915
void setExternLoc(SourceLocation Loc)
Sets the location of the extern keyword.
Expr * getLHS()
Definition: Stmt.h:791
bool wasDeclaredWithTypename() const
Whether this template type parameter was declared with the &#39;typename&#39; keyword.
DeclarationName getName() const
getName - Returns the embedded declaration name.
ArrayRef< const Attr * > getAttrs() const
Definition: Stmt.h:952
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3020
SourceLocation getUsingLoc() const
Return the source location of the &#39;using&#39; keyword.
Definition: DeclCXX.h:3393
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that describes this pack expansion.
Definition: ExprCXX.h:3792
static SizeOfPackExpr * Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, Optional< unsigned > Length=None, ArrayRef< TemplateArgument > PartialArgs=None)
Definition: ExprCXX.cpp:1328
SourceLocation getCategoryNameLoc() const
Definition: DeclObjC.h:2548
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:166
TypeAliasTemplateDecl * getDescribedAliasTemplate() const
Definition: Decl.h:3011
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
llvm::iterator_range< capture_init_iterator > capture_inits()
Retrieve the initialization expressions for this lambda&#39;s captures.
Definition: ExprCXX.h:1783
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.h:401
ObjCCategoryDecl * getCategoryDecl() const
Definition: DeclObjC.cpp:2018
QualType getElementType() const
Definition: Type.h:3059
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:503
Decl * VisitTranslationUnitDecl(TranslationUnitDecl *D)
Represents the declaration of a label.
Definition: Decl.h:468
void setPropertyAttributesAsWritten(PropertyAttributeKind PRVal)
Definition: DeclObjC.h:875
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3579
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3621
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set...
Definition: Decl.h:2676
Decl * VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D)
Expr * VisitMemberExpr(MemberExpr *E)
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr *> exprs, SourceLocation RParenLoc)
Definition: Expr.cpp:1380
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:2208
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2045
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
Definition: ExprCXX.cpp:1073
SourceLocation getFriendLoc() const
Retrieves the location of the &#39;friend&#39; keyword.
Definition: DeclFriend.h:144
bool shouldForceImportDeclContext(ImportDefinitionKind IDK)
Expr * VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E)
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:186
bool canOverflow() const
Returns true if the unary operator can cause an overflow.
Definition: Expr.h:1845
SourceLocation getRParenLoc() const
Definition: Expr.h:3681
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
Definition: DeclTemplate.h:163
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
void addOverriddenMethod(const CXXMethodDecl *MD)
Definition: DeclCXX.cpp:2107
SourceLocation getIdentLocation() const
Returns the location of this using declaration&#39;s identifier.
Definition: DeclCXX.h:3002
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
Definition: DeclObjC.h:1513
void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc)
Turn this (empty) nested-name-specifier into the global nested-name-specifier &#39;::&#39;.
void ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To)
bool isBoundToLvalueReference() const
Determine whether this materialized temporary is bound to an lvalue reference; otherwise, it&#39;s bound to an rvalue reference.
Definition: ExprCXX.h:4226
bool isParameterPack() const
Definition: Type.h:4381
bool isPascal() const
Definition: Expr.h:1681
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Definition: DeclCXX.h:2969
Decl * VisitFunctionDecl(FunctionDecl *D)
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2301
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:360
QualType getEquivalentType() const
Definition: Type.h:4265
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>, and corresponding __opencl_atomic_* for OpenCL 2.0.
Definition: Expr.h:5313
unsigned capture_size() const
Determine the number of captures in this lambda.
Definition: ExprCXX.h:1750
UnaryExprOrTypeTrait getKind() const
Definition: Expr.h:2165
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:1903
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3493
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:89
QualType VisitTypedefType(const TypedefType *T)
Expr * VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E)
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:149
const TemplateArgumentListInfo & getTemplateArgsInfo() const
QualType getInnerType() const
Definition: Type.h:2376
SourceLocation getLParenLoc() const
Definition: Expr.h:3679
arg_range arguments()
Definition: Expr.h:2410
SourceLocation getGotoLoc() const
Definition: Stmt.h:1344
SourceLocation getAtFinallyLoc() const
Definition: StmtObjC.h:147
AccessSpecifier getAccess() const
void setPointOfInstantiation(SourceLocation Loc)
StringLiteral * getFunctionName()
Definition: Expr.cpp:469
StructuralEquivalenceKind
Whether to perform a normal or minimal equivalence check.
bool isMinimalImport() const
Whether the importer will perform a minimal import, creating to-be-completed forward declarations whe...
Definition: ASTImporter.h:123
const StringLiteral * getOutputConstraintLiteral(unsigned i) const
Definition: Stmt.h:1782
static CXXDefaultInitExpr * Create(const ASTContext &C, SourceLocation Loc, FieldDecl *Field)
Field is the non-static data member whose default initializer is used by this expression.
Definition: ExprCXX.h:1178
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:748
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
Definition: DeclObjC.h:2365
SourceLocation getLocEnd() const LLVM_READONLY
Definition: ExprCXX.h:2486
ASTNodeImporter(ASTImporter &Importer)
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2961
Stmt * VisitForStmt(ForStmt *S)
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:4975
SourceLocation getAtCatchLoc() const
Definition: StmtObjC.h:104
A simple visitor class that helps create declaration visitors.
Definition: DeclVisitor.h:70
CharacterKind getKind() const
Definition: Expr.h:1433
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1649
AutoTypeKeyword getKeyword() const
Definition: Type.h:4577
Expr * VisitLambdaExpr(LambdaExpr *LE)
QualType VisitRecordType(const RecordType *T)
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:397
Decl * VisitVarTemplateDecl(VarTemplateDecl *D)
IdentType getIdentType() const
Definition: Expr.h:1236
Stmt * VisitCompoundStmt(CompoundStmt *S)
Stmt * VisitIndirectGotoStmt(IndirectGotoStmt *S)
virtual Decl * Imported(Decl *From, Decl *To)
Subclasses can override this function to observe all of the From -> To declaration mappings as they a...
Definition: ASTImporter.h:319
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
An expression trait intrinsic.
Definition: ExprCXX.h:2579
Decl * VisitImplicitParamDecl(ImplicitParamDecl *D)
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:174
SourceLocation getMemberLocation() const
Definition: DeclCXX.h:2405
bool isImplicitInterfaceDecl() const
isImplicitInterfaceDecl - check that this is an implicitly declared ObjCInterfaceDecl node...
Definition: DeclObjC.h:1914
EnumDecl * getDecl() const
Definition: Type.h:4168
Expr * VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E)
ArrayRef< Expr * > exprs()
Definition: Expr.h:4826
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:1937
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3754
SourceLocation getExpansionLocStart() const
Stmt * VisitWhileStmt(WhileStmt *S)
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3654
SourceRange getBracketsRange() const
Definition: Type.h:2910
bool isArgumentType() const
Definition: Expr.h:2170
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:3492
ObjCImplementationDecl * getImplementation() const
Definition: DeclObjC.cpp:1503
SourceLocation getRBraceLoc() const
Definition: DeclCXX.h:2882
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Definition: Type.h:5196
Expr * VisitCallExpr(CallExpr *E)
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:4144
Decl * VisitLabelDecl(LabelDecl *D)
TypeSourceInfo * getTypeSourceInfo() const
Retrieves the type and source location of the base class.
Definition: DeclCXX.h:298
SourceLocation getStarLoc() const
Definition: Stmt.h:1383
QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T)
bool isCanonical() const
Definition: Type.h:5933
void setHasInheritedDefaultArg(bool I=true)
Definition: Decl.h:1665
bool passAlignment() const
Indicates whether the required alignment should be implicitly passed to the allocation function...
Definition: ExprCXX.h:2074
void sawArrayRangeDesignator(bool ARD=true)
Definition: Expr.h:4221
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:592
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2017
static CXXReinterpretCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Definition: ExprCXX.cpp:645
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
Definition: ExprCXX.h:3008
SourceLocation getIvarLBraceLoc() const
Definition: DeclObjC.h:2438
static MemberExpr * Create(const ASTContext &C, Expr *base, bool isarrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *memberdecl, DeclAccessPair founddecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *targs, QualType ty, ExprValueKind VK, ExprObjectKind OK)
Definition: Expr.cpp:1472
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2478
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4794
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:2944
void setVirtualAsWritten(bool V)
Definition: Decl.h:2037
const Expr * getInitializer() const
Definition: Expr.h:2778
Represents a pack expansion of types.
Definition: Type.h:5165
InitializationStyle getInitializationStyle() const
The kind of initializer this new-expression has.
Definition: ExprCXX.h:2053
Expr * getLHS() const
Definition: Expr.h:3187
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3351
SourceLocation getLocation() const LLVM_READONLY
Definition: ExprCXX.h:1506
Defines various enumerations that describe declaration and type specifiers.
A POD class for pairing a NamedDecl* with an access specifier.
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: Decl.h:1592
StringRef getName() const
Return the actual identifier string.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:3278
ArrayRef< TemplateArgument > getPartialArguments() const
Get.
Definition: ExprCXX.h:3923
void updateFlags(const Decl *From, Decl *To)
Definition: ASTImporter.cpp:93
SourceRange getRange() const
Definition: Attr.h:94
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3608
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers...
Definition: ExprObjC.h:1602
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2872
ast_type_traits::DynTypedNode Node
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Represents a template argument.
Definition: TemplateBase.h:51
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
Definition: Expr.h:3547
LabelStmt * getStmt() const
Definition: Decl.h:492
unsigned getManglingNumber() const
Definition: ExprCXX.h:4220
bool ImportDeclParts(NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC, DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc)
TypeSourceInfo * getDestroyedTypeInfo() const
Retrieve the source location information for the type being destroyed.
Definition: ExprCXX.h:2368
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "if" statement, if any.
Definition: Stmt.cpp:804
void setBody(Stmt *B)
Definition: Decl.cpp:2672
static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
Definition: DeclGroup.h:69
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
Represents a template name that was expressed as a qualified name.
Definition: TemplateName.h:366
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Definition: Expr.h:3563
protocol_iterator protocol_end() const
Definition: DeclObjC.h:2161
NullStmt - This is the null statement ";": C99 6.8.3p3.
Definition: Stmt.h:575
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2461
bool isTypeOperand() const
Definition: ExprCXX.h:711
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
Definition: DeclCXX.cpp:2494
Expr * VisitCXXNamedCastExpr(CXXNamedCastExpr *E)
virtual void CompleteDecl(Decl *D)
Called for ObjCInterfaceDecl, ObjCProtocolDecl, and TagDecl.
SourceLocation getLocation() const
Definition: ExprCXX.h:577
bool isNull() const
Determine whether this template name is NULL.
Dataflow Directional Tag Classes.
void setExtendingDecl(const ValueDecl *ExtendedBy, unsigned ManglingNumber)
Definition: ExprCXX.cpp:1388
TemplateName getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param, const TemplateArgument &ArgPack) const
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
bool isValid() const
Return true if this is a valid SourceLocation object.
bool isVolatile() const
Definition: Stmt.h:1562
tokloc_iterator tokloc_begin() const
Definition: Expr.h:1726
void ImportDeclContext(DeclContext *FromDC, bool ForceImport=false)
ExtInfo getExtInfo() const
Definition: Type.h:3376
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:499
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1208
DeclarationNameInfo getMemberNameInfo() const
Retrieve the member declaration name info.
Definition: Expr.h:2688
void setGetterName(Selector Sel, SourceLocation Loc=SourceLocation())
Definition: DeclObjC.h:928
NestedNameSpecifier * getQualifier() const
Definition: Type.h:5102
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1264
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2145
IdentifierInfo * getOutputIdentifier(unsigned i) const
Definition: Stmt.h:1771
PropertyAttributeKind getPropertyAttributesAsWritten() const
Definition: DeclObjC.h:871
SourceLocation getStartLoc() const LLVM_READONLY
Definition: Stmt.h:527
bool isSimple() const
Definition: Stmt.h:1559
TemplateArgument ImportTemplateArgument(const TemplateArgument &From)
Kind getPropertyImplementation() const
Definition: DeclObjC.h:2845
QualType VisitIncompleteArrayType(const IncompleteArrayType *T)
const Stmt * getFinallyBody() const
Definition: StmtObjC.h:136
SourceLocation getLocStart() const LLVM_READONLY
Definition: TypeLoc.h:154
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:80
SourceLocation getAtLoc() const
Definition: DeclObjC.h:840
QualType VisitAttributedType(const AttributedType *T)
const TemplateArgument * getArgs() const
Retrieve the template arguments.
Definition: Type.h:5106
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3488
bool isImplicit() const
Definition: ExprCXX.h:1010
attr_range attrs() const
Definition: DeclBase.h:497
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:2780
QualType getUnderlyingType() const
Definition: Decl.h:2927
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Definition: DeclCXX.h:3092
DeclContext * getCommonAncestor()
Returns the common ancestor context of this using-directive and its nominated namespace.
Definition: DeclCXX.h:2991
TypeSourceInfo * getTypeSourceInfo() const
Retrieve the type source information for the type being constructed.
Definition: ExprCXX.h:3225
AccessSpecifier getAccess() const
Definition: DeclBase.h:463
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Definition: DeclObjC.h:1570
QualType getUnderlyingType() const
Definition: Type.h:4022
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration, or explicit instantiation definition.
LambdaCaptureKind getCaptureKind() const
Determine the kind of capture.
Definition: ExprCXX.cpp:894
IdentifierNamespace
IdentifierNamespace - The different namespaces in which declarations may appear.
Definition: DeclBase.h:115
unsigned getIndex() const
Retrieve the index of the template parameter.
DeclarationName getMember() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3432
SourceLocation getLBraceLoc() const
Definition: Expr.h:4195
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3675
SourceLocation getSemiLoc() const
Definition: Stmt.h:596
DeclarationName - The name of a declaration.
StmtClass getStmtClass() const
Definition: Stmt.h:391
VectorKind getVectorKind() const
Definition: Type.h:3069
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:578
ArrayRef< QualType > exceptions() const
Definition: Type.h:3810
Expr * getDefaultArg()
Definition: Decl.cpp:2539
SourceRange getIntroducerRange() const
Retrieve the source range covering the lambda introducer, which contains the explicit capture list su...
Definition: ExprCXX.h:1819
Expr * VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E)
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3711
Expr * VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E)
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo &TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization...
Definition: Decl.cpp:3446
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3756
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
Definition: ExprCXX.h:1370
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
Definition: DeclCXX.cpp:1564
Decl * VisitClassTemplateDecl(ClassTemplateDecl *D)
SourceLocation getLocEnd() const LLVM_READONLY
Definition: ExprCXX.h:1862
void setInstantiationDependent(bool ID)
Set whether this expression is instantiation-dependent or not.
Definition: Expr.h:196
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:739
Represents an enum.
Definition: Decl.h:3313
const Expr * getSynchExpr() const
Definition: StmtObjC.h:298
void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin)
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2612
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:146
Expr * VisitExplicitCastExpr(ExplicitCastExpr *E)
Expr * VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE)
ExplicitCastExpr - An explicit cast written in the source code.
Definition: Expr.h:3039
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Tags, declared with &#39;struct foo;&#39; and referenced with &#39;struct foo&#39;.
Definition: DeclBase.h:125
void setInitializedFieldInUnion(FieldDecl *FD)
Definition: Expr.h:4168
Decl * VisitFunctionTemplateDecl(FunctionTemplateDecl *D)
A type that was preceded by the &#39;template&#39; keyword, stored as a Type*.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1068
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:4432
SourceLocation getSetterNameLoc() const
Definition: DeclObjC.h:934
Decl * VisitObjCIvarDecl(ObjCIvarDecl *D)
bool isNull() const
Determine whether this template argument has no value.
Definition: TemplateBase.h:238
Expr * VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE)
const Expr * Replacement
Definition: ParsedAttr.h:67
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it&#39;s the object of a friend declaration...
Definition: DeclBase.h:1071
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Definition: ExprCXX.h:718
const Stmt * getBody() const
Definition: Stmt.h:1093
Decl * VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D)
llvm::APInt getValue() const
Definition: Expr.h:1302
QualType getUnderlyingType() const
Definition: Type.h:4079
CXXRecordDecl * getNamingClass() const
Gets the &#39;naming class&#39; (in the sense of C++0x [class.access.base]p5) of the lookup.
Definition: ExprCXX.h:2905
QualType getModifiedType() const
Definition: Type.h:4264
LabelDecl * getLabel() const
Definition: Expr.h:3632
QualType VisitLValueReferenceType(const LValueReferenceType *T)
path_iterator path_end()
Definition: Expr.h:2917
Represents a pointer to an Objective C object.
Definition: Type.h:5611
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3702
SwitchStmt - This represents a &#39;switch&#39; stmt.
Definition: Stmt.h:1054
Pointer to a block type.
Definition: Type.h:2495
UsingDecl * getUsingDecl() const
Gets the using declaration to which this declaration is tied.
Definition: DeclCXX.cpp:2610
bool IsEquivalent(Decl *D1, Decl *D2)
Determine whether the two declarations are structurally equivalent.
SourceLocation getColonColonLoc() const
Retrieve the location of the &#39;::&#39; in a qualified pseudo-destructor expression.
Definition: ExprCXX.h:2356
SourceLocation getFieldLoc() const
Definition: Expr.h:4433
void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod)
Expr * VisitFloatingLiteral(FloatingLiteral *E)
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2573
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source location information.
Definition: ExprCXX.h:2998
SourceLocation getRParenLoc() const
Definition: StmtObjC.h:55
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
Definition: Type.h:3543
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4135
Complex values, per C99 6.2.5p11.
Definition: Type.h:2333
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
Definition: DeclBase.h:569
unsigned getIndexTypeCVRQualifiers() const
Definition: Type.h:2713
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4732
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
Definition: Decl.h:1657
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2581
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:3837
SourceLocation getLocEnd() const LLVM_READONLY
Definition: ExprCXX.h:2615
Imports selected nodes from one AST context into another context, merging AST nodes where appropriate...
Definition: ASTImporter.h:57
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2226
QualType getCanonicalTypeInternal() const
Definition: Type.h:2214
Represents Objective-C&#39;s collection statement.
Definition: StmtObjC.h:24
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2252
Expr * VisitCXXNoexceptExpr(CXXNoexceptExpr *E)
Expr * VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E)
unsigned getNumObjects() const
Definition: ExprCXX.h:3125
IndirectFieldDecl * getIndirectMember() const
Definition: DeclCXX.h:2399
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:1751
SourceLocation getLocation() const
Retrieve the location of this expression.
Definition: Expr.h:905
SourceLocation getRParenLoc() const
Determine the location of the right parenthesis.
Definition: ExprCXX.h:3898
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
bool IsStructuralMatch(Decl *From, Decl *To, bool Complain)
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
Definition: Expr.cpp:1810
An implicit indirection through a C++ base class, when the field found is in a base class...
Definition: Expr.h:1933
const llvm::APInt & getSize() const
Definition: Type.h:2746
Kind getAttrKind() const
Definition: Type.h:4260
Expr * getCond() const
getCond - Return the condition expression; this is defined in terms of the opaque value...
Definition: Expr.h:3551
protocol_iterator protocol_begin() const
Definition: DeclObjC.h:2381
void setBuiltinID(unsigned ID)
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:716
Stmt * getInit()
Definition: Stmt.h:1089
bool doesUsualArrayDeleteWantSize() const
Answers whether the usual array deallocation function for the allocated type expects the size of the ...
Definition: ExprCXX.h:2081
ExtVectorType - Extended vector type.
Definition: Type.h:3143
SourceRange getDirectInitRange() const
Definition: ExprCXX.h:2124
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the member name, with source location information...
Definition: ExprCXX.h:3407
Opcode getOpcode() const
Definition: Expr.h:1829
virtual void CompleteType(TagDecl *Tag)
Gives the external AST source an opportunity to complete an incomplete type.
param_const_iterator param_begin() const
Definition: DeclObjC.h:388
SourceRange getBracketsRange() const
Definition: Type.h:2853
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1675
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2251
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
Definition: DeclObjC.h:1936
StringRef getBytes() const
Allow access to clients that need the byte representation, such as ASTWriterStmt::VisitStringLiteral(...
Definition: Expr.h:1641
Represents Objective-C&#39;s @finally statement.
Definition: StmtObjC.h:124
The template argument is a type.
Definition: TemplateBase.h:60
QualType getUnderlyingType() const
Definition: Type.h:3999
void setInstantiationOfMemberClass(CXXRecordDecl *RD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member class RD.
Definition: DeclCXX.cpp:1576
void setSetterName(Selector Sel, SourceLocation Loc=SourceLocation())
Definition: DeclObjC.h:936
bool ImportContainerChecked(const InContainerTy &InContainer, OutContainerTy &OutContainer)
The template argument is actually a parameter pack.
Definition: TemplateBase.h:91
bool isArrow() const
Determine whether this member expression used the &#39;->&#39; operator; otherwise, it used the &#39;...
Definition: ExprCXX.h:3394
Represents a base class of a C++ class.
Definition: DeclCXX.h:192
Decl * VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D)
QualType VisitUnaryTransformType(const UnaryTransformType *T)
bool hasTypename() const
Return true if the using declaration has &#39;typename&#39;.
Definition: DeclCXX.h:3415
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
unsigned getNumClobbers() const
Definition: Stmt.h:1609
Decl * VisitObjCTypeParamDecl(ObjCTypeParamDecl *D)
SourceLocation getRParenLoc() const
Definition: Stmt.h:1307
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3532
SourceManager & getSourceManager()
Definition: ASTContext.h:651
void setObjCMethodScopeInfo(unsigned parameterIndex)
Definition: Decl.h:1563
bool isPartiallySubstituted() const
Determine whether this represents a partially-substituted sizeof...
Definition: ExprCXX.h:3918
The type-property cache.
Definition: Type.cpp:3464
Expr * VisitCXXNewExpr(CXXNewExpr *CE)
DeclStmt * getRangeStmt()
Definition: StmtCXX.h:156
Stmt * VisitObjCAtThrowStmt(ObjCAtThrowStmt *S)
unsigned arg_size() const
Retrieve the number of arguments.
Definition: ExprCXX.h:3243
ImplementationControl getImplementationControl() const
Definition: DeclObjC.h:504
SourceLocation getLocEnd() const LLVM_READONLY
Definition: ExprCXX.h:2549
llvm::iterator_range< decls_iterator > decls() const
Definition: ExprCXX.h:2732
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:3183
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2235
SourceLocation getAsmLoc() const
Definition: Stmt.h:1556
outputs_range outputs()
Definition: Stmt.h:1661
GotoStmt - This represents a direct goto.
Definition: Stmt.h:1329
void ImportDefinition(Decl *From)
Import the definition of the given declaration, including all of the declarations it contains...
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1160
Expr * getTarget()
Definition: Stmt.h:1385
void setHadMultipleCandidates(bool V=true)
Sets the flag telling whether this expression refers to a function that was resolved from an overload...
Definition: Expr.h:1179
A template argument list.
Definition: DeclTemplate.h:210
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:239
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
Definition: ExprCXX.h:3447
SourceLocation getCXXLiteralOperatorNameLoc() const
getCXXLiteralOperatorNameLoc - Returns the location of the literal operator name (not the operator ke...
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1585
TypedefNameDecl * getDecl() const
Definition: Type.h:3932
const SwitchCase * getNextSwitchCase() const
Definition: Stmt.h:738
Decl * VisitTypeAliasDecl(TypeAliasDecl *D)
static UnresolvedMemberExpr * Create(const ASTContext &C, bool HasUnresolvedUsing, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.cpp:1264
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Definition: Type.h:3535
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: Expr.h:1167
Expr * VisitInitListExpr(InitListExpr *E)
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:235
shadow_range shadows() const
Definition: DeclCXX.h:3460
unsigned getDepth() const
Definition: Type.h:4379
DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II)
getCXXLiteralOperatorName - Get the name of the literal operator function with II as the identifier...
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4190
Expr * getCond()
Definition: Stmt.h:1223
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:997
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2500
Decl * VisitUsingDirectiveDecl(UsingDirectiveDecl *D)
SourceLocation getWhileLoc() const
Definition: Stmt.h:1232
Defines the clang::SourceLocation class and associated facilities.
SourceLocation getCategoryNameLoc() const
Definition: DeclObjC.h:2434
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3261
void setDefaultArg(Expr *defarg)
Definition: Decl.cpp:2551
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2609
Represents a C++ struct/union/class.
Definition: DeclCXX.h:302
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:5072
ContinueStmt - This represents a continue.
Definition: Stmt.h:1410
bool isValid() const
Expr * VisitDesignatedInitExpr(DesignatedInitExpr *E)
Represents a loop initializing the elements of an array.
Definition: Expr.h:4678
Expr * VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E)
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:76
static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, Stmt *tryBlock, ArrayRef< Stmt *> handlers)
Definition: StmtCXX.cpp:26
SourceLocation getColonLoc() const
Definition: StmtCXX.h:197
Represents a C array with an unspecified size.
Definition: Type.h:2782
TemplateArgumentLocInfo getLocInfo() const
Definition: TemplateBase.h:503
SourceLocation getEllipsisLoc() const
For a pack expansion, determine the location of the ellipsis.
Definition: DeclCXX.h:265
SourceLocation getAttrLoc() const
Definition: Stmt.h:951
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Definition: ExprCXX.cpp:763
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3504
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:29
An index into an array.
Definition: Expr.h:1926
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
Definition: Decl.h:3485
Expr * getRHS() const
Definition: Expr.h:3475
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1966
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:964
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:608
QualType getNamedType() const
Retrieve the type named by the qualified-id.
Definition: Type.h:4978
WhileStmt - This represents a &#39;while&#39; stmt.
Definition: Stmt.h:1147
A structure for storing the information associated with an overloaded template name.
Definition: TemplateName.h:95
static StructuralEquivalenceKind getStructuralEquivalenceKind(const ASTImporter &Importer)
SourceRange getParenOrBraceRange() const
Definition: ExprCXX.h:1437
CleanupObject getObject(unsigned i) const
Definition: ExprCXX.h:3127
unsigned getNumConcatenated() const
getNumConcatenated - Get the number of string literal tokens that were concatenated in translation ph...
Definition: Expr.h:1701
Expr * VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E)
bool isNull() const
Determine whether this is the empty selector.
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4438
Location information for a TemplateArgument.
Definition: TemplateBase.h:393
bool isFailed() const
Definition: DeclCXX.h:3783
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:214
Declaration of a class template.
SourceLocation getAtSynchronizedLoc() const
Definition: StmtObjC.h:287
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:656
Stmt * VisitSwitchStmt(SwitchStmt *S)
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2250
Optional< unsigned > getNumExpansions() const
Determine the number of expansions that will be produced when this pack expansion is instantiated...
Definition: ExprCXX.h:3796
bool isVariadic() const
Definition: DeclObjC.h:456
CompoundStmt * getTryBlock()
Definition: StmtCXX.h:100
bool ImportCastPath(CastExpr *E, CXXCastPath &Path)
SourceLocation getBreakLoc() const
Definition: Stmt.h:1450
SourceLocation getCaseLoc() const
Definition: Stmt.h:784
capture_range captures() const
Retrieve this lambda&#39;s captures.
Definition: ExprCXX.cpp:984
void setPropertyAttributes(PropertyAttributeKind PRVal)
Definition: DeclObjC.h:863
Expr * VisitArraySubscriptExpr(ArraySubscriptExpr *E)
Represents Objective-C&#39;s @try ... @catch ... @finally statement.
Definition: StmtObjC.h:160
protocol_iterator protocol_end() const
Definition: DeclObjC.h:2385
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:266
bool isGlobalDelete() const
Definition: ExprCXX.h:2185
Expr * VisitVAArgExpr(VAArgExpr *E)
SourceLocation getLocation() const
Retrieve the source location of the capture.
unsigned getNumCatchStmts() const
Retrieve the number of @catch statements in this try-catch-finally block.
Definition: StmtObjC.h:209
Expr * getBase() const
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3385
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1585
bool hasExplicitParameters() const
Determine whether this lambda has an explicit parameter list vs.
Definition: ExprCXX.h:1848
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2316
Expr * VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E)
Expr * VisitArrayInitIndexExpr(ArrayInitIndexExpr *E)
SourceRange getTypeIdParens() const
Definition: ExprCXX.h:2045
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Definition: Decl.h:3442
Expr * getPattern()
Retrieve the pattern of the pack expansion.
Definition: ExprCXX.h:3785
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:2025
Expr * VisitOpaqueValueExpr(OpaqueValueExpr *E)
Stmt * VisitDefaultStmt(DefaultStmt *S)
Import only the bare bones needed to establish a valid DeclContext.
SourceLocation getEllipsisLoc() const
Get the location of the ellipsis if this is a pack expansion.
Definition: DeclCXX.h:3728
NameKind getKind() const
Abstract class common to all of the C++ "named"/"keyword" casts.
Definition: ExprCXX.h:248
unsigned getNumElements() const
Definition: Type.h:3060
QualType VisitExtVectorType(const ExtVectorType *T)
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
Definition: ExprCXX.h:2773
void setNextSwitchCase(SwitchCase *SC)
Definition: Stmt.h:742
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:226
The top declaration context.
Definition: Decl.h:107
void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD=nullptr)
unsigned getNumComponents() const
Definition: Expr.h:2086
const ParmVarDecl * getParam() const
Definition: ExprCXX.h:1118
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:257
QualType VisitTypeOfExprType(const TypeOfExprType *T)
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:974
Expr * VisitBinaryConditionalOperator(BinaryConditionalOperator *E)
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4654
Expr * getRHS() const
Definition: Expr.h:3189
ObjCPropertyDecl * getPropertyDecl() const
Definition: DeclObjC.h:2840
ObjCTypeParamVariance getVariance() const
Determine the variance of this type parameter.
Definition: DeclObjC.h:621
SourceLocation getColonLoc() const
Definition: Stmt.h:788
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
Definition: ExprCXX.h:2755
BreakStmt - This represents a break.
Definition: Stmt.h:1438
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:3246
void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL, SourceLocation ColonColonLoc)
Extend the current nested-name-specifier by another nested-name-specifier component of the form &#39;type...
SourceLocation getUsingLoc() const
Returns the source location of the &#39;using&#39; keyword.
Definition: DeclCXX.h:3704
const VarDecl * getCatchParamDecl() const
Definition: StmtObjC.h:96
SourceLocation getLocation() const
Definition: Expr.h:1432
void setObjCDeclQualifier(ObjCDeclQualifier QTVal)
Definition: Decl.h:1596
Expr * VisitExprWithCleanups(ExprWithCleanups *EWC)
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:4162
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding the member name, if any.
Definition: ExprCXX.h:3440
Expr * VisitCompoundLiteralExpr(CompoundLiteralExpr *E)
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
Definition: Decl.cpp:2009
Stmt * getSubStmt()
Definition: Stmt.h:895
bool hadMultipleCandidates() const
Whether the referred constructor was resolved from an overloaded set having size greater than 1...
Definition: ExprCXX.h:1366
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace nested inside this namespace, if any.
Definition: Decl.h:597
SourceLocation getNamespaceLoc() const
Returns the location of the namespace keyword.
Definition: DeclCXX.h:3117
Expr * VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E)
DeclStmt * getLoopVarStmt()
Definition: StmtCXX.h:163
QualType getType() const
Definition: Decl.h:648
AccessSpecifier getAccessSpecifierAsWritten() const
Retrieves the access specifier as written in the source code (which may mean that no access specifier...
Definition: DeclCXX.h:286
TemplateArgument getArgumentPack() const
Retrieve the template template argument pack with which this parameter was substituted.
unsigned getNumArgs() const
Definition: ExprCXX.h:1415
protocol_loc_iterator protocol_loc_begin() const
Definition: DeclObjC.h:2175
A set of overloaded template declarations.
Definition: TemplateName.h:194
const Expr * getCond() const
Definition: Stmt.h:1010
A trivial tuple used to represent a source range.
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:299
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:941
This represents a decl that may have a name.
Definition: Decl.h:248
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding the member name, if any.
Definition: Expr.h:2631
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:556
Expr * VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E)
static DeclarationName getUsingDirectiveName()
getUsingDirectiveName - Return name for all using-directives.
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
Definition: Expr.h:2027
protocol_loc_iterator protocol_loc_begin() const
Definition: DeclObjC.h:2395
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:458
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.h:2009
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2827
Expr * VisitSizeOfPackExpr(SizeOfPackExpr *E)
Expr * getQueriedExpression() const
Definition: ExprCXX.h:2620
Decl * VisitNamespaceDecl(NamespaceDecl *D)
Represents a C++ namespace alias.
Definition: DeclCXX.h:3028
Decl * VisitObjCInterfaceDecl(ObjCInterfaceDecl *D)
SourceLocation getBuiltinLoc() const
Definition: Expr.h:5403
Stmt * VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S)
TemplateDecl * getDescribedTemplate() const
If this is a declaration that describes some template, this method returns that template declaration...
Definition: DeclBase.cpp:230
QualType VisitAtomicType(const AtomicType *T)
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Definition: DeclCXX.h:235
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:281
AccessControl getAccessControl() const
Definition: DeclObjC.h:2005
SourceLocation getIvarRBraceLoc() const
Definition: DeclObjC.h:2440
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
Definition: Expr.h:3544
bool isPropertyAccessor() const
Definition: DeclObjC.h:461
TypeSourceInfo * getWrittenTypeInfo() const
Definition: Expr.h:3980
Selector getGetterName() const
Definition: DeclObjC.h:925
ImplicitParamKind getParameterKind() const
Returns the implicit parameter kind.
Definition: Decl.h:1525
Represents C++ using-directive.
Definition: DeclCXX.h:2924
DeclStmt * getBeginStmt()
Definition: StmtCXX.h:157
SourceLocation getLParenLoc() const
Definition: DeclObjC.h:843
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
Definition: DeclTemplate.h:648
const Expr * getCond() const
Definition: Stmt.h:1092
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
Definition: DeclTemplate.h:653
The global specifier &#39;::&#39;. There is no stored value.
ObjCProtocolList::iterator protocol_iterator
Definition: DeclObjC.h:2147
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
void setType(QualType newType)
Definition: Decl.h:649
bool hasInit() const
Definition: Decl.cpp:2144
SourceLocation getBegin() const
TranslationUnitDecl * getTranslationUnitDecl()
Definition: DeclBase.cpp:361
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:102
SourceLocation getRParenLoc() const
Return the location of the right parentheses.
Definition: Expr.h:2066
Decl * VisitParmVarDecl(ParmVarDecl *D)
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
Definition: Decl.h:730
NamedDecl * getPack() const
Retrieve the parameter pack.
Definition: ExprCXX.h:3901
QualType VisitRValueReferenceType(const RValueReferenceType *T)
Represents Objective-C&#39;s @autoreleasepool Statement.
Definition: StmtObjC.h:357
Stmt * VisitGCCAsmStmt(GCCAsmStmt *S)
QualType VisitAutoType(const AutoType *T)
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2520
IdentifierInfo * getFieldName() const
Definition: Expr.cpp:3763
This class handles loading and caching of source files into memory.
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2728
Stmt * getSubStmt()
Definition: Stmt.h:956
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3557
QualType VisitType(const Type *T)
DeclContext * ImportContext(DeclContext *FromDC)
Import the given declaration context from the "from" AST context into the "to" AST context...
InitListExpr * getSyntacticForm() const
Definition: Expr.h:4207
Declaration of a template function.
Definition: DeclTemplate.h:968
void setPropertyIvarDecl(ObjCIvarDecl *Ivar)
Definition: DeclObjC.h:960
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4772
static ObjCAtTryStmt * Create(const ASTContext &Context, SourceLocation atTryLoc, Stmt *atTryStmt, Stmt **CatchStmts, unsigned NumCatchStmts, Stmt *atFinallyStmt)
Definition: StmtObjC.cpp:46
SourceLocation getReturnLoc() const
Definition: Stmt.h:1495
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateDecl *Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
Expr * VisitCXXThrowExpr(CXXThrowExpr *E)
Stmt * VisitStmt(Stmt *S)
Attr - This represents one attribute.
Definition: Attr.h:43
SourceLocation getLocation() const
Definition: DeclBase.h:419
QualType VisitTypeOfType(const TypeOfType *T)
QualType getPointeeType() const
Definition: Type.h:2632
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3147
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
TypeTrait getTrait() const
Determine which type trait this expression uses.
Definition: ExprCXX.h:2460
A single template declaration.
Definition: TemplateName.h:191
bool isBeingDefined() const
Return true if this decl is currently being defined.
Definition: Decl.h:3182
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
Defines the LambdaCapture class.
const DeclarationNameInfo & getMemberNameInfo() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3426
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:407
Expr * VisitStmtExpr(StmtExpr *E)
EvaluatedStmt * ensureEvaluatedStmt() const
Convert the initializer for this declaration to the elaborated EvaluatedStmt form, which contains extra information on the evaluated value of the initializer.
Definition: Decl.cpp:2224
const IdentifierInfo * getIdentifier() const
Definition: Type.h:5103
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition: Decl.h:375
ConstructionKind getConstructionKind() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
Definition: ExprCXX.h:1389
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
Structure used to store a statement, the constant value to which it was evaluated (if any)...
Definition: Decl.h:785
QualType VisitPackExpansionType(const PackExpansionType *T)
Stmt * getSubStmt()
Definition: Stmt.h:793
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5627
method_range methods() const
Definition: DeclCXX.h:867
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.
bool isOverloaded() const
True if this lookup is overloaded.
Definition: ExprCXX.h:2900
void notePriorDiagnosticFrom(const DiagnosticsEngine &Other)
Note that the prior diagnostic was emitted by some other DiagnosticsEngine, and we may be attaching a...
Definition: Diagnostic.h:798