When package optimization is enabled, treat public decls as non-resilient

as well besides package decls if in the same package boundary.

Resolves rdar://123344579

Author: elsh

include/swift/AST/Decl.h

@@ -4099,20 +4099,36 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
 
   void setBraces(SourceRange braces) { Braces = braces; }
 
-  /// Should this declaration behave as if it must be accessed
-  /// resiliently, even when we're building a non-resilient module?
+  /// Returns whether this declaration is resilient at the definition site, i.e.
+  /// must be accessed resiliently even when its defining module is built
+  /// non-resiliently.
   ///
   /// This is used for diagnostics, because we do not want a behavior
   /// change between builds with resilience enabled and disabled.
   bool isFormallyResilient() const;
 
-  /// Do we need to use resilient access patterns outside of this type's
-  /// resilience domain?
+  /// Returns whether this decl is resilient at the definition site
+  /// \c isFormallyResilient or whether its defining module
+  /// is built resiliently.
   bool isResilient() const;
 
-  /// Do we need to use resilient access patterns when accessing this
-  /// type from the given module?
-  bool isResilient(ModuleDecl *M, ResilienceExpansion expansion) const;
+  /// Returns whether this decl is accessed non/resiliently at the _use_ site
+  /// in \p accessingModule, depending on \p expansion.
+  ///
+  /// If \p expansion is maximal, the decl could be treated as non-resilient
+  /// even though the decl is resilient by definition or its defining module is built
+  /// resiliently. For example, if accessing a decl defined in the same module or
+  /// another module in the same package as the \p accessingModule, the
+  /// decl could be treated as non-resilient (with package optimization enabled in
+  /// case of different modules); this enables bypassing resilience checks at the
+  /// use site so the decl can be accessed directly.
+  ///
+  /// \p accessingModule The module from which this decl is accessed. Might
+  ///                    be the same module as its defining module.
+  /// \p expansion Used to determine whether non-resilience / direct access
+  ///              to this decl is possible.
+  bool isResilient(ModuleDecl *accessingModule,
+                   ResilienceExpansion expansion) const;
 
   /// Determine whether we have already attempted to add any
   /// implicitly-defined initializers to this declaration.

lib/AST/Decl.cpp

