File vendor/ondrejmirtes/better-reflection/src/Reflection/Adapter/ReflectionMethod.php

1:	<?php
2:
3:	declare(strict_types=1);
4:
5:	namespace PHPStan\BetterReflection\Reflection\Adapter;
6:
7:	use Closure;
8:	use OutOfBoundsException;
9:	use ReflectionClass as CoreReflectionClass;
10:	use ReflectionException as CoreReflectionException;
11:	use ReflectionExtension as CoreReflectionExtension;
12:	use ReflectionMethod as CoreReflectionMethod;
13:	use ReflectionType as CoreReflectionType;
14:	use ReturnTypeWillChange;
15:	use PHPStan\BetterReflection\Reflection\Adapter\Exception\NotImplemented;
16:	use PHPStan\BetterReflection\Reflection\Exception\CodeLocationMissing;
17:	use PHPStan\BetterReflection\Reflection\Exception\MethodPrototypeNotFound;
18:	use PHPStan\BetterReflection\Reflection\Exception\NoObjectProvided;
19:	use PHPStan\BetterReflection\Reflection\ReflectionAttribute as BetterReflectionAttribute;
20:	use PHPStan\BetterReflection\Reflection\ReflectionMethod as BetterReflectionMethod;
21:	use PHPStan\BetterReflection\Reflection\ReflectionParameter as BetterReflectionParameter;
22:	use PHPStan\BetterReflection\Util\FileHelper;
23:	use Throwable;
24:	use ValueError;
25:
26:	use function array_map;
27:	use function sprintf;
28:
29:	/** @psalm-suppress PropertyNotSetInConstructor */
30:	final class ReflectionMethod extends CoreReflectionMethod
31:	{
32:	/**
33:	* @var BetterReflectionMethod
34:	*/
35:	private $betterReflectionMethod;
36:	public function __construct(BetterReflectionMethod $betterReflectionMethod)
37:	{
38:	$this->betterReflectionMethod = $betterReflectionMethod;
39:	unset($this->name);
40:	unset($this->class);
41:	}
42:
43:	/** @return non-empty-string */
44:	public function __toString(): string
45:	{
46:	return $this->betterReflectionMethod->__toString();
47:	}
48:
49:	public function inNamespace(): bool
50:	{
51:	return $this->betterReflectionMethod->inNamespace();
52:	}
53:
54:	public function isClosure(): bool
55:	{
56:	return $this->betterReflectionMethod->isClosure();
57:	}
58:
59:	public function isDeprecated(): bool
60:	{
61:	return $this->betterReflectionMethod->isDeprecated();
62:	}
63:
64:	public function isInternal(): bool
65:	{
66:	return $this->betterReflectionMethod->isInternal();
67:	}
68:
69:	public function isUserDefined(): bool
70:	{
71:	return $this->betterReflectionMethod->isUserDefined();
72:	}
73:
74:	/**
75:	* {@inheritDoc}
76:	*/
77:	#[ReturnTypeWillChange]
78:	public function getClosureThis()
79:	{
80:	throw new NotImplemented('Not implemented');
81:	}
82:
83:	public function getClosureScopeClass(): ?CoreReflectionClass
84:	{
85:	throw new NotImplemented('Not implemented');
86:	}
87:
88:	public function getClosureCalledClass(): ?CoreReflectionClass
89:	{
90:	throw new NotImplemented('Not implemented');
91:	}
92:
93:	/**
94:	* {@inheritDoc}
95:	*/
96:	#[ReturnTypeWillChange]
97:	public function getDocComment()
98:	{
99:	return $this->betterReflectionMethod->getDocComment() ?? false;
100:	}
101:
102:	/**
103:	* {@inheritDoc}
104:	*/
105:	#[ReturnTypeWillChange]
106:	public function getStartLine()
107:	{
108:	try {
109:	return $this->betterReflectionMethod->getStartLine();
110:	} catch (CodeLocationMissing $exception) {
111:	return false;
112:	}
113:	}
114:
115:	/**
116:	* {@inheritDoc}
117:	*/
118:	#[ReturnTypeWillChange]
119:	public function getEndLine()
120:	{
121:	try {
122:	return $this->betterReflectionMethod->getEndLine();
123:	} catch (CodeLocationMissing $exception) {
124:	return false;
125:	}
126:	}
127:
128:	/** @psalm-suppress ImplementedReturnTypeMismatch */
129:	public function getExtension(): ?CoreReflectionExtension
130:	{
131:	throw new NotImplemented('Not implemented');
132:	}
133:
134:	/**
135:	* {@inheritDoc}
136:	*/
137:	#[ReturnTypeWillChange]
138:	public function getExtensionName()
139:	{
140:	return $this->betterReflectionMethod->getExtensionName() ?? false;
141:	}
142:
143:	/**
144:	* {@inheritDoc}
145:	*/
146:	#[ReturnTypeWillChange]
147:	public function getFileName()
148:	{
149:	$fileName = $this->betterReflectionMethod->getFileName();
150:
151:	return $fileName !== null ? FileHelper::normalizeSystemPath($fileName) : false;
152:	}
153:
154:	public function getName(): string
155:	{
156:	return $this->betterReflectionMethod->getName();
157:	}
158:
159:	public function getNamespaceName(): string
160:	{
161:	return $this->betterReflectionMethod->getNamespaceName() ?? '';
162:	}
163:
164:	public function getNumberOfParameters(): int
165:	{
166:	return $this->betterReflectionMethod->getNumberOfParameters();
167:	}
168:
169:	public function getNumberOfRequiredParameters(): int
170:	{
171:	return $this->betterReflectionMethod->getNumberOfRequiredParameters();
172:	}
173:
174:	/** @return list<ReflectionParameter> */
175:	public function getParameters(): array
176:	{
177:	return array_map(static function (BetterReflectionParameter $parameter) : ReflectionParameter {
178:	return new ReflectionParameter($parameter);
179:	}, $this->betterReflectionMethod->getParameters());
180:	}
181:
182:	public function hasReturnType(): bool
183:	{
184:	return $this->betterReflectionMethod->hasReturnType();
185:	}
186:
187:	/** @return ReflectionUnionType\|ReflectionNamedType\|ReflectionIntersectionType\|null */
188:	public function getReturnType(): ?CoreReflectionType
189:	{
190:	return ReflectionType::fromTypeOrNull($this->betterReflectionMethod->getReturnType());
191:	}
192:
193:	public function getShortName(): string
194:	{
195:	return $this->betterReflectionMethod->getShortName();
196:	}
197:
198:	/** @return array<string, scalar> */
199:	public function getStaticVariables(): array
200:	{
201:	throw new NotImplemented('Not implemented');
202:	}
203:
204:	public function returnsReference(): bool
205:	{
206:	return $this->betterReflectionMethod->returnsReference();
207:	}
208:
209:	public function isGenerator(): bool
210:	{
211:	return $this->betterReflectionMethod->isGenerator();
212:	}
213:
214:	public function isVariadic(): bool
215:	{
216:	return $this->betterReflectionMethod->isVariadic();
217:	}
218:
219:	public function isPublic(): bool
220:	{
221:	return $this->betterReflectionMethod->isPublic();
222:	}
223:
224:	public function isPrivate(): bool
225:	{
226:	return $this->betterReflectionMethod->isPrivate();
227:	}
228:
229:	public function isProtected(): bool
230:	{
231:	return $this->betterReflectionMethod->isProtected();
232:	}
233:
234:	public function isAbstract(): bool
235:	{
236:	return $this->betterReflectionMethod->isAbstract();
237:	}
238:
239:	public function isFinal(): bool
240:	{
241:	return $this->betterReflectionMethod->isFinal();
242:	}
243:
244:	public function isStatic(): bool
245:	{
246:	return $this->betterReflectionMethod->isStatic();
247:	}
248:
249:	public function isConstructor(): bool
250:	{
251:	return $this->betterReflectionMethod->isConstructor();
252:	}
253:
254:	public function isDestructor(): bool
255:	{
256:	return $this->betterReflectionMethod->isDestructor();
257:	}
258:
259:	/**
260:	* {@inheritDoc}
261:	*/
262:	public function getClosure($object = null): Closure
263:	{
264:	try {
265:	return $this->betterReflectionMethod->getClosure($object);
266:	} catch (NoObjectProvided $e) {
267:	throw new ValueError($e->getMessage(), 0, $e);
268:	} catch (Throwable $e) {
269:	throw new CoreReflectionException($e->getMessage(), 0, $e);
270:	}
271:	}
272:
273:	public function getModifiers(): int
274:	{
275:	return $this->betterReflectionMethod->getModifiers();
276:	}
277:
278:	/**
279:	* @param object $object
280:	* @param mixed $arg
281:	* @param mixed ...$args
282:	*
283:	* @return mixed
284:	*
285:	* @throws CoreReflectionException
286:	*/
287:	#[ReturnTypeWillChange]
288:	public function invoke($object = null, $arg = null, ...$args)
289:	{
290:	try {
291:	return $this->betterReflectionMethod->invoke($object, $arg, ...$args);
292:	} catch (NoObjectProvided $exception) {
293:	return null;
294:	} catch (Throwable $e) {
295:	throw new CoreReflectionException($e->getMessage(), 0, $e);
296:	}
297:	}
298:
299:	/**
300:	* @param object $object
301:	* @param mixed[] $args
302:	*
303:	* @return mixed
304:	*
305:	* @throws CoreReflectionException
306:	*/
307:	#[ReturnTypeWillChange]
308:	public function invokeArgs($object = null, array $args = [])
309:	{
310:	try {
311:	return $this->betterReflectionMethod->invokeArgs($object, $args);
312:	} catch (NoObjectProvided $exception) {
313:	return null;
314:	} catch (Throwable $e) {
315:	throw new CoreReflectionException($e->getMessage(), 0, $e);
316:	}
317:	}
318:
319:	public function getDeclaringClass(): ReflectionClass
320:	{
321:	return new ReflectionClass($this->betterReflectionMethod->getImplementingClass());
322:	}
323:
324:	public function getPrototype(): ReflectionMethod
325:	{
326:	return new self($this->betterReflectionMethod->getPrototype());
327:	}
328:
329:	public function hasPrototype(): bool
330:	{
331:	try {
332:	$this->betterReflectionMethod->getPrototype();
333:
334:	return true;
335:	} catch (MethodPrototypeNotFound $exception) {
336:	return false;
337:	}
338:	}
339:
340:	/**
341:	* {@inheritDoc}
342:	* @codeCoverageIgnore
343:	* @infection-ignore-all
344:	* @psalm-pure
345:	* @phpstan-ignore pureMethod.void
346:	*/
347:	public function setAccessible($accessible): void
348:	{
349:	}
350:
351:	/**
352:	* @param class-string\|null $name
353:	*
354:	* @return list<ReflectionAttribute\|FakeReflectionAttribute>
355:	*/
356:	public function getAttributes(?string $name = null, int $flags = 0): array
357:	{
358:	if ($flags !== 0 && $flags !== ReflectionAttribute::IS_INSTANCEOF) {
359:	throw new ValueError('Argument #2 ($flags) must be a valid attribute filter flag');
360:	}
361:
362:	if ($name !== null && $flags !== 0) {
363:	$attributes = $this->betterReflectionMethod->getAttributesByInstance($name);
364:	} elseif ($name !== null) {
365:	$attributes = $this->betterReflectionMethod->getAttributesByName($name);
366:	} else {
367:	$attributes = $this->betterReflectionMethod->getAttributes();
368:	}
369:
370:	return array_map(static function (BetterReflectionAttribute $betterReflectionAttribute) {
371:	return ReflectionAttributeFactory::create($betterReflectionAttribute);
372:	}, $attributes);
373:	}
374:
375:	public function hasTentativeReturnType(): bool
376:	{
377:	return $this->betterReflectionMethod->hasTentativeReturnType();
378:	}
379:
380:	/** @return ReflectionUnionType\|ReflectionNamedType\|ReflectionIntersectionType\|null */
381:	public function getTentativeReturnType(): ?CoreReflectionType
382:	{
383:	return ReflectionType::fromTypeOrNull($this->betterReflectionMethod->getTentativeReturnType());
384:	}
385:
386:	/** @return mixed[] */
387:	public function getClosureUsedVariables(): array
388:	{
389:	throw new Exception\NotImplemented('Not implemented');
390:	}
391:
392:	/**
393:	* @return mixed
394:	*/
395:	public function __get(string $name)
396:	{
397:	if ($name === 'name') {
398:	return $this->betterReflectionMethod->getName();
399:	}
400:
401:	if ($name === 'class') {
402:	return $this->betterReflectionMethod->getImplementingClass()->getName();
403:	}
404:
405:	throw new OutOfBoundsException(sprintf('Property %s::$%s does not exist.', self::class, $name));
406:	}
407:
408:	public function getBetterReflection(): BetterReflectionMethod
409:	{
410:	return $this->betterReflectionMethod;
411:	}
412:	}
413:

Namespaces

Classes