The PropertyInfo Component

The PropertyInfo Component

The PropertyInfo component allows you to get information about class properties by using different sources of metadata.

While the PropertyAccess component allows you to read and write values to/from objects and arrays, the PropertyInfo component works solely with class definitions to provide information about the data type and visibility - including via getter or setter methods - of the properties within that class.


$ composer require symfony/property-info


If you install this component outside of a Symfony application, you must require the vendor/autoload.php file in your code to enable the class autoloading mechanism provided by Composer. Read this article for more details.

Additional dependencies may be required for some of the extractors provided with this component.


To use this component, create a new Symfony\Component\PropertyInfo\PropertyInfoExtractor instance and provide it with a set of information extractors:

use Example\Namespace\YourAwesomeCoolClass;
use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
use Symfony\Component\PropertyInfo\PropertyInfoExtractor;

// a full list of extractors is shown further below
$phpDocExtractor = new PhpDocExtractor();
$reflectionExtractor = new ReflectionExtractor();

// list of PropertyListExtractorInterface (any iterable)
$listExtractors = [$reflectionExtractor];

// list of PropertyTypeExtractorInterface (any iterable)
$typeExtractors = [$phpDocExtractor, $reflectionExtractor];

// list of PropertyDescriptionExtractorInterface (any iterable)
$descriptionExtractors = [$phpDocExtractor];

// list of PropertyAccessExtractorInterface (any iterable)
$accessExtractors = [$reflectionExtractor];

// list of PropertyInitializableExtractorInterface (any iterable)
$propertyInitializableExtractors = [$reflectionExtractor];

