[ASTMatchers] proof-of-concept: allow matching within a restricted scope.

[sammccall]

Summary

Tools may want to match only within e.g. the main file.
We can run the matcher only over those "top-level decls" but if it "escapes"
e.g. using the hasAncestor() matcher, then all bets are off.
In fact, any use of hasAncestor() or hasParent() will cause us to pay O(|TU|) in
performance to build the parent map, which is unacceptably bad for clangd.

The approach taken here is to restrict the parent map to only include edges
reachable from the top-level decls.
We create a "bounds" object wrapping the decls, and store the parent map cache
in it. This object must be plumbed around manually.

Not asking for review and probably won't in this form, too much plumbing.
Sadly, the better option is probably to make this a mutable attribute of
ASTContext.

include/clang/AST/ASTContext.h

 public:
   IdentifierTable &Idents;
   SelectorTable &Selectors;
   Builtin::Context &BuiltinInfo;
   mutable DeclarationNameTable DeclarationNames;
   IntrusiveRefCntPtr<ExternalASTSource> ExternalSource;
   ASTMutationListener *Listener = nullptr;
 
-  /// Contains parents of a node.
-  using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>;
-
-  /// Maps from a node to its parents. This is used for nodes that have
-  /// pointer identity only, which are more common and we can save space by
-  /// only storing a unique pointer to them.
-  using ParentMapPointers =
-      llvm::DenseMap<const void *,
-                     llvm::PointerUnion4<const Decl *, const Stmt *,
-                                         ast_type_traits::DynTypedNode *,
-                                         ParentVector *>>;
-
-  /// Parent map for nodes without pointer identity. We store a full
-  /// DynTypedNode for all keys.
-  using ParentMapOtherNodes =
-      llvm::DenseMap<ast_type_traits::DynTypedNode,
-                     llvm::PointerUnion4<const Decl *, const Stmt *,
-                                         ast_type_traits::DynTypedNode *,
-                                         ParentVector *>>;
-
   /// Container for either a single DynTypedNode or for an ArrayRef to
   /// DynTypedNode. For use with ParentMap.
   class DynTypedNodeList {
     using DynTypedNode = ast_type_traits::DynTypedNode;
 
     llvm::AlignedCharArrayUnion<ast_type_traits::DynTypedNode,
                                 ArrayRef<DynTypedNode>> Storage;
     bool IsSingleNode;
public:
     bool empty() const { return begin() == end(); }
 
     const DynTypedNode &operator[](size_t N) const {
       assert(N < size() && "Out of bounds!");
       return *(begin() + N);
     }
   };
 
+  class Bounds;
+  std::unique_ptr<Bounds> FullBounds;
+  Bounds& fullBounds() { return *FullBounds;}
+  std::unique_ptr<Bounds, void (*)(Bounds *)>
+  bounds(const std::vector<Decl *> &TopLevelDecls);
+  std::vector<Decl*> topLevelDecls(const Bounds&);
   /// Returns the parents of the given node.
   ///
   /// Note that this will lazily compute the parents of all nodes
   /// and store them for later retrieval. Thus, the first call is O(n)
   /// in the number of AST nodes.
   ///
   /// Caveats and FIXMEs:
   /// Calculating the parent map over all AST nodes will need to load the
   /// full AST. This can be undesirable in the case where the full AST is
   /// expensive to create (for example, when using precompiled header
   /// preambles). Thus, there are good opportunities for optimization here.
   /// One idea is to walk the given node downwards, looking for references
   /// to declaration contexts - once a declaration context is found, compute
   /// the parent map for the declaration context; if that can satisfy the
   /// request, loading the whole AST can be avoided. Note that this is made
   /// more complex by statements in templates having multiple parents - those
   /// problems can be solved by building closure over the templated parts of
   /// the AST, which also avoids touching large parts of the AST.
   /// Additionally, we will want to add an interface to already give a hint
   /// where to search for the parents, for example when looking at a statement
   /// inside a certain function.
   ///
   /// 'NodeT' can be one of Decl, Stmt, Type, TypeLoc,
   /// NestedNameSpecifier or NestedNameSpecifierLoc.
-  template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node) {
-    return getParents(ast_type_traits::DynTypedNode::create(Node));
+  template <typename NodeT>
+  DynTypedNodeList getParents(const NodeT &Node, Bounds &B) {
+    return getParents(ast_type_traits::DynTypedNode::create(Node), B);
   }
-
-  DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node);
+  DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &, Bounds &);
 
   const clang::PrintingPolicy &getPrintingPolicy() const {
     return PrintingPolicy;
   }
 
   void setPrintingPolicy(const clang::PrintingPolicy &Policy) {
     PrintingPolicy = Policy;
   }
using DeallocationFunctionsAndArguments =
       llvm::SmallVector<std::pair<void (*)(void *), void *>, 16>;
   DeallocationFunctionsAndArguments Deallocations;
 
   // FIXME: This currently contains the set of StoredDeclMaps used
   // by DeclContext objects.  This probably should not be in ASTContext,
   // but we include it here so that ASTContext can quickly deallocate them.
   llvm::PointerIntPair<StoredDeclsMap *, 1> LastSDM;
 
-  std::unique_ptr<ParentMapPointers> PointerParents;
-  std::unique_ptr<ParentMapOtherNodes> OtherParents;
-
   std::unique_ptr<VTableContextBase> VTContext;
 
   void ReleaseDeclContextMaps();
-  void ReleaseParentMapEntries();
 
 public:
   enum PragmaSectionFlag : unsigned {
     PSF_None = 0,
     PSF_Read = 0x1,
     PSF_Write = 0x2,
     PSF_Execute = 0x4,
     PSF_Implicit = 0x8,

include/clang/AST/RecursiveASTVisitor.h

public:
 
   /// Invoked after visiting a statement or expression via data recursion.
   /// This is not invoked if the previously invoked \c dataTraverseStmtPre
   /// returned false.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
   bool dataTraverseStmtPost(Stmt *S) { return true; }
 
+  /// Recursively visit an AST, calling TraverseDecl() on its top-level decls.
+  bool TraverseAST(ASTContext &Ctx, ASTContext::Bounds &B) {
+    for (Decl *D : Ctx.topLevelDecls(B))
+      if (!TraverseDecl(D))
+        return false;
+    return true;
+  }
+
   /// Recursively visit a type, by dispatching to
   /// Traverse*Type() based on the argument's getTypeClass() property.
   ///
   /// \returns false if the visitation was terminated early, true
   /// otherwise (including when the argument is a Null type).
   bool TraverseType(QualType T);
 
   /// Recursively visit a type with location, by dispatching to

include/clang/ASTMatchers/ASTMatchFinder.h

 /// Not intended to be subclassed.
 class MatchFinder {
 public:
   /// Contains all information for a given match.
   ///
   /// Every time a match is found, the MatchFinder will invoke the registered
   /// MatchCallback with a MatchResult containing information about the match.
   struct MatchResult {
-    MatchResult(const BoundNodes &Nodes, clang::ASTContext *Context);
+    MatchResult(const BoundNodes &Nodes, clang::ASTContext *Context,
+                clang::ASTContext::Bounds *Bounds);
 
     /// Contains the nodes bound on the current match.
     ///
     /// This allows user code to easily extract matched AST nodes.
     const BoundNodes Nodes;
 
     /// Utilities for interpreting the matched AST structures.
     /// @{
     clang::ASTContext * const Context;
+    clang::ASTContext::Bounds *Bounds;
     clang::SourceManager * const SourceManager;
     /// @}
   };
 
   /// Called when the Match registered for it was successfully found
   /// in the AST.
   class MatchCallback {
   public:
public:
   std::unique_ptr<clang::ASTConsumer> newASTConsumer();
 
   /// Calls the registered callbacks on all matches on the given \p Node.
   ///
   /// Note that there can be multiple matches on a single node, for
   /// example when using decl(forEachDescendant(stmt())).
   ///
   /// @{
-  template <typename T> void match(const T &Node, ASTContext &Context) {
-    match(clang::ast_type_traits::DynTypedNode::create(Node), Context);
+  template <typename T>
+  void match(const T &Node, ASTContext &Context, ASTContext::Bounds &Bounds) {
+    match(clang::ast_type_traits::DynTypedNode::create(Node), Context, Bounds);
   }
   void match(const clang::ast_type_traits::DynTypedNode &Node,
-             ASTContext &Context);
+             ASTContext &Context, ASTContext::Bounds &);
   /// @}
 
   /// Finds all matches in the given AST.
-  void matchAST(ASTContext &Context);
+  void matchAST(ASTContext &, ASTContext::Bounds &);
 
   /// Registers a callback to notify the end of parsing.
   ///
   /// The provided closure is called after parsing is done, before the AST is
   /// traversed. Useful for benchmarking.
   /// Each call to FindAll(...) will call the closure once.
   void registerTestCallbackAfterParsing(ParsingDoneTestCallback *ParsingDone);
 

 ///
 /// If you want to find all matches on the sub-tree rooted at \c Node (rather
 /// than only the matches on \c Node itself), surround the \c Matcher with a
 /// \c findAll().
 ///
 /// \see selectFirst
 /// @{
 template <typename MatcherT, typename NodeT>
-SmallVector<BoundNodes, 1>
-match(MatcherT Matcher, const NodeT &Node, ASTContext &Context);
+SmallVector<BoundNodes, 1> match(MatcherT Matcher, const NodeT &Node,
+                                 ASTContext &Context, ASTContext::Bounds &);
 
 template <typename MatcherT>
-SmallVector<BoundNodes, 1>
-match(MatcherT Matcher, const ast_type_traits::DynTypedNode &Node,
-      ASTContext &Context);
+SmallVector<BoundNodes, 1> match(MatcherT Matcher,
+                                 const ast_type_traits::DynTypedNode &Node,
+                                 ASTContext &Context, ASTContext::Bounds &);
 /// @}
 
 /// Returns the results of matching \p Matcher on the translation unit of
 /// \p Context and collects the \c BoundNodes of all callback invocations.
 template <typename MatcherT>
-SmallVector<BoundNodes, 1> match(MatcherT Matcher, ASTContext &Context);
+SmallVector<BoundNodes, 1> match(MatcherT Matcher, ASTContext &Context,
+                                 ASTContext::Bounds &);
 
 /// Returns the first result of type \c NodeT bound to \p BoundTo.
 ///
 /// Returns \c NULL if there is no match, or if the matching node cannot be
 /// casted to \c NodeT.
 ///
 /// This is useful in combanation with \c match():
 /// \code
public:
   }
   SmallVector<BoundNodes, 1> Nodes;
 };
 }
 
 template <typename MatcherT>
 SmallVector<BoundNodes, 1>
 match(MatcherT Matcher, const ast_type_traits::DynTypedNode &Node,
-      ASTContext &Context) {
+      ASTContext &Context, ASTContext::Bounds &Bounds) {
   internal::CollectMatchesCallback Callback;
   MatchFinder Finder;
   Finder.addMatcher(Matcher, &Callback);
-  Finder.match(Node, Context);
+  Finder.match(Node, Context, Bounds);
   return std::move(Callback.Nodes);
 }
 
 template <typename MatcherT, typename NodeT>
