[SILGen] NFC: Extract application of setter to base into a method on SILGenFunction

This is a preliminary step towards enabling default initialization of
init accessor properties in user-defined initializers because this logic
would have to be shared by multiple places during SILGen.

Author: xedin

lib/SILGen/SILGenFunction.cpp

@@ -1754,3 +1754,73 @@ ParamDecl *SILGenFunction::isMappedToInitAccessorArgument(VarDecl *property) {
 
   return arg->second;
 }
+
+std::pair<SILValue, CanSILFunctionType>
+SILGenFunction::emitApplyOfSetterToBase(SILLocation loc, SILDeclRef setter,
+                                        ManagedValue base,
+                                        SubstitutionMap substitutions) {
+  auto setterFRef = [&]() -> SILValue {
+    auto setterInfo = getConstantInfo(getTypeExpansionContext(), setter);
+    if (setter.hasDecl() && setter.getDecl()->shouldUseObjCDispatch()) {
+      // Emit a thunk we might have to bridge arguments.
+      auto foreignSetterThunk = setter.asForeign(false);
+      return emitDynamicMethodRef(
+                 loc, foreignSetterThunk,
+                 SGM.Types
+                     .getConstantInfo(getTypeExpansionContext(),
+                                      foreignSetterThunk)
+                     .SILFnType)
+          .getValue();
+    }
+
+    return emitGlobalFunctionRef(loc, setter, setterInfo);
+  }();
+
+  auto getSetterType = [&](SILValue setterFRef) {
+    CanSILFunctionType setterTy =
+        setterFRef->getType().castTo<SILFunctionType>();
+    return setterTy->substGenericArgs(SGM.M, substitutions,
+                                      getTypeExpansionContext());
+  };
+
+  auto setterTy = getSetterType(setterFRef);
+  SILFunctionConventions setterConv(setterTy, SGM.M);
+
+  // Emit captures for the setter
+  SmallVector<SILValue, 4> capturedArgs;
+  auto captureInfo = SGM.Types.getLoweredLocalCaptures(setter);
+  if (!captureInfo.getCaptures().empty()) {
+    SmallVector<ManagedValue, 4> captures;
+    emitCaptures(loc, setter, CaptureEmission::AssignByWrapper, captures);
+
+    for (auto capture : captures)
+      capturedArgs.push_back(capture.forward(*this));
+  } else {
+    assert(base);
+
+    SILValue capturedBase;
+    unsigned argIdx = setterConv.getNumSILArguments() - 1;
+
+    if (setterConv.getSILArgumentConvention(argIdx).isInoutConvention()) {
+      capturedBase = base.getValue();
+    } else if (base.getType().isAddress() &&
+               base.getType().getObjectType() ==
+                   setterConv.getSILArgumentType(argIdx,
+                                                 getTypeExpansionContext())) {
+      // If the base is a reference and the setter expects a value, emit a
+      // load. This pattern is emitted for property wrappers with a
+      // nonmutating setter, for example.
+      capturedBase = B.createTrivialLoadOr(loc, base.getValue(),
+                                           LoadOwnershipQualifier::Copy);
+    } else {
+      capturedBase = base.copy(*this, loc).forward(*this);
+    }
+
+    capturedArgs.push_back(capturedBase);
+  }
+
+  PartialApplyInst *setterPAI =
+      B.createPartialApply(loc, setterFRef, substitutions, capturedArgs,
+                           ParameterConvention::Direct_Guaranteed);
+  return {emitManagedRValueWithCleanup(setterPAI).getValue(), setterTy};
+}

lib/SILGen/SILGenFunction.h

@@ -814,6 +814,11 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// value assignment.
   void emitInitAccessor(AccessorDecl *accessor);
 
+  /// Generates code to emit the given setter reference to the given base value.
+  std::pair<SILValue, CanSILFunctionType>
+  emitApplyOfSetterToBase(SILLocation loc, SILDeclRef setter, ManagedValue base,
+                          SubstitutionMap substitutions);
+
   /// Generates code to destroy the instance variables of a class.
   ///
   /// \param selfValue The 'self' value.

lib/SILGen/SILGenLValue.cpp

@@ -1477,78 +1477,6 @@ namespace {
 
       return Mval;
     }
