124 lines
4.4 KiB
C++
124 lines
4.4 KiB
C++
//===- BuildNamespace.h -----------------------------------------*- 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 BuildNamespace and NestedBuildNamespace classes that
|
|
// represent build namespaces in the Scalable Static Analysis Framework.
|
|
//
|
|
// Build namespaces provide an abstraction for grouping program entities (such
|
|
// as those in a shared library or compilation unit) to enable analysis of
|
|
// software projects constructed from individual components.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_ANALYSIS_SCALABLE_MODEL_BUILDNAMESPACE_H
|
|
#define LLVM_CLANG_ANALYSIS_SCALABLE_MODEL_BUILDNAMESPACE_H
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include <optional>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace clang::ssaf {
|
|
|
|
enum class BuildNamespaceKind : unsigned short { CompilationUnit, LinkUnit };
|
|
|
|
llvm::StringRef toString(BuildNamespaceKind BNK);
|
|
|
|
std::optional<BuildNamespaceKind> parseBuildNamespaceKind(llvm::StringRef Str);
|
|
|
|
/// Represents a single namespace in the build process.
|
|
///
|
|
/// A BuildNamespace groups program entities, such as those belonging to a
|
|
/// compilation unit or link unit (e.g., a shared library). Each namespace has a
|
|
/// kind (CompilationUnit or LinkUnit) and a unique identifier name within that
|
|
/// kind.
|
|
///
|
|
/// BuildNamespaces can be composed into NestedBuildNamespace to represent
|
|
/// hierarchical namespace structures that model how software is constructed
|
|
/// from its components.
|
|
class BuildNamespace {
|
|
BuildNamespaceKind Kind;
|
|
std::string Name;
|
|
|
|
auto asTuple() const { return std::tie(Kind, Name); }
|
|
|
|
public:
|
|
BuildNamespace(BuildNamespaceKind Kind, llvm::StringRef Name)
|
|
: Kind(Kind), Name(Name.str()) {}
|
|
|
|
/// Creates a BuildNamespace representing a compilation unit.
|
|
///
|
|
/// \param CompilationId The unique identifier for the compilation unit.
|
|
/// \returns A BuildNamespace with CompilationUnit kind.
|
|
static BuildNamespace makeCompilationUnit(llvm::StringRef CompilationId);
|
|
|
|
bool operator==(const BuildNamespace &Other) const;
|
|
bool operator!=(const BuildNamespace &Other) const;
|
|
bool operator<(const BuildNamespace &Other) const;
|
|
|
|
friend class SerializationFormat;
|
|
};
|
|
|
|
/// Represents a hierarchical sequence of build namespaces.
|
|
///
|
|
/// A NestedBuildNamespace captures namespace qualification for program entities
|
|
/// by maintaining an ordered sequence of BuildNamespace steps. This models how
|
|
/// entities are organized through multiple steps of the build process, such as
|
|
/// first being part of a compilation unit, then incorporated into a link unit.
|
|
///
|
|
/// For example, an entity might be qualified by a compilation unit namespace
|
|
/// followed by a shared library namespace.
|
|
class NestedBuildNamespace {
|
|
friend class SerializationFormat;
|
|
|
|
std::vector<BuildNamespace> Namespaces;
|
|
|
|
public:
|
|
NestedBuildNamespace() = default;
|
|
|
|
explicit NestedBuildNamespace(const std::vector<BuildNamespace> &Namespaces)
|
|
: Namespaces(Namespaces) {}
|
|
|
|
explicit NestedBuildNamespace(const BuildNamespace &N) {
|
|
Namespaces.push_back(N);
|
|
}
|
|
|
|
/// Creates a NestedBuildNamespace representing a compilation unit.
|
|
///
|
|
/// \param CompilationId The unique identifier for the compilation unit.
|
|
/// \returns A NestedBuildNamespace containing a single CompilationUnit
|
|
/// BuildNamespace.
|
|
static NestedBuildNamespace
|
|
makeCompilationUnit(llvm::StringRef CompilationId);
|
|
|
|
/// Creates a new NestedBuildNamespace by appending additional namespace.
|
|
///
|
|
/// \param Namespace The namespace to append.
|
|
NestedBuildNamespace makeQualified(NestedBuildNamespace Namespace) const {
|
|
auto Copy = *this;
|
|
Copy.Namespaces.reserve(Copy.Namespaces.size() +
|
|
Namespace.Namespaces.size());
|
|
llvm::append_range(Copy.Namespaces, Namespace.Namespaces);
|
|
return Copy;
|
|
}
|
|
|
|
bool empty() const;
|
|
|
|
bool operator==(const NestedBuildNamespace &Other) const;
|
|
bool operator!=(const NestedBuildNamespace &Other) const;
|
|
bool operator<(const NestedBuildNamespace &Other) const;
|
|
|
|
friend class JSONWriter;
|
|
friend class LinkUnitResolution;
|
|
};
|
|
|
|
} // namespace clang::ssaf
|
|
|
|
#endif // LLVM_CLANG_ANALYSIS_SCALABLE_MODEL_BUILDNAMESPACE_H
|