-SmallVector<BoundNodes, 1>
-match(MatcherT Matcher, const NodeT &Node, ASTContext &Context) {
-  return match(Matcher, ast_type_traits::DynTypedNode::create(Node), Context);
+SmallVector<BoundNodes, 1> match(MatcherT Matcher, const NodeT &Node,
+                                 ASTContext &Context,
+                                 ASTContext::Bounds &Bounds) {
+  return match(Matcher, ast_type_traits::DynTypedNode::create(Node), Context,
+               Bounds);
 }
 
 template <typename MatcherT>
-SmallVector<BoundNodes, 1>
-match(MatcherT Matcher, ASTContext &Context) {
+SmallVector<BoundNodes, 1> match(MatcherT Matcher, ASTContext &Context,
+                                 ASTContext::Bounds &Bounds) {
   internal::CollectMatchesCallback Callback;
   MatchFinder Finder;
   Finder.addMatcher(Matcher, &Callback);
-  Finder.matchAST(Context);
+  Finder.matchAST(Context, Bounds);
   return std::move(Callback.Nodes);
 }
 
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif

include/clang/ASTMatchers/ASTMatchers.h

 ///   return *this;
 /// }
 /// \endcode
 /// returnStmt(forFunction(hasName("operator=")))
 ///   matches 'return *this'
 ///   but does match 'return > 0'
 AST_MATCHER_P(Stmt, forFunction, internal::Matcher<FunctionDecl>,
               InnerMatcher) {
-  const auto &Parents = Finder->getASTContext().getParents(Node);
+  const auto &Parents =
+      Finder->getASTContext().getParents(Node, Finder->getASTBounds());
 
   llvm::SmallVector<ast_type_traits::DynTypedNode, 8> Stack(Parents.begin(),
                                                             Parents.end());
   while(!Stack.empty()) {
     const auto &CurNode = Stack.back();
     Stack.pop_back();
     if(const auto *FuncDeclNode = CurNode.get<FunctionDecl>()) {
       if(InnerMatcher.matches(*FuncDeclNode, Finder, Builder)) {
         return true;
       }
     } else if(const auto *LambdaExprNode = CurNode.get<LambdaExpr>()) {
       if(InnerMatcher.matches(*LambdaExprNode->getCallOperator(),
                               Finder, Builder)) {
         return true;
       }
     } else {
-      for(const auto &Parent: Finder->getASTContext().getParents(CurNode))
+      for (const auto &Parent :
+           Finder->getASTContext().getParents(CurNode, Finder->getASTBounds()))
         Stack.push_back(Parent);
     }
   }
   return false;
 }
 
 /// Matches a declaration that has external formal linkage.
 ///

include/clang/ASTMatchers/ASTMatchersInternal.h

static_assert(std::is_base_of<Decl, T>::value ||
                       std::is_base_of<Stmt, T>::value ||
                       std::is_base_of<TypeLoc, T>::value,
                   "type not allowed for recursive matching");
     return matchesAncestorOf(ast_type_traits::DynTypedNode::create(Node),
                              Matcher, Builder, MatchMode);
   }
 
   virtual ASTContext &getASTContext() const = 0;
+  virtual ASTContext::Bounds &getASTBounds() const = 0;
 
 protected:
   virtual bool matchesChildOf(const ast_type_traits::DynTypedNode &Node,
                               const DynTypedMatcher &Matcher,
                               BoundNodesTreeBuilder *Builder,
                               TraversalKind Traverse,
                               BindKind Bind) = 0;
 

include/clang/Analysis/Analyses/ExprMutationAnalyzer.h

 namespace clang {
 
 class FunctionParmMutationAnalyzer;
 
 /// Analyzes whether any mutative operations are applied to an expression within
 /// a given statement.
 class ExprMutationAnalyzer {
 public:
-  ExprMutationAnalyzer(const Stmt &Stm, ASTContext &Context)
-      : Stm(Stm), Context(Context) {}
+  ExprMutationAnalyzer(const Stmt &Stm, ASTContext &Context,
+                       ASTContext::Bounds &Bounds)
+      : Stm(Stm), Context(Context), Bounds(Bounds) {}
 
   bool isMutated(const Expr *Exp) { return findMutation(Exp) != nullptr; }
   bool isMutated(const Decl *Dec) { return findMutation(Dec) != nullptr; }
   const Stmt *findMutation(const Expr *Exp);
   const Stmt *findMutation(const Decl *Dec);
 
   bool isPointeeMutated(const Expr *Exp) {
     return findPointeeMutation(Exp) != nullptr;
private:
   const Stmt *findArrayElementMutation(const Expr *Exp);
   const Stmt *findCastMutation(const Expr *Exp);
   const Stmt *findRangeLoopMutation(const Expr *Exp);
   const Stmt *findReferenceMutation(const Expr *Exp);
   const Stmt *findFunctionArgMutation(const Expr *Exp);
 
   const Stmt &Stm;
   ASTContext &Context;
+  ASTContext::Bounds &Bounds;
   llvm::DenseMap<const FunctionDecl *,
                  std::unique_ptr<FunctionParmMutationAnalyzer>>
       FuncParmAnalyzer;
   ResultMap Results;
   ResultMap PointeeResults;
 };
 
 // A convenient wrapper around ExprMutationAnalyzer for analyzing function
 // params.
 class FunctionParmMutationAnalyzer {
 public:
-  FunctionParmMutationAnalyzer(const FunctionDecl &Func, ASTContext &Context);
+  FunctionParmMutationAnalyzer(const FunctionDecl &Func, ASTContext &Context,
+                               ASTContext::Bounds &Bounds);
 
   bool isMutated(const ParmVarDecl *Parm) {
     return findMutation(Parm) != nullptr;
   }
   const Stmt *findMutation(const ParmVarDecl *Parm);
 
 private:
   ExprMutationAnalyzer BodyAnalyzer;
   llvm::DenseMap<const ParmVarDecl *, const Stmt *> Results;
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_ANALYSES_EXPRMUTATIONANALYZER_H

lib/AST/ASTContext.cpp

static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI,
   case LangOptions::ASMM_On:
     return true;
   case LangOptions::ASMM_Off:
     return false;
   }
   llvm_unreachable("getAddressSpaceMapMangling() doesn't cover anything.");
 }
 
+class ASTContext::Bounds {
+  /// Contains parents of a node.
+  using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>;
+
+  /// Maps from a node to its parents. This is used for nodes that have
+  /// pointer identity only, which are more common and we can save space by
+  /// only storing a unique pointer to them.
+  using ParentMapPointers = llvm::DenseMap<
+      const void *,
+      llvm::PointerUnion4<const Decl *, const Stmt *,
+                          ast_type_traits::DynTypedNode *, ParentVector *>>;
+
+  /// Parent map for nodes without pointer identity. We store a full
+  /// DynTypedNode for all keys.
+  using ParentMapOtherNodes = llvm::DenseMap<
+      ast_type_traits::DynTypedNode,
+      llvm::PointerUnion4<const Decl *, const Stmt *,
+                          ast_type_traits::DynTypedNode *, ParentVector *>>;
+
+  ASTContext &Ctx;
+  std::vector<Decl *> TopLevelDecls;
+
+  // Parent map cache.
+  class ParentMapASTVisitor;
+  std::unique_ptr<ParentMapPointers> PointerParents;
+  std::unique_ptr<ParentMapOtherNodes> OtherParents;
+
+  static ast_type_traits::DynTypedNode
+  getSingleDynTypedNodeFromParentMap(ParentMapPointers::mapped_type U) {
+    if (const auto *D = U.dyn_cast<const Decl *>())
+      return ast_type_traits::DynTypedNode::create(*D);
+    if (const auto *S = U.dyn_cast<const Stmt *>())
+      return ast_type_traits::DynTypedNode::create(*S);
+    return *U.get<ast_type_traits::DynTypedNode *>();
+  }
+  template <typename NodeTy, typename MapTy>
+  static ASTContext::DynTypedNodeList getDynNodeFromMap(const NodeTy &Node,
+                                                        const MapTy &Map) {
+    auto I = Map.find(Node);
+    if (I == Map.end()) {
+      return llvm::ArrayRef<ast_type_traits::DynTypedNode>();
+    }
+    if (const auto *V = I->second.template dyn_cast<ParentVector *>()) {
+      return llvm::makeArrayRef(*V);
+    }
+    return getSingleDynTypedNodeFromParentMap(I->second);
+  }
+
+public:
+  Bounds(ASTContext &Ctx, llvm::ArrayRef<Decl *> TopLevelDecls)
+      : Ctx(Ctx), TopLevelDecls(TopLevelDecls) {}
+  ~Bounds() {
+    if (!PointerParents)
+      return;
+    for (const auto &Entry : *PointerParents) {
+      if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
+        delete Entry.second.get<ast_type_traits::DynTypedNode *>();
+      } else if (Entry.second.is<ParentVector *>()) {
+        delete Entry.second.get<ParentVector *>();
+      }
+    }
+    for (const auto &Entry : *OtherParents) {
+      if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
+        delete Entry.second.get<ast_type_traits::DynTypedNode *>();
+      } else if (Entry.second.is<ParentVector *>()) {
+        delete Entry.second.get<ParentVector *>();
+      }
+    }
+  }
+
+  DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node);
+  std::vector<Decl *> topLevelDecls() const { return TopLevelDecls; }
+  ASTContext &getASTContext() { return Ctx; }
+};
+
+ASTContext::DynTypedNodeList
+ASTContext::getParents(const ast_type_traits::DynTypedNode &N, Bounds &B) {
+  assert(&B.getASTContext() == this);
+  return B.getParents(N);
+}
+
+std::unique_ptr<ASTContext::Bounds, void (*)(ASTContext::Bounds *)>
+ASTContext::bounds(const std::vector<Decl *> &TopLevelDecls) {
+  return {new Bounds(*this, TopLevelDecls), [](Bounds *P) { delete P; }};
+}
+
+std::vector<Decl*> ASTContext::topLevelDecls(const Bounds& B) {
+  return B.topLevelDecls();
+}
+
 ASTContext::ASTContext(LangOptions &LOpts, SourceManager &SM,
                        IdentifierTable &idents, SelectorTable &sels,
                        Builtin::Context &builtins)
     : FunctionProtoTypes(this_()), TemplateSpecializationTypes(this_()),
       DependentTemplateSpecializationTypes(this_()),
       SubstTemplateTemplateParmPacks(this_()), SourceMgr(SM), LangOpts(LOpts),
       SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),
       XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,
                                         LangOpts.XRayNeverInstrumentFiles,
                                         LangOpts.XRayAttrListFiles, SM)),
       PrintingPolicy(LOpts), Idents(idents), Selectors(sels),
       BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),
       CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
       CompCategories(this_()), LastSDM(nullptr, 0) {
   TUDecl = TranslationUnitDecl::Create(*this);
+  FullBounds = llvm::make_unique<Bounds>(*this, std::vector<Decl *>{TUDecl});
 }
 
 ASTContext::~ASTContext() {
-  ReleaseParentMapEntries();
-
   // Release the DenseMaps associated with DeclContext objects.
   // FIXME: Is this the ideal solution?
   ReleaseDeclContextMaps();
 
   // Call all of the deallocation functions on all of their targets.
   for (auto &Pair : Deallocations)
     (Pair.first)(Pair.second);
 
ASTContext::~ASTContext() {
   for (std::pair<const MaterializeTemporaryExpr *, APValue *> &MTVPair :
        MaterializedTemporaryValues)
     MTVPair.second->~APValue();
 
   for (const auto &Value : ModuleInitializers)
     Value.second->~PerModuleInitializers();
 }
 
-void ASTContext::ReleaseParentMapEntries() {
-  if (!PointerParents) return;
-  for (const auto &Entry : *PointerParents) {
-    if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
-      delete Entry.second.get<ast_type_traits::DynTypedNode *>();
-    } else if (Entry.second.is<ParentVector *>()) {
-      delete Entry.second.get<ParentVector *>();
-    }
-  }
-  for (const auto &Entry : *OtherParents) {
-    if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
-      delete Entry.second.get<ast_type_traits::DynTypedNode *>();
-    } else if (Entry.second.is<ParentVector *>()) {
-      delete Entry.second.get<ParentVector *>();
-    }
-  }
-}
-
 void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) {
   Deallocations.push_back({Callback, Data});
 }
 
 void
 ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) {
   ExternalSource = std::move(Source);
 }
bool ASTContext::AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const {
   CharUnits sizeChars = getTypeSizeInChars(AtomicTy);
   uint64_t Size = sizeChars.getQuantity();
   CharUnits alignChars = getTypeAlignInChars(AtomicTy);
   unsigned Align = alignChars.getQuantity();
   unsigned MaxInlineWidthInBits = getTargetInfo().getMaxAtomicInlineWidth();
   return (Size != Align || toBits(sizeChars) > MaxInlineWidthInBits);
 }
 
-static ast_type_traits::DynTypedNode getSingleDynTypedNodeFromParentMap(
-    ASTContext::ParentMapPointers::mapped_type U) {
-  if (const auto *D = U.dyn_cast<const Decl *>())
-    return ast_type_traits::DynTypedNode::create(*D);
-  if (const auto *S = U.dyn_cast<const Stmt *>())
-    return ast_type_traits::DynTypedNode::create(*S);
-  return *U.get<ast_type_traits::DynTypedNode *>();
-}
-
-namespace {
-
 /// Template specializations to abstract away from pointers and TypeLocs.
 /// @{
 template <typename T>
-ast_type_traits::DynTypedNode createDynTypedNode(const T &Node) {
+static ast_type_traits::DynTypedNode createDynTypedNode(const T &Node) {
   return ast_type_traits::DynTypedNode::create(*Node);
 }
 template <>
 ast_type_traits::DynTypedNode createDynTypedNode(const TypeLoc &Node) {
   return ast_type_traits::DynTypedNode::create(Node);
 }
 template <>
 ast_type_traits::DynTypedNode
 createDynTypedNode(const NestedNameSpecifierLoc &Node) {
   return ast_type_traits::DynTypedNode::create(Node);
 }
 /// @}
 
-  /// A \c RecursiveASTVisitor that builds a map from nodes to their
-  /// parents as defined by the \c RecursiveASTVisitor.
-  ///
-  /// Note that the relationship described here is purely in terms of AST
-  /// traversal - there are other relationships (for example declaration context)
-  /// in the AST that are better modeled by special matchers.
-  ///
-  /// FIXME: Currently only builds up the map using \c Stmt and \c Decl nodes.
-  class ParentMapASTVisitor : public RecursiveASTVisitor<ParentMapASTVisitor> {
-  public:
-    /// Builds and returns the translation unit's parent map.
-    ///
-    ///  The caller takes ownership of the returned \c ParentMap.
-    static std::pair<ASTContext::ParentMapPointers *,
-                     ASTContext::ParentMapOtherNodes *>
-    buildMap(TranslationUnitDecl &TU) {
-      ParentMapASTVisitor Visitor(new ASTContext::ParentMapPointers,
-                                  new ASTContext::ParentMapOtherNodes);
-      Visitor.TraverseDecl(&TU);
-      return std::make_pair(Visitor.Parents, Visitor.OtherParents);
-    }
+class ASTContext::Bounds::ParentMapASTVisitor
+    : public RecursiveASTVisitor<ParentMapASTVisitor> {
+  static std::pair<ParentMapPointers *,
+                   ParentMapOtherNodes *>
+  buildMap(const std::vector<Decl *> &TopLevelDecls) {
+    ParentMapASTVisitor Visitor(new ParentMapPointers,
+                                new ParentMapOtherNodes);
+    for (Decl *D : TopLevelDecls)
+      Visitor.TraverseDecl(D);
 
-  private:
-    friend class RecursiveASTVisitor<ParentMapASTVisitor>;
 
-    using VisitorBase = RecursiveASTVisitor<ParentMapASTVisitor>;
 
-    ParentMapASTVisitor(ASTContext::ParentMapPointers *Parents,
-                        ASTContext::ParentMapOtherNodes *OtherParents)
-        : Parents(Parents), OtherParents(OtherParents) {}
+  ParentMapASTVisitor(ParentMapPointers *Parents,
+                      ParentMapOtherNodes *OtherParents)
 
-    bool shouldVisitTemplateInstantiations() const {
-      return true;
-    }
+  bool shouldVisitTemplateInstantiations() const { return true; }
 
-    bool shouldVisitImplicitCode() const {
-      return true;
-    }
+  bool shouldVisitImplicitCode() const { return true; }
 
-    template <typename T, typename MapNodeTy, typename BaseTraverseFn,
-              typename MapTy>
-    bool TraverseNode(T Node, MapNodeTy MapNode,
-                      BaseTraverseFn BaseTraverse, MapTy *Parents) {
-      if (!Node)
-        return true;
-      if (ParentStack.size() > 0) {
-        // FIXME: Currently we add the same parent multiple times, but only
-        // when no memoization data is available for the type.
-        // For example when we visit all subexpressions of template
-        // instantiations; this is suboptimal, but benign: the only way to
-        // visit those is with hasAncestor / hasParent, and those do not create
-        // new matches.
-        // The plan is to enable DynTypedNode to be storable in a map or hash
-        // map. The main problem there is to implement hash functions /
-        // comparison operators for all types that DynTypedNode supports that
-        // do not have pointer identity.
-        auto &NodeOrVector = (*Parents)[MapNode];
-        if (NodeOrVector.isNull()) {
-          if (const auto *D = ParentStack.back().get<Decl>())
-            NodeOrVector = D;
-          else if (const auto *S = ParentStack.back().get<Stmt>())
-            NodeOrVector = S;
-          else
-            NodeOrVector =
-                new ast_type_traits::DynTypedNode(ParentStack.back());
-        } else {
-          if (!NodeOrVector.template is<ASTContext::ParentVector *>()) {
-            auto *Vector = new ASTContext::ParentVector(
-                1, getSingleDynTypedNodeFromParentMap(NodeOrVector));
-            delete NodeOrVector
-                    .template dyn_cast<ast_type_traits::DynTypedNode *>();
-            NodeOrVector = Vector;
-          }
+  bool TraverseNode(T Node, MapNodeTy MapNode, BaseTraverseFn BaseTraverse,
+                    MapTy *Parents) {
+          NodeOrVector = new ast_type_traits::DynTypedNode(ParentStack.back());
+        if (!NodeOrVector.template is<ParentVector *>()) {
+          auto *Vector = new ParentVector(
 
-          auto *Vector =
-              NodeOrVector.template get<ASTContext::ParentVector *>();
-          // Skip duplicates for types that have memoization data.
-          // We must check that the type has memoization data before calling
-          // std::find() because DynTypedNode::operator== can't compare all
-          // types.
-          bool Found = ParentStack.back().getMemoizationData() &&
-                       std::find(Vector->begin(), Vector->end(),
-                                 ParentStack.back()) != Vector->end();
-          if (!Found)
-            Vector->push_back(ParentStack.back());
-        }
-      }
-      ParentStack.push_back(createDynTypedNode(Node));
-      bool Result = BaseTraverse();
-      ParentStack.pop_back();
-      return Result;
-    }
+        auto *Vector = NodeOrVector.template get<ParentVector *>();
 
-    bool TraverseDecl(Decl *DeclNode) {
-      return TraverseNode(DeclNode, DeclNode,
-                          [&] { return VisitorBase::TraverseDecl(DeclNode); },
-                          Parents);
-    }
+    return TraverseNode(
+        DeclNode, DeclNode, [&] { return VisitorBase::TraverseDecl(DeclNode); },
 
-    bool TraverseStmt(Stmt *StmtNode) {
-      return TraverseNode(StmtNode, StmtNode,
-                          [&] { return VisitorBase::TraverseStmt(StmtNode); },
-                          Parents);
-    }
+    return TraverseNode(
+        StmtNode, StmtNode, [&] { return VisitorBase::TraverseStmt(StmtNode); },
 
-    bool TraverseTypeLoc(TypeLoc TypeLocNode) {
-      return TraverseNode(
-          TypeLocNode, ast_type_traits::DynTypedNode::create(TypeLocNode),
-          [&] { return VisitorBase::TraverseTypeLoc(TypeLocNode); },
-          OtherParents);
-    }
 
-    bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLocNode) {
-      return TraverseNode(
-          NNSLocNode, ast_type_traits::DynTypedNode::create(NNSLocNode),
-          [&] {
-            return VisitorBase::TraverseNestedNameSpecifierLoc(NNSLocNode);
-          },
-          OtherParents);
-    }
+        [&] { return VisitorBase::TraverseNestedNameSpecifierLoc(NNSLocNode); },
 
-    ASTContext::ParentMapPointers *Parents;
-    ASTContext::ParentMapOtherNodes *OtherParents;
-    llvm::SmallVector<ast_type_traits::DynTypedNode, 16> ParentStack;
-  };
+  ParentMapPointers *Parents;
+  ParentMapOtherNodes *OtherParents;
 
-} // namespace
-
-template <typename NodeTy, typename MapTy>
-static ASTContext::DynTypedNodeList getDynNodeFromMap(const NodeTy &Node,
-                                                      const MapTy &Map) {
-  auto I = Map.find(Node);
-  if (I == Map.end()) {
-    return llvm::ArrayRef<ast_type_traits::DynTypedNode>();
-  }
-  if (const auto *V =
-          I->second.template dyn_cast<ASTContext::ParentVector *>()) {
-    return llvm::makeArrayRef(*V);
-  }
-  return getSingleDynTypedNodeFromParentMap(I->second);
-}
-
 ASTContext::DynTypedNodeList
-ASTContext::getParents(const ast_type_traits::DynTypedNode &Node) {
+ASTContext::Bounds::getParents(const ast_type_traits::DynTypedNode &Node) {
   if (!PointerParents) {
     // We always need to run over the whole translation unit, as
     // hasAncestor can escape any subtree.
-    auto Maps = ParentMapASTVisitor::buildMap(*getTranslationUnitDecl());
+    auto Maps = ParentMapASTVisitor::buildMap(TopLevelDecls);
     PointerParents.reset(Maps.first);
     OtherParents.reset(Maps.second);
   }
   if (Node.getNodeKind().hasPointerIdentity())
     return getDynNodeFromMap(Node.getMemoizationData(), *PointerParents);
   return getDynNodeFromMap(Node, *OtherParents);
 }
 

lib/ASTMatchers/ASTMatchFinder.cpp

void onEndOfTranslationUnit() {
     TimeBucketRegion Timer;
     for (MatchCallback *MC : Matchers->AllCallbacks) {
       if (EnableCheckProfiling)
         Timer.setBucket(&TimeByBucket[MC->getID()]);
       MC->onEndOfTranslationUnit();
     }
   }
 
-  void set_active_ast_context(ASTContext *NewActiveASTContext) {
+  void set_active_ast_context(ASTContext *NewActiveASTContext,
+                              ASTContext::Bounds *Bounds) {
     ActiveASTContext = NewActiveASTContext;
+    ActiveBounds = Bounds;
   }
 
   // The following Visit*() and Traverse*() functions "override"
   // methods in RecursiveASTVisitor.
 
   bool VisitTypedefNameDecl(TypedefNameDecl *DeclNode) {
     // When we see 'typedef A B', we add name 'B' to the set of names
     // A's canonical type maps to.  This is necessary for implementing
public:
   }
 
   template <typename T> void match(const T &Node) {
     matchDispatch(&Node);
   }
 
   // Implements ASTMatchFinder::getASTContext.
   ASTContext &getASTContext() const override { return *ActiveASTContext; }
+  ASTContext::Bounds &getASTBounds() const override { return *ActiveBounds; }
 
   bool shouldVisitTemplateInstantiations() const { return true; }
   bool shouldVisitImplicitCode() const { return true; }
 
 private:
   class TimeBucketRegion {
   public:
     TimeBucketRegion() : Bucket(nullptr) {}
private:
   void matchWithoutFilter(const T &Node, const MC &Matchers) {
     const bool EnableCheckProfiling = Options.CheckProfiling.hasValue();
     TimeBucketRegion Timer;
     for (const auto &MP : Matchers) {
       if (EnableCheckProfiling)
         Timer.setBucket(&TimeByBucket[MP.second->getID()]);
       BoundNodesTreeBuilder Builder;
       if (MP.first.matches(Node, this, &Builder)) {
-        MatchVisitor Visitor(ActiveASTContext, MP.second);
+        MatchVisitor Visitor(ActiveASTContext, ActiveBounds,MP.second);
         Builder.visitMatches(&Visitor);
       }
     }
   }
 
   void matchWithFilter(const ast_type_traits::DynTypedNode &DynNode) {
     auto Kind = DynNode.getNodeKind();
     auto it = MatcherFiltersMap.find(Kind);
     const auto &Filter =
         it != MatcherFiltersMap.end() ? it->second : getFilterForKind(Kind);
 
     if (Filter.empty())
       return;
 
     const bool EnableCheckProfiling = Options.CheckProfiling.hasValue();
     TimeBucketRegion Timer;
     auto &Matchers = this->Matchers->DeclOrStmt;
     for (unsigned short I : Filter) {
       auto &MP = Matchers[I];
       if (EnableCheckProfiling)
         Timer.setBucket(&TimeByBucket[MP.second->getID()]);
       BoundNodesTreeBuilder Builder;
       if (MP.first.matchesNoKindCheck(DynNode, this, &Builder)) {
-        MatchVisitor Visitor(ActiveASTContext, MP.second);
+        MatchVisitor Visitor(ActiveASTContext, ActiveBounds, MP.second);
         Builder.visitMatches(&Visitor);
       }
     }
   }
 
   const std::vector<unsigned short> &
   getFilterForKind(ast_type_traits::ASTNodeKind Kind) {
     auto &Filter = MatcherFiltersMap[Kind];
private:
   // parent.
   //
   // Once there are multiple parents, the breadth first search order does not
   // allow simple memoization on the ancestors. Thus, we only memoize as long
   // as there is a single parent.
   bool memoizedMatchesAncestorOfRecursively(
       const ast_type_traits::DynTypedNode &Node, const DynTypedMatcher &Matcher,
       BoundNodesTreeBuilder *Builder, AncestorMatchMode MatchMode) {
-    if (Node.get<TranslationUnitDecl>() ==
-        ActiveASTContext->getTranslationUnitDecl())
+    if (Node.get<TranslationUnitDecl>() != nullptr)
       return false;
 
     // For AST-nodes that don't have an identity, we can't memoize.
     if (!Builder->isComparable())
       return matchesAncestorOfRecursively(Node, Matcher, Builder, MatchMode);
 
     MatchKey Key;
     Key.MatcherID = Matcher.getID();
bool memoizedMatchesAncestorOfRecursively(
     *Builder = CachedResult.Nodes;
     return CachedResult.ResultOfMatch;
   }
 
   bool matchesAncestorOfRecursively(const ast_type_traits::DynTypedNode &Node,
                                     const DynTypedMatcher &Matcher,
                                     BoundNodesTreeBuilder *Builder,
                                     AncestorMatchMode MatchMode) {
-    const auto &Parents = ActiveASTContext->getParents(Node);
+    const auto &Parents = ActiveASTContext->getParents(Node, *ActiveBounds);
     assert(!Parents.empty() && "Found node that is not in the parent map.");
     if (Parents.size() == 1) {
       // Only one parent - do recursive memoization.
       const ast_type_traits::DynTypedNode Parent = Parents[0];
       BoundNodesTreeBuilder BuilderCopy = *Builder;
       if (Matcher.matches(Parent, this, &BuilderCopy)) {
         *Builder = std::move(BuilderCopy);
         return true;
if (Parents.size() == 1) {
       while (!Queue.empty()) {
         BoundNodesTreeBuilder BuilderCopy = *Builder;
         if (Matcher.matches(Queue.front(), this, &BuilderCopy)) {
           *Builder = std::move(BuilderCopy);
           return true;
         }
         if (MatchMode != ASTMatchFinder::AMM_ParentOnly) {
           for (const auto &Parent :
-               ActiveASTContext->getParents(Queue.front())) {
+               ActiveASTContext->getParents(Queue.front(), *ActiveBounds)) {
             // Make sure we do not visit the same node twice.
             // Otherwise, we'll visit the common ancestors as often as there
             // are splits on the way down.
             if (Visited.insert(Parent.getMemoizationData()).second)
               Queue.push_back(Parent);
           }
         }
         Queue.pop_front();
       }
     }
     return false;
   }
 
   // Implements a BoundNodesTree::Visitor that calls a MatchCallback with
   // the aggregated bound nodes for each match.
   class MatchVisitor : public BoundNodesTreeBuilder::Visitor {
   public:
-    MatchVisitor(ASTContext* Context,
-                 MatchFinder::MatchCallback* Callback)
-      : Context(Context),
-        Callback(Callback) {}
+    MatchVisitor(ASTContext *Context, ASTContext::Bounds *Bounds,
+                 MatchFinder::MatchCallback *Callback)
+        : Context(Context), Bounds(Bounds), Callback(Callback) {}
 
     void visitMatch(const BoundNodes& BoundNodesView) override {
-      Callback->run(MatchFinder::MatchResult(BoundNodesView, Context));
+      Callback->run(
+          MatchFinder::MatchResult(BoundNodesView, Context, Bounds));
     }
 
   private:
     ASTContext* Context;
+    ASTContext::Bounds* Bounds;
     MatchFinder::MatchCallback* Callback;
   };
 
   // Returns true if 'TypeNode' has an alias that matches the given matcher.
   bool typeHasMatchingAlias(const Type *TypeNode,
                             const Matcher<NamedDecl> &Matcher,
                             BoundNodesTreeBuilder *Builder) {
     const Type *const CanonicalType =
private:
   /// We precalculate a list of matchers that pass the toplevel restrict check.
   /// This also allows us to skip the restrict check at matching time. See
   /// use \c matchesNoKindCheck() above.
   llvm::DenseMap<ast_type_traits::ASTNodeKind, std::vector<unsigned short>>
       MatcherFiltersMap;
 
   const MatchFinder::MatchFinderOptions &Options;
   ASTContext *ActiveASTContext;
+  ASTContext::Bounds *ActiveBounds;
 
   // Maps a canonical type to its TypedefDecls.
   llvm::DenseMap<const Type*, std::set<const TypedefNameDecl*> > TypeAliases;
 
   // Maps (matcher, node) -> the match result for memoization.
   typedef std::map<MatchKey, MemoizedMatchResult> MemoizationMap;
   MemoizationMap ResultCache;
 };
MatchASTConsumer(MatchFinder *Finder,
                    MatchFinder::ParsingDoneTestCallback *ParsingDone)
       : Finder(Finder), ParsingDone(ParsingDone) {}
 
 private:
   void HandleTranslationUnit(ASTContext &Context) override {
     if (ParsingDone != nullptr) {
       ParsingDone->run();
     }
-    Finder->matchAST(Context);
+    Finder->matchAST(Context, Context.fullBounds());
   }
 
   MatchFinder *Finder;
   MatchFinder::ParsingDoneTestCallback *ParsingDone;
 };
 
 } // end namespace
 } // end namespace internal
 
 MatchFinder::MatchResult::MatchResult(const BoundNodes &Nodes,
-                                      ASTContext *Context)
-  : Nodes(Nodes), Context(Context),
+                                      ASTContext *Context,
+                                      ASTContext::Bounds *Bounds)
+    : Nodes(Nodes), Context(Context), Bounds(Bounds),
       SourceManager(&Context->getSourceManager()) {}
 
 MatchFinder::MatchCallback::~MatchCallback() {}
 MatchFinder::ParsingDoneTestCallback::~ParsingDoneTestCallback() {}
 
 MatchFinder::MatchFinder(MatchFinderOptions Options)
     : Options(std::move(Options)), ParsingDone(nullptr) {}
 
 MatchFinder::~MatchFinder() {}
bool MatchFinder::addDynamicMatcher(const internal::DynTypedMatcher &NodeMatch,
   return false;
 }
 
 std::unique_ptr<ASTConsumer> MatchFinder::newASTConsumer() {
   return llvm::make_unique<internal::MatchASTConsumer>(this, ParsingDone);
 }
 
 void MatchFinder::match(const clang::ast_type_traits::DynTypedNode &Node,
-                        ASTContext &Context) {
+                        ASTContext &Context, ASTContext::Bounds &Bounds) {
   internal::MatchASTVisitor Visitor(&Matchers, Options);
-  Visitor.set_active_ast_context(&Context);
+  Visitor.set_active_ast_context(&Context, &Bounds);
   Visitor.match(Node);
 }
 
-void MatchFinder::matchAST(ASTContext &Context) {
+void MatchFinder::matchAST(ASTContext &Context, ASTContext::Bounds &Bounds) {
   internal::MatchASTVisitor Visitor(&Matchers, Options);
-  Visitor.set_active_ast_context(&Context);
+  Visitor.set_active_ast_context(&Context, &Bounds);
   Visitor.onStartOfTranslationUnit();
-  Visitor.TraverseDecl(Context.getTranslationUnitDecl());
+  for (Decl* D : Context.topLevelDecls(Bounds))
+    Visitor.TraverseDecl(D);
   Visitor.onEndOfTranslationUnit();
 }
 
 void MatchFinder::registerTestCallbackAfterParsing(
     MatchFinder::ParsingDoneTestCallback *NewParsingDone) {
   ParsingDone = NewParsingDone;
 }
 
 StringRef MatchFinder::MatchCallback::getID() const { return "<unknown>"; }
 
 } // end namespace ast_matchers
 } // end namespace clang

lib/Analysis/ExprMutationAnalyzer.cpp

const Stmt *ExprMutationAnalyzer::findMutationMemoized(
 
   return MemoizedResults[Exp] = nullptr;
 }
 
 const Stmt *ExprMutationAnalyzer::tryEachDeclRef(const Decl *Dec,
                                                  MutationFinder Finder) {
   const auto Refs =
       match(findAll(declRefExpr(to(equalsNode(Dec))).bind(NodeID<Expr>::value)),
-            Stm, Context);
+            Stm, Context, Bounds);
   for (const auto &RefNodes : Refs) {
     const auto *E = RefNodes.getNodeAs<Expr>(NodeID<Expr>::value);
     if ((this->*Finder)(E))
       return E;
   }
   return nullptr;
 }
 
return selectFirst<Expr>(
                                   cxxTypeidExpr(
                                       unless(isPotentiallyEvaluated())),
                                   // The controlling expression of
                                   // `GenericSelectionExpr` is unevaluated.
                                   genericSelectionExpr(hasControllingExpr(
                                       hasDescendant(equalsNode(Exp)))),
                                   cxxNoexceptExpr())))))
                          .bind(NodeID<Expr>::value)),
-                 Stm, Context)) != nullptr;
+                 Stm, Context, Bounds)) != nullptr;
 }
 
 const Stmt *
 ExprMutationAnalyzer::findExprMutation(ArrayRef<BoundNodes> Matches) {
   return tryEachMatch<Expr>(Matches, this, &ExprMutationAnalyzer::findMutation);
 }
 
 const Stmt *
const Stmt *ExprMutationAnalyzer::findDirectMutation(const Expr *Exp) {
   const auto AsNonConstRefReturn = returnStmt(hasReturnValue(equalsNode(Exp)));
 
   const auto Matches =
       match(findAll(stmt(anyOf(AsAssignmentLhs, AsIncDecOperand, AsNonConstThis,
                                AsAmpersandOperand, AsPointerFromArrayDecay,
                                AsOperatorArrowThis, AsNonConstRefArg,
                                AsLambdaRefCaptureInit, AsNonConstRefReturn))
                         .bind("stmt")),
-            Stm, Context);
+            Stm, Context, Bounds);
   return selectFirst<Stmt>("stmt", Matches);
 }
 
 const Stmt *ExprMutationAnalyzer::findMemberMutation(const Expr *Exp) {
   // Check whether any member of 'Exp' is mutated.
   const auto MemberExprs =
       match(findAll(expr(anyOf(memberExpr(hasObjectExpression(equalsNode(Exp))),
                                cxxDependentScopeMemberExpr(
                                    hasObjectExpression(equalsNode(Exp)))))
                         .bind(NodeID<Expr>::value)),
-            Stm, Context);
+            Stm, Context, Bounds);
   return findExprMutation(MemberExprs);
 }
 
 const Stmt *ExprMutationAnalyzer::findArrayElementMutation(const Expr *Exp) {
   // Check whether any element of an array is mutated.
   const auto SubscriptExprs = match(
       findAll(arraySubscriptExpr(hasBase(ignoringImpCasts(equalsNode(Exp))))
                   .bind(NodeID<Expr>::value)),
-      Stm, Context);
+      Stm, Context, Bounds);
   return findExprMutation(SubscriptExprs);
 }
 
 const Stmt *ExprMutationAnalyzer::findCastMutation(const Expr *Exp) {
   // If 'Exp' is casted to any non-const reference type, check the castExpr.
   const auto Casts =
       match(findAll(castExpr(hasSourceExpression(equalsNode(Exp)),
                              anyOf(explicitCastExpr(hasDestinationType(
                                        nonConstReferenceType())),
                                    implicitCastExpr(hasImplicitDestinationType(
                                        nonConstReferenceType()))))
                         .bind(NodeID<Expr>::value)),
-            Stm, Context);
+            Stm, Context, Bounds);
   if (const Stmt *S = findExprMutation(Casts))
     return S;
   // Treat std::{move,forward} as cast.
   const auto Calls =
       match(findAll(callExpr(callee(namedDecl(
                                  hasAnyName("::std::move", "::std::forward"))),
                              hasArgument(0, equalsNode(Exp)))
                         .bind("expr")),
-            Stm, Context);
+            Stm, Context, Bounds);
   return findExprMutation(Calls);
 }
 
 const Stmt *ExprMutationAnalyzer::findRangeLoopMutation(const Expr *Exp) {
   // If range for looping over 'Exp' with a non-const reference loop variable,
   // check all declRefExpr of the loop variable.
   const auto LoopVars =
       match(findAll(cxxForRangeStmt(
                 hasLoopVariable(varDecl(hasType(nonConstReferenceType()))
                                     .bind(NodeID<Decl>::value)),
                 hasRangeInit(equalsNode(Exp)))),
-            Stm, Context);
+            Stm, Context, Bounds);
   return findDeclMutation(LoopVars);
 }
 
 const Stmt *ExprMutationAnalyzer::findReferenceMutation(const Expr *Exp) {
   // Follow non-const reference returned by `operator*()` of move-only classes.
   // These are typically smart pointers with unique ownership so we treat
   // mutation of pointee as mutation of the smart pointer itself.
   const auto Ref =
       match(findAll(cxxOperatorCallExpr(
                         hasOverloadedOperatorName("*"),
                         callee(cxxMethodDecl(ofClass(isMoveOnly()),
                                              returns(nonConstReferenceType()))),
                         argumentCountIs(1), hasArgument(0, equalsNode(Exp)))
                         .bind(NodeID<Expr>::value)),
-            Stm, Context);
+            Stm, Context, Bounds);
   if (const Stmt *S = findExprMutation(Ref))
     return S;
 
   // If 'Exp' is bound to a non-const reference, check all declRefExpr to that.
   const auto Refs = match(
       stmt(forEachDescendant(
           varDecl(
               hasType(nonConstReferenceType()),
               hasInitializer(anyOf(equalsNode(Exp),
                                    conditionalOperator(anyOf(
                                        hasTrueExpression(equalsNode(Exp)),
                                        hasFalseExpression(equalsNode(Exp)))))),
               hasParent(declStmt().bind("stmt")),
               // Don't follow the reference in range statement, we've handled
               // that separately.
               unless(hasParent(declStmt(hasParent(
                   cxxForRangeStmt(hasRangeStmt(equalsBoundNode("stmt"))))))))
               .bind(NodeID<Decl>::value))),
-      Stm, Context);
+      Stm, Context, Bounds);
   return findDeclMutation(Refs);
 }
 
 const Stmt *ExprMutationAnalyzer::findFunctionArgMutation(const Expr *Exp) {
   const auto NonConstRefParam = forEachArgumentWithParam(
       equalsNode(Exp),
       parmVarDecl(hasType(nonConstReferenceType())).bind("parm"));
   const auto IsInstantiated = hasDeclaration(isInstantiated());
   const auto FuncDecl = hasDeclaration(functionDecl().bind("func"));
   const auto Matches = match(
       findAll(expr(anyOf(callExpr(NonConstRefParam, IsInstantiated, FuncDecl,
                                   unless(callee(namedDecl(hasAnyName(
                                       "::std::move", "::std::forward"))))),
                          cxxConstructExpr(NonConstRefParam, IsInstantiated,
                                           FuncDecl)))
                   .bind(NodeID<Expr>::value)),
-      Stm, Context);
+      Stm, Context, Bounds);
   for (const auto &Nodes : Matches) {
     const auto *Exp = Nodes.getNodeAs<Expr>(NodeID<Expr>::value);
     const auto *Func = Nodes.getNodeAs<FunctionDecl>("func");
     if (!Func->getBody() || !Func->getPrimaryTemplate())
       return Exp;
 
     const auto *Parm = Nodes.getNodeAs<ParmVarDecl>("parm");
     const ArrayRef<ParmVarDecl *> AllParams =
         Func->getPrimaryTemplate()->getTemplatedDecl()->parameters();
     QualType ParmType =
         AllParams[std::min<size_t>(Parm->getFunctionScopeIndex(),
                                    AllParams.size() - 1)]
             ->getType();
     if (const auto *T = ParmType->getAs<PackExpansionType>())
       ParmType = T->getPattern();
 
     // If param type is forwarding reference, follow into the function
     // definition and see whether the param is mutated inside.
     if (const auto *RefType = ParmType->getAs<RValueReferenceType>()) {
       if (!RefType->getPointeeType().getQualifiers() &&
           RefType->getPointeeType()->getAs<TemplateTypeParmType>()) {
         std::unique_ptr<FunctionParmMutationAnalyzer> &Analyzer =
             FuncParmAnalyzer[Func];
         if (!Analyzer)
-          Analyzer.reset(new FunctionParmMutationAnalyzer(*Func, Context));
+          Analyzer.reset(
+              new FunctionParmMutationAnalyzer(*Func, Context, Bounds));
         if (Analyzer->findMutation(Parm))
           return Exp;
         continue;
       }
     }
     // Not forwarding reference.
     return Exp;
   }
   return nullptr;
 }
 
 FunctionParmMutationAnalyzer::FunctionParmMutationAnalyzer(
-    const FunctionDecl &Func, ASTContext &Context)
-    : BodyAnalyzer(*Func.getBody(), Context) {
+    const FunctionDecl &Func, ASTContext &Context, ASTContext::Bounds &Bounds)
+    : BodyAnalyzer(*Func.getBody(), Context, Bounds) {
   if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(&Func)) {
     // CXXCtorInitializer might also mutate Param but they're not part of
     // function body, check them eagerly here since they're typically trivial.
     for (const CXXCtorInitializer *Init : Ctor->inits()) {
-      ExprMutationAnalyzer InitAnalyzer(*Init->getInit(), Context);
+      ExprMutationAnalyzer InitAnalyzer(*Init->getInit(), Context, Bounds);
       for (const ParmVarDecl *Parm : Ctor->parameters()) {
         if (Results.find(Parm) != Results.end())
           continue;
         if (const Stmt *S = InitAnalyzer.findMutation(Parm))
           Results[Parm] = S;
       }
     }
   }

lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp

void GCDAntipatternChecker::checkASTCodeBody(const Decl *D,
                                              AnalysisManager &AM,
                                              BugReporter &BR) const {
   if (isTest(D))
     return;
 
   AnalysisDeclContext *ADC = AM.getAnalysisDeclContext(D);
 
   auto SemaphoreMatcherM = findGCDAntiPatternWithSemaphore();
-  auto Matches = match(SemaphoreMatcherM, *D->getBody(), AM.getASTContext());
+  auto Matches = match(SemaphoreMatcherM, *D->getBody(), AM.getASTContext(),
+                       AM.getASTContext().fullBounds());
   for (BoundNodes Match : Matches)
     emitDiagnostics(Match, "semaphore", BR, ADC, this);
 
   auto GroupMatcherM = findGCDAntiPatternWithGroup();
-  Matches = match(GroupMatcherM, *D->getBody(), AM.getASTContext());
+  Matches = match(GroupMatcherM, *D->getBody(), AM.getASTContext(),
+                  AM.getASTContext().fullBounds());
   for (BoundNodes Match : Matches)
     emitDiagnostics(Match, "group", BR, ADC, this);
 }
 
 }
 
 void ento::registerGCDAntipattern(CheckerManager &Mgr) {
   Mgr.registerChecker<GCDAntipatternChecker>();
 }

lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp

auto FinalM = stmt(anyOf(ConversionThroughAssignmentM,
                            ConversionThroughExplicitBooleanCastM,
                            ConversionThroughExplicitNumberCastM,
                            ConversionThroughInitializerM)).bind("conv");
 
   MatchFinder F;
   Callback CB(this, BR, AM.getAnalysisDeclContext(D));
 
   F.addMatcher(stmt(forEachDescendant(FinalM)), &CB);
-  F.match(*D->getBody(), AM.getASTContext());
+  F.match(*D->getBody(), AM.getASTContext(), AM.getASTContext().fullBounds());
 }
 
 void ento::registerNumberObjectConversionChecker(CheckerManager &Mgr) {
   NumberObjectConversionChecker *Chk =
       Mgr.registerChecker<NumberObjectConversionChecker>();
   Chk->Pedantic =
       Mgr.getAnalyzerOptions().getCheckerBooleanOption("Pedantic", false, Chk);
 }

lib/StaticAnalyzer/Checkers/ObjCAutoreleaseWriteChecker.cpp

auto HasParamAndWritesInMarkedFuncM = allOf(
       hasAnyParameter(DoublePointerParamM),
       forEachDescendant(BlockPassedToMarkedFuncM));
 
   auto MatcherM = decl(anyOf(
       objcMethodDecl(HasParamAndWritesInMarkedFuncM).bind(IsMethodBind),
       functionDecl(HasParamAndWritesInMarkedFuncM),
       blockDecl(HasParamAndWritesInMarkedFuncM)));
 
-  auto Matches = match(MatcherM, *D, AM.getASTContext());
+  auto Matches =
+      match(MatcherM, *D, AM.getASTContext(), AM.getASTContext().fullBounds());
   for (BoundNodes Match : Matches)
     emitDiagnostics(Match, D, BR, AM, this);
 }
 
 void ento::registerAutoreleaseWriteChecker(CheckerManager &Mgr) {
   Mgr.registerChecker<ObjCAutoreleaseWriteChecker>();
 }

lib/StaticAnalyzer/Checkers/RunLoopAutoreleaseLeakChecker.cpp

checkTempObjectsInSamePool(const Decl *D, AnalysisManager &AM, BugReporter &BR,
 
   StatementMatcher RunLoopInAutorelease =
       autoreleasePoolStmt(
         hasDescendant(RunLoopRunM),
         hasDescendant(OtherMessageSentM)).bind(AutoreleasePoolBind);
 
   DeclarationMatcher GroupM = decl(hasDescendant(RunLoopInAutorelease));
 
-  auto Matches = match(GroupM, *D, AM.getASTContext());
+  auto Matches =
+      match(GroupM, *D, AM.getASTContext(), AM.getASTContext().fullBounds());
   for (BoundNodes Match : Matches)
     emitDiagnostics(Match, D, BR, AM, Chkr);
 }
 
 static void
 checkTempObjectsInNoPool(const Decl *D, AnalysisManager &AM, BugReporter &BR,
                          const RunLoopAutoreleaseLeakChecker *Chkr) {
 
   auto NoPoolM = unless(hasAncestor(autoreleasePoolStmt()));
 
   StatementMatcher RunLoopRunM = getRunLoopRunM(NoPoolM);
   StatementMatcher OtherMessageSentM = getOtherMessageSentM(NoPoolM);
 
   DeclarationMatcher GroupM = functionDecl(
     isMain(),
     hasDescendant(RunLoopRunM),
     hasDescendant(OtherMessageSentM)
   );
 
-  auto Matches = match(GroupM, *D, AM.getASTContext());
+  auto Matches =
+      match(GroupM, *D, AM.getASTContext(), AM.getASTContext().fullBounds());
 
   for (BoundNodes Match : Matches)
     emitDiagnostics(Match, D, BR, AM, Chkr);
 
 }
 
 void RunLoopAutoreleaseLeakChecker::checkASTCodeBody(const Decl *D,
                         AnalysisManager &AM,
                         BugReporter &BR) const {
   checkTempObjectsInSamePool(D, AM, BR, this);
   checkTempObjectsInNoPool(D, AM, BR, this);
 }
 
 void ento::registerRunLoopAutoreleaseLeakChecker(CheckerManager &mgr) {
   mgr.registerChecker<RunLoopAutoreleaseLeakChecker>();
 }

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

