Suggestion: Add a compiler flag to disallow mapping primitive types

[ssonne]

With the upcoming conditional types in 21316, it will become possible to write mapped types that handle primitive types correctly. However, there's currently no support from the compiler to warn that a mapped type is being incorrectly applied to a primitive (see example below). I suggest two changes:

1. Add a compiler flag that only allows a type that extends object to be used in a mapped type. A potential solution would be to disallow applying keyof to a primitive type.
2. Rewrite commonly used mapped types such as Partial using conditional types, so that code applying them to primitives can compile using the new flag.

Example of how the current behavior of mapping primitive types to themselves (introduced in 12447) can go wrong:

type Lazy<T> = {
  [K in keyof T]: () => T[K];
};

type LazyContainer<T> = {
  val: Lazy<T>;
}

// This should definitely be an error, but it's not
const lazyContainer: LazyContainer<string> = { val: 'abc' };

function strictify<T>(x: Lazy<T>): T {
  const result: Partial<T> = {};

  for (const k in x) {
    result[k] = x[k]();
  }

  return result as T;
}

function strictifyContainer<T>(x: LazyContainer<T>): T {
  return strictify(x.val);
}

const strictString = strictifyContainer(lazyContainer); // runtime type error

With the new flag applied:

type Lazy<T> = {
  [K in keyof T]: () => T[K]; // error, T is not a subtype of object
};

[mhegazy]

However, there's currently no support from the compiler to warn that a mapped type is being incorrectly applied to a primitive

type Lazy<T extends object> = { [K in keyof T]: () => T[K]; };

[ssonne]

@mhegazy It's easy to forget to add that constraint. A compiler flag would prevent user error.

Another point at which to catch the type error is when applying a mapped type to an unconstrained type variable. Clearly in

function strictify<T>(x: Lazy<T>): T {

the fact that x is Lazy<T> means that x can be any primitive type in addition to the intended mapped type.

[mhegazy]

If you add the constraint on Lazy declaration you will get it an error on strictify if unconstrained. in other words the constraints will have to be propagated throughout the system.

We have discussed this issue before, and the conclusion here is that mapped types has affordances to handling primitive types by design; we believe the vast majority of uses of mapped types are on object types, or are OK with skipping primitives (e.g. ReadOnly). If your types represent transformations your functions are doing for instance, and you do not check for the value being an object before applying this transformation, then you should add the constraint. the compiler will honor it and will enforce it.

[typescript-bot]

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