The PropertyInfo Component

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 ReflectionExtractor and DoctrineExtractor both provide list and type information it is probably better that:

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

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

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

  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
      [
          $reflectionExtractor,
          $doctrineExtractor
      ],
      // Type extractors
      [
          $doctrineExtractor,
          $reflectionExtractor
      ]
  );

List Information

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

1
2
3
4
5
6
7
8
9
10

$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 PropertyTypeExtractorInterface provide extensive data type information for a property:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

$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 The PropertyInfo Component for info about the Type class.

Description Information

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

$paragraph = $propertyInfo->getLongDescription($class, $property);
/*
    Example Result
    --------------
    string(79):
        This is the subsequent paragraph in the DocComment.
        It can span multiple lines.
*/

Access Information

Extractors that implement PropertyAccessExtractorInterface provide whether properties are readable or writable as booleans:

1
2
3
4
5

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

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

The 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.

Type::getBuiltInType()

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 Type class, in the form Type::BUILTIN_TYPE_*, are provided for convenience.

Type::isNullable()

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

Type::getClassName()

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

Type::isCollection()

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.)

Type::getCollectionKeyTypes() & Type::getCollectionValueTypes()

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::getCollectionKeyTypes() and Type::getCollectionValueTypes() methods.

ReflectionExtractor

Using PHP reflection, the 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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;

$reflectionExtractor = new ReflectionExtractor();

// List information.
$reflectionExtractor->getProperties($class);

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

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

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

1
2
3
4

# config/packages/framework.yaml
framework:
    property_info:
        enabled: true

PhpDocExtractor

Using phpDocumentor Reflection to parse property and method annotations, the 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:

1
2
3
4
5
6
7
8
9

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);

PhpStanExtractor

This extractor fetches information thanks to the PHPStan parser. It gathers information from annotations of properties and methods, such as @var, @param or @return:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// src/Domain/Foo.php
class Foo
{
    /**
     * @param string $bar
     */
    public function __construct(
        private string $bar,
    ) {
    }
}

// Extraction.php
use Symfony\Component\PropertyInfo\Extractor\PhpStanExtractor;
use App\Domain\Foo;

$phpStanExtractor = new PhpStanExtractor();
$phpStanExtractor->getTypesFromConstructor(Foo::class, 'bar');

SerializerExtractor

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

1
2
3
4
5
6
7
8
9
10
11
12

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);

// the `serializer_groups` option must be configured (may be set to null)
$serializerExtractor->getProperties($class, ['serializer_groups' => ['mygroup']]);

If serializer_groups is set to null, serializer groups metadata won't be checked but you will get only the properties considered by the Serializer Component (notably the @Ignore annotation is taken into account).

DoctrineExtractor

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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.
$doctrineExtractor->getProperties($class);
// Type information.
$doctrineExtractor->getTypes($class, $property);

ConstructorExtractor

The ConstructorExtractor tries to extract properties information by using either the PhpStanExtractor or the ReflectionExtractor on the constructor arguments:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// src/Domain/Foo.php
class Foo
{
    public function __construct(
        private string $bar,
    ) {
    }
}

// Extraction.php
use App\Domain\Foo;
use Symfony\Component\PropertyInfo\Extractor\ConstructorExtractor;

$constructorExtractor = new ConstructorExtractor([new ReflectionExtractor()]);
$constructorExtractor->getTypes(Foo::class, 'bar')[0]->getBuiltinType(); // returns 'string'