Tie attributes to language features

The new `DECL_ATTR_FEATURE_REQUIREMENT` macro in DeclAttr.def can be used to declare that an attribute should only be available when a related language feature is enabled.

Effects:

• `#if hasAttribute(someAttr)` will return `false` unless the required feature is enabled.
• Code completion will not include the attribute unless the required feature is enabled.
• `TypeChecker::checkDeclAttributes()` diagnoses non-implicit uses of the attribute.

Add this mechanism and use it to tie @abi to the ABIAttribute feature. Also design tests for it.

Author: beccadax

include/swift/AST/Attr.h

@@ -31,6 +31,7 @@
 #include "swift/AST/StorageImpl.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/EnumTraits.h"
+#include "swift/Basic/Feature.h"
 #include "swift/Basic/InlineBitfield.h"
 #include "swift/Basic/Located.h"
 #include "swift/Basic/OptimizationMode.h"
@@ -493,6 +494,8 @@ class DeclAttribute : public AttributeBase {
   LLVM_READNONE
   static bool canAttributeAppearOnDeclKind(DeclAttrKind DAK, DeclKind DK);
 
+  static std::optional<Feature> getRequiredFeature(DeclAttrKind DK);
+
   /// Returns the source name of the attribute, without the @ or any arguments.
   StringRef getAttrName() const;
 

include/swift/AST/DeclAttr.def

@@ -42,6 +42,16 @@
                    DECL_ATTR_ALIAS(SPELLING, CLASS)
 #endif
 
+// Diagnose any use of the attribute CLASS without FEATURE_NAME enabled,
+// and also enable other special behavior. If you use this for an experimental
+// feature, please add test cases to:
+// 
+// * test/attr/feature_requirement.swift
+// * test/IDE/complete_decl_attribute_feature_requirement.swift
+#ifndef DECL_ATTR_FEATURE_REQUIREMENT
+#define DECL_ATTR_FEATURE_REQUIREMENT(CLASS, FEATURE_NAME)
+#endif
+
 #ifndef LAST_DECL_ATTR
 #define LAST_DECL_ATTR(CLASS)
 #endif
@@ -516,6 +526,7 @@ DECL_ATTR(lifetime, Lifetime,
 DECL_ATTR(abi, ABI,
   OnAbstractFunction | OnVar /* will eventually add types */ | LongAttribute | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   162)
+DECL_ATTR_FEATURE_REQUIREMENT(ABI, ABIAttribute)
 
 LAST_DECL_ATTR(ABI)
 
@@ -525,4 +536,5 @@ LAST_DECL_ATTR(ABI)
 #undef CONTEXTUAL_SIMPLE_DECL_ATTR
 #undef DECL_ATTR
 #undef CONTEXTUAL_DECL_ATTR
+#undef DECL_ATTR_FEATURE_REQUIREMENT
 #undef LAST_DECL_ATTR

include/swift/IDE/CompletionLookup.h

@@ -600,7 +600,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
                                         SourceLoc CodeCompletionLoc);
 
   static bool canUseAttributeOnDecl(DeclAttrKind DAK, bool IsInSil,
-                                    bool IsConcurrencyEnabled,
+                                    const LangOptions &langOpts,
                                     std::optional<DeclKind> DK, StringRef Name);
 
   void getAttributeDeclCompletions(bool IsInSil, std::optional<DeclKind> DK);

lib/AST/Attr.cpp

@@ -1646,6 +1646,18 @@ uint64_t DeclAttribute::getOptions(DeclAttrKind DK) {
   llvm_unreachable("bad DeclAttrKind");
 }
 
+std::optional<Feature> DeclAttribute::getRequiredFeature(DeclAttrKind DK) {
+  switch (DK) {
+#define DECL_ATTR_FEATURE_REQUIREMENT(CLASS, FEATURE_NAME)                     \
+  case DeclAttrKind::CLASS:                                                    \
+    return Feature::FEATURE_NAME;
+#include "swift/AST/DeclAttr.def"
+  default:
+    return std::nullopt;
+  }
+  llvm_unreachable("bad DeclAttrKind");
+}
+
 StringRef DeclAttribute::getAttrName() const {
   switch (getKind()) {
 #define SIMPLE_DECL_ATTR(NAME, CLASS, ...)                                     \
@@ -2896,6 +2908,10 @@ static bool hasDeclAttribute(const LangOptions &langOpts,
   if (DeclAttribute::isConcurrencyOnly(*kind))
     return false;
 
+  if (auto feature = DeclAttribute::getRequiredFeature(*kind))
+    if (!langOpts.hasFeature(*feature))
+      return false;
+
   return true;
 }
 

lib/IDE/CodeCompletion.cpp

@@ -686,7 +686,7 @@ static void addKeyword(CodeCompletionResultSink &Sink, StringRef Name,
 }
 
 static void addDeclKeywords(CodeCompletionResultSink &Sink, DeclContext *DC,
-                            bool IsConcurrencyEnabled) {
+                            const LangOptions &langOpts) {
   auto isTypeDeclIntroducer = [](CodeCompletionKeywordKind Kind,
                                  std::optional<DeclAttrKind> DAK) -> bool {
     switch (Kind) {
@@ -799,10 +799,16 @@ static void addDeclKeywords(CodeCompletionResultSink &Sink, DeclContext *DC,
       return;
 
     // Remove keywords only available when concurrency is enabled.
-    if (DAK.has_value() && !IsConcurrencyEnabled &&
+    if (DAK.has_value() && !langOpts.EnableExperimentalConcurrency &&
         DeclAttribute::isConcurrencyOnly(*DAK))
       return;
 
+    // Remove experimental keywords.
+    if (DAK.has_value())
+      if (auto feature = DeclAttribute::getRequiredFeature(*DAK))
+        if (!langOpts.hasFeature(*feature))
+          return;
+
     CodeCompletionFlair flair = getFlair(Kind, DAK);
 
     // Special case for 'actor'. Get the same flair with 'kw_class'.
@@ -1019,8 +1025,7 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
     LLVM_FALLTHROUGH;
   }
   case CompletionKind::StmtOrExpr:
-    addDeclKeywords(Sink, CurDeclContext,
-                    Context.LangOpts.EnableExperimentalConcurrency);
+    addDeclKeywords(Sink, CurDeclContext, Context.LangOpts);
     addStmtKeywords(Sink, CurDeclContext, MaybeFuncBody);
     addClosureSignatureKeywordsIfApplicable(Sink, CurDeclContext);
 
@@ -1122,8 +1127,7 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
         .Default(false);
     }) != ParsedKeywords.end();
     if (!HasDeclIntroducer) {
-      addDeclKeywords(Sink, CurDeclContext,
-                      Context.LangOpts.EnableExperimentalConcurrency);
+      addDeclKeywords(Sink, CurDeclContext, Context.LangOpts);
       addLetVarKeywords(Sink);
     }
     break;

lib/IDE/CompletionLookup.cpp

@@ -3023,7 +3023,7 @@ void CompletionLookup::getGenericRequirementCompletions(
 }
 
 bool CompletionLookup::canUseAttributeOnDecl(DeclAttrKind DAK, bool IsInSil,
-                                             bool IsConcurrencyEnabled,
+                                             const LangOptions &langOpts,
                                              std::optional<DeclKind> DK,
                                              StringRef Name) {
   if (DeclAttribute::isUserInaccessible(DAK))
@@ -3034,8 +3034,12 @@ bool CompletionLookup::canUseAttributeOnDecl(DeclAttrKind DAK, bool IsInSil,
     return false;
   if (!IsInSil && DeclAttribute::isSilOnly(DAK))
     return false;
-  if (!IsConcurrencyEnabled && DeclAttribute::isConcurrencyOnly(DAK))
+  if (!langOpts.EnableExperimentalConcurrency
+        && DeclAttribute::isConcurrencyOnly(DAK))
     return false;
+  if (auto feature = DeclAttribute::getRequiredFeature(DAK))
+    if (!langOpts.hasFeature(*feature))
+      return false;
   if (!DK.has_value())
     return true;
   // Hide underscored attributes even if they are not marked as user
@@ -3059,11 +3063,10 @@ void CompletionLookup::getAttributeDeclCompletions(bool IsInSil,
 #include "swift/AST/DeclNodes.def"
     }
   }
-  bool IsConcurrencyEnabled = Ctx.LangOpts.EnableExperimentalConcurrency;
   std::string Description = TargetName.str() + " Attribute";
 #define DECL_ATTR_ALIAS(KEYWORD, NAME) DECL_ATTR(KEYWORD, NAME, 0, 0)
 #define DECL_ATTR(KEYWORD, NAME, ...)                                          \
-  if (canUseAttributeOnDecl(DeclAttrKind::NAME, IsInSil, IsConcurrencyEnabled, \
+  if (canUseAttributeOnDecl(DeclAttrKind::NAME, IsInSil, Ctx.LangOpts,         \
                             DK, #KEYWORD))                                     \
     addDeclAttrKeyword(#KEYWORD, Description);
 #include "swift/AST/DeclAttr.def"

lib/Sema/TypeCheckAttr.cpp

@@ -1789,6 +1789,18 @@ void TypeChecker::checkDeclAttributes(Decl *D) {
   for (auto attr : D->getExpandedAttrs()) {
     if (!attr->isValid()) continue;
 
+    // If the attribute requires a feature that is not enabled, and it is not
+    // an implicit attribute, diagnose and disable it.
+    if (auto feature = DeclAttribute::getRequiredFeature(attr->getKind())) {
+      if (!attr->isImplicit()
+            && !D->getASTContext().LangOpts.hasFeature(*feature)) {
+        Checker.diagnoseAndRemoveAttr(attr, diag::requires_experimental_feature,
+                                      attr->getAttrName(), false,
+                                      getFeatureName(*feature));
+        continue;
+      }
+    }
+
     // If Attr.def says that the attribute cannot appear on this kind of
     // declaration, diagnose it and disable it.
     if (attr->canAppearOnDecl(D)) {

test/IDE/complete_decl_attribute_feature_requirement.swift

@@ -0,0 +1,126 @@
+// This contains code completion test cases for features covered by experimental
+// feature flags, and tests both the case when the feature is disabled and when
+// it's enabled. When a feature becomes non-experimental, move its test cases
+// into the normal complete_decl_attribute.swift test file.
+
+// REQUIRES: asserts
+
+// RUN: %batch-code-completion -filecheck-additional-suffix _DISABLED
+// RUN: %batch-code-completion -filecheck-additional-suffix _ENABLED -enable-experimental-feature ABIAttribute
+
+// NOTE: Please do not include the ", N items" after "Begin completions". The
+// item count creates needless merge conflicts given that an "End completions"
+// line exists for each test.
+
+@#^KEYWORD2^# func method(){}
+
+// KEYWORD2:              Begin completions
+// KEYWORD2_ENABLED-DAG:  Keyword/None:              abi[#Func Attribute#]; name=abi
+// KEYWORD2_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// KEYWORD2:              End completions
+
+@#^KEYWORD3^# class C {}
+
+// KEYWORD3:              Begin completions
+// KEYWORD3_ENABLED-NOT:  Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// KEYWORD3_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// KEYWORD3:              End completions
+
+@#^KEYWORD3_2?check=KEYWORD3^#IB class C2 {}
+// Same as KEYWORD3.
+
+@#^KEYWORD4^# enum E {}
+// KEYWORD4:              Begin completions
+// KEYWORD4_ENABLED-NOT:  Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// KEYWORD4_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// KEYWORD4:              End completions
+
+@#^KEYWORD5^# struct S{}
+// KEYWORD5:              Begin completions
+// KEYWORD5_ENABLED-NOT:  Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// KEYWORD5_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// KEYWORD5:              End completions
+
+@#^ON_GLOBALVAR^# var globalVar
+// ON_GLOBALVAR:              Begin completions
+// ON_GLOBALVAR_ENABLED-DAG:  Keyword/None:              abi[#Var Attribute#]; name=abi
+// ON_GLOBALVAR_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// ON_GLOBALVAR:              End completions
+
+struct _S {
+  @#^ON_INIT^# init()
+// ON_INIT:              Begin completions
+// ON_INIT_ENABLED-DAG:  Keyword/None:              abi[#Constructor Attribute#]; name=abi
+// ON_INIT_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// ON_INIT:              End completions
+
+  @#^ON_PROPERTY^# var foo
+// ON_PROPERTY:              Begin completions
+// ON_PROPERTY_ENABLED-DAG:  Keyword/None:              abi[#Var Attribute#]; name=abi
+// ON_PROPERTY_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// ON_PROPERTY:              End completions
+
+  @#^ON_METHOD^# private
+  func foo()
+// ON_METHOD:              Begin completions
+// ON_METHOD_ENABLED-DAG:  Keyword/None:              abi[#Func Attribute#]; name=abi
+// ON_METHOD_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// ON_METHOD:              End completions
+
+
+  func bar(@#^ON_PARAM_1?check=ON_PARAM^#)
+// ON_PARAM:              Begin completions
+// ON_PARAM_ENABLED-NOT:  Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// ON_PARAM_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// ON_PARAM:              End completions
+
+  func bar(
+    @#^ON_PARAM_2?check=ON_PARAM^#
+
+    arg: Int
+  )
+// Same as ON_PARAM.
+
+  @#^ON_MEMBER_INDEPENDENT_1?check=ON_MEMBER_LAST^#
+
+  func dummy1() {}
+// Same as ON_MEMBER_LAST.
+
+  @#^ON_MEMBER_INDEPENDENT_2?check=ON_MEMBER_LAST^#
+  func dummy2() {}
+// Same as ON_MEMBER_LAST.
+
+
+  @#^ON_MEMBER_LAST^#
+// ON_MEMBER_LAST:              Begin completions
+// ON_MEMBER_LAST_ENABLED-DAG:  Keyword/None:              abi[#Declaration Attribute#]; name=abi
+// ON_MEMBER_LAST_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// ON_MEMBER_LAST:              End completions
+}
+
+func takeClosure(_: () -> Void) {
+  takeClosure { @#^IN_CLOSURE^# in
+    print("x")
+  }
+}
+// IN_CLOSURE:              Begin completions
+// FIXME: Not valid in this position (but CompletionLookup can't tell that)
+// IN_CLOSURE_ENABLED-DAG:  Keyword/None:              abi[#Declaration Attribute#]; name=abi
+// IN_CLOSURE_DISABLED-NOT: Keyword/None:              abi[#{{.*}} Attribute#]; name=abi
+// IN_CLOSURE:              End completions
+
+@#^KEYWORD_INDEPENDENT_1?check=KEYWORD_LAST^#
+
+func dummy1() {}
+// Same as KEYWORD_LAST.
+
+@#^KEYWORD_INDEPENDENT_2?check=KEYWORD_LAST^#
+func dummy2() {}
+// Same as KEYWORD_LAST.
+
+@#^KEYWORD_LAST^#
+
+// KEYWORD_LAST:              Begin completions
+// KEYWORD_LAST_ENABLED-DAG:  Keyword/None:              abi[#Declaration Attribute#]; name=abi
+// KEYWORD_LAST_DISABLED-NOT: Keyword/None:              abi[#Declaration Attribute#]; name=abi
+// KEYWORD_LAST:              End completions

test/Misc/verify-swift-feature-testing.test-sh

@@ -20,6 +20,10 @@ EXCEPTIONAL_FILES = [
     pathlib.Path("test/ModuleInterface/swift-export-as.swift"),
     # Uses the pseudo-feature AvailabilityMacro=
     pathlib.Path("test/Sema/availability_define.swift"),
+    # Tests behavior when you try to use a feature without enabling it
+    pathlib.Path("test/attr/feature_requirement.swift"),
+    # Tests completion with features both enabled and disabled
+    pathlib.Path("test/IDE/complete_decl_attribute_feature_requirement.swift"),
 ]
 
 FEATURE_USAGE_RE = re.compile(

test/attr/feature_requirement.swift

@@ -0,0 +1,16 @@
+// RUN: %target-typecheck-verify-swift -parse-as-library -verify-additional-prefix disabled-
+// RUN: %target-typecheck-verify-swift -parse-as-library -verify-additional-prefix enabled- -enable-experimental-feature ABIAttribute
+
+// REQUIRES: asserts
+
+// This test checks whether DECL_ATTR_FEATURE_REQUIREMENT is being applied correctly.
+// It is expected to need occasional edits as experimental features are stabilized.
+
+@abi(func fn())
+func fn() {}  // expected-disabled-error@-1 {{'abi' attribute is only valid when experimental feature ABIAttribute is enabled}}
+
+#if hasAttribute(abi)
+  #error("does have @abi")  // expected-enabled-error {{does have @abi}}
+#else
+  #error("doesn't have @abi")  // expected-disabled-error {{doesn't have @abi}}
+#endif

tools/swift-ide-test/swift-ide-test.cpp

@@ -457,6 +457,11 @@ FileCheckPath("filecheck", llvm::cl::value_desc("path"),
 static llvm::cl::opt<bool>
 SkipFileCheck("skip-filecheck", llvm::cl::desc("Skip 'FileCheck' checking"),
                                 llvm::cl::cat(Category));
+static llvm::cl::opt<std::string>
+FileCheckSuffix("filecheck-additional-suffix",
+                           llvm::cl::value_desc("check-prefix-suffix"),
+                           llvm::cl::desc("Additional suffix to add to check prefixes as an alternative"),
+                           llvm::cl::cat(Category));
 
 // '-code-completion' options.
 
@@ -1537,11 +1542,32 @@ static int doBatchCodeCompletion(const CompilerInvocation &InitInvok,
         options::CodeCompletionToken != Token.Name)
       continue;
 
+    SmallVector<std::string, 4> expandedCheckPrefixes;
+
     llvm::errs() << "----\n";
     llvm::errs() << "Token: " << Token.Name << "; offset=" << Token.Offset
                  << "; pos=" << Token.Line << ":" << Token.Column;
-    for (auto Prefix : Token.CheckPrefixes) {
-      llvm::errs() << "; check=" << Prefix;
+    for (auto joinedPrefix : Token.CheckPrefixes) {
+      if (options::FileCheckSuffix.empty()) {
+        // Simple case: just copy what we have
+        expandedCheckPrefixes.push_back(joinedPrefix.str());
+      } else {
+        // For each comma-separated prefix, insert a variant with the suffix
+        // added to it: "X,Y" with suffix "_FOO" -> "X,X_FOO,Y,Y_FOO"
+        std::string expandedPrefix;
+        llvm::raw_string_ostream os(expandedPrefix);
+
+        SmallVector<StringRef, 4> splitPrefix;
+        joinedPrefix.split(splitPrefix, ',');
+
+        llvm::interleaveComma(splitPrefix, os, [&](StringRef prefix) {
+          os << prefix << ',' << prefix << options::FileCheckSuffix;
+        });
+
+        expandedCheckPrefixes.push_back(expandedPrefix);
+      }
+
+      llvm::errs() << "; check=" << expandedCheckPrefixes.back();
     }
     llvm::errs() << "\n";
 
@@ -1662,7 +1688,7 @@ static int doBatchCodeCompletion(const CompilerInvocation &InitInvok,
     assert(!options::FileCheckPath.empty());
 
     bool isFileCheckFailed = false;
-    for (auto Prefix : Token.CheckPrefixes) {
+    for (auto Prefix : expandedCheckPrefixes) {
       StringRef FileCheckArgs[] = {options::FileCheckPath, SourceFilename,
                                    "--check-prefixes",     Prefix,
                                    "--input-file",         resultFilename};