Function unifyTypes

src/JSONSchemaInput.ts:204–238

(typesToUnify: TypeRef[], typeName: string, isInferred: boolean)

    }

    function unifyTypes(typesToUnify: TypeRef[], typeName: string, isInferred: boolean): TypeRef {
        if (typesToUnify.length === 0) {
            return panic("Cannot unify empty list of types");
        } else if (typesToUnify.length === 1) {
            return typesToUnify[0];
        } else {
            const unionBuilder = new UnifyUnionBuilder(typeBuilder, typeName, isInferred, unifyTypes);

            const registerType = (t: Type): void => {
                matchTypeExhaustive<void>(
                    t,
                    _anyType => unionBuilder.addAny(),
                    _nullType => unionBuilder.addNull(),
                    _boolType => unionBuilder.addBool(),
                    _integerType => unionBuilder.addInteger(),
                    _doubleType => unionBuilder.addDouble(),
                    _stringType => unionBuilder.addStringType("string"),
                    arrayType => unionBuilder.addArray(arrayType.items.typeRef),
                    classType => unionBuilder.addClass(classType.typeRef),
                    mapType => unionBuilder.addMap(mapType.values.typeRef),
                    enumType => enumType.cases.forEach(s => unionBuilder.addEnumCase(s)),
                    unionType => unionType.members.forEach(registerType),
                    _dateType => unionBuilder.addStringType("date"),
                    _timeType => unionBuilder.addStringType("time"),
                    _dateTimeType => unionBuilder.addStringType("date-time")
                );
            };

            for (const t of typesToUnify) {
                registerType(getHopefullyFinishedType(typeBuilder, t));
            }

            return unionBuilder.buildUnion(false);
        }
    }

    function lookupRef(local: StringMap, localPath: Ref, ref: Ref): [StringMap, Ref] {
        const first = ref.first();