Attachment 349505 Details for Bug 187735 – WIP

[patch] WIP

bug-187735-20180911193515.patch (text/plain), 223.95 KB, created by Thomas Denney on 2018-09-11 19:35:16 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Thomas Denney

Created: 2018-09-11 19:35:16 PDT

Size: 223.95 KB

patch

obsolete

>Subversion Revision: 235894
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index e60abee4189f1442afc52c598099305a20175ed1..857367e8fc3fe32092b17b501a63275324c10e09 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1 +1,97 @@
>+2018-08-31  Thomas Denney  <tdenney@apple.com>
>+
>+        [WHLSL] Metal code generation
>+        https://bugs.webkit.org/show_bug.cgi?id=187735
>+
>+        This patch adds a compiler that creates Metal shaders from WHLSL source.
>+        It provides a webpage (Metal/index.html) that allows the user to enter
>+        WHLSL source and compile it directly to MSL. Please see
>+        https://bugs.webkit.org/show_bug.cgi?id=187738, which is a superset of
>+        this bug, for an implementation of a test suite for WHLSL.
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * WebGPUShadingLanguageRI/MakeArrayRefExpression.js:
>+        (MakeArrayRefExpression): Fixed detection of the type of the expression.
>+        * WebGPUShadingLanguageRI/Metal/ArrayRefDefinition.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/CompileResult.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/ConstexprEmitter.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/Counter.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/ForwardDeclarations.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/FunctionLikeBlockCanBeInlined.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/LineNumbers.js: Added 
>+        * WebGPUShadingLanguageRI/Metal/MSLFunctionDeclaration.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/MSLFunctionDefinition.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/MSLFunctionForwardDeclaration.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/MSLLexer.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/MSLStatementEmitter.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/MSLTypeNamer.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/MetalCodegen.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/NameMangler.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/SortTypeDeclarations.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/StructDefinition.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/Token.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/TypeAttributeMap.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/TypeAttributes.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/TypeOf.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/TypeUnifier.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/VarDeclaration.js: Added
>+        * WebGPUShadingLanguageRI/Metal/WHLSLLexer.js: Added.
>+        * WebGPUShadingLanguageRI/Metal/index.html: Added.
>+        * WebGPUShadingLanguageRI/Metal/metal.css: Added.
>+        * WebGPUShadingLanguageRI/SynthesizeStructAccessors.js:
>+        (synthesizeStructAccessors.setupImplementationData): Added struct
>+        implementation data to the native function instance.
>+        * WebGPUShadingLanguageRI/Test.js: Added additional tests for
>+        interesting cases in the compiler.
>+        (makeInt): Force integer value.
>+        (makeUint): Force unsigned integer value.
>+        (makeUchar): Forced unsigned 8-bit integer value.
>+        (makeBool): Force boolean value.
>+
>+2018-09-11  Thomas Denney  <tdenney@apple.com>
>+
>+        [WHLSL] Improve test suite type safety
>+        https://bugs.webkit.org/show_bug.cgi?id=189502
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Each of the 'makeT' functions now call the relevant cast function on the
>+        value before hand. The checkNumber function has also been removed and
>+        its uses have been replaced with functions that also check the type.
>+        Finally, some of the arithmetic checks have been updated to reflect that
>+        the casts happen outside of WHLSL evaluation.
>+
>+        * WebGPUShadingLanguageRI/Casts.js:
>+        (castToBool): Added.
>+        * WebGPUShadingLanguageRI/Test.js: Updated makeT functions, tests that
>+        used checkNumber, and the uchar arithmetic tests to reflect the casting.
>+
>+2018-09-11  Thomas Denney  <tdenney@apple.com>
>+
>+        [WHLSL] Improve test suite type safety
>+        https://bugs.webkit.org/show_bug.cgi?id=189502
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Each of the 'makeT' functions now call the relevant cast function on the
>+        value before hand. The checkNumber function has also been removed and
>+        its uses have been replaced with functions that also check the type.
>+        Some of the arithmetic checks have been updated to reflect that the
>+        casts happen outside of WHLSL evaluation. Other tests have also been
>+        updated to reflect that some values cannot be precisely expressed in
>+        32-bit floating point.
>+
>+        * WebGPUShadingLanguageRI/Casts.js:
>+        (castToBool): Added.
>+        (castAndCheckValue): Added.
>+        (isBitwiseEquivalent): Moved from Intrinsics.js.
>+        * WebGPUShadingLanguageRI/Intrinsics.js: Ditto.
>+        * WebGPUShadingLanguageRI/SPIRV.html: Update depdencies.
>+        * WebGPUShadingLanguageRI/Test.html: Ditto.
>+        * WebGPUShadingLanguageRI/Test.js: Update makeT functions to do a cast
>+        and check the result. Some tests were also updated to reflect the change
>+        in the behavior of these functions.
>+        * WebGPUShadingLanguageRI/index.html: Update dependencies.
>+
> == Rolled over to ChangeLog-2018-09-11 ==
>diff --git a/Tools/WebGPUShadingLanguageRI/ArrayType.js b/Tools/WebGPUShadingLanguageRI/ArrayType.js
>index 0d56a0b375712c4c14bf731196109dff586bab94..f80b718049ca934b4acab949b7b86f0cd246d6b3 100644
>--- a/Tools/WebGPUShadingLanguageRI/ArrayType.js
>+++ b/Tools/WebGPUShadingLanguageRI/ArrayType.js
>@@ -47,6 +47,11 @@ class ArrayType extends Type {
>             throw new Error("numElements is not a literal: " + this.numElements);
>         return this.numElements.value;
>     }
>+    
>+    get arrayRefType()
>+    {
>+        return new ArrayRefType(this.origin, "thread", this.elementType);
>+    }
> 
>     toString()
>     {
>diff --git a/Tools/WebGPUShadingLanguageRI/Casts.js b/Tools/WebGPUShadingLanguageRI/Casts.js
>index acbb2ea028535b4670423097f7a5b57caf6b8b1c..c8f08ce69a7f32e8a11a0504352a4052df164d3f 100644
>--- a/Tools/WebGPUShadingLanguageRI/Casts.js
>+++ b/Tools/WebGPUShadingLanguageRI/Casts.js
>@@ -39,6 +39,11 @@ function bitwiseCast(typedArrayConstructor1, typedArrayConstructor2, value)
>     return typedArray2[0];
> }
> 
>+function castToBool(value)
>+{
>+    return !!value;
>+}
>+
> function castToUchar(number)
> {
>     return number & 0xFF;
>@@ -113,3 +118,25 @@ function castToFloat(number)
> {
>     return Math.fround(number);
> }
>+
>+function castAndCheckValue(castFunction, value)
>+{
>+    const castedValue = castFunction(value);
>+    if (!isBitwiseEquivalent(castedValue, value))
>+        throw new Error(`${value} was casted and yielded ${castedValue}, which is not bitwise equivalent.`);
>+    return castedValue;
>+}
>+
>+function isBitwiseEquivalent(left, right)
>+{
>+    let doubleArray = new Float64Array(1);
>+    let intArray = new Int32Array(doubleArray.buffer);
>+    doubleArray[0] = left;
>+    let leftInts = Int32Array.from(intArray);
>+    doubleArray[0] = right;
>+    for (let i = 0; i < 2; ++i) {
>+        if (leftInts[i] != intArray[i])
>+            return false;
>+    }
>+    return true;
>+}
>diff --git a/Tools/WebGPUShadingLanguageRI/Intrinsics.js b/Tools/WebGPUShadingLanguageRI/Intrinsics.js
>index 1b0a12af4002a90be635e738f1d5e7d90dcb04d3..68b0dd573fc02ea38517955d8388a646aa90a596 100644
>--- a/Tools/WebGPUShadingLanguageRI/Intrinsics.js
>+++ b/Tools/WebGPUShadingLanguageRI/Intrinsics.js
>@@ -34,20 +34,6 @@ class Intrinsics {
>         // For example, if a native function is declared using "int" rather than "int", then we must
>         // use "int" here, since we don't yet know that they are the same type.
> 
>-        function isBitwiseEquivalent(left, right)
>-        {
>-            let doubleArray = new Float64Array(1);
>-            let intArray = new Int32Array(doubleArray.buffer);
>-            doubleArray[0] = left;
>-            let leftInts = Int32Array.from(intArray);
>-            doubleArray[0] = right;
>-            for (let i = 0; i < 2; ++i) {
>-                if (leftInts[i] != intArray[i])
>-                    return false;
>-            }
>-            return true;
>-        }
>-
>         this._map.set(
>             "native typedef void",
>             type => {
>diff --git a/Tools/WebGPUShadingLanguageRI/MakeArrayRefExpression.js b/Tools/WebGPUShadingLanguageRI/MakeArrayRefExpression.js
>index 0cc6f6ecd23bf03f0ae223f192b1a07ad443709e..cf18b7364b5c993779bf7bbb872b80edf3b10531 100644
>--- a/Tools/WebGPUShadingLanguageRI/MakeArrayRefExpression.js
>+++ b/Tools/WebGPUShadingLanguageRI/MakeArrayRefExpression.js
>@@ -29,8 +29,19 @@ class MakeArrayRefExpression extends Expression {
>     {
>         super(origin);
>         this._lValue = lValue;
>-        if (this.lValue.variable && this.lValue.variable.type && this.lValue.variable.type.isArray && this.lValue.variable.type.elementType) {
>-            this._type = new ArrayRefType(origin, "thread", this.lValue.variable.type.elementType);
>+        let lValueType;
>+        if (lValue instanceof DereferenceExpression)
>+            lValueType = lValue.type;
>+        else if (this.lValue.variable && this.lValue.variable.type)
>+            lValueType = this.lValue.variable.type;
>+
>+        if (lValueType) {
>+            // lValueType = lValueType.unifyNode;
>+            // if (lValueType.isArray && lValueType.elementType)
>+            //     this._type = new ArrayRefType(origin, "thread", lValueType.elementType);
>+            // else
>+            //     this._type = new ArrayRefType(origin, "thread", lValueType);
>+            this._type = lValueType.arrayRefType;
>         }
>     }
> 
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/CompileResult.js b/Tools/WebGPUShadingLanguageRI/Metal/CompileResult.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..22b1acb84f0b2e1167491e5df2f14efe8d5a9407
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/CompileResult.js
>@@ -0,0 +1,60 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+class CompileResult {
>+
>+    constructor(src, err, mangledNameMap, functionSources)
>+    {
>+        this._metalShaderLanguageSource = src;
>+        this._error = err;
>+        this._originalFunctionNameToMangledNames = mangledNameMap;
>+        this._functionSources = functionSources;
>+    }
>+
>+    get metalShaderLanguageSource()
>+    {
>+        return this._metalShaderLanguageSource;
>+    }
>+
>+    get error()
>+    {
>+        return this._error;
>+    }
>+
>+    get originalFunctionNameToMangledNames()
>+    {
>+        return this._originalFunctionNameToMangledNames;
>+    }
>+
>+    get functionSources()
>+    {
>+        return this._functionSources;
>+    }
>+
>+    get didSucceed()
>+    {
>+        return !this.error;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/ConstexprEmitter.js b/Tools/WebGPUShadingLanguageRI/Metal/ConstexprEmitter.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..fe487d72edc65f75d2e69b233b3f9a0c8b828b35
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/ConstexprEmitter.js
>@@ -0,0 +1,49 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+// Used in scenarios where having an auxiliary variable is not possible (e.g. switch cases).
>+class ConstexprEmitter extends Visitor
>+{
>+    visitBoolLiteral(node)
>+    {
>+        return node.value.toString();
>+    }
>+
>+    visitEnumLiteral(node)
>+    {
>+        return node.member.value.visit(this);
>+    }
>+
>+    visitGenericLiteral(node)
>+    {
>+        // FIXME: What happens in the case of halfs/floats/etc
>+        return node.value.toString();
>+    }
>+
>+    visitNullLiteral(node)
>+    {
>+        return "(nullptr)";
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/Counter.js b/Tools/WebGPUShadingLanguageRI/Metal/Counter.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..c4827d09bdd30e5cddc008f67c8d321b34664062
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/Counter.js
>@@ -0,0 +1,38 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+// Provides unique names to variables, functions, and types.
>+class Counter {
>+    constructor(prefix)
>+    {
>+        this._prefix = prefix;
>+        this._value = 0;
>+    }
>+
>+    fresh()
>+    {
>+        return `${this._prefix}${this._value++}`;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/LineNumbers.js b/Tools/WebGPUShadingLanguageRI/Metal/LineNumbers.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..dd476a05c3b56669f1024db65070377d4a1e0284
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/LineNumbers.js
>@@ -0,0 +1,38 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+// This must be called on the original WHLSL source before MSL compilation
>+// to allow translation from character indices to line numbers.
>+function lineNumbers(src)
>+{
>+    const lineNumbers = [];
>+    let lineNumber = 1;
>+    for (let i = 0; i < src.length; i++) {
>+        lineNumbers.push(lineNumber);
>+        if (src[i] == '\n')
>+            lineNumber++;
>+    }
>+    return lineNumbers;
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/MSLCodegenAll.js b/Tools/WebGPUShadingLanguageRI/Metal/MSLCodegenAll.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..3697228d69cd7461b10a24db05a172fbe138371e
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/MSLCodegenAll.js
>@@ -0,0 +1,46 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+load("CompileResult.js");
>+load("ConstexprEmitter.js");
>+load("Counter.js");
>+load("LineNumbers.js");
>+load("MSLFunctionDeclaration.js");
>+load("MSLFunctionDefinition.js");
>+load("MSLFunctionForwardDeclaration.js");
>+load("MSLLexer.js");
>+load("MSLNativeFunctionCall.js");
>+load("MSLStatementEmitter.js");
>+load("MSLTypeNamer.js");
>+load("MetalCodegen.js");
>+load("NameMangler.js");
>+load("SortTypeDeclarations.js");
>+load("Token.js");
>+load("TypeAttributeMap.js");
>+load("TypeAttributes.js");
>+load("TypeOf.js");
>+load("TypeUnifier.js");
>+load("VarDeclaration.js");
>+load("WHLSLLexer.js");
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/MSLFunctionDeclaration.js b/Tools/WebGPUShadingLanguageRI/Metal/MSLFunctionDeclaration.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..85ad5ec6663603f7df8de345ca494459d069f499
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/MSLFunctionDeclaration.js
>@@ -0,0 +1,130 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+// Emits code for for the first line of a function declaration or definition.
>+class MSLFunctionDeclaration {
>+
>+    constructor(funcMangler, funcDef, typeNamer, lineNos, typeAttributes)
>+    {
>+        this._funcMangler = funcMangler;
>+        this._func = funcDef;
>+        this._typeNamer = typeNamer;
>+        this._lineNumbers = lineNos;
>+        this._typeAttributes = typeAttributes;
>+    }
>+
>+    get funcMangler()
>+    {
>+        return this._funcMangler;
>+    }
>+
>+    get func()
>+    {
>+        return this._func;
>+    }
>+
>+    get typeNamer()
>+    {
>+        return this._typeNamer;
>+    }
>+
>+    get lineNumbers()
>+    {
>+        return this._lineNumbers;
>+    }
>+
>+    get typeAttributes()
>+    {
>+        return this._typeAttributes;
>+    }
>+
>+    get isVertexShader()
>+    {
>+        return this._func.shaderType == "vertex";
>+    }
>+
>+    get paramMap()
>+    {
>+        const map = new Map();
>+        let counter = 0;
>+        for (let param of this._func.parameters)
>+            map.set(param.name, `P${counter++}`);
>+        return map;
>+    }
>+
>+    commentLine()
>+    {
>+        const params = [];
>+        for (let paramName of this.paramMap.keys())
>+            params.push(paramName);
>+        let line = `// ${this._func.name}(${params.join(", ")})`;
>+        if (this._lineNumbers && this._func.origin.index && this._lineNumbers[this._func.origin.index])
>+            line += ` @ line ${this._lineNumbers[this._func.origin.index]}`;
>+        return line + "\n";
>+    }
>+
>+    toString()
>+    {
>+        let declLine = this.commentLine();
>+
>+        // TODO: Support shader types other than fragment and vertex.
>+        // What WSL calls `compute` shaders Metal calls `kernel` shaders.
>+        // We're only focussing on `vertex` and `fragment` for now.
>+        if (this._func.shaderType === "vertex" || this._func.shaderType === "fragment")
>+            declLine += `${this._func.shaderType} `;
>+        declLine += `${this._typeNamer.mslTypeName(this._func.returnType)} `;
>+        declLine += this._funcMangler.mangle(this.func);
>+        declLine += "("
>+
>+        let params = [];
>+        const paramMap = this.paramMap;
>+        for (let param of this._func.parameters) {
>+            let pStr = `${this._typeNamer.mslTypeName(param.type)} ${paramMap.get(param.name)}`;
>+            // FIXME: The parser doesn't currently support vertex shaders having uint parameters, so this doesn't work.
>+            if (this.parameterIsVertexId(param) && this.isVertexShader)
>+                pStr += " [[vertex_id]]";
>+            else if (this.parameterIsAttribute(param))
>+                pStr += " [[stage_in]]";
>+            params.push(pStr);
>+        }
>+
>+        declLine += params.join(", ") + ")";
>+
>+        return declLine;
>+    }
>+
>+    parameterIsAttribute(node)
>+    {
>+        // We currently assuming that all parameters to entry points are attributes.
>+        // TODO: Better logic for this, i.e. support samplers.
>+        return this._func.isEntryPoint;
>+    }
>+
>+    parameterIsVertexId(node)
>+    {
>+        // FIXME: This isn't final, and isn't formally specified yet.
>+        return this.isVertexShader && node.name == "wsl_vertexID" && node.type.name == "uint32";
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/MSLFunctionDefinition.js b/Tools/WebGPUShadingLanguageRI/Metal/MSLFunctionDefinition.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..d77b5d8839e50ce60e980a5979c45ff8a392d0f0
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/MSLFunctionDefinition.js
>@@ -0,0 +1,37 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+class MSLFunctionDefinition extends MSLFunctionDeclaration
>+{
>+    toString()
>+    {
>+        let src = super.toString();
>+        src += "\n{\n";
>+        let emitter = new MSLStatementEmitter(this.funcMangler, this.typeNamer, this.func, this.paramMap, this.func.name, this.lineNumbers, this.typeAttributes);
>+        src += emitter.indentedSource();
>+        src += "}";
>+        return src;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/MSLFunctionForwardDeclaration.js b/Tools/WebGPUShadingLanguageRI/Metal/MSLFunctionForwardDeclaration.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..57c6f81353c1f381f967345f8987f3cfb91da518
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/MSLFunctionForwardDeclaration.js
>@@ -0,0 +1,32 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+class MSLFunctionForwardDeclaration extends MSLFunctionDeclaration
>+{
>+    toString()
>+    {
>+        return super.toString() + ";"
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/MSLLexer.js b/Tools/WebGPUShadingLanguageRI/Metal/MSLLexer.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..45c7a18a2aaac2e9517f93c2e2002878d3d78ff3
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/MSLLexer.js
>@@ -0,0 +1,123 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+// Does sufficient lexing for the output of the compiler, not for MSL in general!
>+class MSLLexer {
>+    constructor(src)
>+    {
>+        this._tokens = this._lex(src);
>+    }
>+
>+    get tokens()
>+    {
>+        return this._tokens;
>+    }
>+
>+    get _commentMatchers()
>+    {
>+        return [
>+            { type: "comment", regex: /^(\/\/|\/\*)(\s+)?/ },
>+            { type: "comment-note", regex: /^(TODO:|FIXME:)/ },
>+            { type: "comment", regex: /.*(\n|$)/ }
>+        ]
>+    }
>+
>+    get _defaultMatchers()
>+    {
>+        return [
>+            { type: "comment", regex: /^\/\/(.*?)(\n|$)/, inner: this._commentMatchers },
>+            { type: "directive", regex: /^#(.*?)(\n|$)/ },
>+            { type: "whitespace", regex: /^\s+/ },
>+            { type: "literal", regex: /^([0-9]+)(\.([0-9]*?))?/ },
>+            { type: "type", regex: /^(struct|vertex|fragment|constant|const|threadgroup|thread|device|size_t|uint8_t|uint16_t|uint32_t|int8_t|int16_t|int32_t|((bool|half|float)(2|3|4)x(2|3|4))|((bool|uchar|char|ushort|short|uint|int|half|float)(2|3|4))|float|half|bool)/ },
>+            { type: "keyword", regex: /^(return|if|else|do|while|switch|case|default|break|continue|nullptr|true|false|using|namespace)/ },
>+            { type: "attribute", regex: /^\[\[([A-z][A-z_0-9]+)\]\]/, inner: [
>+                { type: "attribute", regex: /^\[\[[A-z]+$/ },
>+                { type: "literal", regex: /^[0-9]+/ },
>+                { type: "attribute", regex: /^$\]\]/ },
>+                { type: "attribute", regex: /^\[\[([A-z][A-z_0-9]+)\]\]/ }
>+            ] },
>+            { type: "error", regex: /^undefined/ },
>+            { type: "identifier", regex: /^[A-z]([A-z0-9_]*)?/ },
>+            { type: "punctuation", regex: /^(;|\.|$|$|,|\+|\-|=|->|>|<|\!|\}|\{|\*|\?|\:|\[|\])/},
>+            { type: "unknown", regex: /^(.*?)(\n|$)/ }
>+        ];
>+    }
>+
>+    _lex(src, initMatchers = null)
>+    {
>+        const tokens = [];
>+        const matchers = initMatchers ? initMatchers : this._defaultMatchers;
>+
>+        const startOfMultilineComment = /^\/\*/;
>+        const endOfMultilineComment = /\*\//;
>+
>+        const originalLength = src.length;
>+
>+        while (src.length) {
>+            // Special case for multiline comments.
>+            const startMatch = startOfMultilineComment.exec(src);
>+            if (startMatch) {
>+                const endMatch = endOfMultilineComment.exec(src);
>+                if (endMatch) {
>+                    // Important to ignore the first two characters to avoid recursion.
>+                    tokens.push(new Token("comment", startMatch[0], originalLength - src.length));
>+                    const commentText = src.substring(2, endMatch.index + 2);
>+                    for (let innerTok of this._lex(commentText, this.commentMatchers))
>+                        tokens.push(innerTok);
>+                    src = src.substring(endMatch.index + 2);
>+                } else
>+                    throw new Error("Unmatched multiline comment");
>+            }
>+
>+            let didMatch = false;
>+            for (let matcher of matchers) {
>+                const match = matcher.regex.exec(src);
>+                if (match) {
>+                    if (matcher.inner) {
>+                        let innerToks = this._lex(match[0], matcher.inner);
>+                        for (let innerTok of innerToks) {
>+                            innerTok.startIndex += originalLength - src.length;
>+                            tokens.push(innerTok);
>+                        }
>+                    } else
>+                        tokens.push(new Token(matcher.type, match[0], originalLength - src.length));
>+                    src = src.substring(match[0].length);
>+                    didMatch = true;
>+                    break;
>+                }
>+            }
>+            if (!didMatch)
>+                throw new Error(`Nothing matched ${src}`);
>+        }
>+
>+        return tokens;
>+    }
>+}
>+
>+function lexMsl(msl)
>+{
>+    return new MSLLexer(msl).tokens;
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/MSLNativeFunctionCall.js b/Tools/WebGPUShadingLanguageRI/Metal/MSLNativeFunctionCall.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..93b99f4b665230bd61af9fbf4af292befe2dd71a
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/MSLNativeFunctionCall.js
>@@ -0,0 +1,294 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+"use strict";
>+
>+function mslNativeFunctionCall(node, resultVariable, args)
>+{
>+    const key = node.toString();
>+    
>+    const functionsWithTheSameCallingConvention = {
>+        "native bool isfinite(float)" : "isfinite",
>+        "native bool isinf(float)" : "isinf",
>+        "native bool isnormal(float)" : "isnormal",
>+        "native bool isnormal(half)" : "isnormal",
>+        // "native bool operator==(bool,bool)",
>+        "native float acos(float)" : "acos",
>+        // "native float asfloat(int)",
>+        // "native float asfloat(uint)",
>+        "native float asin(float)" : "asin",
>+        "native float atan(float)" : "atan",
>+        "native float atan2(float,float)" : "atan2",
>+        "native float ceil(float)" : "ceil",
>+        "native float cos(float)" : "cos",
>+        "native float cosh(float)" : "cosh",
>+        "native float ddx(float)" : "dfdx",
>+        "native float ddy(float)" : "dfdy", 
>+        "native float exp(float)" : "exp",
>+        // "native float f16tof32(uint)",
>+        "native float floor(float)" : "floor",
>+        "native float log(float)" : "log",
>+        // "native float operator*(float,float)",
>+        // "native float operator+(float,float)",
>+        // "native float operator-(float)",
>+        // "native float operator-(float,float)",
>+        // "native float operator/(float,float)",
>+        "native float pow(float,float)" : "pow",
>+        "native float round(float)" : "round",
>+        "native float sin(float)" : "sin",
>+        "native float sinh(float)" : "sinh",
>+        "native float sqrt(float)" : "sqrt", // This seems to be implemented in terms of pow...
>+        "native float tan(float)" : "tan",
>+        "native float tanh(float)" : "tanh",
>+        "native float trunc(float)" : "trunc",
>+        // "native int asint(float)",
>+        // "native int operator&(int,int)",
>+        // "native int operator*(int,int)",
>+        // "native int operator+(int,int)",
>+        // "native int operator-(int)",
>+        // "native int operator-(int,int)",
>+        // "native int operator/(int,int)",
>+        // "native int operator<<(int,uint)",
>+        // "native int operator>>(int,uint)",
>+        // "native int operator^(int,int)",
>+        // "native int operator|(int,int)",
>+        // "native int operator~(int)",
>+        // "native typedef atomic_int",
>+        // "native typedef atomic_uint",
>+        // "native typedef bool",
>+        // "native typedef char",
>+        // "native typedef float",
>+        // "native typedef half",
>+        // "native typedef int",
>+        // "native typedef sampler",
>+        // "native typedef short",
>+        // "native typedef uchar",
>+        // "native typedef uint",
>+        // "native typedef ushort",
>+        // "native typedef void",
>+        // "native uint asuint(float)",
>+        // "native uint f32tof16(float)",
>+        // "native uint operator&(uint,uint)",
>+        // "native uint operator*(uint,uint)",
>+        // "native uint operator+(uint,uint)",
>+        // "native uint operator-(uint,uint)",
>+        // "native uint operator/(uint,uint)",
>+        // "native uint operator<<(uint,uint)",
>+        // "native uint operator>>(uint,uint)",
>+        // "native uint operator^(uint,uint)",
>+        // "native uint operator|(uint,uint)",
>+        // "native uint operator~(uint)",
>+        // "native void AllMemoryBarrierWithGroupSync()",
>+        // "native void DeviceMemoryBarrierWithGroupSync()",
>+        // "native void GroupMemoryBarrierWithGroupSync()",
>+        // this._map.set(`native typedef ${nativeVectorTypeName}`, type => {
>+        // this._map.set(`native typedef matrix<${typeName}, ${height}, ${width}>`, type => {
>+        // this._map.set(`native typedef vector<${vectorType}, ${vectorSize}>`, type => {
>+        // `native ${type} Load(RWTextureDepth2D<${type}>,int2 location)`,
>+        // `native ${type} Load(RWTextureDepth2DArray<${type}>,int3 location)`,
>+        // `native ${type} Load(TextureDepth2D<${type}>,int3 location)`,
>+        // `native ${type} Load(TextureDepth2D<${type}>,int3 location,int2 offset)`,
>+        // `native ${type} Load(TextureDepth2DArray<${type}>,int4 location)`,
>+        // `native ${type} Load(TextureDepth2DArray<${type}>,int4 location,int2 offset)`,
>+        // `native ${type} Sample(TextureDepth2D<${type}>,sampler,float2 location)`,
>+        // `native ${type} Sample(TextureDepth2D<${type}>,sampler,float2 location,int2 offset)`,
>+        // `native ${type} Sample(TextureDepth2DArray<${type}>,sampler,float3 location)`,
>+        // `native ${type} Sample(TextureDepth2DArray<${type}>,sampler,float3 location,int2 offset)`,
>+        // `native ${type} Sample(TextureDepthCube<${type}>,sampler,float3 location)`,
>+        // `native ${type} SampleBias(TextureDepth2D<${type}>,sampler,float2 location,float Bias)`,
>+        // `native ${type} SampleBias(TextureDepth2D<${type}>,sampler,float2 location,float Bias,int2 offset)`,
>+        // `native ${type} SampleBias(TextureDepth2DArray<${type}>,sampler,float3 location,float Bias)`,
>+        // `native ${type} SampleBias(TextureDepth2DArray<${type}>,sampler,float3 location,float Bias,int2 offset)`,
>+        // `native ${type} SampleBias(TextureDepthCube<${type}>,sampler,float3 location,float Bias)`,
>+        // `native ${type} SampleCmp(TextureDepth2D<${type}>,sampler,float2 location,${type} CompareValue)`,
>+        // `native ${type} SampleCmp(TextureDepth2D<${type}>,sampler,float2 location,${type} CompareValue,int2 offset)`,
>+        // `native ${type} SampleCmp(TextureDepth2DArray<${type}>,sampler,float3 location,${type} CompareValue)`,
>+        // `native ${type} SampleCmp(TextureDepth2DArray<${type}>,sampler,float3 location,${type} CompareValue,int2 offset)`,
>+        // `native ${type} SampleCmp(TextureDepthCube<${type}>,sampler,float3 location,${type} CompareValue)`,
>+        // `native ${type} SampleCmpLevelZero(TextureDepth2D<${type}>,sampler,float2 location,${type} CompareValue)`,
>+        // `native ${type} SampleCmpLevelZero(TextureDepth2D<${type}>,sampler,float2 location,${type} CompareValue,int2 offset)`,
>+        // `native ${type} SampleCmpLevelZero(TextureDepth2DArray<${type}>,sampler,float3 location,${type} CompareValue)`,
>+        // `native ${type} SampleCmpLevelZero(TextureDepth2DArray<${type}>,sampler,float3 location,${type} CompareValue,int2 offset)`,
>+        // `native ${type} SampleCmpLevelZero(TextureDepthCube<${type}>,sampler,float3 location,${type} CompareValue)`,
>+        // `native ${type} SampleGrad(TextureDepth2D<${type}>,sampler,float2 location,float2 DDX,float2 DDY)`,
>+        // `native ${type} SampleGrad(TextureDepth2D<${type}>,sampler,float2 location,float2 DDX,float2 DDY,int2 offset)`,
>+        // `native ${type} SampleGrad(TextureDepth2DArray<${type}>,sampler,float3 location,float2 DDX,float2 DDY)`,
>+        // `native ${type} SampleGrad(TextureDepth2DArray<${type}>,sampler,float3 location,float2 DDX,float2 DDY,int2 offset)`,
>+        // `native ${type} SampleGrad(TextureDepthCube<${type}>,sampler,float3 location,float3 DDX,float3 DDY)`,
>+        // `native ${type} SampleLevel(TextureDepth2D<${type}>,sampler,float2 location,float LOD)`,
>+        // `native ${type} SampleLevel(TextureDepth2D<${type}>,sampler,float2 location,float LOD,int2 offset)`,
>+        // `native ${type} SampleLevel(TextureDepth2DArray<${type}>,sampler,float3 location,float LOD)`,
>+        // `native ${type} SampleLevel(TextureDepth2DArray<${type}>,sampler,float3 location,float LOD,int2 offset)`,
>+        // `native ${type} SampleLevel(TextureDepthCube<${type}>,sampler,float3 location,float LOD)`,
>+        // `native ${type}${length} Load(RWTexture1D<${type}${length}>,int location)`,
>+        // `native ${type}${length} Load(RWTexture1DArray<${type}${length}>,int2 location)`,
>+        // `native ${type}${length} Load(RWTexture2D<${type}${length}>,int2 location)`,
>+        // `native ${type}${length} Load(RWTexture2DArray<${type}${length}>,int3 location)`,
>+        // `native ${type}${length} Load(RWTexture3D<${type}${length}>,int3 location)`,
>+        // `native ${type}${length} Load(Texture1D<${type}${length}>,int2 location)`,
>+        // `native ${type}${length} Load(Texture1D<${type}${length}>,int2 location,int offset)`,
>+        // `native ${type}${length} Load(Texture1DArray<${type}${length}>,int3 location)`,
>+        // `native ${type}${length} Load(Texture1DArray<${type}${length}>,int3 location,int offset)`,
>+        // `native ${type}${length} Load(Texture2D<${type}${length}>,int3 location)`,
>+        // `native ${type}${length} Load(Texture2D<${type}${length}>,int3 location,int2 offset)`,
>+        // `native ${type}${length} Load(Texture2DArray<${type}${length}>,int4 location)`,
>+        // `native ${type}${length} Load(Texture2DArray<${type}${length}>,int4 location,int2 offset)`,
>+        // `native ${type}${length} Load(Texture3D<${type}${length}>,int4 location)`,
>+        // `native ${type}${length} Load(Texture3D<${type}${length}>,int4 location,int3 offset)`,
>+        // `native ${type}${length} Sample(Texture1D<${type}${length}>,sampler,float location)`,
>+        // `native ${type}${length} Sample(Texture1D<${type}${length}>,sampler,float location,int offset)`,
>+        // `native ${type}${length} Sample(Texture1DArray<${type}${length}>,sampler,float2 location)`,
>+        // `native ${type}${length} Sample(Texture1DArray<${type}${length}>,sampler,float2 location,int offset)`,
>+        // `native ${type}${length} Sample(Texture2D<${type}${length}>,sampler,float2 location)`,
>+        // `native ${type}${length} Sample(Texture2D<${type}${length}>,sampler,float2 location,int2 offset)`,
>+        // `native ${type}${length} Sample(Texture2DArray<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}${length} Sample(Texture2DArray<${type}${length}>,sampler,float3 location,int2 offset)`,
>+        // `native ${type}${length} Sample(Texture3D<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}${length} Sample(Texture3D<${type}${length}>,sampler,float3 location,int3 offset)`,
>+        // `native ${type}${length} Sample(TextureCube<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}${length} SampleBias(Texture2D<${type}${length}>,sampler,float2 location,float Bias)`,
>+        // `native ${type}${length} SampleBias(Texture2D<${type}${length}>,sampler,float2 location,float Bias,int2 offset)`,
>+        // `native ${type}${length} SampleBias(Texture2DArray<${type}${length}>,sampler,float3 location,float Bias)`,
>+        // `native ${type}${length} SampleBias(Texture2DArray<${type}${length}>,sampler,float3 location,float Bias,int2 offset)`,
>+        // `native ${type}${length} SampleBias(TextureCube<${type}${length}>,sampler,float3 location,float Bias)`,
>+        // `native ${type}${length} SampleGrad(Texture2D<${type}${length}>,sampler,float2 location,float2 DDX,float2 DDY)`,
>+        // `native ${type}${length} SampleGrad(Texture2D<${type}${length}>,sampler,float2 location,float2 DDX,float2 DDY,int2 offset)`,
>+        // `native ${type}${length} SampleGrad(Texture2DArray<${type}${length}>,sampler,float3 location,float2 DDX,float2 DDY)`,
>+        // `native ${type}${length} SampleGrad(Texture2DArray<${type}${length}>,sampler,float3 location,float2 DDX,float2 DDY,int2 offset)`,
>+        // `native ${type}${length} SampleGrad(TextureCube<${type}${length}>,sampler,float3 location,float3 DDX,float3 DDY)`,
>+        // `native ${type}${length} SampleLevel(Texture2D<${type}${length}>,sampler,float2 location,float LOD)`,
>+        // `native ${type}${length} SampleLevel(Texture2D<${type}${length}>,sampler,float2 location,float LOD,int2 offset)`,
>+        // `native ${type}${length} SampleLevel(Texture2DArray<${type}${length}>,sampler,float3 location,float LOD)`,
>+        // `native ${type}${length} SampleLevel(Texture2DArray<${type}${length}>,sampler,float3 location,float LOD,int2 offset)`,
>+        // `native ${type}${length} SampleLevel(TextureCube<${type}${length}>,sampler,float3 location,float LOD)`,
>+        // `native ${type}4 Gather(Texture2D<${type}${length}>,sampler,float2 location)`,
>+        // `native ${type}4 Gather(Texture2D<${type}${length}>,sampler,float2 location,int2 offset)`,
>+        // `native ${type}4 Gather(Texture2DArray<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}4 Gather(Texture2DArray<${type}${length}>,sampler,float3 location,int2 offset)`,
>+        // `native ${type}4 Gather(TextureCube<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}4 Gather(TextureDepth2D<${type}>,sampler,float2 location)`,
>+        // `native ${type}4 Gather(TextureDepth2D<${type}>,sampler,float2 location,int2 offset)`,
>+        // `native ${type}4 Gather(TextureDepth2DArray<${type}>,sampler,float3 location)`,
>+        // `native ${type}4 Gather(TextureDepth2DArray<${type}>,sampler,float3 location,int2 offset)`,
>+        // `native ${type}4 Gather(TextureDepthCube<${type}>,sampler,float3 location)`,
>+        // `native ${type}4 GatherAlpha(Texture2D<${type}${length}>,sampler,float2 location)`,
>+        // `native ${type}4 GatherAlpha(Texture2D<${type}${length}>,sampler,float2 location,int2 offset)`,
>+        // `native ${type}4 GatherAlpha(Texture2DArray<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}4 GatherAlpha(Texture2DArray<${type}${length}>,sampler,float3 location,int2 offset)`,
>+        // `native ${type}4 GatherAlpha(TextureCube<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}4 GatherBlue(Texture2D<${type}${length}>,sampler,float2 location)`,
>+        // `native ${type}4 GatherBlue(Texture2D<${type}${length}>,sampler,float2 location,int2 offset)`,
>+        // `native ${type}4 GatherBlue(Texture2DArray<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}4 GatherBlue(Texture2DArray<${type}${length}>,sampler,float3 location,int2 offset)`,
>+        // `native ${type}4 GatherBlue(TextureCube<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}4 GatherCmp(TextureDepth2D<${type}>,sampler,float2 location,float compare_value)`,
>+        // `native ${type}4 GatherCmp(TextureDepth2D<${type}>,sampler,float2 location,float compare_value,int2 offset)`,
>+        // `native ${type}4 GatherCmp(TextureDepth2DArray<${type}>,sampler,float3 location,float compare_value)`,
>+        // `native ${type}4 GatherCmp(TextureDepth2DArray<${type}>,sampler,float3 location,float compare_value,int2 offset)`,
>+        // `native ${type}4 GatherCmp(TextureDepthCube<${type}>,sampler,float3 location,float compare_value)`,
>+        // `native ${type}4 GatherCmpRed(TextureDepth2D<${type}>,sampler,float2 location,float compare_value)`,
>+        // `native ${type}4 GatherCmpRed(TextureDepth2D<${type}>,sampler,float2 location,float compare_value,int2 offset)`,
>+        // `native ${type}4 GatherCmpRed(TextureDepth2DArray<${type}>,sampler,float3 location,float compare_value)`,
>+        // `native ${type}4 GatherCmpRed(TextureDepth2DArray<${type}>,sampler,float3 location,float compare_value,int2 offset)`,
>+        // `native ${type}4 GatherCmpRed(TextureDepthCube<${type}>,sampler,float3 location,float compare_value)`,
>+        // `native ${type}4 GatherGreen(Texture2D<${type}${length}>,sampler,float2 location)`,
>+        // `native ${type}4 GatherGreen(Texture2D<${type}${length}>,sampler,float2 location,int2 offset)`,
>+        // `native ${type}4 GatherGreen(Texture2DArray<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}4 GatherGreen(Texture2DArray<${type}${length}>,sampler,float3 location,int2 offset)`,
>+        // `native ${type}4 GatherGreen(TextureCube<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}4 GatherRed(Texture2D<${type}${length}>,sampler,float2 location)`,
>+        // `native ${type}4 GatherRed(Texture2D<${type}${length}>,sampler,float2 location,int2 offset)`,
>+        // `native ${type}4 GatherRed(Texture2DArray<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}4 GatherRed(Texture2DArray<${type}${length}>,sampler,float3 location,int2 offset)`,
>+        // `native ${type}4 GatherRed(TextureCube<${type}${length}>,sampler,float3 location)`,
>+        // `native ${type}4 GatherRed(TextureDepth2D<${type}>,sampler,float2 location)`,
>+        // `native ${type}4 GatherRed(TextureDepth2D<${type}>,sampler,float2 location,int2 offset)`,
>+        // `native ${type}4 GatherRed(TextureDepth2DArray<${type}>,sampler,float3 location)`,
>+        // `native ${type}4 GatherRed(TextureDepth2DArray<${type}>,sampler,float3 location,int2 offset)`,
>+        // `native ${type}4 GatherRed(TextureDepthCube<${type}>,sampler,float3 location)`,
>+        // `native bool operator<(${primitiveType},${primitiveType})`,
>+        // `native bool operator<=(${primitiveType},${primitiveType})`,
>+        // `native bool operator==(${primitiveType},${primitiveType})`,
>+        // `native bool operator>(${primitiveType},${primitiveType})`,
>+        // `native bool operator>=(${primitiveType},${primitiveType})`,
>+        // `native operator char(${primitiveType})`,
>+        // `native operator float(${primitiveType})`,
>+        // `native operator half(${primitiveType})`,
>+        // `native operator int(${primitiveType})`,
>+        // `native operator int(atomic_int)`,
>+        // `native operator short(${primitiveType})`,
>+        // `native operator uchar(${primitiveType})`,
>+        // `native operator uint(${primitiveType})`,
>+        // `native operator uint(atomic_uint)`,
>+        // `native operator ushort(${primitiveType})`,
>+        // `native typedef ${textureType}<${typeArgument}${i}>`,
>+        // `native typedef ${textureType}<${typeArgument}>`,
>+        // `native void GetDimensions(RWTexture1D<${type}${length}>,float* thread Width)`,
>+        // `native void GetDimensions(RWTexture1D<${type}${length}>,uint* thread Width)`,
>+        // `native void GetDimensions(RWTexture1DArray<${type}${length}>,float* thread Width,uint* thread Elements)`,
>+        // `native void GetDimensions(RWTexture1DArray<${type}${length}>,uint* thread Width,uint* thread Elements)`,
>+        // `native void GetDimensions(RWTexture2D<${type}${length}>,float* thread Width,float* thread Height)`,
>+        // `native void GetDimensions(RWTexture2D<${type}${length}>,uint* thread Width,uint* thread Height)`,
>+        // `native void GetDimensions(RWTexture2DArray<${type}${length}>,float* thread Width,float* thread Height,float* thread Elements)`,
>+        // `native void GetDimensions(RWTexture2DArray<${type}${length}>,uint* thread Width,uint* thread Height,uint* thread Elements)`,
>+        // `native void GetDimensions(RWTexture3D<${type}${length}>,float* thread Width,float* thread Height,float* thread Depth)`,
>+        // `native void GetDimensions(RWTexture3D<${type}${length}>,uint* thread Width,uint* thread Height,uint* thread Depth)`,
>+        // `native void GetDimensions(RWTextureDepth2D<${type}>,float* thread Width,float* thread Height)`,
>+        // `native void GetDimensions(RWTextureDepth2D<${type}>,uint* thread Width,uint* thread Height)`,
>+        // `native void GetDimensions(RWTextureDepth2DArray<${type}>,float* thread Width,float* thread Height,float* thread Elements)`,
>+        // `native void GetDimensions(RWTextureDepth2DArray<${type}>,uint* thread Width,uint* thread Height,uint* thread Elements)`,
>+        // `native void GetDimensions(Texture1D<${type}${length}>,uint MipLevel,uint* thread Width,uint* thread NumberOfLevels)`,
>+        // `native void GetDimensions(Texture1DArray<${type}${length}>,uint MipLevel,uint* thread Width,uint* thread Elements,uint* thread NumberOfLevels)`,
>+        // `native void GetDimensions(Texture2D<${type}${length}>,uint MipLevel,uint* thread Width,uint* thread Height,uint* thread NumberOfLevels)`,
>+        // `native void GetDimensions(Texture2DArray<${type}${length}>,uint MipLevel,uint* thread Width,uint* thread Height,uint* thread Elements,uint* thread NumberOfLevels)`,
>+        // `native void GetDimensions(Texture3D<${type}${length}>,uint MipLevel,uint* thread Width,uint* thread Height,uint* thread Depth,uint* thread NumberOfLevels)`,
>+        // `native void GetDimensions(TextureCube<${type}${length}>,uint MipLevel,uint* thread Width,uint* thread Height,uint* thread NumberOfLevels)`,
>+        // `native void GetDimensions(TextureDepth2D<${type}>,uint MipLevel,uint* thread Width,uint* thread Height,uint* thread NumberOfLevels)`,
>+        // `native void GetDimensions(TextureDepth2DArray<${type}>,uint MipLevel,uint* thread Width,uint* thread Height,uint* thread Elements,uint* thread NumberOfLevels)`,
>+        // `native void GetDimensions(TextureDepthCube<${type}>,uint MipLevel,uint* thread Width,uint* thread Height,uint* thread NumberOfLevels)`,
>+        // `native void Store(RWTexture1D<${type}${length}>,${type}${length},uint location)`,
>+        // `native void Store(RWTexture1DArray<${type}${length}>,${type}${length},uint2 location)`,
>+        // `native void Store(RWTexture2D<${type}${length}>,${type}${length},uint2 location)`,
>+        // `native void Store(RWTexture2DArray<${type}${length}>,${type}${length},uint3 location)`,
>+        // `native void Store(RWTexture3D<${type}${length}>,${type}${length},uint3 location)`,
>+        // `native void Store(RWTextureDepth2D<${type}>,${type},uint2 location)`,
>+        // `native void Store(RWTextureDepth2DArray<${type}>,${type},uint3 location)`
>+    };
>+    
>+    if (key in functionsWithTheSameCallingConvention) {
>+        const callString = `${functionsWithTheSameCallingConvention[key]}(${args.join(", ")})`;
>+        if (resultVariable)
>+            return `${resultVariable} = ${callString};`;
>+        else
>+            return `${callString};`;
>+    }
>+    
>+    const functionsWithDifferentCallingConventions = {};
>+    
>+    if (key in functionsWithDifferentCallingConventions)
>+        return functionsWithDifferentCallingConventions[key]();
>+    
>+    throw new Error(`${node} doesn't have mapping to a native Metal function.`);
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/MSLStatementEmitter.js b/Tools/WebGPUShadingLanguageRI/Metal/MSLStatementEmitter.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..2a1a2315528d232c32ec16b59b88f107280acb85
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/MSLStatementEmitter.js
>@@ -0,0 +1,927 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+class MSLStatementEmitter extends Visitor {
>+
>+    constructor(funcMangler, typeNamer, func, paramMap, debugName, lineNos, typeAttributes, resultVar = null, counter = null, ancestorReturnType = null)
>+    {
>+        super();
>+        this._funcMangler = funcMangler;
>+        this._typeNamer = typeNamer;
>+        this._func = func;
>+        this._nameMap = paramMap;
>+        this._nameMapStack = [];
>+        this._debugName = debugName;
>+        this._lineNumbers = lineNos;
>+        this._typeAttributes = typeAttributes;
>+        this._resultVar = resultVar;
>+        this._counter = counter ? counter : new Counter("V");
>+        this._indentLevel = 0;
>+        this._lines = [];
>+        this._ancestorReturnType = ancestorReturnType ? ancestorReturnType : func.returnType;
>+
>+        this._loopConditionVariableStack = [];
>+        this._loopConditionNodeStack = [];
>+        this._loopIncrementNodeStack = [];
>+
>+        this._actualResult = Node.visit(this._func, this);
>+    }
>+
>+    get ancestorReturnType()
>+    {
>+        return this._ancestorReturnType;
>+    }
>+
>+    _emitReturnZeroValue()
>+    {
>+        if (this.ancestorReturnType.name === "void")
>+            this._add(`return;`);
>+        else {
>+            const resultVar = this._fresh();
>+            this._add(metalSourceForVarDeclaration(this._typeNamer, this.ancestorReturnType, resultVar) + ";");
>+            this._zeroInitialize(this.ancestorReturnType, resultVar);
>+            this._add(`return ${resultVar};`);
>+        }
>+    }
>+
>+    _zeroInitialize(type, variableName, allowComment = true)
>+    {
>+        const emitter = this;
>+
>+        class ZeroInitializer extends Visitor {
>+            visitNativeType(node)
>+            {
>+                if (node.name == "bool")
>+                    emitter._add(`${variableName} = false;`);
>+                else
>+                    emitter._add(`${variableName} = 0;`);
>+            }
>+
>+            visitPtrType(node)
>+            {
>+                emitter._add(`${variableName} = nullptr;`);
>+            }
>+
>+            visitArrayType(node)
>+            {
>+                for (let i = 0; i < node.numElements.value; i++)
>+                    emitter._zeroInitialize(node.elementType, `${variableName}[${i}]`, false);
>+            }
>+
>+            visitArrayRefType(node)
>+            {
>+                emitter._add(`${variableName}.ptr = nullptr;`);
>+                emitter._add(`${variableName}.length = 0;`);
>+            }
>+
>+            visitEnumType(node)
>+            {
>+                emitter._zeroInitialize(node.baseType, variableName, false);
>+            }
>+
>+            visitStructType(node)
>+            {
>+                const typeAttributes = emitter._typeAttributes.attributesForType(node);
>+
>+                for (let field of node.fields) {
>+                    const fieldName = typeAttributes.mangledFieldName(field.name);
>+                    emitter._zeroInitialize(field.type, `${variableName}.${fieldName}`, false);
>+                }
>+            }
>+
>+            visitVectorType(node)
>+            {
>+                const elementNames = [ "x", "y", "z", "w" ];
>+                for (let i = 0; i < node.numElementsValue; i++)
>+                    emitter._add(`${variableName}.${elementNames[i]} = 0;`);
>+            }
>+
>+            visitMatrixType(node)
>+            {
>+                for (let i = 0; i < node.numRowsValue; i++) {
>+                    for (let j = 0; j < node.numRowsValue; j++) {
>+                        emitter._zeroInitialize(node.elementType, `${variableName}[${i}][${j}]`, false);
>+                    }
>+                }
>+            }
>+
>+            visitTypeRef(node)
>+            {
>+                node.type.visit(this);
>+            }
>+        }
>+        if (allowComment)
>+            this._add(`// Zero initialization of ${variableName}`);
>+        Node.visit(type, new ZeroInitializer());
>+    }
>+
>+    get actualResult()
>+    {
>+        return this._actualResult;
>+    }
>+
>+    get lines()
>+    {
>+        return this._lines;
>+    }
>+
>+    indentedSource()
>+    {
>+        return this._lines.map(line => "    " + line + "\n").join("");
>+    }
>+
>+    get _loopConditionVariable()
>+    {
>+        return this._loopConditionVariableStack[this._loopConditionVariableStack.length - 1];
>+    }
>+
>+    get _loopCondition()
>+    {
>+        return this._loopConditionNodeStack[this._loopConditionNodeStack.length - 1];
>+    }
>+
>+    get _loopIncrement()
>+    {
>+        return this._loopIncrementNodeStack[this._loopIncrementNodeStack.length - 1];
>+    }
>+
>+    _add(linesString)
>+    {
>+        for (let line of linesString.split('\n')) {
>+            for (let i = 0; i < this._indentLevel; i++)
>+                line = "    " + line;
>+            this._lines.push(line);
>+        }
>+    }
>+
>+    _addLines(lines)
>+    {
>+        for (let line of lines)
>+            this._add(line);
>+    }
>+
>+    _fresh()
>+    {
>+        return this._counter.fresh();
>+    }
>+
>+    _indent()
>+    {
>+        this._indentLevel++;
>+    }
>+
>+    _unindent()
>+    {
>+        this._indentLevel--;
>+    }
>+
>+    // Atomic statements.
>+
>+    visitBreak(node)
>+    {
>+        this._add("break;")
>+    }
>+
>+    visitContinue(node)
>+    {
>+        // This is necessary because for loops are compiled as while loops, so we need to do
>+        // the loop increment and condition check before returning to the beginning of the loop.
>+        this._emitLoopBodyEnd();
>+        this._add("continue;");
>+    }
>+
>+    // Basic compound statements.
>+
>+    visitBlock(block)
>+    {
>+        this._nameMapStack.push(this._nameMap);
>+        this._nameMap = new Map(this._nameMap);
>+        for (let stmt of block.statements) {
>+            if (stmt.origin && stmt.origin.index && this._lineNumbers && this._lineNumbers[stmt.origin.index])
>+                this._add(`// ${this._debugName} @ line ${this._lineNumbers[stmt.origin.index]}`);
>+            Node.visit(stmt, this);
>+        }
>+        this._nameMap = this._nameMapStack.pop();
>+    }
>+
>+    visitReturn(node)
>+    {
>+        let expr = node.value.visit(this);
>+        if (this._resultVar)
>+            this._add(`${this._resultVar} = ${expr};`);
>+        else
>+            this._add(`return ${expr};`);
>+    }
>+
>+    _inScope(emitBraces = false, emitBlockClosure)
>+    {
>+        if (emitBraces)
>+            this._add("{");
>+        this._indent();
>+
>+        this._nameMapStack.push(this._nameMap);
>+        this._nameMap = new Map(this._nameMap);
>+
>+        const res = emitBlockClosure();
>+
>+        this._nameMap = this._nameMapStack.pop();
>+        if (emitBraces)
>+            this._add("}");
>+
>+        this._unindent();
>+
>+        return res;
>+    }
>+
>+    _emitScoped(node, emitBraces = false)
>+    {
>+        if (!node)
>+            throw new Error(`Can't emit scoped null node`);
>+
>+        return this._inScope(emitBraces, () => Node.visit(node, this));
>+    }
>+
>+    visitIfStatement(node)
>+    {
>+        let condition = node.conditional.visit(this);
>+        this._add(`if (${condition}) {`);
>+        this._emitScoped(node.body);
>+        // At the moment the parser emits Block nodes for the if and else bodies, so this allows us
>+        // to check whether or not the else body is actually empty, and therefore doesn't need to be emitted.
>+        // (This isn't necessary, it just yields shorter, easier to read output).
>+        const shouldEmitElseBody = node.elseBody && (!(node.elseBody instanceof Block) || node.elseBody.statements.length);
>+        if (shouldEmitElseBody) {
>+            this._add(`} else {`);
>+            this._emitScoped(node.elseBody);
>+            this._add('}');
>+        } else
>+            this._add('}');
>+    }
>+
>+    visitIdentityExpression(node)
>+    {
>+        return node.target.visit(this);
>+    }
>+
>+    visitLogicalNot(node)
>+    {
>+        const type = typeOf(node);
>+        if (type) {
>+            let expr = Node.visit(node.operand, this);
>+            let id = this._fresh();
>+            this._add(metalSourceForVarDeclaration(this._typeNamer, type, id) + ";");
>+            this._add(`${id} = !(${expr});`);
>+            return id;
>+        } else
>+            throw new Error(`Couldn't determine type of ! expression ${node}'`);
>+    }
>+
>+    visitDereferenceExpression(node)
>+    {
>+        // An assignment such as someStruct.field = someValue is parsed as
>+        // *((&someStruct)->value) = someValue
>+        if (this._canAvoidDereferenceBecauseDereferencingReferenceNode(node.ptr))
>+            return this._doNotProduceReferenceFromReferenceNode(node.ptr);
>+        else
>+            return `(*(${node.ptr.visit(this)}))`;
>+    }
>+
>+    _canAvoidDereferenceBecauseDereferencingReferenceNode(node)
>+    {
>+        const emitter = this;
>+
>+        class PossibleRefVisitor extends Visitor {
>+            visitMakePtrExpression(node) { return true; }
>+
>+            visitCallExpression(node)
>+            {
>+                return emitter._isOperatorAnder(node.func) || emitter._isOperatorIndexer(node.func);
>+            }
>+        }
>+
>+        // To avoid returning undefined/issues with functions not being defined.
>+        return Node.visit(node, new PossibleRefVisitor()) ? true : false;
>+    }
>+
>+    _isOperatorAnder(node)
>+    {
>+        const anderRegex = /^operator\&\.(.*?)$/;
>+        return node instanceof NativeFunc && anderRegex.test(node.name);
>+    }
>+
>+    _isOperatorGetter(node)
>+    {
>+        const getterRegex = /^operator\.(.*?)$/;
>+        return node instanceof NativeFunc && getterRegex.test(node.name);
>+    }
>+
>+    _isOperatorIndexer(node)
>+    {
>+        return node instanceof NativeFunc && node.name == "operator&[]";
>+    }
>+
>+    _isOperatorSetter(node)
>+    {
>+        const setterRegex = /^operator\.(.*?)=$/;
>+        return node instanceof NativeFunc && setterRegex.test(node.name)
>+    }
>+
>+    _isOperatorCast(node)
>+    {
>+        return node instanceof NativeFunc && node.name == "operator cast";
>+    }
>+
>+    _isUnaryOperator(node)
>+    {
>+        const operatorRegex = /^operator\~$/;
>+        return node instanceof NativeFunc && operatorRegex.test(node.name);
>+    }
>+
>+    _isBinaryOperator(node)
>+    {
>+        const operatorRegex = /operator(\+|\-|\*|\/|\^|\&|\||\&\&|\|\||\<\<|\>\>|\<|\<\=|\>|\>\=|\=\=|\!\=)$/;
>+        return node instanceof NativeFunc && operatorRegex.test(node.name);
>+    }
>+
>+    _isOperatorValue(node)
>+    {
>+        return node instanceof NativeFunc && node.name == "operator.value";
>+    }
>+
>+    _isOperatorLength(node)
>+    {
>+        return node instanceof NativeFunc && node.name == "operator.length";
>+    }
>+
>+    _extractOperatorName(node)
>+    {
>+        return node.name.substring("operator".length);
>+    }
>+
>+    _doNotProduceReferenceFromReferenceNode(node)
>+    {
>+        const emitter = this;
>+
>+        class DefiniteRefVisitor extends Visitor {
>+
>+            visitMakePtrExpression(node)
>+            {
>+                return Node.visit(node.lValue, emitter);
>+            }
>+
>+            visitCallExpression(node)
>+            {
>+                const anderRegex = /^operator\&\.(.*?)$/;
>+                if (anderRegex.test(node.func.name))
>+                    return emitter._handleFieldAccess(node.func.implementationData, node.argumentList[0]);
>+                else if (node.func.name === "operator&[]")
>+                    return emitter._handleIndexAccess(node);
>+            }
>+        }
>+
>+        return Node.visit(node, new DefiniteRefVisitor());
>+    }
>+
>+    visitVariableDecl(node)
>+    {
>+        let id = this._fresh();
>+        this._nameMap.set(node.name, id);
>+
>+        this._add(`${metalSourceForVarDeclaration(this._typeNamer, node.type, id)}; // ${node.name}`);
>+
>+        if (node.initializer) {
>+            let expr = node.initializer.visit(this);
>+            this._add(`${id} = ${expr};`);
>+        } else
>+            this._zeroInitialize(node.type, id);
>+    }
>+
>+    visitVariableRef(node)
>+    {
>+        if (node.variable instanceof AnonymousVariable)
>+            return Node.visit(node.variable, this);
>+        let name = node.name;
>+        if (!this._nameMap.has(name))
>+            throw new Error(`${node.name} not found in this function's variable map`);
>+        return this._nameMap.get(name);
>+    }
>+
>+    visitMakeArrayRefExpression(node)
>+    {
>+        const elemName = Node.visit(node.lValue, this);
>+        const arrayType = typeOf(node.lValue);
>+        const id = this._fresh();
>+        this._add(metalSourceForVarDeclaration(this._typeNamer, node.type, id) + ";");
>+        this._add(`${id}.length = ${node.numElements.value};`);
>+        if (arrayType.isArray)
>+            this._add(`${id}.ptr = ${elemName};`);
>+        else
>+            this._add(`${id}.ptr = &(${elemName});`);
>+        return id;
>+    }
>+
>+    visitConvertPtrToArrayRefExpression(node)
>+    {
>+        const lValue = node.lValue.visit(this);
>+        const type = typeOf(node);
>+        const id = this._fresh();
>+        this._add(metalSourceForVarDeclaration(this._typeNamer, type, id) + ";");
>+        this._add(`${id}.length = 1;`);
>+        this._add(`${id}.ptr = ${lValue};`);
>+        return id;
>+    }
>+
>+    visitAnonymousVariable(node)
>+    {
>+        // Anonymous variable names are of the form anonVar<i> (where i is an integer), i.e.
>+        // the set of anonymous variable names is disjoint from the set of definable variable names.
>+        if (!this._nameMap.has(node.name)) {
>+            let id = this._fresh();
>+            this._nameMap.set(node.name, id);
>+            this._add(metalSourceForVarDeclaration(this._typeNamer, node.type, id) + `; // ${node.name}`);
>+            this._zeroInitialize(node.type, id);
>+            return id;
>+        } else
>+            return this._nameMap.get(node.name);
>+    }
>+
>+    visitAssignment(node)
>+    {
>+        const lhs = Node.visit(node.lhs, this);
>+        const rhs = Node.visit(node.rhs, this);
>+        this._add(`${lhs} = ${rhs};`);
>+        return rhs;
>+    }
>+
>+    visitCommaExpression(node)
>+    {
>+        let result;
>+        for (let expr of node.list)
>+            result = Node.visit(expr, this);
>+        return result;
>+    }
>+
>+    visitCallExpression(node)
>+    {
>+        const args = [];
>+        for (let i = node.argumentList.length; i--;)
>+            args.unshift(node.argumentList[i].visit(this));
>+
>+        let resultVariable;
>+        if (node.func.returnType.name !== "void") {
>+            resultVariable = this._fresh();
>+            this._add(`// Result variable for call ${node.func.name}(${args.join(", ")})`);
>+            this._add(`${metalSourceForVarDeclaration(this._typeNamer, node.resultType, resultVariable)};`);
>+        }
>+
>+        if (node.func instanceof FuncDef) {
>+            const mangledCallName = this._funcMangler.mangle(node.func);
>+            const callString = `${mangledCallName}(${args.join(", ")})`;
>+            if (resultVariable)
>+                this._add(`${resultVariable} = ${callString};`);
>+            else
>+                this_add(`${callString};`);
>+        } else
>+            this._makeNativeFunctionCall(node.func, resultVariable, args);
>+
>+        return resultVariable;
>+    }
>+
>+    _makeNativeFunctionCall(node, resultVariable, args)
>+    {
>+        if (!(node instanceof NativeFunc))
>+            throw new Error(`${node} should be a native function.`);
>+
>+        // FIXME: Tidy this up!
>+
>+        if (this._isOperatorAnder(node))
>+            this._emitOperatorAnder(node, resultVariable, args);
>+        else if (node.implementationData instanceof BuiltinVectorGetter)
>+            this._emitBuiltinVectorGetter(node, resultVariable, args);
>+        else if (node.implementationData instanceof BuiltinVectorSetter)
>+            this._emitBuiltinVectorSetter(node, resultVariable, args);
>+        else if (node.implementationData instanceof BuiltinMatrixGetter)
>+            this._emitBuiltinMatrixGetter(node, resultVariable, args);
>+        else if (node.implementationData instanceof BuiltinMatrixSetter)
>+            this._emitBuiltinMatrixSetter(node, resultVariable, args);
>+        else if (this._isOperatorValue(node))
>+            this._add(`${result} = ${args[0]};`);
>+        else if (this._isOperatorLength(node))
>+            this._emitOperatorLength(node, resultVariable, args);
>+        else if (this._isOperatorSetter(node))
>+            this._emitOperatorSetter(node, resultVariable, args);
>+        else if (this._isOperatorGetter(node))
>+            this._emitOperatorGetter(node, resultVariable, args);
>+        else if (this._isOperatorIndexer(node))
>+            this._emitOperatorIndexer(node, resultVariable, args);
>+        else if (this._isOperatorCast(node))
>+            this._emitOperatorCast(node, resultVariable, args);
>+        else if (this._isUnaryOperator(node))
>+            this._add(`${result} = ${this._extractOperatorName(node)}(${args[0]});`);
>+        else if (this._isBinaryOperator(node))
>+            this._add(`${result} = ${args[0]} ${this._extractOperatorName(node)} ${args[1]};`);
>+        else
>+            this._add(mslNativeFunctionCall(node, resultVariable, args));
>+
>+        return resultVariable;
>+    }
>+
>+    _emitCallToMetalFunction(name, result, args)
>+    {
>+        this._add(`${result} = ${name}(${args.join(", ")});`);
>+    }
>+
>+    _emitBuiltinVectorGetter(node, result, args)
>+    {
>+        this._add(`${result} = ${args[0]}.${node.implementationData.elementName};`);
>+    }
>+
>+    _emitBuiltinVectorSetter(node, result, args)
>+    {
>+        this._add(`${result} = ${args[0]};`);
>+        this._add(`${result}.${node.implementationData.elementName} = ${args[1]};`);
>+    }
>+
>+    _emitBuiltinMatrixGetter(node, result, args)
>+    {
>+        this._add(`if (${args[1]} < 0 || ${args[1]} >= ${node.implementationData.height}) {`);
>+        this._indent();
>+        this._emitReturnZeroValue();
>+        this._unindent();
>+        this._add('}');
>+        this._add(`${result} = ${args[0]}[${args[1]}];`);
>+    }
>+
>+    _emitBuiltinMatrixSetter(node, result, args)
>+    {
>+        this._add(`if (${args[1]} < 0 || ${args[1]} >= ${node.implementationData.height}) {`);
>+        this._indent();
>+        this._emitReturnZeroValue();
>+        this._unindent();
>+        this._add('}');
>+        this._add(`${result} = ${args[0]};`);
>+        this._add(`${result}[${args[1]}] = ${args[2]};`);
>+    }
>+
>+    _emitOperatorLength(node, result, args)
>+    {
>+        const paramType = typeOf(node.parameters[0]);
>+        if (paramType instanceof ArrayRefType)
>+            this._add(`${result} = ${args[0]}.length;`);
>+        else if (paramType instanceof ArrayType)
>+            this._add(`${result} = ${paramType.numElements.visit(this)};`);
>+        else
>+            throw new Error(`Unhandled paramter type ${paramType} for operator.length`);
>+    }
>+
>+    _emitOperatorCast(node, result, args)
>+    {
>+        const retType = this._typeNamer.mslTypeName(node.returnType);
>+        this._add(`${result} = ${retType}(${args.join(", ")});`);
>+    }
>+
>+    _emitOperatorIndexer(node, result, args)
>+    {
>+        if (!(typeOf(node.parameters[0]) instanceof ArrayRefType))
>+            throw new Error(`Support for operator&[] ${node.parameters[0]} not implemented.`);
>+
>+        this._add(`if (${args[1]} >= ${args[0]}.length) {`);
>+        this._indent();
>+        this._emitReturnZeroValue();
>+        this._unindent();
>+        this._add(`}`);
>+        this._add(`${result} = (${this._typeNamer.mslTypeName(node.returnType)})&(${args[0]}.ptr[${args[1]}]);`);
>+    }
>+
>+    _handleFieldAccess(implementationData, arg)
>+    {
>+        const type = implementationData.type;
>+        const field = this._typeAttributes.attributesForType(type).mangledFieldName(implementationData.name);
>+
>+        if (arg instanceof MakePtrExpression) {
>+            const argId = Node.visit(arg.lValue, this);
>+            if (arg.lValue && arg.lValue instanceof VariableRef)
>+                return `${argId}.${field}`;
>+            else
>+                return `(${argId}).${field}`;
>+        } else
>+            return `${arg.visit(this)}->${field}`;
>+    }
>+
>+    _emitOperatorAnder(node, result, args)
>+    {
>+        const type = node.implementationData.type;
>+        const field = this._typeAttributes.attributesForType(type).mangledFieldName(node.implementationData.name);
>+        this._add(`${result} = (${this._typeNamer.mslTypeName(node.returnType)})&((${args[0]})->${field});`);
>+    }
>+
>+    _emitOperatorGetter(node, result, args)
>+    {
>+        const type = node.implementationData.type;
>+        const field = this._typeAttributes.attributesForType(type).mangledFieldName(node.implementationData.name);
>+        this._add(`${result} = ${args[0]}.${field};`);
>+    }
>+
>+    _emitOperatorSetter(node, result, args)
>+    {
>+        // FIXME: Currently no WHLSL source produces structs that only have getters/setters rather than the ander,
>+        // and the ander is always preferred over the getter and setter.
>+        const type = node.implementationData.type;
>+        const field = this._typeAttributes.attributesForType(type).mangledFieldName(node.implementationData.name);
>+        this._add(`${args[0]}.${field} = ${args[1]};`);
>+        this._add(`${result} = ${args[0]}`);
>+    }
>+
>+    _handleIndexAccess(node)
>+    {
>+        const array = node.argumentList[0];
>+        const index = node.argumentList[1];
>+
>+        // FIXME: Avoid so much special casing.
>+
>+        if (array instanceof MakeArrayRefExpression) {
>+            if (index.isLiteral) {
>+                // Type checking will hopefully have already ensured this...
>+                if (index.value >= 0 && index.value < array.numElements.value) {
>+                    const variable = Node.visit(array.lValue, this);
>+                    return `${variable}[${index.value}]`;
>+                } else
>+                    throw new Error(`Index out of bounds in ${node}`);
>+            } else {
>+                // TODO: It would be interesting to see what kind of BCE could be done here.
>+                // Index checks aren't necessary for values < 0 because the type checker will
>+                // have already ensured that the index value type is an unsigned integer.
>+                const variable = Node.visit(array.lValue, this);
>+                const indexId = Node.visit(index, this);
>+                this._add(`if (${indexId} >= ${array.numElements.value}) {`);
>+                this._indent();
>+                this._emitReturnZeroValue();
>+                this._unindent();
>+                this._add(`}`);
>+                return `${variable}[${indexId}]`;
>+            }
>+        } else if (typeOf(array) instanceof ArrayRefType) {
>+            const variable = array.visit(this);
>+            const indexId = index.visit(this);
>+            this._add(`if (${indexId} >= ${variable}.length) {`);
>+            this._indent();
>+            this._emitReturnZeroValue();
>+            this._unindent();
>+            this._add('}');
>+            return `${variable}.ptr[${indexId}]`;
>+        } else
>+            this._add(`// TODO: Handle ${array} in MSLStatementEmitter._handleIndexAccess`);
>+    }
>+
>+    visitMakePtrExpression(node)
>+    {
>+        const expr = node.lValue.visit(this);
>+        return `&(${expr})`;
>+    }
>+
>+    // Loop code generation. Loops all follow the same style where they declare a conditional variable (boolean)
>+    // which is checked on each iteration (all loops are compiled to a while loop or do/while loop). The check is
>+    // emitted in _emitLoopCondition. For loops additionally have _emitLoopBodyEnd for the increment on each iteration.
>+
>+    visitForLoop(node)
>+    {
>+        this._emitAsLoop(node.condition, node.increment, (conditionVar) => {
>+            Node.visit(node.initialization, this); // initalization can be null
>+            this._emitLoopCondition();
>+            this._add(`while (${conditionVar}) {`);
>+            this._emitScoped(node.body);
>+            this._emitLoopBodyEnd();
>+            this._add('}');
>+        });
>+    }
>+
>+    visitWhileLoop(node)
>+    {
>+        this._emitAsLoop(node.conditional, null, (conditionVar) => {
>+            this._add(`while (${conditionVar}) {`);
>+            this._emitScoped(node.body);
>+            this._emitLoopCondition();
>+            this._add('}');
>+        });
>+    }
>+
>+    visitDoWhileLoop(node)
>+    {
>+        this._emitAsLoop(node.conditional, null, conditionVar => {
>+            this._add("do {");
>+            this._emitScoped(node.body);
>+            this._emitLoopBodyEnd();
>+            this._add(`} while (${conditionVar});`);
>+        });
>+    }
>+
>+    _emitAsLoop(conditional, increment, emitLoopBody)
>+    {
>+        const conditionVar = this._fresh();
>+        this._loopConditionVariableStack.push(conditionVar);
>+        this._loopConditionNodeStack.push(conditional);
>+        this._loopIncrementNodeStack.push(increment);
>+        this._add(`bool ${conditionVar} = true;`);
>+
>+        emitLoopBody(conditionVar);
>+
>+        this._loopIncrementNodeStack.pop();
>+        this._loopConditionVariableStack.pop();
>+        this._loopConditionNodeStack.pop();
>+    }
>+
>+    _emitLoopBodyEnd()
>+    {
>+        this._emitLoopIncrement();
>+        this._emitLoopCondition();
>+    }
>+
>+    _emitLoopIncrement()
>+    {
>+        if (this._loopIncrement)
>+            this._emitScoped(this._loopIncrement);
>+    }
>+
>+    _emitLoopCondition()
>+    {
>+        if (this._loopCondition) {
>+            const conditionResult = this._emitScoped(this._loopCondition);
>+            this._add(`${this._loopConditionVariable} = ${conditionResult};`);
>+        }
>+    }
>+
>+    // Switch statements.
>+
>+    visitSwitchStatement(node)
>+    {
>+        const caseValueEmitter = new ConstexprEmitter();
>+
>+        let switchValue = Node.visit(node.value, this);
>+        this._add(`switch (${switchValue}) {`);
>+        this._indent();
>+
>+        for (let i = 0; i < node.switchCases.length; i++) {
>+            let switchCase = node.switchCases[i];
>+            if (!switchCase.isDefault)
>+                this._add(`case ${switchCase.value.visit(caseValueEmitter)}: {`);
>+            else
>+                this._add("default: {");
>+            this._emitScoped(switchCase.body);
>+            this._add("}");
>+        }
>+
>+        this._unindent();
>+        this._add("}");
>+    }
>+
>+    visitSwitchCase(node)
>+    {
>+        throw new Error(`// FIXME: Hit |visitSwitchCase|, should be handled by |visitSwitchStatement|`);
>+    }
>+
>+    // Literals
>+
>+    visitBoolLiteral(node)
>+    {
>+        const fresh = this._fresh();
>+        this._add(`bool ${fresh} = ${node.value};`);
>+        return fresh;
>+    }
>+
>+    visitEnumLiteral(node)
>+    {
>+        return node.member.value.visit(this);
>+    }
>+
>+    visitGenericLiteral(node)
>+    {
>+        const fresh = this._fresh();
>+        this._add(metalSourceForVarDeclaration(this._typeNamer, node.type, fresh) + ";");
>+        this._add(`${fresh} = ${node.value};`);
>+        return fresh;
>+    }
>+
>+    visitNullLiteral(node)
>+    {
>+        return `(nullptr)`;
>+    }
>+
>+    visitDotExpression(node)
>+    {
>+        throw new Error(`Dot expressions ${node} should have been converted to an operator`);
>+    }
>+
>+    visitTrapStatement(node)
>+    {
>+        this._emitReturnZeroValue();
>+    }
>+
>+    visitLogicalExpression(node)
>+    {
>+        const result = this._fresh();
>+        this._add(`// Result variable for ${node.text}`);
>+        this._add(`bool ${result};`);
>+        if (node.text == "&&") {
>+            const left = node.left.visit(this);
>+            this._add(`if (!${left}) {`)
>+            this._indent();
>+            this._add(`${result} = false;`);
>+            this._unindent();
>+            this._add('} else {');
>+            this._indent();
>+            const right = node.right.visit(this);
>+            this._add(`${result} = ${right};`);
>+            this._unindent();
>+            this._add('}');
>+        } else if (node.text == "||") {
>+            const left = node.left.visit(this);
>+            this._add(`${result} = ${left};`);
>+            this._add(`if (!${result}) {`);
>+            this._indent();
>+            const right = node.right.visit(this);
>+            this._add(`${result} = ${right};`);
>+            this._unindent();
>+            this._add("}");
>+        } else
>+            throw new Error(`Unrecognized logical expression ${node.text}`);
>+        return result;
>+    }
>+
>+    visitTernaryExpression(node)
>+    {
>+        // FIXME: If each of the three expressions isn't a compound expression or statement then just user ternary syntax.
>+        let resultType = typeOf(node.bodyExpression);
>+        if (node.isLValue)
>+            resultType = new PtrType(node.origin, "thread", resultType);
>+        let resultVar = this._fresh();
>+        this._add(metalSourceForVarDeclaration(this._typeNamer, resultType, resultVar) + ";");
>+        const predicate = node.predicate.visit(this);
>+        this._add(`if (${predicate}) {`);
>+        this._indent();
>+        const bodyExpression = node.bodyExpression.visit(this);
>+        if (node.isLValue)
>+            this._add(`${resultVar} = &(${bodyExpression});`);
>+        else
>+            this._add(`${resultVar} = ${bodyExpression};`);
>+        this._unindent();
>+        this._add("} else {");
>+        this._indent();
>+        const elseExpression = node.elseExpression.visit(this);
>+        if (node.isLValue)
>+            this._add(`${resultVar} = &(${elseExpression});`);
>+        else
>+            this._add(`${resultVar} = ${elseExpression};`);
>+        this._unindent();
>+        this._add("}");
>+
>+        if (node.isLValue)
>+            resultVar = `*(${resultVar})`;
>+
>+        return resultVar;
>+    }
>+
>+    // Unimplemented methods. I write out comments for these rather than throwing exceptions because it makes it easier for me
>+    // to see where the nodes occur in the abstract syntax tree
>+
>+    visitIndexExpression(node)
>+    {
>+        this._add("// TODO: visitIndexExpression");
>+    }
>+
>+    visitNativeFunc(node)
>+    {
>+        this._add("// TODO: visitNativeFunc");
>+    }
>+
>+    visitNativeTypeInstance(node)
>+    {
>+        this._add("// TODO: visitNativeTypeInstance");
>+    }
>+
>+    visitReadModifyWriteExpression(node)
>+    {
>+        this._add("// TODO: visitReadModifyWriteExpression");
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/MSLTypeNamer.js b/Tools/WebGPUShadingLanguageRI/Metal/MSLTypeNamer.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..99f83c3fb220cd9432e16be95b5c807527ac415a
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/MSLTypeNamer.js
>@@ -0,0 +1,149 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+class MSLTypeNamer {
>+
>+    constructor(typeUnifier)
>+    {
>+        this._typeUnifier = typeUnifier;
>+    }
>+
>+    get typeUnifier() 
>+    {
>+        return this._typeUnifier; 
>+    }
>+    
>+    uniqueTypeId(type) 
>+    { 
>+        return this.typeUnifier.uniqueTypeId(type); 
>+    }
>+    
>+    // Yields the string that should be used in MSL source for the type.
>+    mslTypeName(type)
>+    {
>+        let name;
>+
>+        const typeUnifier = this.typeUnifier;
>+        const typeNamer = this;
>+
>+        class TypeNameVisitor extends Visitor {
>+            visitNativeType(node)
>+            {
>+                const nativeTypeNameMap = {
>+                    "void": "void",
>+                    "bool": "bool",
>+                    "uchar": "uint8_t",
>+                    "ushort": "uint16_t",
>+                    "uint": "uint32_t",
>+                    "char": "int8_t",
>+                    "short": "int16_t",
>+                    "int": "int32_t",
>+                    "half": "half",
>+                    "float": "float",
>+                    "atomic_int": "atomic_int",
>+                    "atomic_uint": "atomic_uint"
>+                };
>+
>+                name = nativeTypeNameMap[node.name];
>+            }
>+
>+            visitStructType(node)
>+            {
>+                name = typeUnifier.uniqueTypeId(node);
>+            }
>+
>+            visitEnumType(node) 
>+            { 
>+                return Node.visit(node.baseType, this); 
>+            }
>+
>+            visitReferenceType(node)
>+            {
>+                name = `${node.addressSpace} ${typeNamer.mslTypeName(node.elementType)}*`;
>+            }
>+
>+            visitArrayType(node)
>+            {
>+                // The address space can be null if the array is nested within another.
>+                name = `${node.addressSpace ? node.addressSpace + " " : ""}${typeNamer.mslTypeName(node.elementType)}*`;
>+            }
>+
>+            visitArrayRefType(node)
>+            {
>+                name = typeUnifier.uniqueTypeId(node);
>+            }
>+
>+            visitVectorType(node)
>+            {
>+                // Vector type names work slightly differently to native type names
>+                const elementTypeNameMap = {
>+                    "bool": "bool",
>+                    "char": "char",
>+                    "uchar": "uchar",
>+                    "short": "short",
>+                    "ushort": "ushort",
>+                    "int": "int",
>+                    "uint": "uint",
>+                    "half": "half",
>+                    "float": "float"
>+                };
>+
>+                const elementTypeName = elementTypeNameMap[node.elementType.name];
>+                if (!elementTypeName)
>+                    throw new Error(`${node.elementType.name} is not a supported vector element type`);
>+
>+                name = `${elementTypeName}${node.numElementsValue}`;
>+            }
>+
>+            visitTypeRef(node)
>+            {
>+                node.type.visit(this);
>+            }
>+
>+            visitMatrixType(node)
>+            {
>+                // Matrix type names work slightly differently to native type names
>+                const elementTypeNameMap = {
>+                    "bool": "bool",
>+                    "half": "half",
>+                    "float": "float"
>+                };
>+
>+                const elementTypeName = elementTypeNameMap[node.elementType.name];
>+                if (!elementTypeName)
>+                    throw new Error(`${node.elementType.name} is not a supported vector element type`);
>+
>+                name = `${elementTypeName}${node.numRowsValue}x${node.numColumnsValue}`;
>+            }
>+        }
>+
>+        type.visit(new TypeNameVisitor());
>+
>+        if (!name)
>+            throw new Error(`${type} doesn't have a name`);
>+
>+        return name;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/MetalCodegen.js b/Tools/WebGPUShadingLanguageRI/Metal/MetalCodegen.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..3ffcdcdba464d46b4e30e5a4cdcdb42f3ba9e3c1
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/MetalCodegen.js
>@@ -0,0 +1,252 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+const DefaultMetalSource = `#include <metal_stdlib>
>+using namespace metal;
>+
>+`;
>+
>+// Handles the compilation of Program AST instances to CompileResult instances, which
>+// include the raw MSL. In general clients should call |whlslToMsl|, which parses,
>+// typechecks, and inlines the WHLSL before passing it to this compiler.
>+class MetalCodegen {
>+
>+    constructor(program, lineNos = null)
>+    {
>+        this._program = program;
>+        this._lineNumbers = lineNos;
>+        this._declarations = [];
>+        this._funcNameMangler = new NameMangler("F");
>+        this._typeUnifier = new TypeUnifier();
>+        this._typeNamer = new MSLTypeNamer(this._typeUnifier);
>+        this._forwardTypeDecls = [];
>+        this._typeDefinitions = [];
>+        this._forwardFunctionDecls = [];
>+        this._functionDefintions = [];
>+    }
>+
>+    get program()
>+    {
>+        return this._program;
>+    }
>+
>+    get declarations()
>+    {
>+        return this._declarations;
>+    }
>+
>+    get functionSources()
>+    {
>+        return this._functionSources;
>+    }
>+
>+    // The main entry point for the compiler, however clients should generally call whlslToMsl,
>+    // which is defined at the bottom of this file.
>+    generateMsl()
>+    {
>+        try {
>+            const src = this._tryGenerateMsl();
>+            const mangledMap = {};
>+            for (let func of this._functionDefintions) {
>+                const key = func.func.name;
>+                const value = this._funcNameMangler.mangle(func.func);
>+                mangledMap[key] = value;
>+            }
>+
>+            return new CompileResult(src, null, mangledMap, this._functionSources);
>+        } catch (e) {
>+            return new CompileResult(null, e, null, null);
>+        }
>+    }
>+
>+    _tryGenerateMsl()
>+    {
>+        // Step 1: Find all the functions to compile
>+
>+        const functionsToCompile = this._findFunctionsToCompile();
>+        for (let func of functionsToCompile)
>+            func.visit(this._typeUnifier);
>+
>+        // Step 2: Find properties of the types and create type and function declarations.
>+
>+        this._allTypeAttributes = new TypeAttributesMap(functionsToCompile, this._typeUnifier);
>+        this._createTypeDecls();
>+        this._createFunctionDecls(functionsToCompile);
>+
>+        // Step 3: Generate the actual MSL source code.
>+
>+        let outputStr = DefaultMetalSource;
>+
>+        const addSection = (title, decls) => {
>+            outputStr += `#pragma mark - ${title}\n\n${decls.join("\n\n")}\n\n`;
>+        };
>+
>+        addSection("Forward type declarations", this._forwardTypeDecls);
>+        addSection("Type definitions", this._typeDefinitions);
>+        addSection("Forward function declarations", this._forwardFunctionDecls);
>+        addSection("Function definitions", this._functionDefintions);
>+
>+        if (!this._allowComments)
>+            outputStr = this._removeCommentsAndEmptyLines(outputStr);
>+
>+        return outputStr;
>+    }
>+
>+    _findFunctionsToCompile()
>+    {
>+        const entryPointFunctions = [];
>+        for (let [name, instances] of this._program.functions) {
>+            for (let instance of instances) {
>+                if (instance.isEntryPoint)
>+                    entryPointFunctions.push(instance);
>+            }
>+        }
>+        const functions = new Set(entryPointFunctions);
>+
>+        class FindFunctionsThatGetCalled extends Visitor {
>+            visitCallExpression(node)
>+            {
>+                super.visitCallExpression(node);
>+                if (node.func instanceof FuncDef) {
>+                    functions.add(node.func);
>+                    node.func.visit(this);
>+                }
>+            }
>+        }
>+        const findFunctionsThatGetCalledVisitor = new FindFunctionsThatGetCalled();
>+        for (let entryPoint of entryPointFunctions)
>+            entryPoint.visit(findFunctionsThatGetCalledVisitor);
>+        return Array.from(functions);
>+    }
>+
>+    _createTypeDecls()
>+    {
>+        const typesThatNeedDeclaration = this._typeUnifier.typesThatNeedDeclaration();
>+        const typeDeclsInOrder = this._sortTypeDeclarationsInTopologicalOrder(typesThatNeedDeclaration);
>+
>+        for (let type of typeDeclsInOrder) {
>+            if (type instanceof StructType) {
>+                this._forwardTypeDecls.push(this._metalSourceForStructForwardDeclaration(type, this._typeNamer));
>+                this._typeDefinitions.push(this._metalSourceForStructDefinition(type, this._typeNamer, this._allTypeAttributes.attributesForType(type)));
>+            } else if (type instanceof ArrayRefType) {
>+                this._forwardTypeDecls.push(this._metalSourceForArrayRefForwardDeclaration(type, this._typeNamer));
>+                this._typeDefinitions.push(this._metalSourceForArrayRefDefinition(type, this._typeNamer));
>+            } else
>+                throw new Error(`${type} cannot be declared in Metal`);
>+        }
>+    }
>+
>+    _createFunctionDecls(unifiedFunctionDefs)
>+    {
>+        for (let func of unifiedFunctionDefs) {
>+            this._forwardFunctionDecls.push(new MSLFunctionForwardDeclaration(this._funcNameMangler, func, this._typeNamer, this._lineNumbers, this._allTypeAttributes));
>+            this._functionDefintions.push(new MSLFunctionDefinition(this._funcNameMangler, func, this._typeNamer, this._lineNumbers, this._allTypeAttributes));
>+        }
>+    }
>+
>+    _sortTypeDeclarationsInTopologicalOrder(typesToDeclare)
>+    {
>+        const declarations = new Array();
>+        for (let type of typesToDeclare)
>+            declarations.push(type);
>+        const typeOrder = sortTypeDeclarations(typesToDeclare, this._typeUnifier);
>+        const typeOrderMap = new Map();
>+        for (let i = 0; i < typeOrder.length; i++)
>+            typeOrderMap.set(typeOrder[i], i);
>+        return declarations.sort((a, b) => typeOrderMap.get(a) - typeOrderMap.get(b));
>+    }
>+
>+    // Also removes #pragma marks.
>+    _removeCommentsAndEmptyLines(src)
>+    {
>+        const singleLineCommentRegex = /(\/\/|\#pragma)(.*?)($|\n)/;
>+        const lines = src.split('\n')
>+            .map(line => line.replace(singleLineCommentRegex, '').trimEnd())
>+            .filter(line => line.length > 0);
>+        return lines.join('\n');
>+    }
>+
>+    _metalSourceForArrayRefDefinition(arrayRefType, typeNamer)
>+    {
>+        let src = `struct ${typeNamer.uniqueTypeId(arrayRefType)} {\n`;
>+        const fakePtrType = new PtrType(arrayRefType.origin, arrayRefType.addressSpace, arrayRefType.elementType);
>+        src += `    ${metalSourceForVarDeclaration(typeNamer, fakePtrType, "ptr")};\n`;
>+        src += "    uint32_t length;\n";
>+        src += "};";
>+        return src;
>+    }
>+
>+    _metalSourceForArrayRefForwardDeclaration(arrayRefType, typeNamer)
>+    {
>+        return `struct ${typeNamer.uniqueTypeId(arrayRefType)};`;
>+    }
>+
>+    _metalSourceForStructForwardDeclaration(structType, typeNamer)
>+    {
>+        return `struct ${typeNamer.uniqueTypeId(structType)};`;
>+    }
>+
>+    _metalSourceForStructDefinition(structType, typeNamer, structTypeAttributes)
>+    {
>+        let src = `struct ${typeNamer.uniqueTypeId(structType)} {\n`;
>+
>+        let index = 0;
>+        for (let [fieldName, field] of structType.fieldMap) {
>+            const mangledFieldName = structTypeAttributes.mangledFieldName(fieldName);
>+            src += `    ${metalSourceForVarDeclaration(typeNamer, field.type, mangledFieldName)}`;
>+
>+            const annotations = [];
>+            if (structTypeAttributes.isVertexAttribute)
>+                annotations.push(`attribute(${index++})`);
>+            if (structTypeAttributes.isVertexOutputOrFragmentInput && fieldName === "wsl_Position")
>+                annotations.push("position");
>+            if (structTypeAttributes.isFragmentOutput && fieldName === "wsl_Color")
>+                annotations.push("color(0)");
>+            if (annotations.length)
>+                src += ` [[${annotations.join(", ")}]]`;
>+            src += ";\n";
>+        }
>+
>+        src += "};";
>+
>+        return src;
>+    }
>+}
>+
>+// Main wrapper for the compiler. Clients should use this function to compile WHLSL.
>+function whlslToMsl(src) {
>+    let parsedProgram;
>+    try {
>+        parsedProgram = prepare("/internal/test", 0, src);
>+    } catch (e) {
>+        return new CompileResult(null, e, null, null);
>+    }
>+
>+    if (!(parsedProgram instanceof Program))
>+        return new CompileResult(null, new Error("Compilation failed"), null, null);
>+
>+    const compiler = new MetalCodegen(parsedProgram, lineNumbers(src));
>+    return compiler.generateMsl();
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/MetalTest.js b/Tools/WebGPUShadingLanguageRI/Metal/MetalTest.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..6c8cda63b46ba337cef964ce13876300363f5c14
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/MetalTest.js
>@@ -0,0 +1,229 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+"use strict";
>+
>+load("../Node.js");
>+load("../Type.js");
>+load("../ReferenceType.js");
>+load("../Value.js");
>+load("../Expression.js");
>+load("../Rewriter.js");
>+load("../Visitor.js");
>+load("../CreateLiteral.js");
>+load("../CreateLiteralType.js");
>+load("../PropertyAccessExpression.js");
>+load("../NativeType.js");
>+
>+load("../AddressSpace.js");
>+load("../AnonymousVariable.js");
>+load("../ArrayRefType.js");
>+load("../ArrayType.js");
>+load("../Assignment.js");
>+load("../AutoWrapper.js");
>+load("../Block.js");
>+load("../BoolLiteral.js");
>+load("../Break.js");
>+load("../BuiltinMatrixGetter.js");
>+load("../BuiltinMatrixSetter.js");
>+load("../BuiltinVectorGetter.js");
>+load("../BuiltinVectorSetter.js");
>+load("../CallExpression.js");
>+load("../CallFunction.js");
>+load("../Casts.js");
>+load("../Check.js");
>+load("../CheckLiteralTypes.js");
>+load("../CheckLoops.js");
>+load("../CheckRecursion.js");
>+load("../CheckRecursiveTypes.js");
>+load("../CheckReturns.js");
>+load("../CheckTypesWithArguments.js");
>+load("../CheckUnreachableCode.js");
>+load("../CheckWrapped.js");
>+load("../Checker.js");
>+load("../CloneProgram.js");
>+load("../CommaExpression.js");
>+load("../ConstexprFolder.js");
>+load("../Continue.js");
>+load("../ConvertPtrToArrayRefExpression.js");
>+load("../DoWhileLoop.js");
>+load("../DotExpression.js");
>+load("../DereferenceExpression.js");
>+load("../EArrayRef.js");
>+load("../EBuffer.js");
>+load("../EBufferBuilder.js");
>+load("../EPtr.js");
>+load("../EnumLiteral.js");
>+load("../EnumMember.js");
>+load("../EnumType.js");
>+load("../EvaluationCommon.js");
>+load("../Evaluator.js");
>+load("../ExpressionFinder.js");
>+load("../ExternalOrigin.js");
>+load("../Field.js");
>+load("../FindHighZombies.js");
>+load("../FlattenedStructOffsetGatherer.js");
>+load("../FloatLiteral.js");
>+load("../FloatLiteralType.js");
>+load("../FoldConstexprs.js");
>+load("../ForLoop.js");
>+load("../Func.js");
>+load("../FuncDef.js");
>+load("../FuncParameter.js");
>+load("../FunctionLikeBlock.js");
>+load("../HighZombieFinder.js");
>+load("../IdentityExpression.js");
>+load("../IfStatement.js");
>+load("../IndexExpression.js");
>+load("../InferTypesForCall.js");
>+load("../Inline.js");
>+load("../Inliner.js");
>+load("../IntLiteral.js");
>+load("../IntLiteralType.js");
>+load("../Intrinsics.js");
>+load("../LateCheckAndLayoutBuffers.js");
>+load("../LateChecker.js");
>+load("../Lexer.js");
>+load("../LexerToken.js");
>+load("../LiteralTypeChecker.js");
>+load("../LogicalExpression.js");
>+load("../LogicalNot.js");
>+load("../LoopChecker.js");
>+load("../MakeArrayRefExpression.js");
>+load("../MakePtrExpression.js");
>+load("../MatrixType.js");
>+load("../NameContext.js");
>+load("../NameFinder.js");
>+load("../NameResolver.js");
>+load("../NativeFunc.js");
>+load("../NormalUsePropertyResolver.js");
>+load("../NullLiteral.js");
>+load("../NullType.js");
>+load("../OperatorAnderIndexer.js");
>+load("../OperatorArrayRefLength.js");
>+load("../OriginKind.js");
>+load("../OverloadResolutionFailure.js");
>+load("../Parse.js");
>+load("../Prepare.js");
>+load("../PropertyResolver.js");
>+load("../Program.js");
>+load("../ProgramWithUnnecessaryThingsRemoved.js");
>+load("../PtrType.js");
>+load("../ReadModifyWriteExpression.js");
>+load("../RecursionChecker.js");
>+load("../RecursiveTypeChecker.js");
>+load("../ResolveNames.js");
>+load("../ResolveOverloadImpl.js");
>+load("../ResolveProperties.js");
>+load("../ResolveTypeDefs.js");
>+load("../Return.js");
>+load("../ReturnChecker.js");
>+load("../ReturnException.js");
>+load("../Sampler.js");
>+load("../StandardLibrary.js");
>+load("../StatementCloner.js");
>+load("../StructLayoutBuilder.js");
>+load("../StructType.js");
>+load("../SwitchCase.js");
>+load("../SwitchStatement.js");
>+load("../SynthesizeArrayOperatorLength.js");
>+load("../SynthesizeEnumFunctions.js");
>+load("../SynthesizeStructAccessors.js");
>+load("../SynthesizeCopyConstructorOperator.js");
>+load("../SynthesizeDefaultConstructorOperator.js");
>+load("../TernaryExpression.js");
>+load("../Texture.js");
>+load("../TextureOperations.js");
>+load("../TrapStatement.js");
>+load("../TypeDef.js");
>+load("../TypeDefResolver.js");
>+load("../TypeRef.js");
>+load("../TypeOverloadResolutionFailure.js");
>+load("../TypedValue.js");
>+load("../UintLiteral.js");
>+load("../UintLiteralType.js");
>+load("../UnificationContext.js");
>+load("../UnreachableCodeChecker.js");
>+load("../VariableDecl.js");
>+load("../VariableRef.js");
>+load("../VectorType.js");
>+load("../VisitingSet.js");
>+load("../WLexicalError.js");
>+load("../WSyntaxError.js");
>+load("../WTrapError.js");
>+load("../WTypeError.js");
>+load("../WhileLoop.js");
>+load("../WrapChecker.js");
>+
>+load("MSLCodegenAll.js");
>+
>+let src = `
>+struct VertexInput { float2 a; }
>+struct VertexOutput { float a; }
>+enum E { A = 0, B = 1, C = 42};
>+
>+vertex VertexOutput vertexShader(VertexInput vertexInput)
>+{
>+    VertexOutput result;
>+    bool a = isfinite(0.f);
>+    bool b = isinf(0.f);
>+    bool c = isnormal(0.f);
>+    // TODO: isnormal(half)
>+    float d = acos(0.f);
>+    float e = asin(0.f);
>+    float f = atan(0.f);
>+    float g = atan2(0.f, 0.f);
>+    float h = ceil(0.f);
>+    float i = cos(0.f);
>+    float j = cosh(0.f);
>+    // Shouldn't be able to call these two in a vertex shader...
>+    float k = ddx(0.f);
>+    float l = ddy(0.f);
>+    float m = exp(0.f);
>+    float n = floor(0.f);
>+    float o = log(0.f);
>+    float p = pow(0.f, 0.f);
>+    float q = round(0.f);
>+    float r = sin(0.f);
>+    float s = sinh(0.f);
>+    float t = sinh(0.f);
>+    // float u = sqrt(0.f);
>+    float v = tan(0.f);
>+    float w = tanh(0.f);
>+    float x = trunc(0.f);
>+    return result;
>+}
>+
>+E foo() { return E.C; }
>+`;
>+
>+let result = whlslToMsl(src);
>+
>+if (result.error) {
>+    if (result.error.message)
>+        print(result.error.message);
>+    print(JSON.stringify(result.error, null, 4));
>+} else
>+    print(result.metalShaderLanguageSource);
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/NameMangler.js b/Tools/WebGPUShadingLanguageRI/Metal/NameMangler.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..bec1f642b7f33f9a933adb8a988adbbd1d7669c0
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/NameMangler.js
>@@ -0,0 +1,41 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+class NameMangler {
>+
>+    constructor(prefix)
>+    {
>+        this._prefix = prefix;
>+        this._counter = 0;
>+        this._mangledNameMap = new Map();
>+    }
>+
>+    mangle(key)
>+    {
>+        if (!this._mangledNameMap.has(key))
>+            this._mangledNameMap.set(key, `${this._prefix}${this._counter++}`);
>+        return this._mangledNameMap.get(key);
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/SortTypeDeclarations.js b/Tools/WebGPUShadingLanguageRI/Metal/SortTypeDeclarations.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..1e6889fe87527fd2fa2cdbd1135c5bc585db03ae
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/SortTypeDeclarations.js
>@@ -0,0 +1,51 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+function sortTypeDeclarations(types, typeUnifier)
>+{
>+    let visitedSet = new Set();
>+    let visitedOrder = [];
>+
>+    class TypeOrderer extends Visitor {
>+        visitStructType(node)
>+        {
>+            const id = typeUnifier.uniqueTypeId(node);
>+            if (!visitedSet.has(id)) {
>+                visitedOrder.push(node);
>+                super.visitStructType(node);
>+            }
>+            visitedSet.add(id);
>+        }
>+    
>+        // An empty implementation ensures that we don't recurse into the element type and needlessly create dependencies.
>+        visitReferenceType(node) {}
>+    }
>+
>+    const typeOrderer = new TypeOrderer();
>+    for (let type of types)
>+        type.visit(typeOrderer);
>+
>+    return visitedOrder.reverse();
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/Token.js b/Tools/WebGPUShadingLanguageRI/Metal/Token.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..58ac65d8228678a4e550c09d9c953dc4dd3ab0c7
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/Token.js
>@@ -0,0 +1,55 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+// The output of MSLLexer.
>+class Token {
>+
>+    constructor(type, src, start)
>+    {
>+        this._type = type;
>+        this._src = src;
>+        this._startIndex = start;
>+    }
>+
>+    get type()
>+    {
>+        return this._type;
>+    }
>+
>+    get src()
>+    {
>+        return this._src;
>+    }
>+
>+    get startIndex()
>+    {
>+        return this._startIndex;
>+    }
>+
>+    set startIndex(i)
>+    {
>+        this._startIndex = i;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/TypeAttributeMap.js b/Tools/WebGPUShadingLanguageRI/Metal/TypeAttributeMap.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..c8b745b59ee8eb252e13219a92c6788a31a01303
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/TypeAttributeMap.js
>@@ -0,0 +1,66 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+// Provides lookup for all the top level types in the program.
>+class TypeAttributesMap  {
>+
>+    constructor(functionDefs, typeUnifier)
>+    {
>+        this._typeUnifier = typeUnifier;
>+        this._typeAttributeMap = new Map();
>+
>+        for (let funcDef of functionDefs) {
>+            if (funcDef.shaderType == "vertex")
>+                this._visitVertexShader(funcDef);
>+            else if (funcDef.shaderType == "fragment")
>+                this._visitFragmentShader(funcDef);
>+        }
>+    }
>+
>+    attributesForType(type)
>+    {
>+        const key = this._typeUnifier.uniqueTypeId(type);
>+        let attrs = this._typeAttributeMap.get(key);
>+        if (!attrs)
>+            this._typeAttributeMap.set(key, attrs = new TypeAttributes(type));
>+        return attrs;
>+    }
>+
>+    _visitVertexShader(func)
>+    {
>+        this.attributesForType(func.returnType).isVertexOutputOrFragmentInput = true;
>+        for (let param of func.parameters)
>+            this.attributesForType(param.type).isVertexAttribute = true;
>+    }
>+
>+    _visitFragmentShader(func)
>+    {
>+        this.attributesForType(func.returnType).isFragmentOutput = true;
>+        for (let param of func.parameters)
>+            this.attributesForType(param.type).isVertexOutputOrFragmentInput = true;
>+    }
>+
>+    // FIXME: Support compute shaders.
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/TypeAttributes.js b/Tools/WebGPUShadingLanguageRI/Metal/TypeAttributes.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..fa967d351f9e6ee47aae07d8736f549e8ce88a70
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/TypeAttributes.js
>@@ -0,0 +1,86 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+class TypeAttributes {
>+
>+    constructor(type)
>+    {
>+        this._type = type;
>+        this._isVertexAttribute = false;
>+        this._isVertexOutputOrFragmentInput = false;
>+        this._isFragmentOutput = false;
>+        this._fieldMangler = new NameMangler('field');
>+
>+        if (type instanceof StructType) {
>+            for (let field of type.fields)
>+                this._fieldMangler.mangle(field.name)
>+        }
>+    }
>+
>+    get type()
>+    {
>+        return this._type;
>+    }
>+
>+    get isVertexAttribute()
>+    {
>+        return this._isVertexAttribute;
>+    }
>+
>+    set isVertexAttribute(va)
>+    {
>+        this._isVertexAttribute = va;
>+    }
>+
>+    get isVertexOutputOrFragmentInput()
>+    {
>+        return this._isVertexOutputOrFragmentInput;
>+    }
>+
>+    set isVertexOutputOrFragmentInput(vo)
>+    {
>+        this._isVertexOutputOrFragmentInput = vo;
>+    }
>+
>+    get isFragmentOutput()
>+    {
>+        return this._isFragmentOutput;
>+    }
>+
>+    set isFragmentOutput(fo)
>+    {
>+        this._isFragmentOutput = fo;
>+    }
>+
>+    get fieldMangler()
>+    {
>+        return this._fieldMangler;
>+    }
>+
>+    mangledFieldName(fieldName)
>+    {
>+        return this.fieldMangler.mangle(fieldName);
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/TypeOf.js b/Tools/WebGPUShadingLanguageRI/Metal/TypeOf.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..49ef6f2066ea3b280dcbc61488563f595675c43e
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/TypeOf.js
>@@ -0,0 +1,323 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+function typeOf(node) {
>+    class TypeVisitor extends Visitor {
>+        visitAnonymousVariable(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+
>+        visitArrayRefType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitArrayType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitAssignment(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+
>+        visitCallExpression(node)
>+        {
>+            return node.func.visit(this);
>+        }
>+
>+        visitCommaExpression(node)
>+        {
>+            return node.list[node.list.length - 1].visit(this);
>+        }
>+
>+        visitConvertPtrToArrayRefExpression(node)
>+        {
>+            const ptrType = typeOf(node.lValue);
>+            return new ArrayRefType(node.origin, ptrType.addressSpace, ptrType.elementType);
>+        }
>+
>+        visitDotExpression(node)
>+        {
>+            return node.struct.fieldMap.get(node.fieldName).type.visit(this);
>+        }
>+
>+        visitElementalType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitEnumType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitField(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+
>+        visitFunc(node)
>+        {
>+            return node.returnType.visit(this);
>+        }
>+
>+        visitFuncDef(node)
>+        {
>+            return node.returnType.visit(this);
>+        }
>+
>+        visitFuncParameter(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+
>+        visitFunctionLikeBlock(node)
>+        {
>+            return node.returnType.visit(this);
>+        }
>+
>+        visitGenericLiteralType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitIdentityExpression(node)
>+        {
>+            return node.target.visit(this);
>+        }
>+
>+        visitIndexExpression(node)
>+        {
>+            return node.array.elementType.visit(this);
>+        }
>+
>+        visitLogicalExpression(node)
>+        {
>+            throw new Error("FIXME: Implement TypeVisitor.visitLogicalExpression");
>+        }
>+
>+        visitLogicalNot(node)
>+        {
>+            return node.operand.visit(this);
>+        }
>+
>+        visitMakeArrayRefExpression(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+
>+        visitMakePtrExpression(node)
>+        {
>+            throw new Error("FIXME: Implement TypeVisitor.visitMakePtrExpression");
>+        }
>+
>+        visitMatrixType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitNativeFunc(node)
>+        {
>+            return node.returnType.visit(this);
>+        }
>+
>+        visitNativeFuncInstance(node)
>+        {
>+            return node.returnType.visit(this);
>+        }
>+
>+        visitNativeType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitNativeTypeInstance(node)
>+        {
>+            return node;
>+        }
>+
>+        visitNullLiteral(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+
>+        visitNullType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitPtrType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitReadModifyWriteExpression(node)
>+        {
>+            throw new Error("FIXME: Implement TypeVisitor.visitReadModifyWriteExpression");
>+        }
>+
>+        visitReferenceType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitStructType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitTypeDef(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+
>+        visitTypeRef(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+
>+        visitVariableDecl(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+
>+        visitVariableRef(node)
>+        {
>+            return node.variable.type.visit(this);
>+        }
>+
>+        visitVectorType(node)
>+        {
>+            return node;
>+        }
>+
>+        visitBlock(node)
>+        {
>+            throw new Error("Block has no type");
>+        }
>+
>+        visitBoolLiteral(node)
>+        {
>+            throw new Error("BoolLiteral has no type");
>+        }
>+
>+        visitBreak(node)
>+        {
>+            throw new Error("Break has no type");
>+        }
>+
>+        visitConstexprTypeParameter(node)
>+        {
>+            throw new Error("ConstexprTypeParameter has no type");
>+        }
>+
>+        visitContinue(node)
>+        {
>+            throw new Error("Continue has no type");
>+        }
>+
>+        visitDereferenceExpression(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+
>+        visitDoWhileLoop(node)
>+        {
>+            throw new Error("DoWhileLoop has no type");
>+        }
>+
>+        visitEnumLiteral(node)
>+        {
>+            throw new Error("EnumLiteral has no type");
>+        }
>+
>+        visitEnumMember(node)
>+        {
>+            throw new Error("EnumMember has no type");
>+        }
>+
>+        visitForLoop(node)
>+        {
>+            throw new Error("ForLoop has no type");
>+        }
>+        visitGenericLiteral(node)
>+        {
>+            return node.type.visit(this);
>+        }
>+        visitIfStatement(node)
>+        {
>+            throw new Error("IfStatement has no type");
>+        }
>+
>+        visitProgram(node)
>+        {
>+            throw new Error("Program has no type");
>+        }
>+
>+        visitProtocolDecl(node)
>+        {
>+            throw new Error("ProtocolDecl has no type");
>+        }
>+
>+        visitProtocolFuncDecl(node)
>+        {
>+            throw new Error("ProtocolFuncDecl has no type");
>+        }
>+
>+        visitProtocolRef(node)
>+        {
>+            throw new Error("ProtocolRef has no type");
>+        }
>+
>+        visitReturn(node)
>+        {
>+            throw new Error("Return has no type");
>+        }
>+
>+        visitSwitchCase(node)
>+        {
>+            throw new Error("SwitchCase has no type");
>+        }
>+
>+        visitSwitchStatement(node)
>+        {
>+            throw new Error("SwitchStatement has no type");
>+        }
>+
>+        visitTrapStatement(node)
>+        {
>+            throw new Error("TrapStatement has no type");
>+        }
>+
>+        visitWhileLoop(node)
>+        {
>+            throw new Error("WhileLoop has no type");
>+        }
>+    }
>+    return node.visit(new TypeVisitor());
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/TypeUnifier.js b/Tools/WebGPUShadingLanguageRI/Metal/TypeUnifier.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..5cbe8e1c0398da2961c784705a849ccd178ec30c
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/TypeUnifier.js
>@@ -0,0 +1,133 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+ // FIXME: This class needs a better name.
>+class TypeUnifier extends Visitor {
>+
>+    constructor()
>+    {
>+        super();
>+
>+        this._typeNameMangler = new NameMangler('T');
>+        this._allTypes = new Set();
>+    }
>+
>+    get allTypes()
>+    {
>+        return this._allTypes;
>+    }
>+
>+    uniqueTypeId(type)
>+    {
>+        return type.visit(this);
>+    }
>+
>+    visitTypeRef(node)
>+    {
>+        if ((node.typeArguments && node.typeArguments.length) || !node.name) {
>+            return node.type.visit(this);
>+        }
>+
>+        if (!this._allTypes.has(node.type))
>+            node.type.visit(this);
>+
>+        const baseType = typeOf(node);
>+
>+        if (baseType instanceof NativeType || baseType instanceof VectorType)
>+            return baseType.visit(this);
>+
>+        return this._typeNameMangler.mangle(node.name);
>+    }
>+
>+    visitStructType(node)
>+    {
>+        this._allTypes.add(node);
>+        for (let field of node.fields)
>+            field.visit(this);
>+        return this._typeNameMangler.mangle(node.name);
>+    }
>+
>+    visitEnumType(node)
>+    {
>+        this._allTypes.add(node);
>+        node.baseType.visit(this);
>+        return this._typeNameMangler.mangle(node.name);
>+    }
>+
>+    visitNativeType(node)
>+    {
>+        this._allTypes.add(node);
>+        return node.name;
>+    }
>+
>+    visitPtrType(node)
>+    {
>+        this._allTypes.add(node);
>+        node.elementType.visit(this);
>+        return `${node.elementType.visit(this)}* ${node.addressSpace}`;
>+    }
>+
>+    visitArrayType(node)
>+    {
>+        this._allTypes.add(node);
>+        node.elementType.visit(this);
>+        return `${node.elementType.visit(this)}[${node.numElements}]`;
>+    }
>+
>+    visitArrayRefType(node)
>+    {
>+        this._allTypes.add(node);
>+        // The name mangler is used here because array refs are "user-defined" types in the sense
>+        // that they will need to be defined as structs in the Metal output.
>+        return this._typeNameMangler.mangle(`${node.elementType.visit(this)}[] ${node.addressSpace}`);
>+    }
>+
>+    visitVectorType(node)
>+    {
>+        this._allTypes.add(node);
>+        return node.toString();
>+    }
>+
>+    visitMakeArrayRefExpression(node)
>+    {
>+        if (!node.type)
>+            throw new Error(node);
>+        return node.type.visit(this);
>+    }
>+
>+    typesThatNeedDeclaration()
>+    {
>+        const declSet = new Set();
>+        const nameSet = new Set();
>+        for (let type of this._allTypes) {
>+            const name = type.visit(this);
>+            if ((type instanceof StructType || type instanceof ArrayRefType) && !nameSet.has(name)) {
>+                declSet.add(type);
>+                nameSet.add(name);
>+            }
>+        }
>+        return declSet;
>+    }
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/VarDeclaration.js b/Tools/WebGPUShadingLanguageRI/Metal/VarDeclaration.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..f502be3fd3e666206ba76b1f678c4f40058e0c73
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/VarDeclaration.js
>@@ -0,0 +1,43 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+function metalSourceForVarDeclaration(typeNamer, type, name)
>+{
>+    type = typeOf(type); // Unwrap TypeRef if necessary
>+    if (type.isArray) {
>+        let arrayType = type;
>+        const sizes = [ arrayType.numElementsValue ];
>+        let elementType = typeOf(arrayType.elementType);
>+        while (elementType.isArray) {
>+            arrayType = elementType;
>+            sizes.push(arrayType.numElementsValue);
>+            elementType = arrayType.elementType;
>+        }
>+        return `${typeNamer.mslTypeName(elementType)} ${name}${sizes.map(size => `[${size}]`).join('')}`;
>+    } else if (type.isPtr)
>+        return (type).addressSpace + " " + metalSourceForVarDeclaration(typeNamer, (type).elementType, `(*${name})`);
>+    else
>+        return `${typeNamer.mslTypeName(type)} ${name}`;
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/WHLSLLexer.js b/Tools/WebGPUShadingLanguageRI/Metal/WHLSLLexer.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..06316443d303d94c8d2870c1262934e927478cda
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/WHLSLLexer.js
>@@ -0,0 +1,110 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+function lexWhitespaceAndComment(src, startIndex) {
>+    // WHLSL permits multiline comments, but the (restricted) MSL lexer doesn't
>+    const wsRegex = /^\s+/;
>+    const oneLineCommentRegex = /^\/\/(.*?)(\n|$)/;
>+    const multilineCommentStartRegex = /^\/\*/;
>+    const multilineCommentEndRegex = /\*\//;
>+
>+    const tokens = [];
>+
>+    const originalLength = src.length;
>+
>+    while (src.length) {
>+        const wsMatch = wsRegex.exec(src);
>+        if (wsMatch) {
>+            tokens.push(new Token("whitespace", wsMatch[0], originalLength - src.length + startIndex));
>+            src = src.substring(wsMatch[0].length);
>+            continue;
>+        }
>+
>+        const oneLineCommentMatch = oneLineCommentRegex.exec(src);
>+        if (oneLineCommentMatch) {
>+            tokens.push(new Token("comment", oneLineCommentMatch[0], originalLength - src.length + startIndex));
>+            src = src.substring(oneLineCommentMatch[0].length);
>+            continue;
>+        }
>+
>+        const multilineCommentStartMatch = multilineCommentStartRegex.exec(src);
>+        if (multilineCommentStartMatch) {
>+            const multilineCommentEndMatch = multilineCommentEndRegex.exec(src);
>+            if (multilineCommentEndMatch) {
>+                const index = multilineCommentEndMatch.index + 2;
>+                tokens.push(new Token("comment", src.substring(0, index), originalLength - src.length + startIndex));
>+                src = src.substring(index);
>+            } else {
>+                throw new Error(`Multiline comment not terminated properly: '${src}'`);
>+            }
>+            continue;
>+        }
>+
>+        throw new Error(`Failed to tokenize whitespace/comment string '${src}'`);
>+    }
>+
>+    return tokens;
>+}
>+
>+function lexWHLSL(src)
>+{
>+    const lexer = new Lexer("/internal/test", "user", 0, src);
>+    let index = 0;
>+    let hasTokens = true;
>+    let tokens = [];
>+
>+    const mapWHLSLTokens = {
>+        "floatLiteral": "literal",
>+        "intHexLiteral": "literal",
>+        "uintHexLiteral": "literal",
>+        "intLiteral": "literal",
>+        "uintLiteral": "literal"
>+    };
>+    const identifiersThatAreTypes = new Set([
>+        "int", "uint", "float", "int32", "uint32", "uint8", "float2", "float3", "float4", "vertex", "fragment", "void", "bool"
>+    ]);
>+
>+    while (hasTokens) {
>+        const next = lexer.next();
>+        if (next) {
>+            if (next.index > index) {
>+                tokens = tokens.concat(lexWhitespaceAndComment(src.substring(index, next.index), index));
>+            }
>+            index = next.index + next.text.length;
>+            let kind = next.kind;
>+            if (kind in mapWHLSLTokens)
>+                kind = mapWHLSLTokens[kind];
>+            if (kind == "identifier" && identifiersThatAreTypes.has(next.text))
>+                kind = "type";
>+            tokens.push(new Token(kind, next.text, next.index));
>+        } else {
>+            hasTokens = false;
>+        }
>+    }
>+    if (index != src.length) {
>+        tokens = tokens.concat(lexWhitespaceAndComment(src.substring(index), index));
>+    }
>+    return tokens;
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/index.html b/Tools/WebGPUShadingLanguageRI/Metal/index.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..a5d7a535780d86e47e1ac5b5b4a0733ece1fd17d
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/index.html
>@@ -0,0 +1,458 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+    <title>WebGPU Shading Language (WHLSL) &#8594; Metal Shading Language</title>
>+    
>+    <script src="../Node.js"></script>
>+    <script src="../Type.js"></script>
>+    <script src="../ReferenceType.js"></script>
>+    <script src="../Value.js"></script>
>+    <script src="../Expression.js"></script>
>+    <script src="../Rewriter.js"></script>
>+    <script src="../Visitor.js"></script>
>+    <script src="../CreateLiteral.js"></script>
>+    <script src="../CreateLiteralType.js"></script>
>+    <script src="../PropertyAccessExpression.js"></script>
>+    <script src="../NativeType.js"></script>
>+
>+    <script src="../AddressSpace.js"></script>
>+    <script src="../AnonymousVariable.js"></script>
>+    <script src="../ArrayRefType.js"></script>
>+    <script src="../ArrayType.js"></script>
>+    <script src="../Assignment.js"></script>
>+    <script src="../AutoWrapper.js"></script>
>+    <script src="../Block.js"></script>
>+    <script src="../BoolLiteral.js"></script>
>+    <script src="../Break.js"></script>
>+    <script src="../BuiltinMatrixGetter.js"></script>
>+    <script src="../BuiltinMatrixSetter.js"></script>
>+    <script src="../BuiltinVectorGetter.js"></script>
>+    <script src="../BuiltinVectorSetter.js"></script>
>+    <script src="../CallExpression.js"></script>
>+    <script src="../CallFunction.js"></script>
>+    <script src="../Casts.js"></script>
>+    <script src="../Check.js"></script>
>+    <script src="../CheckLiteralTypes.js"></script>
>+    <script src="../CheckLoops.js"></script>
>+    <script src="../CheckRecursion.js"></script>
>+    <script src="../CheckRecursiveTypes.js"></script>
>+    <script src="../CheckReturns.js"></script>
>+    <script src="../CheckTypesWithArguments.js"></script>
>+    <script src="../CheckUnreachableCode.js"></script>
>+    <script src="../CheckWrapped.js"></script>
>+    <script src="../Checker.js"></script>
>+    <script src="../CloneProgram.js"></script>
>+    <script src="../CommaExpression.js"></script>
>+    <script src="../ConstexprFolder.js"></script>
>+    <script src="../Continue.js"></script>
>+    <script src="../ConvertPtrToArrayRefExpression.js"></script>
>+    <script src="../DoWhileLoop.js"></script>
>+    <script src="../DotExpression.js"></script>
>+    <script src="../DereferenceExpression.js"></script>
>+    <script src="../EArrayRef.js"></script>
>+    <script src="../EBuffer.js"></script>
>+    <script src="../EBufferBuilder.js"></script>
>+    <script src="../EPtr.js"></script>
>+    <script src="../EnumLiteral.js"></script>
>+    <script src="../EnumMember.js"></script>
>+    <script src="../EnumType.js"></script>
>+    <script src="../EvaluationCommon.js"></script>
>+    <script src="../Evaluator.js"></script>
>+    <script src="../ExpressionFinder.js"></script>
>+    <script src="../ExternalOrigin.js"></script>
>+    <script src="../Field.js"></script>
>+    <script src="../FindHighZombies.js"></script>
>+    <script src="../FlattenedStructOffsetGatherer.js"></script>
>+    <script src="../FloatLiteral.js"></script>
>+    <script src="../FloatLiteralType.js"></script>
>+    <script src="../FoldConstexprs.js"></script>
>+    <script src="../ForLoop.js"></script>
>+    <script src="../Func.js"></script>
>+    <script src="../FuncDef.js"></script>
>+    <script src="../FuncParameter.js"></script>
>+    <script src="../FunctionLikeBlock.js"></script>
>+    <script src="../HighZombieFinder.js"></script>
>+    <script src="../IdentityExpression.js"></script>
>+    <script src="../IfStatement.js"></script>
>+    <script src="../IndexExpression.js"></script>
>+    <script src="../InferTypesForCall.js"></script>
>+    <script src="../Inline.js"></script>
>+    <script src="../Inliner.js"></script>
>+    <script src="../IntLiteral.js"></script>
>+    <script src="../IntLiteralType.js"></script>
>+    <script src="../Intrinsics.js"></script>
>+    <script src="../IsBitwiseEquivalent.js"></script>
>+    <script src="../LateChecker.js"></script>
>+    <script src="../LateCheckAndLayoutBuffers.js"></script>
>+    <script src="../Lexer.js"></script>
>+    <script src="../LexerToken.js"></script>
>+    <script src="../LiteralTypeChecker.js"></script>
>+    <script src="../LogicalExpression.js"></script>
>+    <script src="../LogicalNot.js"></script>
>+    <script src="../LoopChecker.js"></script>
>+    <script src="../MakeArrayRefExpression.js"></script>
>+    <script src="../MakePtrExpression.js"></script>
>+    <script src="../MatrixType.js"></script>
>+    <script src="../NameContext.js"></script>
>+    <script src="../NameFinder.js"></script>
>+    <script src="../NameResolver.js"></script>
>+    <script src="../NativeFunc.js"></script>
>+    <script src="../NormalUsePropertyResolver.js"></script>
>+    <script src="../NullLiteral.js"></script>
>+    <script src="../NullType.js"></script>
>+    <script src="../OperatorAnderIndexer.js"></script>
>+    <script src="../OperatorArrayRefLength.js"></script>
>+    <script src="../OriginKind.js"></script>
>+    <script src="../OverloadResolutionFailure.js"></script>
>+    <script src="../Parse.js"></script>
>+    <script src="../Prepare.js"></script>
>+    <script src="../PropertyResolver.js"></script>
>+    <script src="../Program.js"></script>
>+    <script src="../ProgramWithUnnecessaryThingsRemoved.js"></script>
>+    <script src="../PtrType.js"></script>
>+    <script src="../ReadModifyWriteExpression.js"></script>
>+    <script src="../RecursionChecker.js"></script>
>+    <script src="../RecursiveTypeChecker.js"></script>
>+    <script src="../ResolveNames.js"></script>
>+    <script src="../ResolveOverloadImpl.js"></script>
>+    <script src="../ResolveProperties.js"></script>
>+    <script src="../ResolveTypeDefs.js"></script>
>+    <script src="../Return.js"></script>
>+    <script src="../ReturnChecker.js"></script>
>+    <script src="../ReturnException.js"></script>
>+    <script src="../Sampler.js"></script>
>+    <script src="../FastStandardLibrary.js"></script>
>+    <script src="../StatementCloner.js"></script>
>+    <script src="../StructLayoutBuilder.js"></script>
>+    <script src="../StructType.js"></script>
>+    <script src="../SwitchCase.js"></script>
>+    <script src="../SwitchStatement.js"></script>
>+    <script src="../SynthesizeArrayOperatorLength.js"></script>
>+    <script src="../SynthesizeEnumFunctions.js"></script>
>+    <script src="../SynthesizeStructAccessors.js"></script>
>+    <script src="../SynthesizeCopyConstructorOperator.js"></script>
>+    <script src="../SynthesizeDefaultConstructorOperator.js"></script>
>+    <script src="../TernaryExpression.js"></script>
>+    <script src="../Texture.js"></script>
>+    <script src="../TextureOperations.js"></script>
>+    <script src="../TrapStatement.js"></script>
>+    <script src="../TypeDef.js"></script>
>+    <script src="../TypeDefResolver.js"></script>
>+    <script src="../TypeRef.js"></script>
>+    <script src="../TypeOverloadResolutionFailure.js"></script>
>+    <script src="../TypedValue.js"></script>
>+    <script src="../UintLiteral.js"></script>
>+    <script src="../UintLiteralType.js"></script>
>+    <script src="../UnificationContext.js"></script>
>+    <script src="../UnreachableCodeChecker.js"></script>
>+    <script src="../VariableDecl.js"></script>
>+    <script src="../VariableRef.js"></script>
>+    <script src="../VectorType.js"></script>
>+    <script src="../VisitingSet.js"></script>
>+    <script src="../WLexicalError.js"></script>
>+    <script src="../WSyntaxError.js"></script>
>+    <script src="../WTrapError.js"></script>
>+    <script src="../WTypeError.js"></script>
>+    <script src="../WhileLoop.js"></script>
>+    <script src="../WrapChecker.js"></script>
>+
>+    <script src="CompileResult.js"></script>
>+    <script src="ConstexprEmitter.js"></script>
>+    <script src="Counter.js"></script>
>+    <script src="LineNumbers.js"></script>
>+    <script src="MSLFunctionDeclaration.js"></script>
>+    <script src="MSLFunctionDefinition.js"></script>
>+    <script src="MSLFunctionForwardDeclaration.js"></script>
>+    <script src="MSLLexer.js"></script>
>+    <script src="MSLStatementEmitter.js"></script>
>+    <script src="MSLTypeNamer.js"></script>
>+    <script src="MetalCodegen.js"></script>
>+    <script src="NameMangler.js"></script>
>+    <script src="SortTypeDeclarations.js"></script>
>+    <script src="Token.js"></script>
>+    <script src="TypeAttributeMap.js"></script>
>+    <script src="TypeAttributes.js"></script>
>+    <script src="TypeOf.js"></script>
>+    <script src="TypeUnifier.js"></script>
>+    <script src="VarDeclaration.js"></script>
>+    <script src="WHLSLLexer.js"></script>
>+
>+<link rel="stylesheet" type="text/css" href="metal.css" />
>+
>+<script>
>+let defaultShaderSource = `struct VertexInput {
>+    float2 position;
>+    float3 color;
>+}
>+
>+struct VertexOutput {
>+    float4 wsl_Position;
>+    float3 color;
>+}
>+
>+struct FragmentOutput {
>+    float4 wsl_Color;
>+}
>+
>+vertex VertexOutput vertexShader(VertexInput vertexInput) {
>+    VertexOutput result;
>+    result.wsl_Position = float4(vertexInput.position, 0., 1.);
>+    result.color = vertexInput.color;
>+    return result;
>+}
>+
>+fragment FragmentOutput fragmentShader(VertexOutput stageIn) {
>+    FragmentOutput result;
>+    result.wsl_Color = float4(stageIn.color, 1.);
>+    return result;
>+}`;
>+
>+let whlslContainer;
>+let mslContainer;
>+
>+let whlslSourceView;
>+let mslSourceView;
>+
>+const LocalStorageWhlslKeyName = "ShaderSource";
>+const LocalStorageMslKeyName = "ShaderMSLResult";
>+
>+window.addEventListener("load", () => {
>+    mslContainer = document.getElementById("MetalOutput");
>+    mslSourceView = new SourceView("MSL (previous compilation)", mslContainer, (src) => new MSLLexer(src).tokens);
>+
>+    try {
>+        const localStorage = window.localStorage;
>+        const mslSource = localStorage.getItem(LocalStorageMslKeyName);
>+        mslSourceView.src = mslSource;
>+    } catch(e) {
>+    }
>+
>+    whlslContainer = document.getElementById("WHLSLInput");
>+    whlslSourceView = new SourceView("WHLSL", whlslContainer, lexWHLSL, compileWHLSL, true);
>+
>+    try {
>+        const localStorage = window.localStorage;
>+        let whlslSource = localStorage.getItem(LocalStorageWhlslKeyName);
>+        if (!whlslSource)
>+            whlslSource = defaultShaderSource;
>+        whlslSourceView.src = whlslSource;
>+        whlslSourceView.compile();
>+    } catch (e) {
>+        console.log(e);
>+    }
>+});
>+
>+function compileWHLSL(src) {
>+    window.localStorage.setItem(LocalStorageWhlslKeyName, src);
>+    const compileResult = whlslToMsl(src);
>+
>+    if (compileResult.didSucceed) {
>+        mslSourceView.src = compileResult.metalShaderLanguageSource;
>+        mslSourceView.name = "MSL";
>+        window.localStorage.setItem(LocalStorageMslKeyName, compileResult.metalShaderLanguageSource);
>+    } else {
>+        mslSourceView.name = "MSL (previous compilation)";
>+        whlslSourceView.errorText = compileResult.error.message;
>+    }
>+}
>+
>+// Wraps a textarea and a bunch of buttons
>+class SourceView {
>+    constructor(name, container, lexer, compiler = null, editable = false)
>+    {
>+        this._name = name;
>+        this._container = container;
>+        this._lexingDelegate = lexer;
>+        this._compiler = compiler;
>+        this._copySources = new Map();
>+        this._src = "";
>+        this._tokens = [];
>+        this._editable = editable;
>+        this._errorText = "";
>+    }
>+
>+    get name() { return this._name; }
>+    get editable() { return this._editable; }
>+    get src() { return this._src; }
>+
>+    set src(newSrc)
>+    {
>+        this._src = newSrc;
>+        this._tokens = this._lexingDelegate(this._src);
>+        this._updateView();
>+    }
>+
>+    get copySources() { return this._copySources; }
>+    set copySources(cs)
>+    {
>+        this._copySources = cs;
>+        this._updateView();
>+    }
>+
>+    get errorText() { return this._errorText; }
>+
>+    set errorText(newErrorText)
>+    {
>+        this._errorText = newErrorText;
>+        if (this._errorBox && newErrorText)
>+            this._errorBox.innerText = this._errorText;
>+    }
>+
>+    set name(newName)
>+    {
>+        this._name = newName;
>+        if (this._header)
>+            this._header.innerText = this.name;
>+    }
>+
>+    _updateView()
>+    {
>+        this._presentSource(this._tokens, this._container);
>+    }
>+
>+    _removeAllChildren(node)
>+    {
>+        while (node.hasChildNodes()) {
>+            node.removeChild(node.lastChild);
>+        }
>+    }
>+
>+    _splitTokensIntoLines(tokens)
>+    {
>+        const lines = [];
>+        let currentLine = [];
>+        lines.push(currentLine);
>+
>+        for (let tok of tokens) {
>+            let tokSections = tok.src.split('\n');
>+            for (let i = 0; i < tokSections.length; i++) {
>+                let tokSection = tokSections[i];
>+
>+                let span = document.createElement('span');
>+                span.innerText = tokSection;
>+                span.className = `code-${tok.type}`;
>+                currentLine.push(span);
>+
>+                if (i != tokSections.length - 1) {
>+                    currentLine = [];
>+                    lines.push(currentLine);
>+                }
>+            }
>+        }
>+
>+        return lines;
>+    }
>+
>+    _presentSource(tokens, container)
>+    {
>+        this._removeAllChildren(container);
>+
>+        this._header = document.createElement('h2');
>+        this._header.innerText = this.name;
>+        container.appendChild(this._header);
>+
>+        const lines = this._splitTokensIntoLines(tokens);
>+
>+        const srcTable = document.createElement('table');
>+        srcTable.className = 'code-source';
>+
>+        for (let i = 0; i < lines.length; i++) {
>+            const currentRow = document.createElement('tr');
>+
>+            const currentLineNumber = document.createElement('td');
>+            currentLineNumber.className = 'line-no';
>+            currentLineNumber.dataset.content = (i + 1).toString(); // line-no shown with CSS
>+            currentRow.appendChild(currentLineNumber);
>+
>+            const currentLineElement = document.createElement('td');
>+            currentLineElement.className = 'line';
>+            for (let span of lines[i]) {
>+                currentLineElement.appendChild(span);
>+            }
>+            currentRow.appendChild(currentLineElement);
>+
>+            srcTable.appendChild(currentRow);
>+        }
>+
>+        container.appendChild(srcTable);
>+
>+        if (this.editable) {
>+            const editButton = document.createElement('input');
>+            editButton.type = "button";
>+            editButton.value = "Edit";
>+            editButton.addEventListener("click", () => this.edit());
>+            container.appendChild(editButton);
>+        }
>+
>+        for (let [name, source] of this.copySources) {
>+            const copyButton = document.createElement('input');
>+            copyButton.type = "button";
>+            copyButton.value = `Copy ${name}`;
>+            copyButton.addEventListener("click", () => {
>+                const fakeTextarea = document.createElement('textarea');
>+                fakeTextarea.value = source;
>+                document.body.appendChild(fakeTextarea);
>+                fakeTextarea.focus();
>+                fakeTextarea.select();
>+                document.execCommand("copy");
>+                document.body.removeChild(fakeTextarea);
>+            });
>+            container.appendChild(copyButton);
>+        }
>+
>+        this._createErrorBox();
>+    }
>+
>+    edit()
>+    {
>+        this._removeAllChildren(this._container);
>+
>+        this._header = document.createElement('h2');
>+        this._header.innerText = this.name;
>+        this._container.appendChild(this._header);
>+
>+        this._textarea = document.createElement('textarea');
>+        this._textarea.value = this.src;
>+        this._container.appendChild(this._textarea);
>+
>+        const compileButton = document.createElement('input');
>+        compileButton.type = "button";
>+        compileButton.value = "Compile";
>+        compileButton.addEventListener("click", () => this.compile());
>+        this._container.appendChild(compileButton);
>+
>+        this._createErrorBox();
>+    }
>+
>+    _createErrorBox()
>+    {
>+        this._errorBox = document.createElement('div');
>+        if (this.errorText) {
>+            this._errorBox.innerText = this.errorText;
>+            this._errorText = null;
>+        }
>+        this._container.appendChild(this._errorBox);
>+    }
>+
>+    compile()
>+    {
>+        let src = this._textarea ? this._textarea.value : this._src;
>+        this._compiler(src);
>+        this.src = src;
>+    }
>+}
>+</script>
>+</head>
>+<body>
>+<table cellspacing="0" cellpadding="0">
>+    <tr>
>+        <td class="container-cell">
>+            <div id="WHLSLInput"></div>
>+        </td>
>+        <td class="container-cell">
>+            <div id="MetalOutput"></div>
>+        </td>
>+    </tr>
>+</table>
>+</body>
>+</html>
>diff --git a/Tools/WebGPUShadingLanguageRI/Metal/metal.css b/Tools/WebGPUShadingLanguageRI/Metal/metal.css
>new file mode 100644
>index 0000000000000000000000000000000000000000..d315d02232c6244a8c1597461ee88c00db6d2c55
>--- /dev/null
>+++ b/Tools/WebGPUShadingLanguageRI/Metal/metal.css
>@@ -0,0 +1,113 @@
>+textarea, .code-source {
>+    font-family: "SF Mono", monospace;
>+    font-size: 11pt;
>+    padding: 5px;
>+    width: 800px;
>+    height: 800px;
>+    margin: 1em 0;
>+    display: block;
>+}
>+
>+input[type=button] {
>+    font-size: 16pt;
>+}
>+
>+.code-source {
>+    overflow-x: scroll;
>+    overflow-y: scroll;
>+    border: 1px solid black;
>+    display: block;
>+    background-color: #1F1F24;
>+    color: white;
>+    white-space: nowrap;
>+}
>+
>+td {
>+    border: 1px solid black;
>+}
>+
>+body {
>+    font-family: -apple-system, sans-serif;
>+}
>+
>+h1, h2 {
>+    text-align: center;
>+}
>+
>+table {
>+    width:100%;
>+    border:none;
>+    border-collapse: collapse;
>+
>+}
>+
>+.container-cell {
>+    width:50%;
>+}
>+
>+th, td {
>+    border:none;
>+    vertical-align:top;
>+    margin: 0;
>+    -webkit-border-horizontal-spacing: 0px;
>+    -webkit-border-vertical-spacing: 0px;
>+    border-collapse: collapse;
>+    box-sizing: border-box;
>+    border-spacing: 0;
>+}
>+
>+.code-comment {
>+    color: #9e9e9e;
>+    font-style: italic;
>+    white-space: pre;
>+}
>+
>+.code-comment-note {
>+    color: #F4E218;
>+    font-style: italic;
>+    font-weight:bold;
>+}
>+
>+.code-keyword, .code-type {
>+    color: #FD5FA2;
>+    font-weight: bold;
>+}
>+
>+.code-literal {
>+    color: #9686F5;
>+}
>+
>+.code-attribute {
>+    color: #AEF29D;
>+    font-weight: bold;
>+}
>+
>+.code-whitespace {
>+    white-space: pre;
>+}
>+
>+.code-error {
>+    color: #fc5a3a;
>+    text-decoration: underline;
>+}
>+
>+.code-directive {
>+    color: #FC8F3F;
>+}
>+
>+.line-no {
>+    color: #616065;
>+    text-align: right;
>+    -webkit-user-select:none;
>+    padding-left: 5px;
>+    padding-right: 5px;
>+    border-right: 1px solid #616065;
>+}
>+
>+.line-no::before {
>+    content: attr(data-content);
>+}
>+
>+.line {
>+    padding-left: 5px;
>+}
>\ No newline at end of file
>diff --git a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js b/Tools/WebGPUShadingLanguageRI/StandardLibrary.js
>index cf3093bbe8cf37b293d38a79e6e769116c449338..2e1ea919455be71537a836de2e10284e4c0ae33f 100644
>--- a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js
>+++ b/Tools/WebGPUShadingLanguageRI/StandardLibrary.js
>@@ -39,8 +39,8 @@ let standardLibrary = (function() {
>         for (let type of [`void`, `bool`, `uchar`, `ushort`, `uint`, `char`, `short`, `int`, `half`, `float`, `atomic_int`, `atomic_uint`]) {
>             print(`native typedef ${type};`);
>         }
>-        for (let type of [`bool`, `uchar`, `ushort`, `uint`, `char`, `short`, `int`, `half`, `float`]) {
>-            for (let size of [2, 3, 4]) {
>+        for (var type of [`bool`, `uchar`, `ushort`, `uint`, `char`, `short`, `int`, `half`, `float`]) {
>+            for (var size of [2, 3, 4]) {
>                 print(`native typedef vector<${type}, ${size}>;`);
>                 print(`typedef ${type}${size} = vector<${type}, ${size}>;`);
>             }
>diff --git a/Tools/WebGPUShadingLanguageRI/SynthesizeStructAccessors.js b/Tools/WebGPUShadingLanguageRI/SynthesizeStructAccessors.js
>index a0181468a25ed4c09050d7bf1d61f44ed3a0aa66..24a209433bde0c1bbc2085654a0612c8c65fe9cd 100644
>--- a/Tools/WebGPUShadingLanguageRI/SynthesizeStructAccessors.js
>+++ b/Tools/WebGPUShadingLanguageRI/SynthesizeStructAccessors.js
>@@ -42,6 +42,13 @@ function synthesizeStructAccessors(program)
>                 nativeFunc.implementation = (argumentList, node) => {
>                     return implementation(argumentList, field.offset, type.size, field.type.size);
>                 };
>+
>+                nativeFunc.implementationData = {
>+                    name: field.name,
>+                    type: type,
>+                    offset: field.offset,
>+                    size: field.type.size
>+                };
>             }
>             
>             function createFieldType()
>diff --git a/Tools/WebGPUShadingLanguageRI/Test.js b/Tools/WebGPUShadingLanguageRI/Test.js
>index 2bcea7d7da3cb382f1aabe2167ef3a7891392333..84dfb78b9e30bf57b5dccc6443b714fa16749a51 100644
>--- a/Tools/WebGPUShadingLanguageRI/Test.js
>+++ b/Tools/WebGPUShadingLanguageRI/Test.js
>@@ -55,32 +55,37 @@ function doLex(code)
> 
> function makeInt(program, value)
> {
>-    return TypedValue.box(program.intrinsics.int, value);
>+    return TypedValue.box(program.intrinsics.int, castAndCheckValue(castToInt, value));
> }
> 
> function makeUint(program, value)
> {
>-    return TypedValue.box(program.intrinsics.uint, value);
>+    return TypedValue.box(program.intrinsics.uint, castAndCheckValue(castToUint, value));
> }
> 
> function makeUchar(program, value)
> {
>-    return TypedValue.box(program.intrinsics.uchar, value);
>+    return TypedValue.box(program.intrinsics.uchar, castAndCheckValue(castToUchar, value));
> }
> 
> function makeBool(program, value)
> {
>-    return TypedValue.box(program.intrinsics.bool, value);
>+    return TypedValue.box(program.intrinsics.bool, castAndCheckValue(castToBool, value));
> }
> 
> function makeFloat(program, value)
> {
>-    return TypedValue.box(program.intrinsics.float, value);
>+    return TypedValue.box(program.intrinsics.float, castAndCheckValue(castToFloat, value));
>+}
>+
>+function makeCastedFloat(program, value)
>+{
>+    return TypedValue.box(program.intrinsics.float, castToFloat(value));
> }
> 
> function makeHalf(program, value)
> {
>-    return TypedValue.box(program.intrinsics.half, value);
>+    return TypedValue.box(program.intrinsics.half, castAndCheckValue(castToHalf, value));
> }
> 
> function makeEnum(program, enumName, value)
>@@ -221,19 +226,12 @@ function makeRW2DDepthTextureArray(program, array, elementType)
>     return TypedValue.box(program.intrinsics[`RWTextureDepth2DArray<${elementType}>`], new TextureDepth2DArrayRW(elementType, array));
> }
> 
>-function checkNumber(program, result, expected)
>-{
>-    if (!result.type.unifyNode.isNumber)
>-        throw new Error("Wrong result type; result: " + result);
>-    if (result.value != expected)
>-        throw new Error("Wrong result: " + result.value + " (expected " + expected + ")");
>-}
>-
> function checkInt(program, result, expected)
> {
>     if (!result.type.equals(program.intrinsics.int))
>         throw new Error("Wrong result type; result: " + result);
>-    checkNumber(program, result, expected);
>+    if (result.value != expected)
>+        throw new Error(`Wrong result: ${result.value} (expected ${expected})`);
> }
> 
> function checkEnum(program, result, expected)
>@@ -439,6 +437,27 @@ tests.intSimpleMath = function() {
>     checkInt(program, callFunction(program, "foo", [makeInt(program, 7), makeInt(program, -2)]), -3);
> }
> 
>+tests.incrementAndDecrement = function() {
>+    let program = doPrep(`
>+    int foo1() { int x = 0; return x++; }
>+    int foo2() { int x = 0; x++; return x; }
>+    int foo3() { int x = 0; return ++x; }
>+    int foo4() { int x = 0; ++x; return x; }
>+    int foo5() { int x = 0; return x--; }
>+    int foo6() { int x = 0; x--; return x; }
>+    int foo7() { int x = 0; return --x; }
>+    int foo8() { int x = 0; --x; return x; }
>+    `);
>+    checkInt(program, callFunction(program, "foo1", []), 0);
>+    checkInt(program, callFunction(program, "foo2", []), 1);
>+    checkInt(program, callFunction(program, "foo3", []), 1);
>+    checkInt(program, callFunction(program, "foo4", []), 1);
>+    checkInt(program, callFunction(program, "foo5", []), 0);
>+    checkInt(program, callFunction(program, "foo6", []), -1);
>+    checkInt(program, callFunction(program, "foo7", []), -1);
>+    checkInt(program, callFunction(program, "foo8", []), -1);
>+}
>+
> tests.uintSimpleMath = function() {
>     let program = doPrep("test uint foo(uint x, uint y) { return x + y; }");
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 7), makeUint(program, 5)]), 12);
>@@ -1039,13 +1058,13 @@ tests.passNullToPtrMonomorphicArrayRef = function()
> tests.returnIntLiteralUint = function()
> {
>     let program = doPrep("test uint foo() { return 42; }");
>-    checkNumber(program, callFunction(program, "foo", []), 42);
>+    checkUint(program, callFunction(program, "foo", []), 42);
> }
> 
> tests.returnIntLiteralFloat = function()
> {
>     let program = doPrep("test float foo() { return 42; }");
>-    checkNumber(program, callFunction(program, "foo", []), 42);
>+    checkFloat(program, callFunction(program, "foo", []), 42);
> }
> 
> tests.badIntLiteralForInt = function()
>@@ -2355,6 +2374,149 @@ tests.nestedSubscriptLValueEmulationSimple = function()
>     checkInt(program, callFunction(program, "testSetValuesMutateValuesAndSum", []), 5565);
> }
> 
>+tests.nestedSubscriptWithArraysInStructs = function()
>+{
>+    let program = doPrep(`
>+        struct Foo {
>+            int[7] array;
>+        }
>+        int sum(Foo foo)
>+        {
>+            int result = 0;
>+            for (uint i = 0; i < foo.array.length; i++)
>+                result += foo.array[i];
>+            return result;
>+        }
>+        struct Bar {
>+            Foo[6] array;
>+        }
>+        int sum(Bar bar)
>+        {
>+            int result = 0;
>+            for (uint i = 0; i < bar.array.length; i++)
>+                result += sum(bar.array[i]);
>+            return result;
>+        }
>+        struct Baz {
>+            Bar[5] array;
>+        }
>+        int sum(Baz baz)
>+        {
>+            int result = 0;
>+            for (uint i = 0; i < baz.array.length; i++)
>+                result += sum(baz.array[i]);
>+            return result;
>+        }
>+        void setValues(thread Baz* baz)
>+        {
>+            for (uint i = 0; i < baz->array.length; i++) {
>+                for (uint j = 0; j < baz->array[i].array.length; j++) {
>+                    for (uint k = 0; k < baz->array[i].array[j].array.length; k++)
>+                        baz->array[i].array[j].array[k] = int(i + j + k);
>+                }
>+            }
>+        }
>+        int testSetValuesAndSum()
>+        {
>+            Baz baz;
>+            setValues(&baz);
>+            return sum(baz);
>+        }
>+        int testSetValuesMutateValuesAndSum()
>+        {
>+            Baz baz;
>+            setValues(&baz);
>+            for (uint i = baz.array.length; i--;) {
>+                for (uint j = baz.array[i].array.length; j--;) {
>+                    for (uint k = baz.array[i].array[j].array.length; k--;)
>+                        baz.array[i].array[j].array[k] = baz.array[i].array[j].array[k] * int(k);
>+                }
>+            }
>+            return sum(baz);
>+        }
>+    `);
>+    checkInt(program, callFunction(program, "testSetValuesAndSum", []), 1575);
>+    checkInt(program, callFunction(program, "testSetValuesMutateValuesAndSum", []), 5565);
>+}
>+
>+tests.nestedSubscript = function()
>+{
>+    let program = doPrep(`
>+        int sum(int[7] array)
>+        {
>+            int result = 0;
>+            for (uint i = array.length; i--;)
>+                result += array[i];
>+            return result;
>+        }
>+        int sum(int[6][7] array)
>+        {
>+            int result = 0;
>+            for (uint i = array.length; i--;)
>+                result += sum(array[i]);
>+            return result;
>+        }
>+        int sum(int[5][6][7] array)
>+        {
>+            int result = 0;
>+            for (uint i = array.length; i--;)
>+                result += sum(array[i]);
>+            return result;
>+        }
>+        void setValues(thread int[][6][7] array)
>+        {
>+            for (uint i = array.length; i--;) {
>+                for (uint j = array[i].length; j--;) {
>+                    for (uint k = array[i][j].length; k--;)
>+                        array[i][j][k] = int(i + j + k);
>+                }
>+            }
>+        }
>+        int testSetValuesAndSum()
>+        {
>+            int[5][6][7] array;
>+            setValues(@array);
>+            return sum(array);
>+        }
>+        int testSetValuesMutateValuesAndSum()
>+        {
>+            int[5][6][7] array;
>+            setValues(@array);
>+            for (uint i = array.length; i--;) {
>+                for (uint j = array[i].length; j--;) {
>+                    for (uint k = array[i][j].length; k--;)
>+                        array[i][j][k] = array[i][j][k] * int(k);
>+                }
>+            }
>+            return sum(array);
>+        }
>+    `);
>+    checkInt(program, callFunction(program, "testSetValuesAndSum", []), 1575);
>+    checkInt(program, callFunction(program, "testSetValuesMutateValuesAndSum", []), 5565);
>+}
>+
>+tests.lotsOfLocalVariables = function()
>+{
>+    let src = "int sum() {\n";
>+    src += "    int i = 0;\n";
>+    let target = 0;
>+    const numVars = 1024;
>+    for (let i = 0; i < numVars; i++) {
>+        const value = i * 3;
>+        src += `   i = ${i};\n`;
>+        src += `   int V${i} = (i + 3) * (i + 3);\n`;
>+        target += (i + 3) * (i + 3);
>+    }
>+    src += "    int result = 0;\n";
>+    for (let i = 0; i < numVars; i++) {
>+        src += `    result += V${i};\n`;
>+    }
>+    src += "    return result;\n";
>+    src += "}";
>+    let program = doPrep(src);
>+    checkInt(program, callFunction(program, "sum", []), target);
>+}
>+
> tests.operatorBool = function()
> {
>     let program = doPrep(`
>@@ -2552,7 +2714,6 @@ tests.uintBitAnd = function()
>     `);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 1), makeUint(program, 7)]), 1);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 65535), makeUint(program, 42)]), 42);
>-    checkUint(program, callFunction(program, "foo", [makeUint(program, -1), makeUint(program, -7)]), 4294967289);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 0), makeUint(program, 85732)]), 0);
> }
> 
>@@ -2566,7 +2727,6 @@ tests.uintBitOr = function()
>     `);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 1), makeUint(program, 7)]), 7);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 65535), makeUint(program, 42)]), 65535);
>-    checkUint(program, callFunction(program, "foo", [makeUint(program, -1), makeUint(program, -7)]), 4294967295);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 0), makeUint(program, 85732)]), 85732);
> }
> 
>@@ -2580,7 +2740,6 @@ tests.uintBitXor = function()
>     `);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 1), makeUint(program, 7)]), 6);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 65535), makeUint(program, 42)]), 65493);
>-    checkUint(program, callFunction(program, "foo", [makeUint(program, -1), makeUint(program, -7)]), 6);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 0), makeUint(program, 85732)]), 85732);
> }
> 
>@@ -2594,7 +2753,6 @@ tests.uintBitNot = function()
>     `);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 1)]), 4294967294);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 65535)]), 4294901760);
>-    checkUint(program, callFunction(program, "foo", [makeUint(program, -1)]), 0);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 0)]), 4294967295);
> }
> 
>@@ -2608,7 +2766,6 @@ tests.uintLShift = function()
>     `);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 1), makeUint(program, 7)]), 128);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 65535), makeUint(program, 2)]), 262140);
>-    checkUint(program, callFunction(program, "foo", [makeUint(program, -1), makeUint(program, 5)]), 4294967264);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 0), makeUint(program, 3)]), 0);
> }
> 
>@@ -2622,7 +2779,6 @@ tests.uintRShift = function()
>     `);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 1), makeUint(program, 7)]), 0);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 65535), makeUint(program, 2)]), 16383);
>-    checkUint(program, callFunction(program, "foo", [makeUint(program, -1), makeUint(program, 5)]), 134217727);
>     checkUint(program, callFunction(program, "foo", [makeUint(program, 0), makeUint(program, 3)]), 0);
> }
> 
>@@ -2635,9 +2791,8 @@ tests.ucharBitAnd = function()
>         }
>     `);
>     checkUchar(program, callFunction(program, "foo", [makeUchar(program, 1), makeUchar(program, 7)]), 1);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 65535), makeUchar(program, 42)]), 42);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, -1), makeUchar(program, -7)]), 249);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 0), makeUchar(program, 85732)]), 0);
>+    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 255), makeUchar(program, 42)]), 42);
>+    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 0), makeUchar(program, 255)]), 0);
> }
> 
> tests.ucharBitOr = function()
>@@ -2649,9 +2804,8 @@ tests.ucharBitOr = function()
>         }
>     `);
>     checkUchar(program, callFunction(program, "foo", [makeUchar(program, 1), makeUchar(program, 7)]), 7);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 65535), makeUchar(program, 42)]), 255);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, -1), makeUchar(program, -7)]), 255);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 0), makeUchar(program, 85732)]), 228);
>+    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 255), makeUchar(program, 42)]), 255);
>+    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 0), makeUchar(program, 228)]), 228);
> }
> 
> tests.ucharBitXor = function()
>@@ -2663,9 +2817,8 @@ tests.ucharBitXor = function()
>         }
>     `);
>     checkUchar(program, callFunction(program, "foo", [makeUchar(program, 1), makeUchar(program, 7)]), 6);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 65535), makeUchar(program, 42)]), 213);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, -1), makeUchar(program, -7)]), 6);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 0), makeUchar(program, 85732)]), 228);
>+    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 255), makeUchar(program, 42)]), 213);
>+    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 0), makeUchar(program, 255)]), 255);
> }
> 
> tests.ucharBitNot = function()
>@@ -2677,8 +2830,7 @@ tests.ucharBitNot = function()
>         }
>     `);
>     checkUchar(program, callFunction(program, "foo", [makeUchar(program, 1)]), 254);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 65535)]), 0);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, -1)]), 0);
>+    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 255)]), 0);
>     checkUchar(program, callFunction(program, "foo", [makeUchar(program, 0)]), 255);
> }
> 
>@@ -2691,8 +2843,7 @@ tests.ucharLShift = function()
>         }
>     `);
>     checkUchar(program, callFunction(program, "foo", [makeUchar(program, 1), makeUint(program, 7)]), 128);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 65535), makeUint(program, 2)]), 252);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, -1), makeUint(program, 5)]), 224);
>+    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 255), makeUint(program, 2)]), 252);
>     checkUchar(program, callFunction(program, "foo", [makeUchar(program, 0), makeUint(program, 3)]), 0);
> }
> 
>@@ -2705,8 +2856,8 @@ tests.ucharRShift = function()
>         }
>     `);
>     checkUchar(program, callFunction(program, "foo", [makeUchar(program, 1), makeUint(program, 7)]), 0);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 65535), makeUint(program, 2)]), 255);
>-    checkUchar(program, callFunction(program, "foo", [makeUchar(program, -1), makeUint(program, 5)]), 255);
>+    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 255), makeUint(program, 2)]), 63);
>+    checkUchar(program, callFunction(program, "foo", [makeUchar(program, 255), makeUint(program, 5)]), 7);
>     checkUchar(program, callFunction(program, "foo", [makeUchar(program, 0), makeUint(program, 3)]), 0);
> }
> 
>@@ -7293,14 +7444,14 @@ tests.textureSample = function() {
>     checkFloat(program, callFunction(program, "foo14", [texture2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo14", [texture2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo14", [texture2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height)]), (34 + 35 + 38 + 39) / 4);
>-    checkFloat(program, callFunction(program, "foo14", [texture2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>-    checkFloat(program, callFunction(program, "foo14", [texture2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((12 + 13 + 20 + 21) / 4) + ((34 + 35 + 38 + 39) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo14", [texture2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>+    checkFloat(program, callFunction(program, "foo14", [texture2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((12 + 13 + 20 + 21) / 4) + ((34 + 35 + 38 + 39) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo15", [texture2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 0), makeInt(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo15", [texture2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>     checkFloat(program, callFunction(program, "foo15", [texture2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>     checkFloat(program, callFunction(program, "foo15", [texture2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (35 + 36 + 39 + 40) / 4);
>-    checkFloat(program, callFunction(program, "foo15", [texture2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>-    checkFloat(program, callFunction(program, "foo15", [texture2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((13 + 14 + 21 + 22) / 4) + ((35 + 36 + 39 + 40) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo15", [texture2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>+    checkFloat(program, callFunction(program, "foo15", [texture2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((13 + 14 + 21 + 22) / 4) + ((35 + 36 + 39 + 40) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo16", [texture2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo16", [texture2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1)]), (34 + 35 + 38 + 39) / 4);
>     checkFloat(program, callFunction(program, "foo16", [texture2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0.5)]), (12 + 13 + 20 + 21) / 4);
>@@ -7326,25 +7477,25 @@ tests.textureSample = function() {
>     checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height)]), (34 + 35 + 38 + 39) / 4);
>-    checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>-    checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((12 + 13 + 20 + 21) / 4) + ((34 + 35 + 38 + 39) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>+    checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((12 + 13 + 20 + 21) / 4) + ((34 + 35 + 38 + 39) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0)]), (54 + 55 + 62 + 63) / 4);
>     checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height)]), (54 + 55 + 62 + 63) / 4);
>     checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height)]), (76 + 77 + 80 + 81) / 4);
>-    checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (54 + 55 + 62 + 63) / 4);
>-    checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((54 + 55 + 62 + 63) / 4) + ((76 + 77 + 80 + 81) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (54 + 55 + 62 + 63) / 4);
>+    checkFloat(program, callFunction(program, "foo20", [texture2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((54 + 55 + 62 + 63) / 4) + ((76 + 77 + 80 + 81) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 0), makeInt(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>     checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>     checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (35 + 36 + 39 + 40) / 4);
>-    checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>-    checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((13 + 14 + 21 + 22) / 4) + ((35 + 36 + 39 + 40) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>+    checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((13 + 14 + 21 + 22) / 4) + ((35 + 36 + 39 + 40) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 0), makeInt(program, 0)]), (54 + 55 + 62 + 63) / 4);
>     checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 1), makeInt(program, 0)]), (55 + 56 + 63 + 64) / 4);
>     checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (55 + 56 + 63 + 64) / 4);
>     checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (77 + 78 + 81 + 82) / 4);
>-    checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (55 + 56 + 63 + 64) / 4);
>-    checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((55 + 56 + 63 + 64) / 4) + ((77 + 78 + 81 + 82) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (55 + 56 + 63 + 64) / 4);
>+    checkFloat(program, callFunction(program, "foo21", [texture2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((55 + 56 + 63 + 64) / 4) + ((77 + 78 + 81 + 82) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo22", [texture2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo22", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 1)]), (34 + 35 + 38 + 39) / 4);
>     checkFloat(program, callFunction(program, "foo22", [texture2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0.5)]), (12 + 13 + 20 + 21) / 4);
>@@ -7372,7 +7523,7 @@ tests.textureSample = function() {
>     checkFloat(program, callFunction(program, "foo16", [texture2D, makeSampler(program, {minFilter: "linear", lodMinClamp: 1, lodMaxClamp: 1}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 2)]), (34 + 35 + 38 + 39) / 4);
>     checkFloat(program, callFunction(program, "foo16", [texture2D, makeSampler(program, {minFilter: "linear", lodMinClamp: 1, lodMaxClamp: 1}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0)]), (34 + 35 + 38 + 39) / 4);
>     checkFloat(program, callFunction(program, "foo14", [texture2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height)]), (34 + 35 + 38 + 39) / 4);
>-    checkFloat(program, callFunction(program, "foo14", [texture2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear", maxAnisotropy: 2}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 4 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, (4/3) / texture2D.ePtr.loadValue().height)]), (34 + 35 + 38 + 39) / 4);
>+    checkFloat(program, callFunction(program, "foo14", [texture2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear", maxAnisotropy: 2}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 4 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, (4/3) / texture2D.ePtr.loadValue().height)]), (34 + 35 + 38 + 39) / 4);
>     let texture1DInt4 = make1DTexture(program, [[[1, 2, 3, 4], [100, 200, 300, 400], [101, 202, 301, 401], [13, 14, 15, 16]], [[17, 18, 19, 20], [21, 22, 23, 24]], [[25, 26, 27, 28]]], "int4");
>     checkInt(program, callFunction(program, "foo24", [texture1DInt4, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5)]), 100);
>     checkInt(program, callFunction(program, "foo25", [texture1DInt4, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5)]), 201);
>@@ -7414,14 +7565,14 @@ tests.textureSample = function() {
>     checkFloat(program, callFunction(program, "foo35", [textureDepth2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo35", [textureDepth2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo35", [textureDepth2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height)]), (34 + 35 + 38 + 39) / 4);
>-    checkFloat(program, callFunction(program, "foo35", [textureDepth2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>-    checkFloat(program, callFunction(program, "foo35", [textureDepth2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((12 + 13 + 20 + 21) / 4) + ((34 + 35 + 38 + 39) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo35", [textureDepth2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>+    checkFloat(program, callFunction(program, "foo35", [textureDepth2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((12 + 13 + 20 + 21) / 4) + ((34 + 35 + 38 + 39) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo36", [textureDepth2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 0), makeInt(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo36", [textureDepth2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>     checkFloat(program, callFunction(program, "foo36", [textureDepth2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>     checkFloat(program, callFunction(program, "foo36", [textureDepth2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (35 + 36 + 39 + 40) / 4);
>-    checkFloat(program, callFunction(program, "foo36", [textureDepth2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>-    checkFloat(program, callFunction(program, "foo36", [textureDepth2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((13 + 14 + 21 + 22) / 4) + ((35 + 36 + 39 + 40) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo36", [textureDepth2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>+    checkFloat(program, callFunction(program, "foo36", [textureDepth2D, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((13 + 14 + 21 + 22) / 4) + ((35 + 36 + 39 + 40) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo37", [textureDepth2D, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo37", [textureDepth2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1)]), (34 + 35 + 38 + 39) / 4);
>     checkFloat(program, callFunction(program, "foo37", [textureDepth2D, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0.5)]), (12 + 13 + 20 + 21) / 4);
>@@ -7447,25 +7598,25 @@ tests.textureSample = function() {
>     checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height)]), (34 + 35 + 38 + 39) / 4);
>-    checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>-    checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((12 + 13 + 20 + 21) / 4) + ((34 + 35 + 38 + 39) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (12 + 13 + 20 + 21) / 4);
>+    checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((12 + 13 + 20 + 21) / 4) + ((34 + 35 + 38 + 39) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0)]), (54 + 55 + 62 + 63) / 4);
>     checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height)]), (54 + 55 + 62 + 63) / 4);
>     checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height)]), (76 + 77 + 80 + 81) / 4);
>-    checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (54 + 55 + 62 + 63) / 4);
>-    checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((54 + 55 + 62 + 63) / 4) + ((76 + 77 + 80 + 81) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height)]), (54 + 55 + 62 + 63) / 4);
>+    checkFloat(program, callFunction(program, "foo41", [textureDepth2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height)]), (((54 + 55 + 62 + 63) / 4) + ((76 + 77 + 80 + 81) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 0), makeInt(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>     checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>     checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (35 + 36 + 39 + 40) / 4);
>-    checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>-    checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((13 + 14 + 21 + 22) / 4) + ((35 + 36 + 39 + 40) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (13 + 14 + 21 + 22) / 4);
>+    checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((13 + 14 + 21 + 22) / 4) + ((35 + 36 + 39 + 40) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 0), makeInt(program, 0)]), (54 + 55 + 62 + 63) / 4);
>     checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 0), makeInt(program, 1), makeInt(program, 0)]), (55 + 56 + 63 + 64) / 4);
>     checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 1 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 1 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (55 + 56 + 63 + 64) / 4);
>     checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, 2 / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, 2 / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (77 + 78 + 81 + 82) / 4);
>-    checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (55 + 56 + 63 + 64) / 4);
>-    checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((55 + 56 + 63 + 64) / 4) + ((77 + 78 + 81 + 82) / 4)) / 2);
>+    checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.25) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (55 + 56 + 63 + 64) / 4);
>+    checkFloat(program, callFunction(program, "foo42", [textureDepth2DArray, makeSampler(program, {minFilter: "linear", mipmapFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 1), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().width), makeFloat(program, 0), makeFloat(program, 0), makeCastedFloat(program, Math.pow(2, 0.5) / texture2D.ePtr.loadValue().height), makeInt(program, 1), makeInt(program, 0)]), (((55 + 56 + 63 + 64) / 4) + ((77 + 78 + 81 + 82) / 4)) / 2);
>     checkFloat(program, callFunction(program, "foo43", [textureDepth2DArray, makeSampler(program, {magFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0)]), (12 + 13 + 20 + 21) / 4);
>     checkFloat(program, callFunction(program, "foo43", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 1)]), (34 + 35 + 38 + 39) / 4);
>     checkFloat(program, callFunction(program, "foo43", [textureDepth2DArray, makeSampler(program, {minFilter: "linear"}), makeFloat(program, 0.5), makeFloat(program, 0.5), makeFloat(program, 0), makeFloat(program, 0.5)]), (12 + 13 + 20 + 21) / 4);
>@@ -7946,13 +8097,6 @@ function* doTest(testFilter)
>         throw new Error("Test setup is incomplete.");
>     let before = preciseTime();
> 
>-    print("Compiling standard library...");
>-    const compileBefore = preciseTime();
>-    yield;
>-    prepare();
>-    const compileAfter = preciseTime();
>-    print(`    OK, took ${Math.round((compileAfter - compileBefore) * 1000)} ms`);
>-
>     let names = [];
>     for (let s in tests)
>         names.push(s);
>@@ -7978,7 +8122,7 @@ function* doTest(testFilter)
>     print("That took " + (after - before) * 1000 + " ms.");
> }
> 
>-if (!this.window) {
>+if (!this.window && !this.runningInCocoaHost) {
>     Error.stackTraceLimit = Infinity;
>     for (let _ of doTest(testFilter)) { }
> }
>diff --git a/Tools/WebGPUShadingLanguageRI/Type.js b/Tools/WebGPUShadingLanguageRI/Type.js
>index 2db158d099b326a93e7335e4e696138c5edbefdb..ac99d38ace1cfeb342a8eff04487f9de3b4038b3 100644
>--- a/Tools/WebGPUShadingLanguageRI/Type.js
>+++ b/Tools/WebGPUShadingLanguageRI/Type.js
>@@ -36,6 +36,11 @@ class Type extends Node {
>     get isEnum() { return false; }
>     get isPrimitive() { return false; }
>     
>+    get arrayRefType()
>+    {
>+        return new ArrayRefType(this.origin, "thread", this);
>+    }
>+    
>     // Have to call these on the unifyNode.
>     argumentForAndOverload(origin, value)
>     {

Actions: View | Formatted Diff | Diff

Attachments on bug 187735: 345174 | 345185 | 345208 | 345219 | 345220 | 348257 | 348407 | 348703 | 348852 | 348869 | 348884 | 349505 | 349524 | 349612 | 349696 | 349733 | 349735 | 349817 | 349826 | 349839 | 349939 | 349957 | 350095 | 350174