Configuration for warnings (#2241)

* Added support for disabling specific warnings or turning them into errors.

* Added API entry points for adding diagnostic severity overrides and manipulating some sink flags.

4 files changed, 120 insertions, 0 deletions

diff --git a/source/slang/slang-api.cpp b/source/slang/slang-api.cpp
index ba0b4296a..911bd0f0f 100644
--- a/source/slang/slang-api.cpp
+++ b/source/slang/slang-api.cpp
@@ -831,3 +831,29 @@ SLANG_API SlangResult spLoadReproAsFileSystem(
     return SLANG_OK;
 }
 
+SLANG_API void spOverrideDiagnosticSeverity(
+    slang::ICompileRequest* request,
+    SlangInt messageID,
+    SlangSeverity overrideSeverity)
+{
+    if (!request)
+        return;
+
+    request->overrideDiagnosticSeverity(messageID, overrideSeverity);
+}
+
+SLANG_API SlangDiagnosticFlags spGetDiagnosticFlags(slang::ICompileRequest* request)
+{
+    if (!request)
+        return 0;
+
+    return request->getDiagnosticFlags();
+}
+
+SLANG_API void spSetDiagnosticFlags(slang::ICompileRequest* request, SlangDiagnosticFlags flags)
+{
+    if (!request)
+        return;
+
+    request->setDiagnosticFlags(flags);
+}
diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h
index a9a19d29c..39ee830d2 100755
--- a/source/slang/slang-compiler.h
+++ b/source/slang/slang-compiler.h
@@ -2539,6 +2539,11 @@ namespace Slang
         virtual SLANG_NO_THROW void SLANG_MCALL setTargetLineDirectiveMode(
             SlangInt targetIndex,
             SlangLineDirectiveMode mode) SLANG_OVERRIDE;
+        virtual SLANG_NO_THROW void SLANG_MCALL overrideDiagnosticSeverity(
+            SlangInt messageID,
+            SlangSeverity overrideSeverity) SLANG_OVERRIDE;
+        virtual SLANG_NO_THROW SlangDiagnosticFlags SLANG_MCALL getDiagnosticFlags() SLANG_OVERRIDE;
+        virtual SLANG_NO_THROW void SLANG_MCALL setDiagnosticFlags(SlangDiagnosticFlags flags) SLANG_OVERRIDE;
 
         EndToEndCompileRequest(
             Session* session);
diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp
index 6705f836b..875f18980 100644
--- a/source/slang/slang-options.cpp
+++ b/source/slang/slang-options.cpp
@@ -21,6 +21,7 @@
 
 #include "../compiler-core/slang-command-line-args.h"
 #include "../compiler-core/slang-artifact-info.h"
+#include "../compiler-core/slang-core-diagnostics.h"
 
 #include <assert.h>
 
@@ -550,6 +551,9 @@ struct OptionsParser
             "      glsl, hlsl, spirv, spirv-assembly, dxbc,\n"
             "      dxbc-assembly, dxil, dxil-assembly\n"
             "  -v, -version: Display the build version.\n"
+            "  -warnings-as-errors all: Treat all warnings as errors.\n"
+            "  -warnings-as-errors <id>[,<id>...]: Treat specific warning ids as errors.\n"
+            "  -warnings-disable <id>[,<id>...]: Disable specific warning ids.\n"
             "  --: Treat the rest of the command line as input files.\n"
             "\n"
             "Target code generation options:\n"
@@ -704,6 +708,25 @@ struct OptionsParser
 #undef EXECUTABLE_EXTENSION
     }
 
+    SlangResult overrideDiagnosticSeverity(String const& identifierList, Severity overrideSeverity)
+    {
+        List<UnownedStringSlice> slices;
+        StringUtil::split(identifierList.getUnownedSlice(), ',', slices);
+        Index sliceCount = slices.getCount();
+
+        for (Index i = 0; i < sliceCount; ++i)
+        {
+            UnownedStringSlice warningIdentifier = slices[i];
+
+            Int warningIndex = -1;
+            SLANG_RETURN_ON_FAIL(StringUtil::parseInt(warningIdentifier, warningIndex));
+
+            requestImpl->getSink()->overrideDiagnosticSeverity(int(warningIndex), overrideSeverity);
+        }
+
+        return SLANG_OK;
+    }
+
     SlangResult parse(
         int             argc,
         char const* const*  argv)
