================
@@ -6837,64 +6846,55 @@ ExprResult
Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
assert(!ParamType.hasQualifiers() &&
"non-type template parameter type cannot be qualified");
+ // If either the parameter has a dependent type or the argument is
+ // type-dependent, there's nothing we can check now.
+ if (ParamType->isDependentType() || DeductionArg->isTypeDependent()) {
+ // Force the argument to the type of the parameter to maintain invariants.
+ ExprResult E = ImpCastExprToType(
+ DeductionArg, ParamType.getNonLValueExprType(Context), CK_Dependent,
+ ParamType->isLValueReferenceType() ? VK_LValue
+ : ParamType->isRValueReferenceType() ? VK_XValue
+ : VK_PRValue);
+ if (E.isInvalid())
+ return ExprError();
+ setDeductionArg(E.get());
+ SugaredConverted = TemplateArgument(Arg);
+ CanonicalConverted = TemplateArgument(
+ Context.getCanonicalTemplateArgument(SugaredConverted));
+ return Arg;
+ }
+
// FIXME: When Param is a reference, should we check that Arg is an lvalue?
- if (CTAK == CTAK_Deduced &&
+ if (CTAK == CTAK_Deduced && !StrictCheck &&
(ParamType->isReferenceType()
? !Context.hasSameType(ParamType.getNonReferenceType(),
- Arg->getType())
- : !Context.hasSameUnqualifiedType(ParamType, Arg->getType()))) {
- // FIXME: If either type is dependent, we skip the check. This isn't
- // correct, since during deduction we're supposed to have replaced each
- // template parameter with some unique (non-dependent) placeholder.
- // FIXME: If the argument type contains 'auto', we carry on and fail the
- // type check in order to force specific types to be more specialized than
- // 'auto'. It's not clear how partial ordering with 'auto' is supposed to
- // work. Similarly for CTAD, when comparing 'A<x>' against 'A'.
- if ((ParamType->isDependentType() || Arg->isTypeDependent()) &&
- !Arg->getType()->getContainedDeducedType()) {
- SugaredConverted = TemplateArgument(Arg);
- CanonicalConverted = TemplateArgument(
- Context.getCanonicalTemplateArgument(SugaredConverted));
- return Arg;
- }
+ DeductionArg->getType())
+ : !Context.hasSameUnqualifiedType(ParamType,
+ DeductionArg->getType()))) {
// FIXME: This attempts to implement C++ [temp.deduct.type]p17. Per DR1770,
// we should actually be checking the type of the template argument in P,
// not the type of the template argument deduced from A, against the
// template parameter type.
Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
- << Arg->getType()
- << ParamType.getUnqualifiedType();
+ << Arg->getType() << ParamType.getUnqualifiedType();
NoteTemplateParameterLocation(*Param);
return ExprError();
}
- // If either the parameter has a dependent type or the argument is
- // type-dependent, there's nothing we can check now.
- if (ParamType->isDependentType() || Arg->isTypeDependent()) {
- // Force the argument to the type of the parameter to maintain invariants.
- auto *PE = dyn_cast<PackExpansionExpr>(Arg);
- if (PE)
- Arg = PE->getPattern();
- ExprResult E = ImpCastExprToType(
- Arg, ParamType.getNonLValueExprType(Context), CK_Dependent,
- ParamType->isLValueReferenceType() ? VK_LValue
- : ParamType->isRValueReferenceType() ? VK_XValue
- : VK_PRValue);
----------------
mizvekov wrote:
This is not removed by the way, this was moved up a little bit.
The problem here was even getting into this case for #132562.
This is meant for type-dependent parameter or argument, but in the case of the
issue this was considering the argument as type-dependent, even though the
pattern is not, because an unexpanded pack expression is always type-dependent.
In this case, we could have proceed checking it the same as for the
non-dependent case.
https://github.com/llvm/llvm-project/pull/134461
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
