Merge pull request #69735 from Azoy/static-exclusive-only

Introduce @_staticExclusiveOnly

Author: Azoy

include/swift/AST/Attr.def

@@ -530,6 +530,9 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(actor, Actor,
 CONTEXTUAL_SIMPLE_DECL_ATTR(_resultDependsOnSelf, ResultDependsOnSelf,
   OnFunc | DeclModifier | UserInaccessible | ABIBreakingToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   150)
+SIMPLE_DECL_ATTR(_staticExclusiveOnly, StaticExclusiveOnly,
+  OnStruct | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
+  151)
 
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsSema.def

@@ -1917,6 +1917,20 @@ WARNING(extern_c_maybe_invalid_name, none,
         "C name '%0' may be invalid; explicitly specify the name in @_extern(c) to suppress this warning",
         (StringRef))
 
+// @_staticExclusiveOnly
+ERROR(attr_static_exclusive_only_disabled,none,
+      "attribute requires '-enable-experimental feature StaticExclusiveOnly'", ())
+ERROR(attr_static_exclusive_only_noncopyable,none,
+      "@_staticExclusiveOnly can only be applied to noncopyable types", ())
+ERROR(attr_static_exclusive_only_let_only,none,
+      "variable of type %0 must be declared with a 'let'", (Type))
+NOTE(attr_static_exclusive_only_type_nonmutating,none,
+     "%0 is a non-mutable type", (Type))
+ERROR(attr_static_exclusive_only_let_only_param,none,
+      "parameter of type %0 must be declared as either 'borrowing' or 'consuming'", (Type))
+ERROR(attr_static_exclusive_only_mutating,none,
+      "type %0 cannot have mutating function %1", (Type, ValueDecl *))
+
 ERROR(c_func_variadic, none,
       "cannot declare variadic argument %0 in %kind1",
       (DeclName, const ValueDecl *))

include/swift/Basic/Features.def

@@ -259,6 +259,9 @@ EXPERIMENTAL_FEATURE(Extern, true)
 // global functions and key paths.
 EXPERIMENTAL_FEATURE(InferSendableFromCaptures, false)
 
+/// Enable the `@_staticExclusiveOnly` attribute.
+EXPERIMENTAL_FEATURE(StaticExclusiveOnly, true)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/AST/ASTPrinter.cpp

@@ -3640,6 +3640,10 @@ static bool usesFeatureExtern(Decl *decl) {
   return decl->getAttrs().hasAttribute<ExternAttr>();
 }
 
+static bool usesFeatureStaticExclusiveOnly(Decl *decl) {
+  return decl->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>();
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {

lib/Sema/TypeCheckAttr.cpp

@@ -353,6 +353,8 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
 
   void visitNonEscapableAttr(NonEscapableAttr *attr);
   void visitUnsafeNonEscapableResultAttr(UnsafeNonEscapableResultAttr *attr);
+
+  void visitStaticExclusiveOnlyAttr(StaticExclusiveOnlyAttr *attr);
 };
 
 } // end anonymous namespace
@@ -501,6 +503,15 @@ void AttributeChecker::visitMutationAttr(DeclAttribute *attr) {
         break;
       }
     }
+
+    // Types who are marked @_staticExclusiveOnly cannot have mutating functions.
+    if (auto SD = contextTy->getStructOrBoundGenericStruct()) {
+      if (SD->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>() &&
+          attrModifier == SelfAccessKind::Mutating) {
+        diagnoseAndRemoveAttr(attr, diag::attr_static_exclusive_only_mutating,
+                              contextTy, FD);
+      }
+    }
   } else {
     diagnoseAndRemoveAttr(attr, diag::mutating_invalid_global_scope,
                           attrModifier);
@@ -7244,6 +7255,22 @@ void AttributeChecker::visitUnsafeNonEscapableResultAttr(
   }
 }
 
+void AttributeChecker::visitStaticExclusiveOnlyAttr(
+    StaticExclusiveOnlyAttr *attr) {
+  if (!Ctx.LangOpts.hasFeature(Feature::StaticExclusiveOnly)) {
+    diagnoseAndRemoveAttr(attr, diag::attr_static_exclusive_only_disabled);
+    return;
+  }
+
+  // Can only be applied to structs.
+  auto structDecl = cast<StructDecl>(D);
+
+  if (!structDecl->getDeclaredInterfaceType()
+                 ->isNoncopyable(D->getDeclContext())) {
+    diagnoseAndRemoveAttr(attr, diag::attr_static_exclusive_only_noncopyable);
+  }
+}
+
 namespace {
 
 class ClosureAttributeChecker

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1630,6 +1630,7 @@ namespace  {
     UNINTERESTING_ATTR(LexicalLifetimes)
     UNINTERESTING_ATTR(NonEscapable)
     UNINTERESTING_ATTR(UnsafeNonEscapableResult)
+    UNINTERESTING_ATTR(StaticExclusiveOnly)
 #undef UNINTERESTING_ATTR
 
     void visitAvailableAttr(AvailableAttr *attr) {

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2468,6 +2468,21 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         }
       }
     }
+
+    // @_staticExclusiveOnly types cannot be put into 'var's, only 'let'.
+    if (auto SD = VD->getInterfaceType()->getStructOrBoundGenericStruct()) {
+      if (getASTContext().LangOpts.hasFeature(Feature::StaticExclusiveOnly) &&
+          SD->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>() &&
+          !VD->isLet()) {
+        SD->getASTContext().Diags.diagnoseWithNotes(
+          VD->diagnose(diag::attr_static_exclusive_only_let_only,
+                       VD->getInterfaceType()),
+          [&]() {
+            SD->diagnose(diag::attr_static_exclusive_only_type_nonmutating,
+                       SD->getDeclaredInterfaceType());
+          });
+      }
+    }
   }
 
   bool checkBoundInOutVarDecl(PatternBindingDecl *pbd, unsigned patternIndex,
@@ -4146,6 +4161,22 @@ void TypeChecker::checkParameterList(ParameterList *params,
         }
       }
     }
+
+    // @_staticExclusiveOnly types cannot be passed as 'inout', only as either
+    // a borrow or as consuming.
+    if (auto SD = param->getInterfaceType()->getStructOrBoundGenericStruct()) {
+      if (SD->getASTContext().LangOpts.hasFeature(Feature::StaticExclusiveOnly) &&
+          SD->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>() &&
+          param->isInOut()) {
+        SD->getASTContext().Diags.diagnoseWithNotes(
+          param->diagnose(diag::attr_static_exclusive_only_let_only_param,
+                          param->getInterfaceType()),
+          [&]() {
+            SD->diagnose(diag::attr_static_exclusive_only_type_nonmutating,
+                       SD->getDeclaredInterfaceType());
+          });
+      }
+    }
   }
 
   // For source compatibility, allow duplicate internal parameter names

lib/Sema/TypeCheckType.cpp

@@ -3556,10 +3556,23 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
     }
 
     // Validate the presence of ownership for a noncopyable parameter.
-    if (inStage(TypeResolutionStage::Interface))
+    if (inStage(TypeResolutionStage::Interface)) {
       diagnoseMissingOwnership(getASTContext(), dc, ownership,
                                eltTypeRepr, ty, options);
 
+      // @_staticExclusiveOnly types cannot be passed as 'inout' in function
+      // types.
+      if (auto SD = ty->getStructOrBoundGenericStruct()) {
+        if (getASTContext().LangOpts.hasFeature(Feature::StaticExclusiveOnly) &&
+            SD->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>() &&
+            ownership == ParamSpecifier::InOut) {
+          diagnose(eltTypeRepr->getLoc(),
+                   diag::attr_static_exclusive_only_let_only_param,
+                   ty);
+        }
+      }
+    }
+
     Identifier argumentLabel;
     Identifier parameterName;
     if (inputRepr->getElement(i).NameLoc.isValid() &&

test/attr/attr_static_exclusive_only.swift

@@ -0,0 +1,70 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature StaticExclusiveOnly
+
+@_staticExclusiveOnly // expected-error {{@_staticExclusiveOnly can only be applied to noncopyable types}}
+struct A {}
+
+@_staticExclusiveOnly // OK
+struct B: ~Copyable { // expected-note {{'B' is a non-mutable type}}
+                      // expected-note@-1 {{'B' is a non-mutable type}}
+                      // expected-note@-2 {{'B' is a non-mutable type}}
+                      // expected-note@-3 {{'B' is a non-mutable type}}
+                      // expected-note@-4 {{'B' is a non-mutable type}}
+  mutating func change() { // expected-error {{type 'B' cannot have mutating function 'change()'}}
+    print("123")
+  }
+}
+
+let b0 = B() // OK
+
+var b1 = B() // expected-error {{variable of type 'B' must be declared with a 'let'}}
+
+class C {
+  var b2 = B() // expected-error {{variable of type 'B' must be declared with a 'let'}}
+  let b3 = B() // OK
+}
+
+struct D: ~Copyable {
+  var b4 = B() // expected-error {{variable of type 'B' must be declared with a 'let'}}
+  let b5 = B() // OK
+}
+
+func e(_: borrowing B) {} // OK
+
+func f(_: inout B) {} // expected-error {{parameter of type 'B' must be declared as either 'borrowing' or 'consuming'}}
+
+func g(_: (inout B) -> ()) {} // expected-error {{parameter of type 'B' must be declared as either 'borrowing' or 'consuming'}}
+
+func h(_: (borrowing B) -> ()) {} // OK
+
+func i() {
+  let _: (Int, Int) -> Int = {
+    var b6 = B() // expected-error {{variable of type 'B' must be declared with a 'let'}}
+                 // expected-warning@-1 {{initialization of variable 'b6' was never used; consider replacing with assignment to '_' or removing it}}
+
+    return $0 + $1
+  }
+}
+
+@_staticExclusiveOnly // expected-error {{@_staticExclusiveOnly may only be used on 'struct' declarations}}
+enum J {}
+
+@_staticExclusiveOnly // expected-error {{@_staticExclusiveOnly may only be used on 'struct' declarations}}
+class K {}
+
+@_staticExclusiveOnly // expected-error {{@_staticExclusiveOnly may only be used on 'struct' declarations}}
+func l() {}
+
+@_staticExclusiveOnly // expected-error {{@_staticExclusiveOnly may only be used on 'struct' declarations}}
+let m = 123
+
+@_staticExclusiveOnly // expected-error {{@_staticExclusiveOnly may only be used on 'struct' declarations}}
+protocol N {}
+
+func o(_: consuming B) {} // OK
+
+func p(_: (consuming B) -> ()) {} // OK
+
+@_staticExclusiveOnly
+struct Q<T>: ~Copyable {} // expected-note {{'Q<T>' is a non-mutable type}}
+
+var r0 = Q<Int>() // expected-error {{variable of type 'Q<Int>' must be declared with a 'let'}}