Index Signatures break Mapped type key picking.

[jasonswearingen]

Update: Please see the second comment, titled "simple repro"

Summary

I'm trying to create type definitions for a mixin object. when doing so I found the following error if one of the mixed types has an index signature.

removing the index signature "fixes" the problem.

TypeScript Version: 3.3.3333

Code

/** helper that returns prop names except those to filter.  This helper type is needed to actually remove the prop, as otherwise the prop still exists in the type just as "never".  */
type PropsRemove_Name<TTarget, TPropToRemove> = { [ K in keyof TTarget ]: TTarget[ K ] extends TPropToRemove ? never : K }[ keyof TTarget ];
/** remove props of the given type.   always removes ```never``` type props.  if no ```TPropToRemove``` is provided, removes just ```never``` type props. */
type PropsRemove<TTarget,TPropToRemove=never> = Pick<TTarget, PropsRemove_Name<TTarget,TPropToRemove>>;

/** type used to demonstrate the bug */
type TestType = {
	a: number;
} & {	
	b: boolean;
	[ key: string ]: boolean; //THE OFFENDING LINE
}

let testRemoval: PropsRemove<TestType,number>;

Expected behavior:

//expect typescript to provide the proper definition. 
testRemoval.b; //boolean

Actual behavior:

//with the index signature, typescript provides no properties in the dropdown
testRemoval; //no properties

//when the index signature is removed, typescript provides the proper definition. 
testRemoval.b; //boolean

Related Issues: didn't really see any :(

[jasonswearingen]

simple repro:

/** type used to demonstrate the bug */
type TestType ={
	b: boolean;
	[ key: string ]: boolean;
}

let testSimple: Pick<TestType, keyof TestType>;
testSimple; //no properties in vscode intellisense dropdown, nor available in type propagation (unioning, etc).  comment the index signature to get properties.

[jack-williams]

This is related to: #17867

[RyanCavanaugh]

keyof TestType is string | number

Pick<TestType, string | number> is { [k: string]: boolean }

I think both of those are fairly inarguable given the definition of both operations. Pick<T, keyof T> is not guaranteed to produce T for this reason.

[jasonswearingen]

sorry @RyanCavanaugh, not following you, I don't spend enough time with type definitions I guess :/

Maybe my "simple" repro muddys the issue. I want to do as shown in the initial post: remove a property, but can not when an index signature is in the type.