Avoid Decl::getASTContext in hot paths where possible, Part 1

[riccibruno]

Summary

Decl::getASTContext and DeclContext::getParentASTContext are not that cheap
since they must walk back to the TUDecl, potentially after many cache misses along the way.

Instrumentation shows that most of the iterations in getTranslationUnitDecl could be
eliminated by passing a ref to the ASTContext as a function parameter.
The goal here is not to remove all the calls to getASTContext, but instead
eliminate a good fraction of the iterations in getTranslationUnitDecl.

instrumentation_ref_d0fc1788129 KBDownload

This patch deals with:

VarDecl::isThisDeclarationADefinition
VarTemplateDecl::isThisDeclarationADefinition
Decl::canBeWeakImported
Decl::isWeakImported
VarDecl::getActingDefinition
ValueDecl::isWeak
VarDecl::checkInitIsICE
ComparisonCategoryInfo::ValueInfo::getIntValue
ComparisonCategoryInfo::ValueInfo::hasValidIntValue
VarDecl::isKnownToBeDefined
VarDecl::getDefinition
VarDecl::hasDefinition
VarTemplateDecl::getDefinition
VarDecl::getTemplateInstantiationPattern

[aaron.ballman]

I'd like @rsmith's opinion on whether this is a good churn or not. I think it's mostly reasonable, but it's also a lot of changes for identical behavior and in some cases the changes are a bit unfortunate.

include/clang/ASTMatchers/ASTMatchers.h

4504

I don't care for this refactoring -- the new code repeats the types from the function definition and is considerably harder to read.

lib/AST/Decl.cpp

2386

Bad use of auto, though it is used above so maybe it should stay for local consistency.

lib/Sema/SemaDecl.cpp

2860

I'm not keen on the code duplication. :-(

[riccibruno]

Just to expend on the instrumentation results: The measurement was done with all of Boost. I would take the estimation of the time wasted with
a grain of salt since this is just num_iterations * 10ns which is obviously a very rough estimation.
However on my machine I get that removing half of the iterations in getTranslationUnitDecl reduce the run-time of an fsyntax-only by a little more than 1%.

Extrapolating from this, this could be worth about 2% if we remove, say 80%, of the iterations in getTranslationUnitDecl.

I guess that the question is: Is this churn worth about 2% ? I would like to argue that yes since:

1. 2% is a lot for something that is morally a simple getter.
2. The methods of the expression classes must already take a ref to the ASTContext if they need it.
3. In the vast majority of cases the context is already easily available. It is true though that this requires propagating it in some functions.
4. This figure do not include some potential gains in the time needed to do the AST -> LLVM IR code generation.
5. I suspect (but have not done the measurement) that the gain is even greater during a typical compilation where more than one thread is used since possibly more iterations are going to cause an expensive LLC miss.

[riccibruno]

Addressed inline comments

[vsk]

Thanks for working on this :). It’d be interesting to see some pre/post patch compile time numbers on CTMark.

Naive/strawman alternative here, but: what’s the impact on peak RSS and compile time of just storing an ASTContext pointer in Decl/DeclContext? If it’s not out of the question to grow Decl etc. and it gives a nice speed up, that might be a simpler approach.

[riccibruno]

In D55658#1332240, @vsk wrote:

Thanks for working on this :). It’d be interesting to see some pre/post patch compile time numbers on CTMark.

Naive/strawman alternative here, but: what’s the impact on peak RSS and compile time of just storing an ASTContext pointer in Decl/DeclContext? If it’s not out of the question to grow Decl etc. and it gives a nice speed up, that might be a simpler approach.

I will try to get some numbers from CTMark.

I don't think that storing a ref/pointer to the ASTContext in each DeclContext (no point in storing it in Decl) is a great idea.
I experimented with this and the speedup from avoiding the lookup of the ASTContext is almost completely offset by
the slowdown from the increased memory usage.

[vsk]

In D55658#1332249, @riccibruno wrote:

In D55658#1332240, @vsk wrote:

Thanks for working on this :). It’d be interesting to see some pre/post patch compile time numbers on CTMark.

Naive/strawman alternative here, but: what’s the impact on peak RSS and compile time of just storing an ASTContext pointer in Decl/DeclContext? If it’s not out of the question to grow Decl etc. and it gives a nice speed up, that might be a simpler approach.

I will try to get some numbers from CTMark.

I don't think that storing a ref/pointer to the ASTContext in each DeclContext (no point in storing it in Decl) is a great idea.
I experimented with this and the speedup from avoiding the lookup of the ASTContext is almost completely offset by
the slowdown from the increased memory usage.

Good to know, thanks for trying it out!

include/clang/AST/ComparisonCategories.h

struct ValueInfo {
     ComparisonCategoryResult Kind;
     VarDecl *VD;
 
     ValueInfo(ComparisonCategoryResult Kind, VarDecl *VD)
         : Kind(Kind), VD(VD) {}
 
     /// True iff we've successfully evaluated the variable as a constant
     /// expression and extracted its integer value.
-    bool hasValidIntValue() const;
+    bool hasValidIntValue(const ASTContext &Context) const;
 
     /// Get the constant integer value used by this variable to represent
     /// the comparison category result type.
-    llvm::APSInt getIntValue() const;
+    llvm::APSInt getIntValue(const ASTContext &Context) const;
   };
 private:
   const ASTContext &Ctx;
 
   /// A map containing the comparison category result decls from the
   /// standard library. The key is a value of ComparisonCategoryResult.
   mutable llvm::SmallVector<
       ValueInfo, static_cast<unsigned>(ComparisonCategoryResult::Last) + 1>

 
 public:
   QualType getType() const;
 
   const ValueInfo *getValueInfo(ComparisonCategoryResult ValueKind) const {
     ValueInfo *Info = lookupValueInfo(ValueKind);
     assert(Info &&
            "comparison category does not contain the specified result kind");
-    assert(Info->hasValidIntValue() &&
+    assert(Info->hasValidIntValue(Ctx) &&
            "couldn't determine the integer constant for this value");
     return Info;
   }
 
   /// True iff the comparison category is an equality comparison.
   bool isEquality() const { return !isOrdered(); }
 
   /// True iff the comparison category is a relational comparison.

include/clang/AST/Decl.h

ValueDecl(Kind DK, DeclContext *DC, SourceLocation L,
     : NamedDecl(DK, DC, L, N), DeclType(T) {}
 
 public:
   QualType getType() const { return DeclType; }
   void setType(QualType newType) { DeclType = newType; }
 
   /// Determine whether this symbol is weakly-imported,
   ///        or declared with the weak or weak-ref attr.
-  bool isWeak() const;
+  bool isWeak(const ASTContext &Context) const;
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
 };
 
 /// A struct with extended info about a syntactic
 /// name qualifier, to be used for the case of out-of-line declarations.
enum DefinitionKind {
 
     /// This declaration is definitely a definition.
     Definition
   };
 
   /// Check whether this declaration is a definition. If this could be
   /// a tentative definition (in C), don't check whether there's an overriding
   /// definition.
-  DefinitionKind isThisDeclarationADefinition(ASTContext &) const;
-  DefinitionKind isThisDeclarationADefinition() const {
-    return isThisDeclarationADefinition(getASTContext());
-  }
+  DefinitionKind isThisDeclarationADefinition(const ASTContext &Context) const;
 
   /// Check whether this variable is defined in this translation unit.
-  DefinitionKind hasDefinition(ASTContext &) const;
-  DefinitionKind hasDefinition() const {
-    return hasDefinition(getASTContext());
-  }
+  DefinitionKind hasDefinition(const ASTContext &Context) const;
 
   /// Get the tentative definition that acts as the real definition in a TU.
   /// Returns null if there is a proper definition available.
-  VarDecl *getActingDefinition();
-  const VarDecl *getActingDefinition() const {
-    return const_cast<VarDecl*>(this)->getActingDefinition();
+  VarDecl *getActingDefinition(const ASTContext &Context);
+  const VarDecl *getActingDefinition(const ASTContext &Context) const {
+    return const_cast<VarDecl *>(this)->getActingDefinition(Context);
   }
 
   /// Get the real (not just tentative) definition for this declaration.
-  VarDecl *getDefinition(ASTContext &);
-  const VarDecl *getDefinition(ASTContext &C) const {
-    return const_cast<VarDecl*>(this)->getDefinition(C);
-  }
-  VarDecl *getDefinition() {
-    return getDefinition(getASTContext());
-  }
-  const VarDecl *getDefinition() const {
-    return const_cast<VarDecl*>(this)->getDefinition();
+  VarDecl *getDefinition(const ASTContext &Context);
+  const VarDecl *getDefinition(const ASTContext &Context) const {
+    return const_cast<VarDecl *>(this)->getDefinition(Context);
   }
 
   /// Determine whether this is or was instantiated from an out-of-line
   /// definition of a static data member.
   bool isOutOfLine() const override;
 
   /// Returns true for file scoped variable declaration.
   bool isFileVarDecl() const {
public:
   /// expression, or in C++11, whether the initializer is a constant
   /// expression.
   ///
   /// \pre isInitKnownICE()
   bool isInitICE() const;
 
   /// Determine whether the value of the initializer attached to this
   /// declaration is an integral constant expression.
-  bool checkInitIsICE() const;
+  bool checkInitIsICE(const ASTContext &Context) const;
 
   void setInitStyle(InitializationStyle Style) {
     VarDeclBits.InitStyle = Style;
   }
 
   /// The style of initialization for this declaration.
   ///
   /// C-style initialization is "int x = 1;". Call-style initialization is
public:
   }
 
   /// This is a definition which should be demoted to a declaration.
   ///
   /// In some cases (mostly module merging) we can end up with two visible
   /// definitions one of which needs to be demoted to a declaration to keep
   /// the AST invariants.
   void demoteThisDefinitionToDeclaration() {
-    assert(isThisDeclarationADefinition() && "Not a definition!");
+    assert(isThisDeclarationADefinition(getASTContext()) &&
+           "Not a definition!");
     assert(!isa<ParmVarDecl>(this) && "Cannot demote ParmVarDecls!");
     NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = 1;
   }
 
   /// Determine whether this variable is the exception variable in a
   /// C++ catch statememt or an Objective-C \@catch statement.
   bool isExceptionVariable() const {
     return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ExceptionVar;
public:
   bool isNonEscapingByref() const;
 
   void setEscapingByref() {
     NonParmVarDeclBits.EscapingByref = true;
   }
 
   /// Retrieve the variable declaration from which this variable could
   /// be instantiated, if it is an instantiation (rather than a non-template).
-  VarDecl *getTemplateInstantiationPattern() const;
+  VarDecl *getTemplateInstantiationPattern(const ASTContext &Context) const;
 
   /// If this variable is an instantiated static data member of a
   /// class template specialization, returns the templated static data member
   /// from which it was instantiated.
   VarDecl *getInstantiatedFromStaticDataMember() const;
 
   /// If this variable is an instantiation of a variable template or a
   /// static data member of a class template, determine what kind of
public:
   /// a VarDecl.
   VarTemplateDecl *getDescribedVarTemplate() const;
 
   void setDescribedVarTemplate(VarTemplateDecl *Template);
 
   // Is this variable known to have a definition somewhere in the complete
   // program? This may be true even if the declaration has internal linkage and
   // has no definition within this source file.
-  bool isKnownToBeDefined() const;
+  bool isKnownToBeDefined(const ASTContext &Context) const;
 
   /// Do we need to emit an exit-time destructor for this variable?
   bool isNoDestroy(const ASTContext &) const;
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
 };

include/clang/AST/DeclBase.h

public:
   }
 
   /// Determine whether this is a weak-imported symbol.
   ///
   /// Weak-imported symbols are typically marked with the
   /// 'weak_import' attribute, but may also be marked with an
   /// 'availability' attribute where we're targing a platform prior to
   /// the introduction of this feature.
-  bool isWeakImported() const;
+  bool isWeakImported(const ASTContext &Context) const;
 
   /// Determines whether this symbol can be weak-imported,
   /// e.g., whether it would be well-formed to add the weak_import
   /// attribute.
   ///
   /// \param IsDefinition Set to \c true to indicate that this
   /// declaration cannot be weak-imported because it has a definition.
-  bool canBeWeakImported(bool &IsDefinition) const;
+  bool canBeWeakImported(const ASTContext &Context, bool &IsDefinition) const;
 
   /// Determine whether this declaration came from an AST file (such as
   /// a precompiled header or module) rather than having been parsed.
   bool isFromASTFile() const { return FromASTFile; }
 
   /// Retrieve the global declaration ID associated with this
   /// declaration, which specifies where this Decl was loaded from.
   unsigned getGlobalID() const {

include/clang/AST/DeclTemplate.h

 
   /// Get the underlying variable declarations of the template.
   VarDecl *getTemplatedDecl() const {
     return static_cast<VarDecl *>(TemplatedDecl);
   }
 
   /// Returns whether this template declaration defines the primary
   /// variable pattern.
-  bool isThisDeclarationADefinition() const {
-    return getTemplatedDecl()->isThisDeclarationADefinition();
+  bool isThisDeclarationADefinition(const ASTContext &Context) const {
+    return getTemplatedDecl()->isThisDeclarationADefinition(Context);
   }
 
-  VarTemplateDecl *getDefinition();
+  VarTemplateDecl *getDefinition(const ASTContext &Context);
 
   /// Create a variable template node.
   static VarTemplateDecl *Create(ASTContext &C, DeclContext *DC,
                                  SourceLocation L, DeclarationName Name,
                                  TemplateParameterList *Params,
                                  VarDecl *Decl);
 
   /// Create an empty variable template node.

include/clang/ASTMatchers/ASTMatchers.h

 /// \endcode
 ///
 /// Usable as: Matcher<TagDecl>, Matcher<VarDecl>, Matcher<FunctionDecl>,
 ///   Matcher<ObjCMethodDecl>
 AST_POLYMORPHIC_MATCHER(isDefinition,
                         AST_POLYMORPHIC_SUPPORTED_TYPES(TagDecl, VarDecl,
                                                         ObjCMethodDecl,
                                                         FunctionDecl)) {
-  return Node.isThisDeclarationADefinition();
+  return IsDefinitionMatcher<NodeType>::get(Finder->getASTContext(), Node);
 }
 
 /// Matches if a function declaration is variadic.
 ///
 /// Example matches f, but not g or h. The function i will not match, even when
 /// compiled in C mode.
 /// \code
 ///   void f(...);

include/clang/ASTMatchers/ASTMatchersInternal.h

 };
 
 template <>
 inline const CompoundStmt *
 CompoundStmtMatcher<StmtExpr>::get(const StmtExpr &Node) {
   return Node.getSubStmt();
 }
 
+template <typename Ty> struct IsDefinitionMatcher {
+  static bool get(const ASTContext &, const Ty &Node) {
+    return Node.isThisDeclarationADefinition();
+  }
+};
+
+template <>
+inline bool IsDefinitionMatcher<VarDecl>::get(const ASTContext &Context,
+                                              const VarDecl &Node) {
+  return Node.isThisDeclarationADefinition(Context);
+}
+
 } // namespace internal
 
 } // namespace ast_matchers
 
 } // namespace clang
 
 #endif // LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H

