Sema: Consider non-LE structs to be of a restricted type by default

In non-library-evolution mode, gated behind the CheckImplementationOnly
feature flag, report references to structs marked with
`@_implementationOnly` from a fragile context. Preventing references
from inlinable functions and structs not marked `@_implementationOnly`.

Author: xymus

include/swift/AST/DiagnosticsSema.def

@@ -3847,7 +3847,8 @@ ERROR(decl_from_hidden_module,none,
       "%2 was not imported by this file|"
       "C++ types from imported module %2 do not support library evolution|"
       "it was imported via the internal bridging header|"
-      "%2 was not imported publicly}3",
+      "%2 was not imported publicly|"
+      "it is a struct marked '@_implementationOnly'}3",
       (const Decl *, unsigned, Identifier, unsigned))
 ERROR(typealias_desugars_to_type_from_hidden_module,none,
       "%0 aliases '%1.%2' and cannot be used %select{here|"
@@ -3865,7 +3866,8 @@ ERROR(typealias_desugars_to_type_from_hidden_module,none,
       "%4 was not imported by this file|"
       "C++ types from imported module %4 do not support library evolution|"
       "it was imported via the internal bridging header|"
-      "%4 was not imported publicly}5",
+      "%4 was not imported publicly|"
+      "it is a struct marked '@_implementationOnly'}5",
       (const TypeAliasDecl *, StringRef, StringRef, unsigned, Identifier, unsigned))
 ERROR(conformance_from_implementation_only_module,none,
       "cannot use conformance of %0 to %1 %select{here|as property wrapper here|"
@@ -3881,7 +3883,8 @@ ERROR(conformance_from_implementation_only_module,none,
       "%3 was not imported by this file|"
       "C++ types from imported module %3 do not support library evolution|"
       "it was imported via the internal bridging header|"
-      "%3 was not imported publicly}4",
+      "%3 was not imported publicly|"
+      "it is a struct marked '@_implementationOnly'}4",
       (Type, Identifier, unsigned, Identifier, unsigned))
 NOTE(assoc_conformance_from_implementation_only_module,none,
      "in associated type %0 (inferred as %1)", (Type, Type))
@@ -7349,7 +7352,8 @@ ERROR(inlinable_decl_ref_from_hidden_module,
       "%2 was not imported by this file|"
       "C++ APIs from imported module %2 do not support library evolution|"
       "it was imported via the internal bridging header|"
-      "%2 was not imported publicly}3",
+      "%2 was not imported publicly|"
+      "it is a struct marked '@_implementationOnly'}3",
       (const ValueDecl *, unsigned, Identifier, unsigned))
 
 ERROR(inlinable_typealias_desugars_to_type_from_hidden_module,
@@ -7361,7 +7365,8 @@ ERROR(inlinable_typealias_desugars_to_type_from_hidden_module,
       "%4 was not imported by this file|"
       "C++ types from imported module %4 do not support library evolution|"
       "it was imported via the internal bridging header|"
-      "%4 was not imported publicly}5",
+      "%4 was not imported publicly|"
+      "it is a struct marked '@_implementationOnly'}5",
       (const TypeAliasDecl *, StringRef, StringRef, unsigned, Identifier, unsigned))
 
 NOTE(missing_import_inserted,

lib/Sema/ResilienceDiagnostics.cpp

@@ -338,6 +338,7 @@ static bool diagnoseValueDeclRefExportability(SourceLoc loc, const ValueDecl *D,
 
   case DisallowedOriginKind::ImplementationOnly:
   case DisallowedOriginKind::FragileCxxAPI:
+  case DisallowedOriginKind::ImplementationOnlyMemoryLayout:
     break;
   }
 

lib/Sema/TypeCheckAccess.cpp

@@ -2163,6 +2163,14 @@ swift::getDisallowedOriginKind(const Decl *decl,
           Feature::AssumeResilientCxxTypes))
     return DisallowedOriginKind::FragileCxxAPI;
 
+  if (isa<StructDecl>(decl) || isa<EnumDecl>(decl)) {
+    if (decl->getASTContext().LangOpts.hasFeature(
+            Feature::CheckImplementationOnly) &&
+        decl->getAttrs().hasAttribute<ImplementationOnlyAttr>()) {
+      return DisallowedOriginKind::ImplementationOnlyMemoryLayout;
+    }
+  }
+
   // Report non-public import last as it can be ignored by the caller.
   // See \c diagnoseValueDeclRefExportability.
   auto importSource = decl->getImportAccessFrom(where.getDeclContext());

lib/Sema/TypeCheckAccess.h

@@ -32,7 +32,7 @@ class SourceFile;
 /// itself. Related checks may also be performed.
 void checkAccessControl(Decl *D);
 
-/// Problematic origin of an exported type.
+/// Problematic origin of a decl that may restrict its exportability.
 ///
 /// This enum must be kept in sync with a number of diagnostics:
 ///   diag::inlinable_decl_ref_from_hidden_module
@@ -52,6 +52,7 @@ enum class DisallowedOriginKind : uint8_t {
   InternalBridgingHeaderImport,
 
   NonPublicImport,
+  ImplementationOnlyMemoryLayout,
   None
 };
 

test/Sema/hidden-memory-layout.swift

@@ -0,0 +1,206 @@
+/// Test @_implementationOnly import exportability diagnostics in non-library-evolution mode
+
+/// Standard / non-embedded
+
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -o %t/indirects.swiftmodule \
+// RUN:   %S/Inputs/implementation-only-imports/indirects.swift \
+// RUN:   -swift-version 5
+// RUN: %target-swift-frontend -emit-module -o %t/directs.swiftmodule -I %t\
+// RUN:    %S/Inputs/implementation-only-imports/directs.swift \
+// RUN:   -swift-version 5
+
+/// Old diags
+// RUN: %target-swift-frontend -emit-module -verify -verify-ignore-unrelated %s -I %t \
+// RUN:   -swift-version 5 \
+// RUN:   -verify-additional-prefix not-opt-in-
+
+/// New diags
+// RUN: %target-swift-frontend -emit-module -verify -verify-ignore-unrelated %s -I %t \
+// RUN:   -swift-version 5 \
+// RUN:   -verify-additional-prefix opt-in- -DUseImplementationOnly \
+// RUN:   -enable-experimental-feature CheckImplementationOnly
+
+/// Embedded
+/// Will also show errors in non-@_neverEmitIntoClient functions.
+
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -o %t/indirects.swiftmodule \
+// RUN:   %S/Inputs/implementation-only-imports/indirects.swift \
+// RUN:   -swift-version 5 -target arm64-apple-none-macho \
+// RUN:   -enable-experimental-feature Embedded
+// RUN: %target-swift-frontend -emit-module -o %t/directs.swiftmodule -I %t\
+// RUN:    %S/Inputs/implementation-only-imports/directs.swift \
+// RUN:   -swift-version 5 -target arm64-apple-none-macho \
+// RUN:   -enable-experimental-feature Embedded
+
+/// Old diags
+// RUN: %target-swift-frontend -emit-module -verify -verify-ignore-unrelated %s -I %t \
+// RUN:   -swift-version 5 -target arm64-apple-none-macho \
+// RUN:   -enable-experimental-feature Embedded \
+// RUN:   -verify-additional-prefix not-opt-in-
+
+/// New diags
+// RUN: %target-swift-frontend -emit-module -verify -verify-ignore-unrelated %s -I %t \
+// RUN:   -swift-version 5 -target arm64-apple-none-macho \
+// RUN:   -enable-experimental-feature Embedded \
+// RUN:   -verify-additional-prefix opt-in- -DUseImplementationOnly \
+// RUN:   -verify-additional-prefix embedded-opt-in- \
+// RUN:   -enable-experimental-feature CheckImplementationOnly
+
+// REQUIRES: swift_feature_Embedded
+// REQUIRES: swift_feature_CheckImplementationOnly
+// REQUIRES: embedded_stdlib_cross_compiling
+
+@_implementationOnly import directs
+// expected-warning @-1 {{using '@_implementationOnly' without enabling library evolution for 'main' may lead to instability during execution}}
+import indirects
+
+/// Referenced types
+
+public struct ExposedLayoutPublic {
+  public init() { fatalError() }
+}
+
+private struct ExposedLayoutPrivate {
+// expected-note @-1 2 {{struct 'ExposedLayoutPrivate' is not '@usableFromInline' or public}}
+// expected-opt-in-note @-2 {{type declared here}}
+  init() { fatalError() } // expected-note {{initializer 'init()' is not '@usableFromInline' or public}}
+}
+
+#if UseImplementationOnly
+@_implementationOnly
+private struct HiddenLayout {
+// expected-opt-in-note @-1 2 {{struct 'HiddenLayout' is not '@usableFromInline' or public}}
+// expected-opt-in-note @-2 1 {{initializer 'init()' is not '@usableFromInline' or public}}
+// expected-opt-in-note @-3 2 {{struct declared here}}
+// expected-opt-in-note @-4 {{type declared here}}
+}
+#else
+private struct HiddenLayout {
+// expected-not-opt-in-note @-1 2 {{struct 'HiddenLayout' is not '@usableFromInline' or public}}
+// expected-not-opt-in-note @-2 1 {{initializer 'init()' is not '@usableFromInline' or public}}
+}
+#endif
+
+public enum ExposedEnumPublic {
+  case A
+  case B
+}
+
+private enum ExposedEnumPrivate {
+// expected-note @-1 2 {{enum 'ExposedEnumPrivate' is not '@usableFromInline' or public}}
+  case A
+// expected-note @-1 1 {{enum case 'A' is not '@usableFromInline' or public}}
+  case B
+}
+
+/// Function use sites
+
+@inlinable
+public func explicitlyInlinable() {
+  let _: ExposedLayoutPublic = ExposedLayoutPublic()
+  let _: ExposedLayoutPrivate = ExposedLayoutPrivate()
+  // expected-error @-1 2 {{struct 'ExposedLayoutPrivate' is private and cannot be referenced from an '@inlinable' function}}
+  // expected-error @-2 {{initializer 'init()' is private and cannot be referenced from an '@inlinable' function}}
+
+  let _: HiddenLayout = HiddenLayout()
+  // expected-error @-1 2 {{struct 'HiddenLayout' is private and cannot be referenced from an '@inlinable' function}}
+  // expected-error @-2 {{initializer 'init()' is private and cannot be referenced from an '@inlinable' function}}
+
+  let _: ExposedEnumPublic = ExposedEnumPublic.A
+  let _: ExposedEnumPrivate = ExposedEnumPrivate.A
+  // expected-error @-1 2 {{enum 'ExposedEnumPrivate' is private and cannot be referenced from an '@inlinable' function}}
+  // expected-error @-2 {{enum case 'A' is private and cannot be referenced from an '@inlinable' function}}
+}
+
+public func implicitlyInlinablePublic() {
+  let _: ExposedLayoutPublic = ExposedLayoutPublic()
+  let _: ExposedLayoutPrivate = ExposedLayoutPrivate()
+  let _: HiddenLayout = HiddenLayout()
+  // expected-embedded-opt-in-error @-1 2 {{struct 'HiddenLayout' cannot be used in an embedded function not marked '@_neverEmitIntoClient' because it is a struct marked '@_implementationOnly'}}
+
+  let _: ExposedEnumPublic = ExposedEnumPublic.A
+  let _: ExposedEnumPrivate = ExposedEnumPrivate.A
+}
+
+private func implicitlyInlinablePrivate() {
+  let _: ExposedLayoutPublic = ExposedLayoutPublic()
+  let _: ExposedLayoutPrivate = ExposedLayoutPrivate()
+  let _: HiddenLayout = HiddenLayout()
+  // expected-embedded-opt-in-error @-1 2 {{struct 'HiddenLayout' cannot be used in an embedded function not marked '@_neverEmitIntoClient' because it is a struct marked '@_implementationOnly'}}
+
+  let _: ExposedEnumPublic = ExposedEnumPublic.A
+  let _: ExposedEnumPrivate = ExposedEnumPrivate.A
+}
+
+@_neverEmitIntoClient
+public func explicitNonInliable() {
+  let _: ExposedLayoutPublic = ExposedLayoutPublic()
+  let _: ExposedLayoutPrivate = ExposedLayoutPrivate()
+  let _: HiddenLayout = HiddenLayout()
+  let _: ExposedEnumPublic = ExposedEnumPublic.A
+  let _: ExposedEnumPrivate = ExposedEnumPrivate.A
+}
+
+@_neverEmitIntoClient
+internal func explicitNonInliableInternal() {
+  let _: ExposedLayoutPublic = ExposedLayoutPublic()
+  let _: ExposedLayoutPrivate = ExposedLayoutPrivate()
+  let _: HiddenLayout = HiddenLayout()
+  let _: ExposedEnumPublic = ExposedEnumPublic.A
+  let _: ExposedEnumPrivate = ExposedEnumPrivate.A
+}
+
+/// Struct use sites
+
+public struct ExposedLayoutPublicUser {
+
+  public var publicField: StructFromDirect
+  // expected-error @-1 {{cannot use struct 'StructFromDirect' in a property declaration marked public or in a '@frozen' or '@usableFromInline' context; 'directs' has been imported as implementation-only}}
+
+  private var privateField: StructFromDirect
+  // expected-opt-in-error @-1 {{cannot use struct 'StructFromDirect' in a property declaration marked public or in a '@frozen' or '@usableFromInline' context; 'directs' has been imported as implementation-only}}
+
+  private var a: ExposedLayoutPublic
+  private var b: ExposedLayoutPrivate
+  // expected-opt-in-error @-1 {{type referenced from a stored property in a '@frozen' struct must be '@usableFromInline' or public}}
+
+  private var c: HiddenLayout
+  // expected-opt-in-error @-1 {{cannot use struct 'HiddenLayout' in a property declaration marked public or in a '@frozen' or '@usableFromInline' context; it is a struct marked '@_implementationOnly'}}
+  // expected-opt-in-error @-2 {{type referenced from a stored property in a '@frozen' struct must be '@usableFromInline' or public}}
+
+  private func privateFunc(h: HiddenLayout) {}
+  // expected-embedded-opt-in-error @-1 {{struct 'HiddenLayout' cannot be used in an embedded function not marked '@_neverEmitIntoClient' because it is a struct marked '@_implementationOnly'}}
+}
+
+private struct ExposedLayoutPrivateUser {
+
+  private var privateField: StructFromDirect
+  // expected-opt-in-error @-1 {{cannot use struct 'StructFromDirect' in a property declaration marked public or in a '@frozen' or '@usableFromInline' context; 'directs' has been imported as implementation-only}}
+
+  private var a: ExposedLayoutPublic
+  private var b: ExposedLayoutPrivate
+  private var c: HiddenLayout
+  // expected-opt-in-error @-1 {{cannot use struct 'HiddenLayout' in a property declaration marked public or in a '@frozen' or '@usableFromInline' context; it is a struct marked '@_implementationOnly'}}
+
+  private func privateFunc(h: HiddenLayout) {}
+  // expected-embedded-opt-in-error @-1 {{struct 'HiddenLayout' cannot be used in an embedded function not marked '@_neverEmitIntoClient' because it is a struct marked '@_implementationOnly'}}
+}
+
+#if UseImplementationOnly
+@_implementationOnly
+private struct HiddenLayoutUser {
+  public var publicField: StructFromDirect
+  private var privateField: StructFromDirect
+  private var a: ExposedLayoutPublic
+  private var b: ExposedLayoutPrivate
+  private var c: HiddenLayout
+
+  @_neverEmitIntoClient
+  private func privateFunc(h: HiddenLayout) {}
+}
+
+@_implementationOnly // expected-opt-in-error {{'@_implementationOnly' may not be used on public declarations}}
+public struct PublicHiddenStruct {}
+#endif