Support inferred string-modified union types

[RonPenton]

I ran into an interesting situation that I wanted to run by the community to see if there's a way to add a new feature into TypeScript to support. I'll grant that it's an edge-case, but it seems like something that could be kind of neat.

Here's the code:

Code

// From Library 1
type status = "success" | "error" | "warning" | "info";

// From Library 2
type statusColor = "success" | "success-dark" | "error" | "error-dark" | "warning" | "warning-dark" | "info" | "info-dark";

// My library
function getColorFromStatus(status: status): statusColor {

    // ideal case: doesn't work:
    return status + "-dark";    // Error TS2322	Type 'string' is not assignable to type 'statusColor'

    // compromise: compiles but not type-safe. Changes to "status" type won't be caught.
    return status + "-dark" as statusColor;

    // safe case: works but extra code + runtime penalty:
    switch (status) {
        case "success": return "success-dark";
        case "error": return "error-dark";
        case "warning": return "warning-dark";
        case "info": return "info-dark";
    }
}

I think it would be neat if the expression:

status + "-dark"

could be automatically inferred to be of type:

"success-dark" | "error-dark" | "warning-dark" | "info-dark";

It's probably a lot more complex than it seems. And there's probably a heck of a lot of issues dealing with what happens with other string operations or if a runtime function like .toUpperCase() is called on the string, and what happens if any item in the union isn't a string, etc, etc. But still.

Any thoughts?

[aluanhaddad]

I believe this is roughly the same idea as proposed in #16746 (comment)

I think it is a great idea, but might be highly complex.

I would say it is not an edge case because, if generalized somewhat, it could allow for something like (syntax is just something I made up)

interface Outer {
  details: Inner
}
interface Inner {
  name: string;
}

type Delimiter = ".";

type DeepKey<T, OKey extends keyof T, IKey extends keyof T[OKey]> = OKey + Delimiter + IKey;

function pick<T, OKey extends keyof T, IKey extends keyof T[OKey]>(o: T, key: DeepKey<T, OKey, IKey>) {
  const [outer, inner] = key.split(".");
  return o[outer][inner];
}

declare const o: Outer;

const name = pick(o, "details" + "." + "name");

[gcnew]

Another related issue #12940.

[DanielRosenwasser]

As well as #12754

[RyanCavanaugh]

We'd either have to invent a completely new kind of type (a deferred-expansion union), which would be a ton of work, or risk people accidently creating combinatorially explosive literal types. This doesn't seem to come up often enough to warrant either scenario.