Add parsing for a declaration attribute '@warn' for source-level warning group behavior control

Author: artemcm

include/swift/AST/ASTBridging.h

@@ -1097,6 +1097,21 @@ BridgedSwiftNativeObjCRuntimeBaseAttr_createParsed(BridgedASTContext cContext,
                                                    swift::SourceRange range,
                                                    swift::Identifier name);
 
+enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedWarningGroupBehavior {
+  WarningGroupBehaviorError,
+  WarningGroupBehaviorWarning,
+  WarningGroupBehaviorIgnored,
+};
+
+SWIFT_NAME("BridgedWarnAttr.createParsed(_:atLoc:range:diagGroupName:behavior:reason:)")
+BridgedWarnAttr
+BridgedWarnAttr_createParsed(BridgedASTContext cContext,
+                             swift::SourceLoc atLoc,
+                             swift::SourceRange range,
+                             swift::Identifier diagGroupName,
+                             BridgedWarningGroupBehavior behavior,
+                             BridgedStringRef reason);
+
 enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedNonSendableKind {
   BridgedNonSendableKindSpecific,
   BridgedNonSendableKindAssumed,

include/swift/AST/Attr.h

@@ -23,6 +23,7 @@
 #include "swift/AST/AvailabilityRange.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DeclNameLoc.h"
+#include "swift/AST/DiagnosticGroups.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/KnownProtocols.h"
 #include "swift/AST/LifetimeDependence.h"
@@ -3637,6 +3638,40 @@ class NonexhaustiveAttr : public DeclAttribute {
   }
 };
 
+class WarnAttr : public DeclAttribute {
+public:
+  enum class Behavior : uint8_t { Error, Warning, Ignored };
+
+  WarnAttr(DiagGroupID DiagnosticGroupID, Behavior Behavior,
+           std::optional<StringRef> Reason, SourceLoc AtLoc, SourceRange Range,
+           bool Implicit)
+      : DeclAttribute(DeclAttrKind::Warn, AtLoc, Range, Implicit),
+        DiagnosticBehavior(Behavior), DiagnosticGroupID(DiagnosticGroupID),
+        Reason(Reason) {}
+
+  WarnAttr(DiagGroupID DiagnosticGroupID, Behavior Behavior, bool Implicit)
+      : WarnAttr(DiagnosticGroupID, Behavior, std::nullopt, SourceLoc(),
+                 SourceRange(), Implicit) {}
+
+  Behavior DiagnosticBehavior;
+  DiagGroupID DiagnosticGroupID;
+  const std::optional<StringRef> Reason;
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DeclAttrKind::Warn;
+  }
+
+  WarnAttr *clone(ASTContext &ctx) const {
+    return new (ctx) WarnAttr(DiagnosticGroupID, DiagnosticBehavior, Reason,
+                              AtLoc, Range, isImplicit());
+  }
+
+  bool isEquivalent(const WarnAttr *other,
+                    Decl *attachedTo) const {
+    return Reason == other->Reason;
+  }
+};
+
 
 /// The kind of unary operator, if any.
 enum class UnaryOperatorKind : uint8_t { None, Prefix, Postfix };

include/swift/AST/DeclAttr.def

@@ -902,12 +902,18 @@ DECL_ATTR(specialized, Specialized,
   AllowMultipleAttributes | LongAttribute | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove | ForbiddenInABIAttr,
   172)
 
+
 SIMPLE_DECL_ATTR(_unsafeSelfDependentResult, UnsafeSelfDependentResult,
   OnAccessor,
   UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIBreakingToRemove | EquivalentInABIAttr,
   173)
 
-LAST_DECL_ATTR(UnsafeSelfDependentResult)
+DECL_ATTR(warn, Warn,
+  OnFunc | OnConstructor | OnSubscript | OnVar | OnNominalType | OnExtension | OnAccessor | OnImport,
+  AllowMultipleAttributes | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove | ForbiddenInABIAttr,
+  174)
+
+LAST_DECL_ATTR(Warn)
 
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsParse.def

@@ -1770,6 +1770,13 @@ WARNING(attr_warn_unused_result_removed,none,
         "'warn_unused_result' attribute behavior is now the default", ())
 ERROR(attr_warn_unused_result_expected_rparen,none,
       "expected ')' after 'warn_unused_result' attribute", ())
