IRGen: Track IsCopyable through type infos.

And use the new bit to ensure we don't try to lower move-only types
with common layout value witness surrogates. Take a bit in the runtime
value witness flags to represent types that are not copyable.

Author: jckarter

include/swift/ABI/MetadataValues.h

@@ -163,7 +163,8 @@ class TargetValueWitnessFlags {
     IsNonBitwiseTakable = 0x00100000,
     HasEnumWitnesses =    0x00200000,
     Incomplete =          0x00400000,
-    // unused             0xFF800000,
+    IsNonCopyable =       0x00800000,
+    // unused             0xFF000000,
   };
 
   static constexpr const uint32_t MaxNumExtraInhabitants = 0x7FFFFFFF;
@@ -209,8 +210,8 @@ class TargetValueWitnessFlags {
                                    (isInline ? 0 : IsNonInline));
   }
 
-  /// True if values of this type can be copied with memcpy and
-  /// destroyed with a no-op.
+  /// True if values of this type can be copied with memcpy (if it's copyable)
+  /// and destroyed with a no-op.
   bool isPOD() const { return !(Data & IsNonPOD); }
   constexpr TargetValueWitnessFlags withPOD(bool isPOD) const {
     return TargetValueWitnessFlags((Data & ~IsNonPOD) |
@@ -227,6 +228,13 @@ class TargetValueWitnessFlags {
     return TargetValueWitnessFlags((Data & ~IsNonBitwiseTakable) |
                                    (isBT ? 0 : IsNonBitwiseTakable));
   }
+  
+  /// True if values of this type can be copied.
+  bool isCopyable() const { return !(Data & IsNonCopyable); }
+  constexpr TargetValueWitnessFlags withCopyable(bool isCopyable) const {
+    return TargetValueWitnessFlags((Data & ~IsNonCopyable) |
+                                   (isCopyable ? 0 : IsNonCopyable));
+  }
 
   /// True if this type's binary representation is that of an enum, and the
   /// enum value witness table entries are available in this type's value

include/swift/AST/Decl.h

@@ -4011,6 +4011,10 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   bool isGlobalActor() const {
     return getGlobalActorInstance() != nullptr;
   }
+  
+  /// Return the `DestructorDecl` for a struct or enum's `deinit` declaration.
+  /// Returns null if the type is a class, or does not have a declared `deinit`.
+  DestructorDecl *getValueTypeDestructor();
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {

lib/AST/Decl.cpp

@@ -4578,6 +4578,18 @@ bool NominalTypeDecl::isResilient() const {
   return getModuleContext()->isResilient();
 }
 
+DestructorDecl *NominalTypeDecl::getValueTypeDestructor() {
+  if (!isa<StructDecl>(this) && !isa<EnumDecl>(this)) {
+    return nullptr;
+  }
+  
+  auto found = lookupDirect(DeclBaseName::createDestructor());
+  if (found.size() != 1) {
+    return nullptr;
+  }
+  return cast<DestructorDecl>(found[0]);
+}
+
 static bool isOriginallyDefinedIn(const Decl *D, const ModuleDecl* MD) {
   if (!MD)
     return false;

lib/IRGen/FixedTypeInfo.h

@@ -42,10 +42,12 @@ class FixedTypeInfo : public TypeInfo {
 protected:
   FixedTypeInfo(llvm::Type *type, Size size,
                 const SpareBitVector &spareBits,
-                Alignment align, IsTriviallyDestroyable_t pod, IsBitwiseTakable_t bt,
+                Alignment align, IsTriviallyDestroyable_t pod,
+                IsBitwiseTakable_t bt,
+                IsCopyable_t copy,
                 IsFixedSize_t alwaysFixedSize,
                 SpecialTypeInfoKind stik = SpecialTypeInfoKind::Fixed)
-      : TypeInfo(type, align, pod, bt, alwaysFixedSize, IsABIAccessible, stik),
+      : TypeInfo(type, align, pod, bt, copy, alwaysFixedSize, IsABIAccessible, stik),
         SpareBits(spareBits) {
     assert(SpareBits.size() == size.getValueInBits());
     assert(isFixedSize());
@@ -55,10 +57,12 @@ class FixedTypeInfo : public TypeInfo {
 
   FixedTypeInfo(llvm::Type *type, Size size,
                 SpareBitVector &&spareBits,
-                Alignment align, IsTriviallyDestroyable_t pod, IsBitwiseTakable_t bt,
+                Alignment align, IsTriviallyDestroyable_t pod,
+                IsBitwiseTakable_t bt,
+                IsCopyable_t copy,
                 IsFixedSize_t alwaysFixedSize,
                 SpecialTypeInfoKind stik = SpecialTypeInfoKind::Fixed)
-      : TypeInfo(type, align, pod, bt, alwaysFixedSize, IsABIAccessible, stik),
+      : TypeInfo(type, align, pod, bt, copy, alwaysFixedSize, IsABIAccessible, stik),
         SpareBits(std::move(spareBits)) {
     assert(SpareBits.size() == size.getValueInBits());
     assert(isFixedSize());

lib/IRGen/GenArchetype.cpp

@@ -102,7 +102,7 @@ class OpaqueArchetypeTypeInfo
   : public ResilientTypeInfo<OpaqueArchetypeTypeInfo>
 {
   OpaqueArchetypeTypeInfo(llvm::Type *type, IsABIAccessible_t abiAccessible)
-      : ResilientTypeInfo(type, abiAccessible) {}
+      : ResilientTypeInfo(type, IsCopyable, abiAccessible) {}
 
 public:
   static const OpaqueArchetypeTypeInfo *

lib/IRGen/GenConcurrency.cpp

@@ -43,7 +43,8 @@ class ExecutorTypeInfo :
   ExecutorTypeInfo(llvm::StructType *storageType,
                    Size size, Alignment align, SpareBitVector &&spareBits)
       : TrivialScalarPairTypeInfo(storageType, size, std::move(spareBits),
-                                  align, IsTriviallyDestroyable, IsFixedSize) {}
+                                  align, IsTriviallyDestroyable,
+                                  IsCopyable, IsFixedSize) {}
 
   static Size getFirstElementSize(IRGenModule &IGM) {
     return IGM.getPointerSize();

lib/IRGen/GenDiffFunc.cpp

@@ -96,7 +96,7 @@ class DifferentiableFuncTypeInfo final
                              SpareBitVector &&spareBits, Alignment align,
                              IsTriviallyDestroyable_t isTriviallyDestroyable, IsFixedSize_t alwaysFixedSize)
       : super(fields, explosionSize, ty, size, std::move(spareBits), align,
-              isTriviallyDestroyable, alwaysFixedSize) {}
+              isTriviallyDestroyable, IsCopyable, alwaysFixedSize) {}
 
   Address projectFieldAddress(IRGenFunction &IGF, Address addr, SILType T,
                               const DifferentiableFuncFieldInfo &field) const {
@@ -270,7 +270,7 @@ class LinearFuncTypeInfo final
                      SpareBitVector &&spareBits, Alignment align, IsTriviallyDestroyable_t isTriviallyDestroyable,
                      IsFixedSize_t alwaysFixedSize)
       : super(fields, explosionSize, ty, size, std::move(spareBits), align,
-              isTriviallyDestroyable, alwaysFixedSize) {}
+              isTriviallyDestroyable, IsCopyable, alwaysFixedSize) {}
 
   Address projectFieldAddress(IRGenFunction &IGF, Address addr, SILType T,
                               const LinearFuncFieldInfo &field) const {