wpide / vendor / nikic / php-parser / lib / PhpParser / BuilderFactory.php

BuilderFactory.php in WPIDE – File Manager & Code Editor 3.5.9, at vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php

400 lines 10.9 KB

Raw Download Zip

1	<?php declare(strict_types=1);
2
3	namespace PhpParser;
4
5	use PhpParser\Node\Arg;
6	use PhpParser\Node\Expr;
7	use PhpParser\Node\Expr\BinaryOp\Concat;
8	use PhpParser\Node\Identifier;
9	use PhpParser\Node\Name;
10	use PhpParser\Node\Scalar\String_;
11	use PhpParser\Node\Stmt\Use_;
12
13	class BuilderFactory
14	{
15	/**
16	* Creates an attribute node.
17	*
18	* @param string\|Name $name Name of the attribute
19	* @param array $args Attribute named arguments
20	*
21	* @return Node\Attribute
22	*/
23	public function attribute($name, array $args = []) : Node\Attribute {
24	return new Node\Attribute(
25	BuilderHelpers::normalizeName($name),
26	$this->args($args)
27	);
28	}
29
30	/**
31	* Creates a namespace builder.
32	*
33	* @param null\|string\|Node\Name $name Name of the namespace
34	*
35	* @return Builder\Namespace_ The created namespace builder
36	*/
37	public function namespace($name) : Builder\Namespace_ {
38	return new Builder\Namespace_($name);
39	}
40
41	/**
42	* Creates a class builder.
43	*
44	* @param string $name Name of the class
45	*
46	* @return Builder\Class_ The created class builder
47	*/
48	public function class(string $name) : Builder\Class_ {
49	return new Builder\Class_($name);
50	}
51
52	/**
53	* Creates an interface builder.
54	*
55	* @param string $name Name of the interface
56	*
57	* @return Builder\Interface_ The created interface builder
58	*/
59	public function interface(string $name) : Builder\Interface_ {
60	return new Builder\Interface_($name);
61	}
62
63	/**
64	* Creates a trait builder.
65	*
66	* @param string $name Name of the trait
67	*
68	* @return Builder\Trait_ The created trait builder
69	*/
70	public function trait(string $name) : Builder\Trait_ {
71	return new Builder\Trait_($name);
72	}
73
74	/**
75	* Creates an enum builder.
76	*
77	* @param string $name Name of the enum
78	*
79	* @return Builder\Enum_ The created enum builder
80	*/
81	public function enum(string $name) : Builder\Enum_ {
82	return new Builder\Enum_($name);
83	}
84
85	/**
86	* Creates a trait use builder.
87	*
88	* @param Node\Name\|string ...$traits Trait names
89	*
90	* @return Builder\TraitUse The create trait use builder
91	*/
92	public function useTrait(...$traits) : Builder\TraitUse {
93	return new Builder\TraitUse(...$traits);
94	}
95
96	/**
97	* Creates a trait use adaptation builder.
98	*
99	* @param Node\Name\|string\|null $trait Trait name
100	* @param Node\Identifier\|string $method Method name
101	*
102	* @return Builder\TraitUseAdaptation The create trait use adaptation builder
103	*/
104	public function traitUseAdaptation($trait, $method = null) : Builder\TraitUseAdaptation {
105	if ($method === null) {
106	$method = $trait;
107	$trait = null;
108	}
109
110	return new Builder\TraitUseAdaptation($trait, $method);
111	}
112
113	/**
114	* Creates a method builder.
115	*
116	* @param string $name Name of the method
117	*
118	* @return Builder\Method The created method builder
119	*/
120	public function method(string $name) : Builder\Method {
121	return new Builder\Method($name);
122	}
123
124	/**
125	* Creates a parameter builder.
126	*
127	* @param string $name Name of the parameter
128	*
129	* @return Builder\Param The created parameter builder
130	*/
131	public function param(string $name) : Builder\Param {
132	return new Builder\Param($name);
133	}
134
135	/**
136	* Creates a property builder.
137	*
138	* @param string $name Name of the property
139	*
140	* @return Builder\Property The created property builder
141	*/
142	public function property(string $name) : Builder\Property {
143	return new Builder\Property($name);
144	}
145
146	/**
147	* Creates a function builder.
148	*
149	* @param string $name Name of the function
150	*
151	* @return Builder\Function_ The created function builder
152	*/
153	public function function(string $name) : Builder\Function_ {
154	return new Builder\Function_($name);
155	}
156
157	/**
158	* Creates a namespace/class use builder.
159	*
160	* @param Node\Name\|string $name Name of the entity (namespace or class) to alias
161	*
162	* @return Builder\Use_ The created use builder
163	*/
164	public function use($name) : Builder\Use_ {
165	return new Builder\Use_($name, Use_::TYPE_NORMAL);
166	}
167
168	/**
169	* Creates a function use builder.
170	*
171	* @param Node\Name\|string $name Name of the function to alias
172	*
173	* @return Builder\Use_ The created use function builder
174	*/
175	public function useFunction($name) : Builder\Use_ {
176	return new Builder\Use_($name, Use_::TYPE_FUNCTION);
177	}
178
179	/**
180	* Creates a constant use builder.
181	*
182	* @param Node\Name\|string $name Name of the const to alias
183	*
184	* @return Builder\Use_ The created use const builder
185	*/
186	public function useConst($name) : Builder\Use_ {
187	return new Builder\Use_($name, Use_::TYPE_CONSTANT);
188	}
189
190	/**
191	* Creates a class constant builder.
192	*
193	* @param string\|Identifier $name Name
194	* @param Node\Expr\|bool\|null\|int\|float\|string\|array $value Value
195	*
196	* @return Builder\ClassConst The created use const builder
197	*/
198	public function classConst($name, $value) : Builder\ClassConst {
199	return new Builder\ClassConst($name, $value);
200	}
201
202	/**
203	* Creates an enum case builder.
204	*
205	* @param string\|Identifier $name Name
206	*
207	* @return Builder\EnumCase The created use const builder
208	*/
209	public function enumCase($name) : Builder\EnumCase {
210	return new Builder\EnumCase($name);
211	}
212
213	/**
214	* Creates node a for a literal value.
215	*
216	* @param Expr\|bool\|null\|int\|float\|string\|array\|\UnitEnum $value $value
217	*
218	* @return Expr
219	*/
220	public function val($value) : Expr {
221	return BuilderHelpers::normalizeValue($value);
222	}
223
224	/**
225	* Creates variable node.
226	*
227	* @param string\|Expr $name Name
228	*
229	* @return Expr\Variable
230	*/
231	public function var($name) : Expr\Variable {
232	if (!\is_string($name) && !$name instanceof Expr) {
233	throw new \LogicException('Variable name must be string or Expr');
234	}
235
236	return new Expr\Variable($name);
237	}
238
239	/**
240	* Normalizes an argument list.
241	*
242	* Creates Arg nodes for all arguments and converts literal values to expressions.
243	*
244	* @param array $args List of arguments to normalize
245	*
246	* @return Arg[]
247	*/
248	public function args(array $args) : array {
249	$normalizedArgs = [];
250	foreach ($args as $key => $arg) {
251	if (!($arg instanceof Arg)) {
252	$arg = new Arg(BuilderHelpers::normalizeValue($arg));
253	}
254	if (\is_string($key)) {
255	$arg->name = BuilderHelpers::normalizeIdentifier($key);
256	}
257	$normalizedArgs[] = $arg;
258	}
259	return $normalizedArgs;
260	}
261
262	/**
263	* Creates a function call node.
264	*
265	* @param string\|Name\|Expr $name Function name
266	* @param array $args Function arguments
267	*
268	* @return Expr\FuncCall
269	*/
270	public function funcCall($name, array $args = []) : Expr\FuncCall {
271	return new Expr\FuncCall(
272	BuilderHelpers::normalizeNameOrExpr($name),
273	$this->args($args)
274	);
275	}
276
277	/**
278	* Creates a method call node.
279	*
280	* @param Expr $var Variable the method is called on
281	* @param string\|Identifier\|Expr $name Method name
282	* @param array $args Method arguments
283	*
284	* @return Expr\MethodCall
285	*/
286	public function methodCall(Expr $var, $name, array $args = []) : Expr\MethodCall {
287	return new Expr\MethodCall(
288	$var,
289	BuilderHelpers::normalizeIdentifierOrExpr($name),
290	$this->args($args)
291	);
292	}
293
294	/**
295	* Creates a static method call node.
296	*
297	* @param string\|Name\|Expr $class Class name
298	* @param string\|Identifier\|Expr $name Method name
299	* @param array $args Method arguments
300	*
301	* @return Expr\StaticCall
302	*/
303	public function staticCall($class, $name, array $args = []) : Expr\StaticCall {
304	return new Expr\StaticCall(
305	BuilderHelpers::normalizeNameOrExpr($class),
306	BuilderHelpers::normalizeIdentifierOrExpr($name),
307	$this->args($args)
308	);
309	}
310
311	/**
312	* Creates an object creation node.
313	*
314	* @param string\|Name\|Expr $class Class name
315	* @param array $args Constructor arguments
316	*
317	* @return Expr\New_
318	*/
319	public function new($class, array $args = []) : Expr\New_ {
320	return new Expr\New_(
321	BuilderHelpers::normalizeNameOrExpr($class),
322	$this->args($args)
323	);
324	}
325
326	/**
327	* Creates a constant fetch node.
328	*
329	* @param string\|Name $name Constant name
330	*
331	* @return Expr\ConstFetch
332	*/
333	public function constFetch($name) : Expr\ConstFetch {
334	return new Expr\ConstFetch(BuilderHelpers::normalizeName($name));
335	}
336
337	/**
338	* Creates a property fetch node.
339	*
340	* @param Expr $var Variable holding object
341	* @param string\|Identifier\|Expr $name Property name
342	*
343	* @return Expr\PropertyFetch
344	*/
345	public function propertyFetch(Expr $var, $name) : Expr\PropertyFetch {
346	return new Expr\PropertyFetch($var, BuilderHelpers::normalizeIdentifierOrExpr($name));
347	}
348
349	/**
350	* Creates a class constant fetch node.
351	*
352	* @param string\|Name\|Expr $class Class name
353	* @param string\|Identifier\|Expr $name Constant name
354	*
355	* @return Expr\ClassConstFetch
356	*/
357	public function classConstFetch($class, $name): Expr\ClassConstFetch {
358	return new Expr\ClassConstFetch(
359	BuilderHelpers::normalizeNameOrExpr($class),
360	BuilderHelpers::normalizeIdentifierOrExpr($name)
361	);
362	}
363
364	/**
365	* Creates nested Concat nodes from a list of expressions.
366	*
367	* @param Expr\|string ...$exprs Expressions or literal strings
368	*
369	* @return Concat
370	*/
371	public function concat(...$exprs) : Concat {
372	$numExprs = count($exprs);
373	if ($numExprs < 2) {
374	throw new \LogicException('Expected at least two expressions');
375	}
376
377	$lastConcat = $this->normalizeStringExpr($exprs[0]);
378	for ($i = 1; $i < $numExprs; $i++) {
379	$lastConcat = new Concat($lastConcat, $this->normalizeStringExpr($exprs[$i]));
380	}
381	return $lastConcat;
382	}
383
384	/**
385	* @param string\|Expr $expr
386	* @return Expr
387	*/
388	private function normalizeStringExpr($expr) : Expr {
389	if ($expr instanceof Expr) {
390	return $expr;
391	}
392
393	if (\is_string($expr)) {
394	return new String_($expr);
395	}
396
397	throw new \LogicException('Expected string or Expr');
398	}
399	}
400