include/clang/Sema/SemaInternal.h

FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI) {
   return FTI.NumParams && !FTIHasSingleVoidParameter(FTI);
 }
 
 // This requires the variable to be non-dependent and the initializer
 // to not be value dependent.
 inline bool IsVariableAConstantExpression(VarDecl *Var, ASTContext &Context) {
   const VarDecl *DefVD = nullptr;
   return !isa<ParmVarDecl>(Var) &&
          Var->isUsableInConstantExpressions(Context) &&
-    Var->getAnyInitializer(DefVD) && DefVD->checkInitIsICE();
+         Var->getAnyInitializer(DefVD) && DefVD->checkInitIsICE(Context);
 }
 
 // Helper function to check whether D's attributes match current CUDA mode.
 // Decls with mismatched attributes and related diagnostics may have to be
 // ignored during this CUDA compilation pass.
 inline bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D) {
   if (!LangOpts.CUDA || !D)
     return true;

lib/AST/ASTContext.cpp

   assert(VD->isFileVarDecl() && "Expected file scoped var");
 
   // If the decl is marked as `declare target to`, it should be emitted for the
   // host and for the device.
   if (LangOpts.OpenMP &&
       OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
     return true;
 
-  if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly &&
+  if (VD->isThisDeclarationADefinition(*this) == VarDecl::DeclarationOnly &&
       !isMSStaticDataMemberInlineDefinition(VD))
     return false;
 
   // Variables that can be needed in other TUs are required.
   auto Linkage = GetGVALinkageForVariable(VD);
   if (!isDiscardableGVALinkage(Linkage))
     return true;
 

lib/AST/ASTImporter.cpp

         // We have found a variable that we may need to merge with. Check it.
         if (FoundVar->hasExternalFormalLinkage() &&
             D->hasExternalFormalLinkage()) {
           if (Importer.IsStructurallyEquivalent(D->getType(),
                                                 FoundVar->getType())) {
 
             // The VarDecl in the "From" context has a definition, but in the
             // "To" context we already have a definition.
-            VarDecl *FoundDef = FoundVar->getDefinition();
-            if (D->isThisDeclarationADefinition() && FoundDef)
+            VarDecl *FoundDef =
+                FoundVar->getDefinition(FoundVar->getASTContext());
+            if (D->isThisDeclarationADefinition(D->getASTContext()) && FoundDef)
               // FIXME Check for ODR error if the two definitions have
               // different initializers?
               return Importer.MapImported(D, FoundDef);
 
             // The VarDecl in the "From" context has an initializer, but in the
             // "To" context we already have an initializer.
             const VarDecl *FoundDInit = nullptr;
             if (D->getInit() && FoundVar->getAnyInitializer(FoundDInit))

   return D2;
 }
 
 ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
   // If this variable has a definition in the translation unit we're coming
   // from,
   // but this particular declaration is not that definition, import the
   // definition and map to that.
-  auto *Definition =
-      cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
+  auto *Definition = cast_or_null<VarDecl>(
+      D->getTemplatedDecl()->getDefinition(D->getASTContext()));
   if (Definition && Definition != D->getTemplatedDecl()) {
     if (ExpectedDecl ImportedDefOrErr = import(
         Definition->getDescribedVarTemplate()))
       return Importer.MapImported(D, *ImportedDefOrErr);
     else
       return ImportedDefOrErr.takeError();
   }
 

     return ToVarTD;
 
   ToTemplated->setDescribedVarTemplate(ToVarTD);
 
   ToVarTD->setAccess(D->getAccess());
   ToVarTD->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToVarTD);
 
-  if (DTemplated->isThisDeclarationADefinition() &&
-      !ToTemplated->isThisDeclarationADefinition()) {
+  if (DTemplated->isThisDeclarationADefinition(DTemplated->getASTContext()) &&
+      !ToTemplated->isThisDeclarationADefinition(
+          ToTemplated->getASTContext())) {
     // FIXME: Import definition!
   }
 
   return ToVarTD;
 }
 
 ExpectedDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl(
     VarTemplateSpecializationDecl *D) {
   // If this record has a definition in the translation unit we're coming from,
   // but this particular declaration is not that definition, import the
   // definition and map to that.
-  VarDecl *Definition = D->getDefinition();
+  VarDecl *Definition = D->getDefinition(D->getASTContext());
   if (Definition && Definition != D) {
     if (ExpectedDecl ImportedDefOrErr = import(Definition))
       return Importer.MapImported(D, *ImportedDefOrErr);
     else
       return ImportedDefOrErr.takeError();
   }
 
   VarTemplateDecl *VarTemplate;

   VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
       TemplateArgs, InsertPos);
   if (D2) {
     // We already have a variable template specialization with these template
     // arguments.
 
     // FIXME: Check for specialization vs. instantiation errors.
 
-    if (VarDecl *FoundDef = D2->getDefinition()) {
-      if (!D->isThisDeclarationADefinition() ||
+    if (VarDecl *FoundDef = D2->getDefinition(D2->getASTContext())) {
+      if (!D->isThisDeclarationADefinition(D->getASTContext()) ||
           IsStructuralMatch(D, FoundDef)) {
         // The record types structurally match, or the "from" translation
         // unit only had a forward declaration anyway; call it the same
         // variable.
         return Importer.MapImported(D, FoundDef);
       }
     }
   } else {

lib/AST/ComparisonCategories.cpp

 #include "clang/AST/ComparisonCategories.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Type.h"
 #include "llvm/ADT/SmallVector.h"
 
 using namespace clang;
 
-bool ComparisonCategoryInfo::ValueInfo::hasValidIntValue() const {
+bool ComparisonCategoryInfo::ValueInfo::hasValidIntValue(
+    const ASTContext &Context) const {
   assert(VD && "must have var decl");
-  if (!VD->checkInitIsICE())
+  if (!VD->checkInitIsICE(Context))
     return false;
 
   // Before we attempt to get the value of the first field, ensure that we
   // actually have one (and only one) field.
   auto *Record = VD->getType()->getAsCXXRecordDecl();
   if (std::distance(Record->field_begin(), Record->field_end()) != 1 ||
       !Record->field_begin()->getType()->isIntegralOrEnumerationType())
     return false;
 
   return true;
 }
 
 /// Attempt to determine the integer value used to represent the comparison
 /// category result by evaluating the initializer for the specified VarDecl as
 /// a constant expression and retreiving the value of the class's first
 /// (and only) field.
 ///
 /// Note: The STL types are expected to have the form:
 ///    struct X { T value; };
 /// where T is an integral or enumeration type.
-llvm::APSInt ComparisonCategoryInfo::ValueInfo::getIntValue() const {
-  assert(hasValidIntValue() && "must have a valid value");
+llvm::APSInt ComparisonCategoryInfo::ValueInfo::getIntValue(
+    const ASTContext &Context) const {
+  assert(hasValidIntValue(Context) && "must have a valid value");
   return VD->evaluateValue()->getStructField(0).getInt();
 }
 
 ComparisonCategoryInfo::ValueInfo *ComparisonCategoryInfo::lookupValueInfo(
     ComparisonCategoryResult ValueKind) const {
   // Check if we already have a cache entry for this value.
   auto It = llvm::find_if(
       Objects, [&](ValueInfo const &Info) { return Info.Kind == ValueKind; });

lib/AST/Decl.cpp

 
 bool VarDecl::isInExternCXXContext() const {
   return getLexicalDeclContext()->isExternCXXContext();
 }
 
 VarDecl *VarDecl::getCanonicalDecl() { return getFirstDecl(); }
 
 VarDecl::DefinitionKind
-VarDecl::isThisDeclarationADefinition(ASTContext &C) const {
+VarDecl::isThisDeclarationADefinition(const ASTContext &Context) const {
   if (isThisDeclarationADemotedDefinition())
     return DeclarationOnly;
 
   // C++ [basic.def]p2:
   //   A declaration is a definition unless [...] it contains the 'extern'
   //   specifier or a linkage-specification and neither an initializer [...],
   //   it declares a non-inline static data member in a class declaration [...],
   //   it declares a static data member outside a class definition and the variable

   if (isSingleLineLanguageLinkage(*this))
     return DeclarationOnly;
 
   // C99 6.9.2p2:
   //   A declaration of an object that has file scope without an initializer,
   //   and without a storage class specifier or the scs 'static', constitutes
   //   a tentative definition.
   // No such thing in C++.
-  if (!C.getLangOpts().CPlusPlus && isFileVarDecl())
+  if (!Context.getLangOpts().CPlusPlus && isFileVarDecl())
     return TentativeDefinition;
 
   // What's left is (in C, block-scope) declarations without initializers or
   // external storage. These are definitions.
   return Definition;
 }
 
-VarDecl *VarDecl::getActingDefinition() {
-  DefinitionKind Kind = isThisDeclarationADefinition();
+VarDecl *VarDecl::getActingDefinition(const ASTContext &Context) {
+  DefinitionKind Kind = isThisDeclarationADefinition(Context);
   if (Kind != TentativeDefinition)
     return nullptr;
 
   VarDecl *LastTentative = nullptr;
   VarDecl *First = getFirstDecl();
   for (auto I : First->redecls()) {
-    Kind = I->isThisDeclarationADefinition();
+    Kind = I->isThisDeclarationADefinition(Context);
     if (Kind == Definition)
       return nullptr;
     else if (Kind == TentativeDefinition)
       LastTentative = I;
   }
   return LastTentative;
 }
 
-VarDecl *VarDecl::getDefinition(ASTContext &C) {
+VarDecl *VarDecl::getDefinition(const ASTContext &Context) {
   VarDecl *First = getFirstDecl();
   for (auto I : First->redecls()) {
-    if (I->isThisDeclarationADefinition(C) == Definition)
+    if (I->isThisDeclarationADefinition(Context) == Definition)
       return I;
   }
   return nullptr;
 }
 
-VarDecl::DefinitionKind VarDecl::hasDefinition(ASTContext &C) const {
+VarDecl::DefinitionKind
+VarDecl::hasDefinition(const ASTContext &Context) const {
   DefinitionKind Kind = DeclarationOnly;
 
   const VarDecl *First = getFirstDecl();
   for (auto I : First->redecls()) {
-    Kind = std::max(Kind, I->isThisDeclarationADefinition(C));
+    Kind = std::max(Kind, I->isThisDeclarationADefinition(Context));
     if (Kind == Definition)
       break;
   }
 
   return Kind;
 }
 
 const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const {

 }
 
 bool VarDecl::isInitICE() const {
   assert(isInitKnownICE() &&
          "Check whether we already know that the initializer is an ICE");
   return Init.get<EvaluatedStmt *>()->IsICE;
 }
 
-bool VarDecl::checkInitIsICE() const {
+bool VarDecl::checkInitIsICE(const ASTContext &Context) const {
   // Initializers of weak variables are never ICEs.
-  if (isWeak())
+  if (isWeak(Context))
     return false;
 
   EvaluatedStmt *Eval = ensureEvaluatedStmt();
   if (Eval->CheckedICE)
     // We have already checked whether this subexpression is an
     // integral constant expression.
     return Eval->IsICE;
 
   const auto *Init = cast<Expr>(Eval->Value);
   assert(!Init->isValueDependent());
 
   // In C++11, evaluate the initializer to check whether it's a constant
   // expression.
-  if (getASTContext().getLangOpts().CPlusPlus11) {
+  if (Context.getLangOpts().CPlusPlus11) {
     SmallVector<PartialDiagnosticAt, 8> Notes;
     evaluateValue(Notes);
     return Eval->IsICE;
   }
 
   // It's an ICE whether or not the definition we found is
   // out-of-line.  See DR 721 and the discussion in Clang PR
   // 6206 for details.
 
   if (Eval->CheckingICE)
     return false;
   Eval->CheckingICE = true;
 
-  Eval->IsICE = Init->isIntegerConstantExpr(getASTContext());
+  Eval->IsICE = Init->isIntegerConstantExpr(Context);
   Eval->CheckingICE = false;
   Eval->CheckedICE = true;
   return Eval->IsICE;
 }
 
 template<typename DeclT>
 static DeclT *getDefinitionOrSelf(DeclT *D) {
   assert(D);
-  if (auto *Def = D->getDefinition())
+  if (DeclT *Def = D->getDefinition())
+    return Def;
+  return D;
+}
+
+template <typename DeclT>
+static DeclT *getDefinitionOrSelf(const ASTContext &Context, DeclT *D) {
+  assert(D);
+  if (DeclT *Def = D->getDefinition(Context))
     return Def;
   return D;
 }
 
 bool VarDecl::isEscapingByref() const {
   return hasAttr<BlocksAttr>() && NonParmVarDeclBits.EscapingByref;
 }
 
 bool VarDecl::isNonEscapingByref() const {
   return hasAttr<BlocksAttr>() && !NonParmVarDeclBits.EscapingByref;
 }
 
-VarDecl *VarDecl::getTemplateInstantiationPattern() const {
+VarDecl *
+VarDecl::getTemplateInstantiationPattern(const ASTContext &Context) const {
   // If it's a variable template specialization, find the template or partial
   // specialization from which it was instantiated.
   if (auto *VDTemplSpec = dyn_cast<VarTemplateSpecializationDecl>(this)) {
     auto From = VDTemplSpec->getInstantiatedFrom();
     if (auto *VTD = From.dyn_cast<VarTemplateDecl *>()) {
       while (auto *NewVTD = VTD->getInstantiatedFromMemberTemplate()) {
         if (NewVTD->isMemberSpecialization())
           break;
         VTD = NewVTD;
       }
-      return getDefinitionOrSelf(VTD->getTemplatedDecl());
+      return getDefinitionOrSelf(Context, VTD->getTemplatedDecl());
     }
     if (auto *VTPSD =
             From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
       while (auto *NewVTPSD = VTPSD->getInstantiatedFromMember()) {
         if (NewVTPSD->isMemberSpecialization())
           break;
         VTPSD = NewVTPSD;
       }
-      return getDefinitionOrSelf<VarDecl>(VTPSD);
+      return getDefinitionOrSelf<VarDecl>(Context, VTPSD);
     }
   }
 
   if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
     if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
       VarDecl *VD = getInstantiatedFromStaticDataMember();
       while (auto *NewVD = VD->getInstantiatedFromStaticDataMember())
         VD = NewVD;
-      return getDefinitionOrSelf(VD);
+      return getDefinitionOrSelf(Context, VD);
     }
   }
 
   if (VarTemplateDecl *VarTemplate = getDescribedVarTemplate()) {
     while (VarTemplate->getInstantiatedFromMemberTemplate()) {
       if (VarTemplate->isMemberSpecialization())
         break;
       VarTemplate = VarTemplate->getInstantiatedFromMemberTemplate();
     }
 
-    return getDefinitionOrSelf(VarTemplate->getTemplatedDecl());
+    return getDefinitionOrSelf(Context, VarTemplate->getTemplatedDecl());
   }
   return nullptr;
 }
 
 VarDecl *VarDecl::getInstantiatedFromStaticDataMember() const {
   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
     return cast<VarDecl>(MSI->getInstantiatedFrom());
 

   return getASTContext().getTemplateOrSpecializationInfo(this)
       .dyn_cast<VarTemplateDecl *>();
 }
 
 void VarDecl::setDescribedVarTemplate(VarTemplateDecl *Template) {
   getASTContext().setTemplateOrSpecializationInfo(this, Template);
 }
 
-bool VarDecl::isKnownToBeDefined() const {
-  const auto &LangOpts = getASTContext().getLangOpts();
+bool VarDecl::isKnownToBeDefined(const ASTContext &Context) const {
+  const auto &LangOpts = Context.getLangOpts();
   // In CUDA mode without relocatable device code, variables of form 'extern
   // __shared__ Foo foo[]' are pointers to the base of the GPU core's shared
   // memory pool.  These are never undefined variables, even if they appear
   // inside of an anon namespace or static function.
   //
   // With CUDA relocatable device code enabled, these variables don't get
   // special handling; they're treated like regular extern variables.
   if (LangOpts.CUDA && !LangOpts.GPURelocatableDeviceCode &&
       hasExternalStorage() && hasAttr<CUDASharedAttr>() &&
       isa<IncompleteArrayType>(getType()))
     return true;
 
-  return hasDefinition();
+  return hasDefinition(Context);
 }
 
 bool VarDecl::isNoDestroy(const ASTContext &Ctx) const {
   return hasGlobalStorage() && (hasAttr<NoDestroyAttr>() ||
                                 (!Ctx.getLangOpts().RegisterStaticDestructors &&
                                  !hasAttr<AlwaysDestroyAttr>()));
 }
 

   char *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
   memcpy(Buffer, Name.data(), Name.size());
   Buffer[Name.size()] = '\0';
   MSAsmName = Buffer;
 }
 
 void ValueDecl::anchor() {}
 
-bool ValueDecl::isWeak() const {
+bool ValueDecl::isWeak(const ASTContext &Context) const {
   for (const auto *I : attrs())
     if (isa<WeakAttr>(I) || isa<WeakRefAttr>(I))
       return true;
 
-  return isWeakImported();
+  return isWeakImported(Context);
 }
 
 void ImplicitParamDecl::anchor() {}
 
 ImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, DeclContext *DC,
                                              SourceLocation IdLoc,
                                              IdentifierInfo *Id, QualType Type,
                                              ImplicitParamKind ParamKind) {

lib/AST/DeclBase.cpp

 /// the target platform.
 ///
 /// When it returns an availability result other than \c AR_Available,
 /// if the \p Message parameter is non-NULL, it will be set to a
 /// string describing why the entity is unavailable.
 ///
 /// FIXME: Make these strings localizable, since they end up in
 /// diagnostics.
-static AvailabilityResult CheckAvailability(ASTContext &Context,
+static AvailabilityResult CheckAvailability(const ASTContext &Context,
                                             const AvailabilityAttr *A,
                                             std::string *Message,
                                             VersionTuple EnclosingVersion) {
   if (EnclosingVersion.empty())
     EnclosingVersion = Context.getTargetInfo().getPlatformMinVersion();
 
   if (EnclosingVersion.empty())
     return AR_Available;
if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
         continue;
       if (!Availability->getIntroduced().empty())
         return Availability->getIntroduced();
     }
   }
   return {};
 }
 
-bool Decl::canBeWeakImported(bool &IsDefinition) const {
+bool Decl::canBeWeakImported(const ASTContext &Context,
+                             bool &IsDefinition) const {
   IsDefinition = false;
 
   // Variables, if they aren't definitions.
   if (const auto *Var = dyn_cast<VarDecl>(this)) {
-    if (Var->isThisDeclarationADefinition()) {
+    if (Var->isThisDeclarationADefinition(Context)) {
       IsDefinition = true;
       return false;
     }
     return true;
 
   // Functions, if they aren't definitions.
   } else if (const auto *FD = dyn_cast<FunctionDecl>(this)) {
     if (FD->hasBody()) {
       IsDefinition = true;
       return false;
     }
     return true;
 
   // Objective-C classes, if this is the non-fragile runtime.
   } else if (isa<ObjCInterfaceDecl>(this) &&
-             getASTContext().getLangOpts().ObjCRuntime.hasWeakClassImport()) {
+             Context.getLangOpts().ObjCRuntime.hasWeakClassImport()) {
     return true;
 
   // Nothing else.
   } else {
     return false;
   }
 }
 
-bool Decl::isWeakImported() const {
+bool Decl::isWeakImported(const ASTContext &Context) const {
   bool IsDefinition;
-  if (!canBeWeakImported(IsDefinition))
+  if (!canBeWeakImported(Context, IsDefinition))
     return false;
 
   for (const auto *A : attrs()) {
     if (isa<WeakImportAttr>(A))
       return true;
 
     if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
-      if (CheckAvailability(getASTContext(), Availability, nullptr,
-                            VersionTuple()) == AR_NotYetIntroduced)
+      if (CheckAvailability(Context, Availability, nullptr, VersionTuple()) ==
+          AR_NotYetIntroduced)
         return true;
     }
   }
 
   return false;
 }
 
 unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) {

lib/AST/DeclTemplate.cpp

ClassScopeFunctionSpecializationDecl::CreateDeserialized(ASTContext &C,
   return new (C, ID) ClassScopeFunctionSpecializationDecl(
       nullptr, SourceLocation(), nullptr, false, TemplateArgumentListInfo());
 }
 
 //===----------------------------------------------------------------------===//
 // VarTemplateDecl Implementation
 //===----------------------------------------------------------------------===//
 
-VarTemplateDecl *VarTemplateDecl::getDefinition() {
+VarTemplateDecl *VarTemplateDecl::getDefinition(const ASTContext &Context) {
   VarTemplateDecl *CurD = this;
   while (CurD) {
-    if (CurD->isThisDeclarationADefinition())
+    if (CurD->isThisDeclarationADefinition(Context))
       return CurD;
     CurD = CurD->getPreviousDecl();
   }
   return nullptr;
 }
 
 VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC,
                                          SourceLocation L, DeclarationName Name,

lib/AST/ExprConstant.cpp

 
 static bool IsLiteralLValue(const LValue &Value) {
   if (Value.getLValueCallIndex())
     return false;
   const Expr *E = Value.Base.dyn_cast<const Expr*>();
   return E && !isa<MaterializeTemporaryExpr>(E);
 }
 
-static bool IsWeakLValue(const LValue &Value) {
+static bool IsWeakLValue(const ASTContext &Context, const LValue &Value) {
   const ValueDecl *Decl = GetLValueBaseDecl(Value);
-  return Decl && Decl->isWeak();
+  return Decl && Decl->isWeak(Context);
 }
 
 static bool isZeroSized(const LValue &Value) {
   const ValueDecl *Decl = GetLValueBaseDecl(Value);
   if (Decl && isa<VarDecl>(Decl)) {
     QualType Ty = Decl->getType();
     if (Ty->isArrayType())
       return Ty->isIncompleteType() ||

 
   if (Value.isMemberPointer())
     return CheckMemberPointerConstantExpression(Info, DiagLoc, Type, Value, Usage);
 
   // Everything else is fine.
   return true;
 }
 
-static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) {
+static bool EvalPointerValueAsBool(const ASTContext &Context,
+                                   const APValue &Value, bool &Result) {
   // A null base expression indicates a null pointer.  These are always
   // evaluatable, and they are false unless the offset is zero.
   if (!Value.getLValueBase()) {
     Result = !Value.getLValueOffset().isZero();
     return true;
   }
 
   // We have a non-null base.  These are generally known to be true, but if it's
   // a weak declaration it can be null at runtime.
   Result = true;
   const ValueDecl *Decl = Value.getLValueBase().dyn_cast<const ValueDecl*>();
-  return !Decl || !Decl->isWeak();
+  return !Decl || !Decl->isWeak(Context);
 }
 
-static bool HandleConversionToBool(const APValue &Val, bool &Result) {
+static bool HandleConversionToBool(const ASTContext &Context,
+                                   const APValue &Val, bool &Result) {
   switch (Val.getKind()) {
   case APValue::Uninitialized:
     return false;
   case APValue::Int:
     Result = Val.getInt().getBoolValue();
     return true;
   case APValue::Float:
     Result = !Val.getFloat().isZero();
     return true;
   case APValue::ComplexInt:
     Result = Val.getComplexIntReal().getBoolValue() ||
              Val.getComplexIntImag().getBoolValue();
     return true;
   case APValue::ComplexFloat:
     Result = !Val.getComplexFloatReal().isZero() ||
              !Val.getComplexFloatImag().isZero();
     return true;
   case APValue::LValue:
-    return EvalPointerValueAsBool(Val, Result);
+    return EvalPointerValueAsBool(Context, Val, Result);
   case APValue::MemberPointer:
     Result = Val.getMemberPointerDecl();
     return true;
   case APValue::Vector:
   case APValue::Array:
   case APValue::Struct:
   case APValue::Union:
   case APValue::AddrLabelDiff:
     return false;
   }
 
   llvm_unreachable("unknown APValue kind");
 }
 
 static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
                                        EvalInfo &Info) {
   assert(E->isRValue() && "missing lvalue-to-rvalue conv in bool condition");
   APValue Val;
   if (!Evaluate(Val, Info, E))
     return false;
-  return HandleConversionToBool(Val, Result);
+  return HandleConversionToBool(Info.Ctx, Val, Result);
 }
 
 template<typename T>
 static bool HandleOverflow(EvalInfo &Info, const Expr *E,
                            const T &SrcValue, QualType DestType) {
   Info.CCEDiag(E, diag::note_constexpr_overflow)
     << SrcValue << DestType;
   return Info.noteUndefinedBehavior();

   // in-flight value.
   if (Info.EvaluatingDecl.dyn_cast<const ValueDecl*>() == VD) {
     Result = Info.EvaluatingDeclValue;
     return true;
   }
 
   // Never evaluate the initializer of a weak variable. We can't be sure that
   // this is the definition which will be used.
-  if (VD->isWeak()) {
+  if (VD->isWeak(Info.Ctx)) {
     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
     return false;
   }
 
   // Check that we can fold the initializer. In C++, we will have already done
   // this in the cases where it matters for conformance.
   SmallVector<PartialDiagnosticAt, 8> Notes;
   if (!VD->evaluateValue(Notes)) {
     Info.FFDiag(E, diag::note_constexpr_var_init_non_constant,
               Notes.size() + 1) << VD;
     Info.Note(VD->getLocation(), diag::note_declared_at);
     Info.addNotes(Notes);
     return false;
-  } else if (!VD->checkInitIsICE()) {
+  } else if (!VD->checkInitIsICE(Info.Ctx)) {
     Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant,
                  Notes.size() + 1) << VD;
     Info.Note(VD->getLocation(), diag::note_declared_at);
     Info.addNotes(Notes);
   }
 
   Result = VD->getEvaluatedValue();
   return true;

     // Ignore LHS but note if we could not evaluate it.
     if (LHSResult.Failed)
       return Info.noteSideEffect();
     return true;
   }
 
   if (E->isLogicalOp()) {
     bool LHSAsBool;
-    if (!LHSResult.Failed && HandleConversionToBool(LHSResult.Val, LHSAsBool)) {
+    if (!LHSResult.Failed &&
+        HandleConversionToBool(Info.Ctx, LHSResult.Val, LHSAsBool)) {
       // We were able to evaluate the LHS, see if we can get away with not
       // evaluating the RHS: 0 && X -> 0, 1 || X -> 1
       if (LHSAsBool == (E->getOpcode() == BO_LOr)) {
         Success(LHSAsBool, E, LHSResult.Val);
         return false; // Ignore RHS
       }
     } else {
       LHSResult.Failed = true;

     if (RHSResult.Failed)
       return false;
     Result = RHSResult.Val;
     return true;
   }
 
   if (E->isLogicalOp()) {
     bool lhsResult, rhsResult;
-    bool LHSIsOK = HandleConversionToBool(LHSResult.Val, lhsResult);
-    bool RHSIsOK = HandleConversionToBool(RHSResult.Val, rhsResult);
+    const ASTContext &Context = Info.Ctx;
+    bool LHSIsOK = HandleConversionToBool(Context, LHSResult.Val, lhsResult);
+    bool RHSIsOK = HandleConversionToBool(Context, RHSResult.Val, rhsResult);
 
     if (LHSIsOK) {
       if (RHSIsOK) {
         if (E->getOpcode() == BO_LOr)
           return Success(lhsResult || rhsResult, E, Result);
         else
           return Success(lhsResult && rhsResult, E, Result);
       }

       // distinct addresses. In clang, the result of such a comparison is
       // unspecified, so it is not a constant expression. However, we do know
       // that the address of a literal will be non-null.
       if ((IsLiteralLValue(LHSValue) || IsLiteralLValue(RHSValue)) &&
           LHSValue.Base && RHSValue.Base)
         return Error(E);
       // We can't tell whether weak symbols will end up pointing to the same
       // object.
-      if (IsWeakLValue(LHSValue) || IsWeakLValue(RHSValue))
+      if (IsWeakLValue(Info.Ctx, LHSValue) || IsWeakLValue(Info.Ctx, RHSValue))
         return Error(E);
       // We can't compare the address of the start of one object with the
       // past-the-end address of another object, per C++ DR1652.
       if ((LHSValue.Base && LHSValue.Offset.isZero() &&
            isOnePastTheEndOfCompleteObject(Info.Ctx, RHSValue)) ||
           (RHSValue.Base && RHSValue.Offset.isZero() &&
            isOnePastTheEndOfCompleteObject(Info.Ctx, LHSValue)))
         return Error(E);

   Info.InConstantContext = InConstantContext;
   return ::EvaluateAsRValue(this, Result, Ctx, Info);
 }
 
 bool Expr::EvaluateAsBooleanCondition(bool &Result,
                                       const ASTContext &Ctx) const {
   EvalResult Scratch;
   return EvaluateAsRValue(Scratch, Ctx) &&
-         HandleConversionToBool(Scratch.Val, Result);
+         HandleConversionToBool(Ctx, Scratch.Val, Result);
 }
 
 bool Expr::EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,
                          SideEffectsKind AllowSideEffects) const {
   EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
   return ::EvaluateAsInt(this, Result, Ctx, AllowSideEffects, Info);
 }
 

       //   type initialized by an ICE can be used in ICEs.
       if (const VarDecl *Dcl = dyn_cast<VarDecl>(D)) {
         if (!Dcl->getType()->isIntegralOrEnumerationType())
           return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
 
         const VarDecl *VD;
         // Look for a declaration of this variable that has an initializer, and
         // check whether it is an ICE.
-        if (Dcl->getAnyInitializer(VD) && VD->checkInitIsICE())
+        if (Dcl->getAnyInitializer(VD) && VD->checkInitIsICE(Ctx))
           return NoDiag();
         else
           return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
       }
     }
     return ICEDiag(IK_NotICE, E->getBeginLoc());
   }
   case Expr::UnaryOperatorClass: {

lib/CodeGen/CGExpr.cpp

       return EmitGlobalNamedRegister(VD, CGM);
 
     // A DeclRefExpr for a reference initialized by a constant expression can
     // appear without being odr-used. Directly emit the constant initializer.
     const Expr *Init = VD->getAnyInitializer(VD);
     const auto *BD = dyn_cast_or_null<BlockDecl>(CurCodeDecl);
     if (Init && !isa<ParmVarDecl>(VD) && VD->getType()->isReferenceType() &&
         VD->isUsableInConstantExpressions(getContext()) &&
-        VD->checkInitIsICE() &&
+        VD->checkInitIsICE(getContext()) &&
         // Do not emit if it is private OpenMP variable.
         !(E->refersToEnclosingVariableOrCapture() &&
           ((CapturedStmtInfo &&
             (LocalDeclMap.count(VD->getCanonicalDecl()) ||
              CapturedStmtInfo->lookup(VD->getCanonicalDecl()))) ||
            LambdaCaptureFields.lookup(VD->getCanonicalDecl()) ||
            (BD && BD->capturesVariable(VD))))) {
       llvm::Constant *Val =

lib/CodeGen/CGExprAgg.cpp

auto EmitCmp = [&](CompareKind K) {
     if (!IsComplex)
       return Cmp;
     assert(K == CompareKind::CK_Equal);
     Value *CmpImag = EmitCompare(Builder, CGF, E, LHSValues.second,
                                  RHSValues.second, K, ".i");
     return Builder.CreateAnd(Cmp, CmpImag, "and.eq");
   };
   auto EmitCmpRes = [&](const ComparisonCategoryInfo::ValueInfo *VInfo) {
-    return Builder.getInt(VInfo->getIntValue());
+    return Builder.getInt(VInfo->getIntValue(CGF.getContext()));
   };
 
   Value *Select;
   if (ArgTy->isNullPtrType()) {
     Select = EmitCmpRes(CmpInfo.getEqualOrEquiv());
   } else if (CmpInfo.isEquality()) {
     Select = Builder.CreateSelect(
         EmitCmp(CK_Equal), EmitCmpRes(CmpInfo.getEqualOrEquiv()),

lib/CodeGen/CGObjCGNU.cpp

                               "objc_lookup_class");
   return CGF.EmitNounwindRuntimeCall(ClassLookupFn, ClassName);
 }
 
 // This has to perform the lookup every time, since posing and related
 // techniques can modify the name -> class mapping.
 llvm::Value *CGObjCGNU::GetClass(CodeGenFunction &CGF,
                                  const ObjCInterfaceDecl *OID) {
-  auto *Value =
-      GetClassNamed(CGF, OID->getNameAsString(), OID->isWeakImported());
+  auto *Value = GetClassNamed(CGF, OID->getNameAsString(),
+                              OID->isWeakImported(CGF.getContext()));
   if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value))
     CGM.setGVProperties(ClassSymbol, OID);
   return Value;
 }
 
 llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
   auto *Value  = GetClassNamed(CGF, "NSAutoreleasePool", false);
   if (CGM.getTriple().isOSBinFormatCOFF()) {

lib/CodeGen/CGObjCMac.cpp

                                                const ObjCInterfaceDecl *Class,
                                                const ObjCMethodDecl *Method) {
   return EmitMessageSend(CGF, Return, ResultType,
                          EmitSelector(CGF, Sel),
                          Receiver, CGF.getContext().getObjCIdType(),
                          false, CallArgs, Method, Class, ObjCTypes);
 }
 
-static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
+static bool isWeakLinkedClass(CodeGen::CodeGenFunction &CGF,
+                              const ObjCInterfaceDecl *ID) {
   do {
-    if (ID->isWeakImported())
+    if (ID->isWeakImported(CGF.getContext()))
       return true;
   } while ((ID = ID->getSuperClass()));
 
   return false;
 }
 
 CodeGen::RValue
 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,

   // Super dispatch assumes that self is non-null; even the messenger
   // doesn't have a null check internally.
   if (IsSuper) {
     ReceiverCanBeNull = false;
 
   // If this is a direct dispatch of a class method, check whether the class,
   // or anything in its hierarchy, was weak-linked.
   } else if (ClassReceiver && Method && Method->isClassMethod()) {
-    ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);
+    ReceiverCanBeNull = isWeakLinkedClass(CGF, ClassReceiver);
 
   // If we're emitting a method, and self is const (meaning just ARC, for now),
   // and the receiver is a load of self, then self is a valid object.
   } else if (auto CurMethod =
                dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
     auto Self = CurMethod->getSelfDecl();
     if (Self->getType().isConstQualified()) {
       if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {

   // The runtime expects exactly the list of defined classes followed
   // by the list of defined categories, in a single array.
   auto array = values.beginArray(ObjCTypes.Int8PtrTy);
   for (unsigned i=0; i<NumClasses; i++) {
     const ObjCInterfaceDecl *ID = ImplementedClasses[i];
     assert(ID);
     if (ObjCImplementationDecl *IMP = ID->getImplementation())
       // We are implementing a weak imported interface. Give it external linkage
-      if (ID->isWeakImported() && !IMP->isWeakImported())
+      if (ID->isWeakImported(CGM.getContext()) &&
+          !IMP->isWeakImported(CGM.getContext()))
         DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
 
     array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy);
   }
   for (unsigned i=0; i<NumCategories; i++)
     array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy);
 
   array.finishAndAddTo(values);

   // Build list of all implemented class addresses in array
   // L_OBJC_LABEL_CLASS_$.
 
   for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
     const ObjCInterfaceDecl *ID = ImplementedClasses[i];
     assert(ID);
     if (ObjCImplementationDecl *IMP = ID->getImplementation())
       // We are implementing a weak imported interface. Give it external linkage
-      if (ID->isWeakImported() && !IMP->isWeakImported()) {
+      if (ID->isWeakImported(CGM.getContext()) &&
+          !IMP->isWeakImported(CGM.getContext())) {
         DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
         DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
       }
   }
 
   AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
                      GetSectionName("__objc_classlist",
                                     "regular,no_dead_strip"));

 
 llvm::Constant *
 CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID,
                                        bool metaclass,
                                        ForDefinition_t isForDefinition) {
   auto prefix =
     (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix());
   return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(),
-                        isForDefinition,
-                        ID->isWeakImported(),
-                        !isForDefinition
-                          && CGM.getTriple().isOSBinFormatCOFF()
-                          && ID->hasAttr<DLLImportAttr>());
+                        isForDefinition, ID->isWeakImported(CGM.getContext()),
+                        !isForDefinition &&
+                            CGM.getTriple().isOSBinFormatCOFF() &&
+                            ID->hasAttr<DLLImportAttr>());
 }
 
 llvm::Constant *
 CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
                                        ForDefinition_t IsForDefinition,
                                        bool Weak, bool DLLImport) {
   llvm::GlobalValue::LinkageTypes L =
       Weak ? llvm::GlobalValue::ExternalWeakLinkage

 
   return CGF.Builder.CreateAlignedLoad(Entry, Align);
 }
 
 /// GetClass - Return a reference to the class for the given interface
 /// decl.
 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
                                               const ObjCInterfaceDecl *ID) {
-  if (ID->isWeakImported()) {
+  if (ID->isWeakImported(CGM.getContext())) {
     auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
     (void)ClassGV;
     assert(!isa<llvm::GlobalVariable>(ClassGV) ||
            cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage());
   }
 
   return EmitClassRef(CGF, ID);
 }

     CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
   CGF.Builder.CreateStore(
       ReceiverAsObject,
       CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
 
   // If this is a class message the metaclass is passed as the target.
   llvm::Value *Target;
   if (IsClassMessage)
-      Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported());
+    Target =
+        EmitMetaClassRef(CGF, Class, Class->isWeakImported(CGM.getContext()));
   else
     Target = EmitSuperClassRef(CGF, Class);
 
   // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
   // ObjCTypes types.
   llvm::Type *ClassTy =
     CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
   Target = CGF.Builder.CreateBitCast(Target, ClassTy);

lib/CodeGen/CodeGenModule.cpp

   SetLLVMFunctionAttributes(GD, FI, F);
   SetLLVMFunctionAttributesForDefinition(D, F);
 
   F->setLinkage(llvm::Function::InternalLinkage);
 
   setNonAliasAttributes(GD, F);
 }
 
-static void setLinkageForGV(llvm::GlobalValue *GV, const NamedDecl *ND) {
+static void setLinkageForGV(const CodeGenModule &CGM, llvm::GlobalValue *GV,
+                            const NamedDecl *ND) {
   // Set linkage and visibility in case we never see a definition.
   LinkageInfo LV = ND->getLinkageAndVisibility();
   // Don't set internal linkage on declarations.
   // "extern_weak" is overloaded in LLVM; we probably should have
   // separate linkage types for this.
   if (isExternallyVisible(LV.getLinkage()) &&
-      (ND->hasAttr<WeakAttr>() || ND->isWeakImported()))
+      (ND->hasAttr<WeakAttr>() || ND->isWeakImported(CGM.getContext())))
     GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
 }
 
 void CodeGenModule::CreateFunctionTypeMetadataForIcall(const FunctionDecl *FD,
                                                        llvm::Function *F) {
   // Only if we are checking indirect calls.
   if (!LangOpts.Sanitize.has(SanitizerKind::CFIICall))
     return;

              ->canLosslesslyBitCastTo(F->getReturnType()) &&
            "unexpected this return");
     F->addAttribute(1, llvm::Attribute::Returned);
   }
 
   // Only a few attributes are set on declarations; these may later be
   // overridden by a definition.
 
-  setLinkageForGV(F, FD);
+  setLinkageForGV(*this, F, FD);
   setGVProperties(F, FD);
 
   if (const auto *CSA = FD->getAttr<CodeSegAttr>())
     F->setSection(CSA->getName());
   else if (const auto *SA = FD->getAttr<SectionAttr>())
      F->setSection(SA->getName());
 
   if (FD->isReplaceableGlobalAllocationFunction()) {

       return;
     }
   } else {
     const auto *VD = cast<VarDecl>(Global);
     assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
     // We need to emit device-side global CUDA variables even if a
     // variable does not have a definition -- we still need to define
     // host-side shadow for it.
-    bool MustEmitForCuda = LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
-                           !VD->hasDefinition() &&
-                           (VD->hasAttr<CUDAConstantAttr>() ||
-                            VD->hasAttr<CUDADeviceAttr>());
+    bool MustEmitForCuda =
+        LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
+        !VD->hasDefinition(Context) &&
+        (VD->hasAttr<CUDAConstantAttr>() || VD->hasAttr<CUDADeviceAttr>());
     if (!MustEmitForCuda &&
-        VD->isThisDeclarationADefinition() != VarDecl::Definition &&
+        VD->isThisDeclarationADefinition(Context) != VarDecl::Definition &&
         !Context.isMSStaticDataMemberInlineDefinition(VD)) {
       if (LangOpts.OpenMP) {
         // Emit declaration of the must-be-emitted declare target variable.
         if (llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
                 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
           if (*Res == OMPDeclareTargetDeclAttr::MT_To) {
             (void)GetAddrOfGlobalVar(VD);
           } else {

     bool VisitVarDecl(VarDecl *VD) {
       if (VD->getTLSKind()) {
         // A thread-local variable cannot be imported.
         SafeToInline = false;
         return SafeToInline;
       }
 
       // A variable definition might imply a destructor call.
-      if (VD->isThisDeclarationADefinition())
+      if (VD->isThisDeclarationADefinition(VD->getASTContext()))
         SafeToInline = !HasNonDllImportDtor(VD->getType());
 
       return SafeToInline;
     }
 
     bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
       if (const auto *D = E->getTemporary()->getDestructor())
         SafeToInline = D->hasAttr<DLLImportAttr>();

     }
 
     if (FD->isMultiVersion())
       return EmitMultiVersionFunctionDefinition(GD, GV);
     return EmitGlobalFunctionDefinition(GD, GV);
   }
 
   if (const auto *VD = dyn_cast<VarDecl>(D))
-    return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
+    return EmitGlobalVarDefinition(VD, !VD->hasDefinition(Context));
 
   llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
 }
 
 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
                                                       llvm::Function *NewFn);
 
 static unsigned

       getOpenMPRuntime().registerTargetGlobalVariable(D, GV);
 
     // FIXME: This code is overly simple and should be merged with other global
     // handling.
     GV->setConstant(isTypeConstant(D->getType(), false));
 
     GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
 
-    setLinkageForGV(GV, D);
+    setLinkageForGV(*this, GV, D);
 
     if (D->getTLSKind()) {
       if (D->getTLSKind() == VarDecl::TLS_Dynamic)
         CXXThreadLocals.push_back(D);
       setTLSMode(GV, *D);
     }
 
     setGVProperties(GV, D);

         isExternallyVisible(D->getLinkageAndVisibility().getLinkage()))
       GV->setSection(".cp.rodata");
 
     // Check if we a have a const declaration with an initializer, we may be
     // able to emit it as available_externally to expose it's value to the
     // optimizer.
     if (Context.getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
         D->getType().isConstQualified() && !GV->hasInitializer() &&
-        !D->hasDefinition() && D->hasInit() && !D->hasAttr<DLLImportAttr>()) {
+        !D->hasDefinition(Context) && D->hasInit() &&
+        !D->hasAttr<DLLImportAttr>()) {
       const auto *Record =
           Context.getBaseElementType(D->getType())->getAsCXXRecordDecl();
       bool HasMutableFields = Record && Record->hasMutableFields();
       if (!HasMutableFields) {
         const VarDecl *InitDecl;
         const Expr *InitExpr = D->getAnyInitializer(InitDecl);
         if (InitExpr) {
           ConstantEmitter emitter(*this);

       // be internal in order to prevent name conflicts with global
       // host variables with the same name in a different TUs.
       if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>()) {
         Linkage = llvm::GlobalValue::InternalLinkage;
 
         // Shadow variables and their properties must be registered
         // with CUDA runtime.
         unsigned Flags = 0;
-        if (!D->hasDefinition())
+        if (!D->hasDefinition(Context))
           Flags |= CGCUDARuntime::ExternDeviceVar;
         if (D->hasAttr<CUDAConstantAttr>())
           Flags |= CGCUDARuntime::ConstantDeviceVar;
         getCUDARuntime().registerDeviceVar(*GV, Flags);
       } else if (D->hasAttr<CUDASharedAttr>())
         // __shared__ variables are odd. Shadows do get created, but
         // they are not registered with the CUDA runtime, so they
         // can't really be used to access their device-side

                                                       llvm::Function *NewFn) {
   // If we're redefining a global as a function, don't transform it.
   if (!isa<llvm::Function>(Old)) return;
 
   replaceUsesOfNonProtoConstant(Old, NewFn);
 }
 
 void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
-  auto DK = VD->isThisDeclarationADefinition();
+  auto DK = VD->isThisDeclarationADefinition(Context);
   if (DK == VarDecl::Definition && VD->hasAttr<DLLImportAttr>())
     return;
 
   TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
   // If we have a definition, this might be a deferred decl. If the
   // instantiation is explicit, make sure we emit it at the end.
-  if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
+  if (VD->getDefinition(getContext()) &&
+      TSK == TSK_ExplicitInstantiationDefinition)
     GetAddrOfGlobalVar(VD);
 
   EmitTopLevelDecl(VD);
 }
 
 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
                                                  llvm::GlobalValue *GV) {
   const auto *D = cast<FunctionDecl>(GD.getDecl());

   } else {
     GA->setName(MangledName);
   }
 
   // Set attributes which are particular to an alias; this is a
   // specialization of the attributes which may be set on a global
   // variable/function.
   if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() ||
-      D->isWeakImported()) {
+      D->isWeakImported(getContext())) {
     GA->setLinkage(llvm::Function::WeakAnyLinkage);
   }
 
   if (const auto *VD = dyn_cast<VarDecl>(D))
     if (VD->getTLSKind())
       setTLSMode(GA, *VD);
 
   SetCommonAttributes(GD, GA);

lib/CodeGen/ItaniumCXXABI.cpp

 
   llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FI);
   llvm::Function *Wrapper =
       llvm::Function::Create(FnTy, getThreadLocalWrapperLinkage(VD, CGM),
                              WrapperName.str(), &CGM.getModule());
 
   CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, Wrapper);
 
-  if (VD->hasDefinition())
+  if (VD->hasDefinition(CGM.getContext()))
     CGM.SetLLVMFunctionAttributesForDefinition(nullptr, Wrapper);
 
   // Always resolve references to the wrapper at link time.
   if (!Wrapper->hasLocalLinkage() && !(isThreadWrapperReplaceable(VD, CGM) &&
       !llvm::GlobalVariable::isLinkOnceLinkage(Wrapper->getLinkage()) &&
       !llvm::GlobalVariable::isWeakODRLinkage(Wrapper->getLinkage())))
     Wrapper->setVisibility(llvm::GlobalValue::HiddenVisibility);
 

   for (const VarDecl *VD : CXXThreadLocals) {
     llvm::GlobalVariable *Var =
         cast<llvm::GlobalVariable>(CGM.GetGlobalValue(CGM.getMangledName(VD)));
     llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Var);
 
     // Some targets require that all access to thread local variables go through
     // the thread wrapper.  This means that we cannot attempt to create a thread
     // wrapper or a thread helper.
-    if (isThreadWrapperReplaceable(VD, CGM) && !VD->hasDefinition()) {
+    if (isThreadWrapperReplaceable(VD, CGM) &&
+        !VD->hasDefinition(CGM.getContext())) {
       Wrapper->setLinkage(llvm::Function::ExternalLinkage);
       continue;
     }
 
     // Mangle the name for the thread_local initialization function.
     SmallString<256> InitFnName;
     {
       llvm::raw_svector_ostream Out(InitFnName);
       getMangleContext().mangleItaniumThreadLocalInit(VD, Out);
     }
 
     // If we have a definition for the variable, emit the initialization
     // function as an alias to the global Init function (if any). Otherwise,
     // produce a declaration of the initialization function.
     llvm::GlobalValue *Init = nullptr;
     bool InitIsInitFunc = false;
-    if (VD->hasDefinition()) {
+    if (VD->hasDefinition(CGM.getContext())) {
       InitIsInitFunc = true;
       llvm::Function *InitFuncToUse = InitFunc;
       if (isTemplateInstantiation(VD->getTemplateSpecializationKind()))
         InitFuncToUse = UnorderedInits.lookup(VD->getCanonicalDecl());
       if (InitFuncToUse)
         Init = llvm::GlobalAlias::create(Var->getLinkage(), InitFnName.str(),
                                          InitFuncToUse);
     } else {

lib/Index/IndexingContext.cpp

getDeclContextForTemplateInstationPattern(const Decl *D) {
   if (const auto *CTSD =
           dyn_cast<ClassTemplateSpecializationDecl>(D->getDeclContext()))
     return CTSD->getTemplateInstantiationPattern();
   else if (const auto *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
     return RD->getInstantiatedFromMemberClass();
   return nullptr;
 }
 
-static const Decl *adjustTemplateImplicitInstantiation(const Decl *D) {
+static const Decl *
+adjustTemplateImplicitInstantiation(const ASTContext &Context, const Decl *D) {
   if (const ClassTemplateSpecializationDecl *
       SD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
     return SD->getTemplateInstantiationPattern();
   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     return FD->getTemplateInstantiationPattern();
   } else if (auto *VD = dyn_cast<VarDecl>(D)) {
-    return VD->getTemplateInstantiationPattern();
+    return VD->getTemplateInstantiationPattern(Context);
   } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
     return RD->getInstantiatedFromMemberClass();
   } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
     return ED->getInstantiatedFromMemberEnum();
   } else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D)) {
     const auto *ND = cast<NamedDecl>(D);
     if (const CXXRecordDecl *Pattern =
             getDeclContextForTemplateInstationPattern(ND)) {
bool IndexingContext::handleDeclOccurrence(const Decl *D, SourceLocation Loc,
   }
 
   if (!OrigD)
     OrigD = D;
 
   if (isTemplateImplicitInstantiation(D)) {
     if (!IsRef)
       return true;
-    D = adjustTemplateImplicitInstantiation(D);
+    D = adjustTemplateImplicitInstantiation(*Ctx, D);
     if (!D)
       return true;
     assert(!isTemplateImplicitInstantiation(D));
   }
 
   if (IsRef)
     Roles |= (unsigned)SymbolRole::Reference;
   else if (isDeclADefinition(OrigD, ContainerDC, *Ctx))

lib/Sema/Sema.cpp

if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
       // If this is a variable template and none of its specializations is used,
       // we should warn.
       for (const auto *Spec : Template->specializations())
         if (ShouldRemoveFromUnused(SemaRef, Spec))
           return true;
 
     // UnusedFileScopedDecls stores the first declaration.
     // The declaration may have become definition so check again.
-    const VarDecl *DeclToCheck = VD->getDefinition();
+    const VarDecl *DeclToCheck = VD->getDefinition(SemaRef->Context);
     if (DeclToCheck)
       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
 
     // Later redecls may add new information resulting in not having to warn,
     // so check again.
     DeclToCheck = VD->getMostRecentDecl();
     if (DeclToCheck != VD)
       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
           !isExternalWithNoLinkageType(FD) &&
           !FD->getMostRecentDecl()->isInlined() &&
           !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
         continue;
       if (FD->getBuiltinID())
         continue;
     } else {
       auto *VD = cast<VarDecl>(ND);
-      if (VD->hasDefinition() != VarDecl::DeclarationOnly)
+      if (VD->hasDefinition(Context) != VarDecl::DeclarationOnly)
         continue;
       if (VD->isExternallyVisible() &&
           !isExternalWithNoLinkageType(VD) &&
           !VD->getMostRecentDecl()->isInline() &&
           !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
         continue;
 
       // Skip VarDecls that lack formal definitions but which we know are in
       // fact defined somewhere.
-      if (VD->isKnownToBeDefined())
+      if (VD->isKnownToBeDefined(Context))
         continue;
     }
 
     Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
   }
 }
 
 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
void Sema::ActOnEndOfTranslationUnit() {
   //   translation unit contains a file scope declaration of that
   //   identifier, with the composite type as of the end of the
   //   translation unit, with an initializer equal to 0.
   llvm::SmallSet<VarDecl *, 32> Seen;
   for (TentativeDefinitionsType::iterator
             T = TentativeDefinitions.begin(ExternalSource),
          TEnd = TentativeDefinitions.end();
        T != TEnd; ++T) {
-    VarDecl *VD = (*T)->getActingDefinition();
+    VarDecl *VD = (*T)->getActingDefinition(Context);
 
     // If the tentative definition was completed, getActingDefinition() returns
     // null. If we've already seen this variable before, insert()'s second
     // return value is false.
     if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
       continue;
 
     if (const IncompleteArrayType *ArrayT
for (UnusedFileScopedDeclsType::iterator
               << /*function*/0 << DiagD->getDeclName();
           else
             Diag(DiagD->getLocation(),
                  isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
                                            : diag::warn_unused_function)
               << DiagD->getDeclName();
         }
       } else {
-        const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
+        const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition(Context);
         if (!DiagD)
           DiagD = cast<VarDecl>(*I);
         if (DiagD->isReferenced()) {
           Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
                 << /*variable*/1 << DiagD->getDeclName();
         } else if (DiagD->getType().isConstQualified()) {
           const SourceManager &SM = SourceMgr;
           if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||

lib/Sema/SemaChecking.cpp

   ValueDecl *D = nullptr;
   if (DeclRefExpr *R = dyn_cast<DeclRefExpr>(E)) {
     D = R->getDecl();
   } else if (MemberExpr *M = dyn_cast<MemberExpr>(E)) {
     D = M->getMemberDecl();
   }
 
   // Weak Decls can be null.
-  if (!D || D->isWeak())
+  if (!D || D->isWeak(Context))
     return;
 
   // Check for parameter decl with nonnull attribute
   if (const auto* PV = dyn_cast<ParmVarDecl>(D)) {
     if (getCurFunction() &&
         !getCurFunction()->ModifiedNonNullParams.count(PV)) {
       if (const Attr *A = PV->getAttr<NonNullAttr>()) {
         ComplainAboutNonnullParamOrCall(A);

lib/Sema/SemaDecl.cpp

       if (OA && isa<OwnershipAttr>(i))
         return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
       return true;
     }
 
   return false;
 }
 
-static bool isAttributeTargetADefinition(Decl *D) {
+static bool isAttributeTargetADefinition(Sema &S, Decl *D) {
   if (VarDecl *VD = dyn_cast<VarDecl>(D))
-    return VD->isThisDeclarationADefinition();
+    return VD->isThisDeclarationADefinition(S.Context);
   if (TagDecl *TD = dyn_cast<TagDecl>(D))
     return TD->isCompleteDefinition() || TD->isBeingDefined();
   return true;
 }
 
 /// Merge alignment attributes from \p Old to \p New, taking into account the
 /// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
 ///

     if (OldAlign != NewAlign) {
       S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
         << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity()
         << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();
       S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
     }
   }
 
-  if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
+  if (OldAlignasAttr && !NewAlignasAttr &&
+      isAttributeTargetADefinition(S, New)) {
     // C++11 [dcl.align]p6:
     //   if any declaration of an entity has an alignment-specifier,
     //   every defining declaration of that entity shall specify an
     //   equivalent alignment.
     // C11 6.7.5/7:
     //   If the definition of an object does not have an alignment
     //   specifier, any other declaration of that object shall also
     //   have no alignment specifier.

     if (isa<MSInheritanceAttr>(NewAttr))
       S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D));
     return true;
   }
 
   return false;
 }
 
-static const NamedDecl *getDefinition(const Decl *D) {
+static const NamedDecl *getDefinition(Sema &SemaRef, const Decl *D) {
   if (const TagDecl *TD = dyn_cast<TagDecl>(D))
     return TD->getDefinition();
   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
-    const VarDecl *Def = VD->getDefinition();
+    const VarDecl *Def = VD->getDefinition(SemaRef.Context);
     if (Def)
       return Def;
-    return VD->getActingDefinition();
+    return VD->getActingDefinition(SemaRef.Context);
   }
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
     return FD->getDefinition();
   return nullptr;
 }
 
 static bool hasAttribute(const Decl *D, attr::Kind Kind) {
   for (const auto *Attribute : D->attrs())
     if (Attribute->getKind() == Kind)
       return true;
   return false;
 }
 
 /// checkNewAttributesAfterDef - If we already have a definition, check that
 /// there are no new attributes in this declaration.
 static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
   if (!New->hasAttrs())
     return;
 
-  const NamedDecl *Def = getDefinition(Old);
+  const NamedDecl *Def = getDefinition(S, Old);
   if (!Def || Def == New)
     return;
 
   AttrVec &NewAttributes = New->getAttrs();
   for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
     const Attr *NewAttribute = NewAttributes[I];
 
     if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
       if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {
         Sema::SkipBodyInfo SkipBody;
         S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def), &SkipBody);
 
         // If we're skipping this definition, drop the "alias" attribute.
         if (SkipBody.ShouldSkip) {
           NewAttributes.erase(NewAttributes.begin() + I);
           --E;
           continue;
         }
       } else {
         VarDecl *VD = cast<VarDecl>(New);
-        unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
-                                VarDecl::TentativeDefinition
+        unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition(
+                            S.Context) == VarDecl::TentativeDefinition
                             ? diag::err_alias_after_tentative
                             : diag::err_redefinition;
         S.Diag(VD->getLocation(), Diag) << VD->getDeclName();
         if (Diag == diag::err_redefinition)
           S.notePreviousDefinition(Def, VD->getLocation());
         else
           S.Diag(Def->getLocation(), diag::note_previous_definition);
         VD->setInvalidDecl();
       }
       ++I;
       continue;
     }
 
     if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
       // Tentative definitions are only interesting for the alias check above.
-      if (VD->isThisDeclarationADefinition() != VarDecl::Definition) {
+      if (VD->isThisDeclarationADefinition(S.Context) != VarDecl::Definition) {
         ++I;
         continue;
       }
     }
 
     if (hasAttribute(Def, NewAttribute->getKind())) {
       ++I;
       continue; // regular attr merging will take care of validating this.

       Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
       Diag(Old->getLocation(), diag::note_previous_declaration);
     }
   }
 
   // This redeclaration adds a section attribute.
   if (New->hasAttr<SectionAttr>() && !Old->hasAttr<SectionAttr>()) {
     if (auto *VD = dyn_cast<VarDecl>(New)) {
-      if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) {
+      if (VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly) {
         Diag(New->getLocation(), diag::warn_attribute_section_on_redeclaration);
         Diag(Old->getLocation(), diag::note_previous_declaration);
       }
     }
   }
 
   // Redeclaration adds code-seg attribute.
   const auto *NewCSA = New->getAttr<CodeSegAttr>();

     return Sema::CXXCopyAssignment;
   } else if (MD->isMoveAssignmentOperator()) {
     return Sema::CXXMoveAssignment;
   }
 
   return Sema::CXXInvalid;
 }
 
+template <typename DeclT>
+static bool isThisDeclarationADefinition(const ASTContext &, const DeclT *D) {
+  return D->isThisDeclarationADefinition();
+}
+
+static bool isThisDeclarationADefinition(const ASTContext &Context,
+                                         const VarDecl *VD) {
+  return VD->isThisDeclarationADefinition(Context);
+}
+
 // Determine whether the previous declaration was a definition, implicit
 // declaration, or a declaration.
 template <typename T>
 static std::pair<diag::kind, SourceLocation>
-getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {
+getNoteDiagForInvalidRedeclaration(const ASTContext &Context, const T *Old,
+                                   const T *New) {
   diag::kind PrevDiag;
   SourceLocation OldLocation = Old->getLocation();
-  if (Old->isThisDeclarationADefinition())
+  if (isThisDeclarationADefinition(Context, Old))
     PrevDiag = diag::note_previous_definition;
   else if (Old->isImplicit()) {
     PrevDiag = diag::note_previous_implicit_declaration;
     if (OldLocation.isInvalid())
       OldLocation = New->getLocation();
   } else
     PrevDiag = diag::note_previous_declaration;
   return std::make_pair(PrevDiag, OldLocation);
 }
 
 /// canRedefineFunction - checks if a function can be redefined. Currently,
 /// only extern inline functions can be redefined, and even then only in
 /// GNU89 mode.
 static bool canRedefineFunction(const FunctionDecl *FD,
                                 const LangOptions& LangOpts) {
   return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
           !LangOpts.CPlusPlus &&
           FD->isInlineSpecified() &&
           FD->getStorageClass() == SC_Extern);
 }
 

     }
   }
 
   // If the old declaration is invalid, just give up here.
   if (Old->isInvalidDecl())
     return true;
 
   // Disallow redeclaration of some builtins.
-  if (!getASTContext().canBuiltinBeRedeclared(Old)) {
+  if (!Context.canBuiltinBeRedeclared(Old)) {
     Diag(New->getLocation(), diag::err_builtin_redeclare) << Old->getDeclName();
     Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
         << Old << Old->getType();
     return true;
   }
 
   diag::kind PrevDiag;
   SourceLocation OldLocation;
   std::tie(PrevDiag, OldLocation) =
-      getNoteDiagForInvalidRedeclaration(Old, New);
+      getNoteDiagForInvalidRedeclaration(Context, Old, New);
 
   // Don't complain about this if we're in GNU89 mode and the old function
   // is an extern inline function.
   // Don't complain about specializations. They are not supposed to have
   // storage classes.
   if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
       New->getStorageClass() == SC_Static &&
       Old->hasExternalFormalLinkage() &&

     mergeParamDeclAttributes(*ni, *oi, *this);
 
   CheckObjCMethodOverride(newMethod, oldMethod);
 }
 
 static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl* Old) {
   assert(!S.Context.hasSameType(New->getType(), Old->getType()));
 
-  S.Diag(New->getLocation(), New->isThisDeclarationADefinition()
+  S.Diag(New->getLocation(), New->isThisDeclarationADefinition(S.Context)
          ? diag::err_redefinition_different_type
          : diag::err_redeclaration_different_type)
     << New->getDeclName() << New->getType() << Old->getType();
 
   diag::kind PrevDiag;
   SourceLocation OldLocation;
-  std::tie(PrevDiag, OldLocation)
-    = getNoteDiagForInvalidRedeclaration(Old, New);
+  std::tie(PrevDiag, OldLocation) =
+      getNoteDiagForInvalidRedeclaration(S.Context, Old, New);
   S.Diag(OldLocation, PrevDiag);
   New->setInvalidDecl();
 }
 
 /// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
 /// scope as a previous declaration 'Old'.  Figure out how to merge their types,
 /// emitting diagnostics as appropriate.
 ///

 
   MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous));
   if (New->isInvalidDecl())
     return;
 
   diag::kind PrevDiag;
   SourceLocation OldLocation;
   std::tie(PrevDiag, OldLocation) =
