Made some progress.

Interestingly this works:

/**
 * @template M of self::TYPES
 * @template T of key-of<M>
 * @param T $type
 *
 * @return new<M[T]>
 */
public static function get(string $type) : object
{
	$class = self::TYPES[$type];
	return new $class('now');
}

But this doesn't:

/**
 * @template T of key-of<self::TYPES>
 * @param T $type
 *
 * @return new<self::TYPES[T]>
 */
public static function get2(string $type) : object
{
	$class = self::TYPES[$type];
	return new $class('now');
}
/**
 * @template T of class-string
 * @param T $type
 *
 * @return new<T>
 */
public static function create(string $type) : object
{
	return new $type();
}

I have the feeling this has something to do with \PHPStan\Type\NewObjectType::isResolvable:

public function isResolvable(): bool
{
	return !TypeUtils::containsTemplateType($this->type);
}

Maybe we should allow class-string there...

This is already possible, without new:

/**
 * @template T of object
 * @param class-string<T> $type
 *
 * @return T
 */
public static function create(string $type) : object
{
	return new $type();
}

have the feeling this has something to do with \PHPStan\Type\NewObjectType::isResolvable:

I don't think it does. Other late-resolvable types look the same. You need to launch Xdebug and see what's going on :)

Updated the PR. I think this is ready now.

new is only needed when you are working with templated types like:

/**
 * @template M of self::TYPES
 * @template T of key-of<M>
 * @param T $type
 *
 * @return new<M[T]>
 */
public static function get(string $type) : object
{
	$class = self::TYPES[$type];
	return new $class('now');
}

For simple cases, you can use:

/**
 * @template T of object
 * @param class-string<T> $type
 *
 * @return T
 */
public static function create(string $type) : object
{
	return new $type();
}

What was the problem described here? #3050 (comment)

I guess writing it like this just will not be possible:

/**
 * @template T of key-of<self::TYPES>
 * @param T $type
 *
 * @return new<self::TYPES[T]>
 */
public static function get2(string $type) : object
{
	$class = self::TYPES[$type];
	return new $class('now');
}

When I use your suggested syntax (with another template), it works.

@ruudk Can you please send this working example with a description to this article? https://phpstan.org/blog/generics-by-examples

Source is here: https://github.com/phpstan/phpstan/blob/1.11.x/website/src/_posts/generics-by-examples.md

self::TYPES[T] is a parse error currently which is why it doesn't work. Needs to be fixed in the phpdoc-parser.

Writing (self::TYPES)[T] is a workaround.

@rvanvelzen Nice! I added this example also to the test.

Can you please send this working example with a description to this article? https://phpstan.org/blog/generics-by-examples

Done in phpstan/phpstan#10971

self::TYPES[T] is a parse error currently which is why it doesn't work. Needs to be fixed in the phpdoc-parser.

Writing (self::TYPES)[T] is a workaround.

@rvanvelzen Interesting,

Maybe that fix will make this possible without new?

@template T of key-of<self::TYPES>
@template O of class-string<self::TYPES[T]>
@param T $type
@return O

Edit: tried it, doesn't work.

The improvement to phpdoc-parser has been merged here, please rebase this branch and try out what it improves (add tests for previously impossible use-cases).

You can also try it out in the playground https://phpstan.org/try, it has been updated too.

@ondrejmirtes Rebased. With the fix in phpdoc-parser we can remove the parenthesis. This simplifies the syntax. Updated the example too.

Awesome, thank you!

Did we just remove the need for class-string-map? This looks awfully similar:

	/**
	 * @template T of key-of<self::TYPES>
	 * @param T $type
	 *
	 * @return new<self::TYPES[T]>
	 */

No, probably not, see phpstan/phpstan#9521