Attachment #348993 for bug #189014

View Details Raw Unified Return to Bug 189014

| Differences between



2018-09-05  Myles C. Maxfield  <mmaxfield@apple.com>

        [WHLSL] The parser is too slow
        https://bugs.webkit.org/show_bug.cgi?id=189014

        Reviewed by NOBODY (OOPS!).

        This patch includes two changes:
        1. Migrate from using try/catch to simply returning the WSyntaxError. This means that
           each parser call has to check for this sentinel value. The lexer still can throw if
           it encounters an unknown token or an unmatched "/*" token (which is rare).
        2. After removing try/catch, making the sentinel values not inherit from Error (the
           Error constructor was taking lots of time)
        2. Previously, every time the parser failed (which is many times per expression) it was
           running a regex over the entire source text to figure out where the error occurred.
           Instead, we can preprocess the text string to find these line numbers ahead of time.

        Together, these make the parser 75x faster. Parsing the standard library goes from 2.5
        hours down to 2 minutes. Because it's now a reasonable length, this patch uncomments
        the bulk of the standard library.

        * WebGPUShadingLanguageRI/All.js:
        * WebGPUShadingLanguageRI/Lexer.js:
        (Lexer):
        (Lexer.prototype.lineNumberForIndex):
        * WebGPUShadingLanguageRI/Parse.js:
        (fail):
        (backtrackingScope):
        (testScope):
        (genericConsume):
        (consumeEndOfTypeArgs):
        (parseTerm):
        (parseConstexpr):
        (parseTypeArguments):
        (parseType.getAddressSpace):
        (parseType):
        (parseTypeDef):
        (genericParseLeft):
        (parseCallExpression.let.parseArguments):
        (isCallExpression):
        (parseSuffixOperator):
        (parsePossibleSuffix):
        (parsePreIncrement):
        (parsePossiblePrefix):
        (parsePossibleTernaryConditional):
        (parsePossibleAssignment):
        (parsePostIncrement):
        (parseEffectfulExpression):
        (genericParseCommaExpression):
        (parseEffectfulStatement):
        (parseReturn):
        (parseBreak):
        (parseContinue):
        (parseIfStatement):
        (parseWhile):
        (parseFor):
        (parseDo):
        (parseVariableDecls):
        (parseSwitchCase):
        (parseSwitchStatement):
        (parseStatement):
        (parseBlockBody):
        (parseBlock):
        (parseParameter):
        (parseFuncName):
        (parseFuncDecl):
        (parseFuncDef):
        (parseField):
        (parseStructType):
        (parseNativeFunc):
        (parseNative):
        (parseRestrictedFuncDef):
        (parseEnumMember):
        (parseEnumType):
        (parse):
        * WebGPUShadingLanguageRI/SPIRV.html:
        * WebGPUShadingLanguageRI/StandardLibrary.js:
        (let.standardLibrary):
        * WebGPUShadingLanguageRI/Test.html:
        * WebGPUShadingLanguageRI/Test.js:
        (checkFail.doPrep): Deleted.
        * WebGPUShadingLanguageRI/WLexicalError.js: Added.
        (WLexicalError):
        * WebGPUShadingLanguageRI/index.html:

2018-09-05  Woodrow Wang  <woodrow_wang@apple.com>

        Added runtime feature flag for web API statistics

Lines 168-173 load("VariableDecl.js"); a/Tools/WebGPUShadingLanguageRI/All.js_sec1
- a/Tools/WebGPUShadingLanguageRI/All.js +1 lines
168	load("VariableRef.js");	168	load("VariableRef.js");
169	load("VectorType.js");	169	load("VectorType.js");
170	load("VisitingSet.js");	170	load("VisitingSet.js");
		171	load("WLexicalError.js");
171	load("WSyntaxError.js");	172	load("WSyntaxError.js");
172	load("WTrapError.js");	173	load("WTrapError.js");
173	load("WTypeError.js");	174	load("WTypeError.js");



        this._text = text;
        this._index = 0;
        this._stack = [];

        this._lineNumbers = [];
        let lineNumber = 1;
        for (let i = 0; i < this._text.length; ++i) {
            this._lineNumbers.push(lineNumber);
            if (this._text[i] == '\n')
                ++lineNumber;
        }
    }
    
    get lineNumber()

    
    lineNumberForIndex(index)
    {
        return this._lineNumbers[index] + this._lineNumberOffset;
        return (matches ? matches.length : 0) + this._lineNumberOffset;
    }
    
    get state() { return {index: this._index, stack: this._stack.concat()}; }

    
    fail(error)
    {
        throw new WLexicalError(this.originString, error);
    }
    
    backtrackingScope(callback)
    {
        let state = this.state;
        try {
            return callback();
        } catch (e) {
            if (e instanceof WSyntaxError) {
                this.state = state;
                return null;
            }
            throw e;
        }
    }
    
    testScope(callback)
    {
        let state = this.state;
        try {
            callback();
            return true;
        } catch (e) {
            if (e instanceof WSyntaxError)
                return false;
            throw e;
        } finally {
            this.state = state;
        }
    }
}

