@idlizer/core 2.1.9-arktscgen-5 → 2.1.9-arktscgen-8

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

@@ -5,6 +5,10 @@ export function isInModule(nodeOrPackage, module) {
         return isInModule(idl.getPackageName(nodeOrPackage), module);
     return module.packages.some(modulePackage => nodeOrPackage.startsWith(modulePackage));
 }
+export function isInExternalModule(node) {
+    var _a;
+    return (_a = getModuleFor(node).external) !== null && _a !== void 0 ? _a : false;
+}
 export function getModuleFor(nodeOrPackage) {
     if (typeof nodeOrPackage === "object")
         return getModuleFor(idl.getPackageName(nodeOrPackage));

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

@@ -20,11 +20,9 @@ export declare class UnionRuntimeTypeChecker {
     private convertors;
     private conflictingConvertors;
     private duplicateMembers;
-    private discriminators;
     constructor(convertors: ArgConvertor[]);
     private checkConflicts;
     makeDiscriminator(value: string, convertorIndex: number, writer: LanguageWriter): LanguageExpression;
-    reportConflicts(context: string | undefined, writer: LanguageWriter): void;
 }
 export declare function flattenUnionType(library: LibraryInterface, type: IDLType): IDLType;
 //# sourceMappingURL=unions.d.ts.map

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

@@ -15,8 +15,8 @@
 import { convertType } from "../LanguageWriters";
 import { IDLCustomObjectType, IDLUndefinedType, isType, isUnionType } from '../idl';
 import { collapseTypes } from "./idl/common";
-import { CustomTypeConvertor } from "../LanguageWriters/ArgConvertors";
 import { RuntimeType } from "../LanguageWriters/common";
+import { Language } from "../Language";
 export class UnionFlattener {
     constructor(resolver) {
         this.resolver = resolver;
@@ -53,7 +53,6 @@ export class UnionRuntimeTypeChecker {
         this.convertors = convertors;
         this.conflictingConvertors = new Set();
         this.duplicateMembers = new Set();
-        this.discriminators = [];
         this.checkConflicts();
     }
     checkConflicts() {
@@ -87,31 +86,12 @@ export class UnionRuntimeTypeChecker {
     }
     makeDiscriminator(value, convertorIndex, writer) {
         const convertor = this.convertors[convertorIndex];
-        if (this.conflictingConvertors.has(convertor) && writer.language.needsUnionDiscrimination) {
+        if (this.conflictingConvertors.has(convertor) && writer.language === Language.TS) {
             const discriminator = convertor.unionDiscriminator(value, convertorIndex, writer, this.duplicateMembers);
-            this.discriminators.push([discriminator, convertor, convertorIndex]);
             if (discriminator)
                 return discriminator;
         }
-        return writer.makeNaryOp("||", convertor.runtimeTypes.map((it, runtimeTypeIndex) => writer.makeNaryOp("==", [
-            writer.makeUnionVariantCondition(convertor, value, `${value}_type`, RuntimeType[it], convertorIndex, runtimeTypeIndex)
-        ])));
-    }
-    reportConflicts(context, writer) {
-        if (this.discriminators.filter(([discriminator, _, __]) => discriminator === undefined).length > 1) {
-            let report = `Union discrimination code can not be generated for \`${context}\`.\n`;
-            report += `Possible reasons for that are too similar or unresolved types in union (see below).\n`;
-            report += ` #  | type                          | duplicated properties         | resolved | discriminator expression\n`;
-            const properties = Array.from(this.duplicateMembers).join(",").padEnd(30);
-            this.discriminators.forEach(([discr, conv, n]) => {
-                const num = n.toString().padEnd(3);
-                const typename = conv.targetType(writer).padEnd(30);
-                const resolved = (conv instanceof CustomTypeConvertor ? "no" : "yes").padEnd(9);
-                const discriminator = discr ? discr.asString() : "<undefined>";
-                report += ` ${num}| ${typename}| ${properties}| ${resolved}| ${discriminator}\n`;
-            });
-            // throw new Error(report)
-        }
+        return writer.makeString(writer.discriminate(value, convertorIndex, convertor.idlType, convertor.runtimeTypes));
     }
 }
 export function flattenUnionType(library, type) {

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

@@ -0,0 +1,4 @@
+import * as idl from "../idl";
+import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+export declare function inplaceFQN(node: idl.IDLNode, resolver: ReferenceResolver): void;
+//# sourceMappingURL=FqnTransformer.d.ts.map

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

@@ -0,0 +1,17 @@
+import * as idl from "../idl";
+export function inplaceFQN(node, resolver) {
+    if (idl.isReferenceType(node))
+        inplaceReferenceFQN(node, resolver);
+    idl.forEachChild(node, (child) => {
+        if (idl.isReferenceType(child))
+            inplaceReferenceFQN(child, resolver);
+    });
+}
+function inplaceReferenceFQN(ref, resolver) {
+    const resolved = resolver.resolveTypeReference(ref);
+    if (resolved === undefined) {
+        throw new Error("Can not expand FQN for " + ref.name);
+    }
+    ref.name = idl.getFQName(resolved);
+}
+//# sourceMappingURL=FqnTransformer.js.map

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

@@ -0,0 +1,8 @@
+import * as idl from "../idl";
+import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+export declare function inplaceGenerics(node: idl.IDLNode, resolver: ReferenceResolver, options?: {
+    ignore?: ((node: idl.IDLNode) => boolean)[];
+}): void;
+export declare function isInplacedGeneric(entry: idl.IDLEntry): boolean;
+export declare function maybeRestoreGenerics(maybeTransformedGeneric: idl.IDLReferenceType | idl.IDLEntry, resolver: ReferenceResolver): idl.IDLReferenceType | undefined;
+//# sourceMappingURL=GenericTransformer.d.ts.map

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

@@ -0,0 +1,141 @@
+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 { 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);
+    });
+    if (idl.isReferenceType(node)) {
+        candidates.push(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));
+    candidates.forEach(it => inplaceReferenceGenerics(it, resolver, options));
+}
+export function isInplacedGeneric(entry) {
+    return idl.hasExtAttribute(entry, idl.IDLExtendedAttributes.OriginalGenericName);
+}
+export function maybeRestoreGenerics(maybeTransformedGeneric, resolver) {
+    if (idl.isReferenceType(maybeTransformedGeneric)) {
+        const resolved = resolver.resolveTypeReference(maybeTransformedGeneric);
+        return resolved ? maybeRestoreGenerics(resolved, resolver) : undefined;
+    }
+    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)
+            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 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 createIgnoreMaterializedRule(resolver) {
+    return (node) => idl.isInterface(node) && isMaterialized(node, resolver);
+}
+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("|"),
+    });
+    return monomorphizedEntry;
+}
+function hasTypeParameterTypeChild(node) {
+    let result = false;
+    idl.forEachChild(node, (child) => {
+        if (idl.isTypeParameterType(child))
+            result = true;
+    });
+    return result;
+}
+function inplaceReferenceGenerics(ref, resolver, options) {
+    var _a, _b;
+    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);
+    }
+    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);
+}
+//# sourceMappingURL=GenericTransformer.js.map

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

