dot-language-support 1.6.1 → 2.0.0

package/lib/esm/binder.js

@@ -0,0 +1,296 @@
+import { SyntaxKind, } from "./types.js";
+import { getIdentifierText, nodeContainsErrors } from "./checker.js";
+import { isIdentifierNode } from "./parser.js";
+const binder = createBinder();
+export function bindSourceFile(file) {
+    binder.bind(file);
+}
+function createBinder() {
+    let parent = undefined;
+    let symbolTable = undefined;
+    let colorTable = undefined;
+    let graphContext = 0;
+    function bind(node) {
+        if (!node)
+            return;
+        const saveParent = parent;
+        const saveContext = graphContext;
+        node.parent = saveParent;
+        node.graphContext = saveContext;
+        parent = node;
+        innerBind(node);
+        parent = saveParent;
+        graphContext = saveContext;
+    }
+    function innerBind(node) {
+        switch (node.kind) {
+            case SyntaxKind.DirectedGraph:
+            case SyntaxKind.UndirectedGraph:
+                return bindGraph(node);
+            case SyntaxKind.AttributeStatement:
+                return bindAttributeStatement(node);
+            case SyntaxKind.EdgeStatement:
+                return bindEdgeStatement(node);
+            case SyntaxKind.NodeStatement:
+                return bindNodeStatement(node);
+            case SyntaxKind.SubGraph:
+                return bindSubGraph(node);
+            case SyntaxKind.SubGraphStatement:
+                return bindSubGraphStatement(node);
+            case SyntaxKind.IdEqualsIdStatement:
+                return bindIdEqualsIdStatement(node);
+            case SyntaxKind.QuotedTextIdentifier:
+                return bindQuotedTextIdentifier(node);
+            case SyntaxKind.EdgeRhs:
+                return bindEdgeRhs(node);
+            case SyntaxKind.AttributeContainer:
+                return bindAttributeContainer(node);
+            case SyntaxKind.Assignment:
+                return bindAssignment(node);
+            case SyntaxKind.NormalPortDeclaration:
+                return bindNormalPortDeclaration(node);
+            case SyntaxKind.CompassPortDeclaration:
+                return bindCompassPortDeclaration(node);
+            case SyntaxKind.NodeId:
+                return bindNodeId(node);
+            default:
+                if (node.kind >= SyntaxKind.FirstNode)
+                    throw "TODO";
+        }
+    }
+    function bindGraph(node) {
+        if (node.strict) {
+            graphContext |= 2;
+        }
+        switch (node.kind) {
+            case SyntaxKind.DirectedGraph:
+                graphContext |= 4;
+                break;
+            case SyntaxKind.UndirectedGraph:
+                graphContext |= 8;
+                break;
+        }
+        if (node.id) {
+            ensureGlobalSymbol(node.id);
+            bind(node.id);
+        }
+        ;
+        if (node.strict)
+            bind(node.strict);
+        bindChildren(node.statements);
+    }
+    function bindAttributeStatement(node) {
+        bind(node.subject);
+        bindChildren(node.attributes);
+        if (node.terminator)
+            bind(node.terminator);
+    }
+    function bindEdgeStatement(node) {
+        bindChildren(node.attributes);
+        bindChildren(node.rhs);
+        bind(node.source);
+        if (node.terminator)
+            bind(node.terminator);
+    }
+    function bindNodeStatement(node) {
+        bind(node.id);
+        bindChildren(node.attributes);
+        if (node.terminator)
+            bind(node.terminator);
+    }
+    function bindSubGraph(node) {
+        if (node.id) {
+            bind(node.id);
+        }
+        ;
+        bindChildren(node.statements);
+    }
+    function bindSubGraphStatement(node) {
+        bind(node.subgraph);
+        if (node.terminator)
+            bind(node.terminator);
+    }
+    function bindIdEqualsIdStatement(node) {
+        bind(node.leftId);
+        bind(node.rightId);
+        if (node.rightId && !nodeContainsErrors(node.rightId)) {
+            if (isAttributeName("color", node.leftId)) {
+                ensureGlobalColor(node.rightId);
+            }
+            else if (isAttributeName("fillcolor", node.leftId)) {
+                ensureGlobalColor(node.rightId);
+            }
+            else if (isAttributeName("bgcolor", node.leftId)) {
+                ensureGlobalColor(node.rightId);
+            }
+            else if (isAttributeName("fontcolor", node.leftId)) {
+                ensureGlobalColor(node.rightId);
+            }
+        }
+        if (node.terminator)
+            bind(node.terminator);
+    }
+    function bindQuotedTextIdentifier(node) {
+        bindChildren(node.values);
+        node.concatenation = node.values.map(v => v.text).join("");
+    }
+    function bindEdgeRhs(node) {
+        bind(node.operation);
+        bind(node.target);
+    }
+    function bindAttributeContainer(node) {
+        bind(node.openBracket);
+        bindChildren(node.assignments);
+        bind(node.closeBracket);
+    }
+    function bindAssignment(node) {
+        const attrContainer = node.parent;
+        console.assert(!!attrContainer);
+        const superParentStatement = attrContainer.parent;
+        console.assert(!!superParentStatement);
+        bind(node.leftId);
+        let carrierIdentifier = undefined;
+        switch (superParentStatement.kind) {
+            case SyntaxKind.NodeStatement:
+                carrierIdentifier = superParentStatement.id.id;
+                break;
+            case SyntaxKind.EdgeStatement:
+                break;
+            case SyntaxKind.SubGraphStatement:
+                break;
+            case SyntaxKind.AttributeStatement:
+                break;
+        }
+        if (carrierIdentifier)
+            ensureMemberSymbol(node.leftId, carrierIdentifier);
+        bind(node.rightId);
+        if (node.rightId && !nodeContainsErrors(node.rightId)) {
+            if (isAttributeName("color", node.leftId)) {
+                ensureGlobalColor(node.rightId);
+            }
+        }
+        if (node.terminator)
+            bind(node.terminator);
+    }
+    function bindNormalPortDeclaration(node) {
+        bind(node.colon);
+        ensureGlobalSymbol(node.id);
+        bind(node.id);
+        if (node.compassPt)
+            bind(node.compassPt);
+    }
+    function bindCompassPortDeclaration(node) {
+        bind(node.colon);
+        if (node.compassPt)
+            bind(node.compassPt);
+    }
+    function bindNodeId(node) {
+        ensureGlobalSymbol(node.id);
+        bind(node.id);
+        if (node.port)
+            bind(node.port);
+    }
+    function bindChildren(nodes) {
+        for (const n of nodes)
+            bind(n);
+    }
+    function createSymbolTable() {
+        return new Map();
+    }
+    function createColorTable() {
+        return new Map();
+    }
+    function ensureMemberSymbol(node, carrier) {
+        if (node && carrier && isIdentifierNode(node)) {
+            const name = getIdentifierText(node);
+            if (name === undefined)
+                return;
+            const carrierSymbol = carrier.symbol;
+            if (carrierSymbol === undefined)
+                throw "carrierSymbol is undefined";
+            let symbols = carrierSymbol.members;
+            if (symbols === undefined)
+                carrierSymbol.members = symbols = createSymbolTable();
+            ensureSymbolOnTable(name, node, symbols);
+            return;
+        }
+        console.warn("ensureSymbol called on non-identifier node");
+        debugger;
+    }
+    function ensureGlobalSymbol(node) {
+        if (node && isIdentifierNode(node)) {
+            const symbols = symbolTable;
+            const name = getIdentifierText(node);
+            if (name === undefined)
+                return;
+            if (symbols === undefined)
+                throw "symbolTable is undefined";
+            ensureSymbolOnTable(name, node, symbols);
+            return;
+        }
+        console.warn("ensureSymbol called on non-identifier node");
+        debugger;
+    }
+    function ensureSymbolOnTable(name, node, symbols) {
+        if (!name)
+            return;
+        let sym = symbols.get(name);
+        if (sym === undefined) {
+            sym = createSymbol(name, node);
+            symbols.set(name, sym);
+        }
+        else {
+            if (!sym.references)
+                sym.references = [node];
+            else
+                sym.references.push(node);
+        }
+        node.symbol = sym;
+    }
+    function ensureGlobalColor(node) {
+        if (node && isIdentifierNode(node)) {
+            const colors = colorTable;
+            const name = getIdentifierText(node);
+            if (name === undefined)
+                return;
+            if (colors === undefined)
+                throw "symbolTable is undefined";
+            const color = createColor(node);
+            colors.set(name, color);
+            return;
+        }
+        console.warn("ensureSymbol called on non-identifier node");
+        debugger;
+    }
+    function createSymbol(name, node) {
+        if (!name)
+            throw "name is falsy";
+        if (!node)
+            throw "node is undefined or null";
+        return {
+            name,
+            firstMention: node,
+            references: undefined,
+        };
+    }
+    function createColor(node) {
+        return {
+            node,
+        };
+    }
+    function isAttributeName(name, id) {
+        return id ? getIdentifierText(id).trim().toLowerCase() === name : false;
+    }
+    return {
+        bind: file => {
+            symbolTable = createSymbolTable();
+            colorTable = createColorTable();
+            const { graph } = file;
+            if (graph)
+                bind(graph);
+            file.symbols = symbolTable;
+            file.colors = colorTable;
+        },
+    };
+}
+//# sourceMappingURL=binder.js.map

