maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

unique_ptr-ify ownership of ASTConsumers 

(after fixing a bug in MultiplexConsumer I noticed the ownership of the
nested consumers was implemented with raw pointers - so this fixes
that... and follows the source back to its origin pushing unique_ptr
ownership up through there too)

llvm-svn: 213307
This commit is contained in:
David Blaikie 2014-07-17 20:40:36 +00:00
parent fa59e62012
commit a51666a4d6
42 changed files with 346 additions and 338 deletions

5
clang/examples/PrintFunctionNames/PrintFunctionNames.cpp
View File

@ -36,8 +36,9 @@ public:
class PrintFunctionNamesAction : public PluginASTAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI, llvm::StringRef) {
return new PrintFunctionsConsumer();
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
llvm::StringRef) {
return llvm::make_unique<PrintFunctionsConsumer>();
}
bool ParseArgs(const CompilerInstance &CI,

8
clang/include/clang/ARCMigrate/ARCMTActions.h
View File

@ -37,8 +37,8 @@ class MigrateSourceAction : public ASTFrontendAction {
FileRemapper Remapper;
protected:
bool BeginInvocation(CompilerInstance &CI) override;
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
};
class MigrateAction : public WrapperFrontendAction {
@ -65,8 +65,8 @@ public:
unsigned migrateAction);
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
bool BeginInvocation(CompilerInstance &CI) override;
};

2
clang/include/clang/ASTMatchers/ASTMatchFinder.h
View File

@ -148,7 +148,7 @@ public:
MatchCallback *Action);
/// \brief Creates a clang ASTConsumer that finds all matches.
clang::ASTConsumer *newASTConsumer();
std::unique_ptr<clang::ASTConsumer> newASTConsumer();
/// \brief Calls the registered callbacks on all matches on the given \p Node.
///

4
clang/include/clang/CodeGen/CodeGenAction.h
View File

@ -37,8 +37,8 @@ protected:
bool hasIRSupport() const override;
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
void ExecuteAction() override;

14
clang/include/clang/Frontend/ASTConsumers.h
View File

@ -16,6 +16,8 @@
#include "clang/Basic/LLVM.h"
#include <memory>
namespace clang {
class ASTConsumer;
@ -30,24 +32,26 @@ 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.
ASTConsumer *CreateASTPrinter(raw_ostream *OS, StringRef FilterString);
std::unique_ptr<ASTConsumer> CreateASTPrinter(raw_ostream *OS,
StringRef FilterString);
// AST dumper: dumps the raw AST in human-readable form to stderr; this is
// intended for debugging.
ASTConsumer *CreateASTDumper(StringRef FilterString, bool DumpLookups = false);
std::unique_ptr<ASTConsumer> CreateASTDumper(StringRef FilterString,
bool DumpLookups = false);
// AST Decl node lister: prints qualified names of all filterable AST Decl
// nodes.
ASTConsumer *CreateASTDeclNodeLister();
std::unique_ptr<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.
ASTConsumer *CreateASTViewer();
std::unique_ptr<ASTConsumer> CreateASTViewer();
// DeclContext printer: prints out the DeclContext tree in human-readable form
// to stderr; this is intended for debugging.
ASTConsumer *CreateDeclContextPrinter();
std::unique_ptr<ASTConsumer> CreateDeclContextPrinter();
} // end clang namespace

5
clang/include/clang/Frontend/CompilerInstance.h
View File

@ -14,6 +14,7 @@
#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"
@ -443,11 +444,11 @@ public:
/// takeASTConsumer - Remove the current AST consumer and give ownership to
/// the caller.
ASTConsumer *takeASTConsumer() { return Consumer.release(); }
std::unique_ptr<ASTConsumer> takeASTConsumer() { return std::move(Consumer); }
/// setASTConsumer - Replace the current AST consumer; the compiler instance
/// takes ownership of \p Value.
void setASTConsumer(ASTConsumer *Value);
void setASTConsumer(std::unique_ptr<ASTConsumer> Value);
/// }
/// @name Semantic analysis

23
clang/include/clang/Frontend/FrontendAction.h
View File

