//===------- 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/DeclTemplate.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/GlobalDecl.h"

#include "clang/AST/Mangle.h"

#include "clang/AST/QualTypeNames.h"

#include <stdio.h>

#include <memory>

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 *scope, bool WithGlobalNsPrefix);

static bool getFullyQualifiedTemplateName(const ASTContext &Ctx,

                                          TemplateName &TName,

                                          bool WithGlobalNsPrefix) {

  bool Changed = false;

  NestedNameSpecifier *NNS = nullptr;

  TemplateDecl *ArgTDecl = TName.getAsTemplateDecl();

  // ArgTDecl won't be NULL because we asserted that this isn't a

  // dependent context very early in the call chain.

  assert(ArgTDecl != nullptr);

  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 = nullptr;

    }

  } else {

    NNS = createNestedNameSpecifierForScopeOf(

        Ctx, ArgTDecl, true, WithGlobalNsPrefix);

  }

  if (NNS) {

    TName = Ctx.getQualifiedTemplateName(NNS,

                                         /*TemplateKeyword=*/false, ArgTDecl);

    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 Type *TypePtr,

                                                 bool WithGlobalNsPrefix) {

  // DependentTemplateTypes exist within template declarations and

  // definitions. Therefore we shouldn't encounter them at the end of

  // a translation unit. If we do, the caller has made an error.

  assert(!isa<DependentTemplateSpecializationType>(TypePtr));

  // In case of template specializations, iterate over the arguments

  // and fully qualify them as well.

  if (const auto *TST = dyn_cast<const TemplateSpecializationType>(TypePtr)) {

    bool MightHaveChanged = false;

    SmallVector<TemplateArgument, 4> FQArgs;

    for (TemplateSpecializationType::iterator I = TST->begin(), E = TST->end();

         I != E; ++I) {

      // Cheap to copy and potentially modified by

      // getFullyQualifedTemplateArgument.

      TemplateArgument Arg(*I);

      MightHaveChanged |= getFullyQualifiedTemplateArgument(

          Ctx, Arg, WithGlobalNsPrefix);

      FQArgs.push_back(Arg);

    }

    // If a fully qualified arg is different from the unqualified arg,

    // allocate new type in the AST.

    if (MightHaveChanged) {

      QualType QT = Ctx.getTemplateSpecializationType(

          TST->getTemplateName(), FQArgs,

          TST->getCanonicalTypeInternal());

      // getTemplateSpecializationType returns a fully qualified

      // version of the specialization itself, so no need to qualify

      // it.

      return QT.getTypePtr();

    }

  } else if (const auto *TSTRecord = dyn_cast<const RecordType>(TypePtr)) {

    // 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.

    if (const auto *TSTDecl =

        dyn_cast<ClassTemplateSpecializationDecl>(TSTRecord->getDecl())) {

      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 a fully qualified arg is different from the unqualified arg,

      // allocate new type in the AST.

      if (MightHaveChanged) {

        TemplateName TN(TSTDecl->getSpecializedTemplate());

        QualType QT = Ctx.getTemplateSpecializationType(

            TN, FQArgs,

            TSTRecord->getCanonicalTypeInternal());

        // getTemplateSpecializationType returns a fully qualified

        // version of the specialization itself, so no need to qualify

        // it.

        return QT.getTypePtr();

      }

    }

  }

  return TypePtr;

}

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 nullptr;  // no starting '::', no anonymous

  } else if (const auto *TD = dyn_cast<TagDecl>(DC)) {

    return createNestedNameSpecifier(Ctx, TD, FullyQualify, WithGlobalNsPrefix);

  } else if (const auto *TDD = dyn_cast<TypedefNameDecl>(DC)) {

    return createNestedNameSpecifier(

        Ctx, TDD, FullyQualify, WithGlobalNsPrefix);

  } else if (WithGlobalNsPrefix && 
DC->isTranslationUnit()0
) {

    return NestedNameSpecifier::GlobalSpecifier(Ctx);

  }

  return nullptr;  // 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::Global:

      // Already fully qualified

      return Scope;

    case NestedNameSpecifier::Namespace:

      return TypeName::createNestedNameSpecifier(

          Ctx, Scope->getAsNamespace(), WithGlobalNsPrefix);

    case NestedNameSpecifier::NamespaceAlias:

      // Namespace aliases are only valid for the duration of the

      // scope where they were introduced, and therefore are often

      // invalid at the end of the TU.  So use the namespace name more

      // likely to be valid at the end of the TU.

      return TypeName::createNestedNameSpecifier(

          Ctx,

          Scope->getAsNamespaceAlias()->getNamespace()->getCanonicalDecl(),

          WithGlobalNsPrefix);

    case NestedNameSpecifier::Identifier:

      // A function or some other construct that makes it un-namable

      // at the end of the TU. Skip the current component of the name,

      // but use the name of it's prefix.

      return getFullyQualifiedNestedNameSpecifier(

          Ctx, Scope->getPrefix(), WithGlobalNsPrefix);

    case NestedNameSpecifier::Super:

    case NestedNameSpecifier::TypeSpec:

    case NestedNameSpecifier::TypeSpecWithTemplate: {

      const Type *Type = Scope->getAsType();

      // Find decl context.

      const TagDecl *TD = nullptr;

      if (const TagType *TagDeclType = Type->getAs<TagType>()) {

        TD = TagDeclType->getDecl();

      } else {

        TD = Type->getAsCXXRecordDecl();

      }

      if (TD) {

        return TypeName::createNestedNameSpecifier(Ctx, TD,

                                                   true /*FullyQualified*/,

                                                   WithGlobalNsPrefix);

      } else if (const auto *TDD = dyn_cast<TypedefType>(Type)) {

        return TypeName::createNestedNameSpecifier(Ctx, TDD->getDecl(),

                                                   true /*FullyQualified*/,

                                                   WithGlobalNsPrefix);

      }

      return Scope;

    }

  }

  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);

  const DeclContext *DC = Decl->getDeclContext()->getRedeclContext();

  const auto *Outer = dyn_cast_or_null<NamedDecl>(DC);

  const auto *OuterNS = dyn_cast_or_null<NamespaceDecl>(DC);

  if (Outer && 
!(32
OuterNS32
 && 
OuterNS->isAnonymousNamespace()17
)) {

    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->spec_begin() != ClassTempl->spec_end()) {

          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 (dyn_cast<TranslationUnitDecl>(Outer)) {

      // Context is the TU. Nothing needs to be done.

      return nullptr;

    } 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 nullptr;

    }

  } else if (WithGlobalNsPrefix && 
DC->isTranslationUnit()0
) {

    return NestedNameSpecifier::GlobalSpecifier(Ctx);

  }

  return nullptr;

}

