quicktype 18.0.6 → 19.0.4

package/dist/quicktype-core/TypeGraph.js

@@ -1,420 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeIndirectionIntersections = exports.optionalToNullable = exports.noneToAny = exports.TypeGraph = exports.TypeAttributeStoreView = exports.TypeAttributeStore = exports.typeAndAttributesForTypeRef = exports.attributesForTypeRef = exports.derefTypeRef = exports.assertTypeRefGraph = exports.typeRefIndex = exports.makeTypeRef = exports.isTypeRef = void 0;
-const collection_utils_1 = require("collection-utils");
-const Type_1 = require("./Type");
-const TypeUtils_1 = require("./TypeUtils");
-const Support_1 = require("./support/Support");
-const TypeBuilder_1 = require("./TypeBuilder");
-const GraphRewriting_1 = require("./GraphRewriting");
-const TypeNames_1 = require("./attributes/TypeNames");
-const Graph_1 = require("./Graph");
-const TypeAttributes_1 = require("./attributes/TypeAttributes");
-const Messages_1 = require("./Messages");
-const indexBits = 26;
-const indexMask = (1 << indexBits) - 1;
-const serialBits = 31 - indexBits;
-const serialMask = (1 << serialBits) - 1;
-function isTypeRef(x) {
-    return typeof x === "number";
-}
-exports.isTypeRef = isTypeRef;
-function makeTypeRef(graph, index) {
-    (0, Support_1.assert)(index <= indexMask, "Too many types in graph");
-    return ((graph.serial & serialMask) << indexBits) | index;
-}
-exports.makeTypeRef = makeTypeRef;
-function typeRefIndex(tref) {
-    return tref & indexMask;
-}
-exports.typeRefIndex = typeRefIndex;
-function assertTypeRefGraph(tref, graph) {
-    (0, Support_1.assert)(((tref >> indexBits) & serialMask) === (graph.serial & serialMask), "Mixing the wrong type reference and graph");
-}
-exports.assertTypeRefGraph = assertTypeRefGraph;
-function getGraph(graphOrBuilder) {
-    if (graphOrBuilder instanceof TypeGraph)
-        return graphOrBuilder;
-    return graphOrBuilder.originalGraph;
-}
-function derefTypeRef(tref, graphOrBuilder) {
-    const graph = getGraph(graphOrBuilder);
-    assertTypeRefGraph(tref, graph);
-    return graph.typeAtIndex(typeRefIndex(tref));
-}
-exports.derefTypeRef = derefTypeRef;
-function attributesForTypeRef(tref, graphOrBuilder) {
-    const graph = getGraph(graphOrBuilder);
-    assertTypeRefGraph(tref, graph);
-    return graph.atIndex(typeRefIndex(tref))[1];
-}
-exports.attributesForTypeRef = attributesForTypeRef;
-function typeAndAttributesForTypeRef(tref, graphOrBuilder) {
-    const graph = getGraph(graphOrBuilder);
-    assertTypeRefGraph(tref, graph);
-    return graph.atIndex(typeRefIndex(tref));
-}
-exports.typeAndAttributesForTypeRef = typeAndAttributesForTypeRef;
-class TypeAttributeStore {
-    _typeGraph;
-    _values;
-    _topLevelValues = new Map();
-    constructor(_typeGraph, _values) {
-        this._typeGraph = _typeGraph;
-        this._values = _values;
-    }
-    getTypeIndex(t) {
-        const tref = t.typeRef;
-        assertTypeRefGraph(tref, this._typeGraph);
-        return typeRefIndex(tref);
-    }
-    attributesForType(t) {
-        const index = this.getTypeIndex(t);
-        const maybeAttributes = this._values[index];
-        if (maybeAttributes !== undefined) {
-            return maybeAttributes;
-        }
-        return TypeAttributes_1.emptyTypeAttributes;
-    }
-    attributesForTopLevel(name) {
-        const maybeAttributes = this._topLevelValues.get(name);
-        if (maybeAttributes !== undefined) {
-            return maybeAttributes;
-        }
-        return TypeAttributes_1.emptyTypeAttributes;
-    }
-    setInMap(attributes, kind, value) {
-        // FIXME: This is potentially super slow
-        return new Map(attributes).set(kind, value);
-    }
-    set(kind, t, value) {
-        const index = this.getTypeIndex(t);
-        while (index >= this._values.length) {
-            this._values.push(undefined);
-        }
-        this._values[index] = this.setInMap(this.attributesForType(t), kind, value);
-    }
-    setForTopLevel(kind, topLevelName, value) {
-        this._topLevelValues.set(topLevelName, this.setInMap(this.attributesForTopLevel(topLevelName), kind, value));
-    }
-    tryGetInMap(attributes, kind) {
-        return attributes.get(kind);
-    }
-    tryGet(kind, t) {
-        return this.tryGetInMap(this.attributesForType(t), kind);
-    }
-    tryGetForTopLevel(kind, topLevelName) {
-        return this.tryGetInMap(this.attributesForTopLevel(topLevelName), kind);
-    }
-}
-exports.TypeAttributeStore = TypeAttributeStore;
-class TypeAttributeStoreView {
-    _attributeStore;
-    _definition;
-    constructor(_attributeStore, _definition) {
-        this._attributeStore = _attributeStore;
-        this._definition = _definition;
-    }
-    set(t, value) {
-        this._attributeStore.set(this._definition, t, value);
-    }
-    setForTopLevel(name, value) {
-        this._attributeStore.setForTopLevel(this._definition, name, value);
-    }
-    tryGet(t) {
-        return this._attributeStore.tryGet(this._definition, t);
-    }
-    get(t) {
-        return (0, Support_1.defined)(this.tryGet(t));
-    }
-    tryGetForTopLevel(name) {
-        return this._attributeStore.tryGetForTopLevel(this._definition, name);
-    }
-    getForTopLevel(name) {
-        return (0, Support_1.defined)(this.tryGetForTopLevel(name));
-    }
-}
-exports.TypeAttributeStoreView = TypeAttributeStoreView;
-class TypeGraph {
-    serial;
-    _haveProvenanceAttributes;
-    _typeBuilder;
-    _attributeStore = undefined;
-    // FIXME: OrderedMap?  We lose the order in PureScript right now, though,
-    // and maybe even earlier in the TypeScript driver.
-    _topLevels = new Map();
-    _types;
-    _parents = undefined;
-    _printOnRewrite = false;
-    constructor(typeBuilder, serial, _haveProvenanceAttributes) {
-        this.serial = serial;
-        this._haveProvenanceAttributes = _haveProvenanceAttributes;
-        this._typeBuilder = typeBuilder;
-    }
-    get isFrozen() {
-        return this._typeBuilder === undefined;
-    }
-    get attributeStore() {
-        return (0, Support_1.defined)(this._attributeStore);
-    }
-    freeze(topLevels, types, typeAttributes) {
-        (0, Support_1.assert)(!this.isFrozen, "Tried to freeze TypeGraph a second time");
-        for (const t of types) {
-            assertTypeRefGraph(t.typeRef, this);
-        }
-        this._attributeStore = new TypeAttributeStore(this, typeAttributes);
-        // The order of these three statements matters.  If we set _typeBuilder
-        // to undefined before we deref the TypeRefs, then we need to set _types
-        // before, also, because the deref will call into typeAtIndex, which requires
-        // either a _typeBuilder or a _types.
-        this._types = types;
-        this._typeBuilder = undefined;
-        this._topLevels = (0, collection_utils_1.mapMap)(topLevels, tref => derefTypeRef(tref, this));
-    }
-    get topLevels() {
-        (0, Support_1.assert)(this.isFrozen, "Cannot get top-levels from a non-frozen graph");
-        return this._topLevels;
-    }
-    typeAtIndex(index) {
-        if (this._typeBuilder !== undefined) {
-            return this._typeBuilder.typeAtIndex(index);
-        }
-        return (0, Support_1.defined)(this._types)[index];
-    }
-    atIndex(index) {
-        if (this._typeBuilder !== undefined) {
-            return this._typeBuilder.atIndex(index);
-        }
-        const t = this.typeAtIndex(index);
-        return [t, (0, Support_1.defined)(this._attributeStore).attributesForType(t)];
-    }
-    filterTypes(predicate) {
-        const seen = new Set();
-        let types = [];
-        function addFromType(t) {
-            if (seen.has(t))
-                return;
-            seen.add(t);
-            const required = predicate === undefined || predicate(t);
-            if (required) {
-                types.push(t);
-            }
-            for (const c of t.getChildren()) {
-                addFromType(c);
-            }
-        }
-        for (const [, t] of this.topLevels) {
-            addFromType(t);
-        }
-        return new Set(types);
-    }
-    allNamedTypes() {
-        return this.filterTypes(TypeUtils_1.isNamedType);
-    }
-    allNamedTypesSeparated() {
-        const types = this.allNamedTypes();
-        return (0, TypeUtils_1.separateNamedTypes)(types);
-    }
-    allProvenance() {
-        (0, Support_1.assert)(this._haveProvenanceAttributes);
-        const view = new TypeAttributeStoreView(this.attributeStore, TypeBuilder_1.provenanceTypeAttributeKind);
-        const sets = Array.from(this.allTypesUnordered()).map(t => {
-            const maybeSet = view.tryGet(t);
-            if (maybeSet !== undefined)
-                return maybeSet;
-            return new Set();
-        });
-        const result = new Set();
-        (0, collection_utils_1.setUnionManyInto)(result, sets);
-        return result;
-    }
-    setPrintOnRewrite() {
-        this._printOnRewrite = true;
-    }
-    checkLostTypeAttributes(builder, newGraph) {
-        if (!this._haveProvenanceAttributes || builder.lostTypeAttributes)
-            return;
-        const oldProvenance = this.allProvenance();
-        const newProvenance = newGraph.allProvenance();
-        if (oldProvenance.size !== newProvenance.size) {
-            const difference = (0, collection_utils_1.setSubtract)(oldProvenance, newProvenance);
-            const indexes = Array.from(difference);
-            return (0, Messages_1.messageError)("IRTypeAttributesNotPropagated", { count: difference.size, indexes });
-        }
-    }
-    printRewrite(title) {
-        if (!this._printOnRewrite)
-            return;
-        console.log(`\n# ${title}`);
-    }
-    // Each array in `replacementGroups` is a bunch of types to be replaced by a
-    // single new type.  `replacer` is a function that takes a group and a
-    // TypeBuilder, and builds a new type with that builder that replaces the group.
-    // That particular TypeBuilder will have to take as inputs types in the old
-    // graph, but return types in the new graph.  Recursive types must be handled
-    // carefully.
-    rewrite(title, stringTypeMapping, alphabetizeProperties, replacementGroups, debugPrintReconstitution, replacer, force = false) {
-        this.printRewrite(title);
-        if (!force && replacementGroups.length === 0)
-            return this;
-        const builder = new GraphRewriting_1.GraphRewriteBuilder(this, stringTypeMapping, alphabetizeProperties, this._haveProvenanceAttributes, replacementGroups, debugPrintReconstitution, replacer);
-        const newGraph = builder.finish();
-        this.checkLostTypeAttributes(builder, newGraph);
-        if (this._printOnRewrite) {
-            newGraph.setPrintOnRewrite();
-            newGraph.printGraph();
-        }
-        if (!builder.didAddForwardingIntersection)
-            return newGraph;
-        return removeIndirectionIntersections(newGraph, stringTypeMapping, debugPrintReconstitution);
-    }
-    remap(title, stringTypeMapping, alphabetizeProperties, map, debugPrintRemapping, force = false) {
-        this.printRewrite(title);
-        if (!force && map.size === 0)
-            return this;
-        const builder = new GraphRewriting_1.GraphRemapBuilder(this, stringTypeMapping, alphabetizeProperties, this._haveProvenanceAttributes, map, debugPrintRemapping);
-        const newGraph = builder.finish();
-        this.checkLostTypeAttributes(builder, newGraph);
-        if (this._printOnRewrite) {
-            newGraph.setPrintOnRewrite();
-            newGraph.printGraph();
-        }
-        (0, Support_1.assert)(!builder.didAddForwardingIntersection);
-        return newGraph;
-    }
-    garbageCollect(alphabetizeProperties, debugPrintReconstitution) {
-        const newGraph = this.remap("GC", (0, TypeBuilder_1.getNoStringTypeMapping)(), alphabetizeProperties, new Map(), debugPrintReconstitution, true);
-        return newGraph;
-    }
-    rewriteFixedPoint(alphabetizeProperties, debugPrintReconstitution) {
-        let graph = this;
-        for (;;) {
-            const newGraph = this.rewrite("fixed-point", (0, TypeBuilder_1.getNoStringTypeMapping)(), alphabetizeProperties, [], debugPrintReconstitution, Support_1.mustNotHappen, true);
-            if (graph.allTypesUnordered().size === newGraph.allTypesUnordered().size) {
-                return graph;
-            }
-            graph = newGraph;
-        }
-    }
-    allTypesUnordered() {
-        (0, Support_1.assert)(this.isFrozen, "Tried to get all graph types before it was frozen");
-        return new Set((0, Support_1.defined)(this._types));
-    }
-    makeGraph(invertDirection, childrenOfType) {
-        return new Graph_1.Graph((0, Support_1.defined)(this._types), invertDirection, childrenOfType);
-    }
-    getParentsOfType(t) {
-        assertTypeRefGraph(t.typeRef, this);
-        if (this._parents === undefined) {
-            const parents = (0, Support_1.defined)(this._types).map(_ => new Set());
-            for (const p of this.allTypesUnordered()) {
-                for (const c of p.getChildren()) {
-                    const index = c.index;
-                    parents[index] = parents[index].add(p);
-                }
-            }
-            this._parents = parents;
-        }
-        return this._parents[t.index];
-    }
-    printGraph() {
-        const types = (0, Support_1.defined)(this._types);
-        for (let i = 0; i < types.length; i++) {
-            const t = types[i];
-            const parts = [];
-            parts.push(`${t.debugPrintKind}${t.hasNames ? ` ${t.getCombinedName()}` : ""}`);
-            const children = t.getChildren();
-            if (children.size > 0) {
-                parts.push(`children ${Array.from(children)
-                    .map(c => c.index)
-                    .join(",")}`);
-            }
-            for (const [kind, value] of t.getAttributes()) {
-                const maybeString = kind.stringify(value);
-                if (maybeString !== undefined) {
-                    parts.push(maybeString);
-                }
-            }
-            console.log(`${i}: ${parts.join(" | ")}`);
-        }
-    }
-}
-exports.TypeGraph = TypeGraph;
-function noneToAny(graph, stringTypeMapping, debugPrintReconstitution) {
-    const noneTypes = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), t => t.kind === "none");
-    if (noneTypes.size === 0) {
-        return graph;
-    }
-    (0, Support_1.assert)(noneTypes.size === 1, "Cannot have more than one none type");
-    return graph.rewrite("none to any", stringTypeMapping, false, [Array.from(noneTypes)], debugPrintReconstitution, (types, builder, forwardingRef) => {
-        const attributes = (0, TypeUtils_1.combineTypeAttributesOfTypes)("union", types);
-        const tref = builder.getPrimitiveType("any", attributes, forwardingRef);
-        return tref;
-    });
-}
-exports.noneToAny = noneToAny;
-function optionalToNullable(graph, stringTypeMapping, debugPrintReconstitution) {
-    function rewriteClass(c, builder, forwardingRef) {
-        const properties = (0, collection_utils_1.mapMap)(c.getProperties(), (p, name) => {
-            const t = p.type;
-            let ref;
-            if (!p.isOptional || t.isNullable) {
-                ref = builder.reconstituteType(t);
-            }
-            else {
-                const nullType = builder.getPrimitiveType("null");
-                let members;
-                if (t instanceof Type_1.UnionType) {
-                    members = (0, collection_utils_1.setMap)(t.members, m => builder.reconstituteType(m)).add(nullType);
-                }
-                else {
-                    members = new Set([builder.reconstituteType(t), nullType]);
-                }
-                const attributes = TypeNames_1.namesTypeAttributeKind.setDefaultInAttributes(t.getAttributes(), () => TypeNames_1.TypeNames.make(new Set([name]), new Set(), true));
-                ref = builder.getUnionType(attributes, members);
-            }
-            return builder.makeClassProperty(ref, p.isOptional);
-        });
-        if (c.isFixed) {
-            return builder.getUniqueClassType(c.getAttributes(), true, properties, forwardingRef);
-        }
-        else {
-            return builder.getClassType(c.getAttributes(), properties, forwardingRef);
-        }
-    }
-    const classesWithOptional = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), t => t instanceof Type_1.ClassType && (0, collection_utils_1.mapSome)(t.getProperties(), p => p.isOptional));
-    const replacementGroups = Array.from(classesWithOptional).map(c => [c]);
-    if (classesWithOptional.size === 0) {
-        return graph;
-    }
-    return graph.rewrite("optional to nullable", stringTypeMapping, false, replacementGroups, debugPrintReconstitution, (setOfClass, builder, forwardingRef) => {
-        (0, Support_1.assert)(setOfClass.size === 1);
-        const c = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(setOfClass));
-        return rewriteClass(c, builder, forwardingRef);
-    });
-}
-exports.optionalToNullable = optionalToNullable;
-function removeIndirectionIntersections(graph, stringTypeMapping, debugPrintRemapping) {
-    const map = [];
-    for (const t of graph.allTypesUnordered()) {
-        if (!(t instanceof Type_1.IntersectionType))
-            continue;
-        const seen = new Set([t]);
-        let current = t;
-        while (current.members.size === 1) {
-            const member = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(current.members));
-            if (!(member instanceof Type_1.IntersectionType)) {
-                map.push([t, member]);
-                break;
-            }
-            if (seen.has(member)) {
-                // FIXME: Technically, this is an any type.
-                return (0, Support_1.panic)("There's a cycle of intersection types");
-            }
-            seen.add(member);
-            current = member;
-        }
-    }
-    return graph.remap("remove indirection intersections", stringTypeMapping, false, new Map(map), debugPrintRemapping);
-}
-exports.removeIndirectionIntersections = removeIndirectionIntersections;

