UseNullptrCheck.cpp

Go to the documentation of this file.

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "UseNullptrCheck.h"
#include "../utils/Matchers.h"
#include "../utils/OptionsUtils.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::tidy::modernize {
namespace {
 
AST_MATCHER(Type, sugaredNullptrType) {
  const Type *DesugaredType = Node.getUnqualifiedDesugaredType();
  if (const auto *BT = dyn_cast<BuiltinType>(DesugaredType))
    return BT->getKind() == BuiltinType::NullPtr;
  return false;
}
 
AST_MATCHER(DecltypeType, decltypeTypeNullptrLiteral) {
  if (const Expr *E = Node.getUnderlyingExpr())
    return isa<CXXNullPtrLiteralExpr>(E->IgnoreParens());
  return false;
}
 
} // namespace
 
static constexpr char CastSequence[] = "sequence";
 
/// 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 explicit casts is necessary so that an entire sequence
/// can be replaced instead of just the inner-most implicit cast.
///
/// TODO/NOTE: The second "anyOf" below discards matches on a substituted type,
/// since we don't know if that would _always_ be a pointer type for all other
/// specializations, unless the expression was "__null", in which case we assume
/// that all specializations are expected to be for pointer types. Ideally this
/// would check for the "NULL" macro instead, but that'd be harder to express.
/// In practice, "NULL" is often defined as "__null", and this is a useful
/// condition.
void UseNullptrCheck::registerMatchers(MatchFinder *Finder) {
  auto ImplicitCastToNull = implicitCastExpr(
      anyOf(hasCastKind(CK_NullToPointer), hasCastKind(CK_NullToMemberPointer)),
      anyOf(hasSourceExpression(gnuNullExpr()),
            unless(hasImplicitDestinationType(
                qualType(substTemplateTypeParmType())))),
      unless(hasSourceExpression(hasType(sugaredNullptrType()))),
      unless(hasImplicitDestinationType(
          qualType(matchers::matchesAnyListedTypeName(IgnoredTypes)))));
 
  const auto IsOrHasDescendant = [](const auto &InnerMatcher) {
    return anyOf(InnerMatcher, hasDescendant(InnerMatcher));
  };
 
  Finder->addMatcher(
      castExpr(anyOf(ImplicitCastToNull,
                     explicitCastExpr(hasDescendant(ImplicitCastToNull))),
               unless(hasAncestor(explicitCastExpr())),
               unless(hasAncestor(cxxRewrittenBinaryOperator())))
          .bind(CastSequence),
      this);
 
  Finder->addMatcher(
      cxxRewrittenBinaryOperator(
          // Match rewritten operators, but verify (in the check method)
          // that if an implicit cast is found, it is not from another
          // nested rewritten operator.
          expr().bind("matchBinopOperands"),
          hasEitherOperand(IsOrHasDescendant(
              implicitCastExpr(ImplicitCastToNull,
                               hasAncestor(cxxRewrittenBinaryOperator().bind(
                                   "checkBinopOperands")))
                  .bind(CastSequence))),
          // Skip defaulted comparison operators.
          unless(hasAncestor(functionDecl(isDefaulted())))),
      this);
 
  if (UseNullptrT)
    Finder->addMatcher(typeLoc(loc(decltypeType(decltypeTypeNullptrLiteral())))
                           .bind("matchDecltypeNullptr"),
                       this);
}
 
static bool isReplaceableRange(SourceLocation StartLoc, SourceLocation EndLoc,
                               const SourceManager &SM) {
  return SM.isWrittenInSameFile(StartLoc, EndLoc);
}
 
/// 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.
static void replaceWithNullptr(ClangTidyCheck &Check, const SourceManager &SM,
                               SourceLocation StartLoc, SourceLocation EndLoc) {
  const 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.
  const SourceLocation PreviousLocation = StartLoc.getLocWithOffset(-1);
  const bool NeedsSpace =
      isAlphanumeric(*SM.getCharacterData(PreviousLocation));
  Check.diag(Range.getBegin(), "use nullptr") << FixItHint::CreateReplacement(
      Range, NeedsSpace ? " nullptr" : "nullptr");
}
 
/// 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.
static 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);
}
 