Lines 70-76 class LexerToken { a/Tools/WebGPUShadingLanguageRI/LexerToken.js_sec1
- a/Tools/WebGPUShadingLanguageRI/LexerToken.js -1 / +1 lines
70		70
71	get originString()	71	get originString()
72	{	72	{
73	return this.origin + ":" + (this.lineNumber + 1);	73	return this.origin + ":" + this.lineNumber;
74	}	74	}
75		75
76	toString()	76	toString()



function parse(program, origin, originKind, lineNumberOffset, text)
{
    let lexer = new Lexer(origin, originKind, lineNumberOffset, text);

    // The hardest part of dealing with C-like languages is parsing variable declaration statements.
    // Let's consider if this happens in WSL. Here are the valid statements in WSL that being with an
    // identifier, if we assume that any expression can be a standalone statement.

    // pointers means that we can still allow function call statements - unlike in C, those cannot
    // have arbitrary expressions as the callee. The remaining two problems are solved by
    // backtracking. In all other respects, this is a simple recursive descent parser.

    function fail(error)
    {
        return new WSyntaxError(lexer.originString, error);
    }

    function backtrackingScope(callback)
    {
        let state = lexer.state;
        let maybeError = callback();
        if (maybeError instanceof WSyntaxError) {
            lexer.state = state;
            return null;
        } else
            return maybeError;
    }

    function testScope(callback)
    {
        let state = lexer.state;
        let maybeError = callback();
        lexer.state = state;
        return !(maybeError instanceof WSyntaxError);
    }

    function genericConsume(callback, explanation)
    {
        let token = lexer.next();
        if (!token)
            return fail("Unexpected end of file");
        if (!callback(token))
            return fail("Unexpected token: " + token.text + "; expected: " + explanation);
        return token;
    }

    function consume(...texts)
    {
        return genericConsume(token => texts.includes(token.text), texts);
    }

    function consumeKind(kind)
    {
        return genericConsume(token => token.kind == kind, kind);
    }

    function assertNext(...texts)
    {
        let maybeError = consume(...texts);
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        lexer.push(maybeError);
    }

    function genericTest(callback)
    {
        let token = lexer.peek();

            return token;
        return null;
    }

    function test(...texts)
    {
        return genericTest(token => texts.includes(token.text));
    }

    function testKind(kind)
    {
        return genericTest(token => token.kind == kind);
    }

    function tryConsume(...texts)
    {
        let result = test(...texts);

            lexer.next();
        return result;
    }

    function tryConsumeKind(kind)
    {
        let result = testKind(kind);

            lexer.next();
        return result;
    }

    function consumeEndOfTypeArgs()
    {
        let rightShift = tryConsume(">>");
        if (rightShift)
            lexer.push(new LexerToken(lexer, rightShift, rightShift.index, rightShift.kind, ">"));
        else {
            let maybeError = consume(">");
            if (maybeError instanceof WSyntaxError)
                return maybeError;
        }
    }

    function parseTerm()
    {
        let token;

        if (token = tryConsumeKind("intLiteral")) {
            let intVersion = (+token.text) | 0;
            if ("" + intVersion !== token.text)
                return fail("Integer literal is not an integer: " + token.text);
            return new IntLiteral(token, intVersion);
        }
        if (token = tryConsumeKind("uintLiteral")) {
            let uintVersion = token.text.substr(0, token.text.length - 1) >>> 0;
            if (uintVersion + "u" !== token.text)
                return fail("Integer literal is not 32-bit unsigned integer: " + token.text);
            return new UintLiteral(token, uintVersion);
        }
        if ((token = tryConsumeKind("intHexLiteral"))

            else
                intVersion = intVersion >>> 0;
            if (intVersion.toString(16) !== hexString)
                return fail("Hex integer literal is not an integer: " + token.text);
            if (token.kind == "intHexLiteral")
                return new IntLiteral(token, intVersion);
            return new UintLiteral(token, intVersion >>> 0);

        if (token = tryConsume("true", "false"))
            return new BoolLiteral(token, token.text == "true");
        // FIXME: Need support for other literals too.
        let maybeError = consume("(");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let result = parseExpression();
        if (result instanceof WSyntaxError)
            return result;
        maybeError = consume(")");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return result;
    }

    function parseConstexpr()
    {
        let token;
        if (token = tryConsume("-")) {
            let term = parseTerm();
            if (term instanceof WSyntaxError)
                return term;
            return new CallExpression(token, "operator" + token.text, [term]);
        }
        let left = parseTerm();
        if (left instanceof WSyntaxError)
            return left;
        if (token = tryConsume(".")) {
            let maybeError = consumeKind("identifier")
            if (maybeError instanceof WSyntaxError)
                return maybeError;
            left = new DotExpression(token, left, maybeError.text);
        }
        return left;
    }

    function parseTypeArguments()
    {
        if (!test("<"))
            return [];

        let result = [];
        let maybeError = consume("<");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        while (!test(">")) {
            // It's possible for a constexpr or type can syntactically overlap in the single
            // identifier case. Let's consider the possibilities:

            // 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 typeRef = backtrackingScope(() => {
                let result = consumeKind("identifier");
                if (result instanceof WSyntaxError)
                    return result;
                let maybeError = assertNext(",", ">", ">>");
                if (maybeError instanceof WSyntaxError)
                    return maybeError;
                return new TypeRef(result, result.text);
            });
            if (typeRef)
                result.push(typeRef);
            else {
                let constexpr = backtrackingScope(() => {
                    let result = parseConstexpr();
                    if (result instanceof WSyntaxError)
                        return result;
                    let maybeError = assertNext(",", ">", ">>");
                    if (maybeError instanceof WSyntaxError)
                        return maybeError;
                    return result;
                });
                if (constexpr)
                    result.push(constexpr);
                else {
                    let type = parseType();
                    if (type instanceof WSyntaxError)
                        return type;
                    result.push(type);
                }
            }
            if (!tryConsume(","))
                break;
        }
        maybeError = consumeEndOfTypeArgs();
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return result;
    }

    function parseType()
    {
        let token;

        let addressSpaceConsumed = false;
        if (token = tryConsume(...addressSpaces))
            addressSpace = token.text;

        let name = consumeKind("identifier");
        if (name instanceof WSyntaxError)
            return name;
        let typeArguments = parseTypeArguments();
        if (typeArguments instanceof WSyntaxError)
            return typeArguments;
        let type = new TypeRef(name, name.text, typeArguments);

        function getAddressSpace()
        {
            addressSpaceConsumed = true;
            if (addressSpace)
                return addressSpace;
            let consumedAddressSpace = consume(...addressSpaces);
            if (consumedAddressSpace instanceof WSyntaxError)
                return consumedAddressSpace;
            return consumedAddressSpace.text;
        }

        const typeConstructorStack = [ ];

        for (let token; token = tryConsume("*", "[");) {
            if (token.text == "*") {
                // Likewise, the address space must be parsed before parsing continues.
                const addressSpace = getAddressSpace();
                if (addressSpace instanceof WSyntaxError)
                    return addressSpace;
                typeConstructorStack.unshift(type => new PtrType(token, addressSpace, type));
                continue;
            }

            if (tryConsume("]")) {
                const addressSpace = getAddressSpace();
                if (addressSpace instanceof WSyntaxError)
                    return addressSpace;
                typeConstructorStack.unshift(type => new ArrayRefType(token, addressSpace, type));
                continue;
            }

            const lengthExpr = parseConstexpr();
            if (lengthExpr instanceof WSyntaxError)
                return lengthExpr;
            typeConstructorStack.unshift(type => new ArrayType(token, type, lengthExpr));
            let maybeError = consume("]");
            if (maybeError instanceof WSyntaxError)
                return maybeError;
        }

        for (let constructor of typeConstructorStack)
            type = constructor(type);

        if (addressSpace && !addressSpaceConsumed)
            return fail("Address space specified for type that does not need address space");

        return type;
    }

    function parseTypeDef()
    {
        let origin = consume("typedef");
        if (origin instanceof WSyntaxError)
            return origin;
        let maybeError = consumeKind("identifier");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let name = maybeError.text;
        maybeError = consume("=");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let type = parseType();
        if (type instanceof WSyntaxError)
            return type;
        maybeError = consume(";");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return new TypeDef(origin, name, type);
    }

    function genericParseLeft(texts, nextParser, constructor)
    {
        let left = nextParser();
        if (left instanceof WSyntaxError)
            return left;
        let token;
        while (token = tryConsume(...texts))
            left = constructor(token, left, nextParser());
        return left;
    }

    function parseLeftOperatorCall(texts, nextParser)
    {
        return genericParseLeft(

            (token, left, right) =>
                new CallExpression(token, "operator" + token.text, [left, right]));
    }

    function parseCallExpression()
    {
        let parseArguments = function(origin, callName) {
            let argumentList = [];
            while (!test(")")) {
                let argument = parsePossibleAssignment();
                if (argument instanceof WSyntaxError)
                    return argument;
                argumentList.push(argument);
                if (!tryConsume(","))
                    break;
            }
            let maybeError = consume(")");
            if (maybeError instanceof WSyntaxError)
                return maybeError;
            return new CallExpression(origin, callName, argumentList);
        }

        let name = backtrackingScope(() => {
            let name = consumeKind("identifier");
            if (name instanceof WSyntaxError)
                return name;
            let maybeError = consume("(");
            if (maybeError instanceof WSyntaxError)
                return maybeError;
            return name;
        });


            return result;
        } else {
            let returnType = parseType();
            if (returnType instanceof WSyntaxError)
                return returnType;
            let maybeError = consume("(");
            if (maybeError instanceof WSyntaxError)
                return maybeError;
            let result = parseArguments(returnType.origin, "operator cast");
            result.setCastData(returnType);
            return result;
        }
    }

    function isCallExpression()
    {
        return testScope(() => {
                let maybeError = consumeKind("identifier");
                if (maybeError instanceof WSyntaxError)
                    return maybeError;
                maybeError = consume("(");
                if (maybeError instanceof WSyntaxError)
                    return maybeError;
            }) || testScope(() => {
                let type = parseType();
                if (type instanceof WSyntaxError)
                    return type;
                let maybeError = consume("(");
                if (maybeError instanceof WSyntaxError)
                    return maybeError;
            });
    }

    function emitIncrement(token, old, extraArg)
    {
        let args = [old];
        if (extraArg)
            args.push(extraArg);

        let name = "operator" + token.text;
        if (/=$/.test(name))
            name = RegExp.leftContext;

        if (name == "operator")
            throw new Error("Invalid name: " + name);

        return new CallExpression(token, name, args);
    }

    function finishParsingPostIncrement(token, left)
    {
        let readModifyWrite = new ReadModifyWriteExpression(token, left);

        readModifyWrite.resultExp = readModifyWrite.oldValueRef();
        return readModifyWrite;
    }

    function parseSuffixOperator(left, acceptableOperators)
    {
        let token;

            case "->":
                if (token.text == "->")
                    left = new DereferenceExpression(token, left);
                let maybeError = consumeKind("identifier");
                if (maybeError instanceof WSyntaxError)
                    return maybeError;
                left = new DotExpression(token, left, maybeError.text);
                break;
            case "[": {
                let index = parseExpression();
                if (index instanceof WSyntaxError)
                    return index;
                let maybeError = consume("]");
                if (maybeError instanceof WSyntaxError)
                    return maybeError;
                left = new IndexExpression(token, left, index);
                break;
            }

        }
        return left;
    }

    function parsePossibleSuffix()
    {
        let acceptableOperators = ["++", "--", ".", "->", "["];

        let left;
        if (isCallExpression()) {
            left = parseCallExpression();
            if (left instanceof WSyntaxError)
                return left;
            acceptableOperators = limitedOperators;
        } else {
            left = parseTerm();
            if (left instanceof WSyntaxError)
                return left;
        }

        return parseSuffixOperator(left, acceptableOperators);
    }

    function finishParsingPreIncrement(token, left, extraArg)
    {
        let readModifyWrite = new ReadModifyWriteExpression(token, left);

        readModifyWrite.resultExp = readModifyWrite.newValueRef();
        return readModifyWrite;
    }

    function parsePreIncrement()
    {
        let token = consume("++", "--");
        if (token instanceof WSyntaxError)
            return token;
        let left = parsePossiblePrefix();
        if (left instanceof WSyntaxError)
            return left;
        return finishParsingPreIncrement(token, left);
    }

    function parsePossiblePrefix()
    {
        let token;
        if (test("++", "--"))
            return parsePreIncrement();
        if (token = tryConsume("+", "-", "~")) {
            let possiblePrefix = parsePossiblePrefix();
            if (possiblePrefix instanceof WSyntaxError)
                return WSyntaxError;
            return new CallExpression(token, "operator" + token.text, [possiblePrefix]);
        } if (token = tryConsume("*")) {
            let possiblePrefix = parsePossiblePrefix();
            if (possiblePrefix instanceof WSyntaxError)
                return WSyntaxError;
            return new DereferenceExpression(token, possiblePrefix);
        } if (token = tryConsume("&")) {
            let possiblePrefix = parsePossiblePrefix();
            if (possiblePrefix instanceof WSyntaxError)
                return WSyntaxError;
            return new MakePtrExpression(token, possiblePrefix);
        } if (token = tryConsume("@")) {
            let possiblePrefix = parsePossiblePrefix();
            if (possiblePrefix instanceof WSyntaxError)
                return WSyntaxError;
            return new MakeArrayRefExpression(token, possiblePrefix);
        } if (token = tryConsume("!")) {
            let remainder = parsePossiblePrefix();
            if (remainder instanceof WSyntaxError)
                return remainder;
            return new LogicalNot(token, new CallExpression(remainder.origin, "bool", [remainder]));
        }
        return parsePossibleSuffix();
    }

    function parsePossibleProduct()
    {
        return parseLeftOperatorCall(["*", "/", "%"], parsePossiblePrefix);
    }

    function parsePossibleSum()
    {
        return parseLeftOperatorCall(["+", "-"], parsePossibleProduct);
    }

    function parsePossibleShift()
    {
        return parseLeftOperatorCall(["<<", ">>"], parsePossibleSum);
    }

    function parsePossibleRelationalInequality()
    {
        return parseLeftOperatorCall(["<", ">", "<=", ">="], parsePossibleShift);
    }

    function parsePossibleRelationalEquality()
    {
        return genericParseLeft(

                return result;
            });
    }

    function parsePossibleBitwiseAnd()
    {
        return parseLeftOperatorCall(["&"], parsePossibleRelationalEquality);
    }

    function parsePossibleBitwiseXor()
    {
        return parseLeftOperatorCall(["^"], parsePossibleBitwiseAnd);
    }

    function parsePossibleBitwiseOr()
    {
        return parseLeftOperatorCall(["|"], parsePossibleBitwiseXor);
    }

    function parseLeftLogicalExpression(texts, nextParser)
    {
        return genericParseLeft(
            texts, nextParser,
            (token, left, right) => new LogicalExpression(token, token.text, new CallExpression(left.origin, "bool", [left]), new CallExpression(right.origin, "bool", [right])));
    }

    function parsePossibleLogicalAnd()
    {
        return parseLeftLogicalExpression(["&&"], parsePossibleBitwiseOr);
    }

    function parsePossibleLogicalOr()
    {
        return parseLeftLogicalExpression(["||"], parsePossibleLogicalAnd);
    }

    function parsePossibleTernaryConditional()
    {
        let predicate = parsePossibleLogicalOr();
        if (predicate instanceof WSyntaxError)
            return predicate;
        let operator = tryConsume("?");
        if (!operator)
            return predicate;
        let bodyExpression = parsePossibleAssignment();
        if (bodyExpression instanceof WSyntaxError)
            return bodyExpression;
        let maybeError = consume(":");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let elseExpression = parsePossibleAssignment();
        if (elseExpression instanceof WSyntaxError)
            return elseExpression;
        return new TernaryExpression(operator, predicate, bodyExpression, elseExpression);
    }

    function parsePossibleAssignment(mode)
    {
        let lhs = parsePossibleTernaryConditional();
        if (lhs instanceof WSyntaxError)
            return lhs;
        let operator = tryConsume("=", "+=", "-=", "*=", "/=", "%=", "^=", "|=", "&=");
        if (!operator) {
            if (mode == "required")
                return fail("Expected assignment: " + lexer._text.substring(lexer._index));
            return lhs;
        }
        if (operator.text == "=") {
            let innerAssignment = parsePossibleAssignment();
            if (innerAssignment instanceof WSyntaxError)
                return innerAssignment;
            return new Assignment(operator, lhs, innerAssignment);
        }
        let innerAssignment = parsePossibleAssignment();
        if (innerAssignment instanceof WSyntaxError)
            return innerAssignment;
        return finishParsingPreIncrement(operator, lhs, innerAssignment);
    }

    function parseAssignment()
    {
        return parsePossibleAssignment("required");
    }

    function parsePostIncrement()
    {
        let term = parseTerm();
        if (term instanceof WSyntaxError)
            return term;
        let left = parseSuffixOperator(term, ".", "->", "[");
        if (left instanceof WSyntaxError)
            return left;
        let token = consume("++", "--");
        if (token instanceof WSyntaxError)
            return token;
        return finishParsingPostIncrement(token, left);
    }

    function parseEffectfulExpression()
    {
        if (isCallExpression())
            return parseCallExpression();
        let preIncrement = backtrackingScope(parsePreIncrement);
        if (preIncrement)
            return preIncrement;
        let postIncrement = backtrackingScope(parsePostIncrement);
        if (postIncrement)
            return postIncrement;
        return parseAssignment();
    }

    function genericParseCommaExpression(finalExpressionParser)
    {
        let list = [];
        let origin = lexer.peek();
        if (!origin)
            return fail("Unexpected end of file");
        for (;;) {
            let effectfulExpression = backtrackingScope(() => {
                let effectfulExpression = parseEffectfulExpression();
                if (effectfulExpression instanceof WSyntaxError)
                    return effectfulExpression;
                let maybeError = consume(",");
                if (maybeError instanceof WSyntaxError)
                    return maybeError;
                return effectfulExpression;
            });
            if (!effectfulExpression) {
                let final = finalExpressionParser();

            return list[0];
        return new CommaExpression(origin, list);
    }

    function parseCommaExpression()
    {
        return genericParseCommaExpression(parsePossibleAssignment);
    }

    function parseExpression()
    {
        return parseCommaExpression();
    }

    function parseEffectfulStatement()
    {
        let result = genericParseCommaExpression(parseEffectfulExpression);
        if (result instanceof WSyntaxError)
            return result;
        let maybeError = consume(";");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return result;
    }

    function parseReturn()
    {
        let origin = consume("return");
        if (origin instanceof WSyntaxError)
            return origin;
        if (tryConsume(";"))
            return new Return(origin, null);
        let expression = parseExpression();
        if (expression instanceof WSyntaxError)
            return expression;
        let maybeError = consume(";");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return new Return(origin, expression);
    }

    function parseBreak()
    {
        let origin = consume("break");
        if (origin instanceof WSyntaxError)
            return origin;
        let maybeError = consume(";");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return new Break(origin);
    }

    function parseContinue()
    {
        let origin = consume("continue");
        if (origin instanceof WSyntaxError)
            return origin;
        let maybeError = consume(";");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return new Continue(origin);
    }

    function parseIfStatement()
    {
        let origin = consume("if");
        if (origin instanceof WSyntaxError)
            return origin;
        let maybeError = consume("(");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let conditional = parseExpression();
        if (conditional instanceof WSyntaxError)
            return conditional;
        maybeError = consume(")");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let body = parseStatement();
        if (body instanceof WSyntaxError)
            return body;
        let elseBody;
        if (tryConsume("else")) {
            elseBody = parseStatement();
            if (elseBody instanceof WSyntaxError)
                return elseBody;
        }
        return new IfStatement(origin, new CallExpression(conditional.origin, "bool", [conditional]), body, elseBody);
    }

    function parseWhile()
    {
        let origin = consume("while");
        if (origin instanceof WSyntaxError)
            return origin;
        let maybeError = consume("(");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let conditional = parseExpression();
        if (conditional instanceof WSyntaxError)
            return conditional;
        maybeError = consume(")");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let body = parseStatement();
        if (body instanceof WSyntaxError)
            return body;
        return new WhileLoop(origin, new CallExpression(conditional.origin, "bool", [conditional]), body);
    }

    function parseFor()
    {
        let origin = consume("for");
        if (origin instanceof WSyntaxError)
            return origin;
        let maybeError = consume("(");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let initialization;
        if (tryConsume(";"))
            initialization = undefined;
        else {
            initialization = backtrackingScope(parseVariableDecls);
            if (!initialization) {
                initialization = parseEffectfulStatement();
                if (initialization instanceof WSyntaxError)
                    return initialization;
            }
        }
        let condition = tryConsume(";");
        if (condition)
            condition = undefined;
        else {
            condition = parseExpression();
            if (condition instanceof WSyntaxError)
                return condition;
            maybeError = consume(";");
            if (maybeError instanceof WSyntaxError)
                return maybeError;
            condition = new CallExpression(condition.origin, "bool", [condition]);
        }
        let increment;

            increment = undefined;
        else {
            increment = parseExpression();
            if (increment instanceof WSyntaxError)
                return increment;
            maybeError = consume(")");
            if (maybeError instanceof WSyntaxError)
                return maybeError;
        }
        let body = parseStatement();
        if (body instanceof WSyntaxError)
            return body;
        return new ForLoop(origin, initialization, condition, increment, body);
    }

    function parseDo()
    {
        let origin = consume("do");
        if (origin instanceof WSyntaxError)
            return origin;
        let body = parseStatement();
        if (body instanceof WSyntaxError)
            return body;
        let maybeError = consume("while");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        maybeError = consume("(");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let conditional = parseExpression();
        if (conditional instanceof WSyntaxError)
            return conditional;
        maybeError = consume(")");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return new DoWhileLoop(origin, body, new CallExpression(conditional.origin, "bool", [conditional]));
    }

    function parseVariableDecls()
    {
        let type = parseType();
        if (type instanceof WSyntaxError)
            return type;
        let list = [];
        do {
            let name = consumeKind("identifier");
            if (name instanceof WSyntaxError)
                return name;
            let initializer = tryConsume("=") ? parseExpression() : null;
            if (initializer instanceof WSyntaxError)
                return initializer;
            list.push(new VariableDecl(name, name.text, type, initializer));
            let maybeError = consume(",", ";");
            if (maybeError instanceof WSyntaxError)
                return maybeError;
            if (maybeError.text != ",")
                break;
        } while (true);
        return new CommaExpression(type.origin, list);
    }

    function parseSwitchCase()
    {
        let token = consume("default", "case");
        if (token instanceof WSyntaxError)
            return token;
        let value;
        if (token.text == "case") {
            value = parseConstexpr();
            if (value instanceof WSyntaxError)
                return value;
        }
        let maybeError = consume(":");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let body = parseBlockBody("}", "default", "case");
        if (body instanceof WSyntaxError)
            return body;
        return new SwitchCase(token, value, body);
    }

    function parseSwitchStatement()
    {
        let origin = consume("switch");
        if (origin instanceof WSyntaxError)
            return origin;
        let maybeError = consume("(");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let value = parseExpression();
        if (value instanceof WSyntaxError)
            return value;
        maybeError = consume(")");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        maybeError = consume("{");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let result = new SwitchStatement(origin, value);
        while (!tryConsume("}")) {
            let switchCase = parseSwitchCase();
            if (switchCase instanceof WSyntaxError)
                return switchCase;
            result.add(switchCase);
        }
        return result;
    }

    function parseStatement()
    {
        let token = lexer.peek();

            return parseSwitchStatement();
        if (token.text == "trap") {
            let origin = consume("trap");
            if (origin instanceof WSyntaxError)
                return origin;
            consume(";");
            return new TrapStatement(origin);
        }
        if (token.text == "{")
            return parseBlock();
        let variableDecl = backtrackingScope(parseVariableDecls);
        if (variableDecl)
            return variableDecl;
        return parseEffectfulStatement();
    }

    function parseBlockBody(...terminators)
    {
        let block = new Block(origin);
        while (!test(...terminators)) {
            let statement = parseStatement();
            if (statement instanceof WSyntaxError)
                return statement;
            if (statement)
                block.add(statement);
        }
        return block;
    }

    function parseBlock()
    {
        let origin = consume("{");
        if (origin instanceof WSyntaxError)
            return origin;
        let block = parseBlockBody("}");
        if (block instanceof WSyntaxError)
            return block;
        let maybeError = consume("}");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return block;
    }

    function parseParameter()
    {
        let type = parseType();
        if (type instanceof WSyntaxError)
            return type;
        let name = tryConsumeKind("identifier");
        return new FuncParameter(type.origin, name ? name.text : null, type);
    }

    function parseParameters()
    {
        let maybeError = consume("(");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let parameters = [];
        while (!test(")")) {
            let parameter = parseParameter();
            if (parameter instanceof WSyntaxError)
                return parameter;
            parameters.push(parameter);
            if (!tryConsume(","))
                break;
        }
        maybeError = consume(")");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return parameters;
    }

    function parseFuncName()
    {
        if (tryConsume("operator")) {
            let token = consume("+", "-", "*", "/", "%", "^", "&", "|", "<", ">", "<=", ">=", "==", "++", "--", ".", "~", "<<", ">>", "[");
            if (token instanceof WSyntaxError)
                return token;
            if (token.text == "&") {
                if (tryConsume("[")) {
                    let maybeError = consume("]");
                    if (maybeError instanceof WSyntaxError)
                        return maybeError;
                    return "operator&[]";
                }
                if (tryConsume(".")) {
                    let maybeError = consumeKind("identifier");
                    if (maybeError instanceof WSyntaxError)
                        return maybeError;
                    return "operator&." + maybeError.text;
                }
                return "operator&";
            }
            if (token.text == ".") {
                let maybeError = consumeKind("identifier");
                if (maybeError instanceof WSyntaxError)
                    return maybeError;
                let result = "operator." + maybeError.text;
                if (tryConsume("="))
                    result += "=";
                return result;
            }
            if (token.text == "[") {
                let maybeError = consume("]");
                if (maybeError instanceof WSyntaxError)
                    return maybeError;
                let result = "operator[]";
                if (tryConsume("="))
                    result += "=";

            }
            return "operator" + token.text;
        }
        let maybeError = consumeKind("identifier");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return maybeError.text;
    }

    function parseFuncDecl()

        if (operatorToken) {
            origin = operatorToken;
            returnType = parseType();
            if (returnType instanceof WSyntaxError)
                return returnType;
            name = "operator cast";
            isCast = true;
        } else {
            shaderType = tryConsume("vertex", "fragment");
            returnType = parseType();
            if (returnType instanceof WSyntaxError)
                return returnType;
            if (shaderType) {
                origin = shaderType;
                shaderType = shaderType.text;
            } else
                origin = returnType.origin;
            name = parseFuncName();
            if (name instanceof WSyntaxError)
                return name;
            isCast = false;
        }
        let parameters = parseParameters();
        if (parameters instanceof WSyntaxError)
            return parameters;
        return new Func(origin, name, returnType, parameters, isCast, shaderType);
    }

    function parseFuncDef()
    {
        let func = parseFuncDecl();
        if (func instanceof WSyntaxError)
            return func;
        let body = parseBlock();
        if (body instanceof WSyntaxError)
            return body;
        return new FuncDef(func.origin, func.name, func.returnType, func.parameters, body, func.isCast, func.shaderType);
    }

    function parseField()
    {
        let type = parseType();
        if (type instanceof WSyntaxError)
            return type;
        let name = consumeKind("identifier");
        if (name instanceof WSyntaxError)
            return name;
        let maybeError = consume(";");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return new Field(name, name.text, type);
    }

    function parseStructType()
    {
        let origin = consume("struct");
        if (origin instanceof WSyntaxError)
            return origin;
        let name = consumeKind("identifier");
        if (name instanceof WSyntaxError)
            return name;
        let result = new StructType(origin, name.text);
        let maybeError = consume("{");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        while (!tryConsume("}")) {
            let field = parseField();
            if (field instanceof WSyntaxError)
                return field;
            result.add(field);
        }
        return result;
    }

    function parseNativeFunc()
    {
        let func = parseFuncDecl();
        if (func instanceof WSyntaxError)
            return func;
        let maybeError = consume(";");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return new NativeFunc(func.origin, func.name, func.returnType, func.parameters, func.isCast, func.shaderType);
    }

    function parseNative()
    {
        let origin = consume("native");
        if (origin instanceof WSyntaxError)
            return origin;
        if (tryConsume("typedef")) {
            let name = consumeKind("identifier");
            if (name instanceof WSyntaxError)
                return name;
            let args = parseTypeArguments();
            if (args instanceof WSyntaxError)
                return args;
            let maybeError = consume(";");
            if (maybeError instanceof WSyntaxError)
                return maybeError;
            return NativeType.create(origin, name.text, args);
        }
        return parseNativeFunc();
    }

    function parseRestrictedFuncDef()
    {
        let maybeError = consume("restricted");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let result;
        if (tryConsume("native")) {
            result = parseNativeFunc();
            if (result instanceof WSyntaxError)
                return result;
        } else {
            result = parseFuncDef();
            if (result instanceof WSyntaxError)
                return result;
        }
        result.isRestricted = true;
        return result;
    }

    function parseEnumMember()
    {
        let name = consumeKind("identifier");
        if (name instanceof WSyntaxError)
            return name;
        let value = null;
        if (tryConsume("=")) {
            value = parseConstexpr();
            if (value instanceof WSyntaxError)
                return value;
        }
        return new EnumMember(name, name.text, value);
    }

    function parseEnumType()
    {
        let maybeError = consume("enum");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let name = consumeKind("identifier");
        if (name instanceof WSyntaxError)
            return name;
        let baseType;
        if (tryConsume(":")) {
            baseType = parseType();
            if (baseType instanceof WSyntaxError)
                return baseType;
        } else
            baseType = new TypeRef(name, "int");
        maybeError = consume("{");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        let result = new EnumType(name, name.text, baseType);
        while (!test("}")) {
            let enumMember = parseEnumMember();
            if (enumMember instanceof WSyntaxError)
                return enumMember;
            result.add(enumMember);
            if (!tryConsume(","))
                break;
        }
        maybeError = consume("}");
        if (maybeError instanceof WSyntaxError)
            return maybeError;
        return result;
    }

    for (;;) {
        let token = lexer.peek();
        if (!token)
            return;
        if (token.text == ";")
            lexer.next();
        else if (token.text == "typedef") {
            let typeDef = parseTypeDef();
            if (typeDef instanceof WSyntaxError)
                throw typeDef;
            program.add(typeDef);
        } else if (originKind == "native" && token.text == "native") {
            let native = parseNative();
            if (native instanceof WSyntaxError)
                throw native;
            program.add(native);
        } else if (originKind == "native" && token.text == "restricted") {
            let restrictedFuncDef = parseRestrictedFuncDef();
            if (restrictedFuncDef instanceof WSyntaxError)
                throw restrictedFuncDef;
            program.add(restrictedFuncDef);
        } else if (token.text == "struct") {
            let struct = parseStructType();
            if (struct instanceof WSyntaxError)
                throw struct;
            program.add(struct);
        } else if (token.text == "enum") {
            let enumType = parseEnumType();
            if (enumType instanceof WSyntaxError)
                throw enumType;
            program.add(enumType);
        } else {
            let funcDef = parseFuncDef();
            if (funcDef instanceof WSyntaxError)
                throw funcDef;
            program.add(funcDef);
        }
    }
}


