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

Author: artemcm

include/swift/AST/ASTBridging.h

@@ -1151,6 +1151,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/ExportKind.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/KnownProtocols.h"
@@ -3678,6 +3679,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

@@ -905,12 +905,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 | OnDestructor | 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

@@ -1768,6 +1768,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
+WARNING(attr_warn_unknown_diagnostic_group_identifier,none,
+        "the diagnostic group identifier '%0' is unknown", (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

@@ -573,6 +573,9 @@ EXPERIMENTAL_FEATURE(CheckImplementationOnlyStrict, false)
 /// Check that use sites have the required @_spi import for operators.
 EXPERIMENTAL_FEATURE(EnforceSPIOperatorGroup, true)
 
+/// Enable source-level warning control with `@warn`
+EXPERIMENTAL_FEATURE(SourceWarningControl, true)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/AST/ASTDumper.cpp

@@ -5610,6 +5610,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");
@@ -2017,6 +2042,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

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

@@ -337,6 +337,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>();

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -198,6 +198,8 @@ extension ASTGenVisitor {
         return handle(self.generateStorageRestrictionAttr(attribute: node)?.asDeclAttribute)
       case .SwiftNativeObjCRuntimeBase:
         return handle(self.generateSwiftNativeObjCRuntimeBaseAttr(attribute: node)?.asDeclAttribute)
+      case .Warn:
+        return handle(self.generateWarnAttr(attribute: node)?.asDeclAttribute)
       case .Transpose:
         return handle(self.generateTransposeAttr(attribute: node)?.asDeclAttribute)
       case .TypeEraser:
@@ -2198,6 +2200,56 @@ extension ASTGenVisitor {
       name: name
     )
   }
+  
+  /// E.g.:
+  ///   ```
+  ///   @warn(DiagGroupID, as: Behavior, reason: String?)
+  ///   ```
+  func generateWarnAttr(attribute node: AttributeSyntax) -> BridgedWarnAttr? {
+    guard let diagGroupIdentifier: swift.Identifier = self.generateWithLabeledExprListArguments(attribute: node, { args in
+      self.generateConsumingAttrOption(args: &args, label: nil) { expr in
+        guard let declRefExpr = expr.as(DeclReferenceExprSyntax.self) else {
+          return nil
+        }
+        return self.generateIdentifier(declRefExpr.baseName)
+      }
+    }) else {
+      return nil
+    }
+    
+    guard let behavior: BridgedWarningGroupBehavior = self.generateWithLabeledExprListArguments(attribute: node, { args in
+      self.generateConsumingAttrOption(args: &args, label: "as") { expr in
+        guard let declRefExpr = expr.as(DeclReferenceExprSyntax.self) else {
+          return nil
+        }
+        switch declRefExpr.baseName.text {
+        case "error": return BridgedWarningGroupBehavior.WarningGroupBehaviorError
+        case "warning": return BridgedWarningGroupBehavior.WarningGroupBehaviorWarning
+        case "ignored": return BridgedWarningGroupBehavior.WarningGroupBehaviorIgnored
+        default: return nil
+        }
+      }
+    }) else {
+      return nil
+    }
+    
+    let reason: BridgedStringRef
+    if let userSpecifiedReason = self.generateWithLabeledExprListArguments(attribute: node, { args in
+      self.generateConsumingSimpleStringLiteralAttrOption(args: &args, label: "reason")}) {
+      reason = userSpecifiedReason
+    } else {
+      reason = allocateBridgedString("")
+    }
+
+    return .createParsed(
+      self.ctx,
+      atLoc: self.generateSourceLoc(node.atSign),
+      range: self.generateAttrSourceRange(node),
+      diagGroupName: diagGroupIdentifier,
+      behavior: behavior,
+      reason: reason
+    )
+  }
 
   /// E.g.:
   ///   ```