@@ -90,7 +90,9 @@ type StringProperties<T> = {
     [Property in keyof T as (T[Property] extends string ? Property : never)]: T[Property];
 };
 export declare function sorted<T, N extends keyof StringProperties<T>>(array: T[], key: ((value: T) => string) | N): T[];
-export declare function getExtractorName(target: idl.IDLInterface, language: Language, toPtr?: boolean): string;
-export declare function getExternalTypePackage(node: idl.IDLEntry): string | undefined;
+export declare function getExtractor(target: idl.IDLInterface, lang: Language, toPtr?: boolean): {
+    receiver?: string;
+    method: string;
+};
 export {};
 //# sourceMappingURL=util.d.ts.map

package/build/lib/src/util.js

@@ -17,7 +17,8 @@ import * as fs from "fs";
 import * as ts from "typescript";
 import * as idl from "./idl";
 import { Language } from './Language';
-import { generatorConfiguration } from './config';
+import { isInExternalModule } from './peer-generation/modules';
+import { getInternalClassName, getInternalClassQualifiedName } from './peer-generation/Materialized';
 /** True if this is visible outside this file, false otherwise */
 export function isNodePublic(node) {
     return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Public) !== 0;
@@ -690,16 +691,24 @@ export function sorted(array, key) {
     return array.map(it => it)
         .sort((a, b) => comparator.compare(a[key], b[key]));
 }
-export function getExtractorName(target, language, toPtr = true) {
-    // TODO: Update for CJ
-    return toPtr ? `to${target.name}Ptr` : `from${target.name}Ptr`;
-}
-export function getExternalTypePackage(node) {
-    if (!idl.isInterface(node))
-        return undefined;
-    const pack = idl.getPackageName(node);
-    if (generatorConfiguration().externalPackages.includes(pack))
-        return `@${pack}`;
-    return generatorConfiguration().externalTypes.get(node.name);
+function getExtractorClass(target, toPtr = true) {
+    if (isInExternalModule(target)) {
+        const qualifiedName = idl.getQualifiedName(target, "namespace.name");
+        const name = qualifiedName.split(`.`).map(it => capitalize(it)).join("");
+        return name;
+    }
+    return toPtr ? "Peer" : "";
+}
+export function getExtractor(target, lang, toPtr = true) {
+    const receiver = isInExternalModule(target)
+        ? `extractors`
+        : toPtr
+            ? undefined // TBD: update to MaterializedBase when import is updated
+            : (lang == Language.CJ || lang == Language.KOTLIN)
+                ? getInternalClassName(target.name)
+                : getInternalClassQualifiedName(target, "namespace.name", lang);
+    const extractorClass = getExtractorClass(target, toPtr);
+    const method = toPtr ? `to${extractorClass}Ptr` : `from${extractorClass}Ptr`;
+    return { receiver, method };
 }
 //# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.9-arktscgen-5",
+  "version": "2.1.9-arktscgen-8",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,7 +34,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.7.5",
+    "@koalaui/interop": "1.7.6",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },