Merge pull request #61193 from gottesmm/moveonly-deinits

[move-only] Implement support for move only deinits

Author: gottesmm

include/swift/AST/DiagnosticsParse.def

@@ -720,6 +720,14 @@ ERROR(sil_vtable_bad_entry_kind,none,
 ERROR(sil_vtable_expect_rsquare,none,
       "expected ']' after vtable entry kind", ())
 
+// SIL MoveOnlyDeinit
+ERROR(expected_sil_moveonlydeinit_colon,none,
+      "expected ':' in a MoveOnlyDeinit entry", ())
+ERROR(sil_moveonlydeinit_func_not_found,none,
+      "sil function not found %0", (Identifier))
+ERROR(sil_moveonlydeinit_nominal_not_found,none,
+      "sil nominal decl not found %0", (Identifier))
+
 // SIL Global
 ERROR(sil_global_variable_not_found,none,
       "sil global not found %0", (Identifier))

include/swift/Parse/ParseSILSupport.h

@@ -29,6 +29,7 @@ namespace swift {
     virtual bool parseDeclSIL(Parser &P) = 0;
     virtual bool parseDeclSILStage(Parser &P) = 0;
     virtual bool parseSILVTable(Parser &P) = 0;
+    virtual bool parseSILMoveOnlyDeinit(Parser &P) = 0;
     virtual bool parseSILGlobal(Parser &P) = 0;
     virtual bool parseSILWitnessTable(Parser &P) = 0;
     virtual bool parseSILDefaultWitnessTable(Parser &P) = 0;

include/swift/Parse/Parser.h

@@ -976,13 +976,12 @@ class Parser {
     PD_AllowTopLevel        = 1 << 1,
     PD_HasContainerType     = 1 << 2,
     PD_DisallowInit         = 1 << 3,
-    PD_AllowDestructor      = 1 << 4,
-    PD_AllowEnumElement     = 1 << 5,
-    PD_InProtocol           = 1 << 6,
-    PD_InClass              = 1 << 7,
-    PD_InExtension          = 1 << 8,
-    PD_InStruct             = 1 << 9,
-    PD_InEnum               = 1 << 10,
+    PD_AllowEnumElement     = 1 << 4,
+    PD_InProtocol           = 1 << 5,
+    PD_InClass              = 1 << 6,
+    PD_InExtension          = 1 << 7,
+    PD_InStruct             = 1 << 8,
+    PD_InEnum               = 1 << 9,
   };
 
   /// Options that control the parsing of declarations.

include/swift/SIL/Notifications.h

@@ -15,6 +15,7 @@
 
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/STLExtras.h"
+#include "swift/SIL/SILMoveOnlyDeinit.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
@@ -68,6 +69,9 @@ class DeserializationNotificationHandlerBase {
   virtual void didDeserialize(ModuleDecl *mod,
                               SILDefaultWitnessTable *wtable) = 0;
 
+  /// Observe that we deserialized a move only deinit declaration.
+  virtual void didDeserialize(ModuleDecl *mod, SILMoveOnlyDeinit *deinit) = 0;
+
   virtual ~DeserializationNotificationHandlerBase() = default;
 };
 
@@ -109,6 +113,10 @@ class DeserializationNotificationHandler
   virtual void didDeserialize(ModuleDecl *mod,
                               SILDefaultWitnessTable *wtable) override {}
 
+  /// Observe that we deserialized a move only deinit declaration.
+  virtual void didDeserialize(ModuleDecl *mod,
+                              SILMoveOnlyDeinit *deinit) override {}
+
   virtual StringRef getName() const = 0;
 
   virtual ~DeserializationNotificationHandler() = default;
@@ -239,6 +247,7 @@ class DeserializationNotificationHandlerSet final
   void didDeserialize(ModuleDecl *mod, SILWitnessTable *wtable) override;
   void didDeserialize(ModuleDecl *mod,
                       SILDefaultWitnessTable *wtable) override;
+  void didDeserialize(ModuleDecl *mod, SILMoveOnlyDeinit *deinit) override;
 };
 } // namespace swift
 

include/swift/SIL/SILModule.h

@@ -19,6 +19,7 @@
 
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Builtins.h"
+#include "swift/AST/Decl.h"
 #include "swift/AST/SILLayout.h"
 #include "swift/AST/SILOptions.h"
 #include "swift/Basic/IndexTrie.h"
@@ -32,6 +33,7 @@
 #include "swift/SIL/SILDifferentiabilityWitness.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILGlobalVariable.h"
