TemplateName.cpp | Explore in Territory

//===- TemplateName.cpp - C++ Template Name Representation ----------------===//
//
// 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 the TemplateName interface and subclasses.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/TemplateName.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/DependenceFlags.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/TemplateBase.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/OperatorKinds.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <optional>
#include <string>

usingnamespaceclang;

DeducedTemplateStorage::DeducedTemplateStorage(TemplateName Underlying,
                                               const DefaultArguments &DefArgs)
    : … { … }

void DeducedTemplateStorage::Profile(llvm::FoldingSetNodeID &ID,
                                     const ASTContext &Context) const { … }

void DeducedTemplateStorage::Profile(llvm::FoldingSetNodeID &ID,
                                     const ASTContext &Context,
                                     TemplateName Underlying,
                                     const DefaultArguments &DefArgs) { … }

TemplateArgument
SubstTemplateTemplateParmPackStorage::getArgumentPack() const { … }

TemplateTemplateParmDecl *
SubstTemplateTemplateParmPackStorage::getParameterPack() const { … }

TemplateTemplateParmDecl *
SubstTemplateTemplateParmStorage::getParameter() const { … }

void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) { … }

void SubstTemplateTemplateParmStorage::Profile(
    llvm::FoldingSetNodeID &ID, TemplateName Replacement, Decl *AssociatedDecl,
    unsigned Index, std::optional<unsigned> PackIndex) { … }

SubstTemplateTemplateParmPackStorage::SubstTemplateTemplateParmPackStorage(
    ArrayRef<TemplateArgument> ArgPack, Decl *AssociatedDecl, unsigned Index,
    bool Final)
    : … { … }

void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
                                                   ASTContext &Context) { … }

Decl *SubstTemplateTemplateParmPackStorage::getAssociatedDecl() const { … }

bool SubstTemplateTemplateParmPackStorage::getFinal() const { … }

void SubstTemplateTemplateParmPackStorage::Profile(
    llvm::FoldingSetNodeID &ID, ASTContext &Context,
    const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index,
    bool Final) { … }

TemplateName::TemplateName(void *Ptr) { … }

TemplateName::TemplateName(TemplateDecl *Template) : … { … }
TemplateName::TemplateName(OverloadedTemplateStorage *Storage)
    : … { … }
TemplateName::TemplateName(AssumedTemplateStorage *Storage)
    : … { … }
TemplateName::TemplateName(SubstTemplateTemplateParmStorage *Storage)
    : … { … }
TemplateName::TemplateName(SubstTemplateTemplateParmPackStorage *Storage)
    : … { … }
TemplateName::TemplateName(QualifiedTemplateName *Qual) : … { … }
TemplateName::TemplateName(DependentTemplateName *Dep) : … { … }
TemplateName::TemplateName(UsingShadowDecl *Using) : … { … }
TemplateName::TemplateName(DeducedTemplateStorage *Deduced)
    : … { … }

bool TemplateName::isNull() const { … }

TemplateName::NameKind TemplateName::getKind() const { … }

TemplateDecl *TemplateName::getAsTemplateDecl(bool IgnoreDeduced) const { … }

std::pair<TemplateDecl *, DefaultArguments>
TemplateName::getTemplateDeclAndDefaultArgs() const { … }

std::optional<TemplateName> TemplateName::desugar(bool IgnoreDeduced) const { … }

OverloadedTemplateStorage *TemplateName::getAsOverloadedTemplate() const { … }

AssumedTemplateStorage *TemplateName::getAsAssumedTemplateName() const { … }

SubstTemplateTemplateParmStorage *
TemplateName::getAsSubstTemplateTemplateParm() const { … }

SubstTemplateTemplateParmPackStorage *
TemplateName::getAsSubstTemplateTemplateParmPack() const { … }

QualifiedTemplateName *TemplateName::getAsQualifiedTemplateName() const { … }

DependentTemplateName *TemplateName::getAsDependentTemplateName() const { … }

UsingShadowDecl *TemplateName::getAsUsingShadowDecl() const { … }

DeducedTemplateStorage *TemplateName::getAsDeducedTemplateName() const { … }

TemplateNameDependence TemplateName::getDependence() const { … }

bool TemplateName::isDependent() const { … }

bool TemplateName::isInstantiationDependent() const { … }

bool TemplateName::containsUnexpandedParameterPack() const { … }

void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
                         Qualified Qual) const { … }

const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
                                             TemplateName N) { … }
llvm/clang/lib/AST/TemplateName.cpp
