Rename BuiltInTypes to BuiltInDefinitions

The class manages both built-in types and directives — matching the
GraphQL spec's "built-in scalars" and "built-in directives" terminology.
"Standard types" does not appear in the spec at all.

Beyond the rename, consolidates all built-in concerns that were spread
across Type, Introspection, and Directive into BuiltInDefinitions:

- New constants: SCALAR_TYPE_NAMES, INTROSPECTION_TYPE_NAMES,
  BUILT_IN_TYPE_NAMES, BUILT_IN_DIRECTIVE_NAMES
- New static helpers: isIntrospectionType(), isBuiltInDirective(),
  isBuiltInType(), isBuiltInTypeName(), overrideScalarTypes()
- Renamed: standardTypes() → scalarTypes(), allTypes() → types(),
  $standardTypeOverrides → $scalarTypeOverrides
- Scalar fallbacks use new IntType() directly (breaks circular dep)

Removes all non-@api static forwarding from Introspection and Directive
— those classes now only expose constants and @api methods.
Removes getStandardTypes(), overrideStandardTypes(), builtInTypes()
from Type — callers use BuiltInDefinitions directly.

SchemaConfig/Schema rename builtInTypes → builtInDefinitions.

Refs #1426 (comment)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: spawnia

docs/class-reference.md

@@ -724,7 +724,7 @@ Usage example:
   types?: Types|null,
   directives?: array<Directive>|null,
   typeLoader?: TypeLoader|null,
-  builtInTypes?: BuiltInTypes|null,
+  builtInDefinitions?: BuiltInDefinitions|null,
   assumeValid?: bool|null,
   astNode?: SchemaDefinitionNode|null,
   extensionASTNodes?: array<SchemaExtensionNode>|null,

src/Executor/ReferenceExecutor.php

@@ -88,9 +88,9 @@ protected function __construct(ExecutionContext $context)
         $this->subFieldCache = new \SplObjectStorage();
         $this->fieldArgsCache = new \SplObjectStorage();
 
