+ */
+class CheckTypeDeclarationsPassTest extends TestCase
+{
+ public function testProcessThrowsExceptionOnInvalidTypesConstructorArguments()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Bar::__construct" accepts "stdClass", "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Foo" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('foo', Foo::class);
+ $container->register('bar', Bar::class)
+ ->addArgument(new Reference('foo'));
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessThrowsExceptionOnInvalidTypesMethodCallArguments()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\BarMethodCall::setFoo" accepts "stdClass", "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Foo" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('foo', Foo::class);
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setFoo', [new Reference('foo')]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessFailsWhenPassingNullToRequiredArgument()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Bar::__construct" accepts "stdClass", "NULL" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('bar', Bar::class)
+ ->addArgument(null);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessThrowsExceptionWhenMissingArgumentsInConstructor()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Bar::__construct()" requires 1 arguments, 0 passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('bar', Bar::class);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessSuccessWhenPassingTooManyArgumentInConstructor()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('foo', \stdClass::class);
+ $container->register('bar', Bar::class)
+ ->addArgument(new Reference('foo'))
+ ->addArgument(new Reference('foo'));
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->addToAssertionCount(1);
+ }
+
+ public function testProcessRegisterWithClassName()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register(Foo::class, Foo::class);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(Foo::class, $container->get(Foo::class));
+ }
+
+ public function testProcessThrowsExceptionWhenMissingArgumentsInMethodCall()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\BarMethodCall::setFoo()" requires 1 arguments, 0 passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('foo', \stdClass::class);
+ $container->register('bar', BarMethodCall::class)
+ ->addArgument(new Reference('foo'))
+ ->addMethodCall('setFoo', []);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessVariadicFails()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 2 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\BarMethodCall::setFoosVariadic" accepts "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Foo", "stdClass" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('stdClass', \stdClass::class);
+ $container->register('foo', Foo::class);
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setFoosVariadic', [
+ new Reference('foo'),
+ new Reference('foo'),
+ new Reference('stdClass'),
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessVariadicFailsOnPassingBadTypeOnAnotherArgument()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\BarMethodCall::setFoosVariadic" accepts "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Foo", "stdClass" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('stdClass', \stdClass::class);
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setFoosVariadic', [
+ new Reference('stdClass'),
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessVariadicSuccess()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('foo', Foo::class);
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setFoosVariadic', [
+ new Reference('foo'),
+ new Reference('foo'),
+ new Reference('foo'),
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(Foo::class, $container->get('bar')->foo);
+ }
+
+ public function testProcessSuccessWhenNotUsingOptionalArgument()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('foo', Foo::class);
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setFoosOptional', [
+ new Reference('foo'),
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(Foo::class, $container->get('bar')->foo);
+ }
+
+ public function testProcessSuccessWhenUsingOptionalArgumentWithGoodType()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('foo', Foo::class);
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setFoosOptional', [
+ new Reference('foo'),
+ new Reference('foo'),
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(Foo::class, $container->get('bar')->foo);
+ }
+
+ public function testProcessFailsWhenUsingOptionalArgumentWithBadType()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 2 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\BarMethodCall::setFoosOptional" accepts "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Foo", "stdClass" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('stdClass', \stdClass::class);
+ $container->register('foo', Foo::class);
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setFoosOptional', [
+ new Reference('foo'),
+ new Reference('stdClass'),
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessSuccessWhenPassingNullToOptional()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarOptionalArgument::class)
+ ->addArgument(null);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertNull($container->get('bar')->foo);
+ }
+
+ public function testProcessSuccessWhenPassingNullToOptionalThatDoesNotAcceptNull()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\BarOptionalArgumentNotNull::__construct" accepts "int", "NULL" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarOptionalArgumentNotNull::class)
+ ->addArgument(null);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessFailsWhenPassingBadTypeToOptional()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\BarOptionalArgument::__construct" accepts "stdClass", "string" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarOptionalArgument::class)
+ ->addArgument('string instead of stdClass');
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertNull($container->get('bar')->foo);
+ }
+
+ public function testProcessSuccessScalarType()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setScalars', [
+ 1,
+ 'string',
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(BarMethodCall::class, $container->get('bar'));
+ }
+
+ public function testProcessFailsOnPassingScalarTypeToConstructorTypedWithClass()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Bar::__construct" accepts "stdClass", "integer" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('bar', Bar::class)
+ ->addArgument(1);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessFailsOnPassingScalarTypeToMethodTypedWithClass()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\BarMethodCall::setFoo" accepts "stdClass", "string" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setFoo', [
+ 'builtin type instead of class',
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessFailsOnPassingClassToScalarTypedParameter()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\BarMethodCall::setScalars" accepts "int", "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Foo" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('foo', Foo::class);
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setScalars', [
+ new Reference('foo'),
+ new Reference('foo'),
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessSuccessOnPassingBadScalarType()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setScalars', [
+ 1,
+ true,
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(BarMethodCall::class, $container->get('bar'));
+ }
+
+ public function testProcessSuccessPassingBadScalarTypeOptionalArgument()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setScalars', [
+ 1,
+ 'string',
+ 'string instead of optional boolean',
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(BarMethodCall::class, $container->get('bar'));
+ }
+
+ public function testProcessSuccessWhenPassingArray()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setArray', [[]]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(BarMethodCall::class, $container->get('bar'));
+ }
+
+ public function testProcessSuccessWhenPassingIntegerToArrayTypedParameter()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidParameterTypeException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\Component\DependencyInjection\Tests\Fixtures\CheckTypeDeclarationsPass\BarMethodCall::setArray" accepts "array", "integer" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setArray', [1]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessSuccessWhenPassingAnIteratorArgumentToIterable()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarMethodCall::class)
+ ->addMethodCall('setIterable', [new IteratorArgument([])]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->addToAssertionCount(1);
+ }
+
+ public function testProcessFactory()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('foo', Foo::class);
+ $container->register('bar', Bar::class)
+ ->setFactory([
+ new Reference('foo'),
+ 'createBar',
+ ]);
+
+ /* Asserts that the class of Bar is well detected */
+ $container->register('bar_call', BarMethodCall::class)
+ ->addMethodCall('setBar', [new Reference('bar')]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(Bar::class, $container->get('bar'));
+ }
+
+ public function testProcessFactoryFailsOnInvalidParameterType()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Foo::createBarArguments" accepts "stdClass", "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Foo" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('foo', Foo::class);
+ $container->register('bar', Bar::class)
+ ->addArgument(new Reference('foo'))
+ ->setFactory([
+ new Reference('foo'),
+ 'createBarArguments',
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessFactoryFailsOnInvalidParameterTypeOptional()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar": argument 2 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Foo::createBarArguments" accepts "stdClass", "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\Foo" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('stdClass', \stdClass::class);
+ $container->register('foo', Foo::class);
+ $container->register('bar', Bar::class)
+ ->addArgument(new Reference('stdClass'))
+ ->addArgument(new Reference('foo'))
+ ->setFactory([
+ new Reference('foo'),
+ 'createBarArguments',
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+ }
+
+ public function testProcessFactorySuccessOnValidTypes()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('stdClass', \stdClass::class);
+ $container->register('foo', Foo::class);
+ $container->register('bar', Bar::class)
+ ->addArgument(new Reference('stdClass'))
+ ->addArgument(new Reference('stdClass'))
+ ->setFactory([
+ new Reference('foo'),
+ 'createBarArguments',
+ ]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->addToAssertionCount(1);
+ }
+
+ public function testProcessFactoryCallbackSuccessOnValidType()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('bar', \DateTime::class)
+ ->setFactory('date_create');
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(\DateTime::class, $container->get('bar'));
+ }
+
+ public function testProcessDoesNotLoadCodeByDefault()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('foo', FooNotExisting::class);
+ $container->register('bar', BarNotExisting::class)
+ ->addArgument(new Reference('foo'))
+ ->addMethodCall('setFoo', [
+ new Reference('foo'),
+ 'string',
+ 1,
+ ]);
+
+ (new CheckTypeDeclarationsPass())->process($container);
+
+ $this->addToAssertionCount(1);
+ }
+
+ public function testProcessFactoryDoesNotLoadCodeByDefault()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('foo', FooNotExisting::class);
+ $container->register('bar', BarNotExisting::class)
+ ->setFactory([
+ new Reference('foo'),
+ 'notExistingMethod',
+ ]);
+
+ (new CheckTypeDeclarationsPass())->process($container);
+
+ $this->addToAssertionCount(1);
+ }
+
+ public function testProcessPassingBuiltinTypeDoesNotLoadCodeByDefault()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('bar', BarNotExisting::class)
+ ->addArgument(1);
+
+ (new CheckTypeDeclarationsPass())->process($container);
+
+ $this->addToAssertionCount(1);
+ }
+
+ public function testProcessDoesNotThrowsExceptionOnValidTypes()
+ {
+ $container = new ContainerBuilder();
+
+ $container->register('foo', \stdClass::class);
+ $container->register('bar', Bar::class)
+ ->addArgument(new Reference('foo'));
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(\stdClass::class, $container->get('bar')->foo);
+ }
+
+ public function testProcessThrowsOnIterableTypeWhenScalarPassed()
+ {
+ $this->expectException(\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException::class);
+ $this->expectExceptionMessage('Invalid definition for service "bar_call": argument 1 of "Symfony\\Component\\DependencyInjection\\Tests\\Fixtures\\CheckTypeDeclarationsPass\\BarMethodCall::setIterable" accepts "iterable", "integer" passed.');
+
+ $container = new ContainerBuilder();
+
+ $container->register('bar_call', BarMethodCall::class)
+ ->addMethodCall('setIterable', [2]);
+
+ (new CheckTypeDeclarationsPass(true))->process($container);
+
+ $this->assertInstanceOf(\stdClass::class, $container->get('bar')->foo);
+ }
+}
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/Bar.php b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/Bar.php
new file mode 100644
index 000000000000..403841ce88df
--- /dev/null
+++ b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/Bar.php
@@ -0,0 +1,13 @@
+foo = $foo;
+ }
+}
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/BarMethodCall.php b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/BarMethodCall.php
new file mode 100644
index 000000000000..c308ef954571
--- /dev/null
+++ b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/BarMethodCall.php
@@ -0,0 +1,39 @@
+foo = $foo;
+ }
+
+ public function setFoosVariadic(Foo $foo, Foo ...$foos)
+ {
+ $this->foo = $foo;
+ }
+
+ public function setFoosOptional(Foo $foo, Foo $fooOptional = null)
+ {
+ $this->foo = $foo;
+ }
+
+ public function setScalars(int $int, string $string, bool $bool = false)
+ {
+ }
+
+ public function setArray(array $array)
+ {
+ }
+
+ public function setIterable(iterable $iterable)
+ {
+ }
+}
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/BarOptionalArgument.php b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/BarOptionalArgument.php
new file mode 100644
index 000000000000..4f348895132c
--- /dev/null
+++ b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/BarOptionalArgument.php
@@ -0,0 +1,13 @@
+foo = $foo;
+ }
+}
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/BarOptionalArgumentNotNull.php b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/BarOptionalArgumentNotNull.php
new file mode 100644
index 000000000000..07f27817c031
--- /dev/null
+++ b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/BarOptionalArgumentNotNull.php
@@ -0,0 +1,13 @@
+foo = $foo;
+ }
+}
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/Foo.php b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/Foo.php
new file mode 100644
index 000000000000..dde7afce91fd
--- /dev/null
+++ b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/CheckTypeDeclarationsPass/Foo.php
@@ -0,0 +1,16 @@
+
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy