packages/deriver/tests/Unit/Deriver/Evaluator/Execution/Call/MethodInvocationTest.php

1<?php
2
3declare (strict_types=1);
4
5namespace Tests\Unit\Deriver\Evaluator\Execution\Call;
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\FunctionEvaluator;
14use Deriver\Deriver\Evaluator\Builtin\Library;
15use Deriver\Deriver\Evaluator\Builtin\ScalarFunctions;
16use Deriver\Deriver\Evaluator\Call\ArgumentBindings;
17use Deriver\Deriver\Evaluator\Call\BoundArgument;
18use Deriver\Deriver\Evaluator\Call\BoundInstruction;
19use Deriver\Deriver\Evaluator\Call\CallDecision;
20use Deriver\Deriver\Evaluator\Call\CallDescription;
21use Deriver\Deriver\Evaluator\Call\CallDescriptor;
22use Deriver\Deriver\Evaluator\Call\CallEvaluator;
23use Deriver\Deriver\Evaluator\Call\Evaluators;
24use Deriver\Deriver\Evaluator\Call\Extensions;
25use Deriver\Deriver\Evaluator\Call\Plan\Action;
26use Deriver\Deriver\Evaluator\Call\Plan\Expression;
27use Deriver\Deriver\Evaluator\Call\Plan\PlanActions;
28use Deriver\Deriver\Evaluator\Call\Plan\PlanCompiler;
29use Deriver\Deriver\Evaluator\Call\Plan\PlanFootprints;
30use Deriver\Deriver\Evaluator\Call\Plan\PlanValidation;
31use Deriver\Deriver\Evaluator\Call\Plan\SemanticPlan;
32use Deriver\Deriver\Evaluator\Call\Precedence;
33use Deriver\Deriver\Evaluator\Call\Provider\DispatchDecision;
34use Deriver\Deriver\Evaluator\Call\Provider\DispatchProvider;
35use Deriver\Deriver\Evaluator\Call\Provider\DispatchRequest;
36use Deriver\Deriver\Evaluator\Call\Provider\DispatchTarget;
37use Deriver\Deriver\Evaluator\Call\Registrations;
38use Deriver\Deriver\Evaluator\Call\SignatureIdentity;
39use Deriver\Deriver\Evaluator\Call\StateRegistry;
40use Deriver\Deriver\Evaluator\Declaration\Declarations;
41use Deriver\Deriver\Evaluator\Declaration\Parameter as DeclarationParameter;
42use Deriver\Deriver\Evaluator\Declaration\Signature;
43use Deriver\Deriver\Evaluator\EvaluatorConfig;
44use Deriver\Deriver\Evaluator\Evidence\Frontier;
45use Deriver\Deriver\Evaluator\Execution\Call\Allocation;
46use Deriver\Deriver\Evaluator\Execution\Call\ArgumentBinding;
47use Deriver\Deriver\Evaluator\Execution\Call\ArgumentOrder;
48use Deriver\Deriver\Evaluator\Execution\Call\CallableCheck;
49use Deriver\Deriver\Evaluator\Execution\Call\CallExecutor;
50use Deriver\Deriver\Evaluator\Execution\Call\CallResolution;
51use Deriver\Deriver\Evaluator\Execution\Call\Closure\Binding;
52use Deriver\Deriver\Evaluator\Execution\Call\Closure\Capture;
53use Deriver\Deriver\Evaluator\Execution\Call\Contract\Inputs;
54use Deriver\Deriver\Evaluator\Execution\Call\Contract\NativeArguments;
55use Deriver\Deriver\Evaluator\Execution\Call\Creation\Access;
56use Deriver\Deriver\Evaluator\Execution\Call\Member\Constants;
57use Deriver\Deriver\Evaluator\Execution\Call\Member\Invocation;
58use Deriver\Deriver\Evaluator\Execution\Call\MethodInvocation;
59use Deriver\Deriver\Evaluator\Execution\Call\Native\Invocation as NativeInvocation;
60use Deriver\Deriver\Evaluator\Execution\Call\Native\Properties;
61use Deriver\Deriver\Evaluator\Execution\Call\Native\Signatures;
62use Deriver\Deriver\Evaluator\Execution\Call\ParameterBinding;
63use Deriver\Deriver\Evaluator\Execution\Call\PassedArgument;
64use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Arguments;
65use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Creation;
66use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Methods;
67use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Modes;
68use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Resolution;
69use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Target;
70use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Transfer;
71use Deriver\Deriver\Evaluator\Execution\Call\ProviderDispatch;
72use Deriver\Deriver\Evaluator\Execution\Call\SymbolicEnums;
73use Deriver\Deriver\Evaluator\Execution\Call\TypeBinding;
74use Deriver\Deriver\Evaluator\Execution\Call\TypeCheck;
75use Deriver\Deriver\Evaluator\Execution\Call\UnknownCall;
76use Deriver\Deriver\Evaluator\Execution\Completion\Alternative;
77use Deriver\Deriver\Evaluator\Execution\Completion\Assessment;
78use Deriver\Deriver\Evaluator\Execution\Completion\Completion;
79use Deriver\Deriver\Evaluator\Execution\Completion\CompletionKind;
80use Deriver\Deriver\Evaluator\Execution\Completion\Exceptional;
81use Deriver\Deriver\Evaluator\Execution\Completion\StorageSnapshot;
82use Deriver\Deriver\Evaluator\Execution\Constant\ClassNames;
83use Deriver\Deriver\Evaluator\Execution\Constraints;
84use Deriver\Deriver\Evaluator\Execution\Context;
85use Deriver\Deriver\Evaluator\Execution\Control\ExceptionChain;
86use Deriver\Deriver\Evaluator\Execution\Control\ExceptionMatch;
87use Deriver\Deriver\Evaluator\Execution\Control\Handler;
88use Deriver\Deriver\Evaluator\Execution\Control\ObservationLimit;
89use Deriver\Deriver\Evaluator\Execution\Control\StateJoin;
90use Deriver\Deriver\Evaluator\Execution\Control\Unwinding;
91use Deriver\Deriver\Evaluator\Execution\Demand\Cell;
92use Deriver\Deriver\Evaluator\Execution\Demand\Components;
93use Deriver\Deriver\Evaluator\Execution\Demand\Discovery;
94use Deriver\Deriver\Evaluator\Execution\Demand\Key;
95use Deriver\Deriver\Evaluator\Execution\Demand\Table;
96use Deriver\Deriver\Evaluator\Execution\Dependencies;
97use Deriver\Deriver\Evaluator\Execution\Evaluator;
98use Deriver\Deriver\Evaluator\Execution\EvaluatorConfig as ExecutionEvaluatorConfig;
99use Deriver\Deriver\Evaluator\Execution\Havoc;
100use Deriver\Deriver\Evaluator\Execution\InstructionTransfer;
101use Deriver\Deriver\Evaluator\Execution\Memory\Location;
102use Deriver\Deriver\Evaluator\Execution\Memory\Materialization;
103use Deriver\Deriver\Evaluator\Execution\Memory\Memory;
104use Deriver\Deriver\Evaluator\Execution\Memory\ReferenceConstraint;
105use Deriver\Deriver\Evaluator\Execution\Memory\Slots\SlotReference;
106use Deriver\Deriver\Evaluator\Execution\Memory\Slots\StateStorage;
107use Deriver\Deriver\Evaluator\Execution\Memory\StorageCapture;
108use Deriver\Deriver\Evaluator\Execution\ObservationCollector;
109use Deriver\Deriver\Evaluator\Execution\Operation\Conversions;
110use Deriver\Deriver\Evaluator\Execution\Operation\ScalarErrors;
111use Deriver\Deriver\Evaluator\Execution\State;
112use Deriver\Deriver\Evaluator\Execution\Summary\CompletionRecord;
113use Deriver\Deriver\Evaluator\Execution\Summary\Evaluation;
114use Deriver\Deriver\Evaluator\Execution\Summary\Invocation as SummaryInvocation;
115use Deriver\Deriver\Evaluator\Execution\Summary\Isolation;
116use Deriver\Deriver\Evaluator\Execution\Trace\Derivation;
117use Deriver\Deriver\Evaluator\Execution\Transfer\ConstantTransfer;
118use Deriver\Deriver\Evaluator\Execution\Transfer\IntrinsicTransfer;
119use Deriver\Deriver\Evaluator\Execution\Transfer\MemoryStep;
120use Deriver\Deriver\Evaluator\Execution\Transfer\ObjectAccess;
121use Deriver\Deriver\Evaluator\Execution\Transfer\PropertyAccessCheck;
122use Deriver\Deriver\Evaluator\Execution\Transfer\PropertyLookup;
123use Deriver\Deriver\Evaluator\Execution\Transfer\PropertySlot;
124use Deriver\Deriver\Evaluator\Execution\Transfer\PropertyTransfer;
125use Deriver\Deriver\Evaluator\Execution\Transfer\PureStep;
126use Deriver\Deriver\Evaluator\Execution\Transfer\ReferenceAssignment;
127use Deriver\Deriver\Evaluator\Request\Budget;
128use Deriver\Deriver\Evaluator\Request\EntryPoint;
129use Deriver\Deriver\Evaluator\Request\QueryScope;
130use Deriver\Deriver\Evaluator\Request\ReturnQuery;
131use Deriver\Deriver\Evaluator\Scalar\Arrays;
132use Deriver\Deriver\Evaluator\Scalar\Identity;
133use Deriver\Deriver\Evaluator\Scalar\Operations;
134use Deriver\Deriver\Evaluator\TargetProfile;
135use Deriver\Deriver\Evaluator\Term;
136use Deriver\Deriver\Evaluator\TermKind;
137use Deriver\Deriver\Execution\DerivationResult;
138use Deriver\Deriver\Execution\QueryExecution;
139use Deriver\Deriver\Execution\ResultAssessment;
140use Deriver\Deriver\Identity\QueryEncoding;
141use Deriver\Deriver\Identity\ValueGraph;
142use Deriver\Deriver\Lowerer\AggregateLowering;
143use Deriver\Deriver\Lowerer\AssignmentLowering;
144use Deriver\Deriver\Lowerer\CallLowering;
145use Deriver\Deriver\Lowerer\Control\DestructuringLowering;
146use Deriver\Deriver\Lowerer\Control\ExceptionLowering;
147use Deriver\Deriver\Lowerer\Declaration\CallableIdentity;
148use Deriver\Deriver\Lowerer\Declaration\CallableSource;
149use Deriver\Deriver\Lowerer\Declaration\ConstantSignatures;
150use Deriver\Deriver\Lowerer\Declaration\Index;
151use Deriver\Deriver\Lowerer\Declaration\Indexer;
152use Deriver\Deriver\Lowerer\Declaration\Metadata\ClassConstant;
153use Deriver\Deriver\Lowerer\Declaration\Metadata\ClassDeclaration;
154use Deriver\Deriver\Lowerer\Declaration\Metadata\PropertyDeclaration;
155use Deriver\Deriver\Lowerer\Declaration\Traits\Composition;
156use Deriver\Deriver\Lowerer\ExpressionLowering;
157use Deriver\Deriver\Lowerer\Graph\Argument;
158use Deriver\Deriver\Lowerer\Graph\BasicBlock;
159use Deriver\Deriver\Lowerer\Graph\CallableGraph;
160use Deriver\Deriver\Lowerer\Graph\CatchTarget;
161use Deriver\Deriver\Lowerer\Graph\ExceptionRegion;
162use Deriver\Deriver\Lowerer\Graph\Instruction;
163use Deriver\Deriver\Lowerer\Graph\Parameter;
164use Deriver\Deriver\Lowerer\Graph\Terminator;
165use Deriver\Deriver\Lowerer\Hierarchy\Access as HierarchyAccess;
166use Deriver\Deriver\Lowerer\Hierarchy\Builtins;
167use Deriver\Deriver\Lowerer\Hierarchy\Dispatch;
168use Deriver\Deriver\Lowerer\InstructionEmitter;
169use Deriver\Deriver\Lowerer\Lowerer;
170use Deriver\Deriver\Lowerer\LoweringScope;
171use Deriver\Deriver\Lowerer\StatementLowering;
172use Deriver\Deriver\MicroEvaluatorConversion;
173use Deriver\Deriver\Parser\Node\File;
174use Deriver\Deriver\Parser\Parser;
175use Deriver\Deriver\Parser\ParserConfig;
176use Deriver\Deriver\Parser\TargetSyntax;
177use Deriver\Deriver\Providers\ProviderExpansion;
178use Deriver\Deriver\Resolver\AssignmentPatterns;
179use Deriver\Deriver\Resolver\ClassScope;
180use Deriver\Deriver\Resolver\ExpressionValidation;
181use Deriver\Deriver\Resolver\MagicContext;
182use Deriver\Deriver\Resolver\Resolver;
183use Deriver\Deriver\Selection\QueryValidation;
184use Deriver\Deriver\SnapshotIdentity;
185use Deriver\Deriver\Sources\LineMap;
186use Deriver\Deriver\Sources\Path;
187use Deriver\Deriver\Sources\Source;
188use Deriver\Deriver\Sources\SourceRef;
189use Deriver\Deriver\Sources\Sources;
190use Deriver\Exception\ParserException;
191use Deriver\Exception\ResolutionException;
192use JsonException;
193use Override;
194use PHPUnit\Framework\Attributes\CoversClass;
195use PHPUnit\Framework\Attributes\DataProvider;
196use PHPUnit\Framework\Attributes\Small;
197use PHPUnit\Framework\Attributes\UsesClass;
198use PHPUnit\Framework\TestCase;
199
200#[UsesClass(Resolver::class)]
201#[UsesClass(ExpressionValidation::class)]
202#[UsesClass(ResolutionException::class)]
203#[UsesClass(ParserConfig::class)]
204#[UsesClass(ParserException::class)]
205#[CoversClass(MethodInvocation::class)]
206#[UsesClass(Exceptional::class)]
207#[UsesClass(SignatureIdentity::class)]
208#[UsesClass(Precedence::class)]
209#[UsesClass(Declarations::class)]
210#[UsesClass(SymbolicEnums::class)]
211#[UsesClass(QueryExecution::class)]
212#[UsesClass(QueryValidation::class)]
213#[UsesClass(ResultAssessment::class)]
214#[UsesClass(Deriver::class)]
215#[UsesClass(Constraints::class)]
216#[UsesClass(Argument::class)]
217#[UsesClass(BasicBlock::class)]
218#[UsesClass(CallableGraph::class)]
219#[UsesClass(CallableIdentity::class)]
220#[UsesClass(CatchTarget::class)]
221#[UsesClass(ClassConstant::class)]
222#[UsesClass(ClassDeclaration::class)]
223#[UsesClass(ExceptionRegion::class)]
224#[UsesClass(Instruction::class)]
225#[UsesClass(Parameter::class)]
226#[UsesClass(PropertyDeclaration::class)]
227#[UsesClass(Terminator::class)]
228#[UsesClass(Allocation::class)]
229#[UsesClass(ArgumentBinding::class)]
230#[UsesClass(ArgumentOrder::class)]
231#[UsesClass(CallExecutor::class)]
232#[UsesClass(CallResolution::class)]
233#[UsesClass(CallableCheck::class)]
234#[UsesClass(Binding::class)]
235#[UsesClass(Capture::class)]
236#[UsesClass(Access::class)]
237#[UsesClass(Builtins::class)]
238#[UsesClass(Dispatch::class)]
239#[UsesClass(HierarchyAccess::class)]
240#[UsesClass(Constants::class)]
241#[UsesClass(Invocation::class)]
242#[UsesClass(Inputs::class)]
243#[UsesClass(NativeArguments::class)]
244#[UsesClass(NativeInvocation::class)]
245#[UsesClass(Properties::class)]
246#[UsesClass(Signatures::class)]
247#[UsesClass(ParameterBinding::class)]
248#[UsesClass(PassedArgument::class)]
249#[UsesClass(Arguments::class)]
250#[UsesClass(Creation::class)]
251#[UsesClass(Methods::class)]
252#[UsesClass(Modes::class)]
253#[UsesClass(Resolution::class)]
254#[UsesClass(Target::class)]
255#[UsesClass(Transfer::class)]
256#[UsesClass(ProviderDispatch::class)]
257#[UsesClass(TypeBinding::class)]
258#[UsesClass(TypeCheck::class)]
259#[UsesClass(UnknownCall::class)]
260#[UsesClass(Completion::class)]
261#[UsesClass(ClassNames::class)]
262#[UsesClass(Context::class)]
263#[UsesClass(ExceptionChain::class)]
264#[UsesClass(ExceptionMatch::class)]
265#[UsesClass(Handler::class)]
266#[UsesClass(ObservationLimit::class)]
267#[UsesClass(StateJoin::class)]
268#[UsesClass(Unwinding::class)]
269#[UsesClass(Cell::class)]
270#[UsesClass(Components::class)]
271#[UsesClass(Discovery::class)]
272#[UsesClass(Key::class)]
273#[UsesClass(Table::class)]
274#[UsesClass(Dependencies::class)]
275#[UsesClass(Havoc::class)]
276#[UsesClass(InstructionTransfer::class)]
277#[UsesClass(Evaluator::class)]
278#[UsesClass(SlotReference::class)]
279#[UsesClass(StateStorage::class)]
280#[UsesClass(ObservationCollector::class)]
281#[UsesClass(Conversions::class)]
282#[UsesClass(ScalarErrors::class)]
283#[UsesClass(State::class)]
284#[UsesClass(CompletionRecord::class)]
285#[UsesClass(Evaluation::class)]
286#[UsesClass(SummaryInvocation::class)]
287#[UsesClass(Isolation::class)]
288#[UsesClass(ConstantTransfer::class)]
289#[UsesClass(IntrinsicTransfer::class)]
290#[UsesClass(MemoryStep::class)]
291#[UsesClass(ObjectAccess::class)]
292#[UsesClass(PropertyAccessCheck::class)]
293#[UsesClass(PropertyLookup::class)]
294#[UsesClass(PropertySlot::class)]
295#[UsesClass(PropertyTransfer::class)]
296#[UsesClass(PureStep::class)]
297#[UsesClass(ReferenceAssignment::class)]
298#[UsesClass(Location::class)]
299#[UsesClass(Materialization::class)]
300#[UsesClass(Memory::class)]
301#[UsesClass(ReferenceConstraint::class)]
302#[UsesClass(StorageCapture::class)]
303#[UsesClass(ArgumentBindings::class)]
304#[UsesClass(BoundArgument::class)]
305#[UsesClass(FunctionEvaluator::class)]
306#[UsesClass(Library::class)]
307#[UsesClass(ScalarFunctions::class)]
308#[UsesClass(CallDescription::class)]
309#[UsesClass(PlanActions::class)]
310#[UsesClass(PlanCompiler::class)]
311#[UsesClass(PlanFootprints::class)]
312#[UsesClass(PlanValidation::class)]
313#[UsesClass(CallDecision::class)]
314#[UsesClass(CallDescriptor::class)]
315#[UsesClass(Action::class)]
316#[UsesClass(Expression::class)]
317#[UsesClass(SemanticPlan::class)]
318#[UsesClass(DispatchDecision::class)]
319#[UsesClass(DispatchRequest::class)]
320#[UsesClass(DispatchTarget::class)]
321#[UsesClass(Extensions::class)]
322#[UsesClass(ProviderExpansion::class)]
323#[UsesClass(Evaluators::class)]
324#[UsesClass(StateRegistry::class)]
325#[UsesClass(DeclarationParameter::class)]
326#[UsesClass(Signature::class)]
327#[UsesClass(DeriverConfig::class)]
328#[UsesClass(EntryPoint::class)]
329#[UsesClass(Sources::class)]
330#[UsesClass(Path::class)]
331#[UsesClass(Snapshot::class)]
332#[UsesClass(Source::class)]
333#[UsesClass(TargetProfile::class)]
334#[UsesClass(Budget::class)]
335#[UsesClass(QueryScope::class)]
336#[UsesClass(ReturnQuery::class)]
337#[UsesClass(ResultRef::class)]
338#[UsesClass(SourceRef::class)]
339#[UsesClass(Alternative::class)]
340#[UsesClass(Assessment::class)]
341#[UsesClass(Derivation::class)]
342#[UsesClass(DerivationResult::class)]
343#[UsesClass(Frontier::class)]
344#[UsesClass(QueryEncoding::class)]
345#[UsesClass(ValueGraph::class)]
346#[UsesClass(Statistics::class)]
347#[UsesClass(StorageSnapshot::class)]
348#[UsesClass(Parser::class)]
349#[UsesClass(File::class)]
350#[UsesClass(AggregateLowering::class)]
351#[UsesClass(AssignmentLowering::class)]
352#[UsesClass(CallLowering::class)]
353#[UsesClass(Lowerer::class)]
354#[UsesClass(DestructuringLowering::class)]
355#[UsesClass(ExceptionLowering::class)]
356#[UsesClass(ExpressionLowering::class)]
357#[UsesClass(InstructionEmitter::class)]
358#[UsesClass(LoweringScope::class)]
359#[UsesClass(StatementLowering::class)]
360#[UsesClass(ConstantSignatures::class)]
361#[UsesClass(CallableSource::class)]
362#[UsesClass(Indexer::class)]
363#[UsesClass(Index::class)]
364#[UsesClass(Composition::class)]
365#[UsesClass(LineMap::class)]
366#[UsesClass(MagicContext::class)]
367#[UsesClass(AssignmentPatterns::class)]
368#[UsesClass(ClassScope::class)]
369#[UsesClass(TargetSyntax::class)]
370#[UsesClass(Arrays::class)]
371#[UsesClass(Identity::class)]
372#[UsesClass(Operations::class)]
373#[UsesClass(Term::class)]
374#[Small]
375final class MethodInvocationTest extends TestCase
376{
377    public function testApplyPreservesTheSemanticContract(): void
378    {
379        $source = '<?php class Box{public $value="first";function __clone(){$this->value="clone";}}function target(){$a=new Box;$b=clone $a;return [$a->value,$b->value];}';
380        $symbol = 'target';
381        $input = new Sources([new Source('fixture.php', $source)]);
382        $configuration = new DeriverConfig();
383        $contributions = new Contributions();
384        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
385        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
386        $contributions1 = $providers->contributions;
387        $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);
388        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
389        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
390        $snapshotId = $identity->id;
391        $input1 = $providers->input;
392        $parser = new Parser(new ParserConfig($target->version));
393        $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));
394        $program = new Index($snapshotId, $trees);
395        $result = (new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics()))))->derive(new ReturnQuery($symbol));
396        self::assertSame(['first', 'clone'], $result->normalOutcomes[0]->values['return']->native());
397        self::assertSame([], $result->frontiers);
398        self::assertSame([], $result->exceptionalOutcomes);
399    }
400    public function testCandidatesRetainsKnownImplementationsAndUnknownRemainder(): void
401    {
402        $input = new Sources([new Source('fixture.php', '<?php interface I{function run();}final class A implements I{function run(){return 1;}}final class B implements I{function run(){return 2;}}function target(I $value){return $value->run();}')]);
403        $configuration = new DeriverConfig();
404        $contributions = new Contributions();
405        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
406        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
407        $contributions1 = $providers->contributions;
408        $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);
409        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
410        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
411        $snapshotId = $identity->id;
412        $input1 = $providers->input;
413        $parser = new Parser(new ParserConfig($target->version));
414        $trees = array_map(static fn (Source $source): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source->path), $source->contents, $source->declarationsOnly))), iterator_to_array($input1, false));
415        $program = new Index($snapshotId, $trees);
416        $session = new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics())));
417        $result = $session->derive(new ReturnQuery('target'));
418        self::assertContains('OPEN_DISPATCH', array_column($result->frontiers, 'code'));
419        $values = array_map(static fn (Alternative $a): int|float|string|bool|null => $a->values['return']->literal, $result->normalOutcomes);
420        self::assertContains(1, $values);
421        self::assertContains(2, $values);
422    }
423    public function testReceiverPreservesForwardedLateStaticCalls(): void
424    {
425        $state = new State();
426        $state->lateStaticClass = 'Child';
427        $source = '<?php function target(){return 1;}';
428        $budget = new Budget();
429        $configuration = new DeriverConfig();
430        $contributions = new Contributions();
431        $input = new Sources([new Source('fixture.php', $source)]);
432        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
433        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
434        $contributions1 = $providers->contributions;
435        $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);
436        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
437        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
438        $snapshotId = $identity->id;
439        $input1 = $providers->input;
440        $parser = new Parser(new ParserConfig($target->version));
441        $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));
442        $program1 = new Index($snapshotId, $trees);
443        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
444        $snapshotId1 = 'test';
445        $input2 = new Sources([new Source('fixture.php', $source)]);
446        $profile = $execution->configuration->target;
447        $parser1 = new Parser(new ParserConfig($profile->version));
448        $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));
449        $program = new Index($snapshotId1, $trees1);
450        $invocation = new MethodInvocation(new Evaluator(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)));
451        self::assertNull($invocation->receiver(Term::constant('self'), $state, 'ParentClass', true));
452        $invocation->receiver(Term::constant('Other'), $state, 'Other', true);
453        self::assertSame('Child', $state->lateStaticClass);
454    }
455    public function testCalledClassForwardsRelativeNamesWithoutChangingCallerState(): void
456    {
457        $source = '<?php function target(){return 1;}';
458        $budget = new Budget();
459        $configuration = new DeriverConfig();
460        $contributions = new Contributions();
461        $input = new Sources([new Source('fixture.php', $source)]);
462        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
463        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
464        $contributions1 = $providers->contributions;
465        $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);
466        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
467        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
468        $snapshotId = $identity->id;
469        $input1 = $providers->input;
470        $parser = new Parser(new ParserConfig($target->version));
471        $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));
472        $program1 = new Index($snapshotId, $trees);
473        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
474        $snapshotId1 = 'test';
475        $input2 = new Sources([new Source('fixture.php', $source)]);
476        $profile = $execution->configuration->target;
477        $parser1 = new Parser(new ParserConfig($profile->version));
478        $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));
479        $program = new Index($snapshotId1, $trees1);
480        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
481        $body = $context->program->callable('target');
482        self::assertNotNull($body);
483        $machine = new Evaluator($context);
484        $state = new State();
485        $instruction = new BoundInstruction('arg', 'argument', $body->source, 'result', ['prepared', 'input']);
486        $state->lateStaticClass = 'Child';
487        $invocation = new MethodInvocation($machine);
488        self::assertSame('Child', $invocation->calledClass(Term::constant('self'), $state, 'Base', true));
489        self::assertSame('Other', $invocation->calledClass(Term::constant('Other'), $state, 'Other', true));
490        self::assertSame('Child', $state->lateStaticClass);
491    }
492    /**
493     * @param Term $name Unknown method spelling
494     */
495    #[DataProvider('providerUnknownNames')]
496    public function testApplyRetainsUnresolvedMethodNamesAndBothCompletions(Term $name): void
497    {
498        $source = '<?php function target(){return 1;}';
499        $budget = new Budget();
500        $configuration = new DeriverConfig();
501        $contributions = new Contributions();
502        $input = new Sources([new Source('fixture.php', $source)]);
503        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
504        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
505        $contributions1 = $providers->contributions;
506        $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);
507        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
508        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
509        $snapshotId = $identity->id;
510        $input1 = $providers->input;
511        $parser = new Parser(new ParserConfig($target->version));
512        $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));
513        $program1 = new Index($snapshotId, $trees);
514        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
515        $snapshotId1 = 'test';
516        $input2 = new Sources([new Source('fixture.php', $source)]);
517        $profile = $execution->configuration->target;
518        $parser1 = new Parser(new ParserConfig($profile->version));
519        $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));
520        $program = new Index($snapshotId1, $trees1);
521        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
522        $caller = $context->program->callable('target');
523        self::assertNotNull($caller);
524        $state = new State();
525        $state->registers = ['receiver' => Term::parameter('object', 'object'), 'name' => $name];
526        $paths = (new MethodInvocation(new Evaluator($context)))->apply($caller, new BoundInstruction('call', 'invoke-method', $caller->source, 'result', ['receiver', 'name']), $state, []);
527        self::assertCount(2, $paths);
528        self::assertSame(CompletionKind::Normal, $paths[0]->completion->kind);
529        self::assertSame(CompletionKind::Throw, $paths[1]->completion->kind);
530        self::assertSame(['OPEN_DISPATCH'], array_column($context->frontiers, 'code'));
531    }
532    /**
533     * @return array<string,array{Term}>
534     */
535    public static function providerUnknownNames(): array
536    {
537        return ['symbolic' => [Term::parameter('method', 'string')], 'nonstring' => [Term::constant(1)]];
538    }
539    /**
540     * @param Term $receiver Invalid instance receiver
541     */
542    #[DataProvider('providerInvalidReceivers')]
543    public function testApplyRaisesAnErrorForConcreteNonObjectReceivers(Term $receiver): void
544    {
545        $source = '<?php function target(){return 1;}';
546        $budget = new Budget();
547        $configuration = new DeriverConfig();
548        $contributions = new Contributions();
549        $input = new Sources([new Source('fixture.php', $source)]);
550        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
551        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
552        $contributions1 = $providers->contributions;
553        $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);
554        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
555        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
556        $snapshotId = $identity->id;
557        $input1 = $providers->input;
558        $parser = new Parser(new ParserConfig($target->version));
559        $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));
560        $program1 = new Index($snapshotId, $trees);
561        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
562        $snapshotId1 = 'test';
563        $input2 = new Sources([new Source('fixture.php', $source)]);
564        $profile = $execution->configuration->target;
565        $parser1 = new Parser(new ParserConfig($profile->version));
566        $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));
567        $program = new Index($snapshotId1, $trees1);
568        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
569        $caller = $context->program->callable('target');
570        self::assertNotNull($caller);
571        $state = new State();
572        $state->registers = ['receiver' => $receiver, 'name' => Term::constant('run')];
573        $paths = (new MethodInvocation(new Evaluator($context)))->apply($caller, new BoundInstruction('call', 'invoke-method', $caller->source, 'result', ['receiver', 'name']), $state, []);
574        self::assertCount(1, $paths);
575        self::assertSame(CompletionKind::Throw, $paths[0]->completion->kind);
576        self::assertSame('Error', $paths[0]->completion->value?->literal);
577        self::assertSame([], $context->frontiers);
578    }
579    /**
580     * @return array<string,array{Term}>
581     */
582    public static function providerInvalidReceivers(): array
583    {
584        return ['integer' => [Term::constant(1)], 'array' => [Term::array([])], 'null' => [Term::constant(null)]];
585    }
586    public function testCandidatesKeepsApplicableProviderTargetsAndTheirReceiverOverrides(): void
587    {
588        $source = '<?php class Impl{public int $value;function run(){return $this->value;}}function target(){}';
589        $budget = new Budget();
590        $configuration = new DeriverConfig();
591        $contributions = new Contributions();
592        $input = new Sources([new Source('fixture.php', $source)]);
593        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
594        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
595        $contributions1 = $providers->contributions;
596        $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);
597        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
598        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
599        $snapshotId = $identity->id;
600        $input1 = $providers->input;
601        $parser = new Parser(new ParserConfig($target->version));
602        $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));
603        $program1 = new Index($snapshotId, $trees);
604        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
605        $snapshotId1 = 'test';
606        $input2 = new Sources([new Source('fixture.php', $source)]);
607        $profile = $execution->configuration->target;
608        $parser1 = new Parser(new ParserConfig($profile->version));
609        $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));
610        $program = new Index($snapshotId1, $trees1);
611        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
612        $caller = $context->program->callable('target');
613        self::assertNotNull($caller);
614        $state = new State();
615        $original = new Term(TermKind::Object, 'original', attributes: ['class' => 'Impl']);
616        $replacement = new Term(TermKind::Object, 'replacement', attributes: ['class' => 'Impl']);
617        $state->memory->write(new Location('object:original', ['value']), Term::constant(1));
618        $state->memory->write(new Location('object:replacement', ['value']), Term::constant(7));
619        $decision = new DispatchDecision([new DispatchTarget('missing', condition: Term::constant(false)), new DispatchTarget('Impl::run', $replacement), new DispatchTarget('Impl::run', condition: Term::constant(true))], true);
620        $paths = (new MethodInvocation(new Evaluator($context)))->candidates($caller, new BoundInstruction('call', 'invoke-method', $caller->source, 'result'), $state, [], $original, 'Service', 'run', $decision);
621        self::assertCount(2, $paths);
622        self::assertSame([7, 1], array_map(static fn (State $path): int|float|string|bool|null => $path->registers['result']->literal, $paths));
623        self::assertSame([CompletionKind::Normal, CompletionKind::Normal], array_column(array_column($paths, 'completion'), 'kind'));
624        self::assertSame([], $context->frontiers);
625        self::assertNotSame($paths[0]->memory, $paths[1]->memory);
626    }
627    /**
628     * @param bool $exhaustive Provider completeness
629     * @param string $modifier Captured class finality
630     * @param int $expectedCount Source result plus any open normal and exceptional paths
631     * @param list<string> $codes Expected boundaries
632     */
633    #[DataProvider('providerWorldBounds')]
634    public function testCandidatesUsesOnlyExplicitCompletenessBounds(bool $exhaustive, string $modifier, int $expectedCount, array $codes): void
635    {
636        $source = '<?php ' . $modifier . ' class Box{function run(){return 1;}}function target(){}';
637        $budget = new Budget();
638        $configuration = new DeriverConfig();
639        $contributions = new Contributions();
640        $input = new Sources([new Source('fixture.php', $source)]);
641        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
642        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
643        $contributions1 = $providers->contributions;
644        $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);
645        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
646        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
647        $snapshotId = $identity->id;
648        $input1 = $providers->input;
649        $parser = new Parser(new ParserConfig($target->version));
650        $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));
651        $program1 = new Index($snapshotId, $trees);
652        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
653        $snapshotId1 = 'test';
654        $input2 = new Sources([new Source('fixture.php', $source)]);
655        $profile = $execution->configuration->target;
656        $parser1 = new Parser(new ParserConfig($profile->version));
657        $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));
658        $program = new Index($snapshotId1, $trees1);
659        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
660        $caller = $context->program->callable('target');
661        self::assertNotNull($caller);
662        $paths = (new MethodInvocation(new Evaluator($context)))->candidates($caller, new BoundInstruction('call', 'invoke-method', $caller->source, 'result'), new State(), [], Term::parameter('box', 'Box'), 'BoX', 'run', new DispatchDecision(exhaustive: $exhaustive));
663        self::assertCount($expectedCount, $paths);
664        self::assertSame(1, $paths[0]->registers['result']->native());
665        self::assertSame($codes, array_column($context->frontiers, 'code'));
666    }
667    /**
668     * @return array<string,array{bool,string,int,list<string>}>
669     */
670    public static function providerWorldBounds(): array
671    {
672        return ['open' => [false, '', 3, ['OPEN_DISPATCH']], 'complete provider' => [true, '', 1, []], 'final declaration' => [false, 'final', 1, []]];
673    }
674    /**
675     * @param string $operation Method syntax
676     * @param Term $receiver Concrete or unresolved runtime receiver
677     * @param int $expected Selected source or provider result
678     */
679    #[DataProvider('providerProviderSelection')]
680    public function testApplyUsesProvidersForUnresolvedTargetsAndKeepsKnownSourceTargets(string $operation, Term $receiver, int $expected): void
681    {
682        $provider = self::createStub(DispatchProvider::class);
683        $provider->method('id')->willReturn('example.dispatch');
684        $provider->method('version')->willReturn('1');
685        $provider->method('resolve')->willReturn(new DispatchDecision([new DispatchTarget('provided')], true));
686        $source = '<?php class Box{static function run(){return 1;}}function provided(){return 2;}function target(){}';
687        $budget = new Budget();
688        $configuration = new DeriverConfig();
689        $contributions = new Contributions(providers: [$provider]);
690        $input = new Sources([new Source('fixture.php', $source)]);
691        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
692        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
693        $contributions1 = $providers->contributions;
694        $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);
695        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
696        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
697        $snapshotId = $identity->id;
698        $input1 = $providers->input;
699        $parser = new Parser(new ParserConfig($target->version));
700        $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));
701        $program1 = new Index($snapshotId, $trees);
702        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
703        $snapshotId1 = 'test';
704        $input2 = new Sources([new Source('fixture.php', $source)]);
705        $profile = $execution->configuration->target;
706        $parser1 = new Parser(new ParserConfig($profile->version));
707        $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));
708        $program = new Index($snapshotId1, $trees1);
709        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
710        $caller = $context->program->callable('target');
711        self::assertNotNull($caller);
712        $state = new State();
713        $state->registers = ['receiver' => $receiver, 'name' => Term::constant('run')];
714        $paths = (new MethodInvocation(new Evaluator($context)))->apply($caller, new BoundInstruction('call', $operation, $caller->source, 'result', ['receiver', 'name']), $state, []);
715        self::assertCount(1, $paths);
716        self::assertSame($expected, $paths[0]->registers['result']->native());
717        self::assertSame([], $context->frontiers);
718    }
719    /**
720     * @return array<string,array{string,Term,int}>
721     */
722    public static function providerProviderSelection(): array
723    {
724        return ['known static' => ['invoke-static', Term::constant('Box'), 1], 'known object' => ['invoke-method', new Term(TermKind::Object, 'box', attributes: ['class' => 'Box']), 1], 'unknown static' => ['invoke-static', Term::constant('Missing'), 2], 'unknown object' => ['invoke-method', new Term(TermKind::Object, 'box', attributes: ['class' => 'Missing']), 2], 'symbolic receiver' => ['invoke-method', Term::parameter('receiver', 'Missing'), 2]];
725    }
726    public function testCandidatesKeepsAnUnresolvedBoundaryWhenNoFeasibleImplementationExists(): void
727    {
728        $source = '<?php function target(){return 1;}';
729        $budget = new Budget();
730        $configuration = new DeriverConfig();
731        $contributions = new Contributions();
732        $input = new Sources([new Source('fixture.php', $source)]);
733        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
734        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
735        $contributions1 = $providers->contributions;
736        $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);
737        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
738        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
739        $snapshotId = $identity->id;
740        $input1 = $providers->input;
741        $parser = new Parser(new ParserConfig($target->version));
742        $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));
743        $program1 = new Index($snapshotId, $trees);
744        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
745        $snapshotId1 = 'test';
746        $input2 = new Sources([new Source('fixture.php', $source)]);
747        $profile = $execution->configuration->target;
748        $parser1 = new Parser(new ParserConfig($profile->version));
749        $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));
750        $program = new Index($snapshotId1, $trees1);
751        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
752        $caller = $context->program->callable('target');
753        self::assertNotNull($caller);
754        $paths = (new MethodInvocation(new Evaluator($context)))->candidates($caller, new BoundInstruction('call', 'invoke-method', $caller->source, 'result'), new State(), [], Term::parameter('receiver', 'Missing'), 'Missing', 'run', new DispatchDecision([new DispatchTarget('missing', condition: Term::constant(false))], true));
755        self::assertCount(2, $paths);
756        self::assertSame(['OPEN_DISPATCH'], array_column($context->frontiers, 'code'));
757    }
758    public function testHandledInvokesUserEvaluatorsOnATypeBoundWithoutSource(): void
759    {
760        $evaluator = new class (new CallDescriptor('example.missing-run', '1', 'Missing::run'), new SemanticPlan([Action::returns(Expression::literal(Term::constant(7)))])) implements CallEvaluator {
761            /**
762             * @param CallDescriptor $metadata Stable evaluator registration
763             * @param SemanticPlan $plan Ordered API semantics
764             */
765            public function __construct(public readonly CallDescriptor $metadata, public readonly SemanticPlan $plan)
766            {
767            }
768            /**
769             * @return CallDescriptor Stable registration
770             */
771            #[Override]
772            public function descriptor(): CallDescriptor
773            {
774                return $this->metadata;
775            }
776            /**
777             * @param CallDescription $call Selected target
778             * @return CallDecision Declarative fixture semantics
779             */
780            #[Override]
781            public function evaluate(CallDescription $call): CallDecision
782            {
783                return CallDecision::handled($this->plan);
784            }
785        };
786        $input = new Sources([new Source('fixture.php', '<?php function target(?Missing $value){return $value->run();}')]);
787        $configuration = new DeriverConfig();
788        $contributions = new Contributions(evaluators: [$evaluator]);
789        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
790        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
791        $contributions1 = $providers->contributions;
792        $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);
793        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
794        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
795        $snapshotId = $identity->id;
796        $input1 = $providers->input;
797        $parser = new Parser(new ParserConfig($target->version));
798        $trees = array_map(static fn (Source $source): File => (new Resolver())->resolve($parser->parse(new Source(Path::normalize($source->path), $source->contents, $source->declarationsOnly))), iterator_to_array($input1, false));
799        $program = new Index($snapshotId, $trees);
800        $session = new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics())));
801        $result = $session->derive(new ReturnQuery('target'));
802        self::assertSame([7, 'OPEN_DISPATCH'], array_map(static fn (Alternative $a): int|float|string|bool|null => $a->values['return']->literal, $result->normalOutcomes));
803        self::assertContains('Error', array_map(static fn (Exceptional $e): mixed => $e->exception->literal, $result->exceptionalOutcomes));
804        self::assertSame(['OPEN_DISPATCH'], array_column($result->frontiers, 'code'));
805    }
806    public function testHandledLeavesSelectedSourceImplementationsAndUnhandledTypesToDispatch(): void
807    {
808        $evaluator = new class (new CallDescriptor('example.missing-run', '1', 'Missing::run'), new SemanticPlan([Action::returns(Expression::literal(Term::constant(7)))])) implements CallEvaluator {
809            /**
810             * @param CallDescriptor $metadata Stable evaluator registration
811             * @param SemanticPlan $plan Ordered API semantics
812             */
813            public function __construct(public readonly CallDescriptor $metadata, public readonly SemanticPlan $plan)
814            {
815            }
816            /**
817             * @return CallDescriptor Stable registration
818             */
819            #[Override]
820            public function descriptor(): CallDescriptor
821            {
822                return $this->metadata;
823            }
824            /**
825             * @param CallDescription $call Selected target
826             * @return CallDecision Declarative fixture semantics
827             */
828            #[Override]
829            public function evaluate(CallDescription $call): CallDecision
830            {
831                return CallDecision::handled($this->plan);
832            }
833        };
834        $source = '<?php function target(){return 1;}';
835        $budget = new Budget();
836        $configuration = new DeriverConfig();
837        $contributions = new Contributions(evaluators: [$evaluator]);
838        $input = new Sources([new Source('fixture.php', $source)]);
839        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
840        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
841        $contributions1 = $providers->contributions;
842        $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);
843        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
844        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
845        $snapshotId = $identity->id;
846        $input1 = $providers->input;
847        $parser = new Parser(new ParserConfig($target->version));
848        $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));
849        $program1 = new Index($snapshotId, $trees);
850        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
851        $snapshotId1 = 'test';
852        $input2 = new Sources([new Source('fixture.php', $source)]);
853        $profile = $execution->configuration->target;
854        $parser1 = new Parser(new ParserConfig($profile->version));
855        $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));
856        $program = new Index($snapshotId1, $trees1);
857        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
858        $caller = $context->program->callable('target');
859        self::assertNotNull($caller);
860        $invocation = new MethodInvocation(new Evaluator($context));
861        $instruction = new BoundInstruction('call', 'invoke-method', $caller->source, 'result');
862        self::assertSame([], $invocation->handled($caller, $instruction, new State(), [], Term::parameter('receiver', 'Missing'), 'Missing', 'run', ['Missing' => 'Missing::run']));
863        self::assertSame([], $invocation->handled($caller, $instruction, new State(), [], Term::parameter('receiver', 'Other'), 'Other|null', 'run', []));
864    }
865    public function testReceiverBindsTheCurrentInstanceForStaticSyntaxOnlyWhenOneExists(): void
866    {
867        $source = '<?php function target(){return 1;}';
868        $budget = new Budget();
869        $configuration = new DeriverConfig();
870        $contributions = new Contributions();
871        $input = new Sources([new Source('fixture.php', $source)]);
872        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
873        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
874        $contributions1 = $providers->contributions;
875        $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);
876        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
877        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
878        $snapshotId = $identity->id;
879        $input1 = $providers->input;
880        $parser = new Parser(new ParserConfig($target->version));
881        $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));
882        $program1 = new Index($snapshotId, $trees);
883        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
884        $snapshotId1 = 'test';
885        $input2 = new Sources([new Source('fixture.php', $source)]);
886        $profile = $execution->configuration->target;
887        $parser1 = new Parser(new ParserConfig($profile->version));
888        $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));
889        $program = new Index($snapshotId1, $trees1);
890        $invocation = new MethodInvocation(new Evaluator(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)));
891        $state = new State();
892        $receiver = new Term(TermKind::Object, 'explicit', attributes: ['class' => 'Box']);
893        $current = new Term(TermKind::Object, 'current', attributes: ['class' => 'Box']);
894        $state->memory->write($state->local('this'), $current);
895        self::assertSame($receiver, $invocation->receiver($receiver, $state, 'Box', false));
896        self::assertSame($current, $invocation->receiver(Term::constant('self'), $state, 'Box', true));
897        self::assertNull($invocation->receiver(Term::constant('Box'), new State(), 'Box', true));
898    }
899    #[DataProvider('providerIdentities')]
900    public function testIdentityKeepsOnlyStableReceiverSpellings(Term $receiver, ?string $expected): void
901    {
902        $state = new State();
903        $source = '<?php function target(){return 1;}';
904        $budget = new Budget();
905        $configuration = new DeriverConfig();
906        $contributions = new Contributions();
907        $input = new Sources([new Source('fixture.php', $source)]);
908        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
909        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
910        $contributions1 = $providers->contributions;
911        $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);
912        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
913        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
914        $snapshotId = $identity->id;
915        $input1 = $providers->input;
916        $parser = new Parser(new ParserConfig($target->version));
917        $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));
918        $program1 = new Index($snapshotId, $trees);
919        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
920        $snapshotId1 = 'test';
921        $input2 = new Sources([new Source('fixture.php', $source)]);
922        $profile = $execution->configuration->target;
923        $parser1 = new Parser(new ParserConfig($profile->version));
924        $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));
925        $program = new Index($snapshotId1, $trees1);
926        $invocation = new MethodInvocation(new Evaluator(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators)));
927        $first = $invocation->identity($receiver, $state);
928        $second = $invocation->identity($receiver, $state);
929        self::assertSame($expected ?? 'parameter-object:0', $first);
930        self::assertSame($expected ?? 'parameter-object:1', $second);
931    }
932    /**
933     * @return iterable<string, array{Term, string|null}>
934     */
935    public static function providerIdentities(): iterable
936    {
937        yield 'parameter' => [Term::parameter('repo', 'Repo'), 'repo'];
938        yield 'external input' => [new Term(TermKind::External, 'object:this:Ctl::repo', attributes: ['type' => 'Repo']), 'object:this:Ctl::repo'];
939        yield 'stable property read' => [new Term(TermKind::Opaque, 'object:this:Ctl::repo', attributes: ['type' => 'Repo', 'stability' => 'state']), 'object:this:Ctl::repo'];
940        yield 'object' => [new Term(TermKind::Object, 'object:1', attributes: ['class' => 'Repo']), 'object:1'];
941        yield 'residual reason' => [Term::opaque('OPEN_DISPATCH', 'Repo'), null];
942        yield 'unnamed expression' => [new Term(TermKind::Binary, null, attributes: ['type' => 'Repo']), null];
943    }
944    /**
945     * @param Term $receiver Spelled target
946     * @param bool $static \Deriver\Deriver\Evaluator\Execution\Call\Member\Invocation syntax
947     * @param string $expected Called class
948     */
949    #[DataProvider('providerCalledClasses')]
950    public function testCalledClassForwardsEveryRelativeSpellingWithoutRebindingInstanceCalls(Term $receiver, bool $static, string $expected): void
951    {
952        $state = new State();
953        $state->lateStaticClass = 'Child';
954        $source = '<?php function target(){return 1;}';
955        $budget = new Budget();
956        $configuration = new DeriverConfig();
957        $contributions = new Contributions();
958        $input = new Sources([new Source('fixture.php', $source)]);
959        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
960        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
961        $contributions1 = $providers->contributions;
962        $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);
963        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
964        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
965        $snapshotId = $identity->id;
966        $input1 = $providers->input;
967        $parser = new Parser(new ParserConfig($target->version));
968        $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));
969        $program1 = new Index($snapshotId, $trees);
970        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
971        $snapshotId1 = 'test';
972        $input2 = new Sources([new Source('fixture.php', $source)]);
973        $profile = $execution->configuration->target;
974        $parser1 = new Parser(new ParserConfig($profile->version));
975        $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));
976        $program = new Index($snapshotId1, $trees1);
977        self::assertSame($expected, (new MethodInvocation(new Evaluator(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators))))->calledClass($receiver, $state, 'Resolved', $static));
978    }
979    /**
980     * @return array<string,array{Term,bool,string}>
981     */
982    public static function providerCalledClasses(): array
983    {
984        return ['self' => [Term::constant('SELF'), true, 'Child'], 'parent' => [Term::constant('PARENT'), true, 'Child'], 'static' => [Term::constant('STATIC'), true, 'Child'], 'explicit' => [Term::constant('Box'), true, 'Resolved'], 'instance' => [Term::constant('self'), false, 'Resolved'], 'symbolic class' => [new Term(TermKind::Opaque), true, 'Resolved']];
985    }
986    /**
987     * @throws JsonException If fixture metadata cannot be encoded
988     */
989    #[DataProvider('providerProgramsDynamicClassProgramsmethods')]
990    public function testApplySeparatesLiteralAndRuntimeClassOperands(string $source, string $expected): void
991    {
992        $symbol = 'target';
993        $input = new Sources([new Source('fixture.php', $source)]);
994        $configuration = new DeriverConfig();
995        $contributions = new Contributions();
996        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
997        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
998        $contributions1 = $providers->contributions;
999        $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);
1000        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
1001        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
1002        $snapshotId = $identity->id;
1003        $input1 = $providers->input;
1004        $parser = new Parser(new ParserConfig($target->version));
1005        $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));
1006        $program = new Index($snapshotId, $trees);
1007        $result = (new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics()))))->derive(new ReturnQuery($symbol));
1008        self::assertSame([], $result->frontiers);
1009        self::assertSame([], $result->sourceDiagnostics);
1010        self::assertSame([], $result->exceptionalOutcomes);
1011        self::assertCount(1, $result->normalOutcomes);
1012        self::assertSame(json_decode($expected, true, flags: JSON_THROW_ON_ERROR), $result->normalOutcomes[0]->values['return']->native());
1013    }
1014    /**
1015     * @return iterable<string,array{string,string}> Method and callable fixtures
1016     */
1017    public static function providerProgramsDynamicClassProgramsmethods(): iterable
1018    {
1019        $generated = [];
1020        $operations = ['new' => 'return get_class(new $class);', 'method' => 'return $class::value();', 'property' => 'return $class::$value;', 'instance' => 'return $object instanceof $class;', 'first-class' => '$callable=$class::value(...);return $callable();'];
1021        foreach (['self', 'parent', 'static', '\self', 'SELF', 'Box', '\bOx', 'Base'] as $class) {
1022            foreach ($operations as $name1 => $operation) {
1023                $known = in_array($class, ['Box', '\bOx', 'Base'], true);
1024                $expected = $name1 === 'instance' ? $known ? 'true' : 'false' : (!$known ? '"Error"' : ($name1 === 'new' ? $class === 'Base' ? '"Base"' : '"Box"' : ($class === 'Base' ? '3' : '7')));
1025                $source = '<?php class Base{public static $value=3;public static function value(){return 3;}}class Box extends Base{public static $value=7;public static function value(){return 7;}public static function run(){$object=new Box;$class=' . var_export($class, true) . ';try{' . $operation . '}catch(Throwable $e){return get_class($e);}}}function target(){return Box::run();}';
1026                $generated[$class . ' ' . $name1] = [$source, $expected];
1027            }
1028        }
1029        foreach (['self', 'parent', 'static'] as $class) {
1030            foreach ($operations as $name1 => $operation) {
1031                $body = str_replace('$class', $class, $operation);
1032                $expected = $name1 === 'instance' ? 'true' : ($name1 === 'new' ? $class === 'parent' ? '"Base"' : '"Box"' : ($class === 'parent' ? '3' : '7'));
1033                $generated['literal ' . $class . ' ' . $name1] = ['<?php class Base{public static $value=3;static function value(){return 3;}}class Box extends Base{public static $value=7;static function value(){return 7;}static function run(){$object=new Box;' . $body . '}}function target(){return Box::run();}', $expected];
1034            }
1035        }
1036        $generated['method arguments remain unevaluated'] = ['<?php class Box{static function value($x){return $x;}static function run(){$log=[];$class="self";try{$class::value($log[]=1);}catch(Error $e){}return $log;}}function target(){return Box::run();}', '[]'];
1037        $generated['constructor arguments remain unevaluated'] = ['<?php class Box{function __construct($x){}static function run(){$log=[];$class="self";try{new $class($log[]=1);}catch(Error $e){}return $log;}}function target(){return Box::run();}', '[]'];
1038        $generated['static syntax on an object'] = ['<?php class Box{static function value(){return 7;}}function target(){$object=new Box;return $object::value();}', '7'];
1039        $generated['static syntax on an enum'] = ['<?php enum E{case A;static function value(){return 7;}}function target(){$object=E::A;return $object::value();}', '7'];
1040        $generated['static property on an object'] = ['<?php class Box{static $value=7;}function target(){$object=new Box;return $object::$value;}', '7'];
1041        $generated['canonical class after first-class acquisition'] = ['<?php class Base{static function value(){return static::class;}}class Box extends Base{}function target(){$class="\bOx";$callable=$class::value(...);return $callable();}', '"Box"'];
1042        $generated['object instanceof object class'] = ['<?php class Box{}function target(){$bound=new Box;return new Box instanceof $bound;}', 'true'];
1043        $generated['closure instanceof closure class'] = ['<?php function target(){$bound=fn()=>1;return (fn()=>2) instanceof $bound;}', 'true'];
1044        $generated['object instanceof array rejected'] = ['<?php class Box{}function target(){$bound=[];try{return new Box instanceof $bound;}catch(Error $e){return "Error";}}', '"Error"'];
1045        $generated['object instanceof integer rejected'] = ['<?php class Box{}function target(){$bound=1;try{return new Box instanceof $bound;}catch(Error $e){return "Error";}}', '"Error"'];
1046        $generated['object instanceof null rejected'] = ['<?php class Box{}function target(){$bound=null;try{return new Box instanceof $bound;}catch(Error $e){return "Error";}}', '"Error"'];
1047        $generated['scalar instanceof invalid bound short circuits'] = ['<?php function target(){$bound=1;return 0 instanceof $bound;}', 'false'];
1048        $generated['allocation from an object'] = ['<?php class Box{}function target(){$class=new Box;return get_class(new $class);}', '"Box"'];
1049        $generated['object static nonstatic method rejected'] = ['<?php class Box{function value(){return 7;}}function target(){$object=new Box;try{return $object::value();}catch(Error $e){return "Error";}}', '"Error"'];
1050        $generated['literal called class is canonical'] = ['<?php class Box{static function value(){return static::class;}}function target(){return bOx::value();}', '"Box"'];
1051        $generated['dynamic called class is canonical'] = ['<?php class Box{static function value(){return static::class;}}function target(){$class="bOx";return $class::value();}', '"Box"'];
1052        foreach ($generated as $name => $case) {
1053            if (str_contains($name, 'method') || str_contains($name, 'first-class') || str_contains($name, 'called class') || str_contains($name, 'static syntax')) {
1054                yield $name => $case;
1055            }
1056        }
1057    }
1058}
1059