-        $builtIn = $context->schema->getBuiltInTypes();
-        $this->skipDirective = $builtIn->skipDirective();
-        $this->includeDirective = $builtIn->includeDirective();
+        $builtInDefinitions = $context->schema->getBuiltInDefinitions();
+        $this->skipDirective = $builtInDefinitions->skipDirective();
+        $this->includeDirective = $builtInDefinitions->includeDirective();
     }
 
     /**
@@ -690,10 +690,10 @@ protected function getFieldDef(Schema $schema, ObjectType $parentType, string $f
             return $parentType->findField($fieldName);
         }
 
-        $builtIn = $schema->getBuiltInTypes();
-        $this->schemaMetaFieldDef ??= $builtIn->schemaMetaFieldDef();
-        $this->typeMetaFieldDef ??= $builtIn->typeMetaFieldDef();
-        $this->typeNameMetaFieldDef ??= $builtIn->typeNameMetaFieldDef();
+        $builtInDefinitions = $schema->getBuiltInDefinitions();
+        $this->schemaMetaFieldDef ??= $builtInDefinitions->schemaMetaFieldDef();
+        $this->typeMetaFieldDef ??= $builtInDefinitions->typeMetaFieldDef();
+        $this->typeNameMetaFieldDef ??= $builtInDefinitions->typeNameMetaFieldDef();
 
         $queryType = $schema->getQueryType();
 

src/GraphQL.php

@@ -12,6 +12,7 @@
 use GraphQL\Language\AST\DocumentNode;
 use GraphQL\Language\Parser;
 use GraphQL\Language\Source;
+use GraphQL\Type\BuiltInDefinitions;
 use GraphQL\Type\Definition\Directive;
 use GraphQL\Type\Definition\ScalarType;
 use GraphQL\Type\Definition\Type;
@@ -188,7 +189,7 @@ public static function promiseToExecute(
      */
     public static function getStandardDirectives(): array
     {
-        return Directive::getInternalDirectives();
+        return BuiltInDefinitions::standard()->directives();
     }
 
     /**
@@ -202,7 +203,7 @@ public static function getStandardDirectives(): array
      */
     public static function getStandardTypes(): array
     {
-        return Type::getStandardTypes();
+        return BuiltInDefinitions::standard()->scalarTypes();
     }
 
     /**
@@ -218,7 +219,7 @@ public static function getStandardTypes(): array
      */
     public static function overrideStandardTypes(array $types): void
     {
-        Type::overrideStandardTypes($types);
+        BuiltInDefinitions::overrideScalarTypes($types);
     }
 
     /**

src/Type/BuiltInTypes.php src/Type/BuiltInDefinitions.phpsrc/Type/BuiltInTypes.php renamed to src/Type/BuiltInDefinitions.php

@@ -6,31 +6,68 @@
 use GraphQL\Language\DirectiveLocation;
 use GraphQL\Language\Printer;
 use GraphQL\Type\Definition\Argument;
+use GraphQL\Type\Definition\BooleanType;
 use GraphQL\Type\Definition\Directive;
 use GraphQL\Type\Definition\EnumType;
 use GraphQL\Type\Definition\EnumValueDefinition;
 use GraphQL\Type\Definition\FieldDefinition;
+use GraphQL\Type\Definition\FloatType;
+use GraphQL\Type\Definition\IDType;
 use GraphQL\Type\Definition\InputObjectField;
 use GraphQL\Type\Definition\InputObjectType;
 use GraphQL\Type\Definition\InterfaceType;
+use GraphQL\Type\Definition\IntType;
 use GraphQL\Type\Definition\ListOfType;
 use GraphQL\Type\Definition\NamedType;
 use GraphQL\Type\Definition\NonNull;
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Type\Definition\ResolveInfo;
 use GraphQL\Type\Definition\ScalarType;
+use GraphQL\Type\Definition\StringType;
 use GraphQL\Type\Definition\Type;
 use GraphQL\Type\Definition\UnionType;
 use GraphQL\Type\Definition\WrappingType;
 use GraphQL\Utils\AST;
 use GraphQL\Utils\Utils;
 
-class BuiltInTypes
+class BuiltInDefinitions
 {
+    protected const SCALAR_TYPE_NAMES = [
+        Type::INT,
+        Type::FLOAT,
+        Type::STRING,
+        Type::BOOLEAN,
+        Type::ID,
+    ];
+
+    public const INTROSPECTION_TYPE_NAMES = [
+        Introspection::SCHEMA_OBJECT_NAME,
+        Introspection::TYPE_OBJECT_NAME,
+        Introspection::DIRECTIVE_OBJECT_NAME,
+        Introspection::FIELD_OBJECT_NAME,
+        Introspection::INPUT_VALUE_OBJECT_NAME,
+        Introspection::ENUM_VALUE_OBJECT_NAME,
+        Introspection::TYPE_KIND_ENUM_NAME,
+        Introspection::DIRECTIVE_LOCATION_ENUM_NAME,
+    ];
+
+    public const BUILT_IN_TYPE_NAMES = [
+        ...self::SCALAR_TYPE_NAMES,
+        ...self::INTROSPECTION_TYPE_NAMES,
+    ];
+
+    public const BUILT_IN_DIRECTIVE_NAMES = [
+        Directive::INCLUDE_NAME,
+        Directive::SKIP_NAME,
+        Directive::DEPRECATED_NAME,
+        Directive::ONE_OF_NAME,
+    ];
+
+    /** Singleton containing standard built-in definitions. */
     private static ?self $standard = null;
 
     /** @var array<string, ScalarType> */
-    private array $scalars = [];
+    private array $scalarTypes = [];
 
     private ?ObjectType $schemaTypeInstance = null;
 
