UnsafeBufferUsage.h

Go to the documentation of this file.

//===- UnsafeBufferUsage.h - Replace pointers with modern C++ ---*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
//  This file defines an analysis that aids replacing buffer accesses through
//  raw pointers with safer C++ abstractions such as containers and views/spans.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_UNSAFEBUFFERUSAGE_H
#define LLVM_CLANG_ANALYSIS_ANALYSES_UNSAFEBUFFERUSAGE_H
 
#include "clang/AST/Decl.h"
#include "clang/AST/Stmt.h"
 
namespace clang {
 
using DefMapTy = llvm::DenseMap<const VarDecl *, std::vector<const VarDecl *>>;
 
/// The interface that lets the caller handle unsafe buffer usage analysis
/// results by overriding this class's handle... methods.
class UnsafeBufferUsageHandler {
public:
  UnsafeBufferUsageHandler() = default;
  virtual ~UnsafeBufferUsageHandler() = default;
 
  /// This analyses produces large fixits that are organized into lists
  /// of primitive fixits (individual insertions/removals/replacements).
  using FixItList = llvm::SmallVectorImpl<FixItHint>;
 
  /// Invoked when an unsafe operation over raw pointers is found.
  virtual void handleUnsafeOperation(const Stmt *Operation,
                                     bool IsRelatedToDecl) = 0;
 
  /// Invoked when a fix is suggested against a variable. This function groups
  /// all variables that must be fixed together (i.e their types must be changed to the
  /// same target type to prevent type mismatches) into a single fixit.
  virtual void handleUnsafeVariableGroup(const VarDecl *Variable,
                                         const DefMapTy &VarGrpMap,
                                         FixItList &&Fixes) = 0;
 
  /// Returns a reference to the `Preprocessor`:
  virtual bool isSafeBufferOptOut(const SourceLocation &Loc) const = 0;
 
  /// Returns the text indicating that the user needs to provide input there:
  virtual std::string
  getUserFillPlaceHolder(StringRef HintTextToUser = "placeholder") const {
    std::string s = std::string("<# ");
    s += HintTextToUser;
    s += " #>";
    return s;
  }
};
 
// This function invokes the analysis and allows the caller to react to it
// through the handler class.
void checkUnsafeBufferUsage(const Decl *D, UnsafeBufferUsageHandler &Handler,
                            bool EmitSuggestions);
 
namespace internal {
// Tests if any two `FixItHint`s in `FixIts` conflict.  Two `FixItHint`s
// conflict if they have overlapping source ranges.
bool anyConflict(const llvm::SmallVectorImpl<FixItHint> &FixIts,
                 const SourceManager &SM);
} // namespace internal
} // end namespace clang
 
#endif /* LLVM_CLANG_ANALYSIS_ANALYSES_UNSAFEBUFFERUSAGE_H */