Typescript failed to expand type in generic for unknown reason

[mmis1000]

TypeScript Version: 3.1.3

Search Terms:

Code

type Or<T> = T [
    {
        [K in keyof T]: T[K] extends ((...arg:any[])=>any)?
            never:
            K
    } [keyof T]
]

// F is unknown
type F = Or<[
    string,
    number
]>

// F_ is string|number
type F_ = ([
    string,
    number
])[
    {
        [K in keyof ([
            string,
            number
        ])]: ([
            string,
            number
        ])[K] extends ((...arg:any[])=>any)?
            never:
            K
    } [keyof ([
        string,
        number
    ])]
]

Expected behavior:
I will get the type string|number for both case

Actual behavior:
The generic failed to expand the type and make F as unknown for unknown reason,
while manully inline it in F_ typed as expected

Playground Link:
link
Related Issues:

[Nathan-Fenner]

Here's a slightly reduced version of the above:

type KeepKeyNotFunc<T, K extends keyof T> = T[K] extends Function ? never : K;

type E = [string, number];

// Expected = number | "0" | "1" | "length"
type Expected = 
    {
        [K in keyof E]: KeepKeyNotFunc<E, K>
    }[keyof E]

// Generic<T> is the same as "Expected", but with E replaced by generic T
type Generic<T> = 
    {
        [K in keyof T]: KeepKeyNotFunc<T, K>
    }[keyof T]


// Unexpected = 2 | "0" | "1" | (() => string) | (() => string) | (() => "0" | "1") | ((...items: ("0" | "1")[]) => number) | { (...items: ConcatArray<"0" | "1">[]): ("0" | "1")[]; (...items: ("0" | "1" | ConcatArray<"0" | "1">)[]): ("0" | "1")[]; } | ... 22 more ... | (() => IterableIterator<...>)
type Unexpected = Generic<[
    string,
    number
]>

// F = string | number
type F = E[Expected]

// errors: 
// Type '(start?: number, end?: number) => ("0" | "1")[]' cannot be used as an index type.
// Type '() => IterableIterator<"0" | "1">' cannot be used as an index type.
// Type '(...items: ("0" | "1")[]) => number' cannot be used as an index type.
// ...
type F_ = E[Unexpected]

I wasn't able to reduce it further.

[mmis1000]

I found the error may come from two error instead of only one:

1. keyof erroneously enumerate all prototype keys of tuple/array

type H1 = keyof {}
type H2 = keyof [1, 2]

// H1 does not include prototype keys, but H2 does

2. side effect cause by typescript 3.1 change that force array/tuple methods not mappable in mapped types to preserve correct array behavious, which make keys of function not excludable in this case

type H5<T> = 
    {
        [K in keyof T]: never
    }[keyof T]

// This should have nothing, but there are actully something due to ts 3.1 change
type H6 = H5<[1]>

/** more precise example */
type H7<T extends {"indexOf": any}> = 
    {
        [K in keyof T]: never
    }["indexOf"]

// what? how does here be anything?
type H8 = H7<[1]>

[RyanCavanaugh]

@weswigham this seems fishy to me; we should discuss at some point

[weswigham]

It's fishy because our mapped type behavior for tuples is fishy - at best effort we attempt to map a tuple into a tuple (this is our homomorphic mapped type logic), however this means there's an observable difference between a generic and nongeneric mapped type. Let me show using the examples above with the immediate indexes removed, for clarity. Specifically, in

type E = [string, number];

// Expected = number | "0" | "1" | "length"
type Expected = 
    {
        [K in keyof E]: KeepKeyNotFunc<E, K>
    }

keyof E is going to eagerly resolve to E's keys, which are all the methods and everything else, which then get filtered and remapped (the result is an object with a ton of never valued keys). In the generic example:

type Generic<T> = 
    {
        [K in keyof T]: KeepKeyNotFunc<T, K>
    }
type Unexpected = Generic<[
    string,
    number
]>

only the tuple members get mapped and you still get a tuple out - so that means Unexpected here just becomes ["0", "1"]. Now, that difference is quite important here - the "full mapping" done by the non generic type means that when it gets indexed into, all the keys are present in the mapped result (but most are never) and the resulting values are effectively filtered. In the generic version, the outer indexing operation by keyof T is still going to index by what full list of keys, but this time, none of them have been mapped, because the tuple mapping operation only mapped tuple members, and not the parent array members.

Essentially, it's because K in keyof T and keyof T don't use the same set of keys - the latter is always all keys, while the former can be limited in scope by a "homomorphic" operation.