@@ -55,54 +92,97 @@ class BuiltInTypes
     private array $directives = [];
 
     /** @var array<string, Type&NamedType>|null */
-    private ?array $allTypesCache = null;
+    private ?array $typesCache = null;
 
     /** @var array<string, ScalarType> */
-    private array $standardTypeOverrides;
+    private array $scalarTypeOverrides;
 
-    /** @param array<string, ScalarType> $standardTypeOverrides */
-    public function __construct(array $standardTypeOverrides = [])
+    /** @param array<string, ScalarType> $scalarTypeOverrides */
+    public function __construct(array $scalarTypeOverrides = [])
     {
-        $this->standardTypeOverrides = $standardTypeOverrides;
+        $this->scalarTypeOverrides = $scalarTypeOverrides;
     }
 
     public static function standard(): self
     {
         return self::$standard ??= new self();
     }
 
-    public static function resetStandard(): void
+    /** @param array<ScalarType> $types */
+    public static function overrideScalarTypes(array $types): void
     {
-        self::$standard = null;
+        // Preserve non-overridden scalar instances from the current standard.
+        $scalarOverrides = self::$standard !== null
+            ? self::$standard->scalarTypes()
+            : [];
+
+        foreach ($types as $type) {
+            // @phpstan-ignore-next-line generic type is not enforced by PHP
+            if (! $type instanceof ScalarType) {
+                $typeClass = ScalarType::class;
+                $notType = Utils::printSafe($type);
+                throw new InvariantViolation("Expecting instance of {$typeClass}, got {$notType}");
+            }
+
+            if (! in_array($type->name, self::SCALAR_TYPE_NAMES, true)) {
+                $builtInScalarNames = implode(', ', self::SCALAR_TYPE_NAMES);
+                $notBuiltInName = Utils::printSafe($type->name);
+                throw new InvariantViolation("Expecting one of the following names for a built-in scalar type: {$builtInScalarNames}; got {$notBuiltInName}"); // @phpstan-ignore missingType.checkedException (validation is part of the public contract)
+            }
+
+            $scalarOverrides[$type->name] = $type;
+        }
+
+        self::$standard = new self($scalarOverrides);
+    }
+
+    public static function isIntrospectionType(NamedType $type): bool
+    {
+        return in_array($type->name, self::INTROSPECTION_TYPE_NAMES, true);
+    }
+
+    public static function isBuiltInDirective(Directive $directive): bool
+    {
+        return in_array($directive->name, self::BUILT_IN_DIRECTIVE_NAMES, true);
     }
 
     public function int(): ScalarType
     {
-        return $this->scalars[Type::INT] ??= $this->standardTypeOverrides[Type::INT] ?? Type::int();
+        return $this->scalarTypes[Type::INT]
+            ??= $this->scalarTypeOverrides[Type::INT]
+            ?? new IntType(); // @phpstan-ignore missingType.checkedException (static configuration is known to be correct)
     }
 
     public function float(): ScalarType
     {
-        return $this->scalars[Type::FLOAT] ??= $this->standardTypeOverrides[Type::FLOAT] ?? Type::float();
+        return $this->scalarTypes[Type::FLOAT]
+            ??= $this->scalarTypeOverrides[Type::FLOAT]
+            ?? new FloatType(); // @phpstan-ignore missingType.checkedException (static configuration is known to be correct)
     }
 
     public function string(): ScalarType
     {
-        return $this->scalars[Type::STRING] ??= $this->standardTypeOverrides[Type::STRING] ?? Type::string();
+        return $this->scalarTypes[Type::STRING]
+            ??= $this->scalarTypeOverrides[Type::STRING]
+            ?? new StringType(); // @phpstan-ignore missingType.checkedException (static configuration is known to be correct)
     }
 
     public function boolean(): ScalarType
     {
-        return $this->scalars[Type::BOOLEAN] ??= $this->standardTypeOverrides[Type::BOOLEAN] ?? Type::boolean();
+        return $this->scalarTypes[Type::BOOLEAN]
+            ??= $this->scalarTypeOverrides[Type::BOOLEAN]
+            ?? new BooleanType(); // @phpstan-ignore missingType.checkedException (static configuration is known to be correct)
     }
 
     public function id(): ScalarType
     {
-        return $this->scalars[Type::ID] ??= $this->standardTypeOverrides[Type::ID] ?? Type::id();
+        return $this->scalarTypes[Type::ID]
+            ??= $this->scalarTypeOverrides[Type::ID]
+            ?? new IDType(); // @phpstan-ignore missingType.checkedException (static configuration is known to be correct)
     }
 
     /** @return array<string, ScalarType> */
