Add experimental feature @inline(always)

The intent for `@inline(always)` is to act as an optimization control.
The user can rely on inlining to happen or the compiler will emit an error
message.

Because function values can be dynamic (closures, protocol/class lookup)
this guarantee can only be upheld for direct function references.

In cases where the optimizer can resolve dynamic function values the
attribute shall be respected.

rdar://148608854

Author: aschwaighofer

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocBoxToStack.swift

@@ -504,7 +504,8 @@ private extension ApplySite {
     {
       if self is FullApplySite,
          // If the function is inlined later, there is no point in specializing it.
-         !callee.shouldOptimize || callee.inlineStrategy == .always
+         !callee.shouldOptimize || callee.inlineStrategy == .heuristicAlways ||
+         callee.inlineStrategy == .always
       {
         return nil
       }

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -302,7 +302,9 @@ private func shouldInline(apply: FullApplySite, callee: Function, alreadyInlined
     return false
   }
 
-  if apply.parentFunction.isGlobalInitOnceFunction && callee.inlineStrategy == .always {
+  if apply.parentFunction.isGlobalInitOnceFunction && (
+      callee.inlineStrategy == .heuristicAlways ||
+      callee.inlineStrategy == .always) {
     // Some arithmetic operations, like integer conversions, are not transparent but `inline(__always)`.
     // Force inlining them in global initializers so that it's possible to statically initialize the global.
     return true

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -316,13 +316,15 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
   public enum InlineStrategy {
     case automatic
     case never
+    case heuristicAlways
     case always
   }
 
   public var inlineStrategy: InlineStrategy {
     switch bridged.getInlineStrategy() {
       case .InlineDefault: return .automatic
       case .NoInline: return .never
+      case .HeuristicAlwaysInline: return .heuristicAlways
       case .AlwaysInline: return .always
       default:
         fatalError()

include/swift/AST/AttrKind.h

@@ -79,7 +79,8 @@ llvm::StringRef getAccessLevelSpelling(AccessLevel value);
 
 enum class ENUM_EXTENSIBILITY_ATTR(closed) InlineKind : uint8_t {
   Never SWIFT_NAME("never") = 0,
-  Always SWIFT_NAME("always") = 1,
+  AlwaysUnderscored SWIFT_NAME("alwaysUnderscored") = 1,
+  Always SWIFT_NAME("always") = 2,
   Last_InlineKind = Always
 };
 

include/swift/AST/DiagnosticsSIL.def

@@ -448,6 +448,10 @@ ERROR(circular_transparent,none,
 NOTE(note_while_inlining,none,
      "while inlining here", ())
 
+// '@inline(always)' diagnostics
+ERROR(circular_inlineAlways,none,
+      "inlining '@inline(always)' functions forms circular loop", ())
+
 // Pre-specializations
 ERROR(cannot_prespecialize,none,
       "Cannot pre-specialize %0", (StringRef))

include/swift/AST/DiagnosticsSema.def

@@ -8924,5 +8924,16 @@ ERROR(invalid_redecl_of_file_isolation,none,
 NOTE(invalid_redecl_of_file_isolation_prev,none,
      "default isolation was previously declared here", ())
 
+//===----------------------------------------------------------------------===//
+// MARK: `@inline(always)` attribute
+//===----------------------------------------------------------------------===//
+ERROR(attr_inline_always_experimental,none,
+      "'@inline(always)' is an experimental feature", ())
+ERROR(attr_inline_always_requires_inlinable,none,
+      "'@inline(always)' on public or package declarations must be used "
+      "together with '@inlinable'", ())
+ERROR(attr_inline_always_no_usable_from_inline,none,
+      "cannot use '@inline(always)' together with '@usableFromInline'", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/PrintOptions.h

@@ -403,6 +403,9 @@ struct PrintOptions {
   /// Suppress @_lifetime attribute and emit @lifetime instead.
   bool SuppressLifetimes = false;
 
+  /// Suppress @inline(always) attribute and emit @inline(__always) instead.
+  bool SuppressInlineAlways = false;
+
   /// Whether to print the \c{/*not inherited*/} comment on factory initializers.
   bool PrintFactoryInitializerComment = true;
 

include/swift/Basic/Features.def

@@ -550,6 +550,9 @@ EXPERIMENTAL_FEATURE(ImportMacroAliases, true)
 /// Enable borrow/mutate accessors
 EXPERIMENTAL_FEATURE(BorrowAndMutateAccessors, false)
 
+/// Allow use of @inline(always) attribute
+SUPPRESSIBLE_EXPERIMENTAL_FEATURE(InlineAlways, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

include/swift/SIL/SILBridging.h

@@ -470,6 +470,7 @@ struct BridgedFunction {
   enum class InlineStrategy {
     InlineDefault,
     NoInline,
+    HeuristicAlwaysInline,
     AlwaysInline
   };
 

include/swift/SIL/SILDeclRef.h

@@ -404,8 +404,10 @@ struct SILDeclRef {
   SerializedKind_t getSerializedKind() const;
   /// True if the function has noinline attribute.
   bool isNoinline() const;
-  /// True if the function has __always inline attribute.
+  /// True if the function has always inline attribute.
   bool isAlwaysInline() const;
+  /// True if the function has __always inline attribute.
+  bool isUnderscoredAlwaysInline() const;
   /// True if the function has the @backDeployed attribute.
   bool isBackDeployed() const;