@ahejlsberg This is super close to a solution of #37181. Will it will allow us to do:

function makeBox<T>(value: T) {
    return { value };
};

// Can we do it or something similar? Currently doesn't compile :(
type MakeBox<T> = ReturnType<typeof makeBox<T>>

// As it now allows us to do (no generics though)
const stringMakeBox = makeBox<string>;
type MakeBox = ReturnType<typeof stringMakeBox>

// And even more relevant to support generics if we can now do:
type MakeBox = ReturnType<typeof makeBox<string>>

Up to now makeBox<string> was illegal without calling it. But now that it is supported allowing typeof on it seems to fit nicely.

Building the TypeScript playground for this PR would be better.

This is super close to a solution of #37181. Will it will allow us to do...

Yes, you can indeed use that pattern to capture a generic return type of a generic function. This is something that previously wasn't possible. I'll update the PR description to include an example.

Let's say we have a function f have a call signature f<T extends number, Q>() and a construct signature new f<T extends string>()

What will this PR behave? They have different argument counts and even different different type constraints

Let's say we have a function f have a call signature f<T extends number, Q>() and a construct signature...

This works just fine:

declare const f: {
    <T extends number, Q>(): [T, Q];
    new <T extends string>(): [T];
};

type T0 = typeof f<string>;  // new () = [string]
type T1 = typeof f<number, string>;  // () => [number, string]

But an error occurs here:

declare const g: {
    <T extends number>(): [T];
    new <T extends string>(): [T];
};

type T2 = typeof g<string>;  // Error, type 'string' does not satisfy the constraint 'number'

@typescript-bot test this
@typescript-bot user test this inline
@typescript-bot run dt
@typescript-bot perf test this

Heya @ahejlsberg, I'm starting to run the inline community code test suite on this PR at 8e466ba. Hold tight - I'll update this comment with the log link once the build has been queued.

Did this feature get released in 4.7? Somehow when I try the example with ts version 4.7.4 (latest as of today) it complains in the editor.

Yep, works in the playground - given that those inline error messages dont come from the official typescript extension (to my knowledge)- it's likely a local setup issue causing this

It doesn't works on build-ins method 🤔
https://www.typescriptlang.org/play?jsx=0#code/FAYw9gdgzgLgBCAhiAFgUzgXjhNB3OAdTUQGsBZRABwB5g44BBAGnrgCU0YBXAJwgAqATypoaMEWjAAzOAHkARgCs0IGAG0ARAHMucvBAAKvMKN4SAImigheASyowwvKJoC6NRgD4vcAPR+cGi8JrzAXgAUAJQA3MCgkLBwiFhwAN5wCgBccACMcAC+wBKiTKklUrKI8eDQ8AAm1iCUVKmKKmoAdLow+kYmZpZN9o7OUJ6RiFFAA

const cache = new WeakMap<
  A,
  ReturnType<typeof Object["getOwnPropertyDescriptors"]<A>> // error
>();

const a = { b: 1 }
type A = typeof a

const descMap = Object.getOwnPropertyDescriptors<A>(a)

    'A' only refers to a type, but is being used as a value here.
    Variable 'ReturnType' implicitly has an 'any' type.
    Conversion of type '{ b: number; }' to type '<T>(o: T) => { [P in keyof T]: TypedPropertyDescriptor<T[P]>; } & { [x: string]: PropertyDescriptor; }' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.
      Type '{ b: number; }' provides no match for the signature '<T>(o: T): { [P in keyof T]: TypedPropertyDescriptor<T[P]>; } & { [x: string]: PropertyDescriptor; }'.
    ',' expected.
    '>' expected.
    Expression expected.
    Expression expected.
    Expression expected.

You cant use brackets, just qualified names:

https://www.typescriptlang.org/play?jsx=0#code/FAYw9gdgzgLgBCAhiAFgUzgXjhNB3OAdTUQGsBZRABwB5g44BBAGnrgCU0YBXAJwgAqATypoaMEWjAAzOAHkARgCs0IGADoA5lzl4IABV5hRvCQBE0UELwCWVGGF5QajAHyu4wVwAoAlAG5gUEhYOEQsOABvOAUALjgARjgAX2AJUSYI9KlZRCDwaHgAE0sQSioIxRU1LR09Q2M0UyELK1t7R2c3b0RfIA

How to use this feature with overloaded functions ?

declare function foo<T extends keyof HTMLElementTagNameMap>(arg: T): HTMLElementTagNameMap[T];
declare function foo<T extends HTMLElement>(arg: T): T;
type FirstFoo = typeof foo<"div">;    // error
const f: ReturnType<FirstFoo> = foo("div");