Lines 151-156 td { a/Tools/WebGPUShadingLanguageRI/SPIRV.html_sec1
- a/Tools/WebGPUShadingLanguageRI/SPIRV.html +1 lines
151	<script src="VariableRef.js"></script>	151	<script src="VariableRef.js"></script>
152	<script src="VectorType.js"></script>	152	<script src="VectorType.js"></script>
153	<script src="VisitingSet.js"></script>	153	<script src="VisitingSet.js"></script>
		154	<script src="WLexicalError.js"></script>
154	<script src="WSyntaxError.js"></script>	155	<script src="WSyntaxError.js"></script>
155	<script src="WTrapError.js"></script>	156	<script src="WTrapError.js"></script>
156	<script src="WTypeError.js"></script>	157	<script src="WTypeError.js"></script>



            }
            return result;
        }

        /*
        for (let type of [`bool`, `uchar`, `ushort`, `uint`, `char`, `short`, `int`, `half`, `float`]) {
            for (let size of [2, 3, 4]) {
                for (let maxValue of [2, 3, 4]) {

            }
        }
        print();
        /*
        for (let type of [`uint`, `int`]) {
            for (let functionName of [`Add`, `And`, `Exchange`, `Max`, `Min`, `Or`, `Xor`]) {
                print(`native void Interlocked${functionName}(thread atomic_${type}*, ${type}, thread ${type}*);`);

        }
        print();
        */

        for (let type of [`uchar`, `ushort`, `uint`, `char`, `short`, `int`, `half`, `float`]) {
            for (let length of [``, `2`, `3`, `4`]) {
                print(`native ${type}${length} Sample(Texture1D<${type}${length}>, sampler, float location);`);

Lines 145-150 a/Tools/WebGPUShadingLanguageRI/Test.html_sec1
- a/Tools/WebGPUShadingLanguageRI/Test.html +1 lines
145	<script src="VariableRef.js"></script>	145	<script src="VariableRef.js"></script>
146	<script src="VectorType.js"></script>	146	<script src="VectorType.js"></script>
147	<script src="VisitingSet.js"></script>	147	<script src="VisitingSet.js"></script>
		148	<script src="WLexicalError.js"></script>
148	<script src="WSyntaxError.js"></script>	149	<script src="WSyntaxError.js"></script>
149	<script src="WTrapError.js"></script>	150	<script src="WTrapError.js"></script>
150	<script src="WTypeError.js"></script>	151	<script src="WTypeError.js"></script>



    }
});

