| //===------- QualTypeNames.cpp - Generate Complete QualType Names ---------===// |
| // |
| // 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 "clang/AST/QualTypeNames.h" |
| #include "clang/AST/DeclTemplate.h" |
| #include "clang/AST/DeclarationName.h" |
| #include "clang/AST/Mangle.h" |
| #include "clang/AST/Type.h" |
| |
| namespace clang { |
| |
| namespace TypeName { |
| |
| /// Create a NestedNameSpecifier for Namesp and its enclosing |
| /// scopes. |
| /// |
| /// \param[in] Ctx - the AST Context to be used. |
| /// \param[in] Namesp - the NamespaceDecl for which a NestedNameSpecifier |
| /// is requested. |
| /// \param[in] WithGlobalNsPrefix - Indicate whether the global namespace |
| /// specifier "::" should be prepended or not. |
| static NestedNameSpecifier |
| createNestedNameSpecifier(const ASTContext &Ctx, const NamespaceDecl *Namesp, |
| bool WithGlobalNsPrefix); |
| |
| /// Create a NestedNameSpecifier for TagDecl and its enclosing |
| /// scopes. |
| /// |
| /// \param[in] Ctx - the AST Context to be used. |
| /// \param[in] TD - the TagDecl for which a NestedNameSpecifier is |
| /// requested. |
| /// \param[in] FullyQualify - Convert all template arguments into fully |
| /// qualified names. |
| /// \param[in] WithGlobalNsPrefix - Indicate whether the global namespace |
| /// specifier "::" should be prepended or not. |
| static NestedNameSpecifier createNestedNameSpecifier(const ASTContext &Ctx, |
| const TypeDecl *TD, |
| bool FullyQualify, |
| bool WithGlobalNsPrefix); |
| |
| static NestedNameSpecifier |
| createNestedNameSpecifierForScopeOf(const ASTContext &Ctx, const Decl *decl, |
| bool FullyQualified, |
| bool WithGlobalNsPrefix); |
| |
| static NestedNameSpecifier getFullyQualifiedNestedNameSpecifier( |
| const ASTContext &Ctx, NestedNameSpecifier NNS, bool WithGlobalNsPrefix); |
| |
| static bool getFullyQualifiedTemplateName(const ASTContext &Ctx, |
| TemplateName &TName, |
| bool WithGlobalNsPrefix) { |
| bool Changed = false; |
| NestedNameSpecifier NNS = std::nullopt; |
| |
| TemplateDecl *ArgTDecl = TName.getAsTemplateDecl(); |
| if (!ArgTDecl) // ArgTDecl can be null in dependent contexts. |
| return false; |
| |
| QualifiedTemplateName *QTName = TName.getAsQualifiedTemplateName(); |
| |
| if (QTName && |
| !QTName->hasTemplateKeyword() && |
| (NNS = QTName->getQualifier())) { |
| NestedNameSpecifier QNNS = |
| getFullyQualifiedNestedNameSpecifier(Ctx, NNS, WithGlobalNsPrefix); |
| if (QNNS != NNS) { |
| Changed = true; |
| NNS = QNNS; |
| } else { |
| NNS = std::nullopt; |
| } |
| } else { |
| NNS = createNestedNameSpecifierForScopeOf( |
| Ctx, ArgTDecl, true, WithGlobalNsPrefix); |
| } |
| if (NNS) { |
| TemplateName UnderlyingTN(ArgTDecl); |
| if (UsingShadowDecl *USD = TName.getAsUsingShadowDecl()) |
| UnderlyingTN = TemplateName(USD); |
| TName = |
| Ctx.getQualifiedTemplateName(NNS, |
| /*TemplateKeyword=*/false, UnderlyingTN); |
| Changed = true; |
| } |
| return Changed; |
| } |
| |
| static bool getFullyQualifiedTemplateArgument(const ASTContext &Ctx, |
| TemplateArgument &Arg, |
| bool WithGlobalNsPrefix) { |
| bool Changed = false; |
| |
| // Note: we do not handle TemplateArgument::Expression, to replace it |
| // we need the information for the template instance decl. |
| |
| if (Arg.getKind() == TemplateArgument::Template) { |
| TemplateName TName = Arg.getAsTemplate(); |
| Changed = getFullyQualifiedTemplateName(Ctx, TName, WithGlobalNsPrefix); |
| if (Changed) { |
| Arg = TemplateArgument(TName); |
| } |
| } else if (Arg.getKind() == TemplateArgument::Type) { |
| QualType SubTy = Arg.getAsType(); |
| // Check if the type needs more desugaring and recurse. |
| QualType QTFQ = getFullyQualifiedType(SubTy, Ctx, WithGlobalNsPrefix); |
| if (QTFQ != SubTy) { |
| Arg = TemplateArgument(QTFQ); |
| Changed = true; |
| } |
| } |
| return Changed; |
| } |
| |
| static const Type *getFullyQualifiedTemplateType(const ASTContext &Ctx, |
| const TagType *TSTRecord, |
| ElaboratedTypeKeyword Keyword, |
| NestedNameSpecifier Qualifier, |
| bool WithGlobalNsPrefix) { |
| // We are asked to fully qualify and we have a Record Type, |
| // which can point to a template instantiation with no sugar in any of |
| // its template argument, however we still need to fully qualify them. |
| |
| const auto *TD = TSTRecord->getOriginalDecl(); |
| const auto *TSTDecl = dyn_cast<ClassTemplateSpecializationDecl>(TD); |
| if (!TSTDecl) |
| return Ctx.getTagType(Keyword, Qualifier, TD, /*OwnsTag=*/false) |
| .getTypePtr(); |
| |
| const TemplateArgumentList &TemplateArgs = TSTDecl->getTemplateArgs(); |
| |
| bool MightHaveChanged = false; |
| SmallVector<TemplateArgument, 4> FQArgs; |
| for (unsigned int I = 0, E = TemplateArgs.size(); I != E; ++I) { |
| // cheap to copy and potentially modified by |
| // getFullyQualifedTemplateArgument |
| TemplateArgument Arg(TemplateArgs[I]); |
| MightHaveChanged |= |
| getFullyQualifiedTemplateArgument(Ctx, Arg, WithGlobalNsPrefix); |
| FQArgs.push_back(Arg); |
| } |
| |
| if (!MightHaveChanged) |
| return Ctx.getTagType(Keyword, Qualifier, TD, /*OwnsTag=*/false) |
| .getTypePtr(); |
| // If a fully qualified arg is different from the unqualified arg, |
| // allocate new type in the AST. |
| TemplateName TN = Ctx.getQualifiedTemplateName( |
| Qualifier, /*TemplateKeyword=*/false, |
| TemplateName(TSTDecl->getSpecializedTemplate())); |
| QualType QT = Ctx.getTemplateSpecializationType( |
| Keyword, TN, FQArgs, |
| /*CanonicalArgs=*/{}, TSTRecord->getCanonicalTypeInternal()); |
| // getTemplateSpecializationType returns a fully qualified |
| // version of the specialization itself, so no need to qualify |
| // it. |
| return QT.getTypePtr(); |
| } |
| |
| static const Type * |
| getFullyQualifiedTemplateType(const ASTContext &Ctx, |
| const TemplateSpecializationType *TST, |
| bool WithGlobalNsPrefix) { |
| TemplateName TName = TST->getTemplateName(); |
| bool MightHaveChanged = |
| getFullyQualifiedTemplateName(Ctx, TName, WithGlobalNsPrefix); |
| SmallVector<TemplateArgument, 4> FQArgs; |
| // Cheap to copy and potentially modified by |
| // getFullyQualifedTemplateArgument. |
| for (TemplateArgument Arg : TST->template_arguments()) { |
| MightHaveChanged |= |
| getFullyQualifiedTemplateArgument(Ctx, Arg, WithGlobalNsPrefix); |
| FQArgs.push_back(Arg); |
| } |
| |
| if (!MightHaveChanged) |
| return TST; |
| |
| QualType NewQT = |
| Ctx.getTemplateSpecializationType(TST->getKeyword(), TName, FQArgs, |
| /*CanonicalArgs=*/{}, TST->desugar()); |
| // getTemplateSpecializationType returns a fully qualified |
| // version of the specialization itself, so no need to qualify |
| // it. |
| return NewQT.getTypePtr(); |
| } |
| |
| static NestedNameSpecifier createOuterNNS(const ASTContext &Ctx, const Decl *D, |
| bool FullyQualify, |
| bool WithGlobalNsPrefix) { |
| const DeclContext *DC = D->getDeclContext(); |
| if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) { |
| while (NS && NS->isInline()) { |
| // Ignore inline namespace; |
| NS = dyn_cast<NamespaceDecl>(NS->getDeclContext()); |
| } |
| if (NS && NS->getDeclName()) { |
| return createNestedNameSpecifier(Ctx, NS, WithGlobalNsPrefix); |
| } |
| return std::nullopt; // no starting '::', no anonymous |
| } |
| if (const auto *TD = dyn_cast<TagDecl>(DC)) |
| return createNestedNameSpecifier(Ctx, TD, FullyQualify, WithGlobalNsPrefix); |
| if (const auto *TDD = dyn_cast<TypedefNameDecl>(DC)) |
| return createNestedNameSpecifier(Ctx, TDD, FullyQualify, |
| WithGlobalNsPrefix); |
| if (WithGlobalNsPrefix && DC->isTranslationUnit()) |
| return NestedNameSpecifier::getGlobal(); |
| return std::nullopt; // no starting '::' if |WithGlobalNsPrefix| is false |
| } |
| |
| /// Return a fully qualified version of this name specifier. |
| static NestedNameSpecifier getFullyQualifiedNestedNameSpecifier( |
| const ASTContext &Ctx, NestedNameSpecifier Scope, bool WithGlobalNsPrefix) { |
| switch (Scope.getKind()) { |
| case NestedNameSpecifier::Kind::Null: |
| llvm_unreachable("can't fully qualify the empty nested name specifier"); |
| case NestedNameSpecifier::Kind::Global: |
| case NestedNameSpecifier::Kind::MicrosoftSuper: |
| // Already fully qualified |
| return Scope; |
| case NestedNameSpecifier::Kind::Namespace: |
| return TypeName::createNestedNameSpecifier( |
| Ctx, Scope.getAsNamespaceAndPrefix().Namespace->getNamespace(), |
| WithGlobalNsPrefix); |
| case NestedNameSpecifier::Kind::Type: { |
| const Type *Type = Scope.getAsType(); |
| // Find decl context. |
| const TypeDecl *TD; |
| if (const TagType *TagDeclType = Type->getAs<TagType>()) |
| TD = TagDeclType->getOriginalDecl(); |
| else if (const auto *D = dyn_cast<TypedefType>(Type)) |
| TD = D->getDecl(); |
| else |
| return Scope; |
| return TypeName::createNestedNameSpecifier(Ctx, TD, /*FullyQualify=*/true, |
| WithGlobalNsPrefix); |
| } |
| } |
| llvm_unreachable("bad NNS kind"); |
| } |
| |
| /// Create a nested name specifier for the declaring context of |
| /// the type. |
| static NestedNameSpecifier |
| createNestedNameSpecifierForScopeOf(const ASTContext &Ctx, const Decl *Decl, |
| bool FullyQualified, |
| bool WithGlobalNsPrefix) { |
| assert(Decl); |
| |
| // Some declaration cannot be qualified. |
| if (Decl->isTemplateParameter()) |
| return std::nullopt; |
| const DeclContext *DC = Decl->getDeclContext()->getRedeclContext(); |
| const auto *Outer = dyn_cast<NamedDecl>(DC); |
| const auto *OuterNS = dyn_cast<NamespaceDecl>(DC); |
| if (OuterNS && OuterNS->isAnonymousNamespace()) |
| OuterNS = dyn_cast<NamespaceDecl>(OuterNS->getParent()); |
| if (Outer) { |
| if (const auto *CxxDecl = dyn_cast<CXXRecordDecl>(DC)) { |
| if (ClassTemplateDecl *ClassTempl = |
| CxxDecl->getDescribedClassTemplate()) { |
| // We are in the case of a type(def) that was declared in a |
| // class template but is *not* type dependent. In clang, it |
| // gets attached to the class template declaration rather than |
| // any specific class template instantiation. This result in |
| // 'odd' fully qualified typename: |
| // |
| // vector<_Tp,_Alloc>::size_type |
| // |
| // Make the situation is 'useable' but looking a bit odd by |
| // picking a random instance as the declaring context. |
| if (!ClassTempl->specializations().empty()) { |
| Decl = *(ClassTempl->spec_begin()); |
| Outer = dyn_cast<NamedDecl>(Decl); |
| OuterNS = dyn_cast<NamespaceDecl>(Decl); |
| } |
| } |
| } |
| |
| if (OuterNS) { |
| return createNestedNameSpecifier(Ctx, OuterNS, WithGlobalNsPrefix); |
| } else if (const auto *TD = dyn_cast<TagDecl>(Outer)) { |
| return createNestedNameSpecifier( |
| Ctx, TD, FullyQualified, WithGlobalNsPrefix); |
| } else if (isa<TranslationUnitDecl>(Outer)) { |
| // Context is the TU. Nothing needs to be done. |
| return std::nullopt; |
| } else { |
| // Decl's context was neither the TU, a namespace, nor a |
| // TagDecl, which means it is a type local to a scope, and not |
| // accessible at the end of the TU. |
| return std::nullopt; |
| } |
| } else if (WithGlobalNsPrefix && DC->isTranslationUnit()) { |
| return NestedNameSpecifier::getGlobal(); |
| } |
| return std::nullopt; |
| } |
| |
| /// Create a nested name specifier for the declaring context of |
| /// the type. |
| static NestedNameSpecifier |
| createNestedNameSpecifierForScopeOf(const ASTContext &Ctx, const Type *TypePtr, |
| bool FullyQualified, |
| bool WithGlobalNsPrefix) { |
| if (!TypePtr) |
| return std::nullopt; |
| |
| Decl *Decl = nullptr; |
| // There are probably other cases ... |
| if (const auto *TDT = dyn_cast<TypedefType>(TypePtr)) { |
| Decl = TDT->getDecl(); |
| } else if (const auto *TagDeclType = dyn_cast<TagType>(TypePtr)) { |
| Decl = TagDeclType->getOriginalDecl(); |
| } else if (const auto *TST = dyn_cast<TemplateSpecializationType>(TypePtr)) { |
| Decl = TST->getTemplateName().getAsTemplateDecl(); |
| } else { |
| Decl = TypePtr->getAsCXXRecordDecl(); |
| } |
| |
| if (!Decl) |
| return std::nullopt; |
| |
| return createNestedNameSpecifierForScopeOf( |
| Ctx, Decl, FullyQualified, WithGlobalNsPrefix); |
| } |
| |
| static NestedNameSpecifier |
| createNestedNameSpecifier(const ASTContext &Ctx, const NamespaceDecl *Namespace, |
| bool WithGlobalNsPrefix) { |
| while (Namespace && Namespace->isInline()) { |
| // Ignore inline namespace; |
| Namespace = dyn_cast<NamespaceDecl>(Namespace->getDeclContext()); |
| } |
| if (!Namespace) |
| return std::nullopt; |
| |
| bool FullyQualify = true; // doesn't matter, DeclContexts are namespaces |
| return NestedNameSpecifier( |
| Ctx, Namespace, |
| createOuterNNS(Ctx, Namespace, FullyQualify, WithGlobalNsPrefix)); |
| } |
| |
| NestedNameSpecifier createNestedNameSpecifier(const ASTContext &Ctx, |
| const TypeDecl *TD, |
| bool FullyQualify, |
| bool WithGlobalNsPrefix) { |
| const Type *TypePtr = Ctx.getTypeDeclType(TD).getTypePtr(); |
| if (auto *RD = dyn_cast<TagType>(TypePtr)) { |
| // We are asked to fully qualify and we have a Record Type (which |
| // may point to a template specialization) or Template |
| // Specialization Type. We need to fully qualify their arguments. |
| TypePtr = getFullyQualifiedTemplateType( |
| Ctx, RD, ElaboratedTypeKeyword::None, |
| createOuterNNS(Ctx, TD, FullyQualify, WithGlobalNsPrefix), |
| WithGlobalNsPrefix); |
| } else if (auto *TST = dyn_cast<TemplateSpecializationType>(TypePtr)) { |
| TypePtr = getFullyQualifiedTemplateType(Ctx, TST, WithGlobalNsPrefix); |
| } |
| return NestedNameSpecifier(TypePtr); |
| } |
| |
| /// Return the fully qualified type, including fully-qualified |
| /// versions of any template parameters. |
| QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx, |
| bool WithGlobalNsPrefix) { |
| // In case of myType* we need to strip the pointer first, fully |
| // qualify and attach the pointer once again. |
| if (isa<PointerType>(QT.getTypePtr())) { |
| // Get the qualifiers. |
| Qualifiers Quals = QT.getQualifiers(); |
| QT = getFullyQualifiedType(QT->getPointeeType(), Ctx, WithGlobalNsPrefix); |
| QT = Ctx.getPointerType(QT); |
| // Add back the qualifiers. |
| QT = Ctx.getQualifiedType(QT, Quals); |
| return QT; |
| } |
| |
| if (auto *MPT = dyn_cast<MemberPointerType>(QT.getTypePtr())) { |
| // Get the qualifiers. |
| Qualifiers Quals = QT.getQualifiers(); |
| // Fully qualify the pointee and class types. |
| QT = getFullyQualifiedType(QT->getPointeeType(), Ctx, WithGlobalNsPrefix); |
| NestedNameSpecifier Qualifier = getFullyQualifiedNestedNameSpecifier( |
| Ctx, MPT->getQualifier(), WithGlobalNsPrefix); |
| QT = Ctx.getMemberPointerType(QT, Qualifier, |
| MPT->getMostRecentCXXRecordDecl()); |
| // Add back the qualifiers. |
| QT = Ctx.getQualifiedType(QT, Quals); |
| return QT; |
| } |
| |
| // In case of myType& we need to strip the reference first, fully |
| // qualify and attach the reference once again. |
| if (isa<ReferenceType>(QT.getTypePtr())) { |
| // Get the qualifiers. |
| bool IsLValueRefTy = isa<LValueReferenceType>(QT.getTypePtr()); |
| Qualifiers Quals = QT.getQualifiers(); |
| QT = getFullyQualifiedType(QT->getPointeeType(), Ctx, WithGlobalNsPrefix); |
| // Add the r- or l-value reference type back to the fully |
| // qualified one. |
| if (IsLValueRefTy) |
| QT = Ctx.getLValueReferenceType(QT); |
| else |
| QT = Ctx.getRValueReferenceType(QT); |
| // Add back the qualifiers. |
| QT = Ctx.getQualifiedType(QT, Quals); |
| return QT; |
| } |
| |
| // Handle types with attributes such as `unique_ptr<int> _Nonnull`. |
| if (auto *AT = dyn_cast<AttributedType>(QT.getTypePtr())) { |
| QualType NewModified = |
| getFullyQualifiedType(AT->getModifiedType(), Ctx, WithGlobalNsPrefix); |
| QualType NewEquivalent = |
| getFullyQualifiedType(AT->getEquivalentType(), Ctx, WithGlobalNsPrefix); |
| Qualifiers Qualifiers = QT.getLocalQualifiers(); |
| return Ctx.getQualifiedType( |
| Ctx.getAttributedType(AT->getAttrKind(), NewModified, NewEquivalent), |
| Qualifiers); |
| } |
| |
| // Remove the part of the type related to the type being a template |
| // parameter (we won't report it as part of the 'type name' and it |
| // is actually make the code below to be more complex (to handle |
| // those) |
| while (isa<SubstTemplateTypeParmType>(QT.getTypePtr())) { |
| // Get the qualifiers. |
| Qualifiers Quals = QT.getQualifiers(); |
| |
| QT = cast<SubstTemplateTypeParmType>(QT.getTypePtr())->desugar(); |
| |
| // Add back the qualifiers. |
| QT = Ctx.getQualifiedType(QT, Quals); |
| } |
| |
| if (const auto *TST = |
| dyn_cast<const TemplateSpecializationType>(QT.getTypePtr())) { |
| |
| const Type *T = getFullyQualifiedTemplateType(Ctx, TST, WithGlobalNsPrefix); |
| if (T == TST) |
| return QT; |
| return Ctx.getQualifiedType(T, QT.getQualifiers()); |
| } |
| |
| // Local qualifiers are attached to the QualType outside of the |
| // elaborated type. Retrieve them before descending into the |
| // elaborated type. |
| Qualifiers PrefixQualifiers = QT.getLocalQualifiers(); |
| QT = QualType(QT.getTypePtr(), 0); |
| |
| // We don't consider the alias introduced by `using a::X` as a new type. |
| // The qualified name is still a::X. |
| if (const auto *UT = QT->getAs<UsingType>()) { |
| QT = Ctx.getQualifiedType(UT->desugar(), PrefixQualifiers); |
| return getFullyQualifiedType(QT, Ctx, WithGlobalNsPrefix); |
| } |
| |
| // Create a nested name specifier if needed. |
| NestedNameSpecifier Prefix = createNestedNameSpecifierForScopeOf( |
| Ctx, QT.getTypePtr(), true /*FullyQualified*/, WithGlobalNsPrefix); |
| |
| // In case of template specializations iterate over the arguments and |
| // fully qualify them as well. |
| if (const auto *TT = dyn_cast<TagType>(QT.getTypePtr())) { |
| // We are asked to fully qualify and we have a Record Type (which |
| // may point to a template specialization) or Template |
| // Specialization Type. We need to fully qualify their arguments. |
| |
| const Type *TypePtr = getFullyQualifiedTemplateType( |
| Ctx, TT, TT->getKeyword(), Prefix, WithGlobalNsPrefix); |
| QT = QualType(TypePtr, 0); |
| } else if (const auto *TT = dyn_cast<TypedefType>(QT.getTypePtr())) { |
| QT = Ctx.getTypedefType( |
| TT->getKeyword(), Prefix, TT->getDecl(), |
| getFullyQualifiedType(TT->desugar(), Ctx, WithGlobalNsPrefix)); |
| } else { |
| assert(!Prefix && "Unhandled type node"); |
| } |
| QT = Ctx.getQualifiedType(QT, PrefixQualifiers); |
| return QT; |
| } |
| |
| std::string getFullyQualifiedName(QualType QT, |
| const ASTContext &Ctx, |
| const PrintingPolicy &Policy, |
| bool WithGlobalNsPrefix) { |
| QualType FQQT = getFullyQualifiedType(QT, Ctx, WithGlobalNsPrefix); |
| return FQQT.getAsString(Policy); |
| } |
| |
| NestedNameSpecifier getFullyQualifiedDeclaredContext(const ASTContext &Ctx, |
| const Decl *Decl, |
| bool WithGlobalNsPrefix) { |
| return createNestedNameSpecifierForScopeOf(Ctx, Decl, /*FullyQualified=*/true, |
| WithGlobalNsPrefix); |
| } |
| |
| } // end namespace TypeName |
| } // end namespace clang |
