[move-only] Teach SILGen how to emit deinits for nominal non-class move only types.

Even though with this change we emit the deinit, it isn't used yet since we
still need to implement the move only deinit table/teach the checker how to call
these/teach IRGen how to call this from the destroying value witness.

Author: gottesmm

lib/SILGen/SILGen.cpp

@@ -11,11 +11,13 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "silgen"
+
 #include "ManagedValue.h"
 #include "RValue.h"
 #include "SILGenFunction.h"
 #include "SILGenFunctionBuilder.h"
 #include "Scope.h"
+#include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/Evaluator.h"
 #include "swift/AST/GenericEnvironment.h"
@@ -26,6 +28,7 @@
 #include "swift/AST/PropertyWrappers.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/ResilienceExpansion.h"
+#include "swift/AST/SILGenRequests.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Statistic.h"
@@ -34,7 +37,6 @@
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILProfiler.h"
-#include "swift/AST/SILGenRequests.h"
 #include "swift/Serialization/SerializedModuleLoader.h"
 #include "swift/Serialization/SerializedSILLoader.h"
 #include "swift/Strings.h"
@@ -1085,15 +1087,17 @@ void SILGenModule::emitFunctionDefinition(SILDeclRef constant, SILFunction *f) {
 
   case SILDeclRef::Kind::Deallocator: {
     auto *dd = cast<DestructorDecl>(constant.getDecl());
-    auto *cd = cast<ClassDecl>(dd->getDeclContext());
-
-    if (usesObjCAllocator(cd)) {
-      preEmitFunction(constant, f, dd);
-      PrettyStackTraceSILFunction X("silgen emitDestructor -dealloc", f);
-      f->createProfiler(dd, constant);
-      SILGenFunction(*this, *f, dd).emitObjCDestructor(constant);
-      postEmitFunction(constant, f);
-      return;
+    auto *nom = dd->getDeclContext();
+
+    if (auto *cd = dyn_cast<ClassDecl>(nom)) {
+      if (usesObjCAllocator(cd)) {
+        preEmitFunction(constant, f, dd);
+        PrettyStackTraceSILFunction X("silgen emitDestructor -dealloc", f);
+        f->createProfiler(dd, constant);
+        SILGenFunction(*this, *f, dd).emitObjCDestructor(constant);
+        postEmitFunction(constant, f);
+        return;
+      }
     }
 
     auto loc = RegularLocation::getAutoGeneratedLocation(dd);
@@ -1605,6 +1609,17 @@ void SILGenModule::emitDestructor(ClassDecl *cd, DestructorDecl *dd) {
   }
 }
 
+void SILGenModule::emitMoveOnlyDestructor(NominalTypeDecl *cd,
+                                          DestructorDecl *dd) {
+  assert(cd->isMoveOnly());
+
+  emitAbstractFuncDecl(dd);
+
+  // Emit the deallocating destructor.
+  SILDeclRef deallocator(dd, SILDeclRef::Kind::Deallocator);
+  emitFunctionDefinition(deallocator, getFunction(deallocator, ForDefinition));
+}
+
 void SILGenModule::emitDefaultArgGenerator(SILDeclRef constant,
                                            ParamDecl *param) {
   switch (param->getDefaultArgumentKind()) {

lib/SILGen/SILGen.h

@@ -312,8 +312,15 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   /// Generates code for the given class's destructor and adds
   /// the SILFunction to the current SILModule under the name
   /// SILDeclRef(cd, Destructor).
+  ///
+  /// TODO: Rename to emitClassDestructor.
   void emitDestructor(ClassDecl *cd, DestructorDecl *dd);
 
+  /// Generates code for the given move only nominal type's destructor and adds
+  /// the SILFunction to the current SILModule under the name SILDeclRef(nd,
+  /// dd).
+  void emitMoveOnlyDestructor(NominalTypeDecl *nd, DestructorDecl *dd);
+
   /// Emits the default argument generator with the given expression.
   void emitDefaultArgGenerator(SILDeclRef constant, ParamDecl *param);
 

lib/SILGen/SILGenDestructor.cpp

@@ -15,8 +15,10 @@
 #include "SILGenFunction.h"
 #include "SILGenFunctionBuilder.h"
 #include "SwitchEnumBuilder.h"
+#include "swift/AST/Decl.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/SubstitutionMap.h"
+#include "swift/SIL/SILValue.h"
 #include "swift/SIL/TypeLowering.h"
 #include "llvm/ADT/SmallSet.h"
 
@@ -30,7 +32,7 @@ void SILGenFunction::emitDestroyingDestructor(DestructorDecl *dd) {
   if (dd->isImplicit())
     Loc.markAutoGenerated();
 
-  auto cd = cast<ClassDecl>(dd->getDeclContext());
+  auto cd = cast<ClassDecl>(dd->getDeclContext()->getSelfNominalTypeDecl());
   auto &C = cd->getASTContext();
   SILValue selfValue = emitSelfDecl(dd->getImplicitSelfDecl());
 
@@ -159,6 +161,14 @@ void SILGenFunction::emitDestroyingDestructor(DestructorDecl *dd) {
 }
 
 void SILGenFunction::emitDeallocatingDestructor(DestructorDecl *dd) {
+  auto *nom = dd->getDeclContext()->getSelfNominalTypeDecl();
+  if (isa<ClassDecl>(nom))
+    return emitDeallocatingClassDestructor(dd);
+  assert(nom->isMoveOnly());
+  return emitDeallocatingMoveOnlyDestructor(dd);
+}
+
+void SILGenFunction::emitDeallocatingClassDestructor(DestructorDecl *dd) {
   MagicFunctionName = DeclName(SGM.M.getASTContext().getIdentifier("deinit"));
 
   // The deallocating destructor is always auto-generated.
@@ -212,6 +222,42 @@ void SILGenFunction::emitDeallocatingDestructor(DestructorDecl *dd) {
   B.createReturn(loc, emitEmptyTuple(loc));
 }
 
+void SILGenFunction::emitDeallocatingMoveOnlyDestructor(DestructorDecl *dd) {
+  MagicFunctionName = DeclName(SGM.M.getASTContext().getIdentifier("deinit"));
+
+  RegularLocation loc(dd);
+  if (dd->isImplicit())
+    loc.markAutoGenerated();
+
+  // Emit the prolog.
+  auto selfValue = emitSelfDecl(dd->getImplicitSelfDecl());
+
+  // Create a basic block to jump to for the implicit destruction behavior
+  // of releasing the elements and calling the superclass destructor.
+  // We won't actually emit the block until we finish with the destructor body.
+  prepareEpilog(None, false, CleanupLocation(loc));
+
+  auto cleanupLoc = CleanupLocation(loc);
+
+  emitProfilerIncrement(dd->getTypecheckedBody());
+  emitStmt(dd->getTypecheckedBody());
+
+  Optional<SILValue> maybeReturnValue;
+  SILLocation returnLoc(loc);
+  std::tie(maybeReturnValue, returnLoc) = emitEpilogBB(loc);
+
+  if (!maybeReturnValue)
+    return;
+
+  // Clean up our members, consuming our +1 self value as we do it.
+  emitMoveOnlyMemberDestruction(selfValue,
+                                dd->getDeclContext()->getSelfNominalTypeDecl(),
+                                cleanupLoc, nullptr);
+
+  // Return.
+  B.createReturn(loc, emitEmptyTuple(loc));
+}
+
 void SILGenFunction::emitIVarDestroyer(SILDeclRef ivarDestroyer) {
   auto cd = cast<ClassDecl>(ivarDestroyer.getDecl());
   RegularLocation loc(cd);
@@ -440,6 +486,39 @@ void SILGenFunction::emitClassMemberDestruction(ManagedValue selfValue,
   }
 }
 
+void SILGenFunction::emitMoveOnlyMemberDestruction(SILValue selfValue,
+                                                   NominalTypeDecl *nom,
+                                                   CleanupLocation cleanupLoc,
+                                                   SILBasicBlock *finishBB) {
+  if (selfValue->getType().isAddress()) {
+    for (VarDecl *vd : nom->getStoredProperties()) {
+      const TypeLowering &ti = getTypeLowering(vd->getType());
+      if (ti.isTrivial())
+        continue;
+
+      SILValue addr = B.createStructElementAddr(
+          cleanupLoc, selfValue, vd, ti.getLoweredType().getAddressType());
+      addr = B.createBeginAccess(
+          cleanupLoc, addr, SILAccessKind::Deinit, SILAccessEnforcement::Static,
+          false /*noNestedConflict*/, false /*fromBuiltin*/);
+      B.createDestroyAddr(cleanupLoc, addr);
+      B.createEndAccess(cleanupLoc, addr, false /*is aborting*/);
+    }
+  } else {
+    auto *d =
+        B.createDestructureStruct(cleanupLoc, selfValue, OwnershipKind::Owned);
+    for (auto result : d->getResults()) {
+      B.emitDestroyValueOperation(cleanupLoc, result);
+    }
+  }
+
+  if (finishBB)
+    B.createBranch(cleanupLoc, finishBB);
+
+  if (finishBB)
+    B.emitBlock(finishBB);
+}
+
 void SILGenFunction::emitObjCDestructor(SILDeclRef dtor) {
   auto dd = cast<DestructorDecl>(dtor.getDecl());
   auto cd = cast<ClassDecl>(dd->getDeclContext());

lib/SILGen/SILGenFunction.h

@@ -634,6 +634,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   void emitFunction(FuncDecl *fd);
   /// Emits code for a ClosureExpr.
   void emitClosure(AbstractClosureExpr *ce);
+
   /// Generates code for a class destroying destructor. This
   /// emits the body code from the DestructorDecl, calls the base class
   /// destructor, then implicitly releases the elements of the class.
@@ -646,10 +647,18 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// Generate code into @main for starting the async main on the main thread.
   void emitAsyncMainThreadStart(SILDeclRef entryPoint);
 
+  /// Generates code for class/move only deallocating destructor. This calls the
+  /// destroying destructor and then deallocates 'self'.
+  void emitDeallocatingDestructor(DestructorDecl *dd);
+
   /// Generates code for a class deallocating destructor. This
   /// calls the destroying destructor and then deallocates 'self'.
-  void emitDeallocatingDestructor(DestructorDecl *dd);
-  
+  void emitDeallocatingClassDestructor(DestructorDecl *dd);
+
+  /// Generates code for the deinit of the move only type and destroys all of
+  /// the fields.
+  void emitDeallocatingMoveOnlyDestructor(DestructorDecl *dd);
+
   /// Generates code for a struct constructor.
   /// This allocates the new 'self' value, emits the
   /// body code, then returns the final initialized 'self'.
@@ -692,6 +701,18 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                   CleanupLocation cleanupLoc,
                                   SILBasicBlock* finishBB);
 
+  /// Generates code to destroy the instance variables of a move only non-class
+  /// nominal type.
+  ///
+  /// \param selfValue The 'self' value.
+  /// \param nd The nominal declaration whose members are being destroyed.
+  /// \param finishBB If set, used as the basic block after members have been
+  ///                 destroyed, and we're ready to perform final cleanups
+  ///                 before returning.
+  void emitMoveOnlyMemberDestruction(SILValue selfValue, NominalTypeDecl *nd,
+                                     CleanupLocation cleanupLoc,
+                                     SILBasicBlock *finishBB);
+
   /// Generates code to destroy linearly recursive data structures, without
   /// building up the call stack.
   ///

lib/SILGen/SILGenType.cpp

@@ -1141,9 +1141,17 @@ class SILGenType : public TypeMemberVisitor<SILGenType> {
         !isa<ProtocolDecl>(cd->getDeclContext()))
       SGM.emitObjCConstructorThunk(cd);
   }
+
   void visitDestructorDecl(DestructorDecl *dd) {
-    assert(isa<ClassDecl>(theType) && "destructor in a non-class type");
-    SGM.emitDestructor(cast<ClassDecl>(theType), dd);
+    if (auto *cd = dyn_cast<ClassDecl>(theType))
+      return SGM.emitDestructor(cast<ClassDecl>(theType), dd);
+    if (auto *nom = dyn_cast<NominalTypeDecl>(theType)) {
+      if (nom->isMoveOnly()) {
+        return SGM.emitMoveOnlyDestructor(nom, dd);
+      }
+    }
+    assert(isa<ClassDecl>(theType) &&
+           "destructor in a non-class, non-moveonly type");
   }
 
   void visitEnumCaseDecl(EnumCaseDecl *ecd) {}