Author: Younan Zhang Date: 2025-06-02T17:10:07+08:00 New Revision: e04e140adb600add79b414f137a13af9d89c8c0d
URL: https://github.com/llvm/llvm-project/commit/e04e140adb600add79b414f137a13af9d89c8c0d DIFF: https://github.com/llvm/llvm-project/commit/e04e140adb600add79b414f137a13af9d89c8c0d.diff LOG: [Clang] Reapply CWG2369 "Ordering between constraints and substitution" (#122423) The previous approach broke code generation for the MS ABI due to an unintended code path during constraint substitution. This time we address the issue by inspecting the evaluation contexts and thereby avoiding that code path. This reapplies 96eced624 (#102857). Added: clang/test/CodeGenCXX/ms-mangle-requires.cpp Modified: clang/include/clang/Sema/Sema.h clang/include/clang/Sema/Template.h clang/lib/Sema/SemaConcept.cpp clang/lib/Sema/SemaOverload.cpp clang/lib/Sema/SemaTemplateDeduction.cpp clang/lib/Sema/SemaTemplateDeductionGuide.cpp clang/lib/Sema/SemaTemplateInstantiate.cpp clang/lib/Sema/SemaTemplateInstantiateDecl.cpp clang/lib/Sema/TreeTransform.h clang/test/CXX/drs/cwg23xx.cpp clang/test/CXX/drs/cwg26xx.cpp clang/test/CXX/drs/cwg27xx.cpp clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp clang/test/CXX/temp/temp.constr/temp.constr.atomic/constrant-satisfaction-conversions.cpp clang/test/SemaCXX/concept-crash-on-diagnostic.cpp clang/test/SemaCXX/cxx20-ctad-type-alias.cpp clang/test/SemaCXX/cxx23-assume.cpp clang/test/SemaCXX/cxx2c-fold-exprs.cpp clang/test/SemaCXX/lambda-unevaluated.cpp clang/test/SemaCXX/overload-resolution-deferred-templates.cpp clang/test/SemaTemplate/concepts-recursive-inst.cpp clang/test/SemaTemplate/concepts.cpp clang/test/SemaTemplate/cxx2a-constraint-exprs.cpp clang/test/SemaTemplate/deduction-guide.cpp clang/test/SemaTemplate/nested-implicit-deduction-guides.cpp clang/www/cxx_dr_status.html Removed: ################################################################################ diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 6ce9ae588b637..8040f1ac6af01 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -10505,13 +10505,34 @@ class Sema final : public SemaBase { OverloadCandidateParamOrder PO = {}, bool AggregateCandidateDeduction = false); + struct CheckNonDependentConversionsFlag { + /// Do not consider any user-defined conversions when constructing the + /// initializing sequence. + bool SuppressUserConversions; + + /// Before constructing the initializing sequence, we check whether the + /// parameter type and argument type contain any user defined conversions. + /// If so, do not initialize them. This effectively bypasses some undesired + /// instantiation before checking constaints, which might otherwise result + /// in non-SFINAE errors e.g. recursive constraints. + bool OnlyInitializeNonUserDefinedConversions; + + CheckNonDependentConversionsFlag( + bool SuppressUserConversions, + bool OnlyInitializeNonUserDefinedConversions) + : SuppressUserConversions(SuppressUserConversions), + OnlyInitializeNonUserDefinedConversions( + OnlyInitializeNonUserDefinedConversions) {} + }; + /// Check that implicit conversion sequences can be formed for each argument /// whose corresponding parameter has a non-dependent type, per DR1391's /// [temp.deduct.call]p10. bool CheckNonDependentConversions( FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes, ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet, - ConversionSequenceList &Conversions, bool SuppressUserConversions, + ConversionSequenceList &Conversions, + CheckNonDependentConversionsFlag UserConversionFlag, CXXRecordDecl *ActingContext = nullptr, QualType ObjectType = QualType(), Expr::Classification ObjectClassification = {}, OverloadCandidateParamOrder PO = {}); @@ -12555,6 +12576,11 @@ class Sema final : public SemaBase { /// /// \param OriginalCallArgs If non-NULL, the original call arguments against /// which the deduced argument types should be compared. + /// \param CheckNonDependent Callback before substituting into the declaration + /// with the deduced template arguments. + /// \param OnlyInitializeNonUserDefinedConversions is used as a workaround for + /// some breakages introduced by CWG2369, where non-user-defined conversions + /// are checked first before the constraints. TemplateDeductionResult FinishTemplateArgumentDeduction( FunctionTemplateDecl *FunctionTemplate, SmallVectorImpl<DeducedTemplateArgument> &Deduced, @@ -12562,7 +12588,10 @@ class Sema final : public SemaBase { sema::TemplateDeductionInfo &Info, SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs, bool PartialOverloading, bool PartialOrdering, - llvm::function_ref<bool()> CheckNonDependent = [] { return false; }); + llvm::function_ref<bool(bool)> CheckNonDependent = + [](bool /*OnlyInitializeNonUserDefinedConversions*/) { + return false; + }); /// Perform template argument deduction from a function call /// (C++ [temp.deduct.call]). @@ -12598,7 +12627,7 @@ class Sema final : public SemaBase { bool PartialOrdering, QualType ObjectType, Expr::Classification ObjectClassification, bool ForOverloadSetAddressResolution, - llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent); + llvm::function_ref<bool(ArrayRef<QualType>, bool)> CheckNonDependent); /// Deduce template arguments when taking the address of a function /// template (C++ [temp.deduct.funcaddr]) or matching a specialization to @@ -13074,6 +13103,9 @@ class Sema final : public SemaBase { /// Was the enclosing context a non-instantiation SFINAE context? bool SavedInNonInstantiationSFINAEContext; + /// Whether we're substituting into constraints. + bool InConstraintSubstitution; + /// The point of instantiation or synthesis within the source code. SourceLocation PointOfInstantiation; @@ -13123,9 +13155,9 @@ class Sema final : public SemaBase { CodeSynthesisContext() : Kind(TemplateInstantiation), - SavedInNonInstantiationSFINAEContext(false), Entity(nullptr), - Template(nullptr), TemplateArgs(nullptr), NumTemplateArgs(0), - DeductionInfo(nullptr) {} + SavedInNonInstantiationSFINAEContext(false), + InConstraintSubstitution(false), Entity(nullptr), Template(nullptr), + TemplateArgs(nullptr), NumTemplateArgs(0), DeductionInfo(nullptr) {} /// Determines whether this template is an actual instantiation /// that should be counted toward the maximum instantiation depth. @@ -13369,9 +13401,22 @@ class Sema final : public SemaBase { /// /// \param SkipForSpecialization when specified, any template specializations /// in a traversal would be ignored. + /// /// \param ForDefaultArgumentSubstitution indicates we should continue looking /// when encountering a specialized member function template, rather than /// returning immediately. + void getTemplateInstantiationArgs( + MultiLevelTemplateArgumentList &Result, const NamedDecl *D, + const DeclContext *DC = nullptr, bool Final = false, + std::optional<ArrayRef<TemplateArgument>> Innermost = std::nullopt, + bool RelativeToPrimary = false, const FunctionDecl *Pattern = nullptr, + bool ForConstraintInstantiation = false, + bool SkipForSpecialization = false, + bool ForDefaultArgumentSubstitution = false); + + /// This creates a new \p MultiLevelTemplateArgumentList and invokes the other + /// overload with it as the first parameter. Prefer this overload in most + /// situations. MultiLevelTemplateArgumentList getTemplateInstantiationArgs( const NamedDecl *D, const DeclContext *DC = nullptr, bool Final = false, std::optional<ArrayRef<TemplateArgument>> Innermost = std::nullopt, @@ -13644,7 +13689,7 @@ class Sema final : public SemaBase { ExprResult SubstConstraintExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs); - // Unlike the above, this does not evaluates constraints. + // Unlike the above, this does not evaluate constraints. ExprResult SubstConstraintExprWithoutSatisfaction( Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs); @@ -13794,6 +13839,12 @@ class Sema final : public SemaBase { return CodeSynthesisContexts.size() > NonInstantiationEntries; } + /// Determine whether we are currently performing constraint substitution. + bool inConstraintSubstitution() const { + return !CodeSynthesisContexts.empty() && + CodeSynthesisContexts.back().InConstraintSubstitution; + } + using EntityPrinter = llvm::function_ref<void(llvm::raw_ostream &)>; /// \brief create a Requirement::SubstitutionDiagnostic with only a @@ -14786,10 +14837,10 @@ class Sema final : public SemaBase { const MultiLevelTemplateArgumentList &TemplateArgs, SourceRange TemplateIDRange); - bool CheckInstantiatedFunctionTemplateConstraints( - SourceLocation PointOfInstantiation, FunctionDecl *Decl, - ArrayRef<TemplateArgument> TemplateArgs, - ConstraintSatisfaction &Satisfaction); + bool CheckFunctionTemplateConstraints(SourceLocation PointOfInstantiation, + FunctionDecl *Decl, + ArrayRef<TemplateArgument> TemplateArgs, + ConstraintSatisfaction &Satisfaction); /// \brief Emit diagnostics explaining why a constraint expression was deemed /// unsatisfied. diff --git a/clang/include/clang/Sema/Template.h b/clang/include/clang/Sema/Template.h index f9a10cfafb1f7..af0c1e8506cf3 100644 --- a/clang/include/clang/Sema/Template.h +++ b/clang/include/clang/Sema/Template.h @@ -522,6 +522,12 @@ enum class TemplateSubstitutionKind : char { llvm::PointerUnion<Decl *, DeclArgumentPack *> * findInstantiationOf(const Decl *D); + /// Similar to \p findInstantiationOf(), but it wouldn't assert if the + /// instantiation was not found within the current instantiation scope. This + /// is helpful for on-demand declaration instantiation. + llvm::PointerUnion<Decl *, DeclArgumentPack *> * + getInstantiationOfIfExists(const Decl *D); + void InstantiatedLocal(const Decl *D, Decl *Inst); void InstantiatedLocalPackArg(const Decl *D, VarDecl *Inst); void MakeInstantiatedLocalArgPack(const Decl *D); diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp index c6a54dc141ded..a4f660c39b4b5 100644 --- a/clang/lib/Sema/SemaConcept.cpp +++ b/clang/lib/Sema/SemaConcept.cpp @@ -792,7 +792,7 @@ bool Sema::CheckFunctionConstraints(const FunctionDecl *FD, bool ForOverloadResolution) { // Don't check constraints if the function is dependent. Also don't check if // this is a function template specialization, as the call to - // CheckinstantiatedFunctionTemplateConstraints after this will check it + // CheckFunctionTemplateConstraints after this will check it // better. if (FD->isDependentContext() || FD->getTemplatedKind() == @@ -1060,12 +1060,55 @@ bool Sema::EnsureTemplateArgumentListConstraints( return false; } -bool Sema::CheckInstantiatedFunctionTemplateConstraints( +static bool CheckFunctionConstraintsWithoutInstantiation( + Sema &SemaRef, SourceLocation PointOfInstantiation, + FunctionTemplateDecl *Template, ArrayRef<TemplateArgument> TemplateArgs, + ConstraintSatisfaction &Satisfaction) { + SmallVector<AssociatedConstraint, 3> TemplateAC; + Template->getAssociatedConstraints(TemplateAC); + if (TemplateAC.empty()) { + Satisfaction.IsSatisfied = true; + return false; + } + + LocalInstantiationScope Scope(SemaRef); + + FunctionDecl *FD = Template->getTemplatedDecl(); + // Collect the list of template arguments relative to the 'primary' + // template. We need the entire list, since the constraint is completely + // uninstantiated at this point. + + // FIXME: Add TemplateArgs through the 'Innermost' parameter once + // the refactoring of getTemplateInstantiationArgs() relands. + MultiLevelTemplateArgumentList MLTAL; + MLTAL.addOuterTemplateArguments(Template, std::nullopt, /*Final=*/false); + SemaRef.getTemplateInstantiationArgs( + MLTAL, /*D=*/FD, FD, + /*Final=*/false, /*Innermost=*/std::nullopt, /*RelativeToPrimary=*/true, + /*Pattern=*/nullptr, /*ForConstraintInstantiation=*/true); + MLTAL.replaceInnermostTemplateArguments(Template, TemplateArgs); + + Sema::ContextRAII SavedContext(SemaRef, FD); + std::optional<Sema::CXXThisScopeRAII> ThisScope; + if (auto *Method = dyn_cast<CXXMethodDecl>(FD)) + ThisScope.emplace(SemaRef, /*Record=*/Method->getParent(), + /*ThisQuals=*/Method->getMethodQualifiers()); + return SemaRef.CheckConstraintSatisfaction( + Template, TemplateAC, MLTAL, PointOfInstantiation, Satisfaction); +} + +bool Sema::CheckFunctionTemplateConstraints( SourceLocation PointOfInstantiation, FunctionDecl *Decl, ArrayRef<TemplateArgument> TemplateArgs, ConstraintSatisfaction &Satisfaction) { // In most cases we're not going to have constraints, so check for that first. FunctionTemplateDecl *Template = Decl->getPrimaryTemplate(); + + if (!Template) + return ::CheckFunctionConstraintsWithoutInstantiation( + *this, PointOfInstantiation, Decl->getDescribedFunctionTemplate(), + TemplateArgs, Satisfaction); + // Note - code synthesis context for the constraints check is created // inside CheckConstraintsSatisfaction. SmallVector<AssociatedConstraint, 3> TemplateAC; diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index 69768dd3a7212..390508a0fca31 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -7848,11 +7848,14 @@ static void AddMethodTemplateCandidateImmediately( /*PartialOrdering=*/false, ObjectType, ObjectClassification, CandidateSet.getKind() == clang::OverloadCandidateSet::CSK_AddressOfOverloadSet, - [&](ArrayRef<QualType> ParamTypes) { + [&](ArrayRef<QualType> ParamTypes, + bool OnlyInitializeNonUserDefinedConversions) { return S.CheckNonDependentConversions( MethodTmpl, ParamTypes, Args, CandidateSet, Conversions, - SuppressUserConversions, ActingContext, ObjectType, - ObjectClassification, PO); + Sema::CheckNonDependentConversionsFlag( + SuppressUserConversions, + OnlyInitializeNonUserDefinedConversions), + ActingContext, ObjectType, ObjectClassification, PO); }); Result != TemplateDeductionResult::Success) { OverloadCandidate &Candidate = @@ -7964,10 +7967,14 @@ static void AddTemplateOverloadCandidateImmediately( /*ObjectClassification=*/Expr::Classification(), CandidateSet.getKind() == OverloadCandidateSet::CSK_AddressOfOverloadSet, - [&](ArrayRef<QualType> ParamTypes) { + [&](ArrayRef<QualType> ParamTypes, + bool OnlyInitializeNonUserDefinedConversions) { return S.CheckNonDependentConversions( FunctionTemplate, ParamTypes, Args, CandidateSet, Conversions, - SuppressUserConversions, nullptr, QualType(), {}, PO); + Sema::CheckNonDependentConversionsFlag( + SuppressUserConversions, + OnlyInitializeNonUserDefinedConversions), + nullptr, QualType(), {}, PO); }); Result != TemplateDeductionResult::Success) { OverloadCandidate &Candidate = @@ -8041,7 +8048,8 @@ void Sema::AddTemplateOverloadCandidate( bool Sema::CheckNonDependentConversions( FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes, ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet, - ConversionSequenceList &Conversions, bool SuppressUserConversions, + ConversionSequenceList &Conversions, + CheckNonDependentConversionsFlag UserConversionFlag, CXXRecordDecl *ActingContext, QualType ObjectType, Expr::Classification ObjectClassification, OverloadCandidateParamOrder PO) { // FIXME: The cases in which we allow explicit conversions for constructor @@ -8054,8 +8062,9 @@ bool Sema::CheckNonDependentConversions( bool HasThisConversion = Method && !isa<CXXConstructorDecl>(Method); unsigned ThisConversions = HasThisConversion ? 1 : 0; - Conversions = - CandidateSet.allocateConversionSequences(ThisConversions + Args.size()); + if (Conversions.empty()) + Conversions = + CandidateSet.allocateConversionSequences(ThisConversions + Args.size()); // Overload resolution is always an unevaluated context. EnterExpressionEvaluationContext Unevaluated( @@ -8079,6 +8088,46 @@ bool Sema::CheckNonDependentConversions( } } + // A speculative workaround for self-dependent constraint bugs that manifest + // after CWG2369. + // FIXME: Add references to the standard once P3606 is adopted. + auto MaybeInvolveUserDefinedConversion = [&](QualType ParamType, + QualType ArgType) { + ParamType = ParamType.getNonReferenceType(); + ArgType = ArgType.getNonReferenceType(); + bool PointerConv = ParamType->isPointerType() && ArgType->isPointerType(); + if (PointerConv) { + ParamType = ParamType->getPointeeType(); + ArgType = ArgType->getPointeeType(); + } + + if (auto *RT = ParamType->getAs<RecordType>()) + if (auto *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()); + RD && RD->hasDefinition()) { + if (llvm::any_of(LookupConstructors(RD), [](NamedDecl *ND) { + auto Info = getConstructorInfo(ND); + if (!Info) + return false; + CXXConstructorDecl *Ctor = Info.Constructor; + /// isConvertingConstructor takes copy/move constructors into + /// account! + return !Ctor->isCopyOrMoveConstructor() && + Ctor->isConvertingConstructor( + /*AllowExplicit=*/true); + })) + return true; + } + + if (auto *RT = ArgType->getAs<RecordType>()) + if (auto *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()); + RD && RD->hasDefinition() && + !RD->getVisibleConversionFunctions().empty()) { + return true; + } + + return false; + }; + unsigned Offset = Method && Method->hasCXXExplicitFunctionObjectParameter() ? 1 : 0; @@ -8099,13 +8148,16 @@ bool Sema::CheckNonDependentConversions( // For members, 'this' got ConvIdx = 0 previously. ConvIdx = ThisConversions + I; } - Conversions[ConvIdx] - = TryCopyInitialization(*this, Args[I], ParamType, - SuppressUserConversions, - /*InOverloadResolution=*/true, - /*AllowObjCWritebackConversion=*/ - getLangOpts().ObjCAutoRefCount, - AllowExplicit); + if (Conversions[ConvIdx].isInitialized()) + continue; + if (UserConversionFlag.OnlyInitializeNonUserDefinedConversions && + MaybeInvolveUserDefinedConversion(ParamType, Args[I]->getType())) + continue; + Conversions[ConvIdx] = TryCopyInitialization( + *this, Args[I], ParamType, UserConversionFlag.SuppressUserConversions, + /*InOverloadResolution=*/true, + /*AllowObjCWritebackConversion=*/ + getLangOpts().ObjCAutoRefCount, AllowExplicit); if (Conversions[ConvIdx].isBad()) return true; } diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp index 5566057cccef8..94edd553aacd7 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -3885,7 +3885,7 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction( TemplateDeductionInfo &Info, SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs, bool PartialOverloading, bool PartialOrdering, - llvm::function_ref<bool()> CheckNonDependent) { + llvm::function_ref<bool(bool)> CheckNonDependent) { // Unevaluated SFINAE context. EnterExpressionEvaluationContext Unevaluated( *this, Sema::ExpressionEvaluationContext::Unevaluated); @@ -3914,18 +3914,6 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction( Result != TemplateDeductionResult::Success) return Result; - // C++ [temp.deduct.call]p10: [DR1391] - // If deduction succeeds for all parameters that contain - // template-parameters that participate in template argument deduction, - // and all template arguments are explicitly specified, deduced, or - // obtained from default template arguments, remaining parameters are then - // compared with the corresponding arguments. For each remaining parameter - // P with a type that was non-dependent before substitution of any - // explicitly-specified template arguments, if the corresponding argument - // A cannot be implicitly converted to P, deduction fails. - if (CheckNonDependent()) - return TemplateDeductionResult::NonDependentConversionFailure; - // Form the template argument list from the deduced template arguments. TemplateArgumentList *SugaredDeducedArgumentList = TemplateArgumentList::CreateCopy(Context, CTAI.SugaredConverted); @@ -3940,6 +3928,42 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction( Owner = FunctionTemplate->getLexicalDeclContext(); FunctionDecl *FD = FunctionTemplate->getTemplatedDecl(); + if (CheckNonDependent(/*OnlyInitializeNonUserDefinedConversions=*/true)) + return TemplateDeductionResult::NonDependentConversionFailure; + + // C++20 [temp.deduct.general]p5: [CWG2369] + // If the function template has associated constraints, those constraints + // are checked for satisfaction. If the constraints are not satisfied, type + // deduction fails. + // + // FIXME: We haven't implemented CWG2369 for lambdas yet, because we need + // to figure out how to instantiate lambda captures to the scope without + // first instantiating the lambda. + bool IsLambda = isLambdaCallOperator(FD) || isLambdaConversionOperator(FD); + if (!IsLambda && !IsIncomplete) { + if (CheckFunctionTemplateConstraints( + Info.getLocation(), + FunctionTemplate->getCanonicalDecl()->getTemplatedDecl(), + CTAI.CanonicalConverted, Info.AssociatedConstraintsSatisfaction)) + return TemplateDeductionResult::MiscellaneousDeductionFailure; + if (!Info.AssociatedConstraintsSatisfaction.IsSatisfied) { + Info.reset(Info.takeSugared(), TemplateArgumentList::CreateCopy( + Context, CTAI.CanonicalConverted)); + return TemplateDeductionResult::ConstraintsNotSatisfied; + } + } + // C++ [temp.deduct.call]p10: [CWG1391] + // If deduction succeeds for all parameters that contain + // template-parameters that participate in template argument deduction, + // and all template arguments are explicitly specified, deduced, or + // obtained from default template arguments, remaining parameters are then + // compared with the corresponding arguments. For each remaining parameter + // P with a type that was non-dependent before substitution of any + // explicitly-specified template arguments, if the corresponding argument + // A cannot be implicitly converted to P, deduction fails. + if (CheckNonDependent(/*OnlyInitializeNonUserDefinedConversions=*/false)) + return TemplateDeductionResult::NonDependentConversionFailure; + MultiLevelTemplateArgumentList SubstArgs( FunctionTemplate, CanonicalDeducedArgumentList->asArray(), /*Final=*/false); @@ -3974,8 +3998,8 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction( // ([temp.constr.decl]), those constraints are checked for satisfaction // ([temp.constr.constr]). If the constraints are not satisfied, type // deduction fails. - if (!IsIncomplete) { - if (CheckInstantiatedFunctionTemplateConstraints( + if (IsLambda && !IsIncomplete) { + if (CheckFunctionTemplateConstraints( Info.getLocation(), Specialization, CTAI.CanonicalConverted, Info.AssociatedConstraintsSatisfaction)) return TemplateDeductionResult::MiscellaneousDeductionFailure; @@ -4435,7 +4459,7 @@ TemplateDeductionResult Sema::DeduceTemplateArguments( bool PartialOrdering, QualType ObjectType, Expr::Classification ObjectClassification, bool ForOverloadSetAddressResolution, - llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent) { + llvm::function_ref<bool(ArrayRef<QualType>, bool)> CheckNonDependent) { if (FunctionTemplate->isInvalidDecl()) return TemplateDeductionResult::Invalid; @@ -4657,9 +4681,10 @@ TemplateDeductionResult Sema::DeduceTemplateArguments( Result = FinishTemplateArgumentDeduction( FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info, &OriginalCallArgs, PartialOverloading, PartialOrdering, - [&, CallingCtx]() { + [&, CallingCtx](bool OnlyInitializeNonUserDefinedConversions) { ContextRAII SavedContext(*this, CallingCtx); - return CheckNonDependent(ParamTypesForArgChecking); + return CheckNonDependent(ParamTypesForArgChecking, + OnlyInitializeNonUserDefinedConversions); }); }); return Result; @@ -4740,8 +4765,8 @@ TemplateDeductionResult Sema::DeduceTemplateArguments( /*AdjustExceptionSpec*/false); // Unevaluated SFINAE context. - EnterExpressionEvaluationContext Unevaluated( - *this, Sema::ExpressionEvaluationContext::Unevaluated); + std::optional<EnterExpressionEvaluationContext> Unevaluated( + std::in_place, *this, Sema::ExpressionEvaluationContext::Unevaluated); SFINAETrap Trap(*this); Deduced.resize(TemplateParams->size()); @@ -4784,13 +4809,14 @@ TemplateDeductionResult Sema::DeduceTemplateArguments( DeduceReturnType(Specialization, Info.getLocation(), false)) return TemplateDeductionResult::MiscellaneousDeductionFailure; + Unevaluated = std::nullopt; // [C++26][expr.const]/p17 // An expression or conversion is immediate-escalating if it is not initially // in an immediate function context and it is [...] // a potentially-evaluated id-expression that denotes an immediate function. if (IsAddressOfFunction && getLangOpts().CPlusPlus20 && Specialization->isImmediateEscalating() && - parentEvaluationContext().isPotentiallyEvaluated() && + currentEvaluationContext().isPotentiallyEvaluated() && CheckIfFunctionSpecializationIsImmediate(Specialization, Info.getLocation())) return TemplateDeductionResult::MiscellaneousDeductionFailure; diff --git a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp index c75013b05d990..bdc46a0115a45 100644 --- a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp +++ b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp @@ -955,10 +955,12 @@ Expr *buildIsDeducibleConstraint(Sema &SemaRef, Context.getTrivialTypeSourceInfo( Context.getDeducedTemplateSpecializationType( TemplateName(AliasTemplate), /*DeducedType=*/QualType(), - /*IsDependent=*/true)), // template specialization type whose - // arguments will be deduced. + /*IsDependent=*/true), + AliasTemplate->getLocation()), // template specialization type whose + // arguments will be deduced. Context.getTrivialTypeSourceInfo( - ReturnType), // type from which template arguments are deduced. + ReturnType, AliasTemplate->getLocation()), // type from which template + // arguments are deduced. }; return TypeTraitExpr::Create( Context, Context.getLogicalOperationType(), AliasTemplate->getLocation(), diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp index 3a04a24d3aa7a..a1c7143e3b874 100644 --- a/clang/lib/Sema/SemaTemplateInstantiate.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp @@ -474,6 +474,21 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs( assert((ND || DC) && "Can't find arguments for a decl if one isn't provided"); // Accumulate the set of template argument lists in this structure. MultiLevelTemplateArgumentList Result; + getTemplateInstantiationArgs( + Result, ND, DC, Final, Innermost, RelativeToPrimary, Pattern, + ForConstraintInstantiation, SkipForSpecialization, + ForDefaultArgumentSubstitution); + return Result; +} + +void Sema::getTemplateInstantiationArgs( + MultiLevelTemplateArgumentList &Result, const NamedDecl *ND, + const DeclContext *DC, bool Final, + std::optional<ArrayRef<TemplateArgument>> Innermost, bool RelativeToPrimary, + const FunctionDecl *Pattern, bool ForConstraintInstantiation, + bool SkipForSpecialization, bool ForDefaultArgumentSubstitution) { + assert((ND || DC) && "Can't find arguments for a decl if one isn't provided"); + // Accumulate the set of template argument lists in this structure. using namespace TemplateInstArgsHelpers; const Decl *CurDecl = ND; @@ -533,14 +548,12 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs( } if (R.IsDone) - return Result; + return; if (R.ClearRelativeToPrimary) RelativeToPrimary = false; assert(R.NextDecl); CurDecl = R.NextDecl; } - - return Result; } bool Sema::CodeSynthesisContext::isInstantiationRecord() const { @@ -609,6 +622,12 @@ Sema::InstantiatingTemplate::InstantiatingTemplate( Inst.NumTemplateArgs = TemplateArgs.size(); Inst.DeductionInfo = DeductionInfo; Inst.InstantiationRange = InstantiationRange; + Inst.InConstraintSubstitution = + Inst.Kind == CodeSynthesisContext::ConstraintSubstitution; + if (!SemaRef.CodeSynthesisContexts.empty()) + Inst.InConstraintSubstitution |= + SemaRef.CodeSynthesisContexts.back().InConstraintSubstitution; + SemaRef.pushCodeSynthesisContext(Inst); AlreadyInstantiating = !Inst.Entity ? false : @@ -1375,6 +1394,12 @@ namespace { // Whether an incomplete substituion should be treated as an error. bool BailOutOnIncomplete; + private: + // CWG2770: Function parameters should be instantiated when they are + // needed by a satisfaction check of an atomic constraint or + // (recursively) by another function parameter. + bool maybeInstantiateFunctionParameterToScope(ParmVarDecl *OldParm); + public: typedef TreeTransform<TemplateInstantiator> inherited; @@ -1431,12 +1456,19 @@ namespace { ArrayRef<UnexpandedParameterPack> Unexpanded, bool &ShouldExpand, bool &RetainExpansion, UnsignedOrNone &NumExpansions) { - return getSema().CheckParameterPacksForExpansion(EllipsisLoc, - PatternRange, Unexpanded, - TemplateArgs, - ShouldExpand, - RetainExpansion, - NumExpansions); + if (SemaRef.CurrentInstantiationScope && + SemaRef.inConstraintSubstitution()) { + for (UnexpandedParameterPack ParmPack : Unexpanded) { + NamedDecl *VD = ParmPack.first.dyn_cast<NamedDecl *>(); + if (auto *PVD = dyn_cast_if_present<ParmVarDecl>(VD); + PVD && maybeInstantiateFunctionParameterToScope(PVD)) + return true; + } + } + + return getSema().CheckParameterPacksForExpansion( + EllipsisLoc, PatternRange, Unexpanded, TemplateArgs, ShouldExpand, + RetainExpansion, NumExpansions); } void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { @@ -1920,9 +1952,57 @@ Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) { // template parameter. } + if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(D); + PVD && SemaRef.CurrentInstantiationScope && + SemaRef.inConstraintSubstitution() && + maybeInstantiateFunctionParameterToScope(PVD)) + return nullptr; + return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs); } +bool TemplateInstantiator::maybeInstantiateFunctionParameterToScope( + ParmVarDecl *OldParm) { + if (SemaRef.CurrentInstantiationScope->getInstantiationOfIfExists(OldParm)) + return false; + + if (!OldParm->isParameterPack()) + return !TransformFunctionTypeParam(OldParm, /*indexAdjustment=*/0, + /*NumExpansions=*/std::nullopt, + /*ExpectParameterPack=*/false); + + SmallVector<UnexpandedParameterPack, 2> Unexpanded; + + // Find the parameter packs that could be expanded. + TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc(); + PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>(); + TypeLoc Pattern = ExpansionTL.getPatternLoc(); + SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded); + assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); + + bool ShouldExpand = false; + bool RetainExpansion = false; + UnsignedOrNone OrigNumExpansions = + ExpansionTL.getTypePtr()->getNumExpansions(); + UnsignedOrNone NumExpansions = OrigNumExpansions; + if (TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), + Pattern.getSourceRange(), Unexpanded, + ShouldExpand, RetainExpansion, NumExpansions)) + return true; + + assert(ShouldExpand && !RetainExpansion && + "Shouldn't preserve pack expansion when evaluating constraints"); + ExpandingFunctionParameterPack(OldParm); + for (unsigned I = 0; I != *NumExpansions; ++I) { + Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I); + if (!TransformFunctionTypeParam(OldParm, /*indexAdjustment=*/0, + /*NumExpansions=*/OrigNumExpansions, + /*ExpectParameterPack=*/false)) + return true; + } + return false; +} + Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) { Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs); if (!Inst) @@ -4502,9 +4582,8 @@ static const Decl *getCanonicalParmVarDecl(const Decl *D) { return D; } - llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> * -LocalInstantiationScope::findInstantiationOf(const Decl *D) { +LocalInstantiationScope::getInstantiationOfIfExists(const Decl *D) { D = getCanonicalParmVarDecl(D); for (LocalInstantiationScope *Current = this; Current; Current = Current->Outer) { @@ -4529,6 +4608,14 @@ LocalInstantiationScope::findInstantiationOf(const Decl *D) { break; } + return nullptr; +} + +llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> * +LocalInstantiationScope::findInstantiationOf(const Decl *D) { + auto *Result = getInstantiationOfIfExists(D); + if (Result) + return Result; // If we're performing a partial substitution during template argument // deduction, we may not have values for template parameters yet. if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) || diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index 4ef2b653ee876..bcad815e1587f 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -12,7 +12,6 @@ #include "TreeTransform.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" -#include "clang/AST/ASTLambda.h" #include "clang/AST/ASTMutationListener.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/DependentDiagnostic.h" @@ -5846,8 +5845,24 @@ void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, savedContext.pop(); } - DeclGroupRef DG(Function); - Consumer.HandleTopLevelDecl(DG); + // We never need to emit the code for a lambda in unevaluated context. + // We also can't mangle a lambda in the require clause of a function template + // during constraint checking as the MSI ABI would need to mangle the (not yet + // specialized) enclosing declaration + // FIXME: Should we try to skip this for non-lambda functions too? + bool ShouldSkipCG = [&] { + auto *RD = dyn_cast<CXXRecordDecl>(Function->getParent()); + if (!RD || !RD->isLambda()) + return false; + + return llvm::any_of(ExprEvalContexts, [](auto &Context) { + return Context.isUnevaluated() || Context.isImmediateFunctionContext(); + }); + }(); + if (!ShouldSkipCG) { + DeclGroupRef DG(Function); + Consumer.HandleTopLevelDecl(DG); + } // This class may have local implicit instantiations that need to be // instantiation within this scope. diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index bd839087c66ed..c8d29f0a625f8 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -715,7 +715,7 @@ class TreeTransform { /// variables vector are acceptable. /// /// LastParamTransformed, if non-null, will be set to the index of the last - /// parameter on which transfromation was started. In the event of an error, + /// parameter on which transformation was started. In the event of an error, /// this will contain the parameter which failed to instantiate. /// /// Return true on error. diff --git a/clang/test/CXX/drs/cwg23xx.cpp b/clang/test/CXX/drs/cwg23xx.cpp index 74e72f2371e2a..128566537b577 100644 --- a/clang/test/CXX/drs/cwg23xx.cpp +++ b/clang/test/CXX/drs/cwg23xx.cpp @@ -365,6 +365,35 @@ struct A { #endif } // namespace cwg2363 +namespace cwg2369 { // cwg2369: partial +#if __cplusplus >= 202002L +template <class T> struct Z { + typedef typename T::x xx; +}; + +template <class T> +concept C = requires { typename T::A; }; +template <C T> typename Z<T>::xx f(void *, T); // #1 +template <class T> void f(int, T); // #2 + +struct A { +} a; + +struct ZZ { + template <class T, class = typename Z<T>::xx> operator T *(); + operator int(); +}; + +void foo() { + ZZ zz; + f(1, a); // OK, deduction fails for #1 because there is no conversion from int + // to void* + f(zz, 42); // OK, deduction fails for #1 because C<int> is not satisfied +} + +#endif +} // namespace cwg2369 + namespace cwg2370 { // cwg2370: no namespace N { typedef int type; diff --git a/clang/test/CXX/drs/cwg26xx.cpp b/clang/test/CXX/drs/cwg26xx.cpp index 3eb70583b6026..ab4d3695b6e22 100644 --- a/clang/test/CXX/drs/cwg26xx.cpp +++ b/clang/test/CXX/drs/cwg26xx.cpp @@ -310,7 +310,7 @@ void f(T) requires requires { []() { T::invalid; } (); }; // since-cxx20-note@-3 {{in instantiation of requirement here}} // since-cxx20-note@-4 {{while substituting template arguments into constraint expression here}} // since-cxx20-note@#cwg2672-f-0 {{while checking constraint satisfaction for template 'f<int>' required here}} -// since-cxx20-note@#cwg2672-f-0 {{in instantiation of function template specialization 'cwg2672::f<int>' requested here}} +// since-cxx20-note@#cwg2672-f-0 {{while substituting deduced template arguments into function template 'f' [with T = int]}} void f(...); template <class T> diff --git a/clang/test/CXX/drs/cwg27xx.cpp b/clang/test/CXX/drs/cwg27xx.cpp index a87d26dfc9acf..7caf36a9f23b2 100644 --- a/clang/test/CXX/drs/cwg27xx.cpp +++ b/clang/test/CXX/drs/cwg27xx.cpp @@ -174,6 +174,26 @@ static_assert(!__is_layout_compatible(StructWithAnonUnion, StructWithAnonUnion3) #endif } // namespace cwg2759 +namespace cwg2770 { // cwg2770: 20 open 2023-07-14 +#if __cplusplus >= 202002L +template<typename T> +struct B { + static_assert(sizeof(T) == 1); + using type = int; +}; + +template<typename T> +int f(T t, typename B<T>::type u) requires (sizeof(t) == 1); + +template<typename T> +int f(T t, long); + +int i = f(1, 2); +int j = f('a', 2); + +#endif +} // namespace cwg2770 + namespace cwg2789 { // cwg2789: 18 #if __cplusplus >= 202302L template <typename T = int> diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp index 651cca927d513..19145f68b2f75 100644 --- a/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp +++ b/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp @@ -154,7 +154,7 @@ void func() { bar<int>(); // expected-note@-1 {{while checking constraint satisfaction for template 'bar<int>' required here}} \ - // expected-note@-1 {{in instantiation of function template specialization}} + // expected-note@-1 {{while substituting deduced template arguments into function template 'bar' [with T = int]}} // expected-note@#bar {{in instantiation of static data member}} // expected-note@#bar {{in instantiation of requirement here}} // expected-note@#bar {{while checking the satisfaction of nested requirement requested here}} diff --git a/clang/test/CXX/temp/temp.constr/temp.constr.atomic/constrant-satisfaction-conversions.cpp b/clang/test/CXX/temp/temp.constr/temp.constr.atomic/constrant-satisfaction-conversions.cpp index 083e743818121..59e6a48e48878 100644 --- a/clang/test/CXX/temp/temp.constr/temp.constr.atomic/constrant-satisfaction-conversions.cpp +++ b/clang/test/CXX/temp/temp.constr/temp.constr.atomic/constrant-satisfaction-conversions.cpp @@ -11,7 +11,7 @@ template<typename T> struct S { // expected-error@+3{{atomic constraint must be of type 'bool' (found 'S<int>')}} // expected-note@#FINST{{while checking constraint satisfaction}} -// expected-note@#FINST{{in instantiation of function template specialization}} +// expected-note@#FINST{{while substituting deduced template arguments into function template 'f' [with T = int]}} template<typename T> requires (S<T>{}) void f(T); void f(long); @@ -19,7 +19,7 @@ void f(long); // Ensure this applies to operator && as well. // expected-error@+3{{atomic constraint must be of type 'bool' (found 'S<int>')}} // expected-note@#F2INST{{while checking constraint satisfaction}} -// expected-note@#F2INST{{in instantiation of function template specialization}} +// expected-note@#F2INST{{while substituting deduced template arguments into function template 'f2' [with T = int]}} template<typename T> requires (S<T>{} && true) void f2(T); void f2(long); @@ -32,7 +32,7 @@ template<typename T> requires requires { // expected-note@-4{{while checking the satisfaction}} // expected-note@-6{{while substituting template arguments}} // expected-note@#F3INST{{while checking constraint satisfaction}} - // expected-note@#F3INST{{in instantiation of function template specialization}} + // expected-note@#F3INST{{while substituting deduced template arguments into function template 'f3' [with T = int]}} // } void f3(T); diff --git a/clang/test/CodeGenCXX/ms-mangle-requires.cpp b/clang/test/CodeGenCXX/ms-mangle-requires.cpp new file mode 100644 index 0000000000000..15318ecffaf01 --- /dev/null +++ b/clang/test/CodeGenCXX/ms-mangle-requires.cpp @@ -0,0 +1,59 @@ +// RUN: %clang_cc1 -std=c++20 -triple=x86_64-windows-msvc -Wno-defaulted-function-deleted -fms-compatibility -fms-extensions -emit-llvm %s -o - | FileCheck %s + +namespace CWG2369 { + +namespace Regression1 { + +template <class, class Up> +using compare_three_way_result_t = Up::type; + +struct sfinae_assign_base {}; + +template <class Tp> +concept is_derived_from_optional = + requires(Tp param) { []<class Up>(Up) {}(param); }; + +template <class Tp, class Up> + requires(is_derived_from_optional<Up> && []<class W>(W) { return true; }(Up())) +compare_three_way_result_t<Tp, Up> operator<=>(Tp, Up); + +struct RuntimeModeArgs { + auto operator<=>(const RuntimeModeArgs &) const = default; + sfinae_assign_base needs_admin; +}; + +RuntimeModeArgs foo() { + return {}; +} + +// CHECK: ?foo@Regression1@CWG2369@@YA?AURuntimeModeArgs@12@XZ + +} // namespace Regression1 + +namespace Regression2 { + +template <class _Tp> +constexpr _Tp * __to_address(_Tp *) { + return nullptr; +} + +template <class _Ip> +concept contiguous_iterator = requires(_Ip __i) { __to_address(__i); }; + +struct basic_string_view { + template <contiguous_iterator _It> + basic_string_view(_It, _It); +}; + +const char *str; +void sv() { basic_string_view(str, str); } + +void m_fn2() { + const char __trans_tmp_1 = *__to_address(&__trans_tmp_1); +} + +// CHECK: define {{.*}} @"??$__to_address@$$CBD@Regression2@CWG2369@@YAPEBDPEBD@Z" + +} // namespace Regression2 + +} diff --git a/clang/test/SemaCXX/concept-crash-on-diagnostic.cpp b/clang/test/SemaCXX/concept-crash-on-diagnostic.cpp index 1efed72522fef..b02930e145700 100644 --- a/clang/test/SemaCXX/concept-crash-on-diagnostic.cpp +++ b/clang/test/SemaCXX/concept-crash-on-diagnostic.cpp @@ -31,7 +31,7 @@ void function() { // expected-note@#3 {{checking the satisfaction of concept 'convertible_to<bool, bool>'}} // expected-note@#2 {{substituting template arguments into constraint expression here}} // expected-note@#5 {{checking constraint satisfaction for template 'compare<Object *, Object *>'}} -// expected-note@#5 {{in instantiation of function template specialization 'compare<Object *, Object *>' requested here}} +// expected-note@#5 {{while substituting deduced template arguments into function template 'compare' [with IteratorL = Object *, IteratorR = Object *]}} // expected-note@#4 {{candidate template ignored: constraints not satisfied [with IteratorL = Object *, IteratorR = Object *]}} // We don't know exactly the substituted type for `lhs == rhs`, thus a placeholder 'expr-type' is emitted. diff --git a/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp b/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp index c863cc841af42..aeb02c9e4898e 100644 --- a/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp +++ b/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp @@ -196,7 +196,7 @@ struct Foo { template <int K> using Bar = Foo<double, K>; // expected-note {{constraints not satisfied for class template 'Foo'}} -// expected-note@-1 {{candidate template ignored: could not match}} +// expected-note@-1 {{candidate template ignored: could not match}} expected-note@-1 {{candidate template ignored: constraints not satisfied}} // expected-note@-2 {{implicit deduction guide declared as 'template <int K> requires __is_deducible(test14::Bar, Foo<double, K>) Bar(Foo<double, K>) -> Foo<double, K>'}} // expected-note@-3 {{implicit deduction guide declared as 'template <int K> requires __is_deducible(test14::Bar, Foo<double, K>) Bar(const double (&)[K]) -> Foo<double, K>'}} double abc[3]; diff --git a/clang/test/SemaCXX/cxx23-assume.cpp b/clang/test/SemaCXX/cxx23-assume.cpp index 7f80cdfe7d452..726cb3bff652e 100644 --- a/clang/test/SemaCXX/cxx23-assume.cpp +++ b/clang/test/SemaCXX/cxx23-assume.cpp @@ -129,12 +129,12 @@ constexpr int f5() requires (!C<T>) { return 2; } // expected-note 4 {{while che static_assert(f5<int>() == 1); static_assert(f5<D>() == 1); // expected-note 3 {{while checking constraint satisfaction}} - // expected-note@-1 3 {{in instantiation of}} + // expected-note@-1 3 {{while substituting deduced template arguments}} // expected-error@-2 {{no matching function for call}} static_assert(f5<double>() == 2); -static_assert(f5<E>() == 1); // expected-note {{while checking constraint satisfaction}} expected-note {{in instantiation of}} -static_assert(f5<F>() == 2); // expected-note {{while checking constraint satisfaction}} expected-note {{in instantiation of}} +static_assert(f5<E>() == 1); // expected-note {{while checking constraint satisfaction}} expected-note {{while substituting deduced template arguments}} +static_assert(f5<F>() == 2); // expected-note {{while checking constraint satisfaction}} expected-note {{while substituting deduced template arguments}} // Do not validate assumptions whose evaluation would have side-effects. constexpr int foo() { diff --git a/clang/test/SemaCXX/cxx2c-fold-exprs.cpp b/clang/test/SemaCXX/cxx2c-fold-exprs.cpp index 48061439941f2..4220486d3aed3 100644 --- a/clang/test/SemaCXX/cxx2c-fold-exprs.cpp +++ b/clang/test/SemaCXX/cxx2c-fold-exprs.cpp @@ -233,7 +233,7 @@ void g() { A<Thingy, Thingy> *ap; f(ap, ap); // expected-error{{no matching function for call to 'f'}} \ // expected-note {{while checking constraint satisfaction}} \ - // expected-note {{in instantiation of function template specialization}} + // expected-note {{while substituting deduced template arguments}} } } diff --git a/clang/test/SemaCXX/lambda-unevaluated.cpp b/clang/test/SemaCXX/lambda-unevaluated.cpp index 40f8a729fd912..9289fc9ec1243 100644 --- a/clang/test/SemaCXX/lambda-unevaluated.cpp +++ b/clang/test/SemaCXX/lambda-unevaluated.cpp @@ -174,7 +174,7 @@ int* func(T) requires requires { []() { T::foo(); }; }; // expected-error{{type double* func(...); static_assert(__is_same(decltype(func(0)), double*)); // expected-note {{while checking constraint satisfaction for template 'func<int>' required here}} - // expected-note@-1 {{in instantiation of function template specialization 'lambda_in_constraints::func<int>'}} + // expected-note@-1 {{while substituting deduced template arguments into function template 'func' [with T = int]}} static_assert(__is_same(decltype(func(WithFoo())), int*)); template <class T> @@ -252,7 +252,7 @@ S s("a"); // #use // expected-note@#S-requires {{substituting template arguments into constraint expression here}} // expected-note@#S-requires {{in instantiation of requirement here}} // expected-note@#use {{checking constraint satisfaction for template 'S<const char *>' required here}} -// expected-note@#use {{requested here}} +// expected-note@#use {{while substituting deduced template arguments into function template 'S' [with value:auto = const char *]}} // expected-note-re@#S 2{{candidate constructor {{.*}} not viable}} // expected-note@#S-ctor {{constraints not satisfied}} // expected-note-re@#S-requires {{because {{.*}} would be invalid}} diff --git a/clang/test/SemaCXX/overload-resolution-deferred-templates.cpp b/clang/test/SemaCXX/overload-resolution-deferred-templates.cpp index 4c5ac5dcbbd04..7cb71e075d50e 100644 --- a/clang/test/SemaCXX/overload-resolution-deferred-templates.cpp +++ b/clang/test/SemaCXX/overload-resolution-deferred-templates.cpp @@ -187,7 +187,7 @@ void f(int); void g(int n) { f(n); } // OK void h(short n) { f(n); } // expected-error@#GH62096-err {{static assertion failed due to requirement 'sizeof(short) == 0'}} \ -// expected-note@-1{{in instantiation of function template specialization}} \ +// expected-note@-1{{while substituting deduced template arguments}} \ // expected-note@-1{{while checking constraint satisfaction for template}} // expected-note@#GH62096-note1{{in instantiation}} // expected-note@#GH62096-note1{{while substituting template arguments into constraint expression here}} diff --git a/clang/test/SemaTemplate/concepts-recursive-inst.cpp b/clang/test/SemaTemplate/concepts-recursive-inst.cpp index 9330df8cdd039..097cad1a64179 100644 --- a/clang/test/SemaTemplate/concepts-recursive-inst.cpp +++ b/clang/test/SemaTemplate/concepts-recursive-inst.cpp @@ -76,7 +76,7 @@ auto it = begin(rng); // #BEGIN_CALL // expected-note@#INF_BEGIN {{while checking the satisfaction of concept 'Inf<DirectRecursiveCheck::my_range>' requested here}} // expected-note@#INF_BEGIN {{while substituting template arguments into constraint expression here}} // expected-note@#BEGIN_CALL {{while checking constraint satisfaction for template 'begin<DirectRecursiveCheck::my_range>' required here}} -// expected-note@#BEGIN_CALL {{in instantiation of function template specialization}} +// expected-note@#BEGIN_CALL {{while substituting deduced template arguments into function template}} // Fallout of the failure is failed lookup, which is necessary to stop odd // cascading errors. @@ -103,7 +103,7 @@ namespace GH50891 { // expected-note@#OP_TO {{while checking the satisfaction of concept 'Numeric<GH50891::Deferred>' requested here}} // expected-note@#OP_TO {{while substituting template arguments into constraint expression here}} // expected-note@#FOO_CALL {{while checking constraint satisfaction for template}} - // expected-note@#FOO_CALL {{in instantiation of function template specialization}} + // expected-note@#FOO_CALL {{while substituting deduced template arguments into function template}} // expected-note@#FOO_CALL {{in instantiation of requirement here}} // expected-note@#NUMERIC {{while substituting template arguments into constraint expression here}} @@ -143,3 +143,222 @@ namespace GH60323 { Size().sizeparens(i); } } + +namespace CWG2369_Regressions { + +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109397 +namespace GCC_103997 { + +template<typename _type, typename _stream> +concept streamable = requires(_stream &s, _type &&v) { + s << static_cast<_type &&>(v); +}; + +struct type_a { + template<typename _arg> + type_a &operator<<(_arg &&) { + // std::clog << "type_a" << std::endl; + return *this; + } +}; + +struct type_b { + type_b &operator<<(type_a const &) { + // std::clog << "type_b" << std::endl; + return *this; + } +}; + +struct type_c { + type_b b; + template<typename _arg> + requires streamable<_arg, type_b> + friend type_c &operator<<(type_c &c, _arg &&a) { + // std::clog << "type_c" << std::endl; + c.b << static_cast<_arg &&>(a); + return c; + } +}; + +void foo() { + type_a a; + type_c c; + a << c; // "type_a\n" (gcc gives error here) + c << a; // "type_c\ntype_b\n" +} + +} + +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108393 +namespace GCC_108393 { + +template<class> +struct iterator_traits +{}; + +template<class T> + requires requires(T __t, T __u) { __t == __u; } +struct iterator_traits<T> +{}; + +template<class T> +concept C = requires { typename iterator_traits<T>::A; }; + +struct unreachable_sentinel_t +{ + template<C _Iter> + friend constexpr bool operator==(unreachable_sentinel_t, const _Iter&) noexcept; +}; + +template<class T> +struct S +{}; + +static_assert(!C<S<unreachable_sentinel_t>>); + +} + +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107429 +namespace GCC_107429 { + +struct tag_foo { } inline constexpr foo; +struct tag_bar { } inline constexpr bar; + +template<typename... T> +auto f(tag_foo, T... x) +{ + return (x + ...); +} + +template<typename... T> +concept fooable = requires (T... x) { f(foo, x...); }; + +template<typename... T> requires (fooable<T...>) +auto f(tag_bar, T... x) +{ + return f(foo, x...); +} + +auto test() +{ + return f(bar, 1, 2, 3); +} + +} + +namespace GCC_99599 { + +struct foo_tag {}; +struct bar_tag {}; + +template <class T> +concept fooable = requires(T it) { + invoke_tag(foo_tag{}, it); // <-- here +}; + +template <class T> auto invoke_tag(foo_tag, T in) { return in; } + +template <fooable T> auto invoke_tag(bar_tag, T it) { return it; } + +int main() { + // Neither line below compiles in GCC 11, independently of the other + return invoke_tag(foo_tag{}, 2) + invoke_tag(bar_tag{}, 2); +} + +} + +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99599#c22 +namespace GCC_99599_2 { + +template<typename T> class indirect { +public: + template<typename U> requires + requires (const T& t, const U& u) { t == u; } + friend constexpr bool operator==(const indirect&, const U&) { return false; } + +private: + T* _M_ptr{}; +}; + +indirect<int> i; +bool b = i == 1; + +} + +namespace GCC_99599_3 { + +template<typename T> +struct S { T t; }; + +template<typename T> +concept C = sizeof(S<T>) > 0; + +struct I; + +struct from_range_t { + explicit from_range_t() = default; +}; +inline constexpr from_range_t from_range; + +template<typename T> +concept FromRange = __is_same_as (T, from_range_t); + +//#define WORKAROUND +#ifdef WORKAROUND +template<FromRange U, C T> +void f(U, T*); +#else +template<C T> +void f(from_range_t, T*); +#endif + +void f(...); + +void g(I* p) { + f(0, p); +} + +} + +namespace GCC_99599_4 { + +struct A { + A(...); +}; + +template <class T> void f(A, T) { } + +int main() +{ + f(42, 24); +} + +} + +namespace FAILED_GCC_110160 { +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=110160 +// Current heuristic FAILED; GCC trunk also failed +// https://godbolt.org/z/r3Pz9Tehz +#if 0 +#include <sstream> +#include <string> + +template <class T> +concept StreamCanReceiveString = requires(T& t, std::string s) { + { t << s }; +}; + +struct NotAStream {}; +struct UnrelatedType {}; + +template <StreamCanReceiveString S> +S& operator<<(S& s, UnrelatedType) { + return s; +} + +static_assert(!StreamCanReceiveString<NotAStream>); + +static_assert(StreamCanReceiveString<std::stringstream>); +#endif +} +} diff --git a/clang/test/SemaTemplate/concepts.cpp b/clang/test/SemaTemplate/concepts.cpp index f335ca3bd22bc..3e50a8bce24af 100644 --- a/clang/test/SemaTemplate/concepts.cpp +++ b/clang/test/SemaTemplate/concepts.cpp @@ -1177,3 +1177,26 @@ template <has_member_ diff erence_type Tp> struct incrementable_traits<Tp>; // expected-error {{not more specialized than the primary}} } + +namespace InjectedClassNameType { + +template <class, class _Err> class expected { +public: + template <class...> + expected(...); + + template <class _T2, class _E2> + friend bool operator==(expected x, expected<_T2, _E2>) + requires requires { + { x }; + } + { + return true; + } +}; + +bool test_val_types() { + return expected<void, int>() == 1; +} + +} diff --git a/clang/test/SemaTemplate/cxx2a-constraint-exprs.cpp b/clang/test/SemaTemplate/cxx2a-constraint-exprs.cpp index f4403587a6259..5809ef684bbf3 100644 --- a/clang/test/SemaTemplate/cxx2a-constraint-exprs.cpp +++ b/clang/test/SemaTemplate/cxx2a-constraint-exprs.cpp @@ -34,7 +34,7 @@ namespace constant_evaluated { expected-note@-1{{candidate template ignored}} int a = (foo<int>(), 0); // expected-note@-1 {{while checking}} expected-error@-1{{no matching function}} \ - expected-note@-1 {{in instantiation}} + expected-note@-1 {{while substituting}} template<typename T> void bar() requires requires { requires f<int[2]>; } { }; // expected-note@-1{{in instantiation}} \ expected-note@-1{{while substituting}} \ diff --git a/clang/test/SemaTemplate/deduction-guide.cpp b/clang/test/SemaTemplate/deduction-guide.cpp index faabba5539503..0953f647426fa 100644 --- a/clang/test/SemaTemplate/deduction-guide.cpp +++ b/clang/test/SemaTemplate/deduction-guide.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -std=c++2a -verify -ast-dump -ast-dump-decl-types -ast-dump-filter "deduction guide" %s | FileCheck %s --strict-whitespace -dump-input=always +// RUN: %clang_cc1 -std=c++2a -verify -ast-dump -ast-dump-decl-types -ast-dump-filter "deduction guide" %s | FileCheck %s --strict-whitespace template<auto ...> struct X {}; template<template<typename X, X> typename> struct Y {}; @@ -234,7 +234,7 @@ F s(0); // CHECK: | `-CXXBoolLiteralExpr {{.*}} 'bool' false // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for F> 'auto (U) -> F<value-parameter-0-0>' // CHECK: | `-ParmVarDecl {{.*}} 'U' -// CHECK: `-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for F> 'auto (int) -> F<>' +// CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for F> 'auto (int) -> F<>' // CHECK: |-TemplateArgument integral ''x'' // CHECK: |-TemplateArgument type 'int' // CHECK: | `-BuiltinType {{.*}} 'int' diff --git a/clang/test/SemaTemplate/nested-implicit-deduction-guides.cpp b/clang/test/SemaTemplate/nested-implicit-deduction-guides.cpp index af3e3358f6138..5c7a90273d0e0 100644 --- a/clang/test/SemaTemplate/nested-implicit-deduction-guides.cpp +++ b/clang/test/SemaTemplate/nested-implicit-deduction-guides.cpp @@ -38,7 +38,7 @@ template<typename A, typename T> concept True = true; template<typename T> -concept False = false; +concept False = false; // #False template<class X> struct concepts { template<class Y> struct B { @@ -68,7 +68,7 @@ template<typename X> struct nested_init_list { Y y; }; - template<False F> + template<False F> // #INIT_LIST_INNER_INVALID_HEADER struct concept_fail { // #INIT_LIST_INNER_INVALID X x; F f; @@ -81,7 +81,9 @@ using NIL = nested_init_list<int>::B<int>; // expected-error@+1 {{no viable constructor or deduction guide for deduction of template arguments of 'nested_init_list<int>::concept_fail'}} nested_init_list<int>::concept_fail nil_invalid{1, ""}; -// expected-note@#INIT_LIST_INNER_INVALID {{candidate template ignored: substitution failure [with F = const char *]: constraints not satisfied for class template 'concept_fail' [with F = const char *]}} +// expected-note@#INIT_LIST_INNER_INVALID {{candidate template ignored: constraints not satisfied [with F = const char *]}} +// expected-note@#INIT_LIST_INNER_INVALID_HEADER {{because 'const char *' does not satisfy 'False'}} +// expected-note@#False {{because 'false' evaluated to false}} // expected-note@#INIT_LIST_INNER_INVALID {{implicit deduction guide declared as 'template <False F> concept_fail(int, F) -> concept_fail<F>'}} // expected-note@#INIT_LIST_INNER_INVALID {{candidate function template not viable: requires 1 argument, but 2 were provided}} // expected-note@#INIT_LIST_INNER_INVALID {{implicit deduction guide declared as 'template <False F> concept_fail(concept_fail<F>) -> concept_fail<F>'}} diff --git a/clang/www/cxx_dr_status.html b/clang/www/cxx_dr_status.html index 52c9cb7d37c23..58286db165077 100755 --- a/clang/www/cxx_dr_status.html +++ b/clang/www/cxx_dr_status.html @@ -14049,7 +14049,7 @@ <h2 id="cxxdr">C++ defect report implementation status</h2> <td><a href="https://cplusplus.github.io/CWG/issues/2369.html";>2369</a></td> <td>CD6</td> <td>Ordering between constraints and substitution</td> - <td class="unknown" align="center">Unknown</td> + <td class="partial" align="center">Partial</td> </tr> <tr id="2370"> <td><a href="https://cplusplus.github.io/CWG/issues/2370.html";>2370</a></td> @@ -16468,7 +16468,11 @@ <h2 id="cxxdr">C++ defect report implementation status</h2> <td><a href="https://cplusplus.github.io/CWG/issues/2770.html";>2770</a></td> <td>open</td> <td>Trailing <I>requires-clause</I> can refer to function parameters before they are substituted into</td> - <td align="center">Not resolved</td> + <td align="center"> + <details> + <summary>Not resolved</summary> + Clang 20 implements 2023-07-14 resolution + </details></td> </tr> <tr id="2771"> <td><a href="https://cplusplus.github.io/CWG/issues/2771.html";>2771</a></td> _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