-      getNoteDiagForInvalidRedeclaration(Old, New);
+      getNoteDiagForInvalidRedeclaration(Context, Old, New);
 
   // [dcl.stc]p8: Check if we have a non-static decl followed by a static.
   if (New->getStorageClass() == SC_Static &&
       !New->isStaticDataMember() &&
       Old->hasExternalFormalLinkage()) {
     if (getLangOpts().MicrosoftExt) {
       Diag(New->getLocation(), diag::ext_static_non_static)
           << New->getDeclName();

       !(Old->getLexicalDeclContext()->isRecord() &&
         !New->getLexicalDeclContext()->isRecord())) {
     Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
     Diag(OldLocation, PrevDiag);
     return New->setInvalidDecl();
   }
 
   if (New->isInline() && !Old->getMostRecentDecl()->isInline()) {
-    if (VarDecl *Def = Old->getDefinition()) {
+    if (VarDecl *Def = Old->getDefinition(Context)) {
       // C++1z [dcl.fcn.spec]p4:
       //   If the definition of a variable appears in a translation unit before
       //   its first declaration as inline, the program is ill-formed.
       Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
       Diag(Def->getLocation(), diag::note_previous_definition);
     }
   }
 
   // If this redeclaration makes the variable inline, we may need to add it to
   // UndefinedButUsed.
   if (!Old->isInline() && New->isInline() && Old->isUsed(false) &&
-      !Old->getDefinition() && !New->isThisDeclarationADefinition())
+      !Old->getDefinition(Context) &&
+      !New->isThisDeclarationADefinition(Context))
     UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
                                            SourceLocation()));
 
   if (New->getTLSKind() != Old->getTLSKind()) {
     if (!Old->getTLSKind()) {
       Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
       Diag(OldLocation, PrevDiag);
     } else if (!New->getTLSKind()) {
       Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
       Diag(OldLocation, PrevDiag);
     } else {
       // Do not allow redeclaration to change the variable between requiring
       // static and dynamic initialization.
       // FIXME: GCC allows this, but uses the TLS keyword on the first
       // declaration to determine the kind. Do we need to be compatible here?
       Diag(New->getLocation(), diag::err_thread_thread_different_kind)
         << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
       Diag(OldLocation, PrevDiag);
     }
   }
 
   // C++ doesn't have tentative definitions, so go right ahead and check here.
   if (getLangOpts().CPlusPlus &&
-      New->isThisDeclarationADefinition() == VarDecl::Definition) {
+      New->isThisDeclarationADefinition(Context) == VarDecl::Definition) {
     if (Old->isStaticDataMember() && Old->getCanonicalDecl()->isInline() &&
         Old->getCanonicalDecl()->isConstexpr()) {
       // This definition won't be a definition any more once it's been merged.
       Diag(New->getLocation(),
            diag::warn_deprecated_redundant_constexpr_static_def);
-    } else if (VarDecl *Def = Old->getDefinition()) {
+    } else if (VarDecl *Def = Old->getDefinition(Context)) {
       if (checkVarDeclRedefinition(Def, New))
         return;
     }
   }
 
   if (haveIncompatibleLanguageLinkages(Old, New)) {
     Diag(New->getLocation(), diag::err_different_language_linkage) << New;
     Diag(OldLocation, PrevDiag);

       ND.dropAttr<WeakRefAttr>();
       ND.dropAttr<AliasAttr>();
     }
   }
 
   if (auto *VD = dyn_cast<VarDecl>(&ND)) {
     if (VD->hasInit()) {
       if (const auto *Attr = VD->getAttr<AliasAttr>()) {
-        assert(VD->isThisDeclarationADefinition() &&
+        assert(VD->isThisDeclarationADefinition(S.Context) &&
                !VD->isExternallyVisible() && "Broken AliasAttr handled late!");
         S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD << 0;
         VD->dropAttr<AliasAttr>();
       }
     }
   }
 
   // 'selectany' only applies to externally visible variable declarations.

     Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
     NewVD->setType(FixedT);
     NewVD->setTypeSourceInfo(FixedTInfo);
   }
 
   if (T->isVoidType()) {
     // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names
     //                    of objects and functions.
-    if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) {
+    if (NewVD->isThisDeclarationADefinition(Context) ||
+        getLangOpts().CPlusPlus) {
       Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
         << T;
       NewVD->setInvalidDecl();
       return;
     }
   }
 
   if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {

                                AbstractVariableType))
       VDecl->setInvalidDecl();
   }
 
   // If adding the initializer will turn this declaration into a definition,
   // and we already have a definition for this variable, diagnose or otherwise
   // handle the situation.
   VarDecl *Def;
