Allow @usableFromInline and @inlinable to package decls

Add tests for packgae inline
Add more package acl tests

Resolves rdar://104617133

Author: elsh

include/swift/AST/DiagnosticsSema.def

@@ -2436,10 +2436,10 @@ WARNING(protocol_access_warn,none,
         (bool, AccessLevel, bool, AccessLevel, bool, DescriptiveDeclKind))
 ERROR(protocol_usable_from_inline,none,
       "protocol %select{refined|used}0 by '@usableFromInline' protocol "
-      "must be '@usableForInline' or public", (bool))
+      "must be '@usableFromInline' or public", (bool))
 WARNING(protocol_usable_from_inline_warn,none,
         "protocol %select{refined|used}0 by '@usableFromInline' protocol "
-        "should be '@usableForInline' or public", (bool))
+        "should be '@usableFromInline' or public", (bool))
 ERROR(protocol_property_must_be_computed_var,none,
       "protocols cannot require properties to be immutable; declare read-only "
       "properties by using 'var' with a '{ get }' specifier", ())
@@ -6159,7 +6159,7 @@ ERROR(frozen_attr_on_internal_type,
       (DeclName, AccessLevel))
 
 ERROR(usable_from_inline_attr_with_explicit_access,
-      none, "'@usableFromInline' attribute can only be applied to internal "
+      none, "'@usableFromInline' attribute can only be applied to internal or package "
       "declarations, but %0 is %select{private|fileprivate|%error|package|public|open}1",
       (DeclName, AccessLevel))
 

lib/AST/Decl.cpp

@@ -3646,7 +3646,7 @@ SourceLoc ValueDecl::getAttributeInsertionLoc(bool forModifier) const {
 /// Returns true if \p VD needs to be treated as publicly-accessible
 /// at the SIL, LLVM, and machine levels due to being @usableFromInline.
 bool ValueDecl::isUsableFromInline() const {
-  assert(getFormalAccess() <= AccessLevel::Internal);
+  assert(getFormalAccess() < AccessLevel::Public);
 
   if (getAttrs().hasAttribute<UsableFromInlineAttr>() ||
       getAttrs().hasAttribute<AlwaysEmitIntoClientAttr>() ||
@@ -3767,7 +3767,7 @@ static AccessLevel getAdjustedFormalAccess(const ValueDecl *VD,
     return getMaximallyOpenAccessFor(VD);
 
   if (treatUsableFromInlineAsPublic &&
-      access <= AccessLevel::Internal &&
+      access < AccessLevel::Public &&
       VD->isUsableFromInline()) {
     return AccessLevel::Public;
   }
@@ -4073,8 +4073,9 @@ static bool checkAccess(const DeclContext *useDC, const ValueDecl *VD,
       // marked 'public' if the protocol was '@_versioned' (now
       // '@usableFromInline'). Which works at the ABI level, so let's keep
       // supporting that here by explicitly checking for it.
+      auto protoAccess = proto->getFormalAccess();
       if (access == AccessLevel::Public &&
-          proto->getFormalAccess() == AccessLevel::Internal &&
+          (protoAccess == AccessLevel::Internal || protoAccess == AccessLevel::Package) &&
           proto->isUsableFromInline()) {
         return true;
       }

lib/Sema/TypeCheckAccess.cpp

@@ -1268,7 +1268,8 @@ class UsableFromInlineChecker : public AccessControlCheckerBase,
       : AccessControlCheckerBase(/*checkUsableFromInline=*/true) {}
 
   static bool shouldSkipChecking(const ValueDecl *VD) {
-    if (VD->getFormalAccess() != AccessLevel::Internal)
+    if (VD->getFormalAccess() != AccessLevel::Internal &&
+        VD->getFormalAccess() != AccessLevel::Package)
       return true;
     return !VD->isUsableFromInline();
   };

lib/Sema/TypeCheckAttr.cpp

@@ -2886,8 +2886,9 @@ void AttributeChecker::visitUsableFromInlineAttr(UsableFromInlineAttr *attr) {
     return;
   }
 
-  // @usableFromInline can only be applied to internal declarations.
-  if (VD->getFormalAccess() != AccessLevel::Internal) {
+  // @usableFromInline can only be applied to internal or package declarations.
+  if (VD->getFormalAccess() != AccessLevel::Internal &&
+      VD->getFormalAccess() != AccessLevel::Package) {
     diagnoseAndRemoveAttr(attr,
                           diag::usable_from_inline_attr_with_explicit_access,
                           VD->getName(), VD->getFormalAccess());

test/AutoDiff/Sema/derivative_attr_type_checking.swift

@@ -1,5 +1,5 @@
-// RUN: %target-swift-frontend-typecheck -verify -disable-availability-checking %s
-// RUN: %target-swift-frontend-typecheck -enable-testing -verify -disable-availability-checking %s
+// RUN: %target-swift-frontend-typecheck -verify -disable-availability-checking %s -package-name myPkg
+// RUN: %target-swift-frontend-typecheck -enable-testing -verify -disable-availability-checking %s -package-name myPkg
 
 // Swift.AdditiveArithmetic:3:17: note: cannot yet register derivative default implementation for protocol requirements
 
@@ -1001,6 +1001,12 @@ func _public_original_usablefrominline_derivative(_ x: Float) -> (value: Float,
   fatalError()
 }
 
+package func package_original_package_derivative(_ x: Float) -> Float { x }
+@derivative(of: package_original_package_derivative)
+package func _package_original_package_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
+  fatalError()
+}
+
 func internal_original_internal_derivative(_ x: Float) -> Float { x }
 @derivative(of: internal_original_internal_derivative)
 func _internal_original_internal_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
@@ -1040,6 +1046,28 @@ func _internal_original_alwaysemitintoclient_derivative(_ x: Float) -> (value: F
   fatalError()
 }
 
+
+package func package_original_usablefrominline_derivative(_ x: Float) -> Float { x }
+@usableFromInline
+@derivative(of: package_original_usablefrominline_derivative)
+package func _package_original_usablefrominline_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
+  fatalError()
+}
+
+package func package_original_inlinable_derivative(_ x: Float) -> Float { x }
+@inlinable
+@derivative(of: package_original_inlinable_derivative)
+package func _package_original_inlinable_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
+  fatalError()
+}
+
+package func package_original_alwaysemitintoclient_derivative(_ x: Float) -> Float { x }
+@_alwaysEmitIntoClient
+@derivative(of: package_original_alwaysemitintoclient_derivative)
+package func _package_original_alwaysemitintoclient_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
+  fatalError()
+}
+
 // MARK: - Original function visibility < derivative function visibility
 
 @usableFromInline
@@ -1051,6 +1079,23 @@ public func _usablefrominline_original_public_derivative(_ x: Float) -> (value:
   fatalError()
 }
 
+@usableFromInline
+package func package_usablefrominline_original_public_derivative(_ x: Float) -> Float { x }
+// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_package__usablefrominline_original_public_derivative' is public, but original function 'package_usablefrominline_original_public_derivative' is package}}
+@derivative(of: package_usablefrominline_original_public_derivative)
+// expected-note @+1 {{mark the derivative function as 'package' to match the original function}} {{1-7=package}}
+public func _package__usablefrominline_original_public_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
+  fatalError()
+}
+
+package func package_original_public_derivative(_ x: Float) -> Float { x }
+// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_package_original_public_derivative' is public, but original function 'package_original_public_derivative' is package}}
+@derivative(of: package_original_public_derivative)
+// expected-note @+1 {{mark the derivative function as 'package' to match the original function}} {{1-7=package}}
+public func _package_original_public_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
+  fatalError()
+}
+
 func internal_original_public_derivative(_ x: Float) -> Float { x }
 // expected-error @+1 {{derivative function must have same access level as original function; derivative function '_internal_original_public_derivative' is public, but original function 'internal_original_public_derivative' is internal}}
 @derivative(of: internal_original_public_derivative)
@@ -1059,6 +1104,14 @@ public func _internal_original_public_derivative(_ x: Float) -> (value: Float, p
   fatalError()
 }
 
+func internal_original_package_derivative(_ x: Float) -> Float { x }
+// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_internal_original_package_derivative' is package, but original function 'internal_original_package_derivative' is internal}}
+@derivative(of: internal_original_package_derivative)
+// expected-note @+1 {{mark the derivative function as 'internal' to match the original function}} {{1-8=internal}}
+package func _internal_original_package_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
+  fatalError()
+}
+
 private func private_original_usablefrominline_derivative(_ x: Float) -> Float { x }
 // expected-error @+1 {{derivative function must have same access level as original function; derivative function '_private_original_usablefrominline_derivative' is internal, but original function 'private_original_usablefrominline_derivative' is private}}
 @derivative(of: private_original_usablefrominline_derivative)
