Sorry for the breakage. I was hoping that r245471 fixes it, but apparently, it didn't. And yes, we may need help reproducing the issue / testing possible fixes, as the only platform where the test fails, is Darwin.
On Wed, Aug 19, 2015 at 10:32 PM, Justin Bogner <m...@justinbogner.com> wrote: > Justin Bogner <m...@justinbogner.com> writes: > > Alexander Kornienko via cfe-commits <cfe-commits@lists.llvm.org> writes: > >> Author: alexfh > >> Date: Wed Aug 19 08:13:12 2015 > >> New Revision: 245434 > >> > >> URL: http://llvm.org/viewvc/llvm-project?rev=245434&view=rev > >> Log: > >> [clang-tidy] Add use-nullptr check to clang-tidy. > >> > >> Move UseNullptr from clang-modernize to modernize module in clang-tidy. > >> > >> http://reviews.llvm.org/D12081 > > > > The test this added has been failing tests on Darwin all morning, but it > > doesn't revert cleanly. Can you fix this fairly quickly? Otherwise I'll > > try harder to revert. > > > > > http://lab.llvm.org:8080/green/job/clang-stage1-configure-RA_check/10339/ > > Reverted in r245493. Angel: feel free to ping me if you need help > debugging the problem locally. > > >> > >> Patch by Angel Garcia! > >> > >> Added: > >> clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.cpp > >> clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.h > >> > clang-tools-extra/trunk/test/clang-tidy/modernize-use-nullptr-basic.cpp > >> clang-tools-extra/trunk/test/clang-tidy/modernize-use-nullptr.cpp > >> Modified: > >> clang-tools-extra/trunk/clang-tidy/modernize/CMakeLists.txt > >> clang-tools-extra/trunk/clang-tidy/modernize/ModernizeTidyModule.cpp > >> > >> Modified: clang-tools-extra/trunk/clang-tidy/modernize/CMakeLists.txt > >> URL: > >> > > > http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clang-tidy/modernize/CMakeLists.txt?rev=245434&r1=245433&r2=245434&view=diff > >> > ============================================================================== > >> --- clang-tools-extra/trunk/clang-tidy/modernize/CMakeLists.txt > (original) > >> +++ clang-tools-extra/trunk/clang-tidy/modernize/CMakeLists.txt Wed > > Aug 19 08:13:12 2015 > >> @@ -5,6 +5,7 @@ add_clang_library(clangTidyModernizeModu > >> LoopConvertUtils.cpp > >> ModernizeTidyModule.cpp > >> PassByValueCheck.cpp > >> + UseNullptrCheck.cpp > >> > >> LINK_LIBS > >> clangAST > >> > >> Modified: > clang-tools-extra/trunk/clang-tidy/modernize/ModernizeTidyModule.cpp > >> URL: > > > http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clang-tidy/modernize/ModernizeTidyModule.cpp?rev=245434&r1=245433&r2=245434&view=diff > >> > ============================================================================== > >> --- > > clang-tools-extra/trunk/clang-tidy/modernize/ModernizeTidyModule.cpp > > (original) > >> +++ > > clang-tools-extra/trunk/clang-tidy/modernize/ModernizeTidyModule.cpp > > Wed Aug 19 08:13:12 2015 > >> @@ -12,6 +12,7 @@ > >> #include "../ClangTidyModuleRegistry.h" > >> #include "LoopConvertCheck.h" > >> #include "PassByValueCheck.h" > >> +#include "UseNullptrCheck.h" > >> > >> using namespace clang::ast_matchers; > >> > >> @@ -24,6 +25,7 @@ public: > >> void addCheckFactories(ClangTidyCheckFactories &CheckFactories) > override { > >> > CheckFactories.registerCheck<LoopConvertCheck>("modernize-loop-convert"); > >> > > > CheckFactories.registerCheck<PassByValueCheck>("modernize-pass-by-value"); > >> + > CheckFactories.registerCheck<UseNullptrCheck>("modernize-use-nullptr"); > >> } > >> > >> ClangTidyOptions getModuleOptions() override { > >> @@ -31,6 +33,9 @@ public: > >> auto &Opts = Options.CheckOptions; > >> Opts["modernize-loop-convert.MinConfidence"] = "reasonable"; > >> Opts["modernize-pass-by-value.IncludeStyle"] = "llvm"; // Also: > "google". > >> + > >> + // Comma-separated list of user-defined macros that behave like > NULL. > >> + Opts["modernize-use-nullptr.UserNullMacros"] = ""; > >> return Options; > >> } > >> }; > >> > >> Added: clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.cpp > >> URL: > > > http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.cpp?rev=245434&view=auto > >> > ============================================================================== > >> --- clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.cpp > (added) > >> +++ clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.cpp > > Wed Aug 19 08:13:12 2015 > >> @@ -0,0 +1,472 @@ > >> +//===--- UseNullptrCheck.cpp - > > clang-tidy----------------------------------===// > >> +// > >> +// The LLVM Compiler Infrastructure > >> +// > >> +// This file is distributed under the University of Illinois Open > Source > >> +// License. See LICENSE.TXT for details. > >> +// > >> > > > +//===----------------------------------------------------------------------===// > >> + > >> +#include "UseNullptrCheck.h" > >> +#include "clang/AST/ASTContext.h" > >> +#include "clang/AST/RecursiveASTVisitor.h" > >> +#include "clang/ASTMatchers/ASTMatchFinder.h" > >> +#include "clang/Lex/Lexer.h" > >> + > >> +using namespace clang; > >> +using namespace clang::ast_matchers; > >> +using namespace llvm; > >> + > >> +namespace clang { > >> +namespace tidy { > >> +namespace modernize { > >> + > >> +const char CastSequence[] = "sequence"; > >> +const char NullMacroName[] = "NULL"; > >> + > >> +/// \brief Matches cast expressions that have a cast kind of > CK_NullToPointer > >> +/// or CK_NullToMemberPointer. > >> +/// > >> +/// Given > >> +/// \code > >> +/// int *p = 0; > >> +/// \endcode > >> +/// implicitCastExpr(isNullToPointer()) matches the implicit cast > clang adds > >> +/// around \c 0. > >> +AST_MATCHER(CastExpr, isNullToPointer) { > >> + return Node.getCastKind() == CK_NullToPointer || > >> + Node.getCastKind() == CK_NullToMemberPointer; > >> +} > >> + > >> +AST_MATCHER(Type, sugaredNullptrType) { > >> + const Type *DesugaredType = Node.getUnqualifiedDesugaredType(); > >> + if (const BuiltinType *BT = dyn_cast<BuiltinType>(DesugaredType)) > >> + return BT->getKind() == BuiltinType::NullPtr; > >> + return false; > >> +} > >> + > >> +/// \brief Create a matcher that finds implicit casts as well as > > the head of a > >> +/// sequence of zero or more nested explicit casts that have an > implicit cast > >> +/// to null within. > >> +/// Finding sequences of explict casts is necessary so that an > > entire sequence > >> +/// can be replaced instead of just the inner-most implicit cast. > >> +StatementMatcher makeCastSequenceMatcher() { > >> + StatementMatcher ImplicitCastToNull = implicitCastExpr( > >> + isNullToPointer(), > >> + unless(hasSourceExpression(hasType(sugaredNullptrType())))); > >> + > >> + return castExpr(anyOf(ImplicitCastToNull, > >> + > explicitCastExpr(hasDescendant(ImplicitCastToNull))), > >> + unless(hasAncestor(explicitCastExpr()))) > >> + .bind(CastSequence); > >> +} > >> + > >> +bool isReplaceableRange(SourceLocation StartLoc, SourceLocation EndLoc, > >> + const SourceManager &SM) { > >> + return SM.isWrittenInSameFile(StartLoc, EndLoc); > >> +} > >> + > >> +/// \brief Replaces the provided range with the text "nullptr", but > only if > >> +/// the start and end location are both in main file. > >> +/// Returns true if and only if a replacement was made. > >> +void replaceWithNullptr(ClangTidyCheck &Check, SourceManager &SM, > >> + SourceLocation StartLoc, SourceLocation > EndLoc) { > >> + CharSourceRange Range(SourceRange(StartLoc, EndLoc), true); > >> + // Add a space if nullptr follows an alphanumeric character. This > happens > >> + // whenever there is an c-style explicit cast to nullptr not > surrounded by > >> + // parentheses and right beside a return statement. > >> + SourceLocation PreviousLocation = StartLoc.getLocWithOffset(-1); > >> + bool NeedsSpace = > isAlphanumeric(*SM.getCharacterData(PreviousLocation)); > >> + Check.diag(Range.getBegin(), "use nullptr") << > > FixItHint::CreateReplacement( > >> + Range, NeedsSpace ? " nullptr" : "nullptr"); > >> +} > >> + > >> +/// \brief Returns the name of the outermost macro. > >> +/// > >> +/// Given > >> +/// \code > >> +/// #define MY_NULL NULL > >> +/// \endcode > >> +/// If \p Loc points to NULL, this function will return the name > MY_NULL. > >> +StringRef getOutermostMacroName(SourceLocation Loc, const > SourceManager &SM, > >> + const LangOptions &LO) { > >> + assert(Loc.isMacroID()); > >> + SourceLocation OutermostMacroLoc; > >> + > >> + while (Loc.isMacroID()) { > >> + OutermostMacroLoc = Loc; > >> + Loc = SM.getImmediateMacroCallerLoc(Loc); > >> + } > >> + > >> + return Lexer::getImmediateMacroName(OutermostMacroLoc, SM, LO); > >> +} > >> + > >> +/// \brief RecursiveASTVisitor for ensuring all nodes rooted at a > given AST > >> +/// subtree that have file-level source locations corresponding to a > macro > >> +/// argument have implicit NullTo(Member)Pointer nodes as ancestors. > >> +class MacroArgUsageVisitor : public > > RecursiveASTVisitor<MacroArgUsageVisitor> { > >> +public: > >> + MacroArgUsageVisitor(SourceLocation CastLoc, const SourceManager &SM) > >> + : CastLoc(CastLoc), SM(SM), Visited(false), CastFound(false), > >> + InvalidFound(false) { > >> + assert(CastLoc.isFileID()); > >> + } > >> + > >> + bool TraverseStmt(Stmt *S) { > >> + bool VisitedPreviously = Visited; > >> + > >> + if (!RecursiveASTVisitor<MacroArgUsageVisitor>::TraverseStmt(S)) > >> + return false; > >> + > >> + // The point at which VisitedPreviously is false and Visited is > > true is the > >> + // root of a subtree containing nodes whose locations match > CastLoc. It's > >> + // at this point we test that the Implicit NullTo(Member)Pointer > cast was > >> + // found or not. > >> + if (!VisitedPreviously) { > >> + if (Visited && !CastFound) { > >> + // Found nodes with matching SourceLocations but didn't come > across a > >> + // cast. This is an invalid macro arg use. Can stop traversal > >> + // completely now. > >> + InvalidFound = true; > >> + return false; > >> + } > >> + // Reset state as we unwind back up the tree. > >> + CastFound = false; > >> + Visited = false; > >> + } > >> + return true; > >> + } > >> + > >> + bool VisitStmt(Stmt *S) { > >> + if (SM.getFileLoc(S->getLocStart()) != CastLoc) > >> + return true; > >> + Visited = true; > >> + > >> + const ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(S); > >> + if (Cast && (Cast->getCastKind() == CK_NullToPointer || > >> + Cast->getCastKind() == CK_NullToMemberPointer)) > >> + CastFound = true; > >> + > >> + return true; > >> + } > >> + > >> + bool foundInvalid() const { return InvalidFound; } > >> + > >> +private: > >> + SourceLocation CastLoc; > >> + const SourceManager &SM; > >> + > >> + bool Visited; > >> + bool CastFound; > >> + bool InvalidFound; > >> +}; > >> + > >> +/// \brief Looks for implicit casts as well as sequences of 0 or > > more explicit > >> +/// casts with an implicit null-to-pointer cast within. > >> +/// > >> +/// The matcher this visitor is used with will find a single > > implicit cast or a > >> +/// top-most explicit cast (i.e. it has no explicit casts as an > > ancestor) where > >> +/// an implicit cast is nested within. However, there is no > > guarantee that only > >> +/// explicit casts exist between the found top-most explicit cast and > the > >> +/// possibly more than one nested implicit cast. This visitor finds > all cast > >> +/// sequences with an implicit cast to null within and creates a > replacement > >> +/// leaving the outermost explicit cast unchanged to avoid introducing > >> +/// ambiguities. > >> +class CastSequenceVisitor : public > RecursiveASTVisitor<CastSequenceVisitor> { > >> +public: > >> + CastSequenceVisitor(ASTContext &Context, > >> + SmallVector<StringRef, 1> UserNullMacros, > >> + ClangTidyCheck &check) > >> + : SM(Context.getSourceManager()), Context(Context), > >> + UserNullMacros(std::move(UserNullMacros)), Check(check), > >> + FirstSubExpr(nullptr), PruneSubtree(false) {} > >> + > >> + bool TraverseStmt(Stmt *S) { > >> + // Stop traversing down the tree if requested. > >> + if (PruneSubtree) { > >> + PruneSubtree = false; > >> + return true; > >> + } > >> + return RecursiveASTVisitor<CastSequenceVisitor>::TraverseStmt(S); > >> + } > >> + > >> + // Only VisitStmt is overridden as we shouldn't find other base AST > types > >> + // within a cast expression. > >> + bool VisitStmt(Stmt *S) { > >> + CastExpr *C = dyn_cast<CastExpr>(S); > >> + if (!C) { > >> + FirstSubExpr = nullptr; > >> + return true; > >> + } > >> + if (!FirstSubExpr) > >> + FirstSubExpr = C->getSubExpr()->IgnoreParens(); > >> + > >> + if (C->getCastKind() != CK_NullToPointer && > >> + C->getCastKind() != CK_NullToMemberPointer) { > >> + return true; > >> + } > >> + > >> + SourceLocation StartLoc = FirstSubExpr->getLocStart(); > >> + SourceLocation EndLoc = FirstSubExpr->getLocEnd(); > >> + > >> + // If the location comes from a macro arg expansion, *all* uses of > that > >> + // arg must be checked to result in NullTo(Member)Pointer casts. > >> + // > >> + // If the location comes from a macro body expansion, check to see > if its > >> + // coming from one of the allowed 'NULL' macros. > >> + if (SM.isMacroArgExpansion(StartLoc) && > SM.isMacroArgExpansion(EndLoc)) { > >> + SourceLocation FileLocStart = SM.getFileLoc(StartLoc), > >> + FileLocEnd = SM.getFileLoc(EndLoc); > >> + if (isReplaceableRange(FileLocStart, FileLocEnd, SM) && > >> + allArgUsesValid(C)) { > >> + replaceWithNullptr(Check, SM, FileLocStart, FileLocEnd); > >> + } > >> + return skipSubTree(); > >> + } > >> + > >> + if (SM.isMacroBodyExpansion(StartLoc) && > > SM.isMacroBodyExpansion(EndLoc)) { > >> + StringRef OutermostMacroName = > >> + getOutermostMacroName(StartLoc, SM, Context.getLangOpts()); > >> + > >> + // Check to see if the user wants to replace the macro being > expanded. > >> + if (std::find(UserNullMacros.begin(), UserNullMacros.end(), > >> + OutermostMacroName) == UserNullMacros.end()) { > >> + return skipSubTree(); > >> + } > >> + > >> + StartLoc = SM.getFileLoc(StartLoc); > >> + EndLoc = SM.getFileLoc(EndLoc); > >> + } > >> + > >> + if (!isReplaceableRange(StartLoc, EndLoc, SM)) { > >> + return skipSubTree(); > >> + } > >> + replaceWithNullptr(Check, SM, StartLoc, EndLoc); > >> + > >> + return skipSubTree(); > >> + } > >> + > >> +private: > >> + bool skipSubTree() { > >> + PruneSubtree = true; > >> + return true; > >> + } > >> + > >> + /// \brief Tests that all expansions of a macro arg, one of which > > expands to > >> + /// result in \p CE, yield NullTo(Member)Pointer casts. > >> + bool allArgUsesValid(const CastExpr *CE) { > >> + SourceLocation CastLoc = CE->getLocStart(); > >> + > >> + // Step 1: Get location of macro arg and location of the macro the > > arg was > >> + // provided to. > >> + SourceLocation ArgLoc, MacroLoc; > >> + if (!getMacroAndArgLocations(CastLoc, ArgLoc, MacroLoc)) > >> + return false; > >> + > >> + // Step 2: Find the first ancestor that doesn't expand from this > macro. > >> + ast_type_traits::DynTypedNode ContainingAncestor; > >> + if (!findContainingAncestor( > >> + ast_type_traits::DynTypedNode::create<Stmt>(*CE), MacroLoc, > >> + ContainingAncestor)) > >> + return false; > >> + > >> + // Step 3: > >> + // Visit children of this containing parent looking for the > > least-descended > >> + // nodes of the containing parent which are macro arg expansions > > that expand > >> + // from the given arg location. > >> + // Visitor needs: arg loc > >> + MacroArgUsageVisitor ArgUsageVisitor(SM.getFileLoc(CastLoc), SM); > >> + if (const auto *D = ContainingAncestor.get<Decl>()) > >> + ArgUsageVisitor.TraverseDecl(const_cast<Decl *>(D)); > >> + else if (const auto *S = ContainingAncestor.get<Stmt>()) > >> + ArgUsageVisitor.TraverseStmt(const_cast<Stmt *>(S)); > >> + else > >> + llvm_unreachable("Unhandled ContainingAncestor node type"); > >> + > >> + return !ArgUsageVisitor.foundInvalid(); > >> + } > >> + > >> + /// \brief Given the SourceLocation for a macro arg expansion, finds > the > >> + /// non-macro SourceLocation of the macro the arg was passed to and > the > >> + /// non-macro SourceLocation of the argument in the arg list to that > macro. > >> + /// These results are returned via \c MacroLoc and \c ArgLoc > respectively. > >> + /// These values are undefined if the return value is false. > >> + /// > >> + /// \returns false if one of the returned SourceLocations would be a > >> + /// SourceLocation pointing within the definition of another macro. > >> + bool getMacroAndArgLocations(SourceLocation Loc, SourceLocation > &ArgLoc, > >> + SourceLocation &MacroLoc) { > >> + assert(Loc.isMacroID() && "Only reasonble to call this on macros"); > >> + > >> + ArgLoc = Loc; > >> + > >> + // Find the location of the immediate macro expansion. > >> + while (true) { > >> + std::pair<FileID, unsigned> LocInfo = > SM.getDecomposedLoc(ArgLoc); > >> + const SrcMgr::SLocEntry *E = &SM.getSLocEntry(LocInfo.first); > >> + const SrcMgr::ExpansionInfo &Expansion = E->getExpansion(); > >> + > >> + SourceLocation OldArgLoc = ArgLoc; > >> + ArgLoc = Expansion.getExpansionLocStart(); > >> + if (!Expansion.isMacroArgExpansion()) { > >> + if (!MacroLoc.isFileID()) > >> + return false; > >> + > >> + StringRef Name = > >> + Lexer::getImmediateMacroName(OldArgLoc, SM, > > Context.getLangOpts()); > >> + return std::find(UserNullMacros.begin(), UserNullMacros.end(), > > Name) != > >> + UserNullMacros.end(); > >> + } > >> + > >> + MacroLoc = SM.getImmediateExpansionRange(ArgLoc).first; > >> + > >> + ArgLoc = > Expansion.getSpellingLoc().getLocWithOffset(LocInfo.second); > >> + if (ArgLoc.isFileID()) > >> + return true; > >> + > >> + // If spelling location resides in the same FileID as macro > expansion > >> + // location, it means there is no inner macro. > >> + FileID MacroFID = SM.getFileID(MacroLoc); > >> + if (SM.isInFileID(ArgLoc, MacroFID)) { > >> + // Don't transform this case. If the characters that caused the > >> + // null-conversion come from within a macro, they can't be > changed. > >> + return false; > >> + } > >> + } > >> + > >> + llvm_unreachable("getMacroAndArgLocations"); > >> + } > >> + > >> + /// \brief Tests if TestMacroLoc is found while recursively > unravelling > >> + /// expansions starting at TestLoc. TestMacroLoc.isFileID() must be > true. > >> + /// Implementation is very similar to getMacroAndArgLocations() > > except in this > >> + /// case, it's not assumed that TestLoc is expanded from a macro > argument. > >> + /// While unravelling expansions macro arguments are handled as with > >> + /// getMacroAndArgLocations() but in this function macro body > > expansions are > >> + /// also handled. > >> + /// > >> + /// False means either: > >> + /// - TestLoc is not from a macro expansion > >> + /// - TestLoc is from a different macro expansion > >> + bool expandsFrom(SourceLocation TestLoc, SourceLocation > TestMacroLoc) { > >> + if (TestLoc.isFileID()) { > >> + return false; > >> + } > >> + > >> + SourceLocation Loc = TestLoc, MacroLoc; > >> + > >> + while (true) { > >> + std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(Loc); > >> + const SrcMgr::SLocEntry *E = &SM.getSLocEntry(LocInfo.first); > >> + const SrcMgr::ExpansionInfo &Expansion = E->getExpansion(); > >> + > >> + Loc = Expansion.getExpansionLocStart(); > >> + > >> + if (!Expansion.isMacroArgExpansion()) { > >> + if (Loc.isFileID()) { > >> + return Loc == TestMacroLoc; > >> + } > >> + // Since Loc is still a macro ID and it's not an argument > > expansion, we > >> + // don't need to do the work of handling an argument > > expansion. Simply > >> + // keep recursively expanding until we hit a FileID or a macro > arg > >> + // expansion or a macro arg expansion. > >> + continue; > >> + } > >> + > >> + MacroLoc = SM.getImmediateExpansionRange(Loc).first; > >> + if (MacroLoc.isFileID() && MacroLoc == TestMacroLoc) { > >> + // Match made. > >> + return true; > >> + } > >> + > >> + Loc = > Expansion.getSpellingLoc().getLocWithOffset(LocInfo.second); > >> + if (Loc.isFileID()) { > >> + // If we made it this far without finding a match, there is no > > match to > >> + // be made. > >> + return false; > >> + } > >> + } > >> + > >> + llvm_unreachable("expandsFrom"); > >> + } > >> + > >> + /// \brief Given a starting point \c Start in the AST, find an > > ancestor that > >> + /// doesn't expand from the macro called at file location \c > MacroLoc. > >> + /// > >> + /// \pre MacroLoc.isFileID() > >> + /// \returns true if such an ancestor was found, false otherwise. > >> + bool findContainingAncestor(ast_type_traits::DynTypedNode Start, > >> + SourceLocation MacroLoc, > >> + ast_type_traits::DynTypedNode &Result) { > >> + // Below we're only following the first parent back up the > > AST. This should > >> + // be fine since for the statements we care about there should > > only be one > >> + // parent as far up as we care. If this assumption doesn't hold, > need to > >> + // revisit what to do here. > >> + > >> + assert(MacroLoc.isFileID()); > >> + > >> + while (true) { > >> + const auto &Parents = Context.getParents(Start); > >> + if (Parents.empty()) > >> + return false; > >> + assert(Parents.size() == 1 && > >> + "Found an ancestor with more than one parent!"); > >> + > >> + const ast_type_traits::DynTypedNode &Parent = Parents[0]; > >> + > >> + SourceLocation Loc; > >> + if (const auto *D = Parent.get<Decl>()) > >> + Loc = D->getLocStart(); > >> + else if (const auto *S = Parent.get<Stmt>()) > >> + Loc = S->getLocStart(); > >> + else > >> + llvm_unreachable("Expected to find Decl or Stmt containing > > ancestor"); > >> + > >> + if (!expandsFrom(Loc, MacroLoc)) { > >> + Result = Parent; > >> + return true; > >> + } > >> + Start = Parent; > >> + } > >> + > >> + llvm_unreachable("findContainingAncestor"); > >> + } > >> + > >> +private: > >> + SourceManager &SM; > >> + ASTContext &Context; > >> + const SmallVector<StringRef, 1> &UserNullMacros; > >> + ClangTidyCheck &Check; > >> + Expr *FirstSubExpr; > >> + bool PruneSubtree; > >> +}; > >> + > >> +UseNullptrCheck::UseNullptrCheck(StringRef Name, ClangTidyContext > *Context) > >> + : ClangTidyCheck(Name, Context) { > >> + StringRef UserMacrosStr = Options.get("UserNullMacros", ""); > >> + UserMacrosStr.split(UserNullMacros, ","); > >> + UserNullMacros.push_back(StringRef(NullMacroName)); > >> +} > >> + > >> +void UseNullptrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { > >> + Options.store(Opts, "UserNullMacros", ""); > >> +} > >> + > >> +void UseNullptrCheck::registerMatchers(MatchFinder *Finder) { > >> + Finder->addMatcher(makeCastSequenceMatcher(), this); > >> +} > >> + > >> +void UseNullptrCheck::check(const MatchFinder::MatchResult &Result) { > >> + const auto *NullCast = > Result.Nodes.getNodeAs<CastExpr>(CastSequence); > >> + assert(NullCast && "Bad Callback. No node provided"); > >> + > >> + // Given an implicit null-ptr cast or an explicit cast with an > implicit > >> + // null-to-pointer cast within use CastSequenceVisitor to identify > > sequences > >> + // of explicit casts that can be converted into 'nullptr'. > >> + CastSequenceVisitor(*Result.Context, UserNullMacros, *this) > >> + .TraverseStmt(const_cast<CastExpr *>(NullCast)); > >> +} > >> + > >> +} // namespace modernize > >> +} // namespace tidy > >> +} // namespace clang > >> > >> Added: clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.h > >> URL: > > > http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.h?rev=245434&view=auto > >> > ============================================================================== > >> --- clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.h > (added) > >> +++ clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.h > > Wed Aug 19 08:13:12 2015 > >> @@ -0,0 +1,34 @@ > >> +//===--- UseNullptrCheck.h - clang-tidy--------------------------*- > > C++ -*-===// > >> +// > >> +// The LLVM Compiler Infrastructure > >> +// > >> +// This file is distributed under the University of Illinois Open > Source > >> +// License. See LICENSE.TXT for details. > >> +// > >> > > > +//===----------------------------------------------------------------------===// > >> + > >> +#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NULLPTR_H > >> +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NULLPTR_H > >> + > >> +#include "../ClangTidy.h" > >> + > >> +namespace clang { > >> +namespace tidy { > >> +namespace modernize { > >> + > >> +class UseNullptrCheck : public ClangTidyCheck { > >> +public: > >> + UseNullptrCheck(StringRef Name, ClangTidyContext *Context); > >> + void storeOptions(ClangTidyOptions::OptionMap &Opts) override; > >> + void registerMatchers(ast_matchers::MatchFinder *Finder) override; > >> + void check(const ast_matchers::MatchFinder::MatchResult &Result) > override; > >> + > >> +private: > >> + SmallVector<StringRef, 1> UserNullMacros; > >> +}; > >> + > >> +} // namespace modernize > >> +} // namespace tidy > >> +} // namespace clang > >> + > >> +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NULLPTR_H > >> > >> Added: > clang-tools-extra/trunk/test/clang-tidy/modernize-use-nullptr-basic.cpp > >> URL: > > > http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/clang-tidy/modernize-use-nullptr-basic.cpp?rev=245434&view=auto > >> > ============================================================================== > >> --- > > clang-tools-extra/trunk/test/clang-tidy/modernize-use-nullptr-basic.cpp > > (added) > >> +++ > > clang-tools-extra/trunk/test/clang-tidy/modernize-use-nullptr-basic.cpp > > Wed Aug 19 08:13:12 2015 > >> @@ -0,0 +1,344 @@ > >> +// RUN: $(dirname %s)/check_clang_tidy.sh %s modernize-use-nullptr %t > -- \ > >> +// RUN: -std=c++98 -Wno-non-literal-null-conversion > >> +// REQUIRES: shell > >> + > >> +const unsigned int g_null = 0; > >> +#define NULL 0 > >> + > >> +void test_assignment() { > >> + int *p1 = 0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr > > [modernize-use-nullptr] > >> + // CHECK-FIXES: int *p1 = nullptr; > >> + p1 = 0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use nullptr > >> + // CHECK-FIXES: p1 = nullptr; > >> + > >> + int *p2 = NULL; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr > >> + // CHECK-FIXES: int *p2 = nullptr; > >> + > >> + p2 = p1; > >> + // CHECK-FIXES: p2 = p1; > >> + > >> + const int null = 0; > >> + int *p3 = null; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr > >> + // CHECK-FIXES: int *p3 = nullptr; > >> + > >> + p3 = NULL; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use nullptr > >> + // CHECK-FIXES: p3 = nullptr; > >> + > >> + int *p4 = p3; > >> + // CHECK-FIXES: int *p4 = p3; > >> + > >> + p4 = null; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use nullptr > >> + // CHECK-FIXES: p4 = nullptr; > >> + > >> + int i1 = 0; > >> + > >> + int i2 = NULL; > >> + > >> + int i3 = null; > >> + > >> + int *p5, *p6, *p7; > >> + p5 = p6 = p7 = NULL; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use nullptr > >> + // CHECK-FIXES: p5 = p6 = p7 = nullptr; > >> +} > >> + > >> +struct Foo { > >> + Foo(int *p = NULL) : m_p1(p) {} > >> + // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use nullptr > >> + // CHECK-FIXES: Foo(int *p = nullptr) : m_p1(p) {} > >> + > >> + void bar(int *p = 0) {} > >> + // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use nullptr > >> + // CHECK-FIXES: void bar(int *p = nullptr) {} > >> + > >> + void baz(int i = 0) {} > >> + > >> + int *m_p1; > >> + static int *m_p2; > >> +}; > >> + > >> +int *Foo::m_p2 = NULL; > >> +// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use nullptr > >> +// CHECK-FIXES: int *Foo::m_p2 = nullptr; > >> + > >> +template <typename T> > >> +struct Bar { > >> + Bar(T *p) : m_p(p) { > >> + m_p = static_cast<T*>(NULL); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use nullptr > >> + // CHECK-FIXES: m_p = static_cast<T*>(nullptr); > >> + > >> + m_p = static_cast<T*>(reinterpret_cast<int*>((void*)NULL)); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use nullptr > >> + // CHECK-FIXES: m_p = static_cast<T*>(nullptr); > >> + > >> + m_p = static_cast<T*>(p ? p : static_cast<void*>(g_null)); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: use nullptr > >> + // CHECK-FIXES: m_p = static_cast<T*>(p ? p : > > static_cast<void*>(nullptr)); > >> + > >> + T *p2 = static_cast<T*>(reinterpret_cast<int*>((void*)NULL)); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use nullptr > >> + // CHECK-FIXES: T *p2 = static_cast<T*>(nullptr); > >> + > >> + m_p = NULL; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use nullptr > >> + // CHECK-FIXES: m_p = nullptr; > >> + > >> + int i = static_cast<int>(0.f); > >> + T *i2 = static_cast<int>(0.f); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr > >> + // CHECK-FIXES: T *i2 = nullptr; > >> + } > >> + > >> + T *m_p; > >> +}; > >> + > >> +struct Baz { > >> + Baz() : i(0) {} > >> + int i; > >> +}; > >> + > >> +void test_cxx_cases() { > >> + Foo f(g_null); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr > >> + // CHECK-FIXES: Foo f(nullptr); > >> + > >> + f.bar(NULL); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr > >> + // CHECK-FIXES: f.bar(nullptr); > >> + > >> + f.baz(g_null); > >> + > >> + f.m_p1 = 0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use nullptr > >> + // CHECK-FIXES: f.m_p1 = nullptr; > >> + > >> + Bar<int> b(g_null); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use nullptr > >> + // CHECK-FIXES: Bar<int> b(nullptr); > >> + > >> + Baz b2; > >> + int Baz::*memptr(0); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use nullptr > >> + // CHECK-FIXES: int Baz::*memptr(nullptr); > >> + > >> + memptr = 0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use nullptr > >> + // CHECK-FIXES: memptr = nullptr; > >> +} > >> + > >> +void test_function_default_param1(void *p = 0); > >> +// CHECK-MESSAGES: :[[@LINE-1]]:45: warning: use nullptr > >> +// CHECK-FIXES: void test_function_default_param1(void *p = nullptr); > >> + > >> +void test_function_default_param2(void *p = NULL); > >> +// CHECK-MESSAGES: :[[@LINE-1]]:45: warning: use nullptr > >> +// CHECK-FIXES: void test_function_default_param2(void *p = nullptr); > >> + > >> +void test_function_default_param3(void *p = g_null); > >> +// CHECK-MESSAGES: :[[@LINE-1]]:45: warning: use nullptr > >> +// CHECK-FIXES: void test_function_default_param3(void *p = nullptr); > >> + > >> +void test_function(int *p) {} > >> + > >> +void test_function_no_ptr_param(int i) {} > >> + > >> +void test_function_call() { > >> + test_function(0); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr > >> + // CHECK-FIXES: test_function(nullptr); > >> + > >> + test_function(NULL); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr > >> + // CHECK-FIXES: test_function(nullptr); > >> + > >> + test_function(g_null); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr > >> + // CHECK-FIXES: test_function(nullptr); > >> + > >> + test_function_no_ptr_param(0); > >> +} > >> + > >> +char *test_function_return1() { > >> + return 0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr > >> + // CHECK-FIXES: return nullptr; > >> +} > >> + > >> +void *test_function_return2() { > >> + return NULL; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr > >> + // CHECK-FIXES: return nullptr; > >> +} > >> + > >> +long *test_function_return3() { > >> + return g_null; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr > >> + // CHECK-FIXES: return nullptr; > >> +} > >> + > >> +int test_function_return4() { > >> + return 0; > >> +} > >> + > >> +int test_function_return5() { > >> + return NULL; > >> +} > >> + > >> +int test_function_return6() { > >> + return g_null; > >> +} > >> + > >> +int *test_function_return_cast1() { > >> + return(int)0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr > >> + // CHECK-FIXES: return nullptr; > >> +} > >> + > >> +int *test_function_return_cast2() { > >> +#define RET return > >> + RET(int)0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use nullptr > >> + // CHECK-FIXES: RET nullptr; > >> +#undef RET > >> +} > >> + > >> +// Test parentheses expressions resulting in a nullptr. > >> +int *test_parentheses_expression1() { > >> + return(0); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr > >> + // CHECK-FIXES: return(nullptr); > >> +} > >> + > >> +int *test_parentheses_expression2() { > >> + return(int(0.f)); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr > >> + // CHECK-FIXES: return(nullptr); > >> +} > >> + > >> +int *test_nested_parentheses_expression() { > >> + return((((0)))); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr > >> + // CHECK-FIXES: return((((nullptr)))); > >> +} > >> + > >> +void *test_parentheses_explicit_cast() { > >> + return(static_cast<void*>(0)); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use nullptr > >> + // CHECK-FIXES: return(static_cast<void*>(nullptr)); > >> +} > >> + > >> +void *test_parentheses_explicit_cast_sequence1() { > >> + return(static_cast<void*>(static_cast<int*>((void*)NULL))); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use nullptr > >> + // CHECK-FIXES: return(static_cast<void*>(nullptr)); > >> +} > >> + > >> +void *test_parentheses_explicit_cast_sequence2() { > >> + return(static_cast<void*>(reinterpret_cast<int*>((float*)int(0.f)))); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use nullptr > >> + // CHECK-FIXES: return(static_cast<void*>(nullptr)); > >> +} > >> + > >> +// Test explicit cast expressions resulting in nullptr. > >> +struct Bam { > >> + Bam(int *a) {} > >> + Bam(float *a) {} > >> + Bam operator=(int *a) { return Bam(a); } > >> + Bam operator=(float *a) { return Bam(a); } > >> +}; > >> + > >> +void ambiguous_function(int *a) {} > >> +void ambiguous_function(float *a) {} > >> +void const_ambiguous_function(const int *p) {} > >> +void const_ambiguous_function(const float *p) {} > >> + > >> +void test_explicit_cast_ambiguous1() { > >> + ambiguous_function((int*)0); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use nullptr > >> + // CHECK-FIXES: ambiguous_function((int*)nullptr); > >> +} > >> + > >> +void test_explicit_cast_ambiguous2() { > >> + ambiguous_function((int*)(0)); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use nullptr > >> + // CHECK-FIXES: ambiguous_function((int*)nullptr); > >> +} > >> + > >> +void test_explicit_cast_ambiguous3() { > >> + > ambiguous_function(static_cast<int*>(reinterpret_cast<int*>((float*)0))); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:40: warning: use nullptr > >> + // CHECK-FIXES: ambiguous_function(static_cast<int*>(nullptr)); > >> +} > >> + > >> +Bam test_explicit_cast_ambiguous4() { > >> + return(((int*)(0))); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr > >> + // CHECK-FIXES: return(((int*)nullptr)); > >> +} > >> + > >> +void test_explicit_cast_ambiguous5() { > >> + // Test for ambiguous overloaded constructors. > >> + Bam k((int*)(0)); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use nullptr > >> + // CHECK-FIXES: Bam k((int*)nullptr); > >> + > >> + // Test for ambiguous overloaded operators. > >> + k = (int*)0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr > >> + // CHECK-FIXES: k = (int*)nullptr; > >> +} > >> + > >> +void test_const_pointers_abiguous() { > >> + const_ambiguous_function((int*)0); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use nullptr > >> + // CHECK-FIXES: const_ambiguous_function((int*)nullptr); > >> +} > >> + > >> +// Test where the implicit cast to null is surrounded by another > implict cast > >> +// with possible explict casts in-between. > >> +void test_const_pointers() { > >> + const int *const_p1 = 0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr > >> + // CHECK-FIXES: const int *const_p1 = nullptr; > >> + const int *const_p2 = NULL; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr > >> + // CHECK-FIXES: const int *const_p2 = nullptr; > >> + const int *const_p3 = (int)0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr > >> + // CHECK-FIXES: const int *const_p3 = nullptr; > >> + const int *const_p4 = (int)0.0f; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr > >> + // CHECK-FIXES: const int *const_p4 = nullptr; > >> + const int *const_p5 = (int*)0; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: use nullptr > >> + // CHECK-FIXES: const int *const_p5 = (int*)nullptr; > >> + int *t; > >> + const int *const_p6 = static_cast<int*>(t ? t : > static_cast<int*>(0)); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:69: warning: use nullptr > >> + // CHECK-FIXES: const int *const_p6 = static_cast<int*>(t ? t : > > static_cast<int*>(nullptr)); > >> +} > >> + > >> + > >> +// FIXME: currently, the check doesn't work as it should with > templates. > >> +template<typename T> > >> +class A { > >> + public: > >> + A(T *p = NULL) {} > >> + > >> + void f() { > >> + Ptr = NULL; > >> + } > >> + T *Ptr; > >> +}; > >> + > >> +template<typename T> > >> +T *f2(T *a = NULL) { > >> + return a ? a : NULL; > >> +} > >> > >> Added: clang-tools-extra/trunk/test/clang-tidy/modernize-use-nullptr.cpp > >> URL: > > > http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/clang-tidy/modernize-use-nullptr.cpp?rev=245434&view=auto > >> > ============================================================================== > >> --- clang-tools-extra/trunk/test/clang-tidy/modernize-use-nullptr.cpp > (added) > >> +++ > > clang-tools-extra/trunk/test/clang-tidy/modernize-use-nullptr.cpp Wed > > Aug 19 08:13:12 2015 > >> @@ -0,0 +1,178 @@ > >> +// RUN: $(dirname %s)/check_clang_tidy.sh %s modernize-use-nullptr %t \ > >> +// RUN: -config="{CheckOptions: [{key: > > modernize-use-nullptr.UserNullMacros, value: 'MY_NULL'}]}" \ > >> +// RUN: -- -std=c++11 > >> +// REQUIRES: shell > >> + > >> +#define NULL 0 > >> + > >> +namespace std { > >> + > >> +typedef decltype(nullptr) nullptr_t; > >> + > >> +} // namespace std > >> + > >> +// Just to make sure make_null() could have side effects. > >> +void external(); > >> + > >> +std::nullptr_t make_null() { > >> + external(); > >> + return nullptr; > >> +} > >> + > >> +void func() { > >> + void *CallTest = make_null(); > >> + > >> + int var = 1; > >> + void *CommaTest = (var+=2, make_null()); > >> + > >> + int *CastTest = static_cast<int*>(make_null()); > >> +} > >> + > >> +void dummy(int*) {} > >> +void side_effect() {} > >> + > >> +#define MACRO_EXPANSION_HAS_NULL \ > >> + void foo() { \ > >> + dummy(0); \ > >> + dummy(NULL); \ > >> + side_effect(); \ > >> + } > >> + > >> +MACRO_EXPANSION_HAS_NULL; > >> +#undef MACRO_EXPANSION_HAS_NULL > >> + > >> + > >> +void test_macro_expansion1() { > >> +#define MACRO_EXPANSION_HAS_NULL \ > >> + dummy(NULL); \ > >> + side_effect(); > >> + > >> + MACRO_EXPANSION_HAS_NULL; > >> + > >> +#undef MACRO_EXPANSION_HAS_NULL > >> +} > >> + > >> +// Test macro expansion with cast sequence, PR15572. > >> +void test_macro_expansion2() { > >> +#define MACRO_EXPANSION_HAS_NULL \ > >> + dummy((int*)0); \ > >> + side_effect(); > >> + > >> + MACRO_EXPANSION_HAS_NULL; > >> + > >> +#undef MACRO_EXPANSION_HAS_NULL > >> +} > >> + > >> +void test_macro_expansion3() { > >> +#define MACRO_EXPANSION_HAS_NULL \ > >> + dummy(NULL); \ > >> + side_effect(); > >> + > >> +#define OUTER_MACRO \ > >> + MACRO_EXPANSION_HAS_NULL; \ > >> + side_effect(); > >> + > >> + OUTER_MACRO; > >> + > >> +#undef OUTER_MACRO > >> +#undef MACRO_EXPANSION_HAS_NULL > >> +} > >> + > >> +void test_macro_expansion4() { > >> +#define MY_NULL NULL > >> + int *p = MY_NULL; > >> + // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use nullptr > > [modernize-use-nullptr] > >> + // CHECK-FIXES: int *p = nullptr; > >> +#undef MY_NULL > >> +} > >> + > >> +#define IS_EQ(x, y) if (x != y) return; > >> +void test_macro_args() { > >> + int i = 0; > >> + int *Ptr; > >> + > >> + IS_EQ(static_cast<int*>(0), Ptr); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use nullptr > >> + // CHECK-FIXES: IS_EQ(static_cast<int*>(nullptr), Ptr); > >> + > >> + IS_EQ(0, Ptr); // literal > >> + // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr > >> + // CHECK-FIXES: IS_EQ(nullptr, Ptr); > >> + > >> + IS_EQ(NULL, Ptr); // macro > >> + // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr > >> + // CHECK-FIXES: IS_EQ(nullptr, Ptr); > >> + > >> + // These are ok since the null literal is not spelled within a macro. > >> +#define myassert(x) if (!(x)) return; > >> + myassert(0 == Ptr); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use nullptr > >> + // CHECK-FIXES: myassert(nullptr == Ptr); > >> + > >> + myassert(NULL == Ptr); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use nullptr > >> + // CHECK-FIXES: myassert(nullptr == Ptr); > >> + > >> + // These are bad as the null literal is buried in a macro. > >> +#define BLAH(X) myassert(0 == (X)); > >> +#define BLAH2(X) myassert(NULL == (X)); > >> + BLAH(Ptr); > >> + BLAH2(Ptr); > >> + > >> + // Same as above but testing extra macro expansion. > >> +#define EXPECT_NULL(X) IS_EQ(0, X); > >> +#define EXPECT_NULL2(X) IS_EQ(NULL, X); > >> + EXPECT_NULL(Ptr); > >> + EXPECT_NULL2(Ptr); > >> + > >> + // Almost the same as above but now null literal is not in a macro > so ok > >> + // to transform. > >> +#define EQUALS_PTR(X) IS_EQ(X, Ptr); > >> + EQUALS_PTR(0); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use nullptr > >> + // CHECK-FIXES: EQUALS_PTR(nullptr); > >> + EQUALS_PTR(NULL); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use nullptr > >> + // CHECK-FIXES: EQUALS_PTR(nullptr); > >> + > >> + // Same as above but testing extra macro expansion. > >> +#define EQUALS_PTR_I(X) EQUALS_PTR(X) > >> + EQUALS_PTR_I(0); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use nullptr > >> + // CHECK-FIXES: EQUALS_PTR_I(nullptr); > >> + EQUALS_PTR_I(NULL); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use nullptr > >> + // CHECK-FIXES: EQUALS_PTR_I(nullptr); > >> + > >> + // Ok since null literal not within macro. However, now testing macro > >> + // used as arg to another macro. > >> +#define decorate(EXPR) side_effect(); EXPR; > >> + decorate(IS_EQ(NULL, Ptr)); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use nullptr > >> + // CHECK-FIXES: decorate(IS_EQ(nullptr, Ptr)); > >> + decorate(IS_EQ(0, Ptr)); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use nullptr > >> + // CHECK-FIXES: decorate(IS_EQ(nullptr, Ptr)); > >> + > >> + // This macro causes a NullToPointer cast to happen where 0 is > > assigned to z > >> + // but the 0 literal cannot be replaced because it is also used as an > >> + // integer in the comparison. > >> +#define INT_AND_PTR_USE(X) do { int *z = X; if (X == 4) break; } > while(false) > >> + INT_AND_PTR_USE(0); > >> + > >> + // Both uses of X in this case result in NullToPointer casts so > replacement > >> + // is possible. > >> +#define PTR_AND_PTR_USE(X) do { int *z = X; if (X != z) break; } > while(false) > >> + PTR_AND_PTR_USE(0); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: use nullptr > >> + // CHECK-FIXES: PTR_AND_PTR_USE(nullptr); > >> + PTR_AND_PTR_USE(NULL); > >> + // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: use nullptr > >> + // CHECK-FIXES: PTR_AND_PTR_USE(nullptr); > >> + > >> +#define OPTIONAL_CODE(...) __VA_ARGS__ > >> +#define NOT_NULL dummy(0) > >> +#define CALL(X) X > >> + OPTIONAL_CODE(NOT_NULL); > >> + CALL(NOT_NULL); > >> +} > >> > >> > >> _______________________________________________ > >> cfe-commits mailing list > >> cfe-commits@lists.llvm.org > >> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits >
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