-  if ((Def = VDecl->getDefinition()) && Def != VDecl &&
+  if ((Def = VDecl->getDefinition(Context)) && Def != VDecl &&
       (!VDecl->isStaticDataMember() || VDecl->isOutOfLine()) &&
       !VDecl->isThisDeclarationADemotedDefinition() &&
       checkVarDeclRedefinition(Def, VDecl))
     return;
 
   if (getLangOpts().CPlusPlus) {
     // C++ [class.static.data]p4
     //   If a static data member is of const integral or const

       return;
 
     // C++11 [class.static.data]p3: A static data member can be declared with
     // the constexpr specifier; if so, its declaration shall specify
     // a brace-or-equal-initializer.
     // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to
     // the definition of a variable [...] or the declaration of a static data
     // member.
-    if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() &&
+    if (Var->isConstexpr() && !Var->isThisDeclarationADefinition(Context) &&
         !Var->isThisDeclarationADemotedDefinition()) {
       if (Var->isStaticDataMember()) {
         // C++1z removes the relevant rule; the in-class declaration is always
         // a definition there.
         if (!getLangOpts().CPlusPlus17) {
           Diag(Var->getLocation(),
                diag::err_constexpr_static_mem_var_requires_init)
             << Var->getDeclName();

     if (!Var->isInvalidDecl() &&
         Var->getType().getAddressSpace() == LangAS::opencl_constant &&
         Var->getStorageClass() != SC_Extern && !Var->getInit()) {
       Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
       Var->setInvalidDecl();
       return;
     }
 
-    switch (Var->isThisDeclarationADefinition()) {
+    switch (Var->isThisDeclarationADefinition(Context)) {
     case VarDecl::Definition:
       if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
         break;
 
       // We have an out-of-line definition of a static data member
       // that has an in-class initializer, so we type-check this like
       // a declaration.
       //

       var->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)
     setFunctionHasBranchProtectedScope();
 
   // Warn about externally-visible variables being defined without a
   // prior declaration.  We only want to do this for global
   // declarations, but we also specifically need to avoid doing it for
   // class members because the linkage of an anonymous class can
   // change if it's later given a typedef name.
-  if (var->isThisDeclarationADefinition() &&
+  if (var->isThisDeclarationADefinition(Context) &&
       var->getDeclContext()->getRedeclContext()->isFileContext() &&
       var->isExternallyVisible() && var->hasLinkage() &&
       !var->isInline() && !var->getDescribedVarTemplate() &&
       !isTemplateInstantiation(var->getTemplateSpecializationKind()) &&
       !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
                                   var->getLocation())) {
     // Find a previous declaration that's not a definition.
     VarDecl *prev = var->getPreviousDecl();
-    while (prev && prev->isThisDeclarationADefinition())
+    while (prev && prev->isThisDeclarationADefinition(Context))
       prev = prev->getPreviousDecl();
 
     if (!prev)
       Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
   }
 
   // Cache the result of checking for constant initialization.
   Optional<bool> CacheHasConstInit;

         if (getLangOpts().CPlusPlus11)
           Diag(var->getLocation(), diag::note_use_thread_local);
       }
     }
   }
 
   // Apply section attributes and pragmas to global variables.
   bool GlobalStorage = var->hasGlobalStorage();
-  if (GlobalStorage && var->isThisDeclarationADefinition() &&
+  if (GlobalStorage && var->isThisDeclarationADefinition(Context) &&
       !inTemplateInstantiation()) {
     PragmaStack<StringLiteral *> *Stack = nullptr;
     int SectionFlags = ASTContext::PSF_Implicit | ASTContext::PSF_Read;
     if (var->getType().isConstQualified())
       Stack = &ConstSegStack;
     else if (!var->getInit()) {
       Stack = &BSSSegStack;
       SectionFlags |= ASTContext::PSF_Write;

           << var << Init->getSourceRange();
         for (unsigned I = 0, N = Notes.size(); I != N; ++I)
           Diag(Notes[I].first, Notes[I].second);
       }
     } else if (var->isUsableInConstantExpressions(Context)) {
       // Check whether the initializer of a const variable of integral or
       // enumeration type is an ICE now, since we can't tell whether it was
       // initialized by a constant expression if we check later.
-      var->checkInitIsICE();
+      var->checkInitIsICE(Context);
     }
 
     // Don't emit further diagnostics about constexpr globals since they
     // were just diagnosed.
     if (!var->isConstexpr() && GlobalStorage &&
             var->hasAttr<RequireConstantInitAttr>()) {
       // FIXME: Need strict checking in C++03 here.
-      bool DiagErr = getLangOpts().CPlusPlus11
-          ? !var->checkInitIsICE() : !checkConstInit();
+      bool DiagErr = getLangOpts().CPlusPlus11 ? !var->checkInitIsICE(Context)
+                                               : !checkConstInit();
       if (DiagErr) {
         auto attr = var->getAttr<RequireConstantInitAttr>();
         Diag(var->getLocation(), diag::err_require_constant_init_failed)
           << Init->getSourceRange();
         Diag(attr->getLocation(), diag::note_declared_required_constant_init_here)
           << attr->getRange();
         if (getLangOpts().CPlusPlus11) {
           APValue Value;

   // Note that we are no longer parsing the initializer for this declaration.
   ParsingInitForAutoVars.erase(ThisDecl);
 
   VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
   if (!VD)
     return;
 
   // Apply an implicit SectionAttr if '#pragma clang section bss|data|rodata' is active
-  if (VD->hasGlobalStorage() && VD->isThisDeclarationADefinition() &&
+  if (VD->hasGlobalStorage() && VD->isThisDeclarationADefinition(Context) &&
       !inTemplateInstantiation() && !VD->hasAttr<SectionAttr>()) {
     if (PragmaClangBSSSection.Valid)
       VD->addAttr(PragmaClangBSSSectionAttr::CreateImplicit(Context,
                                                             PragmaClangBSSSection.SectionName,
                                                             PragmaClangBSSSection.PragmaLocation));
     if (PragmaClangDataSection.Valid)
       VD->addAttr(PragmaClangDataSectionAttr::CreateImplicit(Context,
                                                              PragmaClangDataSection.SectionName,

     checkAllowedCUDAInitializer(VD);
 
   // Grab the dllimport or dllexport attribute off of the VarDecl.
   const InheritableAttr *DLLAttr = getDLLAttr(VD);
 
   // Imported static data members cannot be defined out-of-line.
   if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
     if (VD->isStaticDataMember() && VD->isOutOfLine() &&
-        VD->isThisDeclarationADefinition()) {
+        VD->isThisDeclarationADefinition(Context)) {
       // We allow definitions of dllimport class template static data members
       // with a warning.
       CXXRecordDecl *Context =
         cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext());
       bool IsClassTemplateMember =
           isa<ClassTemplatePartialSpecializationDecl>(Context) ||
           Context->getDescribedClassTemplate();
 

     } else {
       Diag(VD->getLocation(), diag::err_attribute_dll_thread_local) << VD
                                                                     << DLLAttr;
       VD->setInvalidDecl();
     }
   }
 
   if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) {
-    if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {
+    if (!Attr->isInherited() && !VD->isThisDeclarationADefinition(Context)) {
       Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr;
       VD->dropAttr<UsedAttr>();
     }
   }
 
   const DeclContext *DC = VD->getDeclContext();
   // If there's a #pragma GCC visibility in scope, and this isn't a class
   // member, set the visibility of this variable.

lib/Sema/SemaDeclAttr.cpp

   // Aliases should be on declarations, not definitions.
   if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->isThisDeclarationADefinition()) {
       S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 0;
       return;
     }
   } else {
     const auto *VD = cast<VarDecl>(D);
-    if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {
+    if (VD->isThisDeclarationADefinition(S.Context) &&
+        VD->isExternallyVisible()) {
       S.Diag(AL.getLoc(), diag::err_alias_is_definition) << VD << 0;
       return;
     }
   }
 
   // FIXME: check if target symbol exists in current file
 
   D->addAttr(::new (S.Context) AliasAttr(AL.getRange(), S.Context, Str,

   D->addAttr(::new (S.Context)
              WarnUnusedResultAttr(AL.getRange(), S.Context,
                                   AL.getAttributeSpellingListIndex()));
 }
 
 static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   // weak_import only applies to variable & function declarations.
   bool isDef = false;
-  if (!D->canBeWeakImported(isDef)) {
+  if (!D->canBeWeakImported(S.Context, isDef)) {
     if (isDef)
       S.Diag(AL.getLoc(), diag::warn_attribute_invalid_on_definition)
         << "weak_import";
     else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
              (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
               (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
       // Nothing to warn about here.
     } else

lib/Sema/SemaDeclCXX.cpp

     InitializationSequence Seq(S, Entity, Kind, Init);
     E = Seq.Perform(S, Entity, Kind, Init);
     if (E.isInvalid())
       return true;
     E = S.ActOnFinishFullExpr(E.get(), Loc);
     if (E.isInvalid())
       return true;
     RefVD->setInit(E.get());
-    RefVD->checkInitIsICE();
+    RefVD->checkInitIsICE(S.Context);
 
     E = S.BuildDeclarationNameExpr(CXXScopeSpec(),
                                    DeclarationNameInfo(B->getDeclName(), Loc),
                                    RefVD);
     if (E.isInvalid())
       return true;
 
     B->setBinding(T, E.get());

       continue;
 
     case Decl::Var:
     case Decl::Decomposition: {
       // C++1y [dcl.constexpr]p3 allows anything except:
       //   a definition of a variable of non-literal type or of static or
       //   thread storage duration or for which no initialization is performed.
       const auto *VD = cast<VarDecl>(DclIt);
-      if (VD->isThisDeclarationADefinition()) {
+      if (VD->isThisDeclarationADefinition(SemaRef.Context)) {
         if (VD->isStaticLocal()) {
           SemaRef.Diag(VD->getLocation(),
                        diag::err_constexpr_local_var_static)
             << isa<CXXConstructorDecl>(Dcl)
             << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
           return false;
         }
         if (!VD->getType()->isDependentType() &&

 
     VarDecl *VD = ValInfo->VD;
     assert(VD && "should not be null!");
 
     // Attempt to diagnose reasons why the STL definition of this type
     // might be foobar, including it failing to be a constant expression.
     // TODO Handle more ways the lookup or result can be invalid.
     if (!VD->isStaticDataMember() || !VD->isConstexpr() || !VD->hasInit() ||
-        !VD->checkInitIsICE())
+        !VD->checkInitIsICE(Context))
       return UnsupportedSTLError(USS_InvalidMember, MemName, VD);
 
     // Attempt to evaluate the var decl as a constant expression and extract
     // the value of its first field as a ICE. If this fails, the STL
     // implementation is not supported.
-    if (!ValInfo->hasValidIntValue())
+    if (!ValInfo->hasValidIntValue(Context))
       return UnsupportedSTLError();
 
     MarkVariableReferenced(Loc, VD);
   }
 
   // We've successfully built the required types and expressions. Update
   // the cache and return the newly cached value.
   FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)] = true;

lib/Sema/SemaExpr.cpp

       break;
     default:
       break;
     }
     S.DiagRuntimeBehavior(Loc, nullptr,
                           S.PDiag(diag::warn_comparison_always)
                               << 0 /*self-comparison*/ << !Result.empty()
                               << Result);
-  } else if (DL && DR &&
-             DL->getType()->isArrayType() && DR->getType()->isArrayType() &&
-             !DL->isWeak() && !DR->isWeak()) {
+  } else if (DL && DR && DL->getType()->isArrayType() &&
+             DR->getType()->isArrayType() && !DL->isWeak(S.Context) &&
+             !DR->isWeak(S.Context)) {
     // What is it always going to evaluate to?
     StringRef Result;
     switch(Opc) {
     case BO_EQ: // e.g. array1 == array2
       Result = "false";
       break;
     case BO_NE: // e.g. array1 != array2
       Result = "true";

lib/Sema/SemaExprCXX.cpp

 static inline bool VariableCanNeverBeAConstantExpression(VarDecl *Var,
     ASTContext &Context) {
   if (isa<ParmVarDecl>(Var)) return true;
   const VarDecl *DefVD = nullptr;
 
   // If there is no initializer - this can not be a constant expression.
   if (!Var->getAnyInitializer(DefVD)) return true;
   assert(DefVD);
-  if (DefVD->isWeak()) return false;
+  if (DefVD->isWeak(Context))
+    return false;
   EvaluatedStmt *Eval = DefVD->ensureEvaluatedStmt();
 
   Expr *Init = cast<Expr>(Eval->Value);
 
   if (Var->getType()->isDependentType() || Init->isValueDependent()) {
     // FIXME: Teach the constant evaluator to deal with the non-dependent parts
     // of value-dependent expressions, and use it here to determine whether the
     // initializer is a potential constant expression.

lib/Sema/SemaLookup.cpp

       Entity = Pattern;
   } else if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Entity)) {
     if (CXXRecordDecl *Pattern = RD->getTemplateInstantiationPattern())
       Entity = Pattern;
   } else if (EnumDecl *ED = dyn_cast<EnumDecl>(Entity)) {
     if (auto *Pattern = ED->getTemplateInstantiationPattern())
       Entity = Pattern;
   } else if (VarDecl *VD = dyn_cast<VarDecl>(Entity)) {
-    if (VarDecl *Pattern = VD->getTemplateInstantiationPattern())
+    if (VarDecl *Pattern = VD->getTemplateInstantiationPattern(S.Context))
       Entity = Pattern;
   }
 
   // Walk up to the containing context. That might also have been instantiated
   // from a template.
   DeclContext *Context = Entity->getLexicalDeclContext();
   if (Context->isFileContext())
     return S.getOwningModule(Entity);

                         const PartialDiagnostic &TypoDiag,
                         bool ErrorRecovery) {
   diagnoseTypo(Correction, TypoDiag, PDiag(diag::note_previous_decl),
                ErrorRecovery);
 }
 
 /// Find which declaration we should import to provide the definition of
 /// the given declaration.
-static NamedDecl *getDefinitionToImport(NamedDecl *D) {
+static NamedDecl *getDefinitionToImport(const ASTContext &Context,
+                                        NamedDecl *D) {
   if (VarDecl *VD = dyn_cast<VarDecl>(D))
-    return VD->getDefinition();
+    return VD->getDefinition(Context);
   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
     return FD->getDefinition();
   if (TagDecl *TD = dyn_cast<TagDecl>(D))
     return TD->getDefinition();
   if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D))
     return ID->getDefinition();
   if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D))
     return PD->getDefinition();
   if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
-    return getDefinitionToImport(TD->getTemplatedDecl());
+    return getDefinitionToImport(Context, TD->getTemplatedDecl());
   return nullptr;
 }
 
 void Sema::diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
                                  MissingImportKind MIK, bool Recover) {
   // Suggest importing a module providing the definition of this entity, if
   // possible.
-  NamedDecl *Def = getDefinitionToImport(Decl);
+  NamedDecl *Def = getDefinitionToImport(Context, Decl);
   if (!Def)
     Def = Decl;
 
   Module *Owner = getOwningModule(Def);
   assert(Owner && "definition of hidden declaration is not in a module");
 
   llvm::SmallVector<Module*, 8> OwningModules;
   OwningModules.push_back(Owner);

lib/Sema/SemaOpenMP.cpp

     }
 
     OpenMPDirectiveKind CurrDir = Stack->getCurrentDirective();
     // OpenMP [2.9.3.6, Restrictions, C/C++, p.4]
     //  If a list-item is a reference type then it must bind to the same object
     //  for all threads of the team.
     if (!ASE && !OASE) {
       if (VD) {
-        VarDecl *VDDef = VD->getDefinition();
+        VarDecl *VDDef = VD->getDefinition(S.Context);
         if (VD->getType()->isReferenceType() && VDDef && VDDef->hasInit()) {
           DSARefChecker Check(Stack);
           if (Check.Visit(VDDef->getInit())) {
             S.Diag(ELoc, diag::err_omp_reduction_ref_type_arg)
                 << getOpenMPClauseName(ClauseKind) << ERange;
             S.Diag(VDDef->getLocation(), diag::note_defined_here) << VDDef;
             continue;
           }

lib/Sema/SemaTemplateInstantiate.cpp

 
         if (TSK == TSK_ExplicitInstantiationDefinition) {
           // C++0x [temp.explicit]p8:
           //   An explicit instantiation definition that names a class template
           //   specialization explicitly instantiates the class template
           //   specialization and is only an explicit instantiation definition
           //   of members whose definition is visible at the point of
           //   instantiation.
-          if (!Var->getInstantiatedFromStaticDataMember()->getDefinition())
+          if (!Var->getInstantiatedFromStaticDataMember()->getDefinition(
+                  Context))
             continue;
 
           Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
           InstantiateVariableDefinition(PointOfInstantiation, Var);
         } else {
           Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
         }
       }

lib/Sema/SemaTemplateInstantiateDecl.cpp

           VarTemplate, FromVar, InsertPos, TemplateArgsInfo, Converted));
 }
 
 /// Instantiates a variable template specialization by completing it
 /// with appropriate type information and initializer.
 VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl(
     VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
     const MultiLevelTemplateArgumentList &TemplateArgs) {
-  assert(PatternDecl->isThisDeclarationADefinition() &&
+  assert(PatternDecl->isThisDeclarationADefinition(Context) &&
          "don't have a definition to instantiate from");
 
   // Do substitution on the type of the declaration
   TypeSourceInfo *DI =
       SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
                 PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
   if (!DI)
     return nullptr;

   Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
   Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));
 
   // Delay instantiation of the initializer for variable templates or inline
   // static data members until a definition of the variable is needed. We need
   // it right away if the type contains 'auto'.
   if ((!isa<VarTemplateSpecializationDecl>(NewVar) &&
        !InstantiatingVarTemplate &&
-       !(OldVar->isInline() && OldVar->isThisDeclarationADefinition() &&
-         !NewVar->isThisDeclarationADefinition())) ||
+       !(OldVar->isInline() && OldVar->isThisDeclarationADefinition(Context) &&
+         !NewVar->isThisDeclarationADefinition(Context))) ||
       NewVar->getType()->isUndeducedType())
     InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
 
   // Diagnose unused local variables with dependent types, where the diagnostic
   // will have been deferred.
   if (!NewVar->isInvalidDecl() &&
       NewVar->getDeclContext()->isFunctionOrMethod() &&
       OldVar->getType()->isDependentType())

       // This variable may have local implicit instantiations that need to be
       // instantiated within this scope.
       LocalInstantiations.perform();
       Local.Exit();
       GlobalInstantiations.perform();
     }
 
     // Find actual definition
-    Def = PatternDecl->getDefinition(getASTContext());
+    Def = PatternDecl->getDefinition(Context);
   } else {
     // If this is a static data member, find its out-of-line definition.
     assert(Var->isStaticDataMember() && "not a static data member?");
     PatternDecl = Var->getInstantiatedFromStaticDataMember();
 
     assert(PatternDecl && "data member was not instantiated from a template?");
     assert(PatternDecl->isStaticDataMember() && "not a static data member?");
-    Def = PatternDecl->getDefinition();
+    Def = PatternDecl->getDefinition(Context);
   }
 
   TemplateSpecializationKind TSK = Var->getTemplateSpecializationKind();
 
   // If we don't have a definition of the variable template, we won't perform
   // any instantiation. Rather, we rely on the user to instantiate this
   // definition (or provide a specialization for it) in another translation
   // unit.

       : Consumer(Consumer), Var(Var) { }
 
     ~PassToConsumerRAII() {
       Consumer.HandleCXXStaticMemberVarInstantiation(Var);
     }
   } PassToConsumerRAII(Consumer, Var);
 
   // If we already have a definition, we're done.
-  if (VarDecl *Def = Var->getDefinition()) {
+  if (VarDecl *Def = Var->getDefinition(Context)) {
     // We may be explicitly instantiating something we've already implicitly
     // instantiated.
     Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
                                        PointOfInstantiation);
     return;
   }
 
   InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);