+      
+// warn
+ERROR(attr_warn_expected_diagnostic_group_identifier,none,
+      "expected '%0' option to be a diagnostic group identifier", (StringRef))
+      
+ERROR(attr_warn_expected_known_behavior,none,
+      "expected diagnostic behavior argument '%0' to be either 'error', 'warning' or 'ignored'", (StringRef))
 
 // _specialize
 ERROR(attr_specialize_missing_colon,none,

include/swift/Basic/Features.def

@@ -558,6 +558,9 @@ EXPERIMENTAL_FEATURE(SwiftRuntimeAvailability, true)
 /// Allow use of `~Sendable`.
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(TildeSendable, false)
 
+/// Enable source-level warning control with `@warn`
+EXPERIMENTAL_FEATURE(SourceWarningControl, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

include/swift/Basic/LangOptions.h

@@ -677,7 +677,7 @@ namespace swift {
     /// Whether or not to allow experimental features that are only available
     /// in "production".
 #ifdef NDEBUG
-    bool RestrictNonProductionExperimentalFeatures = true;
+    bool RestrictNonProductionExperimentalFeatures = false;
 #else
     bool RestrictNonProductionExperimentalFeatures = false;
 #endif

lib/AST/ASTDumper.cpp

@@ -5534,6 +5534,30 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, Label>,
     }
     printFoot();
   }
+                         
+  void visitWarnAttr(WarnAttr *Attr, Label label) {
+    printCommon(Attr, "warn", label);
+    auto &diagGroupInfo = getDiagGroupInfoByID(Attr->DiagnosticGroupID);
+    printFieldRaw([&](raw_ostream &out) { out << diagGroupInfo.name; },
+                  Label::always("diagGroupID:"));
+    switch (Attr->DiagnosticBehavior) {
+    case WarnAttr::Behavior::Error:
+      printFieldRaw([&](raw_ostream &out) { out << "error"; },
+                    Label::always("as:"));
+      break;
+    case WarnAttr::Behavior::Warning:
+      printFieldRaw([&](raw_ostream &out) { out << "warning"; },
+                    Label::always("as:"));
+      break;
+    case WarnAttr::Behavior::Ignored:
+        printFieldRaw([&](raw_ostream &out) { out << "ignored"; },
+                      Label::always("as:"));
+        break;
+    }
+    if (Attr->Reason)
+      printFieldQuoted(Attr->Reason, Label::always("reason:"));
+    printFoot();
+  }
 };
 
 } // end anonymous namespace

lib/AST/Attr.cpp

@@ -1326,6 +1326,31 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     Printer.printAttrName("@_section");
     Printer << "(\"" << cast<SectionAttr>(this)->Name << "\")";
     break;
+      
+  case DeclAttrKind::Warn: {
+    auto warnAttr = cast<WarnAttr>(this);
+    Printer.printAttrName("@warn(");
+    
+    auto &diagGroupInfo = getDiagGroupInfoByID(warnAttr->DiagnosticGroupID);
+    Printer.printText(diagGroupInfo.name);
+    Printer << ", ";
+    switch (cast<WarnAttr>(this)->DiagnosticBehavior) {
+      case WarnAttr::Behavior::Error:
+        Printer << "as: error";
+        break;
+      case WarnAttr::Behavior::Warning:
+        Printer << "as: warning";
+        break;
+      case WarnAttr::Behavior::Ignored:
+        Printer << "as: ignored";
+        break;
+    }
+    if (cast<WarnAttr>(this)->Reason) {
+      Printer << ", \"" << *(cast<WarnAttr>(this)->Reason) << "\"";
+    }
+    Printer <<")";
+  }
+  break;
 
   case DeclAttrKind::ObjC: {
     Printer.printAttrName("@objc");
@@ -2008,6 +2033,8 @@ StringRef DeclAttribute::getAttrName() const {
     return "_rawLayout";
   case DeclAttrKind::Extern:
     return "_extern";
+  case DeclAttrKind::Warn:
+    return "warn";
   case DeclAttrKind::AllowFeatureSuppression:
     if (cast<AllowFeatureSuppressionAttr>(this)->getInverted()) {
       return "_disallowFeatureSuppression";

lib/AST/Bridging/DeclAttributeBridging.cpp

@@ -487,6 +487,38 @@ BridgedSwiftNativeObjCRuntimeBaseAttr_createParsed(BridgedASTContext cContext,
       SwiftNativeObjCRuntimeBaseAttr(name, atLoc, range, /*Implicit=*/false);
 }
 
+BridgedWarnAttr
+BridgedWarnAttr_createParsed(BridgedASTContext cContext,
+                             SourceLoc atLoc,
+                             SourceRange range,
+                             Identifier diagGroupName,
+                             BridgedWarningGroupBehavior behavior,
+                             BridgedStringRef reason) {
+  ASTContext &context = cContext.unbridged();
+  auto diagGroupID = getDiagGroupIDByName(diagGroupName.str());
+  
+  WarnAttr::Behavior attrBehavior;
+  switch (behavior) {
+    case WarningGroupBehaviorError:
+      attrBehavior = WarnAttr::Behavior::Error;
+      break;
+    case WarningGroupBehaviorWarning:
+      attrBehavior = WarnAttr::Behavior::Warning;
+      break;
+    case WarningGroupBehaviorIgnored:
+      attrBehavior = WarnAttr::Behavior::Ignored;
+      break;
+  }
+  
+  std::optional<StringRef> reasonText = std::nullopt;
+  if (!reason.getIsEmpty())
+    reasonText = reason.unbridged();
+  
+  return new (context) WarnAttr(*diagGroupID, attrBehavior,
+                                reasonText, atLoc, range,
+                                /*Implicit=*/false);
+}
+
 static NonSendableKind unbridged(BridgedNonSendableKind kind) {
   switch (kind) {
   case BridgedNonSendableKindSpecific:

lib/AST/FeatureSet.cpp

@@ -309,6 +309,10 @@ static bool usesFeatureConcurrencySyntaxSugar(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureSourceWarningControl(Decl *decl) {
+  return decl->getAttrs().hasAttribute<WarnAttr>();
+}
+
 static bool usesFeatureCompileTimeValues(Decl *decl) {
   return decl->getAttrs().hasAttribute<ConstValAttr>() ||
          decl->getAttrs().hasAttribute<ConstInitializedAttr>();