Skip to content

Commit 9b12c0b

Browse files
mizvekovmizvekov
committed
[clang] CWG2398: improve overload resolution backwards compat
With this change, we discriminate if the primary template and which partial specializations would have participated in overload resolution prior to P0522 changes. We collect those in an initial set. If this set is not empty, or the primary template would have matched, we proceed with this set as the candidates for overload resolution. Otherwise, we build a new overload set with everything else, and proceed as usual.
1 parent 47e6d18 commit 9b12c0b

File tree

8 files changed

+97
-53
lines changed

8 files changed

+97
-53
lines changed

‎clang/docs/ReleaseNotes.rst

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -204,7 +204,8 @@ Resolutions to C++ Defect Reports
204204
(`CWG2351: void{} <https://cplusplus.github.io/CWG/issues/2351.html>`_).
205205

206206
- Clang now has improved resolution to CWG2398, allowing class templates to have
207-
default arguments deduced when partial ordering.
207+
default arguments deduced when partial ordering, and better backwards compatibility
208+
in overload resolution.
208209

209210
- Clang now allows comparing unequal object pointers that have been cast to ``void *``
210211
in constant expressions. These comparisons always worked in non-constant expressions.

‎clang/include/clang/Sema/Sema.h

Lines changed: 9 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -11636,7 +11636,8 @@ class Sema final : public SemaBase {
1163611636
SourceLocation RAngleLoc, unsigned ArgumentPackIndex,
1163711637
SmallVectorImpl<TemplateArgument> &SugaredConverted,
1163811638
SmallVectorImpl<TemplateArgument> &CanonicalConverted,
11639-
CheckTemplateArgumentKind CTAK);
11639+
CheckTemplateArgumentKind CTAK,
11640+
bool *MatchedPackOnParmToNonPackOnArg);
1164011641

1164111642
/// Check that the given template arguments can be provided to
1164211643
/// the given template, converting the arguments along the way.
@@ -11683,7 +11684,8 @@ class Sema final : public SemaBase {
1168311684
SmallVectorImpl<TemplateArgument> &SugaredConverted,
1168411685
SmallVectorImpl<TemplateArgument> &CanonicalConverted,
1168511686
bool UpdateArgsWithConversions = true,
11686-
bool *ConstraintsNotSatisfied = nullptr, bool PartialOrderingTTP = false);
11687+
bool *ConstraintsNotSatisfied = nullptr, bool PartialOrderingTTP = false,
11688+
bool *MatchedPackOnParmToNonPackOnArg = nullptr);
1168711689

1168811690
bool CheckTemplateTypeArgument(
1168911691
TemplateTypeParmDecl *Param, TemplateArgumentLoc &Arg,
@@ -11717,7 +11719,8 @@ class Sema final : public SemaBase {
1171711719
/// It returns true if an error occurred, and false otherwise.
1171811720
bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
1171911721
TemplateParameterList *Params,
11720-
TemplateArgumentLoc &Arg, bool IsDeduced);
11722+
TemplateArgumentLoc &Arg, bool IsDeduced,
11723+
bool *MatchedPackOnParmToNonPackOnArg);
1172111724

1172211725
void NoteTemplateLocation(const NamedDecl &Decl,
1172311726
std::optional<SourceRange> ParamRange = {});
@@ -12418,7 +12421,7 @@ class Sema final : public SemaBase {
1241812421
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
1241912422
TemplateParameterList *PParam, TemplateDecl *PArg, TemplateDecl *AArg,
1242012423
const DefaultArguments &DefaultArgs, SourceLocation ArgLoc,
12421-
bool IsDeduced);
12424+
bool IsDeduced, bool *MatchedPackOnParmToNonPackOnArg);
1242212425

