[Sema] Warn on uses of @_implementationOnly imports without library-evolution

@_implementationOnly was designed for use from resilient modules only,
using it from non-resilient modules in unsupported. This change adds a
warning about it.

If anyone hits this warning, they should either enable library-evolution
or consider adopting the new `internal import` when it is available as
it handles this scenario properly.

What leads to a crash: an @_implementationOnly import fully hides the
dependency from indirect clients. This can lead to the compiler being
unaware of some internal details of a non-resilient module when building
a client against it. In turn this may lead to run time crashes from
miscompilation.

In general one could still use @_implementationOnly in a non-resilient
modules as long as it's referenced only from function bodies. However,
references from even non-public properties does lead to important memory
layout information being hidden from clients of the module.

rdar://78129903

Author: xymus

include/swift/AST/DiagnosticsSema.def

@@ -1098,6 +1098,10 @@ ERROR(module_not_compiled_with_library_evolution,none,
       "module %0 was not compiled with library evolution support; "
       "using it means binary compatibility for %1 can't be guaranteed",
       (Identifier, Identifier))
+WARNING(implementation_only_requires_library_evolution,none,
+        "using '@_implementationOnly' without enabling library evolution "
+        "for %0 may lead to instability during execution",
+        (Identifier))
 
 ERROR(module_allowable_client_violation,none,
       "module %0 doesn't allow importation from module %1",

lib/Sema/ImportResolution.cpp

@@ -796,6 +796,18 @@ void UnboundImport::validateResilience(NullablePtr<ModuleDecl> topLevelModule,
   if (topLevelModule.get() == ctx.TheBuiltinModule)
     return;
 
+  // @_implementationOnly is only supported when used from modules built with
+  // library-evolution. Otherwise it can lead to runtime crashes from a lack
+  // of memory layout information when building clients unaware of the
+  // dependency. The missing information is provided at run time by resilient
+  // modules.
+  if (import.options.contains(ImportFlags::ImplementationOnly) &&
+      !SF.getParentModule()->isResilient() && topLevelModule) {
+    ctx.Diags.diagnose(import.importLoc,
+                       diag::implementation_only_requires_library_evolution,
+                       SF.getParentModule()->getName());
+  }
+
   if (import.options.contains(ImportFlags::ImplementationOnly) ||
       import.accessLevel < AccessLevel::Public)
     return;

test/Sema/implementation-only-import-from-non-resilient.swift

@@ -0,0 +1,23 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+/// Build 2 libs.
+// RUN: %target-swift-frontend -emit-module %t/empty.swift -o %t/A.swiftmodule \
+// RUN:   -enable-library-evolution -swift-version 5
+// RUN: %target-swift-frontend -emit-module %t/empty.swift -o %t/B.swiftmodule \
+// RUN:   -enable-library-evolution -swift-version 5
+
+/// Build a client with and without library-evolution.
+// RUN: %target-swift-frontend -typecheck %t/client-non-resilient.swift -I %t -verify
+// RUN: %target-swift-frontend -typecheck %t/client-resilient.swift -I %t -verify \
+// RUN:   -enable-library-evolution -swift-version 5
+
+//--- empty.swift
+
+//--- client-non-resilient.swift
+@_implementationOnly import A // expected-warning {{using '@_implementationOnly' without enabling library evolution for 'main' may lead to instability during execution}}
+import B
+
+//--- client-resilient.swift
+@_implementationOnly import A
+import B