lib/Sema/SemaType.cpp

 
   deduceOpenCLImplicitAddrSpace(state, type, TAL);
 }
 
 void Sema::completeExprArrayBound(Expr *E) {
   if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
     if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
       if (isTemplateInstantiation(Var->getTemplateSpecializationKind())) {
-        auto *Def = Var->getDefinition();
+        auto *Def = Var->getDefinition(Context);
         if (!Def) {
           SourceLocation PointOfInstantiation = E->getExprLoc();
           InstantiateVariableDefinition(PointOfInstantiation, Var);
-          Def = Var->getDefinition();
+          Def = Var->getDefinition(Context);
 
           // If we don't already have a point of instantiation, and we managed
           // to instantiate a definition, this is the point of instantiation.
           // Otherwise, we don't request an end-of-TU instantiation, so this is
           // not a point of instantiation.
           // FIXME: Is this really the right behavior?
           if (Var->getPointOfInstantiation().isInvalid() && Def) {
             assert(Var->getTemplateSpecializationKind() ==

       return false;
     }
     D = ED->getDefinition();
   } else if (auto *FD = dyn_cast<FunctionDecl>(D)) {
     if (auto *Pattern = FD->getTemplateInstantiationPattern())
       FD = Pattern;
     D = FD->getDefinition();
   } else if (auto *VD = dyn_cast<VarDecl>(D)) {
-    if (auto *Pattern = VD->getTemplateInstantiationPattern())
+    if (auto *Pattern = VD->getTemplateInstantiationPattern(Context))
       VD = Pattern;
-    D = VD->getDefinition();
+    D = VD->getDefinition(Context);
   }
   assert(D && "missing definition for pattern of instantiated definition");
 
   *Suggested = D;
 
   auto DefinitionIsVisible = [&] {
     // The (primary) definition might be in a visible module.
     if (isVisible(D))

lib/Serialization/ASTReaderDecl.cpp

       isa<ImportDecl>(D) ||
       isa<PragmaCommentDecl>(D) ||
       isa<PragmaDetectMismatchDecl>(D))
     return true;
   if (isa<OMPThreadPrivateDecl>(D) || isa<OMPDeclareReductionDecl>(D))
     return !D->getDeclContext()->isFunctionOrMethod();
   if (const auto *Var = dyn_cast<VarDecl>(D))
     return Var->isFileVarDecl() &&
-           (Var->isThisDeclarationADefinition() == VarDecl::Definition ||
+           (Var->isThisDeclarationADefinition(Ctx) == VarDecl::Definition ||
             OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Var));
   if (const auto *Func = dyn_cast<FunctionDecl>(D))
     return Func->doesThisDeclarationHaveABody() || HasBody;
 
   if (auto *ES = D->getASTContext().getExternalSource())
     if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
       return true;
 

   auto *VD = static_cast<VarDecl *>(D);
   auto *PrevVD = cast<VarDecl>(Previous);
   D->RedeclLink.setPrevious(PrevVD);
   D->First = PrevVD->First;
 
   // We should keep at most one definition on the chain.
   // FIXME: Cache the definition once we've found it. Building a chain with
   // N definitions currently takes O(N^2) time here.
-  if (VD->isThisDeclarationADefinition() == VarDecl::Definition) {
+  if (VD->isThisDeclarationADefinition(Reader.getContext()) ==
+      VarDecl::Definition) {
     for (VarDecl *CurD = PrevVD; CurD; CurD = CurD->getPreviousDecl()) {
-      if (CurD->isThisDeclarationADefinition() == VarDecl::Definition) {
+      if (CurD->isThisDeclarationADefinition(Reader.getContext()) ==
+          VarDecl::Definition) {
         Reader.mergeDefinitionVisibility(CurD, VD);
         VD->demoteThisDefinitionToDeclaration();
         break;
       }
     }
   }
 }
 

lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp

SVal SimpleSValBuilder::evalCastFromLoc(Loc val, QualType castTy) {
   // Casting a Loc to a bool will almost always be true,
   // unless this is a weak function or a symbolic region.
   if (castTy->isBooleanType()) {
     switch (val.getSubKind()) {
       case loc::MemRegionValKind: {
         const MemRegion *R = val.castAs<loc::MemRegionVal>().getRegion();
         if (const FunctionCodeRegion *FTR = dyn_cast<FunctionCodeRegion>(R))
           if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(FTR->getDecl()))
-            if (FD->isWeak())
+            if (FD->isWeak(getContext()))
               // FIXME: Currently we are using an extent symbol here,
               // because there are no generic region address metadata
               // symbols to use, only content metadata.
               return nonloc::SymbolVal(SymMgr.getExtentSymbol(FTR));
 
         if (const SymbolicRegion *SymR = R->getSymbolicBase())
           return makeNonLoc(SymR->getSymbol(), BO_NE,
                             BasicVals.getZeroWithPtrWidth(), castTy);

tools/libclang/CIndex.cpp

     return clang_getNullCursor();
   }
 
   case Decl::Var:
   case Decl::VarTemplateSpecialization:
   case Decl::VarTemplatePartialSpecialization:
   case Decl::Decomposition: {
     // Ask the variable if it has a definition.
-    if (const VarDecl *Def = cast<VarDecl>(D)->getDefinition())
+    if (const VarDecl *Def =
+            cast<VarDecl>(D)->getDefinition(D->getASTContext()))
       return MakeCXCursor(Def, TU);
     return clang_getNullCursor();
   }
 
   case Decl::FunctionTemplate: {
     const FunctionDecl *Def = nullptr;
     if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def))
       return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU);
     return clang_getNullCursor();
   }
 
   case Decl::ClassTemplate: {
     if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl()
                                                             ->getDefinition())
       return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(),
                           TU);
     return clang_getNullCursor();
   }
 
   case Decl::VarTemplate: {
     if (VarDecl *Def =
-            cast<VarTemplateDecl>(D)->getTemplatedDecl()->getDefinition())
+            cast<VarTemplateDecl>(D)->getTemplatedDecl()->getDefinition(
+                D->getASTContext()))
       return MakeCXCursor(cast<VarDecl>(Def)->getDescribedVarTemplate(), TU);
     return clang_getNullCursor();
   }
 
   case Decl::Using:
     return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D), 
                                        D->getLocation(), TU);
 

