Improvements in -X support (#1852)

* #include an absolute path didn't work - because paths were taken to always be relative.

* Added SourceLoc handling for command line parsing.

* Fix typo in debug.

* Fix issue around the DiagnosticSink used in options parsing not having a writer available - by having DiagnosticSink parenting.

* Small rename for clarity.

* WIP extracting command line args for downstream tools.

* Unit tests/bug fixes around extracting args.

* Use DownstreamArgs in the EndToEndCompileRequest

* Passing downstream compiler options downstream.

* Fix issue with endToEndReq being nullptr.

* Fix issue with diagnostics number change.

* Small improvements to how the source line is displayed if it's too long.
Default to 120, as suggested in previous review.

* Make render test use x-args parsing and CommandArgReader.

* Added missing diagnostics.

* More DownstreamArgs to linkage so can be seen by 'components'.
Added dxc-x-arg test.

* Used combination of name and args instead of two Lists, which whilst equivalent was perhaps a little confusing.

* Added documentation for -X support.

* Added test for x-args parsing diagnostic. Improved diagnostic with list of known names.

* Fix issues from merge.

* Fix lookup for -matrix-layout-column-major in render test.

* Remove commented out line.

9 files changed, 235 insertions, 205 deletions

diff --git a/tools/render-test/diagnostic-defs.h b/tools/render-test/diagnostic-defs.h
new file mode 100644
index 000000000..e48012550
--- /dev/null
+++ b/tools/render-test/diagnostic-defs.h
@@ -0,0 +1,33 @@
+//
+
+// The file is meant to be included multiple times, to produce different
+// pieces of declaration/definition code related to diagnostic messages
+//
+// Each diagnostic is declared here with:
+//
+//     DIAGNOSTIC(id, severity, name, messageFormat)
+//
+// Where `id` is the unique diagnostic ID, `severity` is the default
+// severity (from the `Severity` enum), `name` is a name used to refer
+// to this diagnostic from code, and `messageFormat` is the default
+// (non-localized) message for the diagnostic, with placeholders
+// for any arguments.
+
+#ifndef DIAGNOSTIC
+#error Need to #define DIAGNOSTIC(...) before including 
+#define DIAGNOSTIC(id, severity, name, messageFormat) /* */
+#endif
+
+//
+// -1 - Notes that decorate another diagnostic.
+//
+
+
+DIAGNOSTIC(1001, Error, expectingCommaComputeDispatch, "expected 3 comma separated integers for compute dispatch size")
+DIAGNOSTIC(1002, Error, expectingPositiveComputeDispatch, "expected 3 comma positive integers for compute dispatch size")
+DIAGNOSTIC(1003, Error, unknownSourceLanguage, "unknown source language name")
+DIAGNOSTIC(1003, Error, unknown, "unknown source language name")
+DIAGNOSTIC(1004, Error, unknownCommandLineOption, "unknown command-line option '$0'")
+DIAGNOSTIC(1005, Error, unexpectedPositionalArg, "unexpected positional arg")
+
+#undef DIAGNOSTIC
diff --git a/tools/render-test/diagnostics.cpp b/tools/render-test/diagnostics.cpp
new file mode 100644
index 000000000..2bc337256
--- /dev/null
+++ b/tools/render-test/diagnostics.cpp
@@ -0,0 +1,21 @@
+// diagnostics.cpp
+#include "diagnostics.h"
+
+namespace Slang {
+
+namespace RenderTestDiagnostics
+{
+#define DIAGNOSTIC(id, severity, name, messageFormat) const DiagnosticInfo name = { id, Severity::severity, #name, messageFormat };
+#include "diagnostic-defs.h"
+#undef DIAGNOSTIC
+}
+
+static const DiagnosticInfo* const kDiagnostics[] =
+{
+#define DIAGNOSTIC(id, severity, name, messageFormat) &RenderTestDiagnostics::name, 
+#include "diagnostic-defs.h"
+#undef DIAGNOSTIC
+};
+
+
+} // namespace Slang
diff --git a/tools/render-test/diagnostics.h b/tools/render-test/diagnostics.h
new file mode 100644
index 000000000..08ba28e27
--- /dev/null
+++ b/tools/render-test/diagnostics.h
@@ -0,0 +1,25 @@
+#ifndef SLANG_CORE_DIAGNOSTICS_H
+#define SLANG_CORE_DIAGNOSTICS_H
+
+#include "../../source/core/slang-basic.h"
+#include "../../source/core/slang-writer.h"
+
+#include "../../source/compiler-core/slang-source-loc.h"
+#include "../../source/compiler-core/slang-diagnostic-sink.h"
+
+#include "../../slang.h"
+
+namespace Slang
+{
+
+DiagnosticsLookup* getCoreDiagnosticsLookup();
+
+namespace RenderTestDiagnostics
+{
+#define DIAGNOSTIC(id, severity, name, messageFormat) extern const DiagnosticInfo name;
+#include "diagnostic-defs.h"
+}
+
+}
+
+#endif
diff --git a/tools/render-test/options.cpp b/tools/render-test/options.cpp
index dcf0b77b1..5d3560351 100644
--- a/tools/render-test/options.cpp
+++ b/tools/render-test/options.cpp
@@ -15,6 +15,10 @@
 
 #include "../../source/core/slang-type-text-util.h"
 
+#include "../../source/compiler-core/slang-command-line-args.h"
+
+#include "diagnostics.h"
+
 namespace renderer_test {
 using namespace Slang;
 
@@ -34,173 +38,135 @@ static gfx::DeviceType _toRenderType(Slang::RenderApiType apiType)
     }
 }
 