1242312426
/// Mark which template parameters are used in a given expression.
1242412427
///
@@ -13417,7 +13420,8 @@ class Sema final : public SemaBase {
1341713420
bool InstantiateClassTemplateSpecialization(
1341813421
SourceLocation PointOfInstantiation,
1341913422
ClassTemplateSpecializationDecl *ClassTemplateSpec,
13420-
TemplateSpecializationKind TSK, bool Complain = true);
13423+
TemplateSpecializationKind TSK, bool Complain = true,
13424+
bool PrimaryHasMatchedPackOnParmToNonPackOnArg = false);
1342113425

1342213426
/// Instantiates the definitions of all of the member
1342313427
/// of the given class, which is an instantiation of a class template

‎clang/include/clang/Sema/TemplateDeduction.h

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,11 @@ class TemplateDeductionInfo {
5151
/// Have we suppressed an error during deduction?
5252
bool HasSFINAEDiagnostic = false;
5353

54+
/// Have we matched any packs on the parameter side, versus any non-packs on
55+
/// the argument side, in a context where the opposite matching is also
56+
/// allowed?
57+
bool MatchedPackOnParmToNonPackOnArg = false;
58+
5459
/// The template parameter depth for which we're performing deduction.
5560
unsigned DeducedDepth;
5661

@@ -87,6 +92,14 @@ class TemplateDeductionInfo {
8792
return DeducedDepth;
8893
}
8994

95+
bool hasMatchedPackOnParmToNonPackOnArg() const {
96+
return MatchedPackOnParmToNonPackOnArg;
97+
}
98+
99+
void setMatchedPackOnParmToNonPackOnArg() {
100+
MatchedPackOnParmToNonPackOnArg = true;
101+
}
102+
90103
/// Get the number of explicitly-specified arguments.
91104
unsigned getNumExplicitArgs() const {
92105
return ExplicitArgs;

‎clang/lib/Sema/SemaLookup.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3666,7 +3666,8 @@ Sema::LookupLiteralOperator(Scope *S, LookupResult &R,
36663666
TemplateArgumentLoc Arg(TemplateArgument(StringLit), StringLit);
36673667
if (CheckTemplateArgument(
36683668
Params->getParam(0), Arg, FD, R.getNameLoc(), R.getNameLoc(),
3669-
0, SugaredChecked, CanonicalChecked, CTAK_Specified) ||
3669+
0, SugaredChecked, CanonicalChecked, CTAK_Specified,
3670+
/*MatchedPackOnParmToNonPackOnArg=*/nullptr) ||
36703671
Trap.hasErrorOccurred())
36713672
IsTemplate = false;
36723673
}

‎clang/lib/Sema/SemaTemplate.cpp

Lines changed: 26 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -5179,7 +5179,7 @@ bool Sema::CheckTemplateArgument(
51795179
unsigned ArgumentPackIndex,
51805180
SmallVectorImpl<TemplateArgument> &SugaredConverted,
51815181
SmallVectorImpl<TemplateArgument> &CanonicalConverted,
5182-
CheckTemplateArgumentKind CTAK) {
5182+
CheckTemplateArgumentKind CTAK, bool *MatchedPackOnParmToNonPackOnArg) {
51835183
// Check template type parameters.
51845184
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
51855185
return CheckTemplateTypeArgument(TTP, Arg, SugaredConverted,
@@ -5395,7 +5395,8 @@ bool Sema::CheckTemplateArgument(
53955395
case TemplateArgument::Template:
53965396
case TemplateArgument::TemplateExpansion:
53975397
if (CheckTemplateTemplateArgument(TempParm, Params, Arg,
5398-
/*IsDeduced=*/CTAK != CTAK_Specified))
5398+
/*IsDeduced=*/CTAK != CTAK_Specified,
5399+
MatchedPackOnParmToNonPackOnArg))
53995400
return true;
54005401

54015402
SugaredConverted.push_back(Arg.getArgument());
@@ -5469,7 +5470,7 @@ bool Sema::CheckTemplateArgumentList(
54695470
SmallVectorImpl<TemplateArgument> &SugaredConverted,
54705471
SmallVectorImpl<TemplateArgument> &CanonicalConverted,
54715472
bool UpdateArgsWithConversions, bool *ConstraintsNotSatisfied,
5472-
bool PartialOrderingTTP) {
5473+
bool PartialOrderingTTP, bool *MatchedPackOnParmToNonPackOnArg) {
54735474

54745475
if (ConstraintsNotSatisfied)
54755476
*ConstraintsNotSatisfied = false;
@@ -5545,10 +5546,10 @@ bool Sema::CheckTemplateArgumentList(
55455546

55465547
if (ArgIdx < NumArgs) {
55475548
// Check the template argument we were given.
5548-
if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template, TemplateLoc,
5549-
RAngleLoc, SugaredArgumentPack.size(),
5550-
SugaredConverted, CanonicalConverted,
5551-
CTAK_Specified))
5549+
if (CheckTemplateArgument(
5550+
*Param, NewArgs[ArgIdx], Template, TemplateLoc, RAngleLoc,
5551+
SugaredArgumentPack.size(), SugaredConverted, CanonicalConverted,
5552+
CTAK_Specified, MatchedPackOnParmToNonPackOnArg))
55525553
return true;
55535554

55545555
CanonicalConverted.back().setIsDefaulted(
@@ -5714,7 +5715,8 @@ bool Sema::CheckTemplateArgumentList(
57145715
// Check the default template argument.
57155716
if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc, RAngleLoc, 0,
57165717
SugaredConverted, CanonicalConverted,
5717-
CTAK_Specified))
5718+
CTAK_Specified,
5719+
/*MatchedPackOnParmToNonPackOnArg=*/nullptr))
57185720
return true;
57195721

57205722
SugaredConverted.back().setIsDefaulted(true);
@@ -7292,10 +7294,10 @@ static void DiagnoseTemplateParameterListArityMismatch(
72927294
Sema &S, TemplateParameterList *New, TemplateParameterList *Old,
72937295
Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc);
72947296

7295-
bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
7296-
TemplateParameterList *Params,
7297-
TemplateArgumentLoc &Arg,
7298-
bool IsDeduced) {
7297+
bool Sema::CheckTemplateTemplateArgument(
7298+
TemplateTemplateParmDecl *Param, TemplateParameterList *Params,
7299+
TemplateArgumentLoc &Arg, bool IsDeduced,
7300+
bool *MatchedPackOnParmToNonPackOnArg) {
72997301
TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
73007302
auto [Template, DefaultArgs] = Name.getTemplateDeclAndDefaultArgs();
73017303
if (!Template) {
@@ -7339,7 +7341,8 @@ bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
73397341
// A template-argument matches a template template-parameter P when P
73407342
// is at least as specialized as the template-argument A.
73417343
if (!isTemplateTemplateParameterAtLeastAsSpecializedAs(
7342-
Params, Param, Template, DefaultArgs, Arg.getLocation(), IsDeduced))
7344+
Params, Param, Template, DefaultArgs, Arg.getLocation(), IsDeduced,
7345+
MatchedPackOnParmToNonPackOnArg))
73437346
return true;
73447347
// P2113
73457348
// C++20[temp.func.order]p2
@@ -9757,11 +9760,14 @@ DeclResult Sema::ActOnExplicitInstantiation(
97579760

97589761
// Check that the template argument list is well-formed for this
97599762
// template.
9763+
bool PrimaryHasMatchedPackOnParmToNonPackOnArg = false;
97609764
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
9761-
if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, TemplateArgs,
9762-
/*DefaultArgs=*/{}, false, SugaredConverted,
9763-
CanonicalConverted,
9764-
/*UpdateArgsWithConversions=*/true))
9765+
if (CheckTemplateArgumentList(
9766+
ClassTemplate, TemplateNameLoc, TemplateArgs,
9767+
/*DefaultArgs=*/{}, false, SugaredConverted, CanonicalConverted,
9768+
/*UpdateArgsWithConversions=*/true,
9769+
/*ConstraintsNotSatisfied=*/nullptr, /*PartialOrderingTTP=*/false,
9770+
&PrimaryHasMatchedPackOnParmToNonPackOnArg))
97659771
return true;
97669772

