@@ -3,30 +3,23 @@
 namespace PHPStan\Analyser;
 
 use PHPStan\PhpDocParser\Ast\PhpDoc\TemplateTagValueNode;
-use function serialize;
 
 final class IntermediaryNameScope
 {
 
 	/**
-	 * @api
-	 * @param non-empty-string|null $namespace
-	 * @param array<string, string> $uses alias(string) => fullName(string)
 	 * @param array<string, array{string, TemplateTagValueNode}> $templatePhpDocNodes
-	 * @param array<string, string> $constUses alias(string) => fullName(string)
 	 * @param array<string, true> $typeAliasesMap
 	 * @param array{string, string, string, string|null, string|null}|null $traitData
 	 */
 	public function __construct(
-		private ?string $namespace,
-		private array $uses,
+		private NamespaceUses $namespaceUses,
 		private ?string $className = null,
 		private ?string $functionName = null,
 		private array $templatePhpDocNodes = [],
 		private ?self $parent = null,
 		private array $typeAliasesMap = [],
 		private bool $bypassTypeAliases = false,
-		private array $constUses = [],
 		private ?string $typeAliasClassName = null,
 		private ?array $traitData = null,
 	)
@@ -38,23 +31,23 @@ public function __construct(
 	 */
 	public function getNamespace(): ?string
 	{
-		return $this->namespace;
+		return $this->namespaceUses->getNamespace();
 	}
 
 	/**
 	 * @return array<string, string>
 	 */
 	public function getUses(): array
 	{
-		return $this->uses;
+		return $this->namespaceUses->getUses();
 	}
 
 	/**
 	 * @return array<string, string>
 	 */
 	public function getConstUses(): array
 	{
-		return $this->constUses;
+		return $this->namespaceUses->getConstUses();
 	}
 
 	public function getClassName(): ?string
@@ -78,15 +71,13 @@ public function getTemplatePhpDocNodes(): array
 	public function withTraitData(string $fileName, string $className, string $traitName, ?string $lookForTraitName, ?string $docComment): self
 	{
 		return new self(
-			$this->namespace,
-			$this->uses,
+			$this->namespaceUses,
 			$this->className,
 			$this->functionName,
 			$this->templatePhpDocNodes,
 			$this->parent,
 			$this->typeAliasesMap,
 			$this->bypassTypeAliases,
-			$this->constUses,
 			$this->typeAliasClassName,
 			[$fileName, $className, $traitName, $lookForTraitName, $docComment],
 		);
@@ -102,68 +93,18 @@ public function unsetTemplatePhpDocNodes(array $namesToUnset): self
 			unset($templatePhpDocNodes[$name]);
 		}
 		return new self(
-			$this->namespace,
-			$this->uses,
+			$this->namespaceUses,
 			$this->className,
 			$this->functionName,
 			$templatePhpDocNodes,
 			$this->parent,
 			$this->typeAliasesMap,
 			$this->bypassTypeAliases,
-			$this->constUses,
 			$this->typeAliasClassName,
 			$this->traitData,
 		);
 	}
 
-	/**
-	 * Restores sharing of identical property values and parent scopes after hydration from the file cache.
-	 *
-	 * serialize() keeps objects shared within an entry but stores arrays by value, so
-	 * every hydrated scope carries its own copy of the same uses maps.
-	 * Without interning, the name scope map of a file with many members takes up
-	 * many times more memory when loaded from the cache than when freshly created.
-	 *
-	 * @param array<string, self|array<mixed>> $pool
-	 */
-	public function intern(array &$pool): self
-	{
-		$key = serialize($this);
-		if (isset($pool[$key])) {
-			/** @var self */
-			return $pool[$key];
-		}
-
-		$this->uses = self::internArray($pool, $this->uses);
-		$this->templatePhpDocNodes = self::internArray($pool, $this->templatePhpDocNodes);
-		$this->typeAliasesMap = self::internArray($pool, $this->typeAliasesMap);
-		$this->constUses = self::internArray($pool, $this->constUses);
-		if ($this->parent !== null) {
-			$this->parent = $this->parent->intern($pool);
-		}
-
-		return $pool[$key] = $this;
-	}
-
-	/**
-	 * @template T of array<mixed>
-	 * @param array<string, self|array<mixed>> $pool
-	 * @param T $value
-	 * @return T
-	 */
-	private static function internArray(array &$pool, array $value): array
-	{
-		$key = 'a:' . serialize($value);
-		if (isset($pool[$key])) {
-			/** @var T */
-			return $pool[$key];
-		}
-
-		$pool[$key] = $value;
-
-		return $value;
-	}
-
 	/**
 	 * @return array{string, string, string, string|null, string|null}|null
 	 */
@@ -195,24 +136,4 @@ public function getClassNameForTypeAlias(): ?string
 		return $this->typeAliasClassName;
 	}
 