-
-    std::pair<SILValue, CanSILFunctionType>
-    applySetterToBase(SILGenFunction &SGF, SILLocation loc, SILDeclRef setter,
-                      ManagedValue base) const {
-      auto setterFRef = [&]() -> SILValue {
-        auto setterInfo =
-            SGF.getConstantInfo(SGF.getTypeExpansionContext(), setter);
-        if (setter.hasDecl() && setter.getDecl()->shouldUseObjCDispatch()) {
-          // Emit a thunk we might have to bridge arguments.
-          auto foreignSetterThunk = setter.asForeign(false);
-          return SGF
-              .emitDynamicMethodRef(
-                  loc, foreignSetterThunk,
-                  SGF.SGM.Types
-                      .getConstantInfo(SGF.getTypeExpansionContext(),
-                                       foreignSetterThunk)
-                      .SILFnType)
-              .getValue();
-        }
-
-        return SGF.emitGlobalFunctionRef(loc, setter, setterInfo);
-      }();
-
-      auto getSetterType = [&](SILValue setterFRef) {
-        CanSILFunctionType setterTy =
-            setterFRef->getType().castTo<SILFunctionType>();
-        return setterTy->substGenericArgs(SGF.SGM.M, Substitutions,
-                                          SGF.getTypeExpansionContext());
-      };
-
-      auto setterTy = getSetterType(setterFRef);
-      SILFunctionConventions setterConv(setterTy, SGF.SGM.M);
-
-      // Emit captures for the setter
-      SmallVector<SILValue, 4> capturedArgs;
-      auto captureInfo = SGF.SGM.Types.getLoweredLocalCaptures(setter);
-      if (!captureInfo.getCaptures().empty()) {
-        SmallVector<ManagedValue, 4> captures;
-        SGF.emitCaptures(loc, setter, CaptureEmission::AssignByWrapper,
-                         captures);
-
-        for (auto capture : captures)
-          capturedArgs.push_back(capture.forward(SGF));
-      } else {
-        assert(base);
-
-        SILValue capturedBase;
-        unsigned argIdx = setterConv.getNumSILArguments() - 1;
-
-        if (setterConv.getSILArgumentConvention(argIdx).isInoutConvention()) {
-          capturedBase = base.getValue();
-        } else if (base.getType().isAddress() &&
-                   base.getType().getObjectType() ==
-                       setterConv.getSILArgumentType(
-                           argIdx, SGF.getTypeExpansionContext())) {
-          // If the base is a reference and the setter expects a value, emit a
-          // load. This pattern is emitted for property wrappers with a
-          // nonmutating setter, for example.
-          capturedBase = SGF.B.createTrivialLoadOr(
-              loc, base.getValue(), LoadOwnershipQualifier::Copy);
-        } else {
-          capturedBase = base.copy(SGF, loc).forward(SGF);
-        }
-
-        capturedArgs.push_back(capturedBase);
-      }
-
-      PartialApplyInst *setterPAI =
-          SGF.B.createPartialApply(loc, setterFRef, Substitutions, capturedArgs,
-                                   ParameterConvention::Direct_Guaranteed);
-      return {SGF.emitManagedRValueWithCleanup(setterPAI).getValue(), setterTy};
-    }
   };
 
   class InitAccessorComponent
@@ -1593,8 +1521,8 @@ namespace {
       CanSILFunctionType setterTy;
 
       if (auto *setter = field->getOpaqueAccessor(AccessorKind::Set)) {
-        std::tie(setterFRef, setterTy) =
-            applySetterToBase(SGF, loc, SILDeclRef(setter), base);
+        std::tie(setterFRef, setterTy) = SGF.emitApplyOfSetterToBase(
+            loc, SILDeclRef(setter), base, Substitutions);
       } else {
         setterFRef = SILUndef::get(initFRef->getType(), SGF.F);
         setterTy = initFRef->getType().castTo<SILFunctionType>();
@@ -1897,7 +1825,7 @@ namespace {
         SILValue setterFn;
         CanSILFunctionType setterTy;
         std::tie(setterFn, setterTy) =
-            applySetterToBase(SGF, loc, Accessor, base);
+            SGF.emitApplyOfSetterToBase(loc, Accessor, base, Substitutions);
 
         // Create the assign_by_wrapper with the initializer and setter.