Add note, check against feature

Author: Azoy

include/swift/AST/DiagnosticsSema.def

@@ -1924,6 +1924,8 @@ 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,

lib/Sema/TypeCheckAttr.cpp

@@ -7259,12 +7259,14 @@ 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->isNoncopyable()) {
+  if (!structDecl->getDeclaredInterfaceType()
+                 ->isNoncopyable(D->getDeclContext())) {
     diagnoseAndRemoveAttr(attr, diag::attr_static_exclusive_only_noncopyable);
   }
 }

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2484,10 +2484,16 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     // @_staticExclusiveOnly types cannot be put into 'var's, only 'let'.
     if (auto SD = VD->getInterfaceType()->getStructOrBoundGenericStruct()) {
-      if (SD->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>() &&
+      if (getASTContext().LangOpts.hasFeature(Feature::StaticExclusiveOnly) &&
+          SD->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>() &&
           !VD->isLet()) {
-        VD->diagnose(diag::attr_static_exclusive_only_let_only,
-                     VD->getInterfaceType());
+        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());
+          });
       }
     }
   }
@@ -4236,10 +4242,16 @@ 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->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>() &&
+      if (SD->getASTContext().LangOpts.hasFeature(Feature::StaticExclusiveOnly) &&
+          SD->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>() &&
           param->isInOut()) {
-        param->diagnose(diag::attr_static_exclusive_only_let_only_param,
-                        param->getInterfaceType());
+        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());
+          });
       }
     }
   }

lib/Sema/TypeCheckType.cpp

@@ -3563,7 +3563,8 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
       // @_staticExclusiveOnly types cannot be passed as 'inout' in function
       // types.
       if (auto SD = ty->getStructOrBoundGenericStruct()) {
-        if (SD->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>() &&
+        if (getASTContext().LangOpts.hasFeature(Feature::StaticExclusiveOnly) &&
+            SD->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>() &&
             ownership == ParamSpecifier::InOut) {
           diagnose(eltTypeRepr->getLoc(),
                    diag::attr_static_exclusive_only_let_only_param,

test/attr/attr_static_exclusive_only.swift

@@ -1,10 +1,14 @@
 // RUN: %target-typecheck-verify-swift -enable-experimental-feature StaticExclusiveOnly
 
-@_staticExclusiveOnly // expected-error{{@_staticExclusiveOnly can only be applied to noncopyable types}}
+@_staticExclusiveOnly // expected-error {{@_staticExclusiveOnly can only be applied to noncopyable types}}
 struct A {}
 
 @_staticExclusiveOnly // OK
-struct B: ~Copyable {
+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 {{@_staticExclusiveOnly type 'B' cannot have mutating function 'change()'}}
     print("123")
   }
@@ -40,3 +44,27 @@ func i() {
     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'}}