Attachment #345819 for bug #187988

View Details Raw Unified Return to Bug 187988

| Differences between



2018-07-25  Thomas Denney  <tdenney@apple.com>

        [WHLSL] Remove generics from the interpreter
        https://bugs.webkit.org/show_bug.cgi?id=187988

        Reviewed by NOBODY (OOPS!).

        * WebGPUShadingLanguageRI/All.js:
        * WebGPUShadingLanguageRI/BuiltinVectorCasts.js: Added.
        (BuiltinVectorCasts):
        (BuiltinVectorCasts.prototype.get baseTypeName):
        (BuiltinVectorCasts.prototype.get parameterSizes):
        (BuiltinVectorCasts.prototype.get outputSize):
        (BuiltinVectorCasts.prototype.toString):
        (BuiltinVectorCasts.functions):
        (BuiltinVectorCasts._vectorParameterSizesForMaximumSize):
        (BuiltinVectorCasts.prototype.instantiateImplementation):
        * WebGPUShadingLanguageRI/BuiltinVectorEqualityOperator.js: Copied from Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js.
        (BuiltinVectorEqualityOperator):
        (BuiltinVectorEqualityOperator.prototype.get baseTypeName):
        (BuiltinVectorEqualityOperator.prototype.get size):
        (BuiltinVectorEqualityOperator.prototype.toString):
        (BuiltinVectorEqualityOperator.functions):
        (BuiltinVectorEqualityOperator.prototype.instantiateImplementation):
        * WebGPUShadingLanguageRI/BuiltinVectorGetter.js: Copied from Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js.
        (BuiltinVectorGetter):
        (BuiltinVectorGetter.prototype.get baseTypeName):
        (BuiltinVectorGetter.prototype.get size):
        (BuiltinVectorGetter.prototype.get elementName):
        (BuiltinVectorGetter.prototype.get index):
        (BuiltinVectorGetter.prototype.toString):
        (BuiltinVectorGetter.functions):
        (BuiltinVectorGetter.prototype.instantiateImplementation):
        * WebGPUShadingLanguageRI/BuiltinVectorIndexGetter.js: Copied from Tools/WebGPUShadingLanguageRI/LiteralTypeChecker.js.
        (BuiltinVectorIndexGetter):
        (BuiltinVectorIndexGetter.prototype.get baseTypeName):
        (BuiltinVectorIndexGetter.prototype.get size):
        (BuiltinVectorIndexGetter.prototype.toString):
        (BuiltinVectorIndexGetter.functions):
        (BuiltinVectorIndexGetter.prototype.instantiateImplementation):
        * WebGPUShadingLanguageRI/BuiltinVectorIndexSetter.js: Added.
        (BuiltinVectorIndexSetter):
        (BuiltinVectorIndexSetter.prototype.get baseTypeName):
        (BuiltinVectorIndexSetter.prototype.get size):
        (BuiltinVectorIndexSetter.prototype.get elementName):
        (BuiltinVectorIndexSetter.prototype.get index):
        (BuiltinVectorIndexSetter.prototype.toString):
        (BuiltinVectorIndexSetter.functions):
        (BuiltinVectorIndexSetter.prototype.instantiateImplementation):
        * WebGPUShadingLanguageRI/BuiltinVectorSetter.js: Added.
        (BuiltinVectorSetter):
        (BuiltinVectorSetter.prototype.get baseTypeName):
        (BuiltinVectorSetter.prototype.get size):
        (BuiltinVectorSetter.prototype.get elementName):
        (BuiltinVectorSetter.prototype.get index):
        (BuiltinVectorSetter.prototype.toString):
        (BuiltinVectorSetter.functions):
        (BuiltinVectorSetter.prototype.instantiateImplementation):
        * WebGPUShadingLanguageRI/CallExpression.js:
        (CallExpression.resolve):
        (CallExpression.prototype.resolve):
        (CallExpression.prototype._resolveToOperatorAnderIndexer):
        (CallExpression.prototype._resolveToOperatorLength):
        (CallExpression.prototype.toString):
        (CallExpression):
        * WebGPUShadingLanguageRI/Checker.js:
        (Checker.prototype._finishVisitingPropertyAccess):
        * WebGPUShadingLanguageRI/Func.js:
        (Func.prototype.toDeclString):
        * WebGPUShadingLanguageRI/FuncInstantiator.js:
        (FuncInstantiator.prototype.getUnique.FindTypeVariable.prototype.visitTypeRef): Deleted.
        (FuncInstantiator.prototype.getUnique.FindTypeVariable.prototype.visitTypeVariable): Deleted.
        (FuncInstantiator.prototype.getUnique.FindTypeVariable): Deleted.
        * WebGPUShadingLanguageRI/Intrinsics.js:
        (Intrinsics):
        * WebGPUShadingLanguageRI/LiteralTypeChecker.js:
        (LiteralTypeChecker.prototype.visitGenericLiteralType):
        (LiteralTypeChecker):
        * WebGPUShadingLanguageRI/NativeType.js:
        (NativeType.prototype.toString):
        (NativeType):
        * WebGPUShadingLanguageRI/NativeTypeInstance.js:
        (NativeTypeInstance.prototype.toString):
        (NativeTypeInstance):
        * WebGPUShadingLanguageRI/OperatorAnderIndex.js: Added.
        (OperatorAnderIndexer):
        (OperatorAnderIndexer.prototype.get addressSpace):
        (OperatorAnderIndexer.prototype.get baseTypeName):
        (OperatorAnderIndexer.prototype.toString):
        (OperatorAnderIndexer.functions):
        (OperatorAnderIndexer.prototype.instantiateImplementation):
        * WebGPUShadingLanguageRI/OperatorArrayRefLength.js: Renamed from Tools/WebGPUShadingLanguageRI/DoubleLiteralType.js.
        (OperatorArrayRefLength):
        (OperatorArrayRefLength.prototype.get addressSpace):
        (OperatorArrayRefLength.prototype.get baseTypeName):
        (OperatorArrayRefLength.prototype.toString):
        (OperatorArrayRefLength.prototype.instantiateImplementation):
        * WebGPUShadingLanguageRI/OperatorBool.js: Copied from Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js.
        (OperatorBool):
        (OperatorBool.prototype.get baseTypeName):
        (OperatorBool.prototype.toString):
        (OperatorBool.functions):
        (OperatorBool.prototype.instantiateImplementation):
        * WebGPUShadingLanguageRI/Parse.js:
        (parseTerm):
        (parseTypeDef):
        (isCallExpression):
        (parseFuncDecl):
        (parseStructType):
        (parseNative):
        (parse):
        (parseProtocolRef): Deleted.
        (parseTypeParameters): Deleted.
        (parseTypeArguments): Deleted.
        (parseProtocolFuncDecl): Deleted.
        (parseProtocolDecl): Deleted.
        * WebGPUShadingLanguageRI/Prepare.js:
        (let.prepare):
        * WebGPUShadingLanguageRI/SPIRV.html:
        * WebGPUShadingLanguageRI/SPIRVCodegen.js:
        (ConstantFinder.prototype.visitGenericLiteralType):
        (ConstantFinder):
        (generateSPIRV):
        * WebGPUShadingLanguageRI/StandardLibrary.js:
        (addFunctionsFromClass):
        (restricted.operator.T.T): Deleted.
        (operator.T.Equatable.bool): Deleted.
        (operator.T.vec2.T): Deleted.
        (bool.operator.T.Equatable): Deleted.
        (thread.T.operator.T): Deleted.
        (operator.T.vec3.T): Deleted.
        (operator.T.vec4.T): Deleted.
        (uint.length): Deleted.
        * WebGPUShadingLanguageRI/StructType.js:
        (StructType.prototype.get isStruct):
        (StructType.prototype.toString):
        (StructType):
        * WebGPUShadingLanguageRI/SwizzleOp.js:
        (SwizzleOp):
        (SwizzleOp.prototype.get baseTypeName):
        (SwizzleOp.prototype.toString):
        (SwizzleOp.functions.):
        (SwizzleOp.functions):
        (SwizzleOp.prototype.instantiateImplementation):
        (SwizzleOp.allSwizzleOperators.): Deleted.
        (SwizzleOp.allSwizzleOperators): Deleted.
        * WebGPUShadingLanguageRI/SynthesizeArrayOperatorLength.js: Renamed from Tools/WebGPUShadingLanguageRI/DoubleLiteral.js.
        (synthesizeArrayOperatorLength.FindArrayTypes.prototype.visitArrayType):
        (synthesizeArrayOperatorLength.FindArrayTypes):
        (synthesizeArrayOperatorLength):
        * WebGPUShadingLanguageRI/SynthesizeCopyConstructorOperator.js: Copied from Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js.
        (synthesizeCopyConstructorOperator.FindAllTypes.prototype.visitNativeType):
        (synthesizeCopyConstructorOperator.FindAllTypes.prototype.visitStructType):
        (synthesizeCopyConstructorOperator.FindAllTypes.prototype.visitElementalType):
        (synthesizeCopyConstructorOperator.FindAllTypes):
        (synthesizeCopyConstructorOperator):
        * WebGPUShadingLanguageRI/SynthesizeDefaultConstructorOperator.js: Copied from Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js.
        (synthesizeDefaultConstructorOperator.FindAllTypes.prototype.visitNativeType):
        (synthesizeDefaultConstructorOperator.FindAllTypes.prototype.visitStructType):
        (synthesizeDefaultConstructorOperator.FindAllTypes.prototype.visitElementalType):
        (synthesizeDefaultConstructorOperator.FindAllTypes):
        (synthesizeDefaultConstructorOperator):
        * WebGPUShadingLanguageRI/Test.html:
        * WebGPUShadingLanguageRI/Test.js:
        (makeDouble): Deleted.
        (checkDouble): Deleted.
        * WebGPUShadingLanguageRI/Type.js:
        (Type.prototype.get isStruct):
        * WebGPUShadingLanguageRI/TypeDef.js:
        (TypeDef.prototype.toString):
        (TypeDef):
        * WebGPUShadingLanguageRI/TypeRef.js:
        (TypeRef.prototype.toString):
        (TypeRef):
        * WebGPUShadingLanguageRI/index.html:

2018-07-24  Thomas Denney  <tdenney@apple.com>

        Remove support for the double type from WHLSL
        https://bugs.webkit.org/show_bug.cgi?id=187977

        Reviewed by Myles C. Maxfield.

        * WebGPUShadingLanguageRI/All.js: Removed DoubleLiteral.js and DoubleLiteralType.js include.
        * WebGPUShadingLanguageRI/DoubleLiteral.js: Removed.
        * WebGPUShadingLanguageRI/DoubleLiteralType.js: Removed.
        * WebGPUShadingLanguageRI/Intrinsics.js: Removed double arithmetic functions.
        * WebGPUShadingLanguageRI/Parse.js:
        (parseTerm): Removed parsing of double literals.
        * WebGPUShadingLanguageRI/SPIRV.html: Removed DoubleLiteral.js and DoubleLiteralType.js include.
        * WebGPUShadingLanguageRI/SPIRVCodegen.js: Removed double type logic.
        * WebGPUShadingLanguageRI/StandardLibrary.js: Removed double type declarations.
        * WebGPUShadingLanguageRI/Test.html: Removed DoubleLiteral.js and DoubleLiteralType.js include.
        * WebGPUShadingLanguageRI/Test.js: Removed tests that test doubles or ported them to use floats.
        * WebGPUShadingLanguageRI/index.html: Removed DoubleLiteral.js and DoubleLiteralType.js include.

2018-07-24  Daniel Bates  <dabates@apple.com>

        Move-constructing NeverDestroyed should move construct underlying object instead of copy constructing it



load("CreateLiteral.js");
load("CreateLiteralType.js");
load("PropertyAccessExpression.js");
load("SwizzleOp.js");

load("AddressSpace.js");
load("AnonymousVariable.js");

load("Check.js");
load("CheckLiteralTypes.js");
load("CheckLoops.js");
load("CheckRecursiveTypes.js");
load("CheckRecursion.js");
load("CheckRecursiveTypes.js");
load("CheckReturns.js");
load("CheckUnreachableCode.js");
load("CheckWrapped.js");

load("ConstexprTypeParameter.js");
load("Continue.js");
load("ConvertPtrToArrayRefExpression.js");
load("DereferenceExpression.js");
load("DoWhileLoop.js");
load("DotExpression.js");
load("DereferenceExpression.js");
load("DoubleLiteralType.js");
load("EArrayRef.js");
load("EBuffer.js");
load("EBufferBuilder.js");

load("NormalUsePropertyResolver.js");
load("NullLiteral.js");
load("NullType.js");
load("OperatorAnderIndex.js");
load("OperatorArrayRefLength.js");
load("OperatorBool.js");
load("BuiltinVectorCasts.js");
load("BuiltinVectorGetter.js");
load("BuiltinVectorSetter.js");
load("BuiltinVectorIndexGetter.js");
load("BuiltinVectorIndexSetter.js");
load("BuiltinVectorEqualityOperator.js");
load("OriginKind.js");
load("OverloadResolutionFailure.js");
load("Parse.js");
load("Prepare.js");
load("PropertyResolver.js");
load("Program.js");
load("ProgramWithUnnecessaryThingsRemoved.js");
load("PropertyResolver.js");
load("Protocol.js");
load("ProtocolDecl.js");
load("ProtocolFuncDecl.js");

load("Substitution.js");
load("SwitchCase.js");
load("SwitchStatement.js");
load("SynthesizeArrayOperatorLength.js");
load("SynthesizeEnumFunctions.js");
load("SynthesizeStructAccessors.js");
load("SynthesizeCopyConstructorOperator.js");
load("SynthesizeDefaultConstructorOperator.js");
load("TrapStatement.js");
load("TypeDef.js");
load("TypeDefResolver.js");



