nested-requirements.cpp (#52)

* Remove unused headers

* checkpoint

Author: zyn0217

clang/include/clang/Sema/Sema.h

@@ -14717,7 +14717,8 @@ class Sema final : public SemaBase {
       ArrayRef<AssociatedConstraint> AssociatedConstraints,
       const MultiLevelTemplateArgumentList &TemplateArgLists,
       SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction,
-      const ConceptReference *TopLevelConceptId = nullptr);
+      const ConceptReference *TopLevelConceptId = nullptr,
+      Expr **ConvertedExpr = nullptr);
 
   /// \brief Check whether the given non-dependent constraint expression is
   /// satisfied. Returns false and updates Satisfaction with the satisfaction

clang/lib/Sema/SemaConcept.cpp

@@ -36,8 +36,6 @@
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/Timer.h"
-#include "llvm/Support/WithColor.h"
 #include <cstddef>
 #include <optional>
 
@@ -345,7 +343,7 @@ static ExprResult EvaluateAtomicConstraint(
   return SubstitutedExpression;
 }
 
-static bool calculateConstraintSatisfaction(
+static ExprResult calculateConstraintSatisfaction(
     Sema &S, const NormalizedConstraint &Constraint, const NamedDecl *Template,
     SourceLocation TemplateNameLoc, const MultiLevelTemplateArgumentList &MLTAL,
     ConstraintSatisfaction &Satisfaction, UnsignedOrNone PackSubstitutionIndex);
@@ -417,7 +415,7 @@ SubstitutionInTemplateArguments(
   return std::move(MLTAL);
 }
 
-static bool calculateConstraintSatisfaction(
+static ExprResult calculateConstraintSatisfaction(
     Sema &S, const AtomicConstraint &Constraint, const NamedDecl *Template,
     SourceLocation TemplateNameLoc, const MultiLevelTemplateArgumentList &MLTAL,
     ConstraintSatisfaction &Satisfaction,
@@ -497,7 +495,7 @@ static bool calculateConstraintSatisfaction(
   if (!Satisfaction.IsSatisfied)
     Satisfaction.Details.emplace_back(SubstitutedAtomicExpr.get());
 
-  return SubstitutedAtomicExpr.isUsable();
+  return SubstitutedAtomicExpr;
 }
 
 static UnsignedOrNone EvaluateFoldExpandedConstraintSize(
@@ -533,7 +531,7 @@ static UnsignedOrNone EvaluateFoldExpandedConstraintSize(
   return NumExpansions;
 }
 
-static bool calculateConstraintSatisfaction(
+static ExprResult calculateConstraintSatisfaction(
     Sema &S, const FoldExpandedConstraint &FE, const NamedDecl *Template,
     SourceLocation TemplateNameLoc, const MultiLevelTemplateArgumentList &MLTAL,
     ConstraintSatisfaction &Satisfaction) {
@@ -568,12 +566,13 @@ static bool calculateConstraintSatisfaction(
     Sema::ArgPackSubstIndexRAII SubstIndex(S, I);
     Satisfaction.IsSatisfied = false;
     Satisfaction.ContainsErrors = false;
-    bool Success = calculateConstraintSatisfaction(
+    // FIXME
+    ExprResult Expr = calculateConstraintSatisfaction(
         S, FE.getNormalizedPattern(), Template, TemplateNameLoc,
         *SubstitutedArgs, Satisfaction, UnsignedOrNone(I));
     // SFINAE errors shouldn't prevent disjunction from evaluating
     // FIXME: Does !Success == SFINAE errors occurred?
-    if (!Success && Conjunction)
+    if (!Expr.isUsable() && Conjunction)
       return false;
     if (!Conjunction && Satisfaction.IsSatisfied) {
       Satisfaction.Details.erase(Satisfaction.Details.begin() +
@@ -589,25 +588,12 @@ static bool calculateConstraintSatisfaction(
   return true;
 }
 
-static bool calculateConstraintSatisfaction(
+static ExprResult calculateConstraintSatisfaction(
     Sema &S, const ConceptIdConstraint &Constraint, const NamedDecl *Template,
     SourceLocation TemplateNameLoc, const MultiLevelTemplateArgumentList &MLTAL,
     ConstraintSatisfaction &Satisfaction,
     UnsignedOrNone PackSubstitutionIndex) {
 
-  // If the expression has been calculated, e.g. when we are in a nested
-  // requirement, do not compute it repeatedly.
-  if (auto *Expr = Constraint.getConceptSpecializationExpr();
-      Expr && Expr->getDependence() == ExprDependence::None) {
-    auto &Calculated = Expr->getSatisfaction();
-    Satisfaction.ContainsErrors = Calculated.ContainsErrors;
-    Satisfaction.IsSatisfied = Calculated.IsSatisfied;
-    Satisfaction.Details.insert(Satisfaction.Details.end(),
-                                Calculated.records().begin(),
-                                Calculated.records().end());
-    return !Satisfaction.ContainsErrors;
-  }
-
   Sema::ContextRAII CurContext(
       S, Constraint.getConceptId()->getNamedConcept()->getDeclContext(),
       /*NewThisContext=*/false);
@@ -620,11 +606,12 @@ static bool calculateConstraintSatisfaction(
 
   auto Size = Satisfaction.Details.size();
 
-  bool Ok = calculateConstraintSatisfaction(
+  ExprResult E = calculateConstraintSatisfaction(
       S, Constraint.getNormalizedConstraint(), Template, TemplateNameLoc, MLTAL,
       Satisfaction, PackSubstitutionIndex);
 
-  if (Size != Satisfaction.Details.size()) {
+  if (!E.isUsable())
+    return E;
 
     llvm::SmallVector<TemplateArgument> SubstitutedOuterMost;
     std::optional<MultiLevelTemplateArgumentList> SubstitutedArgs =
@@ -633,7 +620,7 @@ static bool calculateConstraintSatisfaction(
                                         PackSubstitutionIndex);
 
     if (!SubstitutedArgs)
-      return Ok;
+    return E.isUsable();
 
     Sema::SFINAETrap Trap(S);
     Sema::ArgPackSubstIndexRAII SubstIndex(
@@ -652,12 +639,15 @@ static bool calculateConstraintSatisfaction(
     AdjustConstraintDepth Adjust(S, Depth);
       if (Adjust.TransformTemplateArguments(Ori->getTemplateArgs(),
                                             Ori->NumTemplateArgs, TransArgs))
-        return Ok;
+    return false;
 
     if (S.SubstTemplateArguments(TransArgs.arguments(), *SubstitutedArgs,
                                  OutArgs) ||
-        Trap.hasErrorOccurred())
-        return Ok;
+      Trap.hasErrorOccurred()) {
+    Satisfaction.ContainsErrors = true;
+    Satisfaction.IsSatisfied = false;
+    return false;
+  }
 
     CXXScopeSpec SS;
     SS.Adopt(Constraint.getConceptId()->getNestedNameSpecifierLoc());
@@ -669,18 +659,20 @@ static bool calculateConstraintSatisfaction(
         /*CheckConstraintSatisfaction=*/false);
 
     if (SubstitutedConceptId.isInvalid() || Trap.hasErrorOccurred())
-      return Ok;
+    return false;
+
+  if (Size != Satisfaction.Details.size()) {
 
     Satisfaction.Details.insert(
         Satisfaction.Details.begin() + Size,
         UnsatisfiedConstraintRecord(
             SubstitutedConceptId.getAs<ConceptSpecializationExpr>()
                 ->getConceptReference()));
   }
-  return Ok;
+  return SubstitutedConceptId;
 }
 
-static bool calculateConstraintSatisfaction(
+static ExprResult calculateConstraintSatisfaction(
     Sema &S, const CompoundConstraint &Constraint, const NamedDecl *Template,
     SourceLocation TemplateNameLoc, const MultiLevelTemplateArgumentList &MLTAL,
     ConstraintSatisfaction &Satisfaction,
@@ -691,35 +683,49 @@ static bool calculateConstraintSatisfaction(
   bool Conjunction =
       Constraint.getCompoundKind() == NormalizedConstraint::CCK_Conjunction;
 
-  bool Ok = calculateConstraintSatisfaction(
+  ExprResult LHS = calculateConstraintSatisfaction(
       S, Constraint.getLHS(), Template, TemplateNameLoc, MLTAL, Satisfaction,
       PackSubstitutionIndex);
 
-  if (Conjunction && !Ok)
+  if (Conjunction && !LHS.isUsable())
     return false;
 
-  if (!Conjunction && Ok && Satisfaction.IsSatisfied &&
+  if (!Conjunction && LHS.isUsable() && Satisfaction.IsSatisfied &&
       !Satisfaction.ContainsErrors)
-    return true;
+    return LHS;
 
-  if (Conjunction && Ok &&
+  if (Conjunction && LHS.isUsable() &&
       (!Satisfaction.IsSatisfied || Satisfaction.ContainsErrors))
-    return true;
+    return LHS;
 
   Satisfaction.ContainsErrors = false;
   Satisfaction.IsSatisfied = false;
 
-  Ok = calculateConstraintSatisfaction(S, Constraint.getRHS(), Template,
-                                         TemplateNameLoc, MLTAL, Satisfaction,
+  ExprResult RHS = calculateConstraintSatisfaction(
+      S, Constraint.getRHS(), Template, TemplateNameLoc, MLTAL, Satisfaction,
                                          PackSubstitutionIndex);
-  if (Ok && Satisfaction.IsSatisfied && !Satisfaction.ContainsErrors)
+  if (RHS.isUsable() && Satisfaction.IsSatisfied && !Satisfaction.ContainsErrors)
     Satisfaction.Details.erase(Satisfaction.Details.begin() +
                                    EffectiveDetailEndIndex,
                                Satisfaction.Details.end());
-  return Ok;
+
+  if (!LHS.isUsable())
+    return RHS;
+
+  if (!RHS.isUsable())
+    return LHS;
+
+  return BinaryOperator::Create(
+      S.Context, LHS.get(), RHS.get(),
+      BinaryOperator::getOverloadedOpcode(
+          Constraint.getCompoundKind() == NormalizedConstraint::CCK_Conjunction
+              ? OO_AmpAmp
+              : OO_PipePipe),
+      S.Context.BoolTy, VK_PRValue, OK_Ordinary, Constraint.getBeginLoc(),
+      FPOptionsOverride{});
 }
 
-static bool calculateConstraintSatisfaction(
+static ExprResult calculateConstraintSatisfaction(
     Sema &S, const NormalizedConstraint &Constraint, const NamedDecl *Template,
     SourceLocation TemplateNameLoc, const MultiLevelTemplateArgumentList &MLTAL,
     ConstraintSatisfaction &Satisfaction,
@@ -753,7 +759,10 @@ static bool CheckConstraintSatisfaction(
     ArrayRef<AssociatedConstraint> AssociatedConstraints,
     const MultiLevelTemplateArgumentList &TemplateArgsLists,
     SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction,
-    const ConceptReference *TopLevelConceptId = nullptr) {
+    Expr **ConvertedExpr, const ConceptReference *TopLevelConceptId = nullptr) {
+
+  if (ConvertedExpr)
+    *ConvertedExpr = nullptr;
 
   if (AssociatedConstraints.empty()) {
     Satisfaction.IsSatisfied = true;
@@ -790,7 +799,6 @@ static bool CheckConstraintSatisfaction(
                                     const_cast<NormalizedConstraint *>(C),
                                     Template, /*CSE=*/nullptr,
                                     S.ArgPackSubstIndex);
-  }
 
   ExprResult Res = calculateConstraintSatisfaction(
               S, *C, Template, TemplateIDRange.getBegin(), TemplateArgsLists,
@@ -810,16 +818,16 @@ bool Sema::CheckConstraintSatisfaction(
     ArrayRef<AssociatedConstraint> AssociatedConstraints,
     const MultiLevelTemplateArgumentList &TemplateArgsLists,
     SourceRange TemplateIDRange, ConstraintSatisfaction &OutSatisfaction,
-    const ConceptReference *TopLevelConceptId) {
+    const ConceptReference *TopLevelConceptId, Expr **ConvertedExpr) {
   if (AssociatedConstraints.empty()) {
     OutSatisfaction.IsSatisfied = true;
     return false;
   }
   const auto *Template = Entity.dyn_cast<const NamedDecl *>();
   if (!Template) {
-    return ::CheckConstraintSatisfaction(*this, nullptr, AssociatedConstraints,
-                                         TemplateArgsLists, TemplateIDRange,
-                                         OutSatisfaction, TopLevelConceptId);
+    return ::CheckConstraintSatisfaction(
+        *this, nullptr, AssociatedConstraints, TemplateArgsLists,
+        TemplateIDRange, OutSatisfaction, ConvertedExpr, TopLevelConceptId);
   }
   // Invalid templates could make their way here. Substituting them could result
   // in dependent expressions.
@@ -850,13 +858,15 @@ bool Sema::CheckConstraintSatisfaction(
 
   auto Satisfaction =
       std::make_unique<ConstraintSatisfaction>(Owner, FlattenedArgs);
-  if (::CheckConstraintSatisfaction(*this, Template, AssociatedConstraints,
-                                    TemplateArgsLists, TemplateIDRange,
-                                    *Satisfaction, TopLevelConceptId)) {
+  if (::CheckConstraintSatisfaction(
+          *this, Template, AssociatedConstraints, TemplateArgsLists,
+          TemplateIDRange, *Satisfaction, ConvertedExpr, TopLevelConceptId)) {
     OutSatisfaction = *Satisfaction;
     return true;
   }
 
+  // FIXME: cache ConvertedExpr for nested requirements?
+
   if (auto *Cached = SatisfactionCache.FindNodeOrInsertPos(ID, InsertPos)) {
     // The evaluation of this constraint resulted in us trying to re-evaluate it
     // recursively. This isn't really possible, except we try to form a
@@ -1612,7 +1622,8 @@ substituteParameterMappings(Sema &S, NormalizedConstraintWithParamMapping &N,
       SourceLocation Loc = ArgsAsWritten->NumTemplateArgs > I
                     ? ArgsAsWritten->arguments()[I].getLocation()
                                : SourceLocation();
-      // FIXME: Investigate when we couldn't preserve the SourceLoc. What shall we do??
+      // FIXME: Investigate when we couldn't preserve the SourceLoc. What shall
+      // we do??
       // assert(Loc.isValid());
       if (OccurringIndices[I]) {
         NamedDecl *Param = TemplateParams->begin()[I];
@@ -1945,9 +1956,14 @@ NormalizedConstraint *NormalizedConstraint::fromConstraintExpr(
 const NormalizedConstraint *Sema::getNormalizedAssociatedConstraints(
     ConstrainedDeclOrNestedRequirement ConstrainedDeclOrNestedReq,
     ArrayRef<AssociatedConstraint> AssociatedConstraints) {
-  if (!ConstrainedDeclOrNestedReq)
-    return NormalizedConstraint::fromAssociatedConstraints(
+  if (!ConstrainedDeclOrNestedReq) {
+    auto *Normalized = NormalizedConstraint::fromAssociatedConstraints(
         *this, nullptr, AssociatedConstraints);
+    if (!Normalized || substituteParameterMappings(*this, *Normalized))
+      return nullptr;
+
+    return Normalized;
+  }
 
   // FIXME: ConstrainedDeclOrNestedReq is never a NestedRequirement!
   const NamedDecl *ND =

clang/lib/Sema/SemaTemplateInstantiate.cpp

@@ -2939,6 +2939,7 @@ TemplateInstantiator::TransformNestedRequirement(
     return Req;
   }
 
+#if 0
   if (Req->isDependent() || AlwaysRebuild()) {
     Sema::InstantiatingTemplate ReqInst(
         SemaRef, Constraint->getBeginLoc(), Req,
@@ -2956,24 +2957,29 @@ TemplateInstantiator::TransformNestedRequirement(
 
   if (Constraint->isInstantiationDependent())
     return new (C) concepts::NestedRequirement(Constraint);
+#endif
 
   bool Success;
+  Expr *NewConstraint;
   TemplateDeductionInfo Info(Constraint->getBeginLoc());
   {
     EnterExpressionEvaluationContext ContextRAII(
         SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
-    Sema::InstantiatingTemplate ConstrInst(SemaRef, Constraint->getBeginLoc(),
-                                           Req, Info,
+    Sema::InstantiatingTemplate ConstrInst(
+        SemaRef, Constraint->getBeginLoc(), Req,
+        Sema::InstantiatingTemplate::ConstraintsCheck(),
                                            Constraint->getSourceRange());
+
     if (ConstrInst.isInvalid())
       return nullptr;
 
     Sema::SFINAETrap Trap(SemaRef);
 
     Success = !SemaRef.CheckConstraintSatisfaction(
         Req, AssociatedConstraint(Constraint, SemaRef.ArgPackSubstIndex),
-        TemplateArgs, Constraint->getSourceRange(), Satisfaction);
+        TemplateArgs, Constraint->getSourceRange(), Satisfaction,
+        /*TopLevelConceptId=*/nullptr, &NewConstraint);
 
     assert(!Success || !Trap.hasErrorOccurred() &&
                            "Substitution failures must be handled "
@@ -2984,7 +2990,10 @@ TemplateInstantiator::TransformNestedRequirement(
     return NestedReqWithDiag(Constraint, Satisfaction);
 
   // FIXME: const correctness
-  return new (C) concepts::NestedRequirement(C, Constraint, Satisfaction);
+  // MLTAL might be dependent.
+  if (!NewConstraint)
+    NewConstraint = Constraint;
+  return new (C) concepts::NestedRequirement(C, NewConstraint, Satisfaction);
 }
 
 TypeSourceInfo *Sema::SubstType(TypeSourceInfo *T,

clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp

@@ -43,11 +43,10 @@ namespace std_example {
       requires sizeof(a) == 4; // OK
       requires a == 0; // expected-error{{substitution into constraint expression resulted in a non-constant expression}}
       // expected-note@-1{{while checking the satisfaction of nested requirement requested here}}
-      // expected-note@-2{{in instantiation of requirement here}}
-      // expected-note@-3{{while checking the satisfaction of nested requirement requested here}}
-      // expected-note@-6{{while substituting template arguments into constraint expression here}}
-      // expected-note@-5{{function parameter 'a' with unknown value cannot be used in a constant expression}}
-      // expected-note@-8{{declared here}}
+      // expected-note@-2{{while checking the satisfaction of nested requirement requested here}}
+      // expected-note@-5{{while substituting template arguments into constraint expression here}}
+      // expected-note@-4{{function parameter 'a' with unknown value cannot be used in a constant expression}}
+      // expected-note@-7{{declared here}}
     };
     static_assert(C2<int>); // expected-error{{static assertion failed}}
     // expected-note@-1{{while checking the satisfaction of concept 'C2<int>' requested here}}
@@ -161,12 +160,13 @@ void func() {
   // expected-note@#bar {{because 'X<SubstitutionFailureNestedRequires::ErrorExpressions_NotSF::False>::value' evaluated to false}}
 
   bar<int>();
+  // expected-error@-1 {{no matching function for call to 'bar'}} \
   // expected-note@-1 {{while checking constraint satisfaction for template 'bar<int>' required here}} \
-  // expected-note@-1 {{while substituting deduced template arguments into function template 'bar' [with T = int]}}
+  // 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}}
   // expected-note@#bar {{while substituting template arguments into constraint expression here}}
+  // expected-note@#bar {{candidate template ignored}}
   // expected-error@#X_Value {{type 'int' cannot be used prior to '::' because it has no members}}
 }
 }