Add capability to fully suppress a warning group and have warnings default-escalate to errors

- Adds '-Wsuppress <group>' flag which can be used to fully supress emission of warning diagnostics belonging to the specified group.
- Adds 'DefaultEscalate' flag which can be used on grouped warning diagnostics in order to have them escalated to errors by-default. They can still be downgraded back to warnings with '-Wwarning'.

Author: artemcm

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/WarningTreatmentRule.h"
 #include "swift/Localization/LocalizationFormat.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/StringRef.h"
@@ -911,12 +911,12 @@ namespace swift {
     }
 
     /// Apply rules specifing what warnings should or shouldn't be treated as
-    /// errors. For group rules the string is a group name defined by
-    /// DiagnosticGroups.def
+    /// errors or be suppressed. For group rules the string is a group name
+    /// defined by DiagnosticGroups.def.
     /// 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 setWarningTreatmentRules(const std::vector<WarningTreatmentRule> &rules);
 
     /// Whether to print diagnostic names after their messages
     void setPrintDiagnosticNamesMode(PrintDiagnosticNamesMode val) {

include/swift/AST/DiagnosticsSema.def

@@ -8939,10 +8939,10 @@ ERROR(attr_inline_always_no_usable_from_inline,none,
 // MARK: Swift Performance hints
 //===----------------------------------------------------------------------===//
 
-GROUPED_WARNING(perf_hint_function_returns_array,PerfHintReturnTypeImplicitCopy,none,
+GROUPED_WARNING(perf_hint_function_returns_array,PerfHintReturnTypeImplicitCopy,DefaultEscalate,
                 "Performance: %0 returns a%select{ dictionary|n array}1, leading to implicit copies. "
                 "Consider using an 'inout' parameter instead.", (const FuncDecl *, bool))
-GROUPED_WARNING(perf_hint_closure_returns_array,PerfHintReturnTypeImplicitCopy,none,
+GROUPED_WARNING(perf_hint_closure_returns_array,PerfHintReturnTypeImplicitCopy,DefaultEscalate,
                 "Performance: closure returns a%select{ dictionary|n array}0, leading to implicit copies. "
                 "Consider using an 'inout' parameter instead.", (bool))
 

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/WarningTreatmentRule.h"
 #include "llvm/ADT/Hashing.h"
 #include <vector>
 
@@ -61,8 +61,8 @@ class DiagnosticOptions {
   /// Suppress all remarks
   bool SuppressRemarks = false;
 
-  /// Rules for escalating warnings to errors
-  std::vector<WarningAsErrorRule> WarningsAsErrorsRules;
+  /// Rules for suppressing or escalating warnings to errors
+  std::vector<WarningTreatmentRule> WarningTreatmentRules;
 
   /// When printing diagnostics, include either the diagnostic name
   /// (diag::whatever) at the end or the associated diagnostic group.

include/swift/Basic/WarningAsErrorRule.h renamed to include/swift/Basic/WarningTreatmentRule.h

@@ -1,17 +1,17 @@
-//===--- WarningAsErrorRule.h -----------------------------------*- C++ -*-===//
+//===--- WarningTreatmentRule.h -----------------------------------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 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_WARNINGASERRORRULE_H
-#define SWIFT_BASIC_WARNINGASERRORRULE_H
+#ifndef SWIFT_BASIC_WARNINGTREATMENTRULE_H
+#define SWIFT_BASIC_WARNINGTREATMENTRULE_H
 
 #include "llvm/Support/ErrorHandling.h"
 #include <string>
@@ -21,45 +21,49 @@
 namespace swift {
 
 /// Describes a rule how to treat a warning or all warnings.
-class WarningAsErrorRule {
+class WarningTreatmentRule {
 public:
-  enum class Action { Disable, Enable };
+  enum class Action { AsWarning, AsError, Suppress };
   struct TargetAll {};
   struct TargetGroup {
     std::string name;
   };
   using Target = std::variant<TargetAll, TargetGroup>;
 
   /// Init as a rule targeting all diagnostic groups
-  WarningAsErrorRule(Action action) : action(action), target(TargetAll()) {}
+  WarningTreatmentRule(Action action) : action(action), target(TargetAll()) {}
   /// Init as a rule targeting a specific diagnostic group
-  WarningAsErrorRule(Action action, const std::string &group)
+  WarningTreatmentRule(Action action, const std::string &group)
       : action(action), target(TargetGroup{group}) {}
 
   Action getAction() const { return action; }
 
   Target getTarget() const { return target; }
 
   static bool hasConflictsWithSuppressWarnings(
-      const std::vector<WarningAsErrorRule> &rules) {
+      const std::vector<WarningTreatmentRule> &rules) {
     bool warningsAsErrorsAllEnabled = false;
     for (const auto &rule : rules) {
       const auto target = rule.getTarget();
       if (std::holds_alternative<TargetAll>(target)) {
         // Only `-warnings-as-errors` conflicts with `-suppress-warnings`
         switch (rule.getAction()) {
-        case WarningAsErrorRule::Action::Enable:
+        case Action::AsError:
           warningsAsErrorsAllEnabled = true;
           break;
-        case WarningAsErrorRule::Action::Disable:
+        case Action::AsWarning:
           warningsAsErrorsAllEnabled = false;
           break;
+        case Action::Suppress:
+          llvm_unreachable("cannot suppress all warnings");
+          break;
         }
       } else if (std::holds_alternative<TargetGroup>(target)) {
         // Both `-Wwarning` and `-Werror` conflict with `-suppress-warnings`
-        return true;
+        if (rule.getAction() == Action::AsError || rule.getAction() == Action::AsWarning)
+          return true;
       } else {
-        llvm_unreachable("unhandled WarningAsErrorRule::Target");
+        llvm_unreachable("unhandled WarningTreatmentRule::Target");
       }
     }
     return warningsAsErrorsAllEnabled;
@@ -72,4 +76,4 @@ class WarningAsErrorRule {
 
 } // end namespace swift
 
-#endif // SWIFT_BASIC_WARNINGASERRORRULE_H
+#endif // SWIFT_BASIC_WARNINGTREATMENTRULE_H

include/swift/Option/Options.td

@@ -929,6 +929,12 @@ def Wwarning : Separate<["-"], "Wwarning">,
   MetaVarName<"<diagnostic_group>">,
   HelpText<"Treat this warning group as warning">;
 
+def Wsuppress : Separate<["-"], "Wsuppress">,
+  Group<warning_treating_Group>,
+  Flags<[FrontendOption, HelpHidden]>,
+  MetaVarName<"<diagnostic_group>">,
+  HelpText<"Suppress this warning group">;
+
 def suppress_remarks : Flag<["-"], "suppress-remarks">,
   Flags<[FrontendOption]>,
   HelpText<"Suppress all remarks">;

lib/AST/DiagnosticEngine.cpp

@@ -82,6 +82,11 @@ enum class DiagnosticOptions {
   /// by various warning options (-Wwarning, -Werror). This only makes sense
   /// for warnings.
   DefaultIgnore,
+
+  /// This warning diagnostic should be escalated to an error by default,
+  /// but can be downgraded accordingly with -Wwarning. This only makes sense
+  /// for warnings
+  DefaultEscalate
 };
 struct StoredDiagnosticInfo {
   DiagnosticKind kind : 2;
@@ -91,16 +96,19 @@ struct StoredDiagnosticInfo {
   bool isDeprecation : 1;
   bool isNoUsage : 1;
   bool defaultIgnore : 1;
+  bool defaultEscalate : 1;
   DiagGroupID groupID;
 
   constexpr StoredDiagnosticInfo(DiagnosticKind k, bool firstBadToken,
                                  bool fatal, bool isAPIDigesterBreakage,
                                  bool deprecation, bool noUsage,
-                                 bool defaultIgnore, DiagGroupID groupID)
+                                 bool defaultIgnore, bool defaultEscalate,
+                                 DiagGroupID groupID)
       : kind(k), pointsToFirstBadToken(firstBadToken), isFatal(fatal),
         isAPIDigesterBreakage(isAPIDigesterBreakage),
         isDeprecation(deprecation), isNoUsage(noUsage),
-        defaultIgnore(defaultIgnore), groupID(groupID) {}
+        defaultIgnore(defaultIgnore), defaultEscalate(defaultEscalate),
+        groupID(groupID) {}
   constexpr StoredDiagnosticInfo(DiagnosticKind k, DiagnosticOptions opts,
                                  DiagGroupID groupID)
       : StoredDiagnosticInfo(k,
@@ -110,6 +118,7 @@ struct StoredDiagnosticInfo {
                              opts == DiagnosticOptions::Deprecation,
                              opts == DiagnosticOptions::NoUsage,
                              opts == DiagnosticOptions::DefaultIgnore,
+                             opts == DiagnosticOptions::DefaultEscalate,
                              groupID) {}
 };
 } // end anonymous namespace
@@ -162,6 +171,21 @@ DiagnosticState::DiagnosticState() {
 
   // Initialize warningsAsErrors to default
   warningsAsErrors.resize(DiagGroupsCount);
+
+  // Initialize warning diagnostics which default to
+  // being emitted as errors (DefaultEscalate)
+  for (const auto &info : storedDiagnosticInfos) {
+    if (info.defaultEscalate) {
+      
+      if (info.groupID != DiagGroupID::no_group) {
+        getDiagGroupInfoByID(info.groupID).traverseDepthFirst([&](auto group) {
+          warningsAsErrors[(unsigned)info.groupID] = true;
+          for (DiagID diagID : group.diagnostics)
+            ignoredDiagnostics[(unsigned)diagID] = false;
+        });
+      }
+    }
+  }
 }
 
 Diagnostic::Diagnostic(DiagID ID)
@@ -567,38 +591,44 @@ bool DiagnosticEngine::finishProcessing() {
   return hadError;
 }
 
-void DiagnosticEngine::setWarningsAsErrorsRules(
-    const std::vector<WarningAsErrorRule> &rules) {
+void DiagnosticEngine::setWarningTreatmentRules(
+    const std::vector<WarningTreatmentRule> &rules) {
   std::vector<std::string> unknownGroups;
   for (const auto &rule : rules) {
-    bool isEnabled = [&] {
+    bool treatAsError = [&] {
       switch (rule.getAction()) {
-      case WarningAsErrorRule::Action::Enable:
+      case WarningTreatmentRule::Action::AsError:
         return true;
-      case WarningAsErrorRule::Action::Disable:
+      case WarningTreatmentRule::Action::AsWarning:
+      case WarningTreatmentRule::Action::Suppress:
         return false;
       }
     }();
     auto target = rule.getTarget();
-    if (auto group = std::get_if<WarningAsErrorRule::TargetGroup>(&target)) {
+    if (auto group = std::get_if<WarningTreatmentRule::TargetGroup>(&target)) {
       auto name = std::string_view(group->name);
       // Validate the group name and set the new behavior for each diagnostic
       // associated with the group and all its subgroups.
       if (auto groupID = getDiagGroupIDByName(name);
           groupID && *groupID != DiagGroupID::no_group) {
         getDiagGroupInfoByID(*groupID).traverseDepthFirst([&](auto group) {
-          state.setWarningsAsErrorsForDiagGroupID(*groupID, isEnabled);
-          for (DiagID diagID : group.diagnostics) {
-            state.setIgnoredDiagnostic(diagID, false);
+          if (rule.getAction() == WarningTreatmentRule::Action::Suppress) {
+            for (DiagID diagID : group.diagnostics)
+              state.setIgnoredDiagnostic(diagID, true);
+          }
+          else {
+            state.setWarningsAsErrorsForDiagGroupID(*groupID, treatAsError);
+            for (DiagID diagID : group.diagnostics)
+              state.setIgnoredDiagnostic(diagID, false);
           }
         });
       } else {
         unknownGroups.push_back(std::string(name));
       }
-    } else if (std::holds_alternative<WarningAsErrorRule::TargetAll>(target)) {
-      state.setAllWarningsAsErrors(isEnabled);
+    } else if (std::holds_alternative<WarningTreatmentRule::TargetAll>(target)) {
+      state.setAllWarningsAsErrors(treatAsError);
     } else {
-      llvm_unreachable("unhandled WarningAsErrorRule::Target");
+      llvm_unreachable("unhandled WarningTreatmentRule::Target");
     }
   }
   for (const auto &unknownGroup : unknownGroups) {

lib/Frontend/CompilerInvocation.cpp

@@ -2646,31 +2646,36 @@ static bool ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
   // If the "embedded" flag was provided, enable the EmbeddedRestrictions
   // warning group. This group is opt-in in non-Embedded builds.
   if (isEmbedded(Args)) {
-    Opts.WarningsAsErrorsRules.push_back(
-        WarningAsErrorRule(WarningAsErrorRule::Action::Disable,
-                           "EmbeddedRestrictions"));
+    Opts.WarningTreatmentRules.push_back(
+        WarningTreatmentRule(WarningTreatmentRule::Action::AsWarning,
+                             "EmbeddedRestrictions"));
   }
 
   Opts.SuppressWarnings |= Args.hasArg(OPT_suppress_warnings);
   Opts.SuppressRemarks |= Args.hasArg(OPT_suppress_remarks);
   for (const Arg *arg : Args.filtered(OPT_warning_treating_Group)) {
-    Opts.WarningsAsErrorsRules.push_back([&] {
+    Opts.WarningTreatmentRules.push_back([&] {
       switch (arg->getOption().getID()) {
       case OPT_warnings_as_errors:
-        return WarningAsErrorRule(WarningAsErrorRule::Action::Enable);
+        return WarningTreatmentRule(WarningTreatmentRule::Action::AsError);
       case OPT_no_warnings_as_errors:
-        return WarningAsErrorRule(WarningAsErrorRule::Action::Disable);
+        return WarningTreatmentRule(WarningTreatmentRule::Action::AsWarning);
       case OPT_Werror:
-        return WarningAsErrorRule(WarningAsErrorRule::Action::Enable,
-                                  arg->getValue());
+        return WarningTreatmentRule(WarningTreatmentRule::Action::AsError,
+                                    arg->getValue());
       case OPT_Wwarning:
-        return WarningAsErrorRule(WarningAsErrorRule::Action::Disable,
-                                  arg->getValue());
+        return WarningTreatmentRule(WarningTreatmentRule::Action::AsWarning,
+                                    arg->getValue());
+      // ACTODO
+      case OPT_Wsuppress:
+          return WarningTreatmentRule(WarningTreatmentRule::Action::Suppress,
+                                      arg->getValue());
       default:
         llvm_unreachable("unhandled warning as error option");
       }
     }());
   }
+
   if (Args.hasArg(OPT_debug_diagnostic_names)) {
     Opts.PrintDiagnosticNames = PrintDiagnosticNamesMode::Identifier;
   }
@@ -2715,8 +2720,8 @@ static bool ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
     }
   }
   assert(!(Opts.SuppressWarnings &&
-           WarningAsErrorRule::hasConflictsWithSuppressWarnings(
-               Opts.WarningsAsErrorsRules)) &&
+           WarningTreatmentRule::hasConflictsWithSuppressWarnings(
+               Opts.WarningTreatmentRules)) &&
          "conflicting arguments; should have been caught by driver");
 
   return false;
@@ -2735,7 +2740,7 @@ static void configureDiagnosticEngine(
   if (Options.SuppressRemarks) {
     Diagnostics.setSuppressRemarks(true);
   }
-  Diagnostics.setWarningsAsErrorsRules(Options.WarningsAsErrorsRules);
+  Diagnostics.setWarningTreatmentRules(Options.WarningTreatmentRules);
   Diagnostics.setPrintDiagnosticNamesMode(Options.PrintDiagnosticNames);
 
   std::string docsPath = Options.DiagnosticDocumentationPath;

test/PerformanceHints/array-ret-override.swift

@@ -6,3 +6,11 @@
 func foo() -> [Int] {
     return [1,2,3,4,5,6]
 }
+
+@performanceOverride(PerfHintReturnTypeImplicitCopy, "Just Testing")
+func bar() -> Int {
+    let myCoolArray = { () -> [Int] in 
+        return [1, 2]
+    }
+    return myCoolArray().count
+}

test/PerformanceHints/array-ret.swift

@@ -1,10 +1,30 @@
 // RUN: %empty-directory(%t)
 
-// RUN: %target-swift-frontend -typecheck %s -diagnostic-style llvm -enable-experimental-feature SwiftPerformanceHints &> %t/output_warn.txt
+// Ensure diagnosed as error by-default
+// RUN: not %target-swift-frontend -typecheck %s -diagnostic-style llvm -enable-experimental-feature SwiftPerformanceHints &> %t/output_err.txt
+// RUN: cat %t/output_err.txt | %FileCheck %s
+
+// Ensure downgraded to a warning with '-Wwarning'
+// RUN: %target-swift-frontend -typecheck %s -diagnostic-style llvm -enable-experimental-feature SwiftPerformanceHints -Wwarning PerfHintReturnTypeImplicitCopy &> %t/output_warn.txt
 // RUN: cat %t/output_warn.txt | %FileCheck %s -check-prefix CHECK-WARN
 
+// Ensure fully suppressed with '-Wsuppress'
+// RUN: %target-swift-frontend -typecheck %s -diagnostic-style llvm -enable-experimental-feature SwiftPerformanceHints -Wsuppress PerfHintReturnTypeImplicitCopy -verify
+
+// CHECK: error: Performance: 'foo()' returns an array, leading to implicit copies. Consider using an 'inout' parameter instead. [#PerfHintReturnTypeImplicitCopy]
+// CHECK: error: Performance: closure returns an array, leading to implicit copies. Consider using an 'inout' parameter instead. [#PerfHintReturnTypeImplicitCopy]
+
 // CHECK-WARN: warning: Performance: 'foo()' returns an array, leading to implicit copies. Consider using an 'inout' parameter instead. [#PerfHintReturnTypeImplicitCopy]
+// CHECK-WARN: warning: Performance: closure returns an array, leading to implicit copies. Consider using an 'inout' parameter instead. [#PerfHintReturnTypeImplicitCopy]
+
 
 func foo() -> [Int] {
     return [1,2,3,4,5,6]
 }
+
+func bar() -> Int {
+    let myCoolArray = { () -> [Int] in 
+        return [1, 2]
+    }
+    return myCoolArray().count
+}