CXXInheritance.cpp | Explore in Territory

//===- CXXInheritance.cpp - C++ Inheritance -------------------------------===//
//
// 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 provides routines that help analyzing C++ inheritance hierarchies.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/CXXInheritance.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/RecordLayout.h"
#include "clang/AST/TemplateName.h"
#include "clang/AST/Type.h"
#include "clang/Basic/LLVM.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Support/Casting.h"
#include <algorithm>
#include <utility>
#include <cassert>
#include <vector>

usingnamespaceclang;

/// isAmbiguous - Determines whether the set of paths provided is
/// ambiguous, i.e., there are two or more paths that refer to
/// different base class subobjects of the same type. BaseType must be
/// an unqualified, canonical class type.
bool CXXBasePaths::isAmbiguous(CanQualType BaseType) { … }

/// clear - Clear out all prior path information.
void CXXBasePaths::clear() { … }

/// Swaps the contents of this CXXBasePaths structure with the
/// contents of Other.
void CXXBasePaths::swap(CXXBasePaths &Other) { … }

bool CXXRecordDecl::isDerivedFrom(const CXXRecordDecl *Base) const { … }

bool CXXRecordDecl::isDerivedFrom(const CXXRecordDecl *Base,
                                  CXXBasePaths &Paths) const { … }

bool CXXRecordDecl::isVirtuallyDerivedFrom(const CXXRecordDecl *Base) const { … }

bool CXXRecordDecl::isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const { … }

bool
CXXRecordDecl::isCurrentInstantiation(const DeclContext *CurContext) const { … }

bool CXXRecordDecl::forallBases(ForallBasesCallback BaseMatches) const { … }

bool CXXBasePaths::lookupInBases(ASTContext &Context,
                                 const CXXRecordDecl *Record,
                                 CXXRecordDecl::BaseMatchesCallback BaseMatches,
                                 bool LookupInDependent) { … }

bool CXXRecordDecl::lookupInBases(BaseMatchesCallback BaseMatches,
                                  CXXBasePaths &Paths,
                                  bool LookupInDependent) const { … }

bool CXXRecordDecl::FindBaseClass(const CXXBaseSpecifier *Specifier,
                                  CXXBasePath &Path,
                                  const CXXRecordDecl *BaseRecord) { … }

bool CXXRecordDecl::FindVirtualBaseClass(const CXXBaseSpecifier *Specifier,
                                         CXXBasePath &Path,
                                         const CXXRecordDecl *BaseRecord) { … }

static bool isOrdinaryMember(const NamedDecl *ND) { … }

static bool findOrdinaryMember(const CXXRecordDecl *RD, CXXBasePath &Path,
                               DeclarationName Name) { … }

bool CXXRecordDecl::hasMemberName(DeclarationName Name) const { … }

static bool
findOrdinaryMemberInDependentClasses(const CXXBaseSpecifier *Specifier,
                                     CXXBasePath &Path, DeclarationName Name) { … }

std::vector<const NamedDecl *> CXXRecordDecl::lookupDependentName(
    DeclarationName Name,
    llvm::function_ref<bool(const NamedDecl *ND)> Filter) { … }

void OverridingMethods::add(unsigned OverriddenSubobject,
                            UniqueVirtualMethod Overriding) { … }

void OverridingMethods::add(const OverridingMethods &Other) { … }

void OverridingMethods::replaceAll(UniqueVirtualMethod Overriding) { … }

namespace {

class FinalOverriderCollector { … };

} // namespace

void FinalOverriderCollector::Collect(const CXXRecordDecl *RD,
                                      bool VirtualBase,
                                      const CXXRecordDecl *InVirtualSubobject,
                                      CXXFinalOverriderMap &Overriders) { … }

FinalOverriderCollector::~FinalOverriderCollector() { … }

void
CXXRecordDecl::getFinalOverriders(CXXFinalOverriderMap &FinalOverriders) const { … }

static void
AddIndirectPrimaryBases(const CXXRecordDecl *RD, ASTContext &Context,
                        CXXIndirectPrimaryBaseSet& Bases) { … }

void
CXXRecordDecl::getIndirectPrimaryBases(CXXIndirectPrimaryBaseSet& Bases) const { … }
llvm/clang/lib/AST/CXXInheritance.cpp