tests.commentParsing = function() {
    let program = doPrep(`
        /* this comment
        runs over multiple lines */
        bool foo() { return true; }
    `);
    checkBool(program, callFunction(program, "foo", []), true);

    checkFail(
        () => doPrep(`
        /* this comment
        runs over multiple lines
        bool foo() { return true; }
        `),
        (e) => e instanceof WSyntaxError);
}

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

    // FIXME: Gather other components
}

tests.commentParsing = function() {
    let program = doPrep(`
        /* this comment
        runs over multiple lines */
        bool foo() { return true; }
    `);
    checkBool(program, callFunction(program, "foo", []), true);

    checkFail(
        () => doPrep(`
        /* this comment
        runs over multiple lines
        bool foo() { return true; }
        `),
        (e) => e instanceof WLexicalError);
}

okToTest = true;

let testFilter = /.*/; // run everything by default

    for (let _ of doTest(testFilter)) { }
}





/*
 * Copyright (C) 2018 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */
"use strict";

class WLexicalError extends Error {
    constructor(originString, message)
    {
        super("Lexical error at " + originString + ": " + message);
        this.originString = originString;
        this.syntaxErrorMessage = message;
    }
}




 */
"use strict";

class WSyntaxError {
    constructor(originString, message)
    {
        this.payload = "Syntax error at " + originString + ": " + message;
        this.originString = originString;
        this.syntaxErrorMessage = message;
    }

Lines 145-150 a/Tools/WebGPUShadingLanguageRI/index.html_sec1
- a/Tools/WebGPUShadingLanguageRI/index.html +1 lines
145	<script src="VariableRef.js"></script>	145	<script src="VariableRef.js"></script>
146	<script src="VectorType.js"></script>	146	<script src="VectorType.js"></script>
147	<script src="VisitingSet.js"></script>	147	<script src="VisitingSet.js"></script>
		148	<script src="WLexicalError.js"></script>
148	<script src="WSyntaxError.js"></script>	149	<script src="WSyntaxError.js"></script>
149	<script src="WTrapError.js"></script>	150	<script src="WTrapError.js"></script>
150	<script src="WTypeError.js"></script>	151	<script src="WTypeError.js"></script>

Return to Bug 189014

Lines 35-40 class Lexer { a/Tools/WebGPUShadingLanguageRI/Lexer.js_sec1
- a/Tools/WebGPUShadingLanguageRI/Lexer.js -32 / +10 lines
35	this._text = text;	35	this._text = text;
36	this._index = 0;	36	this._index = 0;
37	this._stack = [];	37	this._stack = [];
		38
		39	this._lineNumbers = [];
		40	let lineNumber = 1;
		41	for (let i = 0; i < this._text.length; ++i) {
		42	this._lineNumbers.push(lineNumber);
		43	if (this._text[i] == '\n')
		44	++lineNumber;
		45	}
38	}	46	}
39		47
40	get lineNumber()	48	get lineNumber()
Lines 53-60 class Lexer { a/Tools/WebGPUShadingLanguageRI/Lexer.js_sec2
53		61
54	lineNumberForIndex(index)	62	lineNumberForIndex(index)
55	{	63	{
56	let matches = this._text.substring(0, index).match(/\n/g);	64	return this._lineNumbers[index] + this._lineNumberOffset;
57	return (matches ? matches.length : 0) + this._lineNumberOffset;
58	}	65	}
59		66
60	get state() { return {index: this._index, stack: this._stack.concat()}; }	67	get state() { return {index: this._index, stack: this._stack.concat()}; }
Lines 166-200 class Lexer { a/Tools/WebGPUShadingLanguageRI/Lexer.js_sec3
166		173
167	fail(error)	174	fail(error)
168	{	175	{
169	throw new WSyntaxError(this.originString, error);	176	throw new WLexicalError(this.originString, error);
170	}
171
172	backtrackingScope(callback)
173	{
174	let state = this.state;
175	try {
176	return callback();
177	} catch (e) {
178	if (e instanceof WSyntaxError) {
179	this.state = state;
180	return null;
181	}
182	throw e;
183	}
184	}
185
186	testScope(callback)
187	{
188	let state = this.state;
189	try {
190	callback();
191	return true;
192	} catch (e) {
193	if (e instanceof WSyntaxError)
194	return false;
195	throw e;
196	} finally {
197	this.state = state;
198	}
199	}	177	}
200	}	178	}