@ -41,8 +41,8 @@ class FrontendAction {
friend class WrapperFrontendAction;
private:
ASTConsumer* CreateWrappedASTConsumer(CompilerInstance &CI,
StringRef InFile);
std::unique_ptr<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 ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) = 0;
virtual std::unique_ptr<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,11 +227,10 @@ public:
class PluginASTAction : public ASTFrontendAction {
virtual void anchor();
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override = 0;
public:
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override = 0;
/// \brief Parse the given plugin command line arguments.
///
/// \param CI - The compiler instance, for use in reporting diagnostics.
@ -247,8 +246,8 @@ class PreprocessorFrontendAction : public FrontendAction {
protected:
/// \brief Provide a default implementation which returns aborts;
/// this method should never be called by FrontendAction clients.
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
public:
bool usesPreprocessorOnly() const override { return true; }
@ -264,8 +263,8 @@ class WrapperFrontendAction : public FrontendAction {
std::unique_ptr<FrontendAction> WrappedAction;
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
bool BeginInvocation(CompilerInstance &CI) override;
bool BeginSourceFileAction(CompilerInstance &CI, StringRef Filename) override;
void ExecuteAction() override;

51
clang/include/clang/Frontend/FrontendActions.h
View File

@ -26,8 +26,8 @@ class FileEntry;
class InitOnlyAction : public FrontendAction {
void ExecuteAction() override;
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<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:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
};
class ASTDumpAction : public ASTFrontendAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
};
class ASTDeclListAction : public ASTFrontendAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
};
class ASTViewAction : public ASTFrontendAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
};
class DeclContextPrintAction : public ASTFrontendAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
};
class GeneratePCHAction : public ASTFrontendAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
TranslationUnitKind getTranslationUnitKind() override {
return TU_Prefix;
@ -98,8 +98,8 @@ class GenerateModuleAction : public ASTFrontendAction {
bool IsSystem;
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
TranslationUnitKind getTranslationUnitKind() override {
return TU_Module;
@ -128,8 +128,8 @@ public:
class SyntaxOnlyAction : public ASTFrontendAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<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:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
void ExecuteAction() override;
public:
@ -152,8 +152,8 @@ public:
class VerifyPCHAction : public ASTFrontendAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
void ExecuteAction() override;
@ -177,8 +177,8 @@ class ASTMergeAction : public FrontendAction {
std::vector<std::string> ASTFiles;
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
bool BeginSourceFileAction(CompilerInstance &CI,
StringRef Filename) override;
@ -200,7 +200,8 @@ public:
class PrintPreambleAction : public FrontendAction {
protected:
void ExecuteAction() override;
ASTConsumer *CreateASTConsumer(CompilerInstance &, StringRef) override {
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
StringRef) override {
return nullptr;
}

4
clang/include/clang/Frontend/MultiplexConsumer.h
View File

@ -29,7 +29,7 @@ class MultiplexASTDeserializationListener;
class MultiplexConsumer : public SemaConsumer {
public:
// Takes ownership of the pointers in C.
MultiplexConsumer(ArrayRef<ASTConsumer*> C);
MultiplexConsumer(std::vector<std::unique_ptr<ASTConsumer>> C);
~MultiplexConsumer();
// ASTConsumer
@ -59,7 +59,7 @@ public:
void ForgetSema() override;
private:
std::vector<ASTConsumer*> Consumers; // Owns these.
std::vector<std::unique_ptr<ASTConsumer>> Consumers; // Owns these.
std::unique_ptr<MultiplexASTMutationListener> MutationListener;
std::unique_ptr<MultiplexASTDeserializationListener> DeserializationListener;
};

28
clang/include/clang/Rewrite/Frontend/ASTConsumers.h
View File

@ -15,6 +15,8 @@
#define REWRITE_ASTCONSUMERS_H
#include "clang/Basic/LLVM.h"
#include <memory>
#include <string>
namespace clang {
@ -26,23 +28,21 @@ 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.
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);
std::unique_ptr<ASTConsumer>
CreateObjCRewriter(const std::string &InFile, raw_ostream *OS,
DiagnosticsEngine &Diags, const LangOptions &LOpts,
bool SilenceRewriteMacroWarning);
std::unique_ptr<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.
ASTConsumer *CreateHTMLPrinter(raw_ostream *OS, Preprocessor &PP,
bool SyntaxHighlight = true,
bool HighlightMacros = true);
std::unique_ptr<ASTConsumer> CreateHTMLPrinter(raw_ostream *OS,
Preprocessor &PP,
bool SyntaxHighlight = true,
bool HighlightMacros = true);
} // end clang namespace

12
clang/include/clang/Rewrite/Frontend/FrontendActions.h
View File

@ -22,8 +22,8 @@ class FixItOptions;
class HTMLPrintAction : public ASTFrontendAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
};
class FixItAction : public ASTFrontendAction {
@ -31,8 +31,8 @@ protected:
std::unique_ptr<FixItRewriter> Rewriter;
std::unique_ptr<FixItOptions> FixItOpts;
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
bool BeginSourceFileAction(CompilerInstance &CI,
StringRef Filename) override;
@ -59,8 +59,8 @@ protected:
class RewriteObjCAction : public ASTFrontendAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
};
class RewriteMacrosAction : public PreprocessorFrontendAction {

7
clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h
View File

@ -37,10 +37,9 @@ public:
/// CreateAnalysisConsumer - Creates an ASTConsumer to run various code
/// analysis passes. (The set of analyses run is controlled by command-line
/// options.)
AnalysisASTConsumer *CreateAnalysisConsumer(const Preprocessor &pp,
const std::string &output,
AnalyzerOptionsRef opts,
ArrayRef<std::string> plugins);
std::unique_ptr<AnalysisASTConsumer>
CreateAnalysisConsumer(const Preprocessor &pp, const std::string &output,
AnalyzerOptionsRef opts, ArrayRef<std::string> plugins);
} // end GR namespace

4
clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h
View File

@ -22,8 +22,8 @@ namespace ento {
class AnalysisAction : public ASTFrontendAction {
protected:
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
};
void printCheckerHelp(raw_ostream &OS, ArrayRef<std::string> plugins);

5
clang/include/clang/Tooling/Tooling.h
View File

@ -30,6 +30,7 @@
#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"
@ -335,8 +336,8 @@ inline std::unique_ptr<FrontendActionFactory> newFrontendActionFactory(
SourceFileCallbacks *Callbacks)
: ConsumerFactory(ConsumerFactory), Callbacks(Callbacks) {}
clang::ASTConsumer *CreateASTConsumer(clang::CompilerInstance &,
StringRef) override {
std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance &, StringRef) override {
return ConsumerFactory->newASTConsumer();
}

6
clang/lib/ARCMigrate/ARCMT.cpp
View File

@ -446,11 +446,11 @@ public:
ARCMTMacroTrackerAction(std::vector<SourceLocation> &ARCMTMacroLocs)
: ARCMTMacroLocs(ARCMTMacroLocs) { }
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override {
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override {
CI.getPreprocessor().addPPCallbacks(
new ARCMTMacroTrackerPPCallbacks(ARCMTMacroLocs));
return new ASTConsumer();
return llvm::make_unique<ASTConsumer>();
}
};

38
clang/lib/ARCMigrate/ObjCMT.cpp
View File

@ -185,23 +185,17 @@ ObjCMigrateAction::ObjCMigrateAction(FrontendAction *WrappedAction,
MigrateDir = "."; // user current directory if none is given.
}
ASTConsumer *ObjCMigrateAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
ObjCMigrateAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
PPConditionalDirectiveRecord *
PPRec = new PPConditionalDirectiveRecord(CompInst->getSourceManager());
CompInst->getPreprocessor().addPPCallbacks(PPRec);
ASTConsumer *
WrappedConsumer = WrapperFrontendAction::CreateASTConsumer(CI, InFile);
ASTConsumer *MTConsumer = new ObjCMigrateASTConsumer(MigrateDir,
ObjCMigAction,
Remapper,
CompInst->getFileManager(),
PPRec,
CompInst->getPreprocessor(),
false,
ArrayRef<std::string>());
ASTConsumer *Consumers[] = { MTConsumer, WrappedConsumer };
return new MultiplexConsumer(Consumers);
std::vector<std::unique_ptr<ASTConsumer>> Consumers;
Consumers.push_back(WrapperFrontendAction::CreateASTConsumer(CI, InFile));
Consumers.push_back(llvm::make_unique<ObjCMigrateASTConsumer>(
MigrateDir, ObjCMigAction, Remapper, CompInst->getFileManager(), PPRec,
CompInst->getPreprocessor(), false, ArrayRef<std::string>()));
return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
}
bool ObjCMigrateAction::BeginInvocation(CompilerInstance &CI) {
@ -1865,8 +1859,8 @@ static std::vector<std::string> getWhiteListFilenames(StringRef DirPath) {
return Filenames;
}
ASTConsumer *MigrateSourceAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
MigrateSourceAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
PPConditionalDirectiveRecord *
PPRec = new PPConditionalDirectiveRecord(CI.getSourceManager());
unsigned ObjCMTAction = CI.getFrontendOpts().ObjCMTAction;
@ -1883,14 +1877,10 @@ ASTConsumer *MigrateSourceAction::CreateASTConsumer(CompilerInstance &CI,
CI.getPreprocessor().addPPCallbacks(PPRec);
std::vector<std::string> WhiteList =
getWhiteListFilenames(CI.getFrontendOpts().ObjCMTWhiteListPath);
return new ObjCMigrateASTConsumer(CI.getFrontendOpts().OutputFile,
ObjCMTAction,
Remapper,
CI.getFileManager(),
PPRec,
CI.getPreprocessor(),
/*isOutputFile=*/true,
WhiteList);
return llvm::make_unique<ObjCMigrateASTConsumer>(
CI.getFrontendOpts().OutputFile, ObjCMTAction, Remapper,
CI.getFileManager(), PPRec, CI.getPreprocessor(),
/*isOutputFile=*/true, WhiteList);
}
namespace {

4
clang/lib/ASTMatchers/ASTMatchFinder.cpp
View File

@ -823,8 +823,8 @@ bool MatchFinder::addDynamicMatcher(const internal::DynTypedMatcher &NodeMatch,
return false;
}
ASTConsumer *MatchFinder::newASTConsumer() {
return new internal::MatchASTConsumer(this, ParsingDone);
std::unique_ptr<ASTConsumer> MatchFinder::newASTConsumer() {
return llvm::make_unique<internal::MatchASTConsumer>(this, ParsingDone);
}
void MatchFinder::match(const clang::ast_type_traits::DynTypedNode &Node,

15
clang/lib/CodeGen/CodeGenAction.cpp
View File

@ -590,8 +590,8 @@ static raw_ostream *GetOutputStream(CompilerInstance &CI,
llvm_unreachable("Invalid action!");
}
ASTConsumer *CodeGenAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
BackendAction BA = static_cast<BackendAction>(Act);
std::unique_ptr<raw_ostream> OS(GetOutputStream(CI, InFile, BA));
if (BA != Backend_EmitNothing && !OS)
@ -623,11 +623,12 @@ ASTConsumer *CodeGenAction::CreateASTConsumer(CompilerInstance &CI,
LinkModuleToUse = ModuleOrErr.get();
}
BEConsumer = new BackendConsumer(BA, CI.getDiagnostics(), CI.getCodeGenOpts(),
CI.getTargetOpts(), CI.getLangOpts(),
CI.getFrontendOpts().ShowTimers, InFile,
LinkModuleToUse, OS.release(), *VMContext);
return BEConsumer;
auto Result = llvm::make_unique<BackendConsumer>(
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);
}
void CodeGenAction::ExecuteAction() {

25
clang/lib/Frontend/ASTConsumers.cpp
View File

@ -118,17 +118,19 @@ namespace {
};
} // end anonymous namespace
ASTConsumer *clang::CreateASTPrinter(raw_ostream *Out,
StringRef FilterString) {
return new ASTPrinter(Out, /*Dump=*/ false, FilterString);
std::unique_ptr<ASTConsumer> clang::CreateASTPrinter(raw_ostream *Out,
StringRef FilterString) {
return llvm::make_unique<ASTPrinter>(Out, /*Dump=*/false, FilterString);
}
ASTConsumer *clang::CreateASTDumper(StringRef FilterString, bool DumpLookups) {
return new ASTPrinter(nullptr, /*Dump=*/true, FilterString, DumpLookups);
std::unique_ptr<ASTConsumer> clang::CreateASTDumper(StringRef FilterString,
bool DumpLookups) {
return llvm::make_unique<ASTPrinter>(nullptr, /*Dump=*/true, FilterString,
DumpLookups);
}
ASTConsumer *clang::CreateASTDeclNodeLister() {
return new ASTDeclNodeLister(nullptr);
std::unique_ptr<ASTConsumer> clang::CreateASTDeclNodeLister() {
return llvm::make_unique<ASTDeclNodeLister>(nullptr);
}
//===----------------------------------------------------------------------===//
@ -164,8 +166,9 @@ void ASTViewer::HandleTopLevelSingleDecl(Decl *D) {
}
}
ASTConsumer *clang::CreateASTViewer() { return new ASTViewer(); }
std::unique_ptr<ASTConsumer> clang::CreateASTViewer() {
return llvm::make_unique<ASTViewer>();
}
//===----------------------------------------------------------------------===//
/// DeclContextPrinter - Decl and DeclContext Visualization
@ -475,6 +478,6 @@ void DeclContextPrinter::PrintDeclContext(const DeclContext* DC,
}
}
}
ASTConsumer *clang::CreateDeclContextPrinter() {
return new DeclContextPrinter();
std::unique_ptr<ASTConsumer> clang::CreateDeclContextPrinter() {
return llvm::make_unique<DeclContextPrinter>();
}

4
clang/lib/Frontend/ASTMerge.cpp
View File

@ -16,8 +16,8 @@
using namespace clang;
ASTConsumer *ASTMergeAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
ASTMergeAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
return AdaptedAction->CreateASTConsumer(CI, InFile);
}

32
clang/lib/Frontend/ASTUnit.cpp
View File

@ -891,12 +891,12 @@ class TopLevelDeclTrackerAction : public ASTFrontendAction {
public:
ASTUnit &Unit;
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override {
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override {
CI.getPreprocessor().addPPCallbacks(
new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue()));
return new TopLevelDeclTrackerConsumer(Unit,
Unit.getCurrentTopLevelHashValue());
return llvm::make_unique<TopLevelDeclTrackerConsumer>(
Unit, Unit.getCurrentTopLevelHashValue());
}
public:
@ -916,8 +916,8 @@ public:
explicit PrecompilePreambleAction(ASTUnit &Unit)
: Unit(Unit), HasEmittedPreamblePCH(false) {}
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
bool hasEmittedPreamblePCH() const { return HasEmittedPreamblePCH; }
void setHasEmittedPreamblePCH() { HasEmittedPreamblePCH = true; }
bool shouldEraseOutputFiles() override { return !hasEmittedPreamblePCH(); }
@ -979,8 +979,9 @@ public:
}
ASTConsumer *PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::string Sysroot;
std::string OutputFile;
raw_ostream *OS = nullptr;
@ -993,8 +994,8 @@ ASTConsumer *PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI,
CI.getPreprocessor().addPPCallbacks(new MacroDefinitionTrackerPPCallbacks(
Unit.getCurrentTopLevelHashValue()));
return new PrecompilePreambleConsumer(Unit, this, CI.getPreprocessor(),
Sysroot, OS);
return llvm::make_unique<PrecompilePreambleConsumer>(
Unit, this, CI.getPreprocessor(), Sysroot, OS);
}
static bool isNonDriverDiag(const StoredDiagnostic &StoredDiag) {
@ -1689,7 +1690,7 @@ void ASTUnit::transferASTDataFromCompilerInstance(CompilerInstance &CI) {
assert(CI.hasInvocation() && "missing invocation");
LangOpts = CI.getInvocation().LangOpts;
TheSema.reset(CI.takeSema());
Consumer.reset(CI.takeASTConsumer());
Consumer = CI.takeASTConsumer();
if (CI.hasASTContext())
Ctx = &CI.getASTContext();
if (CI.hasPreprocessor())
@ -1863,12 +1864,13 @@ ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(
if (Persistent && !TrackerAct) {
Clang->getPreprocessor().addPPCallbacks(
new MacroDefinitionTrackerPPCallbacks(AST->getCurrentTopLevelHashValue()));
std::vector<ASTConsumer*> Consumers;
std::vector<std::unique_ptr<ASTConsumer>> Consumers;
if (Clang->hasASTConsumer())
Consumers.push_back(Clang->takeASTConsumer());
Consumers.push_back(new TopLevelDeclTrackerConsumer(*AST,
AST->getCurrentTopLevelHashValue()));
Clang->setASTConsumer(new MultiplexConsumer(Consumers));
Consumers.push_back(llvm::make_unique<TopLevelDeclTrackerConsumer>(
*AST, AST->getCurrentTopLevelHashValue()));
Clang->setASTConsumer(
llvm::make_unique<MultiplexConsumer>(std::move(Consumers)));
}
if (!Act->Execute()) {
AST->transferASTDataFromCompilerInstance(*Clang);

8
clang/lib/Frontend/ChainedIncludesSource.cpp
View File

@ -158,12 +158,12 @@ IntrusiveRefCntPtr<ExternalSemaSource> clang::createChainedIncludesSource(
SmallVector<char, 256> serialAST;
llvm::raw_svector_ostream OS(serialAST);
std::unique_ptr<ASTConsumer> consumer;
consumer.reset(new PCHGenerator(Clang->getPreprocessor(), "-", nullptr,
/*isysroot=*/"", &OS));
auto consumer =
llvm::make_unique<PCHGenerator>(Clang->getPreprocessor(), "-", nullptr,
/*isysroot=*/"", &OS);
Clang->getASTContext().setASTMutationListener(
consumer->GetASTMutationListener());
Clang->setASTConsumer(consumer.release());
Clang->setASTConsumer(std::move(consumer));
Clang->createSema(TU_Prefix, nullptr);
if (firstInclude) {

4
clang/lib/Frontend/CompilerInstance.cpp
View File

@ -101,8 +101,8 @@ void CompilerInstance::setSema(Sema *S) {
TheSema.reset(S);
}
void CompilerInstance::setASTConsumer(ASTConsumer *Value) {
Consumer.reset(Value);
void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
Consumer = std::move(Value);
}
void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {

38
clang/lib/Frontend/FrontendAction.cpp
View File

@ -134,9 +134,10 @@ void FrontendAction::setCurrentInput(const FrontendInputFile &CurrentInput,
CurrentASTUnit.reset(AST);
}
ASTConsumer* FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
StringRef InFile) {
ASTConsumer* Consumer = CreateASTConsumer(CI, InFile);
std::unique_ptr<ASTConsumer>
FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer> Consumer = CreateASTConsumer(CI, InFile);
if (!Consumer)
return nullptr;
@ -145,7 +146,8 @@ ASTConsumer* FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
// Make sure the non-plugin consumer is first, so that plugins can't
// modifiy the AST.
std::vector<ASTConsumer*> Consumers(1, Consumer);
std::vector<std::unique_ptr<ASTConsumer>> Consumers;
Consumers.push_back(std::move(Consumer));
for (size_t i = 0, e = CI.getFrontendOpts().AddPluginActions.size();
i != e; ++i) {
@ -155,16 +157,15 @@ ASTConsumer* FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
it = FrontendPluginRegistry::begin(),
ie = FrontendPluginRegistry::end();
it != ie; ++it) {
if (it->getName() == CI.getFrontendOpts().AddPluginActions[i]) {
std::unique_ptr<PluginASTAction> P(it->instantiate());
FrontendAction* c = P.get();
if (P->ParseArgs(CI, CI.getFrontendOpts().AddPluginArgs[i]))
Consumers.push_back(c->CreateASTConsumer(CI, InFile));
}
if (it->getName() != CI.getFrontendOpts().AddPluginActions[i])
continue;
std::unique_ptr<PluginASTAction> P = it->instantiate();
if (P->ParseArgs(CI, CI.getFrontendOpts().AddPluginArgs[i]))
Consumers.push_back(P->CreateASTConsumer(CI, InFile));
}
}
return new MultiplexConsumer(Consumers);
return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
}
bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
@ -307,8 +308,8 @@ bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
if (!usesPreprocessorOnly()) {
CI.createASTContext();
std::unique_ptr<ASTConsumer> Consumer(
CreateWrappedASTConsumer(CI, InputFile));
std::unique_ptr<ASTConsumer> Consumer =
CreateWrappedASTConsumer(CI, InputFile);
if (!Consumer)
goto failure;
@ -349,7 +350,7 @@ bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
goto failure;
}
CI.setASTConsumer(Consumer.release());
CI.setASTConsumer(std::move(Consumer));
if (!CI.hasASTConsumer())
goto failure;
}
@ -444,7 +445,7 @@ void FrontendAction::EndSourceFile() {
CI.resetAndLeakSema();
CI.resetAndLeakASTContext();
}
BuryPointer(CI.takeASTConsumer());
BuryPointer(CI.takeASTConsumer().get());
} else {
if (!isCurrentFileAST()) {
CI.setSema(nullptr);
@ -516,14 +517,15 @@ void ASTFrontendAction::ExecuteAction() {
void PluginASTAction::anchor() { }
ASTConsumer *
std::unique_ptr<ASTConsumer>
PreprocessorFrontendAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!");
}
ASTConsumer *WrapperFrontendAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
WrapperFrontendAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return WrappedAction->CreateASTConsumer(CI, InFile);
}
bool WrapperFrontendAction::BeginInvocation(CompilerInstance &CI) {

63
clang/lib/Frontend/FrontendActions.cpp
View File

@ -33,9 +33,9 @@ using namespace clang;
// Custom Actions
//===----------------------------------------------------------------------===//
ASTConsumer *InitOnlyAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return new ASTConsumer();
std::unique_ptr<ASTConsumer>
InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
return llvm::make_unique<ASTConsumer>();
}
void InitOnlyAction::ExecuteAction() {
@ -45,36 +45,37 @@ void InitOnlyAction::ExecuteAction() {
// AST Consumer Actions
//===----------------------------------------------------------------------===//
ASTConsumer *ASTPrintAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile))
return CreateASTPrinter(OS, CI.getFrontendOpts().ASTDumpFilter);
return nullptr;
}
ASTConsumer *ASTDumpAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
return CreateASTDumper(CI.getFrontendOpts().ASTDumpFilter,
CI.getFrontendOpts().ASTDumpLookups);
}
ASTConsumer *ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
return CreateASTDeclNodeLister();
}
ASTConsumer *ASTViewAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
return CreateASTViewer();
}
ASTConsumer *DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return CreateDeclContextPrinter();
}
ASTConsumer *GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
std::string Sysroot;
std::string OutputFile;
raw_ostream *OS = nullptr;
@ -83,8 +84,8 @@ ASTConsumer *GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI,
if (!CI.getFrontendOpts().RelocatablePCH)
Sysroot.clear();
return new PCHGenerator(CI.getPreprocessor(), OutputFile, nullptr, Sysroot,
OS);
return llvm::make_unique<PCHGenerator>(CI.getPreprocessor(), OutputFile,
nullptr, Sysroot, OS);
}
bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
@ -111,16 +112,17 @@ bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
return false;
}
ASTConsumer *GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<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 new PCHGenerator(CI.getPreprocessor(), OutputFile, Module,
Sysroot, OS);
return llvm::make_unique<PCHGenerator>(CI.getPreprocessor(), OutputFile,
Module, Sysroot, OS);
}
static SmallVectorImpl<char> &
@ -363,19 +365,20 @@ bool GenerateModuleAction::ComputeASTConsumerArguments(CompilerInstance &CI,
return false;
}
ASTConsumer *SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return new ASTConsumer();
std::unique_ptr<ASTConsumer>
SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
return llvm::make_unique<ASTConsumer>();
}
ASTConsumer *DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return new ASTConsumer();
std::unique_ptr<ASTConsumer>
DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return llvm::make_unique<ASTConsumer>();
}
ASTConsumer *VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return new ASTConsumer();
std::unique_ptr<ASTConsumer>
VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
return llvm::make_unique<ASTConsumer>();
}
void VerifyPCHAction::ExecuteAction() {

111
clang/lib/Frontend/MultiplexConsumer.cpp
View File

@ -183,118 +183,113 @@ void MultiplexASTMutationListener::DeclarationMarkedUsed(const Decl *D) {
} // end namespace clang
MultiplexConsumer::MultiplexConsumer(ArrayRef<ASTConsumer *> C)
: Consumers(C.begin(), C.end()), MutationListener(),
DeserializationListener() {
MultiplexConsumer::MultiplexConsumer(
std::vector<std::unique_ptr<ASTConsumer>> C)
: Consumers(std::move(C)), MutationListener(), DeserializationListener() {
// Collect the mutation listeners and deserialization listeners of all
// children, and create a multiplex listener each if so.
std::vector<ASTMutationListener*> mutationListeners;
std::vector<ASTDeserializationListener*> serializationListeners;
for (size_t i = 0, e = Consumers.size(); i != e; ++i) {
ASTMutationListener* mutationListener =
Consumers[i]->GetASTMutationListener();
if (mutationListener)
for (auto &Consumer : Consumers) {
if (auto *mutationListener = Consumer->GetASTMutationListener())
mutationListeners.push_back(mutationListener);
ASTDeserializationListener* serializationListener =
Consumers[i]->GetASTDeserializationListener();
if (serializationListener)
if (auto *serializationListener = Consumer->GetASTDeserializationListener())
serializationListeners.push_back(serializationListener);
}
if (mutationListeners.size()) {
MutationListener.reset(new MultiplexASTMutationListener(mutationListeners));
if (!mutationListeners.empty()) {
MutationListener =
llvm::make_unique<MultiplexASTMutationListener>(mutationListeners);
}
if (serializationListeners.size()) {
DeserializationListener.reset(
new MultiplexASTDeserializationListener(serializationListeners));
if (!serializationListeners.empty()) {
DeserializationListener =
llvm::make_unique<MultiplexASTDeserializationListener>(
serializationListeners);
}
}
MultiplexConsumer::~MultiplexConsumer() {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
delete Consumers[i];
}
MultiplexConsumer::~MultiplexConsumer() {}
void MultiplexConsumer::Initialize(ASTContext &Context) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->Initialize(Context);
for (auto &Consumer : Consumers)
Consumer->Initialize(Context);
}
bool MultiplexConsumer::HandleTopLevelDecl(DeclGroupRef D) {
bool Continue = true;
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Continue = Continue && Consumers[i]->HandleTopLevelDecl(D);
for (auto &Consumer : Consumers)
Continue = Continue && Consumer->HandleTopLevelDecl(D);
return Continue;
}
void MultiplexConsumer::HandleInlineMethodDefinition(CXXMethodDecl *D) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleInlineMethodDefinition(D);
for (auto &Consumer : Consumers)
Consumer->HandleInlineMethodDefinition(D);
}
void MultiplexConsumer::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleCXXStaticMemberVarInstantiation(VD);
void MultiplexConsumer::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
for (auto &Consumer : Consumers)
Consumer->HandleCXXStaticMemberVarInstantiation(VD);
}
void MultiplexConsumer::HandleInterestingDecl(DeclGroupRef D) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleInterestingDecl(D);
for (auto &Consumer : Consumers)
Consumer->HandleInterestingDecl(D);
}
void MultiplexConsumer::HandleTranslationUnit(ASTContext &Ctx) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleTranslationUnit(Ctx);
for (auto &Consumer : Consumers)
Consumer->HandleTranslationUnit(Ctx);
}
void MultiplexConsumer::HandleTagDeclDefinition(TagDecl *D) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleTagDeclDefinition(D);
for (auto &Consumer : Consumers)
Consumer->HandleTagDeclDefinition(D);
}
void MultiplexConsumer::HandleTagDeclRequiredDefinition(const TagDecl *D) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleTagDeclRequiredDefinition(D);
for (auto &Consumer : Consumers)
Consumer->HandleTagDeclRequiredDefinition(D);
}
void MultiplexConsumer::HandleCXXImplicitFunctionInstantiation(FunctionDecl *D){
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleCXXImplicitFunctionInstantiation(D);
for (auto &Consumer : Consumers)
Consumer->HandleCXXImplicitFunctionInstantiation(D);
}
void MultiplexConsumer::HandleTopLevelDeclInObjCContainer(DeclGroupRef D) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleTopLevelDeclInObjCContainer(D);
for (auto &Consumer : Consumers)
Consumer->HandleTopLevelDeclInObjCContainer(D);
}
void MultiplexConsumer::HandleImplicitImportDecl(ImportDecl *D) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleImplicitImportDecl(D);
for (auto &Consumer : Consumers)
Consumer->HandleImplicitImportDecl(D);
}
void MultiplexConsumer::HandleLinkerOptionPragma(llvm::StringRef Opts) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleLinkerOptionPragma(Opts);
for (auto &Consumer : Consumers)
Consumer->HandleLinkerOptionPragma(Opts);
}
void MultiplexConsumer::HandleDetectMismatch(llvm::StringRef Name, llvm::StringRef Value) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleDetectMismatch(Name, Value);
for (auto &Consumer : Consumers)
Consumer->HandleDetectMismatch(Name, Value);
}
void MultiplexConsumer::HandleDependentLibrary(llvm::StringRef Lib) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleDependentLibrary(Lib);
for (auto &Consumer : Consumers)
Consumer->HandleDependentLibrary(Lib);
}
void MultiplexConsumer::CompleteTentativeDefinition(VarDecl *D) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->CompleteTentativeDefinition(D);
for (auto &Consumer : Consumers)
Consumer->CompleteTentativeDefinition(D);
}
void MultiplexConsumer::HandleVTable(
CXXRecordDecl *RD, bool DefinitionRequired) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->HandleVTable(RD, DefinitionRequired);
for (auto &Consumer : Consumers)
Consumer->HandleVTable(RD, DefinitionRequired);
}
ASTMutationListener *MultiplexConsumer::GetASTMutationListener() {
@ -306,18 +301,18 @@ ASTDeserializationListener *MultiplexConsumer::GetASTDeserializationListener() {
}
void MultiplexConsumer::PrintStats() {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
Consumers[i]->PrintStats();
for (auto &Consumer : Consumers)
Consumer->PrintStats();
}
void MultiplexConsumer::InitializeSema(Sema &S) {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumers[i]))
for (auto &Consumer : Consumers)
if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumer.get()))
SC->InitializeSema(S);
}
void MultiplexConsumer::ForgetSema() {
for (size_t i = 0, e = Consumers.size(); i != e; ++i)
if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumers[i]))
for (auto &Consumer : Consumers)
if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumer.get()))
SC->ForgetSema();
}