package/dist/quicktype-core/TypeUtils.d.ts

@@ -1,33 +0,0 @@
-import { TypeAttributes, CombinationKind } from "./attributes/TypeAttributes";
-import { Type, PrimitiveType, ArrayType, EnumType, ObjectType, MapType, ClassType, ClassProperty, SetOperationType, UnionType } from "./Type";
-import { StringTypes } from "./attributes/StringTypes";
-export declare function assertIsObject(t: Type): ObjectType;
-export declare function assertIsClass(t: Type): ClassType;
-export declare function setOperationMembersRecursively<T extends SetOperationType>(setOperation: T, combinationKind: CombinationKind | undefined): [ReadonlySet<Type>, TypeAttributes];
-export declare function setOperationMembersRecursively<T extends SetOperationType>(setOperations: T[], combinationKind: CombinationKind | undefined): [ReadonlySet<Type>, TypeAttributes];
-export declare function makeGroupsToFlatten<T extends SetOperationType>(setOperations: Iterable<T>, include: ((members: ReadonlySet<Type>) => boolean) | undefined): Type[][];
-export declare function combineTypeAttributesOfTypes(combinationKind: CombinationKind, types: Iterable<Type>): TypeAttributes;
-export declare function isAnyOrNull(t: Type): boolean;
-export declare function removeNullFromUnion(t: UnionType, sortBy?: boolean | ((t: Type) => any)): [PrimitiveType | null, ReadonlySet<Type>];
-export declare function removeNullFromType(t: Type): [PrimitiveType | null, ReadonlySet<Type>];
-export declare function nullableFromUnion(t: UnionType): Type | null;
-export declare function nonNullTypeCases(t: Type): ReadonlySet<Type>;
-export declare function getNullAsOptional(cp: ClassProperty): [boolean, ReadonlySet<Type>];
-export declare function isNamedType(t: Type): boolean;
-export type SeparatedNamedTypes = {
-    objects: ReadonlySet<ObjectType>;
-    enums: ReadonlySet<EnumType>;
-    unions: ReadonlySet<UnionType>;
-};
-export declare function separateNamedTypes(types: Iterable<Type>): SeparatedNamedTypes;
-export declare function directlyReachableTypes<T>(t: Type, setForType: (t: Type) => ReadonlySet<T> | null): ReadonlySet<T>;
-export declare function directlyReachableSingleNamedType(type: Type): Type | undefined;
-export declare function stringTypesForType(t: PrimitiveType): StringTypes;
-export type StringTypeMatchers<U> = {
-    dateType?: (dateType: PrimitiveType) => U;
-    timeType?: (timeType: PrimitiveType) => U;
-    dateTimeType?: (dateTimeType: PrimitiveType) => U;
-};
-export declare function matchTypeExhaustive<U>(t: Type, noneType: (noneType: PrimitiveType) => U, anyType: (anyType: PrimitiveType) => U, nullType: (nullType: PrimitiveType) => U, boolType: (boolType: PrimitiveType) => U, integerType: (integerType: PrimitiveType) => U, doubleType: (doubleType: PrimitiveType) => U, stringType: (stringType: PrimitiveType) => U, arrayType: (arrayType: ArrayType) => U, classType: (classType: ClassType) => U, mapType: (mapType: MapType) => U, objectType: (objectType: ObjectType) => U, enumType: (enumType: EnumType) => U, unionType: (unionType: UnionType) => U, transformedStringType: (transformedStringType: PrimitiveType) => U): U;
-export declare function matchType<U>(type: Type, anyType: (anyType: PrimitiveType) => U, nullType: (nullType: PrimitiveType) => U, boolType: (boolType: PrimitiveType) => U, integerType: (integerType: PrimitiveType) => U, doubleType: (doubleType: PrimitiveType) => U, stringType: (stringType: PrimitiveType) => U, arrayType: (arrayType: ArrayType) => U, classType: (classType: ClassType) => U, mapType: (mapType: MapType) => U, enumType: (enumType: EnumType) => U, unionType: (unionType: UnionType) => U, transformedStringType?: (transformedStringType: PrimitiveType) => U): U;
-export declare function matchCompoundType(t: Type, arrayType: (arrayType: ArrayType) => void, classType: (classType: ClassType) => void, mapType: (mapType: MapType) => void, objectType: (objectType: ObjectType) => void, unionType: (unionType: UnionType) => void): void;

