Index: include/clang/AST/DeclTemplate.h =================================================================== --- include/clang/AST/DeclTemplate.h +++ include/clang/AST/DeclTemplate.h @@ -736,9 +736,10 @@ void loadLazySpecializationsImpl() const; - template typename SpecEntryTraits::DeclType* + template + typename SpecEntryTraits::DeclType* findSpecializationImpl(llvm::FoldingSetVector &Specs, - ArrayRef Args, void *&InsertPos); + void *&InsertPos, ProfileArguments... ProfileArgs); template void addSpecializationImpl(llvm::FoldingSetVector &Specs, @@ -1985,7 +1986,22 @@ ->getInjectedSpecializationType(); } - // FIXME: Add Profile support! + void Profile(llvm::FoldingSetNodeID &ID) const { + llvm::SmallVector AC; + getAssociatedConstraints(AC); + Profile(ID, getTemplateArgs().asArray(), AC, getASTContext()); + } + + static void + Profile(llvm::FoldingSetNodeID &ID, ArrayRef TemplateArgs, + ArrayRef AssociatedConstraints, ASTContext &Context) { + ID.AddInteger(TemplateArgs.size()); + for (const TemplateArgument &TemplateArg : TemplateArgs) + TemplateArg.Profile(ID, Context); + ID.AddInteger(AssociatedConstraints.size()); + for (const Expr *Constraint : AssociatedConstraints) + Constraint->Profile(ID, Context, /*Canonical=*/true); + } static bool classof(const Decl *D) { return classofKind(D->getKind()); } @@ -2109,7 +2125,9 @@ /// Return the partial specialization with the provided arguments if it /// exists, otherwise return the insertion point. ClassTemplatePartialSpecializationDecl * - findPartialSpecialization(ArrayRef Args, void *&InsertPos); + findPartialSpecialization(ArrayRef Args, + ArrayRef AssociatedConstraints, + void *&InsertPos); /// Insert the specified partial specialization knowing that it is not /// already in. InsertPos must be obtained from findPartialSpecialization. @@ -2806,6 +2824,23 @@ return First->InstantiatedFromMember.setInt(true); } + void Profile(llvm::FoldingSetNodeID &ID) const { + llvm::SmallVector AC; + getAssociatedConstraints(AC); + Profile(ID, getTemplateArgs().asArray(), AC, getASTContext()); + } + + static void + Profile(llvm::FoldingSetNodeID &ID, ArrayRef TemplateArgs, + ArrayRef AssociatedConstraints, ASTContext &Context) { + ID.AddInteger(TemplateArgs.size()); + for (const TemplateArgument &TemplateArg : TemplateArgs) + TemplateArg.Profile(ID, Context); + ID.AddInteger(AssociatedConstraints.size()); + for (const Expr *Constraint : AssociatedConstraints) + Constraint->Profile(ID, Context, /*Canonical=*/true); + } + static bool classof(const Decl *D) { return classofKind(D->getKind()); } static bool classofKind(Kind K) { @@ -2924,7 +2959,9 @@ /// Return the partial specialization with the provided arguments if it /// exists, otherwise return the insertion point. VarTemplatePartialSpecializationDecl * - findPartialSpecialization(ArrayRef Args, void *&InsertPos); + findPartialSpecialization(ArrayRef Args, + ArrayRef AssociatedConstraints, + void *&InsertPos); /// Insert the specified partial specialization knowing that it is not /// already in. InsertPos must be obtained from findPartialSpecialization. Index: include/clang/Basic/DiagnosticSemaKinds.td =================================================================== --- include/clang/Basic/DiagnosticSemaKinds.td +++ include/clang/Basic/DiagnosticSemaKinds.td @@ -2465,11 +2465,9 @@ "%select{and |because }0%1 does not satisfy %2">; def note_atomic_constraint_evaluated_to_false_elaborated : Note< "%select{and |because }0'%1' (%2 %3 %4) evaluated to false">; -def err_could_not_normalize_ill_formed_constraint : Error< - "required expansion of concept specialization %0 failed, substituted " - "expression would be illegal">; -def note_could_not_normalize_ill_formed_constraint_reason : Note< - "because: %0">; +def note_could_not_normalize_argument_substitution_failed : Note< + "when substituting into %0 %1. Make sure concept arguments are " + "valid for any substitution">; def err_template_different_requires_clause : Error< "requires clause differs in template redeclaration">; Index: include/clang/Sema/Sema.h =================================================================== --- include/clang/Sema/Sema.h +++ include/clang/Sema/Sema.h @@ -5765,6 +5765,19 @@ /// A diagnostic is emitted if it is not, and false is returned. bool CheckConstraintExpression(Expr *CE); +private: + /// \brief Caches pairs of template-like decls whose associated constraints + /// were checked for subsumption and whether or not the first's constraints + /// did in fact subsume the second's. + llvm::DenseMap, bool> SubsumptionCache; + +public: + /// \brief Returns whether the given declaration's associated constraints are + /// more constrained than another declaration's according to the partial + /// ordering of constraints. + bool IsMoreConstrained(NamedDecl *D1, ArrayRef AC1, + NamedDecl *D2, ArrayRef AC2); + /// \brief Check whether the given list of constraint expressions are /// satisfied (as if in a 'conjunction') given template arguments. /// \param ConstraintExprs a list of constraint expressions, treated as if @@ -5838,6 +5851,9 @@ void DiagnoseUnsatisfiedIllFormedConstraint(SourceLocation DiagnosticLocation, StringRef Diagnostic); + void DiagnoseRedeclarationConstraintMismatch(const TemplateParameterList *Old, + const TemplateParameterList *New); + // ParseObjCStringLiteral - Parse Objective-C string literals. ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs, ArrayRef Strings); Index: lib/AST/ASTImporter.cpp =================================================================== --- lib/AST/ASTImporter.cpp +++ lib/AST/ASTImporter.cpp @@ -5014,15 +5014,26 @@ D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs)) return std::move(Err); - // Try to find an existing specialization with these template arguments. + // Try to find an existing specialization with these template arguments and + // constraints. void *InsertPos = nullptr; ClassTemplateSpecializationDecl *PrevDecl = nullptr; ClassTemplatePartialSpecializationDecl *PartialSpec = dyn_cast(D); - if (PartialSpec) + llvm::SmallVector PartialSpecAC; + if (PartialSpec) { + PartialSpec->getAssociatedConstraints(PartialSpecAC); + // Import associated constraints into the "To" context. + for (const Expr *&Constraint : PartialSpecAC) { + ExpectedExpr ConstraintOrErr = import(Constraint); + if (!ConstraintOrErr) + return ConstraintOrErr.takeError(); + Constraint = *ConstraintOrErr; + } PrevDecl = - ClassTemplate->findPartialSpecialization(TemplateArgs, InsertPos); - else + ClassTemplate->findPartialSpecialization(TemplateArgs, PartialSpecAC, + InsertPos); + } else PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, InsertPos); if (PrevDecl) { @@ -5089,10 +5100,11 @@ // Update InsertPos, because preceding import calls may have invalidated // it by adding new specializations. - if (!ClassTemplate->findPartialSpecialization(TemplateArgs, InsertPos)) + auto *PartSpec = cast(D2); + if (!ClassTemplate->findPartialSpecialization(TemplateArgs, PartialSpecAC, + InsertPos)) // Add this partial specialization to the class template. - ClassTemplate->AddPartialSpecialization( - cast(D2), InsertPos); + ClassTemplate->AddPartialSpecialization(PartSpec, InsertPos); } else { // Not a partial specialization. if (GetImportedOrCreateDecl( Index: lib/AST/DeclTemplate.cpp =================================================================== --- lib/AST/DeclTemplate.cpp +++ lib/AST/DeclTemplate.cpp @@ -231,15 +231,15 @@ } } -template +template typename RedeclarableTemplateDecl::SpecEntryTraits::DeclType * RedeclarableTemplateDecl::findSpecializationImpl( - llvm::FoldingSetVector &Specs, ArrayRef Args, - void *&InsertPos) { + llvm::FoldingSetVector &Specs, void *&InsertPos, + ProfileArguments... ProfileArgs) { using SETraits = SpecEntryTraits; llvm::FoldingSetNodeID ID; - EntryType::Profile(ID, Args, getASTContext()); + EntryType::Profile(ID, ProfileArgs..., getASTContext()); EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos); return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr; } @@ -254,8 +254,8 @@ #ifndef NDEBUG void *CorrectInsertPos; assert(!findSpecializationImpl(Specializations, - SETraits::getTemplateArgs(Entry), - CorrectInsertPos) && + CorrectInsertPos, + SETraits::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos && "given incorrect InsertPos for specialization"); #endif @@ -312,7 +312,7 @@ FunctionDecl * FunctionTemplateDecl::findSpecialization(ArrayRef Args, void *&InsertPos) { - return findSpecializationImpl(getSpecializations(), Args, InsertPos); + return findSpecializationImpl(getSpecializations(), InsertPos, Args); } void FunctionTemplateDecl::addSpecialization( @@ -418,7 +418,7 @@ ClassTemplateSpecializationDecl * ClassTemplateDecl::findSpecialization(ArrayRef Args, void *&InsertPos) { - return findSpecializationImpl(getSpecializations(), Args, InsertPos); + return findSpecializationImpl(getSpecializations(), InsertPos, Args); } void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D, @@ -428,8 +428,9 @@ ClassTemplatePartialSpecializationDecl * ClassTemplateDecl::findPartialSpecialization(ArrayRef Args, - void *&InsertPos) { - return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos); + ArrayRef AssociatedConstraints, void *&InsertPos) { + return findSpecializationImpl(getPartialSpecializations(), InsertPos, + Args, AssociatedConstraints); } void ClassTemplateDecl::AddPartialSpecialization( @@ -1033,7 +1034,7 @@ VarTemplateSpecializationDecl * VarTemplateDecl::findSpecialization(ArrayRef Args, void *&InsertPos) { - return findSpecializationImpl(getSpecializations(), Args, InsertPos); + return findSpecializationImpl(getSpecializations(), InsertPos, Args); } void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D, @@ -1043,8 +1044,9 @@ VarTemplatePartialSpecializationDecl * VarTemplateDecl::findPartialSpecialization(ArrayRef Args, - void *&InsertPos) { - return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos); + ArrayRef AssociatedConstraints, void *&InsertPos) { + return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args, + AssociatedConstraints); } void VarTemplateDecl::AddPartialSpecialization( Index: lib/Sema/SemaConcept.cpp =================================================================== --- lib/Sema/SemaConcept.cpp +++ lib/Sema/SemaConcept.cpp @@ -392,4 +392,450 @@ diagnoseUnsatisfiedConstraintExpr(*this, Pair.first, Pair.second, First); First = false; } +} +namespace { +struct AtomicConstraint { + AtomicConstraint(const Expr *ConstraintExpr, + const ASTTemplateArgumentListInfo *ParameterMapping = nullptr) : + ConstraintExpr{ConstraintExpr}, ParameterMapping{ParameterMapping} {} + + bool subsumes(ASTContext &C, const AtomicConstraint &Other) const { + // C++ [temp.constr.order] p2 + // - an atomic constraint A subsumes another atomic constraint B + // if and only if the A and B are identical [...] + // + // C++ [temp.constr.atomic] p2 + // Two atomic constraints are identical if they are formed from the + // same expression and the targets of the parameter mappings are + // equivalent according to the rules for expressions [...] + + // We do not actually substitute the parameter mappings, therefore the + // constraint expressions are the originals, and comparing them will + // suffice. + if (ConstraintExpr != Other.ConstraintExpr) + return false; + + // Check that the parameter lists are identical + if ((!ParameterMapping) != (!Other.ParameterMapping)) + return false; + if (!ParameterMapping) + return true; + if (ParameterMapping->NumTemplateArgs != + Other.ParameterMapping->NumTemplateArgs) + return false; + + for (unsigned I = 0, S = ParameterMapping->NumTemplateArgs; I < S; ++I) + if (!C.getCanonicalTemplateArgument( + ParameterMapping->arguments()[I].getArgument()) + .structurallyEquals(C.getCanonicalTemplateArgument( + Other.ParameterMapping->arguments()[I].getArgument()))) + return false; + + + return true; + } + + const Expr *ConstraintExpr; + const ASTTemplateArgumentListInfo *ParameterMapping; +}; + +/// \brief A normalized constraint, as defined in C++ [temp.constr.normal], is +/// either an atomic constraint, a conjunction of normalized constraints or a +/// disjunction of normalized constraints. +struct NormalizedConstraint { + enum CompoundConstraintKind { CCK_Conjunction, CCK_Disjunction }; + + using CompoundConstraint = llvm::PointerIntPair< + std::pair *, 1, + CompoundConstraintKind>; + + llvm::PointerUnion Constraint; + + NormalizedConstraint(AtomicConstraint *C) : Constraint{C} {}; + NormalizedConstraint(ASTContext &C, NormalizedConstraint LHS, + NormalizedConstraint RHS, CompoundConstraintKind Kind) + : Constraint{CompoundConstraint{ + new (C) std::pair{LHS, + RHS}, + Kind}} {}; + + CompoundConstraintKind getCompoundKind() const { + assert(!isAtomic() && "getCompoundKind called on atomic constraint."); + return Constraint.get().getInt(); + } + + bool isAtomic() const { return Constraint.is(); } + + NormalizedConstraint &getLHS() const { + assert(!isAtomic() && "getLHS called on atomic constraint."); + return Constraint.get().getPointer()->first; + } + + NormalizedConstraint &getRHS() const { + assert(!isAtomic() && "getRHS called on atomic constraint."); + return Constraint.get().getPointer()->second; + } + + AtomicConstraint *getAtomicConstraint() const { + assert(isAtomic() && + "getAtomicConstraint called on non-atomic constraint."); + return Constraint.get(); + } + static llvm::Optional fromConstraintExpr( + Sema &S, const Expr *E, TemplateDecl *TD = nullptr, + const ASTTemplateArgumentListInfo *ParameterMapping = nullptr) { + assert(E != nullptr); + + // C++ [temp.constr.normal]p1.1 + // [...] + // - The normal form of an expression (E) is the normal form of E. + // [...] + if (auto *P = dyn_cast(E)) + return fromConstraintExpr(S, P->getSubExpr(), TD, ParameterMapping); + if (auto *BO = dyn_cast(E)) { + if (BO->getOpcode() == BO_LAnd || BO->getOpcode() == BO_LOr) { + auto LHS = fromConstraintExpr(S, BO->getLHS(), TD, ParameterMapping); + if (!LHS) + return llvm::Optional{}; + auto RHS = fromConstraintExpr(S, BO->getRHS(), TD, ParameterMapping); + if (!RHS) + return llvm::Optional{}; + + return NormalizedConstraint( + S.Context, std::move(*LHS), std::move(*RHS), + BO->getOpcode() == BO_LAnd ? CCK_Conjunction : CCK_Disjunction); + } + } else if (auto *CSE = dyn_cast(E)) { + // C++ [temp.constr.normal]p1.1 + // [...] + // The normal form of an id-expression of the form C, + // where C names a concept, is the normal form of the + // constraint-expression of C, after substituting A1, A2, ..., AN for C’s + // respective template parameters in the parameter mappings in each atomic + // constraint. If any such substitution results in an invalid type or + // expression, the program is ill-formed; no diagnostic is required. + // [...] + const ASTTemplateArgumentListInfo *Mapping = + CSE->getTemplateArgsAsWritten(); + if (!ParameterMapping) { + // This is a top level CSE. + // + // template + // concept C = true; + // + // template + // void foo() requires C {} -> Mapping is + // + llvm::SmallVector TempList; + bool InstantiationDependent = false; + TemplateArgumentListInfo TALI(Mapping->LAngleLoc, Mapping->RAngleLoc); + for (auto &Arg : Mapping->arguments()) + TALI.addArgument(Arg); + bool Failed = S.CheckTemplateArgumentList(CSE->getNamedConcept(), + E->getBeginLoc(), TALI, /*PartialTemplateArgs=*/false, TempList, + /*UpdateArgsWithConversions=*/false, &InstantiationDependent); + // The potential failure case here is this: + // + // template + // concept C = true; + // + // template + // void foo() requires C // The immediate constraint expr + // // contains a CSE with incorrect no. + // // of arguments. + // {} + // This case should have been handled when C was parsed. + assert( + !Failed && + "Unmatched arguments in top level concept specialization " + "expression should've been caught while it was being constructed"); + + if (InstantiationDependent) + // The case is this: + // + // template + // concept C = true; + // + // template + // void foo() requires C // The immediate constraint expr + // // contains a CSE whose parameters + // // are not mappable to arguments + // // without concrete values. + // {} + // + // Just treat C as an atomic constraint. + return NormalizedConstraint{new (S.Context) + AtomicConstraint(E, Mapping)}; + + return fromConstraintExpr(S, + CSE->getNamedConcept()->getConstraintExpr(), + CSE->getNamedConcept(), Mapping); + } + + // This is not a top level CSE. + // + // template + // concept C1 = true; + // + // template + // concept C2 = C1; -> We are here. + // Mapping is {T1=U, T2=T} + // ParameterMapping is {T=X, U=Y}, TD is C2 + // + // template + // void foo() requires C2 {} + // + // We would like to substitute ParameterMapping into Mapping, to get + // ParameterMapping={T1=Y, T2=X} for the next level down. + // Instead of doing the direct substitution of ParameterMapping into + // Mapping, we instead substitute ParameterMapping into C1 and take + // the substituted argument list as the ParameterMapping for the next + // level down. + assert(TD && "ParameterMapping provided without TemplateDecl"); + + TemplateArgumentListInfo TALI(ParameterMapping->LAngleLoc, + ParameterMapping->RAngleLoc); + for (auto &Arg : ParameterMapping->arguments()) + TALI.addArgument(Arg); + llvm::SmallVector TempList; + bool InstantiationDependent = false; + bool Success = + !S.CheckTemplateArgumentList(TD, ParameterMapping->LAngleLoc, + TALI, /*PartialTemplateArgs=*/false, + TempList, + /*UpdateArgsWithConversions=*/false, + &InstantiationDependent) && + !InstantiationDependent; + assert(Success && "ParameterMapping should have already been cheked " + "against template argument list earlier."); + + auto DiagnoseSubstitutionError = [&](unsigned int Diag) { + std::string TemplateArgString = S.getTemplateArgumentBindingsText( + TD->getTemplateParameters(), TempList.data(), TempList.size()); + S.Diag(CSE->getBeginLoc(), Diag) + << const_cast(CSE) + << TemplateArgString; + }; + + MultiLevelTemplateArgumentList MLTAL; + MLTAL.addOuterTemplateArguments(TempList); + + ExprResult Result = S.SubstExpr( + const_cast(CSE), MLTAL); + if (!Result.isUsable() || Result.isInvalid()) { + // C++ [temp.constr.normal] + // If any such substitution results in an invalid type or + // expression, the program is ill-formed; no diagnostic is required. + + // A diagnostic was already emitted from the substitution , but + // we'll let the user know why it's not SFINAEd from them. + DiagnoseSubstitutionError( + diag::note_could_not_normalize_argument_substitution_failed); + return llvm::Optional{}; + } + ParameterMapping = cast(Result.get()) + ->getTemplateArgsAsWritten(); + + TemplateArgumentListInfo SubstTALI(ParameterMapping->LAngleLoc, + ParameterMapping->RAngleLoc); + for (auto &Arg : ParameterMapping->arguments()) + SubstTALI.addArgument(Arg); + llvm::SmallVector Converted; + bool Failure = S.CheckTemplateArgumentList( + CSE->getNamedConcept(), CSE->getBeginLoc(), SubstTALI, + /*PartialTemplateArgs=*/false, Converted, + /*UpdateArgsWithConversions=*/true, &InstantiationDependent); + // The case is this: + // + // template + // concept C1 = true; + // + // template + // concept C2 = C1; // After substituting Ts = {T}, the + // // resulting argument list does not match + // // the parameter list. + // + // template + // void foo() requires C2 {} + // + // This case should be checked when substituting into C1, and will + // be caught by the if above. + assert(!Failure && + "Template argument list match should have been checked during " + "substitution."); + if (InstantiationDependent) + // The case is this: + // + // template + // concept C1 = true; + // + // template + // concept C2 = C1; // After substituting Us = {Ts}, we cannot + // // match arguments to parameters. + // + // template + // void foo() requires C2 {} + // + // Treat the CSE as an atomic expression. + return NormalizedConstraint{new (S.Context) + AtomicConstraint(E, ParameterMapping)}; + + return fromConstraintExpr(S, CSE->getNamedConcept()->getConstraintExpr(), + CSE->getNamedConcept(), ParameterMapping); + } + return NormalizedConstraint{new (S.Context) + AtomicConstraint(E, ParameterMapping)}; + } + + static llvm::Optional fromConstraintExprs(Sema &S, + ArrayRef E) { + assert(E.size() != 0); + auto First = fromConstraintExpr(S, E[0]); + if (E.size() == 1) + return First; + auto Second = fromConstraintExpr(S, E[1]); + if (!Second) + return llvm::Optional{}; + llvm::Optional Conjunction; + Conjunction.emplace(S.Context, std::move(*First), std::move(*Second), + CCK_Conjunction); + for (unsigned I = 2; I < E.size(); ++I) { + auto Next = fromConstraintExpr(S, E[I]); + if (!Next) + return llvm::Optional{}; + NormalizedConstraint NewConjunction(S.Context, std::move(*Conjunction), + std::move(*Next), CCK_Conjunction); + *Conjunction = std::move(NewConjunction); + } + return Conjunction; + } +}; +} // namespace + +using NormalForm = + llvm::SmallVector, 4>; + +static NormalForm makeCNF(const NormalizedConstraint &Normalized) { + if (Normalized.isAtomic()) + return {{Normalized.getAtomicConstraint()}}; + + NormalForm LCNF = makeCNF(Normalized.getLHS()); + NormalForm RCNF = makeCNF(Normalized.getRHS()); + if (Normalized.getCompoundKind() == NormalizedConstraint::CCK_Conjunction) { + LCNF.reserve(LCNF.size() + RCNF.size()); + while (!RCNF.empty()) + LCNF.push_back(std::move(RCNF.pop_back_val())); + return LCNF; + } + + // Disjunction + NormalForm Res; + Res.reserve(LCNF.size() * RCNF.size()); + for (auto &LDisjunction : LCNF) + for (auto &RDisjunction : RCNF) { + NormalForm::value_type Combined; + Combined.reserve(LDisjunction.size() + RDisjunction.size()); + std::copy(LDisjunction.begin(), LDisjunction.end(), + std::back_inserter(Combined)); + std::copy(RDisjunction.begin(), RDisjunction.end(), + std::back_inserter(Combined)); + Res.emplace_back(Combined); + } + return Res; +} + +static NormalForm makeDNF(const NormalizedConstraint &Normalized) { + if (Normalized.isAtomic()) + return {{Normalized.getAtomicConstraint()}}; + + NormalForm LDNF = makeDNF(Normalized.getLHS()); + NormalForm RDNF = makeDNF(Normalized.getRHS()); + if (Normalized.getCompoundKind() == NormalizedConstraint::CCK_Disjunction) { + LDNF.reserve(LDNF.size() + RDNF.size()); + while (!RDNF.empty()) + LDNF.push_back(std::move(RDNF.pop_back_val())); + return LDNF; + } + + // Conjunction + NormalForm Res; + Res.reserve(LDNF.size() * RDNF.size()); + for (auto &LConjunction : LDNF) { + for (auto &RConjunction : RDNF) { + NormalForm::value_type Combined; + Combined.reserve(LConjunction.size() + RConjunction.size()); + std::copy(LConjunction.begin(), LConjunction.end(), + std::back_inserter(Combined)); + std::copy(RConjunction.begin(), RConjunction.end(), + std::back_inserter(Combined)); + Res.emplace_back(Combined); + } + } + return Res; +} + +static bool subsumes(Sema &S, ArrayRef P, + ArrayRef Q) { + // C++ [temp.constr.order] p2 + // In order to determine if a constraint P subsumes a constraint Q, P is + // transformed into disjunctive normal form, and Q is transformed into + // conjunctive normal form. [...] + auto PNormalized = NormalizedConstraint::fromConstraintExprs(S, P); + if (!PNormalized) + // Program is ill formed at this point. + return false; + const NormalForm PDNF = makeDNF(*PNormalized); + + auto QNormalized = NormalizedConstraint::fromConstraintExprs(S, Q); + if (!QNormalized) + // Program is ill formed at this point. + return false; + const NormalForm QCNF = makeCNF(*QNormalized); + + // C++ [temp.constr.order] p2 + // Then, P subsumes Q if and only if, for every disjunctive clause Pi in the + // disjunctive normal form of P, Pi subsumes every conjunctive clause Qj in + // the conjuctive normal form of Q, where [...] + for (const auto &Pi : PDNF) { + for (const auto &Qj : QCNF) { + // C++ [temp.constr.order] p2 + // - [...] a disjunctive clause Pi subsumes a conjunctive clause Qj if + // and only if there exists an atomic constraint Pia in Pi for which + // there exists an atomic constraint, Qjb, in Qj such that Pia + // subsumes Qjb. + bool Found = false; + for (const AtomicConstraint *Pia : Pi) { + for (const AtomicConstraint *Qjb : Qj) { + if (Pia->subsumes(S.Context, *Qjb)) { + Found = true; + break; + } + } + if (Found) + break; + } + if (!Found) { + return false; + } + } + } + return true; +} + +bool Sema::IsMoreConstrained(NamedDecl *D1, ArrayRef AC1, + NamedDecl *D2, ArrayRef AC2) { + if (AC1.empty()) + return AC2.empty(); + if (AC2.empty()) + // TD1 has associated constraints and TD2 does not. + return true; + + std::pair Key{D1, D2}; + auto CacheEntry = SubsumptionCache.find(Key); + if (CacheEntry != SubsumptionCache.end()) { + return CacheEntry->second; + } + bool Subsumes = subsumes(*this, AC1, AC2); + SubsumptionCache.try_emplace(Key, Subsumes); + return Subsumes; } \ No newline at end of file Index: lib/Sema/SemaTemplate.cpp =================================================================== --- lib/Sema/SemaTemplate.cpp +++ lib/Sema/SemaTemplate.cpp @@ -1049,11 +1049,11 @@ // Check that we have valid decl-specifiers specified. auto CheckValidDeclSpecifiers = [this, &D] { // C++ [temp.param] - // p1 + // p1 // template-parameter: // ... // parameter-declaration - // p2 + // p2 // ... A storage class shall not be specified in a template-parameter // declaration. // [dcl.typedef]p1: @@ -3767,7 +3767,9 @@ } if (isSameAsPrimaryTemplate(VarTemplate->getTemplateParameters(), - Converted)) { + Converted) + && (!Context.getLangOpts().ConceptsTS + || !TemplateParams->hasAssociatedConstraints())) { // C++ [temp.class.spec]p9b3: // // -- The argument list of the specialization shall not be identical @@ -3785,10 +3787,12 @@ void *InsertPos = nullptr; VarTemplateSpecializationDecl *PrevDecl = nullptr; - if (IsPartialSpecialization) + if (IsPartialSpecialization) { // FIXME: Template parameter list matters too - PrevDecl = VarTemplate->findPartialSpecialization(Converted, InsertPos); - else + SmallVector AC; + TemplateParams->getAssociatedConstraints(AC); + PrevDecl = VarTemplate->findPartialSpecialization(Converted, AC, InsertPos); + } else PrevDecl = VarTemplate->findSpecialization(Converted, InsertPos); VarTemplateSpecializationDecl *Specialization = nullptr; @@ -6979,6 +6983,7 @@ bool Complain, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc) { + // TODO: Concepts: Check constrained-parameter constraints here. // Check the actual kind (type, non-type, template). if (Old->getKind() != New->getKind()) { if (Complain) { @@ -7686,10 +7691,13 @@ void *InsertPos = nullptr; ClassTemplateSpecializationDecl *PrevDecl = nullptr; - if (isPartialSpecialization) + if (isPartialSpecialization) { // FIXME: Template parameter list matters, too - PrevDecl = ClassTemplate->findPartialSpecialization(Converted, InsertPos); - else + SmallVector AC; + TemplateParams->getAssociatedConstraints(AC); + PrevDecl = ClassTemplate->findPartialSpecialization(Converted, AC, + InsertPos); + } else PrevDecl = ClassTemplate->findSpecialization(Converted, InsertPos); ClassTemplateSpecializationDecl *Specialization = nullptr; @@ -7712,7 +7720,9 @@ Converted); if (Context.hasSameType(CanonType, - ClassTemplate->getInjectedClassNameSpecialization())) { + ClassTemplate->getInjectedClassNameSpecialization()) + && (!Context.getLangOpts().ConceptsTS + || !TemplateParams->hasAssociatedConstraints())) { // C++ [temp.class.spec]p9b3: // // -- The argument list of the specialization shall not be identical @@ -10323,3 +10333,9 @@ MissingImportKind::PartialSpecialization, /*Recover*/true); } + + // p1 + // template-parameter: + // ... + // parameter-declaration + // p2 \ No newline at end of file Index: lib/Sema/SemaTemplateDeduction.cpp =================================================================== --- lib/Sema/SemaTemplateDeduction.cpp +++ lib/Sema/SemaTemplateDeduction.cpp @@ -2709,6 +2709,23 @@ static constexpr bool value = true; }; +template +static Sema::TemplateDeductionResult +CheckDeducedArgumentConstraints(Sema& S, TemplateDeclT *Template, + ArrayRef DeducedArgs, + TemplateDeductionInfo& Info) { + llvm::SmallVector AssociatedConstraints; + Template->getAssociatedConstraints(AssociatedConstraints); + if (S.CheckConstraintSatisfaction(Template, AssociatedConstraints, + DeducedArgs, Info.getLocation(), + Info.AssociatedConstraintsSatisfaction) + || !Info.AssociatedConstraintsSatisfaction.IsSatisfied) { + Info.reset(TemplateArgumentList::CreateCopy(S.Context, DeducedArgs)); + return Sema::TDK_ConstraintsNotSatisfied; + } + return Sema::TDK_Success; +} + /// Complete template argument deduction for a partial specialization. template static typename std::enable_if::value, @@ -2786,6 +2803,9 @@ if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; + if (auto Result = CheckDeducedArgumentConstraints(S, Partial, Builder, Info)) + return Result; + return Sema::TDK_Success; } @@ -2828,23 +2848,10 @@ if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; - return Sema::TDK_Success; -} + if (auto Result = CheckDeducedArgumentConstraints(S, Template, Builder, + Info)) + return Result; -template -static Sema::TemplateDeductionResult -CheckDeducedArgumentConstraints(Sema& S, TemplateDeclT *Template, - ArrayRef DeducedArgs, - TemplateDeductionInfo& Info) { - llvm::SmallVector AssociatedConstraints; - Template->getAssociatedConstraints(AssociatedConstraints); - if (S.CheckConstraintSatisfaction(Template, AssociatedConstraints, - DeducedArgs, Info.getLocation(), - Info.AssociatedConstraintsSatisfaction) - || !Info.AssociatedConstraintsSatisfaction.IsSatisfied) { - Info.reset(TemplateArgumentList::CreateCopy(S.Context, DeducedArgs)); - return Sema::TDK_ConstraintsNotSatisfied; - } return Sema::TDK_Success; } @@ -2887,10 +2894,6 @@ if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; - if (TemplateDeductionResult Result - = CheckDeducedArgumentConstraints(*this, Partial, DeducedArgs, Info)) - return Result; - return ::FinishTemplateArgumentDeduction( *this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info); } @@ -2932,10 +2935,6 @@ if (Trap.hasErrorOccurred()) return Sema::TDK_SubstitutionFailure; - if (TemplateDeductionResult Result - = CheckDeducedArgumentConstraints(*this, Partial, DeducedArgs, Info)) - return Result; - return ::FinishTemplateArgumentDeduction( *this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info); } @@ -3045,12 +3044,6 @@ = TemplateArgumentList::CreateCopy(Context, Builder); Info.setExplicitArgs(ExplicitArgumentList); - if (TemplateDeductionResult Result - = CheckDeducedArgumentConstraints(*this, FunctionTemplate, - ExplicitArgumentList->asArray(), - Info)) - return Result; - // Template argument deduction and the final substitution should be // done in the context of the templated declaration. Explicit // argument substitution, on the other hand, needs to happen in the @@ -3364,7 +3357,7 @@ return Result; if (TemplateDeductionResult Result - = CheckDeducedArgumentConstraints(*this, FunctionTemplate, DeducedArgs, + = CheckDeducedArgumentConstraints(*this, FunctionTemplate, Builder, Info)) return Result; @@ -4900,6 +4893,18 @@ TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, unsigned NumCallArguments2) { + + auto JudgeByConstraints = [&] () -> FunctionTemplateDecl * { + llvm::SmallVector AC1, AC2; + FT1->getAssociatedConstraints(AC1); + FT2->getAssociatedConstraints(AC2); + bool MoreConstrained1 = IsMoreConstrained(FT1, AC1, FT2, AC2); + bool MoreConstrained2 = IsMoreConstrained(FT2, AC2, FT1, AC1); + if (MoreConstrained1 == MoreConstrained2) + return nullptr; + return MoreConstrained1 ? FT1 : FT2; + }; + bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, NumCallArguments1); bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, @@ -4909,7 +4914,7 @@ return Better1 ? FT1 : FT2; if (!Better1 && !Better2) // Neither is better than the other - return nullptr; + return JudgeByConstraints(); // FIXME: This mimics what GCC implements, but doesn't match up with the // proposed resolution for core issue 692. This area needs to be sorted out, @@ -4919,7 +4924,7 @@ if (Variadic1 != Variadic2) return Variadic1? FT2 : FT1; - return nullptr; + return JudgeByConstraints(); } /// Determine if the two templates are equivalent. @@ -5044,7 +5049,6 @@ static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2, TemplateLikeDecl *P2, TemplateDeductionInfo &Info) { - // TODO: Concepts: Regard constraints // C++ [temp.class.order]p1: // For two class template partial specializations, the first is at least as // specialized as the second if, given the following rewrite to two @@ -5115,8 +5119,16 @@ bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info); bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info); - if (Better1 == Better2) - return nullptr; + if (Better1 == Better2) { + llvm::SmallVector AC1, AC2; + PS1->getAssociatedConstraints(AC1); + PS2->getAssociatedConstraints(AC2); + bool MoreConstrained1 = IsMoreConstrained(PS1, AC1, PS2, AC2); + bool MoreConstrained2 = IsMoreConstrained(PS2, AC2, PS1, AC1); + if (MoreConstrained1 == MoreConstrained2) + return nullptr; + return MoreConstrained1 ? PS1 : PS2; + } return Better1 ? PS1 : PS2; } @@ -5126,11 +5138,23 @@ ClassTemplateDecl *Primary = Spec->getSpecializedTemplate(); QualType PrimaryT = Primary->getInjectedClassNameSpecialization(); QualType PartialT = Spec->getInjectedSpecializationType(); + auto JudgeByConstraints = [&] { + llvm::SmallVector PrimaryAC, SpecAC; + Primary->getAssociatedConstraints(PrimaryAC); + Spec->getAssociatedConstraints(SpecAC); + bool MoreConstrainedPrimary = IsMoreConstrained(Primary, PrimaryAC, Spec, + SpecAC); + bool MoreConstrainedSpec = IsMoreConstrained(Spec, SpecAC, Primary, + PrimaryAC); + if (MoreConstrainedPrimary == MoreConstrainedSpec) + return false; + return MoreConstrainedSpec; + }; if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info)) - return false; - if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)) { + return JudgeByConstraints(); + if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)){ Info.clearSFINAEDiagnostic(); - return false; + return JudgeByConstraints(); } return true; } @@ -5155,8 +5179,17 @@ bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info); bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info); - if (Better1 == Better2) - return nullptr; + if (Better1 == Better2) { + llvm::SmallVector AC1, AC2; + PS1->getAssociatedConstraints(AC1); + PS2->getAssociatedConstraints(AC2); + bool MoreConstrained1 = IsMoreConstrained(PS1, AC1, PS2, AC2); + bool MoreConstrained2 = IsMoreConstrained(PS2, AC2, PS1, AC1); + if (MoreConstrained1 == MoreConstrained2) { + return nullptr; + } + return MoreConstrained1 ? PS1 : PS2; + } return Better1 ? PS1 : PS2; } @@ -5176,11 +5209,25 @@ CanonTemplate, PrimaryArgs); QualType PartialT = Context.getTemplateSpecializationType( CanonTemplate, Spec->getTemplateArgs().asArray()); + + auto JudgeByConstraints = [&] { + llvm::SmallVector PrimaryAC, SpecAC; + Primary->getAssociatedConstraints(PrimaryAC); + Spec->getAssociatedConstraints(SpecAC); + bool MoreConstrainedPrimary = IsMoreConstrained(Primary, PrimaryAC, Spec, + SpecAC); + bool MoreConstrainedSpec = IsMoreConstrained(Spec, SpecAC, Primary, + PrimaryAC); + if (MoreConstrainedPrimary == MoreConstrainedSpec) + return false; + return MoreConstrainedSpec; + }; + if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info)) - return false; - if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)) { + return JudgeByConstraints(); + if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)){ Info.clearSFINAEDiagnostic(); - return false; + return JudgeByConstraints(); } return true; } Index: lib/Sema/SemaTemplateInstantiateDecl.cpp =================================================================== --- lib/Sema/SemaTemplateInstantiateDecl.cpp +++ lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -3501,8 +3501,10 @@ // Figure out where to insert this class template partial specialization // in the member template's set of class template partial specializations. void *InsertPos = nullptr; + SmallVector InstAC; + InstParams->getAssociatedConstraints(InstAC); ClassTemplateSpecializationDecl *PrevDecl - = ClassTemplate->findPartialSpecialization(Converted, InsertPos); + = ClassTemplate->findPartialSpecialization(Converted, InstAC, InsertPos); // Build the canonical type that describes the converted template // arguments of the class template partial specialization. @@ -3625,8 +3627,10 @@ // Figure out where to insert this variable template partial specialization // in the member template's set of variable template partial specializations. void *InsertPos = nullptr; + llvm::SmallVector InstAC; + InstParams->getAssociatedConstraints(InstAC); VarTemplateSpecializationDecl *PrevDecl = - VarTemplate->findPartialSpecialization(Converted, InsertPos); + VarTemplate->findPartialSpecialization(Converted, InstAC, InsertPos); // Build the canonical type that describes the converted template // arguments of the variable template partial specialization. Index: lib/Serialization/ASTReaderDecl.cpp =================================================================== --- lib/Serialization/ASTReaderDecl.cpp +++ lib/Serialization/ASTReaderDecl.cpp @@ -2233,12 +2233,14 @@ void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl( ClassTemplatePartialSpecializationDecl *D) { - RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D); - + // We need to read the template params first because redeclarable is going to + // need them for profiling TemplateParameterList *Params = Record.readTemplateParameterList(); D->TemplateParams = Params; D->ArgsAsWritten = Record.readASTTemplateArgumentListInfo(); + RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D); + // These are read/set from/to the first declaration. if (ThisDeclID == Redecl.getFirstID()) { D->InstantiatedFromMember.setPointer( @@ -2334,12 +2336,12 @@ /// using Template(Partial)SpecializationDecl as input type. void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl( VarTemplatePartialSpecializationDecl *D) { - RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D); - TemplateParameterList *Params = Record.readTemplateParameterList(); D->TemplateParams = Params; D->ArgsAsWritten = Record.readASTTemplateArgumentListInfo(); + RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D); + // These are read/set from/to the first declaration. if (ThisDeclID == Redecl.getFirstID()) { D->InstantiatedFromMember.setPointer( Index: lib/Serialization/ASTWriterDecl.cpp =================================================================== --- lib/Serialization/ASTWriterDecl.cpp +++ lib/Serialization/ASTWriterDecl.cpp @@ -1484,11 +1484,11 @@ void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl( ClassTemplatePartialSpecializationDecl *D) { - VisitClassTemplateSpecializationDecl(D); - Record.AddTemplateParameterList(D->getTemplateParameters()); Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten()); + VisitClassTemplateSpecializationDecl(D); + // These are read/set from/to the first declaration. if (D->getPreviousDecl() == nullptr) { Record.AddDeclRef(D->getInstantiatedFromMember()); @@ -1544,11 +1544,11 @@ void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl( VarTemplatePartialSpecializationDecl *D) { - VisitVarTemplateSpecializationDecl(D); - Record.AddTemplateParameterList(D->getTemplateParameters()); Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten()); + VisitVarTemplateSpecializationDecl(D); + // These are read/set from/to the first declaration. if (D->getPreviousDecl() == nullptr) { Record.AddDeclRef(D->getInstantiatedFromMember()); Index: test/CXX/concepts-ts/temp/temp.constr/temp.constr.normal/p1.cpp =================================================================== --- /dev/null +++ test/CXX/concepts-ts/temp/temp.constr/temp.constr.normal/p1.cpp @@ -0,0 +1,68 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s + +namespace maybe_incorrect_args { + template + concept C = true; + + // diagnostic expected here - the Cs are treated as atomic, and since + // they originate from different source-level constructs, they do not subsume + // each other. + template requires C + struct A {}; // expected-note{{template is declared here}} + + template requires C && true + struct A {}; // expected-error{{class template partial specialization is not more specialized than the primary template}} +} + +namespace ill_formed_subst { + + template + struct B; // expected-note 2{{template is declared here}} + + template + concept C1 = true; + + template + concept C2 = C1::foo>; + // expected-error@-1 2{{implicit instantiation of undefined template 'ill_formed_subst::B'}} + // expected-note@-2 2{{when substituting into C1::foo> [with T = type-parameter-0-0, U = int]. Make sure concept arguments are valid for any substitution}} + + template requires C2 + struct A {}; // expected-note {{template is declared here}} + + template requires C2 && true + struct A {}; // expected-error {{class template partial specialization is not more specialized than the primary template}} +} + +namespace incorrect_args_after_subst { + template + concept C1 = true; // expected-note 2{{template is declared here}} + + template + concept C2 = C1; + // expected-error@-1 2{{too many template arguments for concept 'C1'}} + // expected-note@-2 2{{when substituting into C1 [with Ts = ]. Make sure concept arguments are valid for any substitution}} + + template requires C2 + struct A {}; // expected-note{{template is declared here}} + + template requires C2 && true + struct A {}; // expected-error{{class template partial specialization is not more specialized than the primary template}} +} + +namespace maybe_incorrect_args_after_subst { + template + concept C1 = true; + + template + concept C2 = C1; + + // no diagnostic expected here - C1 is treated as atomic, and since it + // originates at the same source level construct, the specialized subsumes the + // primary. + template requires C2 + struct A {}; + + template requires C2 && true + struct A {}; +} Index: test/CXX/concepts-ts/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp =================================================================== --- /dev/null +++ test/CXX/concepts-ts/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp @@ -0,0 +1,84 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s + +template requires sizeof(T) >= 4 +class A{}; // expected-note{{template is declared here}} + +template requires sizeof(T) >= 4 && sizeof(T) <= 10 +class A{}; // expected-error{{class template partial specialization is not more specialized than the primary template}} + +template +concept C1 = sizeof(T) >= 4; + +template requires C1 +class B{}; + +template requires C1 && sizeof(T) <= 10 +class B{}; + +template +concept C2 = sizeof(T) > 1 && sizeof(T) <= 8; + +template +class C{}; + +template requires C1 +class C{}; + +template +class D{}; // expected-note{{previous definition is here}} + +template +class D{}; // expected-error{{class template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}} expected-error{{redefinition of 'D'}} + +template requires C1 // expected-note{{previous template declaration is here}} +class E{}; + +template // expected-error{{requires clause differs in template redeclaration}} +class E{}; // expected-error{{class template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}} + +template +struct F{ enum{ value = 1 }; }; + +template requires C1 && C2 +struct F{ enum{ value = 2 }; }; + +template requires C1 || C2 +struct F{ enum{ value = 3 }; }; + +static_assert(F::value == 2); +static_assert(F::value == 3); +static_assert(F::value == 1); + +template +concept C3 = true; + +template +concept C4 = C3; + +// C4 is normalized to C3@ because there is a pack +// expansion into a non-pack parameter. therefore the two C4 subsume each +// other and the following is non-ambiguous. + +template requires C4 +struct G { }; + +template requires C4 && C4 +struct G { }; + +// Here the two C3s cannot be normalized further, and do not subsume each other +// because they originate in two different locations in code. + +template requires C3 +struct H { }; // expected-note {{template is declared here}} + +template requires C3 && C4 +struct H { }; // expected-error {{class template partial specialization is not more specialized than the primary template}} + +// Make sure atomic constraints subsume each other only if their parameter +// mappings are identical. + +template requires C2 +struct I { }; // expected-note {{template is declared here}} + +template requires C2 +struct I { }; // expected-error {{class template partial specialization is not more specialized than the primary template}} \ No newline at end of file Index: test/CXX/concepts-ts/temp/temp.constr/temp.constr.order/function-templates.cpp =================================================================== --- /dev/null +++ test/CXX/concepts-ts/temp/temp.constr/temp.constr.order/function-templates.cpp @@ -0,0 +1,82 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s + +template requires sizeof(T) >= 4 +bool a() { return false; } // expected-note {{candidate function [with T = unsigned int]}} + +template requires sizeof(T) >= 4 && sizeof(T) <= 10 +bool a() { return true; } // expected-note {{candidate function [with T = unsigned int]}} + +bool av = a(); // expected-error {{call to 'a' is ambiguous}} + +template +concept C1 = sizeof(T) >= 4; + +template requires C1 +constexpr bool b() { return false; } + +template requires C1 && sizeof(T) <= 10 +constexpr bool b() { return true; } + +static_assert(b()); +static_assert(!b()); + +template +concept C2 = sizeof(T) > 1 && sizeof(T) <= 8; + +template +bool c() { return false; } + +template requires C1 +bool c() { return true; } + +template requires C1 +constexpr bool d() { return false; } + +template +constexpr bool d() { return true; } + +static_assert(!d()); + +template +constexpr int e() { return 1; } + +template requires C1 && C2 +constexpr int e() { return 2; } + +template requires C1 || C2 +constexpr int e() { return 3; } + +static_assert(e() == 2); +static_assert(e() == 3); +static_assert(e() == 1); + +template +concept BiggerThan = sizeof(T) > sizeof(U); + +template +concept BiggerThanInt = BiggerThan; + +template requires BiggerThan +void f() { } +// expected-note@-1 {{candidate function [with T = long long, U = int]}} + +template requires BiggerThanInt +void f() { } +// expected-note@-1 {{candidate function [with T = long long, U = int]}} + +static_assert(sizeof(f())); +// expected-error@-1 {{call to 'f' is ambiguous}} + +template +concept C3 = true; + +template +concept C4 = true && C3; + +template requires C3 +int g() { } + +template requires C4 +int g() { } + +static_assert(sizeof(g())); \ No newline at end of file Index: test/CXX/concepts-ts/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp =================================================================== --- /dev/null +++ test/CXX/concepts-ts/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp @@ -0,0 +1,53 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s + +template requires sizeof(T) >= 4 +bool a = false; // expected-note{{template is declared here}} + +template requires sizeof(T) >= 4 && sizeof(T) <= 10 +bool a = true; // expected-error{{variable template partial specialization is not more specialized than the primary template}} + +template +concept C1 = sizeof(T) >= 4; + +template requires C1 +bool b = false; + +template requires C1 && sizeof(T) <= 10 +bool b = true; + +template +concept C2 = sizeof(T) > 1 && sizeof(T) <= 8; + +template +bool c = false; + +template requires C1 +bool c = true; + +template +bool d = false; + +template +bool d = true; // expected-error{{variable template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}} + +template requires C1 +bool e = false; + +template +bool e = true; // expected-error{{variable template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}} + +template +constexpr int f = 1; + +template requires C1 && C2 +constexpr int f = 2; + +template requires C1 || C2 +constexpr int f = 3; + +static_assert(f == 2); +static_assert(f == 3); +static_assert(f == 1); + + +