[SILGen] InitAccessors: Extract emission of assign_or_init into a separate method

New method is going to be used to emit default value initializations
for user-defined constructors.

Author: xedin

lib/SILGen/SILGenFunction.cpp

@@ -1815,3 +1815,42 @@ SILGenFunction::emitApplyOfSetterToBase(SILLocation loc, SILDeclRef setter,
                            ParameterConvention::Direct_Guaranteed);
   return emitManagedRValueWithCleanup(setterPAI).getValue();
 }
+
+void SILGenFunction::emitAssignOrInit(SILLocation loc, ManagedValue selfValue,
+                                      VarDecl *field, ManagedValue newValue,
+                                      SubstitutionMap substitutions) {
+  auto fieldTy = field->getValueInterfaceType();
+  if (!substitutions.empty())
+    fieldTy = fieldTy.subst(substitutions);
+
+  // Emit the init accessor function partially applied to the base.
+  SILValue initFRef = emitGlobalFunctionRef(
+      loc, getAccessorDeclRef(field->getOpaqueAccessor(AccessorKind::Init)));
+  if (!substitutions.empty()) {
+    // If there are substitutions we need to emit partial apply to
+    // apply substitutions to the init accessor reference type.
+    auto initTy =
+        initFRef->getType().castTo<SILFunctionType>()->substGenericArgs(
+            SGM.M, substitutions, getTypeExpansionContext());
+
+    SILFunctionConventions setterConv(initTy, SGM.M);
+
+    // Emit partial apply without argument to produce a substituted
+    // init accessor reference.
+    PartialApplyInst *initPAI =
+        B.createPartialApply(loc, initFRef, substitutions, ArrayRef<SILValue>(),
+                             ParameterConvention::Direct_Guaranteed);
+    initFRef = emitManagedRValueWithCleanup(initPAI).getValue();
+  }
+
+  SILValue setterFRef;
+  if (auto *setter = field->getOpaqueAccessor(AccessorKind::Set)) {
+    setterFRef = emitApplyOfSetterToBase(loc, SILDeclRef(setter), selfValue,
+                                         substitutions);
+  } else {
+    setterFRef = SILUndef::get(initFRef->getType(), F);
+  }
+
+  B.createAssignOrInit(loc, selfValue.getValue(), newValue.forward(*this),
+                       initFRef, setterFRef, AssignOrInitInst::Unknown);
+}

lib/SILGen/SILGenFunction.h

@@ -818,6 +818,17 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                    ManagedValue base,
                                    SubstitutionMap substitutions);
 
+  /// Emit `assign_or_init` instruction that is going to either initialize
+  /// or assign the given value to the given field.
+  ///
+  /// \param loc The location to use for the instruction.
+  /// \param selfValue The 'self' value.
+  /// \param field The field to assign or initialize.
+  /// \param newValue the value to assign/initialize the field with.
+  /// \param substitutions The substitutions to apply to initializer and setter.
+  void emitAssignOrInit(SILLocation loc, ManagedValue selfValue, VarDecl *field,
+                        ManagedValue newValue, SubstitutionMap substitutions);
+
   /// Generates code to destroy the instance variables of a class.
   ///
   /// \param selfValue The 'self' value.

lib/SILGen/SILGenLValue.cpp

@@ -1522,24 +1522,10 @@ namespace {
     void set(SILGenFunction &SGF, SILLocation loc, ArgumentSource &&value,
              ManagedValue base) &&
         override {
-      auto *field = cast<VarDecl>(Storage);
-      // Emit the init accessor function partially applied to the base.
-      SILValue initFRef =
-          emitPartialInitAccessorReference(SGF, loc, getAccessorDecl());
-
-      SILValue setterFRef;
-      if (auto *setter = field->getOpaqueAccessor(AccessorKind::Set)) {
-        setterFRef = SGF.emitApplyOfSetterToBase(loc, SILDeclRef(setter), base,
-                                                 Substitutions);
-      } else {
-        setterFRef = SILUndef::get(initFRef->getType(), SGF.F);
-      }
-
+      VarDecl *field = cast<VarDecl>(Storage);
       auto Mval =
           emitValue(SGF, loc, field, std::move(value), AccessorKind::Init);
-
-      SGF.B.createAssignOrInit(loc, base.getValue(), Mval.forward(SGF),
-                               initFRef, setterFRef, AssignOrInitInst::Unknown);
+      SGF.emitAssignOrInit(loc, base, field, Mval, Substitutions);
     }
 
     RValue get(SILGenFunction &SGF, SILLocation loc, ManagedValue base,
@@ -1567,33 +1553,6 @@ namespace {
                            Indices.isNull() ? nullptr : &Indices,
                            ArgListForDiagnostics};
     }
-
-  private:
-    SILValue emitPartialInitAccessorReference(SILGenFunction &SGF,
-                                              SILLocation loc,
-                                              AccessorDecl *initAccessor) {
-      assert(initAccessor->isInitAccessor());
-      auto initConstant = SGF.getAccessorDeclRef(initAccessor);
-      SILValue initFRef = SGF.emitGlobalFunctionRef(loc, initConstant);
-
-      // If there are no substitutions there is no need to emit partial
-      // apply.
-      if (Substitutions.empty())
-        return initFRef;
-
-      CanSILFunctionType initTy =
-          initFRef->getType().castTo<SILFunctionType>()->substGenericArgs(
-              SGF.SGM.M, Substitutions, SGF.getTypeExpansionContext());
-
-      SILFunctionConventions setterConv(initTy, SGF.SGM.M);
-
-      // Emit partial apply without argument to produce a substituted
-      // init accessor reference.
-      PartialApplyInst *initPAI = SGF.B.createPartialApply(
-          loc, initFRef, Substitutions, ArrayRef<SILValue>(),
-          ParameterConvention::Direct_Guaranteed);
-      return SGF.emitManagedRValueWithCleanup(initPAI).getValue();
-    }
   };
 
   class GetterSetterComponent