/// 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 nullptr0
;

  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->getDecl();

  } else if (const auto *TST = dyn_cast<TemplateSpecializationType>(TypePtr)) {

    Decl = TST->getTemplateName().getAsTemplateDecl();

  } else {

    Decl = TypePtr->getAsCXXRecordDecl();

  }

  if (!Decl) 
return nullptr0
;

  return createNestedNameSpecifierForScopeOf(

      Ctx, Decl, FullyQualified, WithGlobalNsPrefix);

}

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 nullptr0
;

  bool FullyQualified = true;  // doesn't matter, DeclContexts are namespaces

  return NestedNameSpecifier::Create(

      Ctx,

      createOuterNNS(Ctx, Namespace, FullyQualified, WithGlobalNsPrefix),

      Namespace);

}

NestedNameSpecifier *createNestedNameSpecifier(const ASTContext &Ctx,

                                               const TypeDecl *TD,

                                               bool FullyQualify,

                                               bool WithGlobalNsPrefix) {

  return NestedNameSpecifier::Create(

      Ctx,

      createOuterNNS(Ctx, TD, FullyQualify, WithGlobalNsPrefix),

      false /*No TemplateKeyword*/,

      TD->getTypeForDecl());

}

/// 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);

    QualType Class = getFullyQualifiedType(QualType(MPT->getClass(), 0), Ctx,

                                           WithGlobalNsPrefix);

    QT = Ctx.getMemberPointerType(QT, Class.getTypePtr());

    // 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;

  }

  // 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);

  }

  NestedNameSpecifier *Prefix = nullptr;

  // 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);

  ElaboratedTypeKeyword Keyword = ETK_None;

  if (const auto *ETypeInput = dyn_cast<ElaboratedType>(QT.getTypePtr())) {

    QT = ETypeInput->getNamedType();

    assert(!QT.hasLocalQualifiers());

    Keyword = ETypeInput->getKeyword();

  }

  // Create a nested name specifier if needed.

  Prefix = createNestedNameSpecifierForScopeOf(Ctx, QT.getTypePtr(),

                                               true /*FullyQualified*/,

                                               WithGlobalNsPrefix);

  // In case of template specializations iterate over the arguments and

  // fully qualify them as well.

  if (isa<const TemplateSpecializationType>(QT.getTypePtr()) ||

      isa<const RecordType>(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, QT.getTypePtr(), WithGlobalNsPrefix);

    QT = QualType(TypePtr, 0);

  }

  if (Prefix || 
Keyword != ETK_None83
) {

    QT = Ctx.getElaboratedType(Keyword, Prefix, QT);

  }

  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);

}

}  // end namespace TypeName

}  // end namespace clang