[IRGen] Do not set HasLayoutString flag for non-copyable types requiring metadata instantiation

rdar://157795547

When types contain stored properties of resilient types, we instantiate their metadata at runtime. If those types are non-copyable, they won't have layout strings, so we must not set the flag.

Author: drexin

lib/IRGen/GenMeta.cpp

@@ -5808,8 +5808,12 @@ namespace {
         return false;
       }
 
-      if (IGM.Context.LangOpts.hasFeature(Feature::LayoutStringValueWitnessesInstantiation) &&
-          IGM.getOptions().EnableLayoutStringValueWitnessesInstantiation) {
+      auto &TI = IGM.getTypeInfo(getLoweredType());
+
+      if (IGM.Context.LangOpts.hasFeature(
+              Feature::LayoutStringValueWitnessesInstantiation) &&
+          IGM.getOptions().EnableLayoutStringValueWitnessesInstantiation &&
+          TI.isCopyable(ResilienceExpansion::Maximal)) {
         return !!getLayoutString() || needsSingletonMetadataInitialization(IGM, Target);
       }
 
@@ -6285,9 +6289,11 @@ namespace {
     }
 
     bool hasInstantiatedLayoutString() {
+      auto &TI = IGM.getTypeInfo(getLoweredType());
       if (IGM.Context.LangOpts.hasFeature(
               Feature::LayoutStringValueWitnessesInstantiation) &&
-          IGM.getOptions().EnableLayoutStringValueWitnessesInstantiation) {
+          IGM.getOptions().EnableLayoutStringValueWitnessesInstantiation &&
+          TI.isCopyable(ResilienceExpansion::Maximal)) {
         return needsSingletonMetadataInitialization(IGM, Target);
       }
 

test/Interpreter/Inputs/layout_string_witnesses_types.swift

@@ -341,11 +341,13 @@ public struct NestedWrapper<T> {
     }
 }
 
-struct InternalGeneric<T> {
+struct InternalGeneric<T: ~Copyable>: ~Copyable {
     let y: Int
     let x: T
 }
 
+extension InternalGeneric: Copyable where T: Copyable {}
+
 public enum SinglePayloadSimpleClassEnum {
     case empty0
     case empty1
@@ -711,7 +713,7 @@ public func preSpec() {
 }
 
 @inline(never)
-public func testAssign<T>(_ ptr: UnsafeMutablePointer<T>, from x: T) {
+public func testAssign<T: ~Copyable>(_ ptr: UnsafeMutablePointer<T>, from x: consuming T) {
     ptr.pointee = x
 }
 
@@ -721,7 +723,7 @@ public func testAssignCopy<T>(_ ptr: UnsafeMutablePointer<T>, from x: inout T) {
 }
 
 @inline(never)
-public func testInit<T>(_ ptr: UnsafeMutablePointer<T>, to x: T) {
+public func testInit<T: ~Copyable>(_ ptr: UnsafeMutablePointer<T>, to x: consuming T) {
     ptr.initialize(to: x)
 }
 
@@ -731,32 +733,32 @@ public func testInitTake<T>(_ ptr: UnsafeMutablePointer<T>, to x: consuming T) {
 }
 
 @inline(never)
-public func testDestroy<T>(_ ptr: UnsafeMutablePointer<T>) {
+public func testDestroy<T: ~Copyable>(_ ptr: UnsafeMutablePointer<T>) {
     _ = ptr.move()
 }
 
 @inline(never)
-public func allocateInternalGenericPtr<T>(of tpe: T.Type) -> UnsafeMutableRawPointer {
+public func allocateInternalGenericPtr<T: ~Copyable>(of tpe: T.Type) -> UnsafeMutableRawPointer {
     return UnsafeMutableRawPointer(
         UnsafeMutablePointer<InternalGeneric<T>>.allocate(capacity: 1))
 }
 
 @inline(never)
-public func testGenericAssign<T>(_ ptr: __owned UnsafeMutableRawPointer, from x: T) {
+public func testGenericAssign<T: ~Copyable>(_ ptr: __owned UnsafeMutableRawPointer, from x: consuming T) {
     let ptr = ptr.assumingMemoryBound(to: InternalGeneric<T>.self)
     let x = InternalGeneric(y: 23, x: x)
     testAssign(ptr, from: x)
 }
 
 @inline(never)
-public func testGenericInit<T>(_ ptr: __owned UnsafeMutableRawPointer, to x: T) {
+public func testGenericInit<T: ~Copyable>(_ ptr: __owned UnsafeMutableRawPointer, to x: consuming T) {
     let ptr = ptr.assumingMemoryBound(to: InternalGeneric<T>.self)
     let x = InternalGeneric(y: 23, x: x)
     testInit(ptr, to: x)
 }
 
 @inline(never)
-public func testGenericDestroy<T>(_ ptr: __owned UnsafeMutableRawPointer, of tpe: T.Type) {
+public func testGenericDestroy<T: ~Copyable>(_ ptr: __owned UnsafeMutableRawPointer, of tpe: T.Type) {
     let ptr = ptr.assumingMemoryBound(to: InternalGeneric<T>.self)
     testDestroy(ptr)
 }

test/Interpreter/layout_string_witnesses_dynamic.swift

@@ -4,7 +4,7 @@
 // RUN: %target-codesign %t/%target-library-name(layout_string_witnesses_types)
 // RUN: %target-swift-frontend -target %target-future-triple -enable-experimental-feature LayoutStringValueWitnesses -enable-experimental-feature LayoutStringValueWitnessesInstantiation -enable-layout-string-value-witnesses -enable-layout-string-value-witnesses-instantiation -enable-library-evolution -enable-autolinking-runtime-compatibility-bytecode-layouts -emit-module -emit-module-path=%t/layout_string_witnesses_types_resilient.swiftmodule %S/Inputs/layout_string_witnesses_types_resilient.swift
 // RUN: %target-build-swift -target %target-future-triple -g -Xfrontend -enable-experimental-feature -Xfrontend LayoutStringValueWitnesses -Xfrontend -enable-experimental-feature -Xfrontend LayoutStringValueWitnessesInstantiation -Xfrontend -enable-layout-string-value-witnesses -Xfrontend -enable-layout-string-value-witnesses-instantiation -Xfrontend -enable-library-evolution -c -parse-as-library -o %t/layout_string_witnesses_types_resilient.o %S/Inputs/layout_string_witnesses_types_resilient.swift
-// RUN: %target-build-swift -target %target-future-triple -g -parse-stdlib -module-name layout_string_witnesses_dynamic -llayout_string_witnesses_types -L%t %t/layout_string_witnesses_types_resilient.o -I %t -o %t/main %s %target-rpath(%t)
+// RUN: %target-build-swift -target %target-future-triple -g -Xfrontend -enable-experimental-feature -Xfrontend LayoutStringValueWitnesses -Xfrontend -enable-experimental-feature -Xfrontend LayoutStringValueWitnessesInstantiation -Xfrontend -enable-layout-string-value-witnesses -Xfrontend -enable-layout-string-value-witnesses-instantiation -parse-stdlib -module-name layout_string_witnesses_dynamic -llayout_string_witnesses_types -L%t %t/layout_string_witnesses_types_resilient.o -I %t -o %t/main %s %target-rpath(%t)
 // RUN: %target-codesign %t/main
 // RUN: %target-run %t/main %t/%target-library-name(layout_string_witnesses_types) | %FileCheck %s --check-prefix=CHECK -check-prefix=CHECK-%target-os
 
@@ -1275,6 +1275,72 @@ func testNonCopyableGenericEnumSimpleClass() {
 
 testNonCopyableGenericEnumSimpleClass()
 
+public struct NonCopyableResilientWrapper: ~Copyable {
+    let x: SimpleResilient
+    let y: Int
+}
+
+func testNonCopyableResilientStruct() {
+    let ptr = allocateInternalGenericPtr(of: NonCopyableResilientWrapper.self)
+
+    do {
+        let x = TestClass()
+        testGenericInit(ptr, to: NonCopyableResilientWrapper(x: SimpleResilient(x: 23, y: x), y: 5))
+    }
+
+    do {
+        let y = TestClass()
+        // CHECK: Before deinit
+        print("Before deinit")
+
+        // CHECK-NEXT: TestClass deinitialized!
+        testGenericAssign(ptr, from: NonCopyableResilientWrapper(x: SimpleResilient(x: 23, y: y), y: 7))
+    }
+
+    // CHECK-NEXT: Before deinit
+    print("Before deinit")
+
+    // CHECK-NEXT: TestClass deinitialized!
+    testGenericDestroy(ptr, of: NonCopyableResilientWrapper.self)
+
+    ptr.deallocate()
+}
+
+testNonCopyableResilientStruct()
+
+public enum NonCopyableResilientEnum: ~Copyable {
+    case x(SimpleResilient, Int)
+    case y(Int)
+}
+
+func testNonCopyableResilientEnum() {
+    let ptr = allocateInternalGenericPtr(of: NonCopyableResilientEnum.self)
+
+    do {
+        let x = TestClass()
+        testGenericInit(ptr, to: NonCopyableResilientEnum.x(SimpleResilient(x: 23, y: x), 5))
+    }
+
+    do {
+        let y = TestClass()
+        // CHECK: Before deinit
+        print("Before deinit")
+
+        // CHECK-NEXT: TestClass deinitialized!
+        testGenericAssign(ptr, from: NonCopyableResilientEnum.x(SimpleResilient(x: 23, y: y), 7))
+    }
+
+    // CHECK-NEXT: Before deinit
+    print("Before deinit")
+
+    // CHECK-NEXT: TestClass deinitialized!
+    testGenericDestroy(ptr, of: NonCopyableResilientEnum.self)
+
+    ptr.deallocate()
+}
+
+testNonCopyableResilientEnum()
+
 #if os(macOS)
 
 import Foundation