}
}
- Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
+ Transform *createTransform(const TransformOptions &Opts) override {
return new AddOverrideTransform(Opts);
}
};
/// \see Transform::run().
virtual int apply(const clang::tooling::CompilationDatabase &Database,
- const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
+ const std::vector<std::string> &SourcePaths) override;
virtual bool handleBeginSource(clang::CompilerInstance &CI,
- llvm::StringRef Filename) LLVM_OVERRIDE;
+ llvm::StringRef Filename) override;
private:
AddOverrideFixer *Fixer;
StringRef FileName, bool IsAngled,
CharSourceRange FilenameRange, const FileEntry *File,
StringRef SearchPath, StringRef RelativePath,
- const Module *Imported) LLVM_OVERRIDE {
+ const Module *Imported) override {
SourceManager &SM = Self->Sources;
const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(HashLoc));
assert(FE && "Valid file expected.");
// Keep track of the current file in the stack
virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
SrcMgr::CharacteristicKind FileType,
- FileID PrevFID) LLVM_OVERRIDE {
+ FileID PrevFID) override {
SourceManager &SM = Self->Sources;
switch (Reason) {
case EnterFile:
}
virtual void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
- const MacroDirective *MD) LLVM_OVERRIDE {
+ const MacroDirective *MD) override {
Guard->Count++;
// If this #ifndef is the top-most directive and the symbol isn't defined
}
virtual void MacroDefined(const Token &MacroNameTok,
- const MacroDirective *MD) LLVM_OVERRIDE {
+ const MacroDirective *MD) override {
Guard->Count++;
// If this #define is the second directive of the file and the symbol
}
}
- virtual void Endif(SourceLocation Loc, SourceLocation IfLoc) LLVM_OVERRIDE {
+ virtual void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
Guard->Count++;
// If it's the #endif corresponding to the top-most #ifndef
}
virtual void MacroExpands(const Token &, const MacroDirective *, SourceRange,
- const MacroArgs *) LLVM_OVERRIDE {
+ const MacroArgs *) override {
Guard->Count++;
}
virtual void MacroUndefined(const Token &,
- const MacroDirective *) LLVM_OVERRIDE {
+ const MacroDirective *) override {
Guard->Count++;
}
virtual void Defined(const Token &, const MacroDirective *,
- SourceRange) LLVM_OVERRIDE {
+ SourceRange) override {
Guard->Count++;
}
virtual void If(SourceLocation, SourceRange,
- ConditionValueKind) LLVM_OVERRIDE {
+ ConditionValueKind) override {
Guard->Count++;
}
virtual void Elif(SourceLocation, SourceRange, ConditionValueKind,
- SourceLocation) LLVM_OVERRIDE {
+ SourceLocation) override {
Guard->Count++;
}
virtual void Ifdef(SourceLocation, const Token &,
- const MacroDirective *) LLVM_OVERRIDE {
+ const MacroDirective *) override {
Guard->Count++;
}
- virtual void Else(SourceLocation, SourceLocation) LLVM_OVERRIDE {
+ virtual void Else(SourceLocation, SourceLocation) override {
Guard->Count++;
}
ActionFactory(MatchFinder &Finder, Transform &Owner)
: Finder(Finder), Owner(Owner) {}
- virtual FrontendAction *create() LLVM_OVERRIDE {
+ virtual FrontendAction *create() override {
return new FactoryAdaptor(Finder, Owner);
}
}
virtual bool BeginSourceFileAction(CompilerInstance &CI,
- StringRef Filename) LLVM_OVERRIDE {
+ StringRef Filename) override {
if (!ASTFrontendAction::BeginSourceFileAction(CI, Filename))
return false;
return Owner.handleBeginSource(CI, Filename);
}
- virtual void EndSourceFileAction() LLVM_OVERRIDE {
+ virtual void EndSourceFileAction() override {
Owner.handleEndSource();
return ASTFrontendAction::EndSourceFileAction();
}
/// Since.Msvc = Version(10);
/// }
///
-/// Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
+/// Transform *createTransform(const TransformOptions &Opts) override {
/// return new MyTransform(Opts);
/// }
/// };
Since.Msvc = Version(11);
}
- Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
+ Transform *createTransform(const TransformOptions &Opts) override {
return new LoopConvertTransform(Opts);
}
};
#define CLANG_MODERNIZE_LOOP_CONVERT_H
#include "Core/Transform.h"
-#include "llvm/Support/Compiler.h" // For LLVM_OVERRIDE
+#include "llvm/Support/Compiler.h" // For override
// Forward decl for private implementation.
struct TUTrackingInfo;
/// \see Transform::run().
virtual int apply(const clang::tooling::CompilationDatabase &Database,
- const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
+ const std::vector<std::string> &SourcePaths) override;
virtual bool handleBeginSource(clang::CompilerInstance &CI,
- llvm::StringRef Filename) LLVM_OVERRIDE;
+ llvm::StringRef Filename) override;
private:
llvm::OwningPtr<TUTrackingInfo> TUInfo;
};
Since.Msvc = Version(11);
}
- Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
+ Transform *createTransform(const TransformOptions &Opts) override {
return new PassByValueTransform(Opts);
}
};
/// \see Transform::apply().
virtual int apply(const clang::tooling::CompilationDatabase &Database,
- const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
+ const std::vector<std::string> &SourcePaths) override;
private:
/// \brief Setups the \c IncludeDirectives for the replacer.
virtual bool handleBeginSource(clang::CompilerInstance &CI,
- llvm::StringRef Filename) LLVM_OVERRIDE;
+ llvm::StringRef Filename) override;
llvm::OwningPtr<IncludeDirectives> IncludeManager;
ConstructorParamReplacer *Replacer;
private:
/// \brief Entry point to the callback called when matches are made.
virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
- LLVM_OVERRIDE;
+ override;
unsigned &AcceptedChanges;
unsigned &RejectedChanges;
Since.Msvc = Version(11);
}
- Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
+ Transform *createTransform(const TransformOptions &Opts) override {
return new ReplaceAutoPtrTransform(Opts);
}
};
/// \see Transform::run().
virtual int apply(const clang::tooling::CompilationDatabase &Database,
- const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
+ const std::vector<std::string> &SourcePaths) override;
};
#endif // CLANG_MODERNIZE_REPLACE_AUTO_PTR_H
/// \brief Entry point to the callback called when matches are made.
virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
- LLVM_OVERRIDE;
+ override;
private:
/// \brief Locates the \c auto_ptr token when it is referred by a \c TypeLoc.
/// \brief Entry point to the callback called when matches are made.
virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
- LLVM_OVERRIDE;
+ override;
private:
unsigned &AcceptedChanges;
Since.Msvc = Version(10);
}
- Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
+ Transform *createTransform(const TransformOptions &Opts) override {
return new UseAutoTransform(Opts);
}
};
/// \see Transform::run().
virtual int apply(const clang::tooling::CompilationDatabase &Database,
- const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
+ const std::vector<std::string> &SourcePaths) override;
};
#endif // CLANG_MODERNIZE_USE_AUTO_H
/// \brief Entry point to the callback called when matches are made.
virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
- LLVM_OVERRIDE;
+ override;
private:
unsigned &AcceptedChanges;
/// \brief Entry point to the callback called when matches are made.
virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
- LLVM_OVERRIDE;
+ override;
private:
unsigned &AcceptedChanges;
Since.Msvc = Version(10);
}
- Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
+ Transform *createTransform(const TransformOptions &Opts) override {
return new UseNullptrTransform(Opts);
}
};
#define CLANG_MODERNIZE_USE_NULLPTR_H
#include "Core/Transform.h"
-#include "llvm/Support/Compiler.h" // For LLVM_OVERRIDE
+#include "llvm/Support/Compiler.h" // For override
/// \brief Subclass of Transform that transforms null pointer constants into
/// C++11's nullptr keyword where possible.
/// \see Transform::run().
virtual int apply(const clang::tooling::CompilationDatabase &Database,
- const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
+ const std::vector<std::string> &SourcePaths) override;
};
#endif // CLANG_MODERNIZE_USE_NULLPTR_H
/// Any query which resulted in a parse error. The error message is in ErrStr.
struct InvalidQuery : Query {
InvalidQuery(const Twine &ErrStr) : Query(QK_Invalid), ErrStr(ErrStr.str()) {}
- bool run(llvm::raw_ostream &OS, QuerySession &QS) const LLVM_OVERRIDE;
+ bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
std::string ErrStr;
/// No-op query (i.e. a blank line).
struct NoOpQuery : Query {
NoOpQuery() : Query(QK_NoOp) {}
- bool run(llvm::raw_ostream &OS, QuerySession &QS) const LLVM_OVERRIDE;
+ bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
static bool classof(const Query *Q) { return Q->Kind == QK_NoOp; }
};
/// Query for "help".
struct HelpQuery : Query {
HelpQuery() : Query(QK_Help) {}
- bool run(llvm::raw_ostream &OS, QuerySession &QS) const LLVM_OVERRIDE;
+ bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
static bool classof(const Query *Q) { return Q->Kind == QK_Help; }
};
struct MatchQuery : Query {
MatchQuery(const ast_matchers::dynamic::DynTypedMatcher &Matcher)
: Query(QK_Match), Matcher(Matcher) {}
- bool run(llvm::raw_ostream &OS, QuerySession &QS) const LLVM_OVERRIDE;
+ bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
ast_matchers::dynamic::DynTypedMatcher Matcher;
template <typename T> struct SetQuery : Query {
SetQuery(T QuerySession::*Var, T Value)
: Query(SetQueryKind<T>::value), Var(Var), Value(Value) {}
- bool run(llvm::raw_ostream &OS, QuerySession &QS) const LLVM_OVERRIDE {
+ bool run(llvm::raw_ostream &OS, QuerySession &QS) const override {
QS.*Var = Value;
return true;
}
AnalyzerDiagnosticConsumer(ClangTidyContext &Context) : Context(Context) {}
void FlushDiagnosticsImpl(std::vector<const ento::PathDiagnostic *> &Diags,
- FilesMade *filesMade) LLVM_OVERRIDE {
+ FilesMade *filesMade) override {
for (std::vector<const ento::PathDiagnostic *>::iterator I = Diags.begin(),
E = Diags.end();
I != E; ++I) {
}
}
- StringRef getName() const LLVM_OVERRIDE { return "ClangTidyDiags"; }
- bool supportsLogicalOpControlFlow() const LLVM_OVERRIDE { return true; }
- bool supportsCrossFileDiagnostics() const LLVM_OVERRIDE { return true; }
+ StringRef getName() const override { return "ClangTidyDiags"; }
+ bool supportsLogicalOpControlFlow() const override { return true; }
+ bool supportsCrossFileDiagnostics() const override { return true; }
private:
ClangTidyContext &Context;
public:
ActionFactory(ClangTidyASTConsumerFactory *ConsumerFactory)
: ConsumerFactory(ConsumerFactory) {}
- FrontendAction *create() LLVM_OVERRIDE {
+ FrontendAction *create() override {
return new Action(ConsumerFactory);
}
public:
Action(ClangTidyASTConsumerFactory *Factory) : Factory(Factory) {}
ASTConsumer *CreateASTConsumer(CompilerInstance &Compiler,
- StringRef File) LLVM_OVERRIDE {
+ StringRef File) override {
return Factory->CreateASTConsumer(Compiler, File);
}
void setName(StringRef Name);
private:
- void run(const ast_matchers::MatchFinder::MatchResult &Result) LLVM_OVERRIDE;
+ void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
ClangTidyContext *Context;
std::string CheckName;
};
// more generic and should be pulled out into a more useful Diagnostics
// library.
void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
- const Diagnostic &Info) LLVM_OVERRIDE;
+ const Diagnostic &Info) override;
// Flushes the internal diagnostics buffer to the ClangTidyContext.
- void finish() LLVM_OVERRIDE;
+ void finish() override;
private:
void addFixes(const Diagnostic &Info, ClangTidyError &Error);
/// For example, if have a clang-tidy check like:
/// \code
/// class MyTidyCheck : public ClangTidyCheck {
-/// void registerMatchers(ast_matchers::MatchFinder *Finder) LLVM_OVERRIDE {
+/// void registerMatchers(ast_matchers::MatchFinder *Finder) override {
/// ..
/// }
/// };
/// \code
/// class MyModule : public ClangTidyModule {
/// void
-/// addCheckFactories(ClangTidyCheckFactories &CheckFactories) LLVM_OVERRIDE {
+/// addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
/// CheckFactories.addCheckFactory(
/// "myproject-my-check", new ClangTidyCheckFactory<MyTidyCheck>());
/// }
/// \endcode
template <typename T> class ClangTidyCheckFactory : public CheckFactoryBase {
public:
- ClangTidyCheck *createCheck() LLVM_OVERRIDE { return new T; }
+ ClangTidyCheck *createCheck() override { return new T; }
};
class ClangTidyCheckFactories;
class GoogleModule : public ClangTidyModule {
public:
void
- addCheckFactories(ClangTidyCheckFactories &CheckFactories) LLVM_OVERRIDE {
+ addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.addCheckFactory(
"google-explicit-constructor",
new ClangTidyCheckFactory<ExplicitConstructorCheck>());
/// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Explicit_Constructors
class ExplicitConstructorCheck : public ClangTidyCheck {
public:
- void registerMatchers(ast_matchers::MatchFinder *Finder) LLVM_OVERRIDE;
+ void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void
- check(const ast_matchers::MatchFinder::MatchResult &Result) LLVM_OVERRIDE;
+ check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
} // namespace tidy
StringRef FileName, bool IsAngled,
CharSourceRange FilenameRange, const FileEntry *File,
StringRef SearchPath, StringRef RelativePath,
- const Module *Imported) LLVM_OVERRIDE {
+ const Module *Imported) override {
// FIXME: This is a dummy implementation to show how to get at preprocessor
// information. Implement a real include order check.
Check.diag(HashLoc, "This is an include");
class LLVMModule : public ClangTidyModule {
public:
void
- addCheckFactories(ClangTidyCheckFactories &CheckFactories) LLVM_OVERRIDE {
+ addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.addCheckFactory(
"llvm-include-order", new ClangTidyCheckFactory<IncludeOrderCheck>());
CheckFactories.addCheckFactory(
/// see: http://llvm.org/docs/CodingStandards.html#include-style
class IncludeOrderCheck : public ClangTidyCheck {
public:
- void registerPPCallbacks(CompilerInstance &Compiler) LLVM_OVERRIDE;
+ void registerPPCallbacks(CompilerInstance &Compiler) override;
};
/// \brief Checks that long namespaces have a closing comment.
/// see: http://llvm.org/docs/CodingStandards.html#namespace-indentation
class NamespaceCommentCheck : public ClangTidyCheck {
public:
- void registerMatchers(ast_matchers::MatchFinder *Finder) LLVM_OVERRIDE;
+ void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void
- check(const ast_matchers::MatchFinder::MatchResult &Result) LLVM_OVERRIDE;
+ check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
} // namespace tidy
Using Expands-to-Override Macros
================================
-Like LLVM's ``LLVM_OVERRIDE``, several projects have macros that conditionally
+Like LLVM's ``override``, several projects have macros that conditionally
expand to the ``override`` keyword when compiling with C++11 features enabled.
To maintain compatibility with non-C++11 builds, the Add-Override Transform
supports detection and use of these macros instead of using the ``override``
class MyModule : public ClangTidyModule {
public:
virtual void
- addCheckFactories(ClangTidyCheckFactories &CheckFactories) LLVM_OVERRIDE {
+ addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.addCheckFactory(
"my-explicit-constructor",
new ClangTidyCheckFactory<ExplicitConstructorCheck>());
void FileChanged(clang::SourceLocation Loc,
clang::PPCallbacks::FileChangeReason Reason,
clang::SrcMgr::CharacteristicKind FileType,
- clang::FileID PrevFID = clang::FileID()) LLVM_OVERRIDE;
+ clang::FileID PrevFID = clang::FileID()) override;
void FileSkipped(const clang::FileEntry &ParentFile,
const clang::Token &FilenameTok,
- clang::SrcMgr::CharacteristicKind FileType) LLVM_OVERRIDE;
+ clang::SrcMgr::CharacteristicKind FileType) override;
bool FileNotFound(llvm::StringRef FileName,
- llvm::SmallVectorImpl<char> &RecoveryPath) LLVM_OVERRIDE;
+ llvm::SmallVectorImpl<char> &RecoveryPath) override;
void InclusionDirective(clang::SourceLocation HashLoc,
const clang::Token &IncludeTok,
llvm::StringRef FileName, bool IsAngled,
const clang::FileEntry *File,
llvm::StringRef SearchPath,
llvm::StringRef RelativePath,
- const clang::Module *Imported) LLVM_OVERRIDE;
+ const clang::Module *Imported) override;
void moduleImport(clang::SourceLocation ImportLoc, clang::ModuleIdPath Path,
- const clang::Module *Imported) LLVM_OVERRIDE;
- void EndOfMainFile() LLVM_OVERRIDE;
- void Ident(clang::SourceLocation Loc, const std::string &str) LLVM_OVERRIDE;
+ const clang::Module *Imported) override;
+ void EndOfMainFile() override;
+ void Ident(clang::SourceLocation Loc, const std::string &str) override;
void PragmaDirective(clang::SourceLocation Loc,
- clang::PragmaIntroducerKind Introducer) LLVM_OVERRIDE;
+ clang::PragmaIntroducerKind Introducer) override;
void PragmaComment(clang::SourceLocation Loc,
const clang::IdentifierInfo *Kind,
- const std::string &Str) LLVM_OVERRIDE;
+ const std::string &Str) override;
void PragmaDetectMismatch(clang::SourceLocation Loc, const std::string &Name,
- const std::string &Value) LLVM_OVERRIDE;
+ const std::string &Value) override;
void PragmaDebug(clang::SourceLocation Loc,
- llvm::StringRef DebugType) LLVM_OVERRIDE;
+ llvm::StringRef DebugType) override;
void PragmaMessage(clang::SourceLocation Loc, llvm::StringRef Namespace,
clang::PPCallbacks::PragmaMessageKind Kind,
- llvm::StringRef Str) LLVM_OVERRIDE;
+ llvm::StringRef Str) override;
void PragmaDiagnosticPush(clang::SourceLocation Loc,
- llvm::StringRef Namespace) LLVM_OVERRIDE;
+ llvm::StringRef Namespace) override;
void PragmaDiagnosticPop(clang::SourceLocation Loc,
- llvm::StringRef Namespace) LLVM_OVERRIDE;
+ llvm::StringRef Namespace) override;
void PragmaDiagnostic(clang::SourceLocation Loc, llvm::StringRef Namespace,
clang::diag::Mapping mapping,
- llvm::StringRef Str) LLVM_OVERRIDE;
+ llvm::StringRef Str) override;
void PragmaOpenCLExtension(clang::SourceLocation NameLoc,
const clang::IdentifierInfo *Name,
clang::SourceLocation StateLoc,
- unsigned State) LLVM_OVERRIDE;
+ unsigned State) override;
void PragmaWarning(clang::SourceLocation Loc, llvm::StringRef WarningSpec,
- llvm::ArrayRef<int> Ids) LLVM_OVERRIDE;
- void PragmaWarningPush(clang::SourceLocation Loc, int Level) LLVM_OVERRIDE;
- void PragmaWarningPop(clang::SourceLocation Loc) LLVM_OVERRIDE;
+ llvm::ArrayRef<int> Ids) override;
+ void PragmaWarningPush(clang::SourceLocation Loc, int Level) override;
+ void PragmaWarningPop(clang::SourceLocation Loc) override;
void MacroExpands(const clang::Token &MacroNameTok,
const clang::MacroDirective *MD, clang::SourceRange Range,
- const clang::MacroArgs *Args) LLVM_OVERRIDE;
+ const clang::MacroArgs *Args) override;
void MacroDefined(const clang::Token &MacroNameTok,
- const clang::MacroDirective *MD) LLVM_OVERRIDE;
+ const clang::MacroDirective *MD) override;
void MacroUndefined(const clang::Token &MacroNameTok,
- const clang::MacroDirective *MD) LLVM_OVERRIDE;
+ const clang::MacroDirective *MD) override;
void Defined(const clang::Token &MacroNameTok,
const clang::MacroDirective *MD,
- clang::SourceRange Range) LLVM_OVERRIDE;
- void SourceRangeSkipped(clang::SourceRange Range) LLVM_OVERRIDE;
+ clang::SourceRange Range) override;
+ void SourceRangeSkipped(clang::SourceRange Range) override;
void If(clang::SourceLocation Loc, clang::SourceRange ConditionRange,
- ConditionValueKind ConditionValue) LLVM_OVERRIDE;
+ ConditionValueKind ConditionValue) override;
void Elif(clang::SourceLocation Loc, clang::SourceRange ConditionRange,
- ConditionValueKind ConditionValue, clang::SourceLocation IfLoc) LLVM_OVERRIDE;
+ ConditionValueKind ConditionValue, clang::SourceLocation IfLoc) override;
void Ifdef(clang::SourceLocation Loc, const clang::Token &MacroNameTok,
- const clang::MacroDirective *MD) LLVM_OVERRIDE;
+ const clang::MacroDirective *MD) override;
void Ifndef(clang::SourceLocation Loc, const clang::Token &MacroNameTok,
- const clang::MacroDirective *MD) LLVM_OVERRIDE;
+ const clang::MacroDirective *MD) override;
void Else(clang::SourceLocation Loc,
- clang::SourceLocation IfLoc) LLVM_OVERRIDE;
+ clang::SourceLocation IfLoc) override;
void Endif(clang::SourceLocation Loc,
- clang::SourceLocation IfLoc) LLVM_OVERRIDE;
+ clang::SourceLocation IfLoc) override;
// Helper functions.
private:
virtual bool BeginSourceFileAction(CompilerInstance &CI,
- StringRef FileName) LLVM_OVERRIDE {
+ StringRef FileName) override {
if (!PreprocessOnlyAction::BeginSourceFileAction(CI, FileName))
return false;
VFHelper.mapVirtualFiles(CI.getSourceManager());
return true;
}
- virtual void EndSourceFileAction() LLVM_OVERRIDE {
+ virtual void EndSourceFileAction() override {
const tooling::Replacement &Replace =
FileIncludes->addAngledInclude(FileToModify, Include);
if (Replace.isApplicable())
private:
bool BeginSourceFileAction(CompilerInstance &Compiler,
- llvm::StringRef file_name) LLVM_OVERRIDE {
+ llvm::StringRef file_name) override {
Context->setSourceManager(&Compiler.getSourceManager());
Check.registerPPCallbacks(Compiler);
return true;