@idlizer/core 2.1.10-arktscgen-7 → 2.1.10-arktscgen-10

package/build/lib/src/LanguageWriters/writers/KotlinLanguageWriter.js

@@ -85,20 +85,20 @@ export class KotlinEnumWithGetter {
         let mangledName = removePoints(idl.getQualifiedName(this.enumEntity, 'namespace.name'));
         writer.writeClass(mangledName, () => {
             const enumType = idl.createReferenceType(this.enumEntity);
-            writer.makeStaticBlock(() => {
+            writer.writeStaticEntitiesBlock(() => {
                 members.forEach(it => {
-                    writer.writeFieldDeclaration(it.name, enumType, [FieldModifier.PUBLIC, FieldModifier.STATIC, FieldModifier.FINAL], false, writer.makeString(`${mangledName}(${it.stringId ? `\"${it.stringId}\"` : it.numberId})`));
+                    writer.writeFieldDeclaration(it.name, enumType, [FieldModifier.PUBLIC, FieldModifier.STATIC, FieldModifier.READONLY], false, writer.makeString(`${mangledName}(${it.stringId ? `\"${it.stringId}\"` : it.numberId})`));
                 });
             });
             const value = 'value';
-            writer.writeFieldDeclaration(value, idl.IDLI32Type, [FieldModifier.PUBLIC], true, writer.makeNull());
+            writer.writeFieldDeclaration(value, idl.IDLI32Type, [FieldModifier.PUBLIC, FieldModifier.READONLY], true);
             const signature = new MethodSignature(idl.IDLVoidType, [idl.IDLI32Type]);
             writer.writeConstructorImplementation('constructor', signature, () => {
                 writer.writeStatement(writer.makeAssign(`this.${value}`, undefined, writer.makeString(signature.argName(0)), false));
             });
             if (isStringEnum) {
                 const stringValue = 'stringValue';
-                writer.writeFieldDeclaration(stringValue, idl.IDLStringType, [FieldModifier.PUBLIC], true, writer.makeNull());
+                writer.writeFieldDeclaration(stringValue, idl.IDLStringType, [FieldModifier.PUBLIC, FieldModifier.READONLY], true);
                 const signature = new MethodSignature(idl.IDLVoidType, [idl.IDLStringType]);
                 writer.writeConstructorImplementation('constructor', signature, () => {
                     writer.writeStatement(writer.makeAssign(`this.${stringValue}`, undefined, writer.makeString(signature.argName(0)), false));
@@ -123,11 +123,11 @@ class KotlinMapForEachStatement {
     }
 }
 export class KotlinThrowErrorStatement {
-    constructor(message) {
-        this.message = message;
+    constructor(exception) {
+        this.exception = exception;
     }
     write(writer) {
-        writer.print(`throw Error("${this.message}")`);
+        writer.print(`throw ${this.exception.asString()}`);
     }
 }
 class KotlinArrayResizeStatement {
@@ -236,11 +236,11 @@ export class KotlinLanguageWriter extends LanguageWriter {
     maybeSemicolon() { return ""; }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? `${superClass}` : undefined;
-        let implementsClause = interfaces ? `${interfaces.join(' , ')}` : undefined;
+        let implementsClause = interfaces ? `${interfaces.join(', ')}` : undefined;
         let inheritancePart = [extendsClause, implementsClause]
             .filter(isDefined)
-            .join(' , ');
-        inheritancePart = inheritancePart.length != 0 ? ' : '.concat(inheritancePart) : '';
+            .join(', ');
+        inheritancePart = inheritancePart.length != 0 ? ': '.concat(inheritancePart) : '';
         this.printer.print(`public open class ${name}${inheritancePart} {`);
         this.pushIndent();
         op(this);
@@ -286,7 +286,11 @@ export class KotlinLanguageWriter extends LanguageWriter {
         prefix = prefix ? prefix.trim() + " " : "";
         const typeParams = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : "";
         const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && signature.isArgOptional(i) ? idl.maybeUnwrapOptionalType(it) : it);
-        this.printer.print(`${prefix}fun ${name}${typeParams}(${normalizedArgs.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}${signature.isArgOptional(index) ? "?" : ``}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
+        if (signature.returnType === idl.IDLThisType) {
+            throw new Error(`Return type 'this' must be substituted when generating for Kotlin`);
+        }
+        const returnTypePart = needReturn ? ": " + this.getNodeName(signature.returnType) : "";
+        this.printer.print(`${prefix}fun ${name}${typeParams}(${normalizedArgs.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}${signature.isArgOptional(index) ? "?" : ``}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${returnTypePart}${needBracket ? " {" : ""}`);
     }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
         const init = initExpr != undefined ? ` = ${initExpr.asString()}` : ``;
@@ -348,30 +352,32 @@ export class KotlinLanguageWriter extends LanguageWriter {
         const realInteropType = this.getNodeName(type);
         let expr;
         switch (realInteropType) {
-            case "UByteArray":
-            case "IntArray":
-            case "FloatArray":
+            case "KUint8ArrayPtr":
+            case "KInt32ArrayPtr":
+            case "KFloat32ArrayPtr":
                 expr = `${varName}Pinned.addressOf(0)`;
                 break;
-            case "KPointer":
             case "KNativePointer":
             case "KSerializerBuffer":
                 expr = `${varName}.toCPointer<CPointed>()!!`;
                 break;
-            case "BigInteger":
+            case "KByte":
+            case "KShort":
+            case "KUShort":
             case "KInt":
+            case "KUInt":
             case "KLong":
+            case "KULong":
             case "KFloat":
             case "KDouble":
-            case "String":
             case "KStringPtr":
-            case "KBoolean":
-            case "Float":
-            case "Double":
-            case "UInt":
-            case "Int":
                 expr = varName;
                 break;
+            case "Boolean": {
+                // small trick to hide all casts Boolean <=> KBoolean in a NativeModule
+                expr = `${varName}.toByte()`;
+                break;
+            }
             default: throw new Error(`Unexpected type ${realInteropType} in interop with Kotlin`);
         }
         return this.makeString(expr);
@@ -381,26 +387,32 @@ export class KotlinLanguageWriter extends LanguageWriter {
         let expr;
         switch (realInteropType) {
             case "KNativePointer":
-            case "KPointer":
                 expr = `${varName}.toLong()`;
                 break;
+            case "KByte":
+            case "KShort":
+            case "KUShort":
             case "KInt":
+            case "KUInt":
             case "KLong":
-            case "BigInteger":
-            case "Float":
-            case "Double":
-            case "Long":
-            case "Int":
+            case "KULong":
+            case "KFloat":
+            case "KDouble":
                 expr = varName;
                 break;
-            case "String":
             case "KStringPtr":
                 expr = `${varName}?.toKString() ?: ""`;
                 break;
-            case "Boolean":
-            case "KBoolean":
+            case "Boolean": {
+                // small trick to hide all casts Boolean <=> KBoolean in a NativeModule
                 expr = `${varName} != 0.toByte()`;
                 break;
+            }
+            case "Any": {
+                // unsupported case for now, implementation returns Unit (analogue of void) instead of a real object
+                expr = varName;
+                break;
+            }
             case "KInteropReturnBuffer":
                 expr = `${varName}.useContents { KInteropReturnBuffer(length, data.toLong()) }`;
                 break;
@@ -409,19 +421,20 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return this.makeString(expr);
     }
     writeMethodDeclaration(name, signature, modifiers) {
-        this.writeDeclaration(name, signature, true, false, modifiers);
+        this.writeDeclaration(name, signature, true, false, modifiers, []);
     }
     writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
         const delegationType = ((delegationCall === null || delegationCall === void 0 ? void 0 : delegationCall.delegationType) == DelegationType.THIS) ? "this" : "super";
         const superInvocation = delegationCall
             ? ` : ${delegationType}(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")})`
-            : "";
+            : ``;
         const argList = signature.args.map((it, index) => {
             var _a;
             const maybeDefault = ((_a = signature.defaults) === null || _a === void 0 ? void 0 : _a[index]) ? ` = ${signature.defaults[index]}` : "";
             return `${signature.argName(index)}: ${this.getNodeName(it)}${maybeDefault}`;
         }).join(", ");
-        this.print(`constructor(${argList})${superInvocation} {`);
+        const modifierList = modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(" ") + " " : "";
+        this.print(`${modifierList}constructor(${argList})${superInvocation} {`);
         this.pushIndent();
         op(this);
         this.popIndent();
@@ -494,6 +507,8 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return new KotlinLambdaExpression(this, signature, this.resolver, body);
     }
     makeThrowError(message) {
+        if (typeof message === 'string')
+            message = this.makeString(`Error("${message}")`);
         return new KotlinThrowErrorStatement(message);
     }
     makeReturn(expr) {
@@ -590,7 +605,7 @@ export class KotlinLanguageWriter extends LanguageWriter {
         throw new Error("Not implemented");
     }
     get supportedModifiers() {
-        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.OVERRIDE];
+        return [MethodModifier.PUBLIC, MethodModifier.PROTECTED, MethodModifier.PRIVATE, MethodModifier.OVERRIDE, MethodModifier.OPEN];
     }
     get supportedFieldModifiers() {
         return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.OVERRIDE];
@@ -605,7 +620,7 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return new KotlinEnumWithGetter(enumEntity, options.isExport);
     }
     castToBoolean(value) {
-        return `if (${value}) { 1 } else { 0 }`;
+        return value;
     }
     castToInt(value, bitness) {
         return `${this.escapeKeyword(value)}.${bitness == 8 ? 'toByte()' : 'toInt()'}`;
@@ -616,15 +631,17 @@ export class KotlinLanguageWriter extends LanguageWriter {
     makeNewObject(objectName, params = []) {
         return new KotlinNewObjectExpression(objectName, params);
     }
+    makeFunctionReference(name) {
+        return this.makeString(`::${name}`);
+    }
+    makeMethodReference(receiver, method) {
+        return this.makeString(`${receiver}::${method}`);
+    }
     escapeKeyword(keyword) {
         return keyword;
     }
-    makeStaticBlock(op) {
-        this.printer.print('companion object {');
-        this.printer.pushIndent();
-        op(this);
-        this.popIndent();
-        this.printer.print('}');
+    writeStaticEntitiesBlock(op) {
+        this.writePrefixedBlock("companion object", op);
     }
     pushNamespace(namespace, options) { }
     popNamespace(options) { }

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.d.ts

@@ -71,7 +71,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeNull(type?: idl.IDLOptionalType): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
-    makeThrowError(message: string): LanguageStatement;
+    makeThrowError(message: string | LanguageExpression): LanguageStatement;
     makeReturn(expr: LanguageExpression): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.js

@@ -63,11 +63,11 @@ class TSUnwrapOptionalExpression {
 //                         STATEMENTS                         //
 ////////////////////////////////////////////////////////////////
 class TSThrowErrorStatement {
-    constructor(message) {
-        this.message = message;
+    constructor(exception) {
+        this.exception = exception;
     }
     write(writer) {
-        writer.print(`throw new Error('${this.message}')`);
+        writer.print(`throw ${this.exception.asString()}`);
     }
 }
 export class TSReturnStatement extends ReturnStatement {
@@ -339,6 +339,8 @@ export class TSLanguageWriter extends LanguageWriter {
         return new TSLambdaExpression(this, this.typeConvertor, signature, this.resolver, body);
     }
     makeThrowError(message) {
+        if (typeof message === 'string')
+            message = this.makeString(`new Error('${message}')`);
         return new TSThrowErrorStatement(message);
     }
     makeReturn(expr) {

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

@@ -18,4 +18,10 @@ export interface LibraryInterface extends ReferenceResolver {
      */
     libraryPrefix: string;
 }
+export declare function getTransformer(library: LibraryInterface, from: idl.IDLNode, to: idl.IDLNode): {
+    module: string;
+    ns?: string;
+    method: string;
+};
+export declare function mapLibraryName(node: idl.IDLEntry, lang: Language, mapping?: Map<string, Map<string, string>>, prefix?: string): string;
 //# sourceMappingURL=LibraryInterface.d.ts.map

package/build/lib/src/LibraryInterface.js

@@ -1,2 +1,23 @@
-export {};
+import * as idl from "./idl";
+import { Language } from "./Language";
+import { getModuleFor } from "./peer-generation/modules";
+export function getTransformer(library, from, to) {
+    const convertor = library.createTypeNameConvertor(Language.CPP);
+    const withNS = Language.supportNS(library.language);
+    const handwritten = library.layout.handwrittenPackage();
+    return {
+        module: withNS ? handwritten : `${handwritten}.extractors`,
+        ns: withNS ? "extractors" : undefined,
+        method: `transform_${convertor.convert(from)}_to_${convertor.convert(to)}`
+    };
+}
+export function mapLibraryName(node, lang, mapping, prefix = "@") {
+    var _a, _b;
+    const module = getModuleFor(node);
+    if (module.tsLikePackage !== undefined) {
+        return `^` + module.tsLikePackage;
+    }
+    const packageName = idl.getPackageName(node);
+    return `^` + ((_b = (_a = mapping === null || mapping === void 0 ? void 0 : mapping.get(packageName)) === null || _a === void 0 ? void 0 : _a.get(lang.name)) !== null && _b !== void 0 ? _b : `${prefix}${packageName}`);
+}
 //# sourceMappingURL=LibraryInterface.js.map

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

@@ -1,11 +1,12 @@
 import { stringOrNone } from "../util";
-import { IDLCallback, IDLConstructor, IDLEntry, IDLEnum, IDLInterface, IDLMethod, IDLParameter, IDLProperty, IDLTypedef, IDLNamespace, IDLFile, IDLImport, IDLReferenceType, IDLCallable, IDLConstant, SignatureTag, IDLVersion } from "../idl";
+import { IDLCallback, IDLConstructor, IDLEntry, IDLEnum, IDLInterface, IDLMethod, IDLParameter, IDLProperty, IDLTypedef, IDLNamespace, IDLFile, IDLImport, IDLCallable, IDLConstant, SignatureTag, IDLVersion } from "../idl";
 import { Language } from "../Language";
+import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 export declare class CustomPrintVisitor {
     private resolver;
     private language;
     output: string[];
-    constructor(resolver: (type: IDLReferenceType) => IDLEntry | undefined, language: Language);
+    constructor(resolver: ReferenceResolver, language: Language);
     currentInterface?: IDLInterface;
     visit(node: IDLEntry, wrapNamespaces?: boolean): void;
     printMetadata(node: IDLEnum): void;

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

@@ -12,12 +12,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { indentedBy, isInNamespace } from "../util";
-import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName, IDLObjectType, isConstant, } from "../idl";
-import { resolveSyntheticType, parseIDLFile } from "./deserialize";
+import { indentedBy } from "../util";
+import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName, IDLObjectType, isConstant, isInNamespace, } from "../idl";
+import { parseIDLFile } from "./deserialize";
 import { Language } from "../Language";
 import { warn } from "../util";
 import { isInIdlize } from "../idl";
+import { maybeRestoreThrows } from "../transformers/transformUtils";
 export class CustomPrintVisitor {
     constructor(resolver, language) {
         this.resolver = resolver;
@@ -208,7 +209,7 @@ export class CustomPrintVisitor {
         // Let's skip imported declarations
         if (isTypedef(node) &&
             hasExtAttribute(node, IDLExtendedAttributes.Import)) {
-            let definition = this.resolver(createReferenceType(node));
+            let definition = this.resolver.resolveTypeReference(createReferenceType(node));
             // TODO: handle namespace case better!
             // TODO: namespace-related-to-rework
             //throw new Error("not implemented yet")
@@ -269,8 +270,10 @@ export class CustomPrintVisitor {
             this.output.push(this.indented(value));
     }
     printTypeForTS(type, undefinedToVoid, sequenceToArrayInterface = false, isCommonMethod = false) {
+        var _a;
         if (!type)
             throw new Error("Missing type");
+        type = (_a = maybeRestoreThrows(type, this.resolver)) !== null && _a !== void 0 ? _a : type;
         if (isOptionalType(type))
             return `${this.printTypeForTS(type.type, undefinedToVoid, sequenceToArrayInterface)} | undefined`;
         if (isPrimitiveType(type)) {
@@ -320,7 +323,7 @@ export class CustomPrintVisitor {
     toTypeName(node) {
         var _a, _b;
         if (isReferenceType(node)) {
-            const decl = this.resolver(node);
+            const decl = this.resolver.resolveTypeReference(node);
             if (decl) {
                 if (isSyntheticEntry(decl)) {
                     if (isInterface(decl)) {
@@ -365,7 +368,7 @@ export class CustomPrintVisitor {
     }
 }
 export function idlToDtsString(name, content) {
-    let printer = new CustomPrintVisitor(resolveSyntheticType, Language.TS);
+    let printer = new CustomPrintVisitor({ resolveTypeReference: () => undefined, toDeclaration: () => IDLVoidType }, Language.TS);
     const idlFile = parseIDLFile(name, content);
     printer.printPackage(idlFile);
     linearizeNamespaceMembers(idlFile.entries).forEach(it => {

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

@@ -31,7 +31,7 @@ interface Token {
     value: string;
     location: Location;
 }
-type ModifierToken = "static" | "readonly" | "async";
+type ModifierToken = "static" | "readonly" | "async" | "optional";
 type ModifiersContainer = {
     [Key in ModifierToken]?: Token;
 };

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

@@ -69,7 +69,7 @@ const unsupportedDeclarations = new Set(["deleter", "getter", "includes", "inher
 const interfaceContent = new Set([idl.IDLKind.Constructor, idl.IDLKind.Const, idl.IDLKind.Property, idl.IDLKind.Method, idl.IDLKind.Callable]);
 const globalContent = new Set([idl.IDLKind.Namespace, idl.IDLKind.Interface, idl.IDLKind.Enum, idl.IDLKind.Method, idl.IDLKind.Typedef, idl.IDLKind.Callback, idl.IDLKind.Import, idl.IDLKind.Version, idl.IDLKind.Const]);
 const havingBlocks = new Set([idl.IDLKind.Namespace, idl.IDLKind.Interface, idl.IDLKind.Enum]);
-const modifierTokens = new Set(["static", "readonly", "async"]);
+const modifierTokens = new Set(["static", "readonly", "async", "optional"]);
 // Uncomment in case of parser debugging
 function trac(s) {
     // console.log(s)
@@ -402,7 +402,7 @@ export class Parser {
             }
             switch (this.curValue) {
                 case "attribute":
-                    this.assertPossibleModifiers("static", "readonly");
+                    this.assertPossibleModifiers("static", "readonly", "optional");
                     return this.parseAttribute();
                 case "callback":
                     return this.parseCallback();
@@ -737,7 +737,7 @@ export class Parser {
         const ext = this.consumeCurrentExtended();
         const isReadonly = !!this.currentModifiers.readonly;
         const isStatic = !!this.currentModifiers.static;
-        const isOptional = extractOptional(ext);
+        let isOptional = !!this.currentModifiers.optional || extractOptional(ext);
         this.skip("attribute");
         const type = this.parseType();
         const name = this.parseSingleIdentifier();

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

@@ -1,5 +1,5 @@
 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";
+import { IDLCallable, IDLCallback, IDLConstant, IDLConstructor, IDLContainerKind, IDLContainerType, IDLEntry, IDLEnum, IDLEnumMember, IDLExtendedAttribute, IDLFile, IDLImport, IDLInterface, IDLInterfaceSubkind, IDLMethod, IDLNamespace, IDLNode, IDLOptionalType, IDLParameter, IDLPrimitiveType, IDLProperty, IDLReferenceType, IDLType, IDLTypedef, IDLTypeParameterType, IDLUnionType, IDLVersion } from "./node";
 export type IDLNodeInitializer = {
     extendedAttributes?: IDLExtendedAttribute[];
     fileName?: string;
@@ -40,4 +40,39 @@ export declare function createCallback(name: string, parameters: IDLParameter[],
 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;
+export declare function generateSyntheticIdlNodeName(type: IDLType): string;
+export declare function generateSyntheticUnionName(types: IDLType[]): string;
+export declare const IDLPointerType: IDLPrimitiveType;
+export declare const IDLVoidType: IDLPrimitiveType;
+export declare const IDLBooleanType: IDLPrimitiveType;
+export declare const IDLI8Type: IDLPrimitiveType;
+export declare const IDLU8Type: IDLPrimitiveType;
+export declare const IDLI16Type: IDLPrimitiveType;
+export declare const IDLU16Type: IDLPrimitiveType;
+export declare const IDLI32Type: IDLPrimitiveType;
+export declare const IDLU32Type: IDLPrimitiveType;
+export declare const IDLI64Type: IDLPrimitiveType;
+export declare const IDLU64Type: IDLPrimitiveType;
+export declare const IDLF16Type: IDLPrimitiveType;
+export declare const IDLF32Type: IDLPrimitiveType;
+export declare const IDLF64Type: IDLPrimitiveType;
+export declare const IDLBigintType: IDLPrimitiveType;
+export declare const IDLNumberType: IDLPrimitiveType;
+export declare const IDLStringType: IDLPrimitiveType;
+export declare const IDLAnyType: IDLPrimitiveType;
+export declare const IDLUndefinedType: IDLPrimitiveType;
+export declare const IDLUnknownType: IDLPrimitiveType;
+export declare const IDLObjectType: IDLPrimitiveType;
+export declare const IDLThisType: IDLPrimitiveType;
+export declare const IDLDate: IDLPrimitiveType;
+export declare const IDLBufferType: IDLPrimitiveType;
+export declare const IDLUint8ArrayType: IDLContainerType;
+export declare const IDLSerializerBuffer: IDLPrimitiveType;
+export declare const IDLFunctionType: IDLPrimitiveType;
+export declare const IDLCustomObjectType: IDLPrimitiveType;
+export declare const IDLInteropReturnBufferType: IDLPrimitiveType;
+export declare const IDLNullTypeName = "idlize.stdlib.Null";
+export declare const IDLThrowsTypeName = "idlize.stdlib.Throws";
+export declare function isUndefinedType(type: IDLNode): type is IDLPrimitiveType;
+export declare function isVoidType(type: IDLNode): type is IDLPrimitiveType;
 //# sourceMappingURL=builders.d.ts.map

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

@@ -12,8 +12,8 @@
  * 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 { capitalize } from "../util";
+import { isOptionalType, getFQName, isContainerType, isNamedNode, isPrimitiveType } from "./discriminators";
 import { IDLKind } from "./node";
 const innerIdlSymbol = Symbol("innerIdlSymbol");
 export function createPrimitiveType(name) {
@@ -132,4 +132,64 @@ export function createConstant(name, type, value, nodeInitializer = {}) {
         type,
         value }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
+export function generateSyntheticIdlNodeName(type) {
+    if (isPrimitiveType(type))
+        return capitalize(type.name);
+    if (isContainerType(type)) {
+        const typeArgs = type.elementType.map(it => generateSyntheticIdlNodeName(it)).join("_").replaceAll(".", "_");
+        switch (type.containerKind) {
+            case "sequence": return "Array_" + typeArgs;
+            case "record": return "Map_" + typeArgs;
+            case "Promise": return "Promise_" + typeArgs;
+            default: throw new Error(`Unknown container type ${type.containerKind}`);
+        }
+    }
+    if (isNamedNode(type))
+        return type.name.split('.').map(capitalize).join('_');
+    if (isOptionalType(type))
+        return `Opt_${generateSyntheticIdlNodeName(type.type)}`;
+    throw `Can not compute type name of ${IDLKind[type.kind]}`;
+}
+export function generateSyntheticUnionName(types) {
+    return `Union_${types.map(it => generateSyntheticIdlNodeName(it)).join("_").replaceAll(".", "_")}`;
+}
+/// STANDARD LIBRARY
+export const IDLPointerType = createPrimitiveType('pointer');
+export const IDLVoidType = createPrimitiveType('void');
+export const IDLBooleanType = createPrimitiveType('boolean');
+export const IDLI8Type = createPrimitiveType('i8');
+export const IDLU8Type = createPrimitiveType('u8');
+export const IDLI16Type = createPrimitiveType('i16');
+export const IDLU16Type = createPrimitiveType('u16');
+export const IDLI32Type = createPrimitiveType('i32');
+export const IDLU32Type = createPrimitiveType('u32');
+export const IDLI64Type = createPrimitiveType('i64');
+export const IDLU64Type = createPrimitiveType('u64');
+export const IDLF16Type = createPrimitiveType('f16');
+export const IDLF32Type = createPrimitiveType('f32');
+export const IDLF64Type = createPrimitiveType('f64');
+export const IDLBigintType = createPrimitiveType("bigint");
+export const IDLNumberType = createPrimitiveType('number');
+export const IDLStringType = createPrimitiveType('String');
+export const IDLAnyType = createPrimitiveType('any');
+export const IDLUndefinedType = createPrimitiveType('undefined');
+export const IDLUnknownType = createPrimitiveType('unknown');
+export const IDLObjectType = createPrimitiveType('Object');
+export const IDLThisType = createPrimitiveType('this');
+export const IDLDate = createPrimitiveType('date');
+export const IDLBufferType = createPrimitiveType('buffer');
+export const IDLUint8ArrayType = createContainerType('sequence', [IDLU8Type]);
+export const IDLSerializerBuffer = createPrimitiveType('SerializerBuffer');
+// Stub for IdlPeerLibrary
+export const IDLFunctionType = createPrimitiveType('Function');
+export const IDLCustomObjectType = createPrimitiveType('CustomObject');
+export const IDLInteropReturnBufferType = createPrimitiveType('InteropReturnBuffer');
+export const IDLNullTypeName = "idlize.stdlib.Null";
+export const IDLThrowsTypeName = "idlize.stdlib.Throws";
+export function isUndefinedType(type) {
+    return isPrimitiveType(type) && type.name === IDLUndefinedType.name;
+}
+export function isVoidType(type) {
+    return isPrimitiveType(type) && type.name === IDLVoidType.name;
+}
 //# sourceMappingURL=builders.js.map

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

@@ -44,5 +44,8 @@ export interface IDLPrintOptions {
     allowUnknownKinds: boolean;
 }
 export declare function toIDLString(file: IDLFile, options: Partial<IDLPrintOptions>): string;
+export declare const DebugUtils: {
+    debugPrintType: (type: IDLType) => string;
+};
 export {};
 //# sourceMappingURL=dump.d.ts.map

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

@@ -13,10 +13,10 @@
  * limitations under the License.
  */
 import { IndentedPrinter } from "../IndentedPrinter";
+import { IDLNullTypeName, IDLStringType, IDLUndefinedType } from "./builders";
 import { isInterface, isOptionalType, isPrimitiveType, isContainerType, isReferenceType, isUnionType, isTypeParameterType, hasExtAttribute } from "./discriminators";
 import { IDLKeywords } from "./keywords";
 import { IDLExtendedAttributes, IDLKind } from "./node";
-import { IDLNullTypeName, IDLUndefinedType, IDLStringType } from "./stdlib";
 export function escapeIDLKeyword(name) {
     return name + (IDLKeywords.has(name) ? "_" : "");
 }
@@ -43,8 +43,16 @@ export function printType(type, options) {
     }
     if (isPrimitiveType(type))
         return type.name;
-    if (isContainerType(type))
-        return `${type.containerKind}<${type.elementType.map(it => printType(it)).join(", ")}>`;
+    if (isContainerType(type)) {
+        const maybeExtendedAttributes = type.extendedAttributes && type.extendedAttributes.length
+            ? `[${quoteAttributeValues(type.extendedAttributes)}] `
+            : '';
+        const res = `${maybeExtendedAttributes}${type.containerKind}<${type.elementType.map(it => printType(it)).join(", ")}>`;
+        if (maybeExtendedAttributes.length) {
+            return `(${res})`;
+        }
+        return res;
+    }
     if (isReferenceType(type)) {
         const maybeExtendedAttributes = type.extendedAttributes && type.extendedAttributes.length
             ? `[${quoteAttributeValues(type.extendedAttributes)}] `
@@ -128,8 +136,9 @@ export class IDLWriter {
     printProperty(idl) {
         const staticMod = idl.isStatic ? "static " : "";
         const readonlyMod = idl.isReadonly ? "readonly " : "";
+        const optional = idl.isOptional ? "optional " : "";
         return this.printExtendedAttributes(idl)
-            .print(`${staticMod}${readonlyMod}attribute ${nameWithType(idl)};`);
+            .print(`${staticMod}${readonlyMod}${optional}attribute ${nameWithType(idl)};`);
     }
     printExtendedAttributes(idl) {
         var _a;
@@ -324,4 +333,13 @@ export function toIDLString(file, options) {
     file.entries.forEach(it => writer.printIDL(it, options));
     return writer.getOutput().join("\n");
 }
+export const DebugUtils = {
+    debugPrintType: (type) => {
+        const filename = type.fileName ? `, fileName: '${type.fileName}'` : "";
+        if (isContainerType(type)) {
+            return `[IDLType, name: '${printType(type)}', kind: '${IDLKind[type.kind]}', elements: [${type.elementType.map(DebugUtils.debugPrintType).join(', ')}]${filename}]`;
+        }
+        return `[IDLType, name: '${printType(type)}', kind: '${IDLKind[type.kind]}'${filename}]`;
+    },
+};
 //# sourceMappingURL=dump.js.map

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

@@ -3,7 +3,6 @@ export * from './discriminators';
 export * from './dump';
 export * from './keywords';
 export * from './node';
-export * from './stdlib';
 export * from './utils';
 export * from './visitors';
 //# sourceMappingURL=index.d.ts.map

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

@@ -17,7 +17,6 @@ export * from './discriminators';
 export * from './dump';
 export * from './keywords';
 export * from './node';
-export * from './stdlib';
 export * from './utils';
 export * from './visitors';
 //# sourceMappingURL=index.js.map

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

@@ -35,6 +35,7 @@ export declare enum IDLExtendedAttributes {
     Accessor = "Accessor",
     Annotations = "Annotations",
     Async = "Async",
+    AsRecord = "AsRecord",
     CallSignature = "CallSignature",
     CommonMethod = "CommonMethod",
     Component = "Component",

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

@@ -51,6 +51,7 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["Accessor"] = "Accessor";
     IDLExtendedAttributes["Annotations"] = "Annotations";
     IDLExtendedAttributes["Async"] = "Async";
+    IDLExtendedAttributes["AsRecord"] = "AsRecord";
     IDLExtendedAttributes["CallSignature"] = "CallSignature";
     IDLExtendedAttributes["CommonMethod"] = "CommonMethod";
     IDLExtendedAttributes["Component"] = "Component";

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

@@ -29,6 +29,7 @@ export declare const IDLFunctionType: IDLPrimitiveType;
 export declare const IDLCustomObjectType: IDLPrimitiveType;
 export declare const IDLInteropReturnBufferType: IDLPrimitiveType;
 export declare const IDLNullTypeName = "idlize.stdlib.Null";
+export declare const IDLThrowsTypeName = "idlize.stdlib.Throws";
 export declare function isUndefinedType(type: IDLNode): type is IDLPrimitiveType;
 export declare function isVoidType(type: IDLNode): type is IDLPrimitiveType;
 //# sourceMappingURL=stdlib.d.ts.map