I couldn't get the code to work. The error message is Type 'string' does not satisfy the constraint 'HTMLElement'.
Why does it have to satisfy both foos ? How to pick the first foo ?

https://www.typescriptlang.org/play?ts=4.9.3#code/CYUwxgNghgTiAEAzArgOzAFwJYHtVJxwB4AVeEADwxFWAGd4BrEATx0XgAkSBZAGQCiEEAFsaGElADmAOShieUAA4A+ABSwpALngkAlDu78ho8ZNnyQipQG0SAXQDcAKFCRYCFOmx4CxMpTUtAxGgsJiqBjqmjr6sS4YLEoIAGJYMHQYKYTwALzwicnsfkQARMBYAG6lKi5geJlIOgBKIBjIMKgkSSBEaRlZhCp5fmrlVaV6LkA

The code works if I change the second foo to declare function foo<T extends HTMLElement, U>(arg: T, _unused: U): T;.
But I can't get it to work if foo have only one parameter. (Is there still something ambiguous to the compiler in this case that prevent the compiler from picking the first foo ?)

Higher-order instantiation expressions don't resolve properly, as they weren't accounted for in the test baselines (see also issue #52035).

declare function transform<
    const A extends readonly any[], 
    F extends <
        V extends A[number], 
        K extends keyof A,
    >(value: V, index: K, array: A) => any
>(array: [...A], func: F): { [K in keyof A]: ReturnType<typeof func<A[K], K>> };

const $2 = transform(["object", "string", "number"], k => ({ type: k }));
    // ^?
    // Should be [{ type: "object" }, { type: "string" }, { type: "number" }], but is [any, any, any]

https://www.typescriptlang.org/play?target=99&jsx=0&ts=5.0.0-dev.20221220#code/CYUwxgNghgTiAEAzArgOzAFwJYHtXwxilQGdEcYBbAHgCh4H4w8SN4BBeEADwxFWAl4cKMDwQAnvGISA2gF0ANPHqMAYl179B8Oo33wAapr4Ch7WamSUARiBhKVBxgGkT2oQGsQEnIg6KqgwAfAAUAG5QEMggAFxGylgCPPEuyrBEEvHsAJTwALzB0qgStGEZUFnwsgB0deyOKOjxajnxAN7Vbknw3r7+DfEASiAYyDCoACoSAA4g1BizIH5IaGDUFi6OLsFFAL4A3LS0zKRsACQATAUERKTkVKGyAEQ4NgBW4BjPys+sMEkAOY-eDPKy2ezPRyeApFUKdRZzeIwvY5HJHfQAekx8AAegB+ILwbHwADKAAscMgIMB4HZqgilvFXh8vs94HtlIykaD-kD2Zz4Ny4qDwXYYAL5EA

Correct, instantiation expressions currently have no equivalent in type land.

Is there any issue tracking a design for a way we could do that?

I've been trying to do something that I'd be able to accomplish if I could have a type like

// type ApplyFn<Fn, Arg> = (some magic...)
type Applied = ApplyFn<<T>(value: T) => { value: T }, 1 | 2 | 3> // { value: 1 | 2 | 3 }

Someone correct me if I'm wrong but it seems there's no way to do this for an arbitrary function.

It also solves #20719.

Correct, instantiation expressions currently have no equivalent in type land.

Is there any issue tracking a design for a way we could do that?

I've been trying to do something that I'd be able to accomplish if I could have a type like

// type ApplyFn<Fn, Arg> = (some magic...)
type Applied = ApplyFn<<T>(value: T) => { value: T }, 1 | 2 | 3> // { value: 1 | 2 | 3 }

Someone correct me if I'm wrong but it seems there's no way to do this for an arbitrary function.

I don't believe there is. Instantiation expressions only work for values; you can't use a similar method in types.
I tried to work around the lack of higher-order generics by using a generic function type, but I think the core limitations are the same, so it's not supported. The function-type type parameter is said to be not generic.

type Fn = <Arg>() => unknown
type ApplyFn<T, F extends Fn> = T extends unknown ? ReturnType<F<T>> : never

const f = <T>(): [T] => ({} as [T])

type t1 = ApplyFn<1 | 2, typeof f>

The following (direct instead of the type parameter) works:

type ApplyFn<T> = T extends unknown ? ReturnType<typeof f<T>> : never

type t1 = ApplyFn<1 | 2>
//   ^? [1] | [2]