Lines 773-780 let standardLibrary = (function() { a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js_sec1
- a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js -4 / +2 lines
773	}	773	}
774	return result;	774	return result;
775	}	775	}
776		776
777	/*
778	for (let type of [`bool`, `uchar`, `ushort`, `uint`, `char`, `short`, `int`, `half`, `float`]) {	777	for (let type of [`bool`, `uchar`, `ushort`, `uint`, `char`, `short`, `int`, `half`, `float`]) {
779	for (let size of [2, 3, 4]) {	778	for (let size of [2, 3, 4]) {
780	for (let maxValue of [2, 3, 4]) {	779	for (let maxValue of [2, 3, 4]) {
Lines 1889-1895 let standardLibrary = (function() { a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js_sec2
1889	}	1888	}
1890	}	1889	}
1891	print();	1890	print();
1892		1891	/*
1893	for (let type of [`uint`, `int`]) {	1892	for (let type of [`uint`, `int`]) {
1894	for (let functionName of [`Add`, `And`, `Exchange`, `Max`, `Min`, `Or`, `Xor`]) {	1893	for (let functionName of [`Add`, `And`, `Exchange`, `Max`, `Min`, `Or`, `Xor`]) {
1895	print(`native void Interlocked${functionName}(thread atomic_${type}, ${type}, thread ${type});`);	1894	print(`native void Interlocked${functionName}(thread atomic_${type}, ${type}, thread ${type});`);
Lines 1898-1904 let standardLibrary = (function() { a/Tools/WebGPUShadingLanguageRI/StandardLibrary.js_sec3
1898	}	1897	}
1899	print();	1898	print();
1900	*/	1899	*/
1901
1902	for (let type of [`uchar`, `ushort`, `uint`, `char`, `short`, `int`, `half`, `float`]) {	1900	for (let type of [`uchar`, `ushort`, `uint`, `char`, `short`, `int`, `half`, `float`]) {
1903	for (let length of [``, `2`, `3`, `4`]) {	1901	for (let length of [``, `2`, `3`, `4`]) {
1904	print(`native ${type}${length} Sample(Texture1D<${type}${length}>, sampler, float location);`);	1902	print(`native ${type}${length} Sample(Texture1D<${type}${length}>, sampler, float location);`);

Lines 329-351 tests = new Proxy({}, { a/Tools/WebGPUShadingLanguageRI/Test.js_sec1
- a/Tools/WebGPUShadingLanguageRI/Test.js -18 / +17 lines
329	}	329	}
330	});	330	});
331		331
332	tests.commentParsing = function() {
333	let program = doPrep(`
334	/* this comment
335	runs over multiple lines */
336	bool foo() { return true; }
337	`);
338	checkBool(program, callFunction(program, "foo", []), true);
339
340	checkFail(
341	() => doPrep(`
342	/* this comment
343	runs over multiple lines
344	bool foo() { return true; }
345	`),
346	(e) => e instanceof WSyntaxError);
347	}
348
349	tests.ternaryExpression = function() {	332	tests.ternaryExpression = function() {
350	let program = doPrep(`	333	let program = doPrep(`
351	int foo(int x)	334	int foo(int x)
Lines 7626-7631 tests.textureGather = function() { a/Tools/WebGPUShadingLanguageRI/Test.js_sec2
7626	// FIXME: Gather other components	7609	// FIXME: Gather other components
7627	}	7610	}
7628		7611
		7612	tests.commentParsing = function() {
		7613	let program = doPrep(`
		7614	/* this comment
		7615	runs over multiple lines */
		7616	bool foo() { return true; }
		7617	`);
		7618	checkBool(program, callFunction(program, "foo", []), true);
		7619
		7620	checkFail(
		7621	() => doPrep(`
		7622	/* this comment
		7623	runs over multiple lines
		7624	bool foo() { return true; }
		7625	`),
		7626	(e) => e instanceof WLexicalError);
		7627	}
		7628
7629	okToTest = true;	7629	okToTest = true;
7630		7630
7631	let testFilter = /.*/; // run everything by default	7631	let testFilter = /.*/; // run everything by default
Lines 7683-7686 if (!this.window) { a/Tools/WebGPUShadingLanguageRI/Test.js_sec3
7683	for (let _ of doTest(testFilter)) { }	7683	for (let _ of doTest(testFilter)) { }
7684	}	7684	}
7685		7685
7686

Lines 24-33 a/Tools/WebGPUShadingLanguageRI/WSyntaxError.js_sec1
- a/Tools/WebGPUShadingLanguageRI/WSyntaxError.js -2 / +2 lines
24	*/	24	*/
25	"use strict";	25	"use strict";
26		26
27	class WSyntaxError extends Error {	27	class WSyntaxError {
28	constructor(originString, message)	28	constructor(originString, message)
29	{	29	{
30	super("Syntax error at " + originString + ": " + message);	30	this.payload = "Syntax error at " + originString + ": " + message;
31	this.originString = originString;	31	this.originString = originString;
32	this.syntaxErrorMessage = message;	32	this.syntaxErrorMessage = message;
33	}	33	}

Lines 1-3 a/Tools/ChangeLog_sec1
- a/Tools/ChangeLog +85 lines
		1	2018-09-05 Myles C. Maxfield <mmaxfield@apple.com>
		2
		3	[WHLSL] The parser is too slow
		4	https://bugs.webkit.org/show_bug.cgi?id=189014
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This patch includes two changes:
		9	1. Migrate from using try/catch to simply returning the WSyntaxError. This means that
		10	each parser call has to check for this sentinel value. The lexer still can throw if
		11	it encounters an unknown token or an unmatched "/*" token (which is rare).
		12	2. After removing try/catch, making the sentinel values not inherit from Error (the
		13	Error constructor was taking lots of time)
		14	2. Previously, every time the parser failed (which is many times per expression) it was
		15	running a regex over the entire source text to figure out where the error occurred.
		16	Instead, we can preprocess the text string to find these line numbers ahead of time.
		17
		18	Together, these make the parser 75x faster. Parsing the standard library goes from 2.5
		19	hours down to 2 minutes. Because it's now a reasonable length, this patch uncomments
		20	the bulk of the standard library.
		21
		22	* WebGPUShadingLanguageRI/All.js:
		23	* WebGPUShadingLanguageRI/Lexer.js:
		24	(Lexer):
		25	(Lexer.prototype.lineNumberForIndex):
		26	* WebGPUShadingLanguageRI/Parse.js:
		27	(fail):
		28	(backtrackingScope):
		29	(testScope):
		30	(genericConsume):
		31	(consumeEndOfTypeArgs):
		32	(parseTerm):
		33	(parseConstexpr):
		34	(parseTypeArguments):
		35	(parseType.getAddressSpace):
		36	(parseType):
		37	(parseTypeDef):
		38	(genericParseLeft):
		39	(parseCallExpression.let.parseArguments):
		40	(isCallExpression):
		41	(parseSuffixOperator):
		42	(parsePossibleSuffix):
		43	(parsePreIncrement):
		44	(parsePossiblePrefix):
		45	(parsePossibleTernaryConditional):
		46	(parsePossibleAssignment):
		47	(parsePostIncrement):
		48	(parseEffectfulExpression):
		49	(genericParseCommaExpression):
		50	(parseEffectfulStatement):
		51	(parseReturn):
		52	(parseBreak):
		53	(parseContinue):
		54	(parseIfStatement):
		55	(parseWhile):
		56	(parseFor):
		57	(parseDo):
		58	(parseVariableDecls):
		59	(parseSwitchCase):
		60	(parseSwitchStatement):
		61	(parseStatement):
		62	(parseBlockBody):
		63	(parseBlock):
		64	(parseParameter):
65	(parseFuncName):
66	(parseFuncDecl):
67	(parseFuncDef):
68	(parseField):
69	(parseStructType):
70	(parseNativeFunc):
71	(parseNative):
72	(parseRestrictedFuncDef):
73	(parseEnumMember):
74	(parseEnumType):
75	(parse):
76	* WebGPUShadingLanguageRI/SPIRV.html:
77	* WebGPUShadingLanguageRI/StandardLibrary.js:
78	(let.standardLibrary):
79	* WebGPUShadingLanguageRI/Test.html:
80	* WebGPUShadingLanguageRI/Test.js:
81	(checkFail.doPrep): Deleted.
82	* WebGPUShadingLanguageRI/WLexicalError.js: Added.
83	(WLexicalError):
84	* WebGPUShadingLanguageRI/index.html:
85
1	2018-09-05 Woodrow Wang <woodrow_wang@apple.com>	86	2018-09-05 Woodrow Wang <woodrow_wang@apple.com>
2		87
3	Added runtime feature flag for web API statistics	88	Added runtime feature flag for web API statistics

Line 0 a/Tools/WebGPUShadingLanguageRI/WLexicalError.js_sec1
- a/Tools/WebGPUShadingLanguageRI/WLexicalError.js +35 lines
	1	/*
	2	* Copyright (C) 2018 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 WLexicalError extends Error {
	28	constructor(originString, message)
	29	{
	30	super("Lexical error at " + originString + ": " + message);
	31	this.originString = originString;
	32	this.syntaxErrorMessage = message;
	33	}
	34	}
	35