-    public function standardTypes(): array
+    public function scalarTypes(): array
     {
         return [
             Type::INT => $this->int(),
@@ -113,6 +193,16 @@ public function standardTypes(): array
         ];
     }
 
+    public static function isBuiltInTypeName(string $name): bool
+    {
+        return in_array($name, BuiltInDefinitions::BUILT_IN_TYPE_NAMES, true);
+    }
+
+    public static function isBuiltInType(NamedType $type): bool
+    {
+        return in_array($type->name, BuiltInDefinitions::BUILT_IN_TYPE_NAMES, true);
+    }
+
     public function schemaType(): ObjectType
     {
         return $this->schemaTypeInstance ??= new ObjectType([ // @phpstan-ignore missingType.checkedException (static configuration is known to be correct)
@@ -773,11 +863,11 @@ public function directives(): array
     }
 
     /** @return array<string, Type&NamedType> */
-    public function allTypes(): array
+    public function types(): array
     {
-        return $this->allTypesCache ??= array_merge(
+        return $this->typesCache ??= array_merge(
             $this->introspectionTypes(),
-            $this->standardTypes()
+            $this->scalarTypes()
         );
     }
 }

src/Type/Definition/Directive.php

@@ -3,7 +3,6 @@
 namespace GraphQL\Type\Definition;
 
 use GraphQL\Language\AST\DirectiveDefinitionNode;
-use GraphQL\Type\BuiltInTypes;
 
 /**
  * @phpstan-import-type ArgumentListConfig from Argument
@@ -67,40 +66,4 @@ public function __construct(array $config)
 
         $this->config = $config;
     }
-
-    /** @return array<string, Directive> */
-    public static function getInternalDirectives(): array
-    {
-        return BuiltInTypes::standard()->directives();
-    }
-
-    public static function includeDirective(): Directive
-    {
-        return BuiltInTypes::standard()->includeDirective();
-    }
-
-    public static function skipDirective(): Directive
-    {
-        return BuiltInTypes::standard()->skipDirective();
-    }
-
-    public static function deprecatedDirective(): Directive
-    {
-        return BuiltInTypes::standard()->deprecatedDirective();
-    }
-
-    public static function oneOfDirective(): Directive
-    {
-        return BuiltInTypes::standard()->oneOfDirective();
-    }
-
-    public static function isSpecifiedDirective(Directive $directive): bool
-    {
-        return array_key_exists($directive->name, self::getInternalDirectives());
-    }
-
-    public static function resetCachedInstances(): void
-    {
-        BuiltInTypes::resetStandard();
-    }
 }

src/Type/Definition/NamedTypeImplementation.php

@@ -3,6 +3,7 @@
 namespace GraphQL\Type\Definition;
 
 use GraphQL\Error\InvariantViolation;
+use GraphQL\Type\BuiltInDefinitions;
 
 /**
  * @see NamedType
@@ -43,7 +44,7 @@ protected function inferName(): string
 
     public function isBuiltInType(): bool
     {
-        return in_array($this->name, Type::BUILT_IN_TYPE_NAMES, true);
+        return BuiltInDefinitions::isBuiltInType($this);
     }
 
     public function name(): string