97679773
// Find the class template specialization declaration that
@@ -9882,7 +9888,9 @@ DeclResult Sema::ActOnExplicitInstantiation(
98829888
= cast_or_null<ClassTemplateSpecializationDecl>(
98839889
Specialization->getDefinition());
98849890
if (!Def)
9885-
InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK);
9891+
InstantiateClassTemplateSpecialization(
9892+
TemplateNameLoc, Specialization, TSK,
9893+
/*Complain=*/true, PrimaryHasMatchedPackOnParmToNonPackOnArg);
98869894
else if (TSK == TSK_ExplicitInstantiationDefinition) {
98879895
MarkVTableUsed(TemplateNameLoc, Specialization, true);
98889896
Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());

‎clang/lib/Sema/SemaTemplateDeduction.cpp

Lines changed: 30 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -2767,8 +2767,12 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
27672767
for (; hasTemplateArgumentForDeduction(As, ArgIdx) &&
27682768
PackScope.hasNextElement();
27692769
++ArgIdx) {
2770-
if (!FoldPackParameter && !As[ArgIdx].isPackExpansion())
2771-
return TemplateDeductionResult::MiscellaneousDeductionFailure;
2770+
if (!As[ArgIdx].isPackExpansion()) {
2771+
if (!FoldPackParameter)
2772+
return TemplateDeductionResult::MiscellaneousDeductionFailure;
2773+
if (FoldPackArgument)
2774+
Info.setMatchedPackOnParmToNonPackOnArg();
2775+
}
27722776
// Deduce template arguments from the pattern.
27732777
if (auto Result = DeduceTemplateArguments(
27742778
S, TemplateParams, Pattern, As[ArgIdx], Info, PartialOrdering,
@@ -2962,15 +2966,20 @@ static bool ConvertDeducedTemplateArgument(
29622966
TemplateArgumentLoc ArgLoc = S.getTrivialTemplateArgumentLoc(
29632967
Arg, QualType(), Info.getLocation(), Param);
29642968

2969+
bool MatchedPackOnParmToNonPackOnArg = false;
29652970
// Check the template argument, converting it as necessary.
2966-
return S.CheckTemplateArgument(
2971+
auto Res = S.CheckTemplateArgument(
29672972
Param, ArgLoc, Template, Template->getLocation(),
29682973
Template->getSourceRange().getEnd(), ArgumentPackIndex, SugaredOutput,
29692974
CanonicalOutput,
29702975
IsDeduced
29712976
? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound
29722977
: Sema::CTAK_Deduced)
2973-
: Sema::CTAK_Specified);
2978+
: Sema::CTAK_Specified,
2979+
&MatchedPackOnParmToNonPackOnArg);
2980+
if (MatchedPackOnParmToNonPackOnArg)
2981+
Info.setMatchedPackOnParmToNonPackOnArg();
2982+
return Res;
29742983
};
29752984

29762985
if (Arg.getKind() == TemplateArgument::Pack) {
@@ -3165,7 +3174,8 @@ static TemplateDeductionResult ConvertDeducedTemplateArguments(
31653174
// Check whether we can actually use the default argument.
31663175
if (S.CheckTemplateArgument(
31673176
Param, DefArg, TD, TD->getLocation(), TD->getSourceRange().getEnd(),
3168-
0, SugaredBuilder, CanonicalBuilder, Sema::CTAK_Specified)) {
3177+
0, SugaredBuilder, CanonicalBuilder, Sema::CTAK_Specified,
3178+
/*MatchedPackOnParmToNonPackOnArg=*/nullptr)) {
31693179
Info.Param = makeTemplateParameter(
31703180
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
31713181
// FIXME: These template arguments are temporary. Free them!
@@ -3314,16 +3324,20 @@ FinishTemplateArgumentDeduction(
33143324
return TemplateDeductionResult::SubstitutionFailure;
33153325
}
33163326

3327+
bool MatchedPackOnParmToNonPackOnArg = false;
33173328
bool ConstraintsNotSatisfied;
33183329
SmallVector<TemplateArgument, 4> SugaredConvertedInstArgs,
33193330
CanonicalConvertedInstArgs;
33203331
if (S.CheckTemplateArgumentList(
33213332
Template, Partial->getLocation(), InstArgs, /*DefaultArgs=*/{}, false,
33223333
SugaredConvertedInstArgs, CanonicalConvertedInstArgs,
3323-
/*UpdateArgsWithConversions=*/true, &ConstraintsNotSatisfied))
3334+
/*UpdateArgsWithConversions=*/true, &ConstraintsNotSatisfied,
3335+
/*PartialOrderingTTP=*/false, &MatchedPackOnParmToNonPackOnArg))
33243336
return ConstraintsNotSatisfied
33253337
? TemplateDeductionResult::ConstraintsNotSatisfied
33263338
: TemplateDeductionResult::SubstitutionFailure;
3339+
if (MatchedPackOnParmToNonPackOnArg)
3340+
Info.setMatchedPackOnParmToNonPackOnArg();
33273341

33283342
TemplateParameterList *TemplateParams = Template->getTemplateParameters();
33293343
for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
@@ -6470,8 +6484,8 @@ bool Sema::isMoreSpecializedThanPrimary(
64706484

64716485
bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
64726486
TemplateParameterList *P, TemplateDecl *PArg, TemplateDecl *AArg,
6473-
const DefaultArguments &DefaultArgs, SourceLocation ArgLoc,
6474-
bool IsDeduced) {
6487+
const DefaultArguments &DefaultArgs, SourceLocation ArgLoc, bool IsDeduced,
6488+
bool *MatchedPackOnParmToNonPackOnArg) {
64756489
// C++1z [temp.arg.template]p4: (DR 150)
64766490
// A template template-parameter P is at least as specialized as a
64776491
// template template-argument A if, given the following rewrite to two
@@ -6523,11 +6537,11 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
65236537
// If the rewrite produces an invalid type, then P is not at least as
65246538
// specialized as A.
65256539
SmallVector<TemplateArgument, 4> CanonicalPArgs;
6526-
if (CheckTemplateArgumentList(AArg, ArgLoc, PArgList, DefaultArgs, false,
6527-
PArgs, CanonicalPArgs,
6528-
/*UpdateArgsWithConversions=*/true,
6529-
/*ConstraintsNotSatisfied=*/nullptr,
6530-
/*PartialOrderingTTP=*/true))
6540+
if (CheckTemplateArgumentList(
6541+
AArg, ArgLoc, PArgList, DefaultArgs, false, PArgs, CanonicalPArgs,
6542+
/*UpdateArgsWithConversions=*/true,
6543+
/*ConstraintsNotSatisfied=*/nullptr,
6544+
/*PartialOrderingTTP=*/true, MatchedPackOnParmToNonPackOnArg))
65316545
return false;
65326546
}
65336547

@@ -6553,6 +6567,9 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
65536567
IsDeduced ? PackFold::ArgumentToParameter : PackFold::Both,
65546568
/*HasDeducedAnyParam=*/nullptr)) {
65556569
case clang::TemplateDeductionResult::Success:
6570+
if (MatchedPackOnParmToNonPackOnArg &&
6571+
Info.hasMatchedPackOnParmToNonPackOnArg())
6572+
*MatchedPackOnParmToNonPackOnArg = true;
65566573
break;
65576574

65586575
case TemplateDeductionResult::MiscellaneousDeductionFailure:

‎clang/lib/Sema/SemaTemplateInstantiate.cpp

Lines changed: 14 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -4004,11 +4004,11 @@ bool Sema::usesPartialOrExplicitSpecialization(
40044004
/// Get the instantiation pattern to use to instantiate the definition of a
40054005
/// given ClassTemplateSpecializationDecl (either the pattern of the primary
40064006
/// template or of a partial specialization).
4007-
static ActionResult<CXXRecordDecl *>
4008-
getPatternForClassTemplateSpecialization(
4007+
static ActionResult<CXXRecordDecl *> getPatternForClassTemplateSpecialization(
40094008
Sema &S, SourceLocation PointOfInstantiation,
40104009
ClassTemplateSpecializationDecl *ClassTemplateSpec,
4011-
TemplateSpecializationKind TSK) {
4010+
TemplateSpecializationKind TSK,
4011+
bool PrimaryHasMatchedPackOnParmToNonPackOnArg) {
40124012
Sema::InstantiatingTemplate Inst(S, PointOfInstantiation, ClassTemplateSpec);
40134013
if (Inst.isInvalid())
40144014
return {/*Invalid=*/true};
@@ -4031,7 +4031,7 @@ getPatternForClassTemplateSpecialization(
40314031
// specialization with the template argument lists of the partial
40324032
// specializations.
40334033
typedef PartialSpecMatchResult MatchResult;
4034-
SmallVector<MatchResult, 4> Matched;
4034+
SmallVector<MatchResult, 4> Matched, ExtraMatched;
40354035
SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
40364036
Template->getPartialSpecializations(PartialSpecs);
40374037
TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation);
@@ -4048,11 +4048,13 @@ getPatternForClassTemplateSpecialization(
40484048
MakeDeductionFailureInfo(S.Context, Result, Info));
40494049
(void)Result;
40504050
} else {
4051-
Matched.push_back(PartialSpecMatchResult());
4052-
Matched.back().Partial = Partial;
4053-
Matched.back().Args = Info.takeCanonical();
4051+
auto &List =
4052+
Info.hasMatchedPackOnParmToNonPackOnArg() ? ExtraMatched : Matched;
4053+
List.push_back(MatchResult{Partial, Info.takeCanonical()});
40544054
}
40554055
}
4056+
if (Matched.empty() && PrimaryHasMatchedPackOnParmToNonPackOnArg)
4057+
Matched = std::move(ExtraMatched);
40564058

40574059
// If we're dealing with a member template where the template parameters
40584060
// have been instantiated, this provides the original template parameters
@@ -4155,16 +4157,18 @@ getPatternForClassTemplateSpecialization(
41554157
bool Sema::InstantiateClassTemplateSpecialization(
41564158
SourceLocation PointOfInstantiation,
41574159
ClassTemplateSpecializationDecl *ClassTemplateSpec,
4158-
TemplateSpecializationKind TSK, bool Complain) {
4160+
TemplateSpecializationKind TSK, bool Complain,
4161+
bool PrimaryHasMatchedPackOnParmToNonPackOnArg) {
41594162
// Perform the actual instantiation on the canonical declaration.
41604163
ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
41614164
ClassTemplateSpec->getCanonicalDecl());
41624165
if (ClassTemplateSpec->isInvalidDecl())
41634166
return true;
41644167

41654168
ActionResult<CXXRecordDecl *> Pattern =
4166-
getPatternForClassTemplateSpecialization(*this, PointOfInstantiation,
4167-
ClassTemplateSpec, TSK);
4169+
getPatternForClassTemplateSpecialization(
4170+
*this, PointOfInstantiation, ClassTemplateSpec, TSK,
4171+
PrimaryHasMatchedPackOnParmToNonPackOnArg);
41684172
if (!Pattern.isUsable())
41694173
return Pattern.isInvalid();
41704174

0 commit comments

Comments
 (0)