Instantiate function parameters as needed

zyn0217 · zyn0217 · commit bb31d36a92fb · 2024-08-17T22:25:54.000+08:00
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
@@ -14450,6 +14450,11 @@ class Sema final : public SemaBase {
       ArrayRef<TemplateArgument> TemplateArgs,
       ConstraintSatisfaction &Satisfaction);
 
+  bool CheckFunctionConstraintsWithoutInstantiation(
+      SourceLocation PointOfInstantiation, FunctionTemplateDecl *Template,
+      ArrayRef<TemplateArgument> TemplateArgs,
+      ConstraintSatisfaction &Satisfaction);
+
   /// \brief Emit diagnostics explaining why a constraint expression was deemed
   /// unsatisfied.
   /// \param First whether this is the first time an unsatisfied constraint is
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
@@ -461,13 +461,17 @@ static ExprResult calculateConstraintSatisfaction(
           return ExprError();
 
         llvm::FoldingSetNodeID ID;
+        // llvm::errs() << "Preparing for checking " << Template << "\n";
         if (Template &&
             DiagRecursiveConstraintEval(S, ID, Template, AtomicExpr, MLTAL)) {
+          // Template->dump();
           Satisfaction.IsSatisfied = false;
           Satisfaction.ContainsErrors = true;
+          // __builtin_trap();
           return ExprEmpty();
         }
 
+        // llvm::errs() << "Pushing " << Template << "\n";
         SatisfactionStackRAII StackRAII(S, Template, ID);
 
         // We do not want error diagnostics escaping here.
@@ -1122,6 +1126,139 @@ bool Sema::CheckInstantiatedFunctionTemplateConstraints(
                                      PointOfInstantiation, Satisfaction);
 }
 
