Merge branch 'master' into conform-integer-literals

Author: fairywreath

docs/scripts/Program.cs

@@ -11,12 +11,13 @@ public static string getAnchorId(string title)
         {
             StringBuilder sb = new StringBuilder();
             title = title.Trim().ToLower();
+
             foreach (var ch in title)
             {
                 if (ch >= 'a' && ch <= 'z' || ch >= '0' && ch <= '9'
-                    || ch == '-')
+                    || ch == '-'|| ch =='_')
                     sb.Append(ch);
-                else if (ch==' ' || ch =='_')
+                else if (ch == ' ' )
                     sb.Append('-');
             }
             return sb.ToString();

docs/user-guide/09-targets.md

@@ -412,6 +412,47 @@ Slang's CPU compute target supports only a compute pipeline.
 
 Because CPU target support flexible pointer-based addressing and large low-latency caches, a compute kernel can simply be passed a small fixed number of pointers and be relied upon to load parameter values of any types via indirection through those pointers.
 
+## WebGPU
+
+> #### Note
+>
+> Slang support for WebGPU is work in progress.
+
+WebGPU is a graphics and compute API.
+It is similar in spirit to modern APIs, like Metal, Direct3D 12 and Vulkan, but with concessions to portability and privacy.
+
+WebGPU is available both in browsers as a JavaScript API, and natively as a C/C++ API.
+[Dawn](https://github.com/google/dawn), is a native WebGPU implementation used by the Chrome browser.
+
+By combining Slang, [Dawn](https://github.com/google/dawn) and [Emscripten](https://emscripten.org/),
+an application can easily target any native API, and the web, with a single codebase consisting of C++ and Slang code.
+
+WebGPU shader modules are created from WGSL (WebGPU Shading Language) source files.
+WebGPU does not use an intermediate representation - WGSL code is compiled to backend-specific code by
+compilers provided by the WebGPU implementation.
+
+### Pipelines
+
+WebGPU supports render and compute pipelines.
+
+The WebGPU render pipeline includes the following programmable stages:
+
+- The vertex stage outputs vertex data
+
+- The fragment stage outputs fragments
+
+### Parameter Passing
+
+WebGPU uses groups of bindings called bind groups to bind things like textures, buffers and samplers.
+Bind group objects are passed as arguments when encoding bind group setting commands.
+
+There is a notion of equivalence for bind groups, and a notion of equivalence for pipelines defined in
+terms of bind group equivalence.
+This equivalence allows an application to save some bind group setting commands, when switching between
+pipelines, if bindings are grouped together appropriately.
+
+Which bindings are grouped together can be controlled using Slang's `ParameterBlock` generic type.
+
 ## Summary
 
 This chapter has reviewed the main target platforms supported by the Slang compiler and runtime system.

docs/user-guide/toc.html

@@ -42,7 +42,7 @@
 <li data-link="convenience-features#subscript-operator"><span>Subscript Operator</span></li>
 <li data-link="convenience-features#tuple-types"><span>Tuple Types</span></li>
 <li data-link="convenience-features#optionalt-type"><span>`Optional&lt;T&gt;` type</span></li>
-<li data-link="convenience-features#if-let-syntax"><span>`if_let` syntax</span></li>
+<li data-link="convenience-features#if_let-syntax"><span>`if_let` syntax</span></li>
 <li data-link="convenience-features#reinterprett-operation"><span>`reinterpret&lt;T&gt;` operation</span></li>
 <li data-link="convenience-features#pointers-limited"><span>Pointers (limited)</span></li>
 <li data-link="convenience-features#extensions"><span>Extensions</span></li>
@@ -66,7 +66,7 @@
 <li data-link="capabilities#conflicting-capabilities"><span>Conflicting Capabilities</span></li>
 <li data-link="capabilities#requirements-in-parent-scope"><span>Requirements in Parent Scope</span></li>
 <li data-link="capabilities#inference-of-capability-requirements"><span>Inference of Capability Requirements</span></li>
-<li data-link="capabilities#inference-on-target-switch"><span>Inference on target_switch</span></li>
+<li data-link="capabilities#inference-on-target_switch"><span>Inference on target_switch</span></li>
 <li data-link="capabilities#capability-aliases"><span>Capability Aliases</span></li>
 <li data-link="capabilities#validation-of-capability-requirements"><span>Validation of Capability Requirements</span></li>
 </ul>
@@ -135,6 +135,7 @@
 <li data-link="targets#metal"><span>Metal</span></li>
 <li data-link="targets#cuda-and-optix"><span>CUDA and OptiX</span></li>
 <li data-link="targets#cpu-compute"><span>CPU Compute</span></li>
+<li data-link="targets#webgpu"><span>WebGPU</span></li>
 <li data-link="targets#summary"><span>Summary</span></li>
 </ul>
 </li>

include/slang-deprecated.h

@@ -101,7 +101,7 @@ extern "C"
         int targetIndex,
         bool val);
 
-    /*! @see slang::ICompileRequest::setIngoreCapabilityCheck */
+    /*! @see slang::ICompileRequest::setIgnoreCapabilityCheck */
     SLANG_API void spSetIgnoreCapabilityCheck(slang::ICompileRequest* request, bool val);
 
     /*! @see slang::ICompileRequest::setCodeGenTarget */
@@ -936,11 +936,11 @@ extern "C"
     /// Count should *NOT* include terminating zero.
     SLANG_API SlangUInt32 spComputeStringHash(const char* chars, size_t count);
 
-    /// Get a type layout representing reflection information for the global-scope prameters.
+    /// Get a type layout representing reflection information for the global-scope parameters.
     SLANG_API SlangReflectionTypeLayout* spReflection_getGlobalParamsTypeLayout(
         SlangReflection* reflection);
 
-    /// Get a variable layout representing reflection information for the global-scope prameters.
+    /// Get a variable layout representing reflection information for the global-scope parameters.
     SLANG_API SlangReflectionVariableLayout* spReflection_getGlobalParamsVarLayout(
         SlangReflection* reflection);
 
@@ -1409,7 +1409,7 @@ struct ICompileRequest : public ISlangUnknown
     virtual SLANG_NO_THROW void const* SLANG_MCALL getCompileRequestCode(size_t* outSize) = 0;
 
     /** Get the compilation result as a file system.
-    The result is not written to the actual OS file system, but is made avaiable as an
+    The result is not written to the actual OS file system, but is made available as an
     in memory representation.
     */
     virtual SLANG_NO_THROW ISlangMutableFileSystem* SLANG_MCALL

include/slang.h

@@ -305,7 +305,7 @@ convention for interface methods.
 /// SLANG_INLINE exists to have a way to inline consistent with SLANG_ALWAYS_INLINE
 #define SLANG_INLINE inline
 
-// If explicilty disabled and not set, set to not available
+// If explicitly disabled and not set, set to not available
 #if !defined(SLANG_HAS_EXCEPTIONS) && defined(SLANG_DISABLE_EXCEPTIONS)
     #define SLANG_HAS_EXCEPTIONS 0
 #endif
@@ -488,9 +488,9 @@ convention for interface methods.
     #define SLANG_UNALIGNED_ACCESS 0
 #endif
 
-// One endianess must be set
+// One endianness must be set
 #if ((SLANG_BIG_ENDIAN | SLANG_LITTLE_ENDIAN) == 0)
-    #error "Couldn't determine endianess"
+    #error "Couldn't determine endianness"
 #endif
 
 #ifndef SLANG_NO_INTTYPES
@@ -551,7 +551,7 @@ typedef uint32_t SlangSizeT;
     {
         SLANG_SEVERITY_DISABLED = 0, /**< A message that is disabled, filtered out. */
         SLANG_SEVERITY_NOTE,         /**< An informative message. */
-        SLANG_SEVERITY_WARNING,      /**< A warning, which indicates a possible proble. */
+        SLANG_SEVERITY_WARNING,      /**< A warning, which indicates a possible problem. */
         SLANG_SEVERITY_ERROR,        /**< An error, indicating that compilation failed. */
         SLANG_SEVERITY_FATAL,    /**< An unrecoverable error, which forced compilation to abort. */
         SLANG_SEVERITY_INTERNAL, /**< An internal error, indicating a logic error in the compiler.
@@ -811,10 +811,10 @@ typedef uint32_t SlangSizeT;
     {
         SLANG_DEBUG_INFO_LEVEL_NONE = 0, /**< Don't emit debug information at all. */
         SLANG_DEBUG_INFO_LEVEL_MINIMAL,  /**< Emit as little debug information as possible, while
-                                            still supporting stack trackes. */
+                                            still supporting stack trackers. */
         SLANG_DEBUG_INFO_LEVEL_STANDARD, /**< Emit whatever is the standard level of debug
                                             information for each target. */
-        SLANG_DEBUG_INFO_LEVEL_MAXIMAL,  /**< Emit as much debug infromation as possible for each
+        SLANG_DEBUG_INFO_LEVEL_MAXIMAL,  /**< Emit as much debug information as possible for each
                                             target. */
     };
 
@@ -823,7 +823,7 @@ typedef uint32_t SlangSizeT;
     enum SlangDebugInfoFormat : SlangDebugInfoFormatIntegral
     {
         SLANG_DEBUG_INFO_FORMAT_DEFAULT, ///< Use the default debugging format for the target
-        SLANG_DEBUG_INFO_FORMAT_C7, ///< CodeView C7 format (typically means debugging infomation is
+        SLANG_DEBUG_INFO_FORMAT_C7, ///< CodeView C7 format (typically means debugging information is
                                     ///< embedded in the binary)
         SLANG_DEBUG_INFO_FORMAT_PDB, ///< Program database
 
@@ -1958,14 +1958,14 @@ public:                                                              \
         // This `MyParams` type introduces two existential type parameters:
         // one for `material` and one for `lights`. Even though `lights`
         // is an array, it only introduces one type parameter, because
-        // we need to hae a *single* concrete type for all the array
+        // we need to have a *single* concrete type for all the array
         // elements to be able to generate specialized code.
         //
         SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM,
 
         // An existential object parameter represents a value
         // that needs to be passed in to provide data for some
-        // interface-type shader paameter.
+        // interface-type shader parameter.
         //
         // Consider this example:
         //
@@ -2025,13 +2025,13 @@ public:                                                              \
     parameters of different types as occupying the same binding space for layout
     (e.g., in SPIR-V both a `Texture2D` and `SamplerState` use the same space of
     `binding` indices, and are not allowed to overlap), while those same types
-    map to different types of bindingsin the API (e.g., both textures and samplers
+    map to different types of bindings in the API (e.g., both textures and samplers
     use different `VkDescriptorType` values).
 
     When you want to answer "what register/binding did this parameter use?" you
     should use `SlangParameterCategory`.
 
-    When you wnat to answer "what type of descriptor range should this parameter use?"
+    When you want to answer "what type of descriptor range should this parameter use?"
     you should use `SlangBindingType`.
     */
     typedef SlangUInt32 SlangBindingTypeIntegral;
@@ -3601,7 +3601,7 @@ struct IGlobalSession : public ISlangUnknown
     */
     virtual SLANG_NO_THROW ISlangSharedLibraryLoader* SLANG_MCALL getSharedLibraryLoader() = 0;
 
-    /** Returns SLANG_OK if a the compilation target is supported for this session
+    /** Returns SLANG_OK if the compilation target is supported for this session
 
     @param target The compilation target to test
     @return SLANG_OK if the target is available
@@ -3611,7 +3611,7 @@ struct IGlobalSession : public ISlangUnknown
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL
     checkCompileTargetSupport(SlangCompileTarget target) = 0;
 
-    /** Returns SLANG_OK if a the pass through support is supported for this session
+    /** Returns SLANG_OK if the pass through support is supported for this session
     @param session Session
     @param target The compilation target to test
     @return SLANG_OK if the target is available
@@ -3689,7 +3689,7 @@ struct IGlobalSession : public ISlangUnknown
      *   @param argc The number of command line arguments.
      *   @param argv An input array of command line arguments to parse.
      *   @param outSessionDesc A pointer to a SessionDesc struct to receive parsed session desc.
-     *   @param outAuxAllocation Auxillary memory allocated to hold data used in the sesion desc.
+     *   @param outAuxAllocation Auxiliary memory allocated to hold data used in the session desc.
      */
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL parseCommandLineArguments(
         int argc,
@@ -3815,7 +3815,7 @@ information.
 
 In order to be able to load code, the session owns a set
 of active "search paths" for resolving `#include` directives
-and `import` declrations, as well as a set of global
+and `import` declarations, as well as a set of global
 preprocessor definitions that will be used for all code
 that gets `import`ed in the session.
 
@@ -3880,7 +3880,7 @@ struct ISession : public ISlangUnknown
     function will return null.
 
     It is an error to create a composite component type that recursively
-    aggregates the a single module more than once.
+    aggregates a single module more than once.
     */
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL createCompositeComponentType(
         IComponentType* const* componentTypes,
@@ -3953,7 +3953,7 @@ struct ISession : public ISlangUnknown
         to explicitly specify which implementation types should be included in the final compiled
         code. For example, if an module defines `IMaterial` interface and `AMaterial`,
         `BMaterial`, `CMaterial` types that implements the interface, the user can exclude
-        `CMaterial` implementation from the resulting shader code by explcitly adding
+        `CMaterial` implementation from the resulting shader code by explicitly adding
         `AMaterial:IMaterial` and `BMaterial:IMaterial` conformances to a composite
         `IComponentType` and get entry point code from it. The resulting code will not have
         anything related to `CMaterial` in the dynamic dispatch logic. If the user does not
@@ -4006,7 +4006,7 @@ struct IMetadata : public ISlangCastable
     SLANG_COM_INTERFACE(0x8044a8a3, 0xddc0, 0x4b7f, {0xaf, 0x8e, 0x2, 0x6e, 0x90, 0x5d, 0x73, 0x32})
 
     /*
-    Returns whether a resource parameter at the specifieid binding location is actually being used
+    Returns whether a resource parameter at the specified binding location is actually being used
     in the compiled shader.
     */
     virtual SlangResult isParameterLocationUsed(
@@ -4136,7 +4136,7 @@ struct IComponentType : public ISlangUnknown
 
     Has the same requirements as getEntryPointCode.
 
-    The result is not written to the actual OS file system, but is made avaiable as an
+    The result is not written to the actual OS file system, but is made available as an
     in memory representation.
     */
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL getResultAsFileSystem(
@@ -4166,7 +4166,7 @@ struct IComponentType : public ISlangUnknown
         IComponentType** outSpecializedComponentType,
         ISlangBlob** outDiagnostics = nullptr) = 0;
 
-    /** Link this component type against all of its unsatisifed dependencies.
+    /** Link this component type against all of its unsatisfied dependencies.
 
     A component type may have unsatisfied dependencies. For example, a module
     depends on any other modules it `import`s, and an entry point depends
@@ -4179,7 +4179,7 @@ struct IComponentType : public ISlangUnknown
     It is an error to try to generate/access compiled kernel code for
     a component type with unresolved dependencies, so if dependencies
     remain after whatever manual composition steps an application
-    cares to peform, the `link()` function can be used to automatically
+    cares to perform, the `link()` function can be used to automatically
     compose in any remaining dependencies. The order of parameters
     (and hence the global layout) that results will be deterministic,
     but is not currently documented.

source/slang/slang-capabilities.capdef

@@ -4,7 +4,7 @@
 // This file will be parsed and processed by the slang-capability-generator
 // tool during the build process to produce slang-generated-capability-defs.h
 // and slang-generated-capability-defs-impl.h files that constitute the final
-// C++ source of the compiler. New capabilties should be added by editing
+// C++ source of the compiler. New capabilities should be added by editing
 // this file instead of the generated .h files.
 //
 // A capability atom represent a basic unit that characterizes a single code-gen target or
@@ -1885,7 +1885,7 @@ alias subgroup_arithmetic = GL_KHR_shader_subgroup_arithmetic | _sm_6_0 | _cuda_
 /// Capabilities required to use GLSL-style subgroup operations 'subgroup_shuffle'
 /// [Compound]
 alias subgroup_shuffle = GL_KHR_shader_subgroup_shuffle | _sm_6_0 | _cuda_sm_7_0;
-/// Capabilities required to use GLSL-style subgroup operations 'subgroup_shufle_relative'
+/// Capabilities required to use GLSL-style subgroup operations 'subgroup_shuffle_relative'
 /// [Compound]
 alias subgroup_shufflerelative = GL_KHR_shader_subgroup_shuffle_relative | _sm_6_0 | _cuda_sm_7_0;
 /// Capabilities required to use GLSL-style subgroup operations 'subgroup_clustered'

source/slang/slang-ir-autodiff-fwd.cpp

@@ -2076,6 +2076,7 @@ InstPair ForwardDiffTranscriber::transcribeInstImpl(IRBuilder* builder, IRInst*
     case kIROp_GetArrayLength:
     case kIROp_SizeOf:
     case kIROp_AlignOf:
+    case kIROp_Printf:
         return transcribeNonDiffInst(builder, origInst);
 
         // A call to createDynamicObject<T>(arbitraryData) cannot provide a diff value,

tests/compute/constexpr.slang

@@ -2,6 +2,7 @@
 //TEST(compute):COMPARE_COMPUTE_EX:-slang -gcompute -shaderobj
 //DISABLED://TEST(compute, vulkan):COMPARE_COMPUTE_EX:-vk -gcompute -shaderobj
 //TEST(compute):COMPARE_COMPUTE_EX:-mtl -gcompute -shaderobj
+//TEST(compute):COMPARE_COMPUTE_EX:-wgpu -gcompute -shaderobj
 
 //TEST_INPUT: Texture2D(size=4, content = one):name tex
 //TEST_INPUT: Sampler:name samp

tests/metal/nested-struct-fragment-input.slang

@@ -1,5 +1,6 @@
 //TEST:SIMPLE(filecheck=METAL): -target metal -stage fragment -entry fragmentMain
 //TEST:SIMPLE(filecheck=METALLIB): -target metallib -stage fragment -entry fragmentMain
+//TEST:SIMPLE(filecheck=WGSL): -target wgsl -stage fragment -entry fragmentMain
 
 // METAL: COARSEVERTEX_7
 // METAL: COARSEVERTEX_6
@@ -63,6 +64,16 @@ float4 fragmentMain(FragmentStageInput input)
     // METAL-DAG: {{.*}}->p3{{.*}}->p2{{.*}}->p1{{.*}}=
     // METAL-DAG: {{.*}}->p3{{.*}}->p3{{.*}}->p1{{.*}}=
 
+    // WGSL-DAG: {{.*}}._S{{.*}}=
+
+    // WGSL-DAG: {{.*}}.p2{{.*}}._S{{.*}}=
+    // WGSL-DAG: {{.*}}.p2{{.*}}.p2{{.*}}._S{{.*}}=
+    // WGSL-DAG: {{.*}}.p2{{.*}}.p3{{.*}}._S{{.*}}=
+
+    // WGSL-DAG: {{.*}}.p3{{.*}}._S{{.*}}=
+    // WGSL-DAG: {{.*}}.p3{{.*}}.p2{{.*}}._S{{.*}}=
+    // WGSL-DAG: {{.*}}.p3{{.*}}.p3{{.*}}._S{{.*}}=
+
     outputBuffer[0] = input.coarseVertex.p1 + input.coarseVertex.p2.p1 + +input.coarseVertex.p3.p1;
     return float4(0, 0, 0, 0);
 }

tests/metal/nested-struct-fragment-output.slang

@@ -1,5 +1,6 @@
 //TEST:SIMPLE(filecheck=METAL): -target metal -stage fragment -entry fragmentMain
 //TEST:SIMPLE(filecheck=METALLIB): -target metallib -stage fragment -entry fragmentMain
+//TEST:SIMPLE(filecheck=WGSL): -target wgsl -stage fragment -entry fragmentMain
 
 //METAL-DAG: color(0)
 //METAL-DAG: color(1)
@@ -10,6 +11,15 @@
 //METAL-DAG: color(6)
 //METAL-NOT: color(7)
 
+//WGSL-DAG: location(0)
+//WGSL-DAG: location(1)
+//WGSL-DAG: location(2)
+//WGSL-DAG: location(3)
+//WGSL-DAG: location(4)
+//WGSL-DAG: location(5)
+//WGSL-DAG: location(6)
+//WGSL-NOT: location(7)
+
 //METALLIB: @fragmentMain
 
 RWStructuredBuffer<float> outputBuffer;
@@ -69,6 +79,16 @@ FragmentStageOutput fragmentMain(FragmentStageInput input)
     // METAL-DAG: ={{.*}}.p3{{.*}}.p2{{.*}}.p1
     // METAL-DAG: ={{.*}}.p3{{.*}}.p3{{.*}}.p1
 
+    // WGSL-DAG: ={{.*}}._S{{.*}}
+
+    // WGSL-DAG: ={{.*}}.p2{{.*}}._S{{.*}}
+    // WGSL-DAG: ={{.*}}.p2{{.*}}.p2{{.*}}._S{{.*}}
+    // WGSL-DAG: ={{.*}}.p2{{.*}}.p3{{.*}}._S{{.*}}
+
+    // WGSL-DAG: ={{.*}}.p3{{.*}}._S{{.*}}
+    // WGSL-DAG: ={{.*}}.p3{{.*}}.p2{{.*}}._S{{.*}}
+    // WGSL-DAG: ={{.*}}.p3{{.*}}.p3{{.*}}._S{{.*}}
+
 	outputBuffer[0] = 1;
 	return output;
 }