@profile-psl/psl-parser 0.1.0

package/statementParser.js

@@ -0,0 +1,739 @@
+/* eslint-disable no-case-declarations */
+/*
+Notes from Mischa Reitsma on skipped rules:
+- The no case declarations rule can be fixed by making sure the code in the cases go to dedicated
+  functions. It would make the code way more maintainable and readable.
+*/
+import { getTokens, Token } from "./tokenizer";
+export var SyntaxKind;
+(function (SyntaxKind) {
+    SyntaxKind[SyntaxKind["ASSIGNMENT"] = 0] = "ASSIGNMENT";
+    SyntaxKind[SyntaxKind["BINARY_OPERATOR"] = 1] = "BINARY_OPERATOR";
+    SyntaxKind[SyntaxKind["CATCH_STATEMENT"] = 2] = "CATCH_STATEMENT";
+    SyntaxKind[SyntaxKind["DO_STATEMENT"] = 3] = "DO_STATEMENT";
+    SyntaxKind[SyntaxKind["FOR_STATEMENT"] = 4] = "FOR_STATEMENT";
+    SyntaxKind[SyntaxKind["IDENTIFIER"] = 5] = "IDENTIFIER";
+    SyntaxKind[SyntaxKind["IF_STATEMENT"] = 6] = "IF_STATEMENT";
+    SyntaxKind[SyntaxKind["NUMERIC_LITERAL"] = 7] = "NUMERIC_LITERAL";
+    SyntaxKind[SyntaxKind["POST_CONDITION"] = 8] = "POST_CONDITION";
+    SyntaxKind[SyntaxKind["QUIT_STATEMENT"] = 9] = "QUIT_STATEMENT";
+    SyntaxKind[SyntaxKind["RETURN_STATEMENT"] = 10] = "RETURN_STATEMENT";
+    SyntaxKind[SyntaxKind["SET_STATEMENT"] = 11] = "SET_STATEMENT";
+    SyntaxKind[SyntaxKind["MULTIPLE_VARIABLE_SET"] = 12] = "MULTIPLE_VARIABLE_SET";
+    SyntaxKind[SyntaxKind["STRING_LITERAL"] = 13] = "STRING_LITERAL";
+    SyntaxKind[SyntaxKind["WHILE_STATEMENT"] = 14] = "WHILE_STATEMENT";
+    SyntaxKind[SyntaxKind["TYPE_STATEMENT"] = 15] = "TYPE_STATEMENT";
+    SyntaxKind[SyntaxKind["VARIABLE_DECLARATION"] = 16] = "VARIABLE_DECLARATION";
+    SyntaxKind[SyntaxKind["TYPE_IDENTIFIER"] = 17] = "TYPE_IDENTIFIER";
+})(SyntaxKind || (SyntaxKind = {}));
+var OPERATOR_VALUE;
+(function (OPERATOR_VALUE) {
+    OPERATOR_VALUE["AND_LITERAL"] = "and";
+    OPERATOR_VALUE["APOSTROPHE"] = "'";
+    OPERATOR_VALUE["AT"] = "@";
+    OPERATOR_VALUE["BACK_SLASH"] = "\\";
+    OPERATOR_VALUE["CARROT"] = "^";
+    OPERATOR_VALUE["COLON"] = ":";
+    OPERATOR_VALUE["DOLLAR"] = "$";
+    OPERATOR_VALUE["DOT"] = ".";
+    OPERATOR_VALUE["EQUAL"] = "=";
+    OPERATOR_VALUE["EXCLAMATION"] = "!";
+    OPERATOR_VALUE["GREATER_THAN"] = ">";
+    OPERATOR_VALUE["HASH"] = "#";
+    OPERATOR_VALUE["LEFT_BRACKET"] = "[";
+    OPERATOR_VALUE["LESS_THAN"] = "<";
+    OPERATOR_VALUE["MINUS"] = "-";
+    OPERATOR_VALUE["NOT_LITERAL"] = "not";
+    OPERATOR_VALUE["OR_LITERAL"] = "or";
+    OPERATOR_VALUE["PLUS"] = "+";
+    OPERATOR_VALUE["QUESTION_MARK"] = "?";
+    OPERATOR_VALUE["RIGHT_BRACKET"] = "]";
+    OPERATOR_VALUE["SLASH"] = "/";
+    OPERATOR_VALUE["STAR"] = "*";
+    OPERATOR_VALUE["UNDERSCORE"] = "_";
+    OPERATOR_VALUE["RET"] = "ret";
+})(OPERATOR_VALUE || (OPERATOR_VALUE = {}));
+var STORAGE_MODIFIERS;
+(function (STORAGE_MODIFIERS) {
+    STORAGE_MODIFIERS["STATIC"] = "static";
+    STORAGE_MODIFIERS["NEW"] = "new";
+    STORAGE_MODIFIERS["LITERAL"] = "literal";
+})(STORAGE_MODIFIERS || (STORAGE_MODIFIERS = {}));
+var ACCESS_MODIFIERS;
+(function (ACCESS_MODIFIERS) {
+    ACCESS_MODIFIERS["PUBLIC"] = "public";
+    ACCESS_MODIFIERS["PRIVATE"] = "private";
+})(ACCESS_MODIFIERS || (ACCESS_MODIFIERS = {}));
+var STATEMENT_KEYWORD;
+(function (STATEMENT_KEYWORD) {
+    STATEMENT_KEYWORD["DO"] = "do";
+    STATEMENT_KEYWORD["SET"] = "set";
+    STATEMENT_KEYWORD["IF"] = "if";
+    STATEMENT_KEYWORD["CATCH"] = "catch";
+    STATEMENT_KEYWORD["FOR"] = "for";
+    STATEMENT_KEYWORD["QUIT"] = "quit";
+    STATEMENT_KEYWORD["RETURN"] = "return";
+    STATEMENT_KEYWORD["WHILE"] = "while";
+    STATEMENT_KEYWORD["TYPE"] = "type";
+})(STATEMENT_KEYWORD || (STATEMENT_KEYWORD = {}));
+const UNARY_OPERATORS = [
+    { value: OPERATOR_VALUE.APOSTROPHE },
+    { value: OPERATOR_VALUE.AT },
+    { value: OPERATOR_VALUE.CARROT },
+    { value: OPERATOR_VALUE.DOLLAR, appendable: true },
+    { value: OPERATOR_VALUE.DOT },
+    { value: OPERATOR_VALUE.MINUS },
+    { value: OPERATOR_VALUE.NOT_LITERAL },
+    { value: OPERATOR_VALUE.PLUS },
+    { value: OPERATOR_VALUE.RIGHT_BRACKET },
+    { value: OPERATOR_VALUE.RET },
+];
+const BINARY_OPERATORS = [
+    { value: OPERATOR_VALUE.AND_LITERAL },
+    { value: OPERATOR_VALUE.APOSTROPHE, appendable: true },
+    { value: OPERATOR_VALUE.AT },
+    { value: OPERATOR_VALUE.BACK_SLASH },
+    { value: OPERATOR_VALUE.CARROT },
+    { value: OPERATOR_VALUE.DOT },
+    { value: OPERATOR_VALUE.EQUAL },
+    { value: OPERATOR_VALUE.EXCLAMATION },
+    { value: OPERATOR_VALUE.GREATER_THAN, appendable: true },
+    { value: OPERATOR_VALUE.HASH },
+    { value: OPERATOR_VALUE.LEFT_BRACKET },
+    { value: OPERATOR_VALUE.LESS_THAN, appendable: true },
+    { value: OPERATOR_VALUE.MINUS },
+    { value: OPERATOR_VALUE.NOT_LITERAL, appendable: true },
+    { value: OPERATOR_VALUE.OR_LITERAL },
+    { value: OPERATOR_VALUE.PLUS },
+    { value: OPERATOR_VALUE.QUESTION_MARK },
+    { value: OPERATOR_VALUE.SLASH },
+    { value: OPERATOR_VALUE.STAR },
+    { value: OPERATOR_VALUE.UNDERSCORE },
+];
+export class StatementParser {
+    tokenizer;
+    tokens = [];
+    previousToken;
+    activeToken;
+    constructor(arg) {
+        if (typeof arg === "string") {
+            this.tokenizer = getTokens(arg);
+        }
+        else if (Array.isArray(arg)) {
+            this.tokenizer = arg[Symbol.iterator]();
+        }
+        else {
+            this.tokenizer = arg;
+        }
+        this.next(); // should I?
+    }
+    parseLine() {
+        if (!this.activeToken)
+            return [];
+        const statements = [];
+        do {
+            if (this.activeToken.isNewLine())
+                break;
+            if (this.activeToken.isAlphanumeric()) {
+                const statement = this.parseStatement();
+                if (!statement) {
+                    this.next();
+                    continue;
+                }
+                statements.push(statement);
+            }
+            else if (this.activeToken.isWhiteSpace())
+                this.next(true);
+            else
+                break;
+        } while (this.activeToken);
+        return statements;
+    }
+    parseStatement() {
+        if (!this.activeToken)
+            return null;
+        if (!this.activeToken.isAlphanumeric())
+            return null;
+        const action = this.activeToken;
+        let loadFunction;
+        let kind;
+        const loadSingleExpression = () => {
+            if (!this.next(true))
+                return { action, kind, expressions: [] };
+            const expression = loadFunction();
+            const expressions = expression ? [expression] : [];
+            return { kind, action, expressions };
+        };
+        const loadCommaSeparatedExpressions = () => {
+            if (!this.next(true))
+                return { action, kind, expressions: [] };
+            const expressions = this.loadCommaSeparated(loadFunction);
+            return { kind, action, expressions };
+        };
+        switch (action.value) {
+            case STATEMENT_KEYWORD.DO:
+                loadFunction = () => this.parseExpression();
+                kind = SyntaxKind.DO_STATEMENT;
+                return loadCommaSeparatedExpressions();
+            case STATEMENT_KEYWORD.SET:
+                loadFunction = () => this.parseSetExpression();
+                kind = SyntaxKind.SET_STATEMENT;
+                return loadCommaSeparatedExpressions();
+            case STATEMENT_KEYWORD.IF:
+                loadFunction = () => this.parseExpression();
+                kind = SyntaxKind.IF_STATEMENT;
+                return loadCommaSeparatedExpressions();
+            case STATEMENT_KEYWORD.CATCH:
+                loadFunction = () => this.parseExpression();
+                kind = SyntaxKind.CATCH_STATEMENT;
+                return loadCommaSeparatedExpressions();
+            case STATEMENT_KEYWORD.FOR:
+                return this.parseForStatement();
+            case STATEMENT_KEYWORD.QUIT:
+                loadFunction = () => this.parseExpression();
+                kind = SyntaxKind.QUIT_STATEMENT;
+                return loadCommaSeparatedExpressions();
+            case STATEMENT_KEYWORD.RETURN:
+                loadFunction = () => this.parseExpression();
+                kind = SyntaxKind.RETURN_STATEMENT;
+                return loadSingleExpression();
+            case STATEMENT_KEYWORD.WHILE:
+                loadFunction = () => this.parseExpression();
+                kind = SyntaxKind.WHILE_STATEMENT;
+                return loadSingleExpression();
+            case STATEMENT_KEYWORD.TYPE:
+                return this.parseTypeStatement();
+            default:
+                return null;
+        }
+    }
+    parseTypeStatement() {
+        const action = this.activeToken;
+        this.next(true);
+        let staticToken;
+        let newToken;
+        let publicToken;
+        let literalToken;
+        const getKeyWordToken = (token) => {
+            switch (token.value) {
+                case ACCESS_MODIFIERS.PUBLIC:
+                    publicToken = token;
+                    return true;
+                case STORAGE_MODIFIERS.LITERAL:
+                    literalToken = token;
+                    return true;
+                case STORAGE_MODIFIERS.NEW:
+                    newToken = token;
+                    return true;
+                case STORAGE_MODIFIERS.STATIC:
+                    staticToken = token;
+                    return true;
+                default:
+                    return false;
+            }
+        };
+        const parseTypeAssignments = () => {
+            if (!this.activeToken || !this.activeToken.isAlphanumeric()) {
+                if (literalToken || newToken || publicToken || staticToken) {
+                    const emptyDeclaration = {
+                        id: undefined,
+                        kind: SyntaxKind.VARIABLE_DECLARATION,
+                        literalToken: undefined,
+                        newToken,
+                        publicToken,
+                        staticToken,
+                        type: undefined,
+                    };
+                    return [emptyDeclaration];
+                }
+                return [];
+            }
+            const type = {
+                id: this.activeToken,
+                kind: SyntaxKind.TYPE_IDENTIFIER
+            };
+            if (!this.next(true) || staticToken) {
+                const declaration = {
+                    id: undefined,
+                    kind: SyntaxKind.VARIABLE_DECLARATION,
+                    literalToken,
+                    newToken,
+                    publicToken,
+                    staticToken,
+                    type,
+                };
+                return [declaration];
+            }
+            const assignments = this.loadCommaSeparated(() => {
+                return this.parseAssignment(() => {
+                    // why not parseIdentifier
+                    const variable = this.parseValue();
+                    return {
+                        args: variable.args,
+                        id: variable.id,
+                        kind: SyntaxKind.VARIABLE_DECLARATION,
+                        literalToken,
+                        newToken,
+                        publicToken,
+                        staticToken,
+                        type,
+                    };
+                });
+            });
+            assignments.forEach(expression => {
+                forEachChild(expression, node => {
+                    if (!node)
+                        return null;
+                    if (node.kind === SyntaxKind.VARIABLE_DECLARATION) {
+                        const declaration = node;
+                        if (declaration.args) {
+                            declaration.args = declaration.args
+                                .map((arg) => {
+                                if (!arg)
+                                    return null;
+                                arg.kind =
+                                    SyntaxKind.TYPE_IDENTIFIER;
+                                return arg;
+                            });
+                        }
+                    }
+                    return true;
+                });
+            });
+            return assignments;
+        };
+        while (this.activeToken && getKeyWordToken(this.activeToken)) {
+            if (!this.next(true))
+                break;
+        }
+        const expressions = parseTypeAssignments();
+        return {
+            action,
+            expressions,
+            kind: SyntaxKind.TYPE_STATEMENT,
+        };
+    }
+    parseAssignment(getLeft) {
+        const left = getLeft();
+        let rootNode = left;
+        if (this.activeToken && this.activeToken.isEqualSign()) {
+            const equalSign = this.activeToken;
+            this.next(true);
+            const expression = this.parseExpression();
+            rootNode = { operator: [equalSign], kind: SyntaxKind.ASSIGNMENT };
+            rootNode.left = left;
+            rootNode.right = expression;
+        }
+        return rootNode;
+    }
+    parseForStatement() {
+        if (!this.activeToken)
+            return null;
+        const action = this.activeToken;
+        const forStatement = {
+            action,
+            kind: SyntaxKind.FOR_STATEMENT,
+            expressions: []
+        };
+        if (!this.next())
+            return forStatement; // consume for
+        if (!this.next())
+            return forStatement; // consume first space
+        const spaceOrExpression = this.activeToken;
+        if (spaceOrExpression.isSpace()) {
+            this.next();
+            return forStatement; // argument less for
+        }
+        const expression = this.parseExpression();
+        if (expression)
+            forStatement.expressions.push(expression);
+        return forStatement;
+    }
+    parseSetExpression() {
+        if (!this.activeToken)
+            return null;
+        const postCondition = this.parsePostCondition();
+        const assignment = this.parseAssignment(() => {
+            const setVariables = this.parseSetVariables();
+            if (this.activeToken && this.activeToken.isWhiteSpace())
+                this.next(true);
+            if (postCondition && !setVariables) {
+                postCondition.expression = setVariables;
+                return postCondition;
+            }
+            return setVariables;
+        });
+        if (assignment && postCondition) {
+            postCondition.expression = assignment;
+            return postCondition;
+        }
+        return assignment;
+    }
+    parsePostCondition() {
+        if (!this.activeToken)
+            return null;
+        if (this.activeToken.isColon()) {
+            const colon = this.activeToken;
+            const postCondition = {
+                kind: SyntaxKind.POST_CONDITION,
+                colon
+            };
+            this.next(true);
+            const condition = this.parseExpression();
+            if (!condition)
+                return postCondition;
+            postCondition.condition = condition;
+            return postCondition;
+        }
+        return null;
+    }
+    parseSetVariables() {
+        if (!this.activeToken)
+            return null;
+        if (this.activeToken.isOpenParen()) {
+            this.next(true);
+            const variables = this.loadCommaSeparated(() => this.parseExpression());
+            if (this.activeToken && this.activeToken.isCloseParen())
+                this.next(true);
+            return { variables, kind: SyntaxKind.MULTIPLE_VARIABLE_SET };
+        }
+        else {
+            return this.parseExpression(true);
+        }
+    }
+    parseExpression(ignoreEquals, includeRet) {
+        const postCondition = this.parsePostCondition();
+        let rootNode = this.parseValue(undefined, includeRet);
+        if (!rootNode) {
+            if (postCondition)
+                return postCondition;
+            else
+                return null;
+        }
+        if (this.activeToken && this.activeToken.isEqualSign() && ignoreEquals) {
+            return rootNode;
+        }
+        rootNode = this.parseOperatorSeparatedValues(rootNode, ignoreEquals);
+        if (!rootNode)
+            return null;
+        rootNode = this.parseColonSeparatedValues(rootNode);
+        if (postCondition) {
+            postCondition.expression = rootNode;
+            rootNode = postCondition;
+        }
+        return rootNode;
+    }
+    parseColonSeparatedValues(rootNode) {
+        while (this.activeToken && this.activeToken.isColon()) {
+            const colonToken = this.activeToken;
+            this.next(true);
+            rootNode = {
+                kind: SyntaxKind.BINARY_OPERATOR,
+                left: rootNode,
+                operator: [colonToken],
+                right: this.parseValue(),
+            };
+        }
+        return rootNode;
+    }
+    parseOperatorSeparatedValues(rootNode, ignoreEquals) {
+        while (this.activeToken && getBinaryOperator(this.activeToken.value)) {
+            if (this.activeToken.isEqualSign() && ignoreEquals)
+                break;
+            const operator = this.parseBinaryOperator();
+            if (!operator)
+                return null;
+            operator.left = rootNode;
+            operator.right = this.parseValue();
+            rootNode = operator;
+        }
+        return rootNode;
+    }
+    parseBinaryOperator() {
+        if (!this.activeToken)
+            return null;
+        const binaryOperator = {
+            kind: SyntaxKind.BINARY_OPERATOR,
+            operator: [this.activeToken],
+        };
+        if (!this.next(true))
+            return binaryOperator;
+        let operator;
+        do {
+            operator = getBinaryOperator(this.activeToken.value);
+            if (!operator)
+                break;
+            if (operator) {
+                const not = operator.value === OPERATOR_VALUE.NOT_LITERAL
+                    || operator.value === OPERATOR_VALUE.APOSTROPHE;
+                if (not && binaryOperator.operator.length)
+                    break;
+            }
+            binaryOperator.operator.push(this.activeToken);
+            this.next(true);
+        } while (operator && operator.appendable);
+        return binaryOperator;
+    }
+    parseUnaryOperator(includeRet) {
+        if (!this.activeToken)
+            return [];
+        const leftOperator = [];
+        let unaryOperator = getUnaryOperator(this.activeToken.value, includeRet);
+        if (unaryOperator) {
+            leftOperator.push(this.activeToken);
+            this.next(true);
+            while (unaryOperator && unaryOperator.appendable) {
+                unaryOperator = getUnaryOperator(this.activeToken.value);
+                if (unaryOperator) {
+                    leftOperator.push(this.activeToken);
+                    this.next(true);
+                }
+            }
+        }
+        return leftOperator;
+    }
+    parseValue(tree, includeRet) {
+        let value;
+        if (!this.activeToken || this.activeToken.isWhiteSpace()) {
+            if (tree)
+                return tree;
+            else
+                return null;
+        }
+        const unaryOperator = this.parseUnaryOperator(includeRet);
+        if (!this.activeToken) {
+            return {
+                id: new Token(-1 /* Type.Undefined */, "", { character: 0, line: 0 }),
+                kind: SyntaxKind.IDENTIFIER,
+                unaryOperator,
+            };
+        }
+        if (this.activeToken.type === 1 /* Type.Alphanumeric */) {
+            value = this.parseIdentifier();
+            if (!value)
+                return null;
+            if (unaryOperator.length)
+                value.unaryOperator = unaryOperator;
+        }
+        else if (this.activeToken.type === 9 /* Type.DoubleQuotes */) {
+            value = this.parseStringLiteral();
+            if (!value)
+                return null;
+            if (unaryOperator.length)
+                value.unaryOperator = unaryOperator;
+        }
+        else if (this.activeToken.type === 2 /* Type.Numeric */) {
+            value = {
+                id: this.activeToken,
+                kind: SyntaxKind.NUMERIC_LITERAL
+            };
+            if (unaryOperator.length)
+                value.unaryOperator = unaryOperator;
+            this.next(true);
+        }
+        else if (this.activeToken.type === 40 /* Type.OpenParen */) {
+            this.next(true);
+            value = this.parseExpression();
+            this.next(true);
+        }
+        if (tree && value) {
+            tree.right = value;
+            value = tree;
+        }
+        if (this.activeToken && (this.activeToken.type === 46 /* Type.Period */ ||
+            this.activeToken.type === 94 /* Type.Caret */)) {
+            const operator = {
+                kind: SyntaxKind.BINARY_OPERATOR,
+                left: value,
+                operator: [this.activeToken],
+            };
+            this.next();
+            return this.parseValue(operator);
+        }
+        if (value && this.activeToken && this.activeToken.isWhiteSpace())
+            this.next(true);
+        return value;
+    }
+    parseIdentifier() {
+        if (!this.activeToken)
+            return null;
+        const id = this.activeToken;
+        if (this.next() && this.activeToken.isOpenParen()) {
+            const openParen = this.activeToken;
+            if (this.next(true)) {
+                const args = this.parseArgs();
+                if (this.activeToken.isCloseParen()) {
+                    const closeParen = this.activeToken;
+                    this.next();
+                    return {
+                        id,
+                        kind: SyntaxKind.IDENTIFIER,
+                        args,
+                        openParen,
+                        closeParen
+                    };
+                }
+            }
+        }
+        return { id, kind: SyntaxKind.IDENTIFIER };
+    }
+    parseStringLiteral() {
+        if (!this.activeToken)
+            return null;
+        const openQuote = this.activeToken;
+        this.next();
+        const id = this.activeToken;
+        if (!id || !this.next())
+            return null;
+        if (this.activeToken.isDoubleQuotes()) {
+            const closeQuote = this.activeToken;
+            this.next(true);
+            return { id, kind: SyntaxKind.STRING_LITERAL, openQuote, closeQuote };
+        }
+        return null;
+    }
+    parseArgs() {
+        return this.loadCommaSeparated(() => this.parseExpression(false, true));
+    }
+    loadCommaSeparated(getArg) {
+        const args = [];
+        do {
+            if (!this.activeToken)
+                break;
+            if (this.activeToken.isWhiteSpace()) {
+                if (!this.next(true))
+                    break;
+            }
+            if (this.activeToken.isComma()) {
+                args.push(undefined); // desired behavior?
+                continue;
+            }
+            const arg = getArg();
+            if (arg && !Array.isArray(arg))
+                args.push(arg);
+            else if (arg)
+                args.push(...arg);
+            else if (!arg && args.length > 0)
+                args.push(undefined);
+            else
+                break;
+            if (!this.activeToken)
+                break;
+        } while (this.activeToken.isComma() && this.next(true));
+        return args;
+    }
+    next(skipSpaceOrTab) {
+        if (this.activeToken)
+            this.previousToken = this.activeToken;
+        do {
+            this.activeToken = this.tokenizer.next().value;
+            if (this.activeToken)
+                this.tokens.push(this.activeToken);
+        } while (skipSpaceOrTab &&
+            this.activeToken &&
+            (this.activeToken.isSpace() || this.activeToken.isTab()));
+        return this.activeToken !== undefined;
+    }
+}
+function getBinaryOperator(tokenValue) {
+    return BINARY_OPERATORS.find(o => o.value === tokenValue) || null;
+}
+function getUnaryOperator(tokenValue, includeRet) {
+    const operator = UNARY_OPERATORS.find(o => o.value === tokenValue);
+    if (!operator)
+        return null;
+    if (operator.value === OPERATOR_VALUE.RET && !includeRet)
+        return null;
+    return operator;
+}
+export function forEachChild(node, f) {
+    let goDeeper = false;
+    if (!node)
+        return;
+    switch (node.kind) {
+        case SyntaxKind.DO_STATEMENT:
+        case SyntaxKind.IF_STATEMENT:
+        case SyntaxKind.QUIT_STATEMENT:
+        case SyntaxKind.RETURN_STATEMENT:
+        case SyntaxKind.SET_STATEMENT:
+        case SyntaxKind.WHILE_STATEMENT:
+        case SyntaxKind.FOR_STATEMENT:
+        case SyntaxKind.CATCH_STATEMENT:
+        case SyntaxKind.TYPE_STATEMENT:
+            goDeeper = f(node);
+            if (!goDeeper)
+                return;
+            const statement = node;
+            statement.expressions.forEach(expression => {
+                if (!expression)
+                    return;
+                forEachChild(expression, f);
+            });
+            break;
+        case SyntaxKind.ASSIGNMENT:
+        case SyntaxKind.BINARY_OPERATOR:
+            goDeeper = f(node);
+            if (!goDeeper)
+                return;
+            const assignment = node;
+            const left = assignment.left;
+            if (left && left.kind === SyntaxKind.MULTIPLE_VARIABLE_SET) {
+                left.variables.forEach(n => {
+                    forEachChild(n, f);
+                });
+            }
+            else if (left) {
+                forEachChild(left, f);
+            }
+            const right = assignment.right;
+            if (right) {
+                forEachChild(right, f);
+            }
+            break;
+        case SyntaxKind.POST_CONDITION:
+            goDeeper = f(node);
+            if (!goDeeper)
+                return;
+            const postCondition = node;
+            if (postCondition.condition)
+                forEachChild(postCondition.condition, f);
+            if (postCondition.expression) {
+                const expression = postCondition.expression;
+                if (Array.isArray(expression)) {
+                    // TODO: (Mischa Reitsma) This should be fixed in the types. Seems like the MultiSet is part of the Expression union, which contains expressions, so this is either a bug or some code is ignoring the types or interfaces
+                    expression.forEach(n => {
+                        forEachChild(n, f);
+                    });
+                }
+                else if (expression) {
+                    forEachChild(expression, f);
+                }
+            }
+            break;
+        case SyntaxKind.IDENTIFIER:
+        case SyntaxKind.TYPE_IDENTIFIER:
+            goDeeper = f(node);
+            if (!goDeeper)
+                return;
+            const identifier = node;
+            if (identifier.args)
+                identifier.args.forEach(arg => forEachChild(arg, f));
+            break;
+        case SyntaxKind.VARIABLE_DECLARATION:
+            goDeeper = f(node);
+            if (!goDeeper)
+                return;
+            const declaration = node;
+            if (declaration.args)
+                declaration.args.forEach(arg => forEachChild(arg, f));
+            f(declaration.type);
+            break;
+        case SyntaxKind.NUMERIC_LITERAL:
+        case SyntaxKind.STRING_LITERAL:
+            f(node);
+            break;
+        default:
+            break;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"statementParser.js","sourceRoot":"","sources":["../src/statementParser.ts"],"names":[],"mappings":"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"}