fix: satisfy PHPStan 8.5 strict nullable-offset analysis

PHPStan on PHP 8.5 is stricter about array-offset access when the key
type includes null. Three pre-existing call sites tripped the new
offsetAccess.invalidOffset rule; all three are safe to tighten without
behavior change on any supported PHP version (8.2+).

FieldsBuilder::mapDocBlock — skip @param tags with no variable name
(phpdocumentor returns null there) instead of silently coercing null
into an empty-string key.

GlobTypeMapperCache::registerAnnotations — GlobAnnotationsCache's
withType() sets typeClassName and typeName together, so inside the
`typeClassName !== null` branch typeName is guaranteed non-null. Add
an assert() to document the invariant for the analyser.

IteratorTypeMapper::splitIteratorFromOtherTypes — restructure so the
unset/return happens inside the loop where $key has a concrete
array-key type, instead of carrying a nullable $key across the
loop/early-return boundary. Also drops the unused null initializer.

Author: oojacoboo

src/FieldsBuilder.php

@@ -878,7 +878,13 @@ private function mapParameters(
 
         $docBlockTypes = [];
         foreach ($paramTags as $paramTag) {
-            $docBlockTypes[$paramTag->getVariableName()] = $paramTag->getType();
+            $variableName = $paramTag->getVariableName();
+            // Skip malformed @param tags with no variable name (phpdocumentor returns null for
+            // those). PHPStan 8.5 rejects the implicit null-to-empty-string coercion.
+            if ($variableName === null) {
+                continue;
+            }
+            $docBlockTypes[$variableName] = $paramTag->getType();
         }
 
         $parameterAnnotationsPerParameter = $this->annotationReader->getParameterAnnotationsPerParameter($refParameters);

src/Mappers/GlobTypeMapperCache.php

@@ -48,7 +48,11 @@ public function registerAnnotations(ReflectionClass|string $sourceClass, GlobAnn
                 $this->mapClassToTypeArray[$objectClassName] = $className;
             }
 
+            // GlobAnnotationsCache::withType() sets typeClassName and typeName together, so
+            // inside this branch typeName is guaranteed non-null. Assert the invariant for PHPStan
+            // 8.5+, which is stricter about nullable array offsets.
             $typeName = $globAnnotationsCache->getTypeName();
+            assert($typeName !== null);
             $this->mapNameToType[$typeName] = $className;
         }
 

src/Mappers/Root/IteratorTypeMapper.php

@@ -206,8 +206,6 @@ private function toGraphQLType(Compound $type, Closure $topToGraphQLType, bool $
      */
     private function splitIteratorFromOtherTypes(array &$types): Type|null
     {
-        $iteratorType = null;
-        $key = null;
         foreach ($types as $key => $singleDocBlockType) {
             if (! ($singleDocBlockType instanceof Object_)) {
                 continue;
@@ -216,21 +214,17 @@ private function splitIteratorFromOtherTypes(array &$types): Type|null
             /** @var class-string<object> $fqcn */
             $fqcn     = (string) $singleDocBlockType->getFqsen();
             $refClass = new ReflectionClass($fqcn);
-            // Note : $refClass->isIterable() is only accessible in PHP 7.2
             if (! $refClass->implementsInterface(Iterator::class) && ! $refClass->implementsInterface(IteratorAggregate::class)) {
                 continue;
             }
-            $iteratorType = $singleDocBlockType;
-            break;
-        }
 
-        if ($iteratorType === null) {
-            return null;
-        }
+            // One of the classes in the compound is an iterator. Remove it and let the caller
+            // test the remaining values as potential subTypes.
+            unset($types[$key]);
 
-        // One of the classes in the compound is an iterator. Let's remove it from the list and let's test all other values as potential subTypes.
-        unset($types[$key]);
+            return $singleDocBlockType;
+        }
 
-        return $iteratorType;
+        return null;
     }
 }