keyof does not work with extends in generic type argument.

[We-St]

TypeScript Version: 2.3.4

Code

function shallowCopy<T, U extends T>(s: T, d: U) {
 Object.keys(s).forEach((k: keyof T) => d[k] = s[k]);
}

Expected behavior:
I would expect this function to compile, since U is a sub class of T and U's keys are presumably treated as superset of T's keys. Each key of T should be a key of U as well.

Actual behavior:
TypeScript reports the following error: "Type 'T[keyof T]' is not assignable to type 'U[keyof T]'."

Actually, this seems to be preventing a genuine bug.

interface Tee {
	x: number | string;
}

interface Yoo extends Tee {
	x: number;
}

let t: Tee = { x: "" };
let u: Yoo = { x: 1 };
t = u;
u = t; // Error

shallowCopy<Tee, Yoo>(t, u);

function shallowCopy<T, U extends T>(t: T, u: U) {
	const tKeys = Object.keys(t) as Array<keyof T>;
	for (const key of tKeys) {
		let uk = u[key];
		let tk = t[key];
		tk = uk; // OK -- `number | string` = `number`
		uk = tk; // Error -- `number` = `number | string`
	}
}

The funny thing is that if you had just done function shallowCopy<T>(t: T, u: T) we would have allowed you to call shallowCopy<Tee>(t, u);, even though that is an error too! That's because we normally treat properties as readonly when considering assignability, even though they aren't in this case. I think #13347 is tracking that sort of issue.

[ahejlsberg]

As Andy (Andrewkraft) (@Andy-MS) is pointing out, this is working as intended. You are right that each key of T is a key of U as well, but a U[K] may be a subtype of the corresponding T[K] for the same K, and T[K] is therefore not assignable to U[K].

[mhegazy]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.