@ts-for-gir/cli 3.0.0-beta.9 → 3.0.1

package/src/conflict-resolver.ts

@@ -1,1358 +0,0 @@
-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'
-import type {
-    Environment,
-    GirClassElement,
-    GirRecordElement,
-    GirUnionElement,
-    GirInterfaceElement,
-    GirCallableParamElement,
-    GirMethodElement,
-    GirVirtualMethodElement,
-    GirConstructorElement,
-    GirFunctionElement,
-    GirPropertyElement,
-    GirFieldElement,
-    TsSignal,
-    TsFunction,
-    TsProperty,
-    TsVar,
-    TsTypeSeparator,
-    TsType,
-    TsClass,
-    TsParameter,
-    TypeGirFunction,
-    TypeGirProperty,
-    ConflictChildElement,
-    ConflictGroupedElements,
-    ConflictGroupedElement,
-} from './types/index.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 {
-    private log: Logger
-
-    private girFactory = new GirFactory()
-
-    constructor(private readonly environment: Environment, private readonly verbose: boolean) {
-        this.log = new Logger(environment, verbose, 'ConflictResolver')
-    }
-
-    private girElArrToChildArr<T = TsFunction | TsProperty | TsVar>(
-        dataArr: Array<
-            | GirMethodElement
-            | GirVirtualMethodElement
-            | GirConstructorElement
-            | GirFunctionElement
-            | GirPropertyElement
-            | GirFieldElement
-        >,
-        depth: number,
-    ): ConflictChildElement<T>[] {
-        return dataArr
-            .filter((data) => !!data?._tsData)
-            .map((data) => {
-                if (!data?._tsData) throw new Error('_tsData not set!')
-                return {
-                    depth,
-                    data: data?._tsData as unknown as T,
-                }
-            })
-    }
-
-    private tsElArrToChildArr<T extends ConflictChildElement>(
-        dataArr: Array<TsFunction | TsProperty | TsVar>,
-        depth: number,
-    ): T[] {
-        return dataArr
-            .filter((m) => !!m)
-            .map((data) => {
-                return {
-                    depth,
-                    data,
-                } as T
-            })
-    }
-
-    /**
-     * Get class elements and parent elements (implementations and inherits)
-     * @param tsClass
-     * @param depth
-     * @returns
-     */
-    private getClassElements(tsClass: TsClass, depth: number, processedClasses: string[]) {
-        const tsClassFullPackageSymName = `${tsClass.namespace}-${tsClass.version}.${tsClass.namespace}.${tsClass.name}`
-
-        const signalMethods: ConflictChildElement<TsFunction>[] = []
-        const propertySignalMethods: ConflictChildElement<TsFunction>[] = []
-        const methods: ConflictChildElement<TsFunction>[] = []
-        const virtualMethods: ConflictChildElement<TsFunction>[] = []
-        const staticFunctions: ConflictChildElement<TsFunction>[] = []
-        const constructors: ConflictChildElement<TsFunction>[] = []
-
-        const properties: ConflictChildElement<TsProperty | TsVar>[] = []
-        const fields: ConflictChildElement<TsProperty | TsVar>[] = []
-        const constructProps: ConflictChildElement<TsProperty | TsVar>[] = []
-
-        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) as TsSignal[]
-        for (const tsSignal of _signals) {
-            signalMethods.push(...this.tsElArrToChildArr<ConflictChildElement<TsFunction>>(tsSignal.tsMethods, depth))
-        }
-        // Property signals
-        propertySignalMethods.push(
-            ...this.tsElArrToChildArr<ConflictChildElement<TsFunction>>(tsClass.propertySignalMethods, depth),
-        )
-        // Methods
-        if (tsClass.methods.length) methods.push(...this.girElArrToChildArr<TsFunction>(tsClass.methods, depth))
-        // Virtual methods
-        if (tsClass.virtualMethods.length)
-            virtualMethods.push(...this.girElArrToChildArr<TsFunction>(tsClass.virtualMethods, depth))
-        // Static functions
-        if (tsClass.staticFunctions.length)
-            staticFunctions.push(...this.girElArrToChildArr<TsFunction>(tsClass.staticFunctions, depth))
-        // Constructors
-        if (tsClass.constructors.length)
-            constructors.push(...this.girElArrToChildArr<TsFunction>(tsClass.constructors, depth))
-        // Properties
-        if (tsClass.properties.length)
-            properties.push(...this.girElArrToChildArr<TsProperty | TsVar>(tsClass.properties, depth))
-        // Fields
-        if (tsClass.fields.length) fields.push(...this.girElArrToChildArr<TsProperty | TsVar>(tsClass.fields, depth))
-        // Constructor properties
-        if (tsClass.constructProps.length)
-            constructProps.push(...this.girElArrToChildArr<TsProperty | TsVar>(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,
-        }
-    }
-
-    private tsElementIsMethod(el: TsFunction | TsVar) {
-        return !this.tsElementIsStatic(el) && this.tsElementIsMethodOrFunction(el)
-    }
-
-    private tsElementIsStaticFunction(el: TsFunction | TsVar) {
-        return this.tsElementIsStatic(el) && this.tsElementIsMethodOrFunction(el)
-    }
-
-    private tsElementIsProperty(el: TsFunction | TsVar) {
-        return !this.tsElementIsStatic(el) && this.tsElementIsPropertyOrVariable(el)
-    }
-
-    private tsElementIsStaticProperty(el: TsFunction | TsVar) {
-        return this.tsElementIsStatic(el) && this.tsElementIsPropertyOrVariable(el)
-    }
-
-    private tsElementIsSignal(el: TsFunction | TsVar) {
-        return el.tsTypeName === 'event-methods'
-    }
-
-    private tsElementIsConstructor(el: TsFunction | TsVar) {
-        return el.tsTypeName === 'constructor'
-    }
-
-    private tsElementIsMethodOrFunction(el: TsFunction | TsVar) {
-        return el.tsTypeName === 'function' || el.tsTypeName === 'method' || el.tsTypeName === 'static-function'
-    }
-
-    private tsElementIsPropertyOrVariable(el: TsFunction | TsVar | TsProperty) {
-        return (
-            el.tsTypeName === 'constant' ||
-            el.tsTypeName === 'constructor-property' ||
-            el.tsTypeName === 'property' ||
-            el.tsTypeName === 'static-property'
-        )
-    }
-
-    private tsElementIsStatic(el: TsFunction | TsVar) {
-        return (
-            // el.tsTypeName === 'constructor' ||
-            (el as TsFunction).isStatic || el.tsTypeName === 'static-property' || el.tsTypeName === 'static-function'
-        )
-    }
-
-    private typeIsString(type: TsType) {
-        return (
-            type.type === 'string' ||
-            (type.type.startsWith("'") && type.type.endsWith("'")) ||
-            (type.type.startsWith('"') && type.type.endsWith('"'))
-        )
-    }
-
-    private mergeTypes(leftSeparator: TsTypeSeparator, ...types: Array<TsType | undefined>) {
-        const dest: TsType[] = []
-
-        for (const type of types) {
-            if (!type) continue
-            if (!dest.find((destType) => isEqual(destType, type))) {
-                dest.push({ ...type, leftSeparator })
-            }
-        }
-
-        return dest
-    }
-
-    private setTypesProperty(types: TsType[], property: 'optional', value: boolean) {
-        for (const type of types) {
-            type[property] = value
-        }
-        return types
-    }
-
-    /**
-     * Merges two parameter name and type of two parameters
-     * @param a
-     * @param b
-     * @returns
-     */
-    private mergeParam(a: GirCallableParamElement | undefined, b: GirCallableParamElement | undefined) {
-        if (!a?._tsData && !b?._tsData) {
-            throw new Error('At least one parameter must be defined!')
-        }
-
-        let dest: GirCallableParamElement
-
-        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) as GirCallableParamElement)
-            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
-     */
-    private mergeParams(...params: GirCallableParamElement[][]) {
-        let dest: GirCallableParamElement[] = []
-
-        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<GirCallableParamElement>(length)
-                    for (let i = 0; i < length; i++) {
-                        const aParam = a[i] as GirCallableParamElement | undefined
-                        const bParam = b[i] as GirCallableParamElement | undefined
-                        dest[i] = this.mergeParam(aParam, bParam)
-                    }
-                }
-            }
-        }
-
-        return dest
-    }
-
-    private paramCanBeOptional(
-        girParam: GirCallableParamElement,
-        girParams: GirCallableParamElement[],
-        skip: GirCallableParamElement[] = [],
-    ) {
-        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
-     */
-    private fixOptionalParameters(girParams: GirCallableParamElement[]) {
-        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
-     */
-    public mergeFunctions(baseFunc: TsFunction | null, ...funcs: TsFunction[]) {
-        const returnTypesMap: TsType[] = []
-        for (const func of funcs) {
-            returnTypesMap.push(...func.returnTypes)
-        }
-        const returnTypes = this.mergeTypes('|', ...returnTypesMap)
-
-        const inParamsMap = funcs.map((func) => func.inParams)
-        const inParams: GirCallableParamElement[] = []
-        if (this.paramsHasConflict(...inParamsMap)) {
-            inParams.push(...this.mergeParams(...inParamsMap))
-        }
-
-        const outParamsMap = funcs.map((func) => func.outParams)
-        const outParams: GirCallableParamElement[] = []
-        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) as TsParameter[],
-                outParams: outParams
-                    .map((outParam) => outParam._tsData)
-                    .filter((outParam) => !!outParam) as TsParameter[],
-                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
-     */
-    public mergeProperties(typeSeparator: TsTypeSeparator, baseProp: TsProperty | null, ...props: TsProperty[]) {
-        const typesMap: TsType[] = []
-        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
-     */
-    public hasConflict(a: ConflictChildElement, b: ConflictChildElement) {
-        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
-    }
-
-    public newAnyTsProperty(name: string, girTypeName: TypeGirProperty) {
-        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
-     */
-    public newAnyTsFunction(name: string, girTypeName: TypeGirFunction, isStatic: boolean, parent: TsClass | null) {
-        return this.girFactory.newTsFunction(
-            {
-                name,
-                isStatic,
-                inParams: [
-                    {
-                        name: 'args',
-                        isRest: true,
-                        type: [this.girFactory.newTsType({ type: 'any', isArray: true })],
-                    },
-                ],
-                returnTypes: [{ type: 'any' }],
-                girTypeName,
-            },
-            parent,
-        )
-    }
-
-    public getCompatibleTsProperty(elements: TsProperty[], baseProp: TsProperty) {
-        return elements.find((prop) => !this.propertyHasConflict(baseProp, prop))
-    }
-
-    public getCompatibleTsFunction(elements: TsFunction[], baseFunc: TsFunction) {
-        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
-     */
-    public getTsElementByName(elements: (TsProperty | TsFunction)[], name: string) {
-        return elements.find((el) => el.name === name)
-    }
-
-    protected canAddConflictProperty(conflictProperties: TsProperty[], prop: TsProperty) {
-        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
-    }
-
-    public groupSignalConflicts(signalsMethods: ConflictChildElement<TsFunction>[], baseClass: TsClass) {
-        const groupedConflicts: ConflictGroupedElements = {}
-        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
-    }
-
-    public fixSignalConflicts(groupedElements: ConflictGroupedElements) {
-        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.
-     */
-    public fixIndirectConflicts(name: string, elements: ConflictChildElement[], baseClass: TsClass) {
-        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 as TsFunction
-
-                    // 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 as TsFunction
-                        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 as TsFunction
-                        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 as TsFunction
-
-                    // Constructor vs. Function
-                    if (this.tsElementIsMethodOrFunction(b.data)) {
-                        const bFunc = b.data as TsFunction
-                        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 as TsProperty
-
-                    // Property vs. Function
-                    if (this.tsElementIsMethodOrFunction(b.data)) {
-                        const bFunc = b.data as TsFunction
-                        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 as TsProperty
-                        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)
-     */
-    public fixInternalConflicts(name: string, elements: ConflictChildElement[], baseClass: TsClass) {
-        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 as TsFunction
-
-                    // 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 as TsFunction
-                        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 as TsProperty
-
-                    // Property vs. Function
-                    if (this.tsElementIsMethodOrFunction(b.data)) {
-                        const bFunc = b.data as TsFunction
-                        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 as TsProperty
-                        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 as TsSignal
-                    // 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
-     */
-    public fixDirectConflicts(name: string, elements: ConflictGroupedElement) {
-        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 as TsFunction
-
-                    // Function vs. Function
-                    if (this.tsElementIsMethodOrFunction(b.data)) {
-                        const bFunc = b.data as TsFunction
-                        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 as TsFunction
-                        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 as TsProperty
-
-                    // Property vs. Property
-                    if (this.tsElementIsPropertyOrVariable(b.data)) {
-                        const bProp = b.data as TsProperty
-                        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 as TsFunction
-                        const baseSignal = base.data as TsFunction
-                        // 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 as TsFunction
-
-                    // Constructor vs. Function
-                    if (this.tsElementIsMethodOrFunction(b.data)) {
-                        const bFunc = b.data as TsFunction
-                        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 as TsFunction
-                        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
-     */
-    public fixConflicts(groupedElements: ConflictGroupedElements) {
-        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
-     */
-    public groupConflicts(elements: ConflictChildElement[], tsClass: TsClass) {
-        const groupedConflicts: ConflictGroupedElements = {}
-
-        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
-     */
-    public repairClass(girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement) {
-        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
-     */
-    public paramsHasConflict(...params: GirCallableParamElement[][]) {
-        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
-    }
-
-    public typesHasConflict(a: TsType[], b: TsType[]) {
-        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
-     */
-    public functionHasConflict(a: TsFunction, b: TsFunction) {
-        // 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
-     */
-    public propertyHasConflict(a: TsVar & TsProperty, b: TsVar & TsProperty) {
-        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
-    }
-
-    public signalHasConflict(a: TsSignal, b: TsSignal) {
-        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
-     */
-    public elementHasConflict(
-        a: TsFunction | TsVar | TsProperty | TsSignal,
-        b: TsFunction | TsVar | TsProperty | TsSignal,
-    ) {
-        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 as TsFunction, b as TsFunction)
-        } else if (this.tsElementIsPropertyOrVariable(a) && this.tsElementIsPropertyOrVariable(b)) {
-            return this.propertyHasConflict(a as TsVar & TsProperty, b as TsVar & TsProperty)
-        } else if (this.tsElementIsConstructor(a) && this.tsElementIsConstructor(b)) {
-            return this.functionHasConflict(a as TsFunction, b as TsFunction)
-        } else if (this.tsElementIsSignal(a) && this.tsElementIsSignal(b)) {
-            // TODO
-            return this.signalHasConflict(a as TsSignal, b as TsSignal)
-        } else if (a.tsTypeName !== b.tsTypeName) {
-            return true
-        } else {
-            return true
-        }
-    }
-}