Merge pull request #72313 from nate-chandler/rdar124552608

[BitwiseCopyable] Loosen validation assertion.

Author: nate-chandler

lib/SIL/IR/TypeLowering.cpp

@@ -3196,15 +3196,18 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
     if (hasNoNonconformingNode) {
       llvm::errs() << "Trivial type without a BitwiseCopyable conformance!?:\n"
                    << substType << "\n"
-                   << "of " << origType << "\n";
+                   << "of " << origType << "\n"
+                   << "Disable this validation with -Xllvm "
+                      "-type-lowering-disable-verification.\n";
       assert(false);
     }
   }
 
   if (!lowering.isTrivial() && conformance) {
-    // A non-trivial type can have a conformance in one case:
+    // A non-trivial type can have a conformance in a few cases:
     // (1) contains a conforming archetype
     // (2) is resilient with minimal expansion
+    // (3) containing or being ~Escapable
     bool hasNoConformingArchetypeNode = visitAggregateLeaves(
         origType, substType, forExpansion,
         /*isLeaf=*/
@@ -3217,6 +3220,12 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
                   ResilienceExpansion::Minimal) {
             return true;
           }
+          // A type that may not be escapable is non-trivial but can conform
+          // (case (3)).
+          if (nominal &&
+              nominal->canBeEscapable() != TypeDecl::CanBeInvertible::Always) {
+            return true;
+          }
           // Walk into every aggregate.
           return false;
         },
@@ -3236,6 +3245,13 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
             return false;
           }
 
+          // A type that may not be escapable is non-trivial but can conform
+          // (case (3)).
+          if (nominal &&
+              nominal->canBeEscapable() != TypeDecl::CanBeInvertible::Always) {
+            return false;
+          }
+
           // An archetype may conform but be non-trivial (case (1)).
           if (origTy.isTypeParameter())
             return false;
@@ -3246,7 +3262,9 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
       llvm::errs() << "Non-trivial type with _BitwiseCopyable conformance!?:\n"
                    << substType << "\n";
       conformance.print(llvm::errs());
-      llvm::errs() << "\n";
+      llvm::errs() << "\n"
+                   << "Disable this validation with -Xllvm "
+                      "-type-lowering-disable-verification.\n";
       assert(false);
     }
   }

test/SILGen/bitwise_copyable_stdlib.swift

@@ -0,0 +1,30 @@
+// R N: %target-swift-frontend -enable-experimental-feature NonescapableTypes -enable-experimental-feature BuiltinModule -enable-experimental-feature NoncopyableGenerics -parse-stdlib -module-name Swift -DEMPTY -emit-sil -verify %s
+
+// RUN: %target-swift-frontend                               \
+// RUN:     -emit-sil                                        \
+// RUN:     %s                                               \
+// RUN:     -parse-stdlib                                    \
+// RUN:     -module-name Swift                               \
+// RUN:     -disable-availability-checking                   \
+// RUN:     -enable-experimental-feature BuiltinModule       \
+// RUN:     -enable-experimental-feature BitwiseCopyable     \
+// RUN:     -enable-experimental-feature NoncopyableGenerics \
+// RUN:     -enable-experimental-feature NonescapableTypes   \
+// RUN:     -enable-builtin-module
+
+// REQUIRES: asserts
+
+// Force verification of TypeLowering's isTrivial.
+
+import Builtin
+
+@_marker public protocol Copyable: ~Escapable {}
+@_marker public protocol Escapable: ~Copyable {}
+@_marker public protocol _BitwiseCopyable : ~Escapable {}
+
+struct Storage : ~Escapable, _BitwiseCopyable {}
+
+
+func take<T : _BitwiseCopyable & ~Escapable>(_ t: T) {}
+
+func passStorage(_ s: Storage) { take(s) }