Function shouldBeMap

src/InferMaps.ts:12–54

(properties: Map<string, Type>)

const mapSizeThreshold = 20;

export function shouldBeMap(properties: Map<string, Type>): [OrderedSet<Type>, boolean] | undefined {
    // Only classes with a certain number of properties are inferred
    // as maps.
    if (properties.size < mapSizeThreshold) {
        return undefined;
    }

    // We need to handle three cases for maps (and the fourth case
    // where we leave the class as is):
    //
    // 1. All property types are null.
    // 2. Some property types are null or nullable.
    // 3. No property types are null or nullable.
    let nonNullCases: OrderedSet<Type> | undefined = undefined;
    let isNullable = false;
    let canBeMap = true;
    // Check that all the property types are the same, modulo nullability.
    properties.forEach(t => {
        // The set of types first property can be, minus null.
        const nn = nonNullTypeCases(t);
        if (!nn.isEmpty()) {
            if (nonNullCases !== undefined) {
                // The set of non-null cases for all other properties must
                // be the the same, otherwise we won't infer a map.
                if (!nn.toSet().equals(nonNullCases.toSet())) {
                    canBeMap = false;
                    return false;
                }
            } else {
                nonNullCases = nn;
            }
        }
        isNullable = isNullable || t.isNullable;
    });
    if (!canBeMap) {
        return undefined;
    }
    if (nonNullCases === undefined) {
        assert(isNullable, "Non-nullable map candidate with no types");
        return [OrderedSet(), true];
    }
    return [nonNullCases, isNullable];
}

export function replaceClass(setOfOneClass: Set<ClassType>, builder: GraphRewriteBuilder<ClassType>): TypeRef {
    const c = defined(setOfOneClass.first());