@idlizer/core 2.1.9-arktscgen-9 → 2.1.10-arktscgen-2

package/build/lib/src/diagnosticmessages.d.ts

@@ -2,20 +2,27 @@ import { MessageSeverity, DiagnosticMessage, Location, DiagnosticResults } from
 /**
  * Template for registering different kinds of messages
  */
-export declare class DiagnosticMessageEntry {
+export declare class DiagnosticMessageGroup {
     /**
      * Index for DiagnosticMessageEntry by code
      */
-    static diagnosticMessageByCode: Map<number, DiagnosticMessageEntry>;
+    static diagnosticMessageByCode: Map<string, DiagnosticMessageGroup>;
+    /**
+     * Diagnostic results collected up until now
+     */
     static collectedResults: DiagnosticResults;
+    /**
+     * Generated diagnostic messages belonging to _any_ group
+     */
+    static get allGroupsEntries(): DiagnosticMessage[];
     /**
      * Severity of the diagnostic.
      */
     severity: MessageSeverity;
     /**
-     * Unsigned integer code of the diagnostic.
+     * String representing code of the diagnostic.
      */
-    code: number;
+    code: string;
     /**
      * Description of the diagnostic.
      */
@@ -32,14 +39,13 @@ export declare class DiagnosticMessageEntry {
      * Template for additional parts
      */
     additionalMessageTemplate: string;
-    constructor(severity: MessageSeverity, code: number, codeDescription: string, mainMessageTemplate?: string, additionalMessageTemplate?: string);
+    constructor(severity: MessageSeverity, code: string, codeDescription: string, mainMessageTemplate?: string, additionalMessageTemplate?: string);
     generateDiagnosticMessage(locations: Location[], mainMessage?: string, additionalMessage?: string): DiagnosticMessage;
-    reportDiagnosticMessage(locations: Location[], mainMessage?: string, additionalMessage?: string): void;
-    throwDiagnosticMessage(locations: Location[], mainMessage?: string, additionalMessage?: string): void;
-    static reportCatched(diagnosticMessage: DiagnosticMessage): void;
+    reportDiagnosticMessage(locations: Location[], mainMessage?: string, additionalMessage?: string): DiagnosticMessage;
+    throwDiagnosticMessage(locations: Location[], mainMessage?: string, additionalMessage?: string): never;
 }
-export declare const UnknownErrorMessage: DiagnosticMessageEntry;
-export declare const LoadingErrorMessage: DiagnosticMessageEntry;
-export declare const ParsingErrorMessage: DiagnosticMessageEntry;
-export declare const ProcessingErrorMessage: DiagnosticMessageEntry;
+export declare const InternalFatal: DiagnosticMessageGroup;
+export declare const LoadingFatal: DiagnosticMessageGroup;
+export declare const ParsingFatal: DiagnosticMessageGroup;
+export declare const ProcessingFatal: DiagnosticMessageGroup;
 //# sourceMappingURL=diagnosticmessages.d.ts.map

package/build/lib/src/diagnosticmessages.js

@@ -16,7 +16,13 @@ import { DiagnosticException, DiagnosticResults } from "./diagnostictypes";
 /**
  * Template for registering different kinds of messages
  */
-export class DiagnosticMessageEntry {
+export class DiagnosticMessageGroup {
+    /**
+     * Generated diagnostic messages belonging to _any_ group
+     */
+    static get allGroupsEntries() {
+        return DiagnosticMessageGroup.collectedResults.entries;
+    }
     constructor(severity, code, codeDescription, mainMessageTemplate, additionalMessageTemplate) {
         this.severity = severity;
         this.code = code;
@@ -24,10 +30,10 @@ export class DiagnosticMessageEntry {
         // No cases of codeUri for now, can be embedded into codeDescription later if needed
         this.mainMessageTemplate = mainMessageTemplate !== null && mainMessageTemplate !== void 0 ? mainMessageTemplate : codeDescription;
         this.additionalMessageTemplate = additionalMessageTemplate !== null && additionalMessageTemplate !== void 0 ? additionalMessageTemplate : "See";
-        if (DiagnosticMessageEntry.diagnosticMessageByCode.has(code)) {
+        if (DiagnosticMessageGroup.diagnosticMessageByCode.has(code)) {
             throw new Error(`Duplicate message code ${code}`);
         }
-        DiagnosticMessageEntry.diagnosticMessageByCode.set(code, this);
+        DiagnosticMessageGroup.diagnosticMessageByCode.set(code, this);
     }
     generateDiagnosticMessage(locations, mainMessage, additionalMessage) {
         let msg = {
@@ -45,22 +51,24 @@ export class DiagnosticMessageEntry {
         return msg;
     }
     reportDiagnosticMessage(locations, mainMessage, additionalMessage) {
-        DiagnosticMessageEntry.collectedResults.push(this.generateDiagnosticMessage(locations, mainMessage, additionalMessage));
+        const msg = this.generateDiagnosticMessage(locations, mainMessage, additionalMessage);
+        DiagnosticMessageGroup.collectedResults.push(msg);
+        return msg;
     }
     throwDiagnosticMessage(locations, mainMessage, additionalMessage) {
-        throw new DiagnosticException(this.generateDiagnosticMessage(locations, mainMessage, additionalMessage));
-    }
-    static reportCatched(diagnosticMessage) {
-        this.collectedResults.push(diagnosticMessage);
+        throw new DiagnosticException(this.reportDiagnosticMessage(locations, mainMessage, additionalMessage));
     }
 }
 /**
  * Index for DiagnosticMessageEntry by code
  */
-DiagnosticMessageEntry.diagnosticMessageByCode = new Map();
-DiagnosticMessageEntry.collectedResults = new DiagnosticResults();
-export const UnknownErrorMessage = new DiagnosticMessageEntry("fatal", 0, "Unknown error");
-export const LoadingErrorMessage = new DiagnosticMessageEntry("fatal", 100, "Loading error");
-export const ParsingErrorMessage = new DiagnosticMessageEntry("fatal", 101, "Parsing error");
-export const ProcessingErrorMessage = new DiagnosticMessageEntry("fatal", 102, "Processing error");
+DiagnosticMessageGroup.diagnosticMessageByCode = new Map();
+/**
+ * Diagnostic results collected up until now
+ */
+DiagnosticMessageGroup.collectedResults = new DiagnosticResults();
+export const InternalFatal = new DiagnosticMessageGroup("fatal", "InternalFatal", "Unknown error");
+export const LoadingFatal = new DiagnosticMessageGroup("fatal", "LoadingFatal", "Loading error");
+export const ParsingFatal = new DiagnosticMessageGroup("fatal", "ParsingFatal", "Parsing error");
+export const ProcessingFatal = new DiagnosticMessageGroup("fatal", "ProcessingFatal", "Processing error");
 //# sourceMappingURL=diagnosticmessages.js.map

package/build/lib/src/diagnostictypes.d.ts

@@ -21,9 +21,9 @@ export interface DiagnosticMessage {
      */
     severity: MessageSeverity;
     /**
-     * Unsigned integer code of the diagnostic.
+     * String representing code of the diagnostic.
      */
-    code: number;
+    code: string;
     /**
      * Description of the diagnostic.
      */
@@ -115,16 +115,10 @@ export interface DiagnosticDiffComponent {
      */
     replacement?: string;
 }
-/**
- * Receiver of diagnostic messages.
- */
-export interface DiagnosticReceiver {
-    push(message: DiagnosticMessage): void;
-}
 /**
  * Collection of diagnostic messages with calculated statistics.
  */
-export declare class DiagnosticResults implements DiagnosticReceiver {
+export declare class DiagnosticResults {
     entries: DiagnosticMessage[];
     totals: Record<MessageSeverity, number>;
     push(message: DiagnosticMessage): void;

package/build/lib/src/formatter.d.ts

@@ -1,3 +1,4 @@
-import { DiagnosticResults } from "./diagnostictypes";
+import { DiagnosticResults, DiagnosticMessage } from "./diagnostictypes";
 export declare function outputDiagnosticResultsFormatted(result: DiagnosticResults): void;
+export declare function outputDiagnosticMessageFormatted(message: DiagnosticMessage): void;
 //# sourceMappingURL=formatter.d.ts.map

package/build/lib/src/formatter.js

@@ -15,7 +15,7 @@
 import { MessageSeverityList } from "./diagnostictypes";
 export function outputDiagnosticResultsFormatted(result) {
     for (let message of result.entries) {
-        outputReadableMessage(message);
+        outputDiagnosticMessageFormatted(message);
     }
     outputReadableTotals(result);
 }
@@ -62,11 +62,11 @@ function formatUnderline(indent, lines, lineNo, range, edgeChar, midChar, messag
     }
     return `${indent} | ${midChar.repeat(lines[lineNo - 1].length)}`;
 }
-function outputReadableMessage(message) {
+export function outputDiagnosticMessageFormatted(message) {
     if (message.parts.length == 0) {
         return;
     }
-    console.log(`${message.severity}[E${message.code}]: ${message.codeDescription}`);
+    console.log(`${message.severity}[${message.code}]: ${message.codeDescription}`);
     let digits = lineDigitCount(message);
     let indent = " ".repeat(digits);
     let first = true;

package/build/lib/src/from-idl/deserialize.js

@@ -20,7 +20,8 @@ import * as idl from "../idl";
 import { isDefined, warn } from "../util";
 import { collapseTypes, generateSyntheticUnionName } from "../peer-generation/idl/common";
 import { commonRange } from "../diagnostictypes";
-import { LoadingErrorMessage, ParsingErrorMessage, UnknownErrorMessage } from "../diagnosticmessages";
+import { DiagnosticMessageGroup, LoadingFatal, ParsingFatal, InternalFatal } from "../diagnosticmessages";
+import { FatalParserException, Parser } from "./parser";
 function getTokens(node) {
     return node.tokens;
 }
@@ -135,10 +136,9 @@ class IDLDeserializer {
             }
             const implementations = [];
             node.inheritance.forEach(it => {
-                var _a;
                 const attributes = it.extAttrs;
                 const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], idl.IDLExtendedAttributes.TypeArguments);
-                const attrs = (_a = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : [])) === null || _a === void 0 ? void 0 : _a.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments);
+                const attrs = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : []); // ?.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments)
                 const ref = idl.createReferenceType(it.inheritance, parentTypeArgs, {
                     extendedAttributes: attrs
                 });
@@ -519,8 +519,136 @@ export function toIdlType(fileName, content) {
     const deserializer = new IDLDeserializer(lexicalInfo, 'multiple');
     return deserializer.toIDLType(fileName, webidl2.parseType(content, fileName));
 }
+const DifferenceFound = new DiagnosticMessageGroup("error", "DifferenceFound", "Difference found");
+const noCompare = new Set(["parent", "fileName", "nodeLocation", "nameLocation", "valueLocation", "typesValue"]);
+const canContainMoreCompare = new Set(["extendedAttributes", "typeParameters", "typeArguments"]);
+function safeString(value) {
+    if (typeof value == "symbol") {
+        return String(value);
+    }
+    return JSON.stringify(value, (k, v) => { return noCompare.has(k) ? undefined : v; });
+}
+function joinPath(left, right) {
+    if (!right) {
+        return left;
+    }
+    return `${left}.${right}`;
+}
+function compareDeep(oldData, newData, paths) {
+    var _a;
+    const location = (newData === null || newData === void 0 ? void 0 : newData.kind) && ((_a = newData === null || newData === void 0 ? void 0 : newData.nameLocation) !== null && _a !== void 0 ? _a : newData === null || newData === void 0 ? void 0 : newData.nodeLocation);
+    const diffs = [];
+    if (typeof oldData != typeof newData) {
+        diffs.push({ path: "", oldValue: safeString(oldData), newValue: safeString(newData) });
+    }
+    else if (Array.isArray(oldData) && Array.isArray(newData)) {
+        const len = Math.max(oldData.length, newData.length);
+        if (oldData.length != newData.length) {
+            diffs.push({ path: "", oldValue: `(length=${oldData.length})`, newValue: `(length=${newData.length})` });
+        }
+        for (let i = 0; i < len; ++i) {
+            const deeperDiffs = compareDeep(oldData[i], newData[i], paths);
+            if (deeperDiffs.length > 0) {
+                diffs.push(...deeperDiffs.map(x => { x.path = joinPath("" + i, x.path); return x; }));
+            }
+        }
+    }
+    else if (typeof newData == "object") {
+        const keys = [...new Set([...Object.getOwnPropertyNames(oldData), ...Object.getOwnPropertyNames(newData)])].filter(x => !noCompare.has(x));
+        for (const k of keys) {
+            let oldValue = oldData[k];
+            let newValue = newData[k];
+            if (canContainMoreCompare.has(k)) {
+                if (newValue == null && Array.isArray(oldValue) && oldValue.length == 0) {
+                    continue;
+                }
+                if (oldValue == null && Array.isArray(newValue)) {
+                    continue;
+                }
+                if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+                    if (newValue.length > oldValue.length) {
+                        // Cases when old parser takes attributes from outer declaration and ignores the right ones
+                        newValue = newValue.slice(newValue.length - oldValue.length);
+                    }
+                    else if (oldValue.length > newValue.length) {
+                        // Cases when types in parentheses have own attributes, but old parser adds attributes from outer declaration
+                        oldValue = oldValue.slice(0, newValue.length);
+                    }
+                }
+            }
+            const deeperDiffs = compareDeep(oldValue, newValue, paths);
+            if (deeperDiffs.length > 0) {
+                diffs.push(...deeperDiffs.map(x => { x.path = joinPath(k, x.path); return x; }));
+            }
+        }
+    }
+    else {
+        if (oldData != newData) {
+            diffs.push({ path: "", oldValue: safeString(oldData), newValue: safeString(newData) });
+        }
+    }
+    if (!location) {
+        return diffs;
+    }
+    for (const diff of diffs) {
+        paths.add(diff.path);
+        DifferenceFound.reportDiagnosticMessage([location], `path: ${diff.path} oldValue: ${diff.oldValue} newValue: ${diff.newValue}`);
+    }
+    return [];
+}
+function compareParsingResults(oldFile, newFile) {
+    const paths = new Set();
+    compareDeep(oldFile, newFile, paths);
+    if (paths.size > 0) {
+        DifferenceFound.reportDiagnosticMessage([newFile.nodeLocation], "Differences found in those paths:\n" + [...paths].join("\n"));
+    }
+}
+function parseIdlNew(fileName, content, registerSynthetics) {
+    let file = new Parser(fileName, content).parseIDL();
+    const ancestors = [];
+    const namespaces = [];
+    // Mimic old parser and deserialize.ts behavior:
+    // 1. Add `fileName`.
+    // 2. Add `parent`.
+    // 3. Possibly register node with `addSyntheticType` if "Synthetic" is in attributes
+    idl.forEachChild(file, (node) => {
+        var _a;
+        if (idl.isPrimitiveType(node)) {
+            return;
+        }
+        node.fileName = fileName;
+        if (registerSynthetics && idl.isEntry(node) && ((_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.some(it => it.name === "Synthetic"))) {
+            const fqName = file.packageClause.concat(namespaces).concat([node.name]).join('.');
+            addSyntheticType(fqName, node);
+        }
+        if (ancestors.length) {
+            node.parent = ancestors[ancestors.length - 1];
+        }
+        if (idl.isNamespace(node)) {
+            namespaces.push(node.name);
+        }
+        ancestors.push(node);
+    }, (node) => {
+        if (idl.isPrimitiveType(node)) {
+            return;
+        }
+        if (idl.isNamespace(node)) {
+            namespaces.pop();
+        }
+        ancestors.pop();
+    });
+    return file;
+}
 export function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
     var _a, _b, _c;
+    let newFile;
+    const mode = process.env.IDLPARSE;
+    if (mode == "compare" || mode == "new") {
+        newFile = parseIdlNew(fileName, content, mode == "new");
+        if (mode == "new") {
+            return [newFile, new Map()];
+        }
+    }
     const lexicalInfo = new Map();
     const deserializer = new IDLDeserializer(lexicalInfo, inheritanceMode);
     if (undefined === content) {
@@ -529,7 +657,7 @@ export function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } =
         }
         catch (e) {
             content = "";
-            LoadingErrorMessage.throwDiagnosticMessage([{ documentPath: fileName }], (_a = e.message) !== null && _a !== void 0 ? _a : "");
+            throw new FatalParserException([LoadingFatal.reportDiagnosticMessage([{ documentPath: fileName }], (_a = e.message) !== null && _a !== void 0 ? _a : "")]);
         }
     }
     let lines = (_b = content.match(/[^\r\n]*(\n|\r\n)?/g)) !== null && _b !== void 0 ? _b : [];
@@ -545,9 +673,9 @@ export function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } =
         if (e.name == "WebIDLParseError") {
             let tokens = e.tokens;
             let range = tokens.length > 0 ? rangeForToken(offsets, tokens[0]) : undefined;
-            ParsingErrorMessage.throwDiagnosticMessage([{ documentPath: fileName, range, lines }], e.bareMessage);
+            throw new FatalParserException([ParsingFatal.reportDiagnosticMessage([{ documentPath: fileName, range, lines }], e.bareMessage)]);
         }
-        UnknownErrorMessage.throwDiagnosticMessage([{ documentPath: fileName }], (_c = e.message) !== null && _c !== void 0 ? _c : "");
+        throw new FatalParserException([InternalFatal.reportDiagnosticMessage([{ documentPath: fileName, lines }], (_c = e.message) !== null && _c !== void 0 ? _c : "")]);
     }
     const entries = rawParsingResults
         .filter(it => {
@@ -571,6 +699,10 @@ export function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } =
             node.nameLocation = nameLocation;
         }
     });
+    if (mode == "compare") {
+        compareParsingResults(file, newFile);
+        return [newFile, new Map()];
+    }
     return [file, lexicalInfo];
 }
 function prepareOffsets(lines) {

package/build/lib/src/from-idl/parser.d.ts

@@ -0,0 +1,99 @@
+import * as idl from "../idl";
+import { DiagnosticMessage, Location } from "../diagnostictypes";
+export declare class FatalParserException extends Error {
+    diagnosticMessages?: DiagnosticMessage[];
+    constructor(diagnosticMessages?: DiagnosticMessage[]);
+}
+declare enum TokenKind {
+    Words = "Words",
+    Literal = "Literal",
+    Symbol = "Symbol",
+    Comment = "Comment",
+    Whitespace = "Space",
+    End = "End"
+}
+interface Token {
+    kind: TokenKind;
+    value: string;
+    location: Location;
+}
+type ModifierToken = "static" | "readonly" | "async";
+type ModifiersContainer = {
+    [Key in ModifierToken]?: Token;
+};
+export declare class Parser {
+    fileName: string;
+    content: string;
+    lines: string[];
+    offsets: number[];
+    constructor(fileName: string, content?: string);
+    parseIDL(): idl.IDLFile;
+    _curOffset: number;
+    _curLine: number;
+    _curToken: Token;
+    _prevToken: Token;
+    _generics: string[][];
+    _enableInLiteralParsing: boolean;
+    _match(re: RegExp, kind: TokenKind): Token | undefined;
+    _reDecimal: RegExp;
+    _reInteger: RegExp;
+    _reString: RegExp;
+    _reWords: RegExp;
+    _reSymbol: RegExp;
+    _reWhitespace: RegExp;
+    _reComment: RegExp;
+    _reIsDocComment: RegExp;
+    _matchComment(): Token | undefined;
+    _lexerNext(): void;
+    get curToken(): Token;
+    get curKind(): TokenKind;
+    get curValue(): string;
+    get curLocation(): Location;
+    see(tok: string): boolean;
+    seeAndSkip(tok: string): boolean;
+    seeEof(): boolean;
+    skip(tok: string): void;
+    skipToAfter(tok: string): void;
+    trackLocation(): () => Location;
+    _internalCurrentExtended: idl.IDLExtendedAttribute[] | undefined;
+    consumeCurrentExtended(): idl.IDLExtendedAttribute[] | undefined;
+    currentModifiers: ModifiersContainer;
+    assertPossibleModifiers(...mods: ModifierToken[]): void;
+    precedingComment: Token | undefined;
+    currentPackage: string | undefined;
+    parseSingleIdentifier(): Token;
+    parseFullIdentifier(): Token;
+    parseFullIdentifierOrLiteral(): Token;
+    parseLiteral(): Token;
+    parseAndPushGenerics(ext?: idl.IDLExtendedAttribute[]): string[] | undefined;
+    hasGeneric(name: string): boolean;
+    parseFile(): idl.IDLFile;
+    parseDeclaration(scopeKind: idl.IDLKind): idl.IDLEntry | undefined;
+    parseDeclarationUnsafe(scopeKind: idl.IDLKind): idl.IDLEntry | undefined;
+    parseNamespace(): idl.IDLNamespace;
+    parseInterface(): idl.IDLInterface;
+    parseExtendedAttributes(): idl.IDLExtendedAttribute[] | undefined;
+    parseTypeList(): idl.IDLType[];
+    parseType(outerExt?: idl.IDLExtendedAttribute[]): idl.IDLType;
+    parseReferenceType(): idl.IDLReferenceType;
+    parsePrimitiveType(): idl.IDLPrimitiveType;
+    parseArgTuple(): idl.IDLParameter[];
+    parseArg(): idl.IDLParameter;
+    parseOperation(): idl.IDLCallable | idl.IDLMethod;
+    parseConstructor(): idl.IDLConstructor;
+    parseConst(): idl.IDLConstant;
+    parseAttribute(): idl.IDLProperty;
+    parseTypedef(): idl.IDLTypedef;
+    parseCallback(): idl.IDLCallback;
+    parseEnum(): idl.IDLEnum;
+    parseDictionary(): idl.IDLEnum;
+    parseDictionaryEntry(): idl.IDLEnumMember;
+    parsePackage(): {
+        location: Location;
+        name: string;
+    };
+    parseImport(): idl.IDLImport;
+    parseVersion(): idl.IDLVersion;
+}
+export {};
+//# sourceMappingURL=parser.d.ts.map