@idlizer/core 2.1.2 → 2.1.7

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

@@ -14,6 +14,7 @@
  */
 import { warn } from 'console';
 import * as idl from '../idl';
+import { resolveNamedNode } from '../resolveNamedNode';
 import { Language } from '../Language';
 import { createLanguageWriter } from '../LanguageWriters';
 import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ClassConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, ObjectConvertor, } from "../LanguageWriters/ArgConvertors";
@@ -30,6 +31,7 @@ import { lib, query } from '../library';
 import { isMaterialized } from './isMaterialized';
 import { isInIdlizeInternal } from '../idlize';
 import { isInCurrentModule } from './modules';
+import { generatorConfiguration } from '../config';
 export const lenses = {
     globals: lib.lens(lib.select.files())
         .pipe(lib.select.nodes())
@@ -68,7 +70,7 @@ export class PeerLibrary {
             return this._cachedIdlLibrary;
         }
         this._cachedIdlLibrary = {
-            files: this.files.map(file => file.file)
+            files: this.files.map(file => file)
         };
         return this._cachedIdlLibrary;
     }
@@ -87,17 +89,20 @@ export class PeerLibrary {
     get materializedToGenerate() {
         return Array.from(this.materializedClasses.values()).filter(it => it.needBeGenerated);
     }
-    constructor(language) {
+    constructor(language, useMemoM3 = false) {
         this.language = language;
+        this.useMemoM3 = useMemoM3;
         this.layout = LayoutManager.Empty();
         this._syntheticFile = idl.createFile([]);
         this.files = [];
+        this.auxFiles = [];
         this.builderClasses = new Map();
         this.materializedClasses = new Map();
         this.name = "";
         this.customComponentMethods = [];
         this.targetNameConvertorInstance = this.createTypeNameConvertor(this.language);
         this.interopNameConvertorInstance = new CppNameConvertor(this);
+        this._useFallback = true;
     }
     createLanguageWriter(language) {
         return createLanguageWriter(language !== null && language !== void 0 ? language : this.language, this);
@@ -142,76 +147,120 @@ export class PeerLibrary {
         this.context = context;
     }
     findFileByOriginalFilename(filename) {
-        return this.files.find(it => it.originalFilename === filename);
+        return this.files.find(it => it.fileName === filename);
     }
     mapType(type) {
         return this.targetNameConvertorInstance.convert(type);
     }
-    resolveTypeReference(type) {
-        return this.resolveTypeReferenceScoped(type);
+    enableCache() {
+        this.referenceCache = new Map();
     }
-    resolveTypeReferenceScoped(type, pointOfView, rootEntries) {
-        const entry = this._syntheticFile.entries.find(it => it.name === type.name);
+    resolveTypeReference(type, singleStep) {
+        var _a, _b;
+        if ((_a = this.referenceCache) === null || _a === void 0 ? void 0 : _a.has(type))
+            return this.referenceCache.get(type);
+        let result = this.resolveNamedNode(type.name.split("."), type.parent);
+        if (!singleStep) {
+            const seen = new Set;
+            while (result) {
+                let nextResult = undefined;
+                if (idl.isImport(result))
+                    nextResult = this.resolveImport(result);
+                else if (idl.isReferenceType(result))
+                    nextResult = this.resolveNamedNode(result.name.split("."));
+                else if (idl.isTypedef(result) && idl.isReferenceType(result.type))
+                    nextResult = this.resolveNamedNode(result.type.name.split("."));
+                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 && (idl.isImport(result) || idl.isNamespace(result)))
+            result = undefined;
+        (_b = this.referenceCache) === null || _b === void 0 ? void 0 : _b.set(type, result);
+        return result;
+    }
+    disableFallback() {
+        this._useFallback = false;
+    }
+    resolveNamedNode(target, pov = undefined) {
+        const qualifiedName = target.join(".");
+        const entry = this._syntheticFile.entries.find(it => it.name === qualifiedName);
         if (entry)
             return entry;
-        const qualifiedName = type.name.split(".");
-        let pointOfViewNamespace = idl.fetchNamespaceFrom(type.parent);
-        // TODO: Choose what to do if `rootEntries.some(it => idl.isNamespace(it))`
-        // One of possible options - `rootEntries = rootEntries.flatMap(it => idl.isNamespace(it) ? it.members : it)` - cause error
-        rootEntries !== null && rootEntries !== void 0 ? rootEntries : (rootEntries = this.files.flatMap(it => it.entries));
-        if (1 === qualifiedName.length) {
-            const predefined = rootEntries.filter(it => isInIdlizeInternal(it));
-            const found = predefined.find(it => it.name === qualifiedName[0]);
+        if (1 === target.length) {
+            const predefined = this.files.flatMap(it => it.entries).filter(isInIdlizeInternal);
+            const found = predefined.find(it => it.name === target.at(-1));
             if (found)
                 return found;
         }
-        let doWork = true;
-        while (doWork) {
-            doWork = !!pointOfViewNamespace;
-            let entries = pointOfViewNamespace
-                ? [...pointOfViewNamespace.members]
-                : [...rootEntries];
-            for (let qualifiedNamePart = 0; qualifiedNamePart < qualifiedName.length; ++qualifiedNamePart) {
-                const candidates = entries.filter(it => it.name === qualifiedName[qualifiedNamePart]);
-                if (!candidates.length)
-                    break;
-                if (qualifiedNamePart === qualifiedName.length - 1) {
-                    const target = candidates.length == 1
-                        ? candidates[0]
-                        : candidates.find(it => !idl.hasExtAttribute(it, idl.IDLExtendedAttributes.Import)); // probably the wrong logic here
-                    if (target && idl.isImport(target)) // Temporary disable Import declarations
-                        return undefined;
-                    return target;
-                }
-                entries = [];
-                for (const candidate of candidates) {
-                    if (idl.isNamespace(candidate))
-                        entries.push(...candidate.members);
-                    else if (idl.isEnum(candidate))
-                        entries.push(...candidate.elements);
-                    else if (idl.isInterface(candidate))
-                        entries.push(...candidate.constants, ...candidate.properties, ...candidate.methods);
-                }
+        const corpus = this.files.concat(this.auxFiles);
+        let result = resolveNamedNode(target, pov, corpus);
+        if (result && idl.isEntry(result))
+            return result;
+        if (1 == target.length) {
+            const stdScopes = generatorConfiguration().globalPackages.map(it => it.split('.'));
+            for (const stdScope of stdScopes) {
+                result = resolveNamedNode([...stdScope, ...target], undefined, corpus);
+                if (result && idl.isEntry(result))
+                    return result;
             }
-            pointOfViewNamespace = idl.fetchNamespaceFrom(pointOfViewNamespace === null || pointOfViewNamespace === void 0 ? void 0 : pointOfViewNamespace.parent);
         }
         // TODO: remove the next block after namespaces out of quarantine
-        if (!pointOfView) {
+        if (this._useFallback) {
+            const povAsReadableString = pov
+                ? `'${idl.getFQName(pov)}'`
+                : "[root]";
+            // retry from root
+            pov = undefined;
             const resolveds = [];
+            for (let file of this.files) {
+                result = resolveNamedNode([...file.packageClause, ...target], pov, corpus);
+                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.push(result);
+                }
+            }
+            // and from each namespace
             const traverseNamespaces = (entry) => {
                 if (entry && idl.isNamespace(entry) && entry.members.length) {
-                    //console.log(`Try alien namespace '${idl.getNamespacesPathFor(entry.members[0]).map(obj => obj.name).join(".")}' to resolve name '${type.name}'`)
-                    const resolved = this.resolveTypeReferenceScoped(type, entry, rootEntries);
-                    if (resolved)
+                    const resolved = resolveNamedNode([...idl.getNamespacesPathFor(entry).map(it => it.name), ...target], pov, corpus);
+                    if (resolved) {
+                        console.warn(`WARNING: Name '${qualifiedName}' is not resolved from ${povAsReadableString} but resolved from some namespace: '${idl.getNamespacesPathFor(resolved).map(obj => obj.name).join(".")}'`);
                         resolveds.push(resolved);
+                    }
                     entry.members.forEach(traverseNamespaces);
                 }
             };
             this.files.forEach(file => file.entries.forEach(traverseNamespaces));
-            if (resolveds.length)
-                console.log(`WARNING: Type reference '${type.name}' is not resolved without own namespace/pointOfView but resolved within some other namespace: '${idl.getNamespacesPathFor(resolveds[0]).map(obj => obj.name).join(".")}'`);
+            for (const resolved of resolveds)
+                if (idl.isEntry(resolved))
+                    return resolved;
         } // end of block to remove
-        return undefined; // empty result
+        return undefined;
+    }
+    resolveImport(target) {
+        let result = this.resolveNamedNode(target.clause);
+        if (result) {
+            if (idl.isReferenceType(result))
+                return this.resolveTypeReference(result);
+            if (idl.isImport(result)) {
+                if (result == target) {
+                    console.log("Self-targeted Import?");
+                    return undefined;
+                }
+                return this.resolveImport(result);
+            }
+            if (idl.isEntry(result))
+                return result;
+        }
+        return undefined;
     }
     typeConvertor(param, type, isOptionalParam = false) {
         if (isOptionalParam) {
@@ -243,16 +292,17 @@ export class PeerLibrary {
                 case idl.IDLUndefinedType: return new UndefinedConvertor(param);
                 case idl.IDLVoidType: return new VoidConvertor(param);
                 case idl.IDLUnknownType:
-                case idl.IDLAnyType: return new ObjectConvertor(param);
+                case idl.IDLObjectType:
+                case idl.IDLAnyType: return new ObjectConvertor(param, idl.IDLAnyType);
                 case idl.IDLDate: return new DateConvertor(param);
+                case idl.IDLFunctionType: return new FunctionConvertor(this, param);
                 default: throw new Error(`Unconverted primitive ${idl.DebugUtils.debugPrintType(type)}`);
             }
         }
         if (idl.isReferenceType(type)) {
-            if (isImportAttr(type))
-                return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
             // TODO: special cases for interop types.
-            switch (type.name) {
+            // TODO: this types are not references! NativeModulePrinter must be fixed
+            switch (type.name.replaceAll('%TEXT%:', '')) { // this is really bad stub, to fix legacy references
                 case 'KBoolean': return new BooleanConvertor(param);
                 case 'KInt': return new NumericConvertor(param, idl.IDLI32Type);
                 case 'KFloat': return new NumericConvertor(param, idl.IDLF32Type);
@@ -262,7 +312,12 @@ export class PeerLibrary {
                 case 'number': return new NumberConvertor(param);
                 case 'KPointer': return new PointerConvertor(param);
             }
+            if (generatorConfiguration().forceResource.includes(type.name)) {
+                return new ObjectConvertor(param, type);
+            }
             const decl = this.resolveTypeReference(type);
+            if (decl && isImportAttr(decl) || !decl && isImportAttr(type))
+                return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
             return this.declarationConvertor(param, type, decl);
         }
         if (idl.isUnionType(type)) {
@@ -281,15 +336,28 @@ export class PeerLibrary {
         throw new Error(`Cannot convert: ${type.kind}`);
     }
     declarationConvertor(param, type, declaration) {
+        if (generatorConfiguration().forceResource.includes(type.name)) {
+            return new ObjectConvertor(param, type);
+        }
         let customConv = this.customConvertor(param, type.name, type);
         if (customConv)
             return customConv;
-        if (!declaration)
+        if (!declaration) {
             return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), false, this.targetNameConvertorInstance.convert(type)); // assume some predefined type
+        }
         const declarationName = declaration.name;
         if (isImportAttr(declaration)) {
             return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
         }
+        if (idl.isImport(declaration)) {
+            const target = this.resolveImport(declaration);
+            if (target && idl.isEntry(target))
+                return this.declarationConvertor(param, type, target);
+            else {
+                warn(`Unable to resolve Import ${declaration.clause.join(".")} as ${declaration.name}`);
+                return new CustomTypeConvertor(param, declaration.name, false, declaration.name);
+            }
+        }
         if (idl.isEnum(declaration)) {
             return new EnumConvertor(param, declaration);
         }
@@ -328,11 +396,11 @@ export class PeerLibrary {
     customConvertor(param, typeName, type) {
         switch (typeName) {
             case `Object`:
-                return new CustomTypeConvertor(param, "Object", false, "Object");
+                return new ObjectConvertor(param, idl.IDLObjectType);
             case `Date`:
                 return new DateConvertor(param);
             case `Function`:
-                return new FunctionConvertor(this, param, type);
+                return new FunctionConvertor(this, param);
             case `Record`:
                 return new CustomTypeConvertor(param, "Record", false, "Record<string, string>");
             case `Optional`:
@@ -349,25 +417,19 @@ export class PeerLibrary {
             case idl.IDLVoidType: return idl.IDLVoidType;
             case idl.IDLUndefinedType: return idl.IDLUndefinedType;
             case idl.IDLUnknownType: return ArkCustomObject;
-            case idl.IDLObjectType: return ArkCustomObject;
+            // case idl.IDLObjectType: return ArkCustomObject
         }
         const typeName = idl.isNamedNode(type) ? type.name : undefined;
         switch (typeName) {
             case "object":
-            case "Object": return ArkCustomObject;
-        }
-        if (isImportAttr(type)) {
-            return ArkCustomObject;
+            case "Object": return idl.IDLObjectType;
         }
         if (idl.isReferenceType(type)) {
             // TODO: remove all this!
-            if (type.name === 'Dimension' || type.name === 'Length') {
-                return ArkLength;
-            }
             if (type.name === 'Date') {
                 return ArkDate;
             }
-            if (type.name === 'AnimationRange' || type.name === 'ContentModifier') {
+            if (type.name === 'AnimationRange') {
                 return ArkCustomObject;
             }
             if (type.name === 'Function') {
@@ -388,6 +450,9 @@ export class PeerLibrary {
                 : idl.isTypedef(decl) ? this.toDeclaration(decl.type)
                     : decl;
         }
+        if (isImportAttr(type)) {
+            return ArkCustomObject;
+        }
         return type;
     }
     setFileLayout(strategy) {
@@ -397,7 +462,6 @@ export class PeerLibrary {
 export const ArkInt32 = idl.IDLI32Type;
 export const ArkInt64 = idl.IDLI64Type;
 export const ArkFunction = idl.IDLFunctionType;
-export const ArkLength = idl.IDLLengthType;
 export const ArkDate = idl.IDLDate;
 export const ArkCustomObject = idl.IDLCustomObjectType;
 export function cleanPrefix(name, prefix) {

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

@@ -1,6 +1,6 @@
 import * as idl from '../idl';
 export interface ReferenceResolver {
-    resolveTypeReference(type: idl.IDLReferenceType, pointOfView?: idl.IDLEntry, rootEntries?: idl.IDLEntry[]): idl.IDLEntry | undefined;
+    resolveTypeReference(type: idl.IDLReferenceType, terminalImports?: boolean): idl.IDLEntry | undefined;
     toDeclaration(type: idl.IDLNode): idl.IDLNode;
 }
 export declare function createEmptyReferenceResolver(): ReferenceResolver;

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

@@ -25,9 +25,9 @@ export function createEmptyReferenceResolver() {
 /** Please do not store any global instances */
 export function createAlternativeReferenceResolver(mainResolver, alternatives) {
     return {
-        resolveTypeReference(type, pointOfView, rootEntries) {
+        resolveTypeReference(type, terminalImports) {
             var _a;
-            return (_a = mainResolver.resolveTypeReference(type, pointOfView, rootEntries)) !== null && _a !== void 0 ? _a : alternatives.get(type.name);
+            return (_a = mainResolver.resolveTypeReference(type, terminalImports)) !== null && _a !== void 0 ? _a : alternatives.get(type.name);
         },
         toDeclaration(type) {
             return mainResolver.toDeclaration(type);

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

@@ -2,6 +2,7 @@ import * as idl from "../../idl";
 import { DeclarationConvertor } from "../../LanguageWriters/nameConvertor";
 import { Language } from "../../Language";
 export declare class DeclarationNameConvertor implements DeclarationConvertor<string> {
+    convertImport(decl: idl.IDLImport): string;
     convertInterface(decl: idl.IDLInterface): string;
     convertEnum(decl: idl.IDLEnum): string;
     convertTypedef(decl: idl.IDLTypedef): string;

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

@@ -15,6 +15,10 @@
 import * as idl from "../../idl";
 import { Language } from "../../Language";
 export class DeclarationNameConvertor {
+    convertImport(decl) {
+        console.warn("Imports are not implemented yet");
+        return decl.name;
+    }
     convertInterface(decl) {
         return decl.name;
     }
@@ -50,10 +54,10 @@ export class TSFeatureNameConvertor extends DeclarationNameConvertor {
 TSFeatureNameConvertor.I = new TSFeatureNameConvertor();
 export class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
     convertInterface(decl) {
-        return idl.getFQName(decl);
+        return idl.getQualifiedName(decl, "namespace.name");
     }
     convertEnum(decl) {
-        return idl.getFQName(decl);
+        return idl.getQualifiedName(decl, "namespace.name");
     }
 }
 ETSDeclarationNameConvertor.I = new ETSDeclarationNameConvertor();

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

@@ -1,10 +1,12 @@
 import * as idl from "../../idl";
 import { Language } from "../../Language";
 export declare function generateSyntheticIdlNodeName(type: idl.IDLType): string;
-export declare function qualifiedName(decl: idl.IDLNode, languageOrDelimiter: Language | string): 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 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 isImportAttr(decl: idl.IDLNode): boolean;
 //# sourceMappingURL=common.d.ts.map

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

@@ -28,12 +28,12 @@ export function generateSyntheticIdlNodeName(type) {
         }
     }
     if (idl.isNamedNode(type))
-        return type.name;
+        return type.name.split('.').map(capitalize).join('_');
     if (idl.isOptionalType(type))
         return `Opt_${generateSyntheticIdlNodeName(type.type)}`;
     throw `Can not compute type name of ${idl.IDLKind[type.kind]}`;
 }
-export function qualifiedName(decl, languageOrDelimiter) {
+export function qualifiedName(decl, languageOrDelimiter, pattern) {
     if (!idl.isNamedNode(decl))
         throw new Error("internal error, name required for no-named node");
     const delimiter = typeof languageOrDelimiter === "string"
@@ -41,7 +41,7 @@ export function qualifiedName(decl, languageOrDelimiter) {
         : (languageOrDelimiter === Language.CPP ? '_' : '.');
     if (!idl.isEntry(decl))
         throw new Error(`Expected to have an IDLEntry, got ${idl.IDLKind[decl.kind]}`);
-    return idl.getFQName(decl).split(".").join(delimiter);
+    return idl.getQualifiedName(decl, pattern).split(".").join(delimiter);
 }
 export function collapseTypes(types, name) {
     const seenNames = new Set();
@@ -61,12 +61,29 @@ export function generifiedTypeName(refType, refName) {
     const typeArgs = (_a = refType.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it)).join(",");
     return `${refName ? refName : refType.name}${typeArgs ? `<${typeArgs}>` : ``}`;
 }
+export function sanitizeGenerics(genericDeclarationString) {
+    const eqIdx = genericDeclarationString.indexOf('=');
+    if (eqIdx !== -1) {
+        genericDeclarationString = genericDeclarationString.substring(0, eqIdx);
+    }
+    const extendsIdx = genericDeclarationString.indexOf('extends');
+    if (extendsIdx !== -1) {
+        genericDeclarationString = genericDeclarationString.substring(0, extendsIdx);
+    }
+    return genericDeclarationString.trim();
+}
 export function generateSyntheticUnionName(types) {
     return `Union_${types.map(it => generateSyntheticIdlNodeName(it)).join("_").replaceAll(".", "_")}`;
 }
+export function generateSyntheticFunctionParameterName(parameter) {
+    if (parameter.isOptional) {
+        return generateSyntheticIdlNodeName(idl.createOptionalType(parameter.type));
+    }
+    return generateSyntheticIdlNodeName(parameter.type);
+}
 export function generateSyntheticFunctionName(parameters, returnType, isAsync = false) {
     let prefix = isAsync ? "AsyncCallback" : "Callback";
-    const names = parameters.map(it => `${generateSyntheticIdlNodeName(it.type)}`).concat(generateSyntheticIdlNodeName(returnType));
+    const names = parameters.map(generateSyntheticFunctionParameterName).concat(generateSyntheticIdlNodeName(returnType));
     return `${prefix}_${names.join("_").replaceAll(".", "_")}`;
 }
 export function isImportAttr(decl) {

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

@@ -16,20 +16,31 @@ import { generatorConfiguration } from '../config';
 import * as idl from '../idl';
 import { isBuilderClass } from './BuilderClass';
 export function isMaterialized(declaration, resolver) {
+    var _a;
     if (!idl.isInterfaceSubkind(declaration) && !idl.isClassSubkind(declaration))
         return false;
     if (idl.isHandwritten(declaration) || isBuilderClass(declaration))
         return false;
-    for (const forceMaterialized of generatorConfiguration().forceMaterialized) {
-        if (declaration.name == forceMaterialized)
-            return true;
+    if (generatorConfiguration().forceResource.includes(declaration.name)) {
+        return false;
+    }
+    if (generatorConfiguration().forceMaterialized.includes(declaration.name)) {
+        return true;
     }
-    if (generatorConfiguration().forceCallback.includes(declaration.name)) {
+    // TODO: rework this
+    if (["BaseSpan"].includes(declaration.name)) {
         return false;
     }
-    for (const ignore of generatorConfiguration().ignoreMaterialized) {
-        if (declaration.name.endsWith(ignore))
+    for (const ignore of ["Attribute", "Method", "Interface"]) {
+        if (declaration.name.endsWith(ignore)) {
             return false;
+        }
+    }
+    if (((_a = generatorConfiguration().forceCallback.get(declaration.name)) === null || _a === void 0 ? void 0 : _a.length) === 0) {
+        return false;
+    }
+    if (generatorConfiguration().ignoreMaterialized.includes(declaration.name)) {
+        return false;
     }
     // A materialized class is a class or an interface with methods
     // excluding components and related classes
@@ -46,11 +57,21 @@ export function isMaterialized(declaration, resolver) {
     }
     return false;
 }
+function isSelfReturnMethod(method, entry, resolver) {
+    if (!idl.isReferenceType(method.returnType)) {
+        return false;
+    }
+    const found = resolver.resolveTypeReference(method.returnType);
+    if (!found) {
+        return false;
+    }
+    return idl.getFQName(found) === idl.getFQName(entry);
+}
 export function isStaticMaterialized(declaration, resolver) {
     if (isMaterialized(declaration, resolver)) {
         if (declaration.properties.length || declaration.constructors.length)
             return false;
-        if (!declaration.methods.every(it => it.isStatic))
+        if (!declaration.methods.every(it => it.isStatic && !isSelfReturnMethod(it, declaration, resolver)))
             return false;
         if (idl.hasSuperType(declaration)) {
             const superType = resolver.resolveTypeReference(idl.getSuperType(declaration));

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

@@ -1,5 +1,5 @@
 import { TypeConvertor } from "../LanguageWriters";
-import { IDLContainerType, IDLOptionalType, IDLPrimitiveType, IDLReferenceType, IDLType, IDLTypeParameterType, IDLUnionType } from '../idl';
+import { IDLImport, IDLContainerType, IDLOptionalType, IDLPrimitiveType, IDLReferenceType, IDLType, IDLTypeParameterType, IDLUnionType } from '../idl';
 import { LanguageExpression, LanguageWriter } from "../LanguageWriters/LanguageWriter";
 import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
 import { LibraryInterface } from "../LibraryInterface";
@@ -7,11 +7,12 @@ import { ReferenceResolver } from "./ReferenceResolver";
 export declare class UnionFlattener implements TypeConvertor<IDLType[]> {
     private resolver;
     constructor(resolver: ReferenceResolver);
+    convertImport(type: IDLImport): IDLType[];
     convertUnion(type: IDLUnionType): IDLType[];
     convertTypeReference(type: IDLReferenceType): IDLType[];
     convertOptional(type: IDLOptionalType): IDLType[];
     convertContainer(type: IDLContainerType): IDLType[];
-    convertImport(type: IDLReferenceType, importClause: string): IDLType[];
+    convertTypeReferenceAsImport(type: IDLReferenceType, importClause: string): IDLType[];
     convertPrimitiveType(type: IDLPrimitiveType): IDLType[];
     convertTypeParameter(type: IDLTypeParameterType): IDLType[];
 }

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

@@ -21,6 +21,10 @@ export class UnionFlattener {
     constructor(resolver) {
         this.resolver = resolver;
     }
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
+        return [];
+    }
     convertUnion(type) {
         return type.types.flatMap(it => convertType(this, it));
     }
@@ -34,7 +38,7 @@ export class UnionFlattener {
     convertContainer(type) {
         return [type];
     }
-    convertImport(type, importClause) {
+    convertTypeReferenceAsImport(type, importClause) {
         return [type];
     }
     convertPrimitiveType(type) {
@@ -106,13 +110,13 @@ export class UnionRuntimeTypeChecker {
                 const discriminator = discr ? discr.asString() : "<undefined>";
                 report += ` ${num}| ${typename}| ${properties}| ${resolved}| ${discriminator}\n`;
             });
-            throw new Error(report);
+            // throw new Error(report)
         }
     }
 }
 export function flattenUnionType(library, type) {
-    const unionFlattener = new UnionFlattener(library);
     if (isUnionType(type)) {
+        const unionFlattener = new UnionFlattener(library);
         const allTypes = type.types.flatMap(it => convertType(unionFlattener, it));
         const uniqueTypes = new Set(allTypes);
         return uniqueTypes.size === allTypes.length ? type : collapseTypes(Array.from(uniqueTypes));

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

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