@@ -1076,6 +1129,14 @@ public func _private_original_public_derivative(_ x: Float) -> (value: Float, pu
   fatalError()
 }
 
+private func private_original_package_derivative(_ x: Float) -> Float { x }
+// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_private_original_package_derivative' is package, but original function 'private_original_package_derivative' is private}}
+@derivative(of: private_original_package_derivative)
+// expected-note @+1 {{mark the derivative function as 'private' to match the original function}}
+package func _private_original_package_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
+  fatalError()
+}
+
 private func private_original_internal_derivative(_ x: Float) -> Float { x }
 // expected-error @+1 {{derivative function must have same access level as original function; derivative function '_private_original_internal_derivative' is internal, but original function 'private_original_internal_derivative' is private}}
 @derivative(of: private_original_internal_derivative)
@@ -1110,6 +1171,14 @@ fileprivate func _public_original_private_derivative(_ x: Float) -> (value: Floa
   fatalError()
 }
 
+public func public_original_package_derivative(_ x: Float) -> Float { x }
+// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_public_original_package_derivative' is package, but original function 'public_original_package_derivative' is public}}
+@derivative(of: public_original_package_derivative)
+// expected-note @+1 {{mark the derivative function as '@usableFromInline' to match the original function}} {{1-1=@usableFromInline }}
+package func _public_original_package_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
+  fatalError()
+}
+
 public func public_original_internal_derivative(_ x: Float) -> Float { x }
 // expected-error @+1 {{derivative function must have same access level as original function; derivative function '_public_original_internal_derivative' is internal, but original function 'public_original_internal_derivative' is public}}
 @derivative(of: public_original_internal_derivative)
@@ -1118,6 +1187,14 @@ func _public_original_internal_derivative(_ x: Float) -> (value: Float, pullback
   fatalError()
 }
 
+package func package_original_internal_derivative(_ x: Float) -> Float { x }
+// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_package_original_internal_derivative' is internal, but original function 'package_original_internal_derivative' is package}}
+@derivative(of: package_original_internal_derivative)
+// expected-note @+1 {{mark the derivative function as 'package' to match the original function}} {{1-1=package }}
+func _package_original_internal_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
+  fatalError()
+}
+
 func internal_original_fileprivate_derivative(_ x: Float) -> Float { x }
 // expected-error @+1 {{derivative function must have same access level as original function; derivative function '_internal_original_fileprivate_derivative' is fileprivate, but original function 'internal_original_fileprivate_derivative' is internal}}
 @derivative(of: internal_original_fileprivate_derivative)