[SILGen] InitAccessor: Emit init accessor function

Emit all initializes/accesses properties as arguments
in custom prolog and map them back to the originating
property declarations.

Author: xedin

lib/SILGen/SILGen.cpp

@@ -875,6 +875,16 @@ void SILGenModule::emitFunctionDefinition(SILDeclRef constant, SILFunction *f) {
       break;
     }
 
+    if (constant.isInitAccessor()) {
+      auto *accessor = cast<AccessorDecl>(constant.getDecl());
+      preEmitFunction(constant, f, accessor);
+      PrettyStackTraceSILFunction X("silgen init accessor", f);
+      f->createProfiler(constant);
+      SILGenFunction(*this, *f, accessor).emitInitAccessor(accessor);
+      postEmitFunction(constant, f);
+      break;
+    }
+
     auto *fd = cast<FuncDecl>(constant.getDecl());
 
     preEmitFunction(constant, f, fd);

lib/SILGen/SILGenConstructor.cpp

@@ -1481,3 +1481,81 @@ void SILGenFunction::emitIVarInitializer(SILDeclRef ivarInitializer) {
 
   emitEpilog(loc);
 }
+
+void SILGenFunction::emitInitAccessor(AccessorDecl *accessor) {
+  RegularLocation loc(accessor);
+  loc.markAutoGenerated();
+
+  auto accessorTy = F.getLoweredFunctionType();
+
+  auto createArgument = [&](VarDecl *property, SILType type,
+                            bool markUninitialized = false) {
+    auto *arg = ParamDecl::createImplicit(
+        getASTContext(), property->getBaseIdentifier(),
+        property->getBaseIdentifier(), type.getASTType()->mapTypeOutOfContext(),
+        accessor, ParamSpecifier::InOut);
+
+    RegularLocation loc(property);
+    loc.markAutoGenerated();
+
+    SILValue argValue = F.begin()->createFunctionArgument(type, arg);
+    VarLocs[arg] =
+        markUninitialized
+            ? VarLoc::get(B.createMarkUninitializedOut(loc, argValue))
+            : VarLoc::get(argValue);
+
+    InitAccessorArgumentMappings[property] = arg;
+  };
+
+  // First, emit results, this is our "initializes(...)" properties and
+  // require DI to check that each property is fully initialized.
+  if (auto *initAttr = accessor->getAttrs().getAttribute<InitializesAttr>()) {
+    auto initializedProperties = initAttr->getPropertyDecls(accessor);
+    for (unsigned i = 0, n = initializedProperties.size(); i != n; ++i) {
+      auto *property = initializedProperties[i];
+      auto propertyTy =
+          getSILTypeInContext(accessorTy->getResults()[i], accessorTy);
+      createArgument(property, propertyTy, /*markUninitialized=*/true);
+    }
+  }
+
+  // Collect all of the parameters that represent properties listed by
+  // "accesses" attribute. They have to be emitted in order of arguments which
+  // means after the "newValue" which is emitted by \c emitBasicProlog.
+  Optional<ArrayRef<VarDecl *>> accessedProperties;
+  {
+    if (auto *accessAttr = accessor->getAttrs().getAttribute<AccessesAttr>())
+      accessedProperties = accessAttr->getPropertyDecls(accessor);
+  }
+
+  // Emit `newValue` argument.
+  emitBasicProlog(accessor->getParameters(), /*selfParam=*/nullptr,
+                  TupleType::getEmpty(F.getASTContext()), accessor,
+                  /*throws=*/false, /*throwsLoc=*/SourceLoc(),
+                  /*ignored parameters*/
+                  accessedProperties ? accessedProperties->size() : 0);
+
+  // Emit arguments for all `accesses(...)` properties.
+  if (accessedProperties) {
+    auto propertyIter = accessedProperties->begin();
+    auto propertyArgs = accessorTy->getParameters().slice(
+        accessorTy->getNumParameters() - accessedProperties->size());
+
+    for (const auto &argument : propertyArgs) {
+      createArgument(*propertyIter, getSILTypeInContext(argument, accessorTy));
+      ++propertyIter;
+    }
+  }
+
+  prepareEpilog(accessor->getResultInterfaceType(), accessor->hasThrows(),
+                CleanupLocation(accessor));
+
+  emitProfilerIncrement(accessor->getTypecheckedBody());
+
+  // Emit the actual function body as usual
+  emitStmt(accessor->getTypecheckedBody());
+
+  emitEpilog(accessor);
+
+  mergeCleanupBlocks();
+}

lib/SILGen/SILGenFunction.h

@@ -804,6 +804,12 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// Emit a method that destroys the ivars of a class.
   void emitIVarDestroyer(SILDeclRef ivarDestroyer);
 
+  /// Generates code for the given init accessor represented by AccessorDecl.
+  /// This emits the body code and replaces all `self.<property>` references
+  /// with either argument (if property appears in `acesses` list`) or result
+  /// value assignment.
+  void emitInitAccessor(AccessorDecl *accessor);
+
   /// Generates code to destroy the instance variables of a class.
   ///
   /// \param selfValue The 'self' value.