+namespace {
+
+// We employ a TreeTransform because RAV couldn't recurse into a bunch of
+// Exprs e.g. SizeOfPackExpr, CXXFoldExpr, etc.
+// FIXME: Could we do the Decl instantiation as we substitute into
+// the constraint expressions?
+class InstantiateReferencedParameter
+    : public TreeTransform<InstantiateReferencedParameter> {
+  const MultiLevelTemplateArgumentList &TemplateArgs;
+
+  DeclContext *FunctionDC;
+
+  using inherited = TreeTransform<InstantiateReferencedParameter>;
+
+  bool instantiateParameterToScope(ParmVarDecl *OldParm,
+                                   LocalInstantiationScope &Scope) {
+    // Current context might have been changed by lambda expressions. So resume
+    // it before we substitute parameters.
+    Sema::ContextRAII Context(SemaRef, FunctionDC);
+    std::optional<unsigned> NumExpansions;
+    ParmVarDecl *NewParm = nullptr;
+    unsigned IndexAdjustment = 0;
+    if (OldParm->isParameterPack()) {
+      SmallVector<UnexpandedParameterPack, 2> Unexpanded;
+      TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
+      PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>();
+      TypeLoc Pattern = ExpansionTL.getPatternLoc();
+      SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
+
+      assert(!Unexpanded.empty() &&
+             "A pack Decl doesn't contain anything unexpanded?");
+
+      bool ShouldExpand = false;
+      bool RetainExpansion = false;
+      std::optional<unsigned> OrigNumExpansions =
+          ExpansionTL.getTypePtr()->getNumExpansions();
+      NumExpansions = OrigNumExpansions;
+      if (SemaRef.CheckParameterPacksForExpansion(
+              ExpansionTL.getEllipsisLoc(), Pattern.getSourceRange(),
+              Unexpanded, TemplateArgs, ShouldExpand, RetainExpansion,
+              NumExpansions))
+        return true;
+
+      assert(ShouldExpand && !RetainExpansion &&
+             "Shouldn't retain an expansion here!");
+      Scope.MakeInstantiatedLocalArgPack(OldParm);
+
+      for (unsigned I = 0; I != *NumExpansions; ++I) {
+        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
+        ParmVarDecl *NewParm = SemaRef.SubstParmVarDecl(
+            OldParm, TemplateArgs, /*indexAdjustment=*/IndexAdjustment++,
+            NumExpansions, /*ExpectParameterPack=*/false,
+            /*EvaluateConstraints=*/false);
+        if (!NewParm)
+          return true;
+      }
+
+      return false;
+    }
+    NewParm = SemaRef.SubstParmVarDecl(OldParm, TemplateArgs,
+                                       /*indexAdjustment=*/IndexAdjustment,
+                                       std::nullopt,
+                                       /*ExpectParameterPack=*/false);
+    if (!NewParm)
+      return true;
+    Scope.InstantiatedLocal(OldParm, NewParm);
+    return false;
+  }
+
+public:
+  InstantiateReferencedParameter(
+      Sema &SemaRef, const MultiLevelTemplateArgumentList &TemplateArgs,
+      DeclContext *FunctionDC)
+      : inherited(SemaRef), TemplateArgs(TemplateArgs), FunctionDC(FunctionDC) {
+  }
+
+  Decl *TransformDecl(SourceLocation Loc, Decl *D) {
+    if (auto *PVD = dyn_cast<ParmVarDecl>(D))
+      instantiateParameterToScope(PVD, *SemaRef.CurrentInstantiationScope);
+    return D;
+  }
+
+  void TraverseConstraintExprs(ArrayRef<const Expr *> Exprs) {
+    for (auto *E : Exprs)
+      TransformExpr(const_cast<Expr *>(E));
+  }
+};
+
+} // namespace
+
+bool Sema::CheckFunctionConstraintsWithoutInstantiation(
+    SourceLocation PointOfInstantiation, FunctionTemplateDecl *Template,
+    ArrayRef<TemplateArgument> TemplateArgs,
+    ConstraintSatisfaction &Satisfaction) {
+  FunctionDecl *FD = Template->getTemplatedDecl();
+  SmallVector<const Expr *, 3> TemplateAC;
+  Template->getAssociatedConstraints(TemplateAC);
+  if (TemplateAC.empty()) {
+    Satisfaction.IsSatisfied = true;
+    return false;
+  }
+
+  // Enter the scope of this instantiation. We don't use
+  // PushDeclContext because we don't have a scope.
+  LocalInstantiationScope Scope(*this);
+
+  // 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.
+  DeclContext *NextDC = FD->getFriendObjectKind() ? FD->getLexicalDeclContext()
+                                                  : FD->getDeclContext();
+  MultiLevelTemplateArgumentList MLTAL =
+      getTemplateInstantiationArgs(FD, NextDC,
+                                   /*Final=*/false,
+                                   /*Innermost=*/TemplateArgs,
+                                   /*RelativeToPrimary=*/true,
+                                   /*Pattern=*/nullptr,
+                                   /*ForConstraintInstantiation=*/true);
+
+  InstantiateReferencedParameter(*this, MLTAL, FD)
+      .TraverseConstraintExprs(TemplateAC);
+
+  Qualifiers ThisQuals;
+  CXXRecordDecl *Record = nullptr;
+  if (auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
+    ThisQuals = Method->getMethodQualifiers();
+    Record = Method->getParent();
+  }
+  CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
+  return CheckConstraintSatisfaction(Template, TemplateAC, MLTAL,
+                                     PointOfInstantiation, Satisfaction);
+}
+
 static void diagnoseUnsatisfiedRequirement(Sema &S,
                                            concepts::ExprRequirement *Req,
                                            bool First) {
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -3863,72 +3863,28 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
     FD = const_cast<FunctionDecl *>(FDFriend);
     Owner = FD->getLexicalDeclContext();
   }
+
   // [DR2369]
   // FIXME: We have to partially instantiate lambda's captures for constraint
   // evaluation.
