PHP ReflectionMethod::getReturnType方法代码示例

 public function getReturnType() : Type
 {
     if ($this->returnType === null) {
         $this->returnType = TypehintHelper::decideType($this->reflection->getReturnType(), $this->phpDocReturnType, $this->declaringClass->getName());
     }
     return $this->returnType;
 }

 private function updateDefinition(ContainerBuilder $container, $id, Definition $definition, array $previous = array())
 {
     // circular reference
     if (isset($previous[$id])) {
         return;
     }
     $factory = $definition->getFactory();
     if (null === $factory || null !== $definition->getClass()) {
         return;
     }
     $class = null;
     if (is_string($factory)) {
         try {
             $m = new \ReflectionFunction($factory);
         } catch (\ReflectionException $e) {
             return;
         }
     } else {
         if ($factory[0] instanceof Reference) {
             $previous[$id] = true;
             $factoryDefinition = $container->findDefinition((string) $factory[0]);
             $this->updateDefinition($container, (string) $factory[0], $factoryDefinition, $previous);
             $class = $factoryDefinition->getClass();
         } else {
             $class = $factory[0];
         }
         try {
             $m = new \ReflectionMethod($class, $factory[1]);
         } catch (\ReflectionException $e) {
             return;
         }
     }
     $returnType = $m->getReturnType();
     if (null !== $returnType && !$returnType->isBuiltin()) {
         $returnType = (string) $returnType;
         if (null !== $class) {
             $declaringClass = $m->getDeclaringClass()->getName();
             if ('self' === $returnType) {
                 $returnType = $declaringClass;
             } elseif ('parent' === $returnType) {
                 $returnType = get_parent_class($declaringClass) ?: null;
             }
         }
         $definition->setClass($returnType);
     }
 }

 /**
  * Initializes method prophecy.
  *
  * @param ObjectProphecy                        $objectProphecy
  * @param string                                $methodName
  * @param null|Argument\ArgumentsWildcard|array $arguments
  *
  * @throws \Prophecy\Exception\Doubler\MethodNotFoundException If method not found
  */
 public function __construct(ObjectProphecy $objectProphecy, $methodName, $arguments = null)
 {
     $double = $objectProphecy->reveal();
     if (!method_exists($double, $methodName)) {
         throw new MethodNotFoundException(sprintf('Method `%s::%s()` is not defined.', get_class($double), $methodName), get_class($double), $methodName, $arguments);
     }
     $this->objectProphecy = $objectProphecy;
     $this->methodName = $methodName;
     $reflectedMethod = new \ReflectionMethod($double, $methodName);
     if ($reflectedMethod->isFinal()) {
         throw new MethodProphecyException(sprintf("Can not add prophecy for a method `%s::%s()`\n" . "as it is a final method.", get_class($double), $methodName), $this);
     }
     if (null !== $arguments) {
         $this->withArguments($arguments);
     }
     if (version_compare(PHP_VERSION, '7.0', '>=') && true === $reflectedMethod->hasReturnType()) {
         $type = (string) $reflectedMethod->getReturnType();
         $this->will(function () use($type) {
             switch ($type) {
                 case 'string':
                     return '';
                 case 'float':
                     return 0.0;
                 case 'int':
                     return 0;
                 case 'bool':
                     return false;
                 case 'array':
                     return array();
                 case 'callable':
                 case 'Closure':
                     return function () {
                     };
                 case 'Traversable':
                 case 'Generator':
                     // Remove eval() when minimum version >=5.5
                     /** @var callable $generator */
                     $generator = eval('return function () { yield; };');
                     return $generator();
                 default:
                     $prophet = new Prophet();
                     return $prophet->prophesize($type)->reveal();
             }
         });
     }
 }

 /**
  * @param \ReflectionMethod $method
  *
  * @return TypeInfoMember|null
  */
 protected function methodToTypeInfoMember(\ReflectionMethod $method)
 {
     if (substr($method->name, 0, 2) === '__') {
         return;
     }
     $docb = new DocBlock($method);
     $hint = $docb->getComment() ?: '';
     $link = $docb->getTag('link', '') ?: '';
     if (is_array($link)) {
         $link = $link[0];
     }
     if ($docb->tagExists('param')) {
         // detect return from docblock
         $return = explode(' ', $docb->getTag('return', 'void'), 2)[0];
     } else {
         // detect return from reflection
         $return = $this->canInspectReflectionReturnType ? $method->getReturnType() : '';
     }
     if ($docb->tagExists('param')) {
         // detect params from docblock
         $params = array_map([$this, 'parseDocBlockPropOrParam'], $docb->getTag('param', [], true));
     } else {
         // detect params from reflection
         $params = array_map([$this, 'parseReflectedParams'], $method->getParameters());
     }
     $signature = sprintf('<div class="cm-signature">' . '<span class="type">%s</span> <span class="name">%s</span>' . '(<span class="args">%s</span>)</span>' . '</div>', $return, $method->name, implode(', ', array_map(function ($param) {
         $result = '???';
         if ($param) {
             $result = sprintf('<span class="%s" title="%s"><span class="type">%s</span>$%s</span>', $param['hint'] ? 'arg hint' : 'arg', $param['hint'], count($param['types']) ? implode('|', $param['types']) . ' ' : '', $param['name']);
         }
         return $result;
     }, $params)));
     return new TypeInfoMember($method->name, ['method'], $signature . $hint, $link);
 }

