Conditional type check on type inferred from mapped type false negative

[ksabry]

TypeScript Version: 3.7.0-dev.20190910

Also tested in 3.6.2, 3.5.2

Search Terms:

conditional mapped inference inferred

Code

// Simple mapped type and inferrence
type Mapped<T> = { [K in keyof T]: { name: T[K] } };
type InferFromMapped<T> = T extends Mapped<infer R> ? R : never;

// Object literal type and associated mapped type
// Note that in the real code we don't have a direct reference to LiteralType
type LiteralType = {
	first: "first";
	second: "second";
}
type MappedLiteralType = {
	first: { name: "first" },
	second: { name: "second" },
};

type Inferred = InferFromMapped<MappedLiteralType>;

// UNEXPECTED resolves to false
type Test1 = Inferred extends Record<any, string> ? true : false;

// true as expected
type Test2 = LiteralType extends Record<any, string> ? true : false;

// true as expected; currently using this as a workaround
type Test3 = Inferred extends Record<keyof Inferred, string> ? true : false;

Expected behavior:

As Inferred and LiteralType are equivalent, we would expect Inferred extends Record<any, string> to resolve to true just as the case with LiteralType does.

Actual behavior:

Test1 resolves to false. This has the same behavior for similar expressions of the record (e.g. Record<string, string>, { [key: string]: string }); interestingly though, if we write the record Record<keyof Inferred, string> we get the expected behavior, this is the current workaround I'm using.

We also get the expected behavior if we instead defined MappedLiteralType as Mapped<LiteralType>. However in the code I encountered this, we have no direct access to LiteralType, only Inferred; I added LiteralType to the example only for demonstration of the expected behavior.

Playground Link:

Playground

Related Issues:

[jack-williams]

Definitely looks like some index signatures on not getting set when inferring from mapped types. The issue here is orthogonal to conditional types:

// Smaller repro.
type Mapped<T> = { [K in keyof T]: { name: T[K] } };
type MappedLiteralType = {
	first: { name: "first" },
	second: { name: "second" },
};
declare function foo<R>(r: Mapped<R>): R;
const x: Record<any, string> = foo(undefined as any as MappedLiteralType); // error

Furthermore, the following works correctly:

type Inferred = Pick<InferFromMapped<MappedLiteralType>, keyof InferFromMapped<MappedLiteralType>>;

[ksabry]

I looked into this a bit more, from what I can tell the issue is in isObjectTypeWithInferableIndex (in checker.ts):

/**
 * Return true if type was inferred from an object literal, written as an object type literal, or is the shape of a module
 * with no call or construct signatures.
 */
function isObjectTypeWithInferableIndex(type: Type) {
    return type.symbol && (type.symbol.flags & (SymbolFlags.ObjectLiteral | SymbolFlags.TypeLiteral | SymbolFlags.Enum | SymbolFlags.ValueModule)) !== 0 &&
        !typeHasCallOrConstructSignatures(type);
}

This method is called when comparing the indexes in indexTypesRelatedTo, and returns false for the instantiated ReverseMappedType because its symbol is undefined. Changing it the following fixes the issue (with no failing tests)

/**
 * Return true if type was inferred from an object literal, written as an object type literal, or is the shape of a module
 * with no call or construct signatures.
 */
function isObjectTypeWithInferableIndex(type: Type) {
    // ReverseMappedType does not have a symbol but will always have an inferable index
    if (getObjectFlags(type) & ObjectFlags.ReverseMapped) {
        return true;
    }
    return type.symbol && (type.symbol.flags & (SymbolFlags.ObjectLiteral | SymbolFlags.TypeLiteral | SymbolFlags.Enum | SymbolFlags.ValueModule)) !== 0 &&
        !typeHasCallOrConstructSignatures(type);
}

I don't know if this is the best approach, one other way I tried which also seems to work is to add a TypeLiteral symbol to the ReverseMappedType when it is created in createReverseMappedType:

const reversed = createObjectType(ObjectFlags.ReverseMapped | ObjectFlags.Anonymous, /*symbol*/ undefined) as ReverseMappedType;

->

const symbol = createSymbol(SymbolFlags.TypeLiteral, InternalSymbolName.Type);
const reversed = createObjectType(ObjectFlags.ReverseMapped | ObjectFlags.Anonymous, symbol) as ReverseMappedType;

This approach seems a bit better to me; though it does seem a bit weird to flag an inferred mapped type as a TypeLiteral, a MappedType already has this flag so perhaps it is alright. You could also take this approach, but instead with an entirely separate new SymbolFlag just for this case. (this does not seem like a great idea to me but there might be issues I'm unaware of in putting TypeLiteral on ReverseMappedType)

I would appreciate the perspective of someone is more familiar with any potential implications of these fixes, if all looks good I can make a pr with the change alongside a test.

[weswigham]

@ksabry close! isObjectTypeWithInferableIndex is definitely what needed to be changed, specifically, for a reverse mapped type, we needed to decide that if the index on the reverse mapped type source type was inferable, the index on the reverse mapped type itself is. I've already opened #33450 with the fix - thanks for the help!