-  if (!isLambdaCallOperator(FD) && !isLambdaConversionOperator(FD) &&
-      (!PartialOverloading ||
-       (CanonicalBuilder.size() ==
-        FunctionTemplate->getTemplateParameters()->size()))) {
-    FunctionTemplateDecl *Template = FunctionTemplate->getCanonicalDecl();
-    FunctionDecl *FD = Template->getTemplatedDecl();
-    SmallVector<const Expr *, 3> TemplateAC;
-    Template->getAssociatedConstraints(TemplateAC);
-    if (!TemplateAC.empty()) {
-
-      // Enter the scope of this instantiation. We don't use
-      // PushDeclContext because we don't have a scope.
-      LocalInstantiationScope Scope(*this);
-
-      // 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.
-
-      MultiLevelTemplateArgumentList MLTAL(FD, SugaredBuilder, /*Final=*/false);
-      getTemplateInstantiationArgs(nullptr, FD->getLexicalDeclContext(),
-                                   /*Final=*/false,
-                                   /*Innermost=*/std::nullopt,
-                                   /*RelativeToPrimary=*/true,
-                                   /*Pattern=*/nullptr,
-                                   /*ForConstraintInstantiation=*/true,
-                                   /*SkipForSpecialization=*/false,
-                                   /*Merged=*/&MLTAL);
-
-      MultiLevelTemplateArgumentList JustTemplArgs(
-          Template, CanonicalDeducedArgumentList->asArray(),
-          /*Final=*/false);
-      if (addInstantiatedParametersToScope(nullptr, FD, Scope, JustTemplArgs))
-        return TemplateDeductionResult::MiscellaneousDeductionFailure;
-
-      if (FunctionTemplateDecl *FromMemTempl =
-              Template->getInstantiatedFromMemberTemplate()) {
-        while (FromMemTempl->getInstantiatedFromMemberTemplate())
-          FromMemTempl = FromMemTempl->getInstantiatedFromMemberTemplate();
-        if (addInstantiatedParametersToScope(
-                nullptr, FromMemTempl->getTemplatedDecl(), Scope, MLTAL))
-          return TemplateDeductionResult::MiscellaneousDeductionFailure;
-      }
-
-      Qualifiers ThisQuals;
-      CXXRecordDecl *Record = nullptr;
-      if (auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
-        ThisQuals = Method->getMethodQualifiers();
-        Record = Method->getParent();
-      }
-      CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
-      llvm::SmallVector<Expr *, 1> Converted;
-      if (CheckConstraintSatisfaction(Template, TemplateAC, MLTAL,
-                                      Info.getLocation(),
-                                      Info.AssociatedConstraintsSatisfaction))
-        return TemplateDeductionResult::MiscellaneousDeductionFailure;
-      if (!Info.AssociatedConstraintsSatisfaction.IsSatisfied) {
-        Info.reset(TemplateArgumentList::CreateCopy(Context, SugaredBuilder),
-                   Info.takeCanonical());
-        return TemplateDeductionResult::ConstraintsNotSatisfied;
-      }
+  bool NeedConstraintChecking =
+      !PartialOverloading ||
+      CanonicalBuilder.size() ==
+          FunctionTemplate->getTemplateParameters()->size();
+  bool IsLambda = isLambdaCallOperator(FD) || isLambdaConversionOperator(FD);
+#if 1
+  if (!IsLambda && NeedConstraintChecking) {
+    if (CheckFunctionConstraintsWithoutInstantiation(
+            Info.getLocation(), FunctionTemplate->getCanonicalDecl(),
+            CanonicalBuilder, Info.AssociatedConstraintsSatisfaction))
+      return TemplateDeductionResult::MiscellaneousDeductionFailure;
+    if (!Info.AssociatedConstraintsSatisfaction.IsSatisfied) {
+      Info.reset(Info.takeSugared(),
+                 TemplateArgumentList::CreateCopy(Context, CanonicalBuilder));
+      return TemplateDeductionResult::ConstraintsNotSatisfied;
     }
   }
-
+#endif
   // C++ [temp.deduct.call]p10: [DR1391]
   //   If deduction succeeds for all parameters that contain
   //   template-parameters that participate in template argument deduction,
@@ -3975,9 +3931,7 @@ 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 (!PartialOverloading ||
-      (CanonicalBuilder.size() ==
-       FunctionTemplate->getTemplateParameters()->size())) {
+  if (IsLambda && NeedConstraintChecking) {
     if (CheckInstantiatedFunctionTemplateConstraints(
             Info.getLocation(), Specialization, CanonicalBuilder,
             Info.AssociatedConstraintsSatisfaction))
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -34,6 +34,7 @@
 #include "clang/Sema/SemaSwift.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateInstCallback.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/TimeProfiler.h"
 #include <optional>
 
@@ -2136,7 +2137,7 @@ Decl *TemplateDeclInstantiator::VisitFunctionDecl(
     return nullptr;
   QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
 
-  if (TemplateParams && TemplateParams->size()) {
+  if (false && TemplateParams && TemplateParams->size()) {
     auto *LastParam =
         dyn_cast<TemplateTypeParmDecl>(TemplateParams->asArray().back());
     if (LastParam && LastParam->isImplicit() &&
@@ -2548,7 +2549,7 @@ Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(
     return nullptr;
   QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
 
-  if (TemplateParams && TemplateParams->size()) {
+  if (false && TemplateParams && TemplateParams->size()) {
     auto *LastParam =
         dyn_cast<TemplateTypeParmDecl>(TemplateParams->asArray().back());
     if (LastParam && LastParam->isImplicit() &&
@@ -4577,17 +4578,17 @@ void Sema::addInstantiatedLocalVarsToScope(FunctionDecl *Function,
   }
 }
 
-static bool addInstantiatedParametersToScope(
-    Sema &SemaRef, MutableArrayRef<ParmVarDecl *> InstantiatedParamDecls,
-    const FunctionDecl *PatternDecl, LocalInstantiationScope &Scope,
+bool Sema::addInstantiatedParametersToScope(
+    FunctionDecl *Function, const FunctionDecl *PatternDecl,
+    LocalInstantiationScope &Scope,
     const MultiLevelTemplateArgumentList &TemplateArgs) {
   unsigned FParamIdx = 0;
   for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
     const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
     if (!PatternParam->isParameterPack()) {
       // Simple case: not a parameter pack.
-      assert(FParamIdx < InstantiatedParamDecls.size());
-      ParmVarDecl *FunctionParam = InstantiatedParamDecls[FParamIdx];
+      assert(FParamIdx < Function->getNumParams());
+      ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
       FunctionParam->setDeclName(PatternParam->getDeclName());
       // If the parameter's type is not dependent, update it to match the type
       // in the pattern. They can differ in top-level cv-qualifiers, and we want
@@ -4596,9 +4597,9 @@ static bool addInstantiatedParametersToScope(
       // it's instantiation-dependent.
       // FIXME: Updating the type to work around this is at best fragile.
       if (!PatternDecl->getType()->isDependentType()) {
-        QualType T = SemaRef.SubstType(PatternParam->getType(), TemplateArgs,
-                                       FunctionParam->getLocation(),
-                                       FunctionParam->getDeclName());
+        QualType T = SubstType(PatternParam->getType(), TemplateArgs,
+                               FunctionParam->getLocation(),
+                               FunctionParam->getDeclName());
         if (T.isNull())
           return true;
         FunctionParam->setType(T);
@@ -4612,19 +4613,18 @@ static bool addInstantiatedParametersToScope(
     // Expand the parameter pack.
     Scope.MakeInstantiatedLocalArgPack(PatternParam);
     std::optional<unsigned> NumArgumentsInExpansion =
-        SemaRef.getNumArgumentsInExpansion(PatternParam->getType(),
-                                           TemplateArgs);
+        getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
     if (NumArgumentsInExpansion) {
       QualType PatternType =
           PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
       for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
-        ParmVarDecl *FunctionParam = InstantiatedParamDecls[FParamIdx];
+        ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
         FunctionParam->setDeclName(PatternParam->getDeclName());
         if (!PatternDecl->getType()->isDependentType()) {
-          Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, Arg);
-          QualType T = SemaRef.SubstType(PatternType, TemplateArgs,
-                                         FunctionParam->getLocation(),
-                                         FunctionParam->getDeclName());
+          Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, Arg);
+          QualType T =
+              SubstType(PatternType, TemplateArgs, FunctionParam->getLocation(),
+                        FunctionParam->getDeclName());
           if (T.isNull())
             return true;
           FunctionParam->setType(T);
@@ -4639,25 +4639,6 @@ static bool addInstantiatedParametersToScope(
   return false;
 }
 
-bool Sema::addInstantiatedParametersToScope(
-    FunctionDecl *Function, const FunctionDecl *PatternDecl,
-    LocalInstantiationScope &Scope,
-    const MultiLevelTemplateArgumentList &TemplateArgs) {
-  if (Function)
-    return ::addInstantiatedParametersToScope(*this, Function->parameters(),
-                                              PatternDecl, Scope, TemplateArgs);
-  FunctionTypeLoc TypeLoc = PatternDecl->getFunctionTypeLoc();
-  assert(!TypeLoc.isNull() && "Invalid function TypeLoc?");
-  SmallVector<QualType> ParamTypes;
-  SmallVector<ParmVarDecl *> OutParams;
-  Sema::ExtParameterInfoBuilder ExtParamInfos;
-  if (SubstParmTypes(PatternDecl->getLocation(), TypeLoc.getParams(), nullptr,
-                     TemplateArgs, ParamTypes, &OutParams, ExtParamInfos))
-    return true;
-  return ::addInstantiatedParametersToScope(*this, OutParams, PatternDecl,
-                                            Scope, TemplateArgs);
-}
-
 bool Sema::InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
                                       ParmVarDecl *Param) {
   assert(Param->hasUninstantiatedDefaultArg());
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
@@ -713,7 +713,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/libcxx/include/__chrono/leap_second.h b/libcxx/include/__chrono/leap_second.h