<?php

$f = function (stdClass $x) : stdClass {
};
$r = new ReflectionMethod($f, '__invoke');
var_dump($r->getParameters()[0]->getName());
var_dump($r->getParameters()[0]->getClass());
echo $r->getParameters()[0], "\n";
echo $r->getReturnType(), "\n";
echo $r, "\n";

 /**
  * @param $methodMirror
  *
  * @return string
  */
 protected function describeMethod(ReflectionMethod $methodMirror) : string
 {
     if ($methodMirror->isProtected() || $methodMirror->isPrivate()) {
         return '';
     }
     $this->parseDocComment($methodMirror->getDocComment(), 2);
     $output = "\t.. php:method:: " . $methodMirror->name . " ( ";
     $output .= $this->buildParameterList($methodMirror->getParameters()) . " )\n\n";
     $output .= $this->describeParameters($methodMirror->getParameters());
     if ($methodMirror->hasReturnType()) {
         $output .= "\t\t:returns: \n\t\t:rtype: {$methodMirror->getReturnType()}";
     }
     $output .= "\n\n";
     $output .= $this->currentDocString . "\n\n";
     return $output;
 }

<?php

$closure = function (Test $x) : Test2 {
    return new Test2($x);
};
$rm = new ReflectionMethod($closure, '__invoke');
$rp = $rm->getParameters()[0];
$rt = $rp->getType();
$rrt = $rm->getReturnType();
unset($rm, $rp);
var_dump((string) $rt, (string) $rrt);

 protected function buildMethodSignature(\ReflectionMethod $method, bool $skipAbstract = false, bool $skipDefaultValues = false) : string
 {
     if ($method->isProtected()) {
         $code = 'protected ';
     } elseif ($method->isPrivate()) {
         $code = 'private ';
     } else {
         $code = 'public ';
     }
     if ($method->isAbstract()) {
         if (!$skipAbstract) {
             $code .= 'abstract ';
         }
     } elseif ($method->isFinal()) {
         $code .= 'final ';
     }
     if ($method->isStatic()) {
         $code .= 'static ';
     }
     $code .= 'function ';
     if ($method->returnsReference()) {
         $code .= '& ';
     }
     $code .= $method->getName() . '(';
     foreach ($method->getParameters() as $i => $param) {
         if ($i > 0) {
             $code .= ', ';
         }
         $code .= $this->buildParameterSignature($param, $skipDefaultValues);
     }
     $code .= ')';
     if ($method->hasReturnType()) {
         $type = $method->getReturnType();
         if ($type->isBuiltin) {
             $code .= ': ' . $type;
         } else {
             $code .= ': \\' . $type;
         }
     }
     return $code;
 }

 /**
  * @param ReflectionMethod $method
  *
  * @return bool
  */
 private function allowsReturnNull(ReflectionMethod $method)
 {
     return method_exists(ReflectionMethod::class, 'getReturnType') && method_exists(ReflectionType::class, 'allowsNull') && $method->hasReturnType() && $method->getReturnType()->allowsNull();
 }