xmlui 0.9.50 → 0.9.52

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

@@ -7,42 +7,11 @@ 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,
-// ])
+const RECOVER_FILE = [syntax_kind_1.SyntaxKind.CData, syntax_kind_1.SyntaxKind.Script, syntax_kind_1.SyntaxKind.OpenNodeStart];
+const RECOVER_OPEN_TAG = [syntax_kind_1.SyntaxKind.OpenNodeStart, syntax_kind_1.SyntaxKind.NodeEnd, syntax_kind_1.SyntaxKind.NodeClose, syntax_kind_1.SyntaxKind.CloseNodeStart, syntax_kind_1.SyntaxKind.CData, syntax_kind_1.SyntaxKind.Script];
+const RECOVER_ATTR = [syntax_kind_1.SyntaxKind.Identifier, ...RECOVER_OPEN_TAG];
+const RECOVER_CONTENT_LIST = [syntax_kind_1.SyntaxKind.TextNode, syntax_kind_1.SyntaxKind.StringLiteral, syntax_kind_1.SyntaxKind.CData, syntax_kind_1.SyntaxKind.Script, syntax_kind_1.SyntaxKind.OpenNodeStart, syntax_kind_1.SyntaxKind.CloseNodeStart];
+const RECOVER_CLOSE_TAG = [syntax_kind_1.SyntaxKind.NodeEnd, syntax_kind_1.SyntaxKind.OpenNodeStart, syntax_kind_1.SyntaxKind.CloseNodeStart, syntax_kind_1.SyntaxKind.CData, syntax_kind_1.SyntaxKind.Script];
 function createXmlUiParser(source) {
     return {
         parse: () => parseXmlUiMarkup(source),
@@ -62,24 +31,52 @@ function parseXmlUiMarkup(text) {
         };
     };
     const scanner = (0, scanner_1.createScanner)(false, text, onScannerErr);
+    const fileContentListNode = parseFile();
+    return { node: fileContentListNode, errors };
     function getText(n, ignoreTrivia = true) {
         return text.substring(ignoreTrivia ? n.pos : n.start, n.end);
     }
-    function parseContent() {
+    function parseFile() {
+        while (true) {
+            const token = peekInContent();
+            switch (token.kind) {
+                case syntax_kind_1.SyntaxKind.EndOfFileToken:
+                    bumpAny();
+                    return createNode(syntax_kind_1.SyntaxKind.ContentListNode, node.children);
+                case syntax_kind_1.SyntaxKind.CData:
+                case syntax_kind_1.SyntaxKind.Script:
+                    bumpAny();
+                    break;
+                case syntax_kind_1.SyntaxKind.OpenNodeStart:
+                    parseOpeningTag();
+                    break;
+                default:
+                    const errNode = errNodeUntil(RECOVER_FILE);
+                    errorAt(diagnostics_1.DIAGS.expTagOpen, errNode.pos, errNode.end);
+                    break;
+            }
+        }
+    }
+    function parseContentList() {
         startNode();
         loop: while (true) {
             const token = peekInContent();
             switch (token.kind) {
                 case syntax_kind_1.SyntaxKind.TextNode:
                 case syntax_kind_1.SyntaxKind.StringLiteral:
-                    bump(token.kind);
+                case syntax_kind_1.SyntaxKind.CData:
+                case syntax_kind_1.SyntaxKind.Script:
+                    bumpAny();
+                    break;
+                case syntax_kind_1.SyntaxKind.OpenNodeStart:
+                    parseOpeningTag();
                     break;
                 case syntax_kind_1.SyntaxKind.CloseNodeStart:
-                    break loop;
                 case syntax_kind_1.SyntaxKind.EndOfFileToken:
                     break loop;
                 default:
-                    parseTagLike();
+                    const errNode = errNodeUntil(RECOVER_CONTENT_LIST);
+                    errorAt(diagnostics_1.DIAGS.expTagOpen, errNode.pos, errNode.end);
                     break;
             }
         }
@@ -90,45 +87,23 @@ function parseXmlUiMarkup(text) {
             abandonNode();
         }
     }
-    function parseSourceContent() {
-        while (true) {
-            const token = peekInContent();
-            switch (token.kind) {
-                case syntax_kind_1.SyntaxKind.EndOfFileToken:
-                    bumpAny();
-                    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() {
+    function parseOpeningTag() {
         startNode();
         bump(syntax_kind_1.SyntaxKind.OpenNodeStart);
-        let errInName = false;
-        let openTagName = undefined;
+        let errInName = true;
+        let openTagName = null;
         if (at(syntax_kind_1.SyntaxKind.Identifier)) {
-            openTagName = parseTagName();
+            const tagNameParseRes = parseOpeningTagName();
+            errInName = tagNameParseRes.errInName;
+            openTagName = tagNameParseRes.node;
         }
         else {
-            errInName = true;
-            const errNode = errNodeUntil([syntax_kind_1.SyntaxKind.OpenNodeStart, syntax_kind_1.SyntaxKind.NodeEnd, syntax_kind_1.SyntaxKind.NodeClose, syntax_kind_1.SyntaxKind.CloseNodeStart, syntax_kind_1.SyntaxKind.CData, syntax_kind_1.SyntaxKind.Script]);
+            const errNode = errNodeUntil(RECOVER_OPEN_TAG);
             if (errNode) {
-                errorAt(diagnostics_1.Diag_Tag_Identifier_Expected, errNode.pos, errNode.end);
+                errorAt(diagnostics_1.DIAGS.expTagName, errNode.pos, errNode.end);
             }
             else {
-                error(diagnostics_1.Diag_Tag_Identifier_Expected);
+                error(diagnostics_1.DIAGS.expTagName);
             }
         }
         if (!errInName) {
@@ -142,73 +117,48 @@ function parseXmlUiMarkup(text) {
             }
             case syntax_kind_1.SyntaxKind.NodeEnd: {
                 bumpAny();
-                parseContent();
-                parseClosingTag(openTagName);
+                parseContentList();
+                parseClosingTag(openTagName, errInName);
                 completeNode(syntax_kind_1.SyntaxKind.ElementNode);
                 return;
             }
-            case syntax_kind_1.SyntaxKind.OpenNodeStart:
-            case syntax_kind_1.SyntaxKind.Script:
-            case syntax_kind_1.SyntaxKind.CData: {
-                completeNode(syntax_kind_1.SyntaxKind.ElementNode);
-                error(diagnostics_1.Diag_End_Or_Close_Token_Expected);
-                return;
-            }
-            case syntax_kind_1.SyntaxKind.CloseNodeStart: {
-                error(diagnostics_1.Diag_End_Or_Close_Token_Expected);
-                parseClosingTag(openTagName);
+            default: {
                 completeNode(syntax_kind_1.SyntaxKind.ElementNode);
+                error(diagnostics_1.DIAGS.expEndOrClose);
                 return;
             }
-            default: {
-                error(diagnostics_1.Diag_End_Or_Close_Token_Expected);
-            }
-        }
-    }
-    function parseClosingTag(openTagName) {
-        if (eat(syntax_kind_1.SyntaxKind.CloseNodeStart)) {
-            if (at(syntax_kind_1.SyntaxKind.Identifier)) {
-                const closeTagName = parseTagName();
-                const namesMismatch = openTagName !== undefined && !(0, utils_1.tagNameNodesWithoutErrorsMatch)(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);
         }
     }
-    function parseTagName() {
+    function parseOpeningTagName() {
         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.
-            }
+        if (eat(syntax_kind_1.SyntaxKind.Colon) && !eat(syntax_kind_1.SyntaxKind.Identifier)) {
+            const nameNodeWithColon = completeNode(syntax_kind_1.SyntaxKind.TagNameNode);
+            errorAt(diagnostics_1.DIAGS.expTagNameAfterNamespace, nameNodeWithColon.pos, nameNodeWithColon.end);
+            errNodeUntil([syntax_kind_1.SyntaxKind.Identifier, ...RECOVER_OPEN_TAG]);
+            return { node: nameNodeWithColon, errInName: true };
+        }
+        else {
+            return { node: completeNode(syntax_kind_1.SyntaxKind.TagNameNode), errInName: false };
         }
-        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])) {
-            parseAttr(attrNames);
-            // todo: was this usefuel?
-            // if (at(SyntaxKind.Identifier)) {
-            //   parseAttr(attrNames);
-            // } else {
-            //   const atTagLike = errRecover(Diag_Attr_Identifier_Expected, firstSetTagLike);
-            //   if (atTagLike) {
-            //     parseTagLike();
-            //   }
-            // }
+        loop: while (true) {
+            switch (peek().kind) {
+                case syntax_kind_1.SyntaxKind.EndOfFileToken:
+                // same as RECOVER_OPEN_TAG
+                case syntax_kind_1.SyntaxKind.OpenNodeStart:
+                case syntax_kind_1.SyntaxKind.NodeEnd:
+                case syntax_kind_1.SyntaxKind.NodeClose:
+                case syntax_kind_1.SyntaxKind.CloseNodeStart:
+                case syntax_kind_1.SyntaxKind.CData:
+                case syntax_kind_1.SyntaxKind.Script:
+                    break loop;
+                default:
+                    parseAttr(attrNames);
+            }
         }
         if (node.children.length === 0) {
             abandonNode();
@@ -223,101 +173,118 @@ function parseXmlUiMarkup(text) {
             parseAttrName(attrNames);
         }
         else {
-            const attrNameFollow = [syntax_kind_1.SyntaxKind.Equal];
-            const eqFollows = errRecover(diagnostics_1.Diag_Attr_Identifier_Expected, attrNameFollow);
-            if (!eqFollows) {
-                return;
+            const errNode = errNodeUntil(RECOVER_ATTR);
+            if (errNode) {
+                errorAt(diagnostics_1.DIAGS.expAttrName, errNode.pos, errNode.end);
+                completeNode(syntax_kind_1.SyntaxKind.AttributeNode);
+            }
+            else {
+                abandonNode();
+                error(diagnostics_1.DIAGS.expAttrName);
             }
+            return;
         }
         if (eat(syntax_kind_1.SyntaxKind.Equal)) {
             if (!eat(syntax_kind_1.SyntaxKind.StringLiteral)) {
-                const attrFollowWithoutIdent = [syntax_kind_1.SyntaxKind.NodeEnd, syntax_kind_1.SyntaxKind.NodeClose];
-                errRecover(diagnostics_1.Diag_Attr_Value_Expected, attrFollowWithoutIdent);
+                const errNode = errNodeUntil(RECOVER_ATTR);
+                if (errNode) {
+                    errorAt(diagnostics_1.DIAGS.expAttrStr, errNode.pos, errNode.end);
+                }
+                else {
+                    error(diagnostics_1.DIAGS.expAttrStr);
+                }
             }
         }
         completeNode(syntax_kind_1.SyntaxKind.AttributeNode);
     }
     function parseAttrName(attrNames) {
-        const nameIdent = peek();
+        let nameIdent = peek();
         let nsIdent = undefined;
         startNode();
         bump(syntax_kind_1.SyntaxKind.Identifier);
         if (eat(syntax_kind_1.SyntaxKind.Colon)) {
             if (at(syntax_kind_1.SyntaxKind.Identifier)) {
-                nsIdent = bump(syntax_kind_1.SyntaxKind.Identifier);
+                nsIdent = nameIdent;
+                nameIdent = bump(syntax_kind_1.SyntaxKind.Identifier);
             }
             else {
-                errRecover(diagnostics_1.Diag_Attr_Identifier_Expected, [
-                    syntax_kind_1.SyntaxKind.NodeClose,
-                    syntax_kind_1.SyntaxKind.NodeEnd,
-                    syntax_kind_1.SyntaxKind.Equal,
-                ]);
+                const errNode = errNodeUntil([syntax_kind_1.SyntaxKind.Equal, syntax_kind_1.SyntaxKind.Identifier, ...RECOVER_OPEN_TAG]);
+                if (errNode) {
+                    errorAt(diagnostics_1.DIAGS.expAttrNameAfterNamespace, errNode.pos, errNode.end);
+                }
+                else {
+                    error(diagnostics_1.DIAGS.expAttrNameAfterNamespace);
+                }
             }
         }
         checkAttrName(attrNames, { nsIdent, nameIdent });
         completeNode(syntax_kind_1.SyntaxKind.AttributeKeyNode);
     }
+    function parseClosingTag(openTagName, skipNameMatching) {
+        if (eat(syntax_kind_1.SyntaxKind.CloseNodeStart)) {
+            if (at(syntax_kind_1.SyntaxKind.Identifier)) {
+                const closeTagName = parseClosingTagName();
+                if (!skipNameMatching) {
+                    const namesMismatch = openTagName !== null && !(0, utils_1.tagNameNodesWithoutErrorsMatch)(openTagName, closeTagName, getText);
+                    if (namesMismatch) {
+                        const msg = diagnostics_1.DIAGS.tagNameMismatch(getText(openTagName), getText(closeTagName));
+                        errorAt(msg, closeTagName.pos, closeTagName.end);
+                    }
+                }
+            }
+            else {
+                const errNode = errNodeUntil(RECOVER_CLOSE_TAG);
+                if (errNode) {
+                    errorAt(diagnostics_1.DIAGS.expTagName, errNode.pos, errNode.end);
+                }
+                else {
+                    error(diagnostics_1.DIAGS.expTagName);
+                }
+            }
+            if (!eat(syntax_kind_1.SyntaxKind.NodeEnd)) {
+                error(diagnostics_1.DIAGS.expEnd);
+            }
+        }
+        else {
+            if (openTagName) {
+                errorAt(diagnostics_1.DIAGS.expCloseStartWithName(getText(openTagName)), openTagName.pos, openTagName.end);
+            }
+            else {
+                error(diagnostics_1.DIAGS.expCloseStart);
+            }
+        }
+    }
+    function parseClosingTagName() {
+        startNode();
+        bump(syntax_kind_1.SyntaxKind.Identifier);
+        if (eat(syntax_kind_1.SyntaxKind.Colon) && !eat(syntax_kind_1.SyntaxKind.Identifier)) {
+            const nameNodeWithColon = completeNode(syntax_kind_1.SyntaxKind.TagNameNode);
+            errorAt(diagnostics_1.DIAGS.expTagNameAfterNamespace, nameNodeWithColon.pos, nameNodeWithColon.end);
+            errNodeUntil(RECOVER_OPEN_TAG);
+            return nameNodeWithColon;
+        }
+        else {
+            return completeNode(syntax_kind_1.SyntaxKind.TagNameNode);
+        }
+    }
     /** emits errors when the attribute name is incorrect. Otherwise adds the attribute name to the list of valid names*/
     function checkAttrName(attrNames, { nameIdent, nsIdent }) {
         const attrName = getText(nameIdent);
-        const attrNs = nsIdent === undefined ? undefined : getText(nsIdent);
+        const attrNs = nsIdent && getText(nsIdent);
         const attrKeyMatches = ({ ns, name }) => name === attrName && ns === attrNs;
         const isDuplicate = attrNames.findIndex(attrKeyMatches) !== -1;
         const nameStartsWithUppercase = "A" <= attrName[0] && attrName[0] <= "Z";
         const faultyName = isDuplicate || nameStartsWithUppercase;
+        //TODO: account for the namespace as well
         if (isDuplicate) {
-            errorAt(MakeErr.duplAttr(attrName), nameIdent.pos, nameIdent.end);
+            errorAt(diagnostics_1.DIAGS.duplAttr(attrName), nameIdent.pos, nameIdent.end);
         }
-        if (nameStartsWithUppercase) {
-            errorAt(MakeErr.uppercaseAttr(attrName), nameIdent.pos, nameIdent.end);
+        if (!nsIdent && nameStartsWithUppercase) {
+            errorAt(diagnostics_1.DIAGS.uppercaseAttr(attrName), nameIdent.pos, nameIdent.end);
         }
         if (!faultyName) {
-            attrNames.push({ name: attrName });
-        }
-    }
-    function at(kindToCheck) {
-        return peek().kind === kindToCheck;
-    }
-    function eat(kind) {
-        const kindMatched = at(kind);
-        if (kindMatched) {
-            bumpAny();
+            attrNames.push({ name: attrName, ns: attrNs });
         }
-        return kindMatched;
-    }
-    function atAnyOf(kinds) {
-        return kinds.includes(peek().kind);
-    }
-    function errNodeUntil(tokens) {
-        startNode();
-        advance(tokens);
-        if (node.children.length === 0) {
-            abandonNode();
-            return null;
-        }
-        else {
-            return completeNode(syntax_kind_1.SyntaxKind.ErrorNode);
-        }
-    }
-    /**
-     * report an error and skip the next token if it isn't in the recoveryTokens. EoF isn't skipped.
-     * @param recoveryTokens the [FollowSet](https://www.geeksforgeeks.org/follow-set-in-syntax-analysis/) of the parsed InnerNode. These tokens (or the EoF token) won't be skipped
-     * @returns true if the current token is in the recovery set or EoF
-     * */
-    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;
-    }
-    /** Bumps over the next token and marks it as an error node while adding an error to the error list*/
-    function errorAndBump(errCodeAndMsg) {
-        errRecover(errCodeAndMsg, []);
     }
     function error({ code, message, category }) {
         const { pos, end } = peek();
@@ -338,9 +305,35 @@ function parseXmlUiMarkup(text) {
             end,
         });
     }
+    /**
+    *
+    * @param tokens that won't be consumed
+    * @returns the error node with the consumed tokens, or null if there were no tokens consumed
+    */
+    function errNodeUntil(tokens) {
+        startNode();
+        advance(tokens);
+        if (node.children.length === 0) {
+            abandonNode();
+            return null;
+        }
+        else {
+            return completeNode(syntax_kind_1.SyntaxKind.ErrorNode);
+        }
+    }
     function advance(to) {
         for (let token = peek(); token.kind !== syntax_kind_1.SyntaxKind.EndOfFileToken && !to.includes(token.kind); bumpAny(), token = peek()) { }
     }
+    function eat(kind) {
+        const kindMatched = at(kind);
+        if (kindMatched) {
+            bumpAny();
+        }
+        return kindMatched;
+    }
+    function at(kindToCheck) {
+        return peek().kind === kindToCheck;
+    }
     function peek(inContent = false) {
         if (peekedToken !== undefined) {
             return peekedToken;
@@ -480,7 +473,7 @@ function parseXmlUiMarkup(text) {
             if (errFromScanner !== undefined) {
                 let err;
                 if (errFromScanner.message.code === diagnostics_1.ErrCodes.invalidChar) {
-                    err = MakeErr.invalidChar(scanner.getTokenText());
+                    err = diagnostics_1.DIAGS.invalidChar(scanner.getTokenText());
                 }
                 else {
                     err = errFromScanner.message;
@@ -536,9 +529,6 @@ function parseXmlUiMarkup(text) {
         node = parentNode;
         parents.pop();
     }
-    parseSourceContent();
-    const completedNode = createNode(syntax_kind_1.SyntaxKind.ContentListNode, node.children);
-    return { node: completedNode, errors };
 }
 function createNode(kind, children) {
     const firstChild = children[0];