Merge pull request swiftlang#28137 from ravikandhadai/constexpr-closure-subst-map

Author: swift-ci

include/swift/SIL/SILConstants.h

@@ -18,10 +18,10 @@
 #ifndef SWIFT_SIL_CONSTANTS_H
 #define SWIFT_SIL_CONSTANTS_H
 
+#include "swift/AST/SubstitutionMap.h"
 #include "swift/SIL/SILValue.h"
 #include "llvm/Support/CommandLine.h"
 
-
 namespace swift {
 class SingleValueInstruction;
 class SILValue;
@@ -572,6 +572,7 @@ class SymbolicValue {
   static SymbolicValue makeClosure(
       SILFunction *target,
       ArrayRef<std::pair<SILValue, Optional<SymbolicValue>>> capturedArguments,
+      SubstitutionMap substMap, SILType closureType,
       SymbolicValueAllocator &allocator);
 
   SymbolicClosure *getClosure() const {
@@ -680,19 +681,29 @@ struct SymbolicClosure final
   // The number of SIL values captured by the closure.
   unsigned numCaptures;
 
-  // True iff there exists captured arguments whose constant value is not known.
+  // True iff there exists a captured argument whose constant value is not
+  // known.
   bool hasNonConstantCaptures = true;
 
+  // A substitution map that partially maps the generic paramters of the
+  // applied function to the generic arguments of passed to the call.
+  SubstitutionMap substitutionMap;
+
+  SILType closureType;
+
   SymbolicClosure() = delete;
   SymbolicClosure(const SymbolicClosure &) = delete;
   SymbolicClosure(SILFunction *callee, unsigned numArguments,
+                  SubstitutionMap substMap, SILType closureType,
                   bool nonConstantCaptures)
       : target(callee), numCaptures(numArguments),
-        hasNonConstantCaptures(nonConstantCaptures) {}
+        hasNonConstantCaptures(nonConstantCaptures), substitutionMap(substMap),
+        closureType(closureType) {}
 
 public:
   static SymbolicClosure *create(SILFunction *callee,
                                  ArrayRef<SymbolicClosureArgument> args,
+                                 SubstitutionMap substMap, SILType closureType,
                                  SymbolicValueAllocator &allocator);
 
   ArrayRef<SymbolicClosureArgument> getCaptures() const {
@@ -707,6 +718,10 @@ struct SymbolicClosure final
   SILFunction *getTarget() {
     return target;
   }
+
+  SILType getClosureType() { return closureType; }
+
+  SubstitutionMap getCallSubstitutionMap() { return substitutionMap; }
 };
 
 } // end namespace swift

lib/SIL/SILConstants.cpp

@@ -247,7 +247,9 @@ SymbolicValue::cloneInto(SymbolicValueAllocator &allocator) const {
   case RK_Closure: {
     SymbolicClosure *clo = getClosure();
     ArrayRef<SymbolicClosureArgument> closureArgs = clo->getCaptures();
-    return SymbolicValue::makeClosure(clo->getTarget(), closureArgs, allocator);
+    return SymbolicValue::makeClosure(clo->getTarget(), closureArgs,
+                                      clo->getCallSubstitutionMap(),
+                                      clo->getClosureType(), allocator);
   }
   }
   llvm_unreachable("covered switch");
@@ -744,8 +746,11 @@ Type SymbolicValue::getArrayType() const {
 
 SymbolicValue SymbolicValue::makeClosure(SILFunction *target,
                                          ArrayRef<SymbolicClosureArgument> args,
+                                         SubstitutionMap substMap,
+                                         SILType closureType,
                                          SymbolicValueAllocator &allocator) {
-  auto clo = SymbolicClosure::create(target, args, allocator);
+  auto clo =
+      SymbolicClosure::create(target, args, substMap, closureType, allocator);
   SymbolicValue result;
   result.representationKind = RK_Closure;
   result.value.closure = clo;
@@ -754,6 +759,8 @@ SymbolicValue SymbolicValue::makeClosure(SILFunction *target,
 
 SymbolicClosure *SymbolicClosure::create(SILFunction *target,
                                          ArrayRef<SymbolicClosureArgument> args,
+                                         SubstitutionMap substMap,
+                                         SILType closureType,
                                          SymbolicValueAllocator &allocator) {
   // Determine whether there are captured arguments without a symbolic value.
   bool hasNonConstantCapture = false;
@@ -768,8 +775,8 @@ SymbolicClosure *SymbolicClosure::create(SILFunction *target,
       SymbolicClosure::totalSizeToAlloc<SymbolicClosureArgument>(args.size());
   auto rawMem = allocator.allocate(byteSizeOfArgs, alignof(SymbolicClosure));
   //  Placement initialize the object.
-  auto closure = ::new (rawMem)
-      SymbolicClosure(target, args.size(), hasNonConstantCapture);
+  auto closure = ::new (rawMem) SymbolicClosure(
+      target, args.size(), substMap, closureType, hasNonConstantCapture);
   std::uninitialized_copy(
       args.begin(), args.end(),
       closure->getTrailingObjects<SymbolicClosureArgument>());

lib/SILOptimizer/Utils/ConstExpr.cpp

@@ -1590,6 +1590,10 @@ llvm::Optional<SymbolicValue> ConstExprFunctionState::evaluateClosureCreation(
 
   SmallVector<SymbolicClosureArgument, 4> captures;
 
+  // Map generic parameters of the target to the generic arguments passed to the
+  // call.
+  SubstitutionMap callSubstMap;
+
   // If this is a partial-apply instruction, arguments to this partial-apply
   // instruction are the captures of the closure.
   if (PartialApplyInst *papply = dyn_cast<PartialApplyInst>(closureInst)) {
@@ -1601,10 +1605,13 @@ llvm::Optional<SymbolicValue> ConstExprFunctionState::evaluateClosureCreation(
       }
       captures.push_back({capturedSILValue, capturedSymbolicValue});
     }
+    callSubstMap = papply->getSubstitutionMap().subst(this->substitutionMap);
   }
 
-  auto closureVal =
-      SymbolicValue::makeClosure(target, captures, evaluator.getAllocator());
+  SILType closureType = closureInst->getType();
+  assert(closureType.is<SILFunctionType>());
+  auto closureVal = SymbolicValue::makeClosure(
+      target, captures, callSubstMap, closureType, evaluator.getAllocator());
   setValue(closureInst, closureVal);
   return None;
 }