package/lib/esm/checker.d.ts

@@ -0,0 +1,14 @@
+import { SyntaxNode, Identifier, SyntaxKind, Graph, EdgeStatement, EdgeRhs, SourceFile, SubGraphStatement, NodeId, AttributeStatement, Statement, StatementOf, Token } from "./types.js";
+export declare function checkSourceFile(file: SourceFile): void;
+export declare function findNodeAtOffset(root: SyntaxNode, offset: number, inclusiveEnd?: boolean): SyntaxNode | undefined;
+export declare function getAllowedEdgeOperation(graph: Graph): SyntaxKind.DirectedEdgeOp | SyntaxKind.UndirectedEdgeOp;
+export declare function findAllEdges(node: SyntaxNode): EdgeRhs[];
+export declare function findOptionalSemicolons(node: SyntaxNode): Token<SyntaxKind.SemicolonToken>[];
+export declare function findAllStatements<T extends Statement["kind"]>(node: SyntaxNode, kind?: T): StatementOf<T>[];
+export declare function isAttrStatement(node: SyntaxNode): node is AttributeStatement;
+export declare function isEdgeStatement(node: SyntaxNode): node is EdgeStatement;
+export declare function isSubGraphStatement(node: SyntaxNode): node is SubGraphStatement;
+export declare function isNodeId(node: SyntaxNode): node is NodeId;
+export declare function edgeStatementHasAttributes(es: EdgeStatement): boolean;
+export declare function getIdentifierText(n: Identifier): string;
+export declare function nodeContainsErrors(node: SyntaxNode): boolean;