$propertyInfo = new PropertyInfoExtractor(

// see below for more examples
$class = YourAwesomeCoolClass::class;
$properties = $propertyInfo->getProperties($class);

Extractor Ordering

The order of extractor instances within an array matters: the first non-null result will be returned. That is why you must provide each category of extractors as a separate array, even if an extractor provides information for more than one category.

For example, while the Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor and Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor both provide list and type information it is probably better that:

  • The Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor has priority for list information so that all properties in a class (not just mapped properties) are returned.

  • The Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor has priority for type information so that entity metadata is used instead of type-hinting to provide more accurate type information:

    use Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor;
    use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
    use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
    $reflectionExtractor = new ReflectionExtractor();
    $doctrineExtractor = new DoctrineExtractor(/* ... */);
    $propertyInfo = new PropertyInfoExtractor(
        // List extractors
        // Type extractors

Extractable Information

The Symfony\Component\PropertyInfo\PropertyInfoExtractor class exposes public methods to extract several types of information:


Be sure to pass a class name, not an object to the extractor methods:

// bad! It may work, but not with all extractors

// Good!

List Information

Extractors that implement Symfony\Component\PropertyInfo\PropertyListExtractorInterface provide the list of properties that are available on a class as an array containing each property name as a string:

$properties = $propertyInfo->getProperties($class);
    Example Result
    array(3) {
        [0] => string(8) "username"
        [1] => string(8) "password"
        [2] => string(6) "active"

Type Information

Extractors that implement Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface provide extensive data type information for a property:

$types = $propertyInfo->getTypes($class, $property);
    Example Result
    array(1) {
        [0] =>
            class Symfony\Component\PropertyInfo\Type (6) {
            private $builtinType          => string(6) "string"
            private $nullable             => bool(false)
            private $class                => NULL
            private $collection           => bool(false)
            private $collectionKeyType    => NULL
            private $collectionValueType  => NULL

See Type Objects for info about the Type class.

Description Information

Extractors that implement Symfony\Component\PropertyInfo\PropertyDescriptionExtractorInterface provide long and short descriptions from a properties annotations as strings:

$title = $propertyInfo->getShortDescription($class, $property);
    Example Result
    string(41) "This is the first line of the DocComment."

$paragraph = $propertyInfo->getLongDescription($class, $property);
    Example Result
        These is the subsequent paragraph in the DocComment.
        It can span multiple lines.

Access Information

Extractors that implement Symfony\Component\PropertyInfo\PropertyAccessExtractorInterface provide whether properties are readable or writable as booleans:

$propertyInfo->isReadable($class, $property);
// Example Result: bool(true)

$propertyInfo->isWritable($class, $property);
// Example Result: bool(false)

The Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor looks for getter/isser/setter/hasser method in addition to whether or not a property is public to determine if it’s accessible. This based on how the PropertyAccess works.

Property Initializable Information

Extractors that implement Symfony\Component\PropertyInfo\PropertyInitializableExtractorInterface provide whether properties are initializable through the class’s constructor as booleans:

$propertyInfo->isInitializable($class, $property);
// Example Result: bool(true)

isInitializable() returns true if a constructor’s parameter of the given class matches the given property name.


The main Symfony\Component\PropertyInfo\PropertyInfoExtractor class implements all interfaces, delegating the extraction of property information to the extractors that have been registered with it.

This means that any method available on each of the extractors is also available on the main Symfony\Component\PropertyInfo\PropertyInfoExtractor class.

Type Objects

Compared to the other extractors, type information extractors provide much more information than can be represented as simple scalar values. Because of this, type extractors return an array of Symfony\Component\PropertyInfo\Type objects for each type that the property supports.

For example, if a property supports both integer and string (via the @return int|string annotation), PropertyInfoExtractor::getTypes() will return an array containing two instances of the Symfony\Component\PropertyInfo\Type class.


Most extractors will return only one Symfony\Component\PropertyInfo\Type instance. The Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor is currently the only extractor that returns multiple instances in the array.

Each object will provide 6 attributes, available in the 6 methods:


The Type::getBuiltinType() method returns the built-in PHP data type, which can be one of these string values: array, bool, callable, float, int, iterable, null, object, resource or string.

Constants inside the Symfony\Component\PropertyInfo\Type class, in the form Type::BUILTIN_TYPE_*, are provided for convenience.

New in version 4.4: Support for typed properties (added in PHP 7.4) was introduced in Symfony 4.4.


The Type::isNullable() method will return a boolean value indicating whether the property parameter can be set to null.


If the built-in PHP data type is object, the Type::getClassName() method will return the fully-qualified class or interface name accepted.


The Type::isCollection() method will return a boolean value indicating if the property parameter is a collection - a non-scalar value capable of containing other values. Currently this returns true if:

  • The built-in PHP data type is array;
  • The mutator method the property is derived from has a prefix of add or remove (which are defined as the list of array mutator prefixes);
  • The phpDocumentor annotation is of type “collection” (e.g. @var SomeClass<DateTime>, @var SomeClass<integer,string>, @var Doctrine\Common\Collections\Collection<App\Entity\SomeEntity>, etc.)

New in version 4.2: The support of phpDocumentor collection types was introduced in Symfony 4.2.

Type::getCollectionKeyType() & Type::getCollectionValueType()

If the property is a collection, additional type objects may be returned for both the key and value types of the collection (if the information is available), via the Type::getCollectionKeyType() and Type::getCollectionValueType() methods.


The extraction of property information is performed by extractor classes. An extraction class can provide one or more types of property information by implementing the correct interface(s).

The Symfony\Component\PropertyInfo\PropertyInfoExtractor will iterate over the relevant extractor classes in the order they were set, call the appropriate method and return the first result that is not null.

While you can create your own extractors, the following are already available to cover most use-cases:


Using PHP reflection, the Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor provides list, type and access information from setter and accessor methods. It can also give the type of a property (even extracting it from the constructor arguments), and if it is initializable through the constructor. It supports return and scalar types for PHP 7:

use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;

$reflectionExtractor = new ReflectionExtractor();

// List information.

// Type information.
$reflectionExtractor->getTypes($class, $property);

// Access information.
$reflectionExtractor->isReadable($class, $property);
$reflectionExtractor->isWritable($class, $property);

// Initializable information
$reflectionExtractor->isInitializable($class, $property);

New in version 4.1: The feature to extract the property types from constructor arguments was introduced in Symfony 4.1.


When using the Symfony framework, this service is automatically registered when the property_info feature is enabled:

# config/packages/framework.yaml
        enabled: true



This extractor depends on the phpdocumentor/reflection-docblock library.

Using phpDocumentor Reflection to parse property and method annotations, the Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor provides type and description information. This extractor is automatically registered with the property_info in the Symfony Framework if the dependent library is present:

use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;

$phpDocExtractor = new PhpDocExtractor();

// Type information.
$phpDocExtractor->getTypes($class, $property);
// Description information.
$phpDocExtractor->getShortDescription($class, $property);
$phpDocExtractor->getLongDescription($class, $property);



This extractor depends on the symfony/serializer library.

Using groups metadata from the Serializer component, the Symfony\Component\PropertyInfo\Extractor\SerializerExtractor provides list information. This extractor is not registered automatically with the property_info service in the Symfony Framework:

use Doctrine\Common\Annotations\AnnotationReader;
use Symfony\Component\PropertyInfo\Extractor\SerializerExtractor;
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;

$serializerClassMetadataFactory = new ClassMetadataFactory(
    new AnnotationLoader(new AnnotationReader)
$serializerExtractor = new SerializerExtractor($serializerClassMetadataFactory);

// List information.



This extractor depends on the symfony/doctrine-bridge and doctrine/orm libraries.

Using entity mapping data from Doctrine ORM, the Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor provides list and type information. This extractor is not registered automatically with the property_info service in the Symfony Framework:

use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Tools\Setup;
use Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor;

$config = Setup::createAnnotationMetadataConfiguration([__DIR__], true);
$entityManager = EntityManager::create([
    'driver' => 'pdo_sqlite',
    // ...
], $config);
$doctrineExtractor = new DoctrineExtractor($entityManager);

// List information.
// Type information.
$doctrineExtractor->getTypes($class, $property);

Creating Your Own Extractors

You can create your own property information extractors by creating a class that implements one or more of the following interfaces: Symfony\Component\PropertyInfo\PropertyAccessExtractorInterface, Symfony\Component\PropertyInfo\PropertyDescriptionExtractorInterface, Symfony\Component\PropertyInfo\PropertyListExtractorInterface, Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface and Symfony\Component\PropertyInfo\PropertyInitializableExtractorInterface.

If you have enabled the PropertyInfo component with the FrameworkBundle, you can automatically register your extractor class with the property_info service by defining it as a service with one or more of the following tags:

  • property_info.list_extractor if it provides list information.
  • property_info.type_extractor if it provides type information.
  • property_info.description_extractor if it provides description information.
  • property_info.access_extractor if it provides access information.
  • property_info.initializable_extractor if it provides initializable information (it checks if a property can be initialized through the constructor).

New in version 4.2: The property_info.initializable_extractor was introduced in Symfony 4.2.

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.