2015-08-24 02:36:41 +01:00
< ? php
/*
* This file is part of the Symfony package .
*
* ( c ) Fabien Potencier < fabien @ symfony . com >
*
* For the full copyright and license information , please view the LICENSE
* file that was distributed with this source code .
*/
namespace Symfony\Component\DependencyInjection\Compiler ;
2016-03-12 20:10:13 +00:00
use Symfony\Component\DependencyInjection\Config\AutowireServiceResource ;
2015-08-24 02:36:41 +01:00
use Symfony\Component\DependencyInjection\ContainerBuilder ;
use Symfony\Component\DependencyInjection\Definition ;
use Symfony\Component\DependencyInjection\Exception\RuntimeException ;
2017-02-26 17:31:03 +00:00
use Symfony\Component\DependencyInjection\LazyProxy\InheritanceProxyHelper ;
2015-08-24 02:36:41 +01:00
use Symfony\Component\DependencyInjection\Reference ;
2017-02-26 17:31:03 +00:00
use Symfony\Component\DependencyInjection\TypedReference ;
2015-08-24 02:36:41 +01:00
/**
* Guesses constructor arguments of services definitions and try to instantiate services if necessary .
*
* @ author Kévin Dunglas < dunglas @ gmail . com >
*/
2017-01-31 12:10:56 +00:00
class AutowirePass extends AbstractRecursivePass
2015-08-24 02:36:41 +01:00
{
private $definedTypes = array ();
private $types ;
2016-02-22 00:27:26 +00:00
private $ambiguousServiceTypes = array ();
2017-02-18 17:58:12 +00:00
private $usedTypes = array ();
2017-02-26 17:31:03 +00:00
private $currentDefinition ;
2015-08-24 02:36:41 +01:00
/**
* { @ inheritdoc }
*/
public function process ( ContainerBuilder $container )
{
2016-04-20 13:06:08 +01:00
try {
2017-01-17 20:04:53 +00:00
parent :: process ( $container );
2017-02-18 17:58:12 +00:00
foreach ( $this -> usedTypes as $type => $id ) {
2017-02-19 22:20:06 +00:00
if ( ! isset ( $this -> usedTypes [ $type ]) || ! isset ( $this -> ambiguousServiceTypes [ $type ])) {
continue ;
}
2017-02-18 17:58:12 +00:00
2017-02-19 22:20:06 +00:00
if ( $container -> has ( $type ) && ! $container -> findDefinition ( $type ) -> isAbstract ()) {
continue ;
2017-02-18 17:58:12 +00:00
}
2017-02-19 22:20:06 +00:00
$classOrInterface = class_exists ( $type ) ? 'class' : 'interface' ;
$matchingServices = implode ( ', ' , $this -> ambiguousServiceTypes [ $type ]);
throw new RuntimeException ( sprintf ( 'Unable to autowire argument of type "%s" for the service "%s". Multiple services exist for this %s (%s).' , $type , $id , $classOrInterface , $matchingServices ));
2017-02-18 17:58:12 +00:00
}
2016-08-15 10:28:45 +01:00
} finally {
2016-12-23 12:58:16 +00:00
// Free memory
2016-08-15 10:28:45 +01:00
$this -> definedTypes = array ();
$this -> types = null ;
$this -> ambiguousServiceTypes = array ();
2017-02-19 22:13:25 +00:00
$this -> usedTypes = array ();
2016-04-20 13:06:08 +01:00
}
2015-08-24 02:36:41 +01:00
}
2016-03-12 20:10:13 +00:00
/**
* Creates a resource to help know if this service has changed .
*
* @ param \ReflectionClass $reflectionClass
*
* @ return AutowireServiceResource
2017-01-26 15:09:57 +00:00
*
* @ deprecated since version 3.3 , to be removed in 4.0 . Use ContainerBuilder :: getReflectionClass () instead .
2016-03-12 20:10:13 +00:00
*/
public static function createResourceForClass ( \ReflectionClass $reflectionClass )
{
2017-01-26 15:09:57 +00:00
@ trigger_error ( 'The ' . __METHOD__ . '() method is deprecated since version 3.3 and will be removed in 4.0. Use ContainerBuilder::getReflectionClass() instead.' , E_USER_DEPRECATED );
2016-03-12 20:10:13 +00:00
$metadata = array ();
2016-10-05 21:46:29 +01:00
foreach ( $reflectionClass -> getMethods ( \ReflectionMethod :: IS_PUBLIC ) as $reflectionMethod ) {
if ( ! $reflectionMethod -> isStatic ()) {
$metadata [ $reflectionMethod -> name ] = self :: getResourceMetadataForMethod ( $reflectionMethod );
}
2016-03-12 20:10:13 +00:00
}
return new AutowireServiceResource ( $reflectionClass -> name , $reflectionClass -> getFileName (), $metadata );
}
2015-08-24 02:36:41 +01:00
/**
2017-01-17 20:04:53 +00:00
* { @ inheritdoc }
2015-08-24 02:36:41 +01:00
*/
2017-01-17 20:04:53 +00:00
protected function processValue ( $value , $isRoot = false )
2015-08-24 02:36:41 +01:00
{
2017-02-26 17:31:03 +00:00
if ( $value instanceof TypedReference && $this -> currentDefinition -> isAutowired () && ! $this -> container -> has (( string ) $value )) {
if ( $ref = $this -> getAutowiredReference ( $value -> getType (), $value -> canBeAutoregistered ())) {
$value = new TypedReference (( string ) $ref , $value -> getType (), $value -> getInvalidBehavior (), $value -> canBeAutoregistered ());
}
2017-01-17 20:04:53 +00:00
}
2017-02-26 17:31:03 +00:00
if ( ! $value instanceof Definition ) {
2017-01-17 20:04:53 +00:00
return parent :: processValue ( $value , $isRoot );
2015-08-24 02:36:41 +01:00
}
2017-02-26 17:31:03 +00:00
$parentDefinition = $this -> currentDefinition ;
$this -> currentDefinition = $value ;
2017-01-25 12:02:51 +00:00
2017-02-26 17:31:03 +00:00
try {
if ( ! $value -> isAutowired () || ! $reflectionClass = $this -> container -> getReflectionClass ( $value -> getClass ())) {
return parent :: processValue ( $value , $isRoot );
}
$autowiredMethods = $this -> getMethodsToAutowire ( $reflectionClass );
$methodCalls = $value -> getMethodCalls ();
if ( $constructor = $reflectionClass -> getConstructor ()) {
array_unshift ( $methodCalls , array ( $constructor -> name , $value -> getArguments ()));
} elseif ( $value -> getArguments ()) {
throw new RuntimeException ( sprintf ( 'Cannot autowire service "%s": class %s has no constructor but arguments are defined.' , $this -> currentId , $reflectionClass -> name ));
}
2016-01-30 09:38:42 +00:00
2017-02-26 17:31:03 +00:00
$methodCalls = $this -> autowireCalls ( $reflectionClass , $methodCalls , $autowiredMethods );
$overriddenGetters = $this -> autowireOverridenGetters ( $value -> getOverriddenGetters (), $autowiredMethods );
2017-01-25 12:02:51 +00:00
2017-02-26 17:31:03 +00:00
if ( $constructor ) {
list (, $arguments ) = array_shift ( $methodCalls );
2017-01-25 12:02:51 +00:00
2017-02-26 17:31:03 +00:00
if ( $arguments !== $value -> getArguments ()) {
$value -> setArguments ( $arguments );
}
2016-10-05 21:46:29 +01:00
}
2017-01-17 20:04:53 +00:00
2017-02-26 17:31:03 +00:00
if ( $methodCalls !== $value -> getMethodCalls ()) {
$value -> setMethodCalls ( $methodCalls );
}
2017-01-25 12:02:51 +00:00
2017-02-26 17:31:03 +00:00
if ( $overriddenGetters !== $value -> getOverriddenGetters ()) {
$value -> setOverriddenGetters ( $overriddenGetters );
}
2016-12-23 12:58:16 +00:00
2017-02-26 17:31:03 +00:00
return parent :: processValue ( $value , $isRoot );
} finally {
$this -> currentDefinition = $parentDefinition ;
}
2016-10-05 21:46:29 +01:00
}
/**
* Gets the list of methods to autowire .
*
* @ param \ReflectionClass $reflectionClass
*
* @ return \ReflectionMethod []
*/
2017-02-25 16:12:16 +00:00
private function getMethodsToAutowire ( \ReflectionClass $reflectionClass )
2016-10-05 21:46:29 +01:00
{
$found = array ();
2017-01-25 12:02:51 +00:00
$methodsToAutowire = array ();
2017-01-16 15:14:49 +00:00
2017-02-07 18:39:15 +00:00
if ( $reflectionMethod = $reflectionClass -> getConstructor ()) {
2017-02-25 16:12:16 +00:00
$methodsToAutowire [ strtolower ( $reflectionMethod -> name )] = $reflectionMethod ;
2016-10-05 21:46:29 +01:00
}
2016-12-23 12:58:16 +00:00
foreach ( $reflectionClass -> getMethods ( \ReflectionMethod :: IS_PUBLIC | \ReflectionMethod :: IS_PROTECTED ) as $reflectionMethod ) {
2017-02-25 16:12:16 +00:00
$r = $reflectionMethod ;
2016-10-05 21:46:29 +01:00
2017-02-25 16:12:16 +00:00
while ( true ) {
if ( false !== $doc = $r -> getDocComment ()) {
if ( false !== stripos ( $doc , '@required' ) && preg_match ( '#(?:^/\*\*|\n\s*+\*)\s*+@required(?:\s|\*/$)#i' , $doc )) {
$methodsToAutowire [ strtolower ( $reflectionMethod -> name )] = $reflectionMethod ;
break ;
}
if ( false === stripos ( $doc , '@inheritdoc' ) || ! preg_match ( '#(?:^/\*\*|\n\s*+\*)\s*+(?:\{@inheritdoc\}|@inheritdoc)(?:\s|\*/$)#i' , $doc )) {
break ;
}
}
try {
$r = $r -> getPrototype ();
} catch ( \ReflectionException $e ) {
break ; // method has no prototype
}
2017-02-13 19:55:21 +00:00
}
2016-10-05 21:46:29 +01:00
}
2017-01-25 12:02:51 +00:00
return $methodsToAutowire ;
}
/**
* @ param \ReflectionClass $reflectionClass
* @ param array $methodCalls
* @ param \ReflectionMethod [] $autowiredMethods
*
* @ return array
*/
2017-02-07 18:39:15 +00:00
private function autowireCalls ( \ReflectionClass $reflectionClass , array $methodCalls , array $autowiredMethods )
2017-01-25 12:02:51 +00:00
{
foreach ( $methodCalls as $i => $call ) {
list ( $method , $arguments ) = $call ;
2016-12-23 12:58:16 +00:00
if ( isset ( $autowiredMethods [ $lcMethod = strtolower ( $method )]) && $autowiredMethods [ $lcMethod ] -> isPublic ()) {
2017-01-25 12:02:51 +00:00
$reflectionMethod = $autowiredMethods [ $lcMethod ];
unset ( $autowiredMethods [ $lcMethod ]);
} else {
if ( ! $reflectionClass -> hasMethod ( $method )) {
throw new RuntimeException ( sprintf ( 'Cannot autowire service "%s": method %s::%s() does not exist.' , $this -> currentId , $reflectionClass -> name , $method ));
}
$reflectionMethod = $reflectionClass -> getMethod ( $method );
if ( ! $reflectionMethod -> isPublic ()) {
throw new RuntimeException ( sprintf ( 'Cannot autowire service "%s": method %s::%s() must be public.' , $this -> currentId , $reflectionClass -> name , $method ));
}
}
2017-03-17 09:21:51 +00:00
$arguments = $this -> autowireMethod ( $reflectionMethod , $arguments );
2017-01-25 12:02:51 +00:00
if ( $arguments !== $call [ 1 ]) {
$methodCalls [ $i ][ 1 ] = $arguments ;
}
}
2017-02-07 18:39:15 +00:00
foreach ( $autowiredMethods as $lcMethod => $reflectionMethod ) {
2017-03-17 09:21:51 +00:00
if ( ! $reflectionMethod -> getNumberOfParameters ()) {
continue ; // skip getters
2017-01-25 12:02:51 +00:00
}
2017-03-17 09:21:51 +00:00
if ( ! $reflectionMethod -> isPublic ()) {
throw new RuntimeException ( sprintf ( 'Cannot autowire service "%s": method %s::%s() must be public.' , $this -> currentId , $reflectionClass -> name , $reflectionMethod -> name ));
}
$methodCalls [] = array ( $reflectionMethod -> name , $this -> autowireMethod ( $reflectionMethod , array ()));
2017-01-25 12:02:51 +00:00
}
return $methodCalls ;
2016-10-05 21:46:29 +01:00
}
/**
2016-12-23 12:58:16 +00:00
* Autowires the constructor or a method .
2016-10-05 21:46:29 +01:00
*
* @ param \ReflectionMethod $reflectionMethod
2017-01-25 12:02:51 +00:00
* @ param array $arguments
*
* @ return array The autowired arguments
2016-10-05 21:46:29 +01:00
*
* @ throws RuntimeException
*/
2017-03-17 09:21:51 +00:00
private function autowireMethod ( \ReflectionMethod $reflectionMethod , array $arguments )
2016-10-05 21:46:29 +01:00
{
2017-03-17 09:21:51 +00:00
$isConstructor = $reflectionMethod -> isConstructor ();
if ( ! $isConstructor && ! $arguments && ! $reflectionMethod -> getNumberOfRequiredParameters ()) {
throw new RuntimeException ( sprintf ( 'Cannot autowire service "%s": method %s::%s() has only optional arguments, thus must be wired explicitly.' , $this -> currentId , $reflectionMethod -> class , $reflectionMethod -> name ));
}
2016-10-05 21:46:29 +01:00
foreach ( $reflectionMethod -> getParameters () as $index => $parameter ) {
2016-02-29 00:33:45 +00:00
if ( array_key_exists ( $index , $arguments ) && '' !== $arguments [ $index ]) {
2015-08-24 02:36:41 +01:00
continue ;
}
2017-03-17 09:21:51 +00:00
if ( ! $isConstructor && $parameter -> isOptional () && ! array_key_exists ( $index , $arguments )) {
2017-02-25 16:12:16 +00:00
break ;
}
2017-02-07 18:39:15 +00:00
if ( method_exists ( $parameter , 'isVariadic' ) && $parameter -> isVariadic ()) {
continue ;
}
2015-08-24 02:36:41 +01:00
2017-03-21 08:00:21 +00:00
$type = InheritanceProxyHelper :: getTypeHint ( $reflectionMethod , $parameter , true );
2016-02-22 01:17:09 +00:00
2017-03-21 08:00:21 +00:00
if ( ! $type ) {
2017-02-01 12:10:11 +00:00
// no default value? Then fail
if ( ! $parameter -> isOptional ()) {
2017-03-17 09:21:51 +00:00
throw new RuntimeException ( sprintf ( 'Cannot autowire service "%s": argument $%s of method %s::%s() must have a type-hint or be given a value explicitly.' , $this -> currentId , $parameter -> name , $reflectionMethod -> class , $reflectionMethod -> name ));
2015-08-24 02:36:41 +01:00
}
2017-02-01 12:10:11 +00:00
if ( ! array_key_exists ( $index , $arguments )) {
// specifically pass the default value
$arguments [ $index ] = $parameter -> getDefaultValue ();
2015-08-24 02:36:41 +01:00
}
2017-02-01 12:10:11 +00:00
continue ;
}
2017-03-21 08:00:21 +00:00
if ( $value = $this -> getAutowiredReference ( $type )) {
$this -> usedTypes [ $type ] = $this -> currentId ;
2017-02-26 17:31:03 +00:00
} elseif ( $parameter -> isDefaultValueAvailable ()) {
$value = $parameter -> getDefaultValue ();
} elseif ( $parameter -> allowsNull ()) {
$value = null ;
2017-03-17 09:21:51 +00:00
} else {
2017-03-21 08:00:21 +00:00
if ( $classOrInterface = class_exists ( $type , false ) ? 'class' : ( interface_exists ( $type , false ) ? 'interface' : null )) {
$message = sprintf ( 'Unable to autowire argument of type "%s" for the service "%s". No services were found matching this %s and it cannot be auto-registered.' , $type , $this -> currentId , $classOrInterface );
2017-02-26 17:31:03 +00:00
} else {
2017-03-21 08:00:21 +00:00
$message = sprintf ( 'Cannot autowire argument $%s of method %s::%s() for service "%s": Class %s does not exist.' , $parameter -> name , $reflectionMethod -> class , $reflectionMethod -> name , $this -> currentId , $type );
2015-08-24 02:36:41 +01:00
}
2017-02-26 17:31:03 +00:00
throw new RuntimeException ( $message );
2015-08-24 02:36:41 +01:00
}
2016-02-21 23:51:49 +00:00
$arguments [ $index ] = $value ;
2015-08-24 02:36:41 +01:00
}
2016-02-21 23:51:49 +00:00
// it's possible index 1 was set, then index 0, then 2, etc
// make sure that we re-order so they're injected as expected
ksort ( $arguments );
2016-10-05 21:46:29 +01:00
2017-01-25 12:02:51 +00:00
return $arguments ;
2015-08-24 02:36:41 +01:00
}
2016-12-23 12:58:16 +00:00
/**
* Autowires getters .
*
* @ param array $overridenGetters
* @ param array $autowiredMethods
*
* @ return array
*/
private function autowireOverridenGetters ( array $overridenGetters , array $autowiredMethods )
{
2017-02-07 18:39:15 +00:00
foreach ( $autowiredMethods as $lcMethod => $reflectionMethod ) {
2017-03-17 09:21:51 +00:00
if ( isset ( $overridenGetters [ $lcMethod ]) || $reflectionMethod -> getNumberOfParameters () || $reflectionMethod -> isConstructor ()) {
2016-12-23 12:58:16 +00:00
continue ;
}
2017-03-21 08:00:21 +00:00
if ( ! $type = InheritanceProxyHelper :: getTypeHint ( $reflectionMethod , null , true )) {
$type = InheritanceProxyHelper :: getTypeHint ( $reflectionMethod );
2017-03-17 09:21:51 +00:00
2017-03-21 08:00:21 +00:00
throw new RuntimeException ( sprintf ( 'Cannot autowire service "%s": getter %s::%s() must%s have its return value be configured explicitly.' , $this -> currentId , $reflectionMethod -> class , $reflectionMethod -> name , $type ? '' : ' have a return-type hint or' ));
2017-03-17 09:21:51 +00:00
}
2017-03-21 08:00:21 +00:00
if ( ! $typeRef = $this -> getAutowiredReference ( $type )) {
continue ;
2017-03-17 09:21:51 +00:00
}
2016-12-23 12:58:16 +00:00
2017-02-26 17:31:03 +00:00
$overridenGetters [ $lcMethod ] = $typeRef ;
2017-03-21 08:00:21 +00:00
$this -> usedTypes [ $type ] = $this -> currentId ;
2017-02-26 17:31:03 +00:00
}
2016-12-23 12:58:16 +00:00
2017-02-26 17:31:03 +00:00
return $overridenGetters ;
}
2016-12-23 12:58:16 +00:00
2017-02-26 17:31:03 +00:00
/**
* @ return Reference | null A reference to the service matching the given type , if any
*/
2017-03-21 08:00:21 +00:00
private function getAutowiredReference ( $type , $autoRegister = true )
2017-02-26 17:31:03 +00:00
{
2017-03-21 08:00:21 +00:00
if ( $this -> container -> has ( $type ) && ! $this -> container -> findDefinition ( $type ) -> isAbstract ()) {
return new Reference ( $type );
2017-02-26 17:31:03 +00:00
}
2017-02-19 22:20:06 +00:00
2017-02-26 17:31:03 +00:00
if ( null === $this -> types ) {
$this -> populateAvailableTypes ();
}
2016-12-23 12:58:16 +00:00
2017-03-21 08:00:21 +00:00
if ( isset ( $this -> types [ $type ])) {
return new Reference ( $this -> types [ $type ]);
2016-12-23 12:58:16 +00:00
}
2017-03-21 08:00:21 +00:00
if ( $autoRegister && $class = $this -> container -> getReflectionClass ( $type , true )) {
2017-02-26 17:31:03 +00:00
return $this -> createAutowiredDefinition ( $class );
}
2016-12-23 12:58:16 +00:00
}
2015-08-24 02:36:41 +01:00
/**
* Populates the list of available types .
*/
private function populateAvailableTypes ()
{
$this -> types = array ();
foreach ( $this -> container -> getDefinitions () as $id => $definition ) {
$this -> populateAvailableType ( $id , $definition );
}
}
/**
* Populates the list of available types for a given definition .
*
* @ param string $id
* @ param Definition $definition
*/
private function populateAvailableType ( $id , Definition $definition )
{
2015-11-04 00:40:26 +00:00
// Never use abstract services
if ( $definition -> isAbstract ()) {
return ;
}
2017-02-01 11:51:46 +00:00
foreach ( $definition -> getAutowiringTypes ( false ) as $type ) {
2015-08-24 02:36:41 +01:00
$this -> definedTypes [ $type ] = true ;
$this -> types [ $type ] = $id ;
2017-02-19 22:13:25 +00:00
unset ( $this -> ambiguousServiceTypes [ $type ]);
2015-08-24 02:36:41 +01:00
}
2017-01-26 15:09:57 +00:00
if ( ! $reflectionClass = $this -> container -> getReflectionClass ( $definition -> getClass (), true )) {
2015-11-03 19:42:49 +00:00
return ;
}
2016-02-23 09:13:51 +00:00
foreach ( $reflectionClass -> getInterfaces () as $reflectionInterface ) {
$this -> set ( $reflectionInterface -> name , $id );
2015-08-24 02:36:41 +01:00
}
2016-02-23 09:13:51 +00:00
do {
$this -> set ( $reflectionClass -> name , $id );
} while ( $reflectionClass = $reflectionClass -> getParentClass ());
2015-08-24 02:36:41 +01:00
}
/**
* Associates a type and a service id if applicable .
*
* @ param string $type
* @ param string $id
*/
private function set ( $type , $id )
{
2016-02-22 00:27:26 +00:00
if ( isset ( $this -> definedTypes [ $type ])) {
2015-08-24 02:36:41 +01:00
return ;
}
2016-03-06 22:03:14 +00:00
// is this already a type/class that is known to match multiple services?
if ( isset ( $this -> ambiguousServiceTypes [ $type ])) {
2017-02-14 09:20:20 +00:00
$this -> ambiguousServiceTypes [ $type ][] = $id ;
2016-03-06 22:03:14 +00:00
return ;
}
2016-02-22 00:27:26 +00:00
// check to make sure the type doesn't match multiple services
2017-02-14 09:20:20 +00:00
if ( ! isset ( $this -> types [ $type ]) || $this -> types [ $type ] === $id ) {
$this -> types [ $type ] = $id ;
2015-08-24 02:36:41 +01:00
return ;
}
2017-02-14 09:20:20 +00:00
// keep an array of all services matching this type
if ( ! isset ( $this -> ambiguousServiceTypes [ $type ])) {
$this -> ambiguousServiceTypes [ $type ] = array ( $this -> types [ $type ]);
unset ( $this -> types [ $type ]);
}
$this -> ambiguousServiceTypes [ $type ][] = $id ;
2015-08-24 02:36:41 +01:00
}
/**
* Registers a definition for the type if possible or throws an exception .
*
* @ param \ReflectionClass $typeHint
*
2017-02-26 17:31:03 +00:00
* @ return Reference | null A reference to the registered definition
2015-08-24 02:36:41 +01:00
*
* @ throws RuntimeException
*/
2017-01-17 20:04:53 +00:00
private function createAutowiredDefinition ( \ReflectionClass $typeHint )
2015-08-24 02:36:41 +01:00
{
2016-02-22 00:27:26 +00:00
if ( isset ( $this -> ambiguousServiceTypes [ $typeHint -> name ])) {
$classOrInterface = $typeHint -> isInterface () ? 'interface' : 'class' ;
$matchingServices = implode ( ', ' , $this -> ambiguousServiceTypes [ $typeHint -> name ]);
2017-02-26 17:31:03 +00:00
throw new RuntimeException ( sprintf ( 'Unable to autowire argument of type "%s" for the service "%s". Multiple services exist for this %s (%s).' , $typeHint -> name , $this -> currentId , $classOrInterface , $matchingServices ));
2016-02-22 00:27:26 +00:00
}
if ( ! $typeHint -> isInstantiable ()) {
2017-02-26 17:31:03 +00:00
return ;
2015-08-24 02:36:41 +01:00
}
2017-01-17 20:04:53 +00:00
$currentId = $this -> currentId ;
$this -> currentId = $argumentId = sprintf ( 'autowired.%s' , $typeHint -> name );
2015-08-24 02:36:41 +01:00
$argumentDefinition = $this -> container -> register ( $argumentId , $typeHint -> name );
$argumentDefinition -> setPublic ( false );
2017-01-17 20:04:53 +00:00
$argumentDefinition -> setAutowired ( true );
2015-08-24 02:36:41 +01:00
$this -> populateAvailableType ( $argumentId , $argumentDefinition );
2016-05-02 16:12:26 +01:00
2017-02-26 17:31:03 +00:00
$this -> processValue ( $argumentDefinition , true );
2017-02-26 17:31:03 +00:00
$this -> currentId = $currentId ;
2015-08-24 02:36:41 +01:00
return new Reference ( $argumentId );
}
2017-01-26 15:09:57 +00:00
/**
* @ deprecated since version 3.3 , to be removed in 4.0 .
*/
2016-04-03 08:41:26 +01:00
private static function getResourceMetadataForMethod ( \ReflectionMethod $method )
2016-03-12 20:10:13 +00:00
{
$methodArgumentsMetadata = array ();
foreach ( $method -> getParameters () as $parameter ) {
try {
$class = $parameter -> getClass ();
} catch ( \ReflectionException $e ) {
// type-hint is against a non-existent class
$class = false ;
}
2017-01-22 14:49:28 +00:00
$isVariadic = method_exists ( $parameter , 'isVariadic' ) && $parameter -> isVariadic ();
2016-03-12 20:10:13 +00:00
$methodArgumentsMetadata [] = array (
'class' => $class ,
'isOptional' => $parameter -> isOptional (),
2017-01-22 14:49:28 +00:00
'defaultValue' => ( $parameter -> isOptional () && ! $isVariadic ) ? $parameter -> getDefaultValue () : null ,
2016-03-12 20:10:13 +00:00
);
}
return $methodArgumentsMetadata ;
}
2015-08-24 02:36:41 +01:00
}