From 62a56f39b7c5587a1b2144880500689bea5f32e4 Mon Sep 17 00:00:00 2001 From: David Blaikie Date: Thu, 17 Jul 2014 22:34:12 +0000 Subject: [PATCH] Revert "unique_ptr-ify ownership of ASTConsumers" This reverts commit r213307. Reverting to have some on-list discussion/confirmation about the ongoing direction of smart pointer usage in the LLVM project. llvm-svn: 213325 --- .../PrintFunctionNames/PrintFunctionNames.cpp | 5 +- clang/include/clang/ARCMigrate/ARCMTActions.h | 8 +- clang/include/clang/ASTMatchers/ASTMatchFinder.h | 2 +- clang/include/clang/CodeGen/CodeGenAction.h | 4 +- clang/include/clang/Frontend/ASTConsumers.h | 14 +-- clang/include/clang/Frontend/CompilerInstance.h | 5 +- clang/include/clang/Frontend/FrontendAction.h | 23 +++-- clang/include/clang/Frontend/FrontendActions.h | 51 +++++----- clang/include/clang/Frontend/MultiplexConsumer.h | 4 +- .../include/clang/Rewrite/Frontend/ASTConsumers.h | 28 +++--- .../clang/Rewrite/Frontend/FrontendActions.h | 12 +-- .../StaticAnalyzer/Frontend/AnalysisConsumer.h | 7 +- .../StaticAnalyzer/Frontend/FrontendActions.h | 4 +- clang/include/clang/Tooling/Tooling.h | 5 +- clang/lib/ARCMigrate/ARCMT.cpp | 6 +- clang/lib/ARCMigrate/ObjCMT.cpp | 38 ++++--- clang/lib/ASTMatchers/ASTMatchFinder.cpp | 4 +- clang/lib/CodeGen/CodeGenAction.cpp | 15 ++- clang/lib/Frontend/ASTConsumers.cpp | 25 ++--- clang/lib/Frontend/ASTMerge.cpp | 4 +- clang/lib/Frontend/ASTUnit.cpp | 32 +++--- clang/lib/Frontend/ChainedIncludesSource.cpp | 8 +- clang/lib/Frontend/CompilerInstance.cpp | 4 +- clang/lib/Frontend/FrontendAction.cpp | 38 ++++--- clang/lib/Frontend/FrontendActions.cpp | 63 ++++++------ clang/lib/Frontend/MultiplexConsumer.cpp | 111 +++++++++++---------- clang/lib/Frontend/Rewrite/FrontendActions.cpp | 14 +-- clang/lib/Frontend/Rewrite/HTMLPrint.cpp | 11 +- clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp | 13 ++- clang/lib/Frontend/Rewrite/RewriteObjC.cpp | 12 +-- .../StaticAnalyzer/Frontend/AnalysisConsumer.cpp | 4 +- .../StaticAnalyzer/Frontend/FrontendActions.cpp | 4 +- clang/tools/clang-check/ClangCheck.cpp | 5 +- clang/tools/libclang/Indexing.cpp | 11 +- clang/unittests/AST/EvaluateAsRValueTest.cpp | 7 +- clang/unittests/AST/ExternalASTSourceTest.cpp | 6 +- clang/unittests/AST/NamedDeclPrinterTest.cpp | 4 +- clang/unittests/Frontend/FrontendActionTest.cpp | 6 +- clang/unittests/Sema/ExternalSemaSourceTest.cpp | 4 +- clang/unittests/Tooling/RefactoringTest.cpp | 7 +- clang/unittests/Tooling/TestVisitor.h | 6 +- clang/unittests/Tooling/ToolingTest.cpp | 50 ++++------ 42 files changed, 338 insertions(+), 346 deletions(-) diff --git a/clang/examples/PrintFunctionNames/PrintFunctionNames.cpp b/clang/examples/PrintFunctionNames/PrintFunctionNames.cpp index e8a361d..3f18cd4 100644 --- a/clang/examples/PrintFunctionNames/PrintFunctionNames.cpp +++ b/clang/examples/PrintFunctionNames/PrintFunctionNames.cpp @@ -36,9 +36,8 @@ public: class PrintFunctionNamesAction : public PluginASTAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - llvm::StringRef) { - return llvm::make_unique(); + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, llvm::StringRef) { + return new PrintFunctionsConsumer(); } bool ParseArgs(const CompilerInstance &CI, diff --git a/clang/include/clang/ARCMigrate/ARCMTActions.h b/clang/include/clang/ARCMigrate/ARCMTActions.h index 0f45ccc..b3e74b9 100644 --- a/clang/include/clang/ARCMigrate/ARCMTActions.h +++ b/clang/include/clang/ARCMigrate/ARCMTActions.h @@ -37,8 +37,8 @@ class MigrateSourceAction : public ASTFrontendAction { FileRemapper Remapper; protected: bool BeginInvocation(CompilerInstance &CI) override; - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; }; class MigrateAction : public WrapperFrontendAction { @@ -65,8 +65,8 @@ public: unsigned migrateAction); protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; bool BeginInvocation(CompilerInstance &CI) override; }; diff --git a/clang/include/clang/ASTMatchers/ASTMatchFinder.h b/clang/include/clang/ASTMatchers/ASTMatchFinder.h index 9e8b7b5..8af0546 100644 --- a/clang/include/clang/ASTMatchers/ASTMatchFinder.h +++ b/clang/include/clang/ASTMatchers/ASTMatchFinder.h @@ -148,7 +148,7 @@ public: MatchCallback *Action); /// \brief Creates a clang ASTConsumer that finds all matches. - std::unique_ptr newASTConsumer(); + clang::ASTConsumer *newASTConsumer(); /// \brief Calls the registered callbacks on all matches on the given \p Node. /// diff --git a/clang/include/clang/CodeGen/CodeGenAction.h b/clang/include/clang/CodeGen/CodeGenAction.h index 4619b48..37819c7 100644 --- a/clang/include/clang/CodeGen/CodeGenAction.h +++ b/clang/include/clang/CodeGen/CodeGenAction.h @@ -37,8 +37,8 @@ protected: bool hasIRSupport() const override; - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; void ExecuteAction() override; diff --git a/clang/include/clang/Frontend/ASTConsumers.h b/clang/include/clang/Frontend/ASTConsumers.h index 4afcb0c..366c499 100644 --- a/clang/include/clang/Frontend/ASTConsumers.h +++ b/clang/include/clang/Frontend/ASTConsumers.h @@ -16,8 +16,6 @@ #include "clang/Basic/LLVM.h" -#include - namespace clang { class ASTConsumer; @@ -32,26 +30,24 @@ class TargetOptions; // original C code. The output is intended to be in a format such that // clang could re-parse the output back into the same AST, but the // implementation is still incomplete. -std::unique_ptr CreateASTPrinter(raw_ostream *OS, - StringRef FilterString); +ASTConsumer *CreateASTPrinter(raw_ostream *OS, StringRef FilterString); // AST dumper: dumps the raw AST in human-readable form to stderr; this is // intended for debugging. -std::unique_ptr CreateASTDumper(StringRef FilterString, - bool DumpLookups = false); +ASTConsumer *CreateASTDumper(StringRef FilterString, bool DumpLookups = false); // AST Decl node lister: prints qualified names of all filterable AST Decl // nodes. -std::unique_ptr CreateASTDeclNodeLister(); +ASTConsumer *CreateASTDeclNodeLister(); // Graphical AST viewer: for each function definition, creates a graph of // the AST and displays it with the graph viewer "dotty". Also outputs // function declarations to stderr. -std::unique_ptr CreateASTViewer(); +ASTConsumer *CreateASTViewer(); // DeclContext printer: prints out the DeclContext tree in human-readable form // to stderr; this is intended for debugging. -std::unique_ptr CreateDeclContextPrinter(); +ASTConsumer *CreateDeclContextPrinter(); } // end clang namespace diff --git a/clang/include/clang/Frontend/CompilerInstance.h b/clang/include/clang/Frontend/CompilerInstance.h index 9082d57..44e9102 100644 --- a/clang/include/clang/Frontend/CompilerInstance.h +++ b/clang/include/clang/Frontend/CompilerInstance.h @@ -14,7 +14,6 @@ #include "clang/Basic/SourceManager.h" #include "clang/Frontend/CompilerInvocation.h" #include "clang/Frontend/Utils.h" -#include "clang/AST/ASTConsumer.h" #include "clang/Lex/ModuleLoader.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" @@ -444,11 +443,11 @@ public: /// takeASTConsumer - Remove the current AST consumer and give ownership to /// the caller. - std::unique_ptr takeASTConsumer() { return std::move(Consumer); } + ASTConsumer *takeASTConsumer() { return Consumer.release(); } /// setASTConsumer - Replace the current AST consumer; the compiler instance /// takes ownership of \p Value. - void setASTConsumer(std::unique_ptr Value); + void setASTConsumer(ASTConsumer *Value); /// } /// @name Semantic analysis diff --git a/clang/include/clang/Frontend/FrontendAction.h b/clang/include/clang/Frontend/FrontendAction.h index 990a293..9ac9d28 100644 --- a/clang/include/clang/Frontend/FrontendAction.h +++ b/clang/include/clang/Frontend/FrontendAction.h @@ -41,8 +41,8 @@ class FrontendAction { friend class WrapperFrontendAction; private: - std::unique_ptr CreateWrappedASTConsumer(CompilerInstance &CI, - StringRef InFile); + ASTConsumer* CreateWrappedASTConsumer(CompilerInstance &CI, + StringRef InFile); protected: /// @name Implementation Action Interface @@ -61,8 +61,8 @@ protected: /// getCurrentFile(). /// /// \return The new AST consumer, or null on failure. - virtual std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) = 0; + virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) = 0; /// \brief Callback before starting processing a single input, giving the /// opportunity to modify the CompilerInvocation or do some other action @@ -227,10 +227,11 @@ public: class PluginASTAction : public ASTFrontendAction { virtual void anchor(); -public: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override = 0; +protected: + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override = 0; +public: /// \brief Parse the given plugin command line arguments. /// /// \param CI - The compiler instance, for use in reporting diagnostics. @@ -246,8 +247,8 @@ class PreprocessorFrontendAction : public FrontendAction { protected: /// \brief Provide a default implementation which returns aborts; /// this method should never be called by FrontendAction clients. - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; public: bool usesPreprocessorOnly() const override { return true; } @@ -263,8 +264,8 @@ class WrapperFrontendAction : public FrontendAction { std::unique_ptr WrappedAction; protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; bool BeginInvocation(CompilerInstance &CI) override; bool BeginSourceFileAction(CompilerInstance &CI, StringRef Filename) override; void ExecuteAction() override; diff --git a/clang/include/clang/Frontend/FrontendActions.h b/clang/include/clang/Frontend/FrontendActions.h index 850f87c..84cc82c 100644 --- a/clang/include/clang/Frontend/FrontendActions.h +++ b/clang/include/clang/Frontend/FrontendActions.h @@ -26,8 +26,8 @@ class FileEntry; class InitOnlyAction : public FrontendAction { void ExecuteAction() override; - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; public: // Don't claim to only use the preprocessor, we want to follow the AST path, @@ -41,38 +41,38 @@ public: class ASTPrintAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; }; class ASTDumpAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; }; class ASTDeclListAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; }; class ASTViewAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; }; class DeclContextPrintAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; }; class GeneratePCHAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; TranslationUnitKind getTranslationUnitKind() override { return TU_Prefix; @@ -98,8 +98,8 @@ class GenerateModuleAction : public ASTFrontendAction { bool IsSystem; protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; TranslationUnitKind getTranslationUnitKind() override { return TU_Module; @@ -128,8 +128,8 @@ public: class SyntaxOnlyAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; public: bool hasCodeCompletionSupport() const override { return true; } @@ -139,8 +139,8 @@ public: /// basic debugging and discovery. class DumpModuleInfoAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; void ExecuteAction() override; public: @@ -152,8 +152,8 @@ public: class VerifyPCHAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; void ExecuteAction() override; @@ -177,8 +177,8 @@ class ASTMergeAction : public FrontendAction { std::vector ASTFiles; protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; bool BeginSourceFileAction(CompilerInstance &CI, StringRef Filename) override; @@ -200,8 +200,7 @@ public: class PrintPreambleAction : public FrontendAction { protected: void ExecuteAction() override; - std::unique_ptr CreateASTConsumer(CompilerInstance &, - StringRef) override { + ASTConsumer *CreateASTConsumer(CompilerInstance &, StringRef) override { return nullptr; } diff --git a/clang/include/clang/Frontend/MultiplexConsumer.h b/clang/include/clang/Frontend/MultiplexConsumer.h index 8c414e7..4d31104 100644 --- a/clang/include/clang/Frontend/MultiplexConsumer.h +++ b/clang/include/clang/Frontend/MultiplexConsumer.h @@ -29,7 +29,7 @@ class MultiplexASTDeserializationListener; class MultiplexConsumer : public SemaConsumer { public: // Takes ownership of the pointers in C. - MultiplexConsumer(std::vector> C); + MultiplexConsumer(ArrayRef C); ~MultiplexConsumer(); // ASTConsumer @@ -59,7 +59,7 @@ public: void ForgetSema() override; private: - std::vector> Consumers; // Owns these. + std::vector Consumers; // Owns these. std::unique_ptr MutationListener; std::unique_ptr DeserializationListener; }; diff --git a/clang/include/clang/Rewrite/Frontend/ASTConsumers.h b/clang/include/clang/Rewrite/Frontend/ASTConsumers.h index 9ea96cd..584af3f 100644 --- a/clang/include/clang/Rewrite/Frontend/ASTConsumers.h +++ b/clang/include/clang/Rewrite/Frontend/ASTConsumers.h @@ -15,8 +15,6 @@ #define REWRITE_ASTCONSUMERS_H #include "clang/Basic/LLVM.h" - -#include #include namespace clang { @@ -28,21 +26,23 @@ class Preprocessor; // ObjC rewriter: attempts to rewrite ObjC constructs into pure C code. // This is considered experimental, and only works with Apple's ObjC runtime. -std::unique_ptr -CreateObjCRewriter(const std::string &InFile, raw_ostream *OS, - DiagnosticsEngine &Diags, const LangOptions &LOpts, - bool SilenceRewriteMacroWarning); -std::unique_ptr -CreateModernObjCRewriter(const std::string &InFile, raw_ostream *OS, - DiagnosticsEngine &Diags, const LangOptions &LOpts, - bool SilenceRewriteMacroWarning, bool LineInfo); +ASTConsumer *CreateObjCRewriter(const std::string &InFile, + raw_ostream *OS, + DiagnosticsEngine &Diags, + const LangOptions &LOpts, + bool SilenceRewriteMacroWarning); +ASTConsumer *CreateModernObjCRewriter(const std::string &InFile, + raw_ostream *OS, + DiagnosticsEngine &Diags, + const LangOptions &LOpts, + bool SilenceRewriteMacroWarning, + bool LineInfo); /// CreateHTMLPrinter - Create an AST consumer which rewrites source code to /// HTML with syntax highlighting suitable for viewing in a web-browser. -std::unique_ptr CreateHTMLPrinter(raw_ostream *OS, - Preprocessor &PP, - bool SyntaxHighlight = true, - bool HighlightMacros = true); +ASTConsumer *CreateHTMLPrinter(raw_ostream *OS, Preprocessor &PP, + bool SyntaxHighlight = true, + bool HighlightMacros = true); } // end clang namespace diff --git a/clang/include/clang/Rewrite/Frontend/FrontendActions.h b/clang/include/clang/Rewrite/Frontend/FrontendActions.h index eca3650..fc79270 100644 --- a/clang/include/clang/Rewrite/Frontend/FrontendActions.h +++ b/clang/include/clang/Rewrite/Frontend/FrontendActions.h @@ -22,8 +22,8 @@ class FixItOptions; class HTMLPrintAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; }; class FixItAction : public ASTFrontendAction { @@ -31,8 +31,8 @@ protected: std::unique_ptr Rewriter; std::unique_ptr FixItOpts; - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; bool BeginSourceFileAction(CompilerInstance &CI, StringRef Filename) override; @@ -59,8 +59,8 @@ protected: class RewriteObjCAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; }; class RewriteMacrosAction : public PreprocessorFrontendAction { diff --git a/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h b/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h index 6067dfd..30e5d3d 100644 --- a/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h +++ b/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h @@ -37,9 +37,10 @@ public: /// CreateAnalysisConsumer - Creates an ASTConsumer to run various code /// analysis passes. (The set of analyses run is controlled by command-line /// options.) -std::unique_ptr -CreateAnalysisConsumer(const Preprocessor &pp, const std::string &output, - AnalyzerOptionsRef opts, ArrayRef plugins); +AnalysisASTConsumer *CreateAnalysisConsumer(const Preprocessor &pp, + const std::string &output, + AnalyzerOptionsRef opts, + ArrayRef plugins); } // end GR namespace diff --git a/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h b/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h index 921d67e..21ecfc2 100644 --- a/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h +++ b/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h @@ -22,8 +22,8 @@ namespace ento { class AnalysisAction : public ASTFrontendAction { protected: - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; }; void printCheckerHelp(raw_ostream &OS, ArrayRef plugins); diff --git a/clang/include/clang/Tooling/Tooling.h b/clang/include/clang/Tooling/Tooling.h index fb9178a..769acd3 100644 --- a/clang/include/clang/Tooling/Tooling.h +++ b/clang/include/clang/Tooling/Tooling.h @@ -30,7 +30,6 @@ #ifndef LLVM_CLANG_TOOLING_TOOLING_H #define LLVM_CLANG_TOOLING_TOOLING_H -#include "clang/AST/ASTConsumer.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/LLVM.h" @@ -336,8 +335,8 @@ inline std::unique_ptr newFrontendActionFactory( SourceFileCallbacks *Callbacks) : ConsumerFactory(ConsumerFactory), Callbacks(Callbacks) {} - std::unique_ptr - CreateASTConsumer(clang::CompilerInstance &, StringRef) override { + clang::ASTConsumer *CreateASTConsumer(clang::CompilerInstance &, + StringRef) override { return ConsumerFactory->newASTConsumer(); } diff --git a/clang/lib/ARCMigrate/ARCMT.cpp b/clang/lib/ARCMigrate/ARCMT.cpp index 524c8d9..8a13b2e 100644 --- a/clang/lib/ARCMigrate/ARCMT.cpp +++ b/clang/lib/ARCMigrate/ARCMT.cpp @@ -446,11 +446,11 @@ public: ARCMTMacroTrackerAction(std::vector &ARCMTMacroLocs) : ARCMTMacroLocs(ARCMTMacroLocs) { } - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override { + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override { CI.getPreprocessor().addPPCallbacks( new ARCMTMacroTrackerPPCallbacks(ARCMTMacroLocs)); - return llvm::make_unique(); + return new ASTConsumer(); } }; diff --git a/clang/lib/ARCMigrate/ObjCMT.cpp b/clang/lib/ARCMigrate/ObjCMT.cpp index 565381c4..1a2055e 100644 --- a/clang/lib/ARCMigrate/ObjCMT.cpp +++ b/clang/lib/ARCMigrate/ObjCMT.cpp @@ -185,17 +185,23 @@ ObjCMigrateAction::ObjCMigrateAction(FrontendAction *WrappedAction, MigrateDir = "."; // user current directory if none is given. } -std::unique_ptr -ObjCMigrateAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *ObjCMigrateAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { PPConditionalDirectiveRecord * PPRec = new PPConditionalDirectiveRecord(CompInst->getSourceManager()); CompInst->getPreprocessor().addPPCallbacks(PPRec); - std::vector> Consumers; - Consumers.push_back(WrapperFrontendAction::CreateASTConsumer(CI, InFile)); - Consumers.push_back(llvm::make_unique( - MigrateDir, ObjCMigAction, Remapper, CompInst->getFileManager(), PPRec, - CompInst->getPreprocessor(), false, ArrayRef())); - return llvm::make_unique(std::move(Consumers)); + ASTConsumer * + WrappedConsumer = WrapperFrontendAction::CreateASTConsumer(CI, InFile); + ASTConsumer *MTConsumer = new ObjCMigrateASTConsumer(MigrateDir, + ObjCMigAction, + Remapper, + CompInst->getFileManager(), + PPRec, + CompInst->getPreprocessor(), + false, + ArrayRef()); + ASTConsumer *Consumers[] = { MTConsumer, WrappedConsumer }; + return new MultiplexConsumer(Consumers); } bool ObjCMigrateAction::BeginInvocation(CompilerInstance &CI) { @@ -1859,8 +1865,8 @@ static std::vector getWhiteListFilenames(StringRef DirPath) { return Filenames; } -std::unique_ptr -MigrateSourceAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *MigrateSourceAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { PPConditionalDirectiveRecord * PPRec = new PPConditionalDirectiveRecord(CI.getSourceManager()); unsigned ObjCMTAction = CI.getFrontendOpts().ObjCMTAction; @@ -1877,10 +1883,14 @@ MigrateSourceAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { CI.getPreprocessor().addPPCallbacks(PPRec); std::vector WhiteList = getWhiteListFilenames(CI.getFrontendOpts().ObjCMTWhiteListPath); - return llvm::make_unique( - CI.getFrontendOpts().OutputFile, ObjCMTAction, Remapper, - CI.getFileManager(), PPRec, CI.getPreprocessor(), - /*isOutputFile=*/true, WhiteList); + return new ObjCMigrateASTConsumer(CI.getFrontendOpts().OutputFile, + ObjCMTAction, + Remapper, + CI.getFileManager(), + PPRec, + CI.getPreprocessor(), + /*isOutputFile=*/true, + WhiteList); } namespace { diff --git a/clang/lib/ASTMatchers/ASTMatchFinder.cpp b/clang/lib/ASTMatchers/ASTMatchFinder.cpp index 50531f4..23708e2 100644 --- a/clang/lib/ASTMatchers/ASTMatchFinder.cpp +++ b/clang/lib/ASTMatchers/ASTMatchFinder.cpp @@ -823,8 +823,8 @@ bool MatchFinder::addDynamicMatcher(const internal::DynTypedMatcher &NodeMatch, return false; } -std::unique_ptr MatchFinder::newASTConsumer() { - return llvm::make_unique(this, ParsingDone); +ASTConsumer *MatchFinder::newASTConsumer() { + return new internal::MatchASTConsumer(this, ParsingDone); } void MatchFinder::match(const clang::ast_type_traits::DynTypedNode &Node, diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp index 0c94949..559c2ef 100644 --- a/clang/lib/CodeGen/CodeGenAction.cpp +++ b/clang/lib/CodeGen/CodeGenAction.cpp @@ -590,8 +590,8 @@ static raw_ostream *GetOutputStream(CompilerInstance &CI, llvm_unreachable("Invalid action!"); } -std::unique_ptr -CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *CodeGenAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { BackendAction BA = static_cast(Act); std::unique_ptr OS(GetOutputStream(CI, InFile, BA)); if (BA != Backend_EmitNothing && !OS) @@ -623,12 +623,11 @@ CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { LinkModuleToUse = ModuleOrErr.get(); } - auto Result = llvm::make_unique( - BA, CI.getDiagnostics(), CI.getCodeGenOpts(), CI.getTargetOpts(), - CI.getLangOpts(), (bool)CI.getFrontendOpts().ShowTimers, InFile, - LinkModuleToUse, OS.release(), *VMContext); - BEConsumer = Result.get(); - return std::move(Result); + BEConsumer = new BackendConsumer(BA, CI.getDiagnostics(), CI.getCodeGenOpts(), + CI.getTargetOpts(), CI.getLangOpts(), + CI.getFrontendOpts().ShowTimers, InFile, + LinkModuleToUse, OS.release(), *VMContext); + return BEConsumer; } void CodeGenAction::ExecuteAction() { diff --git a/clang/lib/Frontend/ASTConsumers.cpp b/clang/lib/Frontend/ASTConsumers.cpp index d836ed4..54a6d47 100644 --- a/clang/lib/Frontend/ASTConsumers.cpp +++ b/clang/lib/Frontend/ASTConsumers.cpp @@ -118,19 +118,17 @@ namespace { }; } // end anonymous namespace -std::unique_ptr clang::CreateASTPrinter(raw_ostream *Out, - StringRef FilterString) { - return llvm::make_unique(Out, /*Dump=*/false, FilterString); +ASTConsumer *clang::CreateASTPrinter(raw_ostream *Out, + StringRef FilterString) { + return new ASTPrinter(Out, /*Dump=*/ false, FilterString); } -std::unique_ptr clang::CreateASTDumper(StringRef FilterString, - bool DumpLookups) { - return llvm::make_unique(nullptr, /*Dump=*/true, FilterString, - DumpLookups); +ASTConsumer *clang::CreateASTDumper(StringRef FilterString, bool DumpLookups) { + return new ASTPrinter(nullptr, /*Dump=*/true, FilterString, DumpLookups); } -std::unique_ptr clang::CreateASTDeclNodeLister() { - return llvm::make_unique(nullptr); +ASTConsumer *clang::CreateASTDeclNodeLister() { + return new ASTDeclNodeLister(nullptr); } //===----------------------------------------------------------------------===// @@ -166,9 +164,8 @@ void ASTViewer::HandleTopLevelSingleDecl(Decl *D) { } } -std::unique_ptr clang::CreateASTViewer() { - return llvm::make_unique(); -} + +ASTConsumer *clang::CreateASTViewer() { return new ASTViewer(); } //===----------------------------------------------------------------------===// /// DeclContextPrinter - Decl and DeclContext Visualization @@ -478,6 +475,6 @@ void DeclContextPrinter::PrintDeclContext(const DeclContext* DC, } } } -std::unique_ptr clang::CreateDeclContextPrinter() { - return llvm::make_unique(); +ASTConsumer *clang::CreateDeclContextPrinter() { + return new DeclContextPrinter(); } diff --git a/clang/lib/Frontend/ASTMerge.cpp b/clang/lib/Frontend/ASTMerge.cpp index 57ccd39..ff6434c 100644 --- a/clang/lib/Frontend/ASTMerge.cpp +++ b/clang/lib/Frontend/ASTMerge.cpp @@ -16,8 +16,8 @@ using namespace clang; -std::unique_ptr -ASTMergeAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *ASTMergeAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { return AdaptedAction->CreateASTConsumer(CI, InFile); } diff --git a/clang/lib/Frontend/ASTUnit.cpp b/clang/lib/Frontend/ASTUnit.cpp index 0497a5e9..fc44d9f 100644 --- a/clang/lib/Frontend/ASTUnit.cpp +++ b/clang/lib/Frontend/ASTUnit.cpp @@ -891,12 +891,12 @@ class TopLevelDeclTrackerAction : public ASTFrontendAction { public: ASTUnit &Unit; - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override { + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override { CI.getPreprocessor().addPPCallbacks( new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue())); - return llvm::make_unique( - Unit, Unit.getCurrentTopLevelHashValue()); + return new TopLevelDeclTrackerConsumer(Unit, + Unit.getCurrentTopLevelHashValue()); } public: @@ -916,8 +916,8 @@ public: explicit PrecompilePreambleAction(ASTUnit &Unit) : Unit(Unit), HasEmittedPreamblePCH(false) {} - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override; + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override; bool hasEmittedPreamblePCH() const { return HasEmittedPreamblePCH; } void setHasEmittedPreamblePCH() { HasEmittedPreamblePCH = true; } bool shouldEraseOutputFiles() override { return !hasEmittedPreamblePCH(); } @@ -979,9 +979,8 @@ public: } -std::unique_ptr -PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) { +ASTConsumer *PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { std::string Sysroot; std::string OutputFile; raw_ostream *OS = nullptr; @@ -994,8 +993,8 @@ PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI, CI.getPreprocessor().addPPCallbacks(new MacroDefinitionTrackerPPCallbacks( Unit.getCurrentTopLevelHashValue())); - return llvm::make_unique( - Unit, this, CI.getPreprocessor(), Sysroot, OS); + return new PrecompilePreambleConsumer(Unit, this, CI.getPreprocessor(), + Sysroot, OS); } static bool isNonDriverDiag(const StoredDiagnostic &StoredDiag) { @@ -1690,7 +1689,7 @@ void ASTUnit::transferASTDataFromCompilerInstance(CompilerInstance &CI) { assert(CI.hasInvocation() && "missing invocation"); LangOpts = CI.getInvocation().LangOpts; TheSema.reset(CI.takeSema()); - Consumer = CI.takeASTConsumer(); + Consumer.reset(CI.takeASTConsumer()); if (CI.hasASTContext()) Ctx = &CI.getASTContext(); if (CI.hasPreprocessor()) @@ -1864,13 +1863,12 @@ ASTUnit *ASTUnit::LoadFromCompilerInvocationAction( if (Persistent && !TrackerAct) { Clang->getPreprocessor().addPPCallbacks( new MacroDefinitionTrackerPPCallbacks(AST->getCurrentTopLevelHashValue())); - std::vector> Consumers; + std::vector Consumers; if (Clang->hasASTConsumer()) Consumers.push_back(Clang->takeASTConsumer()); - Consumers.push_back(llvm::make_unique( - *AST, AST->getCurrentTopLevelHashValue())); - Clang->setASTConsumer( - llvm::make_unique(std::move(Consumers))); + Consumers.push_back(new TopLevelDeclTrackerConsumer(*AST, + AST->getCurrentTopLevelHashValue())); + Clang->setASTConsumer(new MultiplexConsumer(Consumers)); } if (!Act->Execute()) { AST->transferASTDataFromCompilerInstance(*Clang); diff --git a/clang/lib/Frontend/ChainedIncludesSource.cpp b/clang/lib/Frontend/ChainedIncludesSource.cpp index 6b14e25..e6e73ac 100644 --- a/clang/lib/Frontend/ChainedIncludesSource.cpp +++ b/clang/lib/Frontend/ChainedIncludesSource.cpp @@ -158,12 +158,12 @@ IntrusiveRefCntPtr clang::createChainedIncludesSource( SmallVector serialAST; llvm::raw_svector_ostream OS(serialAST); - auto consumer = - llvm::make_unique(Clang->getPreprocessor(), "-", nullptr, - /*isysroot=*/"", &OS); + std::unique_ptr consumer; + consumer.reset(new PCHGenerator(Clang->getPreprocessor(), "-", nullptr, + /*isysroot=*/"", &OS)); Clang->getASTContext().setASTMutationListener( consumer->GetASTMutationListener()); - Clang->setASTConsumer(std::move(consumer)); + Clang->setASTConsumer(consumer.release()); Clang->createSema(TU_Prefix, nullptr); if (firstInclude) { diff --git a/clang/lib/Frontend/CompilerInstance.cpp b/clang/lib/Frontend/CompilerInstance.cpp index 7e4ffb1..7cea9e4 100644 --- a/clang/lib/Frontend/CompilerInstance.cpp +++ b/clang/lib/Frontend/CompilerInstance.cpp @@ -101,8 +101,8 @@ void CompilerInstance::setSema(Sema *S) { TheSema.reset(S); } -void CompilerInstance::setASTConsumer(std::unique_ptr Value) { - Consumer = std::move(Value); +void CompilerInstance::setASTConsumer(ASTConsumer *Value) { + Consumer.reset(Value); } void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) { diff --git a/clang/lib/Frontend/FrontendAction.cpp b/clang/lib/Frontend/FrontendAction.cpp index 3535276..7910179 100644 --- a/clang/lib/Frontend/FrontendAction.cpp +++ b/clang/lib/Frontend/FrontendAction.cpp @@ -134,10 +134,9 @@ void FrontendAction::setCurrentInput(const FrontendInputFile &CurrentInput, CurrentASTUnit.reset(AST); } -std::unique_ptr -FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI, - StringRef InFile) { - std::unique_ptr Consumer = CreateASTConsumer(CI, InFile); +ASTConsumer* FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI, + StringRef InFile) { + ASTConsumer* Consumer = CreateASTConsumer(CI, InFile); if (!Consumer) return nullptr; @@ -146,8 +145,7 @@ FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI, // Make sure the non-plugin consumer is first, so that plugins can't // modifiy the AST. - std::vector> Consumers; - Consumers.push_back(std::move(Consumer)); + std::vector Consumers(1, Consumer); for (size_t i = 0, e = CI.getFrontendOpts().AddPluginActions.size(); i != e; ++i) { @@ -157,15 +155,16 @@ FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI, it = FrontendPluginRegistry::begin(), ie = FrontendPluginRegistry::end(); it != ie; ++it) { - if (it->getName() != CI.getFrontendOpts().AddPluginActions[i]) - continue; - std::unique_ptr P = it->instantiate(); - if (P->ParseArgs(CI, CI.getFrontendOpts().AddPluginArgs[i])) - Consumers.push_back(P->CreateASTConsumer(CI, InFile)); + if (it->getName() == CI.getFrontendOpts().AddPluginActions[i]) { + std::unique_ptr P(it->instantiate()); + FrontendAction* c = P.get(); + if (P->ParseArgs(CI, CI.getFrontendOpts().AddPluginArgs[i])) + Consumers.push_back(c->CreateASTConsumer(CI, InFile)); + } } } - return llvm::make_unique(std::move(Consumers)); + return new MultiplexConsumer(Consumers); } bool FrontendAction::BeginSourceFile(CompilerInstance &CI, @@ -308,8 +307,8 @@ bool FrontendAction::BeginSourceFile(CompilerInstance &CI, if (!usesPreprocessorOnly()) { CI.createASTContext(); - std::unique_ptr Consumer = - CreateWrappedASTConsumer(CI, InputFile); + std::unique_ptr Consumer( + CreateWrappedASTConsumer(CI, InputFile)); if (!Consumer) goto failure; @@ -350,7 +349,7 @@ bool FrontendAction::BeginSourceFile(CompilerInstance &CI, goto failure; } - CI.setASTConsumer(std::move(Consumer)); + CI.setASTConsumer(Consumer.release()); if (!CI.hasASTConsumer()) goto failure; } @@ -445,7 +444,7 @@ void FrontendAction::EndSourceFile() { CI.resetAndLeakSema(); CI.resetAndLeakASTContext(); } - BuryPointer(CI.takeASTConsumer().get()); + BuryPointer(CI.takeASTConsumer()); } else { if (!isCurrentFileAST()) { CI.setSema(nullptr); @@ -517,15 +516,14 @@ void ASTFrontendAction::ExecuteAction() { void PluginASTAction::anchor() { } -std::unique_ptr +ASTConsumer * PreprocessorFrontendAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!"); } -std::unique_ptr -WrapperFrontendAction::CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) { +ASTConsumer *WrapperFrontendAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { return WrappedAction->CreateASTConsumer(CI, InFile); } bool WrapperFrontendAction::BeginInvocation(CompilerInstance &CI) { diff --git a/clang/lib/Frontend/FrontendActions.cpp b/clang/lib/Frontend/FrontendActions.cpp index ba16376..ef6bfec 100644 --- a/clang/lib/Frontend/FrontendActions.cpp +++ b/clang/lib/Frontend/FrontendActions.cpp @@ -33,9 +33,9 @@ using namespace clang; // Custom Actions //===----------------------------------------------------------------------===// -std::unique_ptr -InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { - return llvm::make_unique(); +ASTConsumer *InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { + return new ASTConsumer(); } void InitOnlyAction::ExecuteAction() { @@ -45,37 +45,36 @@ void InitOnlyAction::ExecuteAction() { // AST Consumer Actions //===----------------------------------------------------------------------===// -std::unique_ptr -ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile)) return CreateASTPrinter(OS, CI.getFrontendOpts().ASTDumpFilter); return nullptr; } -std::unique_ptr -ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { return CreateASTDumper(CI.getFrontendOpts().ASTDumpFilter, CI.getFrontendOpts().ASTDumpLookups); } -std::unique_ptr -ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { return CreateASTDeclNodeLister(); } -std::unique_ptr -ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *ASTViewAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { return CreateASTViewer(); } -std::unique_ptr -DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) { +ASTConsumer *DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { return CreateDeclContextPrinter(); } -std::unique_ptr -GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { std::string Sysroot; std::string OutputFile; raw_ostream *OS = nullptr; @@ -84,8 +83,8 @@ GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { if (!CI.getFrontendOpts().RelocatablePCH) Sysroot.clear(); - return llvm::make_unique(CI.getPreprocessor(), OutputFile, - nullptr, Sysroot, OS); + return new PCHGenerator(CI.getPreprocessor(), OutputFile, nullptr, Sysroot, + OS); } bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI, @@ -112,17 +111,16 @@ bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI, return false; } -std::unique_ptr -GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) { +ASTConsumer *GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { std::string Sysroot; std::string OutputFile; raw_ostream *OS = nullptr; if (ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile, OS)) return nullptr; - return llvm::make_unique(CI.getPreprocessor(), OutputFile, - Module, Sysroot, OS); + return new PCHGenerator(CI.getPreprocessor(), OutputFile, Module, + Sysroot, OS); } static SmallVectorImpl & @@ -365,20 +363,19 @@ bool GenerateModuleAction::ComputeASTConsumerArguments(CompilerInstance &CI, return false; } -std::unique_ptr -SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { - return llvm::make_unique(); +ASTConsumer *SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { + return new ASTConsumer(); } -std::unique_ptr -DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) { - return llvm::make_unique(); +ASTConsumer *DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { + return new ASTConsumer(); } -std::unique_ptr -VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { - return llvm::make_unique(); +ASTConsumer *VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { + return new ASTConsumer(); } void VerifyPCHAction::ExecuteAction() { diff --git a/clang/lib/Frontend/MultiplexConsumer.cpp b/clang/lib/Frontend/MultiplexConsumer.cpp index 2930cb3..0e933a3 100644 --- a/clang/lib/Frontend/MultiplexConsumer.cpp +++ b/clang/lib/Frontend/MultiplexConsumer.cpp @@ -183,113 +183,118 @@ void MultiplexASTMutationListener::DeclarationMarkedUsed(const Decl *D) { } // end namespace clang -MultiplexConsumer::MultiplexConsumer( - std::vector> C) - : Consumers(std::move(C)), MutationListener(), DeserializationListener() { +MultiplexConsumer::MultiplexConsumer(ArrayRef C) + : Consumers(C.begin(), C.end()), MutationListener(), + DeserializationListener() { // Collect the mutation listeners and deserialization listeners of all // children, and create a multiplex listener each if so. std::vector mutationListeners; std::vector serializationListeners; - for (auto &Consumer : Consumers) { - if (auto *mutationListener = Consumer->GetASTMutationListener()) + for (size_t i = 0, e = Consumers.size(); i != e; ++i) { + ASTMutationListener* mutationListener = + Consumers[i]->GetASTMutationListener(); + if (mutationListener) mutationListeners.push_back(mutationListener); - if (auto *serializationListener = Consumer->GetASTDeserializationListener()) + ASTDeserializationListener* serializationListener = + Consumers[i]->GetASTDeserializationListener(); + if (serializationListener) serializationListeners.push_back(serializationListener); } - if (!mutationListeners.empty()) { - MutationListener = - llvm::make_unique(mutationListeners); + if (mutationListeners.size()) { + MutationListener.reset(new MultiplexASTMutationListener(mutationListeners)); } - if (!serializationListeners.empty()) { - DeserializationListener = - llvm::make_unique( - serializationListeners); + if (serializationListeners.size()) { + DeserializationListener.reset( + new MultiplexASTDeserializationListener(serializationListeners)); } } -MultiplexConsumer::~MultiplexConsumer() {} +MultiplexConsumer::~MultiplexConsumer() { + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + delete Consumers[i]; +} void MultiplexConsumer::Initialize(ASTContext &Context) { - for (auto &Consumer : Consumers) - Consumer->Initialize(Context); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->Initialize(Context); } bool MultiplexConsumer::HandleTopLevelDecl(DeclGroupRef D) { bool Continue = true; - for (auto &Consumer : Consumers) - Continue = Continue && Consumer->HandleTopLevelDecl(D); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Continue = Continue && Consumers[i]->HandleTopLevelDecl(D); return Continue; } void MultiplexConsumer::HandleInlineMethodDefinition(CXXMethodDecl *D) { - for (auto &Consumer : Consumers) - Consumer->HandleInlineMethodDefinition(D); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleInlineMethodDefinition(D); } -void MultiplexConsumer::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { - for (auto &Consumer : Consumers) - Consumer->HandleCXXStaticMemberVarInstantiation(VD); +void MultiplexConsumer::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleCXXStaticMemberVarInstantiation(VD); } void MultiplexConsumer::HandleInterestingDecl(DeclGroupRef D) { - for (auto &Consumer : Consumers) - Consumer->HandleInterestingDecl(D); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleInterestingDecl(D); } void MultiplexConsumer::HandleTranslationUnit(ASTContext &Ctx) { - for (auto &Consumer : Consumers) - Consumer->HandleTranslationUnit(Ctx); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleTranslationUnit(Ctx); } void MultiplexConsumer::HandleTagDeclDefinition(TagDecl *D) { - for (auto &Consumer : Consumers) - Consumer->HandleTagDeclDefinition(D); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleTagDeclDefinition(D); } void MultiplexConsumer::HandleTagDeclRequiredDefinition(const TagDecl *D) { - for (auto &Consumer : Consumers) - Consumer->HandleTagDeclRequiredDefinition(D); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleTagDeclRequiredDefinition(D); } void MultiplexConsumer::HandleCXXImplicitFunctionInstantiation(FunctionDecl *D){ - for (auto &Consumer : Consumers) - Consumer->HandleCXXImplicitFunctionInstantiation(D); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleCXXImplicitFunctionInstantiation(D); } void MultiplexConsumer::HandleTopLevelDeclInObjCContainer(DeclGroupRef D) { - for (auto &Consumer : Consumers) - Consumer->HandleTopLevelDeclInObjCContainer(D); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleTopLevelDeclInObjCContainer(D); } void MultiplexConsumer::HandleImplicitImportDecl(ImportDecl *D) { - for (auto &Consumer : Consumers) - Consumer->HandleImplicitImportDecl(D); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleImplicitImportDecl(D); } void MultiplexConsumer::HandleLinkerOptionPragma(llvm::StringRef Opts) { - for (auto &Consumer : Consumers) - Consumer->HandleLinkerOptionPragma(Opts); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleLinkerOptionPragma(Opts); } void MultiplexConsumer::HandleDetectMismatch(llvm::StringRef Name, llvm::StringRef Value) { - for (auto &Consumer : Consumers) - Consumer->HandleDetectMismatch(Name, Value); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleDetectMismatch(Name, Value); } void MultiplexConsumer::HandleDependentLibrary(llvm::StringRef Lib) { - for (auto &Consumer : Consumers) - Consumer->HandleDependentLibrary(Lib); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleDependentLibrary(Lib); } void MultiplexConsumer::CompleteTentativeDefinition(VarDecl *D) { - for (auto &Consumer : Consumers) - Consumer->CompleteTentativeDefinition(D); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->CompleteTentativeDefinition(D); } void MultiplexConsumer::HandleVTable( CXXRecordDecl *RD, bool DefinitionRequired) { - for (auto &Consumer : Consumers) - Consumer->HandleVTable(RD, DefinitionRequired); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->HandleVTable(RD, DefinitionRequired); } ASTMutationListener *MultiplexConsumer::GetASTMutationListener() { @@ -301,18 +306,18 @@ ASTDeserializationListener *MultiplexConsumer::GetASTDeserializationListener() { } void MultiplexConsumer::PrintStats() { - for (auto &Consumer : Consumers) - Consumer->PrintStats(); + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + Consumers[i]->PrintStats(); } void MultiplexConsumer::InitializeSema(Sema &S) { - for (auto &Consumer : Consumers) - if (SemaConsumer *SC = dyn_cast(Consumer.get())) + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + if (SemaConsumer *SC = dyn_cast(Consumers[i])) SC->InitializeSema(S); } void MultiplexConsumer::ForgetSema() { - for (auto &Consumer : Consumers) - if (SemaConsumer *SC = dyn_cast(Consumer.get())) + for (size_t i = 0, e = Consumers.size(); i != e; ++i) + if (SemaConsumer *SC = dyn_cast(Consumers[i])) SC->ForgetSema(); } diff --git a/clang/lib/Frontend/Rewrite/FrontendActions.cpp b/clang/lib/Frontend/Rewrite/FrontendActions.cpp index 1b5eb28..59fef73 100644 --- a/clang/lib/Frontend/Rewrite/FrontendActions.cpp +++ b/clang/lib/Frontend/Rewrite/FrontendActions.cpp @@ -30,8 +30,8 @@ using namespace clang; // AST Consumer Actions //===----------------------------------------------------------------------===// -std::unique_ptr -HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile)) return CreateHTMLPrinter(OS, CI.getPreprocessor()); return nullptr; @@ -40,9 +40,9 @@ HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { FixItAction::FixItAction() {} FixItAction::~FixItAction() {} -std::unique_ptr -FixItAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { - return llvm::make_unique(); +ASTConsumer *FixItAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { + return new ASTConsumer(); } namespace { @@ -148,8 +148,8 @@ bool FixItRecompile::BeginInvocation(CompilerInstance &CI) { #ifdef CLANG_ENABLE_OBJC_REWRITER -std::unique_ptr -RewriteObjCAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *RewriteObjCAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile, "cpp")) { if (CI.getLangOpts().ObjCRuntime.isNonFragile()) return CreateModernObjCRewriter(InFile, OS, diff --git a/clang/lib/Frontend/Rewrite/HTMLPrint.cpp b/clang/lib/Frontend/Rewrite/HTMLPrint.cpp index 22ccfe6..64da05f 100644 --- a/clang/lib/Frontend/Rewrite/HTMLPrint.cpp +++ b/clang/lib/Frontend/Rewrite/HTMLPrint.cpp @@ -47,12 +47,11 @@ namespace { }; } -std::unique_ptr clang::CreateHTMLPrinter(raw_ostream *OS, - Preprocessor &PP, - bool SyntaxHighlight, - bool HighlightMacros) { - return llvm::make_unique(OS, PP, SyntaxHighlight, - HighlightMacros); +ASTConsumer* clang::CreateHTMLPrinter(raw_ostream *OS, + Preprocessor &PP, + bool SyntaxHighlight, + bool HighlightMacros) { + return new HTMLPrinter(OS, PP, SyntaxHighlight, HighlightMacros); } void HTMLPrinter::Initialize(ASTContext &context) { diff --git a/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp b/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp index c97fa97..3e18a8b 100644 --- a/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp +++ b/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp @@ -675,11 +675,14 @@ RewriteModernObjC::RewriteModernObjC(std::string inFile, raw_ostream* OS, "for @try/@finally (code may not execute properly)"); } -std::unique_ptr clang::CreateModernObjCRewriter( - const std::string &InFile, raw_ostream *OS, DiagnosticsEngine &Diags, - const LangOptions &LOpts, bool SilenceRewriteMacroWarning, bool LineInfo) { - return llvm::make_unique( - InFile, OS, Diags, LOpts, SilenceRewriteMacroWarning, LineInfo); +ASTConsumer *clang::CreateModernObjCRewriter(const std::string& InFile, + raw_ostream* OS, + DiagnosticsEngine &Diags, + const LangOptions &LOpts, + bool SilenceRewriteMacroWarning, + bool LineInfo) { + return new RewriteModernObjC(InFile, OS, Diags, LOpts, + SilenceRewriteMacroWarning, LineInfo); } void RewriteModernObjC::InitializeCommon(ASTContext &context) { diff --git a/clang/lib/Frontend/Rewrite/RewriteObjC.cpp b/clang/lib/Frontend/Rewrite/RewriteObjC.cpp index 8d48d9e..7a72177 100644 --- a/clang/lib/Frontend/Rewrite/RewriteObjC.cpp +++ b/clang/lib/Frontend/Rewrite/RewriteObjC.cpp @@ -600,12 +600,12 @@ RewriteObjC::RewriteObjC(std::string inFile, raw_ostream* OS, "for @try/@finally (code may not execute properly)"); } -std::unique_ptr -clang::CreateObjCRewriter(const std::string &InFile, raw_ostream *OS, - DiagnosticsEngine &Diags, const LangOptions &LOpts, - bool SilenceRewriteMacroWarning) { - return llvm::make_unique(InFile, OS, Diags, LOpts, - SilenceRewriteMacroWarning); +ASTConsumer *clang::CreateObjCRewriter(const std::string& InFile, + raw_ostream* OS, + DiagnosticsEngine &Diags, + const LangOptions &LOpts, + bool SilenceRewriteMacroWarning) { + return new RewriteObjCFragileABI(InFile, OS, Diags, LOpts, SilenceRewriteMacroWarning); } void RewriteObjC::InitializeCommon(ASTContext &context) { diff --git a/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp b/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp index 23199ee..12e514b 100644 --- a/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp +++ b/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp @@ -687,14 +687,14 @@ void AnalysisConsumer::RunPathSensitiveChecks(Decl *D, // AnalysisConsumer creation. //===----------------------------------------------------------------------===// -std::unique_ptr +AnalysisASTConsumer * ento::CreateAnalysisConsumer(const Preprocessor &pp, const std::string &outDir, AnalyzerOptionsRef opts, ArrayRef plugins) { // Disable the effects of '-Werror' when using the AnalysisConsumer. pp.getDiagnostics().setWarningsAsErrors(false); - return llvm::make_unique(pp, outDir, opts, plugins); + return new AnalysisConsumer(pp, outDir, opts, plugins); } //===----------------------------------------------------------------------===// diff --git a/clang/lib/StaticAnalyzer/Frontend/FrontendActions.cpp b/clang/lib/StaticAnalyzer/Frontend/FrontendActions.cpp index 567102b..aa38077 100644 --- a/clang/lib/StaticAnalyzer/Frontend/FrontendActions.cpp +++ b/clang/lib/StaticAnalyzer/Frontend/FrontendActions.cpp @@ -13,8 +13,8 @@ using namespace clang; using namespace ento; -std::unique_ptr -AnalysisAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { +ASTConsumer *AnalysisAction::CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { return CreateAnalysisConsumer(CI.getPreprocessor(), CI.getFrontendOpts().OutputFile, CI.getAnalyzerOpts(), diff --git a/clang/tools/clang-check/ClangCheck.cpp b/clang/tools/clang-check/ClangCheck.cpp index df3b4e0..cc8d43c 100644 --- a/clang/tools/clang-check/ClangCheck.cpp +++ b/clang/tools/clang-check/ClangCheck.cpp @@ -28,7 +28,6 @@ #include "llvm/Option/OptTable.h" #include "llvm/Support/Path.h" #include "llvm/Support/Signals.h" -#include "llvm/ADT/STLExtras.h" using namespace clang::driver; using namespace clang::tooling; @@ -180,14 +179,14 @@ private: namespace clang_check { class ClangCheckActionFactory { public: - std::unique_ptr newASTConsumer() { + clang::ASTConsumer *newASTConsumer() { if (ASTList) return clang::CreateASTDeclNodeLister(); if (ASTDump) return clang::CreateASTDumper(ASTDumpFilter); if (ASTPrint) return clang::CreateASTPrinter(&llvm::outs(), ASTDumpFilter); - return llvm::make_unique(); + return new clang::ASTConsumer(); } }; } diff --git a/clang/tools/libclang/Indexing.cpp b/clang/tools/libclang/Indexing.cpp index f347f9f..58af618 100644 --- a/clang/tools/libclang/Indexing.cpp +++ b/clang/tools/libclang/Indexing.cpp @@ -414,8 +414,8 @@ public: : IndexCtx(clientData, indexCallbacks, indexOptions, cxTU), CXTU(cxTU), SKData(skData) { } - std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override { + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) override { PreprocessorOptions &PPOpts = CI.getPreprocessorOpts(); if (!PPOpts.ImplicitPCHInclude.empty()) { @@ -429,12 +429,13 @@ public: IndexCtx.setPreprocessor(PP); if (SKData) { - auto *PPRec = new PPConditionalDirectiveRecord(PP.getSourceManager()); + PPConditionalDirectiveRecord * + PPRec = new PPConditionalDirectiveRecord(PP.getSourceManager()); PP.addPPCallbacks(PPRec); - SKCtrl = llvm::make_unique(*SKData, *PPRec, PP); + SKCtrl.reset(new TUSkipBodyControl(*SKData, *PPRec, PP)); } - return llvm::make_unique(IndexCtx, SKCtrl.get()); + return new IndexingConsumer(IndexCtx, SKCtrl.get()); } void EndSourceFileAction() override { diff --git a/clang/unittests/AST/EvaluateAsRValueTest.cpp b/clang/unittests/AST/EvaluateAsRValueTest.cpp index b5f9b32..9120c93 100644 --- a/clang/unittests/AST/EvaluateAsRValueTest.cpp +++ b/clang/unittests/AST/EvaluateAsRValueTest.cpp @@ -59,10 +59,9 @@ class EvaluateConstantInitializersVisitor class EvaluateConstantInitializersAction : public clang::ASTFrontendAction { public: - std::unique_ptr - CreateASTConsumer(clang::CompilerInstance &Compiler, - llvm::StringRef FilePath) override { - return llvm::make_unique(); + clang::ASTConsumer *CreateASTConsumer(clang::CompilerInstance &Compiler, + llvm::StringRef FilePath) override { + return new Consumer; } private: diff --git a/clang/unittests/AST/ExternalASTSourceTest.cpp b/clang/unittests/AST/ExternalASTSourceTest.cpp index 6a5db6c..5cc2def 100644 --- a/clang/unittests/AST/ExternalASTSourceTest.cpp +++ b/clang/unittests/AST/ExternalASTSourceTest.cpp @@ -35,9 +35,9 @@ private: return ASTFrontendAction::ExecuteAction(); } - virtual std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) { - return llvm::make_unique(); + virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { + return new ASTConsumer; } IntrusiveRefCntPtr Source; diff --git a/clang/unittests/AST/NamedDeclPrinterTest.cpp b/clang/unittests/AST/NamedDeclPrinterTest.cpp index f8fb984..4823b44 100644 --- a/clang/unittests/AST/NamedDeclPrinterTest.cpp +++ b/clang/unittests/AST/NamedDeclPrinterTest.cpp @@ -68,8 +68,8 @@ PrintedNamedDeclMatches(StringRef Code, const std::vector &Args, PrintMatch Printer(SuppressUnwrittenScope); MatchFinder Finder; Finder.addMatcher(NodeMatch, &Printer); - std::unique_ptr Factory = - newFrontendActionFactory(&Finder); + std::unique_ptr Factory( + newFrontendActionFactory(&Finder)); if (!runToolOnCodeWithArgs(Factory->create(), Code, Args, FileName)) return testing::AssertionFailure() diff --git a/clang/unittests/Frontend/FrontendActionTest.cpp b/clang/unittests/Frontend/FrontendActionTest.cpp index 48bc072..e39d00f 100644 --- a/clang/unittests/Frontend/FrontendActionTest.cpp +++ b/clang/unittests/Frontend/FrontendActionTest.cpp @@ -38,9 +38,9 @@ public: return ASTFrontendAction::BeginSourceFileAction(ci, filename); } - virtual std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) { - return llvm::make_unique(decl_names); + virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, + StringRef InFile) { + return new Visitor(decl_names); } private: diff --git a/clang/unittests/Sema/ExternalSemaSourceTest.cpp b/clang/unittests/Sema/ExternalSemaSourceTest.cpp index 4291b76..bc0d632 100644 --- a/clang/unittests/Sema/ExternalSemaSourceTest.cpp +++ b/clang/unittests/Sema/ExternalSemaSourceTest.cpp @@ -140,10 +140,10 @@ class ExternalSemaSourceInstaller : public clang::ASTFrontendAction { std::unique_ptr OwnedClient; protected: - virtual std::unique_ptr + virtual clang::ASTConsumer * CreateASTConsumer(clang::CompilerInstance &Compiler, llvm::StringRef /* dummy */) { - return llvm::make_unique(); + return new clang::ASTConsumer(); } virtual void ExecuteAction() { diff --git a/clang/unittests/Tooling/RefactoringTest.cpp b/clang/unittests/Tooling/RefactoringTest.cpp index 3e067dd..ddb974a 100644 --- a/clang/unittests/Tooling/RefactoringTest.cpp +++ b/clang/unittests/Tooling/RefactoringTest.cpp @@ -299,12 +299,11 @@ private: public: TestAction(TestVisitor *Visitor) : Visitor(Visitor) {} - virtual std::unique_ptr - CreateASTConsumer(clang::CompilerInstance &compiler, - llvm::StringRef dummy) { + virtual clang::ASTConsumer* CreateASTConsumer( + clang::CompilerInstance& compiler, llvm::StringRef dummy) { Visitor->SM = &compiler.getSourceManager(); /// TestConsumer will be deleted by the framework calling us. - return llvm::make_unique(Visitor); + return new FindConsumer(Visitor); } private: diff --git a/clang/unittests/Tooling/TestVisitor.h b/clang/unittests/Tooling/TestVisitor.h index 23ea754..205a0aa 100644 --- a/clang/unittests/Tooling/TestVisitor.h +++ b/clang/unittests/Tooling/TestVisitor.h @@ -95,10 +95,10 @@ protected: public: TestAction(TestVisitor *Visitor) : Visitor(Visitor) {} - virtual std::unique_ptr - CreateASTConsumer(CompilerInstance &, llvm::StringRef dummy) { + virtual clang::ASTConsumer* CreateASTConsumer( + CompilerInstance&, llvm::StringRef dummy) { /// TestConsumer will be deleted by the framework calling us. - return llvm::make_unique(Visitor); + return new FindConsumer(Visitor); } protected: diff --git a/clang/unittests/Tooling/ToolingTest.cpp b/clang/unittests/Tooling/ToolingTest.cpp index 85ab942..9aede04 100644 --- a/clang/unittests/Tooling/ToolingTest.cpp +++ b/clang/unittests/Tooling/ToolingTest.cpp @@ -28,20 +28,20 @@ namespace { /// Takes an ast consumer and returns it from CreateASTConsumer. This only /// works with single translation unit compilations. class TestAction : public clang::ASTFrontendAction { -public: + public: /// Takes ownership of TestConsumer. - explicit TestAction(std::unique_ptr TestConsumer) - : TestConsumer(std::move(TestConsumer)) {} + explicit TestAction(clang::ASTConsumer *TestConsumer) + : TestConsumer(TestConsumer) {} -protected: - virtual std::unique_ptr - CreateASTConsumer(clang::CompilerInstance &compiler, StringRef dummy) { + protected: + virtual clang::ASTConsumer* CreateASTConsumer( + clang::CompilerInstance& compiler, StringRef dummy) { /// TestConsumer will be deleted by the framework calling us. - return std::move(TestConsumer); + return TestConsumer; } -private: - std::unique_ptr TestConsumer; + private: + clang::ASTConsumer * const TestConsumer; }; class FindTopLevelDeclConsumer : public clang::ASTConsumer { @@ -59,10 +59,8 @@ class FindTopLevelDeclConsumer : public clang::ASTConsumer { TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) { bool FoundTopLevelDecl = false; - EXPECT_TRUE( - runToolOnCode(new TestAction(llvm::make_unique( - &FoundTopLevelDecl)), - "")); + EXPECT_TRUE(runToolOnCode( + new TestAction(new FindTopLevelDeclConsumer(&FoundTopLevelDecl)), "")); EXPECT_FALSE(FoundTopLevelDecl); } @@ -99,17 +97,13 @@ bool FindClassDeclX(ASTUnit *AST) { TEST(runToolOnCode, FindsClassDecl) { bool FoundClassDeclX = false; - EXPECT_TRUE( - runToolOnCode(new TestAction(llvm::make_unique( - &FoundClassDeclX)), - "class X;")); + EXPECT_TRUE(runToolOnCode(new TestAction( + new FindClassDeclXConsumer(&FoundClassDeclX)), "class X;")); EXPECT_TRUE(FoundClassDeclX); FoundClassDeclX = false; - EXPECT_TRUE( - runToolOnCode(new TestAction(llvm::make_unique( - &FoundClassDeclX)), - "class Y;")); + EXPECT_TRUE(runToolOnCode(new TestAction( + new FindClassDeclXConsumer(&FoundClassDeclX)), "class Y;")); EXPECT_FALSE(FoundClassDeclX); } @@ -131,8 +125,8 @@ TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) { } struct IndependentFrontendActionCreator { - std::unique_ptr newASTConsumer() { - return llvm::make_unique(nullptr); + ASTConsumer *newASTConsumer() { + return new FindTopLevelDeclConsumer(nullptr); } }; @@ -191,8 +185,8 @@ struct VerifyEndCallback : public SourceFileCallbacks { virtual void handleEndSource() { ++EndCalled; } - std::unique_ptr newASTConsumer() { - return llvm::make_unique(&Matched); + ASTConsumer *newASTConsumer() { + return new FindTopLevelDeclConsumer(&Matched); } unsigned BeginCalled; unsigned EndCalled; @@ -231,10 +225,10 @@ struct SkipBodyConsumer : public clang::ASTConsumer { }; struct SkipBodyAction : public clang::ASTFrontendAction { - virtual std::unique_ptr - CreateASTConsumer(CompilerInstance &Compiler, StringRef) { + virtual ASTConsumer *CreateASTConsumer(CompilerInstance &Compiler, + StringRef) { Compiler.getFrontendOpts().SkipFunctionBodies = true; - return llvm::make_unique(); + return new SkipBodyConsumer; } }; -- 2.7.4