[SILGen] InitAccessors: Start supporting assign_or_init for properties without a setter

Implement "init accessor" component emission which is paired with
"init accessor" write strategy. Use `SILUndef` for a "setter" operand
of an "assign_or_init" instruction in cases when property with init
accessor doesn't have a setter. DI would detect re-initialization
attempts to produce diagnostics.

Author: xedin

lib/SIL/Verifier/SILVerifier.cpp

@@ -2737,6 +2737,9 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       checkAssigOrInitInstAccessorArgs(Src->getType(), initConv);
     }
 
+    if (isa<SILUndef>(setterFn))
+      return;
+
     // Check setter - it's a partially applied reference which takes
     // `initialValue`.
     CanSILFunctionType setterTy = setterFn->getType().castTo<SILFunctionType>();

lib/SILGen/SILGenLValue.cpp

@@ -1560,7 +1560,7 @@ namespace {
                           ArgumentList *subscriptArgList,
                           PreparedArguments &&indices,
                           bool isOnSelfParameter,
-                          Optional<ActorIsolation> actorIso)
+                          llvm::Optional<ActorIsolation> actorIso)
         : AccessorBasedComponent(
               InitAccessorKind, decl, accessor, isSuper, isDirectAccessorUse,
               substitutions, baseFormalType, typeData, subscriptArgList,
@@ -1587,9 +1587,14 @@ namespace {
 
       SILValue setterFRef;
       CanSILFunctionType setterTy;
-      std::tie(setterFRef, setterTy) = applySetterToBase(
-          SGF, loc, SILDeclRef(field->getOpaqueAccessor(AccessorKind::Set)),
-          base);
+
+      if (auto *setter = field->getOpaqueAccessor(AccessorKind::Set)) {
+        std::tie(setterFRef, setterTy) =
+            applySetterToBase(SGF, loc, SILDeclRef(setter), base);
+      } else {
+        setterFRef = SILUndef::get(initFRef->getType(), SGF.F);
+        setterTy = initFRef->getType().castTo<SILFunctionType>();
+      }
 
       auto Mval =
           emitValue(SGF, loc, field, fieldType, std::move(value), setterTy);
@@ -1618,7 +1623,7 @@ namespace {
     /// the same dynamic PathComponent type as the receiver) to see if they are
     /// identical.  If so, there is a conflicting writeback happening, so emit a
     /// diagnostic.
-    Optional<AccessStorage> getAccessStorage() const override {
+    llvm::Optional<AccessStorage> getAccessStorage() const override {
       return AccessStorage{Storage, IsSuper,
                            Indices.isNull() ? nullptr : &Indices,
                            ArgListForDiagnostics};
@@ -3095,8 +3100,12 @@ namespace {
       case AccessorKind::DidSet:
         llvm_unreachable("cannot use accessor directly to perform an access");
 
-      case AccessorKind::Init:
-        llvm_unreachable("init accessor not yet implemented");
+      case AccessorKind::Init: {
+        auto typeData =
+            getLogicalStorageTypeData(SGF.getTypeExpansionContext(), SGF.SGM,
+                                      AccessKind, FormalRValueType);
+        return asImpl().emitUsingInitAccessor(accessor, isDirect, typeData);
+      }
       }
 
       llvm_unreachable("bad kind");
@@ -3257,6 +3266,11 @@ void LValue::addNonMemberVarComponent(
       llvm_unreachable("cannot dispatch non-member var via distributed thunk");
     }
 
+    void emitUsingInitAccessor(SILDeclRef accessor, bool isDirect,
+                               LValueTypeData typeData) {
+      llvm_unreachable("cannot dispatch non-member var via init accessor");
+    }
+
   } emitter(SGF, loc, var, subs, accessKind, formalRValueType, options,
             actorIso, *this);
 
@@ -3789,6 +3803,13 @@ struct MemberStorageAccessEmitter : AccessEmitter<Impl, StorageType> {
         BaseFormalType, typeData, ArgListForDiagnostics, std::move(Indices),
         IsOnSelfParameter);
   }
+
+  void emitUsingInitAccessor(SILDeclRef accessor, bool isDirect,
+                             LValueTypeData typeData) {
+    LV.add<InitAccessorComponent>(
+        Storage, accessor, IsSuper, isDirect, Subs, BaseFormalType, typeData,
+        ArgListForDiagnostics, std::move(Indices), IsOnSelfParameter, ActorIso);
+  }
 };
 } // end anonymous namespace
 

lib/SILOptimizer/Mandatory/RawSILInstLowering.cpp

@@ -342,22 +342,32 @@ lowerAssignOrInitInstruction(SILBuilderWithScope &b,
         b.createEndAccess(loc, selfRef, /*aborted=*/false);
       }
 
-      auto *setterPA = dyn_cast<PartialApplyInst>(inst->getSetter());
-      assert(setterPA);
-
       // The unused partial_apply violates memory lifetime rules in case "self"
       // is an inout. Therefore we cannot keep it as a dead closure to be
       // cleaned up later. We have to delete it in this pass.
-      toDelete.insert(setterPA);
+      {
+        auto setterRef = inst->getSetter();
+        assert(isa<SILUndef>(setterRef) || isa<PartialApplyInst>(setterRef));
 
-      // Also the argument of the closure (which usually is a "load") has to be
-      // deleted to avoid memory lifetime violations.
-      if (setterPA->getNumArguments() == 1)
-        toDelete.insert(setterPA->getArgument(0));
+        toDelete.insert(setterRef);
+
+        if (auto *setterPA = dyn_cast<PartialApplyInst>(setterRef)) {
+          // Also the argument of the closure (which usually is a "load") has to
+          // be deleted to avoid memory lifetime violations.
+          if (setterPA->getNumArguments() == 1)
+            toDelete.insert(setterPA->getArgument(0));
+        }
+      }
       break;
     }
     case AssignOrInitInst::Set: {
       SILValue setterFn = inst->getSetter();
+
+      if (isa<SILUndef>(setterFn)) {
+        toDelete.insert(inst->getInitializer());
+        return;
+      }
+
       CanSILFunctionType fTy = setterFn->getType().castTo<SILFunctionType>();
       SILFunctionConventions convention(fTy, inst->getModule());
       assert(!convention.hasIndirectSILResults());