/*
 * Copyright (C) 2017 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";

class BuiltinVectorCasts {
    constructor(baseTypeName, parameterSizes)
    {
        this._baseTypeName = baseTypeName;
        this._parameterSizes = parameterSizes;
    }

    get baseTypeName() { return this._baseTypeName; }
    get parameterSizes() { return this._parameterSizes; }
    get outputSize()
    {
        let sum = 0;
        for (let paramSize of this.parameterSizes)
            sum += paramSize;
        return sum;
    }

    toString()
    {
        return `native operator ${this.baseTypeName}${this.outputSize}(${this.parameterSizes.map(x => x == 1 ? this.baseTypeName : this.baseTypeName + x).join(",")})`;
    }

    static functions()
    {
        if (!this._functions) {
            this._functions = [];
        
            const typeNames = [ "uint", "int", "float" ];
            const sizes = [ 2, 3, 4 ];

            for (let typeName of typeNames) {
                for (let size of sizes) {
                    for (let paramSizes of this._vectorParameterSizesForMaximumSize(size))
                        this._functions.push(new BuiltinVectorCasts(typeName, paramSizes));
                }
            }
        }
        return this._functions;
    }

    static _vectorParameterSizesForMaximumSize(maxSize)
    {
        let variants = [ [ maxSize ] ];
        for (let splitPoint = 1; splitPoint < maxSize; splitPoint++) {
            for (let v of BuiltinVectorCasts._vectorParameterSizesForMaximumSize(maxSize - splitPoint))
                variants.push([ splitPoint ].concat(v));
        }
        return variants;
    }

    instantiateImplementation(func)
    {
        func.implementation = (args) => {
            const result = new EPtr(new EBuffer(this.outputSize), 0);
            let offset = 0;
            for (let i = 0; i < args.length; i++) {
                for (let j = 0; j < this.parameterSizes[i]; j++)
                    result.set(offset++, args[i].get(j));
            }
            return result;
        };
        func.implementationData = this;
    }
}



/*
 * Copyright (C) 2017 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";

class BuiltinVectorEqualityOperator {
    constructor(baseTypeName, size)
    {
        this._baseTypeName = baseTypeName;
        this._size = size;
    }

    get baseTypeName() { return this._baseTypeName; }
    get size() { return this._size; }

    toString()
    {
        return `native bool operator==(${this.baseTypeName}${this.size},${this.baseTypeName}${this.size})`;
    }

    static functions()
    {
        if (!this._functions) {
            this._functions = [];
        
            const typeNames = [ "uint", "int", "float" ];
            const sizes = [ 2, 3, 4 ];

            for (let typeName of typeNames) {
                for (let size of sizes)
                    this._functions.push(new BuiltinVectorEqualityOperator(typeName, size));
            }
        }
        return this._functions;
    }

    instantiateImplementation(func)
    {
        func.implementation = ([ref1, ref2], node) => {
            for (let i = 0; i < this.size; i++) {
                if (ref1.get(i) != ref2.get(i))
                    return EPtr.box(false);
            }
            return EPtr.box(true);
        };
        func.implementationData = this;
    }
}



/*
 * Copyright (C) 2017 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";

class BuiltinVectorGetter {
    constructor(baseTypeName, size, elementName, index)
    {
        this._baseTypeName = baseTypeName;
        this._size = size;
        this._elementName = elementName;
        this._index = index;
    }

    get baseTypeName() { return this._baseTypeName; }
    get size() { return this._size; }
    get elementName() { return this._elementName; }
    get index() { return this._index; }

    toString()
    {
        return `native ${this.baseTypeName} operator.${this.elementName}(${this.baseTypeName}${this.size})`;
    }

    static functions()
    {
        if (!this._functions) {
            this._functions = [];
        
            const typeNames = [ "uint", "int", "float" ];
            const sizes = [ 2, 3, 4 ];
            const elements = [ "x", "y", "z", "w" ];

            for (let typeName of typeNames) {
                for (let size of sizes) {
                    for (let i = 0; i < size; i++)
                        this._functions.push(new BuiltinVectorGetter(typeName, size, elements[i], i));
                }
            }
        }
        return this._functions;
    }

    instantiateImplementation(func)
    {
        func.implementation = ([vec], node) => {
            return EPtr.box(vec.get(this.index));
        };
        func.implementationData = this;
    }
}



/*
 * Copyright (C) 2017 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";

class BuiltinVectorIndexGetter {
    constructor(baseTypeName, size)
    {
        this._baseTypeName = baseTypeName;
        this._size = size;
    }

    get baseTypeName() { return this._baseTypeName; }
    get size() { return this._size; }

    toString()
    {
        return `native ${this.baseTypeName} operator[](${this.baseTypeName}${this.size},uint)`;
    }

    static functions()
    {
        if (!this._allIndexGetters) {
            this._allIndexGetters = [];
        
            const typeNames = [ "uint", "int", "float" ];
            const sizes = [ 2, 3, 4 ];

            for (let typeName of typeNames) {
                for (let size of sizes)
                    this._allIndexGetters.push(new BuiltinVectorIndexGetter(typeName, size));
            }
        }
        return this._allIndexGetters;
    }

    instantiateImplementation(func)
    {
        func.implementation = ([vec, index], node) => {
            const indexValue = index.loadValue();
            if (indexValue >= 0 && indexValue < this.size)
                return EPtr.box(vec.get(index.loadValue()));
            else
                throw new Error(`${indexValue} out of bounds for vector of size ${this.size}`);
        };
        func.implementationData = this;
    }
}



/*
 * Copyright (C) 2017 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";

class BuiltinVectorIndexSetter {
    constructor(baseTypeName, size)
    {
        this._baseTypeName = baseTypeName;
        this._size = size;
    }

    get baseTypeName() { return this._baseTypeName; }
    get size() { return this._size; }
    get elementName() { return this._elementName; }
    get index() { return this._index; }

    toString()
    {
        return `native ${this.baseTypeName}${this.size} operator[]=(${this.baseTypeName}${this.size},uint32,${this.baseTypeName})`;
    }

    static functions()
    {
        if (!this._functions) {
            this._functions = [];
        
            const typeNames = [ "uint", "int", "float" ];
            const sizes = [ 2, 3, 4 ];

            for (let typeName of typeNames) {
                for (let size of sizes)
                    this._functions.push(new BuiltinVectorIndexSetter(typeName, size));
            }
        }
        return this._functions;
    }

    instantiateImplementation(func)
    {
        func.implementation = ([base, index, value], node) => {
            const indexValue = index.loadValue();
            if (indexValue >= 0 && indexValue < this.size) {
                let result = new EPtr(new EBuffer(this.size), 0);
                result.copyFrom(base, this.size);
                result.plus(indexValue).copyFrom(value, 1);
                return result;
            } else
                throw new Error(`${indexValue} out of bounds for vector of size ${this.size}`);
        };
        func.implementationData = this;
    }
}



/*
 * Copyright (C) 2017 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";

class BuiltinVectorSetter {
    constructor(baseTypeName, size, elementName, index)
    {
        this._baseTypeName = baseTypeName;
        this._size = size;
        this._elementName = elementName;
        this._index = index;
    }

    get baseTypeName() { return this._baseTypeName; }
    get size() { return this._size; }
    get elementName() { return this._elementName; }
    get index() { return this._index; }

    toString()
    {
        return `native ${this.baseTypeName}${this.size} operator.${this.elementName}=(${this.baseTypeName}${this.size},${this.baseTypeName})`;
    }

    static functions()
    {
        if (!this._functions) {
            this._functions = [];
        
            const typeNames = [ "uint", "int", "float" ];
            const sizes = [ 2, 3, 4 ];
            const elements = [ "x", "y", "z", "w" ];

            for (let typeName of typeNames) {
                for (let size of sizes) {
                    for (let i = 0; i < size; i++)
                        this._functions.push(new BuiltinVectorSetter(typeName, size, elements[i], i));
                }
            }
        }
        return this._functions;
    }

    instantiateImplementation(func)
    {
        func.implementation = ([base, value], node) => {
            let result = new EPtr(new EBuffer(this.size), 0);
            result.copyFrom(base, this.size);
            result.plus(this.index).copyFrom(value, 1);
            return result;
        };
        func.implementationData = this;
    }
}



    get isCast() { return this._isCast; }
    get returnType() { return this._returnType; }
    
    static resolve(origin, possibleOverloads, typeParametersInScope, name, typeArguments, argumentList, argumentTypes, returnType, uintType)
    {
        let call = new CallExpression(origin, name, typeArguments, argumentList);
        call.argumentTypes = argumentTypes.map(argument => argument.visit(new AutoWrapper()));
        call.possibleOverloads = possibleOverloads;
        if (returnType)
            call.setCastData(returnType);
        return {call, resultType: call.resolve(possibleOverloads, typeParametersInScope, typeArguments, uintType)};
    }
    
    resolve(possibleOverloads, typeParametersInScope, typeArguments, uintType)
    {
        if (!possibleOverloads)
            throw new WTypeError(this.origin.originString, "Did not find any functions named " + this.name);

        if (!overload) {
            overload = resolveOverloadImpl(
                possibleOverloads, this.typeArguments, this.argumentTypes, this.returnType);

            if (!overload.func && this.name == "operator&[]")
                return this._resolveToOperatorAnderIndexer(uintType);

            if (!overload.func && this.name == "operator.length")
                return this._resolveToOperatorLength(uintType);
            
            if (!overload.func) {
                failures.push(...overload.failures);
                let message = "Did not find function named " + this.name + " for call with ";

        }
        return this.resolveToOverload(overload);
    }

    _resolveToOperatorAnderIndexer(uintType)
    {
        let arrayRefType = this.argumentTypes[0];
        if (!arrayRefType.isArrayRef)
            throw new WTypeError(this.origin.originString, `Expected ${arrayRefType} to be an array ref type for operator&[]`);
            
        let indexType = this.argumentTypes[1];
        const addressSpace = arrayRefType.addressSpace;
        
        // The later checkLiteralTypes stage will verify that the literal can be represented as a uint
        uintType = TypeRef.wrap(uintType);
        indexType.type = uintType;

        const elementType = this.argumentTypes[0].elementType;
        this.resultType = this._returnType = TypeRef.wrap(new PtrType(this.origin, addressSpace, TypeRef.wrap(elementType)))
        
        let arrayRefAccessor = new OperatorAnderIndexer(this.returnType.toString(), addressSpace);
        let nativeFunc = new NativeFunc(this.origin, "operator&[]", this.resultType, [], [
            new FuncParameter(this.origin, null, arrayRefType),
            new FuncParameter(this.origin, null, uintType)
        ], false, null);

        arrayRefAccessor.instantiateImplementation(nativeFunc);

        this.func = nativeFunc;
        this.actualTypeArguments = [];
        this.instantiatedActualTypeArguments = this.actualTypeArguments;
        
        return this.resultType;
    }

    _resolveToOperatorLength(uintType)
    {
        this.resultType = this._returnType = TypeRef.wrap(uintType);
                
        if (this.argumentTypes[0].isArray) {
            const arrayType = this.argumentTypes[0];
            this.func = new NativeFunc(this.origin, "operator.length", this.resultType, [], [
                new FuncParameter(this.origin, null, arrayType)
            ], false, null);
            this.func.implementation = (args, node) => EPtr.box(arrayType.numElementsValue);
        } else if (this.argumentTypes[0].isArrayRef) {
            const arrayRefType = this.argumentTypes[0];
            const addressSpace = arrayRefType.addressSpace;
            const operatorLength = new OperatorArrayRefLength(arrayRefType.toString(), addressSpace);
            this.func = new NativeFunc(this.origin, "operator.length", this.resultType, [], [
                new FuncParameter(this.origin, null, arrayRefType)
            ], false, null);
            operatorLength.instantiateImplementation(this.func);
        } else
            throw new WTypeError(this.origin.originString, `Expected ${this.argumentTypes[0]} to be array/array ref type for operator.length`);

        
        this.actualTypeArguments = this.instantiatedActualTypeArguments = [];
        return this.resultType;
    }
    
    resolveToOverload(overload)
    {

    toString()
    {
        return (this.isCast ? "operator " + this.returnType : this.name) +
            // "<" + this.typeArguments + ">" +
            (this.actualTypeArguments ? "<<" + this.actualTypeArguments + ">>" : "") +
            "(" + this.argumentList + ")";
    }



        try {
            let result = CallExpression.resolve(
                node.origin, node.possibleGetOverloads, this._currentStatement.typeParameters,
                node.getFuncName, [], [node.base, ...extraArgs], [baseType, ...extraArgTypes], null, this._program.types.get("uint32"));
            node.callForGet = result.call;
            node.resultTypeForGet = result.resultType;
        } catch (e) {

            let result = CallExpression.resolve(
                node.origin, node.possibleAndOverloads, this._currentStatement.typeParameters,
                node.andFuncName, [], [baseForAnd, ...extraArgs], [typeForAnd, ...extraArgTypes],
                null, this._program.types.get("uint32"));
            node.callForAnd = result.call;
            node.resultTypeForAnd = result.resultType.unifyNode.returnTypeFromAndOverload(node.origin);
        } catch (e) {

        try {
            let result = CallExpression.resolve(
                node.origin, node.possibleSetOverloads, this._currentStatement.typeParameters,
                node.setFuncName, [], [node.base, ...extraArgs, null], [baseType, ...extraArgTypes, node.resultType], null, this._program.types.get("uint32"));
            node.callForSet = result.call;
            if (!result.resultType.equals(baseType))
                throw new WTypeError(node.origin.originString, "Result type of setter " + result.call.func + " is not the base type " + baseType);



/*
 * Copyright (C) 2017 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";

let DoubleLiteral = createLiteral({
    literalClassName: "DoubleLiteral",
    preferredTypeName: "double",
    
    negConstexpr(origin)
    {
        return new IntLiteral(origin, -this.value);
    },
    
    createType(origin, value)
    {
        return new DoubleLiteralType(origin, value);
    }
});




/*
 * Copyright (C) 2017 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";

let DoubleLiteralType = createLiteralType({
    preferredTypeName: "double",
    
    verifyAsArgument(unificationContext)
    {
        let realThis = unificationContext.find(this);
        if (!realThis.isFloating)
            return {result: false, reason: "Cannot use double literal with non-floating type " + realThis};
        if (!realThis.canRepresent(this.value))
            return {result: false, reason: "Float literal " + this.value + " does not fit in type " + realThis};
        return {result: true};
    }
});



        if (this.shaderType)
            result += this.shaderType + " ";
        if (this.isCast)
            result += `operator ${this.returnType}`;
        else
            result += `${this.returnType} ${this.name}`;
        return result + "(" + this.parameters + ")";
    }
    

Lines 40-45 class FuncInstantiator { a/Tools/WebGPUShadingLanguageRI/FuncInstantiator.js_sec1
- a/Tools/WebGPUShadingLanguageRI/FuncInstantiator.js +3 lines
40	// resolutions on the original Program.	40	// resolutions on the original Program.
41	getUnique(func, typeArguments)	41	getUnique(func, typeArguments)
42	{	42	{
		43	if (!typeArguments)
		44	typeArguments = [];
		45
43	class FindTypeVariable extends Visitor {	46	class FindTypeVariable extends Visitor {
44	visitTypeRef(node)	47	visitTypeRef(node)
45	{	48	{



        // use "int" here, since we don't yet know that they are the same type.
        
        this._map.set(
            "native typedef void",
            type => {
                this.void = type;
                type.size = 0;

        }

        this._map.set(
            "native typedef int32",
            type => {
                this.int32 = type;
                type.isPrimitive = true;

            });

        this._map.set(
            "native typedef uint32",
            type => {
                this.uint32 = type;
                type.isPrimitive = true;

            });

        this._map.set(
            "native typedef uint8",
            type => {
                this.uint8 = type;
                type.isInt = true;

            });

        this._map.set(
            "native typedef float32",
            type => {
                this.float = type;
                type.isPrimitive = true;

                type.formatValueFromIntLiteral = value => value;
                type.formatValueFromUintLiteral = value => value;
                type.formatValueFromFloatLiteral = value => Math.fround(value);
                type.formatValueFromDoubleLiteral = value => Math.fround(value);
            });

        this._map.set(
            "native typedef bool",
            type => {
                this.double = type;
                type.isPrimitive = true;
                type.size = 1;
                type.isFloating = true;
                type.isNumber = true;
                type.canRepresent = value => true;
                type.populateDefaultValue = (buffer, offset) => buffer.set(offset, 0);
                type.formatValueFromIntLiteral = value => value;
                type.formatValueFromUintLiteral = value => value;
                type.formatValueFromFloatLiteral = value => value;
                type.formatValueFromDoubleLiteral = value => value;
            });

        this._map.set(
            "native typedef bool<>",
            type => {
                this.bool = type;
                type.isPrimitive = true;
                type.size = 1;
                type.populateDefaultValue = (buffer, offset) => buffer.set(offset, false);
            });

        const vectorTypes = [ "int", "uint", "float" ];
        for (let vectorType of vectorTypes) {
            for (let size = 2; size <= 4; size++) {
                const name = `${vectorType}${size}`;
                this._map.set(
                    `native typedef ${name}`,
                    type  => {
                        this[name] = type;
                        type.isPrimitive = true;
                        type.size = size;
                        type.populateDefaultValue = (buffer, offset) => {
                            for (let i = 0; i < size; i++) {
                                buffer.set(offset + i, 0);
                            }
                        }
                    }
                )
            }
        }
        
        this._map.set(
            "native operator int32(uint32)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() | 0);
            });
        
        this._map.set(
            "native operator<> int32(uint8)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() | 0);
            });
        
        this._map.set(
            "native operator int32(uint8)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() | 0);
            });
        
        this._map.set(
            "native operator int32(float)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() | 0);
            });
        
        this._map.set(
            "native operator uint32(int32)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() >>> 0);
            });
        
        this._map.set(
            "native operator<> uint32(uint8)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() >>> 0);
            });
        
        this._map.set(
            "native operator uint32(uint8)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() >>> 0);
            });
        
        this._map.set(
            "native operator uint32(float)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() >>> 0);
            });
        
        this._map.set(
            "native operator uint8(int32)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() & 0xff);
            });
        
        this._map.set(
            "native operator uint8(uint32)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() & 0xff);
            });
        
        this._map.set(
            "native operator uint8(float)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() & 0xff);
            });
        
        this._map.set(
            "native operator float(int32)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue() & 0xff);
            });
        
        this._map.set(
            "native operator<> float(double)",
            func => {
                func.implementation = ([value]) => EPtr.box(Math.fround(value.loadValue()));
            });
        
        this._map.set(
            "native operator float(uint32)",
            func => {
                func.implementation = ([value]) => EPtr.box(Math.fround(value.loadValue()));
            });
        
        this._map.set(
            "native operator float(uint8)",
            func => {
                func.implementation = ([value]) => EPtr.box(Math.fround(value.loadValue()));
            });
        
        this._map.set(
            "native int operator+(int,int)",
            func => {
                func.implementation = ([value]) => EPtr.box(Math.fround(value.loadValue()));
            });
        
        this._map.set(
            "native operator<> double(float)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue());
            });
        
        this._map.set(
            "native operator<> double(int32)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue());
            });
        
        this._map.set(
            "native operator<> double(uint32)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue());
            });
        
        this._map.set(
            "native operator<> double(uint8)",
            func => {
                func.implementation = ([value]) => EPtr.box(value.loadValue());
            });
        
        this._map.set(
            "native int operator+<>(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() + right.loadValue()) | 0);
            });
        
        this._map.set(
            "native uint operator+(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() + right.loadValue()) >>> 0);
            });
        
        this._map.set(
            "native float operator+(float,float)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(Math.fround(left.loadValue() + right.loadValue()));
            });
        
        this._map.set(
            "native int operator-(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() + right.loadValue());
            });
        
        this._map.set(
            "native int operator-<>(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() - right.loadValue()) | 0);
            });
        
        this._map.set(
            "native uint operator-(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() - right.loadValue()) >>> 0);
            });
        
        this._map.set(
            "native float operator-(float,float)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(Math.fround(left.loadValue() - right.loadValue()));
            });
        
        this._map.set(
            "native int operator*(int,int)",
            func => {
                func.implementation = ([left, right]) => {
                    return EPtr.box((left.loadValue() * right.loadValue()) | 0);
                };
        
        this._map.set(
            "native int operator*<>(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() * right.loadValue()) | 0);
            });
        
        this._map.set(
            "native uint operator*(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() * right.loadValue()) >>> 0);
            });
        
        this._map.set(
            "native float operator*(float,float)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(Math.fround(left.loadValue() * right.loadValue()));
            });
        
        this._map.set(
            "native int operator/(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() * right.loadValue());
            });
        
        this._map.set(
            "native int operator/<>(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() / right.loadValue()) | 0);
            });
        
        this._map.set(
            "native uint operator/(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() / right.loadValue()) >>> 0);
            });
        
        this._map.set(
            "native int operator&(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() & right.loadValue());
            });
        
        this._map.set(
            "native uint operator&(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() & right.loadValue()) >>> 0);
            });
        
        this._map.set(
            "native int operator|(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() | right.loadValue());
            });
        
        this._map.set(
            "native uint operator|(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() | right.loadValue()) >>> 0);
            });
        
        this._map.set(
            "native int operator^(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() ^ right.loadValue());
            });
        
        this._map.set(
            "native uint operator^(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() ^ right.loadValue()) >>> 0);
            });
        
        this._map.set(
            "native int operator<<(int,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() << right.loadValue());
            });
        
        this._map.set(
            "native uint operator<<(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box((left.loadValue() << right.loadValue()) >>> 0);
            });
        
        this._map.set(
            "native int operator>>(int,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() >> right.loadValue());
            });
        
        this._map.set(
            "native uint operator>>(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() >>> right.loadValue());
            });
        
        this._map.set(
            "native int operator~(int)",
            func => {
                func.implementation = ([value]) => EPtr.box(~value.loadValue());
            });
        
        this._map.set(
            "native uint operator~(uint)",
            func => {
                func.implementation = ([value]) => EPtr.box((~value.loadValue()) >>> 0);
            });
        
        this._map.set(
            "native float operator/(float,float)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(Math.fround(left.loadValue() / right.loadValue()));
            });
        
        this._map.set(
            "native bool operator==(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() / right.loadValue());
            });
        
        this._map.set(
            "native bool operator==<>(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() == right.loadValue());
            });
        
        this._map.set(
            "native bool operator==<>(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() == right.loadValue());
            });
        
        this._map.set(
            "native bool operator==(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() == right.loadValue());
            });
        
        this._map.set(
            "native bool operator==(bool,bool)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() == right.loadValue());
            });
        
        this._map.set(
            "native bool operator==(float,float)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() == right.loadValue());
            });
        
        this._map.set(
            "native bool operator<(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() < right.loadValue());
            });
        
        this._map.set(
            "native bool operator<<>(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() < right.loadValue());
            });
        
        this._map.set(
            "native bool operator<(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() < right.loadValue());
            });
        
        this._map.set(
            "native bool operator<(float,float)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() < right.loadValue());
            });
        
        this._map.set(
            "native bool operator<=(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() <= right.loadValue());
            });
        
        this._map.set(
            "native bool operator<=(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() <= right.loadValue());
            });
        
        this._map.set(
            "native bool operator<=(float,float)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() <= right.loadValue());
            });
        
        this._map.set(
            "native bool operator>(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() <= right.loadValue());
            });
        
        this._map.set(
            "native bool operator><>(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() > right.loadValue());
            });
        
        this._map.set(
            "native bool operator><>(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() > right.loadValue());
            });
        
        this._map.set(
            "native bool operator>(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() > right.loadValue());
            });
        
        this._map.set(
            "native bool operator>(float,float)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() > right.loadValue());
            });
        
        this._map.set(
            "native bool operator>=(int,int)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() >= right.loadValue());
            });
        
        this._map.set(
            "native bool operator>=<>(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() >= right.loadValue());
            });
        
        this._map.set(
            "native bool operator>=(uint,uint)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() >= right.loadValue());
            });
        
        this._map.set(
            "native bool operator>=(float,float)",
            func => {
                func.implementation = ([left, right]) =>
                    EPtr.box(left.loadValue() >= right.loadValue());
            });
        
        for (let addressSpace of addressSpaces) {
            this._map.set(
                `native T* ${addressSpace} operator&[]<T>(T[] ${addressSpace},uint)`,
                func => {
                    func.implementation = ([ref, index], node) => {
                        ref = ref.loadValue();
                        if (!ref)
                            throw new WTrapError(node.origin.originString, "Null dereference");
                        index = index.loadValue();
                        if (index > ref.length)
                            throw new WTrapError(node.origin.originString, "Array index " + index + " is out of bounds of " + ref);
                        return EPtr.box(ref.ptr.plus(index * node.instantiatedActualTypeArguments[0].size));
                    };
                });

        for (let swizzle of SwizzleOp.functions())
            this._map.set(swizzle.toString(), func => swizzle.instantiateImplementation(func));
                func => {
                    func.implementation = ([ref], node) => {
                        ref = ref.loadValue();
                        if (!ref)
                            return EPtr.box(0);
                        return EPtr.box(ref.length);
                    };
                });
        }

        for (let boolOp of OperatorBool.functions())
            this._map.set(boolOp.toString(), func => boolOp.instantiateImplementation(func));

        for (let anderIndex of OperatorAnderIndexer.functions())
            this._map.set(anderIndex.toString(), func => anderIndex.instantiateImplementation(func));

        for (let cast of BuiltinVectorCasts.functions())
            this._map.set(cast.toString(), func => cast.instantiateImplementation(func));

        for (let getter of BuiltinVectorIndexGetter.functions())
            this._map.set(getter.toString(), func => getter.instantiateImplementation(func));

        for (let setter of BuiltinVectorIndexSetter.functions())
            this._map.set(setter.toString(), func => setter.instantiateImplementation(func));

        for (let equalityOperator of BuiltinVectorEqualityOperator.functions())
            this._map.set(equalityOperator.toString(), func => equalityOperator.instantiateImplementation(func));

        for (let getter of BuiltinVectorGetter.functions())
            this._map.set(getter.toString(), func => getter.instantiateImplementation(func));

        for (let setter of BuiltinVectorSetter.functions())
            this._map.set(setter.toString(), func => setter.instantiateImplementation(func));
    }
    
    add(thing)

Lines 43-48 class LiteralTypeChecker extends Visitor { a/Tools/WebGPUShadingLanguageRI/LiteralTypeChecker.js_sec1
- a/Tools/WebGPUShadingLanguageRI/LiteralTypeChecker.js +2 lines
43	{	43	{
44	if (!node.type)	44	if (!node.type)
45	throw new Error(node + " at " + node.origin.originString + " does not have type");	45	throw new Error(node + " at " + node.origin.originString + " does not have type");
		46	if (!node.type.type.canRepresent(node.value))
		47	throw new Error(`${node.value} at ${node.origin.originString} cannot be represented by ${node.type}`);
46	}	48	}
47	}	49	}
48		50

Lines 65-71 class NativeType extends Type { a/Tools/WebGPUShadingLanguageRI/NativeType.js_sec1
- a/Tools/WebGPUShadingLanguageRI/NativeType.js -1 / +1 lines
65		65
66	toString()	66	toString()
67	{	67	{
68	return "native typedef " + this.name + "<" + this.typeParameters + ">";	68	return `native typedef ${this.name}`;
69	}	69	}
70	}	70	}
71		71

Lines 52-58 class NativeTypeInstance extends Type { a/Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js_sec1
- a/Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js -1 / +1 lines
52		52
53	toString()	53	toString()
54	{	54	{
55	return this.type + "<" + this.typeArguments + ">";	55	return this.type;
56	}	56	}
57	}	57	}
58		58



/*
 * Copyright (C) 2017 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";

class OperatorAnderIndexer {
    constructor(baseTypeName, addressSpace)
    {
        this._baseTypeName = baseTypeName;
        this._addressSpace = addressSpace;
    }

    get addressSpace() { return this._addressSpace; }
    get baseTypeName() { return this._baseTypeName; }

    toString()
    {
        return `native ${this.baseTypeName}* ${this.addressSpace} operator&[](${this.baseTypeName}[] ${this.addressSpace},uint)`;
    }

    static functions()
    {
        if (!this._functions) {
            this._functions = [];
        
            const typeNames = [ "uint", "int", "float", "bool", "int2", "uint2", "float2", "int3", "uint3", "float3", "int4", "uint4", "float4" ];
            const addressSpaces = [ "thread", "threadgroup", "device", "constant" ];

            for (let addressSpace of addressSpaces) {
                for (let typeName of typeNames)
                    this._functions.push(new OperatorAnderIndexer(typeName, addressSpace));
            }
        }
        return this._functions;
    }

    // static indexersForTypeName(typeName)
    // {
    //     const addressSpaces = [ "thread", "threadgroup", "device", "constant" ];
    //     return addressSpaces.map(addrSpace => new OperatorAnderIndexer(typeName, addrSpace));
    // }

    instantiateImplementation(func)
    {
        func.implementation = ([ref, index], node) => {
            ref = ref.loadValue();
            if (!ref)
                throw new WTrapError(node.origin.originString, "Null dereference");
            index = index.loadValue();
            if (index > ref.length)
                throw new WTrapError(node.origin.originString, "Array index " + index + " is out of bounds of " + ref);
            return EPtr.box(ref.ptr.plus(index * node.argumentTypes[0].elementType.size));
        };
        func.implementationData = this;
    }
}



/*
 * Copyright (C) 2017 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";

class OperatorArrayRefLength {
    constructor(baseTypeName, addressSpace)
    {
        this._baseTypeName = baseTypeName;
        this._addressSpace = addressSpace;
    }

    get addressSpace() { return this._addressSpace; }
    get baseTypeName() { return this._baseTypeName; }

    toString()
    {
        return `native uint32 ${this.addressSpace} operator.length(${this.baseTypeName}[] ${this.addressSpace})`;
    }

    instantiateImplementation(func)
    {
        func.implementation = ([ref], node) => {
            ref = ref.loadValue();
            if (!ref)
                return EPtr.box(0);
            return EPtr.box(ref.length);
        };
        func.implementationData = this;
    }
}



/*
 * Copyright (C) 2017 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";

// FIXME: This needs to support registering these functions late

class OperatorBool {
    constructor(baseTypeName)
    {
        this._baseTypeName = baseTypeName;
    }

    get baseTypeName() { return this._baseTypeName; }

    toString()
    {
        return `native operator bool(${this.baseTypeName})`;
    }

    static functions()
    {
        if (!OperatorBool._functions) {
            OperatorBool._functions = [];
        
            // bool is not included because this is generated by the copy constructor
            const typeNames = [ "uint", "int", "float", /*"bool",*/ "int2", "uint2", "float2", "int3", "uint3", "float3", "int4", "uint4", "float4" ];

            for (let typeName of typeNames)
                OperatorBool._functions.push(new OperatorBool(typeName));
        }
        return OperatorBool._functions;
    }

    instantiateImplementation(func)
    {
        func.implementation = ([ref], node) => {
            return EPtr.box(!!ref.loadValue());
        }
        func.implementationData = this;
    }
}



        return result;
    }
    
    function parseProtocolRef()
    {
        let protocolToken = consumeKind("identifier");
        return new ProtocolRef(protocolToken, protocolToken.text);
    }
    
    function consumeEndOfTypeArgs()
    {
        let rightShift = tryConsume(">>");

            consume(">");
    }
    
    function parseTypeParameters()
    {
        if (!test("<"))
            return [];
        
        let result = [];
        consume("<");
        while (!test(">")) {
            let constexpr = lexer.backtrackingScope(() => {
                let type = parseType();
                let name = consumeKind("identifier");
                assertNext(",", ">", ">>");
                return new ConstexprTypeParameter(type.origin, name.text, type);
            });
            if (constexpr)
                result.push(constexpr);
            else {
                let name = consumeKind("identifier");
                let protocol = tryConsume(":") ? parseProtocolRef() : null;
                result.push(new TypeVariable(name, name.text, protocol));
            }
            if (!tryConsume(","))
                break;
        }
        consumeEndOfTypeArgs();
        return result;
    }
    
    function parseTerm()
    {
        let token;

                return new IntLiteral(token, intVersion);
            return new UintLiteral(token, intVersion >>> 0);
        }
        if (token = tryConsumeKind("doubleLiteral"))
            return new DoubleLiteral(token, +token.text);
        if (token = tryConsumeKind("floatLiteral")) {
            let text = token.text;
            let d = token.text.endsWith("d");
            let f = token.text.endsWith("f");
            if (f)
                throw new Error("Literal cannot be both a double literal and a float literal.");
            if (d || f)
                text = text.substring(0, text.length - 1);
            let value = parseFloat(text);
            if (d)
                return new DoubleLiteral(token, value);
            return new FloatLiteral(token, Math.fround(value));
        }
        if (token = tryConsume("true", "false"))

        return left;
    }
    
    function parseTypeArguments()
    {
        if (!test("<"))
            return [];
        
        let result = [];
        consume("<");
        while (!test(">")) {
            // It's possible for a constexpr or type can syntactically overlap in the single
            // identifier case. Let's consider the possibilities:
            //
            //     T          could be type or constexpr
            //     T[]        only type
            //     T[42]      only type (constexpr cannot do indexing)
            //     42         only constexpr
            //
            // In the future we'll allow constexprs to do more things, and then we'll still have
            // the problem that something of the form T[1][2][3]... can either be a type or a
            // constexpr, and we can figure out in the checker which it is.
            let typeOrVariableRef = lexer.backtrackingScope(() => {
                let result = consumeKind("identifier");
                assertNext(",", ">", ">>");
                return new TypeOrVariableRef(result, result.text);
            });
            if (typeOrVariableRef)
                result.push(typeOrVariableRef);
            else {
                let constexpr = lexer.backtrackingScope(() => {
                    let result = parseConstexpr();
                    assertNext(",", ">", ">>");
                    return result;
                });
                if (constexpr)
                    result.push(constexpr);
                else
                    result.push(parseType());
            }
            if (!tryConsume(","))
                break;
        }
        consumeEndOfTypeArgs();
        return result;
    }
    
    function parseType()
    {
        let token;

            addressSpace = token.text;
        
        let name = consumeKind("identifier");
        let typeArguments = [];
        let type = new TypeRef(name, name.text, typeArguments);
        
        function getAddressSpace()

    {
        let origin = consume("typedef");
        let name = consumeKind("identifier").text;
        let typeParameters = [];
        consume("=");
        let type = parseType();
        consume(";");

    function parseCallExpression()
    {
        let name = consumeKind("identifier");
        let typeArguments = [];
        consume("(");
        let argumentList = [];
        while (!test(")")) {

    {
        return lexer.testScope(() => {
            consumeKind("identifier");
            parseTypeArguments();
            consume("(");
        });
    }

        let origin;
        let returnType;
        let name;
        let typeParameters = [];
        let isCast;
        let shaderType;
        let operatorToken = tryConsume("operator");
        if (operatorToken) {
            origin = operatorToken;
            typeParameters = parseTypeParameters();
            returnType = parseType();
            name = "operator cast";
            isCast = true;

            } else
                origin = returnType.origin;
            name = parseFuncName();
            typeParameters = parseTypeParameters();
            isCast = false;
        }
        let parameters = parseParameters();
        return new Func(origin, name, returnType, typeParameters, parameters, isCast, shaderType);
    }

    function parseProtocolFuncDecl()
    {
        let func = parseFuncDecl();
        return new ProtocolFuncDecl(func.origin, func.name, func.returnType, func.typeParameters, func.parameters, func.isCast, func.shaderType);
    }
    
    function parseFuncDef()
    {

        return new FuncDef(func.origin, func.name, func.returnType, func.typeParameters, func.parameters, body, func.isCast, func.shaderType);
    }
    
    function parseProtocolDecl()
    {
        let origin = consume("protocol");
        let name = consumeKind("identifier").text;
        let result = new ProtocolDecl(origin, name);
        if (tryConsume(":")) {
            while (!test("{")) {
                result.addExtends(parseProtocolRef());
                if (!tryConsume(","))
                    break;
            }
        }
        consume("{");
        while (!tryConsume("}")) {
            result.add(parseProtocolFuncDecl());
            consume(";");
        }
        return result;
    }
    
    function parseField()
    {
        let type = parseType();

    {
        let origin = consume("struct");
        let name = consumeKind("identifier").text;
        let typeParameters = [];
        let result = new StructType(origin, name, typeParameters);
        consume("{");
        while (!tryConsume("}"))

        let origin = consume("native");
        if (tryConsume("typedef")) {
            let name = consumeKind("identifier");
            let parameters = [];
            consume(";");
            return new NativeType(origin, name.text, parameters);
        }

            program.add(parseStructType());
        else if (token.text == "enum")
            program.add(parseEnumType());
        else if (token.text == "protocol")
            program.add(parseProtocolDecl());
        else
            program.add(parseFuncDef());
    }

Lines 48-53 let prepare = (() => { a/Tools/WebGPUShadingLanguageRI/Prepare.js_sec1
- a/Tools/WebGPUShadingLanguageRI/Prepare.js +4 lines
48	checkRecursiveTypes(program);	48	checkRecursiveTypes(program);
49	synthesizeStructAccessors(program);	49	synthesizeStructAccessors(program);
50	synthesizeEnumFunctions(program);	50	synthesizeEnumFunctions(program);
		51	synthesizeArrayOperatorLength(program);
		52	synthesizeCopyConstructorOperator(program);
		53	synthesizeDefaultConstructorOperator(program);
51	resolveNamesInFunctions(program, nameResolver);	54	resolveNamesInFunctions(program, nameResolver);
52	resolveTypeDefsInFunctions(program);	55	resolveTypeDefsInFunctions(program);
53		56
Lines 64-69 let prepare = (() => { a/Tools/WebGPUShadingLanguageRI/Prepare.js_sec2
64	checkRecursion(program);	67	checkRecursion(program);
65	checkProgramWrapped(program);	68	checkProgramWrapped(program);
66	findHighZombies(program);	69	findHighZombies(program);
		70	program.visit(new StructLayoutBuilder());
67	inline(program);	71	inline(program);
68		72
69	return program;	73	return program;



    <script src="CreateLiteralType.js"></script>
    <script src="PropertyAccessExpression.js"></script>
    <script src="SwizzleOp.js"></script>
    
    <script src="AddressSpace.js"></script>
    <script src="AnonymousVariable.js"></script>
    <script src="ArrayRefType.js"></script>

    <script src="ConvertPtrToArrayRefExpression.js"></script>
    <script src="DoWhileLoop.js"></script>
    <script src="DotExpression.js"></script>
    <script src="DoubleLiteral.js"></script>
    <script src="DoubleLiteralType.js"></script>
    <script src="DereferenceExpression.js"></script>
    <script src="EArrayRef.js"></script>
    <script src="EBuffer.js"></script>

    <script src="NormalUsePropertyResolver.js"></script>
    <script src="NullLiteral.js"></script>
    <script src="NullType.js"></script>
    <script src="OperatorAnderIndex.js"></script>
    <script src="OperatorArrayRefLength.js"></script>
    <script src="OperatorBool.js"></script>
    <script src="BuiltinVectorCasts.js"></script>
    <script src="BuiltinVectorGetter.js"></script>
    <script src="BuiltinVectorSetter.js"></script>
    <script src="BuiltinVectorIndexGetter.js"></script>
    <script src="BuiltinVectorIndexSetter.js"></script>
    <script src="BuiltinVectorEqualityOperator.js"></script>
    <script src="OriginKind.js"></script>
    <script src="OverloadResolutionFailure.js"></script>
    <script src="Parse.js"></script>

    <script src="Return.js"></script>
    <script src="ReturnChecker.js"></script>
    <script src="ReturnException.js"></script>
    <script src="SPIR-V.js"></script>
    <script src="SPIRVCodegen.js"></script>
    <script src="SPIRVTypeAnalyzer.js"></script>
    <script src="SPIRVVariableAnalyzer.js"></script>
    <script src="StandardLibrary.js"></script>
    <script src="StatementCloner.js"></script>
    <script src="StructLayoutBuilder.js"></script>

    <script src="Substitution.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="TrapStatement.js"></script>
    <script src="TypeDef.js"></script>
    <script src="TypeDefResolver.js"></script>



                values = uintView;
                break;
            }
            case program.intrinsics.double: {
                let arrayBuffer = new ArrayBuffer(Math.max(Uint32Array.BYTES_PER_ELEMENT, Float64Array.BYTES_PER_ELEMENT));
                let doubleView = new Float64Array(arrayBuffer);
                let uintView = new Uint32Array(arrayBuffer);
                doubleView[0] = node.value;
                values = uintView;
                break;
            }
            default:
                throw new Error("Unrecognized literal.");
            }



typedef uint = uint32;

native typedef float32;
native typedef float64;
typedef float = float32;
typedef double = float64;

native operator int32(uint32);
native operator int32(uint8);
native operator int32(float);
native operator int32(double);
native operator uint32(int32);
native operator uint32(uint8);
native operator uint32(float);
native operator uint32(double);
native operator uint8(int32);
native operator uint8(uint32);
native operator uint8(float);
native operator uint8(double);
native operator float(int32);
native operator float(uint32);
native operator float(uint8);
native operator float(double);
native operator double(float);
native operator double(int32);
native operator double(uint32);
native operator double(uint8);

native int operator+(int, int);
native uint operator+(uint, uint);
uint8 operator+(uint8 a, uint8 b) { return uint8(uint(a) + uint(b)); }
native float operator+(float, float);
native double operator+(double, double);
int operator++(int value) { return value + 1; }
uint operator++(uint value) { return value + 1; }
uint8 operator++(uint8 value) { return value + 1; }

native uint operator-(uint, uint);
uint8 operator-(uint8 a, uint8 b) { return uint8(uint(a) - uint(b)); }
native float operator-(float, float);
native double operator-(double, double);
int operator--(int value) { return value - 1; }
uint operator--(uint value) { return value - 1; }
uint8 operator--(uint8 value) { return value - 1; }

native uint operator*(uint, uint);
uint8 operator*(uint8 a, uint8 b) { return uint8(uint(a) * uint(b)); }
native float operator*(float, float);
native double operator*(double, double);
native int operator/(int, int);
native uint operator/(uint, uint);
uint8 operator/(uint8 a, uint8 b) { return uint8(uint(a) / uint(b)); }

uint8 operator<<(uint8 a, uint b) { return uint8(uint(a) << (b & 7)); }
uint8 operator>>(uint8 a, uint b) { return uint8(uint(a) >> (b & 7)); }
native float operator/(float, float);
native double operator/(double, double);
native bool operator==(int, int);
native bool operator==(uint, uint);
bool operator==(uint8 a, uint8 b) { return uint(a) == uint(b); }
native bool operator==(bool, bool);
native bool operator==(float, float);
native bool operator==(double, double);
native bool operator<(int, int);
native bool operator<(uint, uint);
bool operator<(uint8 a, uint8 b) { return uint(a) < uint(b); }
native bool operator<(float, float);
native bool operator<(double, double);
native bool operator<=(int, int);
native bool operator<=(uint, uint);
bool operator<=(uint8 a, uint8 b) { return uint(a) <= uint(b); }
native bool operator<=(float, float);
native bool operator<=(double, double);
native bool operator>(int, int);
native bool operator>(uint, uint);
bool operator>(uint8 a, uint8 b) { return uint(a) > uint(b); }
native bool operator>(float, float);
native bool operator>(double, double);
native bool operator>=(int, int);
native bool operator>=(uint, uint);
bool operator>=(uint8 a, uint8 b) { return uint(a) >= uint(b); }
native bool operator>=(float, float);
native bool operator>=(double, double);

bool operator&(bool a, bool b)
{

    return !value;
}

native typedef int2;
native typedef uint2;
native typedef float2;

protocol Equatable {
    bool operator==(Equatable, Equatable);
}

restricted operator<T> T()
{
    T defaultValue;
    return defaultValue;
}

restricted operator<T> T(T x)
{
    return x;
}

operator<T:Equatable> bool(T x)
{
    return x != T();
}

struct vec2<T> {
    T x;
    T y;
}

typedef int2 = vec2<int>;
typedef uint2 = vec2<uint>;
typedef float2 = vec2<float>;
typedef double2 = vec2<double>;

operator<T> vec2<T>(T x, T y)
{
    vec2<T> result;
    result.x = x;
    result.y = y;
    return result;
}

bool operator==<T:Equatable>(vec2<T> a, vec2<T> b)
{
    return a.x == b.x && a.y == b.y;
}

thread T* operator&[]<T>(thread vec2<T>* foo, uint index)
{
    if (index == 0)
        return &foo->x;
    if (index == 1)
        return &foo->y;
    trap;
}

struct vec3<T> {
    T x;
    T y;
    T z;
}

typedef int3 = vec3<int>;
typedef uint3 = vec3<uint>;
typedef float3 = vec3<float>;
typedef double3 = vec3<double>;

operator<T> vec3<T>(T x, T y, T z)
{
    vec3<T> result;
    result.x = x;
    result.y = y;
    result.z = z;
    return result;
}

operator<T> vec3<T>(vec2<T> v2, T z)
{
    vec3<T> result;
    result.x = v2.x;
    result.y = v2.y;
    result.z = z;
    return result;
}

operator<T> vec3<T>(T x, vec2<T> v2)
{
    vec3<T> result;
    result.x = x;
    result.y = v2.x;
    result.z = v2.y;
    return result;
}

bool operator==<T:Equatable>(vec3<T> a, vec3<T> b)
{
    return a.x == b.x && a.y == b.y && a.z == b.z;
}

native typedef int3;
native typedef uint3;
native typedef float3;
        return &foo->x;
    if (index == 1)
        return &foo->y;
    if (index == 2)
        return &foo->z;
    trap;
}

struct vec4<T> {
    T x;
    T y;
    T z;
    T w;
}

typedef int4 = vec4<int>;
typedef uint4 = vec4<uint>;
typedef float4 = vec4<float>;
typedef double4 = vec4<double>;

operator<T> vec4<T>(T x, T y, T z, T w)
{
    vec4<T> result;
    result.x = x;
    result.y = y;
    result.z = z;
    result.w = w;
    return result;
}

operator<T> vec4<T>(vec2<T> v2, T z, T w)
{
    vec4<T> result;
    result.x = v2.x;
    result.y = v2.y;
    result.z = z;
    result.w = w;
    return result;
}

operator<T> vec4<T>(T x, vec2<T> v2, T w)
{
    vec4<T> result;
    result.x = x;
    result.y = v2.x;
    result.z = v2.y;
    result.w = w;
    return result;
}

operator<T> vec4<T>(T x, T y, vec2<T> v2)
{
    vec4<T> result;
    result.x = x;
    result.y = y;
    result.z = v2.x;
    result.w = v2.y;
    return result;
}

operator<T> vec4<T>(vec2<T> v2a, vec2<T> v2b)
{
    vec4<T> result;
    result.x = v2a.x;
    result.y = v2a.y;
    result.z = v2b.x;
    result.w = v2b.y;
    return result;
}

native typedef int4;
native typedef uint4;
native typedef float4;
    result.x = v3.x;
    result.y = v3.y;
    result.z = v3.z;
    result.w = w;
    return result;
}

operator<T> vec4<T>(T x, vec3<T> v3)
{
    vec4<T> result;
    result.x = x;
    result.y = v3.x;
    result.z = v3.y;
    result.w = v3.z;
    return result;
}

bool operator==<T:Equatable>(vec4<T> a, vec4<T> b)
{
    return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
}

thread T* operator&[]<T>(thread vec4<T>* foo, uint index)
{
    if (index == 0)
        return &foo->x;
    if (index == 1)
        return &foo->y;
    if (index == 2)
        return &foo->z;
    if (index == 3)
        return &foo->w;
    trap;
}

native thread T* operator&[]<T>(thread T[], uint);
native threadgroup T* operator&[]<T>(threadgroup T[], uint);
native device T* operator&[]<T>(device T[], uint);
native constant T* operator&[]<T>(constant T[], uint);

native uint operator.length<T>(thread T[]);
native uint operator.length<T>(threadgroup T[]);
native uint operator.length<T>(device T[]);
native uint operator.length<T>(constant T[]);

uint operator.length<T, uint length>(T[length])
{
    return length;
}
`;

function intToString(x)

    }
}

function addFunctionsFromClass(clss)
{
    standardLibrary += clss.functions().join(";\n") + "\n";
}

// There are 481 swizzle operators, so we compile them as native functions
standardLibrary += SwizzleOp.functions().join(";\n") + ";\n";
standardLibrary += OperatorBool.functions().join(";\n") + ";\n";
standardLibrary += OperatorAnderIndexer.functions().join(";\n") + ";\n";
standardLibrary += BuiltinVectorCasts.functions().join(";\n") + ";\n";
standardLibrary += BuiltinVectorGetter.functions().join(";\n") + ";\n";
standardLibrary += BuiltinVectorSetter.functions().join(";\n") + ";\n";
standardLibrary += BuiltinVectorIndexGetter.functions().join(";\n") + ";\n";
standardLibrary += BuiltinVectorIndexSetter.functions().join(";\n") + ";\n";
standardLibrary += BuiltinVectorEqualityOperator.functions().join(";\n") + ";\n";



    get name() { return this._name; }
    get origin() { return this._origin; }
    get typeParameters() { return this._typeParameters; }
    get isStruct() { return true; }
    
    get fieldNames() { return this._fields.keys(); }
    fieldByName(name) { return this._fields.get(name); }

    
    toString()
    {
        return `struct ${this.name} { ${Array.from(this.fields).join("; ")}; }`;
    }
}



"use strict";

class SwizzleOp {
    constructor(baseTypeName, outSize, components, inSize)
    {
        this._baseTypeName = baseTypeName;
        this._outSize = outSize;
        this._components = components.slice(); // Shallow clone
        this._inSize = inSize;
    }

    get baseTypeName() { return this._baseTypeName; }
    get outSize() { return this._outSize; }
    get components() { return this._components; }
    get inSize() { return this._inSize; }

    toString()
    {
        return `native ${this.baseTypeName}${this.outSize} operator.${this.components.join("")}(${this.baseTypeName}${this.inSize} v)`;
    }

    static functions()
    {
        if (!this._functions) {
            // We can't directly use this._functions in _generateSwizzles
            const functions = [];
            
            function _generateSwizzle(baseTypeName, maxDepth, maxItems, array) {
                if (!array)
                    array = [];
                if (array.length == maxDepth) {
                    functions.push(new SwizzleOp(baseTypeName, array.length, array, maxItems));
                    return;
                }
                for (let i = 0; i < maxItems; ++i) {
                    array.push(intToString(i));
                    _generateSwizzle(baseTypeName, maxDepth, maxItems, array);
                    array.pop();
                }
            };
        
            const typeNames = [ "uint", "int", "float" ];

            for (let typeName of typeNames) {
                for (let maxDepth = 2; maxDepth <= 4; maxDepth++) {
                    for (let maxItems = 2; maxItems <= 4; maxItems++)
                        _generateSwizzle(typeName, maxDepth, maxItems);
                }
            }

            this._functions = functions;
        }
        return this._functions;
    }
}

    instantiateImplementation(func)
    {
        func.implementation = ([vec], node) => {
            const outputBuffer = new EBuffer(this.outSize);
            const readIndices = { 'x': 0, 'y': 1, 'z': 2, 'w': 3 };
            for (let i = 0; i < this.outSize; i++)
                outputBuffer.set(i, vec.get(readIndices[this.components[i]]));
            
            
            return new EPtr(outputBuffer, 0);
        };
        func.implementationData = this;
    }
}



/*
 * Copyright (C) 2017 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 synthesizeArrayOperatorLength(program)
{
    const arrayTypes = new Set();

    class FindArrayTypes extends Visitor {
        visitArrayType(node)
        {
            arrayTypes.add(node);
        }
    }
    
    program.visit(new FindArrayTypes());

    for (let arrayType of arrayTypes) {
        let nativeFunc = new NativeFunc(
            arrayType.origin, "operator.length", new TypeRef(arrayType.origin, "uint32", []), [],
            [
                new FuncParameter(arrayType.origin, null, TypeRef.wrap(arrayType))
            ],
            false, null);
        nativeFunc.implementation = ([array]) => EPtr.box(arrayType.size);
        program.add(nativeFunc);
    }
}



/*
 * Copyright (C) 2017 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 synthesizeCopyConstructorOperator(program)
{
    const types = new Set();

    class FindAllTypes extends Visitor {
        visitNativeType(node)
        { 
            types.add(node); 
        }

        visitStructType(node)
        {
            types.add(node);
            super.visitStructType(node);
        }

        visitElementalType(node)
        {
            types.add(node);
            super.visitElementalType(node);
        }
    }

    program.visit(new FindAllTypes());

    for (let type of types) {
        let nativeFunc = new NativeFunc(type.origin, "operator cast", TypeRef.wrap(type), [], [
            new FuncParameter(type.origin, null, TypeRef.wrap(type))
        ], true, null);
        nativeFunc.implementation = ([arg], node) => {
            let result = new EPtr(new EBuffer(type.size), 0);
            result.copyFrom(arg, type.size);
            return result;
        };
        program.add(nativeFunc);
    }
}



/*
 * Copyright (C) 2017 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 synthesizeDefaultConstructorOperator(program)
{
    const types = new Set();

    class FindAllTypes extends Visitor {
        visitNativeType(node)
        { 
            types.add(node); 
        }

        visitStructType(node)
        {
            types.add(node);
            super.visitStructType(node);
        }

        visitElementalType(node)
        {
            types.add(node);
            super.visitElementalType(node);
        }
    }

    program.visit(new FindAllTypes());

    for (let type of types) {
        let nativeFunc = new NativeFunc(type.origin, "operator cast", TypeRef.wrap(type), [], [], true, null);
        nativeFunc.implementation = ([], node) => {
            let result = new EPtr(new EBuffer(type.size), 0);
            node.type.populateDefaultValue(result.buffer, 0);
            return result;
        };
        program.add(nativeFunc);
    }
}



<script src="ConvertPtrToArrayRefExpression.js"></script>
<script src="DoWhileLoop.js"></script>
<script src="DotExpression.js"></script>
<script src="DoubleLiteral.js"></script>
<script src="DoubleLiteralType.js"></script>
<script src="DereferenceExpression.js"></script>
<script src="EArrayRef.js"></script>
<script src="EBuffer.js"></script>

<script src="NormalUsePropertyResolver.js"></script>
<script src="NullLiteral.js"></script>
<script src="NullType.js"></script>
<script src="OperatorAnderIndex.js"></script>
<script src="OperatorArrayRefLength.js"></script>
<script src="OperatorBool.js"></script>
<script src="BuiltinVectorCasts.js"></script>
<script src="BuiltinVectorGetter.js"></script>
<script src="BuiltinVectorSetter.js"></script>
<script src="BuiltinVectorIndexGetter.js"></script>
<script src="BuiltinVectorIndexSetter.js"></script>
<script src="BuiltinVectorEqualityOperator.js"></script>
<script src="OriginKind.js"></script>
<script src="OverloadResolutionFailure.js"></script>
<script src="Parse.js"></script>

<script src="Substitution.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="TrapStatement.js"></script>
<script src="TypeDef.js"></script>
<script src="TypeDefResolver.js"></script>



    return TypedValue.box(program.intrinsics.float, value);
}

function makeDouble(program, value)
{
    return TypedValue.box(program.intrinsics.double, value);
}

function makeEnum(program, enumName, value)
{
    let enumType = program.types.get(enumName);

        throw new Error("Wrong result: " + result.value + " (expected " + expected + ")");
}

function checkDouble(program, result, expected)
{
    if (!result.type.equals(program.intrinsics.double))
        throw new Error("Wrong result type: " + result.type);
    if (result.value != expected)
        throw new Error("Wrong result: " + result.value + " (expected " + expected + ")");
}

function checkLexerToken(result, expectedIndex, expectedKind, expectedText)
{
    if (result._index != expectedIndex)

    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 42)]), 43);
}

tests.simpleGeneric = function() {
    let program = doPrep(`
        T id<T>(T x) { return x; }
        int foo(int x) { return id(x) + 1; }
    `);
    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 42)]), 43);
}

tests.nameResolutionFailure = function()
{
    checkFail(

        throw new Error("Bad value stored into buffer (expected -111): " + buffer.get(0));
}

tests.simpleProtocol = function()
{
    let program = doPrep(`
        protocol MyAddable {
            MyAddable operator+(MyAddable, MyAddable);
        }
        T add<T:MyAddable>(T a, T b)
        {
            return a + b;
        }
        int foo(int x)
        {
            return add(x, 73);
        }
    `);
    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 45)]), 45 + 73);
}

tests.typeMismatchReturn = function()
{
    checkFail(

{
    checkFail(
        () => doPrep(`
            void bar<T>(T) { }
            void foo(int x, uint y)
            {
                uint z = x + y;
            }
        `),
        (e) => e instanceof WTypeError && e.message.indexOf("native int32 operator+(int32,int32)") != -1);
}

tests.lexerKeyword = function()
{
    let result = doLex("ident for while 123 123u { } {asd asd{ 1a3 1.2 + 3.4 + 1. + .2 1.2f 0.f .3f && ||");
    if (result.length != 25)
        throw new Error("Lexer emitted an incorrect number of tokens (expected 23): " + result.length);
    checkLexerToken(result[0],  0,  "identifier",    "ident");

    checkLexerToken(result[17], 55, "floatLiteral",  "1.");
    checkLexerToken(result[18], 58, "punctuation",   "+");
    checkLexerToken(result[19], 60, "floatLiteral",  ".2");
    checkLexerToken(result[20], 63, "floatLiteral",  "1.2f");
    checkLexerToken(result[21], 68, "floatLiteral",  "0.f");
    checkLexerToken(result[22], 72, "floatLiteral",  ".3f");
    checkLexerToken(result[23], 76, "punctuation",   "&&");
    checkLexerToken(result[24], 79, "punctuation",   "||");
}

        throw new Error("Wrong result for y: " + y + " (x + " + x + ")");
}

tests.genericStructInstance = function()
{
    let program = doPrep(`
        struct Foo<T> {
            T x;
            T y;
        }
        Foo<int> foo(Foo<int> foo)
        {
            Foo<int> result;
            result.x = foo.y;
            result.y = foo.x;
            return result;
        }
    `);
    let structType = TypeRef.instantiate(program.types.get("Foo"), [program.intrinsics.int32]);
    let buffer = new EBuffer(2);
    buffer.set(0, 62);
    buffer.set(1, 24);
    let result = callFunction(program, "foo", [], [new TypedValue(structType, new EPtr(buffer, 0))]);
    let x = result.ePtr.get(0);
    let y = result.ePtr.get(1);
    if (x != 24)
        throw new Error("Wrong result for x: " + x + " (y = " + y + ")");
    if (y != 62)
        throw new Error("Wrong result for y: " + y + " (x + " + x + ")");
}

tests.doubleGenericCallsDoubleGeneric = function()
{
    doPrep(`
        void foo<T, U>(T, U) { }
        void bar<V, W>(V x, W y) { foo(x, y); }
    `);
}

tests.doubleGenericCallsSingleGeneric = function()
{
    checkFail(
        () => doPrep(`
            void foo<T>(T, T) { }
            void bar<V, W>(V x, W y) { foo(x, y); }
        `),
        (e) => e instanceof WTypeError);
}

tests.loadNull = function()
{
    checkFail(
        () => doPrep(`
            void sink(thread int* x) { }
            void foo() { sink(*null); }
        `),
        (e) => e instanceof WTypeError && e.message.indexOf("Type passed to dereference is not a pointer: null") != -1);

        (e) => e instanceof WTrapError);
}

tests.passNullToPtrPolymorphic = function()
{
    checkFail(
        () => doPrep(`
            T foo<T>(thread T* ptr)
            {
                return *ptr;
            }
            int bar()
            {
                return foo(null);
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.passNullToPolymorphic = function()
{
    checkFail(
        () => doPrep(`
            T foo<T>(T ptr)
            {
                return ptr;
            }
            int bar()
            {
                return foo(null);
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.loadNullArrayRef = function()
{
    checkFail(
        () => doPrep(`
            void sink(thread int* x) { }
            void foo() { sink(null[0u]); }
        `),
        (e) => e instanceof WTypeError && e.message.indexOf("Cannot resolve access") != -1);

        (e) => e instanceof WTrapError);
}

tests.passNullToPtrPolymorphicArrayRef = function()
{
    checkFail(
        () => doPrep(`
            T foo<T>(thread T[] ptr)
            {
                return ptr[0u];
            }
            int bar()
            {
                return foo(null);
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.returnIntLiteralUint = function()
{
    let program = doPrep("uint foo() { return 42; }");
    checkNumber(program, callFunction(program, "foo", [], []), 42);
}

tests.returnIntLiteralFloat = function()
{
    let program = doPrep("float foo() { return 42; }");
    checkNumber(program, callFunction(program, "foo", [], []), 42);
}


        (e) => e instanceof WSyntaxError);
}

tests.badIntLiteralForFloat = function()
{
    checkFail(
        () => doPrep("void foo() { float x = 5000000000000000000000000000000000000; }"),
        (e) => e instanceof WSyntaxError);
}

tests.passNullAndNotNull = function()
{
    let program = doPrep(`
        T bar<T>(device T* p, device T*)
        {
            return *p;
        }
        int foo(device int* p)
        {
            return bar(p, null);
        }
    `);
    let buffer = new EBuffer(1);
    buffer.set(0, 13);
    checkInt(program, callFunction(program, "foo", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 13);
}

tests.passNullAndNotNullFullPoly = function()
{
    let program = doPrep(`
        T bar<T>(T p, T)
        {
            return p;
        }
        int foo(device int* p)
        {
            return *bar(p, null);
        }
    `);
    let buffer = new EBuffer(1);
    buffer.set(0, 13);
    checkInt(program, callFunction(program, "foo", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 13);
}

tests.passNullAndNotNullFullPolyReverse = function()
{
    let program = doPrep(`
        T bar<T>(T, T p)
        {
            return p;
        }
        int foo(device int* p)
        {
            return *bar(null, p);
        }
    `);
    let buffer = new EBuffer(1);
    buffer.set(0, 13);
    checkInt(program, callFunction(program, "foo", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 13);
}

tests.nullTypeVariableUnify = function()
{
    let left = new NullType(externalOrigin);

{
    checkFail(
        () => doPrep(`
            void foo(int x)
            {
                foo(x);
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.protocolMonoSigPolyDef = function()
{
    let program = doPrep(`
        struct IntAnd<T> {
            int first;
            T second;
        }
        IntAnd<T> intAnd<T>(int first, T second)
        {
            IntAnd<T> result;
            result.first = first;
            result.second = second;
            return result;
        }
        protocol IntAndable {
            IntAnd<int> intAnd(IntAndable, int);
        }
        int foo<T:IntAndable>(T first, int second)
        {
            IntAnd<int> result = intAnd(first, second);
            return result.first + result.second;
        }
    `);
    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 54), makeInt(program, 12)]), 54 + 12);
}

tests.protocolPolySigPolyDef = function()
{
    let program = doPrep(`
        struct IntAnd<T> {
            int first;
            T second;
        }
        IntAnd<T> intAnd<T>(int first, T second)
        {
            IntAnd<T> result;
            result.first = first;
            result.second = second;
            return result;
        }
        protocol IntAndable {
            IntAnd<T> intAnd<T>(IntAndable, T);
        }
        int foo<T:IntAndable>(T first, int second)
        {
            IntAnd<int> result = intAnd(first, second);
            return result.first + result.second;
        }
    `);
    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 54), makeInt(program, 12)]), 54 + 12);
}

tests.protocolDoublePolySigDoublePolyDef = function()
{
    let program = doPrep(`
        struct IntAnd<T, U> {
            int first;
            T second;
            U third;
        }
        IntAnd<T, U> intAnd<T, U>(int first, T second, U third)
        {
            IntAnd<T, U> result;
            result.first = first;
            result.second = second;
            result.third = third;
            return result;
        }
        protocol IntAndable {
            IntAnd<T, U> intAnd<T, U>(IntAndable, T, U);
        }
        int foo<T:IntAndable>(T first, int second, int third)
        {
            IntAnd<int, int> result = intAnd(first, second, third);
            return result.first + result.second + result.third;
        }
    `);
    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 54), makeInt(program, 12), makeInt(program, 39)]), 54 + 12 + 39);
}

tests.protocolDoublePolySigDoublePolyDefExplicit = function()
{
    let program = doPrep(`
        struct IntAnd<T, U> {
            int first;
            T second;
            U third;
        }
        IntAnd<T, U> intAnd<T, U>(int first, T second, U third)
        {
            IntAnd<T, U> result;
            result.first = first;
            result.second = second;
            result.third = third;
            return result;
        }
        protocol IntAndable {
            IntAnd<T, U> intAnd<T, U>(IntAndable, T, U);
        }
        int foo<T:IntAndable>(T first, int second, int third)
        {
            IntAnd<int, int> result = intAnd<int, int>(first, second, third);
            return result.first + result.second + result.third;
        }
    `);
    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 54), makeInt(program, 12), makeInt(program, 39)]), 54 + 12 + 39);
}

tests.variableShadowing = function()
{
    let program = doPrep(`

    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 1)]), 16);
}

tests.protocolMonoPolySigDoublePolyDefExplicit = function()
{
    checkFail(
        () => {
            let program = doPrep(`
                struct IntAnd<T, U> {
                    int first;
                    T second;
                    U third;
                }
                IntAnd<T, U> intAnd<T, U>(int first, T second, U third)
                {
                    IntAnd<T, U> result;
                    result.first = first;
                    result.second = second;
                    result.third = third;
                    return result;
                }
                protocol IntAndable {
                    IntAnd<T, int> intAnd<T>(IntAndable, T, int);
                }
                int foo<T:IntAndable>(T first, int second, int third)
                {
                    IntAnd<int, int> result = intAnd<int>(first, second, third);
                    return result.first + result.second + result.third;
                }
            `);
            callFunction(program, "foo", [], [makeInt(program, 54), makeInt(program, 12), makeInt(program, 39)]);
        },
        (e) => e instanceof WTypeError);
}

tests.ambiguousOverloadSimple = function()
{
    checkFail(
        () => doPrep(`
            void foo<T>(int, T) { }
            void foo<T>(T, int) { }
            void bar(int a, int b) { foo(a, b); }
        `),
        (e) => e instanceof WTypeError);
}

tests.ambiguousOverloadOverlapping = function()
{
    checkFail(
        () => doPrep(`
            void foo<T>(int, T) { }
            void foo<T>(T, T) { }
            void bar(int a, int b) { foo(a, b); }
        `),
        (e) => e instanceof WTypeError);
}

tests.ambiguousOverloadTieBreak = function()
{
    doPrep(`
        void foo<T>(int, T) { }
        void foo<T>(T, T) { }
        void foo(int, int) { }
        void bar(int a, int b) { foo(a, b); }
    `);
}

tests.intOverloadResolution = function()
{
    let program = doPrep(`
        int foo(int) { return 1; }
        int foo(uint) { return 2; }
        int foo(float) { return 3; }
        int bar() { return foo(42); }
    `);
    checkInt(program, callFunction(program, "bar", [], []), 1);

tests.intOverloadResolutionReverseOrder = function()
{
    let program = doPrep(`
        int foo(float) { return 3; }
        int foo(uint) { return 2; }
        int foo(int) { return 1; }
        int bar() { return foo(42); }

    checkInt(program, callFunction(program, "bar", [], []), 1);
}

tests.intOverloadResolutionGeneric = function()
{
    let program = doPrep(`
        int foo(int) { return 1; }
        int foo<T>(T) { return 2; }
        int bar() { return foo(42); }
    `);
    checkInt(program, callFunction(program, "bar", [], []), 1);
}

tests.intLiteralGeneric = function()
{
    let program = doPrep(`
        int foo<T>(T x) { return 3478; }
        int bar() { return foo(42); }
    `);
    checkInt(program, callFunction(program, "bar", [], []), 3478);
}

tests.intLiteralGenericWithProtocols = function()
{
    let program = doPrep(`
        protocol MyConvertibleToInt {
            operator int(MyConvertibleToInt);
        }
        int foo<T:MyConvertibleToInt>(T x) { return int(x); }
        int bar() { return foo(42); }
    `);
    checkInt(program, callFunction(program, "bar", [], []), 42);
}

tests.uintLiteralGeneric = function()
{
    let program = doPrep(`
        int foo<T>(T x) { return 3478; }
        int bar() { return foo(42u); }
    `);
    checkInt(program, callFunction(program, "bar", [], []), 3478);
}

tests.uintLiteralGenericWithProtocols = function()
{
    let program = doPrep(`
        protocol MyConvertibleToUint {
            operator uint(MyConvertibleToUint);
        }
        uint foo<T:MyConvertibleToUint>(T x) { return uint(x); }
        uint bar() { return foo(42u); }
    `);
    checkUint(program, callFunction(program, "bar", [], []), 42);
}

tests.intLiteralGenericSpecific = function()
{
    let program = doPrep(`
        T foo<T>(T x) { return x; }
        int bar() { return foo(int(42)); }
    `);
    checkInt(program, callFunction(program, "bar", [], []), 42);
}

tests.simpleConstexpr = function()
{
    let program = doPrep(`
        int foo<int a>(int b)
        {
            return a + b;
        }
        int bar(int b)
        {
            return foo<42>(b);
        }
    `);
    checkInt(program, callFunction(program, "bar", [], [makeInt(program, 58)]), 58 + 42);
}

tests.break = function()
{
    let program = doPrep(`

    checkInt(program, callFunction(program, "foo", [], [makeInt(program, 7)]), 7);
}

tests.prefixPlusPlus = function()
{
    let program = doPrep(`
        int foo<int a>(int b)
        {
            return a + b;
        }
        int bar<int a>(int b)
        {
            return foo<a>(b);
        }
        int baz(int b)
        {
            return bar<42>(b);
        }
    `);
    checkInt(program, callFunction(program, "baz", [], [makeInt(program, 58)]), 58 + 42);
}

tests.chainGeneric = function()
{
    let program = doPrep(`
        T foo<T>(T x)
        {
            return x;
        }
        T bar<T>(thread T* ptr)
        {
            return *foo(ptr);
        }
        int baz(int x)
        {
            return bar(&x);
        }
    `);
    checkInt(program, callFunction(program, "baz", [], [makeInt(program, 37)]), 37);
}

tests.chainStruct = function()
{
    let program = doPrep(`
        struct Foo<T> {
            T f;
        }
        struct Bar<T> {
            Foo<thread T*> f;
        }
        int foo(thread Bar<int>* x)
        {
            return *x->f.f;
        }
        int bar(int a)
        {
            Bar<int> x;
            x.f.f = &a;
            return foo(&x);
        }
    `);
    checkInt(program, callFunction(program, "bar", [], [makeInt(program, 4657)]), 4657);
}

tests.chainStructNewlyValid = function()
{
    let program = doPrep(`
        struct Foo<T> {
            T f;
        }
        struct Bar<T> {
            Foo<device T*> f;
        }
        int foo(thread Bar<int>* x)
        {
            return *x->f.f;
        }
        int bar(device int* a)
        {
            Bar<int> x;
            x.f.f = a;
            return foo(&x);
        }
    `);
    let buffer = new EBuffer(1);
    buffer.set(0, 78453);
    checkInt(program, callFunction(program, "bar", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 78453);
}

tests.chainStructDevice = function()
{
    let program = doPrep(`
        struct Foo<T> {
            T f;
        }
        struct Bar<T> {
            Foo<device T*> f;
        }
        int foo(thread Bar<int>* x)
        {
            return *x->f.f;
        }
        int bar(device int* a)
        {
            Bar<int> x;
            x.f.f = a;
            return foo(&x);
        }
    `);
    let buffer = new EBuffer(1);
    buffer.set(0, 79201);
    checkInt(program, callFunction(program, "bar", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 79201);
}

tests.paramChainStructDevice = function()
{
    let program = doPrep(`
        struct Foo<T> {
            T f;
        }
        struct Bar<T> {
            Foo<T> f;
        }
        int foo(thread Bar<device int*>* x)
        {
            return *x->f.f;
        }
        int bar(device int* a)
        {
            Bar<device int*> x;
            x.f.f = a;
            return foo(&x);
        }
    `);
    let buffer = new EBuffer(1);
    buffer.set(0, 79201);
    checkInt(program, callFunction(program, "bar", [], [TypedValue.box(new PtrType(externalOrigin, "device", program.intrinsics.int32), new EPtr(buffer, 0))]), 79201);
}

tests.simpleProtocolExtends = function()
{
    let program = doPrep(`
        protocol Foo {
            void foo(thread Foo*);
        }
        protocol Bar : Foo {
            void bar(thread Bar*);
        }
        void fuzz<T:Foo>(thread T* p)
        {
            foo(p);
        }
        void buzz<T:Bar>(thread T* p)
        {
            fuzz(p);
            bar(p);
        }
        void foo(thread int* p)
        {
            *p = *p + 743;
        }
        void bar(thread int* p)
        {
            *p = *p + 91;
        }
        int thingy(int a)
        {
            buzz(&a);
            return a;
        }
    `);
    checkInt(program, callFunction(program, "thingy", [], [makeInt(program, 642)]), 642 + 743 + 91);
}

tests.protocolExtendsTwo = function()
{
    let program = doPrep(`
        protocol Foo {
            void foo(thread Foo*);
        }
        protocol Bar {
            void bar(thread Bar*);
        }
        protocol Baz : Foo, Bar {
            void baz(thread Baz*);
        }
        void fuzz<T:Foo>(thread T* p)
        {
            foo(p);
        }
        void buzz<T:Bar>(thread T* p)
        {
            bar(p);
        }
        void xuzz<T:Baz>(thread T* p)
        {
            fuzz(p);
            buzz(p);
            baz(p);
        }
        void foo(thread int* p)
        {
            *p = *p + 743;
        }
        void bar(thread int* p)
        {
            *p = *p + 91;
        }
        void baz(thread int* p)
        {
            *p = *p + 39;
        }
        int thingy(int a)
        {
            xuzz(&a);
            return a;
        }
    `);
    checkInt(program, callFunction(program, "thingy", [], [makeInt(program, 642)]), 642 + 743 + 91 + 39);
}

tests.prefixPlusPlus = function()
{
    let program = doPrep(`
        int foo(int x)

    checkBool(program, callFunction(program, "foo", [], []), true);
}

tests.unifyDifferentLiterals = function()
{
    checkFail(
        () => doPrep(`
            void bar<T>(T, T)
            {
            }
            void foo()
            {
                bar(42, 42u);
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.unifyDifferentLiteralsBackwards = function()
{
    checkFail(
        () => doPrep(`
            void bar<T>(T, T)
            {
            }
            void foo()
            {
                bar(42u, 42);
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.unifyVeryDifferentLiterals = function()
{
    checkFail(
        () => doPrep(`
            void bar<T>(T, T)
            {
            }
            void foo()
            {
                bar(42, null);
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.unifyVeryDifferentLiteralsBackwards = function()
{
    checkFail(
        () => doPrep(`
            void bar<T>(T, T)
            {
            }
            void foo()
            {
                bar(null, 42);
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.assignUintToInt = function()
{
    checkFail(

    let program = doPrep(`
        uint foo()
        {
            float[754] array;
            return (@array).length;
        }
    `);

    let program = doPrep(`
        uint foo()
        {
            float[754] array;
            return array.length;
        }
        uint bar()
        {
            int[754] array;
            return array.length;
        }
    `);
    checkUint(program, callFunction(program, "foo", [], []), 754);
    checkUint(program, callFunction(program, "bar", [], []), 754);
}

tests.nonArrayRefArrayLengthFail = function()

        e => e instanceof WTypeError);
}

tests.constexprIsNotLValuePtr = function()
{
    checkFail(
        () => doPrep(`
            thread int* foo<int x>()
            {
                return &x;
            }
        `),
        e => e instanceof WTypeError);
}

tests.constexprIsNotLValueAssign = function()
{
    checkFail(
        () => doPrep(`
            void foo<int x>()
            {
                x = 42;
            }
        `),
        e => e instanceof WTypeError);
}

tests.constexprIsNotLValueRMW = function()
{
    checkFail(
        () => doPrep(`
            void foo<int x>()
            {
                x += 42;
            }
        `),
        e => e instanceof WTypeError);
}

tests.assignLength = function()
{
    checkFail(
        () => doPrep(`
            void foo()
            {
                float[754] array;
                (@array).length = 42;
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.assignLengthHelper = function()
{
    checkFail(
        () => doPrep(`
            void bar(thread float[] array)
            {
                array.length = 42;
            }
            void foo()
            {
                float[754] array;
                bar(@array);
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.simpleGetter = function()

    checkInt(program, callFunction(program, "foo", [], []), 7804);
}

tests.genericAccessors = function()
{
    let program = doPrep(`
        struct Foo<T> {
            T x;
            T[3] y;
        }
        struct Bar<T> {
            T x;
            T y;
        }
        Bar<T> operator.z<T>(Foo<T> foo)
        {
            Bar<T> result;
            result.x = foo.x;
            result.y = foo.y[1];
            return result;
        }
        Foo<T> operator.z=<T>(Foo<T> foo, Bar<T> bar)
        {
            foo.x = bar.x;
            foo.y[1] = bar.y;
            return foo;
        }
        T operator.sum<T:Addable>(Foo<T> foo)
        {
            return foo.x + foo.y[0] + foo.y[1] + foo.y[2];
        }
        T operator.sum<T:Addable>(Bar<T> bar)
        {
            return bar.x + bar.y;
        }
        operator<T> Bar<T>(T x, T y)
        {
            Bar<T> result;
            result.x = x;
            result.y = y;
            return result;
        }
        void setup(thread Foo<int>* foo)
        {
            foo->x = 1;
            foo->y[0] = 2;
            foo->y[1] = 3;
            foo->y[2] = 4;
        }
        int testSuperBasic()
        {
            Foo<int> foo;
            setup(&foo);
            return foo.sum;
        }
        int testZSetterDidSetY()
        {
            Foo<int> foo;
            foo.z = Bar<int>(53, 932);
            return foo.y[1];
        }
        int testZSetter()
        {
            Foo<int> foo;
            foo.z = Bar<int>(53, 932);
            return foo.sum;
        }
        int testZGetter()
        {
            Foo<int> foo;
            // This deliberately does not call setup() just so we test this syntax.
            foo.x = 1;
            foo.y[0] = 2;
            foo.y[1] = 3;
            foo.y[2] = 4;
            return foo.z.sum;
        }
        int testLValueEmulation()
        {
            Foo<int> foo;
            setup(&foo);
            foo.z.y *= 5;
            return foo.sum;
        }
    `);
    checkInt(program, callFunction(program, "testSuperBasic", [], []), 1 + 2 + 3 + 4);
    checkInt(program, callFunction(program, "testZSetterDidSetY", [], []), 932);
    checkInt(program, callFunction(program, "testZSetter", [], []), 53 + 932);
    checkInt(program, callFunction(program, "testZGetter", [], []), 1 + 3);
    checkInt(program, callFunction(program, "testLValueEmulation", [], []), 1 + 2 + 3 * 5 + 4);
}

tests.bitSubscriptAccessor = function()
{
    let program = doPrep(`
        protocol MyBitmaskable : Equatable {
            MyBitmaskable operator&(MyBitmaskable, MyBitmaskable);
            MyBitmaskable operator|(MyBitmaskable, MyBitmaskable);
            MyBitmaskable operator~(MyBitmaskable);
            MyBitmaskable operator<<(MyBitmaskable, uint);
            MyBitmaskable operator>>(MyBitmaskable, uint);
            operator MyBitmaskable(int);
        }
        T maskForBitIndex<T:MyBitmaskable>(uint index)
        {
            return T(1) << index;
        }
        bool operator[]<T:MyBitmaskable>(T value, uint index)
        {
            return bool(value & maskForBitIndex<T>(index));
        }
        T operator[]=<T:MyBitmaskable>(T value, uint index, bool bit)
        {
            T mask = maskForBitIndex<T>(index);
            if (bit)
                value |= mask;
            else
                value &= ~mask;
            return value;
        }
        uint operator.length(int)
        {
            return 32;
        }
        uint operator.length(uint)
        {
            return 32;
        }
        int testIntSetBit3()
        {
            int foo;
            foo[3] = true;
            return foo;
        }
        bool testIntSetGetBit5()
        {
            int foo;
            foo[5] = true;
            return foo[5];
        }
        bool testIntGetBit1()
        {
            int foo;
            return foo[1];
        }
        int testUintSumBits()
        {
            int foo = 42;
            int result;
            for (uint i = 0; i < foo.length; ++i) {
                if (foo[i])
                    result++;
            }
            return result;
        }
        int testUintSwapBits()
        {
            int foo = 42;
            for (uint i = 0; i < foo.length / 2; ++i) {
                bool tmp = foo[i];
                foo[i] = foo[foo.length - i - 1];
                foo[foo.length - i - 1] = tmp;
            }
            return foo;
        }
        struct Foo {
            uint f;
            uint g;
        }
        operator Foo(uint f, uint g)
        {
            Foo result;
            result.f = f;
            result.g = g;
            return result;
        }
        int operator.h(Foo foo)
        {
            return int((foo.f & 0xffff) | ((foo.g & 0xffff) << 16));
        }
        Foo operator.h=(Foo foo, int value)
        {
            foo.f &= ~0xffffu;
            foo.f |= uint(value) & 0xffff;
            foo.g &= ~0xffffu;
            foo.g |= (uint(value) >> 16) & 0xffff;
            return foo;
        }
        int testLValueEmulation()
        {
            Foo foo;
            foo.f = 42;
            foo.g = 37;
            for (uint i = 0; i < foo.h.length; ++i)
                foo.h[i] ^= true;
            return int(foo.f + foo.g);
        }
        struct Bar {
            Foo a;
            Foo b;
        }
        Foo operator.c(Bar bar)
        {
            return Foo(uint(bar.a.h), uint(bar.b.h));
        }
        Bar operator.c=(Bar bar, Foo foo)
        {
            bar.a.h = int(foo.f);
            bar.b.h = int(foo.g);
            return bar;
        }
        int testCrazyLValueEmulation()
        {
            Bar bar;
            bar.a.f = 1;
            bar.a.g = 2;
            bar.b.f = 3;
            bar.b.g = 4;
            for (uint i = 0; i < bar.c.h.length; i += 2)
                bar.c.h[i] ^= true;
            return int(bar.a.f + bar.a.g + bar.b.f + bar.b.g);
        }
    `);
    checkInt(program, callFunction(program, "testIntSetBit3", [], []), 8);
    checkBool(program, callFunction(program, "testIntSetGetBit5", [], []), true);
    checkBool(program, callFunction(program, "testIntGetBit1", [], []), false);
    checkInt(program, callFunction(program, "testUintSumBits", [], []), 3);
    checkInt(program, callFunction(program, "testUintSwapBits", [], []), 1409286144);
    checkInt(program, callFunction(program, "testLValueEmulation", [], []), 130991);
    checkInt(program, callFunction(program, "testCrazyLValueEmulation", [], []), 43696);
}

tests.nestedSubscriptLValueEmulationSimple = function()
{
    let program = doPrep(`

    checkInt(program, callFunction(program, "testSetValuesMutateValuesAndSum", [], []), 5565);
}

tests.nestedSubscriptLValueEmulationGeneric = function()
{
    let program = doPrep(`
        struct Foo<T> {
            T[7] array;
        }
        T operator[]<T>(Foo<T> foo, uint index)
        {
            return foo.array[index];
        }
        Foo<T> operator[]=<T>(Foo<T> foo, uint index, T value)
        {
            foo.array[index] = value;
            return foo;
        }
        uint operator.length<T>(Foo<T> foo)
        {
            return foo.array.length;
        }
        protocol MyAddable {
            MyAddable operator+(MyAddable, MyAddable);
        }
        T sum<T:MyAddable>(Foo<T> foo)
        {
            T result;
            for (uint i = foo.length; i--;)
                result += foo[i];
            return result;
        }
        struct Bar<T> {
            Foo<T>[6] array;
        }
        uint operator.length<T>(Bar<T> bar)
        {
            return bar.array.length;
        }
        Foo<T> operator[]<T>(Bar<T> bar, uint index)
        {
            return bar.array[index];
        }
        Bar<T> operator[]=<T>(Bar<T> bar, uint index, Foo<T> value)
        {
            bar.array[index] = value;
            return bar;
        }
        T sum<T:MyAddable>(Bar<T> bar)
        {
            T result;
            for (uint i = bar.length; i--;)
                result += sum(bar[i]);
            return result;
        }
        struct Baz<T> {
            Bar<T>[5] array;
        }
        Bar<T> operator[]<T>(Baz<T> baz, uint index)
        {
            return baz.array[index];
        }
        Baz<T> operator[]=<T>(Baz<T> baz, uint index, Bar<T> value)
        {
            baz.array[index] = value;
            return baz;
        }
        uint operator.length<T>(Baz<T> baz)
        {
            return baz.array.length;
        }
        T sum<T:MyAddable>(Baz<T> baz)
        {
            T result;
            for (uint i = baz.length; i--;)
                result += sum(baz[i]);
            return result;
        }
        protocol MyConvertibleFromUint {
            operator MyConvertibleFromUint(uint);
        }
        protocol SetValuable : MyAddable, MyConvertibleFromUint { }
        void setValues<T:SetValuable>(thread Baz<T>* baz)
        {
            for (uint i = baz->length; i--;) {
                for (uint j = (*baz)[i].length; j--;) {
                    for (uint k = (*baz)[i][j].length; k--;)
                        (*baz)[i][j][k] = T(i + j + k);
                }
            }
        }
        int testSetValuesAndSum()
        {
            Baz<int> baz;
            setValues(&baz);
            return sum(baz);
        }
        int testSetValuesMutateValuesAndSum()
        {
            Baz<int> baz;
            setValues(&baz);
            for (uint i = baz.length; i--;) {
                for (uint j = baz[i].length; j--;) {
                    for (uint k = baz[i][j].length; k--;)
                        baz[i][j][k] *= int(k);
                }
            }
            return sum(baz);
        }
    `);
    checkInt(program, callFunction(program, "testSetValuesAndSum", [], []), 1575);
    checkInt(program, callFunction(program, "testSetValuesMutateValuesAndSum", [], []), 5565);
}

tests.boolBitAnd = function()
{
    let program = doPrep(`

        }
        bool foo5()
        {
            return 42.5f == 42.5f;
        }
        float bar(float x)
        {

        {
            return bar(7.5f);
        }
        float foo8()
        {
            return bar(7.5d);
        }
        float foo9()
        {
            return float(7.5);

        {
            return float(7.5f);
        }
        float foo11()
        {
            return float(7.5d);
        }
        float foo12()
        {
            return float(7);
        }
        float foo13()
        {
            float x = 7.5f;
            return float(x);
        }
        double foo14()
        {
            double x = 7.5f;
            return double(x);
        }
    `);
    checkBool(program, callFunction(program, "foo", [], []), true);
    checkBool(program, callFunction(program, "foo2", [], []), true);

    checkBool(program, callFunction(program, "foo5", [], []), true);
    checkFloat(program, callFunction(program, "foo6", [], []), 7.5);
    checkFloat(program, callFunction(program, "foo7", [], []), 7.5);
    checkFloat(program, callFunction(program, "foo8", [], []), 7.5);
    checkFloat(program, callFunction(program, "foo9", [], []), 7.5);
    checkFloat(program, callFunction(program, "foo10", [], []), 7.5);
    checkFloat(program, callFunction(program, "foo11", [], []), 7.5);
    checkFloat(program, callFunction(program, "foo12", [], []), 7);
    checkFloat(program, callFunction(program, "foo13", [], []), 7.5);
    checkDouble(program, callFunction(program, "foo14", [], []), 7.5);
    checkFail(
        () => doPrep(`
            int bar(int x)

            }
            int foo()
            {
                bar(4.f);
            }
        `),
        (e) => e instanceof WTypeError);

            }
            int foo()
            {
                bar(4.f);
            }
        `),
        (e) => e instanceof WTypeError);

            }
        `),
        (e) => e instanceof WTypeError);
    checkFail(
        () => doPrep(`
            float bar(float x)
            {
                return x;
            }
            void foo()
            {
                bar(16777217.d);
            }
        `),
        (e) => e instanceof WTypeError);
    checkFail(
        () => doPrep(`
            float bar(float x)
            {
                return x;
            }
            float foo()
            {
                double x = 7.;
                return bar(x);
            }
        `),
        (e) => e instanceof WTypeError);
    checkFail(
        () => doPrep(`
            float foo()
            {
                double x = 7.;
                return x;
            }
        `),
        (e) => e instanceof WTypeError);
}

tests.genericCastInfer = function()
{
    let program = doPrep(`
        struct Complex<T> {
            T real;
            T imag;
        }
        operator<T> Complex<T>(T real, T imag)
        {
            Complex<T> result;
            result.real = real;
            result.imag = imag;
            return result;
        }
        int foo()
        {
            Complex<int> x = Complex<int>(1, 2);
            return x.real + x.imag;
        }
    `);
    checkInt(program, callFunction(program, "foo", [], []), 3);
}

tests.booleanMath = function()

            float3 c = float3(3., 4., 6.);
            return b == c;
        }
        double food()
        {
            double2 a = double2(3., 4.);
            return a[0];
        }
        double food2()
        {
            double2 a = double2(3., 4.);
            double3 b = double3(a, 5.);
            return b[1];
        }
        double food3()
        {
            double3 a = double3(3., 4., 5.);
            double4 b = double4(6., a);
            return b[1];
        }
        double food4()
        {
            double2 a = double2(3., 4.);
            double2 b = double2(5., 6.);
            double4 c = double4(a, b);
            return c[2];
        }
        bool food5()
        {
            double4 a = double4(3., 4., 5., 6.);
            double2 b = double2(4., 5.);
            double4 c = double4(3., b, 6.);
            return a == c;
        }
        bool food6()
        {
            double2 a = double2(4., 5.);
            double3 b = double3(3., a);
            double3 c = double3(3., 4., 6.);
            return b == c;
        }
    `);
    checkInt(program, callFunction(program, "foo", [], []), 3);
    checkInt(program, callFunction(program, "foo2", [], []), 4);

    checkFloat(program, callFunction(program, "foof4", [], []), 5);
    checkBool(program, callFunction(program, "foof5", [], []), true);
    checkBool(program, callFunction(program, "foof6", [], []), false);
    checkDouble(program, callFunction(program, "food", [], []), 3);
    checkDouble(program, callFunction(program, "food2", [], []), 4);
    checkDouble(program, callFunction(program, "food3", [], []), 3);
    checkDouble(program, callFunction(program, "food4", [], []), 5);
    checkBool(program, callFunction(program, "food5", [], []), true);
    checkBool(program, callFunction(program, "food6", [], []), false);
}

tests.builtinVectorGetters = function()
{
    const typeNames = [ "uint", "int", "float" ];
    const sizes = [ 2, 3, 4 ];
    const elements = [ "x", "y", "z", "w" ];
    const initializerList = [ 1, 2, 3, 4 ];

    let tests = [];
    let src = "";
    for (let typeName of typeNames) {
        for (let size of sizes) {
            for (let i = 0; i < size; i++) {
                const functionName = `${typeName}${size}${elements[i]}`;
                src += `${typeName} ${functionName}()
                        {
                            ${typeName}${size} x = ${typeName}${size}(${initializerList.slice(0, size).join(", ")});
                            return x.${elements[i]};
                        }
                        `;
                tests.push({ type: typeName, name: functionName, expectation: initializerList[i] });
            }
        }
    }

    let program = doPrep(src);
    const checkFuncs = {
        "uint": checkUint,
        "int": checkInt,
        "float": checkFloat
    };
    for (let test of tests) {
        const checkFunc = checkFuncs[test.type];
        checkFunc(program, callFunction(program, test.name, [], []), test.expectation);
    }
}

tests.builtinVectorSetters = function()
{
    const typeNames = [ "uint", "int", "float" ];
    const sizes = [ 2, 3, 4 ];
    const elements = [ "x", "y", "z", "w" ];
    const initializerList = [ 1, 2, 3, 4 ];

    let tests = [];
    let src = "";
    for (let typeName of typeNames) {
        for (let size of sizes) {
            for (let i = 0; i < size; i++) {
                const functionName = `${typeName}${size}${elements[i]}`;
                src += `${typeName} ${functionName}()
                        {
                            ${typeName}${size} x = ${typeName}${size}(${initializerList.slice(0, size).join(", ")});
                            x.${elements[i]} = 34;
                            return x.${elements[i]};
                        }
                        `;
                tests.push({ type: typeName, name: functionName, expectation: 34 });
            }
        }
    }

    let program = doPrep(src);
    const checkFuncs = {
        "uint": checkUint,
        "int": checkInt,
        "float": checkFloat
    };
    for (let test of tests) {
        const checkFunc = checkFuncs[test.type];
        checkFunc(program, callFunction(program, test.name, [], []), test.expectation);
    }
}

tests.builtinVectorIndexSetters = function()
{
    const typeNames = [ "uint", "int", "float" ];
    const sizes = [ 2, 3, 4 ];
    const elements = [ "x", "y", "z", "w" ];
    const initializerList = [ 1, 2, 3, 4 ];

    let tests = [];
    let src = "";
    for (let typeName of typeNames) {
        for (let size of sizes) {
            for (let i = 0; i < size; i++) {
                const functionName = `${typeName}${size}${elements[i]}`;
                src += `${typeName} ${functionName}()
                        {
                            ${typeName}${size} x = ${typeName}${size}(${initializerList.slice(0, size).join(", ")});
                            x[${i}] = 34;
                            return x[${i}];
                        }
                        `;
                tests.push({ type: typeName, name: functionName, expectation: 34 });
            }
        }
    }

    let program = doPrep(src);
    const checkFuncs = {
        "uint": checkUint,
        "int": checkInt,
        "float": checkFloat
    };
    for (let test of tests) {
        const checkFunc = checkFuncs[test.type];
        checkFunc(program, callFunction(program, test.name, [], []), test.expectation);
    }
}

tests.simpleEnum = function()

    checkEnum(program, callFunction(program, "death", [], []), 1);
}

tests.enumConstexprGenericFunction = function()
{
    let program = doPrep(`
        enum Axis { X, Y }
        int foo<Axis axis>() { return int(axis); }
        int testX() { return foo<Axis.X>(); }
        int testY() { return foo<Axis.Y>(); }
    `);
    checkInt(program, callFunction(program, "testX", [], []), 0);
    checkInt(program, callFunction(program, "testY", [], []), 1);
}

tests.enumConstexprGenericStruct = function()
{
    let program = doPrep(`
        enum Axis { X, Y }
        struct Foo<Axis axis> { }
        int foo<Axis axis>(Foo<axis>) { return int(axis); }
        int testX()
        {   
            Foo<Axis.X> f;
            return foo(f);
        }
        int testY()
        {   
            Foo<Axis.Y> f;
            return foo(f);
        }
    `);
    checkInt(program, callFunction(program, "testX", [], []), 0);
    checkInt(program, callFunction(program, "testY", [], []), 1);
}

tests.trap = function()
{
    let program = doPrep(`


tests.exhaustiveUint8Switch = function()
{
    let text = "float foo(uint8 x) { switch (uint8(x)) {"
    for (let i = 0; i <= 0xff; ++i)
        text += "case " + i + ": return " + i * 1.5 + ";";
    text += "} }";
    let program = doPrep(text);
    for (let i = 0; i < 0xff; ++i)
        checkFloat(program, callFunction(program, "foo", [], [makeUint8(program, i)]), i * 1.5);
}

tests.notQuiteExhaustiveUint8Switch = function()
{
    let text = "float foo(uint8 x) { switch (uint8(x)) {"
    for (let i = 0; i <= 0xfe; ++i)
        text += "case " + i + ": return " + i * 1.5 + ";";
    text += "} }";


tests.notQuiteExhaustiveUint8SwitchWithDefault = function()
{
    let text = "float foo(uint8 x) { switch (uint8(x)) {"
    for (let i = 0; i <= 0xfe; ++i)
        text += "case " + i + ": return " + i * 1.5 + ";";
    text += "default: return " + 0xff * 1.5 + ";";
    text += "} }";
    let program = doPrep(text);
    for (let i = 0; i < 0xff; ++i)
        checkFloat(program, callFunction(program, "foo", [], [makeUint8(program, i)]), i * 1.5);
}

tests.switchFallThrough = function()

{
    checkFail(
        () => doPrep(`
            float operator.foo(int)
            {
                return 5.43;
            }

    `);
}

tests.operatorWithUninferrableTypeVariable = function()
{
    checkFail(
        () => doPrep(`
            struct Foo {
                int x;
            }
            Foo operator+<T>(Foo a, Foo b)
            {
                Foo result;
                result.x = a.x + b.x;
                return result;
            }
        `),
        e => e instanceof WTypeError);
}

tests.operatorWithoutUninferrableTypeVariable = function()
{
    let program = doPrep(`

    checkInt(program, callFunction(program, "foo", [], []), 645 - 35);
}

tests.operatorCastWithUninferrableTypeVariable = function()
{
    checkFail(
        () => doPrep(`
            struct Foo {
                int x;
            }
            operator<T> Foo(int x)
            {
                Foo result;
                result.x = x;
                return result;
            }
        `),
        e => e instanceof WTypeError);
}

tests.operatorCastWithTypeVariableInferredFromReturnType = function()
{
    let program = doPrep(`
        struct Foo {
            int x;
        }
        protocol Barable {
            void bar(thread Barable*, int);
        }
        void bar(thread double* result, int value)
        {
            *result = double(value);
        }
        operator<T:Barable> T(Foo foo)
        {
            T result;
            bar(&result, foo.x);
            return result;
        }
        int foo()
        {
            Foo foo;
            foo.x = 75;
            double x = double(foo);
            return int(x * 1.5);
        }
    `);
    checkInt(program, callFunction(program, "foo", [], []), 112);
}

tests.incWrongArgumentLength = function()
{
    checkFail(

{
    checkFail(
        () => doPrep(`
            int operator++(float) { return 32; }
        `),
        e => e instanceof WTypeError);
}

{
    checkFail(
        () => doPrep(`
            int operator--(float) { return 32; }
        `),
        e => e instanceof WTypeError);
}

    checkInt(program, callFunction(program, "foo", [], []), 13);
}

tests.anderWithBadIndex = function()
{
    checkFail(() => doPrep(`
        int foo(thread int[] x) { return x[-1]; }
    `), e => e instanceof Error);

    checkFail(() => doPrep(`
        int foo(thread int[] x) { return x[1.f]; }
    `), e => e instanceof Error);

    checkFail(() => doPrep(`
        int foo(thread int[] x, int y) { return x[y]; }
    `), e => e instanceof Error);

    checkFail(() => doPrep(`
        int foo(thread int[] x, float y) { return x[y]; }
    `), e => e instanceof Error);
}

tests.pointerIndexGetter = function()
{
    checkFail(

{
    checkFail(
        () => doPrep(`
            float operator[](int, uint)
            {
                return 5.43;
            }

        struct Foo {
            int x;
        }
        thread int* operator&[](thread Foo[] array, float index)
        {
            return &array[uint(index + 1)].x;
        }

        {
            Foo x;
            x.x = 13;
            return (@x)[float(-1)];
        }
    `);
    checkInt(program, callFunction(program, "foo", [], []), 13);

        e => e instanceof WTypeError && e.message.indexOf("Illegal pointer to non-primitive type: int32* constant* constant") != -1);
}

tests.pointerIndexGetterInProtocol = function()
{
    for (let addressSpace of addressSpaces) {
        checkFail(
            () => doPrep(`
                protocol Foo {
                    int operator[](${addressSpace} Foo*, uint);
                }
                struct Bar { }
                int operator[](Bar, uint) { return 42; }
            `),
            e => e instanceof WTypeError && e.message.indexOf("Cannot have getter for pointer type") != -1);
    }
}

tests.loneIndexSetterInProtocol = function()
{
    checkFail(
        () => doPrep(`
            protocol Foo {
                Foo operator[]=(Foo, uint, int);
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
            Bar operator[]=(Bar, uint, int) { return Bar(); }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Every setter must have a matching getter") != -1);
}

tests.notLoneIndexSetterInProtocol = function()
{
    doPrep(`
        protocol Foo {
            int operator[](Foo, uint);
            Foo operator[]=(Foo, uint, int);
        }
        struct Bar { }
        int operator[](Bar, uint) { return 42; }
        Bar operator[]=(Bar, uint, int) { return Bar(); }
    `);
}

tests.indexSetterWithMismatchedTypeInProtocol = function()
{
    checkFail(
        () => doPrep(`
            protocol Foo {
                double operator[](Foo, uint);
                Foo operator[]=(Foo, uint, int);
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
            Bar operator[]=(Bar, uint, int) { return Bar(); }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Setter and getter must agree on value type") != -1);
}

tests.indexOperatorWrongArgumentLengthInProtocol = function()
{
    checkFail(
        () => doPrep(`
            protocol Foo {
                int operator[]();
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Protocol's type variable (Foo) not mentioned in signature") != -1);
    checkFail(
        () => doPrep(`
            protocol Foo {
                int operator[](Foo);
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters") != -1);
    checkFail(
        () => doPrep(`
            protocol Foo {
                int operator[](Foo, int, int);
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters") != -1);
}

tests.indexOperatorSetterWrongArgumentLengthInProtocol = function()
{
    checkFail(
        () => doPrep(`
            protocol Foo {
                int operator[]=();
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
            Bar operator[]=(Bar, uint, int) { return Bar(); }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Protocol's type variable (Foo) not mentioned in signature") != -1);
    checkFail(
        () => doPrep(`
            protocol Foo {
                int operator[]=(Foo);
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
            Bar operator[]=(Bar, uint, int) { return Bar(); }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters") != -1);
    checkFail(
        () => doPrep(`
            protocol Foo {
                int operator[]=(Foo, int);
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
            Bar operator[]=(Bar, uint, int) { return Bar(); }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters") != -1);
    checkFail(
        () => doPrep(`
            protocol Foo {
                int operator[]=(Foo, int, int, int);
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
            Bar operator[]=(Bar, uint, int) { return Bar(); }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters") != -1);
}

tests.loneIndexSetterPointerInProtocol = function()
{
    checkFail(
        () => doPrep(`
            protocol Foo {
                thread int* operator[]=(thread Foo* ptr, uint, int);
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
            Bar operator[]=(Bar, uint, int) { return Bar(); }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Cannot have setter for pointer type") != -1);
}

tests.indexSetterWithNoGetterOverloadInProtocol = function()
{
    checkFail(
        () => doPrep(`
            protocol Foo {
                int operator[](int, Foo);
                Foo operator[]=(Foo, uint, int);
            }
            struct Bar { }
            int operator[](Bar, uint) { return 42; }
            Bar operator[]=(Bar, uint, int) { return Bar(); }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Did not find function named operator[]= with arguments Foo,uint32") != -1);
}

tests.indexSetterWithNoGetterOverloadFixedInProtocol = function()
{
    doPrep(`
        protocol Foo {
            int operator[](Foo, uint);
            Foo operator[]=(Foo, uint, int);
        }
        struct Bar { }
        int operator[](Bar, uint) { return 42; }
        Bar operator[]=(Bar, uint, int) { return Bar(); }
    `);
}

tests.indexAnderWithNothingWrongInProtocol = function()
{
    let program = doPrep(`
        protocol Foo {
            thread int* operator&[](thread Foo* foo, uint);
        }
        int bar<T:Foo>(T x)
        {
            return x[42];
        }
        struct Bar { }
        thread int* operator&[](thread Bar*, uint)
        {
            int result = 1234;
            return &result;
        }
        int foo()
        {
            return bar(Bar());
        }
    `);
    checkInt(program, callFunction(program, "foo", [], []), 1234);
}

tests.indexAnderWithWrongNumberOfArgumentsInProtocol = function()
{
    checkFail(
        () => doPrep(`
            protocol Foo {
                thread int* operator&[]();
            }
            struct Bar { }
            thread int* operator&[](thread Bar*, uint)
            {
                int result = 1234;
                return &result;
            }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Protocol's type variable (Foo) not mentioned in signature") != -1);
    checkFail(
        () => doPrep(`
            protocol Foo {
                thread int* operator&[](thread Foo* foo);
            }
            struct Bar { }
            thread int* operator&[](thread Bar*, uint)
            {
                int result = 1234;
                return &result;
            }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters for operator&[]") != -1);
    checkFail(
        () => doPrep(`
            protocol Foo {
                thread int* operator&[](thread Foo* foo, uint, uint);
            }
            struct Bar { }
            thread int* operator&[](thread Bar*, uint)
            {
                int result = 1234;
                return &result;
            }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Incorrect number of parameters for operator&[]") != -1);
}

tests.indexAnderDoesntReturnPointerInProtocol = function()
{
    checkFail(
        () => doPrep(`
            protocol Foo {
                int operator&[](thread Foo* foo, uint);
            }
            struct Bar { }
            thread int* operator&[](thread Bar*, uint)
            {
                int result = 1234;
                return &result;
            }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Return type of ander is not a pointer") != -1);
}

tests.indexAnderDoesntTakeReferenceInProtocol = function()
{
    checkFail(
        () => doPrep(`
            protocol Foo {
                thread int* operator&[](Foo foo, uint);
            }
            struct Bar { }
            thread int* operator&[](thread Bar*, uint)
            {
                int result = 1234;
                return &result;
            }
        `),
        e => e instanceof WTypeError && e.message.indexOf("Parameter to ander is not a reference") != -1);
}

tests.indexAnderWithArrayRefInProtocol = function()
{
    let program = doPrep(`
        protocol Foo {
            thread int* operator&[](thread Foo[] array, double index);
        }
        int bar<T:Foo>(thread T[] x)
        {
            return x[1.5];
        }
        struct Bar { }
        thread int* operator&[](thread Bar[], double)
        {
            int result = 1234;
            return &result;
        }
        int foo()
        {
            Bar x;
            return bar(@x);
        }
    `);
    checkInt(program, callFunction(program, "foo", [], []), 1234);
}

tests.andReturnedArrayRef = function()
{
    let program = doPrep(`

Lines 36-41 class Type extends Node { a/Tools/WebGPUShadingLanguageRI/Type.js_sec1
- a/Tools/WebGPUShadingLanguageRI/Type.js +1 lines
36	get isFloating() { return false; }	36	get isFloating() { return false; }
37	get isEnum() { return false; }	37	get isEnum() { return false; }
38	get isPrimitive() { return false; }	38	get isPrimitive() { return false; }
		39	get isStruct() { return false; }
39		40
40	inherits(protocol)	41	inherits(protocol)
41	{	42	{

Lines 41-47 class TypeDef extends Type { a/Tools/WebGPUShadingLanguageRI/TypeDef.js_sec1
- a/Tools/WebGPUShadingLanguageRI/TypeDef.js -1 / +1 lines
41		41
42	toString()	42	toString()
43	{	43	{
44	return "typedef " + this.name + "<" + this.typeParameters + "> = " + this.type;	44	return `typedef ${this.name} = ${this.type}`;
45	}	45	}
46	}	46	}
47		47



    {
        if (!this.name)
            return this.type.toString();
        return this.name;
            return this.name;
        return this.name + "<" + this.typeArguments + ">";
    }
}




<!DOCTYPE html>
<html>
<head>
    <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="SwizzleOp.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="CallExpression.js"></script>
    <script src="CallFunction.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="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="ConstexprTypeParameter.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="FlattenProtocolExtends.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="FuncInstantiator.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="InstantiateImmediates.js"></script>
    <script src="IntLiteral.js"></script>
    <script src="IntLiteralType.js"></script>
    <script src="Intrinsics.js"></script>
    <script src="LateChecker.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="NameContext.js"></script>
    <script src="NameFinder.js"></script>
    <script src="NameResolver.js"></script>
    <script src="NativeFunc.js"></script>
    <script src="NativeFuncInstance.js"></script>
    <script src="NativeType.js"></script>
    <script src="NativeTypeInstance.js"></script>
    <script src="NormalUsePropertyResolver.js"></script>
    <script src="NullLiteral.js"></script>
    <script src="NullType.js"></script>
    <script src="OperatorAnderIndex.js"></script>
    <script src="OperatorArrayRefLength.js"></script>
    <script src="OperatorBool.js"></script>
    <script src="BuiltinVectorCasts.js"></script>
    <script src="BuiltinVectorGetter.js"></script>
    <script src="BuiltinVectorSetter.js"></script>
    <script src="BuiltinVectorIndexGetter.js"></script>
    <script src="BuiltinVectorIndexSetter.js"></script>
    <script src="BuiltinVectorEqualityOperator.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="Protocol.js"></script>
    <script src="ProtocolDecl.js"></script>
    <script src="ProtocolFuncDecl.js"></script>
    <script src="ProtocolRef.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="StandardLibrary.js"></script>
    <script src="StatementCloner.js"></script>
    <script src="StructLayoutBuilder.js"></script>
    <script src="StructType.js"></script>
    <script src="Substitution.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="TrapStatement.js"></script>
    <script src="TypeDef.js"></script>
    <script src="TypeDefResolver.js"></script>
    <script src="TypeOrVariableRef.js"></script>
    <script src="TypeParameterRewriter.js"></script>
    <script src="TypeRef.js"></script>
    <script src="TypeVariable.js"></script>
    <script src="TypeVariableTracker.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="VisitingSet.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>
<style>
#ShaderSource {
    font-family: monospace;

        case "uint32":
            value = parseInt(value) >>> 0;
            break;
        // FIXME: Parse other types
        default:
            presentError("I don't know how to parse values of type " + type);
        }

Return to Bug 187988

Lines 214-227 function generateSPIRV(spirv, program) a/Tools/WebGPUShadingLanguageRI/SPIRVCodegen.js_sec1
- a/Tools/WebGPUShadingLanguageRI/SPIRVCodegen.js -8 lines
214	values = uintView;	214	values = uintView;
215	break;	215	break;
216	}	216	}
217	case program.intrinsics.double: {
218	let arrayBuffer = new ArrayBuffer(Math.max(Uint32Array.BYTES_PER_ELEMENT, Float64Array.BYTES_PER_ELEMENT));
219	let doubleView = new Float64Array(arrayBuffer);
220	let uintView = new Uint32Array(arrayBuffer);
221	doubleView[0] = node.value;
222	values = uintView;
223	break;
224	}
225	default:	217	default:
226	throw new Error("Unrecognized literal.");	218	throw new Error("Unrecognized literal.");
227	}	219	}

Lines 109-117 class TypeRef extends Type { a/Tools/WebGPUShadingLanguageRI/TypeRef.js_sec1
- a/Tools/WebGPUShadingLanguageRI/TypeRef.js -3 / +1 lines
109	{	109	{
110	if (!this.name)	110	if (!this.name)
111	return this.type.toString();	111	return this.type.toString();
112	if (!this.typeArguments.length)	112	return this.name;
113	return this.name;
114	return this.name + "<" + this.typeArguments + ">";
115	}	113	}
116	}	114	}
117		115

Lines 1-3 a/Tools/ChangeLog_sec1
- a/Tools/ChangeLog +196 lines
		1	2018-07-25 Thomas Denney <tdenney@apple.com>
		2
		3	[WHLSL] Remove generics from the interpreter
		4	https://bugs.webkit.org/show_bug.cgi?id=187988
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* WebGPUShadingLanguageRI/All.js:
		9	* WebGPUShadingLanguageRI/BuiltinVectorCasts.js: Added.
		10	(BuiltinVectorCasts):
		11	(BuiltinVectorCasts.prototype.get baseTypeName):
		12	(BuiltinVectorCasts.prototype.get parameterSizes):
		13	(BuiltinVectorCasts.prototype.get outputSize):
		14	(BuiltinVectorCasts.prototype.toString):
		15	(BuiltinVectorCasts.functions):
		16	(BuiltinVectorCasts._vectorParameterSizesForMaximumSize):
		17	(BuiltinVectorCasts.prototype.instantiateImplementation):
		18	* WebGPUShadingLanguageRI/BuiltinVectorEqualityOperator.js: Copied from Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js.
		19	(BuiltinVectorEqualityOperator):
		20	(BuiltinVectorEqualityOperator.prototype.get baseTypeName):
		21	(BuiltinVectorEqualityOperator.prototype.get size):
		22	(BuiltinVectorEqualityOperator.prototype.toString):
		23	(BuiltinVectorEqualityOperator.functions):
		24	(BuiltinVectorEqualityOperator.prototype.instantiateImplementation):
		25	* WebGPUShadingLanguageRI/BuiltinVectorGetter.js: Copied from Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js.
		26	(BuiltinVectorGetter):
		27	(BuiltinVectorGetter.prototype.get baseTypeName):
		28	(BuiltinVectorGetter.prototype.get size):
		29	(BuiltinVectorGetter.prototype.get elementName):
		30	(BuiltinVectorGetter.prototype.get index):
		31	(BuiltinVectorGetter.prototype.toString):
		32	(BuiltinVectorGetter.functions):
		33	(BuiltinVectorGetter.prototype.instantiateImplementation):
		34	* WebGPUShadingLanguageRI/BuiltinVectorIndexGetter.js: Copied from Tools/WebGPUShadingLanguageRI/LiteralTypeChecker.js.
		35	(BuiltinVectorIndexGetter):
		36	(BuiltinVectorIndexGetter.prototype.get baseTypeName):
		37	(BuiltinVectorIndexGetter.prototype.get size):
		38	(BuiltinVectorIndexGetter.prototype.toString):
		39	(BuiltinVectorIndexGetter.functions):
		40	(BuiltinVectorIndexGetter.prototype.instantiateImplementation):
		41	* WebGPUShadingLanguageRI/BuiltinVectorIndexSetter.js: Added.
		42	(BuiltinVectorIndexSetter):
		43	(BuiltinVectorIndexSetter.prototype.get baseTypeName):
		44	(BuiltinVectorIndexSetter.prototype.get size):
		45	(BuiltinVectorIndexSetter.prototype.get elementName):
		46	(BuiltinVectorIndexSetter.prototype.get index):
		47	(BuiltinVectorIndexSetter.prototype.toString):
		48	(BuiltinVectorIndexSetter.functions):
		49	(BuiltinVectorIndexSetter.prototype.instantiateImplementation):
		50	* WebGPUShadingLanguageRI/BuiltinVectorSetter.js: Added.
		51	(BuiltinVectorSetter):
		52	(BuiltinVectorSetter.prototype.get baseTypeName):
		53	(BuiltinVectorSetter.prototype.get size):
		54	(BuiltinVectorSetter.prototype.get elementName):
		55	(BuiltinVectorSetter.prototype.get index):
		56	(BuiltinVectorSetter.prototype.toString):
		57	(BuiltinVectorSetter.functions):
		58	(BuiltinVectorSetter.prototype.instantiateImplementation):
		59	* WebGPUShadingLanguageRI/CallExpression.js:
		60	(CallExpression.resolve):
		61	(CallExpression.prototype.resolve):
		62	(CallExpression.prototype._resolveToOperatorAnderIndexer):
		63	(CallExpression.prototype._resolveToOperatorLength):
		64	(CallExpression.prototype.toString):
65	(CallExpression):
66	* WebGPUShadingLanguageRI/Checker.js:
67	(Checker.prototype._finishVisitingPropertyAccess):
68	* WebGPUShadingLanguageRI/Func.js:
69	(Func.prototype.toDeclString):
70	* WebGPUShadingLanguageRI/FuncInstantiator.js:
71	(FuncInstantiator.prototype.getUnique.FindTypeVariable.prototype.visitTypeRef): Deleted.
72	(FuncInstantiator.prototype.getUnique.FindTypeVariable.prototype.visitTypeVariable): Deleted.
73	(FuncInstantiator.prototype.getUnique.FindTypeVariable): Deleted.
74	* WebGPUShadingLanguageRI/Intrinsics.js:
75	(Intrinsics):
76	* WebGPUShadingLanguageRI/LiteralTypeChecker.js:
77	(LiteralTypeChecker.prototype.visitGenericLiteralType):
78	(LiteralTypeChecker):
79	* WebGPUShadingLanguageRI/NativeType.js:
80	(NativeType.prototype.toString):
81	(NativeType):
82	* WebGPUShadingLanguageRI/NativeTypeInstance.js:
83	(NativeTypeInstance.prototype.toString):
84	(NativeTypeInstance):
85	* WebGPUShadingLanguageRI/OperatorAnderIndex.js: Added.
86	(OperatorAnderIndexer):
87	(OperatorAnderIndexer.prototype.get addressSpace):
88	(OperatorAnderIndexer.prototype.get baseTypeName):
89	(OperatorAnderIndexer.prototype.toString):
90	(OperatorAnderIndexer.functions):
91	(OperatorAnderIndexer.prototype.instantiateImplementation):
92	* WebGPUShadingLanguageRI/OperatorArrayRefLength.js: Renamed from Tools/WebGPUShadingLanguageRI/DoubleLiteralType.js.
93	(OperatorArrayRefLength):
94	(OperatorArrayRefLength.prototype.get addressSpace):
95	(OperatorArrayRefLength.prototype.get baseTypeName):
96	(OperatorArrayRefLength.prototype.toString):
97	(OperatorArrayRefLength.prototype.instantiateImplementation):
98	* WebGPUShadingLanguageRI/OperatorBool.js: Copied from Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js.
99	(OperatorBool):
100	(OperatorBool.prototype.get baseTypeName):
101	(OperatorBool.prototype.toString):
102	(OperatorBool.functions):
103	(OperatorBool.prototype.instantiateImplementation):
104	* WebGPUShadingLanguageRI/Parse.js:
105	(parseTerm):
106	(parseTypeDef):
107	(isCallExpression):
108	(parseFuncDecl):
109	(parseStructType):
110	(parseNative):
111	(parse):
112	(parseProtocolRef): Deleted.
113	(parseTypeParameters): Deleted.
114	(parseTypeArguments): Deleted.
115	(parseProtocolFuncDecl): Deleted.
116	(parseProtocolDecl): Deleted.
117	* WebGPUShadingLanguageRI/Prepare.js:
118	(let.prepare):
119	* WebGPUShadingLanguageRI/SPIRV.html:
120	* WebGPUShadingLanguageRI/SPIRVCodegen.js:
121	(ConstantFinder.prototype.visitGenericLiteralType):
122	(ConstantFinder):
123	(generateSPIRV):
124	* WebGPUShadingLanguageRI/StandardLibrary.js:
125	(addFunctionsFromClass):
126	(restricted.operator.T.T): Deleted.
127	(operator.T.Equatable.bool): Deleted.
128	(operator.T.vec2.T): Deleted.
129	(bool.operator.T.Equatable): Deleted.
130	(thread.T.operator.T): Deleted.
131	(operator.T.vec3.T): Deleted.
132	(operator.T.vec4.T): Deleted.
133	(uint.length): Deleted.
134	* WebGPUShadingLanguageRI/StructType.js:
135	(StructType.prototype.get isStruct):
136	(StructType.prototype.toString):
137	(StructType):
138	* WebGPUShadingLanguageRI/SwizzleOp.js:
139	(SwizzleOp):
140	(SwizzleOp.prototype.get baseTypeName):
141	(SwizzleOp.prototype.toString):
142	(SwizzleOp.functions.):
143	(SwizzleOp.functions):
144	(SwizzleOp.prototype.instantiateImplementation):
145	(SwizzleOp.allSwizzleOperators.): Deleted.
146	(SwizzleOp.allSwizzleOperators): Deleted.
147	* WebGPUShadingLanguageRI/SynthesizeArrayOperatorLength.js: Renamed from Tools/WebGPUShadingLanguageRI/DoubleLiteral.js.
148	(synthesizeArrayOperatorLength.FindArrayTypes.prototype.visitArrayType):
149	(synthesizeArrayOperatorLength.FindArrayTypes):
150	(synthesizeArrayOperatorLength):
151	* WebGPUShadingLanguageRI/SynthesizeCopyConstructorOperator.js: Copied from Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js.
152	(synthesizeCopyConstructorOperator.FindAllTypes.prototype.visitNativeType):
153	(synthesizeCopyConstructorOperator.FindAllTypes.prototype.visitStructType):
154	(synthesizeCopyConstructorOperator.FindAllTypes.prototype.visitElementalType):
155	(synthesizeCopyConstructorOperator.FindAllTypes):
156	(synthesizeCopyConstructorOperator):
157	* WebGPUShadingLanguageRI/SynthesizeDefaultConstructorOperator.js: Copied from Tools/WebGPUShadingLanguageRI/NativeTypeInstance.js.
158	(synthesizeDefaultConstructorOperator.FindAllTypes.prototype.visitNativeType):
159	(synthesizeDefaultConstructorOperator.FindAllTypes.prototype.visitStructType):
160	(synthesizeDefaultConstructorOperator.FindAllTypes.prototype.visitElementalType):
161	(synthesizeDefaultConstructorOperator.FindAllTypes):
162	(synthesizeDefaultConstructorOperator):
163	* WebGPUShadingLanguageRI/Test.html:
164	* WebGPUShadingLanguageRI/Test.js:
165	(makeDouble): Deleted.
166	(checkDouble): Deleted.
167	* WebGPUShadingLanguageRI/Type.js:
168	(Type.prototype.get isStruct):
169	* WebGPUShadingLanguageRI/TypeDef.js:
170	(TypeDef.prototype.toString):
171	(TypeDef):
172	* WebGPUShadingLanguageRI/TypeRef.js:
173	(TypeRef.prototype.toString):
174	(TypeRef):
175	* WebGPUShadingLanguageRI/index.html:
176
177	2018-07-24 Thomas Denney <tdenney@apple.com>
178
179	Remove support for the double type from WHLSL
180	https://bugs.webkit.org/show_bug.cgi?id=187977
181
182	Reviewed by Myles C. Maxfield.
183
184	* WebGPUShadingLanguageRI/All.js: Removed DoubleLiteral.js and DoubleLiteralType.js include.
185	* WebGPUShadingLanguageRI/DoubleLiteral.js: Removed.
186	* WebGPUShadingLanguageRI/DoubleLiteralType.js: Removed.
187	* WebGPUShadingLanguageRI/Intrinsics.js: Removed double arithmetic functions.
188	* WebGPUShadingLanguageRI/Parse.js:
189	(parseTerm): Removed parsing of double literals.
190	* WebGPUShadingLanguageRI/SPIRV.html: Removed DoubleLiteral.js and DoubleLiteralType.js include.
191	* WebGPUShadingLanguageRI/SPIRVCodegen.js: Removed double type logic.
192	* WebGPUShadingLanguageRI/StandardLibrary.js: Removed double type declarations.
193	* WebGPUShadingLanguageRI/Test.html: Removed DoubleLiteral.js and DoubleLiteralType.js include.
194	* WebGPUShadingLanguageRI/Test.js: Removed tests that test doubles or ported them to use floats.
195	* WebGPUShadingLanguageRI/index.html: Removed DoubleLiteral.js and DoubleLiteralType.js include.
196
1	2018-07-24 Daniel Bates <dabates@apple.com>	197	2018-07-24 Daniel Bates <dabates@apple.com>
2		198
3	Move-constructing NeverDestroyed should move construct underlying object instead of copy constructing it	199	Move-constructing NeverDestroyed should move construct underlying object instead of copy constructing it

Lines 34-39 load("Visitor.js"); a/Tools/WebGPUShadingLanguageRI/All.js_sec1
- a/Tools/WebGPUShadingLanguageRI/All.js -5 / +16 lines
34	load("CreateLiteral.js");	34	load("CreateLiteral.js");
35	load("CreateLiteralType.js");	35	load("CreateLiteralType.js");
36	load("PropertyAccessExpression.js");	36	load("PropertyAccessExpression.js");
		37	load("SwizzleOp.js");
37		38
38	load("AddressSpace.js");	39	load("AddressSpace.js");
39	load("AnonymousVariable.js");	40	load("AnonymousVariable.js");
Lines 49-56 load("CallFunction.js"); a/Tools/WebGPUShadingLanguageRI/All.js_sec2
49	load("Check.js");	50	load("Check.js");
50	load("CheckLiteralTypes.js");	51	load("CheckLiteralTypes.js");
51	load("CheckLoops.js");	52	load("CheckLoops.js");
52	load("CheckRecursiveTypes.js");
53	load("CheckRecursion.js");	53	load("CheckRecursion.js");
		54	load("CheckRecursiveTypes.js");
54	load("CheckReturns.js");	55	load("CheckReturns.js");
55	load("CheckUnreachableCode.js");	56	load("CheckUnreachableCode.js");
56	load("CheckWrapped.js");	57	load("CheckWrapped.js");
Lines 61-71 load("ConstexprFolder.js"); a/Tools/WebGPUShadingLanguageRI/All.js_sec3
61	load("ConstexprTypeParameter.js");	62	load("ConstexprTypeParameter.js");
62	load("Continue.js");	63	load("Continue.js");
63	load("ConvertPtrToArrayRefExpression.js");	64	load("ConvertPtrToArrayRefExpression.js");
64	load("DereferenceExpression.js");
65	load("DoWhileLoop.js");	65	load("DoWhileLoop.js");
66	load("DotExpression.js");	66	load("DotExpression.js");
67	load("DoubleLiteral.js");	67	load("DereferenceExpression.js");
68	load("DoubleLiteralType.js");
69	load("EArrayRef.js");	68	load("EArrayRef.js");
70	load("EBuffer.js");	69	load("EBuffer.js");
71	load("EBufferBuilder.js");	70	load("EBufferBuilder.js");
Lines 120-132 load("NativeTypeInstance.js"); a/Tools/WebGPUShadingLanguageRI/All.js_sec4
120	load("NormalUsePropertyResolver.js");	119	load("NormalUsePropertyResolver.js");
121	load("NullLiteral.js");	120	load("NullLiteral.js");
122	load("NullType.js");	121	load("NullType.js");
		122	load("OperatorAnderIndex.js");
		123	load("OperatorArrayRefLength.js");
		124	load("OperatorBool.js");
		125	load("BuiltinVectorCasts.js");
		126	load("BuiltinVectorGetter.js");
		127	load("BuiltinVectorSetter.js");
		128	load("BuiltinVectorIndexGetter.js");
		129	load("BuiltinVectorIndexSetter.js");
		130	load("BuiltinVectorEqualityOperator.js");
123	load("OriginKind.js");	131	load("OriginKind.js");
124	load("OverloadResolutionFailure.js");	132	load("OverloadResolutionFailure.js");
125	load("Parse.js");	133	load("Parse.js");
126	load("Prepare.js");	134	load("Prepare.js");
		135	load("PropertyResolver.js");
127	load("Program.js");	136	load("Program.js");
128	load("ProgramWithUnnecessaryThingsRemoved.js");	137	load("ProgramWithUnnecessaryThingsRemoved.js");
129	load("PropertyResolver.js");
130	load("Protocol.js");	138	load("Protocol.js");
131	load("ProtocolDecl.js");	139	load("ProtocolDecl.js");
132	load("ProtocolFuncDecl.js");	140	load("ProtocolFuncDecl.js");
Lines 149-156 load("StructType.js"); a/Tools/WebGPUShadingLanguageRI/All.js_sec5
149	load("Substitution.js");	157	load("Substitution.js");
150	load("SwitchCase.js");	158	load("SwitchCase.js");
151	load("SwitchStatement.js");	159	load("SwitchStatement.js");
		160	load("SynthesizeArrayOperatorLength.js");
152	load("SynthesizeEnumFunctions.js");	161	load("SynthesizeEnumFunctions.js");
153	load("SynthesizeStructAccessors.js");	162	load("SynthesizeStructAccessors.js");
		163	load("SynthesizeCopyConstructorOperator.js");
		164	load("SynthesizeDefaultConstructorOperator.js");
154	load("TrapStatement.js");	165	load("TrapStatement.js");
155	load("TypeDef.js");	166	load("TypeDef.js");
156	load("TypeDefResolver.js");	167	load("TypeDefResolver.js");

Line 0 a/Tools/WebGPUShadingLanguageRI/BuiltinVectorCasts.js_sec1
- a/Tools/WebGPUShadingLanguageRI/BuiltinVectorCasts.js +90 lines
		1	/*
		2	* Copyright (C) 2017 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
		14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
		17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25	"use strict";
		26
		27	class BuiltinVectorCasts {
		28	constructor(baseTypeName, parameterSizes)
		29	{
		30	this._baseTypeName = baseTypeName;
		31	this._parameterSizes = parameterSizes;
		32	}
		33
		34	get baseTypeName() { return this._baseTypeName; }
		35	get parameterSizes() { return this._parameterSizes; }
		36	get outputSize()
		37	{
		38	let sum = 0;
		39	for (let paramSize of this.parameterSizes)
		40	sum += paramSize;
		41	return sum;
		42	}
		43
		44	toString()
		45	{
		46	return `native operator ${this.baseTypeName}${this.outputSize}(${this.parameterSizes.map(x => x == 1 ? this.baseTypeName : this.baseTypeName + x).join(",")})`;
		47	}
		48
		49	static functions()
		50	{
		51	if (!this._functions) {
		52	this._functions = [];
		53
		54	const typeNames = [ "uint", "int", "float" ];
		55	const sizes = [ 2, 3, 4 ];
		56
		57	for (let typeName of typeNames) {
		58	for (let size of sizes) {
		59	for (let paramSizes of this._vectorParameterSizesForMaximumSize(size))
		60	this._functions.push(new BuiltinVectorCasts(typeName, paramSizes));
		61	}
		62	}
		63	}
		64	return this._functions;
65	}
66
67	static _vectorParameterSizesForMaximumSize(maxSize)
68	{
69	let variants = [ [ maxSize ] ];
70	for (let splitPoint = 1; splitPoint < maxSize; splitPoint++) {
71	for (let v of BuiltinVectorCasts._vectorParameterSizesForMaximumSize(maxSize - splitPoint))
72	variants.push([ splitPoint ].concat(v));
73	}
74	return variants;
75	}
76
77	instantiateImplementation(func)
78	{
79	func.implementation = (args) => {
80	const result = new EPtr(new EBuffer(this.outputSize), 0);
81	let offset = 0;
82	for (let i = 0; i < args.length; i++) {
83	for (let j = 0; j < this.parameterSizes[i]; j++)
84	result.set(offset++, args[i].get(j));
85	}
86	return result;
87	};
88	func.implementationData = this;
89	}
90	}

Lines 42-58 class CallExpression extends Expression { a/Tools/WebGPUShadingLanguageRI/CallExpression.js_sec1
- a/Tools/WebGPUShadingLanguageRI/CallExpression.js -4 / +68 lines
42	get isCast() { return this._isCast; }	42	get isCast() { return this._isCast; }
43	get returnType() { return this._returnType; }	43	get returnType() { return this._returnType; }
44		44
45	static resolve(origin, possibleOverloads, typeParametersInScope, name, typeArguments, argumentList, argumentTypes, returnType)	45	static resolve(origin, possibleOverloads, typeParametersInScope, name, typeArguments, argumentList, argumentTypes, returnType, uintType)
46	{	46	{
47	let call = new CallExpression(origin, name, typeArguments, argumentList);	47	let call = new CallExpression(origin, name, typeArguments, argumentList);
48	call.argumentTypes = argumentTypes.map(argument => argument.visit(new AutoWrapper()));	48	call.argumentTypes = argumentTypes.map(argument => argument.visit(new AutoWrapper()));
49	call.possibleOverloads = possibleOverloads;	49	call.possibleOverloads = possibleOverloads;
50	if (returnType)	50	if (returnType)
51	call.setCastData(returnType);	51	call.setCastData(returnType);
52	return {call, resultType: call.resolve(possibleOverloads, typeParametersInScope, typeArguments)};	52	return {call, resultType: call.resolve(possibleOverloads, typeParametersInScope, typeArguments, uintType)};
53	}	53	}
54		54
55	resolve(possibleOverloads, typeParametersInScope, typeArguments)	55	resolve(possibleOverloads, typeParametersInScope, typeArguments, uintType)
56	{	56	{
57	if (!possibleOverloads)	57	if (!possibleOverloads)
58	throw new WTypeError(this.origin.originString, "Did not find any functions named " + this.name);	58	throw new WTypeError(this.origin.originString, "Did not find any functions named " + this.name);
Lines 77-82 class CallExpression extends Expression { a/Tools/WebGPUShadingLanguageRI/CallExpression.js_sec2
77	if (!overload) {	77	if (!overload) {
78	overload = resolveOverloadImpl(	78	overload = resolveOverloadImpl(
79	possibleOverloads, this.typeArguments, this.argumentTypes, this.returnType);	79	possibleOverloads, this.typeArguments, this.argumentTypes, this.returnType);
		80
		81	if (!overload.func && this.name == "operator&[]")
		82	return this._resolveToOperatorAnderIndexer(uintType);
		83
		84	if (!overload.func && this.name == "operator.length")
		85	return this._resolveToOperatorLength(uintType);
		86
80	if (!overload.func) {	87	if (!overload.func) {
81	failures.push(...overload.failures);	88	failures.push(...overload.failures);
82	let message = "Did not find function named " + this.name + " for call with ";	89	let message = "Did not find function named " + this.name + " for call with ";
Lines 108-113 class CallExpression extends Expression { a/Tools/WebGPUShadingLanguageRI/CallExpression.js_sec3
108	}	115	}
109	return this.resolveToOverload(overload);	116	return this.resolveToOverload(overload);
110	}	117	}
		118
		119	_resolveToOperatorAnderIndexer(uintType)
		120	{
		121	let arrayRefType = this.argumentTypes[0];
		122	if (!arrayRefType.isArrayRef)
		123	throw new WTypeError(this.origin.originString, `Expected ${arrayRefType} to be an array ref type for operator&[]`);
		124
		125	let indexType = this.argumentTypes[1];
		126	const addressSpace = arrayRefType.addressSpace;
		127
		128	// The later checkLiteralTypes stage will verify that the literal can be represented as a uint
		129	uintType = TypeRef.wrap(uintType);
		130	indexType.type = uintType;
		131
		132	const elementType = this.argumentTypes[0].elementType;
		133	this.resultType = this._returnType = TypeRef.wrap(new PtrType(this.origin, addressSpace, TypeRef.wrap(elementType)))
		134
		135	let arrayRefAccessor = new OperatorAnderIndexer(this.returnType.toString(), addressSpace);
		136	let nativeFunc = new NativeFunc(this.origin, "operator&[]", this.resultType, [], [
		137	new FuncParameter(this.origin, null, arrayRefType),
		138	new FuncParameter(this.origin, null, uintType)
		139	], false, null);
		140
		141	arrayRefAccessor.instantiateImplementation(nativeFunc);
		142
		143	this.func = nativeFunc;
		144	this.actualTypeArguments = [];
		145	this.instantiatedActualTypeArguments = this.actualTypeArguments;
		146
		147	return this.resultType;
		148	}
		149
		150	_resolveToOperatorLength(uintType)
		151	{
		152	this.resultType = this._returnType = TypeRef.wrap(uintType);
		153
		154	if (this.argumentTypes[0].isArray) {
		155	const arrayType = this.argumentTypes[0];
		156	this.func = new NativeFunc(this.origin, "operator.length", this.resultType, [], [
		157	new FuncParameter(this.origin, null, arrayType)
		158	], false, null);
		159	this.func.implementation = (args, node) => EPtr.box(arrayType.numElementsValue);
		160	} else if (this.argumentTypes[0].isArrayRef) {
		161	const arrayRefType = this.argumentTypes[0];
		162	const addressSpace = arrayRefType.addressSpace;
		163	const operatorLength = new OperatorArrayRefLength(arrayRefType.toString(), addressSpace);
		164	this.func = new NativeFunc(this.origin, "operator.length", this.resultType, [], [
		165	new FuncParameter(this.origin, null, arrayRefType)
		166	], false, null);
		167	operatorLength.instantiateImplementation(this.func);
		168	} else
		169	throw new WTypeError(this.origin.originString, `Expected ${this.argumentTypes[0]} to be array/array ref type for operator.length`);
		170
		171
		172	this.actualTypeArguments = this.instantiatedActualTypeArguments = [];
		173	return this.resultType;
		174	}
111		175
112	resolveToOverload(overload)	176	resolveToOverload(overload)
113	{	177	{
Lines 141-147 class CallExpression extends Expression { a/Tools/WebGPUShadingLanguageRI/CallExpression.js_sec4
141	toString()	205	toString()
142	{	206	{
143	return (this.isCast ? "operator " + this.returnType : this.name) +	207	return (this.isCast ? "operator " + this.returnType : this.name) +
144	"<" + this.typeArguments + ">" +	208	// "<" + this.typeArguments + ">" +
145	(this.actualTypeArguments ? "<<" + this.actualTypeArguments + ">>" : "") +	209	(this.actualTypeArguments ? "<<" + this.actualTypeArguments + ">>" : "") +
146	"(" + this.argumentList + ")";	210	"(" + this.argumentList + ")";
147	}	211	}

Lines 427-433 class Checker extends Visitor { a/Tools/WebGPUShadingLanguageRI/Checker.js_sec1
- a/Tools/WebGPUShadingLanguageRI/Checker.js -3 / +3 lines
427	try {	427	try {
428	let result = CallExpression.resolve(	428	let result = CallExpression.resolve(
429	node.origin, node.possibleGetOverloads, this._currentStatement.typeParameters,	429	node.origin, node.possibleGetOverloads, this._currentStatement.typeParameters,
430	node.getFuncName, [], [node.base, ...extraArgs], [baseType, ...extraArgTypes], null);	430	node.getFuncName, [], [node.base, ...extraArgs], [baseType, ...extraArgTypes], null, this._program.types.get("uint32"));
431	node.callForGet = result.call;	431	node.callForGet = result.call;
432	node.resultTypeForGet = result.resultType;	432	node.resultTypeForGet = result.resultType;
433	} catch (e) {	433	} catch (e) {
Lines 442-448 class Checker extends Visitor { a/Tools/WebGPUShadingLanguageRI/Checker.js_sec2
442	let result = CallExpression.resolve(	442	let result = CallExpression.resolve(
443	node.origin, node.possibleAndOverloads, this._currentStatement.typeParameters,	443	node.origin, node.possibleAndOverloads, this._currentStatement.typeParameters,
444	node.andFuncName, [], [baseForAnd, ...extraArgs], [typeForAnd, ...extraArgTypes],	444	node.andFuncName, [], [baseForAnd, ...extraArgs], [typeForAnd, ...extraArgTypes],
445	null);	445	null, this._program.types.get("uint32"));
446	node.callForAnd = result.call;	446	node.callForAnd = result.call;
447	node.resultTypeForAnd = result.resultType.unifyNode.returnTypeFromAndOverload(node.origin);	447	node.resultTypeForAnd = result.resultType.unifyNode.returnTypeFromAndOverload(node.origin);
448	} catch (e) {	448	} catch (e) {
Lines 467-473 class Checker extends Visitor { a/Tools/WebGPUShadingLanguageRI/Checker.js_sec3
467	try {	467	try {
468	let result = CallExpression.resolve(	468	let result = CallExpression.resolve(
469	node.origin, node.possibleSetOverloads, this._currentStatement.typeParameters,	469	node.origin, node.possibleSetOverloads, this._currentStatement.typeParameters,
470	node.setFuncName, [], [node.base, ...extraArgs, null], [baseType, ...extraArgTypes, node.resultType], null);	470	node.setFuncName, [], [node.base, ...extraArgs, null], [baseType, ...extraArgTypes, node.resultType], null, this._program.types.get("uint32"));
471	node.callForSet = result.call;	471	node.callForSet = result.call;
472	if (!result.resultType.equals(baseType))	472	if (!result.resultType.equals(baseType))
473	throw new WTypeError(node.origin.originString, "Result type of setter " + result.call.func + " is not the base type " + baseType);	473	throw new WTypeError(node.origin.originString, "Result type of setter " + result.call.func + " is not the base type " + baseType);

Lines 1-41 a/Tools/WebGPUShadingLanguageRI/DoubleLiteral.js_sec1
- a/Tools/WebGPUShadingLanguageRI/DoubleLiteral.js -41 lines
1	/*
2	* Copyright (C) 2017 Apple Inc. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions
6	* are met:
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	*
13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24	*/
25	"use strict";
26
27	let DoubleLiteral = createLiteral({
28	literalClassName: "DoubleLiteral",
29	preferredTypeName: "double",
30
31	negConstexpr(origin)
32	{
33	return new IntLiteral(origin, -this.value);
34	},
35
36	createType(origin, value)
37	{
38	return new DoubleLiteralType(origin, value);
39	}
40	});
41

Lines 65-73 class Func extends Node { a/Tools/WebGPUShadingLanguageRI/Func.js_sec1
- a/Tools/WebGPUShadingLanguageRI/Func.js -2 / +2 lines
65	if (this.shaderType)	65	if (this.shaderType)
66	result += this.shaderType + " ";	66	result += this.shaderType + " ";
67	if (this.isCast)	67	if (this.isCast)
68	result += "operator<" + this.typeParameters + "> " + this.returnType;	68	result += `operator ${this.returnType}`;
69	else	69	else
70	result += this.returnType + " " + this.name + "<" + this.typeParameters + ">";	70	result += `${this.returnType} ${this.name}`;
71	return result + "(" + this.parameters + ")";	71	return result + "(" + this.parameters + ")";
72	}	72	}
73		73

Line 0 a/Tools/WebGPUShadingLanguageRI/OperatorAnderIndex.js_sec1
- a/Tools/WebGPUShadingLanguageRI/OperatorAnderIndex.js +77 lines
		1	/*
		2	* Copyright (C) 2017 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
		14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
		17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25	"use strict";
		26
		27	class OperatorAnderIndexer {
		28	constructor(baseTypeName, addressSpace)
		29	{
		30	this._baseTypeName = baseTypeName;
		31	this._addressSpace = addressSpace;
		32	}
		33
		34	get addressSpace() { return this._addressSpace; }
		35	get baseTypeName() { return this._baseTypeName; }
		36
		37	toString()
		38	{
		39	return `native ${this.baseTypeName}* ${this.addressSpace} operator&[](${this.baseTypeName}[] ${this.addressSpace},uint)`;
		40	}
		41
		42	static functions()
		43	{
		44	if (!this._functions) {
		45	this._functions = [];
		46
		47	const typeNames = [ "uint", "int", "float", "bool", "int2", "uint2", "float2", "int3", "uint3", "float3", "int4", "uint4", "float4" ];
		48	const addressSpaces = [ "thread", "threadgroup", "device", "constant" ];
		49
		50	for (let addressSpace of addressSpaces) {
		51	for (let typeName of typeNames)
		52	this._functions.push(new OperatorAnderIndexer(typeName, addressSpace));
		53	}
		54	}
		55	return this._functions;
		56	}
		57
		58	// static indexersForTypeName(typeName)
		59	// {
		60	// const addressSpaces = [ "thread", "threadgroup", "device", "constant" ];
		61	// return addressSpaces.map(addrSpace => new OperatorAnderIndexer(typeName, addrSpace));
		62	// }
		63
		64	instantiateImplementation(func)
65	{
66	func.implementation = ([ref, index], node) => {
67	ref = ref.loadValue();
68	if (!ref)
69	throw new WTrapError(node.origin.originString, "Null dereference");
70	index = index.loadValue();
71	if (index > ref.length)
72	throw new WTrapError(node.origin.originString, "Array index " + index + " is out of bounds of " + ref);
73	return EPtr.box(ref.ptr.plus(index * node.argumentTypes[0].elementType.size));
74	};
75	func.implementationData = this;
76	}
77	}

Lines 121-132 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec1
- a/Tools/WebGPUShadingLanguageRI/Parse.js -123 / +7 lines
121	return result;	121	return result;
122	}	122	}
123		123
124	function parseProtocolRef()
125	{
126	let protocolToken = consumeKind("identifier");
127	return new ProtocolRef(protocolToken, protocolToken.text);
128	}
129
130	function consumeEndOfTypeArgs()	124	function consumeEndOfTypeArgs()
131	{	125	{
132	let rightShift = tryConsume(">>");	126	let rightShift = tryConsume(">>");
Lines 136-169 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec2
136	consume(">");	130	consume(">");
137	}	131	}
138		132
139	function parseTypeParameters()
140	{
141	if (!test("<"))
142	return [];
143
144	let result = [];
145	consume("<");
146	while (!test(">")) {
147	let constexpr = lexer.backtrackingScope(() => {
148	let type = parseType();
149	let name = consumeKind("identifier");
150	assertNext(",", ">", ">>");
151	return new ConstexprTypeParameter(type.origin, name.text, type);
152	});
153	if (constexpr)
154	result.push(constexpr);
155	else {
156	let name = consumeKind("identifier");
157	let protocol = tryConsume(":") ? parseProtocolRef() : null;
158	result.push(new TypeVariable(name, name.text, protocol));
159	}
160	if (!tryConsume(","))
161	break;
162	}
163	consumeEndOfTypeArgs();
164	return result;
165	}
166
167	function parseTerm()	133	function parseTerm()
168	{	134	{
169	let token;	135	let token;
Lines 201-219 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec3
201	return new IntLiteral(token, intVersion);	167	return new IntLiteral(token, intVersion);
202	return new UintLiteral(token, intVersion >>> 0);	168	return new UintLiteral(token, intVersion >>> 0);
203	}	169	}
204	if (token = tryConsumeKind("doubleLiteral"))
205	return new DoubleLiteral(token, +token.text);
206	if (token = tryConsumeKind("floatLiteral")) {	170	if (token = tryConsumeKind("floatLiteral")) {
207	let text = token.text;	171	let text = token.text;
208	let d = token.text.endsWith("d");
209	let f = token.text.endsWith("f");	172	let f = token.text.endsWith("f");
210	if (d && f)	173	if (f)
211	throw new Error("Literal cannot be both a double literal and a float literal.");
212	if (d \|\| f)
213	text = text.substring(0, text.length - 1);	174	text = text.substring(0, text.length - 1);
214	let value = parseFloat(text);	175	let value = parseFloat(text);
215	if (d)
216	return new DoubleLiteral(token, value);
217	return new FloatLiteral(token, Math.fround(value));	176	return new FloatLiteral(token, Math.fround(value));
218	}	177	}
219	if (token = tryConsume("true", "false"))	178	if (token = tryConsume("true", "false"))
Lines 236-285 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec4
236	return left;	195	return left;
237	}	196	}
238		197
239	function parseTypeArguments()
240	{
241	if (!test("<"))
242	return [];
243
244	let result = [];
245	consume("<");
246	while (!test(">")) {
247	// It's possible for a constexpr or type can syntactically overlap in the single
248	// identifier case. Let's consider the possibilities:
249	//
250	// T could be type or constexpr
251	// T[] only type
252	// T[42] only type (constexpr cannot do indexing)
253	// 42 only constexpr
254	//
255	// In the future we'll allow constexprs to do more things, and then we'll still have
256	// the problem that something of the form T[1][2][3]... can either be a type or a
257	// constexpr, and we can figure out in the checker which it is.
258	let typeOrVariableRef = lexer.backtrackingScope(() => {
259	let result = consumeKind("identifier");
260	assertNext(",", ">", ">>");
261	return new TypeOrVariableRef(result, result.text);
262	});
263	if (typeOrVariableRef)
264	result.push(typeOrVariableRef);
265	else {
266	let constexpr = lexer.backtrackingScope(() => {
267	let result = parseConstexpr();
268	assertNext(",", ">", ">>");
269	return result;
270	});
271	if (constexpr)
272	result.push(constexpr);
273	else
274	result.push(parseType());
275	}
276	if (!tryConsume(","))
277	break;
278	}
279	consumeEndOfTypeArgs();
280	return result;
281	}
282
283	function parseType()	198	function parseType()
284	{	199	{
285	let token;	200	let token;
Lines 289-295 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec5
289	addressSpace = token.text;	204	addressSpace = token.text;
290		205
291	let name = consumeKind("identifier");	206	let name = consumeKind("identifier");
292	let typeArguments = parseTypeArguments();	207	let typeArguments = [];
293	let type = new TypeRef(name, name.text, typeArguments);	208	let type = new TypeRef(name, name.text, typeArguments);
294		209
295	function getAddressSpace()	210	function getAddressSpace()
Lines 325-331 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec6
325	{	240	{
326	let origin = consume("typedef");	241	let origin = consume("typedef");
327	let name = consumeKind("identifier").text;	242	let name = consumeKind("identifier").text;
328	let typeParameters = parseTypeParameters();	243	let typeParameters = [];
329	consume("=");	244	consume("=");
330	let type = parseType();	245	let type = parseType();
331	consume(";");	246	consume(";");
Lines 352-358 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec7
352	function parseCallExpression()	267	function parseCallExpression()
353	{	268	{
354	let name = consumeKind("identifier");	269	let name = consumeKind("identifier");
355	let typeArguments = parseTypeArguments();	270	let typeArguments = [];
356	consume("(");	271	consume("(");
357	let argumentList = [];	272	let argumentList = [];
358	while (!test(")")) {	273	while (!test(")")) {
Lines 370-376 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec8
370	{	285	{
371	return lexer.testScope(() => {	286	return lexer.testScope(() => {
372	consumeKind("identifier");	287	consumeKind("identifier");
373	parseTypeArguments();
374	consume("(");	288	consume("(");
375	});	289	});
376	}	290	}
Lines 865-877 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec9
865	let origin;	779	let origin;
866	let returnType;	780	let returnType;
867	let name;	781	let name;
868	let typeParameters;	782	let typeParameters = [];
869	let isCast;	783	let isCast;
870	let shaderType;	784	let shaderType;
871	let operatorToken = tryConsume("operator");	785	let operatorToken = tryConsume("operator");
872	if (operatorToken) {	786	if (operatorToken) {
873	origin = operatorToken;	787	origin = operatorToken;
874	typeParameters = parseTypeParameters();
875	returnType = parseType();	788	returnType = parseType();
876	name = "operator cast";	789	name = "operator cast";
877	isCast = true;	790	isCast = true;
Lines 884-901 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec10
884	} else	797	} else
885	origin = returnType.origin;	798	origin = returnType.origin;
886	name = parseFuncName();	799	name = parseFuncName();
887	typeParameters = parseTypeParameters();
888	isCast = false;	800	isCast = false;
889	}	801	}
890	let parameters = parseParameters();	802	let parameters = parseParameters();
891	return new Func(origin, name, returnType, typeParameters, parameters, isCast, shaderType);	803	return new Func(origin, name, returnType, typeParameters, parameters, isCast, shaderType);
892	}	804	}
893
894	function parseProtocolFuncDecl()
895	{
896	let func = parseFuncDecl();
897	return new ProtocolFuncDecl(func.origin, func.name, func.returnType, func.typeParameters, func.parameters, func.isCast, func.shaderType);
898	}
899		805
900	function parseFuncDef()	806	function parseFuncDef()
901	{	807	{
Lines 904-929 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec11
904	return new FuncDef(func.origin, func.name, func.returnType, func.typeParameters, func.parameters, body, func.isCast, func.shaderType);	810	return new FuncDef(func.origin, func.name, func.returnType, func.typeParameters, func.parameters, body, func.isCast, func.shaderType);
905	}	811	}
906		812
907	function parseProtocolDecl()
908	{
909	let origin = consume("protocol");
910	let name = consumeKind("identifier").text;
911	let result = new ProtocolDecl(origin, name);
912	if (tryConsume(":")) {
913	while (!test("{")) {
914	result.addExtends(parseProtocolRef());
915	if (!tryConsume(","))
916	break;
917	}
918	}
919	consume("{");
920	while (!tryConsume("}")) {
921	result.add(parseProtocolFuncDecl());
922	consume(";");
923	}
924	return result;
925	}
926
927	function parseField()	813	function parseField()
928	{	814	{
929	let type = parseType();	815	let type = parseType();
Lines 936-942 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec12
936	{	822	{
937	let origin = consume("struct");	823	let origin = consume("struct");
938	let name = consumeKind("identifier").text;	824	let name = consumeKind("identifier").text;
939	let typeParameters = parseTypeParameters();	825	let typeParameters = [];
940	let result = new StructType(origin, name, typeParameters);	826	let result = new StructType(origin, name, typeParameters);
941	consume("{");	827	consume("{");
942	while (!tryConsume("}"))	828	while (!tryConsume("}"))
Lines 956-962 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec13
956	let origin = consume("native");	842	let origin = consume("native");
957	if (tryConsume("typedef")) {	843	if (tryConsume("typedef")) {
958	let name = consumeKind("identifier");	844	let name = consumeKind("identifier");
959	let parameters = parseTypeParameters();	845	let parameters = [];
960	consume(";");	846	consume(";");
961	return new NativeType(origin, name.text, parameters);	847	return new NativeType(origin, name.text, parameters);
962	}	848	}
Lines 1020-1027 function parse(program, origin, originKind, lineNumberOffset, text) a/Tools/WebGPUShadingLanguageRI/Parse.js_sec14
1020	program.add(parseStructType());	906	program.add(parseStructType());
1021	else if (token.text == "enum")	907	else if (token.text == "enum")
1022	program.add(parseEnumType());	908	program.add(parseEnumType());
1023	else if (token.text == "protocol")
1024	program.add(parseProtocolDecl());
1025	else	909	else
1026	program.add(parseFuncDef());	910	program.add(parseFuncDef());
1027	}	911	}

Lines 18-24 td { a/Tools/WebGPUShadingLanguageRI/SPIRV.html_sec1
- a/Tools/WebGPUShadingLanguageRI/SPIRV.html -7 / +13 lines
18	<script src="CreateLiteralType.js"></script>	18	<script src="CreateLiteralType.js"></script>
19	<script src="PropertyAccessExpression.js"></script>	19	<script src="PropertyAccessExpression.js"></script>
20	<script src="SwizzleOp.js"></script>	20	<script src="SwizzleOp.js"></script>
21		21
22	<script src="AddressSpace.js"></script>	22	<script src="AddressSpace.js"></script>
23	<script src="AnonymousVariable.js"></script>	23	<script src="AnonymousVariable.js"></script>
24	<script src="ArrayRefType.js"></script>	24	<script src="ArrayRefType.js"></script>
Lines 47-54 td { a/Tools/WebGPUShadingLanguageRI/SPIRV.html_sec2
47	<script src="ConvertPtrToArrayRefExpression.js"></script>	47	<script src="ConvertPtrToArrayRefExpression.js"></script>
48	<script src="DoWhileLoop.js"></script>	48	<script src="DoWhileLoop.js"></script>
49	<script src="DotExpression.js"></script>	49	<script src="DotExpression.js"></script>
50	<script src="DoubleLiteral.js"></script>
51	<script src="DoubleLiteralType.js"></script>
52	<script src="DereferenceExpression.js"></script>	50	<script src="DereferenceExpression.js"></script>
53	<script src="EArrayRef.js"></script>	51	<script src="EArrayRef.js"></script>
54	<script src="EBuffer.js"></script>	52	<script src="EBuffer.js"></script>
Lines 104-109 td { a/Tools/WebGPUShadingLanguageRI/SPIRV.html_sec3
104	<script src="NormalUsePropertyResolver.js"></script>	102	<script src="NormalUsePropertyResolver.js"></script>
105	<script src="NullLiteral.js"></script>	103	<script src="NullLiteral.js"></script>
106	<script src="NullType.js"></script>	104	<script src="NullType.js"></script>
		105	<script src="OperatorAnderIndex.js"></script>
		106	<script src="OperatorArrayRefLength.js"></script>
		107	<script src="OperatorBool.js"></script>
		108	<script src="BuiltinVectorCasts.js"></script>
		109	<script src="BuiltinVectorGetter.js"></script>
		110	<script src="BuiltinVectorSetter.js"></script>
		111	<script src="BuiltinVectorIndexGetter.js"></script>
		112	<script src="BuiltinVectorIndexSetter.js"></script>
		113	<script src="BuiltinVectorEqualityOperator.js"></script>
107	<script src="OriginKind.js"></script>	114	<script src="OriginKind.js"></script>
108	<script src="OverloadResolutionFailure.js"></script>	115	<script src="OverloadResolutionFailure.js"></script>
109	<script src="Parse.js"></script>	116	<script src="Parse.js"></script>
Lines 126-135 td { a/Tools/WebGPUShadingLanguageRI/SPIRV.html_sec4
126	<script src="Return.js"></script>	133	<script src="Return.js"></script>
127	<script src="ReturnChecker.js"></script>	134	<script src="ReturnChecker.js"></script>
128	<script src="ReturnException.js"></script>	135	<script src="ReturnException.js"></script>
129	<script src="SPIR-V.js"></script>
130	<script src="SPIRVCodegen.js"></script>
131	<script src="SPIRVTypeAnalyzer.js"></script>
132	<script src="SPIRVVariableAnalyzer.js"></script>
133	<script src="StandardLibrary.js"></script>	136	<script src="StandardLibrary.js"></script>
134	<script src="StatementCloner.js"></script>	137	<script src="StatementCloner.js"></script>
135	<script src="StructLayoutBuilder.js"></script>	138	<script src="StructLayoutBuilder.js"></script>
Lines 137-144 td { a/Tools/WebGPUShadingLanguageRI/SPIRV.html_sec5
137	<script src="Substitution.js"></script>	140	<script src="Substitution.js"></script>
138	<script src="SwitchCase.js"></script>	141	<script src="SwitchCase.js"></script>
139	<script src="SwitchStatement.js"></script>	142	<script src="SwitchStatement.js"></script>
		143	<script src="SynthesizeArrayOperatorLength.js"></script>
140	<script src="SynthesizeEnumFunctions.js"></script>	144	<script src="SynthesizeEnumFunctions.js"></script>
141	<script src="SynthesizeStructAccessors.js"></script>	145	<script src="SynthesizeStructAccessors.js"></script>
		146	<script src="SynthesizeCopyConstructorOperator.js"></script>
		147	<script src="SynthesizeDefaultConstructorOperator.js"></script>
142	<script src="TrapStatement.js"></script>	148	<script src="TrapStatement.js"></script>
143	<script src="TypeDef.js"></script>	149	<script src="TypeDef.js"></script>
144	<script src="TypeDefResolver.js"></script>	150	<script src="TypeDefResolver.js"></script>

Lines 40-75 typedef int = int32; a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js_sec1
- a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js -243 / +23 lines
40	typedef uint = uint32;	40	typedef uint = uint32;
41		41
42	native typedef float32;	42	native typedef float32;
43	native typedef float64;
44	typedef float = float32;	43	typedef float = float32;
45	typedef double = float64;
46		44
47	native operator int32(uint32);	45	native operator int32(uint32);
48	native operator int32(uint8);	46	native operator int32(uint8);
49	native operator int32(float);	47	native operator int32(float);
50	native operator int32(double);
51	native operator uint32(int32);	48	native operator uint32(int32);
52	native operator uint32(uint8);	49	native operator uint32(uint8);
53	native operator uint32(float);	50	native operator uint32(float);
54	native operator uint32(double);
55	native operator uint8(int32);	51	native operator uint8(int32);
56	native operator uint8(uint32);	52	native operator uint8(uint32);
57	native operator uint8(float);	53	native operator uint8(float);
58	native operator uint8(double);
59	native operator float(int32);	54	native operator float(int32);
60	native operator float(uint32);	55	native operator float(uint32);
61	native operator float(uint8);	56	native operator float(uint8);
62	native operator float(double);
63	native operator double(float);
64	native operator double(int32);
65	native operator double(uint32);
66	native operator double(uint8);
67		57
68	native int operator+(int, int);	58	native int operator+(int, int);
69	native uint operator+(uint, uint);	59	native uint operator+(uint, uint);
70	uint8 operator+(uint8 a, uint8 b) { return uint8(uint(a) + uint(b)); }	60	uint8 operator+(uint8 a, uint8 b) { return uint8(uint(a) + uint(b)); }
71	native float operator+(float, float);	61	native float operator+(float, float);
72	native double operator+(double, double);
73	int operator++(int value) { return value + 1; }	62	int operator++(int value) { return value + 1; }
74	uint operator++(uint value) { return value + 1; }	63	uint operator++(uint value) { return value + 1; }
75	uint8 operator++(uint8 value) { return value + 1; }	64	uint8 operator++(uint8 value) { return value + 1; }
Lines 77-83 native int operator-(int, int); a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js_sec2
77	native uint operator-(uint, uint);	66	native uint operator-(uint, uint);
78	uint8 operator-(uint8 a, uint8 b) { return uint8(uint(a) - uint(b)); }	67	uint8 operator-(uint8 a, uint8 b) { return uint8(uint(a) - uint(b)); }
79	native float operator-(float, float);	68	native float operator-(float, float);
80	native double operator-(double, double);
81	int operator--(int value) { return value - 1; }	69	int operator--(int value) { return value - 1; }
82	uint operator--(uint value) { return value - 1; }	70	uint operator--(uint value) { return value - 1; }
83	uint8 operator--(uint8 value) { return value - 1; }	71	uint8 operator--(uint8 value) { return value - 1; }
Lines 85-91 native int operator*(int, int); a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js_sec3
85	native uint operator*(uint, uint);	73	native uint operator*(uint, uint);
86	uint8 operator(uint8 a, uint8 b) { return uint8(uint(a) uint(b)); }	74	uint8 operator(uint8 a, uint8 b) { return uint8(uint(a) uint(b)); }
87	native float operator*(float, float);	75	native float operator*(float, float);
88	native double operator*(double, double);
89	native int operator/(int, int);	76	native int operator/(int, int);
90	native uint operator/(uint, uint);	77	native uint operator/(uint, uint);
91	uint8 operator/(uint8 a, uint8 b) { return uint8(uint(a) / uint(b)); }	78	uint8 operator/(uint8 a, uint8 b) { return uint8(uint(a) / uint(b)); }
Lines 108-140 uint8 operator~(uint8 value) { return uint8(~uint(value)); } a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js_sec4
108	uint8 operator<<(uint8 a, uint b) { return uint8(uint(a) << (b & 7)); }	95	uint8 operator<<(uint8 a, uint b) { return uint8(uint(a) << (b & 7)); }
109	uint8 operator>>(uint8 a, uint b) { return uint8(uint(a) >> (b & 7)); }	96	uint8 operator>>(uint8 a, uint b) { return uint8(uint(a) >> (b & 7)); }
110	native float operator/(float, float);	97	native float operator/(float, float);
111	native double operator/(double, double);
112	native bool operator==(int, int);	98	native bool operator==(int, int);
113	native bool operator==(uint, uint);	99	native bool operator==(uint, uint);
114	bool operator==(uint8 a, uint8 b) { return uint(a) == uint(b); }	100	bool operator==(uint8 a, uint8 b) { return uint(a) == uint(b); }
115	native bool operator==(bool, bool);	101	native bool operator==(bool, bool);
116	native bool operator==(float, float);	102	native bool operator==(float, float);
117	native bool operator==(double, double);
118	native bool operator<(int, int);	103	native bool operator<(int, int);
119	native bool operator<(uint, uint);	104	native bool operator<(uint, uint);
120	bool operator<(uint8 a, uint8 b) { return uint(a) < uint(b); }	105	bool operator<(uint8 a, uint8 b) { return uint(a) < uint(b); }
121	native bool operator<(float, float);	106	native bool operator<(float, float);
122	native bool operator<(double, double);
123	native bool operator<=(int, int);	107	native bool operator<=(int, int);
124	native bool operator<=(uint, uint);	108	native bool operator<=(uint, uint);
125	bool operator<=(uint8 a, uint8 b) { return uint(a) <= uint(b); }	109	bool operator<=(uint8 a, uint8 b) { return uint(a) <= uint(b); }
126	native bool operator<=(float, float);	110	native bool operator<=(float, float);
127	native bool operator<=(double, double);
128	native bool operator>(int, int);	111	native bool operator>(int, int);
129	native bool operator>(uint, uint);	112	native bool operator>(uint, uint);
130	bool operator>(uint8 a, uint8 b) { return uint(a) > uint(b); }	113	bool operator>(uint8 a, uint8 b) { return uint(a) > uint(b); }
131	native bool operator>(float, float);	114	native bool operator>(float, float);
132	native bool operator>(double, double);
133	native bool operator>=(int, int);	115	native bool operator>=(int, int);
134	native bool operator>=(uint, uint);	116	native bool operator>=(uint, uint);
135	bool operator>=(uint8 a, uint8 b) { return uint(a) >= uint(b); }	117	bool operator>=(uint8 a, uint8 b) { return uint(a) >= uint(b); }
136	native bool operator>=(float, float);	118	native bool operator>=(float, float);
137	native bool operator>=(double, double);
138		119
139	bool operator&(bool a, bool b)	120	bool operator&(bool a, bool b)
140	{	121	{
Lines 164-393 bool operator~(bool value) a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js_sec5
164	return !value;	145	return !value;
165	}	146	}
166		147
167	protocol Addable {	148	native typedef int2;
168	Addable operator+(Addable, Addable);	149	native typedef uint2;
169	}	150	native typedef float2;
170
171	protocol Equatable {
172	bool operator==(Equatable, Equatable);
173	}
174
175	restricted operator<T> T()
176	{
177	T defaultValue;
178	return defaultValue;
179	}
180
181	restricted operator<T> T(T x)
182	{
183	return x;
184	}
185
186	operator<T:Equatable> bool(T x)
187	{
188	return x != T();
189	}
190
191	struct vec2<T> {
192	T x;
193	T y;
194	}
195
196	typedef int2 = vec2<int>;
197	typedef uint2 = vec2<uint>;
198	typedef float2 = vec2<float>;
199	typedef double2 = vec2<double>;
200
201	operator<T> vec2<T>(T x, T y)
202	{
203	vec2<T> result;
204	result.x = x;
205	result.y = y;
206	return result;
207	}
208
209	bool operator==<T:Equatable>(vec2<T> a, vec2<T> b)
210	{
211	return a.x == b.x && a.y == b.y;
212	}
213
214	thread T* operator&[]<T>(thread vec2<T>* foo, uint index)
215	{
216	if (index == 0)
217	return &foo->x;
218	if (index == 1)
219	return &foo->y;
220	trap;
221	}
222
223	struct vec3<T> {
224	T x;
225	T y;
226	T z;
227	}
228
229	typedef int3 = vec3<int>;
230	typedef uint3 = vec3<uint>;
231	typedef float3 = vec3<float>;
232	typedef double3 = vec3<double>;
233
234	operator<T> vec3<T>(T x, T y, T z)
235	{
236	vec3<T> result;
237	result.x = x;
238	result.y = y;
239	result.z = z;
240	return result;
241	}
242
243	operator<T> vec3<T>(vec2<T> v2, T z)
244	{
245	vec3<T> result;
246	result.x = v2.x;
247	result.y = v2.y;
248	result.z = z;
249	return result;
250	}
251
252	operator<T> vec3<T>(T x, vec2<T> v2)
253	{
254	vec3<T> result;
255	result.x = x;
256	result.y = v2.x;
257	result.z = v2.y;
258	return result;
259	}
260
261	bool operator==<T:Equatable>(vec3<T> a, vec3<T> b)
262	{
263	return a.x == b.x && a.y == b.y && a.z == b.z;
264	}
265		151
266	thread T* operator&[]<T>(thread vec3<T>* foo, uint index)	152	native typedef int3;
267	{	153	native typedef uint3;
268	if (index == 0)	154	native typedef float3;
269	return &foo->x;
270	if (index == 1)
271	return &foo->y;
272	if (index == 2)
273	return &foo->z;
274	trap;
275	}
276
277	struct vec4<T> {
278	T x;
279	T y;
280	T z;
281	T w;
282	}
283
284	typedef int4 = vec4<int>;
285	typedef uint4 = vec4<uint>;
286	typedef float4 = vec4<float>;
287	typedef double4 = vec4<double>;
288
289	operator<T> vec4<T>(T x, T y, T z, T w)
290	{
291	vec4<T> result;
292	result.x = x;
293	result.y = y;
294	result.z = z;
295	result.w = w;
296	return result;
297	}
298
299	operator<T> vec4<T>(vec2<T> v2, T z, T w)
300	{
301	vec4<T> result;
302	result.x = v2.x;
303	result.y = v2.y;
304	result.z = z;
305	result.w = w;
306	return result;
307	}
308
309	operator<T> vec4<T>(T x, vec2<T> v2, T w)
310	{
311	vec4<T> result;
312	result.x = x;
313	result.y = v2.x;
314	result.z = v2.y;
315	result.w = w;
316	return result;
317	}
318
319	operator<T> vec4<T>(T x, T y, vec2<T> v2)
320	{
321	vec4<T> result;
322	result.x = x;
323	result.y = y;
324	result.z = v2.x;
325	result.w = v2.y;
326	return result;
327	}
328
329	operator<T> vec4<T>(vec2<T> v2a, vec2<T> v2b)
330	{
331	vec4<T> result;
332	result.x = v2a.x;
333	result.y = v2a.y;
334	result.z = v2b.x;
335	result.w = v2b.y;
336	return result;
337	}
338		155
339	operator<T> vec4<T>(vec3<T> v3, T w)	156	native typedef int4;
340	{	157	native typedef uint4;
341	vec4<T> result;	158	native typedef float4;
342	result.x = v3.x;
343	result.y = v3.y;
344	result.z = v3.z;
345	result.w = w;
346	return result;
347	}
348
349	operator<T> vec4<T>(T x, vec3<T> v3)
350	{
351	vec4<T> result;
352	result.x = x;
353	result.y = v3.x;
354	result.z = v3.y;
355	result.w = v3.z;
356	return result;
357	}
358
359	bool operator==<T:Equatable>(vec4<T> a, vec4<T> b)
360	{
361	return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
362	}
363
364	thread T* operator&[]<T>(thread vec4<T>* foo, uint index)
365	{
366	if (index == 0)
367	return &foo->x;
368	if (index == 1)
369	return &foo->y;
370	if (index == 2)
371	return &foo->z;
372	if (index == 3)
373	return &foo->w;
374	trap;
375	}
376
377	native thread T* operator&[]<T>(thread T[], uint);
378	native threadgroup T* operator&[]<T>(threadgroup T[], uint);
379	native device T* operator&[]<T>(device T[], uint);
380	native constant T* operator&[]<T>(constant T[], uint);
381
382	native uint operator.length<T>(thread T[]);
383	native uint operator.length<T>(threadgroup T[]);
384	native uint operator.length<T>(device T[]);
385	native uint operator.length<T>(constant T[]);
386
387	uint operator.length<T, uint length>(T[length])
388	{
389	return length;
390	}
391	`;	159	`;
392		160
393	function intToString(x)	161	function intToString(x)
Lines 406-411 function intToString(x) a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js_sec6
406	}	174	}
407	}	175	}
408		176
		177	function addFunctionsFromClass(clss)
		178	{
		179	standardLibrary += clss.functions().join(";\n") + "\n";
		180	}
		181
409	// There are 481 swizzle operators, so we compile them as native functions	182	// There are 481 swizzle operators, so we compile them as native functions
410	standardLibrary += SwizzleOp.allSwizzleOperators().join(";\n") + ";";	183	standardLibrary += SwizzleOp.functions().join(";\n") + ";\n";
411	console.log(standardLibrary);	184	standardLibrary += OperatorBool.functions().join(";\n") + ";\n";
		185	standardLibrary += OperatorAnderIndexer.functions().join(";\n") + ";\n";
		186	standardLibrary += BuiltinVectorCasts.functions().join(";\n") + ";\n";
		187	standardLibrary += BuiltinVectorGetter.functions().join(";\n") + ";\n";
		188	standardLibrary += BuiltinVectorSetter.functions().join(";\n") + ";\n";
		189	standardLibrary += BuiltinVectorIndexGetter.functions().join(";\n") + ";\n";
		190	standardLibrary += BuiltinVectorIndexSetter.functions().join(";\n") + ";\n";
		191	standardLibrary += BuiltinVectorEqualityOperator.functions().join(";\n") + ";\n";

Lines 45-50 class StructType extends Type { a/Tools/WebGPUShadingLanguageRI/StructType.js_sec1
- a/Tools/WebGPUShadingLanguageRI/StructType.js -1 / +2 lines
45	get name() { return this._name; }	45	get name() { return this._name; }
46	get origin() { return this._origin; }	46	get origin() { return this._origin; }
47	get typeParameters() { return this._typeParameters; }	47	get typeParameters() { return this._typeParameters; }
		48	get isStruct() { return true; }
48		49
49	get fieldNames() { return this._fields.keys(); }	50	get fieldNames() { return this._fields.keys(); }
50	fieldByName(name) { return this._fields.get(name); }	51	fieldByName(name) { return this._fields.get(name); }
Lines 94-99 class StructType extends Type { a/Tools/WebGPUShadingLanguageRI/StructType.js_sec2
94		95
95	toString()	96	toString()
96	{	97	{
97	return "struct " + this.name + "<" + this.typeParameters + "> { " + Array.from(this.fields).join("; ") + "; }";	98	return `struct ${this.name} { ${Array.from(this.fields).join("; ")}; }`;
98	}	99	}
99	}	100	}

Lines 25-73 a/Tools/WebGPUShadingLanguageRI/SwizzleOp.js_sec1
- a/Tools/WebGPUShadingLanguageRI/SwizzleOp.js -15 / +35 lines
25	"use strict";	25	"use strict";
26		26
27	class SwizzleOp {	27	class SwizzleOp {
28	constructor(outSize, components, inSize)	28	constructor(baseTypeName, outSize, components, inSize)
29	{	29	{
		30	this._baseTypeName = baseTypeName;
30	this._outSize = outSize;	31	this._outSize = outSize;
31	this._components = components.slice(); // Shallow clone	32	this._components = components.slice(); // Shallow clone
32	this._inSize = inSize;	33	this._inSize = inSize;
33	}	34	}
34		35
		36	get baseTypeName() { return this._baseTypeName; }
35	get outSize() { return this._outSize; }	37	get outSize() { return this._outSize; }
36	get components() { return this._components; }	38	get components() { return this._components; }
37	get inSize() { return this._inSize; }	39	get inSize() { return this._inSize; }
38		40
39	toString()	41	toString()
40	{	42	{
41	return `native vec${this.outSize}<T> operator.${this.components.join("")}<T>(vec${this.inSize}<T> v)`;	43	return `native ${this.baseTypeName}${this.outSize} operator.${this.components.join("")}(${this.baseTypeName}${this.inSize} v)`;
42	}	44	}
43		45
44	static allSwizzleOperators()	46	static functions()
45	{	47	{
46	if (!SwizzleOp._allSwizzleOperators) {	48	if (!this._functions) {
47	SwizzleOp._allSwizzleOperators = [];	49	// We can't directly use this._functions in _generateSwizzles
		50	const functions = [];
48		51
49	function _generateSwizzle(maxDepth, maxItems, array) {	52	function _generateSwizzle(baseTypeName, maxDepth, maxItems, array) {
50	if (!array)	53	if (!array)
51	array = [];	54	array = [];
52	if (array.length == maxDepth) {	55	if (array.length == maxDepth) {
53	SwizzleOp._allSwizzleOperators.push(new SwizzleOp(array.length, array, maxItems));	56	functions.push(new SwizzleOp(baseTypeName, array.length, array, maxItems));
54	return;	57	return;
55	}	58	}
56	for (let i = 0; i < maxItems; ++i) {	59	for (let i = 0; i < maxItems; ++i) {
57	array.push(intToString(i));	60	array.push(intToString(i));
58	_generateSwizzle(maxDepth, maxItems, array);	61	_generateSwizzle(baseTypeName, maxDepth, maxItems, array);
59	array.pop();	62	array.pop();
60	}	63	}
61	};	64	};
62		65
63	for (let maxDepth = 2; maxDepth <= 4; maxDepth++) {	66	const typeNames = [ "uint", "int", "float" ];
64	for (let maxItems = 2; maxItems <= 4; maxItems++)	67
65	_generateSwizzle(maxDepth, maxItems);	68	for (let typeName of typeNames) {
		69	for (let maxDepth = 2; maxDepth <= 4; maxDepth++) {
		70	for (let maxItems = 2; maxItems <= 4; maxItems++)
		71	_generateSwizzle(typeName, maxDepth, maxItems);
		72	}
66	}	73	}
		74
		75	this._functions = functions;
67	}	76	}
68	return SwizzleOp._allSwizzleOperators;	77	return this._functions;
69	}	78	}
70	}
71		79
72	// Initialise the static member (JS doesn't allow static fields declared in the class)	80	instantiateImplementation(func)
73	SwizzleOp._allSwizzleOperators = null;	81	{
		82	func.implementation = ([vec], node) => {
		83	const outputBuffer = new EBuffer(this.outSize);
		84	const readIndices = { 'x': 0, 'y': 1, 'z': 2, 'w': 3 };
		85	for (let i = 0; i < this.outSize; i++)
		86	outputBuffer.set(i, vec.get(readIndices[this.components[i]]));
		87
		88
		89	return new EPtr(outputBuffer, 0);
		90	};
		91	func.implementationData = this;
		92	}
		93	}

Line 0 a/Tools/WebGPUShadingLanguageRI/SynthesizeArrayOperatorLength.js_sec1
- a/Tools/WebGPUShadingLanguageRI/SynthesizeArrayOperatorLength.js +50 lines
	1	/*
	2	* Copyright (C) 2017 Apple Inc. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25	"use strict";
	26
	27	function synthesizeArrayOperatorLength(program)
	28	{
	29	const arrayTypes = new Set();
	30
	31	class FindArrayTypes extends Visitor {
	32	visitArrayType(node)
	33	{
	34	arrayTypes.add(node);
	35	}
	36	}
	37
	38	program.visit(new FindArrayTypes());
	39
	40	for (let arrayType of arrayTypes) {
	41	let nativeFunc = new NativeFunc(
	42	arrayType.origin, "operator.length", new TypeRef(arrayType.origin, "uint32", []), [],
	43	[
	44	new FuncParameter(arrayType.origin, null, TypeRef.wrap(arrayType))
	45	],
	46	false, null);
	47	nativeFunc.implementation = ([array]) => EPtr.box(arrayType.size);
	48	program.add(nativeFunc);
	49	}
	50	}

Lines 41-48 a/Tools/WebGPUShadingLanguageRI/Test.html_sec1
- a/Tools/WebGPUShadingLanguageRI/Test.html -2 / +12 lines
41	<script src="ConvertPtrToArrayRefExpression.js"></script>	41	<script src="ConvertPtrToArrayRefExpression.js"></script>
42	<script src="DoWhileLoop.js"></script>	42	<script src="DoWhileLoop.js"></script>
43	<script src="DotExpression.js"></script>	43	<script src="DotExpression.js"></script>
44	<script src="DoubleLiteral.js"></script>
45	<script src="DoubleLiteralType.js"></script>
46	<script src="DereferenceExpression.js"></script>	44	<script src="DereferenceExpression.js"></script>
47	<script src="EArrayRef.js"></script>	45	<script src="EArrayRef.js"></script>
48	<script src="EBuffer.js"></script>	46	<script src="EBuffer.js"></script>
Lines 98-103 a/Tools/WebGPUShadingLanguageRI/Test.html_sec2
98	<script src="NormalUsePropertyResolver.js"></script>	96	<script src="NormalUsePropertyResolver.js"></script>
99	<script src="NullLiteral.js"></script>	97	<script src="NullLiteral.js"></script>
100	<script src="NullType.js"></script>	98	<script src="NullType.js"></script>
		99	<script src="OperatorAnderIndex.js"></script>
		100	<script src="OperatorArrayRefLength.js"></script>
		101	<script src="OperatorBool.js"></script>
		102	<script src="BuiltinVectorCasts.js"></script>
		103	<script src="BuiltinVectorGetter.js"></script>
		104	<script src="BuiltinVectorSetter.js"></script>
		105	<script src="BuiltinVectorIndexGetter.js"></script>
		106	<script src="BuiltinVectorIndexSetter.js"></script>
		107	<script src="BuiltinVectorEqualityOperator.js"></script>
101	<script src="OriginKind.js"></script>	108	<script src="OriginKind.js"></script>
102	<script src="OverloadResolutionFailure.js"></script>	109	<script src="OverloadResolutionFailure.js"></script>
103	<script src="Parse.js"></script>	110	<script src="Parse.js"></script>
Lines 127-134 a/Tools/WebGPUShadingLanguageRI/Test.html_sec3
127	<script src="Substitution.js"></script>	134	<script src="Substitution.js"></script>
128	<script src="SwitchCase.js"></script>	135	<script src="SwitchCase.js"></script>
129	<script src="SwitchStatement.js"></script>	136	<script src="SwitchStatement.js"></script>
		137	<script src="SynthesizeArrayOperatorLength.js"></script>
130	<script src="SynthesizeEnumFunctions.js"></script>	138	<script src="SynthesizeEnumFunctions.js"></script>
131	<script src="SynthesizeStructAccessors.js"></script>	139	<script src="SynthesizeStructAccessors.js"></script>
		140	<script src="SynthesizeCopyConstructorOperator.js"></script>
		141	<script src="SynthesizeDefaultConstructorOperator.js"></script>
132	<script src="TrapStatement.js"></script>	142	<script src="TrapStatement.js"></script>
133	<script src="TypeDef.js"></script>	143	<script src="TypeDef.js"></script>
134	<script src="TypeDefResolver.js"></script>	144	<script src="TypeDefResolver.js"></script>

Lines 1-155 a/Tools/WebGPUShadingLanguageRI/index.html_sec1
- a/Tools/WebGPUShadingLanguageRI/index.html -149 / +160 lines
1	<!DOCTYPE html>	1	<!DOCTYPE html>
2	<html>	2	<html>
3	<head>	3	<head>
4	<script src="Node.js"></script>	4	<script src="Node.js"></script>
5	<script src="Type.js"></script>	5	<script src="Type.js"></script>
6	<script src="ReferenceType.js"></script>	6	<script src="ReferenceType.js"></script>
7	<script src="Value.js"></script>	7	<script src="Value.js"></script>
8	<script src="Expression.js"></script>	8	<script src="Expression.js"></script>
9	<script src="Rewriter.js"></script>	9	<script src="Rewriter.js"></script>
10	<script src="Visitor.js"></script>	10	<script src="Visitor.js"></script>
11	<script src="CreateLiteral.js"></script>	11	<script src="CreateLiteral.js"></script>
12	<script src="CreateLiteralType.js"></script>	12	<script src="CreateLiteralType.js"></script>
13	<script src="PropertyAccessExpression.js"></script>	13	<script src="PropertyAccessExpression.js"></script>
14	<script src="SwizzleOp.js"></script>	14	<script src="SwizzleOp.js"></script>
15		15
16	<script src="AddressSpace.js"></script>	16	<script src="AddressSpace.js"></script>
17	<script src="AnonymousVariable.js"></script>	17	<script src="AnonymousVariable.js"></script>
18	<script src="ArrayRefType.js"></script>	18	<script src="ArrayRefType.js"></script>
19	<script src="ArrayType.js"></script>	19	<script src="ArrayType.js"></script>
20	<script src="Assignment.js"></script>	20	<script src="Assignment.js"></script>
21	<script src="AutoWrapper.js"></script>	21	<script src="AutoWrapper.js"></script>
22	<script src="Block.js"></script>	22	<script src="Block.js"></script>
23	<script src="BoolLiteral.js"></script>	23	<script src="BoolLiteral.js"></script>
24	<script src="Break.js"></script>	24	<script src="Break.js"></script>
25	<script src="CallExpression.js"></script>	25	<script src="CallExpression.js"></script>
26	<script src="CallFunction.js"></script>	26	<script src="CallFunction.js"></script>
27	<script src="Check.js"></script>	27	<script src="Check.js"></script>
28	<script src="CheckLiteralTypes.js"></script>	28	<script src="CheckLiteralTypes.js"></script>
29	<script src="CheckLoops.js"></script>	29	<script src="CheckLoops.js"></script>
30	<script src="CheckRecursion.js"></script>	30	<script src="CheckRecursion.js"></script>
31	<script src="CheckRecursiveTypes.js"></script>	31	<script src="CheckRecursiveTypes.js"></script>
32	<script src="CheckReturns.js"></script>	32	<script src="CheckReturns.js"></script>
33	<script src="CheckUnreachableCode.js"></script>	33	<script src="CheckUnreachableCode.js"></script>
34	<script src="CheckWrapped.js"></script>	34	<script src="CheckWrapped.js"></script>
35	<script src="Checker.js"></script>	35	<script src="Checker.js"></script>
36	<script src="CloneProgram.js"></script>	36	<script src="CloneProgram.js"></script>
37	<script src="CommaExpression.js"></script>	37	<script src="CommaExpression.js"></script>
38	<script src="ConstexprFolder.js"></script>	38	<script src="ConstexprFolder.js"></script>
39	<script src="ConstexprTypeParameter.js"></script>	39	<script src="ConstexprTypeParameter.js"></script>
40	<script src="Continue.js"></script>	40	<script src="Continue.js"></script>
41	<script src="ConvertPtrToArrayRefExpression.js"></script>	41	<script src="ConvertPtrToArrayRefExpression.js"></script>
42	<script src="DoWhileLoop.js"></script>	42	<script src="DoWhileLoop.js"></script>
43	<script src="DotExpression.js"></script>	43	<script src="DotExpression.js"></script>
44	<script src="DoubleLiteral.js"></script>	44	<script src="DereferenceExpression.js"></script>
45	<script src="DoubleLiteralType.js"></script>	45	<script src="EArrayRef.js"></script>
46	<script src="DereferenceExpression.js"></script>	46	<script src="EBuffer.js"></script>
47	<script src="EArrayRef.js"></script>	47	<script src="EBufferBuilder.js"></script>
48	<script src="EBuffer.js"></script>	48	<script src="EPtr.js"></script>
49	<script src="EBufferBuilder.js"></script>	49	<script src="EnumLiteral.js"></script>
50	<script src="EPtr.js"></script>	50	<script src="EnumMember.js"></script>
51	<script src="EnumLiteral.js"></script>	51	<script src="EnumType.js"></script>
52	<script src="EnumMember.js"></script>	52	<script src="EvaluationCommon.js"></script>
53	<script src="EnumType.js"></script>	53	<script src="Evaluator.js"></script>
54	<script src="EvaluationCommon.js"></script>	54	<script src="ExpressionFinder.js"></script>
55	<script src="Evaluator.js"></script>	55	<script src="ExternalOrigin.js"></script>
56	<script src="ExpressionFinder.js"></script>	56	<script src="Field.js"></script>
57	<script src="ExternalOrigin.js"></script>	57	<script src="FindHighZombies.js"></script>
58	<script src="Field.js"></script>	58	<script src="FlattenProtocolExtends.js"></script>
59	<script src="FindHighZombies.js"></script>	59	<script src="FlattenedStructOffsetGatherer.js"></script>
60	<script src="FlattenProtocolExtends.js"></script>	60	<script src="FloatLiteral.js"></script>
61	<script src="FlattenedStructOffsetGatherer.js"></script>	61	<script src="FloatLiteralType.js"></script>
62	<script src="FloatLiteral.js"></script>	62	<script src="FoldConstexprs.js"></script>
63	<script src="FloatLiteralType.js"></script>	63	<script src="ForLoop.js"></script>
64	<script src="FoldConstexprs.js"></script>	64	<script src="Func.js"></script>
65	<script src="ForLoop.js"></script>	65	<script src="FuncDef.js"></script>
66	<script src="Func.js"></script>	66	<script src="FuncInstantiator.js"></script>
67	<script src="FuncDef.js"></script>	67	<script src="FuncParameter.js"></script>
68	<script src="FuncInstantiator.js"></script>	68	<script src="FunctionLikeBlock.js"></script>
69	<script src="FuncParameter.js"></script>	69	<script src="HighZombieFinder.js"></script>
70	<script src="FunctionLikeBlock.js"></script>	70	<script src="IdentityExpression.js"></script>
71	<script src="HighZombieFinder.js"></script>	71	<script src="IfStatement.js"></script>
72	<script src="IdentityExpression.js"></script>	72	<script src="IndexExpression.js"></script>
73	<script src="IfStatement.js"></script>	73	<script src="InferTypesForCall.js"></script>
74	<script src="IndexExpression.js"></script>	74	<script src="Inline.js"></script>
75	<script src="InferTypesForCall.js"></script>	75	<script src="Inliner.js"></script>
76	<script src="Inline.js"></script>	76	<script src="InstantiateImmediates.js"></script>
77	<script src="Inliner.js"></script>	77	<script src="IntLiteral.js"></script>
78	<script src="InstantiateImmediates.js"></script>	78	<script src="IntLiteralType.js"></script>
79	<script src="IntLiteral.js"></script>	79	<script src="Intrinsics.js"></script>
80	<script src="IntLiteralType.js"></script>	80	<script src="LateChecker.js"></script>
81	<script src="Intrinsics.js"></script>	81	<script src="Lexer.js"></script>
82	<script src="LateChecker.js"></script>	82	<script src="LexerToken.js"></script>
83	<script src="Lexer.js"></script>	83	<script src="LiteralTypeChecker.js"></script>
84	<script src="LexerToken.js"></script>	84	<script src="LogicalExpression.js"></script>
85	<script src="LiteralTypeChecker.js"></script>	85	<script src="LogicalNot.js"></script>
86	<script src="LogicalExpression.js"></script>	86	<script src="LoopChecker.js"></script>
87	<script src="LogicalNot.js"></script>	87	<script src="MakeArrayRefExpression.js"></script>
88	<script src="LoopChecker.js"></script>	88	<script src="MakePtrExpression.js"></script>
89	<script src="MakeArrayRefExpression.js"></script>	89	<script src="NameContext.js"></script>
90	<script src="MakePtrExpression.js"></script>	90	<script src="NameFinder.js"></script>
91	<script src="NameContext.js"></script>	91	<script src="NameResolver.js"></script>
92	<script src="NameFinder.js"></script>	92	<script src="NativeFunc.js"></script>
93	<script src="NameResolver.js"></script>	93	<script src="NativeFuncInstance.js"></script>
94	<script src="NativeFunc.js"></script>	94	<script src="NativeType.js"></script>
95	<script src="NativeFuncInstance.js"></script>	95	<script src="NativeTypeInstance.js"></script>
96	<script src="NativeType.js"></script>	96	<script src="NormalUsePropertyResolver.js"></script>
97	<script src="NativeTypeInstance.js"></script>	97	<script src="NullLiteral.js"></script>
98	<script src="NormalUsePropertyResolver.js"></script>	98	<script src="NullType.js"></script>
99	<script src="NullLiteral.js"></script>	99	<script src="OperatorAnderIndex.js"></script>
100	<script src="NullType.js"></script>	100	<script src="OperatorArrayRefLength.js"></script>
101	<script src="OriginKind.js"></script>	101	<script src="OperatorBool.js"></script>
102	<script src="OverloadResolutionFailure.js"></script>	102	<script src="BuiltinVectorCasts.js"></script>
103	<script src="Parse.js"></script>	103	<script src="BuiltinVectorGetter.js"></script>
104	<script src="Prepare.js"></script>	104	<script src="BuiltinVectorSetter.js"></script>
105	<script src="PropertyResolver.js"></script>	105	<script src="BuiltinVectorIndexGetter.js"></script>
106	<script src="Program.js"></script>	106	<script src="BuiltinVectorIndexSetter.js"></script>
107	<script src="ProgramWithUnnecessaryThingsRemoved.js"></script>	107	<script src="BuiltinVectorEqualityOperator.js"></script>
108	<script src="Protocol.js"></script>	108	<script src="OriginKind.js"></script>
109	<script src="ProtocolDecl.js"></script>	109	<script src="OverloadResolutionFailure.js"></script>
110	<script src="ProtocolFuncDecl.js"></script>	110	<script src="Parse.js"></script>
111	<script src="ProtocolRef.js"></script>	111	<script src="Prepare.js"></script>
112	<script src="PtrType.js"></script>	112	<script src="PropertyResolver.js"></script>
113	<script src="ReadModifyWriteExpression.js"></script>	113	<script src="Program.js"></script>
114	<script src="RecursionChecker.js"></script>	114	<script src="ProgramWithUnnecessaryThingsRemoved.js"></script>
115	<script src="RecursiveTypeChecker.js"></script>	115	<script src="Protocol.js"></script>
116	<script src="ResolveNames.js"></script>	116	<script src="ProtocolDecl.js"></script>
117	<script src="ResolveOverloadImpl.js"></script>	117	<script src="ProtocolFuncDecl.js"></script>
118	<script src="ResolveProperties.js"></script>	118	<script src="ProtocolRef.js"></script>
119	<script src="ResolveTypeDefs.js"></script>	119	<script src="PtrType.js"></script>
120	<script src="Return.js"></script>	120	<script src="ReadModifyWriteExpression.js"></script>
121	<script src="ReturnChecker.js"></script>	121	<script src="RecursionChecker.js"></script>
122	<script src="ReturnException.js"></script>	122	<script src="RecursiveTypeChecker.js"></script>
123	<script src="StandardLibrary.js"></script>	123	<script src="ResolveNames.js"></script>
124	<script src="StatementCloner.js"></script>	124	<script src="ResolveOverloadImpl.js"></script>
125	<script src="StructLayoutBuilder.js"></script>	125	<script src="ResolveProperties.js"></script>
126	<script src="StructType.js"></script>	126	<script src="ResolveTypeDefs.js"></script>
127	<script src="Substitution.js"></script>	127	<script src="Return.js"></script>
128	<script src="SwitchCase.js"></script>	128	<script src="ReturnChecker.js"></script>
129	<script src="SwitchStatement.js"></script>	129	<script src="ReturnException.js"></script>
130	<script src="SynthesizeEnumFunctions.js"></script>	130	<script src="StandardLibrary.js"></script>
131	<script src="SynthesizeStructAccessors.js"></script>	131	<script src="StatementCloner.js"></script>
132	<script src="TrapStatement.js"></script>	132	<script src="StructLayoutBuilder.js"></script>
133	<script src="TypeDef.js"></script>	133	<script src="StructType.js"></script>
134	<script src="TypeDefResolver.js"></script>	134	<script src="Substitution.js"></script>
135	<script src="TypeOrVariableRef.js"></script>	135	<script src="SwitchCase.js"></script>
136	<script src="TypeParameterRewriter.js"></script>	136	<script src="SwitchStatement.js"></script>
137	<script src="TypeRef.js"></script>	137	<script src="SynthesizeArrayOperatorLength.js"></script>
138	<script src="TypeVariable.js"></script>	138	<script src="SynthesizeEnumFunctions.js"></script>
139	<script src="TypeVariableTracker.js"></script>	139	<script src="SynthesizeStructAccessors.js"></script>
140	<script src="TypedValue.js"></script>	140	<script src="SynthesizeCopyConstructorOperator.js"></script>
141	<script src="UintLiteral.js"></script>	141	<script src="SynthesizeDefaultConstructorOperator.js"></script>
142	<script src="UintLiteralType.js"></script>	142	<script src="TrapStatement.js"></script>
143	<script src="UnificationContext.js"></script>	143	<script src="TypeDef.js"></script>
144	<script src="UnreachableCodeChecker.js"></script>	144	<script src="TypeDefResolver.js"></script>
145	<script src="VariableDecl.js"></script>	145	<script src="TypeOrVariableRef.js"></script>
146	<script src="VariableRef.js"></script>	146	<script src="TypeParameterRewriter.js"></script>
147	<script src="VisitingSet.js"></script>	147	<script src="TypeRef.js"></script>
148	<script src="WSyntaxError.js"></script>	148	<script src="TypeVariable.js"></script>
149	<script src="WTrapError.js"></script>	149	<script src="TypeVariableTracker.js"></script>
150	<script src="WTypeError.js"></script>	150	<script src="TypedValue.js"></script>
151	<script src="WhileLoop.js"></script>	151	<script src="UintLiteral.js"></script>
152	<script src="WrapChecker.js"></script>	152	<script src="UintLiteralType.js"></script>
		153	<script src="UnificationContext.js"></script>
		154	<script src="UnreachableCodeChecker.js"></script>
		155	<script src="VariableDecl.js"></script>
		156	<script src="VariableRef.js"></script>
		157	<script src="VisitingSet.js"></script>
		158	<script src="WSyntaxError.js"></script>
		159	<script src="WTrapError.js"></script>
		160	<script src="WTypeError.js"></script>
		161	<script src="WhileLoop.js"></script>
		162	<script src="WrapChecker.js"></script>
153	<style>	163	<style>
154	#ShaderSource {	164	#ShaderSource {
155	font-family: monospace;	165	font-family: monospace;
Lines 415-420 function runShaders() { a/Tools/WebGPUShadingLanguageRI/index.html_sec2
415	case "uint32":	425	case "uint32":
416	value = parseInt(value) >>> 0;	426	value = parseInt(value) >>> 0;
417	break;	427	break;
		428	// FIXME: Parse other types
418	default:	429	default:
419	presentError("I don't know how to parse values of type " + type);	430	presentError("I don't know how to parse values of type " + type);
420	}	431	}