[BitwiseCopyable] Uniform inference for non-frozen

Don't key inference behavior off of library evolution mode.

Author: nate-chandler

lib/SIL/IR/TypeLowering.cpp

@@ -3049,7 +3049,7 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
 
   if (lowering.isTrivial() && !conformance) {
     // A trivial type can lack a conformance in a few cases:
-    // (1) containing or being a resilient type
+    // (1) containing or being a public, non-frozen type
     // (2) containing or being a generic type which doesn't conform
     //     unconditionally but in this particular instantiation is trivial
     // (3) being a special type that's not worth forming a conformance for
@@ -3082,8 +3082,11 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
             return true;
           }
 
-          // Resilient trivial types may not conform (case (1)).
-          if (nominal->isResilient())
+          // Public, non-frozen trivial types may not conform (case (1)).
+          if (nominal
+                  ->getFormalAccessScope(/*useDC=*/nullptr,
+                                         /*treatUsableFromInlineAsPublic=*/true)
+                  .isPublic())
             return true;
 
           auto *module = nominal->getModuleContext();
@@ -3149,8 +3152,11 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
             return false;
           }
 
-          // Resilient trivial types may not conform (case (1)).
-          if (nominal->isResilient())
+          // Public, non-frozen trivial types may not conform (case (1)).
+          if (nominal
+                  ->getFormalAccessScope(/*useDC=*/nullptr,
+                                         /*treatUsableFromInlineAsPublic=*/true)
+                  .isPublic())
             return false;
 
           auto *module = nominal->getModuleContext();

lib/Sema/TypeCheckBitwise.cpp

@@ -57,8 +57,7 @@ getImplicitCheckForNominal(NominalTypeDecl *nominal) {
   if (!nominal
            ->getFormalAccessScope(
                /*useDC=*/nullptr, /*treatUsableFromInlineAsPublic=*/true)
-           .isPublic() ||
-      !nominal->isResilient())
+           .isPublic())
     return {BitwiseCopyableCheck::Implicit};
 
   if (nominal->hasClangNode() ||

test/SILGen/bitwise_copyable.swift

@@ -40,7 +40,7 @@ enum Context<T> {
 
 func doit() -> Context<Int>.Here { .init(t: 0) }
 
-public enum E {
+public enum E : _BitwiseCopyable {
   case a
 }
 

test/Sema/bitwise_copyable.swift

@@ -62,7 +62,8 @@ struct S_Explicit_With_Function_C : _BitwiseCopyable {
 public struct S_Public {}
 
 struct S_Explicit_With_S_Public : _BitwiseCopyable {
-  var s: S_Public
+  var s: S_Public // expected-error   {{non_bitwise_copyable_type_member}}
+                  // expected-note@-4 {{add_nominal_bitwise_copyable_conformance}}
 }
 
 struct S_Explicit_With_Generic<T> : _BitwiseCopyable {

test/Sema/bitwise_copyable_nonresilient.swift

@@ -32,15 +32,17 @@ import Library
 func take<T: _BitwiseCopyable>(_ t: T) {}
 
 struct S_Explicit_With_Oopsional<T> : _BitwiseCopyable {
-  var o: Oopsional<T>
+  var o: Oopsional<T> // expected-error{{non_bitwise_copyable_type_member}}
 }
 
-func passOopsional<T>(_ t: Oopsional<T>) { take(t) }
+func passOopsional<T>(_ t: Oopsional<T>) { take(t) } // expected-error{{type_does_not_conform_decl_owner}}
+                                                     // expected-note@-7{{where_requirement_failure_one_subst}}
 
 
 struct S_Explicit_With_Woopsional<T> : _BitwiseCopyable {
-  var o: Woopsional<T>
+  var o: Woopsional<T> // expected-error{{non_bitwise_copyable_type_member}}
 }
 
-func passWoopsional<T>(_ t: Woopsional<T>) { take(t) }
+func passWoopsional<T>(_ t: Woopsional<T>) { take(t) } // expected-error{{type_does_not_conform_decl_owner}}
+                                                       // expected-note@-15{{where_requirement_failure_one_subst}}