/** * Creates a function signature instance from the supplied reflection. * * @param \ReflectionFunctionAbstract $reflection * * @return self */ public static function fromReflection(\ReflectionFunctionAbstract $reflection) { $returnsReference = $reflection->returnsReference(); $name = $reflection->getShortName(); $parameterExpressions = self::getParameterExpressionsFromReflection($reflection); if ($reflection->isClosure()) { return self::closure($returnsReference, $parameterExpressions, array_keys($reflection->getStaticVariables())); } elseif ($reflection instanceof \ReflectionMethod) { if ($reflection->isPublic()) { $accessModifier = self::ACCESS_PUBLIC; } elseif ($reflection->isProtected()) { $accessModifier = self::ACCESS_PROTECTED; } else { $accessModifier = self::ACCESS_PRIVATE; } if ($reflection->isAbstract()) { $polymorphModifier = self::POLYMORPH_ABSTRACT; } elseif ($reflection->isFinal()) { $polymorphModifier = self::POLYMORPH_FINAL; } else { $polymorphModifier = null; } return self::method($returnsReference, $accessModifier, $polymorphModifier, $reflection->isStatic(), $name, $parameterExpressions); } else { return self::func($returnsReference, $name, $parameterExpressions); } }
/** * Format a function signature. * * @param \ReflectionFunction $reflector * * @return string Formatted signature. */ private static function formatFunction(\ReflectionFunctionAbstract $reflector) { return sprintf('<keyword>function</keyword> %s<function>%s</function>(%s)', $reflector->returnsReference() ? '&' : '', self::formatName($reflector), implode(', ', self::formatFunctionParams($reflector))); }
/** * * @param EntityFunction $callable * @param \ReflectionFunctionAbstract $reflection * @return $this */ public static function parseCallable(EntityFunction $callable, \ReflectionFunctionAbstract $reflection) { $doc = $reflection->getDocComment(); $params = []; if ($doc) { $info = ToolKit::parseDoc($doc); $callable->setDescription($info['desc']); $callable->setReturnInfo($info['return']['type'], $reflection->returnsReference(), $info['return']['desc']); $callable->setOptions($info['options']); $params = $info["params"]; } else { $info = []; } /* @var \ReflectionParameter[] $params */ foreach ($reflection->getParameters() as $param) { $argument = new EntityArgument($param->name); if (isset($params[$param->name]["desc"])) { $argument->description = $params[$param->name]["desc"]; } if ($callable->getLine()) { $argument->setLine($callable->getLine()); } $argument->setOptional($param->isOptional()); $argument->setNullAllowed($param->allowsNull()); $argument->setValue($param->isDefaultValueAvailable() ? $param->getDefaultValue() : null, $param->isPassedByReference()); $argument->setByRef($param->isPassedByReference()); /** @var \ReflectionParameter $param */ if ($param->isArray()) { $argument->setCast(Types::ARR); } if ($c = $param->getClass()) { $argument->setCast(Types::OBJECT, $c->name); } elseif (isset($info['params'][$param->name])) { $_type = $info['params'][$param->name]["type"]; if (strpos($_type, "|") || $_type === "mixed") { // multiple types or mixed $argument->setCast(Types::MIXED); } else { if (strpos($_type, "[]")) { $argument->setCast(Types::ARR, rtrim($_type, '[]')); } if (isset(Types::$codes[$_type])) { $argument->setCast(Types::getType($_type)); } else { $argument->setCast(Types::OBJECT, ltrim($_type, '\\')); } } } else { $argument->warning("not documented"); } $callable->pushArgument($argument); } }
public function matchReflector(\ReflectionFunctionAbstract $reflector) { $this->setReference($reflector->returnsReference()); foreach ($reflector->getParameters() as $i => $parameter) { try { $this->getParameterAtIndex($i)->matchReflector($parameter); } catch (\OutOfBoundsException $e) { $this->appendParameter(ParameterNode::fromReflector($parameter)); } } return $this; }