xmlui 0.4.0

package/dist/scripts/src/parsers/xmlui-parser/parser.js

@@ -0,0 +1,476 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createXmlUiParser = createXmlUiParser;
+exports.parseXmlUiMarkup = parseXmlUiMarkup;
+const CharacterCodes_1 = require("./CharacterCodes");
+const scanner_1 = require("./scanner");
+const syntax_kind_1 = require("./syntax-kind");
+const utils_1 = require("./utils");
+const diagnostics_1 = require("./diagnostics");
+const MakeErr = {
+    uppercaseAttr: function (attrName) {
+        return {
+            category: diagnostics_1.DiagnosticCategory.Error,
+            code: diagnostics_1.ErrCodes.uppercaseAttr,
+            message: `Attribute name '${attrName}' cannot start with an uppercase letter.`,
+        };
+    },
+    duplAttr: function (attrName) {
+        return {
+            category: diagnostics_1.DiagnosticCategory.Error,
+            code: diagnostics_1.ErrCodes.duplAttr,
+            message: `Duplicated attribute: '${attrName}'.`,
+        };
+    },
+    tagNameMismatch: function (openTagName, closeTagName) {
+        return {
+            category: diagnostics_1.DiagnosticCategory.Error,
+            code: diagnostics_1.ErrCodes.tagNameMismatch,
+            message: `Opening and closing tag names should match. Opening tag has a name '${openTagName}', but the closing tag name is '${closeTagName}'.`,
+        };
+    },
+    invalidChar: function (char) {
+        return {
+            category: diagnostics_1.DiagnosticCategory.Error,
+            code: diagnostics_1.ErrCodes.invalidChar,
+            message: `Invalid character '${char}'.`,
+        };
+    },
+};
+const firstSetTagLike = [syntax_kind_1.SyntaxKind.CData, syntax_kind_1.SyntaxKind.Script, syntax_kind_1.SyntaxKind.OpenNodeStart];
+// todo
+// const firstSetContent = firstSetTagLike.concat ([
+//   SyntaxKind.Identifier,
+//   SyntaxKind.StringLiteral,
+// ])
+function createXmlUiParser(source) {
+    return {
+        parse: () => parseXmlUiMarkup(source),
+        getText: (n, ignoreTrivia = true) => source.substring(ignoreTrivia ? n.pos : n.start, n.end),
+    };
+}
+function parseXmlUiMarkup(text) {
+    const errors = [];
+    const parents = [];
+    let peekedToken;
+    let node = { children: [] };
+    let errFromScanner = undefined;
+    const onScannerErr = function (message, length) {
+        errFromScanner = {
+            message,
+            prefixLength: length,
+        };
+    };
+    const scanner = (0, scanner_1.createScanner)(false, text, onScannerErr);
+    function getText(n, ignoreTrivia = true) {
+        return text.substring(ignoreTrivia ? n.pos : n.start, n.end);
+    }
+    function parseContent() {
+        startNode();
+        parseSource();
+        if (node.children && node.children.length > 0) {
+            completeNode(syntax_kind_1.SyntaxKind.ContentListNode);
+        }
+        else {
+            abandonNode();
+        }
+    }
+    function parseSource() {
+        while (true) {
+            const token = peekInContent();
+            switch (token.kind) {
+                case syntax_kind_1.SyntaxKind.TextNode:
+                case syntax_kind_1.SyntaxKind.StringLiteral:
+                    bump(token.kind);
+                    break;
+                case syntax_kind_1.SyntaxKind.CloseNodeStart:
+                    return;
+                case syntax_kind_1.SyntaxKind.EndOfFileToken:
+                    bump(syntax_kind_1.SyntaxKind.EndOfFileToken);
+                    return;
+                default:
+                    parseTagLike();
+                    break;
+            }
+        }
+    }
+    function parseTagLike() {
+        if (!eat(syntax_kind_1.SyntaxKind.CData) && !eat(syntax_kind_1.SyntaxKind.Script)) {
+            if (at(syntax_kind_1.SyntaxKind.OpenNodeStart)) {
+                parseTag();
+            }
+            else {
+                errorAndBump(diagnostics_1.Diag_OpenNodeStart_Token_Expected);
+            }
+        }
+    }
+    function parseTag() {
+        startNode();
+        bump(syntax_kind_1.SyntaxKind.OpenNodeStart);
+        let openTagName = undefined;
+        if (at(syntax_kind_1.SyntaxKind.Identifier)) {
+            openTagName = parseTagName();
+        }
+        else {
+            error(diagnostics_1.Diag_Tag_Identifier_Expected);
+        }
+        parseAttrList();
+        if (eat(syntax_kind_1.SyntaxKind.NodeClose)) {
+            completeNode(syntax_kind_1.SyntaxKind.ElementNode);
+            return;
+        }
+        else if (eat(syntax_kind_1.SyntaxKind.NodeEnd)) {
+            parseContent();
+            if (eat(syntax_kind_1.SyntaxKind.CloseNodeStart)) {
+                if (at(syntax_kind_1.SyntaxKind.Identifier)) {
+                    const closeTagName = parseTagName();
+                    const namesMismatch = openTagName !== undefined && !(0, utils_1.tagNameNodesMatch)(openTagName, closeTagName, getText);
+                    if (namesMismatch) {
+                        error(MakeErr.tagNameMismatch(getText(openTagName), getText(closeTagName)));
+                    }
+                }
+                else {
+                    errRecover(diagnostics_1.Diag_Tag_Identifier_Expected, [syntax_kind_1.SyntaxKind.NodeEnd]);
+                }
+                if (!eat(syntax_kind_1.SyntaxKind.NodeEnd)) {
+                    error(diagnostics_1.Diag_End_Token_Expected);
+                }
+            }
+            else {
+                error(diagnostics_1.Diag_CloseNodeStart_Token_Expected);
+            }
+            completeNode(syntax_kind_1.SyntaxKind.ElementNode);
+            return;
+        }
+        else {
+            error(diagnostics_1.Diag_End_Or_Close_Token_Expected);
+        }
+    }
+    function parseTagName() {
+        startNode();
+        bump(syntax_kind_1.SyntaxKind.Identifier);
+        if (eat(syntax_kind_1.SyntaxKind.Colon)) {
+            if (!eat(syntax_kind_1.SyntaxKind.Identifier)) {
+                //TODO: error, possibly check for Eq and report that a name is missing before the attributes. Should parse as attribute then.
+            }
+        }
+        return completeNode(syntax_kind_1.SyntaxKind.TagNameNode);
+    }
+    function parseAttrList() {
+        startNode();
+        const attrNames = [];
+        while (!atAnyOf([syntax_kind_1.SyntaxKind.EndOfFileToken, syntax_kind_1.SyntaxKind.NodeEnd, syntax_kind_1.SyntaxKind.NodeClose])) {
+            if (at(syntax_kind_1.SyntaxKind.Identifier)) {
+                parseAttr(attrNames);
+            }
+            else {
+                const atTagLike = errRecover(diagnostics_1.Diag_Attr_Identifier_Expected, firstSetTagLike);
+                if (atTagLike) {
+                    parseTagLike();
+                }
+            }
+        }
+        if (node.children.length === 0) {
+            abandonNode();
+        }
+        else {
+            completeNode(syntax_kind_1.SyntaxKind.AttributeListNode);
+        }
+    }
+    function parseAttr(attrNames) {
+        //todo: make this recovery set actualy true (like implement handling cdata ,...)
+        const attrListFollow = [
+            // FOLLOW(AttrList) when a Tag is correct
+            syntax_kind_1.SyntaxKind.NodeClose,
+            syntax_kind_1.SyntaxKind.NodeEnd,
+            // FOLLOW(AttrList) when a Tag contains incorrect, but still parsed tokens for resilience
+            syntax_kind_1.SyntaxKind.CData,
+            // todo
+            // SyntaxKind.ScriptLiteral,
+            syntax_kind_1.SyntaxKind.OpenNodeStart,
+        ];
+        const attrFollow = attrListFollow.concat(syntax_kind_1.SyntaxKind.Identifier);
+        const attrIdent = peek();
+        startNode();
+        bump(syntax_kind_1.SyntaxKind.Identifier);
+        if (eat(syntax_kind_1.SyntaxKind.Equal)) {
+            if (eat(syntax_kind_1.SyntaxKind.StringLiteral)) {
+                const attrName = getText(attrIdent);
+                if (attrNames.includes(attrName)) {
+                    errorAt(MakeErr.duplAttr(attrName), attrIdent.pos, attrIdent.end);
+                }
+                else if (attrName[0] >= "A" && attrName[0] <= "Z") {
+                    errorAt(MakeErr.uppercaseAttr(attrName), attrIdent.pos, attrIdent.end);
+                }
+                else {
+                    attrNames.push(attrName);
+                }
+            }
+            else {
+                errRecover(diagnostics_1.Diag_Attr_Value_Expected, attrFollow);
+            }
+        }
+        else {
+            errRecover(diagnostics_1.Diag_Eq_Token_Expected, attrFollow);
+        }
+        completeNode(syntax_kind_1.SyntaxKind.AttributeNode);
+    }
+    function at(kindToCheck) {
+        return peek().kind === kindToCheck;
+    }
+    function eat(kind) {
+        const kindMatched = at(kind);
+        if (kindMatched) {
+            bumpAny();
+        }
+        return kindMatched;
+    }
+    function atAnyOf(kinds) {
+        return kinds.includes(peek().kind);
+    }
+    /**
+     * @param recoveryTokens the [FollowSet](https://www.geeksforgeeks.org/follow-set-in-syntax-analysis/) of the parsed InnerNode
+     * @returns true if the current token is in the recovery set, otherwise false
+     * */
+    function errRecover(errCodeAndMsg, recoveryTokens) {
+        if (atAnyOf(recoveryTokens) || at(syntax_kind_1.SyntaxKind.EndOfFileToken)) {
+            error(errCodeAndMsg);
+            return true;
+        }
+        startNode();
+        error(errCodeAndMsg);
+        bumpAny();
+        completeNode(syntax_kind_1.SyntaxKind.ErrorNode);
+        return false;
+    }
+    function error({ code, message, category }) {
+        const { pos, end } = peek();
+        errors.push({
+            category,
+            code,
+            message,
+            pos,
+            end,
+        });
+    }
+    function errorAt({ code, message, category }, pos, end) {
+        errors.push({
+            category,
+            code,
+            message,
+            pos,
+            end,
+        });
+    }
+    function peek(inContent = false) {
+        if (peekedToken !== undefined) {
+            return peekedToken;
+        }
+        peekedToken = collectToken(inContent);
+        return peekedToken;
+    }
+    function peekInContent() {
+        var _a;
+        const token = peek(true);
+        if (token.kind === syntax_kind_1.SyntaxKind.EndOfFileToken ||
+            token.kind === syntax_kind_1.SyntaxKind.OpenNodeStart ||
+            token.kind === syntax_kind_1.SyntaxKind.Script ||
+            token.kind === syntax_kind_1.SyntaxKind.CData ||
+            token.kind === syntax_kind_1.SyntaxKind.CloseNodeStart) {
+            return token;
+        }
+        const trivia = token.triviaBefore;
+        const triviaLength = (_a = trivia === null || trivia === void 0 ? void 0 : trivia.length) !== null && _a !== void 0 ? _a : 0;
+        let i = 0;
+        let leadingComments = [];
+        let firstNonCommentTriviaIdx = -1;
+        for (; i < triviaLength; ++i) {
+            if (trivia[i].kind === syntax_kind_1.SyntaxKind.CommentTrivia) {
+                leadingComments.push(trivia[i]);
+            }
+            else {
+                firstNonCommentTriviaIdx = i;
+                break;
+            }
+        }
+        let secondCommentGroupStartIdx = -1;
+        for (; i < triviaLength; ++i) {
+            if (trivia[i].kind === syntax_kind_1.SyntaxKind.CommentTrivia) {
+                secondCommentGroupStartIdx = i;
+                break;
+            }
+        }
+        let parseAsStringLiteral = false;
+        if (token.kind === syntax_kind_1.SyntaxKind.StringLiteral) {
+            const beforeLookahead = token.end;
+            const nextToken = collectToken(true);
+            parseAsStringLiteral =
+                nextToken.kind === syntax_kind_1.SyntaxKind.CData ||
+                    nextToken.kind === syntax_kind_1.SyntaxKind.CloseNodeStart ||
+                    nextToken.kind === syntax_kind_1.SyntaxKind.Script ||
+                    nextToken.kind === syntax_kind_1.SyntaxKind.OpenNodeStart;
+            scanner.resetTokenState(beforeLookahead);
+        }
+        let pos;
+        if (parseAsStringLiteral) {
+            pos = token.pos;
+        }
+        else if (leadingComments.length > 0) {
+            pos = leadingComments[leadingComments.length - 1].end;
+        }
+        else if (firstNonCommentTriviaIdx !== -1) {
+            pos = trivia[firstNonCommentTriviaIdx].pos;
+        }
+        else {
+            pos = token.start;
+        }
+        let start = pos;
+        let triviaBefore = undefined;
+        if (leadingComments.length > 0) {
+            triviaBefore = leadingComments;
+            start = leadingComments[0].pos;
+        }
+        let kind = syntax_kind_1.SyntaxKind.TextNode;
+        let end = -1;
+        if (secondCommentGroupStartIdx !== -1) {
+            end = trivia[secondCommentGroupStartIdx].pos;
+            scanner.resetTokenState(end);
+        }
+        else if (parseAsStringLiteral) {
+            kind = syntax_kind_1.SyntaxKind.StringLiteral;
+            end = token.end;
+        }
+        else {
+            while (true) {
+                const nextChar = scanner.peekChar();
+                if (nextChar === null || nextChar === CharacterCodes_1.CharacterCodes.lessThan) {
+                    break;
+                }
+                scanner.scanChar();
+            }
+            end = scanner.getTokenEnd();
+        }
+        peekedToken = { kind, start, pos, end, triviaBefore };
+        return peekedToken;
+    }
+    /** Same as bumpAny, but with an assertion of the token that was bumped over.
+     * Makes the code more redundant, but also more defensive*/
+    function bump(kind) {
+        const token = bumpAny();
+        if (token.kind !== kind) {
+            throw new Error(`expected ${(0, syntax_kind_1.getSyntaxKindStrRepr)(kind)}, bumped a ${(0, syntax_kind_1.getSyntaxKindStrRepr)(token.kind)}`);
+        }
+    }
+    function bumpAny() {
+        if (peekedToken) {
+            node.children.push(peekedToken);
+            const bumpedToken = peekedToken;
+            peekedToken = undefined;
+            return bumpedToken;
+        }
+        const token = collectToken(false);
+        node.children.push(token);
+        return token;
+    }
+    /** start a new node. Any new tokens or nodes will be put into it's children list from that point. Each call to this should be paired with a [completeNode] */
+    function startNode() {
+        parents.push(node);
+        node = {
+            children: [],
+        };
+    }
+    function completeNode(type) {
+        const completedNode = createNode(type, node.children);
+        const parentNode = parents[parents.length - 1];
+        parentNode.children.push(completedNode);
+        node = parentNode;
+        parents.pop();
+        return completedNode;
+    }
+    function collectToken(inContent) {
+        let kind;
+        let triviaCollected = [];
+        let start = null;
+        while (true) {
+            kind = scanner.scan();
+            if (start === null) {
+                start = scanner.getTokenStart();
+            }
+            //handle error from scanner
+            if (errFromScanner !== undefined) {
+                let err;
+                if (errFromScanner.message.code === diagnostics_1.ErrCodes.invalidChar) {
+                    err = MakeErr.invalidChar(scanner.getText());
+                }
+                else {
+                    err = errFromScanner.message;
+                }
+                const pos = scanner.getTokenStart();
+                const token = {
+                    kind,
+                    start,
+                    pos,
+                    end: scanner.getTokenEnd(),
+                    triviaBefore: triviaCollected.length > 0 ? triviaCollected : undefined,
+                };
+                triviaCollected = [];
+                if (inContent && err.code === diagnostics_1.ErrCodes.invalidChar) {
+                    errFromScanner = undefined;
+                    return token;
+                }
+                const badPrefixEnd = pos + errFromScanner.prefixLength;
+                token.end = badPrefixEnd;
+                scanner.resetTokenState(badPrefixEnd);
+                startNode();
+                node.children.push(token);
+                errorAt(err, pos, badPrefixEnd);
+                completeNode(syntax_kind_1.SyntaxKind.ErrorNode);
+                errFromScanner = undefined;
+                return collectToken(inContent);
+            }
+            switch (kind) {
+                case syntax_kind_1.SyntaxKind.CommentTrivia:
+                case syntax_kind_1.SyntaxKind.NewLineTrivia:
+                case syntax_kind_1.SyntaxKind.WhitespaceTrivia:
+                    triviaCollected.push({
+                        kind,
+                        start,
+                        pos: scanner.getTokenStart(),
+                        end: scanner.getTokenEnd(),
+                    });
+                    break;
+                default:
+                    return {
+                        kind,
+                        start,
+                        pos: scanner.getTokenStart(),
+                        end: scanner.getTokenEnd(),
+                        triviaBefore: triviaCollected.length > 0 ? triviaCollected : undefined,
+                    };
+            }
+        }
+    }
+    function errorAndBump(errCodeAndMsg) {
+        errRecover(errCodeAndMsg, []);
+    }
+    function abandonNode() {
+        const parentNode = parents[parents.length - 1];
+        parentNode.children.push(...node.children);
+        node = parentNode;
+        parents.pop();
+    }
+    parseSource();
+    const completedNode = createNode(syntax_kind_1.SyntaxKind.ContentListNode, node.children);
+    return { node: completedNode, errors };
+}
+function createNode(kind, children) {
+    const firstChild = children[0];
+    const lastChild = children[children.length - 1];
+    return {
+        kind,
+        start: firstChild.start,
+        pos: firstChild.pos,
+        end: lastChild.end,
+        children,
+    };
+}