What is the type of function generic type param

[zyf0330]

Bug Report

I cannot figure out what is the type of generic T in the below playground code.
The generic T param which extends a class in the function, seems to be the never type, but I think it shouldn't be.

🔎 Search Terms

function generic type type param extends never

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about extends and generic

⏯ Playground Link

Playground link with relevant code

🙁 Actual behavior

The generic T seems to be never type.

🙂 Expected behavior

The generic T should be object or any type.

[MartinJohns]

The type of T within test<>() is not known, because it's a generic type argument. Within the function the compiler does not know what type T is, so it can't resolve your conditional type TestT<T>. This is a design limitation.

The generic T seems to be never type.

It's not never, it's T. But what T is is not known.

[zyf0330]

Actually, this is my actual type function which resolves key chain of type. And I don't know how to make it work for generic T.

export type NestedPaths<Type> =
// forbid access Function property
    Type extends Function ? never
        : Type extends string | number | boolean | Date | RegExp | Buffer | Uint8Array | {
            _bsontype: string;
        } ? [] : Type extends ReadonlyArray<infer EleType> ? ([ArrayIndexes<Type>, ...NestedPaths<EleType>] | [...NestedPaths<EleType>])
            : Type extends object ?
                (
                    {
                        [Key in Extract<keyof Type, string>]:
                        // forbid circular reference
                        (Type[Key] extends Type ? [Key] : Type extends Type[Key] ? [Key] : Type[Key] extends ReadonlyArray<infer EleType> ? Type extends EleType ? [Key] : EleType extends Type ? [Key]
                                : [Key, ...NestedPaths<Type[Key]>]
                            : [Key, ...NestedPaths<Type[Key]>]);
                    }[Extract<keyof Type, string>]
                    // allow to infer partial key chain, and ensure to infer the exact depth of key chain
                    | []
                    )
                : [];

[zyf0330]

To simplify it, use this code to explain.

class ClassA {c?: string}
function test<T extends ClassA>() {
    const ks: T extends any ? keyof T : keyof T  = "c" // TS2322: Type '"c"' is not assignable to type 'T extends any ? keyof T :   keyof T'.
    const ks1: keyof T  = "c" // ok
    const ks2: ClassA extends any ? keyof T : keyof T  = "c" // ok
}

How to make ks work?

[MartinJohns]

@zyf0330 You can't. The type of ks depends on the type T, but the type of T is not known within the function, because it's passed along from the outside.

[zyf0330]

Thanks.
I just find a related issue #24560, so it seems that I cannot solve this problem.