namespace {
 
/// 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) {
    assert(CastLoc.isFileID());
  }
 
  bool TraverseStmt(Stmt *S) {
    const 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->getBeginLoc()) != 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 TraverseInitListExpr(InitListExpr *S) {
    // Only go through the semantic form of the InitListExpr, because
    // ImplicitCast might not appear in the syntactic form, and this results in
    // finding usages of the macro argument that don't have a ImplicitCast as an
    // ancestor (thus invalidating the replacement) when they actually have.
    return RecursiveASTVisitor<MacroArgUsageVisitor>::
        TraverseSynOrSemInitListExpr(
            S->isSemanticForm() ? S : S->getSemanticForm());
  }
 
  bool foundInvalid() const { return InvalidFound; }
 
private:
  SourceLocation CastLoc;
  const SourceManager &SM;
 
  bool Visited = false;
  bool CastFound = false;
  bool InvalidFound = false;
};
 
/// 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, ArrayRef<StringRef> NullMacros,
                      ClangTidyCheck &Check)
      : SM(Context.getSourceManager()), Context(Context),
        NullMacros(NullMacros), Check(Check) {}
 
  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) {
    auto *C = dyn_cast<CastExpr>(S);
    // Catch the castExpr inside cxxDefaultArgExpr.
    if (auto *E = dyn_cast<CXXDefaultArgExpr>(S)) {
      C = dyn_cast<CastExpr>(E->getExpr());
      FirstSubExpr = nullptr;
    }
    if (!C) {
      FirstSubExpr = nullptr;
      return true;
    }
 
    auto *CastSubExpr = C->getSubExpr()->IgnoreParens();
    // Ignore cast expressions which cast nullptr literal.
    if (isa<CXXNullPtrLiteralExpr>(CastSubExpr))
      return true;
 
    if (!FirstSubExpr)
      FirstSubExpr = CastSubExpr;
 
    if (C->getCastKind() != CK_NullToPointer &&
        C->getCastKind() != CK_NullToMemberPointer) {
      return true;
    }
 
    SourceLocation StartLoc = FirstSubExpr->getBeginLoc();
    SourceLocation EndLoc = FirstSubExpr->getEndLoc();
 
    // 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)) {
      const SourceLocation FileLocStart = SM.getFileLoc(StartLoc),
                           FileLocEnd = SM.getFileLoc(EndLoc);
      SourceLocation ImmediateMacroArgLoc, MacroLoc;
      // Skip NULL macros used in macro.
      if (!getMacroAndArgLocations(StartLoc, ImmediateMacroArgLoc, MacroLoc) ||
          ImmediateMacroArgLoc != FileLocStart)
        return skipSubTree();
 
      if (isReplaceableRange(FileLocStart, FileLocEnd, SM) &&
          allArgUsesValid(C)) {
        replaceWithNullptr(Check, SM, FileLocStart, FileLocEnd);
      }
      return true;
    }
 
    if (SM.isMacroBodyExpansion(StartLoc) && SM.isMacroBodyExpansion(EndLoc)) {
      const StringRef OutermostMacroName =
          getOutermostMacroName(StartLoc, SM, Context.getLangOpts());
 
      // Check to see if the user wants to replace the macro being expanded.
      if (!llvm::is_contained(NullMacros, OutermostMacroName))
        return skipSubTree();
 
      StartLoc = SM.getFileLoc(StartLoc);
      EndLoc = SM.getFileLoc(EndLoc);
    }
 
    if (!isReplaceableRange(StartLoc, EndLoc, SM))
      return skipSubTree();
    replaceWithNullptr(Check, SM, StartLoc, EndLoc);
 
    return true;
  }
 
