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

package/build/lib/src/transformers/GenericTransformer.js

@@ -1,21 +1,248 @@
 import { generatorConfiguration } from "../config";
 import { toIdlType } from "../from-idl/deserialize";
 import * as idl from "../idl";
-import { isBuilderClass } from "../peer-generation/BuilderClass";
-import { generateSyntheticIdlNodeName } from "../peer-generation/idl/common";
+import { Language } from "../Language";
+import { StructureNameConvertor } from "../LanguageWriters/convertors/CppConvertors";
 import { isMaterialized } from "../peer-generation/isMaterialized";
-import { inplaceFQN } from "./FqnTransformer";
-export function inplaceGenerics(node, resolver, options) {
-    var _a;
-    const candidates = [];
-    idl.forEachChild(node, () => { }, (child) => {
-        if (idl.isReferenceType(child))
-            candidates.push(child);
+import { LayoutManager } from "../peer-generation/LayoutManager";
+import { createCachedReferenceResolver } from "../peer-generation/ReferenceResolver";
+import { toDeclaration } from "../peer-generation/toDeclaration";
+import { IdlTransformer } from "./IdlTransformer";
+export function genericsTransformer(files, options) {
+    const optionsResolver = createCachedReferenceResolver(files);
+    options.ignore.push(ignoreConfigRule(options.ignoreGenerics), createIgnoreMaterializedRule(optionsResolver), createIgnoreResourceRule(optionsResolver));
+    const defaultsGenericsTransformer = new DefaultGenericsTransformer(createCachedReferenceResolver(files));
+    files = files.map(it => defaultsGenericsTransformer.visit(it)).map(idl.linkParentBack);
+    const resolver = createCachedReferenceResolver(files);
+    const resolverAdditionals = new Map();
+    const library = {
+        language: Language.CPP,
+        files: files,
+        typeConvertor: function (param, type, isOptionalParam) {
+            throw new Error('Function not implemented.');
+        },
+        declarationConvertor: function (param, type, declaration) {
+            throw new Error('Function not implemented.');
+        },
+        createTypeNameConvertor: function (language) {
+            throw new Error('Function not implemented.');
+        },
+        createContinuationCallbackReference: function (continuationType) {
+            throw new Error('Function not implemented.');
+        },
+        getCurrentContext: function () {
+            throw new Error('Function not implemented.');
+        },
+        layout: LayoutManager.Empty(),
+        libraryPrefix: '',
+        resolveTypeReference: function (type, options) {
+            if (resolverAdditionals.has(type.name))
+                return resolverAdditionals.get(type.name);
+            return resolver.resolveTypeReference(type, options);
+        },
+        toDeclaration: function (type) {
+            if (!idl.isType(type) && !idl.isEntry(type))
+                throw new Error("toDeclaration can be performed only on types or entries!");
+            return toDeclaration(type, this);
+        }
+    };
+    const production = new Array();
+    const nameConvertor = new StructureNameConvertor(library);
+    const monomorphizeReferencesTransformer = new GenericsTransformer(library, produced => {
+        const anchorDecl = library.resolveTypeReference(idl.createReferenceType(produced.anchor));
+        const producedFqn = produced.anchor.split('.').slice(0, -1).concat(produced.produced.name).join('.');
+        if (!resolverAdditionals.has(producedFqn)) {
+            resolverAdditionals.set(producedFqn, produced.produced);
+            production.push(produced);
+            // hack to be able calculate FQN for this declaration
+            produced.produced.parent = anchorDecl.parent;
+        }
+    }, {
+        nameConvertor: (node) => nameConvertor.convert(node),
+        ignore: options.ignore,
+        ignoreGenerics: options.ignoreGenerics,
+    });
+    files = files.map(it => monomorphizeReferencesTransformer.visit(it)).map(idl.linkParentBack);
+    const debugInsertedEntries = new Set();
+    const insertProductionTransformer = new InsertProductionTransformer(production, {
+        debugInserted: (node) => debugInsertedEntries.add(node),
     });
-    options !== null && options !== void 0 ? options : (options = {});
-    (_a = options.ignore) !== null && _a !== void 0 ? _a : (options.ignore = []);
-    options.ignore.push(ignoreConfigRule, ignoreBuilderClassRule, createIgnoreMaterializedRule(resolver), createIgnoreResourceRule(resolver));
-    candidates.forEach(it => inplaceReferenceGenerics(it, resolver, options));
+    files = files.map(it => insertProductionTransformer.visit(it)).map(idl.linkParentBack);
+    const debugMissedEntries = new Set(production.filter(it => !debugInsertedEntries.has(it.anchor)).map(it => it.anchor));
+    if (debugMissedEntries.size) {
+        throw new Error(`Failed to insert generated generics for entries ${Array.from(debugMissedEntries).join(', ')}`);
+    }
+    return files;
+}
+class DefaultGenericsTransformer extends IdlTransformer {
+    constructor(resolver) {
+        super();
+        this.resolver = resolver;
+    }
+    visit(node) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        if (idl.isReferenceType(node)) {
+            const decl = this.resolver.resolveTypeReference(node);
+            if (!decl) {
+                console.error(`Can not resolve reference for inplacing default generics ${node.name} in file ${(_a = node.fileName) !== null && _a !== void 0 ? _a : '<unknown>'}`);
+                return this.visitEachChild(node);
+            }
+            if (!idl.isTypedef(decl) && !idl.isInterface(decl) && !idl.isCallback(decl)) {
+                return this.visitEachChild(node);
+            }
+            if (((_c = (_b = decl.typeParameters) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > ((_e = (_d = node.typeArguments) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0)) {
+                const defaults = (_h = (_g = (_f = decl.extendedAttributes) === null || _f === void 0 ? void 0 : _f.find(it => it.name === idl.IDLExtendedAttributes.TypeParametersDefaults)) === null || _g === void 0 ? void 0 : _g.typesValue) !== null && _h !== void 0 ? _h : [];
+                while (defaults.length < decl.typeParameters.length) {
+                    defaults.unshift(undefined);
+                }
+                const typeArguments = Array.from((_j = node.typeArguments) !== null && _j !== void 0 ? _j : []);
+                while (decl.typeParameters.length > typeArguments.length) {
+                    if (defaults[typeArguments.length] === undefined) {
+                        const declarationDetails = `${idl.getFQName(decl)}<${((_k = decl.typeParameters) !== null && _k !== void 0 ? _k : [])
+                            .map((it, index) => `${it}${defaults[index] ? '=' + defaults[index] : ''}`)
+                            .join(', ')}>`;
+                        const referenceDetails = `${node.name}<${typeArguments.map(it => idl.printType(it)).join(", ")}>`;
+                        throw new Error(`Can not validate reference to ${declarationDetails} declaration: reference ${referenceDetails} has not enough generic arguments or declaration does not have enough default generic values. Reference defined at: ${node.fileName}`);
+                    }
+                    typeArguments.push(defaults[typeArguments.length]);
+                }
+                return idl.createReferenceType(node.name, typeArguments, idl.cloneNodeInitializer(node));
+            }
+        }
+        return this.visitEachChild(node);
+    }
+}
+class GenericsTransformer extends IdlTransformer {
+    constructor(resolver, producer, options) {
+        super();
+        this.resolver = resolver;
+        this.producer = producer;
+        this.options = options;
+        this.meaninglessFieldsTransformer = new RemoveMeaninglessFieldsTransformer();
+    }
+    visit(node) {
+        var _a;
+        if (idl.isReferenceType(node)) {
+            const ref = this.visitEachChild(node);
+            if (!((_a = ref.typeArguments) === null || _a === void 0 ? void 0 : _a.length) || hasTypeParameterTypeChild(ref)) {
+                return ref;
+            }
+            const resolved = this.resolver.resolveTypeReference(ref);
+            if (!resolved) {
+                throw new Error(`Can not resolve ${ref.name}`);
+            }
+            if (this.options.ignore.some(it => it(ref) || it(resolved)) ||
+                this.options.ignoreGenerics.includes(idl.getFQName(resolved))) {
+                return ref;
+            }
+            if (!idl.isTypedef(resolved) && !idl.isInterface(resolved) && !idl.isCallback(resolved)) {
+                throw new Error(`Unsupported generics target ${resolved.kind}`);
+            }
+            const inplacedRef = idl.createReferenceType(idl.deriveQualifiedNameFrom(monomorphisedEntryName(resolved, ref.typeArguments, this.options), resolved), undefined, idl.cloneNodeInitializer(ref));
+            if (!this.resolver.resolveTypeReference(inplacedRef)) {
+                const monomorphizedEntry = this.visit(this.monomorphizeEntry(resolved, ref.typeArguments));
+                this.producer({ anchor: idl.getFQName(resolved), produced: monomorphizedEntry });
+            }
+            return inplacedRef;
+        }
+        return this.visitEachChild(node);
+    }
+    monomorphizeEntry(typedEntry, typeArguments) {
+        var _a, _b, _c;
+        if (!idl.isTypedef(typedEntry) && !idl.isInterface(typedEntry) && !idl.isCallback(typedEntry))
+            throw new Error(`Can not monomorphize ${typedEntry.kind}`);
+        if (((_a = typedEntry.typeParameters) === null || _a === void 0 ? void 0 : _a.length) != typeArguments.length)
+            throw new Error(`Trying to monomorphize entry ${typedEntry.name} that accepts ${(_b = typedEntry.typeParameters) === null || _b === void 0 ? void 0 : _b.length} type parameters with ${typeArguments.length} type arguments`);
+        const monomorphizedEntry = idl.clone(typedEntry);
+        monomorphizedEntry.name = monomorphisedEntryName(typedEntry, typeArguments, this.options);
+        monomorphizedEntry.typeParameters = undefined;
+        const nameToType = new Map(typedEntry.typeParameters.map((name, index) => [name, typeArguments[index]]));
+        idl.updateEachChild(monomorphizedEntry, (node) => {
+            var _a;
+            if (idl.isTypeParameterType(node)) {
+                if (!nameToType.has(node.name))
+                    throw new Error(`Can not name ${node.name} in type parameters of ${typedEntry.name}: available are ${(_a = typedEntry.typeParameters) === null || _a === void 0 ? void 0 : _a.join(", ")}`);
+                return idl.clone(nameToType.get(node.name));
+            }
+            return node;
+        });
+        (_c = monomorphizedEntry.extendedAttributes) !== null && _c !== void 0 ? _c : (monomorphizedEntry.extendedAttributes = []);
+        monomorphizedEntry.extendedAttributes.push({
+            name: idl.IDLExtendedAttributes.OriginalGenericName,
+            value: idl.getFQName(typedEntry),
+            typesValue: typeArguments,
+        });
+        this.correctTransformOnSerialize(monomorphizedEntry.extendedAttributes, typeArguments);
+        return this.meaninglessFieldsTransformer.visit(monomorphizedEntry);
+    }
+    correctTransformOnSerialize(extendedAttributes, typeArguments) {
+        const transformOnSerializeAttribute = extendedAttributes.find(it => it.name === idl.IDLExtendedAttributes.TransformOnSerialize);
+        if (transformOnSerializeAttribute === undefined)
+            return;
+        const targetType = toIdlType("", transformOnSerializeAttribute.value);
+        if (idl.isReferenceType(targetType)) {
+            const monomorphizedReference = this.visit(idl.createReferenceType(targetType.name, typeArguments, idl.cloneNodeInitializer(targetType)));
+            transformOnSerializeAttribute.value = monomorphizedReference.name;
+        }
+    }
+}
+class InsertProductionTransformer extends IdlTransformer {
+    constructor(production, options) {
+        super();
+        this.options = options;
+        this.production = new Map();
+        for (const result of production) {
+            if (!this.production.has(result.anchor))
+                this.production.set(result.anchor, []);
+            this.production.get(result.anchor).push(result.produced);
+        }
+    }
+    visit(node) {
+        if (idl.isFile(node)) {
+            if (node.entries.some(it => this.production.has(idl.getFQNameSafe(it)))) {
+                return idl.createFile(node.entries.flatMap(it => {
+                    const fqn = idl.getFQNameSafe(it);
+                    if (this.production.has(fqn)) {
+                        this.options.debugInserted(fqn);
+                        return this.production.get(fqn).concat(this.visit(it));
+                    }
+                    return this.visit(it);
+                }), node.fileName, node.packageClause, idl.cloneNodeInitializer(node));
+            }
+        }
+        if (idl.isNamespace(node)) {
+            if (node.members.some(it => this.production.has(idl.getFQNameSafe(it)))) {
+                return idl.createNamespace(node.name, node.members.flatMap(it => {
+                    const fqn = idl.getFQNameSafe(it);
+                    if (this.production.has(fqn)) {
+                        this.options.debugInserted(fqn);
+                        return this.production.get(fqn).concat(this.visit(it));
+                    }
+                    return this.visit(it);
+                }), idl.cloneNodeInitializer(node));
+            }
+        }
+        return this.visitEachChild(node);
+    }
+}
+class RemoveMeaninglessFieldsTransformer extends IdlTransformer {
+    visit(node) {
+        if (idl.isInterface(node) && node.properties.some(it => isMeaninglessFieldType(it.type))) {
+            return idl.createInterface(node.name, node.subkind, node.inheritance.map(it => this.visit(it)), node.constructors.map(it => this.visit(it)), node.constants.map(it => this.visit(it)), node.properties.filter(it => !isMeaninglessFieldType(it.type)).map(it => this.visit(it)), node.methods.map(it => this.visit(it)), node.callables.map(it => this.visit(it)), node.typeParameters, idl.cloneNodeInitializer(node));
+        }
+        if (idl.isMethod(node) && node.parameters.some(it => isMeaninglessFieldType(it.type))) {
+            return idl.createMethod(node.name, node.parameters.filter(it => !isMeaninglessFieldType(it.type)).map(it => this.visit(it)), this.visit(node.returnType), {
+                isAsync: node.isAsync,
+                isFree: node.isFree,
+                isOptional: node.isOptional,
+                isStatic: node.isStatic,
+            }, idl.cloneNodeInitializer(node), node.typeParameters);
+        }
+        if (idl.isCallback(node) && node.parameters.some(it => isMeaninglessFieldType(it.type))) {
+            return idl.createCallback(node.name, node.parameters.filter(it => !isMeaninglessFieldType(it.type)).map(it => this.visit(it)), this.visit(node.returnType), idl.cloneNodeInitializer(node), node.typeParameters);
+        }
+        return this.visitEachChild(node);
+    }
 }
 export function isInplacedGeneric(entry) {
     return idl.hasExtAttribute(entry, idl.IDLExtendedAttributes.OriginalGenericName);
@@ -27,26 +254,17 @@ export function maybeRestoreGenerics(maybeTransformedGeneric, resolver) {
     }
     if (maybeTransformedGeneric && idl.hasExtAttribute(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName)) {
         const originalName = idl.getExtAttribute(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName);
-        const typeArgumentsAttribute = idl.getExtAttribute(maybeTransformedGeneric, idl.IDLExtendedAttributes.TypeArguments);
-        if (!typeArgumentsAttribute)
+        const typeArguments = idl.getExtAttributeTypesValue(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName);
+        if (!typeArguments)
             throw new Error(`Can not restore original generic type arguments for ${originalName}: no type arguments`);
-        const typeArguments = typeArgumentsAttribute.split(',').map(it => { var _a; return toIdlType((_a = maybeTransformedGeneric.fileName) !== null && _a !== void 0 ? _a : "", it); });
-        return idl.createReferenceType(originalName, typeArguments, {
-            extendedAttributes: [{
-                    name: idl.IDLExtendedAttributes.TypeArguments,
-                    value: typeArgumentsAttribute,
-                }]
-        });
+        return idl.createReferenceType(originalName, typeArguments);
     }
     return undefined;
 }
-function ignoreConfigRule(node) {
-    if (idl.isEntry(node))
-        return generatorConfiguration().ignoreGenerics.includes(idl.getFQName(node));
-    return false;
-}
-function ignoreBuilderClassRule(node) {
-    return idl.isInterface(node) && isBuilderClass(node);
+function ignoreConfigRule(ignoreGenerics) {
+    return (node) => {
+        return idl.isEntry(node) && ignoreGenerics.includes(idl.getFQName(node));
+    };
 }
 function createIgnoreMaterializedRule(resolver) {
     return (node) => idl.isInterface(node) && isMaterialized(node, resolver) && !idl.hasExtAttribute(node, idl.IDLExtendedAttributes.TransformOnSerialize);
@@ -63,40 +281,8 @@ function createIgnoreResourceRule(resolver) {
         return generatorConfiguration().forceResource.includes(declaration.name);
     };
 }
-function monomorphisedEntryName(typedEntry, typeArguments) {
-    return typedEntry.name + "_" + typeArguments.map(generateSyntheticIdlNodeName).join("_");
-}
-function monomorphizeEntry(typedEntry, typeArguments) {
-    var _a, _b, _c, _d;
-    if (!idl.isTypedef(typedEntry) && !idl.isInterface(typedEntry) && !idl.isCallback(typedEntry))
-        throw new Error(`Can not monomorphize ${typedEntry.kind}`);
-    if (((_a = typedEntry.typeParameters) === null || _a === void 0 ? void 0 : _a.length) != typeArguments.length)
-        throw new Error(`Trying to monomorphize entry ${typedEntry.name} that accepts ${(_b = typedEntry.typeParameters) === null || _b === void 0 ? void 0 : _b.length} type parameters with ${typeArguments.length} type arguments`);
-    const monomorphizedEntry = idl.clone(typedEntry);
-    monomorphizedEntry.name = monomorphisedEntryName(typedEntry, typeArguments);
-    monomorphizedEntry.typeParameters = undefined;
-    const nameToType = new Map(typedEntry.typeParameters.map((name, index) => [name, typeArguments[index]]));
-    idl.updateEachChild(monomorphizedEntry, (node) => {
-        var _a;
-        if (idl.isTypeParameterType(node)) {
-            if (!nameToType.has(node.name))
-                throw new Error(`Can not name ${node.name} in type parameters of ${typedEntry.name}: available are ${(_a = typedEntry.typeParameters) === null || _a === void 0 ? void 0 : _a.join(", ")}`);
-            return idl.clone(nameToType.get(node.name));
-        }
-        return node;
-    });
-    monomorphizedEntry.extendedAttributes = (_d = (_c = monomorphizedEntry.extendedAttributes) === null || _c === void 0 ? void 0 : _c.filter(it => {
-        return it.name != idl.IDLExtendedAttributes.TypeParameters;
-    })) !== null && _d !== void 0 ? _d : [];
-    monomorphizedEntry.extendedAttributes.push({
-        name: idl.IDLExtendedAttributes.OriginalGenericName,
-        value: idl.getFQName(typedEntry),
-    }, {
-        name: idl.IDLExtendedAttributes.TypeArguments,
-        value: typeArguments.map(type => idl.printType(type)).join("|"),
-    });
-    inplaceRemoveMeaninglessFields(monomorphizedEntry);
-    return monomorphizedEntry;
+function monomorphisedEntryName(typedEntry, typeArguments, options) {
+    return typedEntry.name + "_" + typeArguments.map(options.nameConvertor).join("_");
 }
 function hasTypeParameterTypeChild(node) {
     let result = false;
@@ -106,101 +292,9 @@ function hasTypeParameterTypeChild(node) {
     });
     return result;
 }
-function inplaceReferenceGenerics(ref, resolver, options) {
-    var _a, _b;
-    inplaceDefaultReferenceGenerics(ref, resolver);
-    if (!((_a = ref.typeArguments) === null || _a === void 0 ? void 0 : _a.length) || hasTypeParameterTypeChild(ref)) {
-        return;
-    }
-    ref.typeArguments.forEach(it => inplaceFQN(it, resolver));
-    const resolved = resolver.resolveTypeReference(ref);
-    if (!resolved) {
-        throw new Error(`Can not resolve ${ref.name}`);
-    }
-    if (((_b = options === null || options === void 0 ? void 0 : options.ignore) === null || _b === void 0 ? void 0 : _b.some(it => it(ref) || it(resolved))) || generatorConfiguration().ignoreGenerics.includes(idl.getFQName(resolved))) {
-        return;
-    }
-    if (!idl.isTypedef(resolved) && !idl.isInterface(resolved) && !idl.isCallback(resolved)) {
-        throw new Error(`Unsupported generics target ${resolved.kind}`);
-    }
-    const inplacedRef = idl.createReferenceType(monomorphisedEntryName(resolved, ref.typeArguments));
-    if (!resolver.resolveTypeReference(inplacedRef)) {
-        const monomorphizedEntry = monomorphizeEntry(resolved, ref.typeArguments);
-        insertEntryNearTo(monomorphizedEntry, resolved);
-        inplaceGenerics(monomorphizedEntry, resolver);
-        correctTransformOnSerialize(resolver, monomorphizedEntry, ref.typeArguments, options);
-    }
-    ref.name = inplacedRef.name;
-    ref.typeArguments = undefined;
-}
-function insertEntryNearTo(entry, anchor) {
-    if (!anchor.parent) {
-        throw new Error(`Entry used as anchor has not parent`);
-    }
-    let parentEntries;
-    if (idl.isFile(anchor.parent)) {
-        parentEntries = anchor.parent.entries;
-    }
-    else if (idl.isNamespace(anchor.parent)) {
-        parentEntries = anchor.parent.members;
-    }
-    else {
-        throw new Error(`Can not insert entry, unknown parent kind ${anchor.parent.kind}`);
-    }
-    parentEntries.splice(parentEntries.indexOf(anchor), 0, entry);
-    idl.linkParentBack(anchor.parent);
-}
-// when generic declaration has TransformOnSerialize attribute, for monomorphized entry we must update that attribute that will look
-// at monomorphized TransformOnSerialize
-function correctTransformOnSerialize(resolver, monomorphizedEntry, typeArguments, options) {
-    const targetName = idl.getExtAttribute(monomorphizedEntry, idl.IDLExtendedAttributes.TransformOnSerialize);
-    if (targetName === undefined) {
-        return;
-    }
-    const targetType = toIdlType("", targetName);
-    if (idl.isReferenceType(targetType)) {
-        targetType.typeArguments = typeArguments;
-        inplaceReferenceGenerics(targetType, resolver, options);
-        idl.updateExtAttribute(monomorphizedEntry, idl.IDLExtendedAttributes.TransformOnSerialize, targetType.name);
-    }
-}
-function inplaceDefaultReferenceGenerics(node, resolver) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    const decl = resolver.resolveTypeReference(node);
-    if (!decl) {
-        console.error(`Can not resolve reference for inplacing default generics ${node.name} in file ${(_a = node.fileName) !== null && _a !== void 0 ? _a : '<unknown>'}`);
-        return;
-    }
-    if (!idl.isTypedef(decl) && !idl.isInterface(decl) && !idl.isCallback(decl)) {
-        return;
-    }
-    if (((_c = (_b = decl.typeParameters) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > ((_e = (_d = node.typeArguments) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0)) {
-        const defaults = (_h = (_g = (_f = decl.extendedAttributes) === null || _f === void 0 ? void 0 : _f.find(it => it.name === idl.IDLExtendedAttributes.TypeParametersDefaults)) === null || _g === void 0 ? void 0 : _g.typesValue) !== null && _h !== void 0 ? _h : [];
-        while (defaults.length < decl.typeParameters.length) {
-            defaults.unshift(undefined);
-        }
-        (_j = node.typeArguments) !== null && _j !== void 0 ? _j : (node.typeArguments = []);
-        while (decl.typeParameters.length > node.typeArguments.length) {
-            if (defaults[node.typeArguments.length] === undefined) {
-                throw new Error(`Can not validate reference to ${idl.getFQName(decl)} declaration: reference has not enough generic arguments or declaration does not have enough default generic values`);
-            }
-            node.typeArguments.push(defaults[node.typeArguments.length]);
-        }
-    }
-}
 function isMeaninglessFieldType(type) {
-    return type === idl.IDLVoidType || type === idl.IDLUndefinedType;
-}
-function inplaceRemoveMeaninglessFields(node, options = { recursive: true }) {
-    if (options.recursive) {
-        idl.forEachChild(node, child => inplaceRemoveMeaninglessFields(child, { recursive: false }));
-        return;
-    }
-    if (idl.isInterface(node)) {
-        node.properties = node.properties.filter(it => !isMeaninglessFieldType(it.type));
-    }
-    if (idl.isMethod(node)) {
-        node.parameters = node.parameters.filter(it => !isMeaninglessFieldType(it.type));
-    }
+    return type === idl.IDLVoidType || type === idl.IDLUndefinedType ||
+        idl.isUnionType(type) && type.types.every(isMeaninglessFieldType) ||
+        idl.isOptionalType(type) && isMeaninglessFieldType(type.type);
 }
 //# sourceMappingURL=GenericTransformer.js.map

package/build/lib/src/transformers/IdlTransformer.d.ts

@@ -0,0 +1,6 @@
+import * as idl from "../idl";
+export declare abstract class IdlTransformer {
+    abstract visit(node: idl.IDLNode): idl.IDLNode;
+    visitEachChild(node: idl.IDLNode): idl.IDLNode;
+}
+//# sourceMappingURL=IdlTransformer.d.ts.map

package/build/lib/src/transformers/IdlTransformer.js

@@ -0,0 +1,7 @@
+import * as idl from "../idl";
+export class IdlTransformer {
+    visitEachChild(node) {
+        return idl.visitChildren(node, this.visit.bind(this));
+    }
+}
+//# sourceMappingURL=IdlTransformer.js.map

package/build/lib/src/transformers/NullTransformer.d.ts

@@ -1,3 +1,3 @@
 import * as idl from "../idl";
-export declare function inplaceNullsAsUndefined(node: idl.IDLNode): void;
+export declare function nullsTransformer(files: idl.IDLFile[]): idl.IDLFile[];
 //# sourceMappingURL=NullTransformer.d.ts.map

package/build/lib/src/transformers/NullTransformer.js

@@ -1,31 +1,37 @@
 import * as idl from "../idl";
 import { generateSyntheticUnionName } from "../peer-generation/idl/common";
-export function inplaceNullsAsUndefined(node) {
-    idl.updateEachChild(node, (child) => {
+import { IdlTransformer } from "./IdlTransformer";
+export function nullsTransformer(files) {
+    const transformer = new NullsTransformer();
+    return files.map(it => transformer.visit(it)).map(idl.linkParentBack);
+}
+class NullsTransformer extends IdlTransformer {
+    visit(node) {
         var _a;
-        if (idl.isOptionalType(child)) {
-            if (idl.isUnionType(child.type) && child.type.types.some(isNullReference)) {
-                child.type.types = child.type.types.filter(it => !isNullReference(it));
-                child.type.name = generateSyntheticUnionName(child.type.types);
-                if (child.type.types.length === 1) {
-                    child.type = child.type.types[0];
-                }
-                (_a = child.extendedAttributes) !== null && _a !== void 0 ? _a : (child.extendedAttributes = []);
-                child.extendedAttributes.push({ name: idl.IDLExtendedAttributes.UnionWithNull });
-                return child;
+        if (idl.isOptionalType(node)) {
+            if (idl.isUnionType(node.type) && node.type.types.some(isNullReference)) {
+                const unionTypes = node.type.types.filter(it => !isNullReference(it)).map(it => this.visit(it));
+                const unionName = generateSyntheticUnionName(unionTypes);
+                const extendedAttributes = ((_a = node.extendedAttributes) !== null && _a !== void 0 ? _a : [])
+                    .concat({ name: idl.IDLExtendedAttributes.UnionWithNull });
+                return idl.createOptionalType(unionTypes.length === 1
+                    ? unionTypes[0]
+                    : idl.createUnionType(unionTypes, unionName, idl.cloneNodeInitializer(node.type)), {
+                    documentation: node.documentation,
+                    extendedAttributes,
+                    fileName: node.fileName,
+                });
             }
         }
-        else if (idl.isUnionType(child)) {
-            if (child.types.some(isNullReference)) {
-                child.types = child.types.filter(it => !isNullReference(it));
-                child.name = generateSyntheticUnionName(child.types);
-                return idl.createOptionalType(child.types.length > 1 ? child : child.types[0], { extendedAttributes: [{
-                            name: idl.IDLExtendedAttributes.UnionOnlyNull
-                        }] });
+        else if (idl.isUnionType(node)) {
+            if (node.types.some(isNullReference)) {
+                const unionTypes = node.types.filter(it => !isNullReference(it)).map(it => this.visit(it));
+                const unionName = generateSyntheticUnionName(unionTypes);
+                return idl.createOptionalType(unionTypes.length === 1 ? unionTypes[0] : idl.createUnionType(unionTypes, unionName, idl.cloneNodeInitializer(node)), { extendedAttributes: [{ name: idl.IDLExtendedAttributes.UnionOnlyNull }] });
             }
         }
-        return child;
-    });
+        return this.visitEachChild(node);
+    }
 }
 function isNullReference(node) {
     return idl.isReferenceType(node) && node.name === idl.IDLNullTypeName;

package/build/lib/src/transformers/OnSerializeTransformer.d.ts

@@ -1,3 +1,3 @@
 import * as idl from "../idl";
-export declare function inplaceTransformOnSerializeFromConfig(node: idl.IDLNode): void;
+export declare function transformOnSerializeTransformer(files: idl.IDLFile[], destinationGetter: (node: idl.IDLNode) => string | undefined): idl.IDLFile[];
 //# sourceMappingURL=OnSerializeTransformer.d.ts.map

package/build/lib/src/transformers/OnSerializeTransformer.js

@@ -1,19 +1,34 @@
-import { generatorConfiguration } from "../config";
 import * as idl from "../idl";
-export function inplaceTransformOnSerializeFromConfig(node) {
-    inplaceTransformOnSerializeSelf(node);
-    idl.updateEachChild(node, child => {
-        inplaceTransformOnSerializeSelf(child);
-        return child;
-    });
+import { IdlTransformer } from "./IdlTransformer";
+export function transformOnSerializeTransformer(files, destinationGetter) {
+    const transformer = new TransformOnSerializeTransformer(destinationGetter);
+    return files.map(it => transformer.visit(it)).map(idl.linkParentBack);
 }
-function inplaceTransformOnSerializeSelf(node) {
-    if (!idl.isEntry(node)) {
-        return;
+class TransformOnSerializeTransformer extends IdlTransformer {
+    constructor(destinationGetter) {
+        super();
+        this.destinationGetter = destinationGetter;
     }
-    const transformation = generatorConfiguration().transformOnSerialize.find(it => it.from === idl.getFQName(node));
-    if (transformation !== undefined) {
-        idl.updateExtAttribute(node, idl.IDLExtendedAttributes.TransformOnSerialize, transformation.to);
+    visit(node) {
+        var _a;
+        if (idl.isInterface(node) || idl.isEnum(node) || idl.isTypedef(node) || idl.isCallback(node)) {
+            const destination = this.destinationGetter(node);
+            if (!destination)
+                return this.visitEachChild(node);
+            const nodeInitializer = idl.cloneNodeInitializer(node);
+            nodeInitializer.extendedAttributes = ((_a = nodeInitializer.extendedAttributes) !== null && _a !== void 0 ? _a : [])
+                .filter(it => it.name !== idl.IDLExtendedAttributes.TransformOnSerialize)
+                .concat({ name: idl.IDLExtendedAttributes.TransformOnSerialize, value: destination });
+            if (idl.isInterface(node))
+                return idl.createInterface(node.name, node.subkind, node.inheritance, node.constructors, node.constants, node.properties, node.methods, node.callables, node.typeParameters, nodeInitializer);
+            if (idl.isEnum(node))
+                return idl.createEnum(node.name, node.elements, nodeInitializer);
+            if (idl.isTypedef(node))
+                return idl.createTypedef(node.name, node.type, node.typeParameters, nodeInitializer);
+            if (idl.isCallback(node))
+                return idl.createCallback(node.name, node.parameters, node.returnType, nodeInitializer, node.typeParameters);
+        }
+        return this.visitEachChild(node);
     }
 }
 //# sourceMappingURL=OnSerializeTransformer.js.map

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

@@ -57,6 +57,9 @@ export declare function getExtractor(target: idl.IDLInterface, lang: Language, t
     receiver?: string;
     method: string;
 };
+export declare function getInitializerFeature(lang: Language): string;
+export declare function getInitializerDefaultValue(decl: idl.IDLEntry, lang: Language): string;
+export declare function getSyntheticTypesFileName(): string;
 export declare function getTransformer(library: LibraryInterface, from: idl.IDLNode, to: idl.IDLNode): {
     receiver?: string;
     method: string;
@@ -66,5 +69,6 @@ export declare function scanDirectory(dir: string, fileFilter: (file: string) =>
 export declare function scanInputDirs(inputDirs: string[]): string[];
 export declare function scanInputDirs(inputDirs: string[], fileExtension: string): string[];
 export declare function scanInputDirs(inputDirs: string[], fileFilter: (file: string) => boolean, recursive: boolean): string[];
+export declare function consoleWarn(message: string): void;
 export {};
 //# sourceMappingURL=util.d.ts.map

package/build/lib/src/util.js

@@ -351,6 +351,21 @@ export function getExtractor(target, lang, toPtr = true) {
     const method = toPtr ? `to${extractorClass}Ptr` : `from${extractorClass}Ptr`;
     return { receiver, method };
 }
+export function getInitializerFeature(lang) {
+    // TBD: update code for KT and CJ
+    return "initializers";
+}
+export function getInitializerDefaultValue(decl, lang) {
+    const parent = decl.parent;
+    const fqn = parent && idl.isProperty(decl)
+        ? `${idl.getFQName(parent)}NS.${decl.name}`
+        : idl.getFQName(decl);
+    // TBD: update code for KT and CJ
+    return `${getInitializerFeature(lang)}.${fqn}`;
+}
+export function getSyntheticTypesFileName() {
+    return "synthetic_types";
+}
 export function getTransformer(library, from, to) {
     const convertor = library.createTypeNameConvertor(Language.CPP);
     return {
@@ -401,4 +416,11 @@ export function scanInputDirs(inputDirs, fileFilter = undefined, recursive = fal
         return path.basename(a).localeCompare(path.basename(b));
     });
 }
+const printedWarnMessages = new Set();
+export function consoleWarn(message) {
+    if (printedWarnMessages.has(message))
+        return;
+    printedWarnMessages.add(message);
+    console.warn(message);
+}
 //# sourceMappingURL=util.js.map