@@ -4206,10 +4206,8 @@ bool ValueDecl::hasOpenAccess(const DeclContext *useDC) const {
 
 bool ValueDecl::bypassResilienceInPackage(ModuleDecl *accessingModule) const {
   return getASTContext().LangOpts.EnableBypassResilienceInPackage &&
-          getModuleContext()->inSamePackage(accessingModule) &&
-          !getModuleContext()->isBuiltFromInterface() &&
-          getFormalAccessScope(/*useDC=*/nullptr,
-                               /*treatUsableFromInlineAsPublic=*/true).isPackage();
+         getModuleContext()->inSamePackage(accessingModule) &&
+         !getModuleContext()->isBuiltFromInterface();
 }
 
 /// Given the formal access level for using \p VD, compute the scope where

test/SILGen/package_bypass_resilience.swift

@@ -34,12 +34,13 @@ func foo() {
 // CHECK: sil hidden [ossa] @$s6Client3fooyyF : $@convention(thin) () -> () {
 // CHECK-DEFAULT: [[F_REF:%.*]] = function_ref @$s5Utils9PkgStructV6pkgVarSivg : $@convention(method) (@in_guaranteed PkgStruct) -> Int
 // CHECK-DEFAULT: sil package_external @$s5Utils9PkgStructV6pkgVarSivg : $@convention(method) (@in_guaranteed PkgStruct) -> Int
-// CHECK-BYPASS:  [[ADDR:%.*]] = struct_element_addr %7 : $*PkgStruct, #PkgStruct.pkgVar
+// CHECK-BYPASS:  [[ADDR:%.*]] = struct_element_addr {{.*}} : $*PkgStruct, #PkgStruct.pkgVar
 
 func bar() {
   print(PubStruct().pubVar)
 }
 
 // CHECK: sil hidden [ossa] @$s6Client3baryyF : $@convention(thin) () -> () {
-// CHECK: [[F_REF:%.*]] = function_ref @$s5Utils9PubStructV6pubVarSivg : $@convention(method) (@in_guaranteed PubStruct) -> Int
-// CHECK: sil @$s5Utils9PubStructV6pubVarSivg : $@convention(method) (@in_guaranteed PubStruct) -> Int
+// CHECK-DEFAULT: [[F_REF:%.*]] = function_ref @$s5Utils9PubStructV6pubVarSivg : $@convention(method) (@in_guaranteed PubStruct) -> Int
+// CHECK-DEFAULT: sil @$s5Utils9PubStructV6pubVarSivg : $@convention(method) (@in_guaranteed PubStruct) -> Int
+// CHECK-BYPASS:  [[ADDR:%.*]] = struct_element_addr {{.*}} : $*PubStruct, #PubStruct.pubVar

test/Sema/package_resilience_bypass_exhaustive_switch.swift

@@ -35,10 +35,16 @@ public enum FrozenPublicEnum {
   case two(Int)
 }
 
+@usableFromInline
+enum UfiInternalEnum {
+  case one
+  case two(Int)
+}
+
 //--- ClientDefault.swift
 import Utils
 
-func f(_ arg: PkgEnum) -> Int {
+package func f(_ arg: PkgEnum) -> Int {
   switch arg { // expected-warning {{switch covers known cases, but 'PkgEnum' may have additional unknown values}} {{none}} expected-note {{handle unknown values using "@unknown default"}}
   case .one:
     return 1
@@ -47,7 +53,7 @@ func f(_ arg: PkgEnum) -> Int {
   }
 }
 
-func g(_ arg: UfiPkgEnum) -> Int {
+public func g(_ arg: UfiPkgEnum) -> Int {
   switch arg { // expected-warning {{switch covers known cases, but 'UfiPkgEnum' may have additional unknown values}} {{none}} expected-note {{handle unknown values using "@unknown default"}}
   case .one:
     return 1
@@ -74,33 +80,41 @@ public func k(_ arg: FrozenPublicEnum) -> Int {
   }
 }
 
+public func m(_ arg: UfiInternalEnum) -> Int {
+  switch arg { // no-warning
+  case .one:
+    return 1
+  case .two(let val):
+    return 2 + val
+  }
+}
+
 //--- ClientOptimized.swift
 import Utils
 
-// No warning with optimization to bypass resilience checks for package enums.
-func f(_ arg: PkgEnum) -> Int {
-  switch arg {
+// With optimization enabled to bypass resilience checks within
+// a package boundary, public (non-frozen) or package enums no
+// longer require `@unknown default` in source code switch stmts.
+package func f(_ arg: PkgEnum) -> Int {
+  switch arg { // no-warning
   case .one:
     return 1
   case .two(let val):
     return 2 + val
   }
 }
 
-// Warning still shows up for usableFromInline package enum as the optimization is targeted for
-// decls with package access, not the elevated public access. This might be allowed later.
-func g(_ arg: UfiPkgEnum) -> Int {
-  switch arg { // expected-warning {{switch covers known cases, but 'UfiPkgEnum' may have additional unknown values}} {{none}} expected-note {{handle unknown values using "@unknown default"}}
+public func g(_ arg: UfiPkgEnum) -> Int {
+  switch arg { // no-warning
   case .one:
     return 1
   case .two(let val):
     return 2 + val
   }
 }
 
-// Warning still shows up for public enum as the optimization is targeted for package types.
 public func h(_ arg: PublicEnum) -> Int {
-  switch arg { // expected-warning {{switch covers known cases, but 'PublicEnum' may have additional unknown values}} {{none}} expected-note {{handle unknown values using "@unknown default"}}
+  switch arg { // no-warning
   case .one:
     return 1
   case .two(let val):
@@ -116,3 +130,12 @@ public func k(_ arg: FrozenPublicEnum) -> Int {
     return 2 + val
   }
 }
+
+public func m(_ arg: UfiInternalEnum) -> Int {
+  switch arg { // no-warning
+  case .one:
+    return 1
+  case .two(let val):
+    return 2 + val
+  }
+}