@idlizer/core 2.0.27 → 2.0.28

package/build/lib/src/LanguageWriters/LanguageWriter.d.ts

@@ -212,9 +212,10 @@ export interface PrinterLike {
 }
 export declare abstract class LanguageWriter {
     printer: IndentedPrinter;
-    protected resolver: ReferenceResolver;
+    resolver: ReferenceResolver;
     language: Language;
-    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, language: Language);
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, // TODO make protected again
+    language: Language);
     indentDepth(): number;
     maybeSemicolon(): string;
     abstract writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
@@ -319,7 +320,7 @@ export declare abstract class LanguageWriter {
     makeSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): MethodSignature;
     makeNamedSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): NamedMethodSignature;
     makeNativeMethodNamedSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): NamedMethodSignature;
-    makeSerializerConstructorSignature(): NamedMethodSignature | undefined;
+    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
     mapFieldModifier(modifier: FieldModifier): string;
     mapMethodModifier(modifier: MethodModifier): string;
     /**

package/build/lib/src/LanguageWriters/LanguageWriter.js

@@ -391,7 +391,8 @@ export class NamedMethodSignature extends MethodSignature {
 //                    LANGUAGE WRITER                         //
 ////////////////////////////////////////////////////////////////
 export class LanguageWriter {
-    constructor(printer, resolver, language) {
+    constructor(printer, resolver, // TODO make protected again
+    language) {
         this.printer = printer;
         this.resolver = resolver;
         this.language = language;
@@ -592,7 +593,7 @@ export class LanguageWriter {
     makeNativeMethodNamedSignature(returnType, parameters) {
         return this.makeNamedSignature(returnType, parameters);
     }
-    makeSerializerConstructorSignature() {
+    makeSerializerConstructorSignatures() {
         return undefined;
     }
     mapFieldModifier(modifier) {

package/build/lib/src/LanguageWriters/convertors/CppConvertors.js

@@ -100,7 +100,7 @@ export class GenericCppConvertor {
             case "Object":
                 return this.make('CustomObject');
         }
-        if (generatorConfiguration().param("parameterized").includes(refName)) {
+        if (generatorConfiguration().parameterized.includes(refName)) {
             return this.make('CustomObject');
         }
         let decl = this.resolver.toDeclaration(type);
@@ -242,7 +242,7 @@ export class CppReturnTypeConvertor {
         if (type == idl.IDLStringType)
             return 'void';
         if (type == idl.IDLNumberType)
-            return generatorConfiguration().param("TypePrefix") + 'Int32'; // :(
+            return generatorConfiguration().TypePrefix + 'Int32'; // :(
         return this.convertor.convert(type);
     }
     convertTypeParameter(type) {
@@ -251,7 +251,7 @@ export class CppReturnTypeConvertor {
     convertTypeReference(type) {
         const decl = this.resolver.resolveTypeReference(type);
         if (decl && idl.isInterface(decl) && isMaterialized(decl, this.resolver)) {
-            return generatorConfiguration().param("TypePrefix") + decl.name;
+            return generatorConfiguration().TypePrefix + decl.name;
         }
         return this.convertor.convert(type);
     }

package/build/lib/src/LanguageWriters/convertors/InteropConvertors.js

@@ -35,13 +35,13 @@ export class InteropReturnTypeConvertor {
             // TODO return array by some way
             return "void";
         }
-        return KInteropReturnBuffer;
+        return "void";
     }
     convertImport(type, importClause) {
         throw new Error(`Cannot pass import type ${type.name} through interop`);
     }
     convertOptional(type) {
-        return 'KInteropReturnBuffer';
+        return 'void';
     }
     convertPrimitiveType(type) {
         switch (type) {
@@ -89,7 +89,7 @@ export class InteropReturnTypeConvertor {
                 return KInteropReturnBuffer;
             }
         }
-        return KInteropReturnBuffer;
+        return "void";
     }
     convertUnion(type) {
         return KInteropReturnBuffer;

package/build/lib/src/LanguageWriters/convertors/JavaConvertors.js

@@ -126,6 +126,7 @@ export class JavaTypeNameConvertor {
             case idl.IDLVoidType: return 'void';
             case idl.IDLDate: return 'Date';
             case idl.IDLBufferType: return 'byte[]';
+            case idl.IDLInteropReturnBufferType: return 'byte[]';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }

package/build/lib/src/LanguageWriters/convertors/TSConvertors.js

@@ -146,6 +146,8 @@ export class TSTypeNameConvertor {
                 return 'Date';
             case idl.IDLBufferType:
                 return `ArrayBuffer`;
+            case idl.IDLInteropReturnBufferType:
+                return `KInteropReturnBuffer`;
         }
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }

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

@@ -310,7 +310,7 @@ export class CJLanguageWriter extends LanguageWriter {
         this.printer.print('}');
     }
     generateFunctionDeclaration(name, signature) {
-        const args = signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`);
+        const args = signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`);
         return `public func ${name}(${args.join(", ")}): ${this.getNodeName(signature.returnType)}`;
     }
     writeMethodCall(receiver, method, params, nullable = false) {
@@ -390,7 +390,7 @@ export class CJLanguageWriter extends LanguageWriter {
     writeDeclaration(name, signature, modifiers, postfix) {
         let prefix = modifiers === null || modifiers === void 0 ? void 0 : modifiers.filter(it => this.supportedModifiers.includes(it)).map(it => this.mapMethodModifier(it)).join(" ");
         prefix = prefix ? prefix + " " : "";
-        this.print(`${prefix}func ${name}(${signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
+        this.print(`${prefix}func ${name}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
     }
     writeNativeFunctionCall(printer, name, signature) {
         printer.print(`return unsafe { ${name}(${signature.args.map((it, index) => `${signature.argName(index)}`).join(", ")}) }`);

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

@@ -109,7 +109,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     stringifyMethodReturnType(type: IDLType, hint?: PrintHint): string;
     stringifyMethodArgType(type: IDLType, hint?: PrintHint): string;
     stringifyTypeWithReceiver(type: IDLType, receiver?: string): string;
-    makeSerializerConstructorSignature(): NamedMethodSignature | undefined;
+    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
     makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
     makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
 }

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

@@ -455,12 +455,16 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         }
         return this.getNodeName(type);
     }
-    makeSerializerConstructorSignature() {
-        return new NamedMethodSignature(IDLVoidType, [
+    makeSerializerConstructorSignatures() {
+        const fromBufferCtor = new NamedMethodSignature(IDLVoidType, [
             IDLUint8ArrayType,
             IDLU32Type,
-            createReferenceType("CallbackResourceHolder" /* ast */)
+            createReferenceType("CallbackResourceHolder")
         ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], [undefined, undefined, undefined, PrintHint.AsPointer]);