package/dist/quicktype-core/TypeUtils.js

@@ -1,230 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchCompoundType = exports.matchType = exports.matchTypeExhaustive = exports.stringTypesForType = exports.directlyReachableSingleNamedType = exports.directlyReachableTypes = exports.separateNamedTypes = exports.isNamedType = exports.getNullAsOptional = exports.nonNullTypeCases = exports.nullableFromUnion = exports.removeNullFromType = exports.removeNullFromUnion = exports.isAnyOrNull = exports.combineTypeAttributesOfTypes = exports.makeGroupsToFlatten = exports.setOperationMembersRecursively = exports.assertIsClass = exports.assertIsObject = void 0;
-const collection_utils_1 = require("collection-utils");
-const Support_1 = require("./support/Support");
-const TypeAttributes_1 = require("./attributes/TypeAttributes");
-const Type_1 = require("./Type");
-const StringTypes_1 = require("./attributes/StringTypes");
-function assertIsObject(t) {
-    if (t instanceof Type_1.ObjectType) {
-        return t;
-    }
-    return (0, Support_1.panic)("Supposed object type is not an object type");
-}
-exports.assertIsObject = assertIsObject;
-function assertIsClass(t) {
-    if (!(t instanceof Type_1.ClassType)) {
-        return (0, Support_1.panic)("Supposed class type is not a class type");
-    }
-    return t;
-}
-exports.assertIsClass = assertIsClass;
-function setOperationMembersRecursively(oneOrMany, combinationKind) {
-    const setOperations = Array.isArray(oneOrMany) ? oneOrMany : [oneOrMany];
-    const kind = setOperations[0].kind;
-    const includeAny = kind !== "intersection";
-    const processedSetOperations = new Set();
-    const members = new Set();
-    let attributes = TypeAttributes_1.emptyTypeAttributes;
-    function process(t) {
-        if (t.kind === kind) {
-            const so = t;
-            if (processedSetOperations.has(so))
-                return;
-            processedSetOperations.add(so);
-            if (combinationKind !== undefined) {
-                attributes = (0, TypeAttributes_1.combineTypeAttributes)(combinationKind, attributes, t.getAttributes());
-            }
-            for (const m of so.members) {
-                process(m);
-            }
-        }
-        else if (includeAny || t.kind !== "any") {
-            members.add(t);
-        }
-        else {
-            if (combinationKind !== undefined) {
-                attributes = (0, TypeAttributes_1.combineTypeAttributes)(combinationKind, attributes, t.getAttributes());
-            }
-        }
-    }
-    for (const so of setOperations) {
-        process(so);
-    }
-    return [members, attributes];
-}
-exports.setOperationMembersRecursively = setOperationMembersRecursively;
-function makeGroupsToFlatten(setOperations, include) {
-    const typeGroups = new collection_utils_1.EqualityMap();
-    for (const u of setOperations) {
-        // FIXME: We shouldn't have to make a new set here once we got rid
-        // of immutable.
-        const members = new Set(setOperationMembersRecursively(u, undefined)[0]);
-        if (include !== undefined) {
-            if (!include(members))
-                continue;
-        }
-        let maybeSet = typeGroups.get(members);
-        if (maybeSet === undefined) {
-            maybeSet = new Set();
-            if (members.size === 1) {
-                maybeSet.add((0, Support_1.defined)((0, collection_utils_1.iterableFirst)(members)));
-            }
-        }
-        maybeSet.add(u);
-        typeGroups.set(members, maybeSet);
-    }
-    return Array.from(typeGroups.values()).map(ts => Array.from(ts));
-}
-exports.makeGroupsToFlatten = makeGroupsToFlatten;
-function combineTypeAttributesOfTypes(combinationKind, types) {
-    return (0, TypeAttributes_1.combineTypeAttributes)(combinationKind, Array.from(types).map(t => t.getAttributes()));
-}
-exports.combineTypeAttributesOfTypes = combineTypeAttributesOfTypes;
-function isAnyOrNull(t) {
-    return t.kind === "any" || t.kind === "null";
-}
-exports.isAnyOrNull = isAnyOrNull;
-// FIXME: We shouldn't have to sort here.  This is just because we're not getting
-// back the right order from JSON Schema, due to the changes the intersection types
-// introduced.
-function removeNullFromUnion(t, sortBy = false) {
-    function sort(s) {
-        if (sortBy === false)
-            return s;
-        if (sortBy === true)
-            return (0, collection_utils_1.setSortBy)(s, m => m.kind);
-        return (0, collection_utils_1.setSortBy)(s, sortBy);
-    }
-    const nullType = t.findMember("null");
-    if (nullType === undefined) {
-        return [null, sort(t.members)];
-    }
-    return [nullType, sort((0, collection_utils_1.setFilter)(t.members, m => m.kind !== "null"))];
-}
-exports.removeNullFromUnion = removeNullFromUnion;
-function removeNullFromType(t) {
-    if (t.kind === "null") {
-        return [t, new Set()];
-    }
-    if (!(t instanceof Type_1.UnionType)) {
-        return [null, new Set([t])];
-    }
-    return removeNullFromUnion(t);
-}
-exports.removeNullFromType = removeNullFromType;
-function nullableFromUnion(t) {
-    const [hasNull, nonNulls] = removeNullFromUnion(t);
-    if (hasNull === null)
-        return null;
-    if (nonNulls.size !== 1)
-        return null;
-    return (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(nonNulls));
-}
-exports.nullableFromUnion = nullableFromUnion;
-function nonNullTypeCases(t) {
-    return removeNullFromType(t)[1];
-}
-exports.nonNullTypeCases = nonNullTypeCases;
-function getNullAsOptional(cp) {
-    const [maybeNull, nonNulls] = removeNullFromType(cp.type);
-    if (cp.isOptional) {
-        return [true, nonNulls];
-    }
-    return [maybeNull !== null, nonNulls];
-}
-exports.getNullAsOptional = getNullAsOptional;
-// FIXME: Give this an appropriate name, considering that we don't distinguish
-// between named and non-named types anymore.
-function isNamedType(t) {
-    return ["class", "union", "enum", "object"].indexOf(t.kind) >= 0;
-}
-exports.isNamedType = isNamedType;
-function separateNamedTypes(types) {
-    const objects = (0, collection_utils_1.setFilter)(types, t => t.kind === "object" || t.kind === "class");
-    const enums = (0, collection_utils_1.setFilter)(types, t => t instanceof Type_1.EnumType);
-    const unions = (0, collection_utils_1.setFilter)(types, t => t instanceof Type_1.UnionType);
-    return { objects, enums, unions };
-}
-exports.separateNamedTypes = separateNamedTypes;
-function directlyReachableTypes(t, setForType) {
-    const set = setForType(t);
-    if (set !== null)
-        return set;
-    return (0, collection_utils_1.setUnion)(...Array.from(t.getNonAttributeChildren()).map(c => directlyReachableTypes(c, setForType)));
-}
-exports.directlyReachableTypes = directlyReachableTypes;
-function directlyReachableSingleNamedType(type) {
-    const definedTypes = directlyReachableTypes(type, t => {
-        if ((!(t instanceof Type_1.UnionType) && isNamedType(t)) ||
-            (t instanceof Type_1.UnionType && nullableFromUnion(t) === null)) {
-            return new Set([t]);
-        }
-        return null;
-    });
-    (0, Support_1.assert)(definedTypes.size <= 1, "Cannot have more than one defined type per top-level");
-    return (0, collection_utils_1.iterableFirst)(definedTypes);
-}
-exports.directlyReachableSingleNamedType = directlyReachableSingleNamedType;
-function stringTypesForType(t) {
-    (0, Support_1.assert)(t.kind === "string", "Only strings can have string types");
-    const stringTypes = StringTypes_1.stringTypesTypeAttributeKind.tryGetInAttributes(t.getAttributes());
-    if (stringTypes === undefined) {
-        return (0, Support_1.panic)("All strings must have a string type attribute");
-    }
-    return stringTypes;
-}
-exports.stringTypesForType = stringTypesForType;
-function matchTypeExhaustive(t, noneType, anyType, nullType, boolType, integerType, doubleType, stringType, arrayType, classType, mapType, objectType, enumType, unionType, transformedStringType) {
-    if (t.isPrimitive()) {
-        if ((0, Type_1.isPrimitiveStringTypeKind)(t.kind)) {
-            if (t.kind === "string") {
-                return stringType(t);
-            }
-            return transformedStringType(t);
-        }
-        const kind = t.kind;
-        const f = {
-            none: noneType,
-            any: anyType,
-            null: nullType,
-            bool: boolType,
-            integer: integerType,
-            double: doubleType
-        }[kind];
-        if (f !== undefined)
-            return f(t);
-        return (0, Support_1.assertNever)(f);
-    }
-    else if (t instanceof Type_1.ArrayType)
-        return arrayType(t);
-    else if (t instanceof Type_1.ClassType)
-        return classType(t);
-    else if (t instanceof Type_1.MapType)
-        return mapType(t);
-    else if (t instanceof Type_1.ObjectType)
-        return objectType(t);
-    else if (t instanceof Type_1.EnumType)
-        return enumType(t);
-    else if (t instanceof Type_1.UnionType)
-        return unionType(t);
-    return (0, Support_1.panic)(`Unknown type ${t.kind}`);
-}
-exports.matchTypeExhaustive = matchTypeExhaustive;
-function matchType(type, anyType, nullType, boolType, integerType, doubleType, stringType, arrayType, classType, mapType, enumType, unionType, transformedStringType) {
-    function typeNotSupported(t) {
-        return (0, Support_1.panic)(`Unsupported type ${t.kind} in non-exhaustive match`);
-    }
-    /* tslint:disable:strict-boolean-expressions */
-    return matchTypeExhaustive(type, typeNotSupported, anyType, nullType, boolType, integerType, doubleType, stringType, arrayType, classType, mapType, typeNotSupported, enumType, unionType, transformedStringType || typeNotSupported);
-    /* tslint:enable */
-}
-exports.matchType = matchType;
-function matchCompoundType(t, arrayType, classType, mapType, objectType, unionType) {
-    function ignore(_) {
-        return;
-    }
-    return matchTypeExhaustive(t, ignore, ignore, ignore, ignore, ignore, ignore, ignore, arrayType, classType, mapType, objectType, ignore, unionType, ignore);
-}
-exports.matchCompoundType = matchCompoundType;