private:
  bool skipSubTree() {
    PruneSubtree = true;
    return true;
  }
 
  /// 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) {
    const SourceLocation CastLoc = CE->getBeginLoc();
 
    // 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.
    DynTypedNode ContainingAncestor;
    if (!findContainingAncestor(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();
  }
 
  /// 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 reasonable to call this on macros");
 
    ArgLoc = Loc;
 
    // Find the location of the immediate macro expansion.
    while (true) {
      const std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(ArgLoc);
      const SrcMgr::SLocEntry *E = &SM.getSLocEntry(LocInfo.first);
      const SrcMgr::ExpansionInfo &Expansion = E->getExpansion();
 
      const SourceLocation OldArgLoc = ArgLoc;
      ArgLoc = Expansion.getExpansionLocStart();
      if (!Expansion.isMacroArgExpansion()) {
        if (!MacroLoc.isFileID())
          return false;
 
        const StringRef Name =
            Lexer::getImmediateMacroName(OldArgLoc, SM, Context.getLangOpts());
        return llvm::is_contained(NullMacros, Name);
      }
 
      MacroLoc = SM.getExpansionRange(ArgLoc).getBegin();
 
      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.
      const 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");
  }
 
  /// 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) {
      const 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).getBegin();
      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");
  }
 
  /// 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(DynTypedNode Start, SourceLocation MacroLoc,
                              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, except for the case specified below.
 
    assert(MacroLoc.isFileID());
 
    while (true) {
      const auto &Parents = Context.getParents(Start);
      if (Parents.empty())
        return false;
      if (Parents.size() > 1) {
        // If there are more than one parents, don't do the replacement unless
        // they are InitListsExpr (semantic and syntactic form). In this case we
        // can choose any one here, and the ASTVisitor will take care of
        // traversing the right one.
        for (const auto &Parent : Parents)
          if (!Parent.get<InitListExpr>())
            return false;
      }
 
      const DynTypedNode &Parent = Parents[0];
 
      SourceLocation Loc;
      if (const auto *D = Parent.get<Decl>())
        Loc = D->getBeginLoc();
      else if (const auto *S = Parent.get<Stmt>())
        Loc = S->getBeginLoc();
 
      // TypeLoc and NestedNameSpecifierLoc are members of the parent map. Skip
      // them and keep going up.
      if (Loc.isValid() && !expandsFrom(Loc, MacroLoc)) {
        Result = Parent;
        return true;
      }
 
      Start = Parent;
    }
 
    llvm_unreachable("findContainingAncestor");
  }
 
  SourceManager &SM;
  ASTContext &Context;
  ArrayRef<StringRef> NullMacros;
  ClangTidyCheck &Check;
  Expr *FirstSubExpr = nullptr;
  bool PruneSubtree = false;
};
 
} // namespace
 
UseNullptrCheck::UseNullptrCheck(StringRef Name, ClangTidyContext *Context)
    : ClangTidyCheck(Name, Context),
      NullMacrosStr(Options.get("NullMacros", "NULL")),
      IgnoredTypes(utils::options::parseStringList(Options.get(
          "IgnoredTypes", "_CmpUnspecifiedParam;^std::__cmp_cat::__unspec"))),
      UseNullptrT(Options.get("UseNullptrT", true)),
      IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
                                               utils::IncludeSorter::IS_LLVM),
                      areDiagsSelfContained()) {
  NullMacrosStr.split(NullMacros, ",");
}
 
void UseNullptrCheck::registerPPCallbacks(const SourceManager &SM,
                                          Preprocessor *PP,
                                          Preprocessor *ModuleExpanderPP) {
  IncludeInserter.registerPreprocessor(PP);
}
 
void UseNullptrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
  Options.store(Opts, "NullMacros", NullMacrosStr);
  Options.store(Opts, "IgnoredTypes",
                utils::options::serializeStringList(IgnoredTypes));
  Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
  Options.store(Opts, "UseNullptrT", UseNullptrT);
}
 
void UseNullptrCheck::check(const MatchFinder::MatchResult &Result) {
  if (const auto *MatchedTypeLoc =
          Result.Nodes.getNodeAs<TypeLoc>("matchDecltypeNullptr")) {
    diag(MatchedTypeLoc->getBeginLoc(), "use std::nullptr_t instead")
        << IncludeInserter.createIncludeInsertion(
               Result.SourceManager->getFileID(MatchedTypeLoc->getBeginLoc()),
               "<cstddef>")
        << FixItHint::CreateReplacement(MatchedTypeLoc->getSourceRange(),
                                        "std::nullptr_t");
    return;
  }
 
  const auto *NullCast = Result.Nodes.getNodeAs<CastExpr>(CastSequence);
  assert(NullCast && "Bad Callback. No node provided");
 
  if (Result.Nodes.getNodeAs<CXXRewrittenBinaryOperator>(
          "matchBinopOperands") !=
      Result.Nodes.getNodeAs<CXXRewrittenBinaryOperator>("checkBinopOperands"))
    return;
 
  // 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, NullMacros, *this)
      .TraverseStmt(const_cast<CastExpr *>(NullCast));
}
 
} // namespace clang::tidy::modernize