Key types by their value where describe() was standing in for it

Two hot paths built a description only to use it as a key.

RecursionGuard::run() keys every operation it guards with
describe(VerbosityLevel::value()), and that level resolves the class name
through the ReflectionProvider - two round-trips per guarded call, for a
string that never changes. ObjectType now remembers it.

UnionType::getFiniteTypes() uniqued its members by description. They are
finite types, so FiniteTypeSet keys them by the value they stand for, which
is what the uniquing wants; floats have no such key, equals() not agreeing
with value identity for them, and keep describing themselves.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LDqrN1pcN3qWc7xzKfkJaF

Author: ondrejmirtes

src/Type/ObjectType.php

@@ -124,6 +124,14 @@ class ObjectType implements TypeWithClassName, SubtractableType
 
 	private ?string $cachedDescription = null;
 
+	/**
+	 * The class name as the reflection spells it - the properly cased name, or the
+	 * readable `class@anonymous...` form. Resolving it takes two ReflectionProvider
+	 * round-trips and both the type-only and the value level need it, the latter on
+	 * every operation RecursionGuard guards.
+	 */
+	private ?string $cachedPreciseName = null;
+
 	/**
 	 * The reflection resolved on demand by getClassReflection(), kept apart from the one
 	 * handed to the constructor. The constructor's reflection is part of the type's value
@@ -742,13 +750,21 @@ private function checkSubclassAcceptability(string $thatClass): AcceptsResult
 
 	public function describe(VerbosityLevel $level): string
 	{
+		if ($this->cachedPreciseName !== null && ($level->isValue() || $level->isTypeOnly())) {
+			return $this->cachedPreciseName;
+		}
+
 		$preciseNameCallback = function (): string {
+			if ($this->cachedPreciseName !== null) {
+				return $this->cachedPreciseName;
+			}
+
 			$reflectionProvider = ReflectionProviderStaticAccessor::getInstance();
 			if (!$reflectionProvider->hasClass($this->className)) {
-				return $this->className;
+				return $this->cachedPreciseName = $this->className;
 			}
 
-			return $reflectionProvider->getClassName($this->className);
+			return $this->cachedPreciseName = $reflectionProvider->getClassName($this->className);
 		};
 
 		$preciseWithSubtracted = fn (): string => $this->className . $this->describeSubtractedType($this->subtractedType, $level);

src/Type/UnionType.php

@@ -1662,7 +1662,11 @@ public function getFiniteTypes(): array
 		$types = $this->notBenevolentPickFromTypes(static fn (Type $type) => $type->getFiniteTypes());
 		$uniquedTypes = [];
 		foreach ($types as $type) {
-			$uniquedTypes[$type->describe(VerbosityLevel::cache())] = $type;
+			// These are finite types, so FiniteTypeSet keys them by the value they
+			// stand for - which is what the uniquing wants and what describe() was
+			// standing in for. Floats have no such key (equals() does not agree with
+			// value identity for them) and keep describing themselves.
+			$uniquedTypes[FiniteTypeSet::key($type) ?? $type->describe(VerbosityLevel::cache())] = $type;
 		}
 
 		if (count($uniquedTypes) > InitializerExprTypeResolver::CALCULATE_SCALARS_LIMIT) {