@idlizer/core 2.1.2 → 2.1.7

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

@@ -1,26 +1,76 @@
+import { EOL } from "node:os";
 import * as idl from "../idl";
+export var IDLValidationDiagnosticsCode;
+(function (IDLValidationDiagnosticsCode) {
+    IDLValidationDiagnosticsCode[IDLValidationDiagnosticsCode["INVALID_EXTENDED_ATTRIBUTE"] = 1000] = "INVALID_EXTENDED_ATTRIBUTE";
+    IDLValidationDiagnosticsCode[IDLValidationDiagnosticsCode["ENUM_IS_NOT_CONSISTENT"] = 1001] = "ENUM_IS_NOT_CONSISTENT";
+    IDLValidationDiagnosticsCode[IDLValidationDiagnosticsCode["REFERENCE_IS_NOT_RESOLVED"] = 1002] = "REFERENCE_IS_NOT_RESOLVED";
+})(IDLValidationDiagnosticsCode || (IDLValidationDiagnosticsCode = {}));
+const ENG_ErrorDescription = {
+    [IDLValidationDiagnosticsCode.INVALID_EXTENDED_ATTRIBUTE]: "Invalid extended attribute",
+    [IDLValidationDiagnosticsCode.ENUM_IS_NOT_CONSISTENT]: "Enum includes both string and number values",
+    [IDLValidationDiagnosticsCode.REFERENCE_IS_NOT_RESOLVED]: "Can not resolve reference",
+};
+export const IDLValidationErrorDescription = {
+    en_EN: ENG_ErrorDescription
+};
+class IDLLinterContext {
+    constructor() {
+        this.stack = [{ typeParameters: new Set() }];
+    }
+    enter(rec) {
+        this.stack.push(rec);
+    }
+    leave() {
+        this.stack.pop();
+    }
+    get current() {
+        return this.stack.at(-1);
+    }
+    hasTypeParameter(name) {
+        for (let i = this.stack.length - 1; i >= 0; --i) {
+            if (this.stack[i].typeParameters.has(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+function parseTypeParameter(param) {
+    const extendsIdx = param.indexOf('extends');
+    if (extendsIdx !== -1) {
+        return param.substring(0, extendsIdx).trim();
+    }
+    const eqIdx = param.indexOf('=');
+    if (eqIdx !== -1) {
+        return param.substring(0, eqIdx).trim();
+    }
+    return param;
+}
 export class IDLLinter {
-    constructor(node, resolver, options) {
-        this.node = node;
+    constructor(file, resolver, options, info) {
+        this.file = file;
         this.resolver = resolver;
         this.options = options;
-        this.result = "";
-    }
-    pushError(node, error) {
-        const name = typeof node === 'string' ? node : idl.getFQName(node);
-        if (!this.entryErrors)
-            this.entryErrors = {};
-        if (!this.entryErrors[name])
-            this.entryErrors[name] = [];
-        this.entryErrors[name].push(error);
+        this.info = info;
+        this.context = new IDLLinterContext();
+        this.diagnostics = [];
     }
+    ///
     visit() {
-        this.check(this.node);
-        idl.forEachChild(this.node, node => {
+        idl.forEachChild(this.file, node => {
+            const leave = this.enter(node);
             this.check(node);
+            return leave;
         });
-        this.result = !this.entryErrors ? "" : JSON.stringify(this.entryErrors, undefined, 2);
-        return this.result;
+        return this.diagnostics;
+    }
+    enter(node) {
+        var _a, _b;
+        if (idl.isInterface(node) || idl.isTypedef(node) || idl.isMethod(node) || idl.isCallable(node) || idl.isCallback(node)) {
+            this.context.enter({ typeParameters: new Set((_b = (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.map(parseTypeParameter)) !== null && _b !== void 0 ? _b : []) });
+            return () => this.context.leave();
+        }
     }
     check(node) {
         var _a;
@@ -35,14 +85,26 @@ export class IDLLinter {
         }
     }
     checkValidAttributes(entry, validAttributes) {
+        var _a, _b, _c;
         if (!entry.extendedAttributes)
             return;
         for (const attr of entry.extendedAttributes) {
-            if (!validAttributes.includes(attr.name))
-                this.pushError(entry, `${entry.kind}: Invalid attribute '${attr.name}'`);
+            if (!validAttributes.includes(attr.name)) {
+                const tokens = (_a = this.info) === null || _a === void 0 ? void 0 : _a.get(attr);
+                const ident = tokens === null || tokens === void 0 ? void 0 : tokens.name;
+                const file = idl.getFileFor(entry);
+                this.diagnostics.push({
+                    code: IDLValidationDiagnosticsCode.INVALID_EXTENDED_ATTRIBUTE,
+                    file: (_b = file === null || file === void 0 ? void 0 : file.fileName) !== null && _b !== void 0 ? _b : '',
+                    message: `Invalid attribute '${attr.name}'`,
+                    position: [(_c = ident === null || ident === void 0 ? void 0 : ident.position) !== null && _c !== void 0 ? _c : 0, attr.name.length]
+                });
+            }
         }
     }
     checkEnumConsistency(entry) {
+        var _a, _b, _c, _d;
+        const fileName = (_a = idl.getFileFor(entry)) === null || _a === void 0 ? void 0 : _a.fileName;
         let hasNumber = false;
         let hasString = false;
         for (const element of entry.elements) {
@@ -51,18 +113,46 @@ export class IDLLinter {
             if (typeof element.initializer === 'number')
                 hasNumber = true;
         }
-        if (hasNumber && hasString)
-            this.pushError(entry, "Enum includes both string and number values");
+        if (hasNumber && hasString) {
+            const tokens = (_b = this.info) === null || _b === void 0 ? void 0 : _b.get(entry);
+            const ident = tokens === null || tokens === void 0 ? void 0 : tokens.name;
+            this.diagnostics.push({
+                code: IDLValidationDiagnosticsCode.ENUM_IS_NOT_CONSISTENT,
+                file: fileName !== null && fileName !== void 0 ? fileName : '',
+                message: "Enum includes both string and number values",
+                position: [
+                    (_c = ident === null || ident === void 0 ? void 0 : ident.position) !== null && _c !== void 0 ? _c : 0,
+                    (_d = ident === null || ident === void 0 ? void 0 : ident.value.length) !== null && _d !== void 0 ? _d : 0
+                ]
+            });
+        }
     }
     checkReferenceResolved(reference) {
+        var _a, _b, _c, _d, _e, _f;
         if (IDLLinter.builtinReferences.includes(reference.name))
             return;
+        if (this.context.hasTypeParameter(reference.name)) {
+            return;
+        }
         const resolved = this.resolver.resolveTypeReference(reference);
         if (resolved === undefined) {
             const parentFile = idl.getFileFor(reference);
             const parentNamespace = idl.fetchNamespaceFrom(reference);
             const scopeName = parentNamespace ? idl.getFQName(parentNamespace) : idl.getPackageName(parentFile);
-            this.pushError(scopeName, `Can not resolve reference '${reference.name}' defined in scope '${scopeName}' in file '${parentFile.fileName}''`);
+            let current = reference;
+            let tokens = (_a = this.info) === null || _a === void 0 ? void 0 : _a.get(current);
+            let location = tokens === null || tokens === void 0 ? void 0 : tokens.base;
+            while (current !== undefined && tokens === undefined) {
+                current = current.parent;
+                tokens = (_b = this.info) === null || _b === void 0 ? void 0 : _b.get(current);
+                location = tokens === null || tokens === void 0 ? void 0 : tokens.name;
+            }
+            this.diagnostics.push({
+                code: IDLValidationDiagnosticsCode.REFERENCE_IS_NOT_RESOLVED,
+                file: (_c = parentFile.fileName) !== null && _c !== void 0 ? _c : '',
+                message: `Can not resolve reference '${reference.name}' defined in scope '${scopeName}'`,
+                position: [(_d = location === null || location === void 0 ? void 0 : location.position) !== null && _d !== void 0 ? _d : 0, (_f = (_e = location === null || location === void 0 ? void 0 : location.value) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0]
+            });
         }
     }
 }
@@ -70,12 +160,108 @@ IDLLinter.builtinReferences = [
     idl.IDLTopType.name,
     idl.IDLObjectType.name,
 ];
-class IDLLinterError extends Error {
+export class IDLLinterError extends Error {
+    constructor(message, size) {
+        super(message);
+        this.size = size;
+    }
 }
-export function verifyIDLLinter(node, resolver, options) {
-    const result = new IDLLinter(node, resolver, options).visit();
-    if (result.length)
-        throw new IDLLinterError(result);
+function printErrors(errors, text) {
+    errors.sort((a, b) => a.position[0] - b.position[0]);
+    let ptr = 0;
+    let lines = 1;
+    let cols = 1;
+    return errors.map(error => {
+        while (ptr < error.position[0] && ptr < text.length) {
+            if (text[ptr] === '\n') {
+                ++lines;
+                cols = 0;
+            }
+            ++cols;
+            ++ptr;
+        }
+        return `E: IDL${error.code} ${IDLValidationErrorDescription.en_EN[error.code]} -- ${error.file}:${lines}:${cols} ${error.message}`;
+    }).join(EOL);
+}
+function printErrorWithoutLocation(errors) {
+    errors.sort((a, b) => a.position[0] - b.position[0]);
+    return errors.map(error => {
+        return `E: IDL${error.code} ${IDLValidationErrorDescription.en_EN[error.code]} -- ${error.file} ${error.message}`;
+    }).join(EOL);
+}
+function prettyPrintErrors(errors, text) {
+    errors.sort((a, b) => a.position[0] - b.position[0]);
+    const windowSize = 2;
+    let window = [];
+    let ptr = 0;
+    let lines = 1;
+    let cols = 1;
+    let lineBuffer = '';
+    return errors.map(error => {
+        while (ptr < error.position[0] && ptr < text.length) {
+            if (text[ptr] === '\n') {
+                ++lines;
+                cols = 0;
+                while (window.length > windowSize) {
+                    window.shift();
+                }
+                window.push(lineBuffer);
+                lineBuffer = '';
+            }
+            else {
+                if (text[ptr] !== '\r') {
+                    lineBuffer += text[ptr];
+                }
+            }
+            ++cols;
+            ++ptr;
+        }
+        let currentLine = lineBuffer;
+        let ii = ptr;
+        while (ii < text.length && text[ii] !== '\n') {
+            currentLine += text[ii];
+            ++ii;
+        }
+        let errorLine = '       ';
+        ii = 0;
+        while (ii < cols) {
+            errorLine += ' ';
+            ++ii;
+        }
+        ii = 0;
+        errorLine += '\x1b[31m';
+        while (ii < error.position[1]) {
+            errorLine += '~';
+            ++ii;
+        }
+        errorLine += '\x1b[0m';
+        const windowLines = [...window, currentLine].map((line, i) => {
+            const idx = (lines - (window.length - i));
+            const idxText = idx.toString().padStart(5, ' ');
+            const idxColored = idx === lines
+                ? '\x1b[1m' + idxText + '\x1b[0m'
+                : idxText;
+            return idxColored + ' | ' + line;
+        });
+        let errorText = ''
+            + windowLines.join(EOL)
+            + EOL + errorLine + EOL
+            + `\x1b[31mERROR\x1b[0m: IDL${error.code} ${IDLValidationErrorDescription.en_EN[error.code]}`
+            + EOL + `${error.file}:${lines}:${cols} ${error.message}`
+            + EOL;
+        return errorText;
+    }).join(EOL);
+}
+export function verifyIDLLinter(file, resolver, options, info) {
+    var _a, _b;
+    const result = new IDLLinter(file, resolver, options, info).visit();
+    if (result.length) {
+        const isTTY = Boolean(process.stdout.isTTY);
+        const errorMessage = info
+            ? isTTY ? prettyPrintErrors(result, (_a = file.text) !== null && _a !== void 0 ? _a : '') : printErrors(result, (_b = file.text) !== null && _b !== void 0 ? _b : '')
+            : printErrorWithoutLocation(result);
+        throw new IDLLinterError(errorMessage, result.length);
+    }
     return true;
 }
 //# sourceMappingURL=IDLLinter.js.map

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

@@ -65,7 +65,7 @@ export function scanIDL(inputDir, inputFile) {
         ? [path.join(inputDir, inputFile)]
         : fs.readdirSync(inputDir)
             .map((elem) => path.join(inputDir, elem));
-    return files.map(it => toIDLFile(it));
+    return files.map(it => toIDLFile(it)[0]);
 }
 export const licence = `/*
  * Copyright (c) 2024 Huawei Device Co., Ltd.

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

@@ -1,5 +1,14 @@
+import * as webidl2 from "webidl2";
 import * as idl from "../idl";
+export type WebIDLTokenCollection = Record<string, webidl2.Token | null | undefined>;
+export type IDLTokenInfoMap = Map<unknown, WebIDLTokenCollection>;
 export declare function addSyntheticType(name: string, type: idl.IDLEntry): void;
 export declare function resolveSyntheticType(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
-export declare function toIDLFile(fileName: string, content?: string): idl.IDLFile;
+type IDLInheritanceMode = 'single' | 'multiple';
+interface ToIDLFileProps {
+    inheritanceMode?: IDLInheritanceMode;
+    content?: string;
+}
+export declare function toIDLFile(fileName: string, { content, inheritanceMode }?: ToIDLFileProps): [idl.IDLFile, IDLTokenInfoMap];
+export {};
 //# sourceMappingURL=deserialize.d.ts.map