packages/deriver/tests/Unit/Deriver/Evaluator/Execution/Control/IterationStepTest.php

1<?php
2
3declare (strict_types=1);
4
5namespace Tests\Unit\Deriver\Evaluator\Execution\Control;
6
7use Deriver\Deriver;
8use Deriver\Deriver\Candidate\ResultRef;
9use Deriver\Deriver\Candidate\Snapshot;
10use Deriver\Deriver\Candidate\Statistics;
11use Deriver\Deriver\Contributions;
12use Deriver\Deriver\DeriverConfig;
13use Deriver\Deriver\Evaluator\Builtin\TypePredicates;
14use Deriver\Deriver\Evaluator\Call\BoundInstruction;
15use Deriver\Deriver\Evaluator\Call\Evaluators;
16use Deriver\Deriver\Evaluator\Call\Extensions;
17use Deriver\Deriver\Evaluator\Call\Registrations;
18use Deriver\Deriver\Evaluator\Call\StateRegistry;
19use Deriver\Deriver\Evaluator\EvaluatorConfig;
20use Deriver\Deriver\Evaluator\Evidence\Frontier;
21use Deriver\Deriver\Evaluator\Execution\Call\ArgumentBinding;
22use Deriver\Deriver\Evaluator\Execution\Call\ArgumentOrder;
23use Deriver\Deriver\Evaluator\Execution\Call\TypeBinding;
24use Deriver\Deriver\Evaluator\Execution\Call\TypeCheck;
25use Deriver\Deriver\Evaluator\Execution\Completion\Alternative;
26use Deriver\Deriver\Evaluator\Execution\Completion\Assessment;
27use Deriver\Deriver\Evaluator\Execution\Completion\Completion;
28use Deriver\Deriver\Evaluator\Execution\Completion\StorageSnapshot;
29use Deriver\Deriver\Evaluator\Execution\Constraints;
30use Deriver\Deriver\Evaluator\Execution\Context;
31use Deriver\Deriver\Evaluator\Execution\Control\IterationStep;
32use Deriver\Deriver\Evaluator\Execution\Control\IteratorCursor;
33use Deriver\Deriver\Evaluator\Execution\Control\LoopConvergence;
34use Deriver\Deriver\Evaluator\Execution\Control\ObservationLimit;
35use Deriver\Deriver\Evaluator\Execution\Control\StateJoin;
36use Deriver\Deriver\Evaluator\Execution\Control\Unwinding;
37use Deriver\Deriver\Evaluator\Execution\Demand\Discovery;
38use Deriver\Deriver\Evaluator\Execution\Dependencies;
39use Deriver\Deriver\Evaluator\Execution\Evaluator;
40use Deriver\Deriver\Evaluator\Execution\EvaluatorConfig as ExecutionEvaluatorConfig;
41use Deriver\Deriver\Evaluator\Execution\Havoc;
42use Deriver\Deriver\Evaluator\Execution\InstructionTransfer;
43use Deriver\Deriver\Evaluator\Execution\Memory\LiveArray;
44use Deriver\Deriver\Evaluator\Execution\Memory\Location;
45use Deriver\Deriver\Evaluator\Execution\Memory\Materialization;
46use Deriver\Deriver\Evaluator\Execution\Memory\Memory;
47use Deriver\Deriver\Evaluator\Execution\Memory\ReferenceConstraint;
48use Deriver\Deriver\Evaluator\Execution\Memory\Slots\SlotReference;
49use Deriver\Deriver\Evaluator\Execution\Memory\StorageCapture;
50use Deriver\Deriver\Evaluator\Execution\ObservationCollector;
51use Deriver\Deriver\Evaluator\Execution\Operation\Conversions;
52use Deriver\Deriver\Evaluator\Execution\Operation\ScalarErrors;
53use Deriver\Deriver\Evaluator\Execution\State;
54use Deriver\Deriver\Evaluator\Execution\Summary\Evaluation;
55use Deriver\Deriver\Evaluator\Execution\Summary\Isolation;
56use Deriver\Deriver\Evaluator\Execution\Trace\Derivation;
57use Deriver\Deriver\Evaluator\Execution\Transfer\MemoryStep;
58use Deriver\Deriver\Evaluator\Execution\Transfer\PureStep;
59use Deriver\Deriver\Evaluator\Execution\Transfer\ReferenceAssignment;
60use Deriver\Deriver\Evaluator\Request\Budget;
61use Deriver\Deriver\Evaluator\Request\EntryPoint;
62use Deriver\Deriver\Evaluator\Request\QueryScope;
63use Deriver\Deriver\Evaluator\Request\ReturnQuery;
64use Deriver\Deriver\Evaluator\Scalar\Arrays;
65use Deriver\Deriver\Evaluator\Scalar\Identity;
66use Deriver\Deriver\Evaluator\Scalar\Operations;
67use Deriver\Deriver\Evaluator\TargetProfile;
68use Deriver\Deriver\Evaluator\Term;
69use Deriver\Deriver\Evaluator\TermKind;
70use Deriver\Deriver\Execution\DerivationResult;
71use Deriver\Deriver\Execution\QueryExecution;
72use Deriver\Deriver\Execution\ResultAssessment;
73use Deriver\Deriver\Identity\QueryEncoding;
74use Deriver\Deriver\Identity\ValueGraph;
75use Deriver\Deriver\Lowerer\AggregateLowering;
76use Deriver\Deriver\Lowerer\AssignmentLowering;
77use Deriver\Deriver\Lowerer\Control\DestructuringLowering;
78use Deriver\Deriver\Lowerer\Control\LoopLowering;
79use Deriver\Deriver\Lowerer\Declaration\CallableIdentity;
80use Deriver\Deriver\Lowerer\Declaration\CallableSource;
81use Deriver\Deriver\Lowerer\Declaration\Index;
82use Deriver\Deriver\Lowerer\Declaration\Indexer;
83use Deriver\Deriver\Lowerer\Declaration\Traits\Composition;
84use Deriver\Deriver\Lowerer\ExpressionLowering;
85use Deriver\Deriver\Lowerer\Graph\BasicBlock;
86use Deriver\Deriver\Lowerer\Graph\CallableGraph;
87use Deriver\Deriver\Lowerer\Graph\Instruction;
88use Deriver\Deriver\Lowerer\Graph\Terminator;
89use Deriver\Deriver\Lowerer\Hierarchy\Dispatch;
90use Deriver\Deriver\Lowerer\InstructionEmitter;
91use Deriver\Deriver\Lowerer\Lowerer;
92use Deriver\Deriver\Lowerer\LoweringScope;
93use Deriver\Deriver\Lowerer\StatementLowering;
94use Deriver\Deriver\MicroEvaluatorConversion;
95use Deriver\Deriver\Parser\Node\File;
96use Deriver\Deriver\Parser\Parser;
97use Deriver\Deriver\Parser\ParserConfig;
98use Deriver\Deriver\Parser\TargetSyntax;
99use Deriver\Deriver\Providers\ProviderExpansion;
100use Deriver\Deriver\Resolver\AssignmentPatterns;
101use Deriver\Deriver\Resolver\ClassScope;
102use Deriver\Deriver\Resolver\ExpressionValidation;
103use Deriver\Deriver\Resolver\MagicContext;
104use Deriver\Deriver\Resolver\Resolver;
105use Deriver\Deriver\Selection\QueryValidation;
106use Deriver\Deriver\SnapshotIdentity;
107use Deriver\Deriver\Sources\LineMap;
108use Deriver\Deriver\Sources\Path;
109use Deriver\Deriver\Sources\Source;
110use Deriver\Deriver\Sources\SourceRef;
111use Deriver\Deriver\Sources\Sources;
112use Deriver\Exception\ParserException;
113use Deriver\Exception\ResolutionException;
114use PHPUnit\Framework\Attributes\CoversClass;
115use PHPUnit\Framework\Attributes\DataProvider;
116use PHPUnit\Framework\Attributes\Small;
117use PHPUnit\Framework\Attributes\UsesClass;
118use PHPUnit\Framework\TestCase;
119
120#[UsesClass(Resolver::class)]
121#[UsesClass(ExpressionValidation::class)]
122#[UsesClass(ResolutionException::class)]
123#[UsesClass(ParserConfig::class)]
124#[UsesClass(ParserException::class)]
125#[CoversClass(IterationStep::class)]
126#[UsesClass(QueryExecution::class)]
127#[UsesClass(QueryValidation::class)]
128#[UsesClass(ResultAssessment::class)]
129#[UsesClass(Deriver::class)]
130#[UsesClass(Constraints::class)]
131#[UsesClass(BasicBlock::class)]
132#[UsesClass(CallableGraph::class)]
133#[UsesClass(CallableIdentity::class)]
134#[UsesClass(Instruction::class)]
135#[UsesClass(Terminator::class)]
136#[UsesClass(ArgumentBinding::class)]
137#[UsesClass(ArgumentOrder::class)]
138#[UsesClass(Dispatch::class)]
139#[UsesClass(TypeBinding::class)]
140#[UsesClass(TypeCheck::class)]
141#[UsesClass(Completion::class)]
142#[UsesClass(Context::class)]
143#[UsesClass(IteratorCursor::class)]
144#[UsesClass(LoopConvergence::class)]
145#[UsesClass(ObservationLimit::class)]
146#[UsesClass(StateJoin::class)]
147#[UsesClass(Unwinding::class)]
148#[UsesClass(Discovery::class)]
149#[UsesClass(Dependencies::class)]
150#[UsesClass(InstructionTransfer::class)]
151#[UsesClass(Evaluator::class)]
152#[UsesClass(SlotReference::class)]
153#[UsesClass(ObservationCollector::class)]
154#[UsesClass(Conversions::class)]
155#[UsesClass(ScalarErrors::class)]
156#[UsesClass(State::class)]
157#[UsesClass(Evaluation::class)]
158#[UsesClass(Isolation::class)]
159#[UsesClass(MemoryStep::class)]
160#[UsesClass(PureStep::class)]
161#[UsesClass(ReferenceAssignment::class)]
162#[UsesClass(LiveArray::class)]
163#[UsesClass(Location::class)]
164#[UsesClass(Materialization::class)]
165#[UsesClass(Memory::class)]
166#[UsesClass(ReferenceConstraint::class)]
167#[UsesClass(StorageCapture::class)]
168#[UsesClass(TypePredicates::class)]
169#[UsesClass(Extensions::class)]
170#[UsesClass(ProviderExpansion::class)]
171#[UsesClass(Evaluators::class)]
172#[UsesClass(StateRegistry::class)]
173#[UsesClass(DeriverConfig::class)]
174#[UsesClass(EntryPoint::class)]
175#[UsesClass(Sources::class)]
176#[UsesClass(Path::class)]
177#[UsesClass(Snapshot::class)]
178#[UsesClass(Source::class)]
179#[UsesClass(TargetProfile::class)]
180#[UsesClass(Budget::class)]
181#[UsesClass(QueryScope::class)]
182#[UsesClass(ReturnQuery::class)]
183#[UsesClass(ResultRef::class)]
184#[UsesClass(SourceRef::class)]
185#[UsesClass(Alternative::class)]
186#[UsesClass(Assessment::class)]
187#[UsesClass(Frontier::class)]
188#[UsesClass(Derivation::class)]
189#[UsesClass(DerivationResult::class)]
190#[UsesClass(QueryEncoding::class)]
191#[UsesClass(ValueGraph::class)]
192#[UsesClass(Statistics::class)]
193#[UsesClass(StorageSnapshot::class)]
194#[UsesClass(Parser::class)]
195#[UsesClass(File::class)]
196#[UsesClass(AggregateLowering::class)]
197#[UsesClass(AssignmentLowering::class)]
198#[UsesClass(Lowerer::class)]
199#[UsesClass(DestructuringLowering::class)]
200#[UsesClass(LoopLowering::class)]
201#[UsesClass(ExpressionLowering::class)]
202#[UsesClass(InstructionEmitter::class)]
203#[UsesClass(LoweringScope::class)]
204#[UsesClass(StatementLowering::class)]
205#[UsesClass(CallableSource::class)]
206#[UsesClass(Indexer::class)]
207#[UsesClass(Index::class)]
208#[UsesClass(Composition::class)]
209#[UsesClass(LineMap::class)]
210#[UsesClass(MagicContext::class)]
211#[UsesClass(AssignmentPatterns::class)]
212#[UsesClass(ClassScope::class)]
213#[UsesClass(TargetSyntax::class)]
214#[UsesClass(Havoc::class)]
215#[UsesClass(TypePredicates::class)]
216#[UsesClass(Arrays::class)]
217#[UsesClass(Identity::class)]
218#[UsesClass(Operations::class)]
219#[UsesClass(Term::class)]
220#[Small]
221final class IterationStepTest extends TestCase
222{
223    public function testEvaluatePreservesTheSemanticContract(): void
224    {
225        $source = '<?php function target(){ $a=[1,2,3];foreach($a as &$x){}$x=4;unset($x);$x=5;return $a;}';
226        $symbol = 'target';
227        $input = new Sources([new Source('fixture.php', $source)]);
228        $configuration = new DeriverConfig();
229        $contributions = new Contributions();
230        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
231        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
232        $contributions1 = $providers->contributions;
233        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
234        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
235        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
236        $snapshotId = $identity->id;
237        $input1 = $providers->input;
238        $parser = new Parser(new ParserConfig($target->version));
239        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
240        $program = new Index($snapshotId, $trees);
241        $result = (new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics()))))->derive(new ReturnQuery($symbol));
242        self::assertSame([1, 2, 4], $result->normalOutcomes[0]->values['return']->native());
243        self::assertSame([], $result->frontiers);
244        self::assertSame([], $result->exceptionalOutcomes);
245    }
246    public function testInitializePinsTheArrayCellForLiveTraversal(): void
247    {
248        $state = new State();
249        $state->addresses['array'] = $state->memory->allocate(Term::fromNative([1, 2]));
250        $instruction = new BoundInstruction('i', 'iterator', new SourceRef('test', 'a.php', 0, 1), 'it', ['array'], attributes: ['byReference' => true]);
251        $source = '<?php function target(){return 1;}';
252        $budget = new Budget();
253        $configuration = new DeriverConfig();
254        $contributions = new Contributions();
255        $input = new Sources([new Source('fixture.php', $source)]);
256        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
257        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
258        $contributions1 = $providers->contributions;
259        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
260        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
261        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
262        $snapshotId = $identity->id;
263        $input1 = $providers->input;
264        $parser = new Parser(new ParserConfig($target->version));
265        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
266        $program1 = new Index($snapshotId, $trees);
267        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
268        $snapshotId1 = 'test';
269        $input2 = new Sources([new Source('fixture.php', $source)]);
270        $profile = $execution->configuration->target;
271        $parser1 = new Parser(new ParserConfig($profile->version));
272        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
273        $program = new Index($snapshotId1, $trees1);
274        $iterator = (new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)))->initialize($instruction, $state);
275        self::assertCount(1, $state->memory->liveArrays);
276        self::assertSame(TermKind::Iterator, $iterator->kind);
277    }
278    #[DataProvider('providerCursorReads')]
279    public function testEvaluateReadsCursorValuesAndKeys(string $operation, mixed $expected): void
280    {
281        $state = new State();
282        $state->registers['it'] = new Term(TermKind::Iterator, 'cursor');
283        $array = new Term(TermKind::Array, operands: ['first' => Term::constant(10), 'second' => Term::constant(20)], attributes: ['open' => false]);
284        $state->iterators['cursor'] = new IteratorCursor($array, position: 1);
285        $instruction = new BoundInstruction('i', $operation, new SourceRef('test', 'a.php', 0, 1), 'result', ['it']);
286        $source = '<?php function target(){return 1;}';
287        $budget = new Budget();
288        $configuration = new DeriverConfig();
289        $contributions = new Contributions();
290        $input = new Sources([new Source('fixture.php', $source)]);
291        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
292        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
293        $contributions1 = $providers->contributions;
294        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
295        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
296        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
297        $snapshotId = $identity->id;
298        $input1 = $providers->input;
299        $parser = new Parser(new ParserConfig($target->version));
300        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
301        $program1 = new Index($snapshotId, $trees);
302        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
303        $snapshotId1 = 'test';
304        $input2 = new Sources([new Source('fixture.php', $source)]);
305        $profile = $execution->configuration->target;
306        $parser1 = new Parser(new ParserConfig($profile->version));
307        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
308        $program = new Index($snapshotId1, $trees1);
309        $result = (new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)))->evaluate($instruction, $state);
310        self::assertSame($expected, $result->native());
311        self::assertSame(1, $state->iterators['cursor']->position);
312    }
313    /**
314     * @return iterable<string,array{string,int|string}>
315     */
316    public static function providerCursorReads(): iterable
317    {
318        yield 'public value' => ['iterator-value', 20];
319        yield 'public key' => ['iterator-key', 'second'];
320    }
321    #[DataProvider('providerIterationAdvancement')]
322    public function testEvaluateAdvancesExactlyOnePositionAndReportsAvailability(int $position, bool $expected): void
323    {
324        $state = new State();
325        $state->registers['it'] = new Term(TermKind::Iterator, 'cursor');
326        $array = new Term(TermKind::Array, operands: ['first' => Term::constant(10)], attributes: ['open' => false]);
327        $state->iterators['cursor'] = new IteratorCursor($array, position: $position);
328        $instruction = new BoundInstruction('i', 'iterate', new SourceRef('test', 'a.php', 0, 1), 'result', ['it']);
329        $source = '<?php function target(){return 1;}';
330        $budget = new Budget();
331        $configuration = new DeriverConfig();
332        $contributions = new Contributions();
333        $input = new Sources([new Source('fixture.php', $source)]);
334        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
335        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
336        $contributions1 = $providers->contributions;
337        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
338        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
339        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
340        $snapshotId = $identity->id;
341        $input1 = $providers->input;
342        $parser = new Parser(new ParserConfig($target->version));
343        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
344        $program1 = new Index($snapshotId, $trees);
345        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
346        $snapshotId1 = 'test';
347        $input2 = new Sources([new Source('fixture.php', $source)]);
348        $profile = $execution->configuration->target;
349        $parser1 = new Parser(new ParserConfig($profile->version));
350        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
351        $program = new Index($snapshotId1, $trees1);
352        $result = (new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)))->evaluate($instruction, $state);
353        self::assertSame($expected, $result->native());
354        self::assertSame($position + 1, $state->iterators['cursor']->position);
355        self::assertSame($array, $state->iterators['cursor']->array);
356    }
357    /**
358     * @return iterable<string,array{int,bool}>
359     */
360    public static function providerIterationAdvancement(): iterable
361    {
362        yield 'entry' => [-1, true];
363        yield 'exhausted' => [0, false];
364    }
365    #[DataProvider('providerUnknownIteration')]
366    public function testEvaluateKeepsUnknownIterableAvailabilitySymbolic(Term $array): void
367    {
368        $state = new State();
369        $state->registers['it'] = new Term(TermKind::Iterator, 'cursor');
370        $state->iterators['cursor'] = new IteratorCursor($array);
371        $instruction = new BoundInstruction('i', 'iterate', new SourceRef('test', 'a.php', 0, 1), 'result', ['it']);
372        $source = '<?php function target(){return 1;}';
373        $budget = new Budget();
374        $configuration = new DeriverConfig();
375        $contributions = new Contributions();
376        $input = new Sources([new Source('fixture.php', $source)]);
377        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
378        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
379        $contributions1 = $providers->contributions;
380        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
381        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
382        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
383        $snapshotId = $identity->id;
384        $input1 = $providers->input;
385        $parser = new Parser(new ParserConfig($target->version));
386        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
387        $program1 = new Index($snapshotId, $trees);
388        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
389        $snapshotId1 = 'test';
390        $input2 = new Sources([new Source('fixture.php', $source)]);
391        $profile = $execution->configuration->target;
392        $parser1 = new Parser(new ParserConfig($profile->version));
393        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
394        $program = new Index($snapshotId1, $trees1);
395        $result = (new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)))->evaluate($instruction, $state);
396        self::assertSame(TermKind::External, $result->kind);
397        self::assertSame('cursor:has-next:0', $result->literal);
398        self::assertSame(['type' => 'bool'], $result->attributes);
399        self::assertSame(0, $state->iterators['cursor']->position);
400    }
401    /**
402     * @return iterable<string,array{Term}>
403     */
404    public static function providerUnknownIteration(): iterable
405    {
406        yield 'unknown' => [Term::parameter('items', 'iterable')];
407        yield 'open' => [Term::array([], true)];
408    }
409    public function testEvaluateNeverReadsOperandsOfSymbolicIterablesAsEntries(): void
410    {
411        $state = new State();
412        $state->registers['it'] = new Term(TermKind::Iterator, 'cursor');
413        $state->iterators['cursor'] = new IteratorCursor(new Term(TermKind::Intrinsic, 'explode', [Term::constant(','), Term::parameter('s', 'string')], ['type' => 'array']), position: 0);
414        $source1 = '<?php function target(){return 1;}';
415        $budget = new Budget();
416        $configuration = new DeriverConfig();
417        $contributions = new Contributions();
418        $input = new Sources([new Source('fixture.php', $source1)]);
419        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
420        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
421        $contributions1 = $providers->contributions;
422        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
423        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
424        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
425        $snapshotId = $identity->id;
426        $input1 = $providers->input;
427        $parser = new Parser(new ParserConfig($target->version));
428        $trees = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input1, false));
429        $program1 = new Index($snapshotId, $trees);
430        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
431        $snapshotId1 = 'test';
432        $input2 = new Sources([new Source('fixture.php', $source1)]);
433        $profile = $execution->configuration->target;
434        $parser1 = new Parser(new ParserConfig($profile->version));
435        $trees1 = array_map(static fn (Source $source3): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source3->path), $source3->contents, $source3->declarationsOnly))), iterator_to_array($input2, false));
436        $program = new Index($snapshotId1, $trees1);
437        $step = new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators));
438        $source = new SourceRef('test', 'a.php', 0, 1);
439        self::assertSame('UNKNOWN_ITERABLE', $step->evaluate(new BoundInstruction('i', 'iterator-value', $source, 'value', ['it']), $state)->literal);
440        self::assertSame('UNKNOWN_ITERABLE', $step->evaluate(new BoundInstruction('i', 'iterator-key', $source, 'key', ['it']), $state)->literal);
441    }
442    public function testAdvanceStoresTheCursorAndReportsKnownHeadEntries(): void
443    {
444        $state = new State();
445        $merge = new Term(TermKind::ArrayMerge, operands: [Term::fromNative(['id']), Term::parameter('x', 'array')], attributes: ['type' => 'array']);
446        $cursor = new IteratorCursor($merge, position: 0);
447        $source = '<?php function target(){return 1;}';
448        $budget = new Budget();
449        $configuration = new DeriverConfig();
450        $contributions = new Contributions();
451        $input = new Sources([new Source('fixture.php', $source)]);
452        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
453        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
454        $contributions1 = $providers->contributions;
455        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
456        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
457        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
458        $snapshotId = $identity->id;
459        $input1 = $providers->input;
460        $parser = new Parser(new ParserConfig($target->version));
461        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
462        $program1 = new Index($snapshotId, $trees);
463        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
464        $snapshotId1 = 'test';
465        $input2 = new Sources([new Source('fixture.php', $source)]);
466        $profile = $execution->configuration->target;
467        $parser1 = new Parser(new ParserConfig($profile->version));
468        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
469        $program = new Index($snapshotId1, $trees1);
470        $step = new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators));
471        self::assertTrue($step->advance('cursor', $cursor, Term::fromNative(['id']), $state)->native());
472        self::assertSame($cursor, $state->iterators['cursor']);
473        self::assertSame(TermKind::External, $step->advance('cursor', new IteratorCursor($merge, position: 1), Term::fromNative(['id']), $state)->kind);
474    }
475    #[DataProvider('providerMergeHeads')]
476    public function testEvaluateVisitsTheKnownHeadOfAMergeBeforeItsUnknownSource(int $position, string $operation, string $kind, mixed $expected): void
477    {
478        $state = new State();
479        $state->registers['it'] = new Term(TermKind::Iterator, 'cursor');
480        $merge = new Term(TermKind::ArrayMerge, operands: [Term::fromNative(['id', 'name']), Term::parameter('x', 'array')], attributes: ['type' => 'array']);
481        $state->iterators['cursor'] = new IteratorCursor($merge, position: $position);
482        $source = '<?php function target(){return 1;}';
483        $budget = new Budget();
484        $configuration = new DeriverConfig();
485        $contributions = new Contributions();
486        $input = new Sources([new Source('fixture.php', $source)]);
487        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
488        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
489        $contributions1 = $providers->contributions;
490        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
491        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
492        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
493        $snapshotId = $identity->id;
494        $input1 = $providers->input;
495        $parser = new Parser(new ParserConfig($target->version));
496        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
497        $program1 = new Index($snapshotId, $trees);
498        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
499        $snapshotId1 = 'test';
500        $input2 = new Sources([new Source('fixture.php', $source)]);
501        $profile = $execution->configuration->target;
502        $parser1 = new Parser(new ParserConfig($profile->version));
503        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
504        $program = new Index($snapshotId1, $trees1);
505        $result = (new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)))->evaluate(new BoundInstruction('i', $operation, new SourceRef('test', 'a.php', 0, 1), 'result', ['it']), $state);
506        self::assertSame($kind, $result->kind->value);
507        self::assertSame($expected, $result->isConcrete() ? $result->native() : $result->literal);
508    }
509    /**
510     * @return iterable<string,array{int,string,string,mixed}>
511     */
512    public static function providerMergeHeads(): iterable
513    {
514        yield 'first entry exists' => [-1, 'iterate', 'constant', true];
515        yield 'last head entry exists' => [0, 'iterate', 'constant', true];
516        yield 'source entries are unknown' => [1, 'iterate', 'external', 'cursor:has-next:2'];
517        yield 'head key' => [1, 'iterator-key', 'constant', 1];
518        yield 'head value' => [1, 'iterator-value', 'constant', 'name'];
519        yield 'source value' => [2, 'iterator-value', 'opaque', 'UNKNOWN_ITERABLE'];
520    }
521    public function testKeyIsCertainOnlyForTrackedClosedStorageAndKnownSnapshotEntries(): void
522    {
523        $state = new State();
524        $location = $state->memory->allocate(Term::fromNative(['k' => 1]));
525        $state->memory->liveArrays['live'] = new LiveArray($location, [], 'k');
526        $source = '<?php function target(){return 1;}';
527        $budget = new Budget();
528        $configuration = new DeriverConfig();
529        $contributions = new Contributions();
530        $input = new Sources([new Source('fixture.php', $source)]);
531        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
532        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
533        $contributions1 = $providers->contributions;
534        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
535        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
536        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
537        $snapshotId = $identity->id;
538        $input1 = $providers->input;
539        $parser = new Parser(new ParserConfig($target->version));
540        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
541        $program1 = new Index($snapshotId, $trees);
542        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
543        $snapshotId1 = 'test';
544        $input2 = new Sources([new Source('fixture.php', $source)]);
545        $profile = $execution->configuration->target;
546        $parser1 = new Parser(new ParserConfig($profile->version));
547        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
548        $program = new Index($snapshotId1, $trees1);
549        $step = new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators));
550        self::assertSame('k', $step->key('live', new IteratorCursor(Term::array([]), $location), Term::fromNative(['k' => 1]), null, $state));
551        self::assertNull($step->key('live', new IteratorCursor(Term::array([]), $location), Term::parameter('a', 'array'), null, $state));
552        self::assertSame(0, $step->key('snapshot', new IteratorCursor(Term::fromNative([1]), position: 0), Term::fromNative([1]), null, $state));
553        $havocked = Term::array([new Term(TermKind::Opaque, 'UNKNOWN', attributes: ['maybeUninitialized' => true])], true);
554        self::assertNull($step->key('snapshot', new IteratorCursor($havocked, position: 0), $havocked, null, $state));
555    }
556    public function testUnknownElementInvalidatesArrayOrObjectStorage(): void
557    {
558        $state = new State();
559        $location = $state->memory->allocate(Term::fromNative([1]));
560        $source = '<?php function target(){return 1;}';
561        $budget = new Budget();
562        $configuration = new DeriverConfig();
563        $contributions = new Contributions();
564        $input = new Sources([new Source('fixture.php', $source)]);
565        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
566        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
567        $contributions1 = $providers->contributions;
568        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
569        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
570        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
571        $snapshotId = $identity->id;
572        $input1 = $providers->input;
573        $parser = new Parser(new ParserConfig($target->version));
574        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
575        $program1 = new Index($snapshotId, $trees);
576        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
577        $snapshotId1 = 'test';
578        $input2 = new Sources([new Source('fixture.php', $source)]);
579        $profile = $execution->configuration->target;
580        $parser1 = new Parser(new ParserConfig($profile->version));
581        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
582        $program = new Index($snapshotId1, $trees1);
583        $step = new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators));
584        $array = $step->unknownElement($state, $location, Term::parameter('a', 'array'));
585        self::assertSame([$location->root, true], [$array->root, $array->unknown]);
586        $object = $step->unknownElement($state, $location, new Term(TermKind::Object, 'o1', attributes: ['class' => 'stdClass']));
587        self::assertSame(['object:o1', true], [$object->root, $object->unknown]);
588        $untyped = $step->unknownElement($state, $location, Term::parameter('x'));
589        self::assertTrue($untyped->unknown);
590        self::assertSame(TermKind::Opaque, $state->memory->read($location)->kind);
591    }
592    public function testAdvanceForgetsTheTrackedBucketWhenLiveStorageBecomesUnknown(): void
593    {
594        $state = new State();
595        $location = $state->memory->allocate(Term::parameter('a', 'array'));
596        $state->memory->liveArrays['live'] = new LiveArray($location, [1], 0);
597        $source = '<?php function target(){return 1;}';
598        $budget = new Budget();
599        $configuration = new DeriverConfig();
600        $contributions = new Contributions();
601        $input = new Sources([new Source('fixture.php', $source)]);
602        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
603        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
604        $contributions1 = $providers->contributions;
605        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
606        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
607        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
608        $snapshotId = $identity->id;
609        $input1 = $providers->input;
610        $parser = new Parser(new ParserConfig($target->version));
611        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
612        $program1 = new Index($snapshotId, $trees);
613        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
614        $snapshotId1 = 'test';
615        $input2 = new Sources([new Source('fixture.php', $source)]);
616        $profile = $execution->configuration->target;
617        $parser1 = new Parser(new ParserConfig($profile->version));
618        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
619        $program = new Index($snapshotId1, $trees1);
620        $step = new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators));
621        self::assertSame(TermKind::External, $step->advance('live', new IteratorCursor(Term::parameter('a', 'array'), $location, 1), null, $state)->kind);
622        self::assertNull($state->memory->liveArrays['live']->current);
623        self::assertSame([], $state->memory->liveArrays['live']->remaining);
624    }
625    public function testEvaluateReleasesOnlyTheSelectedIterator(): void
626    {
627        $state = new State();
628        $state->registers['it'] = new Term(TermKind::Iterator, 'cursor');
629        $location = $state->memory->allocate(Term::fromNative([10]));
630        $state->iterators['cursor'] = new IteratorCursor($state->memory->read($location), $location);
631        $other = new IteratorCursor(Term::array([]));
632        $state->iterators['other'] = $other;
633        $state->memory->liveArrays['cursor'] = new LiveArray($location, [0]);
634        $instruction = new BoundInstruction('i', 'iterator-release', new SourceRef('test', 'a.php', 0, 1), 'result', ['it']);
635        $source = '<?php function target(){return 1;}';
636        $budget = new Budget();
637        $configuration = new DeriverConfig();
638        $contributions = new Contributions();
639        $input = new Sources([new Source('fixture.php', $source)]);
640        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
641        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
642        $contributions1 = $providers->contributions;
643        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
644        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
645        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
646        $snapshotId = $identity->id;
647        $input1 = $providers->input;
648        $parser = new Parser(new ParserConfig($target->version));
649        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
650        $program1 = new Index($snapshotId, $trees);
651        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
652        $snapshotId1 = 'test';
653        $input2 = new Sources([new Source('fixture.php', $source)]);
654        $profile = $execution->configuration->target;
655        $parser1 = new Parser(new ParserConfig($profile->version));
656        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
657        $program = new Index($snapshotId1, $trees1);
658        $result = (new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)))->evaluate($instruction, $state);
659        self::assertSame(null, $result->native());
660        self::assertSame(['other' => $other], $state->iterators);
661        self::assertSame([], $state->memory->liveArrays);
662        self::assertSame([10], $state->memory->read($location)->native());
663    }
664    public function testEvaluateReturnsAnExplicitBoundaryWhenNoCurrentEntryExists(): void
665    {
666        $state = new State();
667        $instruction = new BoundInstruction('i', 'iterator-value', new SourceRef('test', 'a.php', 0, 1), 'result', ['missing']);
668        $source = '<?php function target(){return 1;}';
669        $budget = new Budget();
670        $configuration = new DeriverConfig();
671        $contributions = new Contributions();
672        $input = new Sources([new Source('fixture.php', $source)]);
673        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
674        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
675        $contributions1 = $providers->contributions;
676        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
677        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
678        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
679        $snapshotId = $identity->id;
680        $input1 = $providers->input;
681        $parser = new Parser(new ParserConfig($target->version));
682        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
683        $program1 = new Index($snapshotId, $trees);
684        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
685        $snapshotId1 = 'test';
686        $input2 = new Sources([new Source('fixture.php', $source)]);
687        $profile = $execution->configuration->target;
688        $parser1 = new Parser(new ParserConfig($profile->version));
689        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
690        $program = new Index($snapshotId1, $trees1);
691        $result = (new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)))->evaluate($instruction, $state);
692        self::assertSame(TermKind::Opaque, $result->kind);
693        self::assertSame('UNKNOWN_ITERABLE', $result->literal);
694        self::assertSame([], $state->iterators);
695    }
696    public function testEvaluateResolvesLiveAddressesFromThePinnedStorage(): void
697    {
698        $state = new State();
699        $location = $state->memory->allocate(Term::fromNative(['key' => 10]));
700        $state->registers['it'] = new Term(TermKind::Iterator, 'cursor');
701        $state->iterators['cursor'] = new IteratorCursor(Term::array([]), $location);
702        $state->memory->liveArrays['cursor'] = new LiveArray($location, ['key']);
703        $source1 = '<?php function target(){return 1;}';
704        $budget = new Budget();
705        $configuration = new DeriverConfig();
706        $contributions = new Contributions();
707        $input = new Sources([new Source('fixture.php', $source1)]);
708        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
709        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
710        $contributions1 = $providers->contributions;
711        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
712        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
713        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
714        $snapshotId = $identity->id;
715        $input1 = $providers->input;
716        $parser = new Parser(new ParserConfig($target->version));
717        $trees = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input1, false));
718        $program1 = new Index($snapshotId, $trees);
719        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
720        $snapshotId1 = 'test';
721        $input2 = new Sources([new Source('fixture.php', $source1)]);
722        $profile = $execution->configuration->target;
723        $parser1 = new Parser(new ParserConfig($profile->version));
724        $trees1 = array_map(static fn (Source $source3): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source3->path), $source3->contents, $source3->declarationsOnly))), iterator_to_array($input2, false));
725        $program = new Index($snapshotId1, $trees1);
726        $step = new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators));
727        $source = new SourceRef('test', 'a.php', 0, 1);
728        $hasNext = $step->evaluate(new BoundInstruction('i', 'iterate', $source, 'next', ['it']), $state);
729        $result = $step->evaluate(new BoundInstruction('a', 'iterator-address', $source, 'address', ['it']), $state);
730        self::assertTrue($hasNext->native());
731        self::assertSame(TermKind::Location, $result->kind);
732        self::assertSame($location->root, $result->literal);
733        self::assertSame(['key'], $state->addresses['address']->path);
734        self::assertSame(10, $state->memory->read($state->addresses['address'])->native());
735        $state->memory->write($state->addresses['address'], Term::constant(20));
736        self::assertSame(['key' => 20], $state->memory->read($location)->native());
737    }
738    public function testInitializeSnapshotsByValueWithoutAllocatingLiveStorage(): void
739    {
740        $state = new State();
741        $array = Term::fromNative([10]);
742        $state->registers['array'] = $array;
743        $instruction = new BoundInstruction('i', 'iterator', new SourceRef('test', 'a.php', 0, 1), 'it', ['array']);
744        $source = '<?php function target(){return 1;}';
745        $budget = new Budget();
746        $configuration = new DeriverConfig();
747        $contributions = new Contributions();
748        $input = new Sources([new Source('fixture.php', $source)]);
749        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
750        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
751        $contributions1 = $providers->contributions;
752        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
753        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
754        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
755        $snapshotId = $identity->id;
756        $input1 = $providers->input;
757        $parser = new Parser(new ParserConfig($target->version));
758        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
759        $program1 = new Index($snapshotId, $trees);
760        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
761        $snapshotId1 = 'test';
762        $input2 = new Sources([new Source('fixture.php', $source)]);
763        $profile = $execution->configuration->target;
764        $parser1 = new Parser(new ParserConfig($profile->version));
765        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
766        $program = new Index($snapshotId1, $trees1);
767        $iterator = (new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)))->evaluate($instruction, $state);
768        self::assertIsString($iterator->literal);
769        self::assertSame($array, $state->iterators[$iterator->literal]->array);
770        self::assertNull($state->iterators[$iterator->literal]->location);
771        self::assertSame(-1, $state->iterators[$iterator->literal]->position);
772        self::assertSame([], $state->memory->liveArrays);
773        self::assertSame([], $state->memory->cells);
774    }
775    #[DataProvider('providerSubjects')]
776    public function testIterableAcceptsOnlyArraysAndObjects(Term $subject, ?bool $expected): void
777    {
778        $source = '<?php function target(){return 1;}';
779        $budget = new Budget();
780        $configuration = new DeriverConfig();
781        $contributions = new Contributions();
782        $input = new Sources([new Source('fixture.php', $source)]);
783        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
784        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
785        $contributions1 = $providers->contributions;
786        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
787        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
788        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
789        $snapshotId = $identity->id;
790        $input1 = $providers->input;
791        $parser = new Parser(new ParserConfig($target->version));
792        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
793        $program1 = new Index($snapshotId, $trees);
794        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
795        $snapshotId1 = 'test';
796        $input2 = new Sources([new Source('fixture.php', $source)]);
797        $profile = $execution->configuration->target;
798        $parser1 = new Parser(new ParserConfig($profile->version));
799        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
800        $program = new Index($snapshotId1, $trees1);
801        self::assertSame($expected, (new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)))->iterable($subject));
802    }
803    /**
804     * @return iterable<string,array{Term,bool|null}>
805     */
806    public static function providerSubjects(): iterable
807    {
808        yield 'null' => [Term::constant(null), false];
809        yield 'string' => [Term::constant('abc'), false];
810        yield 'false' => [Term::constant(false), false];
811        yield 'array' => [Term::array([]), true];
812        yield 'object' => [new Term(TermKind::Object, 'o1', attributes: ['class' => 'Item']), true];
813        yield 'typed scalar' => [Term::parameter('rows', 'int|string'), false];
814        yield 'typed array' => [Term::parameter('rows', 'array'), true];
815        yield 'nullable array' => [Term::parameter('rows', 'array|null'), null];
816        yield 'mixed' => [Term::parameter('rows'), null];
817    }
818    public function testInitializeSkipsANonIterableSubjectWithAWarning(): void
819    {
820        $state = new State();
821        $state->registers['rows'] = Term::constant(null);
822        $source1 = '<?php function target(){return 1;}';
823        $budget = new Budget();
824        $configuration = new DeriverConfig();
825        $contributions = new Contributions();
826        $input = new Sources([new Source('fixture.php', $source1)]);
827        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
828        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
829        $contributions1 = $providers->contributions;
830        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
831        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
832        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
833        $snapshotId = $identity->id;
834        $input1 = $providers->input;
835        $parser = new Parser(new ParserConfig($target->version));
836        $trees = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input1, false));
837        $program1 = new Index($snapshotId, $trees);
838        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
839        $snapshotId1 = 'test';
840        $input2 = new Sources([new Source('fixture.php', $source1)]);
841        $profile = $execution->configuration->target;
842        $parser1 = new Parser(new ParserConfig($profile->version));
843        $trees1 = array_map(static fn (Source $source3): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source3->path), $source3->contents, $source3->declarationsOnly))), iterator_to_array($input2, false));
844        $program = new Index($snapshotId1, $trees1);
845        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
846        $step = new IterationStep($context);
847        $source = new SourceRef('test', 'a.php', 0, 1);
848        $state->registers['it'] = $step->evaluate(new BoundInstruction('i', 'iterator', $source, 'it', ['rows']), $state);
849        $next = $step->evaluate(new BoundInstruction('n', 'iterate', $source, 'next', ['it']), $state);
850        self::assertFalse($next->native());
851        self::assertSame(['foreach-non-iterable'], array_column(array_values($context->frontiers), 'operation'));
852    }
853    public function testReferencedLeavesAnUndefinedVariableUndefined(): void
854    {
855        $state = new State();
856        $state->addresses['rows'] = $state->local('rows');
857        $source = '<?php function target(){return 1;}';
858        $budget = new Budget();
859        $configuration = new DeriverConfig();
860        $contributions = new Contributions();
861        $input = new Sources([new Source('fixture.php', $source)]);
862        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
863        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
864        $contributions1 = $providers->contributions;
865        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
866        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
867        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
868        $snapshotId = $identity->id;
869        $input1 = $providers->input;
870        $parser = new Parser(new ParserConfig($target->version));
871        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
872        $program1 = new Index($snapshotId, $trees);
873        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
874        $snapshotId1 = 'test';
875        $input2 = new Sources([new Source('fixture.php', $source)]);
876        $profile = $execution->configuration->target;
877        $parser1 = new Parser(new ParserConfig($profile->version));
878        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
879        $program = new Index($snapshotId1, $trees1);
880        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
881        $instruction = new BoundInstruction('i', 'iterator', new SourceRef('test', 'a.php', 0, 1), 'it', ['rows'], attributes: ['byReference' => true]);
882        (new IterationStep($context))->initialize($instruction, $state);
883        self::assertSame(TermKind::Uninitialized, $state->memory->read($state->local('rows'))->kind);
884        self::assertSame([], $state->memory->liveArrays);
885        $frontiers = array_values($context->frontiers);
886        self::assertSame(['uninitialized-read', 'foreach-non-iterable'], array_column($frontiers, 'operation'));
887        self::assertSame(['variable:rows'], $frontiers[0]->knownDependencies);
888    }
889    public function testReferencedCreatesAMissingElementBeforeSkippingIt(): void
890    {
891        $state = new State();
892        $root = $state->local('rows');
893        $state->memory->write($root, Term::array([]));
894        $state->addresses['element'] = new Location($root->root, ['k']);
895        $instruction = new BoundInstruction('i', 'iterator', new SourceRef('test', 'a.php', 0, 1), 'it', ['element'], attributes: ['byReference' => true]);
896        $source = '<?php function target(){return 1;}';
897        $budget = new Budget();
898        $configuration = new DeriverConfig();
899        $contributions = new Contributions();
900        $input = new Sources([new Source('fixture.php', $source)]);
901        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
902        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
903        $contributions1 = $providers->contributions;
904        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
905        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
906        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
907        $snapshotId = $identity->id;
908        $input1 = $providers->input;
909        $parser = new Parser(new ParserConfig($target->version));
910        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
911        $program1 = new Index($snapshotId, $trees);
912        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
913        $snapshotId1 = 'test';
914        $input2 = new Sources([new Source('fixture.php', $source)]);
915        $profile = $execution->configuration->target;
916        $parser1 = new Parser(new ParserConfig($profile->version));
917        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
918        $program = new Index($snapshotId1, $trees1);
919        (new IterationStep(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)))->initialize($instruction, $state);
920        self::assertSame(['k' => null], $state->memory->materialize($state->memory->read($root))->native());
921    }
922    public function testCandidatesRetainsTheUnknownPrefixBesideAKnownSuffix(): void
923    {
924        $source = '<?php function target(){return 1;}';
925        $budget = new Budget();
926        $configuration = new DeriverConfig();
927        $contributions = new Contributions();
928        $input = new Sources([new Source('fixture.php', $source)]);
929        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
930        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
931        $contributions1 = $providers->contributions;
932        $evaluators = new Evaluators(new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision), new Registrations($contributions1->evaluators, $contributions1->providers, $contributions1->domains, $contributions1->intrinsics, $contributions1->stateSlots), $configuration->standardEvaluators);
933        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
934        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
935        $snapshotId = $identity->id;
936        $input1 = $providers->input;
937        $parser = new Parser(new ParserConfig($target->version));
938        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
939        $program1 = new Index($snapshotId, $trees);
940        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
941        $snapshotId1 = 'test';
942        $input2 = new Sources([new Source('fixture.php', $source)]);
943        $profile = $execution->configuration->target;
944        $parser1 = new Parser(new ParserConfig($profile->version));
945        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(Path::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
946        $program = new Index($snapshotId1, $trees1);
947        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
948        $state = new State();
949        $arrays = new Arrays();
950        $array = $arrays->set($arrays->merge(Term::array([]), Term::parameter('x', 'array')), null, Term::constant('z'));
951        $state->registers['it'] = new Term(TermKind::Iterator, 'cursor');
952        $state->iterators['cursor'] = new IteratorCursor($array, position: 0);
953        $paths = (new IterationStep($context))->candidates(new BoundInstruction('v', 'iterator-value', new SourceRef('test', 'x', 0, 1), 'out', ['it']), $state);
954        self::assertNotNull($paths);
955        self::assertCount(2, $paths);
956        self::assertSame('z', $paths[0]->value('out')->native());
957        self::assertFalse($paths[1]->value('out')->isConcrete());
958    }
959}
960