Skip to content

Commit f19eb95

Browse files
sdkrystiansdkrystian
committed
fix: merging of parameter names
1 parent 7353d63 commit f19eb95

File tree

1 file changed

+57
-49
lines changed

1 file changed

+57
-49
lines changed

‎src/lib/AST/ASTVisitor.cpp

+57-49
Original file line numberDiff line numberDiff line change
@@ -1025,69 +1025,75 @@ class ASTVisitor
10251025
return DD->getType();
10261026
}
10271027

1028-
std::unique_ptr<TParam>
1028+
void
10291029
buildTemplateParam(
1030+
std::unique_ptr<TParam>& I,
10301031
const NamedDecl* N)
10311032
{
1032-
auto TP = visit(N, [&]<typename DeclTy>(
1033-
const DeclTy* P) ->
1034-
std::unique_ptr<TParam>
1033+
visit(N, [&]<typename DeclTy>(const DeclTy* P)
10351034
{
10361035
constexpr Decl::Kind kind =
10371036
DeclToKind<DeclTy>();
10381037

10391038
if constexpr(kind == Decl::TemplateTypeParm)
10401039
{
1041-
auto R = std::make_unique<TypeTParam>();
1040+
if(! I)
1041+
I = std::make_unique<TypeTParam>();
1042+
auto* R = static_cast<TypeTParam*>(I.get());
10421043
if(P->wasDeclaredWithTypename())
10431044
R->KeyKind = TParamKeyKind::Typename;
1044-
if(P->hasDefaultArgument())
1045+
if(P->hasDefaultArgument() && !R->Default)
10451046
R->Default = buildTemplateArg(
10461047
P->getDefaultArgument().getArgument());
1047-
return R;
1048+
return;
10481049
}
10491050
else if constexpr(kind == Decl::NonTypeTemplateParm)
10501051
{
1051-
auto R = std::make_unique<NonTypeTParam>();
1052+
if(! I)
1053+
I = std::make_unique<NonTypeTParam>();
1054+
auto* R = static_cast<NonTypeTParam*>(I.get());
10521055
R->Type = buildTypeInfo(P->getType());
1053-
if(P->hasDefaultArgument())
1056+
if(P->hasDefaultArgument() && !R->Default)
10541057
R->Default = buildTemplateArg(
10551058
P->getDefaultArgument().getArgument());
1056-
return R;
1059+
return;
10571060
}
10581061
else if constexpr(kind == Decl::TemplateTemplateParm)
10591062
{
1060-
auto R = std::make_unique<TemplateTParam>();
1061-
for(const NamedDecl* NP : *P->getTemplateParameters())
1062-
R->Params.emplace_back(
1063-
buildTemplateParam(NP));
1064-
1065-
if(P->hasDefaultArgument())
1063+
if(! I)
1064+
I = std::make_unique<TemplateTParam>();
1065+
auto* R = static_cast<TemplateTParam*>(I.get());
1066+
if(R->Params.empty())
1067+
{
1068+
for(const NamedDecl* NP : *P->getTemplateParameters())
1069+
buildTemplateParam(R->Params.emplace_back(), NP);
1070+
}
1071+
if(P->hasDefaultArgument() && !R->Default)
10661072
R->Default = buildTemplateArg(
10671073
P->getDefaultArgument().getArgument());
1068-
return R;
1074+
return;
10691075
}
10701076
MRDOCS_UNREACHABLE();
10711077
});
10721078

1073-
TP->Name = extractName(N);
1079+
if(I->Name.empty())
1080+
I->Name = extractName(N);
10741081
// KRYSTIAN NOTE: Decl::isParameterPack
10751082
// returns true for function parameter packs
1076-
TP->IsParameterPack =
1083+
I->IsParameterPack =
10771084
N->isTemplateParameterPack();
1078-
1079-
return TP;
10801085
}
10811086

10821087
void
10831088
buildTemplateParams(
1084-
TemplateInfo& I,
1089+
TemplateInfo& TI,
10851090
const TemplateParameterList* TPL)
10861091
{
1087-
for(const NamedDecl* ND : *TPL)
1092+
for(std::size_t I = 0; I < TPL->size(); ++I)
10881093
{
1089-
I.Params.emplace_back(
1090-
buildTemplateParam(ND));
1094+
auto& PI = I < TI.Params.size() ?
1095+
TI.Params[I] : TI.Params.emplace_back();
1096+
buildTemplateParam(PI, TPL->getParam(I));
10911097
}
10921098
}
10931099

@@ -2049,15 +2055,12 @@ class ASTVisitor
20492055

20502056
for(const ParmVarDecl* P : D->parameters())
20512057
{
2052-
auto index = P->getFunctionScopeIndex();
2053-
Param& param = index < I.Params.size() ?
2054-
I.Params[index] : I.Params.emplace_back();
2055-
// KRYSTIAN NOTE: it's not clear what the correct thing
2056-
// to do here is. this will use the longest name seen
2057-
// in any redeclaration
2058-
if(std::string_view name = P->getName();
2059-
name.size() > param.Name.size())
2060-
param.Name = name;
2058+
Param& param = created ?
2059+
I.Params.emplace_back() :
2060+
I.Params[P->getFunctionScopeIndex()];
2061+
2062+
if(param.Name.empty())
2063+
param.Name = P->getName();
20612064

20622065
if(! param.Type)
20632066
param.Type = buildTypeInfo(P->getOriginalType());
@@ -2693,13 +2696,14 @@ traverse(
26932696
// explicit specialization, and the described template otherwise
26942697
if(CTD)
26952698
{
2696-
auto& Template = I.Template = std::make_unique<TemplateInfo>();
2699+
if(! I.Template)
2700+
I.Template = std::make_unique<TemplateInfo>();
26972701
// if D is a partial/explicit specialization, extract the template arguments
26982702
if(auto* CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
26992703
{
2700-
extractSymbolID(getInstantiatedFrom(CTD), Template->Primary);
2704+
extractSymbolID(getInstantiatedFrom(CTD), I.Template->Primary);
27012705
// extract the template arguments of the specialization
2702-
buildTemplateArgs(Template->Args, CTSD->getTemplateArgsAsWritten());
2706+
buildTemplateArgs(I.Template->Args, CTSD->getTemplateArgsAsWritten());
27032707
// extract the template parameters if this is a partial specialization
27042708
if(auto* CTPSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
27052709
buildTemplateParams(*I.Template, CTPSD->getTemplateParameters());
@@ -2730,13 +2734,14 @@ traverse(
27302734
// explicit specialization, and the described template otherwise
27312735
if(VTD)
27322736
{
2733-
auto& Template = I.Template = std::make_unique<TemplateInfo>();
2737+
if(! I.Template)
2738+
I.Template = std::make_unique<TemplateInfo>();
27342739
// if D is a partial/explicit specialization, extract the template arguments
27352740
if(auto* VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
27362741
{
2737-
extractSymbolID(getInstantiatedFrom(VTD), Template->Primary);
2742+
extractSymbolID(getInstantiatedFrom(VTD), I.Template->Primary);
27382743
// extract the template arguments of the specialization
2739-
buildTemplateArgs(Template->Args, VTSD->getTemplateArgsAsWritten());
2744+
buildTemplateArgs(I.Template->Args, VTSD->getTemplateArgsAsWritten());
27402745
// extract the template parameters if this is a partial specialization
27412746
if(auto* VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(D))
27422747
buildTemplateParams(*I.Template, VTPSD->getTemplateParameters());
@@ -2764,8 +2769,9 @@ traverse(
27642769
// D is the templated declaration if FTD is non-null
27652770
if(FTD)
27662771
{
2767-
auto& Template = I.Template = std::make_unique<TemplateInfo>();
2768-
buildTemplateParams(*Template, FTD->getTemplateParameters());
2772+
if(! I.Template)
2773+
I.Template = std::make_unique<TemplateInfo>();
2774+
buildTemplateParams(*I.Template, FTD->getTemplateParameters());
27692775
}
27702776

27712777
buildGuide(I, created, D);
@@ -2785,31 +2791,32 @@ traverse(
27852791
// D is the templated declaration if FTD is non-null
27862792
if(FTD || D->isFunctionTemplateSpecialization())
27872793
{
2788-
auto& Template = I.Template = std::make_unique<TemplateInfo>();
2794+
if(! I.Template)
2795+
I.Template = std::make_unique<TemplateInfo>();
27892796

27902797
if(auto* FTSI = D->getTemplateSpecializationInfo())
27912798
{
27922799
extractSymbolID(getInstantiatedFrom(
2793-
FTSI->getTemplate()), Template->Primary);
2800+
FTSI->getTemplate()), I.Template->Primary);
27942801
// TemplateArguments is used instead of TemplateArgumentsAsWritten
27952802
// because explicit specializations of function templates may have
27962803
// template arguments deduced from their return type and parameters
27972804
if(auto* Args = FTSI->TemplateArguments)
2798-
buildTemplateArgs(Template->Args, Args->asArray());
2805+
buildTemplateArgs(I.Template->Args, Args->asArray());
27992806
}
28002807
else if(auto* DFTSI = D->getDependentSpecializationInfo())
28012808
{
28022809
// Only extract the ID of the primary template if there is
28032810
// a single candidate primary template.
28042811
if(auto Candidates = DFTSI->getCandidates(); Candidates.size() == 1)
28052812
extractSymbolID(getInstantiatedFrom(
2806-
Candidates.front()), Template->Primary);
2813+
Candidates.front()), I.Template->Primary);
28072814
if(auto* Args = DFTSI->TemplateArgumentsAsWritten)
2808-
buildTemplateArgs(Template->Args, Args);
2815+
buildTemplateArgs(I.Template->Args, Args);
28092816
}
28102817
else
28112818
{
2812-
buildTemplateParams(*Template, FTD->getTemplateParameters());
2819+
buildTemplateParams(*I.Template, FTD->getTemplateParameters());
28132820
}
28142821
}
28152822

@@ -2835,7 +2842,8 @@ traverse(
28352842

28362843
if(ATD)
28372844
{
2838-
I.Template = std::make_unique<TemplateInfo>();
2845+
if(! I.Template)
2846+
I.Template = std::make_unique<TemplateInfo>();
28392847
buildTemplateParams(*I.Template,
28402848
ATD->getTemplateParameters());
28412849
}

0 commit comments

Comments
 (0)