+        const ownedDataCtor = new NamedMethodSignature(IDLVoidType, [
+            createReferenceType("CallbackResourceHolder")
+        ], ["resourceHolder"], [`nullptr`], [undefined, PrintHint.AsPointer]);
+        return [ownedDataCtor, fromBufferCtor];
     }
     makeLengthSerializer(serializer, value) {
         return undefined;

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

@@ -88,6 +88,6 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeCallIsObject(value: string): LanguageExpression;
     escapeKeyword(keyword: string): string;
     makeDiscriminatorConvertor(convertor: ArgConvertor, value: string, index: number): LanguageExpression | undefined;
-    makeSerializerConstructorSignature(): NamedMethodSignature | undefined;
+    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
 }
 //# sourceMappingURL=TsLanguageWriter.d.ts.map

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

@@ -390,8 +390,8 @@ export class TSLanguageWriter extends LanguageWriter {
             this.makeNaryOp("<=", [ordinal, this.makeString(high.toString())])
         ]);
     }
-    makeSerializerConstructorSignature() {
-        return new NamedMethodSignature(idl.IDLVoidType, [], []);
+    makeSerializerConstructorSignatures() {
+        return [new NamedMethodSignature(idl.IDLVoidType, [], [])];
     }
 }
 //# sourceMappingURL=TsLanguageWriter.js.map

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