-	/**
-	 * @param array<string, mixed> $properties
-	 */
-	public static function __set_state(array $properties): self
-	{
-		return new self(
-			$properties['namespace'],
-			$properties['uses'],
-			$properties['className'],
-			$properties['functionName'],
-			$properties['templatePhpDocNodes'],
-			$properties['parent'],
-			$properties['typeAliasesMap'],
-			$properties['bypassTypeAliases'],
-			$properties['constUses'],
-			$properties['typeAliasClassName'],
-			$properties['traitData'],
-		);
-	}
-
 }
@@ -5,7 +5,12 @@
 /**
  * The namespace and the use statements in effect at a point in a file.
  *
- * This is everything an ExportedPhpDocNode records about the scope a PHPDoc was written in, and
+ * NamespaceUsesTracker hands out one instance until the next namespace or use statement, so
+ * everything created under the same imports shares it. serialize() keeps shared objects shared
+ * but writes arrays by value - the name scope map FileTypeMapper stores in the file cache
+ * therefore holds the imports of a file once instead of once per class, function and method.
+ *
+ * It is also everything an ExportedPhpDocNode records about the scope a PHPDoc was written in, and
  * all of it is read straight off the AST by ExportedNodeVisitor. Asking FileTypeMapper for a
  * NameScope instead would build the name scope map of the whole file, which resolves every PHPDoc
  * in it - far more than the exported nodes need, and it happens in the main process during a
 
@@ -9,13 +9,13 @@
 /**
  * Keeps the namespace and the use statements seen so far while walking a file's statements.
  *
- * Both places that build exported nodes drive one of these - ExportedNodeVisitor for a result
- * cache restore, DependencyResolver during the analysis - so that the PHPDoc scope recorded in
- * the cache and the one computed when checking the cache are produced by the same code.
+ * FileTypeMapper drives one while building a name scope map, and so do both places that build
+ * exported nodes - ExportedNodeVisitor for a result cache restore, DependencyResolver during the
+ * analysis - so that the PHPDoc scope recorded in the result cache and the one computed when
+ * checking the cache are produced by the same code as the one PHPDocs are resolved in.
  *
- * It mirrors what FileTypeMapper does while building a name scope map, except that the uses are
- * cleared when a namespace is entered rather than when it is left. Namespace blocks cover every
- * statement of a file, so nothing can observe the difference.
+ * The uses are cleared when a namespace is entered rather than when it is left. Namespace blocks
+ * cover every statement of a file, so nothing can observe the difference.
  */
 final class NamespaceUsesTracker
 {
 
@@ -7,6 +7,7 @@
 use PhpParser\Node;
 use PHPStan\Analyser\IntermediaryNameScope;
 use PHPStan\Analyser\NameScope;
+use PHPStan\Analyser\NamespaceUsesTracker;
 use PHPStan\BetterReflection\Util\GetLastDocComment;
 use PHPStan\Broker\AnonymousClassNameHelper;
 use PHPStan\Cache\Cache;
@@ -50,7 +51,6 @@
 use function sprintf;
 use function str_contains;
 use function str_starts_with;
-use function strtolower;
 
 #[AutowiredService]
 final class FileTypeMapper
@@ -369,7 +369,9 @@ private function getNameScopeMap(string $fileName): array
 		// (https://github.com/phpstan/phpstan/issues/15037) - a parse that
 		// silently dropped every comment cached PHPDoc-less name-scope maps,
 		// and the content hashes cannot tell them apart from real ones.
-		$variableCacheKey = sprintf('v6-%s', ComposerHelper::getPhpDocParserVersion());
+		// v7: IntermediaryNameScope refers to a NamespaceUses shared with the other name scopes
+		// created under the same use statements
+		$variableCacheKey = sprintf('v7-%s', ComposerHelper::getPhpDocParserVersion());
 		$cached = $this->loadCachedPhpDocNodeMap($cacheKey, $variableCacheKey);
 		if ($cached === null) {
 			[$nameScopeMap, $files] = $this->createPhpDocNodeMap($fileName, null, null, [], $fileName);
@@ -415,11 +417,6 @@ private function loadCachedPhpDocNodeMap(string $cacheKey, string $variableCache
 			}
 
 			if ($useCache) {
-				$pool = [];
-				foreach ($nameScopeMap as $nameScopeKey => $intermediaryNameScope) {
-					$nameScopeMap[$nameScopeKey] = $intermediaryNameScope->intern($pool);
-				}
-
 				return [$nameScopeMap, array_keys($filesWithHashes)];
 			}
 		}
@@ -449,19 +446,18 @@ private function createPhpDocNodeMap(string $fileName, ?string $lookForTrait, ?s
 			$classStack[] = $traitUseClass;
 			$typeAliasStack[] = [];
 		}
-		$namespace = null;
+		$namespaceUsesTracker = new NamespaceUsesTracker();
 
 		$traitFound = false;
 
 		$files = [$fileName];
 
 		/** @var array<string|null> $functionStack */
 		$functionStack = [];
-		$uses = [];
-		$constUses = [];
 		$this->processNodes(
 			$this->phpParser->parseFile($fileName),
-			function (Node $node) use ($fileName, $lookForTrait, &$traitFound, $traitMethodAliases, $originalClassFileName, $activeTraitResolutions, &$nameScopeMap, &$typeMapStack, &$typeAliasStack, &$classStack, &$namespace, &$functionStack, &$uses, &$constUses, &$files): ?int {
+			function (Node $node) use ($fileName, $lookForTrait, &$traitFound, $traitMethodAliases, $originalClassFileName, $activeTraitResolutions, &$nameScopeMap, &$typeMapStack, &$typeAliasStack, &$classStack, $namespaceUsesTracker, &$functionStack, &$files): ?int {
+				$namespaceUsesTracker->enterNode($node);
 				if ($node instanceof Node\Stmt\ClassLike) {
 					if ($traitFound && $fileName === $originalClassFileName) {
 						return self::SKIP_NODE;
@@ -490,7 +486,7 @@ function (Node $node) use ($fileName, $lookForTrait, &$traitFound, $traitMethodA
 							if ($traitFound) {
 								return self::SKIP_NODE;
 							}
-							$className = ltrim(sprintf('%s\\%s', $namespace, $node->name->name), '\\');
+							$className = ltrim(sprintf('%s\\%s', $namespaceUsesTracker->getNamespaceUses()->getNamespace(), $node->name->name), '\\');
 						}
 						$classStack[] = $className;
 						$functionStack[] = null;
@@ -502,7 +498,7 @@ function (Node $node) use ($fileName, $lookForTrait, &$traitFound, $traitMethodA
 						$functionStack[] = $node->name->name;
 					}
 				} elseif ($node instanceof Node\Stmt\Function_) {
-					$functionStack[] = ltrim(sprintf('%s\\%s', $namespace, $node->name->name), '\\');
+					$functionStack[] = ltrim(sprintf('%s\\%s', $namespaceUsesTracker->getNamespaceUses()->getNamespace(), $node->name->name), '\\');
 				} elseif ($node instanceof Node\PropertyHook) {
 					$propertyName = $node->getAttribute('propertyName');
 					if ($propertyName !== null) {
@@ -535,29 +531,25 @@ function (Node $node) use ($fileName, $lookForTrait, &$traitFound, $traitMethodA
 						$parentNameScope = array_last($typeMapStack);
 
 						$typeMapStack[] = new IntermediaryNameScope(
-							$namespace,
-							$uses,
+							$namespaceUsesTracker->getNamespaceUses(),
 							$className,
 							$functionName,
 							$this->chooseTemplateTagValueNodesByPriority($phpDocNode->getTags()),
 							$parentNameScope,
 							array_last($typeAliasStack) ?? [],
-							constUses: $constUses,
 							typeAliasClassName: $lookForTrait,
 						);
 					} elseif ($node instanceof Node\Stmt\ClassLike) {
 						$typeAliasStack[] = [];
 					} else {
 						$parentNameScope = array_last($typeMapStack);
 						$typeMapStack[] = new IntermediaryNameScope(
-							$namespace,
-							$uses,
+							$namespaceUsesTracker->getNamespaceUses(),
 							$className,
 							$functionName,
 							[],
 							$parentNameScope,
 							array_last($typeAliasStack) ?? [],
-							constUses: $constUses,
 							typeAliasClassName: $lookForTrait,
 						);
 					}
@@ -582,14 +574,12 @@ function (Node $node) use ($fileName, $lookForTrait, &$traitFound, $traitMethodA
 					$parentNameScope = array_last($typeMapStack);
 					$typeAliasesMap = array_last($typeAliasStack) ?? [];
 					$nameScopeMap[$nameScopeKey] = new IntermediaryNameScope(
-						$namespace,
-						$uses,
+						$namespaceUsesTracker->getNamespaceUses(),
 						$className,
 						$functionName,
 						$parentNameScope !== null ? $parentNameScope->getTemplatePhpDocNodes() : [],
 						$parentNameScope !== null ? $parentNameScope->getParent() : null,
 						$typeAliasesMap,
-						constUses: $constUses,
 						typeAliasClassName: $lookForTrait,
 					);
 				}
@@ -602,28 +592,7 @@ function (Node $node) use ($fileName, $lookForTrait, &$traitFound, $traitMethodA
 					return null;
 				}
 
-				if ($node instanceof Node\Stmt\Namespace_) {
-					$namespace = $node->name !== null ? (string) $node->name : null;
-				} elseif ($node instanceof Node\Stmt\Use_) {
-					if ($node->type === Node\Stmt\Use_::TYPE_NORMAL) {
-						foreach ($node->uses as $use) {
-							$uses[strtolower($use->getAlias()->name)] = (string) $use->name;
-						}
-					} elseif ($node->type === Node\Stmt\Use_::TYPE_CONSTANT) {
-						foreach ($node->uses as $use) {
-							$constUses[strtolower($use->getAlias()->name)] = (string) $use->name;
-						}
-					}
-				} elseif ($node instanceof Node\Stmt\GroupUse) {
-					$prefix = (string) $node->prefix;
-					foreach ($node->uses as $use) {
-						if ($node->type === Node\Stmt\Use_::TYPE_NORMAL || $use->type === Node\Stmt\Use_::TYPE_NORMAL) {
-							$uses[strtolower($use->getAlias()->name)] = sprintf('%s\\%s', $prefix, (string) $use->name);
-						} elseif ($node->type === Node\Stmt\Use_::TYPE_CONSTANT || $use->type === Node\Stmt\Use_::TYPE_CONSTANT) {
-							$constUses[strtolower($use->getAlias()->name)] = sprintf('%s\\%s', $prefix, (string) $use->name);
-						}
-					}
-				} elseif ($node instanceof Node\Stmt\TraitUse) {
+				if ($node instanceof Node\Stmt\TraitUse) {
 					$traitMethodAliases = [];
 					foreach ($node->adaptations as $traitUseAdaptation) {
 						if (!$traitUseAdaptation instanceof Node\Stmt\TraitUseAdaptation\Alias) {
@@ -694,7 +663,7 @@ function (Node $node) use ($fileName, $lookForTrait, &$traitFound, $traitMethodA
 
 				return null;
 			},
-			static function (Node $node, $callbackResult) use (&$namespace, &$functionStack, &$classStack, &$typeAliasStack, &$uses, &$typeMapStack, &$constUses): void {
+			static function (Node $node, $callbackResult) use (&$functionStack, &$classStack, &$typeAliasStack, &$typeMapStack): void {
 				if ($node instanceof Node\Stmt\ClassLike) {
 					if (count($classStack) === 0) {
 						throw new ShouldNotHappenException();
@@ -712,10 +681,6 @@ static function (Node $node, $callbackResult) use (&$namespace, &$functionStack,
 					}
 
 					array_pop($functionStack);
-				} elseif ($node instanceof Node\Stmt\Namespace_) {
-					$namespace = null;
-					$uses = [];
-					$constUses = [];
 				} elseif ($node instanceof Node\Stmt\ClassMethod || $node instanceof Node\Stmt\Function_) {
 					if (count($functionStack) === 0) {
 						throw new ShouldNotHappenException();