package/lib/esm/checker.js

@@ -0,0 +1,169 @@
+import { SyntaxKind, DiagnosticCategory, } from "./types.js";
+import { assertNever, getStart } from "./service/util.js";
+import { forEachChild } from "./visitor.js";
+export function checkSourceFile(file) {
+    const g = file.graph;
+    if (g) {
+        const messages = checkGraphSemantics(file, g);
+        if (messages) {
+            file.diagnostics.push.apply(file.diagnostics, messages);
+        }
+    }
+}
+function getNarrowerNode(offset, prev, toCheck) {
+    const prevRange = prev.end - prev.pos;
+    if (toCheck.pos <= offset && offset <= toCheck.end) {
+        let nrange = toCheck.end - toCheck.pos;
+        if (nrange < prevRange) {
+            return toCheck;
+        }
+    }
+    return prev;
+}
+function rangeContainsOffset(range, offset, inclusiveEnd) {
+    return inclusiveEnd
+        ? range.pos <= offset && offset <= range.end
+        : range.pos <= offset && offset < range.end;
+}
+export function findNodeAtOffset(root, offset, inclusiveEnd = false) {
+    if (root.pos === offset && root.pos === root.end)
+        return root;
+    if (rangeContainsOffset(root, offset, inclusiveEnd)) {
+        const narrowerChild = forEachChild(root, child => findNodeAtOffset(child, offset, inclusiveEnd));
+        return narrowerChild ? narrowerChild : root;
+    }
+    return undefined;
+}
+export function getAllowedEdgeOperation(graph) {
+    return graph.kind === SyntaxKind.DirectedGraph
+        ? SyntaxKind.DirectedEdgeOp
+        : SyntaxKind.UndirectedEdgeOp;
+}
+function checkGraphSemantics(file, root) {
+    const expectedEdgeOp = getAllowedEdgeOperation(root);
+    const invalidEdgeRhses = findEdgeErrors(expectedEdgeOp, root);
+    return invalidEdgeRhses == undefined || invalidEdgeRhses.length === 0
+        ? undefined
+        : createEdgeViolationDiagnostics(file, expectedEdgeOp, invalidEdgeRhses);
+}
+export function findAllEdges(node) {
+    const allEdges = [];
+    forEachChild(node, child => {
+        if (isEdgeStatement(child)) {
+            if (child.rhs && child.rhs.length > 0) {
+                for (const edgeRhs of child.rhs)
+                    allEdges.push(edgeRhs);
+            }
+        }
+        const childEdges = findAllEdges(child);
+        if (childEdges && childEdges.length > 0)
+            allEdges.push.apply(allEdges, childEdges);
+    });
+    return allEdges;
+}
+export function findOptionalSemicolons(node) {
+    const statements = findAllStatements(node);
+    const terminators = statements.map(p => p.terminator);
+    return terminators.filter(t => !!t);
+}
+function isStatement(node) {
+    return node.kind === SyntaxKind.SubGraphStatement
+        || node.kind === SyntaxKind.EdgeStatement
+        || node.kind === SyntaxKind.NodeStatement
+        || node.kind === SyntaxKind.IdEqualsIdStatement
+        || node.kind === SyntaxKind.AttributeStatement;
+}
+export function findAllStatements(node, kind) {
+    const allStatements = [];
+    forEachChild(node, child => {
+        if ((kind === undefined && isStatement(child)) || (child.kind === kind)) {
+            allStatements.push(child);
+        }
+        const childStatements = findAllStatements(child, kind);
+        if (childStatements && childStatements.length > 0)
+            allStatements.push.apply(allStatements, childStatements);
+    });
+    return allStatements;
+}
+function findEdgeErrors(expectedEdgeOp, node) {
+    const edges = findAllEdges(node);
+    const wrongEdges = edges && edges.length > 0
+        ? edges.filter(e => e.operation.kind !== expectedEdgeOp)
+        : undefined;
+    if (wrongEdges && wrongEdges.length > 0) {
+        wrongEdges.forEach(e => e.operation.flags |= 2);
+        return wrongEdges;
+    }
+    return undefined;
+}
+function createEdgeViolationDiagnostics(file, expectedEdgeOp, violators) {
+    const op = expectedEdgeOp === SyntaxKind.UndirectedEdgeOp ? "--" : "->";
+    const graphType = expectedEdgeOp === SyntaxKind.UndirectedEdgeOp ? "undirected" : "directed";
+    const message = `Invalid edge operation, use "${op}" in ${graphType} graph`;
+    const code = createCheckerError(0);
+    const category = DiagnosticCategory.Error;
+    violators.forEach(edge => edge.operation.flags |= 2);
+    return violators.map(edge => {
+        const start = getStart(file, edge.operation);
+        const end = edge.operation.end;
+        return {
+            message,
+            code,
+            category,
+            start,
+            end,
+        };
+    });
+}
+function getInvalidEdgeRhs(allowedOp, edges) {
+    const res = [];
+    for (const e of edges) {
+        if (e.operation.kind !== allowedOp)
+            res.push(e);
+    }
+    return res;
+}
+export function isAttrStatement(node) {
+    return node.kind === SyntaxKind.AttributeStatement;
+}
+export function isEdgeStatement(node) {
+    return node.kind === SyntaxKind.EdgeStatement;
+}
+export function isSubGraphStatement(node) {
+    return node.kind === SyntaxKind.SubGraphStatement;
+}
+function isGraph(node) {
+    return node.kind === SyntaxKind.DirectedGraph || node.kind === SyntaxKind.UndirectedGraph;
+}
+export function isNodeId(node) {
+    return node.kind === SyntaxKind.NodeId;
+}
+export function edgeStatementHasAttributes(es) {
+    return es.attributes
+        && es.attributes.length > 0
+        && es.attributes.some(a => a.assignments && a.assignments.length > 0);
+}
+export function getIdentifierText(n) {
+    switch (n.kind) {
+        case SyntaxKind.HtmlIdentifier:
+            return n.htmlContent;
+        case SyntaxKind.TextIdentifier:
+            return n.text;
+        case SyntaxKind.NumericIdentifier:
+            return n.text;
+        case SyntaxKind.QuotedTextIdentifier:
+            return n.concatenation;
+        default:
+            return assertNever(n);
+    }
+}
+function createCheckerError(sub) {
+    return {
+        source: 4,
+        sub,
+    };
+}
+export function nodeContainsErrors(node) {
+    return (node.flags & 2) === 2;
+}
+//# sourceMappingURL=checker.js.map

