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

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

@@ -12,6 +12,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import * as idl from '../idl';
+import { getPov, resolveNamedNode } from '../resolveNamedNode';
+import { consoleWarn } from '../util';
 export function createEmptyReferenceResolver() {
     return {
         resolveTypeReference() {
@@ -25,13 +28,101 @@ export function createEmptyReferenceResolver() {
 /** Please do not store any global instances */
 export function createAlternativeReferenceResolver(mainResolver, alternatives) {
     return {
-        resolveTypeReference(type, terminalImports) {
+        resolveTypeReference(type, options) {
             var _a;
-            return (_a = mainResolver.resolveTypeReference(type, terminalImports)) !== null && _a !== void 0 ? _a : alternatives.get(type.name);
+            return (_a = mainResolver.resolveTypeReference(type, options)) !== null && _a !== void 0 ? _a : alternatives.get(type.name);
         },
         toDeclaration(type) {
             return mainResolver.toDeclaration(type);
         },
     };
 }
+export function createAlgotithmicReferenceResolver(files, useFallback = false) {
+    const resolveFallback = (type) => {
+        const target = type.name.split('.');
+        const resolveds = new Set();
+        for (let file of files) {
+            const result = resolveNamedNode([...file.packageClause, ...target], undefined, files);
+            if (result && idl.isEntry(result)) {
+                // too much spam
+                // console.warn(`WARNING: Type reference '${qualifiedName}' is not resolved from ${povAsReadableString} but resolved from some package '${file.packageClause().join(".")}'`)
+                resolveds.add(result);
+            }
+        }
+        // and from each namespace
+        const traverseNamespaces = (entry) => {
+            if (entry && idl.isNamespace(entry) && entry.members.length) {
+                const resolved = resolveNamedNode([...idl.getNamespacesPathFor(entry).map(it => it.name), ...target], undefined, files);
+                if (resolved) {
+                    console.warn(`WARNING: Name '${type.name}' resolved by fallback from some namespace: '${idl.getNamespacesPathFor(resolved).map(obj => obj.name).join(".")}'`);
+                    resolveds.add(resolved);
+                }
+                entry.members.forEach(traverseNamespaces);
+            }
+        };
+        files.forEach(file => file.entries.forEach(traverseNamespaces));
+        if (resolveds.size > 1)
+            console.error(`Resolved multiple possible declarations by ${idl.DebugUtils.debugPrintType(type)}`);
+        return resolveds.size ? resolveds.values().next().value : undefined;
+    };
+    return {
+        resolveTypeReference(type, options) {
+            var _a;
+            let result = (_a = resolveNamedNode(type.name.split("."), getPov(type), files)) !== null && _a !== void 0 ? _a : (useFallback ? resolveFallback(type) : undefined);
+            if (!(options === null || options === void 0 ? void 0 : options.terminalImports)) {
+                const seen = new Set;
+                while (result) {
+                    let nextResult = undefined;
+                    if (idl.isImport(result))
+                        nextResult = resolveNamedNode(result.clause, undefined, files);
+                    if (!nextResult)
+                        break;
+                    if (seen.has(nextResult)) {
+                        console.warn(`Cyclic referenceType: ${type.name}, seen: [${[...seen.values()].map(idl.getFQName).join(", ")}]`);
+                        break;
+                    }
+                    seen.add(nextResult);
+                    result = nextResult;
+                }
+            }
+            if (result) {
+                if (!idl.isEntry(result)) {
+                    throw new Error(`Resolved reference ${idl.DebugUtils.debugPrintType(type)} to not entry type`);
+                }
+                if (idl.isNamespace(result)) {
+                    throw new Error(`Resolved reference ${idl.DebugUtils.debugPrintType(type)} to namespace`);
+                }
+                return result;
+            }
+            return undefined;
+        },
+        toDeclaration(type) {
+            throw new Error("To declaration is not available for default references resolver");
+        }
+    };
+}
+export function createCachedReferenceResolver(files) {
+    const cache = new Map();
+    for (const file of files) {
+        idl.forEachChild(file, node => {
+            if (idl.isEnum(node) || idl.isCallback(node) || idl.isInterface(node) || idl.isTypedef(node)) {
+                const fqn = idl.getFQName(node);
+                if (cache.has(fqn))
+                    consoleWarn(`WARNING: multiple entries with FQN=${fqn} found`);
+                else
+                    cache.set(fqn, node);
+            }
+        });
+    }
+    return {
+        resolveTypeReference(type, options) {
+            if (!(options === null || options === void 0 ? void 0 : options.unresolvedOk) && !cache.has(type.name))
+                consoleWarn(`WARNING: reference ${idl.DebugUtils.debugPrintType(type)} was not found`);
+            return cache.get(type.name);
+        },
+        toDeclaration(type) {
+            throw new Error("Not implemented");
+        },
+    };
+}
 //# sourceMappingURL=ReferenceResolver.js.map

package/build/lib/src/peer-generation/idl/common.d.ts

@@ -1,12 +1,16 @@
 import * as idl from "../../idl";
 import { Language } from "../../Language";
+import { IdlNameConvertor } from "../../LanguageWriters";
 export declare function generateSyntheticIdlNodeName(type: idl.IDLType): string;
 export declare function qualifiedName(decl: idl.IDLNode, languageOrDelimiter: Language | string, pattern: idl.QNPattern): string;
 export declare function collapseTypes(types: idl.IDLType[], name?: string): idl.IDLType;
-export declare function generifiedTypeName(refType: idl.IDLReferenceType | undefined, refName?: string): string | undefined;
+export declare function generifiedTypeName(refType: idl.IDLReferenceType, nameConvertor: IdlNameConvertor, refName?: string): string;
 export declare function sanitizeGenerics(genericDeclarationString: string): string;
 export declare function generateSyntheticUnionName(types: idl.IDLType[]): string;
 export declare function generateSyntheticFunctionParameterName(parameter: idl.IDLParameter): string;
-export declare function generateSyntheticFunctionName(parameters: idl.IDLParameter[], returnType: idl.IDLType, isAsync?: boolean): string;
+export declare function generateSyntheticFunctionName(parameters: idl.IDLParameter[], returnType: idl.IDLType, options?: {
+    isAsync?: boolean;
+    nameConvertor?: IdlNameConvertor;
+}): string;
 export declare function isImportAttr(decl: idl.IDLNode): boolean;
 //# sourceMappingURL=common.d.ts.map

package/build/lib/src/peer-generation/idl/common.js

@@ -54,11 +54,9 @@ export function collapseTypes(types, name) {
     });
     return uniqueTypes.length === 1 ? uniqueTypes[0] : idl.createUnionType(uniqueTypes, name);
 }
-export function generifiedTypeName(refType, refName) {
+export function generifiedTypeName(refType, nameConvertor, refName) {
     var _a;
-    if (!refType)
-        return undefined;
-    const typeArgs = (_a = refType.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it) /* FIXME: BUG! */).join(",");
+    const typeArgs = (_a = refType.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => nameConvertor.convert(it)).join(",");
     return `${refName ? refName : refType.name}${typeArgs ? `<${typeArgs}>` : ``}`;
 }
 export function sanitizeGenerics(genericDeclarationString) {
@@ -81,9 +79,11 @@ export function generateSyntheticFunctionParameterName(parameter) {
     }
     return generateSyntheticIdlNodeName(parameter.type);
 }
-export function generateSyntheticFunctionName(parameters, returnType, isAsync = false) {
-    let prefix = isAsync ? "AsyncCallback" : "Callback";
-    const names = parameters.map(generateSyntheticFunctionParameterName).concat(generateSyntheticIdlNodeName(returnType));
+export function generateSyntheticFunctionName(parameters, returnType, options) {
+    let prefix = (options === null || options === void 0 ? void 0 : options.isAsync) ? "AsyncCallback" : "Callback";
+    const names = (options === null || options === void 0 ? void 0 : options.nameConvertor) !== undefined
+        ? parameters.map(it => options.nameConvertor.convert(it.type)).concat(options.nameConvertor.convert(returnType))
+        : parameters.map(generateSyntheticFunctionParameterName).concat(generateSyntheticIdlNodeName(returnType));
     return `${prefix}_${names.join("_").replaceAll(".", "_")}`;
 }
 export function isImportAttr(decl) {

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

@@ -14,18 +14,17 @@
  */
 import { generatorConfiguration } from '../config';
 import * as idl from '../idl';
-import { isBuilderClass } from './BuilderClass';
 import { getSuper } from './getSuperType';
 export function isMaterialized(declaration, resolver) {
     var _a;
     if (!idl.isInterfaceSubkind(declaration) && !idl.isClassSubkind(declaration))
         return false;
-    if (idl.isHandwritten(declaration) || isBuilderClass(declaration))
+    if (idl.isHandwritten(declaration))
         return false;
     if (generatorConfiguration().forceResource.includes(declaration.name)) {
         return false;
     }
-    if (generatorConfiguration().forceMaterialized.some(r => r === idl.getFQName(declaration))) {
+    if (generatorConfiguration().forceMaterialized.some(r => r === idl.getFQNameSafe(declaration))) {
         return true;
     }
     // TODO: rework this

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

@@ -51,6 +51,8 @@ function getApplicableModuleFor(packageName) {
         if (packageName.startsWith(`idlize.`)) {
             return currentModule();
         }
+        if (packageName === `synthetic`)
+            return currentModule();
         const modules = [...config.modules.keys()].map(it => `"${it}"`).join(", ");
         throw new Error(`Package "${packageName}" is not listed in any module.`
             + ` Add the "${packageName}" to the existed list of modules [${modules}] or new one in the configuration file`);

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

@@ -0,0 +1,4 @@
+import { ReferenceResolver } from "./ReferenceResolver";
+import * as idl from "../idl";
+export declare function toDeclaration(type: idl.IDLType | idl.IDLEntry, resolver: ReferenceResolver): idl.IDLEntry | idl.IDLType;
+//# sourceMappingURL=toDeclaration.d.ts.map

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

@@ -0,0 +1,53 @@
+import * as idl from "../idl";
+import { ArkCustomObject, ArkDate, ArkFunction, forceTypedefAsResource } from "./PeerLibrary";
+import { warn } from "../util";
+import { toIdlType } from "../from-idl/deserialize";
+import { isImportAttr } from "./idl/common";
+export function toDeclaration(type, resolver) {
+    switch (type) {
+        case idl.IDLAnyType: return ArkCustomObject;
+        case idl.IDLVoidType: return idl.IDLVoidType;
+        case idl.IDLUndefinedType: return idl.IDLUndefinedType;
+        case idl.IDLUnknownType: return ArkCustomObject;
+        // case idl.IDLObjectType: return ArkCustomObject
+    }
+    const typeName = idl.isNamedNode(type) ? type.name : undefined;
+    switch (typeName) {
+        case "object":
+        case "Object": return idl.IDLObjectType;
+    }
+    if (idl.isReferenceType(type)) {
+        // TODO: remove all this!
+        if (type.name === 'Date') {
+            return ArkDate;
+        }
+        if (type.name === 'AnimationRange') {
+            return ArkCustomObject;
+        }
+        if (type.name === 'Function') {
+            return ArkFunction;
+        }
+        if (type.name === 'Optional') {
+            return toDeclaration(type.typeArguments[0], resolver);
+        }
+        const decl = resolver.resolveTypeReference(type);
+        if (!decl) {
+            warn(`undeclared type ${idl.DebugUtils.debugPrintType(type)}`);
+        }
+        if (decl && idl.isTypedef(decl) && forceTypedefAsResource(resolver, type, decl)) {
+            return idl.IDLObjectType;
+        }
+        if (decl && idl.hasExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize)) {
+            const type = toIdlType("", idl.getExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize));
+            return toDeclaration(type, resolver);
+        }
+        return !decl ? ArkCustomObject // assume some builtin type
+            : idl.isTypedef(decl) ? toDeclaration(decl.type, resolver)
+                : decl;
+    }
+    if (isImportAttr(type)) {
+        return ArkCustomObject;
+    }
+    return type;
+}
+//# sourceMappingURL=toDeclaration.js.map

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

@@ -22,7 +22,7 @@ export declare class UnionRuntimeTypeChecker {
     private duplicateMembers;
     constructor(convertors: ArgConvertor[]);
     private checkConflicts;
-    makeDiscriminator(value: string, convertorIndex: number, writer: LanguageWriter): LanguageExpression;
+    makeDiscriminator(value: string, convertorIndex: number, writer: LanguageWriter, library: LibraryInterface, type?: IDLType): LanguageExpression;
 }
 export declare function flattenUnionType(library: LibraryInterface, type: IDLType): IDLType;
 //# sourceMappingURL=unions.d.ts.map

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

@@ -12,6 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import * as idl from '../idl';
 import { convertType } from "../LanguageWriters";
 import { IDLCustomObjectType, IDLUndefinedType, isType, isUnionType } from '../idl';
 import { collapseTypes } from "./idl/common";
@@ -84,14 +85,21 @@ export class UnionRuntimeTypeChecker {
             }
         });
     }
-    makeDiscriminator(value, convertorIndex, writer) {
-        const convertor = this.convertors[convertorIndex];
-        if (this.conflictingConvertors.has(convertor) && writer.language === Language.TS) {
-            const discriminator = convertor.unionDiscriminator(value, convertorIndex, writer, this.duplicateMembers);
-            if (discriminator)
-                return discriminator;
+    makeDiscriminator(value, convertorIndex, writer, library, type) {
+        let convertor = this.convertors[convertorIndex];
+        if (writer.language === Language.TS) {
+            const isArray = idl.IDLContainerUtils.isSequence(convertor.idlType);
+            if (isArray || this.conflictingConvertors.has(convertor)) {
+                // Check elements inside array
+                if (type && convertor.idlType != type) {
+                    convertor = library.typeConvertor("", type);
+                }
+                const discriminator = convertor.unionDiscriminator(value, convertorIndex, writer, this.duplicateMembers);
+                if (discriminator)
+                    return discriminator;
+            }
         }
-        return writer.makeString(writer.discriminate(value, convertorIndex, convertor.idlType, convertor.runtimeTypes));
+        return writer.makeString(writer.discriminate(value, convertorIndex, type !== null && type !== void 0 ? type : convertor.idlType, convertor.runtimeTypes));
     }
 }
 export function flattenUnionType(library, type) {

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

@@ -1,3 +1,4 @@
 import { IDLFile, IDLNode, IDLNamedNode } from "./idl";
+export declare function getPov(node: IDLNode): IDLNode | undefined;
 export declare function resolveNamedNode(target: string[], pov: IDLNode | undefined, corpus: IDLFile[]): IDLNamedNode | undefined;
 //# sourceMappingURL=resolveNamedNode.d.ts.map

package/build/lib/src/resolveNamedNode.js

@@ -14,6 +14,13 @@
  */
 import { isReferenceType, hasExtAttribute, IDLExtendedAttributes } from "./idl";
 import { isFile, isNamedNode, isNamespace, isEnum, isInterface, isImport } from "./idl";
+export function getPov(node) {
+    let result = node;
+    while (result && !(isFile(result) || isNamespace(result))) {
+        result = result.parent;
+    }
+    return result;
+}
 export function resolveNamedNode(target, pov, corpus) {
     let result;
     let povScope = [];

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

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

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

@@ -1,17 +1,25 @@
 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);
-    });
+import { IdlTransformer } from "./IdlTransformer";
+export function fqnTransformer(corpus, resolver) {
+    const transformer = new FqnTransformer(resolver);
+    return corpus.map(file => transformer.visit(file)).map(idl.linkParentBack);
 }
-function inplaceReferenceFQN(ref, resolver) {
-    const resolved = resolver.resolveTypeReference(ref);
-    if (resolved === undefined) {
-        throw new Error("Can not expand FQN for " + ref.name);
+class FqnTransformer extends IdlTransformer {
+    constructor(resolver) {
+        super();
+        this.resolver = resolver;
+    }
+    visit(node) {
+        var _a;
+        if (idl.isReferenceType(node)) {
+            const resolved = this.resolver.resolveTypeReference(node);
+            if (resolved === undefined) {
+                this.resolver.resolveTypeReference(node);
+                throw new Error("Can not expand FQN for " + idl.DebugUtils.debugPrintType(node));
+            }
+            return idl.createReferenceType(idl.getFQName(resolved), (_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.visit(it)), idl.cloneNodeInitializer(node));
+        }
+        return this.visitEachChild(node);
     }
-    ref.name = idl.getFQName(resolved);
 }
 //# sourceMappingURL=FqnTransformer.js.map

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

@@ -1,8 +1,9 @@
 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 genericsTransformer(files: idl.IDLFile[], options: {
+    ignore: ((node: idl.IDLNode) => boolean)[];
+    ignoreGenerics: string[];
+}): idl.IDLFile[];
 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