[CSA] Move AnalysisContext.h to AnalysisDeclContext.h

[george.karpenkov]

Summary

The implementation is in AnalysisDeclContext.cpp and the class is called AnalysisDeclContext.

Making those match up has numerous benefits, including:

• easier jump from header to/from implementation
• easily identify filename from class

[NoQ]

Heh, i never noticed. Thanks.

include/clang/Analysis/AnalysisDeclContext.h

15–16 ↗

(On Diff #113944)

Maybe rename those as well?

[george.karpenkov]

@NoQ done. There was also another file not matching up, I'll try to see whether I remember.

[zaks.anna]

Looks good.

cfe/trunk/include/clang/Analysis/Analyses/Consumed.h

 
 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_CONSUMED_H
 #define LLVM_CLANG_ANALYSIS_ANALYSES_CONSUMED_H
 
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/Analysis/Analyses/PostOrderCFGView.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/SourceLocation.h"
 
 namespace clang {
 namespace consumed {
   
   enum ConsumedState {
     // No state information for the given variable.
     CS_None,

cfe/trunk/include/clang/Analysis/Analyses/Dominators.h

 //==- Dominators.h - Implementation of dominators tree for Clang CFG C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the dominators tree functionality for Clang CFGs.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_DOMINATORS_H
 #define LLVM_CLANG_ANALYSIS_ANALYSES_DOMINATORS_H
 
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/Support/GenericDomTree.h"
 #include "llvm/Support/GenericDomTreeConstruction.h"
 
 // FIXME: There is no good reason for the domtree to require a print method
 // which accepts an LLVM Module, so remove this (and the method's argument that
 // needs it) when that is fixed.

cfe/trunk/include/clang/Analysis/Analyses/LiveVariables.h

 // This file implements Live Variables analysis for source-level CFGs.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIVEVARIABLES_H
 #define LLVM_CLANG_ANALYSIS_ANALYSES_LIVEVARIABLES_H
 
 #include "clang/AST/Decl.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "llvm/ADT/ImmutableSet.h"
 
 namespace clang {
 
 class CFG;
 class CFGBlock;
 class Stmt;
 class DeclRefExpr;

cfe/trunk/include/clang/Analysis/Analyses/PostOrderCFGView.h

 
 #include <vector>
 //#include <algorithm>
 
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/BitVector.h"
 
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 
 namespace clang {
 
 class PostOrderCFGView : public ManagedAnalysis {
   virtual void anchor();
 public:
   /// \brief Implements a set of CFGBlocks using a BitVector.

cfe/trunk/include/clang/Analysis/Analyses/ThreadSafety.h

 // See http://clang.llvm.org/docs/LanguageExtensions.html#thread-safety-annotation-checking
 // for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETY_H
 #define LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETY_H
 
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace threadSafety {
 
 class BeforeSet;
 

cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyCommon.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETYCOMMON_H
 #define LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETYCOMMON_H
 
 #include "clang/Analysis/Analyses/PostOrderCFGView.h"
 #include "clang/Analysis/Analyses/ThreadSafetyTIL.h"
 #include "clang/Analysis/Analyses/ThreadSafetyTraverse.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/OperatorKinds.h"
 #include <memory>
 #include <ostream>
 #include <sstream>
 #include <vector>
 
 
 namespace clang {

cfe/trunk/include/clang/Analysis/AnalysisContext.h

-//=== AnalysisContext.h - Analysis context for Path Sens analysis --*- C++ -*-//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines AnalysisDeclContext, a class that manages the analysis
-// context data for path sensitive analysis.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_ANALYSIS_ANALYSISCONTEXT_H
-#define LLVM_CLANG_ANALYSIS_ANALYSISCONTEXT_H
-
-#include "clang/AST/Decl.h"
-#include "clang/Analysis/CFG.h"
-#include "clang/Analysis/CodeInjector.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/FoldingSet.h"
-#include "llvm/Support/Allocator.h"
-#include <memory>
-
-namespace clang {
-
-class Stmt;
-class CFGReverseBlockReachabilityAnalysis;
-class CFGStmtMap;
-class LiveVariables;
-class ManagedAnalysis;
-class ParentMap;
-class PseudoConstantAnalysis;
-class LocationContextManager;
-class StackFrameContext;
-class BlockInvocationContext;
-class AnalysisDeclContextManager;
-class LocationContext;
-
-namespace idx { class TranslationUnit; }
-
-/// The base class of a hierarchy of objects representing analyses tied
-/// to AnalysisDeclContext.
-class ManagedAnalysis {
-protected:
-  ManagedAnalysis() {}
-public:
-  virtual ~ManagedAnalysis();
-
-  // Subclasses need to implement:
-  //
-  //  static const void *getTag();
-  //
-  // Which returns a fixed pointer address to distinguish classes of
-  // analysis objects.  They also need to implement:
-  //
-  //  static [Derived*] create(AnalysisDeclContext &Ctx);
-  //
-  // which creates the analysis object given an AnalysisDeclContext.
-};
-
-
-/// AnalysisDeclContext contains the context data for the function or method
-/// under analysis.
-class AnalysisDeclContext {
-  /// Backpoint to the AnalysisManager object that created this
-  /// AnalysisDeclContext. This may be null.
-  AnalysisDeclContextManager *Manager;
-
-  const Decl * const D;
-
-  std::unique_ptr<CFG> cfg, completeCFG;
-  std::unique_ptr<CFGStmtMap> cfgStmtMap;
-
-  CFG::BuildOptions cfgBuildOptions;
-  CFG::BuildOptions::ForcedBlkExprs *forcedBlkExprs;
-
-  bool builtCFG, builtCompleteCFG;
-  std::unique_ptr<ParentMap> PM;
-  std::unique_ptr<PseudoConstantAnalysis> PCA;
-  std::unique_ptr<CFGReverseBlockReachabilityAnalysis> CFA;
-
-  llvm::BumpPtrAllocator A;
-
-  llvm::DenseMap<const BlockDecl*,void*> *ReferencedBlockVars;
-
-  void *ManagedAnalyses;
-
-public:
-  AnalysisDeclContext(AnalysisDeclContextManager *Mgr,
-                  const Decl *D);
-
-  AnalysisDeclContext(AnalysisDeclContextManager *Mgr,
-                  const Decl *D,
-                  const CFG::BuildOptions &BuildOptions);
-
-  ~AnalysisDeclContext();
-
-  ASTContext &getASTContext() const { return D->getASTContext(); }
-  const Decl *getDecl() const { return D; }
-
-  /// Return the AnalysisDeclContextManager (if any) that created
-  /// this AnalysisDeclContext.
-  AnalysisDeclContextManager *getManager() const {
-    return Manager;
-  }
-  
-  /// Return the build options used to construct the CFG.
-  CFG::BuildOptions &getCFGBuildOptions() {
-    return cfgBuildOptions;
-  }
-
-  const CFG::BuildOptions &getCFGBuildOptions() const {
-    return cfgBuildOptions;
-  }
-
-  /// getAddEHEdges - Return true iff we are adding exceptional edges from
-  /// callExprs.  If this is false, then try/catch statements and blocks
-  /// reachable from them can appear to be dead in the CFG, analysis passes must
-  /// cope with that.
-  bool getAddEHEdges() const { return cfgBuildOptions.AddEHEdges; }
-  bool getUseUnoptimizedCFG() const {
-      return !cfgBuildOptions.PruneTriviallyFalseEdges;
-  }
-  bool getAddImplicitDtors() const { return cfgBuildOptions.AddImplicitDtors; }
-  bool getAddInitializers() const { return cfgBuildOptions.AddInitializers; }
-
-  void registerForcedBlockExpression(const Stmt *stmt);
-  const CFGBlock *getBlockForRegisteredExpression(const Stmt *stmt);
-
-  /// \brief Get the body of the Declaration.
-  Stmt *getBody() const;
-
-  /// \brief Get the body of the Declaration.
-  /// \param[out] IsAutosynthesized Specifies if the body is auto-generated
-  ///             by the BodyFarm.
-  Stmt *getBody(bool &IsAutosynthesized) const;
-
-  /// \brief Checks if the body of the Decl is generated by the BodyFarm.
-  ///
-  /// Note, the lookup is not free. We are going to call getBody behind
-  /// the scenes.
-  /// \sa getBody
-  bool isBodyAutosynthesized() const;
-
-  /// \brief Checks if the body of the Decl is generated by the BodyFarm from a
-  /// model file.
-  ///
-  /// Note, the lookup is not free. We are going to call getBody behind
-  /// the scenes.
-  /// \sa getBody
-  bool isBodyAutosynthesizedFromModelFile() const;
-
-  CFG *getCFG();
-
-  CFGStmtMap *getCFGStmtMap();
-
-  CFGReverseBlockReachabilityAnalysis *getCFGReachablityAnalysis();
-
-  /// Return a version of the CFG without any edges pruned.
-  CFG *getUnoptimizedCFG();
-
-  void dumpCFG(bool ShowColors);
-
-  /// \brief Returns true if we have built a CFG for this analysis context.
-  /// Note that this doesn't correspond to whether or not a valid CFG exists, it
-  /// corresponds to whether we *attempted* to build one.
-  bool isCFGBuilt() const { return builtCFG; }
-
-  ParentMap &getParentMap();
-  PseudoConstantAnalysis *getPseudoConstantAnalysis();
-
-  typedef const VarDecl * const * referenced_decls_iterator;
-
-  llvm::iterator_range<referenced_decls_iterator>
-  getReferencedBlockVars(const BlockDecl *BD);
-
-  /// Return the ImplicitParamDecl* associated with 'self' if this
-  /// AnalysisDeclContext wraps an ObjCMethodDecl.  Returns NULL otherwise.
-  const ImplicitParamDecl *getSelfDecl() const;
-
-  const StackFrameContext *getStackFrame(LocationContext const *Parent,
-                                         const Stmt *S,
-                                         const CFGBlock *Blk,
-                                         unsigned Idx);
-  
-  const BlockInvocationContext *
-  getBlockInvocationContext(const LocationContext *parent,
-                            const BlockDecl *BD,
-                            const void *ContextData);
-
-  /// Return the specified analysis object, lazily running the analysis if
-  /// necessary.  Return NULL if the analysis could not run.
-  template <typename T>
-  T *getAnalysis() {
-    const void *tag = T::getTag();
-    ManagedAnalysis *&data = getAnalysisImpl(tag);
-    if (!data) {
-      data = T::create(*this);
-    }
-    return static_cast<T*>(data);
-  }
-
-  /// Returns true if the root namespace of the given declaration is the 'std'
-  /// C++ namespace.
-  static bool isInStdNamespace(const Decl *D);
-private:
-  ManagedAnalysis *&getAnalysisImpl(const void* tag);
-
-  LocationContextManager &getLocationContextManager();
-};
-
-class LocationContext : public llvm::FoldingSetNode {
-public:
-  enum ContextKind { StackFrame, Scope, Block };
-
-private:
-  ContextKind Kind;
-
-  // AnalysisDeclContext can't be const since some methods may modify its
-  // member.
-  AnalysisDeclContext *Ctx;
-
-  const LocationContext *Parent;
-
-protected:
-  LocationContext(ContextKind k, AnalysisDeclContext *ctx,
-                  const LocationContext *parent)
-    : Kind(k), Ctx(ctx), Parent(parent) {}
-
-public:
-  virtual ~LocationContext();
-
-  ContextKind getKind() const { return Kind; }
-
-  AnalysisDeclContext *getAnalysisDeclContext() const { return Ctx; }
-
-  const LocationContext *getParent() const { return Parent; }
-
-  bool isParentOf(const LocationContext *LC) const;
-
-  const Decl *getDecl() const { return getAnalysisDeclContext()->getDecl(); }
-
-  CFG *getCFG() const { return getAnalysisDeclContext()->getCFG(); }
-
-  template <typename T>
-  T *getAnalysis() const {
-    return getAnalysisDeclContext()->getAnalysis<T>();
-  }
-
-  ParentMap &getParentMap() const {
-    return getAnalysisDeclContext()->getParentMap();
-  }
-
-  const ImplicitParamDecl *getSelfDecl() const {
-    return Ctx->getSelfDecl();
-  }
-
-  const StackFrameContext *getCurrentStackFrame() const;
-
-  /// Return true if the current LocationContext has no caller context.
-  virtual bool inTopFrame() const;
-
-  virtual void Profile(llvm::FoldingSetNodeID &ID) = 0;
-
-  void dumpStack(raw_ostream &OS, StringRef Indent = "") const;
-  void dumpStack() const;
-
-public:
-  static void ProfileCommon(llvm::FoldingSetNodeID &ID,
-                            ContextKind ck,
-                            AnalysisDeclContext *ctx,
-                            const LocationContext *parent,
-                            const void *data);
-};
-
-class StackFrameContext : public LocationContext {
-  // The callsite where this stack frame is established.
-  const Stmt *CallSite;
-
-  // The parent block of the callsite.
-  const CFGBlock *Block;
-
-  // The index of the callsite in the CFGBlock.
-  unsigned Index;
-
-  friend class LocationContextManager;
-  StackFrameContext(AnalysisDeclContext *ctx, const LocationContext *parent,
-                    const Stmt *s, const CFGBlock *blk,
-                    unsigned idx)
-    : LocationContext(StackFrame, ctx, parent), CallSite(s),
-      Block(blk), Index(idx) {}
-
-public:
-  ~StackFrameContext() override {}
-
-  const Stmt *getCallSite() const { return CallSite; }
-
-  const CFGBlock *getCallSiteBlock() const { return Block; }
-
-  /// Return true if the current LocationContext has no caller context.
-  bool inTopFrame() const override { return getParent() == nullptr;  }
-
-  unsigned getIndex() const { return Index; }
-
-  void Profile(llvm::FoldingSetNodeID &ID) override;
-
-  static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx,
-                      const LocationContext *parent, const Stmt *s,
-                      const CFGBlock *blk, unsigned idx) {
-    ProfileCommon(ID, StackFrame, ctx, parent, s);
-    ID.AddPointer(blk);
-    ID.AddInteger(idx);
-  }
-
-  static bool classof(const LocationContext *Ctx) {
-    return Ctx->getKind() == StackFrame;
-  }
-};
-
-class ScopeContext : public LocationContext {
-  const Stmt *Enter;
-
-  friend class LocationContextManager;
-  ScopeContext(AnalysisDeclContext *ctx, const LocationContext *parent,
-               const Stmt *s)
-    : LocationContext(Scope, ctx, parent), Enter(s) {}
-
-public:
-  ~ScopeContext() override {}
-
-  void Profile(llvm::FoldingSetNodeID &ID) override;
-
-  static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx,
-                      const LocationContext *parent, const Stmt *s) {
-    ProfileCommon(ID, Scope, ctx, parent, s);
-  }
-
-  static bool classof(const LocationContext *Ctx) {
-    return Ctx->getKind() == Scope;
-  }
-};
-
-class BlockInvocationContext : public LocationContext {
-  const BlockDecl *BD;
-  
-  // FIXME: Come up with a more type-safe way to model context-sensitivity.
-  const void *ContextData;
-
-  friend class LocationContextManager;
-
-  BlockInvocationContext(AnalysisDeclContext *ctx,
-                         const LocationContext *parent,
-                         const BlockDecl *bd, const void *contextData)
-    : LocationContext(Block, ctx, parent), BD(bd), ContextData(contextData) {}
-
-public:
-  ~BlockInvocationContext() override {}
-
-  const BlockDecl *getBlockDecl() const { return BD; }
-  
-  const void *getContextData() const { return ContextData; }
-
-  void Profile(llvm::FoldingSetNodeID &ID) override;
-
-  static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx,
-                      const LocationContext *parent, const BlockDecl *bd,
-                      const void *contextData) {
-    ProfileCommon(ID, Block, ctx, parent, bd);
-    ID.AddPointer(contextData);
-  }
-
-  static bool classof(const LocationContext *Ctx) {
-    return Ctx->getKind() == Block;
-  }
-};
-
-class LocationContextManager {
-  llvm::FoldingSet<LocationContext> Contexts;
-public:
-  ~LocationContextManager();
-
-  const StackFrameContext *getStackFrame(AnalysisDeclContext *ctx,
-                                         const LocationContext *parent,
-                                         const Stmt *s,
-                                         const CFGBlock *blk, unsigned idx);
-
-  const ScopeContext *getScope(AnalysisDeclContext *ctx,
-                               const LocationContext *parent,
-                               const Stmt *s);
-  
-  const BlockInvocationContext *
-  getBlockInvocationContext(AnalysisDeclContext *ctx,
-                            const LocationContext *parent,
-                            const BlockDecl *BD,
-                            const void *ContextData);
-
-  /// Discard all previously created LocationContext objects.
-  void clear();
-private:
-  template <typename LOC, typename DATA>
-  const LOC *getLocationContext(AnalysisDeclContext *ctx,
-                                const LocationContext *parent,
-                                const DATA *d);
-};
-
-class AnalysisDeclContextManager {
-  typedef llvm::DenseMap<const Decl *, std::unique_ptr<AnalysisDeclContext>>
-      ContextMap;
-
-  ContextMap Contexts;
-  LocationContextManager LocContexts;
-  CFG::BuildOptions cfgBuildOptions;
-
-  /// Pointer to an interface that can provide function bodies for
-  /// declarations from external source.
-  std::unique_ptr<CodeInjector> Injector;
-  
-  /// Flag to indicate whether or not bodies should be synthesized
-  /// for well-known functions.
-  bool SynthesizeBodies;
-
-public:
-  AnalysisDeclContextManager(bool useUnoptimizedCFG = false,
-                             bool addImplicitDtors = false,
-                             bool addInitializers = false,
-                             bool addTemporaryDtors = false,
-                             bool addLifetime = false,
-                             bool addLoopExit = false,
-                             bool synthesizeBodies = false,
-                             bool addStaticInitBranches = false,
-                             bool addCXXNewAllocator = true,
-                             CodeInjector* injector = nullptr);
-
-  ~AnalysisDeclContextManager();
-
-  AnalysisDeclContext *getContext(const Decl *D);
-
-  bool getUseUnoptimizedCFG() const {
-    return !cfgBuildOptions.PruneTriviallyFalseEdges;
-  }
-
-  CFG::BuildOptions &getCFGBuildOptions() {
-    return cfgBuildOptions;
-  }
-  
-  /// Return true if faux bodies should be synthesized for well-known
-  /// functions.
-  bool synthesizeBodies() const { return SynthesizeBodies; }
-
-  const StackFrameContext *getStackFrame(AnalysisDeclContext *Ctx,
-                                         LocationContext const *Parent,
-                                         const Stmt *S,
-                                         const CFGBlock *Blk,
-                                         unsigned Idx) {
-    return LocContexts.getStackFrame(Ctx, Parent, S, Blk, Idx);
-  }
-
-  // Get the top level stack frame.
-  const StackFrameContext *getStackFrame(const Decl *D) {
-    return LocContexts.getStackFrame(getContext(D), nullptr, nullptr, nullptr,
-                                     0);
-  }
-
-  // Get a stack frame with parent.
-  StackFrameContext const *getStackFrame(const Decl *D,
-                                         LocationContext const *Parent,
-                                         const Stmt *S,
-                                         const CFGBlock *Blk,
-                                         unsigned Idx) {
-    return LocContexts.getStackFrame(getContext(D), Parent, S, Blk, Idx);
-  }
-
-  /// Discard all previously created AnalysisDeclContexts.
-  void clear();
-
-private:
-  friend class AnalysisDeclContext;
-
-  LocationContextManager &getLocationContextManager() {
-    return LocContexts;
-  }
-};
-
-} // end clang namespace
-#endif

cfe/trunk/include/clang/Analysis/AnalysisDeclContext.h

+//=== AnalysisDeclContext.h - Analysis context for Path Sens analysis --*- C++ -*-//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines AnalysisDeclContext, a class that manages the analysis
+// context data for path sensitive analysis.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_ANALYSIS_ANALYSISDECLCONTEXT_H
+#define LLVM_CLANG_ANALYSIS_ANALYSISDECLCONTEXT_H
+
+#include "clang/AST/Decl.h"
+#include "clang/Analysis/CFG.h"
+#include "clang/Analysis/CodeInjector.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/FoldingSet.h"
+#include "llvm/Support/Allocator.h"
+#include <memory>
+
+namespace clang {
+
+class Stmt;
+class CFGReverseBlockReachabilityAnalysis;
+class CFGStmtMap;
+class LiveVariables;
+class ManagedAnalysis;
+class ParentMap;
+class PseudoConstantAnalysis;
+class LocationContextManager;
+class StackFrameContext;
+class BlockInvocationContext;
+class AnalysisDeclContextManager;
+class LocationContext;
+
+namespace idx { class TranslationUnit; }
+
+/// The base class of a hierarchy of objects representing analyses tied
+/// to AnalysisDeclContext.
+class ManagedAnalysis {
+protected:
+  ManagedAnalysis() {}
+public:
+  virtual ~ManagedAnalysis();
+
+  // Subclasses need to implement:
+  //
+  //  static const void *getTag();
+  //
+  // Which returns a fixed pointer address to distinguish classes of
+  // analysis objects.  They also need to implement:
+  //
+  //  static [Derived*] create(AnalysisDeclContext &Ctx);
+  //
+  // which creates the analysis object given an AnalysisDeclContext.
+};
+
+
+/// AnalysisDeclContext contains the context data for the function or method
+/// under analysis.
+class AnalysisDeclContext {
+  /// Backpoint to the AnalysisManager object that created this
+  /// AnalysisDeclContext. This may be null.
+  AnalysisDeclContextManager *Manager;
+
+  const Decl * const D;
+
+  std::unique_ptr<CFG> cfg, completeCFG;
+  std::unique_ptr<CFGStmtMap> cfgStmtMap;
+
+  CFG::BuildOptions cfgBuildOptions;
+  CFG::BuildOptions::ForcedBlkExprs *forcedBlkExprs;
+
+  bool builtCFG, builtCompleteCFG;
+  std::unique_ptr<ParentMap> PM;
+  std::unique_ptr<PseudoConstantAnalysis> PCA;
+  std::unique_ptr<CFGReverseBlockReachabilityAnalysis> CFA;
+
+  llvm::BumpPtrAllocator A;
+
+  llvm::DenseMap<const BlockDecl*,void*> *ReferencedBlockVars;
+
+  void *ManagedAnalyses;
+
+public:
+  AnalysisDeclContext(AnalysisDeclContextManager *Mgr,
+                  const Decl *D);
+
+  AnalysisDeclContext(AnalysisDeclContextManager *Mgr,
+                  const Decl *D,
+                  const CFG::BuildOptions &BuildOptions);
+
+  ~AnalysisDeclContext();
+
+  ASTContext &getASTContext() const { return D->getASTContext(); }
+  const Decl *getDecl() const { return D; }
+
+  /// Return the AnalysisDeclContextManager (if any) that created
+  /// this AnalysisDeclContext.
+  AnalysisDeclContextManager *getManager() const {
+    return Manager;
+  }
+  
+  /// Return the build options used to construct the CFG.
+  CFG::BuildOptions &getCFGBuildOptions() {
+    return cfgBuildOptions;
+  }
+
+  const CFG::BuildOptions &getCFGBuildOptions() const {
+    return cfgBuildOptions;
+  }
+
+  /// getAddEHEdges - Return true iff we are adding exceptional edges from
+  /// callExprs.  If this is false, then try/catch statements and blocks
+  /// reachable from them can appear to be dead in the CFG, analysis passes must
+  /// cope with that.
+  bool getAddEHEdges() const { return cfgBuildOptions.AddEHEdges; }
+  bool getUseUnoptimizedCFG() const {
+      return !cfgBuildOptions.PruneTriviallyFalseEdges;
+  }
+  bool getAddImplicitDtors() const { return cfgBuildOptions.AddImplicitDtors; }
+  bool getAddInitializers() const { return cfgBuildOptions.AddInitializers; }
+
+  void registerForcedBlockExpression(const Stmt *stmt);
+  const CFGBlock *getBlockForRegisteredExpression(const Stmt *stmt);
+
+  /// \brief Get the body of the Declaration.
+  Stmt *getBody() const;
+
+  /// \brief Get the body of the Declaration.
+  /// \param[out] IsAutosynthesized Specifies if the body is auto-generated
+  ///             by the BodyFarm.
+  Stmt *getBody(bool &IsAutosynthesized) const;
+
+  /// \brief Checks if the body of the Decl is generated by the BodyFarm.
+  ///
+  /// Note, the lookup is not free. We are going to call getBody behind
+  /// the scenes.
+  /// \sa getBody
+  bool isBodyAutosynthesized() const;
+
+  /// \brief Checks if the body of the Decl is generated by the BodyFarm from a
+  /// model file.
+  ///
+  /// Note, the lookup is not free. We are going to call getBody behind
+  /// the scenes.
+  /// \sa getBody
+  bool isBodyAutosynthesizedFromModelFile() const;
+
+  CFG *getCFG();
+
+  CFGStmtMap *getCFGStmtMap();
+
+  CFGReverseBlockReachabilityAnalysis *getCFGReachablityAnalysis();
+
+  /// Return a version of the CFG without any edges pruned.
+  CFG *getUnoptimizedCFG();
+
+  void dumpCFG(bool ShowColors);
+
+  /// \brief Returns true if we have built a CFG for this analysis context.
+  /// Note that this doesn't correspond to whether or not a valid CFG exists, it
+  /// corresponds to whether we *attempted* to build one.
+  bool isCFGBuilt() const { return builtCFG; }
+
+  ParentMap &getParentMap();
+  PseudoConstantAnalysis *getPseudoConstantAnalysis();
+
+  typedef const VarDecl * const * referenced_decls_iterator;
+
+  llvm::iterator_range<referenced_decls_iterator>
+  getReferencedBlockVars(const BlockDecl *BD);
+
+  /// Return the ImplicitParamDecl* associated with 'self' if this
+  /// AnalysisDeclContext wraps an ObjCMethodDecl.  Returns NULL otherwise.
+  const ImplicitParamDecl *getSelfDecl() const;
+
+  const StackFrameContext *getStackFrame(LocationContext const *Parent,
+                                         const Stmt *S,
+                                         const CFGBlock *Blk,
+                                         unsigned Idx);
+  
+  const BlockInvocationContext *
+  getBlockInvocationContext(const LocationContext *parent,
+                            const BlockDecl *BD,
+                            const void *ContextData);
+
+  /// Return the specified analysis object, lazily running the analysis if
+  /// necessary.  Return NULL if the analysis could not run.
+  template <typename T>
+  T *getAnalysis() {
+    const void *tag = T::getTag();
+    ManagedAnalysis *&data = getAnalysisImpl(tag);
+    if (!data) {
+      data = T::create(*this);
+    }
+    return static_cast<T*>(data);
+  }
+
+  /// Returns true if the root namespace of the given declaration is the 'std'
+  /// C++ namespace.
+  static bool isInStdNamespace(const Decl *D);
+private:
+  ManagedAnalysis *&getAnalysisImpl(const void* tag);
+
+  LocationContextManager &getLocationContextManager();
+};
+
+class LocationContext : public llvm::FoldingSetNode {
+public:
+  enum ContextKind { StackFrame, Scope, Block };
+
+private:
+  ContextKind Kind;
+
+  // AnalysisDeclContext can't be const since some methods may modify its
+  // member.
+  AnalysisDeclContext *Ctx;
+
+  const LocationContext *Parent;
+
+protected:
+  LocationContext(ContextKind k, AnalysisDeclContext *ctx,
+                  const LocationContext *parent)
+    : Kind(k), Ctx(ctx), Parent(parent) {}
+
+public:
+  virtual ~LocationContext();
+
+  ContextKind getKind() const { return Kind; }
+
+  AnalysisDeclContext *getAnalysisDeclContext() const { return Ctx; }
+
+  const LocationContext *getParent() const { return Parent; }
+
+  bool isParentOf(const LocationContext *LC) const;
+
+  const Decl *getDecl() const { return getAnalysisDeclContext()->getDecl(); }
+
+  CFG *getCFG() const { return getAnalysisDeclContext()->getCFG(); }
+
+  template <typename T>
+  T *getAnalysis() const {
+    return getAnalysisDeclContext()->getAnalysis<T>();
+  }
+
+  ParentMap &getParentMap() const {
+    return getAnalysisDeclContext()->getParentMap();
+  }
+
+  const ImplicitParamDecl *getSelfDecl() const {
+    return Ctx->getSelfDecl();
+  }
+
+  const StackFrameContext *getCurrentStackFrame() const;
+
+  /// Return true if the current LocationContext has no caller context.
+  virtual bool inTopFrame() const;
+
+  virtual void Profile(llvm::FoldingSetNodeID &ID) = 0;
+
+  void dumpStack(raw_ostream &OS, StringRef Indent = "") const;
+  void dumpStack() const;
+
+public:
+  static void ProfileCommon(llvm::FoldingSetNodeID &ID,
+                            ContextKind ck,
+                            AnalysisDeclContext *ctx,
+                            const LocationContext *parent,
+                            const void *data);
+};
+
+class StackFrameContext : public LocationContext {
+  // The callsite where this stack frame is established.
+  const Stmt *CallSite;
+
+  // The parent block of the callsite.
+  const CFGBlock *Block;
+
+  // The index of the callsite in the CFGBlock.
+  unsigned Index;
+
+  friend class LocationContextManager;
+  StackFrameContext(AnalysisDeclContext *ctx, const LocationContext *parent,
+                    const Stmt *s, const CFGBlock *blk,
+                    unsigned idx)
+    : LocationContext(StackFrame, ctx, parent), CallSite(s),
+      Block(blk), Index(idx) {}
+
+public:
+  ~StackFrameContext() override {}
+
+  const Stmt *getCallSite() const { return CallSite; }
+
+  const CFGBlock *getCallSiteBlock() const { return Block; }
+
+  /// Return true if the current LocationContext has no caller context.
+  bool inTopFrame() const override { return getParent() == nullptr;  }
+
+  unsigned getIndex() const { return Index; }
+
+  void Profile(llvm::FoldingSetNodeID &ID) override;
+
+  static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx,
+                      const LocationContext *parent, const Stmt *s,
+                      const CFGBlock *blk, unsigned idx) {
+    ProfileCommon(ID, StackFrame, ctx, parent, s);
+    ID.AddPointer(blk);
+    ID.AddInteger(idx);
+  }
+
+  static bool classof(const LocationContext *Ctx) {
+    return Ctx->getKind() == StackFrame;
+  }
+};
+
+class ScopeContext : public LocationContext {
+  const Stmt *Enter;
+
+  friend class LocationContextManager;
+  ScopeContext(AnalysisDeclContext *ctx, const LocationContext *parent,
+               const Stmt *s)
+    : LocationContext(Scope, ctx, parent), Enter(s) {}
+
+public:
+  ~ScopeContext() override {}
+
+  void Profile(llvm::FoldingSetNodeID &ID) override;
+
+  static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx,
+                      const LocationContext *parent, const Stmt *s) {
+    ProfileCommon(ID, Scope, ctx, parent, s);
+  }
+
+  static bool classof(const LocationContext *Ctx) {
+    return Ctx->getKind() == Scope;
+  }
+};
+
+class BlockInvocationContext : public LocationContext {
+  const BlockDecl *BD;
+  
+  // FIXME: Come up with a more type-safe way to model context-sensitivity.
+  const void *ContextData;
+
+  friend class LocationContextManager;
+
+  BlockInvocationContext(AnalysisDeclContext *ctx,
+                         const LocationContext *parent,
+                         const BlockDecl *bd, const void *contextData)
+    : LocationContext(Block, ctx, parent), BD(bd), ContextData(contextData) {}
+
+public:
+  ~BlockInvocationContext() override {}
+
+  const BlockDecl *getBlockDecl() const { return BD; }
+  
+  const void *getContextData() const { return ContextData; }
+
+  void Profile(llvm::FoldingSetNodeID &ID) override;
+
+  static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx,
+                      const LocationContext *parent, const BlockDecl *bd,
+                      const void *contextData) {
+    ProfileCommon(ID, Block, ctx, parent, bd);
+    ID.AddPointer(contextData);
+  }
+
+  static bool classof(const LocationContext *Ctx) {
+    return Ctx->getKind() == Block;
+  }
+};
+
+class LocationContextManager {
+  llvm::FoldingSet<LocationContext> Contexts;
+public:
+  ~LocationContextManager();
+
+  const StackFrameContext *getStackFrame(AnalysisDeclContext *ctx,
+                                         const LocationContext *parent,
+                                         const Stmt *s,
+                                         const CFGBlock *blk, unsigned idx);
+
+  const ScopeContext *getScope(AnalysisDeclContext *ctx,
+                               const LocationContext *parent,
+                               const Stmt *s);
+  
+  const BlockInvocationContext *
+  getBlockInvocationContext(AnalysisDeclContext *ctx,
+                            const LocationContext *parent,
+                            const BlockDecl *BD,
+                            const void *ContextData);
+
+  /// Discard all previously created LocationContext objects.
+  void clear();
+private:
+  template <typename LOC, typename DATA>
+  const LOC *getLocationContext(AnalysisDeclContext *ctx,
+                                const LocationContext *parent,
+                                const DATA *d);
+};
+
+class AnalysisDeclContextManager {
+  typedef llvm::DenseMap<const Decl *, std::unique_ptr<AnalysisDeclContext>>
+      ContextMap;
+
+  ContextMap Contexts;
+  LocationContextManager LocContexts;
+  CFG::BuildOptions cfgBuildOptions;
+
+  /// Pointer to an interface that can provide function bodies for
+  /// declarations from external source.
+  std::unique_ptr<CodeInjector> Injector;
+  
+  /// Flag to indicate whether or not bodies should be synthesized
+  /// for well-known functions.
+  bool SynthesizeBodies;
+
+public:
+  AnalysisDeclContextManager(bool useUnoptimizedCFG = false,
+                             bool addImplicitDtors = false,
+                             bool addInitializers = false,
+                             bool addTemporaryDtors = false,
+                             bool addLifetime = false,
+                             bool addLoopExit = false,
+                             bool synthesizeBodies = false,
+                             bool addStaticInitBranches = false,
+                             bool addCXXNewAllocator = true,
+                             CodeInjector* injector = nullptr);
+
+  ~AnalysisDeclContextManager();
+
+  AnalysisDeclContext *getContext(const Decl *D);
+
+  bool getUseUnoptimizedCFG() const {
+    return !cfgBuildOptions.PruneTriviallyFalseEdges;
+  }
+
+  CFG::BuildOptions &getCFGBuildOptions() {
+    return cfgBuildOptions;
+  }
+  
+  /// Return true if faux bodies should be synthesized for well-known
+  /// functions.
+  bool synthesizeBodies() const { return SynthesizeBodies; }
+
+  const StackFrameContext *getStackFrame(AnalysisDeclContext *Ctx,
+                                         LocationContext const *Parent,
+                                         const Stmt *S,
+                                         const CFGBlock *Blk,
+                                         unsigned Idx) {
+    return LocContexts.getStackFrame(Ctx, Parent, S, Blk, Idx);
+  }
+
+  // Get the top level stack frame.
+  const StackFrameContext *getStackFrame(const Decl *D) {
+    return LocContexts.getStackFrame(getContext(D), nullptr, nullptr, nullptr,
+                                     0);
+  }
+
+  // Get a stack frame with parent.
+  StackFrameContext const *getStackFrame(const Decl *D,
+                                         LocationContext const *Parent,
+                                         const Stmt *S,
+                                         const CFGBlock *Blk,
+                                         unsigned Idx) {
+    return LocContexts.getStackFrame(getContext(D), Parent, S, Blk, Idx);
+  }
+
+  /// Discard all previously created AnalysisDeclContexts.
+  void clear();
+
+private:
+  friend class AnalysisDeclContext;
+
+  LocationContextManager &getLocationContextManager() {
+    return LocContexts;
+  }
+};
+
+} // end clang namespace
+#endif

cfe/trunk/include/clang/Analysis/ProgramPoint.h

 //  This file defines the interface ProgramPoint, which identifies a
 //  distinct location in a function.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ANALYSIS_PROGRAMPOINT_H
 #define LLVM_CLANG_ANALYSIS_PROGRAMPOINT_H
 
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataTypes.h"

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h

 // This file defines the AnalysisManager class that manages the data and policy
 // for path sensitive analysis.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
 
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 
 namespace clang {
 
 class CodeInjector;

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CALLEVENT_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CALLEVENT_H
 
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include <utility>
 
 namespace clang {
 class ProgramPoint;

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h

 //  dataflow analysis via graph reachability.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_COREENGINE_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_COREENGINE_H
 
 #include "clang/AST/Expr.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/BlockCounter.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/WorkList.h"
 #include <memory>
 
 namespace clang {
 

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h

 //== Environment.h - Map from Stmt* to Locations/Values ---------*- C++ -*--==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defined the Environment and EnvironmentManager classes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ENVIRONMENT_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ENVIRONMENT_H
 
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
 #include "llvm/ADT/ImmutableMap.h"
 
 namespace clang {
 
 class LiveVariables;
 
 namespace ento {

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h

 //  exploded graph.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_EXPLODEDGRAPH_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_EXPLODEDGRAPH_H
 
 #include "clang/AST/Decl.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/ProgramPoint.h"
 #include "clang/Analysis/Support/BumpVector.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Allocator.h"

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h

 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_MEMREGION_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_MEMREGION_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/ExprObjC.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <string>
 
 namespace clang {

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SYMBOLMANAGER_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SYMBOLMANAGER_H
 
 #include "clang/AST/Decl.h"
 #include "clang/AST/Expr.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/StoreRef.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/Support/Allocator.h"

cfe/trunk/lib/Analysis/AnalysisDeclContext.cpp

 //== AnalysisDeclContext.cpp - Analysis context for Path Sens analysis -*- C++ -*-//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines AnalysisDeclContext, a class that manages the analysis context
 // data for path sensitive analysis.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "BodyFarm.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Analysis/Analyses/CFGReachabilityAnalysis.h"

cfe/trunk/lib/Analysis/Consumed.cpp

 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/AST/Type.h"
 #include "clang/Analysis/Analyses/PostOrderCFGView.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMap.h"
 #include <memory>
 
 // TODO: Adjust states of args to constructors in the same way that arguments to
 //       function calls are handled.

cfe/trunk/lib/Analysis/LiveVariables.cpp

 // This file implements Live Variables analysis for source-level CFGs.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/Analyses/LiveVariables.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Analysis/Analyses/PostOrderCFGView.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/PriorityQueue.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <vector>
 

cfe/trunk/lib/Analysis/ReachableCode.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/Analyses/ReachableCode.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/AST/StmtCXX.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/SmallVector.h"
 
 using namespace clang;
 

cfe/trunk/lib/Analysis/ThreadSafety.cpp

 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Analysis/Analyses/PostOrderCFGView.h"
 #include "clang/Analysis/Analyses/ThreadSafetyCommon.h"
 #include "clang/Analysis/Analyses/ThreadSafetyLogical.h"
 #include "clang/Analysis/Analyses/ThreadSafetyTIL.h"
 #include "clang/Analysis/Analyses/ThreadSafetyTraverse.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/CFGStmtMap.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/ImmutableMap.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SmallVector.h"

cfe/trunk/lib/Analysis/ThreadSafetyCommon.cpp

 #include "clang/Analysis/Analyses/ThreadSafetyCommon.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/Analysis/Analyses/ThreadSafetyTIL.h"
 #include "clang/Analysis/Analyses/ThreadSafetyTraverse.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/StringRef.h"
 #include <algorithm>
 
 using namespace clang;
 using namespace threadSafety;

cfe/trunk/lib/Analysis/UninitializedValues.cpp

 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Analysis/Analyses/PostOrderCFGView.h"
 #include "clang/Analysis/Analyses/UninitializedValues.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/DomainSpecific/ObjCNoReturn.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PackedVector.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/SaveAndRestore.h"

cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp

 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Analysis/Analyses/CFGReachabilityAnalysis.h"
 #include "clang/Analysis/Analyses/Consumed.h"
 #include "clang/Analysis/Analyses/ReachableCode.h"
 #include "clang/Analysis/Analyses/ThreadSafety.h"
 #include "clang/Analysis/Analyses/UninitializedValues.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/CFGStmtMap.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/BitVector.h"

cfe/trunk/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp

 //  - Identifies erroneous patterns in the last argument to strncat - the number
 //    of bytes to copy.
 //
 //===----------------------------------------------------------------------===//
 #include "ClangSACheckers.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/StmtVisitor.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TypeTraits.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"

cfe/trunk/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp

 //==- CheckSecuritySyntaxOnly.cpp - Basic security checks --------*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines a set of flow-insensitive security checks.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangSACheckers.h"
 #include "clang/AST/StmtVisitor.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 

cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp

 //== ObjCContainersASTChecker.cpp - CoreFoundation containers API *- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // An AST checker that looks for common pitfalls when using 'CFArray',
 // 'CFDictionary', 'CFSet' APIs.
 //
 //===----------------------------------------------------------------------===//
 #include "ClangSACheckers.h"
 #include "clang/AST/StmtVisitor.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;

cfe/trunk/lib/StaticAnalyzer/Core/Environment.cpp

 //== Environment.cpp - Map from Stmt* to Locations/Values -------*- C++ -*--==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defined the Environment and EnvironmentManager classes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace ento;
 
 static const Expr *ignoreTransparentExprs(const Expr *E) {

cfe/trunk/lib/StaticAnalyzer/Core/MemRegion.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/RecordLayout.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/Support/BumpVector.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace ento;
 

cfe/trunk/lib/StaticAnalyzer/Core/PrettyStackTraceLocationContext.h

 //==- PrettyStackTraceLocationContext.h - show analysis backtrace --*- C++ -*-//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_STATICANALYZER_CORE_PRETTYSTACKTRACELOCATIONCONTEXT_H
 #define LLVM_CLANG_LIB_STATICANALYZER_CORE_PRETTYSTACKTRACELOCATIONCONTEXT_H
 
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 
 namespace clang {
 namespace ento {
 
 /// While alive, includes the current analysis stack in a crash trace.
 ///
 /// Example:
 /// \code

cfe/trunk/lib/StaticAnalyzer/Core/RegionStore.cpp

 // Parameter pointers are assumed with no aliasing. Pointee objects of
 // parameters are created lazily.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/Attr.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/Analysis/Analyses/LiveVariables.h"
-#include "clang/Analysis/AnalysisContext.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h"
 #include "llvm/ADT/ImmutableMap.h"