tools/libclang/CXIndexDataConsumer.cpp

bool CXIndexDataConsumer::handleFunction(const FunctionDecl *D) {
 
   DeclInfo DInfo(!D->isFirstDecl(), isDef, isContainer);
   if (isSkipped)
     DInfo.flags |= CXIdxDeclFlag_Skipped;
   return handleDecl(D, D->getLocation(), getCursor(D), DInfo);
 }
 
 bool CXIndexDataConsumer::handleVar(const VarDecl *D) {
-  DeclInfo DInfo(!D->isFirstDecl(), D->isThisDeclarationADefinition(),
+  DeclInfo DInfo(!D->isFirstDecl(),
+                 D->isThisDeclarationADefinition(getASTContext()),
                  /*isContainer=*/false);
   return handleDecl(D, D->getLocation(), getCursor(D), DInfo);
 }
 
 bool CXIndexDataConsumer::handleField(const FieldDecl *D) {
   DeclInfo DInfo(/*isRedeclaration=*/false, /*isDefinition=*/true,
                  /*isContainer=*/false);
   return handleDecl(D, D->getLocation(), getCursor(D), DInfo);

unittests/AST/ASTImporterTest.cpp

                            "input1.cc");
 
   auto *FromDWithInit = FirstDeclMatcher<VarDecl>().match(
       FromTU, varDecl(hasName("a"))); // Decl with init
   auto *FromDWithDef = LastDeclMatcher<VarDecl>().match(
       FromTU, varDecl(hasName("a"))); // Decl with definition
   ASSERT_EQ(FromDWithInit, FromDWithDef->getPreviousDecl());
   ASSERT_TRUE(FromDWithInit->getInit());
-  ASSERT_FALSE(FromDWithInit->isThisDeclarationADefinition());
-  ASSERT_TRUE(FromDWithDef->isThisDeclarationADefinition());
+  ASSERT_FALSE(FromDWithInit->isThisDeclarationADefinition(
+      FromDWithInit->getASTContext()));
+  ASSERT_TRUE(FromDWithDef->isThisDeclarationADefinition(
+      FromDWithDef->getASTContext()));
   ASSERT_FALSE(FromDWithDef->getInit());
 
   auto *ToD = FirstDeclMatcher<VarDecl>().match(
       ToTU, varDecl(hasName("a"))); // Decl with init
   ASSERT_TRUE(ToD->getInit());
-  ASSERT_FALSE(ToD->getDefinition());
+  ASSERT_FALSE(ToD->getDefinition(ToD->getASTContext()));
 
   auto *ImportedD = cast<VarDecl>(Import(FromDWithDef, Lang_CXX11));
   EXPECT_TRUE(ImportedD->getAnyInitializer());
-  EXPECT_TRUE(ImportedD->getDefinition());
+  EXPECT_TRUE(ImportedD->getDefinition(ImportedD->getASTContext()));
 }
 
 TEST_P(ImportVariables, InitAndDefinitionAreInTheFromContext) {
   auto StructA =
       R"(
       struct A {
         static const int a;
       };
       )";
   Decl *ToTU = getToTuDecl(StructA, Lang_CXX);
   Decl *FromTU = getTuDecl(std::string(StructA) + "const int A::a = 1 + 2;",
                            Lang_CXX, "input1.cc");
 
   auto *FromDDeclarationOnly = FirstDeclMatcher<VarDecl>().match(
       FromTU, varDecl(hasName("a")));
   auto *FromDWithDef = LastDeclMatcher<VarDecl>().match(
       FromTU, varDecl(hasName("a"))); // Decl with definition and with init.
   ASSERT_EQ(FromDDeclarationOnly, FromDWithDef->getPreviousDecl());
   ASSERT_FALSE(FromDDeclarationOnly->getInit());