14
clang/lib/Frontend/Rewrite/FrontendActions.cpp
View File

@ -30,8 +30,8 @@ using namespace clang;
// AST Consumer Actions
//===----------------------------------------------------------------------===//
ASTConsumer *HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<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 @@ ASTConsumer *HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI,
FixItAction::FixItAction() {}
FixItAction::~FixItAction() {}
ASTConsumer *FixItAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return new ASTConsumer();
std::unique_ptr<ASTConsumer>
FixItAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
return llvm::make_unique<ASTConsumer>();
}
namespace {
@ -148,8 +148,8 @@ bool FixItRecompile::BeginInvocation(CompilerInstance &CI) {
#ifdef CLANG_ENABLE_OBJC_REWRITER
ASTConsumer *RewriteObjCAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<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,

11
clang/lib/Frontend/Rewrite/HTMLPrint.cpp
View File

@ -47,11 +47,12 @@ namespace {
};
}
ASTConsumer* clang::CreateHTMLPrinter(raw_ostream *OS,
Preprocessor &PP,
bool SyntaxHighlight,
bool HighlightMacros) {
return new HTMLPrinter(OS, PP, SyntaxHighlight, HighlightMacros);
std::unique_ptr<ASTConsumer> clang::CreateHTMLPrinter(raw_ostream *OS,
Preprocessor &PP,
bool SyntaxHighlight,
bool HighlightMacros) {
return llvm::make_unique<HTMLPrinter>(OS, PP, SyntaxHighlight,
HighlightMacros);
}
void HTMLPrinter::Initialize(ASTContext &context) {

13
clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp
View File

@ -675,14 +675,11 @@ RewriteModernObjC::RewriteModernObjC(std::string inFile, raw_ostream* OS,
"for @try/@finally (code may not execute properly)");
}
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);
std::unique_ptr<ASTConsumer> clang::CreateModernObjCRewriter(
const std::string &InFile, raw_ostream *OS, DiagnosticsEngine &Diags,
const LangOptions &LOpts, bool SilenceRewriteMacroWarning, bool LineInfo) {
return llvm::make_unique<RewriteModernObjC>(
InFile, OS, Diags, LOpts, SilenceRewriteMacroWarning, LineInfo);
}
void RewriteModernObjC::InitializeCommon(ASTContext &context) {

12
clang/lib/Frontend/Rewrite/RewriteObjC.cpp
View File

@ -600,12 +600,12 @@ RewriteObjC::RewriteObjC(std::string inFile, raw_ostream* OS,
"for @try/@finally (code may not execute properly)");
}
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);
std::unique_ptr<ASTConsumer>
clang::CreateObjCRewriter(const std::string &InFile, raw_ostream *OS,
DiagnosticsEngine &Diags, const LangOptions &LOpts,
bool SilenceRewriteMacroWarning) {
return llvm::make_unique<RewriteObjCFragileABI>(InFile, OS, Diags, LOpts,
SilenceRewriteMacroWarning);
}
void RewriteObjC::InitializeCommon(ASTContext &context) {

4
clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp
View File

@ -687,14 +687,14 @@ void AnalysisConsumer::RunPathSensitiveChecks(Decl *D,
// AnalysisConsumer creation.
//===----------------------------------------------------------------------===//
AnalysisASTConsumer *
std::unique_ptr<AnalysisASTConsumer>
ento::CreateAnalysisConsumer(const Preprocessor &pp, const std::string &outDir,
AnalyzerOptionsRef opts,
ArrayRef<std::string> plugins) {
// Disable the effects of '-Werror' when using the AnalysisConsumer.
pp.getDiagnostics().setWarningsAsErrors(false);
return new AnalysisConsumer(pp, outDir, opts, plugins);
return llvm::make_unique<AnalysisConsumer>(pp, outDir, opts, plugins);
}
//===----------------------------------------------------------------------===//

4
clang/lib/StaticAnalyzer/Frontend/FrontendActions.cpp
View File

@ -13,8 +13,8 @@
using namespace clang;
using namespace ento;
ASTConsumer *AnalysisAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
std::unique_ptr<ASTConsumer>
AnalysisAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
return CreateAnalysisConsumer(CI.getPreprocessor(),
CI.getFrontendOpts().OutputFile,
CI.getAnalyzerOpts(),

5
clang/tools/clang-check/ClangCheck.cpp
View File

@ -28,6 +28,7 @@
#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;
@ -179,14 +180,14 @@ private:
namespace clang_check {
class ClangCheckActionFactory {
public:
clang::ASTConsumer *newASTConsumer() {
std::unique_ptr<clang::ASTConsumer> newASTConsumer() {
if (ASTList)
return clang::CreateASTDeclNodeLister();
if (ASTDump)
return clang::CreateASTDumper(ASTDumpFilter);
if (ASTPrint)
return clang::CreateASTPrinter(&llvm::outs(), ASTDumpFilter);
return new clang::ASTConsumer();
return llvm::make_unique<clang::ASTConsumer>();
}
};
}

11
clang/tools/libclang/Indexing.cpp
View File

@ -414,8 +414,8 @@ public:
: IndexCtx(clientData, indexCallbacks, indexOptions, cxTU),
CXTU(cxTU), SKData(skData) { }
ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override {
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override {
PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
if (!PPOpts.ImplicitPCHInclude.empty()) {
@ -429,13 +429,12 @@ public:
IndexCtx.setPreprocessor(PP);
if (SKData) {
PPConditionalDirectiveRecord *
PPRec = new PPConditionalDirectiveRecord(PP.getSourceManager());
auto *PPRec = new PPConditionalDirectiveRecord(PP.getSourceManager());
PP.addPPCallbacks(PPRec);
SKCtrl.reset(new TUSkipBodyControl(*SKData, *PPRec, PP));
SKCtrl = llvm::make_unique<TUSkipBodyControl>(*SKData, *PPRec, PP);
}
return new IndexingConsumer(IndexCtx, SKCtrl.get());
return llvm::make_unique<IndexingConsumer>(IndexCtx, SKCtrl.get());
}
void EndSourceFileAction() override {

7
clang/unittests/AST/EvaluateAsRValueTest.cpp
View File

@ -59,9 +59,10 @@ class EvaluateConstantInitializersVisitor
class EvaluateConstantInitializersAction : public clang::ASTFrontendAction {
public:
clang::ASTConsumer *CreateASTConsumer(clang::CompilerInstance &Compiler,
llvm::StringRef FilePath) override {
return new Consumer;
std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance &Compiler,
llvm::StringRef FilePath) override {
return llvm::make_unique<Consumer>();
}
private:

6
clang/unittests/AST/ExternalASTSourceTest.cpp
View File

@ -35,9 +35,9 @@ private:
return ASTFrontendAction::ExecuteAction();
}
virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return new ASTConsumer;
virtual std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return llvm::make_unique<ASTConsumer>();
}
IntrusiveRefCntPtr<ExternalASTSource> Source;

4
clang/unittests/AST/NamedDeclPrinterTest.cpp
View File

@ -68,8 +68,8 @@ PrintedNamedDeclMatches(StringRef Code, const std::vector<std::string> &Args,
PrintMatch Printer(SuppressUnwrittenScope);
MatchFinder Finder;
Finder.addMatcher(NodeMatch, &Printer);
std::unique_ptr<FrontendActionFactory> Factory(
newFrontendActionFactory(&Finder));
std::unique_ptr<FrontendActionFactory> Factory =
newFrontendActionFactory(&Finder);
if (!runToolOnCodeWithArgs(Factory->create(), Code, Args, FileName))
return testing::AssertionFailure()

6
clang/unittests/Frontend/FrontendActionTest.cpp
View File

@ -38,9 +38,9 @@ public:
return ASTFrontendAction::BeginSourceFileAction(ci, filename);
}
virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return new Visitor(decl_names);
virtual std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) {
return llvm::make_unique<Visitor>(decl_names);
}
private:

4
clang/unittests/Sema/ExternalSemaSourceTest.cpp
View File

@ -140,10 +140,10 @@ class ExternalSemaSourceInstaller : public clang::ASTFrontendAction {
std::unique_ptr<DiagnosticConsumer> OwnedClient;
protected:
virtual clang::ASTConsumer *
virtual std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance &Compiler,
llvm::StringRef /* dummy */) {
return new clang::ASTConsumer();
return llvm::make_unique<clang::ASTConsumer>();
}
virtual void ExecuteAction() {

7
clang/unittests/Tooling/RefactoringTest.cpp
View File

@ -299,11 +299,12 @@ private:
public:
TestAction(TestVisitor *Visitor) : Visitor(Visitor) {}
virtual clang::ASTConsumer* CreateASTConsumer(
clang::CompilerInstance& compiler, llvm::StringRef dummy) {
virtual std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance &compiler,
llvm::StringRef dummy) {
Visitor->SM = &compiler.getSourceManager();
/// TestConsumer will be deleted by the framework calling us.
return new FindConsumer(Visitor);
return llvm::make_unique<FindConsumer>(Visitor);
}
private:

6
clang/unittests/Tooling/TestVisitor.h
View File

@ -95,10 +95,10 @@ protected:
public:
TestAction(TestVisitor *Visitor) : Visitor(Visitor) {}
virtual clang::ASTConsumer* CreateASTConsumer(
CompilerInstance&, llvm::StringRef dummy) {
virtual std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(CompilerInstance &, llvm::StringRef dummy) {
/// TestConsumer will be deleted by the framework calling us.
return new FindConsumer(Visitor);
return llvm::make_unique<FindConsumer>(Visitor);
}
protected:

50
clang/unittests/Tooling/ToolingTest.cpp
View File

@ -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(clang::ASTConsumer *TestConsumer)
: TestConsumer(TestConsumer) {}
explicit TestAction(std::unique_ptr<clang::ASTConsumer> TestConsumer)
: TestConsumer(std::move(TestConsumer)) {}
protected:
virtual clang::ASTConsumer* CreateASTConsumer(
clang::CompilerInstance& compiler, StringRef dummy) {
protected:
virtual std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance &compiler, StringRef dummy) {
/// TestConsumer will be deleted by the framework calling us.
return TestConsumer;
return std::move(TestConsumer);
}
private:
clang::ASTConsumer * const TestConsumer;
private:
std::unique_ptr<clang::ASTConsumer> TestConsumer;
};
class FindTopLevelDeclConsumer : public clang::ASTConsumer {
@ -59,8 +59,10 @@ class FindTopLevelDeclConsumer : public clang::ASTConsumer {
TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) {
bool FoundTopLevelDecl = false;
EXPECT_TRUE(runToolOnCode(
new TestAction(new FindTopLevelDeclConsumer(&FoundTopLevelDecl)), ""));
EXPECT_TRUE(
runToolOnCode(new TestAction(llvm::make_unique<FindTopLevelDeclConsumer>(
&FoundTopLevelDecl)),
""));
EXPECT_FALSE(FoundTopLevelDecl);
}
@ -97,13 +99,17 @@ bool FindClassDeclX(ASTUnit *AST) {
TEST(runToolOnCode, FindsClassDecl) {
bool FoundClassDeclX = false;
EXPECT_TRUE(runToolOnCode(new TestAction(
new FindClassDeclXConsumer(&FoundClassDeclX)), "class X;"));
EXPECT_TRUE(
runToolOnCode(new TestAction(llvm::make_unique<FindClassDeclXConsumer>(
&FoundClassDeclX)),
"class X;"));
EXPECT_TRUE(FoundClassDeclX);
FoundClassDeclX = false;
EXPECT_TRUE(runToolOnCode(new TestAction(
new FindClassDeclXConsumer(&FoundClassDeclX)), "class Y;"));
EXPECT_TRUE(
runToolOnCode(new TestAction(llvm::make_unique<FindClassDeclXConsumer>(
&FoundClassDeclX)),
"class Y;"));
EXPECT_FALSE(FoundClassDeclX);
}
@ -125,8 +131,8 @@ TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) {
}
struct IndependentFrontendActionCreator {
ASTConsumer *newASTConsumer() {
return new FindTopLevelDeclConsumer(nullptr);
std::unique_ptr<ASTConsumer> newASTConsumer() {
return llvm::make_unique<FindTopLevelDeclConsumer>(nullptr);
}
};
@ -185,8 +191,8 @@ struct VerifyEndCallback : public SourceFileCallbacks {
virtual void handleEndSource() {
++EndCalled;
}
ASTConsumer *newASTConsumer() {
return new FindTopLevelDeclConsumer(&Matched);
std::unique_ptr<ASTConsumer> newASTConsumer() {
return llvm::make_unique<FindTopLevelDeclConsumer>(&Matched);
}
unsigned BeginCalled;
unsigned EndCalled;
@ -225,10 +231,10 @@ struct SkipBodyConsumer : public clang::ASTConsumer {
};
struct SkipBodyAction : public clang::ASTFrontendAction {
virtual ASTConsumer *CreateASTConsumer(CompilerInstance &Compiler,
StringRef) {
virtual std::unique_ptr<ASTConsumer>
CreateASTConsumer(CompilerInstance &Compiler, StringRef) {
Compiler.getFrontendOpts().SkipFunctionBodies = true;
return new SkipBodyConsumer;
return llvm::make_unique<SkipBodyConsumer>();
}
};