@@ -1,19 +1,16 @@
-export interface GeneratorConfiguration {
-    param<T>(name: string): T;
-    readonly params: Record<string, any>;
-    TypePrefix: string;
-    LibraryPrefix: string;
-    OptionalPrefix: string;
+export interface CoreConfiguration {
+    readonly TypePrefix: string;
+    readonly LibraryPrefix: string;
+    readonly OptionalPrefix: string;
+    readonly rootComponents: string[];
+    readonly standaloneComponents: string[];
+    readonly parameterized: string[];
+    readonly ignoreMaterialized: string[];
+    readonly builderClasses: string[];
+    readonly forceMaterialized: string[];
 }
-export declare class BaseGeneratorConfiguration implements GeneratorConfiguration {
-    readonly params: Record<string, any>;
-    constructor(params?: Record<string, any>);
-    param<T>(name: string): T;
-    get TypePrefix(): string;
-    get LibraryPrefix(): string;
-    get OptionalPrefix(): string;
-}
-export declare function setDefaultConfiguration(config: GeneratorConfiguration): void;
-export declare function generatorConfiguration(): GeneratorConfiguration;
+export declare const defaultCoreConfuguration: CoreConfiguration;
+export declare function setDefaultConfiguration<T extends CoreConfiguration>(config: T): void;
+export declare function generatorConfiguration<T extends CoreConfiguration>(): T;
 export declare function generatorTypePrefix(): string;
 //# sourceMappingURL=config.d.ts.map

package/build/lib/src/config.js

@@ -12,22 +12,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export class BaseGeneratorConfiguration {
-    constructor(params = {}) {
-        this.params = {};
-        Object.assign(this.params, Object.assign({ TypePrefix: "", LibraryPrefix: "", OptionalPrefix: "" }, params));
-    }
-    param(name) {
-        if (name in this.params) {
-            return this.params[name];
-        }
-        throw new Error(`${name} is unknown`);
-    }
-    get TypePrefix() { return this.param("TypePrefix"); }
-    get LibraryPrefix() { return this.param("LibraryPrefix"); }
-    get OptionalPrefix() { return this.param("OptionalPrefix"); }
-}
-let currentConfig = new BaseGeneratorConfiguration();
+export const defaultCoreConfuguration = {
+    TypePrefix: "",
+    LibraryPrefix: "",
+    OptionalPrefix: "",
+    rootComponents: [],
+    standaloneComponents: [],
+    parameterized: [],
+    ignoreMaterialized: [],
+    builderClasses: [],
+    forceMaterialized: [],
+};
+let currentConfig = defaultCoreConfuguration;
 export function setDefaultConfiguration(config) {
     currentConfig = config;
 }
@@ -36,6 +32,6 @@ export function generatorConfiguration() {
 }
 export function generatorTypePrefix() {
     const conf = generatorConfiguration();
-    return `${conf.param("TypePrefix")}${conf.param("LibraryPrefix")}`;
+    return `${conf.TypePrefix}${conf.LibraryPrefix}`;
 }
 //# sourceMappingURL=config.js.map

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

@@ -287,6 +287,7 @@ export declare const IDLUint8ArrayType: IDLContainerType;
 export declare const IDLFunctionType: IDLPrimitiveType;
 export declare const IDLLengthType: IDLPrimitiveType;
 export declare const IDLCustomObjectType: IDLPrimitiveType;
+export declare const IDLInteropReturnBufferType: IDLPrimitiveType;
 export type IDLNodeInitializer = {
     extendedAttributes?: IDLExtendedAttribute[];
     fileName?: string;

package/build/lib/src/idl.js

@@ -333,6 +333,7 @@ export const IDLUint8ArrayType = createContainerType('sequence', [IDLU8Type]);
 export const IDLFunctionType = createPrimitiveType('Function');
 export const IDLLengthType = createPrimitiveType('Length');
 export const IDLCustomObjectType = createPrimitiveType('CustomObject');
+export const IDLInteropReturnBufferType = createPrimitiveType('InteropReturnBuffer');
 export function createNamespace(name, extendedAttributes, fileName) {
     return {
         kind: IDLKind.Namespace,

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

@@ -38,6 +38,7 @@ export * from "./peer-generation/PeerMethod";
 export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
 export * from "./peer-generation/isMaterialized";
+export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";

package/build/lib/src/index.js

@@ -52,6 +52,7 @@ export * from "./peer-generation/PeerMethod";
 export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
 export * from "./peer-generation/isMaterialized";
+export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";

package/build/lib/src/inheritance.js

@@ -39,9 +39,9 @@ export function isCommonMethodOrSubclass(typeChecker, decl) {
     return isSubclass;
 }
 export function determineInheritanceRole(name) {
-    if (generatorConfiguration().param("rootComponents").includes(name))
+    if (generatorConfiguration().rootComponents.includes(name))
         return InheritanceRole.Root;
-    if (generatorConfiguration().param("standaloneComponents").includes(name))
+    if (generatorConfiguration().standaloneComponents.includes(name))
         return InheritanceRole.Standalone;
     return InheritanceRole.Heir;
 }

package/build/lib/src/languageSpecificKeywords.js

@@ -38,7 +38,7 @@ export const CJKeywords = new Set([
     /*'false', */ 'static', 'public', 'private',
     'protected', 'override', 'redef', 'abstract',
     'open', 'operator', 'foreign', 'inout',
-    'prop', 'mut', 'unsafe', 'get', 'set'
+    'prop', 'mut', 'unsafe', 'get', 'set', 'type'
 ]);
 export const IDLKeywords = new Set([
     "attribute", "callback", "object", "toString",

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

@@ -24,7 +24,7 @@ declare function req<A, R>(key: string, fn: (x: A) => R): LibraryQuery<A, R>;
 declare function compose<B, R>(base: LibraryReducer<B>, next: LibraryQuery<B, R>): LibraryReducer<R>;
 declare function concat<A, R1, R2>(f: LibraryQuery<A, R1>, g: LibraryQuery<A, R2>): LibraryQuery<A, [R1, R2]>;
 declare class LensBuilder<R> {
-    private req;
+    req: LibraryReducer<R>;
     private constructor();
     static make<R>(r: LibraryReducer<R>): LensBuilder<R>;
     pipe<T>(r: LibraryQuery<R, T>): LensBuilder<T>;
@@ -48,13 +48,14 @@ export declare const lib: {
         nodes(params: EntitiesParams): LibraryQuery<readonly IDLFile[], idl.IDLNode[]>;
         entries(): LibraryQuery<idl.IDLNode[], idl.IDLEntry[]>;
         interfaces(): LibraryQuery<idl.IDLNode[], idl.IDLInterface[]>;
+        hasExt<T extends idl.IDLNode>(attr: idl.IDLExtendedAttributes): LibraryQuery<T[], T[]>;
         names(): LibraryQuery<idl.IDLNode[], string[]>;
         name(name: string): LibraryReducer<idl.IDLNode[]>;
     };
     utils: {
-        idx: <T>(x: number) => LibraryQuery<T[], T | undefined>;
-        fst: <T_1>() => LibraryQuery<T_1[], T_1 | undefined>;
-        lst: <T_2>() => LibraryQuery<T_2[], T_2 | undefined>;
+        idx: <T_1>(x: number) => LibraryQuery<T_1[], T_1 | undefined>;
+        fst: <T_2>() => LibraryQuery<T_2[], T_2 | undefined>;
+        lst: <T_3>() => LibraryQuery<T_3[], T_3 | undefined>;
     };
     req: typeof req;
     compose: typeof compose;

package/build/lib/src/library.js

@@ -157,6 +157,9 @@ const select = {
     interfaces() {
         return req('interfaces', it => it.filter(idl.isInterface));
     },
+    hasExt(attr) {
+        return req('with_attr=' + serializeParam(attr), it => it.filter(x => idl.hasExtAttribute(x, attr)));
+    },
     names() {
         return req('names', xs => xs.flatMap(x => idl.isNamedNode(x) ? [x.name] : []));
     },

package/build/lib/src/peer-generation/BuilderClass.js

@@ -32,7 +32,7 @@ export class BuilderClass {
  */
 export function isBuilderClass(declaration) {
     const className = declaration.name;
-    if (generatorConfiguration().param("builderClasses").includes(className)) {
+    if (generatorConfiguration().builderClasses.includes(className)) {
         return true;
     }
     if (isCustomBuilderClass(className)) {

package/build/lib/src/peer-generation/LayoutManager.d.ts

@@ -1,7 +1,8 @@
 import { IDLEntry } from "../idl";
 export declare enum LayoutNodeRole {
     PEER = 0,
-    INTERFACE = 1
+    INTERFACE = 1,
+    GLOBAL = 2
 }
 export interface LayoutManagerStrategy {
     resolve(node: IDLEntry, role: LayoutNodeRole): string;

package/build/lib/src/peer-generation/LayoutManager.js

@@ -16,6 +16,7 @@ export var LayoutNodeRole;
 (function (LayoutNodeRole) {
     LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
     LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
+    LayoutNodeRole[LayoutNodeRole["GLOBAL"] = 2] = "GLOBAL";
 })(LayoutNodeRole || (LayoutNodeRole = {}));
 export class LayoutManager {
     constructor(strategy) {

package/build/lib/src/peer-generation/PeerFile.d.ts

@@ -8,6 +8,7 @@ export declare class PeerFile implements LibraryFileInterface {
     readonly peers: Map<string, PeerClass>;
     constructor(originalFilename: string, entries: idl.IDLEntry[], isPredefined?: boolean);
     packageName(): string;
+    package(): idl.IDLPackage | undefined;
     get peersToGenerate(): PeerClass[];
 }
 //# sourceMappingURL=PeerFile.d.ts.map

package/build/lib/src/peer-generation/PeerFile.js

@@ -21,7 +21,7 @@ export class PeerFile {
         this.peers = new Map();
     }
     packageName() {
-        let packageTag = this.entries.find(it => idl.isPackage(it));
+        const packageTag = this.package();
         if (packageTag === undefined) {
             return "";
         }
@@ -30,6 +30,9 @@ export class PeerFile {
         }
         return packageTag.name;
     }
+    package() {
+        return this.entries.find(it => idl.isPackage(it));
+    }
     get peersToGenerate() {
         const peers = Array.from(this.peers.values());
         return peers;