-  ASSERT_FALSE(FromDDeclarationOnly->isThisDeclarationADefinition());
-  ASSERT_TRUE(FromDWithDef->isThisDeclarationADefinition());
+  ASSERT_FALSE(FromDDeclarationOnly->isThisDeclarationADefinition(
+      FromDDeclarationOnly->getASTContext()));
+  ASSERT_TRUE(FromDWithDef->isThisDeclarationADefinition(
+      FromDWithDef->getASTContext()));
   ASSERT_TRUE(FromDWithDef->getInit());
 
   auto *ToD = FirstDeclMatcher<VarDecl>().match(
       ToTU, varDecl(hasName("a")));
   ASSERT_FALSE(ToD->getInit());
-  ASSERT_FALSE(ToD->getDefinition());
+  ASSERT_FALSE(ToD->getDefinition(ToD->getASTContext()));
 
   auto *ImportedD = cast<VarDecl>(Import(FromDWithDef, Lang_CXX11));
   EXPECT_TRUE(ImportedD->getAnyInitializer());
-  EXPECT_TRUE(ImportedD->getDefinition());
+  EXPECT_TRUE(ImportedD->getDefinition(ImportedD->getASTContext()));
 }
 
 struct DeclContextTest : ASTImporterTestBase {};
 
 TEST_P(DeclContextTest, removeDeclOfClassTemplateSpecialization) {
   Decl *TU = getTuDecl(
       R"(
       namespace NS {