[BitwiseCopyable] Suppress via ~.

In addition to the existing language mechanism of
`@available(*, unavailable)`.

Author: nate-chandler

include/swift/AST/DiagnosticsSema.def

@@ -7673,6 +7673,8 @@ ERROR(non_bitwise_copyable_type_indirect_enum_element,none,
       "enum with indirect case cannot conform to 'BitwiseCopyable'", ())
 NOTE(note_non_bitwise_copyable_type_indirect_enum_element,none,
      "indirect case is here", ())
+ERROR(non_bitwise_copyable_type_suppressed,none,
+      "cannot both conform to and suppress conformance to 'BitwiseCopyable'", ())
 ERROR(non_bitwise_copyable_type_noncopyable,none,
       "noncopyable type cannot conform to 'BitwiseCopyable'", ())
 ERROR(non_bitwise_copyable_type_cxx_nontrivial,none,

lib/SIL/IR/TypeLowering.cpp

@@ -3075,6 +3075,7 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
     // (7) being or containing a variadic generic type which doesn't conform
     //     unconditionally but does in this case
     // (8) being or containing the error type
+    // (9) explicitly suppressing conformance
     bool hasNoNonconformingNode = visitAggregateLeaves(
         origType, substType, forExpansion,
         /*isLeafAggregate=*/
@@ -3090,6 +3091,13 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
           if (!nominal)
             return false;
 
+          // A trivial type that suppresses conformance doesn't conform (case
+          // (9)).
+          if (nominal && nominal->suppressesConformance(
+                             KnownProtocolKind::BitwiseCopyable)) {
+            return true;
+          }
+
           // Nominals with fields that are generic may not conform
           // unconditionally (the only kind automatically derived currently)
           // and so may lack a conformance (case (2)).
@@ -3170,6 +3178,13 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
             return true;
           }
 
+          // A trivial type that suppresses conformance doesn't conform (case
+          // (9)).
+          if (nominal->suppressesConformance(
+                  KnownProtocolKind::BitwiseCopyable)) {
+            return false;
+          }
+
           // A generic type may be trivial when instantiated with particular
           // types but lack a conformance (case (3)).
           if (nominal->isGenericContext()) {

lib/Sema/TypeCheckBitwise.cpp

@@ -229,6 +229,13 @@ void BitwiseCopyableStorageVisitor::emitNonconformingMemberTypeDiagnostic(
 static bool checkBitwiseCopyableInstanceStorage(NominalTypeDecl *nominal,
                                                 DeclContext *dc,
                                                 BitwiseCopyableCheck check) {
+  if (nominal->suppressesConformance(KnownProtocolKind::BitwiseCopyable)) {
+    if (!isImplicit(check)) {
+      nominal->diagnose(diag::non_bitwise_copyable_type_suppressed);
+    }
+    return true;
+  }
+
   assert(dc->getParentModule()->getASTContext().getProtocol(
       KnownProtocolKind::BitwiseCopyable));
 

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -122,6 +122,12 @@ struct CheckSuppressions {
 
   bool canSuppress(KnownProtocolKind kp) {
     switch (kp) {
+    case KnownProtocolKind::BitwiseCopyable:
+    // TODO:
+    // case KnownProtocolKind::Sendable:
+    // case KnownProtocolKind::Equatable:
+    // case KnownProtocolKind::Hashable:
+      return true;
     default:
       return false;
     }

stdlib/public/core/CMakeLists.txt

@@ -317,6 +317,7 @@ list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "Freestand
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "Extern")
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "BitwiseCopyable")
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "BorrowingSwitch")
+list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "ConformanceSuppression")
 
 if("${SWIFT_NATIVE_SWIFT_TOOLS_PATH}" STREQUAL "")
   set(swift_bin_dir "${CMAKE_BINARY_DIR}/bin")

stdlib/public/core/CommandLine.swift

@@ -19,8 +19,17 @@ internal func _swift_stdlib_getUnsafeArgvArgc(_: UnsafeMutablePointer<Int32>)
   -> UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>
 
 /// Command-line arguments for the current process.
+#if $BitwiseCopyable && $ConformanceSuppression
 @frozen // namespace
-public enum CommandLine {}
+public enum CommandLine : ~_BitwiseCopyable {
+}
+#else
+@frozen // namespace
+public enum CommandLine {
+}
+@available(*, unavailable)
+extension CommandLine : _BitwiseCopyable {}
+#endif
 
 extension CommandLine {
   /// The backing static variable for argument count may come either from the
@@ -104,7 +113,4 @@ extension CommandLine {
   }
 }
 
-@available(*, unavailable)
-extension CommandLine : _BitwiseCopyable {}
-
 #endif // SWIFT_STDLIB_HAS_COMMANDLINE

stdlib/public/core/MemoryLayout.swift

@@ -39,11 +39,15 @@
 ///     let pointPointer = UnsafeMutableRawPointer.allocate(
 ///             byteCount: count * MemoryLayout<Point>.stride,
 ///             alignment: MemoryLayout<Point>.alignment)
+#if $BitwiseCopyable && $ConformanceSuppression
+@frozen // namespace
+public enum MemoryLayout<T: ~Copyable>: ~_BitwiseCopyable, Copyable {}
+#else
 @frozen // namespace
 public enum MemoryLayout<T: ~Copyable>: Copyable {}
-
 @available(*, unavailable)
 extension MemoryLayout: _BitwiseCopyable {}
+#endif
 
 extension MemoryLayout where T: ~Copyable {
   /// The contiguous memory footprint of `T`, in bytes.

stdlib/public/core/Unicode.swift

@@ -671,9 +671,11 @@ public func transcode<Input, InputEncoding, OutputEncoding>(
 }
 
 /// A namespace for Unicode utilities.
+#if $BitwiseCopyable && $ConformanceSuppression
+@frozen
+public enum Unicode : ~_BitwiseCopyable {}
+#else
 @frozen
 public enum Unicode {}
-
-@available(*, unavailable)
-extension Unicode : _BitwiseCopyable {}
+#endif
 

test/SILGen/bitwise_copyable.swift

@@ -1,8 +1,9 @@
-// RUN: %target-swift-frontend                           \
-// RUN:     %s                                           \
-// RUN:     -emit-silgen                                 \
-// RUN:     -disable-availability-checking               \
-// RUN:     -enable-experimental-feature BitwiseCopyable \
+// RUN: %target-swift-frontend                                  \
+// RUN:     %s                                                  \
+// RUN:     -emit-silgen                                        \
+// RUN:     -disable-availability-checking                      \
+// RUN:     -enable-experimental-feature ConformanceSuppression \
+// RUN:     -enable-experimental-feature BitwiseCopyable        \
 // RUN:     -enable-builtin-module
 
 // REQUIRES: asserts
@@ -59,3 +60,5 @@ struct NeverGoingToBeBitwiseCopyable {
 @available(*, unavailable)
 extension NeverGoingToBeBitwiseCopyable : _BitwiseCopyable {
 }
+
+struct AlsoNotBitwiseCopyable : ~_BitwiseCopyable {}

test/Sema/bitwise_copyable_2.swift

@@ -1,7 +1,8 @@
-// RUN: %target-typecheck-verify-swift                       \
-// RUN:     -enable-experimental-feature NonescapableTypes   \
-// RUN:     -enable-experimental-feature BitwiseCopyable     \
-// RUN:     -enable-builtin-module                           \
+// RUN: %target-typecheck-verify-swift                          \
+// RUN:     -enable-experimental-feature NonescapableTypes      \
+// RUN:     -enable-experimental-feature ConformanceSuppression \
+// RUN:     -enable-experimental-feature BitwiseCopyable        \
+// RUN:     -enable-builtin-module                              \
 // RUN:     -debug-diagnostic-names
 
 // This test file only exists in order to test without noncopyable_generics and can be deleted once that is always enabled.
@@ -35,11 +36,14 @@ func take<T : _BitwiseCopyable>(_ t: T) {}
 func passInternalUsableStruct(_ s: InternalUsableStruct) { take(s) } // expected-error{{type_does_not_conform_decl_owner}}
                                                                      // expected-note@-8{{where_requirement_failure_one_subst}}
 
-func passMemoryLayout<T>(_ m: MemoryLayout<T>) { take(m) } // expected-error{{conformance_availability_unavailable}}
+func passMemoryLayout<T>(_ m: MemoryLayout<T>) { take(m) } // expected-error{{global function 'take' requires that 'MemoryLayout<T>' conform to '_BitwiseCopyable'}}
+                                                           // expected-note@-11{{where 'T' = 'MemoryLayout<T>'}}
 
-func passCommandLine(_ m: CommandLine) { take(m) } // expected-error{{conformance_availability_unavailable}}
+func passCommandLine(_ m: CommandLine) { take(m) } // expected-error{{global function 'take' requires that 'CommandLine' conform to '_BitwiseCopyable'}}
+                                                   // expected-note@-14{{where 'T' = 'CommandLine'}}
 
-func passUnicode(_ m: Unicode) { take(m) } // expected-error{{conformance_availability_unavailable}}
+func passUnicode(_ m: Unicode) { take(m) } // expected-error{{global function 'take' requires that 'Unicode' conform to '_BitwiseCopyable'}}
+                                           // expected-note@-17{{where 'T' = 'Unicode'}}
 
 import Builtin
 
@@ -62,3 +66,29 @@ enum E_Raw_String : String {
 }
 
 func passE_Raw_String(_ e: E_Raw_String) { take(e) }
+
+struct S_Suppressed : ~_BitwiseCopyable {
+  var i: Int
+}
+
+func passS_Suppressed(_ s: S_Suppressed) { take(s) } // expected-error{{global function 'take' requires that 'S_Suppressed' conform to '_BitwiseCopyable'}}
+                                                     // expected-note@-46{{where 'T' = 'S_Suppressed'}}
+
+struct S_Suppressed_Extension {}
+extension S_Suppressed_Extension : ~_BitwiseCopyable {} // expected-error{{conformance to inferrable protocol '_BitwiseCopyable' cannot be suppressed in an extension}}
+
+struct S_Explicit_Suppressed : _BitwiseCopyable, ~_BitwiseCopyable {} // expected-error{{cannot both conform to and suppress conformance to 'BitwiseCopyable'}}
+
+func passS_Explicit_Suppressed(_ s: S_Explicit_Suppressed) { take(s) }
+
+struct S_Suppressed_Explicit : ~_BitwiseCopyable, _BitwiseCopyable {} // expected-error{{cannot both conform to and suppress conformance to 'BitwiseCopyable'}}
+
+func passS_Explicit_Suppressed(_ s: S_Suppressed_Explicit) { take(s) }
+
+struct S_Suppressed_Twice : ~_BitwiseCopyable, ~_BitwiseCopyable {} // expected-warning{{already suppressed conformance to '_BitwiseCopyable'}}
+
+enum E : ~Equatable { // expected-error{{conformance to 'Equatable' cannot be suppressed}}
+  case i
+  case e
+  case io
+}