@ts-for-gir/cli 3.0.0-beta.10

package/lib/conflict-resolver.js

@@ -0,0 +1,1103 @@
+import { GirFactory } from './gir-factory.js';
+import { Logger } from './logger.js';
+import { NO_TSDATA } from './messages.js';
+import { isEqual, merge, clone, typeIsOptional } from './utils.js';
+import { SIGNAL_METHOD_NAMES, MAX_CLASS_PARENT_DEPTH } from './constants.js';
+/**
+ * Resolve conflicts between types caused by overloads / inheritances and implementations
+ * With multiple implementations or a inherit it can happen that the interfaces / parent have the same method and/or property names with incompatible types,
+ * we are trying to resolve this conflicts by merging, overloading or removing this conflicts.
+ */
+export class ConflictResolver {
+    environment;
+    verbose;
+    log;
+    girFactory = new GirFactory();
+    constructor(environment, verbose) {
+        this.environment = environment;
+        this.verbose = verbose;
+        this.log = new Logger(environment, verbose, 'ConflictResolver');
+    }
+    girElArrToChildArr(dataArr, depth) {
+        return dataArr
+            .filter((data) => !!data?._tsData)
+            .map((data) => {
+            if (!data?._tsData)
+                throw new Error('_tsData not set!');
+            return {
+                depth,
+                data: data?._tsData,
+            };
+        });
+    }
+    tsElArrToChildArr(dataArr, depth) {
+        return dataArr
+            .filter((m) => !!m)
+            .map((data) => {
+            return {
+                depth,
+                data,
+            };
+        });
+    }
+    /**
+     * Get class elements and parent elements (implementations and inherits)
+     * @param tsClass
+     * @param depth
+     * @returns
+     */
+    getClassElements(tsClass, depth, processedClasses) {
+        const tsClassFullPackageSymName = `${tsClass.namespace}-${tsClass.version}.${tsClass.namespace}.${tsClass.name}`;
+        const signalMethods = [];
+        const propertySignalMethods = [];
+        const methods = [];
+        const virtualMethods = [];
+        const staticFunctions = [];
+        const constructors = [];
+        const properties = [];
+        const fields = [];
+        const constructProps = [];
+        const depthLimitReached = depth >= MAX_CLASS_PARENT_DEPTH;
+        const classAlreadyProcessed = processedClasses.includes(tsClassFullPackageSymName);
+        if (depthLimitReached || classAlreadyProcessed) {
+            if (depthLimitReached) {
+                this.log.error(`[getClassElements] Maximum recursion depth reached (limit: ${MAX_CLASS_PARENT_DEPTH})!`);
+            }
+            return {
+                signalMethods,
+                propertySignalMethods,
+                methods,
+                virtualMethods,
+                staticFunctions,
+                constructors,
+                properties,
+                fields,
+                constructProps,
+            };
+        }
+        // Signals
+        const _signals = tsClass.signals.map((s) => s._tsData).filter((s) => !!s);
+        for (const tsSignal of _signals) {
+            signalMethods.push(...this.tsElArrToChildArr(tsSignal.tsMethods, depth));
+        }
+        // Property signals
+        propertySignalMethods.push(...this.tsElArrToChildArr(tsClass.propertySignalMethods, depth));
+        // Methods
+        if (tsClass.methods.length)
+            methods.push(...this.girElArrToChildArr(tsClass.methods, depth));
+        // Virtual methods
+        if (tsClass.virtualMethods.length)
+            virtualMethods.push(...this.girElArrToChildArr(tsClass.virtualMethods, depth));
+        // Static functions
+        if (tsClass.staticFunctions.length)
+            staticFunctions.push(...this.girElArrToChildArr(tsClass.staticFunctions, depth));
+        // Constructors
+        if (tsClass.constructors.length)
+            constructors.push(...this.girElArrToChildArr(tsClass.constructors, depth));
+        // Properties
+        if (tsClass.properties.length)
+            properties.push(...this.girElArrToChildArr(tsClass.properties, depth));
+        // Fields
+        if (tsClass.fields.length)
+            fields.push(...this.girElArrToChildArr(tsClass.fields, depth));
+        // Constructor properties
+        if (tsClass.constructProps.length)
+            constructProps.push(...this.girElArrToChildArr(tsClass.constructProps, depth));
+        for (const ifacePackageFullSymName of Object.keys(tsClass.implements)) {
+            if (tsClassFullPackageSymName === ifacePackageFullSymName) {
+                this.log.warn("[getImplementedInterfaceElements] A interface can't implement itself");
+                continue;
+            }
+            const { interface: implementation, depth: parentDepth } = tsClass.implements[ifacePackageFullSymName];
+            const implementationElements = this.getClassElements(implementation, parentDepth + depth + 1, processedClasses);
+            signalMethods.push(...implementationElements.signalMethods);
+            propertySignalMethods.push(...implementationElements.propertySignalMethods);
+            methods.push(...implementationElements.methods);
+            virtualMethods.push(...implementationElements.virtualMethods);
+            staticFunctions.push(...implementationElements.staticFunctions);
+            constructors.push(...implementationElements.constructors);
+            properties.push(...implementationElements.properties);
+            fields.push(...implementationElements.fields);
+            constructProps.push(...implementationElements.constructProps);
+        }
+        for (const ifaceFullPackageSymName of Object.keys(tsClass.inherit)) {
+            if (tsClassFullPackageSymName === ifaceFullPackageSymName) {
+                this.log.warn("[getClassElements] A class can't inherit itself");
+                continue;
+            }
+            const { class: inherit, depth: parentDepth } = tsClass.inherit[ifaceFullPackageSymName];
+            const inheritElements = this.getClassElements(inherit, parentDepth + depth + 1, processedClasses);
+            signalMethods.push(...inheritElements.signalMethods);
+            propertySignalMethods.push(...inheritElements.propertySignalMethods);
+            methods.push(...inheritElements.methods);
+            virtualMethods.push(...inheritElements.virtualMethods);
+            staticFunctions.push(...inheritElements.staticFunctions);
+            constructors.push(...inheritElements.constructors);
+            properties.push(...inheritElements.properties);
+            fields.push(...inheritElements.fields);
+            constructProps.push(...inheritElements.constructProps);
+        }
+        processedClasses.push(tsClassFullPackageSymName);
+        return {
+            signalMethods,
+            propertySignalMethods,
+            methods,
+            virtualMethods,
+            staticFunctions,
+            constructors,
+            properties,
+            fields,
+            constructProps,
+        };
+    }
+    tsElementIsMethod(el) {
+        return !this.tsElementIsStatic(el) && this.tsElementIsMethodOrFunction(el);
+    }
+    tsElementIsStaticFunction(el) {
+        return this.tsElementIsStatic(el) && this.tsElementIsMethodOrFunction(el);
+    }
+    tsElementIsProperty(el) {
+        return !this.tsElementIsStatic(el) && this.tsElementIsPropertyOrVariable(el);
+    }
+    tsElementIsStaticProperty(el) {
+        return this.tsElementIsStatic(el) && this.tsElementIsPropertyOrVariable(el);
+    }
+    tsElementIsSignal(el) {
+        return el.tsTypeName === 'event-methods';
+    }
+    tsElementIsConstructor(el) {
+        return el.tsTypeName === 'constructor';
+    }
+    tsElementIsMethodOrFunction(el) {
+        return el.tsTypeName === 'function' || el.tsTypeName === 'method' || el.tsTypeName === 'static-function';
+    }
+    tsElementIsPropertyOrVariable(el) {
+        return (el.tsTypeName === 'constant' ||
+            el.tsTypeName === 'constructor-property' ||
+            el.tsTypeName === 'property' ||
+            el.tsTypeName === 'static-property');
+    }
+    tsElementIsStatic(el) {
+        return (
+        // el.tsTypeName === 'constructor' ||
+        el.isStatic || el.tsTypeName === 'static-property' || el.tsTypeName === 'static-function');
+    }
+    typeIsString(type) {
+        return (type.type === 'string' ||
+            (type.type.startsWith("'") && type.type.endsWith("'")) ||
+            (type.type.startsWith('"') && type.type.endsWith('"')));
+    }
+    mergeTypes(leftSeparator, ...types) {
+        const dest = [];
+        for (const type of types) {
+            if (!type)
+                continue;
+            if (!dest.find((destType) => isEqual(destType, type))) {
+                dest.push({ ...type, leftSeparator });
+            }
+        }
+        return dest;
+    }
+    setTypesProperty(types, property, value) {
+        for (const type of types) {
+            type[property] = value;
+        }
+        return types;
+    }
+    /**
+     * Merges two parameter name and type of two parameters
+     * @param a
+     * @param b
+     * @returns
+     */
+    mergeParam(a, b) {
+        if (!a?._tsData && !b?._tsData) {
+            throw new Error('At least one parameter must be defined!');
+        }
+        let dest;
+        if (a?._tsData && b?._tsData) {
+            dest = merge({}, clone(a), clone(b));
+            if (!dest._tsData) {
+                throw new Error('Error on merge parameters!');
+            }
+            dest._tsData.type = [];
+            dest._tsData.type = this.mergeTypes('|', ...a._tsData.type, ...b._tsData.type);
+            if (a._tsData.name !== b._tsData.name) {
+                dest._tsData.name = `${a._tsData.name}_or_${b._tsData.name}`;
+            }
+        }
+        else {
+            dest = clone((a || b));
+            if (!dest._tsData) {
+                throw new Error('Error on merge parameters!');
+            }
+            // If `a` or `b` is undefined make the types optional
+            dest._tsData.type = this.setTypesProperty(dest._tsData.type, 'optional', true);
+        }
+        if (typeIsOptional(dest._tsData.type)) {
+            dest._tsData.type = this.setTypesProperty(dest._tsData.type, 'optional', true);
+        }
+        return dest;
+    }
+    /**
+     * Merges parameter names and types of multiple functions
+     * @param params
+     * @returns
+     */
+    mergeParams(...params) {
+        let dest = [];
+        for (const a of params) {
+            for (const b of params) {
+                if (a === b) {
+                    continue;
+                }
+                if (isEqual(a, b)) {
+                    dest = clone(a);
+                }
+                else {
+                    const length = Math.max(a.length, b.length);
+                    dest = new Array(length);
+                    for (let i = 0; i < length; i++) {
+                        const aParam = a[i];
+                        const bParam = b[i];
+                        dest[i] = this.mergeParam(aParam, bParam);
+                    }
+                }
+            }
+        }
+        return dest;
+    }
+    paramCanBeOptional(girParam, girParams, skip = []) {
+        if (!girParam._tsData)
+            return false;
+        let canBeOptional = true;
+        const index = girParams.indexOf(girParam);
+        const following = girParams
+            .slice(index)
+            .filter((p) => !!p._tsData)
+            .filter(() => !skip.includes(girParam))
+            .filter((p) => p.$.direction !== 'out')
+            .map((p) => p._tsData);
+        if (following.some((p) => p && !typeIsOptional(p.type))) {
+            canBeOptional = false;
+        }
+        return canBeOptional;
+    }
+    /**
+     * In Typescript no optional parameters are allowed if the following ones are not optional
+     * @param girParams
+     * @returns
+     */
+    fixOptionalParameters(girParams) {
+        for (const girParam of girParams) {
+            if (!girParam._tsData)
+                throw new Error(NO_TSDATA('fixOptionalParameters'));
+            if (typeIsOptional(girParam._tsData.type) && !this.paramCanBeOptional(girParam, girParams)) {
+                this.setTypesProperty(girParam._tsData.type, 'optional', false);
+            }
+        }
+        return girParams;
+    }
+    /**
+     * Merge function types and parameters together
+     * @param baseFunc The function to change or null if you want to create a new property
+     * @param funcs The functions you want to merge
+     * @returns
+     */
+    mergeFunctions(baseFunc, ...funcs) {
+        const returnTypesMap = [];
+        for (const func of funcs) {
+            returnTypesMap.push(...func.returnTypes);
+        }
+        const returnTypes = this.mergeTypes('|', ...returnTypesMap);
+        const inParamsMap = funcs.map((func) => func.inParams);
+        const inParams = [];
+        if (this.paramsHasConflict(...inParamsMap)) {
+            inParams.push(...this.mergeParams(...inParamsMap));
+        }
+        const outParamsMap = funcs.map((func) => func.outParams);
+        const outParams = [];
+        if (this.paramsHasConflict(...outParamsMap)) {
+            outParams.push(...this.mergeParams(...outParamsMap));
+        }
+        if (!funcs[0]) {
+            throw new Error('At least one function must exist!');
+        }
+        if (baseFunc) {
+            baseFunc.returnTypes = returnTypes;
+            return baseFunc;
+        }
+        return this.girFactory.newTsFunction({
+            name: funcs[0].name,
+            returnTypes: returnTypes,
+            isStatic: funcs[0].isStatic || false,
+            inParams: inParams.map((inParam) => inParam._tsData).filter((inParam) => !!inParam),
+            outParams: outParams
+                .map((outParam) => outParam._tsData)
+                .filter((outParam) => !!outParam),
+            girTypeName: funcs[0].girTypeName,
+        }, funcs[0].parent);
+    }
+    /**
+     * Merge property types together
+     * @param baseProp The property to change or null if you want to create a new property
+     * @param props The properties you want to merge
+     * @returns
+     */
+    mergeProperties(typeSeparator, baseProp, ...props) {
+        const typesMap = [];
+        for (const prop of props) {
+            typesMap.push(...prop.type);
+        }
+        const types = this.mergeTypes(typeSeparator, ...typesMap);
+        // Merge readonly
+        let readonly = false;
+        for (const prop of props) {
+            readonly = readonly || prop.readonly || false;
+        }
+        if (!props[0] || !props[0].name) {
+            throw new Error('At least one property to merge must exist!');
+        }
+        if (baseProp) {
+            baseProp.type = types;
+            baseProp.readonly = readonly;
+            return baseProp;
+        }
+        const newProp = this.girFactory.newTsProperty({
+            readonly: readonly,
+            isStatic: props[0].isStatic || false,
+            name: props[0].name,
+            type: types,
+            girTypeName: props[0].girTypeName,
+        });
+        return newProp;
+    }
+    /**
+     * Check if there is a type conflict between the ts elements a and b
+     * @param a
+     * @param b
+     * @returns
+     */
+    hasConflict(a, b) {
+        if (a !== b && a.data.name === b.data.name) {
+            const name = a.data.name;
+            // Ignore element with name of:
+            if (name === 'constructor' || name === '_init') {
+                return false;
+            }
+            if (this.elementHasConflict(a.data, b.data)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    newAnyTsProperty(name, girTypeName) {
+        return this.girFactory.newTsProperty({
+            name,
+            girTypeName,
+            type: [{ type: 'any' }],
+        });
+    }
+    /**
+     * Returns a new any function: `name(...args: any[]): any`
+     * @param name The name of the function
+     */
+    newAnyTsFunction(name, girTypeName, isStatic, parent) {
+        return this.girFactory.newTsFunction({
+            name,
+            isStatic,
+            inParams: [
+                {
+                    name: 'args',
+                    isRest: true,
+                    type: [this.girFactory.newTsType({ type: 'any', isArray: true })],
+                },
+            ],
+            returnTypes: [{ type: 'any' }],
+            girTypeName,
+        }, parent);
+    }
+    getCompatibleTsProperty(elements, baseProp) {
+        return elements.find((prop) => !this.propertyHasConflict(baseProp, prop));
+    }
+    getCompatibleTsFunction(elements, baseFunc) {
+        return elements.find((func) => !this.functionHasConflict(baseFunc, func));
+    }
+    /**
+     * Use this instead of `getCompatibleTsProperty` and `getCompatibleTsProperty` if you can, because it's much faster
+     * @param elements
+     * @param name
+     * @returns
+     */
+    getTsElementByName(elements, name) {
+        return elements.find((el) => el.name === name);
+    }
+    canAddConflictProperty(conflictProperties, prop) {
+        const canAdd = prop.name &&
+            // Only one property can be defined, no overloads
+            !this.getTsElementByName(conflictProperties, prop.name) &&
+            // Do not set properties with signal method names
+            !SIGNAL_METHOD_NAMES(this.environment).includes(prop.name);
+        return canAdd;
+    }
+    groupSignalConflicts(signalsMethods, baseClass) {
+        const groupedConflicts = {};
+        for (const base of signalsMethods) {
+            for (const b of signalsMethods) {
+                if (base === b) {
+                    continue;
+                }
+                if (base.data.name !== 'connect' && base.data.name !== 'connect_after') {
+                    continue;
+                }
+                const sigNameParam = base.data.inParams[0];
+                // const callbackParam = base.data.inParams[1]
+                const eventName = sigNameParam?._tsData?.type?.[0]?.type;
+                // TODO do not render the callback type as a full string, create a TSCallback instead
+                // const callbackType = callbackParam?._tsData?.type?.[0]?.type
+                // console.debug('eventName', eventName, callbackType)
+                if (!eventName || eventName === 'string') {
+                    continue;
+                }
+                groupedConflicts[eventName] ||= {
+                    baseElements: [],
+                    inheritedElements: [],
+                    baseClass,
+                };
+                const groupedConflict = groupedConflicts[eventName];
+                const isBaseElement = base.depth === 0;
+                if (isBaseElement) {
+                    if (!groupedConflict.baseElements.find((c) => isEqual(c.data, base.data))) {
+                        groupedConflict.baseElements.push(base);
+                    }
+                }
+                else {
+                    if (!groupedConflict.inheritedElements.find((c) => isEqual(c.data, base.data))) {
+                        groupedConflict.inheritedElements.push(base);
+                    }
+                }
+            }
+        }
+        return groupedConflicts;
+    }
+    fixSignalConflicts(groupedElements) {
+        for (const eventName of Object.keys(groupedElements)) {
+            const elements = groupedElements[eventName];
+            const bases = elements.baseElements;
+            if (!bases.length) {
+                // TODO
+                // return this.fixIndirectSignalConflicts(elements.inheritedElements, elements.baseClass)
+                return;
+            }
+            for (const base of bases) {
+                if (base.data.hasUnresolvedConflict) {
+                    continue;
+                }
+                for (const b of elements.inheritedElements) {
+                    if (b === base || b.data.hasUnresolvedConflict) {
+                        continue;
+                    }
+                    // TODO
+                }
+            }
+        }
+    }
+    /**
+     * Check conflicts between the implementations / inheritances
+     * To fix type errors like:
+     * ```
+     *   Interface 'PopoverMenu' can\'t simultaneously extend types 'Popover' and 'Native'.
+     *   Named property 'parent' of types 'Popover' and 'Native' are not identical.
+     */
+    fixIndirectConflicts(name, elements, baseClass) {
+        for (const base of elements) {
+            if (base.data.hasUnresolvedConflict) {
+                continue;
+            }
+            for (const b of elements) {
+                if (b === base || b.data.hasUnresolvedConflict) {
+                    continue;
+                }
+                const className = `${baseClass.namespace}-${baseClass.version}.${baseClass.name}`;
+                // If a element is a function / method
+                if (this.tsElementIsMethodOrFunction(base.data)) {
+                    const baseFunc = base.data;
+                    // Function vs. Property
+                    if (this.tsElementIsPropertyOrVariable(b.data)) {
+                        this.log.debug(`${className}.${name} External Function vs. Property`, baseFunc, b.data);
+                        b.data.hasUnresolvedConflict = true;
+                    }
+                    // Function vs. Signal
+                    else if (this.tsElementIsSignal(b.data)) {
+                        this.log.debug(`${className}.${name} External Function vs. Signal`, baseFunc, b.data);
+                        baseFunc.hasUnresolvedConflict = true;
+                    }
+                    // Function vs. Function
+                    else if (this.tsElementIsMethodOrFunction(b.data)) {
+                        const bFunc = b.data;
+                        this.log.debug(`${className}.${name} External Function vs. Function`, baseFunc.inParams.map((p) => p._tsData?.name).join(', '), bFunc.inParams.map((p) => p._tsData?.name).join(', '));
+                        // Just add conflicting methods to the class
+                        if (!baseClass.conflictMethods.includes(baseFunc)) {
+                            baseClass.conflictMethods.push(baseFunc);
+                        }
+                        if (!baseClass.conflictMethods.includes(bFunc)) {
+                            baseClass.conflictMethods.push(bFunc);
+                        }
+                    }
+                    // Function vs. Constructor
+                    else if (this.tsElementIsConstructor(base.data)) {
+                        const bConstr = b.data;
+                        this.log.debug(`${className}.${name} External Function vs. Constructor`, baseFunc, bConstr);
+                        // Just add conflicting methods to the class
+                        if (!baseClass.conflictMethods.includes(baseFunc)) {
+                            baseClass.conflictMethods.push(baseFunc);
+                        }
+                        if (!baseClass.conflictMethods.includes(bConstr)) {
+                            baseClass.conflictMethods.push(bConstr);
+                        }
+                    }
+                    // Function vs. Unknown
+                    else {
+                        this.log.debug(`${className}.${name} External Unknown ${b.data.tsTypeName}`, baseFunc, b.data);
+                        baseFunc.hasUnresolvedConflict = true;
+                    }
+                }
+                // If a element is a constructor
+                else if (this.tsElementIsConstructor(base.data)) {
+                    const baseConstr = base.data;
+                    // Constructor vs. Function
+                    if (this.tsElementIsMethodOrFunction(b.data)) {
+                        const bFunc = b.data;
+                        this.log.debug(`${className}.${name} External Constructor vs. Function`, baseConstr.inParams.map((p) => p._tsData?.name).join(', '), bFunc.inParams.map((p) => p._tsData?.name).join(', '));
+                        if (!baseClass.conflictMethods.includes(baseConstr)) {
+                            baseClass.conflictMethods.push(baseConstr);
+                        }
+                        if (!baseClass.conflictMethods.includes(bFunc)) {
+                            baseClass.conflictMethods.push(bFunc);
+                        }
+                    }
+                    // Constructor vs. Constructor
+                    else if (this.tsElementIsConstructor(base.data)) {
+                        this.log.debug(`${className}.${name} External Constructor vs. Constructor`, baseConstr, b.data);
+                        const anyFunc = this.newAnyTsFunction(name, baseConstr.girTypeName, baseConstr.isStatic, baseConstr.parent);
+                        // Check if any function is not already added
+                        if (!this.getTsElementByName(baseClass.conflictMethods, anyFunc.name)) {
+                            baseClass.conflictMethods.push(anyFunc);
+                        }
+                    }
+                }
+                // If a element is a property / variable
+                else if (this.tsElementIsPropertyOrVariable(base.data)) {
+                    const baseProp = base.data;
+                    // Property vs. Function
+                    if (this.tsElementIsMethodOrFunction(b.data)) {
+                        const bFunc = b.data;
+                        this.log.debug(`${className}.${name} External Property vs. Function`, baseProp.type[0].type, bFunc);
+                        baseProp.hasUnresolvedConflict = true;
+                    }
+                    // Property vs. Property
+                    else if (this.tsElementIsPropertyOrVariable(b.data)) {
+                        const bProp = b.data;
+                        this.log.debug(`${className}.${name} External Property vs. Property`, baseProp.type[0].type, bProp.type[0].type);
+                        switch (name) {
+                            case 'parent':
+                            case 'window':
+                            case 'parent_instance':
+                            case 'priv':
+                                const mergedProp = this.mergeProperties('&', null, baseProp, bProp);
+                                if (this.canAddConflictProperty(baseClass.conflictProperties, mergedProp)) {
+                                    baseClass.conflictProperties.push(mergedProp);
+                                }
+                                break;
+                            default:
+                                const anyProp = this.newAnyTsProperty(name, baseProp.girTypeName);
+                                if (this.canAddConflictProperty(baseClass.conflictProperties, anyProp)) {
+                                    baseClass.conflictProperties.push(anyProp);
+                                }
+                                break;
+                        }
+                    }
+                    // Property vs. Signal
+                    else if (this.tsElementIsSignal(b.data)) {
+                        this.log.debug(`${className}.${name} External Property vs. Signal`, baseProp, b.data);
+                        base.data.hasUnresolvedConflict = true;
+                    }
+                    else {
+                        this.log.error(`${className}.${name} External Unknown ${b.data.tsTypeName}`, baseProp, b.data);
+                    }
+                }
+                // Other
+                else {
+                    this.log.error(`${className}.${name} External Unknown ${base.data.tsTypeName}`);
+                    base.data.hasUnresolvedConflict = true;
+                }
+            }
+        }
+    }
+    /**
+     * Check conflicts within the class itself (ignores implementations / inheritances)
+     */
+    fixInternalConflicts(name, elements, baseClass) {
+        for (const base of elements) {
+            if (base.data.hasUnresolvedConflict) {
+                continue;
+            }
+            for (const b of elements) {
+                if (b === base || b.data.hasUnresolvedConflict) {
+                    continue;
+                }
+                const className = `${baseClass.namespace}-${baseClass.version}.${baseClass.name}`;
+                // Conflict between injected and original elements
+                if (base.data.isInjected !== b.data.isInjected) {
+                    if (!base.data.isInjected) {
+                        base.data.hasUnresolvedConflict = true;
+                    }
+                    else if (!b.data.isInjected) {
+                        b.data.hasUnresolvedConflict = true;
+                    }
+                    // Copy doc from original element if not set in the injected element
+                    if (!b.data.doc.text && base.data.doc.text) {
+                        b.data.doc = base.data.doc;
+                    }
+                    else if (!base.data.doc.text && b.data.doc.text) {
+                        base.data.doc = b.data.doc;
+                    }
+                    continue;
+                }
+                // If a element is a function / method
+                if (this.tsElementIsMethodOrFunction(base.data)) {
+                    const baseFunc = base.data;
+                    // Function vs. Property
+                    if (this.tsElementIsPropertyOrVariable(b.data)) {
+                        this.log.debug(`${className}.${name} Internal Function vs. Property`, baseFunc, b.data);
+                        b.data.hasUnresolvedConflict = true;
+                    }
+                    // Function vs. Signal
+                    else if (this.tsElementIsSignal(b.data)) {
+                        this.log.debug(`${className}.${name} Internal Function vs. Signal`, baseFunc, b.data);
+                        // Do nothing
+                    }
+                    // Function vs. Function
+                    else if (this.tsElementIsMethodOrFunction(b.data)) {
+                        const bFunc = b.data;
+                        this.log.debug(`${className}.${name} Internal Function vs. Function`, baseFunc.inParams.map((p) => p._tsData?.name).join(', '), bFunc.inParams.map((p) => p._tsData?.name).join(', '));
+                        // Conflict between virtual and non-virtual methods (this should only occur in node-gtk, because Gjs has a vfunc_ prefix for virtual methods)
+                        if (baseFunc.isVirtual !== bFunc.isVirtual) {
+                            if (!baseFunc.isVirtual) {
+                                baseFunc.hasUnresolvedConflict = true;
+                            }
+                            else {
+                                bFunc.hasUnresolvedConflict = true;
+                            }
+                            continue;
+                        }
+                        // Do nothing..
+                    }
+                    else {
+                        this.log.error(`${className}.${name} Internal Unknown ${b.data.tsTypeName}`, baseFunc, b.data);
+                        b.data.hasUnresolvedConflict = true;
+                    }
+                }
+                // If a element is a property / variable
+                else if (this.tsElementIsPropertyOrVariable(base.data)) {
+                    const baseProp = base.data;
+                    // Property vs. Function
+                    if (this.tsElementIsMethodOrFunction(b.data)) {
+                        const bFunc = b.data;
+                        this.log.debug(`${className}.${name} Internal Property vs. Function`, baseProp.type[0].type, bFunc);
+                        baseProp.hasUnresolvedConflict = true;
+                    }
+                    // Property vs. Property
+                    else if (this.tsElementIsPropertyOrVariable(b.data)) {
+                        const bProp = b.data;
+                        this.log.debug(`${className}.${name} Internal Property vs. Property`, baseProp.type[0].type, bProp.type[0].type);
+                        switch (name) {
+                            case 'parent':
+                            case 'window':
+                            case 'parent_instance':
+                                this.mergeProperties('&', baseProp, baseProp, bProp);
+                                break;
+                            default:
+                                // Set property type to any
+                                baseProp.type = [this.girFactory.newTsType({ ...bProp.type, type: 'any' })];
+                                break;
+                        }
+                    }
+                    // Property vs. Signal
+                    else if (this.tsElementIsSignal(b.data)) {
+                        this.log.debug(`${className}.${name} Internal Property vs. Signal`, baseProp, b.data);
+                        base.data.hasUnresolvedConflict = true;
+                    }
+                    else {
+                        this.log.error(`${className}.${name} Internal Unknown ${b.data.tsTypeName}`, baseProp, b.data);
+                    }
+                }
+                // If a element is a signal
+                else if (this.tsElementIsSignal(base.data)) {
+                    const baseSig = base.data;
+                    // Signal vs. Function
+                    if (this.tsElementIsMethodOrFunction(b.data)) {
+                        this.log.debug(`${className}.${name} Internal Signal vs. Function`, baseSig, b.data);
+                        // Do nothing
+                    }
+                    // Signal vs. Property
+                    else if (this.tsElementIsPropertyOrVariable(b.data)) {
+                        this.log.debug(`${className}.${name} Internal Signal vs. Property`, baseSig, b.data);
+                        b.data.hasUnresolvedConflict = true;
+                    }
+                }
+                // Other
+                else {
+                    this.log.error(`${className}.${name} Internal Unknown ${base.data.tsTypeName}`);
+                }
+            }
+        }
+    }
+    /**
+     * Check conflicts of the class with implementations and inheritances
+     */
+    fixDirectConflicts(name, elements) {
+        const className = `${elements.baseClass.namespace}-${elements.baseClass.version}.${elements.baseClass.name}`;
+        for (const base of elements.baseElements) {
+            if (base.data.hasUnresolvedConflict) {
+                continue;
+            }
+            // Each conflicting elements
+            for (const b of elements.inheritedElements) {
+                if (b === base || b.data.hasUnresolvedConflict) {
+                    continue;
+                }
+                // If base element is a function
+                if (this.tsElementIsMethodOrFunction(base.data)) {
+                    const baseFunc = base.data;
+                    // Function vs. Function
+                    if (this.tsElementIsMethodOrFunction(b.data)) {
+                        const bFunc = b.data;
+                        this.log.debug(`${className}.${name} Direct Function vs. Function`, baseFunc.inParams.map((p) => p._tsData?.name).join(', '), bFunc.inParams.map((p) => p._tsData?.name).join(', '));
+                        // Add a function to overload methods if there is not already a compatible version
+                        if (!baseFunc.overloads.includes(bFunc) &&
+                            !this.getCompatibleTsFunction(baseFunc.overloads, bFunc)) {
+                            baseFunc.overloads.push(bFunc);
+                        }
+                    }
+                    // Function vs. Constructor
+                    else if (this.tsElementIsConstructor(b.data)) {
+                        const bConstr = b.data;
+                        this.log.debug(`${className}.${name} Direct Function vs. Constructor`, baseFunc.inParams.map((p) => p._tsData?.name).join(', '), bConstr.inParams.map((p) => p._tsData?.name).join(', '));
+                        // Add a function to overload methods if there is not already a compatible version
+                        if (!this.getCompatibleTsFunction(baseFunc.overloads, bConstr)) {
+                            baseFunc.overloads.push(bConstr);
+                        }
+                    }
+                    // Function vs. Property
+                    else if (this.tsElementIsPropertyOrVariable(b.data)) {
+                        this.log.debug(`${className}.${name} Direct Function vs. Property`);
+                        b.data.hasUnresolvedConflict = true;
+                    }
+                    // Function vs. Signal
+                    else if (this.tsElementIsSignal(b.data)) {
+                        this.log.debug(`${className}.${name} Direct Function vs. Signal`);
+                        // Do nothing
+                    }
+                }
+                // If base element is a property / variable
+                else if (this.tsElementIsPropertyOrVariable(base.data)) {
+                    const baseProp = base.data;
+                    // Property vs. Property
+                    if (this.tsElementIsPropertyOrVariable(b.data)) {
+                        const bProp = b.data;
+                        this.log.debug(`${className}.${name} Direct Property vs. Property`, baseProp.type[0].type, bProp.type[0].type);
+                        switch (name) {
+                            case 'parent':
+                            case 'window':
+                            case 'parent_instance':
+                                this.mergeProperties('&', baseProp, baseProp, bProp);
+                                break;
+                            default:
+                                // Set property type to any
+                                baseProp.type = [this.girFactory.newTsType({ ...bProp.type, type: 'any' })];
+                                break;
+                        }
+                    }
+                    // Property vs. Function
+                    else if (this.tsElementIsMethodOrFunction(b.data)) {
+                        this.log.debug(`${className}.${name} Direct Property vs. Function`);
+                        baseProp.hasUnresolvedConflict = true;
+                    }
+                    // Property vs. Signal
+                    else if (this.tsElementIsSignal(b.data)) {
+                        this.log.debug(`${className}.${name} Direct Property vs. Signal`);
+                        baseProp.hasUnresolvedConflict = true;
+                    }
+                }
+                // If base element is a signal method
+                else if (this.tsElementIsSignal(base.data)) {
+                    // Signal vs. Property
+                    if (this.tsElementIsPropertyOrVariable(b.data)) {
+                        this.log.debug(`${className}.${name} Direct Signal vs. Property`);
+                        b.data.hasUnresolvedConflict = true;
+                    }
+                    // Signal vs. Function
+                    if (this.tsElementIsMethodOrFunction(b.data)) {
+                        this.log.debug(`${className}.${name} Direct Signal vs. Function`);
+                        const bFunc = b.data;
+                        const baseSignal = base.data;
+                        // Add parent class incompatible method as overload
+                        if (!this.getCompatibleTsFunction(baseSignal.overloads, bFunc)) {
+                            baseSignal.overloads.push(bFunc);
+                        }
+                    }
+                }
+                // If a element is a constructor
+                else if (this.tsElementIsConstructor(base.data)) {
+                    const baseConstr = base.data;
+                    // Constructor vs. Function
+                    if (this.tsElementIsMethodOrFunction(b.data)) {
+                        const bFunc = b.data;
+                        this.log.debug(`${className}.${name} Direct Constructor vs. Function`, baseConstr.inParams.map((p) => p._tsData?.name).join(', '), bFunc.inParams.map((p) => p._tsData?.name).join(', '));
+                        // Add a function to overload methods if there is not already a compatible version
+                        if (!this.getCompatibleTsFunction(baseConstr.overloads, bFunc)) {
+                            baseConstr.overloads.push(bFunc);
+                        }
+                    }
+                    // Constructor vs. Constructor
+                    else if (this.tsElementIsConstructor(base.data)) {
+                        const bConstr = b.data;
+                        this.log.debug(`${className}.${name} Direct Constructor vs. Constructor`, baseConstr, bConstr);
+                        // Add the constructor to overload methods if there is not already a compatible version
+                        if (!this.getCompatibleTsFunction(baseConstr.overloads, bConstr)) {
+                            baseConstr.overloads.push(bConstr);
+                        }
+                    }
+                }
+                else {
+                    this.log.warn(`{className}.${name} Unknown ${base.data.tsTypeName}`, base);
+                    base.data.hasUnresolvedConflict = true;
+                }
+            }
+        }
+    }
+    /**
+     * Fix the conflicts of a class
+     * @param groupedElements
+     */
+    fixConflicts(groupedElements) {
+        for (const key of Object.keys(groupedElements)) {
+            const elements = groupedElements[key];
+            // Remove the key prefix `_`
+            const name = key.substring(1);
+            if (elements.baseElements.length === 0) {
+                this.fixIndirectConflicts(name, elements.inheritedElements, elements.baseClass);
+            }
+            this.fixInternalConflicts(name, elements.baseElements, elements.baseClass);
+            this.fixDirectConflicts(name, elements);
+        }
+    }
+    /**
+     * Group conflicts by name and sort them by depth for simpler handling of conflicts
+     */
+    groupConflicts(elements, tsClass) {
+        const groupedConflicts = {};
+        const IGNORE_CONFLICT_NAMES = ['$gtype', '__gtype__'];
+        for (const a of elements) {
+            const name = a.data.name;
+            for (const b of elements) {
+                if (a === b ||
+                    !name ||
+                    !b.data.name ||
+                    IGNORE_CONFLICT_NAMES.includes(name) ||
+                    IGNORE_CONFLICT_NAMES.includes(b.data.name)) {
+                    continue;
+                }
+                if (a && name && b && b.data.name && a !== b && this.hasConflict(a, b)) {
+                    const key = `_${name}`; // if the key would be `toString` this would be always true so we prefix `_`
+                    groupedConflicts[key] ||= {
+                        baseElements: [],
+                        inheritedElements: [],
+                        baseClass: tsClass,
+                    };
+                    const groupedConflict = groupedConflicts[key];
+                    const isBaseElement = a.depth === 0;
+                    if (isBaseElement) {
+                        if (!groupedConflict.baseElements.find((c) => isEqual(c.data, a.data))) {
+                            groupedConflict.baseElements.push(a);
+                        }
+                    }
+                    else {
+                        if (!groupedConflict.baseElements.find((c) => isEqual(c.data, a.data)) &&
+                            !groupedConflict.inheritedElements.find((c) => isEqual(c.data, a.data))) {
+                            groupedConflict.inheritedElements.push(a);
+                        }
+                    }
+                }
+            }
+        }
+        // Sort by depth
+        for (const key of Object.keys(groupedConflicts)) {
+            groupedConflicts[key].inheritedElements = groupedConflicts[key].inheritedElements.sort((a, b) => a.depth - b.depth);
+        }
+        return groupedConflicts;
+    }
+    /**
+     * With multiple implementations or a inherit it can happen that the interfaces / parent have the same method and/or property name with incompatible types.
+     * We merge these types here to solve this problem.
+     * @param girClass
+     */
+    repairClass(girClass) {
+        if (!girClass._tsData)
+            throw new Error(NO_TSDATA('repairClass'));
+        const classElements = this.getClassElements(girClass._tsData, 0, []);
+        // Do not pass a reference of the array here
+        const elements = [
+            ...classElements.signalMethods,
+            ...classElements.propertySignalMethods,
+            ...classElements.methods,
+            ...classElements.virtualMethods,
+            ...classElements.staticFunctions,
+            ...classElements.constructors,
+            ...classElements.properties,
+            ...classElements.fields,
+        ];
+        const groupedElementConflicts = this.groupConflicts(elements, girClass._tsData);
+        const groupedConstructPropConflicts = this.groupConflicts(classElements.constructProps, girClass._tsData);
+        this.fixConflicts(groupedElementConflicts);
+        this.fixConflicts(groupedConstructPropConflicts);
+        return girClass;
+    }
+    /**
+     * Returns true if `p1s` and `p2s` conflicting with each other.
+     * The parameters must have the same length and the same type but can have different names
+     * @param params
+     * @returns
+     */
+    paramsHasConflict(...params) {
+        let conflict = false;
+        for (const p1s of params) {
+            for (const p2s of params) {
+                if (p1s.length !== p2s.length) {
+                    conflict = true;
+                    return conflict;
+                }
+                for (const [i, p1] of p1s.entries()) {
+                    const p2 = p2s[i];
+                    if (p2._tsData && p1._tsData) {
+                        if (this.typesHasConflict(p2._tsData?.type, p1._tsData?.type)) {
+                            conflict = true;
+                            return conflict;
+                        }
+                    }
+                    else {
+                        conflict = true;
+                        return conflict;
+                    }
+                }
+            }
+        }
+        return conflict;
+    }
+    typesHasConflict(a, b) {
+        if (a.length !== b.length) {
+            return true;
+        }
+        // return !isEqual(a, b.data)
+        for (let i = 0; i < a.length; i++) {
+            const aType = a[i];
+            const bType = b[i];
+            if (aType.type !== bType.type ||
+                aType.nullable !== bType.nullable ||
+                aType.optional !== bType.optional ||
+                aType.isFunction !== bType.isFunction ||
+                aType.isCallback !== bType.isCallback ||
+                aType.isArray !== bType.isArray ||
+                aType.callbacks.length !== bType.callbacks.length ||
+                aType.generics.length !== bType.generics.length ||
+                !isEqual(aType.callbacks, bType.callbacks) ||
+                !isEqual(aType.generics, bType.generics) ||
+                !isEqual(aType, bType) // TODO
+            ) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Returns `true` if the function / method types of `a` and `b` are not compatible with each other.
+     * The parameters must have the same length and the same type but can have different names
+     * @param a
+     * @param b
+     * @returns
+     */
+    functionHasConflict(a, b) {
+        // TODO find a better solution for that, not all this methods are conflicting
+        if (a.isVirtual !== b.isVirtual) {
+            return true;
+        }
+        if (this.typesHasConflict(a.returnTypes, b.returnTypes)) {
+            return true;
+        }
+        if (this.paramsHasConflict(a.inParams, b.inParams)) {
+            return true;
+        }
+        if (this.paramsHasConflict(a.outParams, b.outParams)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Returns `true` if the property types of `a` and `b` are not compatible with each other.
+     * @param a
+     * @param b
+     * @returns
+     */
+    propertyHasConflict(a, b) {
+        if (!!a.isStatic !== !!b.isStatic)
+            return false;
+        if (a.name !== b.name)
+            return false;
+        if (!!a.readonly !== !!b.readonly || this.typesHasConflict(a.type, b.type))
+            return true;
+        return false;
+    }
+    signalHasConflict(a, b) {
+        if (!!a.isStatic !== !!b.isStatic)
+            return false;
+        if (a.name !== b.name)
+            return false;
+        // TODO
+        return false;
+    }
+    /**
+     * Returns true if the elements (properties or methods) of `a` and `b` are not compatible with each other (has no conflict).
+     * @param a
+     * @param b
+     * @returns
+     */
+    elementHasConflict(a, b) {
+        if (a.name !== b.name) {
+            return false;
+        }
+        else if (this.tsElementIsStatic(a) !== this.tsElementIsStatic(b)) {
+            return false;
+        }
+        else if (this.tsElementIsMethodOrFunction(a) && this.tsElementIsMethodOrFunction(b)) {
+            return this.functionHasConflict(a, b);
+        }
+        else if (this.tsElementIsPropertyOrVariable(a) && this.tsElementIsPropertyOrVariable(b)) {
+            return this.propertyHasConflict(a, b);
+        }
+        else if (this.tsElementIsConstructor(a) && this.tsElementIsConstructor(b)) {
+            return this.functionHasConflict(a, b);
+        }
+        else if (this.tsElementIsSignal(a) && this.tsElementIsSignal(b)) {
+            // TODO
+            return this.signalHasConflict(a, b);
+        }
+        else if (a.tsTypeName !== b.tsTypeName) {
+            return true;
+        }
+        else {
+            return true;
+        }
+    }
+}
+//# sourceMappingURL=conflict-resolver.js.map