I'm not aware of a specific name of this features. It's the keyof operator you apply here.
The keyof operator takes an object type and produces a string or numeric literal union of its keys.
Your object type T is { name: "john" }. The result of keyof is hence "name" and T[k] returns therefore "john", which is widened to string.
You are observing type widening which happens in this case because there is no constraint on T and T also does not directly infer the string type. You can read more about the specifics in this Pull request.
To solve this, add an extra generic type S which extends string (or any other primitive type which may be valid here). T will be constrained to Record<string, S>.
let test = <
T extends Record<string, S>,
S extends string
>(x: T, c:{ [K in keyof T] : (p:T[K]) => void })=> {}
test({ name:"john" }, { name:(functionParam) => null })
// ^? "john"
Now, the parameter functionParam is correctly inferred to the string literal type "john".
Yes, this is correct. In TypeScript, you can index a type to get the type of the property of that key (see Indexed Access Types). Basing a type on the value of an object's property is impossible, as TypeScript runs at compile time and values are determined at runtime. If you had a type "john" then that is what would show up:
type John = {name: "john"};
let yourName: John["name"];
You can see that the type of yourName is then "john". By default, TypeScript assumes that the object will change, so the type of
let me = {name: "john"};
is inferenced as {name: string} (TypeScript Playground). If it was {name: "john"} by default, then you couldn't change it to something else. Most of the time, when you declare an object, you're going to change it, so this is the safe assumption to make.
John I've declared the property name to be of type "john". Look at the addition to my answer to understand why TypeScript infers the type string instead of the more specific type "john".
T[k]is an Indexed Access Typestringand not just value "john"?"john"is eitherstringwhen typescript assumes that it's variable or more narrowed down only the exact string'john'Literal Types which happens when typescript assumes it can't change. But it's still a subtype of string and can therefore be assigned to the broaderstringtype.