Method InsertTemplateParameters

CodeGenerator.cpp:1782–1885

//-----------------------------------------------------------------------------

void CodeGenerator::InsertTemplateParameters(const TemplateParameterList& list,
                                             const TemplateParamsOnly     templateParamsOnly)
{
    const bool full{TemplateParamsOnly::No == templateParamsOnly};

    if(full) {
        for(const auto* param : list) {
            if(const auto* nonTmplParam = dyn_cast_or_null<NonTypeTemplateParmDecl>(param);
               nonTmplParam and nonTmplParam->hasDefaultArgument()) {
                if(auto val =
                       EvaluateNTTPAsConstantExpr(nonTmplParam->getDefaultArgument().getArgument().getAsExpr())) {
                    auto* init = GetGlobalAST().getTemplateParamObjectDecl(val->first, val->second);

                    InsertTemplateArgsObjectParam(*init);
                }
            }
        }

        mOutputFormatHelper.Append(kwTemplate);
    }

    mOutputFormatHelper.Append("<"sv);

    for(OnceFalse needsComma{}; const auto* param : list) {
        mOutputFormatHelper.AppendComma(needsComma);

        const auto& typeName = GetName(*param);

        if(const auto* tt = dyn_cast_or_null<TemplateTypeParmDecl>(param)) {
            if(full) {
                if(tt->wasDeclaredWithTypename()) {
                    mOutputFormatHelper.Append(kwTypeNameSpace);
                } else if(not tt->hasTypeConstraint()) {
                    mOutputFormatHelper.Append(kwClassSpace);
                }

                mOutputFormatHelper.Append(EllipsisSpace(tt->isParameterPack()));
            }

            if(0 == typeName.size() or tt->isImplicit() /* fixes class container:auto*/) {
                AppendTemplateTypeParamName(mOutputFormatHelper, tt, not full);

            } else {
                if(auto typeConstraint = GetTypeConstraintAsString(tt->getTypeConstraint());
                   not typeConstraint.empty()) {
                    mOutputFormatHelper.Append(std::move(typeConstraint), " "sv);
                }

                mOutputFormatHelper.Append(typeName);
            }

            mOutputFormatHelper.Append(EllipsisSpace(not full and tt->isParameterPack()));

            if(tt->hasDefaultArgument() and not tt->defaultArgumentWasInherited()) {
                const auto& defaultArg = tt->getDefaultArgument();

                if(const auto decltypeType = dyn_cast_or_null<DecltypeType>(defaultArg.getArgument().getAsType())) {
                    mOutputFormatHelper.Append(hlpAssing);