clang/lib/ScalableStaticAnalysis/Analyses/SSAFAnalysesCommon.cpp

//===- SSAFAnalysesCommon.cpp ---------------------------------------------===//
//
// 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 "SSAFAnalysesCommon.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DynamicRecursiveASTVisitor.h"
#include "clang/AST/ExprCXX.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Frontend/SSAFOptions.h"
#include "llvm/ADT/SetVector.h"

using namespace clang;
using namespace ssaf;

std::string ssaf::describeJSONValue(const llvm::json::Value &V) {
  return llvm::formatv("{0:2}", V).str();
}

std::string ssaf::describeJSONValue(const llvm::json::Array &A) {
  return llvm::formatv("array of size {0}", A.size()).str();
}

std::string ssaf::describeJSONValue(const llvm::json::Object &O) {
  return llvm::formatv("an object of {0} key(s)", O.size()).str();
}

namespace {
// Traverses the AST and finds contributors.
class ContributorFinder : public DynamicRecursiveASTVisitor {
public:
  llvm::SetVector<const NamedDecl *> Contributors;
  const SSAFOptions &Opts;

  ContributorFinder(ASTContext &Ctx, const SSAFOptions &Opts,
                    bool ExtractFromSystemHeaders)
      : Opts(Opts), Ctx(Ctx),
        ExtractFromSystemHeaders(ExtractFromSystemHeaders) {
    ShouldVisitTemplateInstantiations = true;
    ShouldVisitImplicitCode = false;
  }

  bool VisitFunctionDecl(FunctionDecl *D) override {
    if (!skipForSystemHeader(D))
      Contributors.insert(D);
    return true;
  }

  bool VisitRecordDecl(RecordDecl *D) override {
    if (skipForSystemHeader(D))
      return true;
    Contributors.insert(D);
    return true;
  }

  bool VisitVarDecl(VarDecl *D) override {
    if (skipForSystemHeader(D))
      return true;
    DeclContext *DC = D->getDeclContext();

    // Collects Decl for global variables or static data members:
    if (DC->isFileContext() || D->isStaticDataMember()) {
      Contributors.insert(D);
      return true;
    }

    // Optionally include block-scope (function-local) variables. Parameters
    // are intentionally skipped: they are exposed via their parent function's
    // USR + a parameter-index suffix in getEntityName, so registering them as
    // independent contributors would be redundant.
    //
    // FIXME: clang::index::generateUSRForDecl can produce non-unique or empty
    // USRs for some local declaration shapes (e.g., locals of certain template
    // instantiations). The current addEntity path returns std::nullopt when
    // that happens and downstream extractors skip gracefully, so this is
    // tolerated for now.
    if (Opts.IncludeLocalEntities && !D->isImplicit() && !isa<ParmVarDecl>(D) &&
        DC->isFunctionOrMethod())
      Contributors.insert(D);
    return true;
  }

  bool VisitLambdaExpr(LambdaExpr *L) override {
    return VisitFunctionDecl(L->getCallOperator());
  }

private:
  bool skipForSystemHeader(const Decl *D) const {
    if (ExtractFromSystemHeaders)
      return false;
    SourceLocation Loc = D->getLocation();
    return Loc.isValid() && Ctx.getSourceManager().isInSystemHeader(Loc);
  }

  ASTContext &Ctx;
  bool ExtractFromSystemHeaders;
};

/// An AST visitor that skips the root node's strict-descendants that are
/// callable Decls and record Decls, because those are separate contributors.
///
/// Clients need to implement their own "MatchAction", which is a function that
/// takes a `DynTypedNode`, decides if the node matches and performs any further
/// callback actions.
/// ContributorFactFinder takes a reference to a "MatchAction". It does not own
/// the "MatchAction", which is usually stateful and may own containers.
class ContributorFactFinder : public DynamicRecursiveASTVisitor {
  llvm::function_ref<void(const DynTypedNode &)> MatchActionRef;
  const NamedDecl *RootDecl = nullptr;

  template <typename NodeTy> void match(const NodeTy &Node) {
    MatchActionRef(DynTypedNode::create(Node));
  }

public:
  ContributorFactFinder(
      llvm::function_ref<void(const DynTypedNode &)> MatchActionRef)
      : MatchActionRef(MatchActionRef) {
    ShouldVisitTemplateInstantiations = true;
    ShouldVisitImplicitCode = false;
  }

  // The entry point:
  void findMatches(const NamedDecl *Contributor) {
    RootDecl = Contributor;
    TraverseDecl(const_cast<NamedDecl *>(Contributor));
  }

  bool TraverseDecl(Decl *Node) override {
    if (!Node)
      return true;
    // To skip callables:
    if (Node != RootDecl &&
        isa<FunctionDecl, BlockDecl, ObjCMethodDecl, RecordDecl>(Node))
      return true;
    match(*Node);
    return DynamicRecursiveASTVisitor::TraverseDecl(Node);
  }

  bool TraverseStmt(Stmt *Node) override {
    if (!Node)
      return true;
    match(*Node);
    return DynamicRecursiveASTVisitor::TraverseStmt(Node);
  }

  bool TraverseLambdaExpr(LambdaExpr *L) override {
    // TODO: lambda captures of pointer variables (by copy or by reference)
    // are currently not tracked. Each capture initializes an implicit closure
    // field from the captured variable, which constitutes a pointer assignment
    // edge that should be recorded here.
    return true; // Skip lambda as it is a callable.
  }
};
} // namespace

void ssaf::findContributors(
    ASTContext &Ctx, const SSAFOptions &Options,
    llvm::DenseMap<const NamedDecl *, std::vector<const NamedDecl *>>
        &Contributors,
    bool ExtractFromSystemHeaders) {
  ContributorFinder Finder{Ctx, Options, ExtractFromSystemHeaders};
  Finder.TraverseAST(Ctx);
  for (const NamedDecl *C : Finder.Contributors)
    Contributors[cast<NamedDecl>(C->getCanonicalDecl())].push_back(C);
}

void ssaf::findMatchesIn(
    const NamedDecl *Contributor,
    llvm::function_ref<void(const DynTypedNode &)> MatchActionRef) {
  ContributorFactFinder{MatchActionRef}.findMatches(Contributor);
}

llvm::Error clang::ssaf::makeEntityNameErr(clang::ASTContext &Ctx,
                                           const clang::NamedDecl *D) {
  return makeErrAtNode(Ctx, D, "failed to create entity name for %s",
                       D->getNameAsString().data());
}