bool potentiallyWritesIntoIvar(const Decl *Parent,
     const char * IvarBind = "Ivar";
     if (!Parent || !Parent->hasBody())
       return false;
     StatementMatcher WriteIntoIvarM = binaryOperator(
         hasOperatorName("="),
         hasLHS(ignoringParenImpCasts(
             objcIvarRefExpr(hasDeclaration(equalsNode(Ivar))).bind(IvarBind))));
     StatementMatcher ParentM = stmt(hasDescendant(WriteIntoIvarM));
-    auto Matches = match(ParentM, *Parent->getBody(), Parent->getASTContext());
+    auto Matches = match(ParentM, *Parent->getBody(), Parent->getASTContext(),
+                         Parent->getASTContext().fullBounds());
     for (BoundNodes &Match : Matches) {
       auto IvarRef = Match.getNodeAs<ObjCIvarRefExpr>(IvarBind);
       if (IvarRef->isFreeIvar())
         return true;
 
       const Expr *Base = IvarRef->getBase();
       if (const auto *ICE = dyn_cast<ImplicitCastExpr>(Base))
         Base = ICE->getSubExpr();

lib/StaticAnalyzer/Core/LoopUnrolling.cpp

while (!N->pred_empty()) {
     }
     // Check the usage of the pass-by-ref function calls and adress-of operator
     // on VD and reference initialized by VD.
     ASTContext &ASTCtx =
         N->getLocationContext()->getAnalysisDeclContext()->getASTContext();
     auto Match =
         match(stmt(anyOf(callByRef(equalsNode(VD)), getAddrTo(equalsNode(VD)),
                          assignedToRef(equalsNode(VD)))),
-              *S, ASTCtx);
+              *S, ASTCtx, ASTCtx.fullBounds());
     if (!Match.empty())
       return true;
 
     N = N->getFirstPred();
   }
   llvm_unreachable("Reached root without finding the declaration of VD");
 }
 
 bool shouldCompletelyUnroll(const Stmt *LoopStmt, ASTContext &ASTCtx,
                             ExplodedNode *Pred, unsigned &maxStep) {
 
   if (!isLoopStmt(LoopStmt))
     return false;
 
   // TODO: Match the cases where the bound is not a concrete literal but an
   // integer with known value
-  auto Matches = match(forLoopMatcher(), *LoopStmt, ASTCtx);
+  auto Matches =
+      match(forLoopMatcher(), *LoopStmt, ASTCtx, ASTCtx.fullBounds());
   if (Matches.empty())
     return false;
 
   auto CounterVar = Matches[0].getNodeAs<VarDecl>("initVarName");
   llvm::APInt BoundNum =
       Matches[0].getNodeAs<IntegerLiteral>("boundNum")->getValue();
   llvm::APInt InitNum =
       Matches[0].getNodeAs<IntegerLiteral>("initNum")->getValue();

lib/StaticAnalyzer/Core/LoopWidening.cpp

const MemRegion *Regions[] = {MRMgr.getStackLocalsRegion(STC),
                                 MRMgr.getGlobalsRegion()};
   RegionAndSymbolInvalidationTraits ITraits;
   for (auto *Region : Regions) {
     ITraits.setTrait(Region,
                      RegionAndSymbolInvalidationTraits::TK_EntireMemSpace);
   }
 
   // References should not be invalidated.
-  auto Matches = match(findAll(stmt(hasDescendant(varDecl(hasType(referenceType())).bind(MatchRef)))),
-                       *LCtx->getDecl()->getBody(), ASTCtx);
+  auto Matches =
+      match(findAll(stmt(hasDescendant(
+                varDecl(hasType(referenceType())).bind(MatchRef)))),
+            *LCtx->getDecl()->getBody(), ASTCtx, ASTCtx.fullBounds());
   for (BoundNodes Match : Matches) {
     const VarDecl *VD = Match.getNodeAs<VarDecl>(MatchRef);
     assert(VD);
     const VarRegion *VarMem = MRMgr.getVarRegion(VD, LCtx);
     ITraits.setTrait(VarMem,
                      RegionAndSymbolInvalidationTraits::TK_PreserveContents);
   }
 

lib/StaticAnalyzer/Core/RegionStore.cpp

if (const auto *RD = TO->getValueType()->getAsCXXRecordDecl()) {
       if (RD->isLambda() && RD->getLambdaCallOperator()->getBody()) {
         using namespace ast_matchers;
 
         const char *DeclBind = "DeclBind";
         StatementMatcher RefToStatic = stmt(hasDescendant(declRefExpr(
               to(varDecl(hasStaticStorageDuration()).bind(DeclBind)))));
         auto Matches =
             match(RefToStatic, *RD->getLambdaCallOperator()->getBody(),
-                  RD->getASTContext());
+                  RD->getASTContext(), RD->getASTContext().fullBounds());
 
         for (BoundNodes &Match : Matches) {
           auto *VD = Match.getNodeAs<VarDecl>(DeclBind);
           const VarRegion *ToInvalidate =
               RM.getRegionManager().getVarRegion(VD, LCtx);
           AddToWorkList(ToInvalidate);
         }
       }

lib/StaticAnalyzer/Core/RetainSummaryManager.cpp

RetainSummaryManager::getPersistentSummary(const RetainSummary &OldSumm) {
   new (Summ) RetainSummary(OldSumm);
   return Summ;
 }
 
 static bool isSubclass(const Decl *D,
                        StringRef ClassName) {
   using namespace ast_matchers;
   DeclarationMatcher SubclassM = cxxRecordDecl(isSameOrDerivedFrom(ClassName));
-  return !(match(SubclassM, *D, D->getASTContext()).empty());
+  return !(
+      match(SubclassM, *D, D->getASTContext(), D->getASTContext().fullBounds())
+          .empty());
 }
 
 static bool isOSObjectSubclass(const Decl *D) {
   return isSubclass(D, "OSObject");
 }
 
 static bool isOSObjectDynamicCast(StringRef S) {
   return S == "safeMetaCast";

lib/Tooling/ASTDiff/ASTDiff.cpp

 
 std::string SyntaxTree::Impl::getRelativeName(const NamedDecl *ND) const {
   return getRelativeName(ND, ND->getDeclContext());
 }
 
 static const DeclContext *getEnclosingDeclContext(ASTContext &AST,
                                                   const Stmt *S) {
   while (S) {
-    const auto &Parents = AST.getParents(*S);
+    const auto &Parents = AST.getParents(*S, AST.fullBounds());
     if (Parents.empty())
       return nullptr;
     const auto &P = Parents[0];
     if (const auto *D = P.get<Decl>())
       return D->getDeclContext();
     S = P.get<Stmt>();
   }
   return nullptr;

lib/Tooling/Refactoring/Rename/USRLocFinder.cpp

 }
 
 // Find all locations identified by the given USRs for rename.
 //
 // This class will traverse the AST and find every AST node whose USR is in the
 // given USRs' set.
 class RenameLocFinder : public RecursiveASTVisitor<RenameLocFinder> {
 public:
-  RenameLocFinder(llvm::ArrayRef<std::string> USRs, ASTContext &Context)
-      : USRSet(USRs.begin(), USRs.end()), Context(Context) {}
+  RenameLocFinder(llvm::ArrayRef<std::string> USRs, ASTContext &Context,
+                  ASTContext::Bounds &Bounds)
+      : USRSet(USRs.begin(), USRs.end()), Context(Context), Bounds(Bounds) {}
 
   // A structure records all information of a symbol reference being renamed.
   // We try to add as few prefix qualifiers as possible.
   struct RenameInfo {
     // The begin location of a symbol being renamed.
     SourceLocation Begin;
     // The end location of a symbol being renamed.
     SourceLocation End;
if (const auto *TargetDecl =
                            /*IgnorePrefixQualifers=*/false};
         RenameInfos.push_back(Info);
       }
     }
     return true;
   }
 
   bool VisitTypeLoc(TypeLoc Loc) {
-    auto Parents = Context.getParents(Loc);
+    auto Parents = Context.getParents(Loc, Bounds);
     TypeLoc ParentTypeLoc;
     if (!Parents.empty()) {
       // Handle cases of nested name specificier locations.
       //
       // The VisitNestedNameSpecifierLoc interface is not impelmented in
       // RecursiveASTVisitor, we have to handle it explicitly.
       if (const auto *NSL = Parents[0].get<NestedNameSpecifierLoc>()) {
         VisitNestedNameSpecifierLocations(*NSL);
if (const auto *ED =
             llvm::dyn_cast_or_null<EnumDecl>(Loc.getType()->getAsTagDecl()))
       return ED;
     return nullptr;
   }
 
   // Get the closest ancester which is a declaration of a given AST node.
   template <typename ASTNodeType>
   const Decl *getClosestAncestorDecl(const ASTNodeType &Node) {
-    auto Parents = Context.getParents(Node);
+    auto Parents = Context.getParents(Node, Bounds);
     // FIXME: figure out how to handle it when there are multiple parents.
     if (Parents.size() != 1)
       return nullptr;
     if (ast_type_traits::ASTNodeKind::getFromNodeKind<Decl>().isBaseOf(
             Parents[0].getNodeKind()))
       return Parents[0].template get<Decl>();
     return getClosestAncestorDecl(Parents[0]);
   }
 
   // Get the parent typeLoc of a given typeLoc. If there is no such parent,
   // return nullptr.
   const TypeLoc *getParentTypeLoc(TypeLoc Loc) const {
-    auto Parents = Context.getParents(Loc);
+    auto Parents = Context.getParents(Loc, Bounds);
     // FIXME: figure out how to handle it when there are multiple parents.
     if (Parents.size() != 1)
       return nullptr;
     return Parents[0].get<TypeLoc>();
   }
 
   // Check whether the USR of a given Decl is in the USRSet.
   bool isInUSRSet(const Decl *Decl) const {
     auto USR = getUSRForDecl(Decl);
     if (USR.empty())
       return false;
     return llvm::is_contained(USRSet, USR);
   }
 
   const std::set<std::string> USRSet;
   ASTContext &Context;
+  ASTContext::Bounds &Bounds;
   std::vector<RenameInfo> RenameInfos;
   // Record all interested using declarations which contains the using-shadow
   // declarations of the symbol declarations being renamed.
   std::vector<const UsingDecl *> UsingDecls;
 };
 
 } // namespace
 
 SymbolOccurrences getOccurrencesOfUSRs(ArrayRef<std::string> USRs,
                                        StringRef PrevName, Decl *Decl) {
   USRLocFindingASTVisitor Visitor(USRs, PrevName, Decl->getASTContext());
   Visitor.TraverseDecl(Decl);
   return Visitor.takeOccurrences();
 }
 
 std::vector<tooling::AtomicChange>
 createRenameAtomicChanges(llvm::ArrayRef<std::string> USRs,
                           llvm::StringRef NewName, Decl *TranslationUnitDecl) {
-  RenameLocFinder Finder(USRs, TranslationUnitDecl->getASTContext());
-  Finder.TraverseDecl(TranslationUnitDecl);
+  ASTContext &Ctx = TranslationUnitDecl->getASTContext();
+  RenameLocFinder Finder(USRs, Ctx, Ctx.fullBounds());
+  Finder.TraverseAST(Ctx, Ctx.fullBounds());
 
   const SourceManager &SM =
       TranslationUnitDecl->getASTContext().getSourceManager();
 
   std::vector<tooling::AtomicChange> AtomicChanges;
   auto Replace = [&](SourceLocation Start, SourceLocation End,
                      llvm::StringRef Text) {
     tooling::AtomicChange ReplaceChange = tooling::AtomicChange(SM, Start);

lib/Tooling/RefactoringCallbacks.cpp

explicit RefactoringASTConsumer(ASTMatchRefactorer &Refactoring)
       : Refactoring(Refactoring) {}
 
   void HandleTranslationUnit(ASTContext &Context) override {
     // The ASTMatchRefactorer is re-used between translation units.
     // Clear the matchers so that each Replacement is only emitted once.
     for (const auto &Callback : Refactoring.Callbacks) {
       Callback->getReplacements().clear();
     }
-    Refactoring.MatchFinder.matchAST(Context);
+    Refactoring.MatchFinder.matchAST(Context, Context.fullBounds());
     for (const auto &Callback : Refactoring.Callbacks) {
       for (const auto &Replacement : Callback->getReplacements()) {
         llvm::Error Err =
             Refactoring.FileToReplaces[Replacement.getFilePath()].add(
                 Replacement);
         if (Err) {
           llvm::errs() << "Skipping replacement " << Replacement.toString()
                        << " due to this error:\n"

unittests/AST/ASTImporterTest.cpp

std::unique_ptr<ASTUnit> FromAST = tooling::buildASTFromCodeWithArgs(
                                  ToCode, ToArgs, OutputFileName);
 
     ASTContext &FromCtx = FromAST->getASTContext(),
                &ToCtx = ToAST->getASTContext();
 
     ASTImporter Importer(ToCtx, ToAST->getFileManager(), FromCtx,
                          FromAST->getFileManager(), false);
 
-    auto FoundNodes = match(SearchMatcher, FromCtx);
+    auto FoundNodes = match(SearchMatcher, FromCtx, FromCtx.fullBounds());
     if (FoundNodes.size() != 1)
       return testing::AssertionFailure()
              << "Multiple potential nodes were found!";
 
     auto ToImport = selectFirst<NodeType>(DeclToImportID, FoundNodes);
     if (!ToImport)
       return testing::AssertionFailure() << "Node type mismatch!";
 
for (const ImportAction &Action : ImportActions) {
       // Create a new importer if needed.
       std::unique_ptr<ASTImporter> &ImporterRef = Importers[{From, To}];
       if (!ImporterRef)
         ImporterRef.reset(new ASTImporter(
             To->getASTContext(), To->getFileManager(), From->getASTContext(),
             From->getFileManager(), false));
 
       // Find the declaration and import it.
-      auto FoundDecl = match(Action.ImportPredicate.bind(DeclToImportID),
-                             From->getASTContext());
+      auto FoundDecl =
+          match(Action.ImportPredicate.bind(DeclToImportID),
+                From->getASTContext(), From->getASTContext().fullBounds());
       EXPECT_TRUE(FoundDecl.size() == 1);
       const Decl *ToImport = selectFirst<Decl>(DeclToImportID, FoundDecl);
       auto Imported = importNode(From, To, *ImporterRef, ToImport);
       EXPECT_TRUE(Imported);
     }
 
     // Find the declaration and import it.
-    auto FoundDecl = match(FinalSelectPredicate.bind(DeclToVerifyID),
-                           AllASTs[FileForFinalCheck]->getASTContext());
+    auto &Ctx = AllASTs[FileForFinalCheck]->getASTContext();
+    auto FoundDecl =
+        match(FinalSelectPredicate.bind(DeclToVerifyID), Ctx, Ctx.fullBounds());
     EXPECT_TRUE(FoundDecl.size() == 1);
     const Decl *ToVerify = selectFirst<Decl>(DeclToVerifyID, FoundDecl);
     MatchVerifier<Decl> Verifier;
     EXPECT_TRUE(
         Verifier.match(ToVerify, BindableMatcher<Decl>(VerificationMatcher)));
   }
 };
 

unittests/AST/DeclMatcher.h

void run(const MatchFinder::MatchResult &Result) override {
     }
   }
 public:
   // Returns the first/last matched node under the tree rooted in `D`.
   template <typename MatcherType>
   NodeType *match(const Decl *D, const MatcherType &AMatcher) {
     MatchFinder Finder;
     Finder.addMatcher(AMatcher.bind(""), this);
-    Finder.matchAST(D->getASTContext());
+    Finder.matchAST(D->getASTContext(), D->getASTContext().fullBounds());
     assert(Node);
     return Node;
   }
 };
 template <typename NodeType>
 using LastDeclMatcher = DeclMatcher<NodeType, DeclMatcherKind::Last>;
 template <typename NodeType>
 using FirstDeclMatcher = DeclMatcher<NodeType, DeclMatcherKind::First>;
DeclCounterWithPredicate()
       : Predicate([](const NodeType *) { return true; }) {}
   DeclCounterWithPredicate(UnaryPredicate P) : Predicate(P) {}
   // Returns the number of matched nodes which satisfy the predicate under the
   // tree rooted in `D`.
   template <typename MatcherType>
   unsigned match(const Decl *D, const MatcherType &AMatcher) {
     MatchFinder Finder;
     Finder.addMatcher(AMatcher.bind(""), this);
-    Finder.matchAST(D->getASTContext());
+    Finder.matchAST(D->getASTContext(), D->getASTContext().fullBounds());
     return Count;
   }
 };
 
 template <typename NodeType>
 using DeclCounter = DeclCounterWithPredicate<NodeType>;
 
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif

unittests/AST/MatchVerifier.h

 /// verifier for the matched node.
 template <typename NodeType> template <typename MatcherType>
 testing::AssertionResult MatchVerifier<NodeType>::match(
     const Decl *D, const MatcherType &AMatcher) {
   MatchFinder Finder;
   Finder.addMatcher(AMatcher.bind(""), this);
 
   setFailure("Could not find match");
-  Finder.match(*D, D->getASTContext());
+  Finder.match(*D, D->getASTContext(), D->getASTContext().fullBounds());
 
   if (!Verified)
     return testing::AssertionFailure() << VerifyResult;
   return testing::AssertionSuccess();
 }
 
 template <typename NodeType>
 void MatchVerifier<NodeType>::run(const MatchFinder::MatchResult &Result) {

unittests/ASTMatchers/ASTMatchersInternalTest.cpp

TEST(MatchFinder, InterceptsStartOfTranslationUnit) {
   std::unique_ptr<FrontendActionFactory> Factory(
       newFrontendActionFactory(&Finder));
   ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), "int x;"));
   EXPECT_TRUE(VerifyCallback.Called);
 
   VerifyCallback.Called = false;
   std::unique_ptr<ASTUnit> AST(tooling::buildASTFromCode("int x;"));
   ASSERT_TRUE(AST.get());
-  Finder.matchAST(AST->getASTContext());
+  Finder.matchAST(AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_TRUE(VerifyCallback.Called);
 }
 
 class VerifyEndOfTranslationUnit : public MatchFinder::MatchCallback {
 public:
   VerifyEndOfTranslationUnit() : Called(false) {}
   void run(const MatchFinder::MatchResult &Result) override {
     EXPECT_FALSE(Called);
TEST(MatchFinder, InterceptsEndOfTranslationUnit) {
   std::unique_ptr<FrontendActionFactory> Factory(
       newFrontendActionFactory(&Finder));
   ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), "int x;"));
   EXPECT_TRUE(VerifyCallback.Called);
 
   VerifyCallback.Called = false;
   std::unique_ptr<ASTUnit> AST(tooling::buildASTFromCode("int x;"));
   ASSERT_TRUE(AST.get());
-  Finder.matchAST(AST->getASTContext());
+  Finder.matchAST(AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_TRUE(VerifyCallback.Called);
 }
 
 TEST(Matcher, matchOverEntireASTContext) {
   std::unique_ptr<ASTUnit> AST =
       clang::tooling::buildASTFromCode("struct { int *foo; };");
   ASSERT_TRUE(AST.get());
   auto PT = selectFirst<PointerType>(
-      "x", match(pointerType().bind("x"), AST->getASTContext()));
+      "x", match(pointerType().bind("x"), AST->getASTContext(),
+                 AST->getASTContext().fullBounds()));
   EXPECT_NE(nullptr, PT);
 }
 
 TEST(IsInlineMatcher, IsInline) {
   EXPECT_TRUE(matches("void g(); inline void f();",
                       functionDecl(isInline(), hasName("f"))));
   EXPECT_TRUE(matches("namespace n { inline namespace m {} }",
                       namespaceDecl(isInline(), hasName("m"))));

unittests/ASTMatchers/ASTMatchersNodeTest.cpp

public:
 
   bool verify(const BoundNodes &Nodes, ASTContext &Context, const Stmt *Node) {
     // Use the original typed pointer to verify we can pass pointers to subtypes
     // to equalsNode.
     const T *TypedNode = cast<T>(Node);
     return selectFirst<T>(
       "", match(stmt(hasParent(
         stmt(has(stmt(equalsNode(TypedNode)))).bind(""))),
-                *Node, Context)) != nullptr;
+                *Node, Context, Context.fullBounds())) != nullptr;
   }
   bool verify(const BoundNodes &Nodes, ASTContext &Context, const Decl *Node) {
     // Use the original typed pointer to verify we can pass pointers to subtypes
     // to equalsNode.
     const T *TypedNode = cast<T>(Node);
     return selectFirst<T>(
       "", match(decl(hasParent(
         decl(has(decl(equalsNode(TypedNode)))).bind(""))),
-                *Node, Context)) != nullptr;
+                *Node, Context, Context.fullBounds())) != nullptr;
   }
   bool verify(const BoundNodes &Nodes, ASTContext &Context, const Type *Node) {
     // Use the original typed pointer to verify we can pass pointers to subtypes
     // to equalsNode.
     const T *TypedNode = cast<T>(Node);
     const auto *Dec = Nodes.getNodeAs<FieldDecl>("decl");
     return selectFirst<T>(
       "", match(fieldDecl(hasParent(decl(has(fieldDecl(
         hasType(type(equalsNode(TypedNode)).bind(""))))))),
-                *Dec, Context)) != nullptr;
+                *Dec, Context, Context.fullBounds())) != nullptr;
   }
 };
 
 TEST(IsEqualTo, MatchesNodesByIdentity) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "class X { class Y {}; };", recordDecl(hasName("::X::Y")).bind(""),
     llvm::make_unique<VerifyAncestorHasChildIsEqual<CXXRecordDecl>>()));
   EXPECT_TRUE(matchAndVerifyResultTrue(

unittests/ASTMatchers/ASTMatchersTest.h

return testing::AssertionFailure()
       << "Verified unexpected result in \"" << Code << "\"";
   }
 
   VerifiedResult = false;
   std::unique_ptr<ASTUnit> AST(buildASTFromCodeWithArgs(Code, Args));
   if (!AST.get())
     return testing::AssertionFailure() << "Parsing error in \"" << Code
                                        << "\" while building AST";
-  Finder.matchAST(AST->getASTContext());
+  Finder.matchAST(AST->getASTContext(), AST->getASTContext().fullBounds()); // XXX
   if (!VerifiedResult && ExpectResult) {
     return testing::AssertionFailure()
       << "Could not verify result in \"" << Code << "\" with AST";
   } else if (VerifiedResult && !ExpectResult) {
     return testing::AssertionFailure()
       << "Verified unexpected result in \"" << Code << "\" with AST";
   }
 

unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

 
 TEST(HasParent, NoDuplicateParents) {
   class HasDuplicateParents : public BoundNodesCallback {
   public:
     bool run(const BoundNodes *Nodes) override { return false; }
     bool run(const BoundNodes *Nodes, ASTContext *Context) override {
       const Stmt *Node = Nodes->getNodeAs<Stmt>("node");
       std::set<const void *> Parents;
-      for (const auto &Parent : Context->getParents(*Node)) {
+      for (const auto &Parent :
+           Context->getParents(*Node, Context->fullBounds())) {
         if (!Parents.insert(Parent.getMemoizationData()).second) {
           return true;
         }
       }
       return false;
     }
   };
   EXPECT_FALSE(matchAndVerifyResultTrue(
VerifyMatchOnNode(StringRef Id, const internal::Matcher<T> &InnerMatcher,
                     StringRef InnerId)
     : Id(Id), InnerMatcher(InnerMatcher), InnerId(InnerId) {
   }
 
   bool run(const BoundNodes *Nodes) override { return false; }
 
   bool run(const BoundNodes *Nodes, ASTContext *Context) override {
     const T *Node = Nodes->getNodeAs<T>(Id);
-    return selectFirst<T>(InnerId, match(InnerMatcher, *Node, *Context)) !=
-      nullptr;
+    return selectFirst<T>(InnerId, match(InnerMatcher, *Node, *Context,
+                                         Context->fullBounds())) != nullptr;
   }
 private:
   std::string Id;
   internal::Matcher<T> InnerMatcher;
   std::string InnerId;
 };
 
 TEST(MatchFinder, CanMatchDeclarationsRecursively) {

unittests/Analysis/ExprMutationAnalyzerTest.cpp

 
 StmtMatcher withEnclosingCompound(ExprMatcher Matcher) {
   return expr(Matcher, hasAncestor(compoundStmt().bind("stmt"))).bind("expr");
 }
 
 bool isMutated(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
   const auto *const S = selectFirst<Stmt>("stmt", Results);
   const auto *const E = selectFirst<Expr>("expr", Results);
-  return ExprMutationAnalyzer(*S, AST->getASTContext()).isMutated(E);
+  return ExprMutationAnalyzer(*S, AST->getASTContext(), AST->getASTContext().fullBounds()).isMutated(E);
 }
 
 SmallVector<std::string, 1>
 mutatedBy(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
   const auto *const S = selectFirst<Stmt>("stmt", Results);
   SmallVector<std::string, 1> Chain;
-  ExprMutationAnalyzer Analyzer(*S, AST->getASTContext());
+  ExprMutationAnalyzer Analyzer(*S, AST->getASTContext(), AST->getASTContext().fullBounds());
   for (const auto *E = selectFirst<Expr>("expr", Results); E != nullptr;) {
     const Stmt *By = Analyzer.findMutation(E);
     std::string buffer;
     llvm::raw_string_ostream stream(buffer);
     By->printPretty(stream, nullptr, AST->getASTContext().getPrintingPolicy());
     Chain.push_back(StringRef(stream.str()).trim().str());
     E = dyn_cast<DeclRefExpr>(By);
   }
const std::string StdForward =
     "template<class T> T&& "
     "forward(typename remove_reference<T>::type&& t) noexcept { return t; } }";
 
 } // namespace
 
 TEST(ExprMutationAnalyzerTest, Trivial) {
   const auto AST = buildASTFromCode("void f() { int x; x; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(),
+            AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 class AssignmentTest : public ::testing::TestWithParam<std::string> {};
 
 TEST_P(AssignmentTest, AssignmentModifies) {
   const std::string ModExpr = "x " + GetParam() + " 10";
   const auto AST = buildASTFromCode("void f() { int x; " + ModExpr + "; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));
 }
 
 INSTANTIATE_TEST_CASE_P(AllAssignmentOperators, AssignmentTest,
                         Values("=", "+=", "-=", "*=", "/=", "%=", "&=", "|=",
                                "^=", "<<=", ">>="), );
 
 class IncDecTest : public ::testing::TestWithParam<std::string> {};
 
 TEST_P(IncDecTest, IncDecModifies) {
   const std::string ModExpr = GetParam();
   const auto AST = buildASTFromCode("void f() { int x; " + ModExpr + "; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));
 }
 
 INSTANTIATE_TEST_CASE_P(AllIncDecOperators, IncDecTest,
                         Values("++x", "--x", "x++", "x--"), );
 
 TEST(ExprMutationAnalyzerTest, NonConstMemberFunc) {
   const auto AST = buildASTFromCode(
       "void f() { struct Foo { void mf(); }; Foo x; x.mf(); }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
 }
 
 TEST(ExprMutationAnalyzerTest, AssumedNonConstMemberFunc) {
   auto AST = buildASTFromCodeWithArgs(
       "struct X { template <class T> void mf(); };"
       "template <class T> void f() { X x; x.mf<T>(); }",
       {"-fno-delayed-template-parsing"});
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf<T>()"));
 
   AST = buildASTFromCodeWithArgs("template <class T> void f() { T x; x.mf(); }",
                                  {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
 
   AST = buildASTFromCodeWithArgs(
       "template <class T> struct X;"
       "template <class T> void f() { X<T> x; x.mf(); }",
       {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.mf()"));
 }
 
 TEST(ExprMutationAnalyzerTest, ConstMemberFunc) {
   const auto AST = buildASTFromCode(
       "void f() { struct Foo { void mf() const; }; Foo x; x.mf(); }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, NonConstOperator) {
   const auto AST = buildASTFromCode(
       "void f() { struct Foo { Foo& operator=(int); }; Foo x; x = 10; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, ConstOperator) {
   const auto AST = buildASTFromCode(
       "void f() { struct Foo { int operator()() const; }; Foo x; x(); }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, ByValueArgument) {
   auto AST = buildASTFromCode("void g(int); void f() { int x; g(x); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void g(int*); void f() { int* x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("typedef int* IntPtr;"
                          "void g(IntPtr); void f() { int* x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "struct A {}; A operator+(A, int); void f() { A x; x + 1; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void f() { struct A { A(int); }; int x; A y(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("struct A { A(); A& operator=(A); };"
                          "void f() { A x, y; y = x; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "template <int> struct A { A(); A(const A&); static void mf(A) {} };"
       "void f() { A<0> x; A<0>::mf(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, ByConstValueArgument) {
   auto AST = buildASTFromCode("void g(const int); void f() { int x; g(x); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void g(int* const); void f() { int* x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("typedef int* const CIntPtr;"
                          "void g(CIntPtr); void f() { int* x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "struct A {}; A operator+(const A, int); void f() { A x; x + 1; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "void f() { struct A { A(const int); }; int x; A y(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("template <int> struct A { A(); A(const A&);"
                          "static void mf(const A&) {} };"
                          "void f() { A<0> x; A<0>::mf(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, ByNonConstRefArgument) {
   auto AST = buildASTFromCode("void g(int&); void f() { int x; g(x); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
   AST = buildASTFromCode("typedef int& IntRef;"
                          "void g(IntRef); void f() { int x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
   AST = buildASTFromCode("template <class T> using TRef = T&;"
                          "void g(TRef<int>); void f() { int x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
   AST = buildASTFromCode(
       "template <class T> struct identity { using type = T; };"
       "template <class T, class U = T&> void g(typename identity<U>::type);"
       "void f() { int x; g<int>(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g<int>(x)"));
 
   AST = buildASTFromCode("typedef int* IntPtr;"
                          "void g(IntPtr&); void f() { int* x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
   AST = buildASTFromCode("typedef int* IntPtr; typedef IntPtr& IntPtrRef;"
                          "void g(IntPtrRef); void f() { int* x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
   AST = buildASTFromCode(
       "struct A {}; A operator+(A&, int); void f() { A x; x + 1; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x + 1"));
 
   AST = buildASTFromCode("void f() { struct A { A(int&); }; int x; A y(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 
   AST = buildASTFromCode("void f() { struct A { A(); A(A&); }; A x; A y(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 
   AST = buildASTFromCode(
       "template <int> struct A { A(); A(const A&); static void mf(A&) {} };"
       "void f() { A<0> x; A<0>::mf(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("A<0>::mf(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, ByConstRefArgument) {
   auto AST = buildASTFromCode("void g(const int&); void f() { int x; g(x); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("typedef const int& CIntRef;"
                          "void g(CIntRef); void f() { int x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("template <class T> using CTRef = const T&;"
                          "void g(CTRef<int>); void f() { int x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST =
       buildASTFromCode("template <class T> struct identity { using type = T; };"
                        "template <class T, class U = const T&>"
                        "void g(typename identity<U>::type);"
                        "void f() { int x; g<int>(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "struct A {}; A operator+(const A&, int); void f() { A x; x + 1; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "void f() { struct A { A(const int&); }; int x; A y(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "void f() { struct A { A(); A(const A&); }; A x; A y(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, ByNonConstRRefArgument) {
   auto AST = buildASTFromCode(
       "void g(int&&); void f() { int x; g(static_cast<int &&>(x)); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("g(static_cast<int &&>(x))"));
 
   AST = buildASTFromCode("struct A {}; A operator+(A&&, int);"
                          "void f() { A x; static_cast<A &&>(x) + 1; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("static_cast<A &&>(x) + 1"));
 
   AST = buildASTFromCode("void f() { struct A { A(int&&); }; "
                          "int x; A y(static_cast<int &&>(x)); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("static_cast<int &&>(x)"));
 
   AST = buildASTFromCode("void f() { struct A { A(); A(A&&); }; "
                          "A x; A y(static_cast<A &&>(x)); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("static_cast<A &&>(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, ByConstRRefArgument) {
   auto AST = buildASTFromCode(
       "void g(const int&&); void f() { int x; g(static_cast<int&&>(x)); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("struct A {}; A operator+(const A&&, int);"
                          "void f() { A x; static_cast<A&&>(x) + 1; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void f() { struct A { A(const int&&); }; "
                          "int x; A y(static_cast<int&&>(x)); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void f() { struct A { A(); A(const A&&); }; "
                          "A x; A y(static_cast<A&&>(x)); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, Move) {
   auto AST = buildASTFromCode(StdRemoveReference + StdMove +
                               "void f() { struct A {}; A x; std::move(x); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(StdRemoveReference + StdMove +
                          "void f() { struct A {}; A x, y; std::move(x) = y; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("std::move(x) = y"));
 
   AST = buildASTFromCode(StdRemoveReference + StdMove +
                          "void f() { int x, y; y = std::move(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST =
       buildASTFromCode(StdRemoveReference + StdMove +
                        "struct S { S(); S(const S&); S& operator=(const S&); };"
                        "void f() { S x, y; y = std::move(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(StdRemoveReference + StdMove +
                          "struct S { S(); S(S&&); S& operator=(S&&); };"
                          "void f() { S x, y; y = std::move(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));
 
   AST = buildASTFromCode(StdRemoveReference + StdMove +
                          "struct S { S(); S(const S&); S(S&&);"
                          "S& operator=(const S&); S& operator=(S&&); };"
                          "void f() { S x, y; y = std::move(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));
 
   AST = buildASTFromCode(StdRemoveReference + StdMove +
                          "struct S { S(); S(const S&); S(S&&);"
                          "S& operator=(const S&); S& operator=(S&&); };"
                          "void f() { const S x; S y; y = std::move(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(StdRemoveReference + StdMove +
                          "struct S { S(); S& operator=(S); };"
                          "void f() { S x, y; y = std::move(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(StdRemoveReference + StdMove +
                          "struct S{}; void f() { S x, y; y = std::move(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("y = std::move(x)"));
 
   AST = buildASTFromCode(
       StdRemoveReference + StdMove +
       "struct S{}; void f() { const S x; S y; y = std::move(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, Forward) {
   auto AST =
       buildASTFromCode(StdRemoveReference + StdForward +
                        "void f() { struct A {}; A x; std::forward<A &>(x); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       StdRemoveReference + StdForward +
       "void f() { struct A {}; A x, y; std::forward<A &>(x) = y; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("std::forward<A &>(x) = y"));
 }
 
 TEST(ExprMutationAnalyzerTest, CallUnresolved) {
   auto AST =
       buildASTFromCodeWithArgs("template <class T> void f() { T x; g(x); }",
                                {"-fno-delayed-template-parsing"});
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
   AST =
       buildASTFromCodeWithArgs("template <int N> void f() { char x[N]; g(x); }",
                                {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
   AST = buildASTFromCodeWithArgs(
       "template <class T> void f(T t) { int x; g(t, x); }",
       {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(t, x)"));
 
   AST = buildASTFromCodeWithArgs(
       "template <class T> void f(T t) { int x; t.mf(x); }",
       {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("t.mf(x)"));
 
   AST = buildASTFromCodeWithArgs(
       "template <class T> struct S;"
       "template <class T> void f() { S<T> s; int x; s.mf(x); }",
       {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("s.mf(x)"));
 
   AST = buildASTFromCodeWithArgs(
       "struct S { template <class T> void mf(); };"
       "template <class T> void f(S s) { int x; s.mf<T>(x); }",
       {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("s.mf<T>(x)"));
 
   AST = buildASTFromCodeWithArgs("template <class F>"
                                  "void g(F f) { int x; f(x); } ",
                                  {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("f(x)"));
 
   AST = buildASTFromCodeWithArgs(
       "template <class T> void f() { int x; (void)T(x); }",
       {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("T(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsValue) {
   auto AST = buildASTFromCode("int f() { int x; return x; }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("int* f() { int* x; return x; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("typedef int* IntPtr;"
                          "IntPtr f() { int* x; return x; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsNonConstRef) {
   const auto AST = buildASTFromCode("int& f() { int x; return x; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("return x;"));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsConstRef) {
   const auto AST = buildASTFromCode("const int& f() { int x; return x; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsNonConstRRef) {
   const auto AST =
       buildASTFromCode("int&& f() { int x; return static_cast<int &&>(x); }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("return static_cast<int &&>(x);"));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsConstRRef) {
   const auto AST = buildASTFromCode(
       "const int&& f() { int x; return static_cast<int&&>(x); }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, TakeAddress) {
   const auto AST = buildASTFromCode("void g(int*); void f() { int x; g(&x); }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("&x"));
 }
 
 TEST(ExprMutationAnalyzerTest, ArrayToPointerDecay) {
   const auto AST =
       buildASTFromCode("void g(int*); void f() { int x[2]; g(x); }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 }
 
 TEST(ExprMutationAnalyzerTest, TemplateWithArrayToPointerDecay) {
   const auto AST = buildASTFromCodeWithArgs(
       "template <typename T> struct S { static constexpr int v = 8; };"
       "template <> struct S<int> { static constexpr int v = 4; };"
       "void g(char*);"
       "template <typename T> void f() { char x[S<T>::v]; g(x); }"
       "template <> void f<int>() { char y[S<int>::v]; g(y); }",
       {"-fno-delayed-template-parsing"});
   const auto ResultsX =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(ResultsX, AST.get()), ElementsAre("g(x)"));
   const auto ResultsY =
-      match(withEnclosingCompound(declRefTo("y")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("y")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(ResultsY, AST.get()), ElementsAre("y"));
 }
 
 TEST(ExprMutationAnalyzerTest, FollowRefModified) {
   auto AST = buildASTFromCode(
       "void f() { int x; int& r0 = x; int& r1 = r0; int& r2 = r1; "
       "int& r3 = r2; r3 = 10; }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("r0", "r1", "r2", "r3", "r3 = 10"));
 
   AST = buildASTFromCode("typedef int& IntRefX;"
                          "using IntRefY = int&;"
                          "void f() { int x; IntRefX r0 = x; IntRefY r1 = r0;"
                          "decltype((x)) r2 = r1; r2 = 10; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("r0", "r1", "r2", "r2 = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, FollowRefNotModified) {
   auto AST = buildASTFromCode(
       "void f() { int x; int& r0 = x; int& r1 = r0; int& r2 = r1; "
       "int& r3 = r2; int& r4 = r3; int& r5 = r4;}");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void f() { int x; int& r0 = x; const int& r1 = r0;}");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("typedef const int& CIntRefX;"
                          "using CIntRefY = const int&;"
                          "void f() { int x; int& r0 = x; CIntRefX r1 = r0;"
                          "CIntRefY r2 = r1; decltype((r1)) r3 = r2;}");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, FollowConditionalRefModified) {
   const auto AST = buildASTFromCode(
       "void f() { int x, y; bool b; int &r = b ? x : y; r = 10; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("r", "r = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, FollowConditionalRefNotModified) {
   const auto AST =
       buildASTFromCode("void f() { int x, y; bool b; int& r = b ? x : y; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, FollowFuncArgModified) {
   auto AST = buildASTFromCode("template <class T> void g(T&& t) { t = 10; }"
                               "void f() { int x; g(x); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
   AST = buildASTFromCode(
       "void h(int&);"
       "template <class... Args> void g(Args&&... args) { h(args...); }"
       "void f() { int x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 
   AST = buildASTFromCode(
       "void h(int&, int);"
       "template <class... Args> void g(Args&&... args) { h(args...); }"
       "void f() { int x, y; g(x, y); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x, y)"));
-  Results = match(withEnclosingCompound(declRefTo("y")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("y")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "void h(int, int&);"
       "template <class... Args> void g(Args&&... args) { h(args...); }"
       "void f() { int x, y; g(y, x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(y, x)"));
-  Results = match(withEnclosingCompound(declRefTo("y")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("y")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("struct S { template <class T> S(T&& t) { t = 10; } };"
                          "void f() { int x; S s(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 
   AST = buildASTFromCode(
       "struct S { template <class T> S(T&& t) : m(++t) { } int m; };"
       "void f() { int x; S s(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 
   AST = buildASTFromCode("template <class U> struct S {"
                          "template <class T> S(T&& t) : m(++t) { } U m; };"
                          "void f() { int x; S<int> s(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 
   AST = buildASTFromCode(StdRemoveReference + StdForward +
                          "template <class... Args> void u(Args&...);"
                          "template <class... Args> void h(Args&&... args)"
                          "{ u(std::forward<Args>(args)...); }"
                          "template <class... Args> void g(Args&&... args)"
                          "{ h(std::forward<Args>(args)...); }"
                          "void f() { int x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("g(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, FollowFuncArgNotModified) {
   auto AST = buildASTFromCode("template <class T> void g(T&&) {}"
                               "void f() { int x; g(x); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("template <class T> void g(T&& t) { t; }"
                          "void f() { int x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("template <class... Args> void g(Args&&...) {}"
                          "void f() { int x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("template <class... Args> void g(Args&&...) {}"
                          "void f() { int y, x; g(y, x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "void h(int, int&);"
       "template <class... Args> void g(Args&&... args) { h(args...); }"
       "void f() { int x, y; g(x, y); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("struct S { template <class T> S(T&& t) { t; } };"
                          "void f() { int x; S s(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "struct S { template <class T> S(T&& t) : m(t) { } int m; };"
       "void f() { int x; S s(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("template <class U> struct S {"
                          "template <class T> S(T&& t) : m(t) { } U m; };"
                          "void f() { int x; S<int> s(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(StdRemoveReference + StdForward +
                          "template <class... Args> void u(Args...);"
                          "template <class... Args> void h(Args&&... args)"
                          "{ u(std::forward<Args>(args)...); }"
                          "template <class... Args> void g(Args&&... args)"
                          "{ h(std::forward<Args>(args)...); }"
                          "void f() { int x; g(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, ArrayElementModified) {
   const auto AST = buildASTFromCode("void f() { int x[2]; x[0] = 10; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x[0] = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, ArrayElementNotModified) {
   const auto AST = buildASTFromCode("void f() { int x[2]; x[0]; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, NestedMemberModified) {
   auto AST =
       buildASTFromCode("void f() { struct A { int vi; }; struct B { A va; }; "
                        "struct C { B vb; }; C x; x.vb.va.vi = 10; }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.vb.va.vi = 10"));
 
   AST = buildASTFromCodeWithArgs(
       "template <class T> void f() { T x; x.y.z = 10; }",
       {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.y.z = 10"));
 
   AST = buildASTFromCodeWithArgs(
       "template <class T> struct S;"
       "template <class T> void f() { S<T> x; x.y.z = 10; }",
       {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.y.z = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, NestedMemberNotModified) {
   auto AST =
       buildASTFromCode("void f() { struct A { int vi; }; struct B { A va; }; "
                        "struct C { B vb; }; C x; x.vb.va.vi; }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCodeWithArgs("template <class T> void f() { T x; x.y.z; }",
                                  {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST =
       buildASTFromCodeWithArgs("template <class T> struct S;"
                                "template <class T> void f() { S<T> x; x.y.z; }",
                                {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, CastToValue) {
   const auto AST =
       buildASTFromCode("void f() { int x; static_cast<double>(x); }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, CastToRefModified) {
   auto AST =
       buildASTFromCode("void f() { int x; static_cast<int &>(x) = 10; }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("static_cast<int &>(x) = 10"));
 
   AST = buildASTFromCode("typedef int& IntRef;"
                          "void f() { int x; static_cast<IntRef>(x) = 10; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("static_cast<IntRef>(x) = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, CastToRefNotModified) {
   const auto AST =
       buildASTFromCode("void f() { int x; static_cast<int&>(x); }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, CastToConstRef) {
   auto AST =
       buildASTFromCode("void f() { int x; static_cast<const int&>(x); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("typedef const int& CIntRef;"
                          "void f() { int x; static_cast<CIntRef>(x); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, LambdaDefaultCaptureByValue) {
   const auto AST = buildASTFromCode("void f() { int x; [=]() { x; }; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, LambdaExplicitCaptureByValue) {
   const auto AST = buildASTFromCode("void f() { int x; [x]() { x; }; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, LambdaDefaultCaptureByRef) {
   const auto AST = buildASTFromCode("void f() { int x; [&]() { x = 10; }; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre(ResultOf(removeSpace, "[&](){x=10;}")));
 }
 
 TEST(ExprMutationAnalyzerTest, LambdaExplicitCaptureByRef) {
   const auto AST = buildASTFromCode("void f() { int x; [&x]() { x = 10; }; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre(ResultOf(removeSpace, "[&x](){x=10;}")));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForArrayByRefModified) {
   auto AST =
       buildASTFromCode("void f() { int x[2]; for (int& e : x) e = 10; }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
 
   AST = buildASTFromCode("typedef int& IntRef;"
                          "void f() { int x[2]; for (IntRef e : x) e = 10; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForArrayByRefNotModified) {
   const auto AST =
       buildASTFromCode("void f() { int x[2]; for (int& e : x) e; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForArrayByValue) {
   auto AST = buildASTFromCode("void f() { int x[2]; for (int e : x) e = 10; }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST =
       buildASTFromCode("void f() { int* x[2]; for (int* e : x) e = nullptr; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "typedef int* IntPtr;"
       "void f() { int* x[2]; for (IntPtr e : x) e = nullptr; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForArrayByConstRef) {
   auto AST =
       buildASTFromCode("void f() { int x[2]; for (const int& e : x) e; }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("typedef const int& CIntRef;"
                          "void f() { int x[2]; for (CIntRef e : x) e; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForNonArrayByRefModified) {
   const auto AST =
       buildASTFromCode("struct V { int* begin(); int* end(); };"
                        "void f() { V x; for (int& e : x) e = 10; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForNonArrayByRefNotModified) {
   const auto AST = buildASTFromCode("struct V { int* begin(); int* end(); };"
                                     "void f() { V x; for (int& e : x) e; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForNonArrayByValue) {
   const auto AST = buildASTFromCode(
       "struct V { const int* begin() const; const int* end() const; };"
       "void f() { V x; for (int e : x) e; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForNonArrayByConstRef) {
   const auto AST = buildASTFromCode(
       "struct V { const int* begin() const; const int* end() const; };"
       "void f() { V x; for (const int& e : x) e; }");
   const auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, UnevaluatedExpressions) {
   auto AST = buildASTFromCode("void f() { int x, y; decltype(x = 10) z = y; }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void f() { int x, y; __typeof(x = 10) z = y; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void f() { int x, y; __typeof__(x = 10) z = y; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void f() { int x; sizeof(x = 10); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void f() { int x; alignof(x = 10); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode("void f() { int x; noexcept(x = 10); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCodeWithArgs("namespace std { class type_info; }"
                                  "void f() { int x; typeid(x = 10); }",
                                  {"-frtti"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(
       "void f() { int x; _Generic(x = 10, int: 0, default: 1); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, NotUnevaluatedExpressions) {
   auto AST = buildASTFromCode("void f() { int x; sizeof(int[x++]); }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x++"));
 
   AST = buildASTFromCodeWithArgs(
       "namespace std { class type_info; }"
       "struct A { virtual ~A(); }; struct B : A {};"
       "struct X { A& f(); }; void f() { X x; typeid(x.f()); }",
       {"-frtti"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x.f()"));
 }
 
 TEST(ExprMutationAnalyzerTest, UniquePtr) {
   const std::string UniquePtrDef =
       "template <class T> struct UniquePtr {"
       "  UniquePtr();"
       "  UniquePtr(const UniquePtr&) = delete;"
       "  UniquePtr(UniquePtr&&);"
       "  UniquePtr& operator=(const UniquePtr&) = delete;"
       "  UniquePtr& operator=(UniquePtr&&);"
       "  T& operator*() const;"
       "  T* operator->() const;"
       "};";
 
   auto AST = buildASTFromCode(UniquePtrDef +
                               "void f() { UniquePtr<int> x; *x = 10; }");
   auto Results =
-      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("* x = 10"));
 
   AST = buildASTFromCode(UniquePtrDef + "void f() { UniquePtr<int> x; *x; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(UniquePtrDef +
                          "void f() { UniquePtr<const int> x; *x; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCode(UniquePtrDef + "struct S { int v; };"
                                         "void f() { UniquePtr<S> x; x->v; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 
   AST = buildASTFromCode(UniquePtrDef +
                          "struct S { int v; };"
                          "void f() { UniquePtr<const S> x; x->v; }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST =
       buildASTFromCode(UniquePtrDef + "struct S { void mf(); };"
                                       "void f() { UniquePtr<S> x; x->mf(); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x"));
 
   AST = buildASTFromCode(UniquePtrDef +
                          "struct S { void mf() const; };"
                          "void f() { UniquePtr<const S> x; x->mf(); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 
   AST = buildASTFromCodeWithArgs(
       UniquePtrDef + "template <class T> void f() { UniquePtr<T> x; x->mf(); }",
       {"-fno-delayed-template-parsing"});
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext(), AST->getASTContext().fullBounds());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x->mf()"));
 }
 
 } // namespace clang