DeclarationName.cpp | Explore in Territory

//===- DeclarationName.cpp - Declaration names implementation -------------===//
//
// 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 implements the DeclarationName and DeclarationNameTable
// classes.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/DeclarationName.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/OpenMPClause.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
#include "clang/AST/TypeOrdering.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/OperatorKinds.h"
#include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <string>

usingnamespaceclang;

static int compareInt(unsigned A, unsigned B) { … }

int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) { … }

static void printCXXConstructorDestructorName(QualType ClassType,
                                              raw_ostream &OS,
                                              PrintingPolicy Policy) { … }

void DeclarationName::print(raw_ostream &OS,
                            const PrintingPolicy &Policy) const { … }

namespace clang {

raw_ostream &operator<<(raw_ostream &OS, DeclarationName N) { … }

} // namespace clang

bool DeclarationName::isDependentName() const { … }

std::string DeclarationName::getAsString() const { … }

void *DeclarationName::getFETokenInfoSlow() const { … }

void DeclarationName::setFETokenInfoSlow(void *T) { … }

LLVM_DUMP_METHOD void DeclarationName::dump() const { … }

DeclarationNameTable::DeclarationNameTable(const ASTContext &C) : … { … }

DeclarationName
DeclarationNameTable::getCXXDeductionGuideName(TemplateDecl *Template) { … }

DeclarationName DeclarationNameTable::getCXXConstructorName(CanQualType Ty) { … }

DeclarationName DeclarationNameTable::getCXXDestructorName(CanQualType Ty) { … }

DeclarationName
DeclarationNameTable::getCXXConversionFunctionName(CanQualType Ty) { … }

DeclarationName
DeclarationNameTable::getCXXSpecialName(DeclarationName::NameKind Kind,
                                        CanQualType Ty) { … }

DeclarationName
DeclarationNameTable::getCXXLiteralOperatorName(const IdentifierInfo *II) { … }

DeclarationNameLoc::DeclarationNameLoc(DeclarationName Name) { … }

bool DeclarationNameInfo::containsUnexpandedParameterPack() const { … }

bool DeclarationNameInfo::isInstantiationDependent() const { … }

std::string DeclarationNameInfo::getAsString() const { … }

raw_ostream &clang::operator<<(raw_ostream &OS, DeclarationNameInfo DNInfo) { … }

void DeclarationNameInfo::printName(raw_ostream &OS, PrintingPolicy Policy) const { … }

SourceLocation DeclarationNameInfo::getEndLocPrivate() const { … }
llvm/clang/lib/AST/DeclarationName.cpp
