[AST/Sema] SE-0487: Rename @extensible into @nonexhaustive

xedin · xedin · commit c9722333b960 · 2025-08-18T23:58:27.000-07:00
This is an accepted spelling for the attribute. This commit also renames the feature flag from `ExtensibleAttribute` to `NonexhaustiveAttribute` to match the spelling of the attribute. (cherry picked from commit fe1ae75)
diff --git a/include/swift/AST/DeclAttr.def b/include/swift/AST/DeclAttr.def
@@ -876,11 +876,11 @@ SIMPLE_DECL_ATTR(constInitialized, ConstInitialized,
   168)
 DECL_ATTR_FEATURE_REQUIREMENT(ConstInitialized, CompileTimeValues)
 
-SIMPLE_DECL_ATTR(extensible, Extensible,
+SIMPLE_DECL_ATTR(nonexhaustive, Nonexhaustive,
   OnEnum,
   ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove | ForbiddenInABIAttr,
   169)
-DECL_ATTR_FEATURE_REQUIREMENT(Extensible, ExtensibleAttribute)
+DECL_ATTR_FEATURE_REQUIREMENT(Nonexhaustive, NonexhaustiveAttribute)
 
 SIMPLE_DECL_ATTR(concurrent, Concurrent,
   OnFunc | OnConstructor | OnSubscript | OnVar,
@@ -891,8 +891,8 @@ SIMPLE_DECL_ATTR(preEnumExtensibility, PreEnumExtensibility,
   OnEnum,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIBreakingToRemove | UnconstrainedInABIAttr,
   171)
-DECL_ATTR_FEATURE_REQUIREMENT(PreEnumExtensibility, ExtensibleAttribute)
-  
+DECL_ATTR_FEATURE_REQUIREMENT(PreEnumExtensibility, NonexhaustiveAttribute)
+
 LAST_DECL_ATTR(PreEnumExtensibility)
 
 #undef DECL_ATTR_ALIAS
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -8712,20 +8712,20 @@ GROUPED_WARNING(
     (StringRef))
 
 //===----------------------------------------------------------------------===//
-// MARK: @extensible and @preEnumExtensibility Attributes
+// MARK: @nonexhaustive and @preEnumExtensibility Attributes
 //===----------------------------------------------------------------------===//
 
-ERROR(extensible_attr_on_frozen_type,none,
-      "cannot use '@extensible' together with '@frozen'", ())
+ERROR(nonexhaustive_attr_on_frozen_type,none,
+      "cannot use '@nonexhaustive' together with '@frozen'", ())
 
-ERROR(extensible_attr_on_internal_type,none, 
-      "'@extensible' attribute can only be applied to public or package "
+ERROR(nonexhaustive_attr_on_internal_type,none,
+      "'@nonexhaustive' attribute can only be applied to public or package "
       "declarations, but %0 is "
       "%select{private|fileprivate|internal|%error|%error|%error}1",
       (DeclName, AccessLevel))
 
-ERROR(pre_enum_extensibility_without_extensible,none,
-      "%0 can only be used together with '@extensible' attribute", (DeclAttribute))
+ERROR(pre_enum_extensibility_without_nonexhaustive,none,
+      "%0 can only be used together with '@nonexhaustive' attribute", (DeclAttribute))
 
 //===----------------------------------------------------------------------===//
 // MARK: `using` declaration
diff --git a/include/swift/Basic/Features.def b/include/swift/Basic/Features.def
@@ -520,16 +520,16 @@ EXPERIMENTAL_FEATURE(AllowRuntimeSymbolDeclarations, true)
 /// Optimize copies of ObjectiveC blocks.
 EXPERIMENTAL_FEATURE(CopyBlockOptimization, true)
 
+/// Allow use of `@nonexhaustive` on public enums
+SUPPRESSIBLE_EXPERIMENTAL_FEATURE(NonexhaustiveAttribute, false)
+
 /// Allow use of `using` declaration that control default isolation
 /// in a file scope.
 EXPERIMENTAL_FEATURE(DefaultIsolationPerFile, false)
 
 /// Enable @_lifetime attribute
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(Lifetimes, true)
 
-/// Allow use of `@extensible` on public enums
-SUPPRESSIBLE_EXPERIMENTAL_FEATURE(ExtensibleAttribute, false)
-
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -5064,7 +5064,7 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, Label>,
   TRIVIAL_ATTR_PRINTER(Used, used)
   TRIVIAL_ATTR_PRINTER(WarnUnqualifiedAccess, warn_unqualified_access)
   TRIVIAL_ATTR_PRINTER(WeakLinked, weak_linked)
-  TRIVIAL_ATTR_PRINTER(Extensible, extensible)
+  TRIVIAL_ATTR_PRINTER(Nonexhaustive, nonexhaustive)
   TRIVIAL_ATTR_PRINTER(Concurrent, concurrent)
   TRIVIAL_ATTR_PRINTER(PreEnumExtensibility, preEnumExtensibility)
 
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -3326,9 +3326,9 @@ suppressingFeatureAddressableTypes(PrintOptions &options,
 }
 
 static void
-suppressingFeatureExtensibleAttribute(PrintOptions &options,
-                                      llvm::function_ref<void()> action) {
-  ExcludeAttrRAII scope1(options.ExcludeAttrList, DeclAttrKind::Extensible);
+suppressingFeatureNonexhaustiveAttribute(PrintOptions &options,
+                                         llvm::function_ref<void()> action) {
+  ExcludeAttrRAII scope1(options.ExcludeAttrList, DeclAttrKind::Nonexhaustive);
   ExcludeAttrRAII scope2(options.ExcludeAttrList, DeclAttrKind::PreEnumExtensibility);
   action();
 }
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -7027,9 +7027,9 @@ bool EnumDecl::treatAsExhaustiveForDiags(const DeclContext *useDC) const {
     if (enumModule->inSamePackage(useDC->getParentModule()))
       return true;
 
-    // When the enum is marked as `@extensible` cross-module access
+    // When the enum is marked as `@nonexhaustive` cross-module access
     // cannot be exhaustive and requires `@unknown default:`.
-    if (getAttrs().hasAttribute<ExtensibleAttr>() &&
+    if (getAttrs().hasAttribute<NonexhaustiveAttr>() &&
         enumModule != useDC->getParentModule())
       return false;
   }
diff --git a/lib/AST/FeatureSet.cpp b/lib/AST/FeatureSet.cpp
@@ -656,8 +656,8 @@ static bool usesFeatureAsyncExecutionBehaviorAttributes(Decl *decl) {
   return false;
 }
 
-static bool usesFeatureExtensibleAttribute(Decl *decl) {
-  return decl->getAttrs().hasAttribute<ExtensibleAttr>();
+static bool usesFeatureNonexhaustiveAttribute(Decl *decl) {
+  return decl->getAttrs().hasAttribute<NonexhaustiveAttr>();
 }
 
 UNINTERESTING_FEATURE(BuiltinSelect)
diff --git a/lib/ASTGen/Sources/ASTGen/DeclAttrs.swift b/lib/ASTGen/Sources/ASTGen/DeclAttrs.swift
@@ -228,7 +228,7 @@ extension ASTGenVisitor {
         .dynamicCallable,
         .eagerMove,
         .exported,
-        .extensible,
+        .nonexhaustive,
         .preEnumExtensibility,
         .discardableResult,
         .disfavoredOverload,
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -247,25 +247,25 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
     }
   }
 
-  void visitExtensibleAttr(ExtensibleAttr *attr) {
+  void visitNonexhaustiveAttr(NonexhaustiveAttr *attr) {
     auto *E = cast<EnumDecl>(D);
 
     if (D->getAttrs().hasAttribute<FrozenAttr>()) {
-      diagnoseAndRemoveAttr(attr, diag::extensible_attr_on_frozen_type);
+      diagnoseAndRemoveAttr(attr, diag::nonexhaustive_attr_on_frozen_type);
       return;
     }
 
     if (E->getFormalAccess() < AccessLevel::Package) {
-      diagnoseAndRemoveAttr(attr, diag::extensible_attr_on_internal_type,
+      diagnoseAndRemoveAttr(attr, diag::nonexhaustive_attr_on_internal_type,
                             E->getName(), E->getFormalAccess());
       return;
     }
   }
 
   void visitPreEnumExtensibilityAttr(PreEnumExtensibilityAttr *attr) {
-    if (!D->getAttrs().hasAttribute<ExtensibleAttr>()) {
+    if (!D->getAttrs().hasAttribute<NonexhaustiveAttr>()) {
       diagnoseAndRemoveAttr(
-          attr, diag::pre_enum_extensibility_without_extensible, attr);
+          attr, diag::pre_enum_extensibility_without_nonexhaustive, attr);
       return;
     }
   }
diff --git a/lib/Sema/TypeCheckDeclOverride.cpp b/lib/Sema/TypeCheckDeclOverride.cpp
@@ -1616,7 +1616,7 @@ namespace  {
     UNINTERESTING_ATTR(Isolated)
     UNINTERESTING_ATTR(Optimize)
     UNINTERESTING_ATTR(Exclusivity)
-    UNINTERESTING_ATTR(Extensible)
+    UNINTERESTING_ATTR(Nonexhaustive)
     UNINTERESTING_ATTR(PreEnumExtensibility)
     UNINTERESTING_ATTR(NoLocks)
     UNINTERESTING_ATTR(NoAllocation)
diff --git a/lib/Sema/TypeCheckSwitchStmt.cpp b/lib/Sema/TypeCheckSwitchStmt.cpp
@@ -1160,7 +1160,7 @@ namespace {
           auto *enumModule = theEnum->getParentModule();
           shouldIncludeFutureVersionComment =
               enumModule->isSystemModule() ||
-              theEnum->getAttrs().hasAttribute<ExtensibleAttr>();
+              theEnum->getAttrs().hasAttribute<NonexhaustiveAttr>();
         }
 
         auto diag =
diff --git a/test/ModuleInterface/nonexhaustive_attr.swift b/test/ModuleInterface/nonexhaustive_attr.swift
@@ -1,29 +1,29 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-swift-emit-module-interface(%t/Library.swiftinterface) %s -enable-experimental-feature ExtensibleAttribute -module-name Library
-// RUN: %target-swift-typecheck-module-from-interface(%t/Library.swiftinterface) -enable-experimental-feature ExtensibleAttribute -module-name Library
+// RUN: %target-swift-emit-module-interface(%t/Library.swiftinterface) %s -enable-experimental-feature NonexhaustiveAttribute -module-name Library
+// RUN: %target-swift-typecheck-module-from-interface(%t/Library.swiftinterface) -enable-experimental-feature NonexhaustiveAttribute -module-name Library
 // RUN: %target-swift-typecheck-module-from-interface(%t/Library.swiftinterface) -module-name Library
 // RUN: %FileCheck %s < %t/Library.swiftinterface
 
-// REQUIRES: swift_feature_ExtensibleAttribute
+// REQUIRES: swift_feature_NonexhaustiveAttribute
 
-// CHECK: #if compiler(>=5.3) && $ExtensibleAttribute
-// CHECK-NEXT: @extensible public enum E {
+// CHECK: #if compiler(>=5.3) && $NonexhaustiveAttribute
+// CHECK-NEXT: @nonexhaustive public enum E {
 // CHECK-NEXT: }
 // CHECK-NEXT: #else
 // CHECK-NEXT: public enum E {
 // CHECK-NEXT: }
 // CHECK-NEXT: #endif
-@extensible
+@nonexhaustive
 public enum E {
 }
 
-// CHECK: #if compiler(>=5.3) && $ExtensibleAttribute
-// CHECK-NEXT: @preEnumExtensibility @extensible public enum F {
+// CHECK: #if compiler(>=5.3) && $NonexhaustiveAttribute
+// CHECK-NEXT: @preEnumExtensibility @nonexhaustive public enum F {
 // CHECK: #else
 // CHECK-NEXT: public enum F {
 // CHECK: #endif
 @preEnumExtensibility
-@extensible
+@nonexhaustive
 public enum F {
   case a
 }
diff --git a/test/ModuleInterface/nonexhaustive_enums.swift b/test/ModuleInterface/nonexhaustive_enums.swift
@@ -6,9 +6,9 @@
 // RUN: %target-swift-frontend -emit-module %t/src/Lib.swift \
 // RUN:   -module-name Lib \
 // RUN:   -emit-module-path %t/Lib.swiftmodule \
-// RUN:   -enable-experimental-feature ExtensibleAttribute
+// RUN:   -enable-experimental-feature NonexhaustiveAttribute
 
-// Check that the errors are produced when using enums from module with `ExtensibleEnums` feature enabled.
+// Check that the errors are produced when using enums from module with `NonexhaustiveEnums` feature enabled.
 // RUN: %target-swift-frontend -typecheck %t/src/TestChecking.swift \
 // RUN:   -swift-version 5 -module-name Client -I %t \
 // RUN:   -verify
@@ -20,7 +20,7 @@
 // RUN:   -module-name Lib \
 // RUN:   -package-name Test \
 // RUN:   -emit-module-path %t/Lib.swiftmodule \
-// RUN:   -enable-experimental-feature ExtensibleAttribute
+// RUN:   -enable-experimental-feature NonexhaustiveAttribute
 
 
 // Different module but the same package
@@ -34,17 +34,17 @@
 // RUN:   -swift-version 6 -module-name Client -I %t \
 // RUN:   -verify
 
-// REQUIRES: swift_feature_ExtensibleAttribute
+// REQUIRES: swift_feature_NonexhaustiveAttribute
 
 //--- Lib.swift
 
-@extensible
+@nonexhaustive
 public enum E {
   case a
 }
 
 @preEnumExtensibility
-@extensible
+@nonexhaustive
 public enum PE {
   case a
 }
@@ -70,7 +70,7 @@ func test_same_module(e: E, f: F) {
 import Lib
 
 func test(e: E, pe: PE, f: F) {
-  // `E` is marked as `@extensible` which means it gets new semantics
+  // `E` is marked as `@nonexhaustive` which means it gets new semantics
 
   switch e {
   // expected-warning@-1 {{switch covers known cases, but 'E' may have additional unknown values, possibly added in future versions; this is an error in the Swift 6 language mode}}
diff --git a/test/attr/attr_extensible.swift b/test/attr/attr_extensible.swift
diff --git a/test/attr/attr_nonexhaustive.swift b/test/attr/attr_nonexhaustive.swift
@@ -0,0 +1,49 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature NonexhaustiveAttribute
+
+// REQUIRES: swift_feature_NonexhaustiveAttribute
+
+@nonexhaustive
+public enum E1 { // Ok
+}
+
+@nonexhaustive // expected-error {{'@nonexhaustive' attribute can only be applied to public or package declarations, but 'E2' is fileprivate}}
+fileprivate enum E2 {}
+
+@nonexhaustive // expected-error {{cannot use '@nonexhaustive' together with '@frozen'}}
+@frozen
+public enum E3 {
+}
+
+@nonexhaustive  // expected-error {{'@nonexhaustive' attribute can only be applied to public or package declarations, but 'E4' is internal}}
+@usableFromInline
+enum E4 {}
+
+@nonexhaustive // expected-error {{@nonexhaustive may only be used on 'enum' declarations}}
+struct Test {
+  @nonexhaustive // expected-error {{@nonexhaustive may only be used on 'enum' declarations}}
+  var v: Int {
+    @nonexhaustive // expected-error {{@nonexhaustive may only be used on 'enum' declarations}}
+    get { 0 }
+  }
+
+  @nonexhaustive // expected-error {{@nonexhaustive may only be used on 'enum' declarations}}
+  var v2: String = ""
+  
+  @nonexhaustive // expected-error {{@nonexhaustive may only be used on 'enum' declarations}}
+  func test() {}
+
+  @nonexhaustive // expected-error {{@nonexhaustive may only be used on 'enum' declarations}}
+  subscript(a: Int) -> Bool {
+    get { false }
+    set { }
+  }
+}
+
+@preEnumExtensibility
+@nonexhaustive
+public enum PE {
+}
+
+@preEnumExtensibility // expected-error {{@preEnumExtensibility can only be used together with '@nonexhaustive' attribute}}
+public enum WrongPreE {
+}
diff --git a/test/attr/feature_requirement.swift b/test/attr/feature_requirement.swift
@@ -1,5 +1,5 @@
 // RUN: %target-typecheck-verify-swift -parse-as-library -disable-experimental-parser-round-trip -verify-additional-prefix disabled-
-// RUN: %target-typecheck-verify-swift -parse-as-library -verify-additional-prefix enabled- -enable-experimental-feature CompileTimeValues -enable-experimental-feature ExtensibleAttribute
+// RUN: %target-typecheck-verify-swift -parse-as-library -verify-additional-prefix enabled- -enable-experimental-feature CompileTimeValues -enable-experimental-feature NonexhaustiveAttribute
 
 // REQUIRES: asserts
 
@@ -15,12 +15,12 @@ public let x = 1  // expected-disabled-error@-1 {{'const' attribute is only vali
   #error("doesn't have @const")  // expected-disabled-error {{doesn't have @const}}
 #endif
 
-@extensible
-public enum E {}  // expected-disabled-error@-1 {{'extensible' attribute is only valid when experimental feature ExtensibleAttribute is enabled}}
+@nonexhaustive
+public enum E {}  // expected-disabled-error@-1 {{'nonexhaustive' attribute is only valid when experimental feature NonexhaustiveAttribute is enabled}}
 
-#if hasAttribute(extensible)
-  #error("does have @extensible")  // expected-enabled-error {{does have @extensible}}
+#if hasAttribute(nonexhaustive)
+  #error("does have @nonexhaustive")  // expected-enabled-error {{does have @nonexhaustive}}
 #else
-  #error("doesn't have @extensible")  // expected-disabled-error {{doesn't have @extensible}}
+  #error("doesn't have @nonexhaustive")  // expected-disabled-error {{doesn't have @nonexhaustive}}
 #endif
 

Original file line number	Diff line number	Diff line change
`@@ -3326,9 +3326,9 @@ suppressingFeatureAddressableTypes(PrintOptions &options,`
`3326`	`3326`	`}`
`3327`	`3327`
`3328`	`3328`	`static void`
`3329`		`-suppressingFeatureExtensibleAttribute(PrintOptions &options,`
`3330`		`- llvm::function_ref<void()> action) {`
`3331`		`- ExcludeAttrRAII scope1(options.ExcludeAttrList, DeclAttrKind::Extensible);`
	`3329`	`+suppressingFeatureNonexhaustiveAttribute(PrintOptions &options,`
	`3330`	`+ llvm::function_ref<void()> action) {`
	`3331`	`+ ExcludeAttrRAII scope1(options.ExcludeAttrList, DeclAttrKind::Nonexhaustive);`
`3332`	`3332`	`ExcludeAttrRAII scope2(options.ExcludeAttrList, DeclAttrKind::PreEnumExtensibility);`
`3333`	`3333`	`action();`
`3334`	`3334`	`}`
Original file line number	Diff line number	Diff line change
`@@ -656,8 +656,8 @@ static bool usesFeatureAsyncExecutionBehaviorAttributes(Decl *decl) {`
`656`	`656`	`return false;`
`657`	`657`	`}`
`658`	`658`
`659`		`-static bool usesFeatureExtensibleAttribute(Decl *decl) {`
`660`		`- return decl->getAttrs().hasAttribute<ExtensibleAttr>();`
	`659`	`+static bool usesFeatureNonexhaustiveAttribute(Decl *decl) {`
	`660`	`+ return decl->getAttrs().hasAttribute<NonexhaustiveAttr>();`
`661`	`661`	`}`
`662`	`662`
`663`	`663`	`UNINTERESTING_FEATURE(BuiltinSelect)`
Original file line number	Diff line number	Diff line change
`@@ -247,25 +247,25 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {`
`247`	`247`	`}`
`248`	`248`	`}`
`249`	`249`
`250`		`- void visitExtensibleAttr(ExtensibleAttr *attr) {`
	`250`	`+ void visitNonexhaustiveAttr(NonexhaustiveAttr *attr) {`
`251`	`251`	`auto *E = cast<EnumDecl>(D);`
`252`	`252`
`253`	`253`	`if (D->getAttrs().hasAttribute<FrozenAttr>()) {`
`254`		`- diagnoseAndRemoveAttr(attr, diag::extensible_attr_on_frozen_type);`
	`254`	`+ diagnoseAndRemoveAttr(attr, diag::nonexhaustive_attr_on_frozen_type);`
`255`	`255`	`return;`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`if (E->getFormalAccess() < AccessLevel::Package) {`
`259`		`- diagnoseAndRemoveAttr(attr, diag::extensible_attr_on_internal_type,`
	`259`	`+ diagnoseAndRemoveAttr(attr, diag::nonexhaustive_attr_on_internal_type,`
`260`	`260`	`E->getName(), E->getFormalAccess());`
`261`	`261`	`return;`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`
`265`	`265`	`void visitPreEnumExtensibilityAttr(PreEnumExtensibilityAttr *attr) {`
`266`		`- if (!D->getAttrs().hasAttribute<ExtensibleAttr>()) {`
	`266`	`+ if (!D->getAttrs().hasAttribute<NonexhaustiveAttr>()) {`
`267`	`267`	`diagnoseAndRemoveAttr(`
`268`		`- attr, diag::pre_enum_extensibility_without_extensible, attr);`
	`268`	`+ attr, diag::pre_enum_extensibility_without_nonexhaustive, attr);`
`269`	`269`	`return;`
`270`	`270`	`}`
`271`	`271`	`}`