package/lib/esm/core.d.ts

@@ -0,0 +1 @@
+export declare function createMapFromTemplate<T>(template: Record<string, T>): Map<string, T>;

package/lib/esm/core.js

@@ -0,0 +1,10 @@
+export function createMapFromTemplate(template) {
+    const map = new Map();
+    for (const key in template) {
+        if (template.hasOwnProperty(key)) {
+            map.set(key, template[key]);
+        }
+    }
+    return map;
+}
+//# sourceMappingURL=core.js.map

package/lib/esm/error.d.ts

@@ -0,0 +1,3 @@
+import type { ErrorCode } from "./types.js";
+export declare const diagnosicSource = "DOT";
+export declare function formatError(error: ErrorCode): string;

package/lib/esm/error.js

@@ -0,0 +1,10 @@
+export const diagnosicSource = "DOT";
+const errorCodeLength = 4;
+const subErrorCodeLength = errorCodeLength - 1;
+export function formatError(error) {
+    const subCode = (error.sub | 0)
+        .toString()
+        .padStart(subErrorCodeLength, "0");
+    return diagnosicSource + error.source + subCode;
+}
+//# sourceMappingURL=error.js.map

package/lib/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./scanner.js";
+export * from "./parser.js";
+export * from "./visitor.js";
+export * from "./service/service.js";