+#include "swift/SIL/SILMoveOnlyDeinit.h"
 #include "swift/SIL/SILPrintContext.h"
 #include "swift/SIL/SILProperty.h"
 #include "swift/SIL/SILType.h"
@@ -161,6 +163,7 @@ class SILModule {
   using DefaultWitnessTableListType = llvm::ilist<SILDefaultWitnessTable>;
   using DifferentiabilityWitnessListType =
       llvm::ilist<SILDifferentiabilityWitness>;
+  using SILMoveOnlyDeinitListType = llvm::ArrayRef<SILMoveOnlyDeinit *>;
   using CoverageMapCollectionType =
       llvm::MapVector<StringRef, SILCoverageMap *>;
   using BasicBlockNameMapType =
@@ -191,6 +194,7 @@ class SILModule {
   friend SILProperty;
   friend SILUndef;
   friend SILWitnessTable;
+  friend SILMoveOnlyDeinit;
   friend Lowering::SILGenModule;
   friend Lowering::TypeConverter;
   class SerializationCallback;
@@ -271,6 +275,13 @@ class SILModule {
   /// The list of SILDifferentiabilityWitnesses in the module.
   DifferentiabilityWitnessListType differentiabilityWitnesses;
 
+  /// Lookup table for SIL vtables from class decls.
+  llvm::DenseMap<const NominalTypeDecl *, SILMoveOnlyDeinit *>
+      MoveOnlyDeinitMap;
+
+  /// The list of SILVTables in the module.
+  std::vector<SILMoveOnlyDeinit *> moveOnlyDeinits;
+
   /// Declarations which are externally visible.
   ///
   /// These are method declarations which are referenced from inlinable
@@ -614,6 +625,25 @@ class SILModule {
   vtable_const_iterator vtable_begin() const { return getVTables().begin(); }
   vtable_const_iterator vtable_end() const { return getVTables().end(); }
 
+  ArrayRef<SILMoveOnlyDeinit *> getMoveOnlyDeinits() const {
+    return ArrayRef<SILMoveOnlyDeinit *>(moveOnlyDeinits);
+  }
+  using moveonlydeinit_iterator = SILMoveOnlyDeinitListType::iterator;
+  using moveonlydeinit_const_iterator =
+      SILMoveOnlyDeinitListType::const_iterator;
+  moveonlydeinit_iterator moveonlydeinit_begin() {
+    return getMoveOnlyDeinits().begin();
+  }
+  moveonlydeinit_iterator moveonlydeinit_end() {
+    return getMoveOnlyDeinits().end();
+  }
+  moveonlydeinit_const_iterator moveonlydeinit_begin() const {
+    return getMoveOnlyDeinits().begin();
+  }
+  moveonlydeinit_const_iterator moveonlydeinit_end() const {
+    return getMoveOnlyDeinits().end();
+  }
+
   using witness_table_iterator = WitnessTableListType::iterator;
   using witness_table_const_iterator = WitnessTableListType::const_iterator;
   WitnessTableListType &getWitnessTableList() { return witnessTables; }
@@ -799,6 +829,15 @@ class SILModule {
   /// hierarchy of \p Class.
   SILFunction *lookUpFunctionInVTable(ClassDecl *Class, SILDeclRef Member);
 
+  /// Look up the deinit mapped to the given move only nominal type decl.
+  /// Returns null on failure.
+  SILMoveOnlyDeinit *lookUpMoveOnlyDeinit(const NominalTypeDecl *nomDecl,
+                                          bool deserializeLazily = true);
+
+  /// Look up the function mapped to the given move only nominal type decl.
+  /// Returns null on failure.
+  SILFunction *lookUpMoveOnlyDeinitFunction(const NominalTypeDecl *nomDecl);
+
   /// Look up the differentiability witness with the given name.
   SILDifferentiabilityWitness *lookUpDifferentiabilityWitness(StringRef name);
 

include/swift/SIL/SILMoveOnlyDeinit.h

@@ -0,0 +1,81 @@
+//===--- SILMoveOnlyDeinit.h ----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+///
+/// This file defines the SILMoveOnlyDeinit class which is used to map a
+/// non-class move only nominal type to the concrete implementation of its
+/// deinit. This function is called in the destroy witness by IRGen and is
+/// called directly by the move checker for concrete classes.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_SILMOVEONLYDEINIT_H
+#define SWIFT_SIL_SILMOVEONLYDEINIT_H
+
+#include "swift/AST/Decl.h"
+#include "swift/SIL/SILAllocated.h"
+#include "swift/SIL/SILDeclRef.h"
+#include "swift/SIL/SILFunction.h"
+
+namespace swift {
+
+enum IsSerialized_t : unsigned char;
+class SILFunction;
+class SILModule;
+
+class SILMoveOnlyDeinit final : public SILAllocated<SILMoveOnlyDeinit> {
+  friend SILModule;
+
+  /// The nominal decl that is mapped to this move only deinit table.
+  NominalTypeDecl *nominalDecl;
+
+  /// The SILFunction that implements this deinit.
+  SILFunction *funcImpl;
+
+  /// Whether or not this deinit table is serialized. If a deinit is not
+  /// serialized, then other modules can not consume directly a move only type
+  /// since the deinit can not be called directly.
+  bool serialized : 1;
+
+  SILMoveOnlyDeinit()
+      : nominalDecl(nullptr), funcImpl(nullptr), serialized(false) {}
+
+  SILMoveOnlyDeinit(NominalTypeDecl *nominaldecl, SILFunction *implementation,
+                    bool serialized);
+  ~SILMoveOnlyDeinit();
+
+public:
+  static SILMoveOnlyDeinit *create(SILModule &mod, NominalTypeDecl *nominalDecl,
+                                   IsSerialized_t serialized,
+                                   SILFunction *funcImpl);
+
+  NominalTypeDecl *getNominalDecl() const { return nominalDecl; }
+
+  SILFunction *getImplementation() const { return funcImpl; }
+
+  bool isSerialized() const { return serialized; }
+
+  void print(llvm::raw_ostream &os, bool verbose) const;
+  void dump() const;
+
+  bool operator==(const SILMoveOnlyDeinit &e) const {
+    return funcImpl == e.funcImpl && serialized == e.serialized &&
+           nominalDecl == e.nominalDecl;
+  }
+
+  bool operator!=(const SILMoveOnlyDeinit &e) const { return !(*this == e); }
+};
+
+} // namespace swift
+
+#endif

include/swift/SIL/SILType.h

@@ -622,6 +622,10 @@ class SILType {
   /// wrapped type.
   bool isMoveOnly() const;
 
+  /// Returns true if and only if this type is a first class move only
+  /// type. NOTE: Returns false if the type is a move only wrapped type.
+  bool isMoveOnlyType() const;
+
   /// Returns true if this SILType is a move only wrapper type.
   ///
   /// Canonical way to check if a SILType is move only. Using is/getAs/castTo

include/swift/SILOptimizer/PassManager/Passes.def

@@ -474,6 +474,8 @@ PASS(PartialApplySimplification, "partial-apply-simplification",
      "Transform partial_apply instructions into explicit closure box constructions")
 PASS(MovedAsyncVarDebugInfoPropagator, "sil-moved-async-var-dbginfo-propagator",
      "Propagate debug info from moved async vars after coroutine funclet boundaries")
+PASS(MoveOnlyDeinitInsertion, "sil-move-only-deinit-insertion",
+     "After running move only checking, convert last destroy_values to deinit calls")
 PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)

include/swift/Serialization/SerializedSILLoader.h

@@ -19,6 +19,7 @@
 #include "swift/SIL/Notifications.h"
 #include "swift/SIL/SILDeclRef.h"
 #include "swift/SIL/SILLinkage.h"
+#include "swift/SIL/SILMoveOnlyDeinit.h"
 #include <memory>
 #include <vector>
 
@@ -63,6 +64,7 @@ class SerializedSILLoader {
   SILFunction *lookupSILFunction(StringRef Name, Optional<SILLinkage> linkage);
   bool hasSILFunction(StringRef Name, Optional<SILLinkage> linkage = None);
   SILVTable *lookupVTable(const ClassDecl *C);
+  SILMoveOnlyDeinit *lookupMoveOnlyDeinit(const NominalTypeDecl *nomDecl);
   SILWitnessTable *lookupWitnessTable(SILWitnessTable *C);
   SILDefaultWitnessTable *lookupDefaultWitnessTable(SILDefaultWitnessTable *C);
   SILDifferentiabilityWitness *

include/swift/Syntax/TokenKinds.def.gyb

@@ -162,6 +162,7 @@ SIL_KEYWORD(sil)
 SIL_KEYWORD(sil_stage)
 SIL_KEYWORD(sil_property)
 SIL_KEYWORD(sil_vtable)
+SIL_KEYWORD(sil_moveonlydeinit)
 SIL_KEYWORD(sil_global)
 SIL_KEYWORD(sil_witness_table)
 SIL_KEYWORD(sil_default_witness_table)