Merge pull request #47 from zyn0217/fix-access-checking-after-normalization

Fix SemaTemplate/concepts-lambda.cpp

Author: cor3ntin

clang/include/clang/Sema/Sema.h

@@ -13134,6 +13134,8 @@ class Sema final : public SemaBase {
     /// Whether we're substituting into constraints.
     bool InConstraintSubstitution;
 
+    bool InParameterMappingSubstitution;
+
     /// The point of instantiation or synthesis within the source code.
     SourceLocation PointOfInstantiation;
 
@@ -13873,11 +13875,17 @@ class Sema final : public SemaBase {
   }
 
   /// Determine whether we are currently performing constraint substitution.
+  // FIXME: Rename it
   bool inConstraintSubstitution() const {
     return !CodeSynthesisContexts.empty() &&
            CodeSynthesisContexts.back().InConstraintSubstitution;
   }
 
+  bool inParameterMappingSubstitution() const {
+    return !CodeSynthesisContexts.empty() &&
+           CodeSynthesisContexts.back().InParameterMappingSubstitution;
+  }
+
   using EntityPrinter = llvm::function_ref<void(llvm::raw_ostream &)>;
 
   /// \brief create a Requirement::SubstitutionDiagnostic with only a

clang/include/clang/Sema/SemaConcept.h

@@ -65,7 +65,7 @@ struct NormalizedConstraint {
   struct AtomicBits {
     LLVM_PREFERRED_TYPE(ConstraintKind)
     unsigned Kind : 5;
-    unsigned : 1;
+    unsigned Placeholder : 1;
     unsigned PackSubstitutionIndex : 26;
     llvm::SmallBitVector Indexes;
     TemplateArgumentLoc *Args;
@@ -114,6 +114,7 @@ struct NormalizedConstraint {
                        const NamedDecl *ConstraintDecl,
                        UnsignedOrNone PackIndex)
       : Atomic{llvm::to_underlying(ConstraintKind::Atomic),
+               /*Placeholder=*/0,
                PackIndex.toInternalRepresentation(),
                /*Indexes=*/{},
                /*Args=*/nullptr,
@@ -134,7 +135,8 @@ struct NormalizedConstraint {
                        NormalizedConstraint *SubConstraint,
                        UnsignedOrNone PackIndex)
       : ConceptId{{llvm::to_underlying(ConstraintKind::ConceptId),
-                   PackIndex.toInternalRepresentation(), /*Indexes=*/{},
+                   /*Placeholder=*/0, PackIndex.toInternalRepresentation(),
+                   /*Indexes=*/{},
                    /*Args=*/nullptr, ConceptId, ConstraintDecl},
                   SubConstraint} {}
 
@@ -237,7 +239,8 @@ struct NormalizedConstraint {
   fromAssociatedConstraints(Sema &S, const NamedDecl *D,
                             ArrayRef<AssociatedConstraint> ACs);
   static NormalizedConstraint *fromConstraintExpr(Sema &S, const NamedDecl *D,
-                                                  const Expr *E);
+                                                  const Expr *E,
+                                                  UnsignedOrNone SubstIndex);
 };
 
 class CompoundConstraint : public NormalizedConstraint {

clang/include/clang/Sema/Template.h

@@ -261,6 +261,7 @@ enum class TemplateSubstitutionKind : char {
       //         ==
       //             AssociatedDecl) &&
       //        "Trying to change incorrect declaration?");
+      TemplateArgumentLists.back().AssociatedDeclAndFinal.setPointer(AssociatedDecl);
       TemplateArgumentLists.back().Args = Args;
     }
 

clang/lib/Sema/SemaConcept.cpp

@@ -368,6 +368,8 @@ SubstitutionInTemplateArguments(
 
   TemplateArgumentListInfo SubstArgs;
   if (Constraint.hasParameterMapping()) {
+    Sema::ArgPackSubstIndexRAII SubstIndex(
+        S, Constraint.getPackSubstitutionIndex());
     if (S.SubstTemplateArgumentsInParameterMapping(
             Constraint.getParameterMapping(), MLTAL, SubstArgs) ||
         Trap.hasErrorOccurred())
@@ -590,6 +592,8 @@ static bool calculateConstraintSatisfaction(
       return Ok;
 
     Sema::SFINAETrap Trap(S);
+    Sema::ArgPackSubstIndexRAII SubstIndex(
+        S, Constraint.getPackSubstitutionIndex());
 
     const ASTTemplateArgumentListInfo *Ori =
         Constraint.getConceptId()->getTemplateArgsAsWritten();
@@ -604,7 +608,8 @@ static bool calculateConstraintSatisfaction(
                                           Ori->NumTemplateArgs, TransArgs))
       return Ok;
 
-    if (S.SubstTemplateArguments(TransArgs.arguments(), MLTAL, OutArgs) ||
+    if (S.SubstTemplateArguments(TransArgs.arguments(), *SubstitutedArgs,
+                                 OutArgs) ||
         Trap.hasErrorOccurred())
       return Ok;
 
@@ -1659,19 +1664,23 @@ static bool substituteParameterMappings(Sema &S, NormalizedConstraint &N,
       /*RelativeToPrimary=*/true,
       /*Pattern=*/nullptr,
       /*ForConstraintInstantiation=*/true);
-
+  // Don't build Subst* nodes to model lambda expressions.
+  // The transform of Subst* is oblivious to the lambda type.
+  MLTAL.setKind(TemplateSubstitutionKind::Rewrite);
   return substituteParameterMappings(S, N, MLTAL,
                                      CSE->getTemplateArgsAsWritten());
 }
 
 NormalizedConstraint *NormalizedConstraint::fromAssociatedConstraints(
     Sema &S, const NamedDecl *D, ArrayRef<AssociatedConstraint> ACs) {
   assert(ACs.size() != 0);
-  auto Conjunction = fromConstraintExpr(S, D, ACs[0].ConstraintExpr);
+  auto *Conjunction =
+      fromConstraintExpr(S, D, ACs[0].ConstraintExpr, ACs[0].ArgPackSubstIndex);
   if (!Conjunction)
     return nullptr;
   for (unsigned I = 1; I < ACs.size(); ++I) {
-    auto Next = fromConstraintExpr(S, D, ACs[I].ConstraintExpr);
+    auto *Next = fromConstraintExpr(S, D, ACs[I].ConstraintExpr,
+                                    ACs[I].ArgPackSubstIndex);
     if (!Next)
       return nullptr;
     Conjunction = CompoundConstraint::CreateConjunction(S.getASTContext(),
@@ -1680,9 +1689,8 @@ NormalizedConstraint *NormalizedConstraint::fromAssociatedConstraints(
   return Conjunction;
 }
 
-NormalizedConstraint *
-NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
-                                         const Expr *E) {
+NormalizedConstraint *NormalizedConstraint::fromConstraintExpr(
+    Sema &S, const NamedDecl *D, const Expr *E, UnsignedOrNone SubstIndex) {
   assert(E != nullptr);
 
   // C++ [temp.constr.normal]p1.1
@@ -1703,10 +1711,10 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
   // See http://cplusplus.github.io/concepts-ts/ts-active.html#28
 
   if (LogicalBinOp BO = E) {
-    auto LHS = fromConstraintExpr(S, D, BO.getLHS());
+    auto *LHS = fromConstraintExpr(S, D, BO.getLHS(), SubstIndex);
     if (!LHS)
       return nullptr;
-    auto RHS = fromConstraintExpr(S, D, BO.getRHS());
+    auto *RHS = fromConstraintExpr(S, D, BO.getRHS(), SubstIndex);
     if (!RHS)
       return nullptr;
 
@@ -1734,7 +1742,7 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
       ConceptDecl *CD = CSE->getNamedConcept();
       SubNF = NormalizedConstraint::fromAssociatedConstraints(
           S, CSE->getNamedConcept(),
-          AssociatedConstraint(CD->getConstraintExpr()));
+          AssociatedConstraint(CD->getConstraintExpr(), SubstIndex));
 
       if (!SubNF)
         return nullptr;
@@ -1744,7 +1752,7 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
 
     return ConceptIdConstraint::Create(S.getASTContext(),
                                        CSE->getConceptReference(), SubNF, D,
-                                       S.ArgPackSubstIndex);
+                                       SubstIndex);
 
   } else if (auto *FE = dyn_cast<const CXXFoldExpr>(E);
              FE && S.getLangOpts().CPlusPlus26 &&
@@ -1759,8 +1767,8 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
             : FoldExpandedConstraint::FoldOperatorKind::Or;
 
     if (FE->getInit()) {
-      auto LHS = fromConstraintExpr(S, D, FE->getLHS());
-      auto RHS = fromConstraintExpr(S, D, FE->getRHS());
+      auto *LHS = fromConstraintExpr(S, D, FE->getLHS(), SubstIndex);
+      auto *RHS = fromConstraintExpr(S, D, FE->getRHS(), SubstIndex);
       if (!LHS || !RHS)
         return nullptr;
 
@@ -1777,13 +1785,13 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
                                                             : CCK_Disjunction),
           RHS);
     }
-    auto Sub = fromConstraintExpr(S, D, FE->getPattern());
+    auto *Sub = fromConstraintExpr(S, D, FE->getPattern(), SubstIndex);
     if (!Sub)
       return nullptr;
     return FoldExpandedConstraint::Create(S.getASTContext(), FE->getPattern(),
                                           Kind, Sub);
   }
-  return AtomicConstraint::Create(S.getASTContext(), E, D, S.ArgPackSubstIndex);
+  return AtomicConstraint::Create(S.getASTContext(), E, D, SubstIndex);
 }
 
 bool FoldExpandedConstraint::AreCompatibleForSubsumption(

clang/lib/Sema/SemaTemplate.cpp

@@ -1165,7 +1165,9 @@ static ExprResult formImmediatelyDeclaredConstraint(
   ExprResult ImmediatelyDeclaredConstraint = S.CheckConceptTemplateId(
       SS, /*TemplateKWLoc=*/SourceLocation(), NameInfo,
       /*FoundDecl=*/FoundDecl ? FoundDecl : NamedConcept, NamedConcept,
-      &ConstraintArgs);
+      &ConstraintArgs,
+      /*DoCheckConstraintSatisfaction=*/
+      !S.inParameterMappingSubstitution());
   if (ImmediatelyDeclaredConstraint.isInvalid() || !EllipsisLoc.isValid())
     return ImmediatelyDeclaredConstraint;
 
@@ -4742,7 +4744,7 @@ ExprResult Sema::CheckConceptTemplateId(
           *TemplateArgs, CTAI.CanonicalConverted);
   MultiLevelTemplateArgumentList MLTAL(NamedConcept, CTAI.CanonicalConverted,
                                        /*Final=*/false);
-      auto *CL = ConceptReference::Create(
+  auto *CL = ConceptReference::Create(
       Context,
       SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc{},
       TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,

clang/lib/Sema/SemaTemplateInstantiate.cpp

@@ -623,10 +623,15 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
     Inst.DeductionInfo = DeductionInfo;
     Inst.InstantiationRange = InstantiationRange;
     Inst.InConstraintSubstitution =
-        Inst.Kind == CodeSynthesisContext::ConstraintSubstitution;
-    if (!SemaRef.CodeSynthesisContexts.empty())
+        Inst.Kind == CodeSynthesisContext::ConstraintsCheck;
+    Inst.InParameterMappingSubstitution =
+        Inst.Kind == CodeSynthesisContext::ParameterMappingSubstitution;
+    if (!SemaRef.CodeSynthesisContexts.empty()) {
       Inst.InConstraintSubstitution |=
           SemaRef.CodeSynthesisContexts.back().InConstraintSubstitution;
+      Inst.InParameterMappingSubstitution |=
+          SemaRef.CodeSynthesisContexts.back().InParameterMappingSubstitution;
+    }
 
     SemaRef.pushCodeSynthesisContext(Inst);
 
@@ -2225,6 +2230,14 @@ TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
     // We're rewriting the template parameter as a reference to another
     // template parameter.
     Arg = getTemplateArgumentPackPatternForRewrite(Arg);
+    if (Arg.getKind() != TemplateArgument::Expression) {
+      assert(SemaRef.inParameterMappingSubstitution());
+      // FIXME: SourceLocation()?
+      ExprResult E = SemaRef.BuildExpressionFromNonTypeTemplateArgument(Arg, SourceLocation());
+      if (E.isInvalid())
+        return E;
+      Arg = TemplateArgument(E.get(), /*IsCanonical=*/false);
+    }
     assert(Arg.getKind() == TemplateArgument::Expression &&
            "unexpected nontype template argument kind in template rewrite");
     // FIXME: This can lead to the same subexpression appearing multiple times
@@ -3249,7 +3262,7 @@ bool Sema::SubstTypeConstraint(
   const ASTTemplateArgumentListInfo *TemplArgInfo =
       TC->getTemplateArgsAsWritten();
 
-  if (!EvaluateConstraints) {
+  if (!EvaluateConstraints && !inParameterMappingSubstitution()) {
     UnsignedOrNone Index = TC->getArgPackSubstIndex();
     if (!Index)
       Index = SemaRef.ArgPackSubstIndex;