@@ -1009,6 +1032,33 @@ struct OptionsParser
                 {
                     requestImpl->getSink()->setFlag(DiagnosticSink::Flag::VerbosePath);
                 }
+                else if (argValue == "-warnings-as-errors")
+                {
+                    CommandLineArg operand;
+                    SLANG_RETURN_ON_FAIL(reader.expectArg(operand));
+
+                    if (operand.value == "all")
+                        requestImpl->getSink()->setFlag(DiagnosticSink::Flag::TreatWarningsAsErrors);
+                    else
+                    {
+                        if (SLANG_FAILED(overrideDiagnosticSeverity(operand.value, Severity::Error)))
+                        {
+                            sink->diagnose(operand.loc, MiscDiagnostics::invalidArgumentForOption, "-warnings-as-errors");
+                            return SLANG_FAIL;
+                        }
+                    }
+                }
+                else if (argValue == "-warnings-disable")
+                {
+                    CommandLineArg operand;
+                    SLANG_RETURN_ON_FAIL(reader.expectArg(operand));
+
+                    if (SLANG_FAILED(overrideDiagnosticSeverity(operand.value, Severity::Disable)))
+                    {
+                        sink->diagnose(operand.loc, MiscDiagnostics::invalidArgumentForOption, "-warnings-disable");
+                        return SLANG_FAIL;
+                    }
+                }
                 else if (argValue == "-verify-debug-serial-ir")
                 {
                     requestImpl->getFrontEndReq()->verifyDebugSerialization = true;
diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp
index 3a180027a..7ce3594e5 100644
--- a/source/slang/slang.cpp
+++ b/source/slang/slang.cpp
@@ -4248,6 +4248,45 @@ void EndToEndCompileRequest::setTargetLineDirectiveMode(
     getLinkage()->targets[targetIndex]->setLineDirectiveMode(LineDirectiveMode(mode));
 }
 
+void EndToEndCompileRequest::overrideDiagnosticSeverity(
+    SlangInt messageID,
+    SlangSeverity overrideSeverity)
+{
+    getSink()->overrideDiagnosticSeverity(int(messageID), Severity(overrideSeverity));
+}
+
+SlangDiagnosticFlags EndToEndCompileRequest::getDiagnosticFlags()
+{
+    DiagnosticSink::Flags sinkFlags = getSink()->getFlags();
+
+    SlangDiagnosticFlags flags = 0;
+
+    if (sinkFlags & DiagnosticSink::Flag::VerbosePath)
+        flags |= SLANG_DIAGNOSTIC_FLAG_VERBOSE_PATHS;
+
+    if (sinkFlags & DiagnosticSink::Flag::TreatWarningsAsErrors)
+        flags |= SLANG_DIAGNOSTIC_FLAG_TREAT_WARNINGS_AS_ERRORS;
+
+    return flags;
+}
+
+void EndToEndCompileRequest::setDiagnosticFlags(SlangDiagnosticFlags flags)
+{
+    DiagnosticSink::Flags sinkFlags = getSink()->getFlags();
+
+    if (flags & SLANG_DIAGNOSTIC_FLAG_VERBOSE_PATHS)
+        sinkFlags |= DiagnosticSink::Flag::VerbosePath;
+    else
+        sinkFlags &= ~DiagnosticSink::Flag::VerbosePath;
+
+    if (flags & SLANG_DIAGNOSTIC_FLAG_TREAT_WARNINGS_AS_ERRORS)
+        sinkFlags |= DiagnosticSink::Flag::TreatWarningsAsErrors;
+    else
+        sinkFlags &= ~DiagnosticSink::Flag::TreatWarningsAsErrors;
+
+    getSink()->setFlags(sinkFlags);
+}
+
 SlangResult EndToEndCompileRequest::addTargetCapability(SlangInt targetIndex, SlangCapabilityID capability)
 {
     auto& targets = getLinkage()->targets;