Add an @_addressableSelf attribute to mark the self param of methods as addressable.

Author: jckarter

include/swift/AST/DeclAttr.def

@@ -513,7 +513,11 @@ DECL_ATTR(lifetime, Lifetime,
   OnAccessor | OnConstructor | OnFunc | OnSubscript | LongAttribute | ABIBreakingToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove | AllowMultipleAttributes,
   161)
 
-LAST_DECL_ATTR(Lifetime)
+SIMPLE_DECL_ATTR(_addressableSelf, AddressableSelf,
+  OnAccessor | OnConstructor | OnFunc | OnSubscript | ABIBreakingToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove | UserInaccessible,
+  162)
+
+LAST_DECL_ATTR(AddressableSelf)
 
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsSema.def

@@ -309,6 +309,11 @@ ERROR(incorrect_explicit_closure_result_vs_return_type,none,
       "declared closure result %0 is incompatible with return type %1",
       (Type, Type))
 
+ERROR(addressable_not_enabled,none,
+      "@_addressable is an experimental feature", ())
+ERROR(addressableSelf_not_on_method,none,
+      "@_addressableSelf cannot be applied to non-member declarations", ())
+
 ERROR(unsupported_closure_attr,none,
       "%select{attribute |}0 '%1' is not supported on a closure",
       (bool, StringRef))

lib/AST/ASTContext.cpp

@@ -4051,6 +4051,10 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
     // The default flagless state.
     break;
   }
+  
+  if (AFD->getAttrs().hasAttribute<AddressableSelfAttr>()) {
+    flags = flags.withAddressable(true);
+  }
 
   return AnyFunctionType::Param(selfTy, Identifier(), flags);
 }

lib/AST/ASTDumper.cpp

@@ -3745,6 +3745,7 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, StringRef>,
   }
 
   TRIVIAL_ATTR_PRINTER(Actor, actor)
+  TRIVIAL_ATTR_PRINTER(AddressableSelf, _addressableSelf)
   TRIVIAL_ATTR_PRINTER(AlwaysEmitConformanceMetadata,
                        always_emit_conformance_metadata)
   TRIVIAL_ATTR_PRINTER(AlwaysEmitIntoClient, always_emit_into_client)

lib/AST/Decl.cpp

@@ -9938,6 +9938,9 @@ ParamDecl *AbstractFunctionDecl::getImplicitSelfDecl(bool createIfNeeded) {
   *selfDecl = new (ctx) ParamDecl(SourceLoc(), SourceLoc(), Identifier(),
                                   getLoc(), ctx.Id_self, this);
   (*selfDecl)->setImplicit();
+  if (getAttrs().hasAttribute<AddressableSelfAttr>()) {
+    (*selfDecl)->setAddressable(true);
+  }
   return *selfDecl;
 }
 

lib/AST/FeatureSet.cpp

@@ -291,6 +291,10 @@ static bool usesFeatureIsolatedAny(Decl *decl) {
 }
 
 static bool usesFeatureAddressableParameters(Decl *d) {
+  if (d->getAttrs().hasAttribute<AddressableSelfAttr>()) {
+    return true;
+  }
+
   auto fd = dyn_cast<AbstractFunctionDecl>(d);
   if (!fd) {
     return false;

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -183,7 +183,8 @@ extension ASTGenVisitor {
         return self.generateUnavailableFromAsyncAttr(attribute: node)?.asDeclAttribute
 
       // Simple attributes.
-      case .alwaysEmitConformanceMetadata,
+      case .addressableSelf,
+        .alwaysEmitConformanceMetadata,
         .alwaysEmitIntoClient,
         .atReasync,
         .atRethrows,

lib/Sema/TypeCheckAttr.cpp

@@ -388,6 +388,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   void visitSILGenNameAttr(SILGenNameAttr *attr);
   void visitUnsafeAttr(UnsafeAttr *attr);
   void visitLifetimeAttr(LifetimeAttr *attr);
+  void visitAddressableSelfAttr(AddressableSelfAttr *attr);
 };
 
 } // end anonymous namespace
@@ -7767,6 +7768,16 @@ void AttributeChecker::visitUnsafeAttr(UnsafeAttr *attr) {
 
 void AttributeChecker::visitLifetimeAttr(LifetimeAttr *attr) {}
 
+void AttributeChecker::visitAddressableSelfAttr(AddressableSelfAttr *attr) {
+  if (!Ctx.LangOpts.hasFeature(Feature::AddressableParameters)) {
+    Ctx.Diags.diagnose(attr->getLocation(), diag::addressable_not_enabled);
+  }
+  
+  if (!D->getDeclContext()->isTypeContext()) {
+    Ctx.Diags.diagnose(attr->getLocation(), diag::addressableSelf_not_on_method);
+  }
+}
+
 namespace {
 
 class ClosureAttributeChecker

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1735,6 +1735,7 @@ namespace  {
     UNINTERESTING_ATTR(StaticExclusiveOnly)
     UNINTERESTING_ATTR(PreInverseGenerics)
     UNINTERESTING_ATTR(Lifetime)
+    UNINTERESTING_ATTR(AddressableSelf)
 #undef UNINTERESTING_ATTR
 
     void visitAvailableAttr(AvailableAttr *attr) {

test/SILGen/addressable_params.swift

@@ -8,7 +8,8 @@ func withUP<T>(to: borrowing @_addressable T, _ body: (UnsafePointer<T>) -> Void
 // Forwarding an addressable parameter binding as an argument to another
 // addressable parameter with matching ownership forwards the address without
 // copying or moving the value.
-// CHECK-LABEL: sil {{.*}}@$s{{.*}}14testForwarding{{.*}} : $@convention(thin) (@in_guaranteed String) -> ()
+// CHECK-LABEL: sil {{.*}}@$s{{.*}}14testForwarding{{.*}} :
+// CHECK-SAME:    $@convention(thin) (@in_guaranteed String) -> ()
 func testForwarding(x: borrowing @_addressable String) {
     // CHECK: [[MO:%.*]] = copyable_to_moveonlywrapper_addr %0
     // CHECK: [[MOR:%.*]] = mark_unresolved_non_copyable_value [no_consume_or_assign] [[MO]]
@@ -29,3 +30,19 @@ func testUseAsNormalArgument(x: borrowing @_addressable String) {
     normalConsumingArgument(copy x)
     normalGenericArgument(x)
 }
+
+struct Foo {
+    var x: String
+
+    // CHECK-LABEL: sil {{.*}}@$s{{.*}}18testForwardingSelf{{.*}} :
+    // CHECK-SAME:    $@convention(method) (@in_guaranteed Foo) -> ()
+    @_addressableSelf borrowing func testForwardingSelf() {
+        // CHECK: [[MO:%.*]] = copyable_to_moveonlywrapper_addr %0
+        // CHECK: [[MOR:%.*]] = mark_unresolved_non_copyable_value [no_consume_or_assign] [[MO]]
+        // CHECK: [[MORC:%.*]] = moveonlywrapper_to_copyable_addr [[MOR]]
+        // CHECK: apply {{.*}}([[MORC]],
+        withUP(to: self) {
+            _ = $0
+        }
+    }
+}