Implement support for unified warning group behavior queries per-diagnostic

Unified across module-wide configuration flags (`-Wwarning`, `-Werror`, etc.) and syntactic configuration attribute `@warn`.

Author: artemcm

include/swift/AST/ASTBridging.h

@@ -26,12 +26,15 @@
 #include "swift/AST/LayoutConstraintKind.h"
 #include "swift/AST/PlatformKind.h"
 #include "swift/Basic/BasicBridging.h"
+#include "swift/Basic/WarningGroupBehavior.h"
 
 #ifdef NOT_COMPILED_WITH_SWIFT_PURE_BRIDGING_MODE
 #include "swift/AST/Attr.h"
 #include "swift/AST/Decl.h"
 #endif
 
+#include <utility>
+
 SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
 namespace llvm {
@@ -1100,26 +1103,36 @@ 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,
+                             swift::WarningGroupBehavior behavior,
                              BridgedStringRef reason);
 
 enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedNonSendableKind {
   BridgedNonSendableKindSpecific,
   BridgedNonSendableKindAssumed,
 };
 
+SWIFT_NAME("BridgedWarningGroupBehaviorRule.getGroupName(self:)")
+BridgedStringRef BridgedWarningGroupBehaviorRule_getGroupName(BridgedWarningGroupBehaviorRule rule);
+
+SWIFT_NAME("BridgedWarningGroupBehaviorRule.getBehavior(self:)")
+swift::WarningGroupBehavior
+BridgedWarningGroupBehaviorRule_getBehavior(BridgedWarningGroupBehaviorRule rule);
+
+
+SWIFT_NAME("getDiagnosticGroupLinksCount()")
+SwiftInt
+BridgedDiagnosticGroupLinks_getCount();
+
+SWIFT_NAME("getDiagnosticGroupLink(at:)")
+std::pair<BridgedStringRef, BridgedStringRef>
+BridgedDiagnosticGroupLinks_getLink(SwiftInt index);
+
 SWIFT_NAME("BridgedNonSendableAttr.createParsed(_:atLoc:range:kind:)")
 BridgedNonSendableAttr BridgedNonSendableAttr_createParsed(
     BridgedASTContext cContext, swift::SourceLoc atLoc,

include/swift/AST/ASTBridgingWrappers.def

@@ -114,6 +114,7 @@ AST_BRIDGING_WRAPPER_NONNULL(CustomAttribute)
 AST_BRIDGING_WRAPPER_NULLABLE(ArgumentList)
 AST_BRIDGING_WRAPPER_NULLABLE(AvailabilitySpec)
 AST_BRIDGING_WRAPPER_CONST_NONNULL(AvailabilityMacroMap)
+AST_BRIDGING_WRAPPER_NULLABLE(WarningGroupBehaviorRule)
 AST_BRIDGING_WRAPPER_NONNULL(PoundAvailableInfo)
 AST_BRIDGING_WRAPPER_NONNULL(LifetimeEntry)
 

include/swift/AST/ASTContext.h

@@ -1483,6 +1483,10 @@ class ASTContext final {
   /// the language options.
   bool shouldPerformTypoCorrection();
 
+  /// Whether the specified SourceFile enables a given diagnostic group
+  /// either syntactically, or via command-line flags.
+  bool isDiagnosticGroupEnabled(SourceFile *sf, DiagGroupID groupID) const;
+
 private:
   friend class IntrinsicInfo;
   /// Retrieve an LLVMContext that is used for scratch space for intrinsic lookup.

include/swift/AST/Attr.h

@@ -42,6 +42,7 @@
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/UUID.h"
 #include "swift/Basic/Version.h"
+#include "swift/Basic/WarningGroupBehavior.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
@@ -3640,20 +3641,18 @@ class NonexhaustiveAttr : public DeclAttribute {
 
 class WarnAttr : public DeclAttribute {
 public:
-  enum class Behavior : uint8_t { Error, Warning, Ignored };
-
-  WarnAttr(DiagGroupID DiagnosticGroupID, Behavior Behavior,
+  WarnAttr(DiagGroupID DiagnosticGroupID, WarningGroupBehavior 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(DiagGroupID DiagnosticGroupID, WarningGroupBehavior Behavior, bool Implicit)
       : WarnAttr(DiagnosticGroupID, Behavior, std::nullopt, SourceLoc(),
                  SourceRange(), Implicit) {}
 
-  Behavior DiagnosticBehavior;
+  WarningGroupBehavior DiagnosticBehavior;
   DiagGroupID DiagnosticGroupID;
   const std::optional<StringRef> Reason;
 

include/swift/AST/DiagnosticEngine.h

@@ -25,7 +25,7 @@
 #include "swift/Basic/PrintDiagnosticNamesMode.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/Basic/Version.h"
-#include "swift/Basic/WarningAsErrorRule.h"
+#include "swift/Basic/WarningGroupBehaviorRule.h"
 #include "swift/Localization/LocalizationFormat.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/StringRef.h"
@@ -628,13 +628,10 @@ namespace swift {
     /// Don't emit any remarks
     bool suppressRemarks = false;
 
-    /// A mapping from `DiagGroupID` identifiers to Boolean values indicating
-    /// whether warnings belonging to the respective diagnostic groups should be
-    /// escalated to errors.
-    llvm::BitVector warningsAsErrors;
-
-    /// Track which diagnostic group (`DiagGroupID`) warnings should be ignored.
-    llvm::BitVector ignoredDiagnosticGroups;
+    /// A mapping from `DiagGroupID` identifiers to `WarningGroupBehavior`
+    /// values indicating how warnings belonging to the respective diagnostic groups
+    /// should be emitted.
+    std::unordered_map<DiagGroupID, WarningGroupBehavior> warningGroupBehaviorMap;
 
     /// For compiler-internal purposes only, track which diagnostics should
     /// be ignored completely. For example, this is used by LLDB to
@@ -657,7 +654,15 @@ namespace swift {
 
     /// Figure out the Behavior for the given diagnostic, taking current
     /// state such as fatality into account.
-    DiagnosticBehavior determineBehavior(const Diagnostic &diag) const;
+    DiagnosticBehavior determineBehavior(const Diagnostic &diag,
+                                         SourceManager &sourceMgr) const;
+
+    /// If this diagnostic is a warning belonging to a diagnostic group,
+    /// figure out if there is a source-level (`@warn`) control for this group
+    /// for this diagnostic's source location.
+    std::optional<DiagnosticBehavior>
+    determineUserControlledWarningBehavior(const Diagnostic &diag,
+                                           SourceManager &sourceMgr) const;
 
     /// Updates the diagnostic state for a diagnostic to emit.
     void updateFor(DiagnosticBehavior behavior);
@@ -684,43 +689,24 @@ namespace swift {
     void setSuppressRemarks(bool val) { suppressRemarks = val; }
     bool getSuppressRemarks() const { return suppressRemarks; }
 
-    /// Sets whether warnings belonging to the diagnostic group identified by
-    /// `id` should be escalated to errors.
-    void setWarningsAsErrorsForDiagGroupID(DiagGroupID id, bool value) {
-      warningsAsErrors[(unsigned)id] = value;
-    }
-
-    /// Returns a Boolean value indicating whether warnings belonging to the
-    /// diagnostic group identified by `id` should be escalated to errors.
-    bool getWarningsAsErrorsForDiagGroupID(DiagGroupID id) const {
-      return warningsAsErrors[(unsigned)id];
-    }
+    /// Configure the command-line warning group handling
+    /// rules (`-Werrr`,`-Wwarning`,`-warnings-as-errors`)
+    void setWarningGroupControlRules(
+        const llvm::SmallVector<WarningGroupBehaviorRule, 4> &rules);
 
-    /// Whether all warnings should be upgraded to errors or not.
-    void setAllWarningsAsErrors(bool value) {
-      // This works as intended because every diagnostic belongs to either a
-      // custom group or the top-level `DiagGroupID::no_group`, which is also
-      // a group.
-      if (value) {
-        warningsAsErrors.set();
-      } else {
-        warningsAsErrors.reset();
-      }
+    const std::unordered_map<DiagGroupID, WarningGroupBehavior> &
+    getWarningGroupBehaviorControlMap() const {
+      return warningGroupBehaviorMap;
     }
 
     void resetHadAnyError() {
       anyErrorOccurred = false;
       fatalErrorOccurred = false;
     }
 
-    /// Set whether a diagnostic group should be ignored.
-    void setIgnoredDiagnosticGroup(DiagGroupID id, bool ignored) {
-      ignoredDiagnosticGroups[(unsigned)id] = ignored;
-    }
-
     /// Query whether a specific diagnostic group is ignored.
     bool isIgnoredDiagnosticGroup(DiagGroupID id) const {
-      return ignoredDiagnosticGroups[(unsigned)id];
+      return warningGroupBehaviorMap.at(id) == WarningGroupBehavior::Ignored;
     }
 
     /// Set a specific diagnostic to be ignored by the compiler.
@@ -738,11 +724,10 @@ namespace swift {
       std::swap(suppressWarnings, other.suppressWarnings);
       std::swap(suppressNotes, other.suppressNotes);
       std::swap(suppressRemarks, other.suppressRemarks);
-      std::swap(warningsAsErrors, other.warningsAsErrors);
+      std::swap(warningGroupBehaviorMap, other.warningGroupBehaviorMap);
       std::swap(fatalErrorOccurred, other.fatalErrorOccurred);
       std::swap(anyErrorOccurred, other.anyErrorOccurred);
       std::swap(previousBehavior, other.previousBehavior);
-      std::swap(ignoredDiagnosticGroups, other.ignoredDiagnosticGroups);
     }
 
   private:
@@ -951,7 +936,15 @@ namespace swift {
     /// Rules are applied in order they appear in the vector.
     /// In case the vector contains rules affecting the same diagnostic ID
     /// the last rule wins.
-    void setWarningsAsErrorsRules(const std::vector<WarningAsErrorRule> &rules);
+    void setWarningGroupControlRules(
+        const llvm::SmallVector<WarningGroupBehaviorRule, 4> &rules) {
+      state.setWarningGroupControlRules(rules);
+    }
+
+    const std::unordered_map<DiagGroupID, WarningGroupBehavior> &
+    getWarningGroupBehaviorControlMap() const {
+      return state.getWarningGroupBehaviorControlMap();
+    }
 
     /// Whether to print diagnostic names after their messages
     void setPrintDiagnosticNamesMode(PrintDiagnosticNamesMode val) {
@@ -1366,7 +1359,8 @@ namespace swift {
           Engine.TentativeDiagnostics.end());
 
       for (auto &diagnostic : diagnostics) {
-        auto behavior = Engine.state.determineBehavior(diagnostic.Diag);
+        auto behavior = Engine.state.determineBehavior(diagnostic.Diag,
+                                                       Engine.SourceMgr);
         if (behavior == DiagnosticBehavior::Fatal ||
             behavior == DiagnosticBehavior::Error)
           return true;

include/swift/Basic/DiagnosticOptions.h

@@ -14,7 +14,7 @@
 #define SWIFT_BASIC_DIAGNOSTICOPTIONS_H
 
 #include "swift/Basic/PrintDiagnosticNamesMode.h"
-#include "swift/Basic/WarningAsErrorRule.h"
+#include "swift/Basic/WarningGroupBehaviorRule.h"
 #include "llvm/ADT/Hashing.h"
 #include <vector>
 
@@ -76,7 +76,7 @@ class DiagnosticOptions {
   bool SuppressRemarks = false;
 
   /// Rules for escalating warnings to errors
-  std::vector<WarningAsErrorRule> WarningsAsErrorsRules;
+  llvm::SmallVector<WarningGroupBehaviorRule, 4> WarningGroupControlRules;
 
   /// When printing diagnostics, include either the diagnostic name
   /// (diag::whatever) at the end or the associated diagnostic group.

include/swift/Basic/WarningAsErrorRule.h

@@ -0,0 +1,50 @@
+//===-- WarningGroupBehavior.h ----------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_WARNINGBEHAVIOR_H
+#define SWIFT_BASIC_WARNINGBEHAVIOR_H
+
+/// `WarningGroupBehavior.h` is imported into Swift. Be *very* careful with what you
+/// include here and keep these includes minimal!
+///
+/// See include guidelines and caveats in `BasicBridging.h`.
+#include "swift/Basic/SwiftBridging.h"
+#include <stdint.h>
+#include <utility>
+#include <array>
+
+namespace swift {
+
+// Describes how a diagnostic group's warnings are to be emitted
+enum ENUM_EXTENSIBILITY_ATTR(closed) WarningGroupBehavior {
+  AsError SWIFT_NAME("error"),
+  AsWarning SWIFT_NAME("warning"),
+  Ignored SWIFT_NAME("ignored"),
+  None SWIFT_NAME("none")
+};
+
+constexpr const auto DiagLinksCount = [] {
+  size_t count = 0;
+#define GROUP_LINK(Parent, Child) ++count;
+#include "swift/AST/DiagnosticGroups.def"
+  return count;
+}();
+
+constexpr std::array<std::pair<const char*, const char*>, swift::DiagLinksCount> DiagnosticGroupLinks = {{
+#define GROUP_LINK(Parent, Child) {#Parent, #Child},
+#include "swift/AST/DiagnosticGroups.def"
+}};
+
+} // namespace swift
+
+#endif // SWIFT_BASIC_WARNINGBEHAVIOR_H
+