-static SlangResult _setRendererType(DeviceType type, const char* arg, Slang::WriterHelper stdError, Options& ioOptions)
-{
-    if (ioOptions.deviceType != DeviceType::Unknown)
-    {
-        stdError.print("Already has renderer option set. Found '%s'\n", arg);
-        return SLANG_FAIL;
-    }
-    ioOptions.deviceType = type;
-    return SLANG_OK;
-}
-
 /* static */SlangResult Options::parse(int argc, const char*const* argv, Slang::WriterHelper stdError, Options& outOptions)
 {
     using namespace Slang;
 
+    RefPtr<CommandLineContext> cmdLineContext(new CommandLineContext);
+
+    DiagnosticSink sink(cmdLineContext->getSourceManager(), nullptr);
+    sink.writer = stdError.getWriter();
+    sink.setFlag(DiagnosticSink::Flag::SourceLocationLine);
+    
     outOptions = Options();
 
-    List<const char*> positionalArgs;
+    CommandLineArgs args(cmdLineContext);
 
-    typedef Options::ShaderProgramType ShaderProgramType;
-    typedef Options::InputLanguageID InputLanguageID;
+    if (argc > 0)
+    {
+        // first argument is the application name
+        outOptions.appName = argv[0];
+        args.setArgs(argv + 1, argc - 1);
+    }
+    else
+    {
+        args.setArgs(argv, argc);
+    }
 
-    //int argCount = argc;
+    SLANG_RETURN_ON_FAIL(outOptions.downstreamArgs.stripDownstreamArgs(args, 0, &sink));
 
-    char const* const* argCursor = argv;
-    char const* const* argEnd = argCursor + argc;
+    CommandLineReader reader(&args, &sink);
 
-    // first argument is the application name
-    if( argCursor != argEnd )
-    {
-        outOptions.appName = *argCursor++;
-    }
+    List<CommandLineArg> positionalArgs;
+
+    typedef Options::ShaderProgramType ShaderProgramType;
+    typedef Options::InputLanguageID InputLanguageID;
 
     // now iterate over arguments to collect options
-    while(argCursor != argEnd)
+    while (reader.hasArg())
     {
-        char const* arg = *argCursor++;
-        if( arg[0] != '-' )
+        CommandLineArg arg = reader.getArgAndAdvance();
+        const auto& argValue = arg.value;
+
+        if(!argValue.startsWith("-"))
         {
             positionalArgs.add(arg);
             continue;
         }
 
-        if( strcmp(arg, "--") == 0 )
+        if (argValue == "--")
         {
-            while(argCursor != argEnd)
+            while (reader.hasArg())
             {
-                positionalArgs.add(*argCursor++);
+                positionalArgs.add(reader.getArgAndAdvance());
             }
             break;
         }
-        else if( strcmp(arg, "-o") == 0 )
+        else if(argValue == "-o")
         {
-            if( argCursor == argEnd )
-            {
-                stdError.print("expected argument for '%s' option\n", arg);
-                return SLANG_FAIL;
-            }
-            outOptions.outputPath = *argCursor++;
+            SLANG_RETURN_ON_FAIL(reader.expectArg(outOptions.outputPath));
         }
-        else if (strcmp(arg, "-profile") == 0)
+        else if (argValue == "-profile")
         {
-            if (argCursor == argEnd)
-            {
-                stdError.print("expected argument for '%s' option\n", arg);
-                return SLANG_FAIL;
-            }
-            outOptions.profileName = *argCursor++;
+            SLANG_RETURN_ON_FAIL(reader.expectArg(outOptions.profileName));
         }
-        else if (strcmp(arg, "-render-features") == 0 || strcmp(arg, "-render-feature") == 0)
+        else if (argValue == "-render-features" || argValue == "-render-feature")
         {
-            if (argCursor == argEnd)
-            {
-                stdError.print("expected argument for '%s' option\n", arg);
-                return SLANG_FAIL;
-            }
-            const char* value = *argCursor++;
+            String features;
+            SLANG_RETURN_ON_FAIL(reader.expectArg(features));
 
             List<UnownedStringSlice> values;
-            StringUtil::split(UnownedStringSlice(value), ',', values);
+            StringUtil::split(features.getUnownedSlice(), ',', values);
 
             for (const auto& value : values)
             {
                 outOptions.renderFeatures.add(value);
             }
         }
-        else if( strcmp(arg, "-xslang") == 0 )
+        else if( argValue == "-xslang" || argValue == "-compile-arg")
         {
+            // This is legacy support, should use -Xslang now
             // This is an option that we want to pass along to Slang
-
-            if( argCursor == argEnd )
-            {
-                stdError.print("expected argument for '%s' option\n", arg);
-                return SLANG_FAIL;
-            }
-            if( outOptions.slangArgCount == Options::kMaxSlangArgs )
-            {
-                stdError.print("maximum number of '%s' options exceeded (%d)\n", arg, Options::kMaxSlangArgs);
-                return SLANG_FAIL;
-            }
-            outOptions.slangArgs[outOptions.slangArgCount++] = *argCursor++;
+            CommandLineArg slangArg;
+            SLANG_RETURN_ON_FAIL(reader.expectArg(slangArg));
+            outOptions.downstreamArgs.getArgsByName("slang").add(slangArg);
         }
-		else if (strcmp(arg, "-compute") == 0)
+		else if (argValue == "-compute")
 		{
 			outOptions.shaderType = ShaderProgramType::Compute;
 		}
-		else if (strcmp(arg, "-graphics") == 0)
+		else if (argValue == "-graphics")
 		{
 			outOptions.shaderType = ShaderProgramType::Graphics;
 		}
-        else if (strcmp(arg, "-gcompute") == 0)
+        else if (argValue == "-gcompute")
         {
             outOptions.shaderType = ShaderProgramType::GraphicsCompute;
         }
-        else if (strcmp(arg, "-rt") == 0)
+        else if (argValue == "-rt")
         {
             outOptions.shaderType = ShaderProgramType::RayTracing;
         }
-        else if( strcmp(arg, "-use-dxil") == 0 )
+        else if(argValue == "-use-dxil")
         {
             outOptions.useDXIL = true;
         }
-        else if (strcmp(arg, "-only-startup") == 0)
+        else if (argValue == "-only-startup")
         {
             outOptions.onlyStartup = true;
         }
-        else if (strcmp(arg, "-compile-arg") == 0)
-        {
-            if (argCursor == argEnd)
-            {
-                stdError.print("expected argument for '%s' option\n", arg);
-                return SLANG_FAIL;
-            }
-
-            const char* compileArg = *argCursor++;
-            outOptions.compileArgs.add(compileArg);
-        }
-        else if (strcmp(arg, "-performance-profile") == 0)
+        else if (argValue == "-performance-profile")
         {
             outOptions.performanceProfile = true;
         }
-        else if (strcmp(arg, "-adapter") == 0)
+        else if (argValue == "-adapter")
         {
-            if (argCursor == argEnd)
-            {
-                stdError.print("expected argument for '%s' option\n", arg);
-                return SLANG_FAIL;
-            }
-
-            outOptions.adapter = *argCursor++;
+            SLANG_RETURN_ON_FAIL(reader.expectArg(outOptions.adapter));
         }
-        else if (strcmp(arg, "-output-using-type") == 0)
+        else if (argValue == "-output-using-type")
         {
             outOptions.outputUsingType = true;
         }
-        else if (strcmp(arg, "-compute-dispatch") == 0)
+        else if (argValue == "-compute-dispatch")
         {
-            if (argCursor == argEnd)
-            {
-                stdError.print("error: expecting a comma separated compute dispatch size for '%s'\n", arg);
-                return SLANG_FAIL;
-            }
+            CommandLineArg dispatchSize;
+            SLANG_RETURN_ON_FAIL(reader.expectArg(dispatchSize));
+
             List<UnownedStringSlice> slices;
-            StringUtil::split(UnownedStringSlice(*argCursor++), ',', slices);
+            StringUtil::split(dispatchSize.value.getUnownedSlice(), ',', slices);
             if (slices.getCount() != 3)
             {
-                stdError.print("error: expected 3 comma separated integers for compute dispatch size for '%s'\n", arg);
+                sink.diagnose(dispatchSize.loc, RenderTestDiagnostics::expectingCommaComputeDispatch);
                 return SLANG_FAIL;
             }
            
@@ -211,45 +177,35 @@ static SlangResult _setRendererType(DeviceType type, const char* arg, Slang::Wri
                 int v = StringToInt(string);
                 if (v < 1)
                 {
-                    stdError.print("error: expected 3 comma positive integers for compute dispatch size for '%s'\n", arg);
+                    sink.diagnose(dispatchSize.loc, RenderTestDiagnostics::expectingPositiveComputeDispatch);
                     return SLANG_FAIL;
                 }
                 outOptions.computeDispatchSize[i] = v;
             }
         }
-        else if (strcmp(arg, "-source-language") == 0)
+        else if (argValue == "-source-language")
         {
-            if (argCursor == argEnd)
-            {
-                stdError.print("error: expecting a source language name for '%s'\n", arg);
-                return SLANG_FAIL;
-            }
-            UnownedStringSlice sourceLanguageText(*argCursor++);
-
-            SlangSourceLanguage sourceLanguage = TypeTextUtil::findSourceLanguage(sourceLanguageText);
+            CommandLineArg sourceLanguageName;
+            SLANG_RETURN_ON_FAIL(reader.expectArg(sourceLanguageName));
+            
+            const SlangSourceLanguage sourceLanguage = TypeTextUtil::findSourceLanguage(sourceLanguageName.value.getUnownedSlice());
             if (sourceLanguage == SLANG_SOURCE_LANGUAGE_UNKNOWN)
             {
-                stdError.print("error: expecting unknown source language name '%s' for '%s'\n", String(sourceLanguageText).getBuffer(), arg);
+                sink.diagnose(sourceLanguageName.loc, RenderTestDiagnostics::unknownSourceLanguage);
                 return SLANG_FAIL;
             }
 
             outOptions.sourceLanguage = sourceLanguage;
         }
-        else if( strcmp(arg, "-no-default-entry-point") == 0 )
+        else if(argValue == "-no-default-entry-point")
         {
             outOptions.dontAddDefaultEntryPoints = true;
         }
-        else if (strcmp(arg, "-nvapi-slot") == 0)
+        else if (argValue == "-nvapi-slot")
         {
-            if (argCursor == argEnd)
-            {
-                stdError.print("error: expecting a register name for '%s'\n", arg);
-                return SLANG_FAIL;
-            }
-
-            outOptions.nvapiExtnSlot = (*argCursor++);
+            SLANG_RETURN_ON_FAIL(reader.expectArg(outOptions.nvapiExtnSlot));
         }
-        else if (strcmp(arg, "-shaderobj") == 0)
+        else if (argValue == "-shaderobj")
         {
             // Note: We ignore this option because it is always enabled now.
             //
@@ -258,11 +214,11 @@ static SlangResult _setRendererType(DeviceType type, const char* arg, Slang::Wri
         else
         {
             // Lookup
-            Slang::UnownedStringSlice argSlice(arg);
+            Slang::UnownedStringSlice argSlice = arg.value.getUnownedSlice();
             if (argSlice.getLength() && argSlice[0] == '-')
             {
                 // Look up the rendering API if set
-                UnownedStringSlice argName = UnownedStringSlice(argSlice.begin() + 1, argSlice.end());
+                UnownedStringSlice argName = argSlice.tail(1);
                 DeviceType deviceType = _toRenderType(RenderApiUtil::findApiTypeByName(argName));
 
                 if (deviceType != DeviceType::Unknown)
@@ -272,17 +228,16 @@ static SlangResult _setRendererType(DeviceType type, const char* arg, Slang::Wri
                 }
 
                 // Lookup the target language type
-                DeviceType languageRenderType =
-                    _toRenderType(RenderApiUtil::findImplicitLanguageRenderApiType(argName));
-                if (languageRenderType != DeviceType::Unknown)
+                DeviceType targetLanguageDeviceType = _toRenderType(RenderApiUtil::findImplicitLanguageRenderApiType(argName));
+                    
+                if (targetLanguageDeviceType != DeviceType::Unknown)
                 {
-                    outOptions.targetLanguageDeviceType = languageRenderType;
+                    outOptions.targetLanguageDeviceType = targetLanguageDeviceType;
                     outOptions.inputLanguageID = (argName == "hlsl" || argName == "glsl" || argName == "cpp" || argName == "cxx" || argName == "c") ?  InputLanguageID::Native : InputLanguageID::Slang;
                     continue;
                 }
             }
-
-            stdError.print("unknown option '%s'\n", arg);
+            sink.diagnose(arg.loc, RenderTestDiagnostics::unknownCommandLineOption, arg.value);
             return SLANG_FAIL;
         }
     }
@@ -295,14 +250,14 @@ static SlangResult _setRendererType(DeviceType type, const char* arg, Slang::Wri
     // first positional argument is source shader path
     if(positionalArgs.getCount())
     {
-        outOptions.sourcePath = positionalArgs[0];
+        outOptions.sourcePath = positionalArgs[0].value;
         positionalArgs.removeAt(0);
     }
 
     // any remaining arguments represent an error
     if(positionalArgs.getCount() != 0)
     {
-        stdError.print("unexpected arguments\n");
+        sink.diagnose(positionalArgs[0].loc, RenderTestDiagnostics::unexpectedPositionalArg);
         return SLANG_FAIL;
     }
 
diff --git a/tools/render-test/options.h b/tools/render-test/options.h
index 2945113fe..7940d0d42 100644
--- a/tools/render-test/options.h
+++ b/tools/render-test/options.h
@@ -12,6 +12,8 @@
 
 #include "../../source/core/slang-process-util.h"
 
+#include "../../source/compiler-core/slang-command-line-args.h"
+
 #include "../../slang-gfx.h"
 
 namespace renderer_test {
@@ -20,12 +22,6 @@ using namespace gfx;
 
 struct Options
 {
-    enum
-    {
-        // maximum number of command-line arguments to pass along to slang
-        kMaxSlangArgs = 16,
-    };
-
     enum class InputLanguageID
     {
         // Slang being used as an HLSL-ish compiler
@@ -35,7 +31,6 @@ struct Options
         Native,
     };
 
-
     enum class ShaderProgramType
     {
         Graphics,
@@ -44,9 +39,9 @@ struct Options
         RayTracing,
     };
 
-    char const* appName = "render-test";
-    char const* sourcePath = nullptr;
-    char const* outputPath = nullptr;
+    Slang::String appName = "render-test";
+    Slang::String sourcePath;
+    Slang::String outputPath;
 	ShaderProgramType shaderType = ShaderProgramType::Graphics;
 
         /// The renderer type inferred from the target language type. Used if a rendererType is not explicitly set.
@@ -57,10 +52,7 @@ struct Options
     SlangSourceLanguage sourceLanguage = SLANG_SOURCE_LANGUAGE_UNKNOWN;
 
         /// Can be used for overriding the profile
-    const char* profileName = nullptr;
-
-    char const* slangArgs[kMaxSlangArgs];
-    int slangArgCount = 0;
+    Slang::String profileName;
 
     bool outputUsingType = false;
 
@@ -73,14 +65,16 @@ struct Options
 
     Slang::List<Slang::String> renderFeatures;          /// Required render features for this test to run
 
-    Slang::List<Slang::String> compileArgs;
-
     Slang::String adapter;                              ///< The adapter to use either name or index
 
     uint32_t computeDispatchSize[3] = { 1, 1, 1 };
 
     Slang::String nvapiExtnSlot;                               ///< The nvapiRegister to use.
 
+    Slang::DownstreamArgs downstreamArgs;                    ///< Args to downstream tools. Here it's just slang
+
+    Options() { downstreamArgs.addName("slang"); }
+
     static SlangResult parse(int argc, const char*const* argv, Slang::WriterHelper stdError, Options& outOptions);
 };
 
diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp
index 5feeeaf21..c04d6db00 100644
--- a/tools/render-test/render-test-main.cpp
+++ b/tools/render-test/render-test-main.cpp
@@ -99,9 +99,9 @@ public:
 
     Result applyBinding(PipelineType pipelineType, ICommandEncoder* encoder);
     void setProjectionMatrix(IShaderObject* rootObject);
-    Result writeBindingOutput(const char* fileName);
+    Result writeBindingOutput(const String& fileName);
 
-    Result writeScreen(const char* filename);
+    Result writeScreen(const String& filename);
 
 protected:
     /// Called in initialize
@@ -652,12 +652,12 @@ void RenderTestApp::finalize()
 {
 }
 
-Result RenderTestApp::writeBindingOutput(const char* fileName)
+Result RenderTestApp::writeBindingOutput(const String& fileName)
 {
     // Wait until everything is complete
     m_queue->wait();
 
-    FILE * f = fopen(fileName, "wb");
+    FILE * f = fopen(fileName.getBuffer(), "wb");
     if (!f)
     {
         return SLANG_FAIL;
@@ -729,7 +729,7 @@ Result RenderTestApp::writeBindingOutput(const char* fileName)
     return SLANG_OK;
 }
 
-Result RenderTestApp::writeScreen(const char* filename)
+Result RenderTestApp::writeScreen(const String& filename)
 {
     size_t rowPitch, pixelSize;
     ComPtr<ISlangBlob> blob;
@@ -738,7 +738,7 @@ Result RenderTestApp::writeScreen(const char* filename)
     auto bufferSize = blob->getBufferSize();
     uint32_t width = static_cast<uint32_t>(rowPitch / pixelSize);
     uint32_t height = static_cast<uint32_t>(bufferSize / rowPitch);
-    return PngSerializeUtil::write(filename, blob, width, height);
+    return PngSerializeUtil::write(filename.getBuffer(), blob, width, height);
 }
 
 Result RenderTestApp::update()
@@ -768,7 +768,7 @@ Result RenderTestApp::update()
     m_queue->wait();
 
     // If we are in a mode where output is requested, we need to snapshot the back buffer here
-    if (m_options.outputPath || m_options.performanceProfile)
+    if (m_options.outputPath.getLength() || m_options.performanceProfile)
     {
         // Wait until everything is complete
 
@@ -807,7 +807,7 @@ Result RenderTestApp::update()
             _outputProfileTime(m_startTicks, endTicks);
         }
 
-        if (m_options.outputPath)
+        if (m_options.outputPath.getLength())
         {
             if (m_options.shaderType == Options::ShaderProgramType::Compute || m_options.shaderType == Options::ShaderProgramType::GraphicsCompute)
             {
@@ -909,8 +909,6 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi
     
     input.profile = "";
     input.target = SLANG_TARGET_NONE;
-    input.args = &options.slangArgs[0];
-    input.argCount = options.slangArgCount;
 
 	SlangSourceLanguage nativeLanguage = SLANG_SOURCE_LANGUAGE_UNKNOWN;
 	SlangPassThrough slangPassThrough = SLANG_PASS_THROUGH_NONE;
@@ -1020,7 +1018,7 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi
 #endif
 
     // Use the profile name set on options if set
-    input.profile = options.profileName ? options.profileName : input.profile;
+    input.profile = options.profileName.getLength() ? options.profileName : input.profile;
 
     StringBuilder rendererName;
     auto info = 
@@ -1085,11 +1083,17 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi
 
         desc.requiredFeatures = requiredFeatureList.getBuffer();
         desc.requiredFeatureCount = (int)requiredFeatureList.getCount();
-        for (int i = 0; i < options.slangArgCount; i++)
+
+        // Look for args going to slang
         {
-            if (UnownedStringSlice(options.slangArgs[i]) == "-matrix-layout-column-major")
+            const auto& args = options.downstreamArgs.getArgsByName("slang");
+            for (const auto& arg : args)
             {
-                desc.slang.defaultMatrixLayoutMode = SLANG_MATRIX_LAYOUT_COLUMN_MAJOR;
+                if (arg.value == "-matrix-layout-column-major")
+                {
+                    desc.slang.defaultMatrixLayoutMode = SLANG_MATRIX_LAYOUT_COLUMN_MAJOR;
+                    break;
+                }
             }
         }
         
diff --git a/tools/render-test/shader-input-layout.cpp b/tools/render-test/shader-input-layout.cpp
index bece936dd..9362efb45 100644
--- a/tools/render-test/shader-input-layout.cpp
+++ b/tools/render-test/shader-input-layout.cpp
@@ -82,7 +82,7 @@ namespace renderer_test
         RefPtr<ShaderInputLayout::ParentVal> parentVal;
         List<RefPtr<ShaderInputLayout::ParentVal>> parentValStack;
 
-        SlangResult parseOption(TokenReader& parser, String const& word, ShaderInputLayout::TextureVal* val)
+        SlangResult parseOption(Misc::TokenReader& parser, String const& word, ShaderInputLayout::TextureVal* val)
         {
             if (word == "depth")
             {
@@ -133,7 +133,7 @@ namespace renderer_test
             return SLANG_OK;
         }
 
-        SlangResult parseOption(TokenReader& parser, String const& word, ShaderInputLayout::SamplerVal* val)
+        SlangResult parseOption(Misc::TokenReader& parser, String const& word, ShaderInputLayout::SamplerVal* val)
         {
             if (word == "depthCompare")
             {
@@ -146,7 +146,7 @@ namespace renderer_test
             return SLANG_OK;
         }
 
-        SlangResult parseOption(TokenReader& parser, String const& word, ShaderInputLayout::DataValBase* val)
+        SlangResult parseOption(Misc::TokenReader& parser, String const& word, ShaderInputLayout::DataValBase* val)
         {
             if (word == "data")
             {
@@ -157,13 +157,13 @@ namespace renderer_test
                 while (!parser.IsEnd() && !parser.LookAhead("]"))
                 {
                     bool negate = false;
-                    if(parser.NextToken().Type == TokenType::OpSub)
+                    if(parser.NextToken().Type == Misc::TokenType::OpSub)
                     {
                         parser.ReadToken();
                         negate = true;
                     }
 
-                    if (parser.NextToken().Type == TokenType::IntLiteral)
+                    if (parser.NextToken().Type == Misc::TokenType::IntLiteral)
                     {
                         uint32_t value = parser.ReadUInt();
                         if(negate) value = uint32_t(-int32_t(value));
@@ -186,7 +186,7 @@ namespace renderer_test
             return SLANG_OK;
         }
 
-        SlangResult parseOption(TokenReader& parser, String const& word, ShaderInputLayout::BufferVal* val)
+        SlangResult parseOption(Misc::TokenReader& parser, String const& word, ShaderInputLayout::BufferVal* val)
         {
             if (word == "stride")
             {
@@ -332,7 +332,7 @@ namespace renderer_test
             return SLANG_OK;
         }
 
-        SlangResult parseOption(TokenReader& parser, String const& word, ShaderInputLayout::ObjectVal* val)
+        SlangResult parseOption(Misc::TokenReader& parser, String const& word, ShaderInputLayout::ObjectVal* val)
         {
             if( word == "type" )
             {
@@ -346,7 +346,7 @@ namespace renderer_test
             return SLANG_OK;
         }
 
-        Format parseFormatOption(TokenReader& parser)
+        Format parseFormatOption(Misc::TokenReader& parser)
         {
             parser.Read("=");
             auto formatWord = parser.ReadWord();
@@ -355,7 +355,7 @@ namespace renderer_test
         }
 
         template<typename T>
-        void maybeParseOptions(TokenReader& parser, T* val)
+        void maybeParseOptions(Misc::TokenReader& parser, T* val)
         {
             // parse options
             if (parser.LookAhead("("))
@@ -378,11 +378,11 @@ namespace renderer_test
             }
         }
 
-        RefPtr<ShaderInputLayout::Val> parseNumericValExpr(TokenReader& parser, bool negate = false)
+        RefPtr<ShaderInputLayout::Val> parseNumericValExpr(Misc::TokenReader& parser, bool negate = false)
         {
             switch(parser.NextToken().Type)
             {
-            case TokenType::IntLiteral:
+            case Misc::TokenType::IntLiteral:
                 {
                     RefPtr<ShaderInputLayout::DataVal> val = new ShaderInputLayout::DataVal;
 
@@ -394,7 +394,7 @@ namespace renderer_test
                 }
                 break;
 
-            case TokenType::DoubleLiteral:
+            case Misc::TokenType::DoubleLiteral:
                 {
                     RefPtr<ShaderInputLayout::DataVal> val = new ShaderInputLayout::DataVal;
 
@@ -414,7 +414,7 @@ namespace renderer_test
             }
         }
 
-        String parseTypeName(TokenReader& parser)
+        String parseTypeName(Misc::TokenReader& parser)
         {
             String typeName = parser.ReadWord();
             if (parser.AdvanceIf("<"))
@@ -429,8 +429,10 @@ namespace renderer_test
             return typeName;
         }
 
-        RefPtr<ShaderInputLayout::Val> parseValExpr(TokenReader& parser)
+        RefPtr<ShaderInputLayout::Val> parseValExpr(Misc::TokenReader& parser)
         {
+            typedef Misc::TokenType TokenType;
+
             switch(parser.NextToken().Type)
             {
             case TokenType::OpSub:
@@ -531,7 +533,7 @@ namespace renderer_test
             }
         }
 
-        RefPtr<ShaderInputLayout::Val> parseVal(TokenReader& parser)
+        RefPtr<ShaderInputLayout::Val> parseVal(Misc::TokenReader& parser)
         {
             auto word = parser.NextToken().Content;
             if (parser.AdvanceIf("begin_array"))
@@ -657,8 +659,11 @@ namespace renderer_test
             parser.ReadToken();
         }
 
-        String parseName(TokenReader& parser)
+        String parseName(Misc::TokenReader& parser)
         {
+            typedef Misc::Token Token;
+            typedef Misc::TokenType TokenType;
+
             StringBuilder builder;
 
             Token nameToken = parser.ReadToken();
@@ -695,7 +700,7 @@ namespace renderer_test
             }
         }
 
-        void parseFieldBindings(TokenReader& parser, ShaderInputLayout::Field& ioField)
+        void parseFieldBindings(Misc::TokenReader& parser, ShaderInputLayout::Field& ioField)
         {
             // parse bindings
             if (parser.LookAhead(":"))
@@ -710,7 +715,7 @@ namespace renderer_test
                     else if (parser.AdvanceIf("name"))
                     {
                         // Optionally consume '=' 
-                        if (parser.NextToken().Type == TokenType::OpAssign)
+                        if (parser.NextToken().Type == Misc::TokenType::OpAssign)
                         {
                             parser.ReadToken();
                         }
@@ -735,7 +740,7 @@ namespace renderer_test
             parentVal = val;
         }
 
-        void parseValEntry(TokenReader& parser)
+        void parseValEntry(Misc::TokenReader& parser)
         {
             auto parentForNewVal = parentVal;
 
@@ -746,19 +751,19 @@ namespace renderer_test
             parentForNewVal->addField(field);
         }
 
-        void parseSetEntry(TokenReader& parser)
+        void parseSetEntry(Misc::TokenReader& parser)
         {
             auto parentForNewVal = parentVal;
 
             ShaderInputLayout::Field field;
             field.name = parseName(parser);
-            parser.Read(TokenType::OpAssign);
+            parser.Read(Misc::TokenType::OpAssign);
             field.val = parseValExpr(parser);
 
             parentForNewVal->addField(field);
         }
 
-        void parseLine(TokenReader& parser)
+        void parseLine(Misc::TokenReader& parser)
         {
             if (parser.LookAhead("entryPointSpecializationArg")
                 || parser.LookAhead("type")
@@ -804,18 +809,18 @@ namespace renderer_test
             RefPtr<ShaderInputLayout::AggVal> rootVal = new ShaderInputLayout::AggVal;
             parentVal = rootVal;
 
-            auto lines = Split(source, '\n');
+            auto lines = Misc::Split(source, '\n');
             for (auto & line : lines)
             {
                 if (line.startsWith("//TEST_INPUT:"))
                 {
                     auto lineContent = line.subString(13, line.getLength() - 13);
-                    TokenReader parser(lineContent);
+                    Misc::TokenReader parser(lineContent);
                     try
                     {
                         parseLine(parser);
                     }
-                    catch (const TextFormatException&)
+                    catch (const Misc::TextFormatException&)
                     {
                         StringBuilder msg;
                         msg << "Invalid input syntax at line " << parser.NextToken().Position.Line;
diff --git a/tools/render-test/slang-support.cpp b/tools/render-test/slang-support.cpp
index 5470ea35a..adfea337c 100644
--- a/tools/render-test/slang-support.cpp
+++ b/tools/render-test/slang-support.cpp
@@ -88,18 +88,21 @@ void ShaderCompilerUtil::Output::reset()
     out.session = session;
 
     // Parse all the extra args
-    if (request.compileArgs.getCount() > 0)
     {
         List<const char*> args;
-        for (const auto& arg : request.compileArgs)
+        for (const auto& arg : options.downstreamArgs.getArgsByName("slang"))
         {
-            args.add(arg.getBuffer());
+            args.add(arg.value.getBuffer());
+        }
+
+        if (args.getCount())
+        {
+            SLANG_RETURN_ON_FAIL(spProcessCommandLineArguments(slangRequest, args.getBuffer(), int(args.getCount())));
         }
-        SLANG_RETURN_ON_FAIL(spProcessCommandLineArguments(slangRequest, args.getBuffer(), int(args.getCount())));
     }
 
     spSetCodeGenTarget(slangRequest, input.target);
-    spSetTargetProfile(slangRequest, 0, spFindProfile(session, input.profile));
+    spSetTargetProfile(slangRequest, 0, spFindProfile(session, input.profile.getBuffer()));
 
     // Define a macro so that shader code in a test can detect what language we
     // are nominally working with.
@@ -140,10 +143,7 @@ void ShaderCompilerUtil::Output::reset()
         spSetCompileFlags(slangRequest, SLANG_COMPILE_FLAG_NO_CODEGEN);
     }
 
-    // Process any additional command-line options specified for Slang using
-    // the `-xslang <arg>` option to `render-test`.
-    SLANG_RETURN_ON_FAIL(spProcessCommandLineArguments(slangRequest, input.args, input.argCount)); 
-
+    
     const auto sourceLanguage = input.sourceLanguage;
 
     int translationUnitIndex = 0;
@@ -322,7 +322,6 @@ void ShaderCompilerUtil::Output::reset()
 /* static */SlangResult ShaderCompilerUtil::compileWithLayout(SlangSession* session, const Options& options, const ShaderCompilerUtil::Input& input, OutputAndLayout& output)
 {
     String sourcePath = options.sourcePath;
-    auto& compileArgs = options.compileArgs;
     auto shaderType = options.shaderType;
 
     List<char> sourceText;
@@ -377,8 +376,6 @@ void ShaderCompilerUtil::Output::reset()
 
     ShaderCompileRequest compileRequest;
 
-    compileRequest.compileArgs = compileArgs;
-
     compileRequest.source = sourceInfo;
 
     // Now we will add the "default" entry point names/stages that
diff --git a/tools/render-test/slang-support.h b/tools/render-test/slang-support.h
index 59d422bc7..3404aac1d 100644
--- a/tools/render-test/slang-support.h
+++ b/tools/render-test/slang-support.h
@@ -38,8 +38,6 @@ struct ShaderCompileRequest
 
     Slang::List<Slang::String> globalSpecializationArgs;
     Slang::List<Slang::String> entryPointSpecializationArgs;
-
-    Slang::List<Slang::String> compileArgs;
 };
 
 
@@ -47,13 +45,11 @@ struct ShaderCompilerUtil
 {
     struct Input
     {
-        SlangCompileTarget      target;
-        SlangSourceLanguage     sourceLanguage;
-        SlangPassThrough        passThrough;
-        PipelineType            pipelineType = PipelineType::Unknown;
-        char const*             profile;
-        const char**            args;
-        int                     argCount;
+        SlangCompileTarget          target;
+        SlangSourceLanguage         sourceLanguage;
+        SlangPassThrough            passThrough;
+        PipelineType                pipelineType = PipelineType::Unknown;
+        Slang::String               profile;
     };
 
     struct Output