Merge pull request swiftlang#20531 from slavapestov/inline-always-is-not-inlinable

@inline(__always) should not imply @inlinable

Author: slavapestov

benchmark/utils/TestsUtils.swift

@@ -221,7 +221,7 @@ public func Random() -> Int64 {
   return lfsrRandomGenerator.randInt()
 }
 
-@inline(__always)
+@inlinable @inline(__always)
 public func CheckResults(
     _ resultsMatch: Bool,
     file: StaticString = #file,

include/swift/AST/Attr.def

@@ -179,7 +179,7 @@ SIMPLE_DECL_ATTR(unsafe_no_objc_tagged_pointer, UnsafeNoObjCTaggedPointer,
   UserInaccessible,
   19)
 DECL_ATTR(inline, Inline,
-  OnFunc | OnAccessor | OnConstructor,
+  OnVar | OnSubscript | OnAbstractFunction,
   20)
 DECL_ATTR(_semantics, Semantics,
   OnAbstractFunction | OnSubscript |

include/swift/AST/DiagnosticsSema.def

@@ -4097,7 +4097,6 @@ ERROR(usable_from_inline_attr_in_protocol,none,
 
 #define FRAGILE_FUNC_KIND \
   "%select{a '@_transparent' function|" \
-  "an '@inline(__always)' function|" \
   "an '@inlinable' function|" \
   "a default argument value|" \
   "a property initializer in a '@_fixed_layout' type}"
@@ -4126,7 +4125,7 @@ NOTE(resilience_decl_declared_here,
 
 ERROR(class_designated_init_inlinable_resilient,none,
       "initializer for class %0 is "
-      "'%select{@_transparent|@inline(__always)|@inlinable|%error}1' and must "
+      "'%select{@_transparent|@inlinable|%error}1' and must "
       "delegate to another initializer", (Type, unsigned))
 
 ERROR(attribute_invalid_on_stored_property,

lib/AST/DeclContext.cpp

@@ -323,18 +323,13 @@ ResilienceExpansion DeclContext::getResilienceExpansion() const {
       if (!funcAccess.isPublic())
         break;
 
-      // Bodies of public transparent and always-inline functions are
-      // serialized, so use conservative access patterns.
+      // If the function is public, @_transparent implies @inlinable.
       if (AFD->isTransparent())
         return ResilienceExpansion::Minimal;
 
       if (AFD->getAttrs().hasAttribute<InlinableAttr>())
         return ResilienceExpansion::Minimal;
 
-      if (auto attr = AFD->getAttrs().getAttribute<InlineAttr>())
-        if (attr->getKind() == InlineKind::Always)
-          return ResilienceExpansion::Minimal;
-
       // If a property or subscript is @inlinable, the accessors are
       // @inlinable also.
       if (auto accessor = dyn_cast<AccessorDecl>(AFD))

lib/SIL/SILDeclRef.cpp

@@ -528,26 +528,47 @@ IsSerialized_t SILDeclRef::isSerialized() const {
   return IsNotSerialized;
 }
 
-/// \brief True if the function has noinline attribute.
+/// \brief True if the function has an @inline(never) attribute.
 bool SILDeclRef::isNoinline() const {
   if (!hasDecl())
     return false;
-  if (auto InlineA = getDecl()->getAttrs().getAttribute<InlineAttr>())
-    if (InlineA->getKind() == InlineKind::Never)
+
+  auto *decl = getDecl();
+  if (auto *attr = decl->getAttrs().getAttribute<InlineAttr>())
+    if (attr->getKind() == InlineKind::Never)
       return true;
-  if (auto *semanticsA = getDecl()->getAttrs().getAttribute<SemanticsAttr>())
-    if (semanticsA->Value.equals("keypath.entry"))
+
+  if (auto *accessorDecl = dyn_cast<AccessorDecl>(decl)) {
+    auto *storage = accessorDecl->getStorage();
+    if (auto *attr = storage->getAttrs().getAttribute<InlineAttr>())
+      if (attr->getKind() == InlineKind::Never)
+        return true;
+  }
+
+  if (auto *attr = decl->getAttrs().getAttribute<SemanticsAttr>())
+    if (attr->Value.equals("keypath.entry"))
       return true;
+
   return false;
 }
 
-/// \brief True if the function has noinline attribute.
+/// \brief True if the function has the @inline(__always) attribute.
 bool SILDeclRef::isAlwaysInline() const {
   if (!hasDecl())
     return false;
-  if (auto InlineA = getDecl()->getAttrs().getAttribute<InlineAttr>())
-    if (InlineA->getKind() == InlineKind::Always)
+
+  auto *decl = getDecl();
+  if (auto attr = decl->getAttrs().getAttribute<InlineAttr>())
+    if (attr->getKind() == InlineKind::Always)
       return true;
+
+  if (auto *accessorDecl = dyn_cast<AccessorDecl>(decl)) {
+    auto *storage = accessorDecl->getStorage();
+    if (auto *attr = storage->getAttrs().getAttribute<InlineAttr>())
+      if (attr->getKind() == InlineKind::Always)
+        return true;
+  }
+
   return false;
 }
 

lib/Sema/ResilienceDiagnostics.cpp

@@ -58,11 +58,6 @@ TypeChecker::getFragileFunctionKind(const DeclContext *DC) {
         return std::make_pair(FragileFunctionKind::Inlinable,
                               /*treatUsableFromInlineAsPublic=*/true);
 
-      if (auto attr = AFD->getAttrs().getAttribute<InlineAttr>())
-        if (attr->getKind() == InlineKind::Always)
-          return std::make_pair(FragileFunctionKind::InlineAlways,
-                                /*treatUsableFromInlineAsPublic=*/true);
-
       // If a property or subscript is @inlinable, the accessors are
       // @inlinable also.
       if (auto accessor = dyn_cast<AccessorDecl>(AFD))

lib/Sema/TypeChecker.h

@@ -1956,7 +1956,6 @@ class TypeChecker final : public LazyResolver {
   /// Used in diagnostic %selects.
   enum class FragileFunctionKind : unsigned {
     Transparent,
-    InlineAlways,
     Inlinable,
     DefaultArgument,
     PropertyInitializer

stdlib/public/SDK/GLKit/GLKMath.swift.gyb

@@ -21,7 +21,7 @@
 // types.
 
 // Do dirty pointer manipulations to index an opaque struct like an array.
-@inline(__always)
+@inlinable @inline(__always)
 public func _indexHomogeneousValue<TTT, T>(_ aggregate: UnsafePointer<TTT>,
                                            _ index: Int) -> T {
   return UnsafeRawPointer(aggregate).load(
@@ -31,7 +31,7 @@ public func _indexHomogeneousValue<TTT, T>(_ aggregate: UnsafePointer<TTT>,
 %{
 def defineSubscript(Type, limit):
   return """
-  public subscript(i: Int) -> Float {{
+  @inlinable public subscript(i: Int) -> Float {{
     @inline(__always)
     get {{
       precondition(i >= 0, "Negative {0} index out of range")

stdlib/public/core/Array.swift

@@ -384,7 +384,7 @@ extension Array {
   }
 
   @_semantics("array.get_element")
-  @inline(__always)
+  @inlinable @inline(__always)
   public // @testable
   func _getElement(
     _ index: Int,
@@ -440,7 +440,7 @@ extension Array: _ArrayProtocol {
   @inlinable
   public // @testable
   var _owner: AnyObject? {
-    @inline(__always)
+    @inlinable @inline(__always)
     get {
       return _buffer.owner      
     }
@@ -1447,7 +1447,7 @@ extension Array {
   ///   method's execution.
   /// - Returns: The return value, if any, of the `body` closure parameter.
   @_semantics("array.withUnsafeMutableBufferPointer")
-  @inline(__always) // Performance: This method should get inlined into the
+  @inlinable @inline(__always) // Performance: This method should get inlined into the
   // caller such that we can combine the partial apply with the apply in this
   // function saving on allocating a closure context. This becomes unnecessary
   // once we allocate noescape closures on the stack.

stdlib/public/core/ArrayShared.swift

@@ -25,7 +25,7 @@ public struct _DependenceToken {
 /// This function is referenced by the compiler to allocate array literals.
 ///
 /// - Precondition: `storage` is `_ContiguousArrayStorage`.
-@inline(__always)
+@inlinable @inline(__always)
 public // COMPILER_INTRINSIC
 func _allocateUninitializedArray<Element>(_  builtinCount: Builtin.Word)
     -> (Array<Element>, Builtin.RawPointer) {