Add the @_unsafeNonEscapableResult function

This will allow NonEscapable types to be returned from a function.

Author: atrick

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -116,6 +116,10 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     }
   }
 
+  public var hasUnsafeNonEscapableResult: Bool {
+    return bridged.hasUnsafeNonEscapableResult()
+  }
+
   /// True if the callee function is annotated with @_semantics("programtermination_point").
   /// This means that the function terminates the program.
   public var isProgramTerminationPoint: Bool { hasSemanticsAttribute("programtermination_point") }

include/swift/AST/Attr.def

@@ -426,6 +426,9 @@ DECL_ATTR(_extern, Extern,
 SIMPLE_DECL_ATTR(_nonEscapable, NonEscapable,
   OnNominalType | UserInaccessible | ABIBreakingToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   148)
+SIMPLE_DECL_ATTR(_unsafeNonEscapableResult, UnsafeNonEscapableResult,
+  OnAbstractFunction | OnSubscript | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIBreakingToRemove,
+  149)
 CONTEXTUAL_SIMPLE_DECL_ATTR(final, Final,
   OnClass | OnFunc | OnAccessor | OnVar | OnSubscript | DeclModifier | ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
   2)

include/swift/SIL/SILBridging.h

@@ -329,6 +329,7 @@ struct BridgedFunction {
   BRIDGED_INLINE bool isDestructor() const;
   BRIDGED_INLINE bool isGenericFunction() const;
   BRIDGED_INLINE bool hasSemanticsAttr(BridgedStringRef attrName) const;
+  BRIDGED_INLINE bool hasUnsafeNonEscapableResult() const;
   BRIDGED_INLINE EffectsKind getEffectAttribute() const;
   BRIDGED_INLINE PerformanceConstraints getPerformanceConstraints() const;
   BRIDGED_INLINE InlineStrategy getInlineStrategy() const;

include/swift/SIL/SILBridgingImpl.h

@@ -498,6 +498,10 @@ bool BridgedFunction::hasSemanticsAttr(BridgedStringRef attrName) const {
   return getFunction()->hasSemanticsAttr(attrName.get());
 }
 
+bool BridgedFunction::hasUnsafeNonEscapableResult() const {
+  return getFunction()->hasUnsafeNonEscapableResult();
+}
+
 BridgedFunction::EffectsKind BridgedFunction::getEffectAttribute() const {
   return (EffectsKind)getFunction()->getEffectsKind();
 }

include/swift/SIL/SILFunction.h

@@ -434,6 +434,10 @@ class SILFunction
   /// from running with pack metadata markers in place.
   unsigned UseStackForPackMetadata : 1;
 
+  /// If true, the function returns a non-escapable value without any
+  /// lifetime-dependence on an argument.
+  unsigned HasUnsafeNonEscapableResult : 1;
+
   static void
   validateSubclassScope(SubclassScope scope, IsThunk_t isThunk,
                         const GenericSpecializationInformation *genericInfo) {
@@ -716,6 +720,14 @@ class SILFunction
     UseStackForPackMetadata = value;
   }
 
+  bool hasUnsafeNonEscapableResult() const {
+    return HasUnsafeNonEscapableResult;
+  }
+
+  void setHasUnsafeNonEscapableResult(bool value) {
+    HasUnsafeNonEscapableResult = value;
+  }
+
   /// Returns true if this is a reabstraction thunk of escaping function type
   /// whose single argument is a potentially non-escaping closure. i.e. the
   /// thunks' function argument may itself have @inout_aliasable parameters.

lib/SIL/IR/SILFunction.cpp

@@ -208,6 +208,7 @@ void SILFunction::init(
   this->IsRuntimeAccessible = isRuntimeAccessible;
   this->ForceEnableLexicalLifetimes = DoNotForceEnableLexicalLifetimes;
   this->UseStackForPackMetadata = DoUseStackForPackMetadata;
+  this->HasUnsafeNonEscapableResult = false;
   this->stackProtection = false;
   this->Inlined = false;
   this->Zombie = false;

lib/SIL/IR/SILFunctionBuilder.cpp

@@ -197,6 +197,10 @@ void SILFunctionBuilder::addFunctionAttributes(
     F->setForceEnableLexicalLifetimes(DoForceEnableLexicalLifetimes);
   }
 
+  if (Attrs.hasAttribute<UnsafeNonEscapableResultAttr>()) {
+    F->setHasUnsafeNonEscapableResult(true);
+  }
+
   // Validate `@differentiable` attributes by calling `getParameterIndices`.
   // This is important for:
   // - Skipping invalid `@differentiable` attributes in non-primary files.

lib/SIL/IR/SILPrinter.cpp

@@ -3245,6 +3245,9 @@ void SILFunction::print(SILPrintContext &PrintCtx) const {
   if (!useStackForPackMetadata()) {
     OS << "[no_onstack_pack_metadata] ";
   }
+  if (hasUnsafeNonEscapableResult()) {
+    OS << "[unsafe_nonescapable_result] ";
+  }
 
   if (isExactSelfClass()) {
     OS << "[exact_self_class] ";

lib/SIL/Parser/ParseSIL.cpp

@@ -1044,6 +1044,7 @@ static bool parseDeclSILOptional(bool *isTransparent,
                                  IsRuntimeAccessible_t *isRuntimeAccessible,
                                  ForceEnableLexicalLifetimes_t *forceEnableLexicalLifetimes,
                                  UseStackForPackMetadata_t *useStackForPackMetadata,
+                                 bool *hasUnsafeNonEscapableResult,
                                  IsExactSelfClass_t *isExactSelfClass,
                                  SILFunction **dynamicallyReplacedFunction,
                                  SILFunction **usedAdHocRequirementWitness,
@@ -1090,6 +1091,9 @@ static bool parseDeclSILOptional(bool *isTransparent,
     else if (useStackForPackMetadata &&
              SP.P.Tok.getText() == "no_onstack_pack_metadata")
       *useStackForPackMetadata = DoNotUseStackForPackMetadata;
+    else if (hasUnsafeNonEscapableResult &&
+             SP.P.Tok.getText() == "unsafe_nonescapable_result")
+      *useStackForPackMetadata = DoNotUseStackForPackMetadata;
     else if (isExactSelfClass && SP.P.Tok.getText() == "exact_self_class")
       *isExactSelfClass = IsExactSelfClass;
     else if (isCanonical && SP.P.Tok.getText() == "canonical")
@@ -7201,6 +7205,7 @@ bool SILParserState::parseDeclSIL(Parser &P) {
   ForceEnableLexicalLifetimes_t forceEnableLexicalLifetimes =
       DoNotForceEnableLexicalLifetimes;
   UseStackForPackMetadata_t useStackForPackMetadata = DoUseStackForPackMetadata;
+  bool hasUnsafeNonEscapableResult = false;
   IsExactSelfClass_t isExactSelfClass = IsNotExactSelfClass;
   bool hasOwnershipSSA = false;
   IsThunk_t isThunk = IsNotThunk;
@@ -7226,6 +7231,7 @@ bool SILParserState::parseDeclSIL(Parser &P) {
           &isTransparent, &isSerialized, &isCanonical, &hasOwnershipSSA,
           &isThunk, &isDynamic, &isDistributed, &isRuntimeAccessible,
           &forceEnableLexicalLifetimes, &useStackForPackMetadata,
+          &hasUnsafeNonEscapableResult,
           &isExactSelfClass, &DynamicallyReplacedFunction,
           &AdHocWitnessFunction, &objCReplacementFor, &specialPurpose,
           &inlineStrategy, &optimizationMode, &perfConstr, &markedAsUsed,
@@ -7266,6 +7272,8 @@ bool SILParserState::parseDeclSIL(Parser &P) {
     FunctionState.F->setForceEnableLexicalLifetimes(
         forceEnableLexicalLifetimes);
     FunctionState.F->setUseStackForPackMetadata(useStackForPackMetadata);
+    FunctionState.F->setHasUnsafeNonEscapableResult(
+      hasUnsafeNonEscapableResult);
     FunctionState.F->setIsExactSelfClass(isExactSelfClass);
     FunctionState.F->setDynamicallyReplacedFunction(
         DynamicallyReplacedFunction);

lib/Sema/TypeCheckAttr.cpp

@@ -162,6 +162,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(Documentation)
   IGNORED_ATTR(LexicalLifetimes)
   IGNORED_ATTR(NonEscapable)
+  IGNORED_ATTR(UnsafeNonEscapableResult)
 #undef IGNORED_ATTR
 
   void visitAlignmentAttr(AlignmentAttr *attr) {