[Constant Evaluator] Make symbolic closures, which are representations

of closure literals in the constant evaluator, store the
substitution map that was in the constant evaluator state when
the closure creation site (partial_apply or thin_to_thick_function)
that created the symbolic closure was evaluated.

A substitution map is a mapping from generic type parameters to types.
This map is updated and maintained by the constant evaluator as it
evaluates function calls. At a partial-application site, the substitution
map captures the mapping from the types of the captured arguments (which
could be generic types) to the types of the symbolic value they represent
(which has to be concrete types). The substitution map would be necessary
to fold the symbolic closure into SIL code that constructs the closure
it represents.

Author: ravikandhadai

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;
 }