@idlizer/core 2.1.10-arktscgen-4 → 2.1.10-arktscgen-6

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

@@ -1,5 +1,19 @@
 import * as idl from "../idl";
 import { DiagnosticMessage, Location } from "../diagnostictypes";
+interface ParseResultOk<T> {
+    ok: true;
+    result: T;
+}
+interface ParseResultFail {
+    ok: false;
+    message: DiagnosticMessage;
+}
+type ParseResult<T> = ParseResultOk<T> | ParseResultFail;
+declare const ParseResult: {
+    ok: <T>(result: T) => ParseResult<T>;
+    fail: <T_1>(message: DiagnosticMessage) => ParseResult<T_1>;
+    unwrap: <T_2>(result: ParseResult<T_2>) => T_2;
+};
 export declare class FatalParserException extends Error {
     diagnosticMessages?: DiagnosticMessage[];
     constructor(diagnosticMessages?: DiagnosticMessage[]);
@@ -27,7 +41,10 @@ export declare class Parser {
     lines: string[];
     offsets: number[];
     constructor(fileName: string, content?: string);
-    parseIDL(): idl.IDLFile;
+    parseIDL<T>(parser: () => T): T;
+    parseIDLFile(): idl.IDLFile;
+    parseIDLType(): idl.IDLType;
+    parseIDLTypeList(): idl.IDLType[];
     _curOffset: number;
     _curLine: number;
     _curToken: Token;
@@ -63,9 +80,10 @@ export declare class Parser {
     currentPackage: string | undefined;
     parseSingleIdentifier(): Token;
     parseFullIdentifier(): Token;
+    parseIdentifierSafe(single?: boolean): ParseResult<Token>;
     parseFullIdentifierOrLiteral(): Token;
     parseLiteral(): Token;
-    parseAndPushGenerics(ext?: idl.IDLExtendedAttribute[]): string[] | undefined;
+    parseAndPushGenerics(ext: idl.IDLExtendedAttribute[] | undefined): string[] | undefined;
     hasGeneric(name: string): boolean;
     parseFile(): idl.IDLFile;
     parseDeclaration(scopeKind: idl.IDLKind): idl.IDLEntry | undefined;

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

@@ -14,8 +14,11 @@
  */
 import * as fs from "fs";
 import * as idl from "../idl";
-import { DiagnosticException } from "../diagnostictypes";
+import { DiagnosticException, MessageSeverityList } from "../diagnostictypes";
 import { DiagnosticMessageGroup, LoadingFatal, InternalFatal } from "../diagnosticmessages";
+const DeprecatedTypeArguments = new DiagnosticMessageGroup("warning", "DeprecatedTypeArguments", "TypeArguments is deprecated", "TypeArguments extended attribute is deprecated");
+const DeprecatedTypeParameters = new DiagnosticMessageGroup("warning", "DeprecatedTypeParameters", "TypeParameters is deprecated", "TypeParameters extended attribute is deprecated");
+const DeprecatedTypedefSyntax = new DiagnosticMessageGroup("warning", "DeprecatedTypedefSyntax", "C-Style typedef syntax is deprecated", "C-Style typedef syntax is deprecated");
 const DuplicateModifier = new DiagnosticMessageGroup("error", "DuplicateModifier", "Duplicate modifier", "Duplicate of");
 const NotApplicableModifier = new DiagnosticMessageGroup("error", "NotApplicableModifier", "Not applicable modifier");
 const DuplicatePackageDeclaration = new DiagnosticMessageGroup("error", "DuplicatePackageDeclaration", "Duplicate package declaration", "Duplicate of");
@@ -33,6 +36,17 @@ const ExpectedReferenceType = new DiagnosticMessageGroup("error", "ExpectedRefer
 const ExpectedGenericArguments = new DiagnosticMessageGroup("error", "ExpectedGenericArguments", "Expected generic arguments");
 const UnexpectedGenericArguments = new DiagnosticMessageGroup("error", "UnexpectedGenericArguments", "Unexpected generic arguments");
 const InlineParsingDepthExceeded = new DiagnosticMessageGroup("fatal", "InlineParsingDepthExceeded", "Inline parsing depth exceeded");
+const ParseResult = {
+    ok: (result) => ({ ok: true, result }),
+    fail: (message) => ({ ok: false, message }),
+    unwrap: (result) => {
+        if (result.ok) {
+            return result.result;
+        }
+        DiagnosticMessageGroup.collectedResults.push(result.message);
+        throw new DiagnosticException(result.message);
+    }
+};
 export class FatalParserException extends Error {
     constructor(diagnosticMessages) {
         super();
@@ -97,20 +111,20 @@ export class Parser {
         this.offsets = prepareOffsets(lines);
         this.lines = lines.map((s) => s.replace(/(\n|\r\n)$/, ""));
     }
-    parseIDL() {
+    parseIDL(parser) {
         var _a;
-        trac("parseIDL");
         const previousDiagnosticsCount = DiagnosticMessageGroup.allGroupsEntries.length;
         try {
             this._lexerNext();
             this._prevToken = this._curToken;
-            let file = this.parseFile();
-            file.text = this.content;
+            let result = parser();
             if (DiagnosticMessageGroup.allGroupsEntries.length != previousDiagnosticsCount) {
-                // Empty for now, messages will be added in following `catch`.
-                throw new FatalParserException();
+                if (DiagnosticMessageGroup.allGroupsEntries.slice(previousDiagnosticsCount).some(msg => MessageSeverityList.indexOf(msg.severity) <= MessageSeverityList.indexOf('error'))) {
+                    // Empty for now, messages will be added in following `catch`.
+                    throw new FatalParserException();
+                }
             }
-            return file;
+            return result;
         }
         catch (e) {
             if (!(e instanceof DiagnosticException) && !(e instanceof FatalParserException)) {
@@ -119,6 +133,22 @@ export class Parser {
             throw new FatalParserException(DiagnosticMessageGroup.allGroupsEntries.slice(previousDiagnosticsCount));
         }
     }
+    parseIDLFile() {
+        trac("parseIDLFile");
+        return this.parseIDL(() => {
+            const file = this.parseFile();
+            file.text = this.content;
+            return file;
+        });
+    }
+    parseIDLType() {
+        trac("parseIDLType");
+        return this.parseIDL(() => this.parseType());
+    }
+    parseIDLTypeList() {
+        trac("parseIDLTypeList");
+        return this.parseIDL(() => this.parseTypeList());
+    }
     _match(re, kind) {
         re.lastIndex = this._curOffset;
         const res = re.exec(this.content);
@@ -246,24 +276,27 @@ export class Parser {
     }
     parseSingleIdentifier() {
         trac("parseSingleIdentifier");
-        const token = this.parseFullIdentifier();
-        if (token.value.includes(".")) {
-            IncorrectIdentifier.throwDiagnosticMessage([this.curLocation]);
-        }
-        return token;
+        return ParseResult.unwrap(this.parseIdentifierSafe(true));
     }
     parseFullIdentifier() {
         trac("parseFullIdentifier");
+        return ParseResult.unwrap(this.parseIdentifierSafe(false));
+    }
+    parseIdentifierSafe(single = false) {
+        trac("parseIdentifierSafe");
         if (this.curKind != TokenKind.Words || literalTypes.has(this.curValue) && this.curValue != "undefined") {
-            UnexpectedToken.throwDiagnosticMessage([this.curLocation], "Unexpected token, expected identifier");
+            return ParseResult.fail(UnexpectedToken.generateDiagnosticMessage([this.curLocation], "Unexpected token, expected identifier"));
+        }
+        if (single && this.curValue.includes(".")) {
+            return ParseResult.fail(IncorrectIdentifier.generateDiagnosticMessage([this.curLocation]));
         }
         if (this.curValue.startsWith("-")) {
             // Valid for identifiers in WebIDL, but not in Idlize
-            IncorrectIdentifier.throwDiagnosticMessage([this.curLocation]);
+            return ParseResult.fail(IncorrectIdentifier.generateDiagnosticMessage([this.curLocation]));
         }
         const token = this.curToken;
         this._lexerNext();
-        return token;
+        return ParseResult.ok(token);
     }
     parseFullIdentifierOrLiteral() {
         trac("parseFullIdentifierOrLiteral");
@@ -286,6 +319,11 @@ export class Parser {
     parseAndPushGenerics(ext) {
         var _a;
         const gen = (_a = extractTypeParameters(ext)) !== null && _a !== void 0 ? _a : [];
+        const found = ext === null || ext === void 0 ? void 0 : ext.find(e => e.name === LEGACY_TYPE_PARAMETERS_ATTRIBUTE);
+        if (found && found.nameLocation) {
+            DeprecatedTypeParameters.reportDiagnosticMessage([found.nameLocation], 'TypeParameters attribute is deprecated, use "<..>" syntax');
+            ext === null || ext === void 0 ? void 0 : ext.splice(ext.indexOf(found), 1);
+        }
         if (this.seeAndSkip("<")) {
             let next = false;
             while (!this.seeAndSkip(">")) {
@@ -298,7 +336,7 @@ export class Parser {
         }
         // To be restored in parseDeclaration
         this._generics.push(gen);
-        return gen;
+        return gen.length === 0 ? undefined : gen;
     }
     hasGeneric(name) {
         return this._generics.some(x => x.includes(name));
@@ -475,7 +513,7 @@ export class Parser {
                 duplicates.add(name.value);
             }
             names.add(name.value);
-            if (name.value == idl.IDLExtendedAttributes.TypeArguments || name.value == idl.IDLExtendedAttributes.TypeParametersDefaults) {
+            if (name.value === LEGACY_TYPE_ARGUMENTS_ATTRIBUTE || name.value === idl.IDLExtendedAttributes.TypeParametersDefaults) {
                 // TypeArguments parsing support
                 try {
                     this._inLiteralParsingLevel += 1;
@@ -553,6 +591,11 @@ export class Parser {
         }
         const name = this.parseFullIdentifier();
         const genArgs = (_a = extractTypeArguments(ext)) !== null && _a !== void 0 ? _a : [];
+        const foundArgAttr = ext === null || ext === void 0 ? void 0 : ext.find(it => it.name === LEGACY_TYPE_ARGUMENTS_ATTRIBUTE);
+        if (foundArgAttr && foundArgAttr.nameLocation) {
+            DeprecatedTypeArguments.reportDiagnosticMessage([foundArgAttr.nameLocation], 'TypeArgument is deprecated extended attribute, use "<..>" syntax');
+            ext === null || ext === void 0 ? void 0 : ext.splice(ext.indexOf(foundArgAttr), 1);
+        }
         if (this.seeAndSkip("<")) {
             let next = false;
             while (!this.seeAndSkip(">")) {
@@ -680,11 +723,13 @@ export class Parser {
         this.skip("const");
         const type = this.parseType();
         const name = this.parseSingleIdentifier();
-        this.skip("=");
-        const value = this.parseLiteral();
+        let value;
+        if (this.seeAndSkip("=")) {
+            value = this.parseLiteral();
+        }
         this.skip(";");
         // Note that raw value (with quoted strings) is used here, that provides compatibility with older code (while being different from `dictionary` processing)
-        return idl.createConstant(name.value, type, value.value, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value.location });
+        return idl.createConstant(name.value, type, value === null || value === void 0 ? void 0 : value.value, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value === null || value === void 0 ? void 0 : value.location });
     }
     parseAttribute() {
         trac("parseAttribute");
@@ -700,17 +745,38 @@ export class Parser {
         return idl.createProperty(name.value, type, isReadonly, isStatic, isOptional, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc(), nameLocation: name.location });
     }
     parseTypedef() {
+        var _a;
         trac("parseTypedef");
         const sloc = this.trackLocation();
         const ext = this.consumeCurrentExtended();
         this.skip("typedef");
         const typeParameters = this.parseAndPushGenerics(ext);
-        const type = this.parseType();
-        const name = this.parseSingleIdentifier();
+        const maybeName = this.parseIdentifierSafe(true);
+        let name;
+        let type;
+        let deprecatedSyntax = false;
+        if (!maybeName.ok) {
+            type = this.parseType();
+            name = this.parseSingleIdentifier();
+            deprecatedSyntax = true;
+        }
+        else if (this.seeAndSkip("=")) {
+            type = this.parseType();
+            name = maybeName.result;
+        }
+        else {
+            type = (_a = builtinTypes.get(maybeName.result.value)) !== null && _a !== void 0 ? _a : idl.createReferenceType(maybeName.result.value, undefined, { extendedAttributes: [], nodeLocation: maybeName.result.location });
+            name = this.parseSingleIdentifier();
+            deprecatedSyntax = true;
+        }
+        this.skip(";");
         if (idl.isUnionType(type)) {
             type.name = name.value;
+            type.extendedAttributes = ext;
+        }
+        if (deprecatedSyntax) {
+            DeprecatedTypedefSyntax.reportDiagnosticMessage([sloc()], "C-Style typedef syntax is deprecated");
         }
-        this.skip(";");
         return idl.createTypedef(name.value, type, typeParameters, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc(), nameLocation: name.location });
     }
     parseCallback() {
@@ -931,13 +997,15 @@ function sanitizeTypeParameter(param) {
     }
     return param;
 }
-function extractTypeParameters(ext) {
-    var _a, _b, _c;
-    return (_c = (_b = (_a = ext === null || ext === void 0 ? void 0 : ext.find(x => x.name == idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.split(",")) === null || _c === void 0 ? void 0 : _c.map(sanitizeTypeParameter);
-}
+const LEGACY_TYPE_PARAMETERS_ATTRIBUTE = "TypeParameters";
+const LEGACY_TYPE_ARGUMENTS_ATTRIBUTE = "TypeArguments";
 function extractTypeArguments(ext) {
     var _a;
-    return (_a = ext === null || ext === void 0 ? void 0 : ext.find(x => x.name == idl.IDLExtendedAttributes.TypeArguments)) === null || _a === void 0 ? void 0 : _a.typesValue;
+    return (_a = ext === null || ext === void 0 ? void 0 : ext.find(x => x.name === LEGACY_TYPE_ARGUMENTS_ATTRIBUTE)) === null || _a === void 0 ? void 0 : _a.typesValue;
+}
+function extractTypeParameters(ext) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = ext === null || ext === void 0 ? void 0 : ext.find(x => x.name === LEGACY_TYPE_PARAMETERS_ATTRIBUTE)) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.split(",")) === null || _c === void 0 ? void 0 : _c.map(sanitizeTypeParameter);
 }
 const builtinTypesList = [idl.IDLPointerType, idl.IDLVoidType, idl.IDLBooleanType,
     idl.IDLObjectType, idl.IDLI8Type, idl.IDLU8Type, idl.IDLI16Type, idl.IDLU16Type,

package/build/lib/src/idl/builders.d.ts

@@ -0,0 +1,43 @@
+import { Location } from "../diagnostictypes";
+import { IDLCallable, IDLCallback, IDLConstant, IDLConstructor, IDLContainerKind, IDLContainerType, IDLEntry, IDLEnum, IDLEnumMember, IDLExtendedAttribute, IDLFile, IDLImport, IDLInterface, IDLInterfaceSubkind, IDLMethod, IDLNamespace, IDLOptionalType, IDLParameter, IDLPrimitiveType, IDLProperty, IDLReferenceType, IDLType, IDLTypedef, IDLTypeParameterType, IDLUnionType, IDLVersion } from "./node";
+export type IDLNodeInitializer = {
+    extendedAttributes?: IDLExtendedAttribute[];
+    fileName?: string;
+    documentation?: string;
+    nodeLocation?: Location;
+    nameLocation?: Location;
+    valueLocation?: Location;
+};
+export declare function createPrimitiveType(name: string): IDLPrimitiveType;
+export declare function createOptionalType(element: IDLType, nodeInitializer?: IDLNodeInitializer): IDLOptionalType;
+export declare function createNamespace(name: string, members?: IDLEntry[], nodeInitializer?: IDLNodeInitializer): IDLNamespace;
+export declare function createVersion(value: string[], nodeInitializer?: IDLNodeInitializer): IDLVersion;
+export declare function createReferenceType(name: string, typeArguments?: IDLType[], nodeInitializer?: IDLNodeInitializer): IDLReferenceType;
+export declare function createReferenceType(source: IDLEntry, typeArguments?: IDLType[], nodeInitializer?: IDLNodeInitializer): IDLReferenceType;
+export declare function createContainerType(container: IDLContainerKind, element: IDLType[], nodeInitializer?: IDLNodeInitializer): IDLContainerType;
+export declare function createUnionType(types: IDLType[], name?: string, nodeInitializer?: IDLNodeInitializer): IDLUnionType;
+export declare function createFile(entries: IDLEntry[], fileName?: string, packageClause?: string[], nodeInitializer?: IDLNodeInitializer): IDLFile;
+export declare function createImport(clause: string[], name?: string, nodeInitializer?: IDLNodeInitializer): IDLImport;
+export declare function createEnum(name: string, elements: IDLEnumMember[], nodeInitializer: IDLNodeInitializer): IDLEnum;
+export declare function createEnumMember(name: string, parent: IDLEnum, type: IDLPrimitiveType, initializer: number | string | undefined, nodeInitializer?: IDLNodeInitializer): IDLEnumMember;
+export declare function createInterface(name: string, subkind: IDLInterfaceSubkind, inheritance?: IDLReferenceType[], constructors?: IDLConstructor[], constants?: IDLConstant[], properties?: IDLProperty[], methods?: IDLMethod[], callables?: IDLCallable[], typeParameters?: string[], nodeInitializer?: IDLNodeInitializer): IDLInterface;
+export declare function createProperty(name: string, type: IDLType, isReadonly?: boolean, isStatic?: boolean, isOptional?: boolean, nodeInitializer?: IDLNodeInitializer): IDLProperty;
+export declare function createParameter(name: string, type: IDLType, isOptional?: boolean, isVariadic?: boolean, nodeInitializer?: IDLNodeInitializer): IDLParameter;
+export type IDLMethodInitializer = {
+    isAsync: boolean;
+    isStatic: boolean;
+    isOptional: boolean;
+    isFree: boolean;
+};
+export declare function createMethod(name: string, parameters: IDLParameter[], returnType: IDLType, methodInitializer?: IDLMethodInitializer, nodeInitializer?: IDLNodeInitializer, typeParameters?: string[]): IDLMethod;
+export type IDLCallableInitializer = {
+    isAsync: boolean;
+    isStatic: boolean;
+};
+export declare function createCallable(name: string, parameters: IDLParameter[], returnType: IDLType, callableInitializer: IDLCallableInitializer, nodeInitializer?: IDLNodeInitializer, typeParameters?: string[]): IDLCallable;
+export declare function createConstructor(parameters: IDLParameter[], returnType: IDLType | undefined, nodeInitializer?: IDLNodeInitializer): IDLConstructor;
+export declare function createCallback(name: string, parameters: IDLParameter[], returnType: IDLType, nodeInitializer?: IDLNodeInitializer, typeParameters?: string[]): IDLCallback;
+export declare function createTypeParameterReference(name: string, nodeInitializer?: IDLNodeInitializer): IDLTypeParameterType;
+export declare function createTypedef(name: string, type: IDLType, typeParameters?: string[], nodeInitializer?: IDLNodeInitializer): IDLTypedef;
+export declare function createConstant(name: string, type: IDLType, value?: string, nodeInitializer?: IDLNodeInitializer): IDLConstant;
+//# sourceMappingURL=builders.d.ts.map

package/build/lib/src/idl/builders.js

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { generateSyntheticIdlNodeName } from "../peer-generation/idl/common";
+import { isOptionalType, getFQName } from "./discriminators";
+import { IDLKind } from "./node";
+const innerIdlSymbol = Symbol("innerIdlSymbol");
+export function createPrimitiveType(name) {
+    return {
+        kind: IDLKind.PrimitiveType,
+        name: name,
+        _idlNodeBrand: innerIdlSymbol,
+        _idlTypeBrand: innerIdlSymbol,
+        _idlNamedNodeBrand: innerIdlSymbol,
+    };
+}
+export function createOptionalType(element, nodeInitializer) {
+    if (isOptionalType(element) && !nodeInitializer) {
+        return element;
+    }
+    if (isOptionalType(element)) {
+        return Object.assign(Object.assign({ kind: IDLKind.OptionalType, type: element.type }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
+    }
+    return Object.assign(Object.assign({ kind: IDLKind.OptionalType, type: element }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
+}
+export function createNamespace(name, members, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.Namespace, members: members !== null && members !== void 0 ? members : [], name: name }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createVersion(value, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.Version, value, name: "version" }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createReferenceType(nameOrSource, typeArguments, nodeInitializer) {
+    let name;
+    if (typeof nameOrSource === 'string') {
+        name = nameOrSource;
+    }
+    else {
+        name = getFQName(nameOrSource);
+    }
+    return Object.assign(Object.assign({ kind: IDLKind.ReferenceType, name,
+        typeArguments }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createContainerType(container, element, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.ContainerType, containerKind: container, elementType: element }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
+}
+export function createUnionType(types, name, nodeInitializer) {
+    if (types.length < 2)
+        throw new Error("IDLUnionType should contain at least 2 types");
+    return Object.assign(Object.assign({ kind: IDLKind.UnionType, name: name !== null && name !== void 0 ? name : "Union_" + types.map(it => generateSyntheticIdlNodeName(it)).join("_"), types: types }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createFile(entries, fileName, packageClause = [], nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.File, packageClause, entries: entries, fileName }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol });
+}
+export function createImport(clause, name, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.Import, name: name !== null && name !== void 0 ? name : "", clause }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createEnum(name, elements, nodeInitializer) {
+    const result = Object.assign(Object.assign({ kind: IDLKind.Enum, name: name, elements: elements }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+    elements.forEach(it => it.parent = result);
+    return result;
+}
+export function createEnumMember(name, parent, type, initializer, nodeInitializer = {}) {
+    return Object.assign(Object.assign({ kind: IDLKind.EnumMember, name: name, parent,
+        type,
+        initializer }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createInterface(name, subkind, inheritance = [], constructors = [], constants = [], properties = [], methods = [], callables = [], typeParameters = [], nodeInitializer = {}) {
+    return Object.assign(Object.assign({ kind: IDLKind.Interface, name,
+        subkind,
+        typeParameters,
+        inheritance,
+        constructors,
+        constants,
+        properties,
+        methods,
+        callables }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createProperty(name, type, isReadonly = false, isStatic = false, isOptional = false, nodeInitializer = {}) {
+    return Object.assign(Object.assign({ name, kind: IDLKind.Property, type,
+        isReadonly,
+        isStatic,
+        isOptional }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createParameter(name, type, isOptional = false, isVariadic = false, nodeInitializer = {}) {
+    return Object.assign(Object.assign({ kind: IDLKind.Parameter, name: name, type: type, isOptional,
+        isVariadic }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createMethod(name, parameters, returnType, methodInitializer = {
+    isAsync: false,
+    isStatic: false,
+    isOptional: false,
+    isFree: false,
+}, nodeInitializer = {}, typeParameters = []) {
+    return Object.assign(Object.assign(Object.assign({ kind: IDLKind.Method, name,
+        parameters,
+        returnType,
+        typeParameters }, methodInitializer), nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createCallable(
+// TODO name here seems useless
+name, parameters, returnType, callableInitializer, nodeInitializer, typeParameters = []) {
+    return Object.assign(Object.assign(Object.assign({ kind: IDLKind.Callable, name,
+        parameters,
+        returnType }, callableInitializer), nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createConstructor(parameters, returnType, nodeInitializer = {}) {
+    return Object.assign(Object.assign({ kind: IDLKind.Constructor, name: "$CONSTRUCTOR%", parameters,
+        returnType }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createCallback(name, parameters, returnType, nodeInitializer = {}, typeParameters = []) {
+    return Object.assign(Object.assign({ kind: IDLKind.Callback, name, parameters, returnType, typeParameters }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createTypeParameterReference(name, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.TypeParameterType, name: name }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createTypedef(name, type, typeParameters = [], nodeInitializer = {}) {
+    return Object.assign(Object.assign({ name, type, typeParameters, kind: IDLKind.Typedef }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+export function createConstant(name, type, value, nodeInitializer = {}) {
+    return Object.assign(Object.assign({ kind: IDLKind.Const, name,
+        type,
+        value }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
+//# sourceMappingURL=builders.js.map

package/build/lib/src/idl/discriminators.d.ts

@@ -0,0 +1,53 @@
+import { stringOrNone } from "../util";
+import { IDLNode, IDLFile, IDLPrimitiveType, IDLContainerType, IDLReferenceType, IDLEnum, IDLEnumMember, IDLUnionType, IDLTypeParameterType, IDLInterface, IDLImport, IDLCallable, IDLMethod, IDLParameter, IDLConstructor, IDLProperty, IDLCallback, IDLConstant, IDLTypedef, IDLType, IDLEntry, IDLNamespace, IDLExtendedAttributes, IDLOptionalType, IDLVersion, IDLNamedNode } from "./node";
+export declare function isFile(node: IDLNode): node is IDLFile;
+export declare function isPrimitiveType(type: IDLNode): type is IDLPrimitiveType;
+export declare function isContainerType(type: IDLNode): type is IDLContainerType;
+export declare function isReferenceType(type: IDLNode): type is IDLReferenceType;
+export declare function isEnum(type: IDLNode): type is IDLEnum;
+export declare function isEnumMember(type: IDLNode): type is IDLEnumMember;
+export declare function isUnionType(type: IDLNode): type is IDLUnionType;
+export declare function isTypeParameterType(type: IDLNode): type is IDLTypeParameterType;
+export declare function isInterface(node: IDLNode): node is IDLInterface;
+export declare function isImport(type: IDLNode): type is IDLImport;
+export declare function isCallable(node: IDLNode): node is IDLCallable;
+export declare function isMethod(node: IDLNode): node is IDLMethod;
+export declare function isParameter(node: IDLNode): node is IDLParameter;
+export declare function isConstructor(node: IDLNode): node is IDLConstructor;
+export declare function isProperty(node: IDLNode): node is IDLProperty;
+export declare function isCallback(node: IDLNode): node is IDLCallback;
+export declare function isInterfaceSubkind(idl: IDLInterface): boolean;
+export declare function isClassSubkind(idl: IDLInterface): boolean;
+export declare function isConstant(node: IDLNode): node is IDLConstant;
+export declare function isTypedef(node: IDLNode): node is IDLTypedef;
+export declare function isType(node: IDLNode): node is IDLType;
+export declare function isEntry(node: IDLNode): node is IDLEntry;
+export declare function isNamespace(node: IDLNode): node is IDLNamespace;
+export declare function isSyntheticEntry(node: IDLNode): boolean;
+export declare function isOptionalType(type: IDLNode): type is IDLOptionalType;
+export declare function isVersion(node: IDLNode): node is IDLVersion;
+export declare function isNamedNode(type: IDLNode): type is IDLNamedNode;
+export declare const IDLContainerUtils: {
+    isRecord: (x: IDLNode) => boolean;
+    isSequence: (x: IDLNode) => boolean;
+    isPromise: (x: IDLNode) => boolean;
+};
+export declare function hasExtAttribute(node: IDLNode, attribute: IDLExtendedAttributes): boolean;
+export declare function getExtAttribute(node: IDLNode, name: IDLExtendedAttributes): stringOrNone;
+export declare function removeExtAttribute(node: IDLNode, name: IDLExtendedAttributes): void;
+export declare function getExtAttributeTypesValue(node: IDLNode, name: IDLExtendedAttributes): IDLType[] | undefined;
+export declare function updateExtAttribute(node: IDLNode, name: IDLExtendedAttributes, value: string | undefined): void;
+export declare function getNamespacesPathFor(node: IDLNode): IDLNamespace[];
+export declare function getFileFor(node: IDLNode): IDLFile | undefined;
+export declare function getPackageClause(node: IDLNode): string[];
+export declare function getPackageName(node: IDLNode): string;
+export declare function getPackageNameSafe(node: IDLNode): string | undefined;
+export declare function isInPackage(entry: IDLEntry | IDLFile, packageName: string, exactMatch?: boolean): boolean;
+export declare function getNamespaceName(a: IDLEntry): string;
+export type QNPattern = "package.namespace.name" | "namespace.name" | "name";
+export declare function deriveQualifiedNameFrom(name: string, from: IDLNode): string;
+export declare function getQualifiedName(a: IDLNode, pattern: QNPattern): string;
+export declare function getFQName(a: IDLNode): string;
+export declare function getFQNameSafe(a: IDLNode): string | undefined;
+export declare function fetchNamespaceFrom(pointOfView?: IDLNode): IDLNamespace | undefined;
+//# sourceMappingURL=discriminators.d.ts.map