package/lib/esm/index.js

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./scanner.js";
+export * from "./parser.js";
+export * from "./visitor.js";
+export * from "./service/service.js";
+//# sourceMappingURL=index.js.map

package/lib/esm/parser.d.ts

@@ -0,0 +1,84 @@
+import { Scanner } from "./scanner.js";
+import { SyntaxKind, SourceFile, Identifier, SyntaxNode, DiagnosticMessage } from "./types";
+export declare enum ParsingContext {
+    None = 0,
+    StatementList = 1,
+    AttributeContainerList = 2,
+    AssignmentList = 3,
+    EdgeRhsList = 4,
+    QuotedTextIdentifierConcatenation = 5,
+    Count = 6
+}
+export declare class Parser {
+    currentToken: SyntaxKind;
+    nodeCount: number;
+    identifiers: Set<string>;
+    identifierCount: number;
+    sourceText: string;
+    scanner: Scanner;
+    currentNodeHasError: boolean;
+    currentContext: ParsingContext;
+    diagnostics: DiagnosticMessage[];
+    constructor();
+    private resetState;
+    private nextToken;
+    private token;
+    private getLinesFromFile;
+    parse(sourceText: string): SourceFile;
+    private parseGraph;
+    private parseIdentifier;
+    private registerIdentifier;
+    private parseTextIdentifier;
+    private parseQuotedTextIdentifierConcatenation;
+    private parseQuotedTextIdentifier;
+    private isQuotedStringFollowing;
+    private parseHtmlIdentifier;
+    private parseNumericIdentifier;
+    private parseStatement;
+    private parseAttributeStatement;
+    private parseAttributeContainer;
+    private isAssignmentStart;
+    private parseIdEqualsIdStatement;
+    private isIdEqualsIdStatement;
+    private parseNodeStatement;
+    private parseEdgeStatement;
+    private parseEdgeRhs;
+    private createMissingNode;
+    private parseAssignment;
+    private parseSubGraph;
+    private parseNodeId;
+    private parseCompassPortDeclaration;
+    private parseNormalPortDeclaration;
+    private parsePortDeclaration;
+    private isCompassPort;
+    private parseList;
+    private getContextParseError;
+    private isInSomeParsingContext;
+    private abortListParsing;
+    private isListElement;
+    private isListTerminator;
+    private createEmptyArray;
+    private finishNode;
+    private createNode;
+    private createNodeArray;
+    private parseTokenNode;
+    private getLastError;
+    private parseErrorAtPosition;
+    private parseErrorAtCurrentToken;
+    private scanError;
+    private reportExpectedError;
+    private parseExpectedOneOf;
+    private parseExpectedTokenOneOf;
+    private parseExpectedToken;
+    private parseExpected;
+    private parseOptionalToken;
+    private parseOptional;
+    private isEdgeOp;
+    private isIdentifier;
+    private isCompassPortKind;
+    private speculationHelper;
+    private lookAhead;
+    private tryParse;
+}
+export declare function isIdentifier(kind: SyntaxKind): boolean;
+export declare function isIdentifierNode(node: SyntaxNode): node is Identifier;