Wrong keyof behaviour for generic with extends types in 2.9

TypeScript Version: 2.9.1, 3.0.0-dev.20180601

Search Terms: keyof 2.9 generics extract extends string number symbol

Code

type StringKeyof<T> = Extract<keyof T, string>;

type Omit<T, K extends StringKeyof<T>> = any;

type WithoutFoo = Omit<{ foo: string }, "foo">; // ok

type WithoutFooGeneric<P extends { foo: string }> = Omit<P, "foo">; // Error: Type '"foo"' does not satisfy the constraint 'Extract<keyof P, string>'.

Expected behavior:

Omit should pass "foo" as valid type for keyof because generic type extends a type that has this string key.

Actual behavior:

Error: Type '"foo"' does not satisfy the constraint 'Extract<keyof P, string>'.

Playground Link: Link

[carlvincentld]

@princefishthrower Your issue is not related to the original issue. I think you might have misunderstood the usage of the keyword Extract or keyof T.

Taking back the interface ISomething with slight alteration to the names:

interface ISomething {
    foo: string;
    bar: Date;
    baz: number;
    qux: () => void;
    quux: { foo: string; };
    corge: symbol;
}

type Keys = keyof ISomething; // 'foo' | 'bar' | 'baz' | 'qux' | 'quux' | 'corge';
type ExtractOfKeys = Extract<Keys, string | Date | number>; // 'foo' | 'bar' | 'baz' | 'qux' | 'quux' | 'corge';

Since the keys of ISomething are all strings, Extract returns the full list of keys.

My guess is you want only the keys foo, bar or baz, since they map to are of ordered types. Instead of Extract, you might be looking to use the following “FieldOfType” type:

type FieldOfType<Type, ValueType> = { [K in keyof Type]: Type[K] extends ValueType ? K : never }[keyof Type];
function isAGgreaterThanB<T>(a: T, b: T, compareOnProperty: FieldOfType<T, string | Date | number>) {
    return a[compareOnProperty] > b[compareOnProperty];
}

type FieldsOfType = FieldOfType<ISomething, string | Date | number>; // 'foo' | 'bar' | 'baz'

Here’s a Playground Link if you want to play with it.

EDIT: The keys map to ordered types instead of are.

[jack-williams]

@amoscatelli No, the issue there is that conditional types ignore the constraints on type parameters when checking assignability, so T[K] extends string ? K : never does not get simplified to K.