|
1
|
|
|
<?php |
|
2
|
|
|
|
|
3
|
|
|
/** |
|
4
|
|
|
* This file is part of Railt package. |
|
5
|
|
|
* |
|
6
|
|
|
* For the full copyright and license information, please view the LICENSE |
|
7
|
|
|
* file that was distributed with this source code. |
|
8
|
|
|
* |
|
9
|
|
|
* @noinspection ALL |
|
10
|
|
|
*/ |
|
11
|
|
|
|
|
12
|
|
|
declare(strict_types=1); |
|
13
|
|
|
|
|
14
|
|
|
use Phplrt\Contracts\Lexer\TokenInterface; |
|
15
|
|
|
use Phplrt\Contracts\Grammar\RuleInterface; |
|
16
|
|
|
use Railt\SDL\Frontend\Ast; |
|
17
|
|
|
use Railt\TypeSystem\Value; |
|
18
|
|
|
|
|
19
|
|
|
return [ |
|
20
|
|
|
|
|
21
|
|
|
/** |
|
22
|
|
|
* ------------------------------------------------------------------------- |
|
23
|
|
|
* Initial State |
|
24
|
|
|
* ------------------------------------------------------------------------- |
|
25
|
|
|
* |
|
26
|
|
|
* The initial state (initial rule identifier) of the parser. |
|
27
|
|
|
* |
|
28
|
|
|
*/ |
|
29
|
|
|
'initial' => 0, |
|
30
|
|
|
|
|
31
|
|
|
/** |
|
32
|
|
|
* ------------------------------------------------------------------------- |
|
33
|
|
|
* Lexer Tokens |
|
34
|
|
|
* ------------------------------------------------------------------------- |
|
35
|
|
|
* |
|
36
|
|
|
* A GraphQL document is comprised of several kinds of indivisible |
|
37
|
|
|
* lexical tokens defined here in a lexical grammar by patterns |
|
38
|
|
|
* of source Unicode characters. |
|
39
|
|
|
* |
|
40
|
|
|
* Tokens are later used as terminal symbols in a GraphQL Document |
|
41
|
|
|
* syntactic grammars. |
|
42
|
|
|
* |
|
43
|
|
|
* @see https://graphql.github.io/graphql-spec/draft/#sec-Source-Text.Lexical-Tokens |
|
44
|
|
|
* @var string[] |
|
45
|
|
|
* |
|
46
|
|
|
*/ |
|
47
|
|
|
'lexemes' => [ |
|
48
|
|
|
'T_AND' => '&', |
|
49
|
|
|
'T_OR' => '\\|', |
|
50
|
|
|
'T_PARENTHESIS_OPEN' => '\\(', |
|
51
|
|
|
'T_PARENTHESIS_CLOSE' => '\\)', |
|
52
|
|
|
'T_BRACKET_OPEN' => '\\[', |
|
53
|
|
|
'T_BRACKET_CLOSE' => '\\]', |
|
54
|
|
|
'T_BRACE_OPEN' => '{', |
|
55
|
|
|
'T_BRACE_CLOSE' => '}', |
|
56
|
|
|
'T_ANGLE_OPEN' => '<', |
|
57
|
|
|
'T_ANGLE_CLOSE' => '>', |
|
58
|
|
|
'T_NON_NULL' => '!', |
|
59
|
|
|
'T_EQUAL' => '=', |
|
60
|
|
|
'T_DIRECTIVE_AT' => '@', |
|
61
|
|
|
'T_COLON' => ':', |
|
62
|
|
|
'T_COMMA' => ',', |
|
63
|
|
|
'T_FLOAT_EXP' => '\\-?(?:0|[1-9][0-9]*)(?:[eE][\\+\\-]?[0-9]+)', |
|
64
|
|
|
'T_FLOAT' => '\\-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)(?:[eE][\\+\\-]?[0-9]+)?', |
|
65
|
|
|
'T_INT' => '\\-?(?:0|[1-9][0-9]*)', |
|
66
|
|
|
'T_TRUE' => '(?<=\\b)true\\b', |
|
67
|
|
|
'T_FALSE' => '(?<=\\b)false\\b', |
|
68
|
|
|
'T_NULL' => '(?<=\\b)null\\b', |
|
69
|
|
|
'T_BLOCK_STRING' => '"""((?:\\\\"|(?!""").)*)"""', |
|
70
|
|
|
'T_STRING' => '"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"', |
|
71
|
|
|
'T_TYPE' => '(?<=\\b)type\\b', |
|
72
|
|
|
'T_ENUM' => '(?<=\\b)enum\\b', |
|
73
|
|
|
'T_UNION' => '(?<=\\b)union\\b', |
|
74
|
|
|
'T_INTERFACE' => '(?<=\\b)interface\\b', |
|
75
|
|
|
'T_SCHEMA' => '(?<=\\b)schema\\b', |
|
76
|
|
|
'T_SCALAR' => '(?<=\\b)scalar\\b', |
|
77
|
|
|
'T_DIRECTIVE' => '(?<=\\b)directive\\b', |
|
78
|
|
|
'T_INPUT' => '(?<=\\b)input\\b', |
|
79
|
|
|
'T_QUERY' => '(?<=\\b)query\\b', |
|
80
|
|
|
'T_MUTATION' => '(?<=\\b)mutation\\b', |
|
81
|
|
|
'T_ON' => '(?<=\\b)on\\b', |
|
82
|
|
|
'T_SUBSCRIPTION' => '(?<=\\b)subscription\\b', |
|
83
|
|
|
'T_EXTEND' => '(?<=\\b)extend\\b', |
|
84
|
|
|
'T_EXTENDS' => '(?<=\\b)extends\\b', |
|
85
|
|
|
'T_IN' => '(?<=\\b)in\\b', |
|
86
|
|
|
'T_OUT' => '(?<=\\b)out\\b', |
|
87
|
|
|
'T_PUBLIC' => '(?<=\\b)public\\b', |
|
88
|
|
|
'T_PRIVATE' => '(?<=\\b)private\\b', |
|
89
|
|
|
'T_IMPLEMENTS' => '(?<=\\b)implements\\b', |
|
90
|
|
|
'T_REPEATABLE' => '(?<=\\b)repeatable\\b', |
|
91
|
|
|
'T_VARIABLE' => '\\$([a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*)', |
|
92
|
|
|
'T_NAME' => '[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*', |
|
93
|
|
|
'T_COMMENT' => '#[^\\n]*', |
|
94
|
|
|
'T_BOM' => '\\x{FEFF}', |
|
95
|
|
|
'T_HTAB' => '\\x09+', |
|
96
|
|
|
'T_WHITESPACE' => '\\x20+', |
|
97
|
|
|
'T_LF' => '\\x0A+', |
|
98
|
|
|
'T_CR' => '\\x0D+', |
|
99
|
|
|
'T_INVISIBLE_WHITESPACES' => '(?:\\x{000B}|\\x{000C}|\\x{0085}|\\x{00A0}|\\x{1680}|[\\x{2000}-\\x{200A}]|\\x{2028}|\\x{2029}|\\x{202F}|\\x{205F}|\\x{3000})+', |
|
100
|
|
|
'T_INVISIBLE' => '(?:\\x{180E}|\\x{200B}|\\x{200C}|\\x{200D}|\\x{2060})+', |
|
101
|
|
|
], |
|
102
|
|
|
|
|
103
|
|
|
/** |
|
104
|
|
|
* ------------------------------------------------------------------------- |
|
105
|
|
|
* Lexer Ignored Tokens |
|
106
|
|
|
* ------------------------------------------------------------------------- |
|
107
|
|
|
* |
|
108
|
|
|
* Before and after every lexical token may be any amount of ignored tokens |
|
109
|
|
|
* including WhiteSpace and Comment. No ignored regions of a source document |
|
110
|
|
|
* are significant, however otherwise ignored source characters may appear |
|
111
|
|
|
* within a lexical token in a significant way, for example a StringValue |
|
112
|
|
|
* may contain white space characters and commas. |
|
113
|
|
|
* |
|
114
|
|
|
* @see https://graphql.github.io/graphql-spec/draft/#sec-Source-Text.Ignored-Tokens |
|
115
|
|
|
* @var string[] |
|
116
|
|
|
* |
|
117
|
|
|
*/ |
|
118
|
|
|
'skips' => [ |
|
119
|
|
|
'T_COMMENT', |
|
120
|
|
|
'T_BOM', |
|
121
|
|
|
'T_HTAB', |
|
122
|
|
|
'T_WHITESPACE', |
|
123
|
|
|
'T_LF', |
|
124
|
|
|
'T_CR', |
|
125
|
|
|
'T_INVISIBLE_WHITESPACES', |
|
126
|
|
|
'T_INVISIBLE', |
|
127
|
|
|
], |
|
128
|
|
|
|
|
129
|
|
|
/** |
|
130
|
|
|
* ------------------------------------------------------------------------- |
|
131
|
|
|
* Parser Grammar |
|
132
|
|
|
* ------------------------------------------------------------------------- |
|
133
|
|
|
* |
|
134
|
|
|
* Array of transition rules for the parser. |
|
135
|
|
|
* |
|
136
|
|
|
*/ |
|
137
|
|
|
'grammar' => [ |
|
138
|
|
|
1 => new \Phplrt\Grammar\Alternation([ |
|
139
|
|
|
6, |
|
140
|
|
|
7, |
|
141
|
|
|
8, |
|
142
|
|
|
9, |
|
143
|
|
|
10, |
|
144
|
|
|
11, |
|
145
|
|
|
12, |
|
146
|
|
|
13, |
|
147
|
|
|
14, |
|
148
|
|
|
15, |
|
149
|
|
|
16, |
|
150
|
|
|
17, |
|
151
|
|
|
18, |
|
152
|
|
|
19, |
|
153
|
|
|
20, |
|
154
|
|
|
21, |
|
155
|
|
|
22, |
|
156
|
|
|
23, |
|
157
|
|
|
24, |
|
158
|
|
|
25, |
|
159
|
|
|
26, |
|
160
|
|
|
27, |
|
161
|
|
|
28, |
|
162
|
|
|
29, |
|
163
|
|
|
]), |
|
164
|
|
|
2 => new \Phplrt\Grammar\Concatenation([ |
|
165
|
|
|
1, |
|
166
|
|
|
]), |
|
167
|
|
|
3 => new \Phplrt\Grammar\Concatenation([ |
|
168
|
|
|
33, |
|
169
|
|
|
30, |
|
170
|
|
|
34, |
|
171
|
|
|
35, |
|
172
|
|
|
]), |
|
173
|
|
|
4 => new \Phplrt\Grammar\Optional(3), |
|
174
|
|
|
5 => new \Phplrt\Grammar\Concatenation([ |
|
175
|
|
|
1, |
|
176
|
|
|
4, |
|
177
|
|
|
]), |
|
178
|
|
|
6 => new \Phplrt\Grammar\Lexeme('T_TRUE', true), |
|
179
|
|
|
7 => new \Phplrt\Grammar\Lexeme('T_FALSE', true), |
|
180
|
|
|
8 => new \Phplrt\Grammar\Lexeme('T_NULL', true), |
|
181
|
|
|
9 => new \Phplrt\Grammar\Lexeme('T_TYPE', true), |
|
182
|
|
|
10 => new \Phplrt\Grammar\Lexeme('T_ENUM', true), |
|
183
|
|
|
11 => new \Phplrt\Grammar\Lexeme('T_UNION', true), |
|
184
|
|
|
12 => new \Phplrt\Grammar\Lexeme('T_INTERFACE', true), |
|
185
|
|
|
13 => new \Phplrt\Grammar\Lexeme('T_SCHEMA', true), |
|
186
|
|
|
14 => new \Phplrt\Grammar\Lexeme('T_SCALAR', true), |
|
187
|
|
|
15 => new \Phplrt\Grammar\Lexeme('T_DIRECTIVE', true), |
|
188
|
|
|
16 => new \Phplrt\Grammar\Lexeme('T_INPUT', true), |
|
189
|
|
|
17 => new \Phplrt\Grammar\Lexeme('T_QUERY', true), |
|
190
|
|
|
18 => new \Phplrt\Grammar\Lexeme('T_MUTATION', true), |
|
191
|
|
|
19 => new \Phplrt\Grammar\Lexeme('T_ON', true), |
|
192
|
|
|
20 => new \Phplrt\Grammar\Lexeme('T_SUBSCRIPTION', true), |
|
193
|
|
|
21 => new \Phplrt\Grammar\Lexeme('T_EXTEND', true), |
|
194
|
|
|
22 => new \Phplrt\Grammar\Lexeme('T_EXTENDS', true), |
|
195
|
|
|
23 => new \Phplrt\Grammar\Lexeme('T_IN', true), |
|
196
|
|
|
24 => new \Phplrt\Grammar\Lexeme('T_OUT', true), |
|
197
|
|
|
25 => new \Phplrt\Grammar\Lexeme('T_PUBLIC', true), |
|
198
|
|
|
26 => new \Phplrt\Grammar\Lexeme('T_PRIVATE', true), |
|
199
|
|
|
27 => new \Phplrt\Grammar\Lexeme('T_IMPLEMENTS', true), |
|
200
|
|
|
28 => new \Phplrt\Grammar\Lexeme('T_REPEATABLE', true), |
|
201
|
|
|
29 => new \Phplrt\Grammar\Lexeme('T_NAME', true), |
|
202
|
|
|
30 => new \Phplrt\Grammar\Concatenation([ |
|
203
|
|
|
36, |
|
204
|
|
|
]), |
|
205
|
|
|
31 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
206
|
|
|
32 => new \Phplrt\Grammar\Concatenation([ |
|
207
|
|
|
31, |
|
208
|
|
|
30, |
|
209
|
|
|
]), |
|
210
|
|
|
33 => new \Phplrt\Grammar\Lexeme('T_ANGLE_OPEN', false), |
|
211
|
|
|
34 => new \Phplrt\Grammar\Repetition(32, 0, INF), |
|
212
|
|
|
35 => new \Phplrt\Grammar\Lexeme('T_ANGLE_CLOSE', false), |
|
213
|
|
|
36 => new \Phplrt\Grammar\Concatenation([ |
|
214
|
|
|
39, |
|
215
|
|
|
1, |
|
216
|
|
|
]), |
|
217
|
|
|
37 => new \Phplrt\Grammar\Lexeme('T_IN', false), |
|
218
|
|
|
38 => new \Phplrt\Grammar\Lexeme('T_OUT', false), |
|
219
|
|
|
39 => new \Phplrt\Grammar\Alternation([ |
|
220
|
|
|
37, |
|
221
|
|
|
38, |
|
222
|
|
|
]), |
|
223
|
|
|
40 => new \Phplrt\Grammar\Lexeme('T_IMPLEMENTS', false), |
|
224
|
|
|
41 => new \Phplrt\Grammar\Lexeme('T_EXTENDS', false), |
|
225
|
|
|
42 => new \Phplrt\Grammar\Concatenation([ |
|
226
|
|
|
1, |
|
227
|
|
|
55, |
|
228
|
|
|
]), |
|
229
|
|
|
43 => new \Phplrt\Grammar\Alternation([ |
|
230
|
|
|
40, |
|
231
|
|
|
41, |
|
232
|
|
|
]), |
|
233
|
|
|
44 => new \Phplrt\Grammar\Concatenation([ |
|
234
|
|
|
1, |
|
235
|
|
|
43, |
|
236
|
|
|
42, |
|
237
|
|
|
]), |
|
238
|
|
|
45 => new \Phplrt\Grammar\Alternation([ |
|
239
|
|
|
89, |
|
240
|
|
|
90, |
|
241
|
|
|
]), |
|
242
|
|
|
46 => new \Phplrt\Grammar\Optional(45), |
|
243
|
|
|
47 => new \Phplrt\Grammar\Concatenation([ |
|
244
|
|
|
52, |
|
245
|
|
|
53, |
|
246
|
|
|
]), |
|
247
|
|
|
48 => new \Phplrt\Grammar\Concatenation([ |
|
248
|
|
|
50, |
|
249
|
|
|
49, |
|
250
|
|
|
51, |
|
251
|
|
|
]), |
|
252
|
|
|
49 => new \Phplrt\Grammar\Alternation([ |
|
253
|
|
|
47, |
|
254
|
|
|
48, |
|
255
|
|
|
42, |
|
256
|
|
|
]), |
|
257
|
|
|
50 => new \Phplrt\Grammar\Lexeme('T_BRACKET_OPEN', false), |
|
258
|
|
|
51 => new \Phplrt\Grammar\Lexeme('T_BRACKET_CLOSE', false), |
|
259
|
|
|
52 => new \Phplrt\Grammar\Alternation([ |
|
260
|
|
|
48, |
|
261
|
|
|
42, |
|
262
|
|
|
]), |
|
263
|
|
|
53 => new \Phplrt\Grammar\Lexeme('T_NON_NULL', false), |
|
264
|
|
|
54 => new \Phplrt\Grammar\Concatenation([ |
|
265
|
|
|
59, |
|
266
|
|
|
42, |
|
267
|
|
|
60, |
|
268
|
|
|
61, |
|
269
|
|
|
]), |
|
270
|
|
|
55 => new \Phplrt\Grammar\Optional(54), |
|
271
|
|
|
56 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
272
|
|
|
57 => new \Phplrt\Grammar\Optional(56), |
|
273
|
|
|
58 => new \Phplrt\Grammar\Concatenation([ |
|
274
|
|
|
57, |
|
275
|
|
|
42, |
|
276
|
|
|
]), |
|
277
|
|
|
59 => new \Phplrt\Grammar\Lexeme('T_ANGLE_OPEN', false), |
|
278
|
|
|
60 => new \Phplrt\Grammar\Repetition(58, 0, INF), |
|
279
|
|
|
61 => new \Phplrt\Grammar\Lexeme('T_ANGLE_CLOSE', false), |
|
280
|
|
|
62 => new \Phplrt\Grammar\Lexeme('T_DIRECTIVE_AT', false), |
|
281
|
|
|
63 => new \Phplrt\Grammar\Concatenation([ |
|
282
|
|
|
62, |
|
283
|
|
|
1, |
|
284
|
|
|
]), |
|
285
|
|
|
64 => new \Phplrt\Grammar\Lexeme('T_FALSE', true), |
|
286
|
|
|
65 => new \Phplrt\Grammar\Lexeme('T_TRUE', true), |
|
287
|
|
|
66 => new \Phplrt\Grammar\Alternation([ |
|
288
|
|
|
64, |
|
289
|
|
|
65, |
|
290
|
|
|
]), |
|
291
|
|
|
67 => new \Phplrt\Grammar\Concatenation([ |
|
292
|
|
|
1, |
|
293
|
|
|
]), |
|
294
|
|
|
68 => new \Phplrt\Grammar\Lexeme('T_FLOAT', true), |
|
295
|
|
|
69 => new \Phplrt\Grammar\Lexeme('T_FLOAT_EXP', true), |
|
296
|
|
|
70 => new \Phplrt\Grammar\Alternation([ |
|
297
|
|
|
68, |
|
298
|
|
|
69, |
|
299
|
|
|
]), |
|
300
|
|
|
71 => new \Phplrt\Grammar\Lexeme('T_INT', true), |
|
301
|
|
|
72 => new \Phplrt\Grammar\Alternation([ |
|
302
|
|
|
91, |
|
303
|
|
|
92, |
|
304
|
|
|
79, |
|
305
|
|
|
88, |
|
306
|
|
|
]), |
|
307
|
|
|
73 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
308
|
|
|
74 => new \Phplrt\Grammar\Optional(73), |
|
309
|
|
|
75 => new \Phplrt\Grammar\Concatenation([ |
|
310
|
|
|
72, |
|
311
|
|
|
74, |
|
312
|
|
|
]), |
|
313
|
|
|
76 => new \Phplrt\Grammar\Lexeme('T_BRACKET_OPEN', false), |
|
314
|
|
|
77 => new \Phplrt\Grammar\Repetition(75, 0, INF), |
|
315
|
|
|
78 => new \Phplrt\Grammar\Lexeme('T_BRACKET_CLOSE', false), |
|
316
|
|
|
79 => new \Phplrt\Grammar\Concatenation([ |
|
317
|
|
|
76, |
|
318
|
|
|
77, |
|
319
|
|
|
78, |
|
320
|
|
|
]), |
|
321
|
|
|
80 => new \Phplrt\Grammar\Lexeme('T_NULL', true), |
|
322
|
|
|
81 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
323
|
|
|
82 => new \Phplrt\Grammar\Lexeme('T_COLON', false), |
|
324
|
|
|
83 => new \Phplrt\Grammar\Optional(81), |
|
325
|
|
|
84 => new \Phplrt\Grammar\Concatenation([ |
|
326
|
|
|
1, |
|
327
|
|
|
82, |
|
328
|
|
|
72, |
|
329
|
|
|
83, |
|
330
|
|
|
]), |
|
331
|
|
|
85 => new \Phplrt\Grammar\Lexeme('T_BRACE_OPEN', false), |
|
332
|
|
|
86 => new \Phplrt\Grammar\Repetition(84, 0, INF), |
|
333
|
|
|
87 => new \Phplrt\Grammar\Lexeme('T_BRACE_CLOSE', false), |
|
334
|
|
|
88 => new \Phplrt\Grammar\Concatenation([ |
|
335
|
|
|
85, |
|
336
|
|
|
86, |
|
337
|
|
|
87, |
|
338
|
|
|
]), |
|
339
|
|
|
89 => new \Phplrt\Grammar\Lexeme('T_BLOCK_STRING', true), |
|
340
|
|
|
90 => new \Phplrt\Grammar\Lexeme('T_STRING', true), |
|
341
|
|
|
91 => new \Phplrt\Grammar\Lexeme('T_VARIABLE', true), |
|
342
|
|
|
92 => new \Phplrt\Grammar\Alternation([ |
|
343
|
|
|
71, |
|
344
|
|
|
70, |
|
345
|
|
|
45, |
|
346
|
|
|
66, |
|
347
|
|
|
80, |
|
348
|
|
|
67, |
|
349
|
|
|
]), |
|
350
|
|
|
93 => new \Phplrt\Grammar\Concatenation([ |
|
351
|
|
|
117, |
|
352
|
|
|
119, |
|
353
|
|
|
]), |
|
354
|
|
|
94 => new \Phplrt\Grammar\Lexeme('T_EXTEND', false), |
|
355
|
|
|
95 => new \Phplrt\Grammar\Concatenation([ |
|
356
|
|
|
94, |
|
357
|
|
|
93, |
|
358
|
|
|
]), |
|
359
|
|
|
96 => new \Phplrt\Grammar\Concatenation([ |
|
360
|
|
|
188, |
|
361
|
|
|
190, |
|
362
|
|
|
]), |
|
363
|
|
|
97 => new \Phplrt\Grammar\Lexeme('T_EXTEND', false), |
|
364
|
|
|
98 => new \Phplrt\Grammar\Concatenation([ |
|
365
|
|
|
97, |
|
366
|
|
|
96, |
|
367
|
|
|
]), |
|
368
|
|
|
99 => new \Phplrt\Grammar\Concatenation([ |
|
369
|
|
|
197, |
|
370
|
|
|
199, |
|
371
|
|
|
]), |
|
372
|
|
|
100 => new \Phplrt\Grammar\Lexeme('T_EXTEND', false), |
|
373
|
|
|
101 => new \Phplrt\Grammar\Concatenation([ |
|
374
|
|
|
100, |
|
375
|
|
|
99, |
|
376
|
|
|
]), |
|
377
|
|
|
102 => new \Phplrt\Grammar\Concatenation([ |
|
378
|
|
|
207, |
|
379
|
|
|
209, |
|
380
|
|
|
]), |
|
381
|
|
|
103 => new \Phplrt\Grammar\Lexeme('T_EXTEND', false), |
|
382
|
|
|
104 => new \Phplrt\Grammar\Concatenation([ |
|
383
|
|
|
103, |
|
384
|
|
|
102, |
|
385
|
|
|
]), |
|
386
|
|
|
105 => new \Phplrt\Grammar\Concatenation([ |
|
387
|
|
|
225, |
|
388
|
|
|
227, |
|
389
|
|
|
]), |
|
390
|
|
|
106 => new \Phplrt\Grammar\Lexeme('T_EXTEND', false), |
|
391
|
|
|
107 => new \Phplrt\Grammar\Concatenation([ |
|
392
|
|
|
106, |
|
393
|
|
|
105, |
|
394
|
|
|
]), |
|
395
|
|
|
108 => new \Phplrt\Grammar\Concatenation([ |
|
396
|
|
|
235, |
|
397
|
|
|
]), |
|
398
|
|
|
109 => new \Phplrt\Grammar\Lexeme('T_EXTEND', false), |
|
399
|
|
|
110 => new \Phplrt\Grammar\Concatenation([ |
|
400
|
|
|
109, |
|
401
|
|
|
108, |
|
402
|
|
|
]), |
|
403
|
|
|
111 => new \Phplrt\Grammar\Concatenation([ |
|
404
|
|
|
239, |
|
405
|
|
|
241, |
|
406
|
|
|
]), |
|
407
|
|
|
112 => new \Phplrt\Grammar\Lexeme('T_EXTEND', false), |
|
408
|
|
|
113 => new \Phplrt\Grammar\Concatenation([ |
|
409
|
|
|
112, |
|
410
|
|
|
111, |
|
411
|
|
|
]), |
|
412
|
|
|
114 => new \Phplrt\Grammar\Alternation([ |
|
413
|
|
|
110, |
|
414
|
|
|
107, |
|
415
|
|
|
104, |
|
416
|
|
|
113, |
|
417
|
|
|
98, |
|
418
|
|
|
101, |
|
419
|
|
|
]), |
|
420
|
|
|
115 => new \Phplrt\Grammar\Alternation([ |
|
421
|
|
|
95, |
|
422
|
|
|
114, |
|
423
|
|
|
]), |
|
424
|
|
|
116 => new \Phplrt\Grammar\Concatenation([ |
|
425
|
|
|
46, |
|
426
|
|
|
93, |
|
427
|
|
|
]), |
|
428
|
|
|
117 => new \Phplrt\Grammar\Concatenation([ |
|
429
|
|
|
121, |
|
430
|
|
|
122, |
|
431
|
|
|
]), |
|
432
|
|
|
118 => new \Phplrt\Grammar\Concatenation([ |
|
433
|
|
|
127, |
|
434
|
|
|
128, |
|
435
|
|
|
129, |
|
436
|
|
|
]), |
|
437
|
|
|
119 => new \Phplrt\Grammar\Optional(118), |
|
438
|
|
|
120 => new \Phplrt\Grammar\Concatenation([ |
|
439
|
|
|
63, |
|
440
|
|
|
255, |
|
441
|
|
|
]), |
|
442
|
|
|
121 => new \Phplrt\Grammar\Lexeme('T_SCHEMA', false), |
|
443
|
|
|
122 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
444
|
|
|
123 => new \Phplrt\Grammar\Concatenation([ |
|
445
|
|
|
130, |
|
446
|
|
|
131, |
|
447
|
|
|
42, |
|
448
|
|
|
]), |
|
449
|
|
|
124 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
450
|
|
|
125 => new \Phplrt\Grammar\Optional(124), |
|
451
|
|
|
126 => new \Phplrt\Grammar\Concatenation([ |
|
452
|
|
|
123, |
|
453
|
|
|
125, |
|
454
|
|
|
]), |
|
455
|
|
|
127 => new \Phplrt\Grammar\Lexeme('T_BRACE_OPEN', false), |
|
456
|
|
|
128 => new \Phplrt\Grammar\Repetition(126, 0, INF), |
|
457
|
|
|
129 => new \Phplrt\Grammar\Lexeme('T_BRACE_CLOSE', false), |
|
458
|
|
|
130 => new \Phplrt\Grammar\Alternation([ |
|
459
|
|
|
132, |
|
460
|
|
|
133, |
|
461
|
|
|
134, |
|
462
|
|
|
]), |
|
463
|
|
|
131 => new \Phplrt\Grammar\Lexeme('T_COLON', false), |
|
464
|
|
|
132 => new \Phplrt\Grammar\Lexeme('T_QUERY', true), |
|
465
|
|
|
133 => new \Phplrt\Grammar\Lexeme('T_MUTATION', true), |
|
466
|
|
|
134 => new \Phplrt\Grammar\Lexeme('T_SUBSCRIPTION', true), |
|
467
|
|
|
135 => new \Phplrt\Grammar\Concatenation([ |
|
468
|
|
|
140, |
|
469
|
|
|
141, |
|
470
|
|
|
1, |
|
471
|
|
|
142, |
|
472
|
|
|
143, |
|
473
|
|
|
]), |
|
474
|
|
|
136 => new \Phplrt\Grammar\Concatenation([ |
|
475
|
|
|
149, |
|
476
|
|
|
148, |
|
477
|
|
|
]), |
|
478
|
|
|
137 => new \Phplrt\Grammar\Concatenation([ |
|
479
|
|
|
46, |
|
480
|
|
|
135, |
|
481
|
|
|
136, |
|
482
|
|
|
]), |
|
483
|
|
|
138 => new \Phplrt\Grammar\Concatenation([ |
|
484
|
|
|
145, |
|
485
|
|
|
146, |
|
486
|
|
|
147, |
|
487
|
|
|
]), |
|
488
|
|
|
139 => new \Phplrt\Grammar\Lexeme('T_REPEATABLE', true), |
|
489
|
|
|
140 => new \Phplrt\Grammar\Lexeme('T_DIRECTIVE', false), |
|
490
|
|
|
141 => new \Phplrt\Grammar\Lexeme('T_DIRECTIVE_AT', false), |
|
491
|
|
|
142 => new \Phplrt\Grammar\Optional(138), |
|
492
|
|
|
143 => new \Phplrt\Grammar\Optional(139), |
|
493
|
|
|
144 => new \Phplrt\Grammar\Concatenation([ |
|
494
|
|
|
46, |
|
495
|
|
|
155, |
|
496
|
|
|
158, |
|
497
|
|
|
159, |
|
498
|
|
|
160, |
|
499
|
|
|
]), |
|
500
|
|
|
145 => new \Phplrt\Grammar\Lexeme('T_PARENTHESIS_OPEN', false), |
|
501
|
|
|
146 => new \Phplrt\Grammar\Repetition(144, 0, INF), |
|
502
|
|
|
147 => new \Phplrt\Grammar\Lexeme('T_PARENTHESIS_CLOSE', false), |
|
503
|
|
|
148 => new \Phplrt\Grammar\Concatenation([ |
|
504
|
|
|
153, |
|
505
|
|
|
1, |
|
506
|
|
|
154, |
|
507
|
|
|
]), |
|
508
|
|
|
149 => new \Phplrt\Grammar\Lexeme('T_ON', false), |
|
509
|
|
|
150 => new \Phplrt\Grammar\Lexeme('T_OR', false), |
|
510
|
|
|
151 => new \Phplrt\Grammar\Lexeme('T_OR', false), |
|
511
|
|
|
152 => new \Phplrt\Grammar\Concatenation([ |
|
512
|
|
|
151, |
|
513
|
|
|
1, |
|
514
|
|
|
]), |
|
515
|
|
|
153 => new \Phplrt\Grammar\Optional(150), |
|
516
|
|
|
154 => new \Phplrt\Grammar\Repetition(152, 0, INF), |
|
517
|
|
|
155 => new \Phplrt\Grammar\Concatenation([ |
|
518
|
|
|
1, |
|
519
|
|
|
161, |
|
520
|
|
|
49, |
|
521
|
|
|
]), |
|
522
|
|
|
156 => new \Phplrt\Grammar\Concatenation([ |
|
523
|
|
|
162, |
|
524
|
|
|
72, |
|
525
|
|
|
]), |
|
526
|
|
|
157 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
527
|
|
|
158 => new \Phplrt\Grammar\Optional(156), |
|
528
|
|
|
159 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
529
|
|
|
160 => new \Phplrt\Grammar\Optional(157), |
|
530
|
|
|
161 => new \Phplrt\Grammar\Lexeme('T_COLON', false), |
|
531
|
|
|
162 => new \Phplrt\Grammar\Lexeme('T_EQUAL', false), |
|
532
|
|
|
163 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
533
|
|
|
164 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
534
|
|
|
165 => new \Phplrt\Grammar\Optional(163), |
|
535
|
|
|
166 => new \Phplrt\Grammar\Concatenation([ |
|
536
|
|
|
46, |
|
537
|
|
|
1, |
|
538
|
|
|
164, |
|
539
|
|
|
165, |
|
540
|
|
|
]), |
|
541
|
|
|
167 => new \Phplrt\Grammar\Concatenation([ |
|
542
|
|
|
46, |
|
543
|
|
|
1, |
|
544
|
|
|
171, |
|
545
|
|
|
172, |
|
546
|
|
|
49, |
|
547
|
|
|
173, |
|
548
|
|
|
174, |
|
549
|
|
|
]), |
|
550
|
|
|
168 => new \Phplrt\Grammar\Repetition(167, 1, INF), |
|
551
|
|
|
169 => new \Phplrt\Grammar\Concatenation([ |
|
552
|
|
|
175, |
|
553
|
|
|
176, |
|
554
|
|
|
177, |
|
555
|
|
|
]), |
|
556
|
|
|
170 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
557
|
|
|
171 => new \Phplrt\Grammar\Optional(169), |
|
558
|
|
|
172 => new \Phplrt\Grammar\Lexeme('T_COLON', false), |
|
559
|
|
|
173 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
560
|
|
|
174 => new \Phplrt\Grammar\Optional(170), |
|
561
|
|
|
175 => new \Phplrt\Grammar\Lexeme('T_PARENTHESIS_OPEN', false), |
|
562
|
|
|
176 => new \Phplrt\Grammar\Repetition(144, 0, INF), |
|
563
|
|
|
177 => new \Phplrt\Grammar\Lexeme('T_PARENTHESIS_CLOSE', false), |
|
564
|
|
|
178 => new \Phplrt\Grammar\Concatenation([ |
|
565
|
|
|
1, |
|
566
|
|
|
185, |
|
567
|
|
|
49, |
|
568
|
|
|
]), |
|
569
|
|
|
179 => new \Phplrt\Grammar\Concatenation([ |
|
570
|
|
|
186, |
|
571
|
|
|
72, |
|
572
|
|
|
]), |
|
573
|
|
|
180 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
574
|
|
|
181 => new \Phplrt\Grammar\Optional(179), |
|
575
|
|
|
182 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
576
|
|
|
183 => new \Phplrt\Grammar\Optional(180), |
|
577
|
|
|
184 => new \Phplrt\Grammar\Concatenation([ |
|
578
|
|
|
46, |
|
579
|
|
|
178, |
|
580
|
|
|
181, |
|
581
|
|
|
182, |
|
582
|
|
|
183, |
|
583
|
|
|
]), |
|
584
|
|
|
185 => new \Phplrt\Grammar\Lexeme('T_COLON', false), |
|
585
|
|
|
186 => new \Phplrt\Grammar\Lexeme('T_EQUAL', false), |
|
586
|
|
|
187 => new \Phplrt\Grammar\Concatenation([ |
|
587
|
|
|
46, |
|
588
|
|
|
96, |
|
589
|
|
|
]), |
|
590
|
|
|
188 => new \Phplrt\Grammar\Concatenation([ |
|
591
|
|
|
191, |
|
592
|
|
|
2, |
|
593
|
|
|
192, |
|
594
|
|
|
]), |
|
595
|
|
|
189 => new \Phplrt\Grammar\Concatenation([ |
|
596
|
|
|
193, |
|
597
|
|
|
194, |
|
598
|
|
|
195, |
|
599
|
|
|
]), |
|
600
|
|
|
190 => new \Phplrt\Grammar\Optional(189), |
|
601
|
|
|
191 => new \Phplrt\Grammar\Lexeme('T_ENUM', false), |
|
602
|
|
|
192 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
603
|
|
|
193 => new \Phplrt\Grammar\Lexeme('T_BRACE_OPEN', false), |
|
604
|
|
|
194 => new \Phplrt\Grammar\Repetition(166, 0, INF), |
|
605
|
|
|
195 => new \Phplrt\Grammar\Lexeme('T_BRACE_CLOSE', false), |
|
606
|
|
|
196 => new \Phplrt\Grammar\Concatenation([ |
|
607
|
|
|
46, |
|
608
|
|
|
99, |
|
609
|
|
|
]), |
|
610
|
|
|
197 => new \Phplrt\Grammar\Concatenation([ |
|
611
|
|
|
200, |
|
612
|
|
|
5, |
|
613
|
|
|
201, |
|
614
|
|
|
]), |
|
615
|
|
|
198 => new \Phplrt\Grammar\Concatenation([ |
|
616
|
|
|
202, |
|
617
|
|
|
203, |
|
618
|
|
|
204, |
|
619
|
|
|
]), |
|
620
|
|
|
199 => new \Phplrt\Grammar\Optional(198), |
|
621
|
|
|
200 => new \Phplrt\Grammar\Lexeme('T_INPUT', false), |
|
622
|
|
|
201 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
623
|
|
|
202 => new \Phplrt\Grammar\Lexeme('T_BRACE_OPEN', false), |
|
624
|
|
|
203 => new \Phplrt\Grammar\Repetition(184, 0, INF), |
|
625
|
|
|
204 => new \Phplrt\Grammar\Lexeme('T_BRACE_CLOSE', false), |
|
626
|
|
|
205 => new \Phplrt\Grammar\Optional(46), |
|
627
|
|
|
206 => new \Phplrt\Grammar\Concatenation([ |
|
628
|
|
|
205, |
|
629
|
|
|
102, |
|
630
|
|
|
]), |
|
631
|
|
|
207 => new \Phplrt\Grammar\Concatenation([ |
|
632
|
|
|
211, |
|
633
|
|
|
5, |
|
634
|
|
|
212, |
|
635
|
|
|
213, |
|
636
|
|
|
]), |
|
637
|
|
|
208 => new \Phplrt\Grammar\Concatenation([ |
|
638
|
|
|
214, |
|
639
|
|
|
215, |
|
640
|
|
|
216, |
|
641
|
|
|
]), |
|
642
|
|
|
209 => new \Phplrt\Grammar\Optional(208), |
|
643
|
|
|
210 => new \Phplrt\Grammar\Concatenation([ |
|
644
|
|
|
219, |
|
645
|
|
|
220, |
|
646
|
|
|
42, |
|
647
|
|
|
221, |
|
648
|
|
|
]), |
|
649
|
|
|
211 => new \Phplrt\Grammar\Lexeme('T_INTERFACE', false), |
|
650
|
|
|
212 => new \Phplrt\Grammar\Optional(210), |
|
651
|
|
|
213 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
652
|
|
|
214 => new \Phplrt\Grammar\Lexeme('T_BRACE_OPEN', false), |
|
653
|
|
|
215 => new \Phplrt\Grammar\Optional(168), |
|
654
|
|
|
216 => new \Phplrt\Grammar\Lexeme('T_BRACE_CLOSE', false), |
|
655
|
|
|
217 => new \Phplrt\Grammar\Alternation([ |
|
656
|
|
|
222, |
|
657
|
|
|
223, |
|
658
|
|
|
]), |
|
659
|
|
|
218 => new \Phplrt\Grammar\Concatenation([ |
|
660
|
|
|
217, |
|
661
|
|
|
42, |
|
662
|
|
|
]), |
|
663
|
|
|
219 => new \Phplrt\Grammar\Lexeme('T_IMPLEMENTS', false), |
|
664
|
|
|
220 => new \Phplrt\Grammar\Optional(217), |
|
665
|
|
|
221 => new \Phplrt\Grammar\Repetition(218, 0, INF), |
|
666
|
|
|
222 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
667
|
|
|
223 => new \Phplrt\Grammar\Lexeme('T_AND', false), |
|
668
|
|
|
224 => new \Phplrt\Grammar\Concatenation([ |
|
669
|
|
|
46, |
|
670
|
|
|
105, |
|
671
|
|
|
]), |
|
672
|
|
|
225 => new \Phplrt\Grammar\Concatenation([ |
|
673
|
|
|
228, |
|
674
|
|
|
5, |
|
675
|
|
|
229, |
|
676
|
|
|
230, |
|
677
|
|
|
]), |
|
678
|
|
|
226 => new \Phplrt\Grammar\Concatenation([ |
|
679
|
|
|
231, |
|
680
|
|
|
232, |
|
681
|
|
|
233, |
|
682
|
|
|
]), |
|
683
|
|
|
227 => new \Phplrt\Grammar\Optional(226), |
|
684
|
|
|
228 => new \Phplrt\Grammar\Lexeme('T_TYPE', false), |
|
685
|
|
|
229 => new \Phplrt\Grammar\Optional(210), |
|
686
|
|
|
230 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
687
|
|
|
231 => new \Phplrt\Grammar\Lexeme('T_BRACE_OPEN', false), |
|
688
|
|
|
232 => new \Phplrt\Grammar\Optional(168), |
|
689
|
|
|
233 => new \Phplrt\Grammar\Lexeme('T_BRACE_CLOSE', false), |
|
690
|
|
|
234 => new \Phplrt\Grammar\Concatenation([ |
|
691
|
|
|
46, |
|
692
|
|
|
108, |
|
693
|
|
|
]), |
|
694
|
|
|
235 => new \Phplrt\Grammar\Concatenation([ |
|
695
|
|
|
236, |
|
696
|
|
|
2, |
|
697
|
|
|
237, |
|
698
|
|
|
]), |
|
699
|
|
|
236 => new \Phplrt\Grammar\Lexeme('T_SCALAR', false), |
|
700
|
|
|
237 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
701
|
|
|
238 => new \Phplrt\Grammar\Concatenation([ |
|
702
|
|
|
46, |
|
703
|
|
|
111, |
|
704
|
|
|
]), |
|
705
|
|
|
239 => new \Phplrt\Grammar\Concatenation([ |
|
706
|
|
|
242, |
|
707
|
|
|
2, |
|
708
|
|
|
243, |
|
709
|
|
|
]), |
|
710
|
|
|
240 => new \Phplrt\Grammar\Concatenation([ |
|
711
|
|
|
245, |
|
712
|
|
|
246, |
|
713
|
|
|
]), |
|
714
|
|
|
241 => new \Phplrt\Grammar\Optional(240), |
|
715
|
|
|
242 => new \Phplrt\Grammar\Lexeme('T_UNION', false), |
|
716
|
|
|
243 => new \Phplrt\Grammar\Repetition(120, 0, INF), |
|
717
|
|
|
244 => new \Phplrt\Grammar\Concatenation([ |
|
718
|
|
|
250, |
|
719
|
|
|
42, |
|
720
|
|
|
251, |
|
721
|
|
|
]), |
|
722
|
|
|
245 => new \Phplrt\Grammar\Lexeme('T_EQUAL', false), |
|
723
|
|
|
246 => new \Phplrt\Grammar\Optional(244), |
|
724
|
|
|
247 => new \Phplrt\Grammar\Lexeme('T_OR', false), |
|
725
|
|
|
248 => new \Phplrt\Grammar\Lexeme('T_OR', false), |
|
726
|
|
|
249 => new \Phplrt\Grammar\Concatenation([ |
|
727
|
|
|
248, |
|
728
|
|
|
42, |
|
729
|
|
|
]), |
|
730
|
|
|
250 => new \Phplrt\Grammar\Optional(247), |
|
731
|
|
|
251 => new \Phplrt\Grammar\Repetition(249, 0, INF), |
|
732
|
|
|
252 => new \Phplrt\Grammar\Alternation([ |
|
733
|
|
|
234, |
|
734
|
|
|
224, |
|
735
|
|
|
206, |
|
736
|
|
|
238, |
|
737
|
|
|
187, |
|
738
|
|
|
196, |
|
739
|
|
|
]), |
|
740
|
|
|
253 => new \Phplrt\Grammar\Alternation([ |
|
741
|
|
|
116, |
|
742
|
|
|
137, |
|
743
|
|
|
252, |
|
744
|
|
|
]), |
|
745
|
|
|
254 => new \Phplrt\Grammar\Concatenation([ |
|
746
|
|
|
260, |
|
747
|
|
|
261, |
|
748
|
|
|
262, |
|
749
|
|
|
]), |
|
750
|
|
|
255 => new \Phplrt\Grammar\Optional(254), |
|
751
|
|
|
257 => new \Phplrt\Grammar\Lexeme('T_COMMA', false), |
|
752
|
|
|
258 => new \Phplrt\Grammar\Optional(257), |
|
753
|
|
|
259 => new \Phplrt\Grammar\Concatenation([ |
|
754
|
|
|
256, |
|
755
|
|
|
258, |
|
756
|
|
|
]), |
|
757
|
|
|
260 => new \Phplrt\Grammar\Lexeme('T_PARENTHESIS_OPEN', false), |
|
758
|
|
|
261 => new \Phplrt\Grammar\Repetition(259, 0, INF), |
|
759
|
|
|
262 => new \Phplrt\Grammar\Lexeme('T_PARENTHESIS_CLOSE', false), |
|
760
|
|
|
263 => new \Phplrt\Grammar\Lexeme('T_COLON', false), |
|
761
|
|
|
256 => new \Phplrt\Grammar\Concatenation([ |
|
762
|
|
|
1, |
|
763
|
|
|
263, |
|
764
|
|
|
72, |
|
765
|
|
|
]), |
|
766
|
|
|
0 => new \Phplrt\Grammar\Repetition(264, 0, INF), |
|
767
|
|
|
264 => new \Phplrt\Grammar\Alternation([ |
|
768
|
|
|
253, |
|
769
|
|
|
115, |
|
770
|
|
|
]) |
|
771
|
|
|
], |
|
772
|
|
|
|
|
773
|
|
|
/** |
|
774
|
|
|
* ------------------------------------------------------------------------- |
|
775
|
|
|
* Parser Reducers |
|
776
|
|
|
* ------------------------------------------------------------------------- |
|
777
|
|
|
* |
|
778
|
|
|
* Array of abstract syntax tree reducers. |
|
779
|
|
|
* |
|
780
|
|
|
*/ |
|
781
|
|
|
'reducers' => [ |
|
782
|
|
|
2 => static function ($children) { |
|
783
|
|
|
return Ast\TypeName::create($children); |
|
784
|
|
|
}, |
|
785
|
|
|
5 => static function ($children) { |
|
786
|
|
|
return Ast\TypeName::create($children); |
|
787
|
|
|
}, |
|
788
|
|
|
1 => static function ($children) { |
|
789
|
|
|
return Ast\Identifier::create($children); |
|
790
|
|
|
}, |
|
791
|
|
|
46 => static function ($children) { |
|
792
|
|
|
return Ast\Description::create($children ?: null); |
|
793
|
|
|
}, |
|
794
|
|
|
48 => static function ($children) { |
|
795
|
|
|
return Ast\Type\ListTypeNode::create($children); |
|
796
|
|
|
}, |
|
797
|
|
|
47 => static function ($children) { |
|
798
|
|
|
return Ast\Type\NonNullTypeNode::create($children); |
|
799
|
|
|
}, |
|
800
|
|
|
42 => static function ($children) { |
|
801
|
|
|
return Ast\Type\NamedTypeNode::create($children); |
|
802
|
|
|
}, |
|
803
|
|
|
63 => static function ($children) { |
|
804
|
|
|
return Ast\Type\NamedDirectiveNode::create($children); |
|
805
|
|
|
}, |
|
806
|
|
|
66 => static function ($children) { |
|
807
|
|
|
return Value\BooleanValue::parse($children->getName() === 'T_TRUE'); |
|
808
|
|
|
}, |
|
809
|
|
|
67 => static function ($children) { |
|
810
|
|
|
return Value\EnumValue::parse($children[0]->value); |
|
811
|
|
|
}, |
|
812
|
|
|
70 => static function ($children) { |
|
813
|
|
|
return Value\FloatValue::parse($children->getValue()); |
|
814
|
|
|
}, |
|
815
|
|
|
71 => static function ($children) { |
|
816
|
|
|
return Value\IntValue::parse($children->getValue()); |
|
817
|
|
|
}, |
|
818
|
|
|
79 => static function ($children) { |
|
819
|
|
|
return Value\ListValue::parse($children); |
|
|
|
|
|
|
820
|
|
|
}, |
|
821
|
|
|
80 => static function ($children) { |
|
|
|
|
|
|
822
|
|
|
return Value\NullValue::parse(null); |
|
823
|
|
|
}, |
|
824
|
|
|
88 => static function ($children) { |
|
825
|
|
|
$result = []; |
|
826
|
|
|
|
|
827
|
|
|
for ($i = 0, $count = \count((array)$children); $i < $count; $i += 2) { |
|
828
|
|
|
$result[$children[$i]->value] = $children[$i + 1]; |
|
829
|
|
|
} |
|
830
|
|
|
|
|
831
|
|
|
return Value\InputObjectValue::parse($result); |
|
832
|
|
|
}, |
|
833
|
|
|
89 => static function ($children) { |
|
834
|
|
|
return Value\StringValue::parse(\substr($children->getValue(), 3, -3)); |
|
835
|
|
|
}, |
|
836
|
|
|
90 => static function ($children) { |
|
837
|
|
|
return Value\StringValue::parse(\substr($children->getValue(), 1, -1)); |
|
838
|
|
|
}, |
|
839
|
|
|
91 => static function ($children) { |
|
840
|
|
|
return Ast\Value\VariableValueNode::parse($children[0]->getValue()); |
|
841
|
|
|
}, |
|
842
|
|
|
95 => static function ($children) { |
|
843
|
|
|
return Ast\Extension\SchemaExtensionNode::create($children); |
|
844
|
|
|
}, |
|
845
|
|
|
98 => static function ($children) { |
|
846
|
|
|
return Ast\Extension\Type\EnumTypeExtensionNode::create($children); |
|
847
|
|
|
}, |
|
848
|
|
|
101 => static function ($children) { |
|
849
|
|
|
return Ast\Extension\Type\InputObjectTypeExtensionNode::create($children); |
|
850
|
|
|
}, |
|
851
|
|
|
104 => static function ($children) { |
|
852
|
|
|
return Ast\Extension\Type\InterfaceTypeExtensionNode::create($children); |
|
853
|
|
|
}, |
|
854
|
|
|
107 => static function ($children) { |
|
855
|
|
|
return Ast\Extension\Type\ObjectTypeExtensionNode::create($children); |
|
856
|
|
|
}, |
|
857
|
|
|
110 => static function ($children) { |
|
858
|
|
|
return Ast\Extension\Type\ScalarTypeExtensionNode::create($children); |
|
859
|
|
|
}, |
|
860
|
|
|
113 => static function ($children) { |
|
861
|
|
|
return Ast\Extension\Type\UnionTypeExtensionNode::create($children); |
|
862
|
|
|
}, |
|
863
|
|
|
116 => static function ($children) { |
|
864
|
|
|
return Ast\Definition\SchemaDefinitionNode::create($children); |
|
865
|
|
|
}, |
|
866
|
|
|
123 => static function ($children) { |
|
867
|
|
|
return Ast\Definition\OperationTypeDefinitionNode::create($children); |
|
868
|
|
|
}, |
|
869
|
|
|
137 => static function ($children) { |
|
870
|
|
|
return Ast\Definition\DirectiveDefinitionNode::create($children); |
|
871
|
|
|
}, |
|
872
|
|
|
139 => static function ($children) { |
|
|
|
|
|
|
873
|
|
|
return Ast\Definition\DirectiveDefinitionIsRepeatableNode::create(); |
|
874
|
|
|
}, |
|
875
|
|
|
148 => static function ($children) { |
|
876
|
|
|
return Ast\Definition\DirectiveDefinitionLocationNode::create($children); |
|
|
|
|
|
|
877
|
|
|
}, |
|
878
|
|
|
144 => static function ($children) { |
|
879
|
|
|
return Ast\Definition\ArgumentDefinitionNode::create($children); |
|
880
|
|
|
}, |
|
881
|
|
|
166 => static function ($children) { |
|
882
|
|
|
return Ast\Definition\EnumValueDefinitionNode::create($children); |
|
883
|
|
|
}, |
|
884
|
|
|
167 => static function ($children) { |
|
885
|
|
|
return Ast\Definition\FieldDefinitionNode::create($children); |
|
886
|
|
|
}, |
|
887
|
|
|
184 => static function ($children) { |
|
888
|
|
|
return Ast\Definition\InputFieldDefinitionNode::create($children); |
|
889
|
|
|
}, |
|
890
|
|
|
187 => static function ($children) { |
|
891
|
|
|
return Ast\Definition\Type\EnumTypeDefinitionNode::create($children); |
|
892
|
|
|
}, |
|
893
|
|
|
196 => static function ($children) { |
|
894
|
|
|
return Ast\Definition\Type\InputObjectTypeDefinitionNode::create($children); |
|
895
|
|
|
}, |
|
896
|
|
|
206 => static function ($children) { |
|
897
|
|
|
return Ast\Definition\Type\InterfaceTypeDefinitionNode::create($children); |
|
898
|
|
|
}, |
|
899
|
|
|
210 => static function ($children) { |
|
900
|
|
|
return Ast\Definition\Type\ImplementedInterfaceNode::create($children); |
|
|
|
|
|
|
901
|
|
|
}, |
|
902
|
|
|
224 => static function ($children) { |
|
903
|
|
|
return Ast\Definition\Type\ObjectTypeDefinitionNode::create($children); |
|
904
|
|
|
}, |
|
905
|
|
|
234 => static function ($children) { |
|
906
|
|
|
return Ast\Definition\Type\ScalarTypeDefinitionNode::create($children); |
|
907
|
|
|
}, |
|
908
|
|
|
238 => static function ($children) { |
|
909
|
|
|
return Ast\Definition\Type\UnionTypeDefinitionNode::create($children); |
|
910
|
|
|
}, |
|
911
|
|
|
244 => static function ($children) { |
|
912
|
|
|
return Ast\Definition\Type\UnionMemberNode::create($children); |
|
|
|
|
|
|
913
|
|
|
}, |
|
914
|
|
|
120 => static function ($children) { |
|
915
|
|
|
return Ast\Executable\DirectiveNode::create($children); |
|
916
|
|
|
}, |
|
917
|
|
|
256 => static function ($children) { |
|
918
|
|
|
return Ast\Executable\ArgumentNode::create($children); |
|
919
|
|
|
} |
|
920
|
|
|
], |
|
921
|
|
|
|
|
922
|
|
|
]; |
railt /
sdl
Loading history...
The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g.
excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths