packages/deriver/tests/Unit/Deriver/Evaluator/Execution/Transfer/PropertyTransferTest.php

1<?php
2
3declare (strict_types=1);
4
5namespace Tests\Unit\Deriver\Evaluator\Execution\Transfer;
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\Library;
14use Deriver\Deriver\Evaluator\Call\BoundInstruction;
15use Deriver\Deriver\Evaluator\Call\Evaluators;
16use Deriver\Deriver\Evaluator\Call\Extensions;
17use Deriver\Deriver\Evaluator\Call\Provider\DispatchDecision;
18use Deriver\Deriver\Evaluator\Call\Registrations;
19use Deriver\Deriver\Evaluator\Call\StateRegistry;
20use Deriver\Deriver\Evaluator\EvaluatorConfig;
21use Deriver\Deriver\Evaluator\Evidence\Frontier;
22use Deriver\Deriver\Evaluator\Execution\Call\Allocation;
23use Deriver\Deriver\Evaluator\Execution\Call\ArgumentBinding;
24use Deriver\Deriver\Evaluator\Execution\Call\ArgumentOrder;
25use Deriver\Deriver\Evaluator\Execution\Call\CallableCheck;
26use Deriver\Deriver\Evaluator\Execution\Call\CallExecutor;
27use Deriver\Deriver\Evaluator\Execution\Call\CallResolution;
28use Deriver\Deriver\Evaluator\Execution\Call\Creation\Access;
29use Deriver\Deriver\Evaluator\Execution\Call\Member\Invocation;
30use Deriver\Deriver\Evaluator\Execution\Call\MethodInvocation;
31use Deriver\Deriver\Evaluator\Execution\Call\Native\Invocation as NativeInvocation;
32use Deriver\Deriver\Evaluator\Execution\Call\Native\Properties;
33use Deriver\Deriver\Evaluator\Execution\Call\Native\Signatures;
34use Deriver\Deriver\Evaluator\Execution\Call\ParameterBinding;
35use Deriver\Deriver\Evaluator\Execution\Call\PassedArgument;
36use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Arguments;
37use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Creation;
38use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Methods;
39use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Modes;
40use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Resolution;
41use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Target;
42use Deriver\Deriver\Evaluator\Execution\Call\Preparation\Transfer;
43use Deriver\Deriver\Evaluator\Execution\Call\TypeBinding;
44use Deriver\Deriver\Evaluator\Execution\Call\TypeCheck;
45use Deriver\Deriver\Evaluator\Execution\Call\UnknownCall;
46use Deriver\Deriver\Evaluator\Execution\Completion\Alternative;
47use Deriver\Deriver\Evaluator\Execution\Completion\Assessment;
48use Deriver\Deriver\Evaluator\Execution\Completion\Completion;
49use Deriver\Deriver\Evaluator\Execution\Completion\CompletionKind;
50use Deriver\Deriver\Evaluator\Execution\Completion\Exceptional;
51use Deriver\Deriver\Evaluator\Execution\Completion\StorageSnapshot;
52use Deriver\Deriver\Evaluator\Execution\Constant\ClassNames;
53use Deriver\Deriver\Evaluator\Execution\Constraints;
54use Deriver\Deriver\Evaluator\Execution\Context;
55use Deriver\Deriver\Evaluator\Execution\Control\ExceptionChain;
56use Deriver\Deriver\Evaluator\Execution\Control\ExceptionMatch;
57use Deriver\Deriver\Evaluator\Execution\Control\Handler;
58use Deriver\Deriver\Evaluator\Execution\Control\ObservationLimit;
59use Deriver\Deriver\Evaluator\Execution\Control\StateJoin;
60use Deriver\Deriver\Evaluator\Execution\Control\Unwinding;
61use Deriver\Deriver\Evaluator\Execution\Demand\Discovery;
62use Deriver\Deriver\Evaluator\Execution\Dependencies;
63use Deriver\Deriver\Evaluator\Execution\Evaluator;
64use Deriver\Deriver\Evaluator\Execution\EvaluatorConfig as ExecutionEvaluatorConfig;
65use Deriver\Deriver\Evaluator\Execution\Havoc;
66use Deriver\Deriver\Evaluator\Execution\InstructionTransfer;
67use Deriver\Deriver\Evaluator\Execution\Memory\Location;
68use Deriver\Deriver\Evaluator\Execution\Memory\Materialization;
69use Deriver\Deriver\Evaluator\Execution\Memory\Memory;
70use Deriver\Deriver\Evaluator\Execution\Memory\ReferenceConstraint;
71use Deriver\Deriver\Evaluator\Execution\Memory\Slots\SlotReference;
72use Deriver\Deriver\Evaluator\Execution\Memory\Slots\StateStorage;
73use Deriver\Deriver\Evaluator\Execution\Memory\StorageCapture;
74use Deriver\Deriver\Evaluator\Execution\ObservationCollector;
75use Deriver\Deriver\Evaluator\Execution\Offset\Address;
76use Deriver\Deriver\Evaluator\Execution\Offset\Path;
77use Deriver\Deriver\Evaluator\Execution\Offset\Transfer as OffsetTransfer;
78use Deriver\Deriver\Evaluator\Execution\Operation\Conversions;
79use Deriver\Deriver\Evaluator\Execution\Operation\ScalarErrors;
80use Deriver\Deriver\Evaluator\Execution\State;
81use Deriver\Deriver\Evaluator\Execution\Summary\Evaluation;
82use Deriver\Deriver\Evaluator\Execution\Summary\Isolation;
83use Deriver\Deriver\Evaluator\Execution\Trace\Derivation;
84use Deriver\Deriver\Evaluator\Execution\Transfer\MemoryStep;
85use Deriver\Deriver\Evaluator\Execution\Transfer\ObjectAccess;
86use Deriver\Deriver\Evaluator\Execution\Transfer\PropertyAccessCheck;
87use Deriver\Deriver\Evaluator\Execution\Transfer\PropertyLookup;
88use Deriver\Deriver\Evaluator\Execution\Transfer\PropertyMagic;
89use Deriver\Deriver\Evaluator\Execution\Transfer\PropertyReference;
90use Deriver\Deriver\Evaluator\Execution\Transfer\PropertySlot;
91use Deriver\Deriver\Evaluator\Execution\Transfer\PropertyTransfer;
92use Deriver\Deriver\Evaluator\Execution\Transfer\PureStep;
93use Deriver\Deriver\Evaluator\Execution\Transfer\ReferenceAssignment;
94use Deriver\Deriver\Evaluator\Request\Budget;
95use Deriver\Deriver\Evaluator\Request\EntryPoint;
96use Deriver\Deriver\Evaluator\Request\QueryScope;
97use Deriver\Deriver\Evaluator\Request\ReturnQuery;
98use Deriver\Deriver\Evaluator\Scalar\Arithmetic;
99use Deriver\Deriver\Evaluator\Scalar\Arrays;
100use Deriver\Deriver\Evaluator\Scalar\Identity;
101use Deriver\Deriver\Evaluator\Scalar\Increment;
102use Deriver\Deriver\Evaluator\Scalar\NumericString;
103use Deriver\Deriver\Evaluator\Scalar\Operations;
104use Deriver\Deriver\Evaluator\TargetProfile;
105use Deriver\Deriver\Evaluator\Term;
106use Deriver\Deriver\Evaluator\TermKind;
107use Deriver\Deriver\Execution\DerivationResult;
108use Deriver\Deriver\Execution\QueryExecution;
109use Deriver\Deriver\Execution\ResultAssessment;
110use Deriver\Deriver\Identity\QueryEncoding;
111use Deriver\Deriver\Identity\ValueGraph;
112use Deriver\Deriver\Lowerer\AggregateLowering;
113use Deriver\Deriver\Lowerer\AssignmentLowering;
114use Deriver\Deriver\Lowerer\CallLowering;
115use Deriver\Deriver\Lowerer\Control\ConditionalLowering;
116use Deriver\Deriver\Lowerer\Control\DestructuringLowering;
117use Deriver\Deriver\Lowerer\Control\ExceptionLowering;
118use Deriver\Deriver\Lowerer\Declaration\CallableIdentity;
119use Deriver\Deriver\Lowerer\Declaration\CallableSource;
120use Deriver\Deriver\Lowerer\Declaration\ConstantSignatures;
121use Deriver\Deriver\Lowerer\Declaration\Index;
122use Deriver\Deriver\Lowerer\Declaration\Indexer;
123use Deriver\Deriver\Lowerer\Declaration\Metadata\ClassDeclaration;
124use Deriver\Deriver\Lowerer\Declaration\Metadata\PropertyDeclaration;
125use Deriver\Deriver\Lowerer\Declaration\Traits\Composition;
126use Deriver\Deriver\Lowerer\EffectInspection;
127use Deriver\Deriver\Lowerer\ExpressionLowering;
128use Deriver\Deriver\Lowerer\Graph\Argument;
129use Deriver\Deriver\Lowerer\Graph\BasicBlock;
130use Deriver\Deriver\Lowerer\Graph\CallableGraph;
131use Deriver\Deriver\Lowerer\Graph\CatchTarget;
132use Deriver\Deriver\Lowerer\Graph\ExceptionRegion;
133use Deriver\Deriver\Lowerer\Graph\Instruction;
134use Deriver\Deriver\Lowerer\Graph\Parameter;
135use Deriver\Deriver\Lowerer\Graph\Terminator;
136use Deriver\Deriver\Lowerer\Hierarchy\Access as HierarchyAccess;
137use Deriver\Deriver\Lowerer\Hierarchy\Builtins;
138use Deriver\Deriver\Lowerer\Hierarchy\Dispatch;
139use Deriver\Deriver\Lowerer\InstructionEmitter;
140use Deriver\Deriver\Lowerer\Lowerer;
141use Deriver\Deriver\Lowerer\LoweringScope;
142use Deriver\Deriver\Lowerer\StatementLowering;
143use Deriver\Deriver\MicroEvaluatorConversion;
144use Deriver\Deriver\Parser\Node\File;
145use Deriver\Deriver\Parser\Parser;
146use Deriver\Deriver\Parser\ParserConfig;
147use Deriver\Deriver\Parser\TargetSyntax;
148use Deriver\Deriver\Providers\ProviderExpansion;
149use Deriver\Deriver\Resolver\AssignmentPatterns;
150use Deriver\Deriver\Resolver\ClassScope;
151use Deriver\Deriver\Resolver\ExpressionValidation;
152use Deriver\Deriver\Resolver\MagicContext;
153use Deriver\Deriver\Resolver\Resolver;
154use Deriver\Deriver\Selection\QueryValidation;
155use Deriver\Deriver\SnapshotIdentity;
156use Deriver\Deriver\Sources\LineMap;
157use Deriver\Deriver\Sources\Path as SourcesPath;
158use Deriver\Deriver\Sources\Source;
159use Deriver\Deriver\Sources\SourceRef;
160use Deriver\Deriver\Sources\Sources;
161use Deriver\Exception\ParserException;
162use Deriver\Exception\ResolutionException;
163use PHPUnit\Framework\Attributes\CoversClass;
164use PHPUnit\Framework\Attributes\DataProvider;
165use PHPUnit\Framework\Attributes\Small;
166use PHPUnit\Framework\Attributes\UsesClass;
167use PHPUnit\Framework\TestCase;
168
169/**
170 * @covers \Deriver\Deriver\Evaluator\Execution\Transfer\PropertyTransfer
171 */
172#[UsesClass(Resolver::class)]
173#[UsesClass(ExpressionValidation::class)]
174#[UsesClass(ResolutionException::class)]
175#[UsesClass(ParserConfig::class)]
176#[UsesClass(ParserException::class)]
177#[CoversClass(PropertyTransfer::class)]
178#[UsesClass(QueryExecution::class)]
179#[UsesClass(QueryValidation::class)]
180#[UsesClass(ResultAssessment::class)]
181#[UsesClass(Deriver::class)]
182#[UsesClass(Constraints::class)]
183#[UsesClass(Argument::class)]
184#[UsesClass(BasicBlock::class)]
185#[UsesClass(CallableGraph::class)]
186#[UsesClass(CallableIdentity::class)]
187#[UsesClass(CatchTarget::class)]
188#[UsesClass(ClassDeclaration::class)]
189#[UsesClass(ExceptionRegion::class)]
190#[UsesClass(Instruction::class)]
191#[UsesClass(Parameter::class)]
192#[UsesClass(PropertyDeclaration::class)]
193#[UsesClass(Terminator::class)]
194#[UsesClass(Allocation::class)]
195#[UsesClass(ArgumentBinding::class)]
196#[UsesClass(ArgumentOrder::class)]
197#[UsesClass(CallExecutor::class)]
198#[UsesClass(CallResolution::class)]
199#[UsesClass(CallableCheck::class)]
200#[UsesClass(Access::class)]
201#[UsesClass(Builtins::class)]
202#[UsesClass(Dispatch::class)]
203#[UsesClass(HierarchyAccess::class)]
204#[UsesClass(Invocation::class)]
205#[UsesClass(MethodInvocation::class)]
206#[UsesClass(NativeInvocation::class)]
207#[UsesClass(Properties::class)]
208#[UsesClass(Signatures::class)]
209#[UsesClass(ParameterBinding::class)]
210#[UsesClass(PassedArgument::class)]
211#[UsesClass(Arguments::class)]
212#[UsesClass(Creation::class)]
213#[UsesClass(Methods::class)]
214#[UsesClass(Modes::class)]
215#[UsesClass(Resolution::class)]
216#[UsesClass(Target::class)]
217#[UsesClass(Transfer::class)]
218#[UsesClass(TypeBinding::class)]
219#[UsesClass(TypeCheck::class)]
220#[UsesClass(UnknownCall::class)]
221#[UsesClass(Completion::class)]
222#[UsesClass(ClassNames::class)]
223#[UsesClass(Context::class)]
224#[UsesClass(ExceptionChain::class)]
225#[UsesClass(ExceptionMatch::class)]
226#[UsesClass(Handler::class)]
227#[UsesClass(ObservationLimit::class)]
228#[UsesClass(StateJoin::class)]
229#[UsesClass(Unwinding::class)]
230#[UsesClass(Discovery::class)]
231#[UsesClass(Dependencies::class)]
232#[UsesClass(Havoc::class)]
233#[UsesClass(InstructionTransfer::class)]
234#[UsesClass(Evaluator::class)]
235#[UsesClass(SlotReference::class)]
236#[UsesClass(StateStorage::class)]
237#[UsesClass(ObservationCollector::class)]
238#[UsesClass(Address::class)]
239#[UsesClass(Path::class)]
240#[UsesClass(OffsetTransfer::class)]
241#[UsesClass(Conversions::class)]
242#[UsesClass(ScalarErrors::class)]
243#[UsesClass(State::class)]
244#[UsesClass(Evaluation::class)]
245#[UsesClass(Isolation::class)]
246#[UsesClass(MemoryStep::class)]
247#[UsesClass(ObjectAccess::class)]
248#[UsesClass(PropertyAccessCheck::class)]
249#[UsesClass(PropertyLookup::class)]
250#[UsesClass(PropertyMagic::class)]
251#[UsesClass(PropertyReference::class)]
252#[UsesClass(PropertySlot::class)]
253#[UsesClass(PureStep::class)]
254#[UsesClass(ReferenceAssignment::class)]
255#[UsesClass(Location::class)]
256#[UsesClass(Materialization::class)]
257#[UsesClass(Memory::class)]
258#[UsesClass(ReferenceConstraint::class)]
259#[UsesClass(StorageCapture::class)]
260#[UsesClass(Library::class)]
261#[UsesClass(DispatchDecision::class)]
262#[UsesClass(Extensions::class)]
263#[UsesClass(ProviderExpansion::class)]
264#[UsesClass(Evaluators::class)]
265#[UsesClass(StateRegistry::class)]
266#[UsesClass(DeriverConfig::class)]
267#[UsesClass(EntryPoint::class)]
268#[UsesClass(Sources::class)]
269#[UsesClass(SourcesPath::class)]
270#[UsesClass(Snapshot::class)]
271#[UsesClass(Source::class)]
272#[UsesClass(TargetProfile::class)]
273#[UsesClass(Budget::class)]
274#[UsesClass(QueryScope::class)]
275#[UsesClass(ReturnQuery::class)]
276#[UsesClass(ResultRef::class)]
277#[UsesClass(SourceRef::class)]
278#[UsesClass(Alternative::class)]
279#[UsesClass(Assessment::class)]
280#[UsesClass(Derivation::class)]
281#[UsesClass(DerivationResult::class)]
282#[UsesClass(Exceptional::class)]
283#[UsesClass(Frontier::class)]
284#[UsesClass(QueryEncoding::class)]
285#[UsesClass(ValueGraph::class)]
286#[UsesClass(Statistics::class)]
287#[UsesClass(StorageSnapshot::class)]
288#[UsesClass(Parser::class)]
289#[UsesClass(File::class)]
290#[UsesClass(AggregateLowering::class)]
291#[UsesClass(AssignmentLowering::class)]
292#[UsesClass(CallLowering::class)]
293#[UsesClass(Lowerer::class)]
294#[UsesClass(ConditionalLowering::class)]
295#[UsesClass(DestructuringLowering::class)]
296#[UsesClass(ExceptionLowering::class)]
297#[UsesClass(EffectInspection::class)]
298#[UsesClass(ExpressionLowering::class)]
299#[UsesClass(InstructionEmitter::class)]
300#[UsesClass(LoweringScope::class)]
301#[UsesClass(StatementLowering::class)]
302#[UsesClass(ConstantSignatures::class)]
303#[UsesClass(CallableSource::class)]
304#[UsesClass(Indexer::class)]
305#[UsesClass(Index::class)]
306#[UsesClass(Composition::class)]
307#[UsesClass(LineMap::class)]
308#[UsesClass(MagicContext::class)]
309#[UsesClass(AssignmentPatterns::class)]
310#[UsesClass(ClassScope::class)]
311#[UsesClass(TargetSyntax::class)]
312#[UsesClass(Arithmetic::class)]
313#[UsesClass(Arrays::class)]
314#[UsesClass(Identity::class)]
315#[UsesClass(Increment::class)]
316#[UsesClass(NumericString::class)]
317#[UsesClass(Operations::class)]
318#[UsesClass(Term::class)]
319#[Small]
320final class PropertyTransferTest extends TestCase
321{
322    public function testApplyHandlesInaccessibleSilentReads(): void
323    {
324        $source = '<?php class B{private $x=1;}function target(){$b=new B;return [isset($b->x),$b->x??9,empty($b->x)];}';
325        $symbol = 'target';
326        $input = new Sources([new Source('fixture.php', $source)]);
327        $configuration = new DeriverConfig();
328        $contributions = new Contributions();
329        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
330        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
331        $contributions1 = $providers->contributions;
332        $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);
333        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
334        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
335        $snapshotId = $identity->id;
336        $input1 = $providers->input;
337        $parser = new Parser(new ParserConfig($target->version));
338        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
339        $program = new Index($snapshotId, $trees);
340        $result = (new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics()))))->derive(new ReturnQuery($symbol));
341        self::assertSame([], $result->frontiers);
342        self::assertSame([], $result->exceptionalOutcomes);
343        self::assertCount(1, $result->normalOutcomes);
344        self::assertSame([false, 9, true], $result->normalOutcomes[0]->values['return']->native());
345    }
346    public function testWriteEnforcesReadonlyClasses(): void
347    {
348        $source = '<?php readonly class B{function __construct(public int $x){}}function target(){$b=new B(1);try{$b->x=2;}catch(Error $e){return $b->x;}return 999;}';
349        $symbol = 'target';
350        $input = new Sources([new Source('fixture.php', $source)]);
351        $configuration = new DeriverConfig();
352        $contributions = new Contributions();
353        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
354        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
355        $contributions1 = $providers->contributions;
356        $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);
357        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
358        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
359        $snapshotId = $identity->id;
360        $input1 = $providers->input;
361        $parser = new Parser(new ParserConfig($target->version));
362        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
363        $program = new Index($snapshotId, $trees);
364        $result = (new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics()))))->derive(new ReturnQuery($symbol));
365        self::assertSame([], $result->frontiers);
366        self::assertSame([], $result->exceptionalOutcomes);
367        self::assertCount(1, $result->normalOutcomes);
368        self::assertSame(1, $result->normalOutcomes[0]->values['return']->native());
369    }
370    public function testInitializeEvaluatesInheritedStaticDefaults(): void
371    {
372        $source = '<?php class A{public static int $x=1+2;}class B extends A{}function target(){return B::$x;}';
373        $symbol = 'target';
374        $input = new Sources([new Source('fixture.php', $source)]);
375        $configuration = new DeriverConfig();
376        $contributions = new Contributions();
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(SourcesPath::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
387        $program = new Index($snapshotId, $trees);
388        $result = (new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics()))))->derive(new ReturnQuery($symbol));
389        self::assertSame(3, $result->normalOutcomes[0]->values['return']->native());
390    }
391    public function testErrorRetainsTheUnchangedMemory(): void
392    {
393        $state = new State();
394        $state->memory->write($state->local('x'), Term::constant(1));
395        $source = '<?php function target(){return 1;}';
396        $budget = new Budget();
397        $configuration = new DeriverConfig();
398        $contributions = new Contributions();
399        $input = new Sources([new Source('fixture.php', $source)]);
400        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
401        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
402        $contributions1 = $providers->contributions;
403        $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);
404        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
405        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
406        $snapshotId = $identity->id;
407        $input1 = $providers->input;
408        $parser = new Parser(new ParserConfig($target->version));
409        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
410        $program1 = new Index($snapshotId, $trees);
411        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
412        $snapshotId1 = 'test';
413        $input2 = new Sources([new Source('fixture.php', $source)]);
414        $profile = $execution->configuration->target;
415        $parser1 = new Parser(new ParserConfig($profile->version));
416        $trees1 = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser1->parse(new Source(SourcesPath::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input2, false));
417        $program = new Index($snapshotId1, $trees1);
418        $result = (new PropertyTransfer(new Evaluator(new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators))))->error($state, 'TypeError');
419        self::assertSame(CompletionKind::Throw, $result->completion->kind);
420        self::assertSame('TypeError', $result->completion->value?->literal);
421        self::assertSame(1, $result->snapshot()['x']->native());
422    }
423    public function testTransferChecksTheDeclaredTypeBeforeCommittingAWrite(): void
424    {
425        $source = '<?php declare(strict_types=1);class B{public int $x=1;}function target(){$b=new B;try{$b->x="42";}catch(TypeError $e){return $b->x;}return 999;}';
426        $symbol = 'target';
427        $input = new Sources([new Source('fixture.php', $source)]);
428        $configuration = new DeriverConfig();
429        $contributions = new Contributions();
430        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
431        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
432        $contributions1 = $providers->contributions;
433        $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);
434        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
435        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
436        $snapshotId = $identity->id;
437        $input1 = $providers->input;
438        $parser = new Parser(new ParserConfig($target->version));
439        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
440        $program = new Index($snapshotId, $trees);
441        $result = (new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics()))))->derive(new ReturnQuery($symbol));
442        self::assertSame(1, $result->normalOutcomes[0]->values['return']->native());
443    }
444    public function testWriteChecksEveryPropertySharingTheDestinationCell(): void
445    {
446        $source = '<?php class B{public int $x=1;public int|string $y=1;}function target(){$b=new B;$b->y=&$b->x;try{$b->y="word";}catch(TypeError $e){return [$b->x,$b->y];}return 999;}';
447        $symbol = 'target';
448        $input = new Sources([new Source('fixture.php', $source)]);
449        $configuration = new DeriverConfig();
450        $contributions = new Contributions();
451        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
452        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
453        $contributions1 = $providers->contributions;
454        $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);
455        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
456        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
457        $snapshotId = $identity->id;
458        $input1 = $providers->input;
459        $parser = new Parser(new ParserConfig($target->version));
460        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
461        $program = new Index($snapshotId, $trees);
462        $result = (new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics()))))->derive(new ReturnQuery($symbol));
463        self::assertSame([1, 1], $result->normalOutcomes[0]->values['return']->native());
464        self::assertSame([], $result->frontiers);
465    }
466    public function testUncertainRetainsErrorsAfterUnknownCallsCanUnsetTypedProperties(): void
467    {
468        $source = '<?php class B{public int $x=2;} function target(){$b=new B; $alias=$b; unknown($b); $after=5; try{return $alias->x;}catch(Error $e){return $after;}}';
469        $symbol = 'target';
470        $input = new Sources([new Source('fixture.php', $source)]);
471        $configuration = new DeriverConfig();
472        $contributions = new Contributions();
473        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
474        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
475        $contributions1 = $providers->contributions;
476        $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);
477        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
478        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
479        $snapshotId = $identity->id;
480        $input1 = $providers->input;
481        $parser = new Parser(new ParserConfig($target->version));
482        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
483        $program = new Index($snapshotId, $trees);
484        $result = (new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics()))))->derive(new ReturnQuery($symbol));
485        self::assertContains(5, array_map(static fn ($outcome) => $outcome->values['return']->literal, $result->normalOutcomes));
486    }
487    #[DataProvider('providerPropertyOperationContracts')]
488    public function testApplyPreservesPropertyValuesAndErrors(string $source, mixed $expected): void
489    {
490        $symbol = 'target';
491        $input = new Sources([new Source('fixture.php', $source)]);
492        $configuration = new DeriverConfig();
493        $contributions = new Contributions();
494        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
495        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
496        $contributions1 = $providers->contributions;
497        $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);
498        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
499        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
500        $snapshotId = $identity->id;
501        $input1 = $providers->input;
502        $parser = new Parser(new ParserConfig($target->version));
503        $trees = array_map(static fn (Source $source1): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source1->path), $source1->contents, $source1->declarationsOnly))), iterator_to_array($input1, false));
504        $program = new Index($snapshotId, $trees);
505        $result = (new QueryExecution($program, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program->diagnostics()))))->derive(new ReturnQuery($symbol));
506        self::assertSame([], $result->frontiers);
507        self::assertSame([], $result->exceptionalOutcomes);
508        self::assertCount(1, $result->normalOutcomes);
509        self::assertSame($expected, $result->normalOutcomes[0]->values['return']->native());
510    }
511    /**
512     * @return iterable<string, array{string,mixed}>
513     */
514    public static function providerPropertyOperationContracts(): iterable
515    {
516        yield 'typed uninitialized read' => ['<?php class B{public int $x;}function target(){$b=new B;try{return $b->x;}catch(Error $e){return "uninitialized";}}', 'uninitialized'];
517        yield 'nullable uninitialized silent' => ['<?php class B{public ?int $x;}function target(){$b=new B;return [isset($b->x),$b->x??8];}', [false, 8]];
518        yield 'typed reference rejects later write' => ['<?php class B{public int $x=1;}function target(){$b=new B;$r=&$b->x;try{$r="word";}catch(TypeError $e){return [$b->x,$r];}return 999;}', [1, 1]];
519        yield 'nullable reference initializes' => ['<?php class B{public ?int $x;}function target(){$b=new B;$r=&$b->x;return [$b->x,$r];}', [null, null]];
520        yield 'nonnullable reference fails' => ['<?php class B{public int $x;}function target(){$b=new B;try{$r=&$b->x;}catch(Error $e){return isset($b->x);}return 999;}', false];
521        yield 'alias coerces source' => ['<?php class B{public int $x=1;}function target(){$b=new B;$r="42";$b->x=&$r;return [$b->x,$r];}', [42, 42]];
522        yield 'increment typed property' => ['<?php class B{public int $x=1;}function target(){$b=new B;return [$b->x++,$b->x,++$b->x];}', [1, 2, 3]];
523        yield 'increment typed uninitialized' => ['<?php class B{public int $x;}function target(){$b=new B;try{$b->x++;}catch(Error $e){return isset($b->x);}return 999;}', false];
524        yield 'readonly unset inside before initialization' => ['<?php class B{public readonly int $x;function run(){unset($this->x);$this->x=4;return $this->x;}}function target(){return (new B)->run();}', 4];
525        yield 'readonly unset outside before initialization' => ['<?php class B{public readonly int $x;}function target(){$b=new B;try{unset($b->x);}catch(Error $e){return "blocked";}return "allowed";}', 'blocked'];
526        yield 'readonly unset after initialization' => ['<?php class B{public readonly int $x;function __construct(){$this->x=4;}function run(){try{unset($this->x);}catch(Error $e){return $this->x;}return 999;}}function target(){return (new B)->run();}', 4];
527        yield 'readonly initialize outside' => ['<?php class B{public readonly int $x;}function target(){$b=new B;try{$b->x=4;}catch(Error $e){return isset($b->x);}return 999;}', false];
528        yield 'readonly clone writes once' => ['<?php class B{function __construct(public readonly int $x){}function __clone(){$this->x=2;try{$this->x=3;}catch(Error $e){}}}function target(){$a=new B(1);$b=clone $a;return [$a->x,$b->x];}', [1, 2]];
529        yield 'readonly failed clone type retains opportunity' => ['<?php class B{function __construct(public readonly int $x){}function __clone(){try{$this->x=[];}catch(TypeError $e){}$this->x=3;}}function target(){$a=new B(1);$b=clone $a;return [$a->x,$b->x];}', [1, 3]];
530        yield 'static array default' => ['<?php class B{public static array $a=[1];}function target(){B::$a[]=2;return B::$a;}', [1, 2]];
531        yield 'static multiple defaults' => ['<?php class B{public static int $x=1;public static int $y=2;}function target(){B::$x=9;return [B::$x,B::$y,B::$x];}', [9, 2, 9]];
532        yield 'static null default' => ['<?php class B{public static $x;}function target(){return B::$x;}', null];
533        yield 'static typed no default' => ['<?php class B{public static int $x;}function target(){try{return B::$x;}catch(Error $e){return "uninitialized";}}', 'uninitialized'];
534        yield 'static default throws' => ['<?php class B{public static int $x=1/0;}function target(){try{return B::$x;}catch(DivisionByZeroError $e){return "division";}}', 'division'];
535        yield 'static missing property' => ['<?php class B{}function target(){try{return B::$missing;}catch(Error $e){return "missing";}}', 'missing'];
536        yield 'instance property as static' => ['<?php class B{public int $x=1;}function target(){try{return B::$x;}catch(Error $e){return "instance";}}', 'instance'];
537        yield 'inaccessible public read' => ['<?php class B{private int $x=1;}function target(){$b=new B;try{return $b->x;}catch(Error $e){return "private";}}', 'private'];
538        yield 'visible silent read' => ['<?php class B{public int $x=3;}function target(){$b=new B;return [isset($b->x),$b->x??8];}', [true, 3]];
539        yield 'magic private read' => ['<?php class B{private int $x=1;function __get($name){return "magic:".$name;}}function target(){return (new B)->x;}', 'magic:x'];
540        yield 'magic missing read' => ['<?php class B{function __get($name){return "magic:".$name;}}function target(){return (new B)->x;}', 'magic:x'];
541        yield 'magic not used for visible property' => ['<?php class B{public int $x=1;function __get($name){return 99;}}function target(){return (new B)->x;}', 1];
542        yield 'magic inaccessible write' => ['<?php class B{private int $x=1;public int $seen=0;function __set($name,$value){$this->seen=$value;}}function target(){$b=new B;$b->x=7;return $b->seen;}', 7];
543        yield 'readonly indirect array write' => ['<?php class B{function __construct(public readonly array $x){}}function target(){$b=new B([1]);try{$b->x[]=2;}catch(Error $e){return $b->x;}return 999;}', [1]];
544        yield 'readonly object handle mutation' => ['<?php class C{public int $x=1;}class B{function __construct(public readonly C $value){}}function target(){$b=new B(new C);$b->value->x=2;return $b->value->x;}', 2];
545        yield 'scalar property write fails' => ['<?php function target(){$a=1;try{$a->x=2;}catch(Error $e){return $a;}return 999;}', 1];
546        yield 'typed unset then initialize' => ['<?php class B{public int $x=1;}function target(){$b=new B;unset($b->x);$b->x=2;return $b->x;}', 2];
547    }
548    public function testWritePreservesBothTypeOutcomesAndTheirIndependentMemory(): void
549    {
550        $source1 = '<?php function target(){return 1;}';
551        $budget = new Budget();
552        $configuration = new DeriverConfig();
553        $contributions = new Contributions();
554        $input = new Sources([new Source('fixture.php', $source1)]);
555        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
556        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
557        $contributions1 = $providers->contributions;
558        $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);
559        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
560        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
561        $snapshotId = $identity->id;
562        $input1 = $providers->input;
563        $parser = new Parser(new ParserConfig($target->version));
564        $trees = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input1, false));
565        $program1 = new Index($snapshotId, $trees);
566        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
567        $snapshotId1 = 'test';
568        $input2 = new Sources([new Source('fixture.php', $source1)]);
569        $profile = $execution->configuration->target;
570        $parser1 = new Parser(new ParserConfig($profile->version));
571        $trees1 = array_map(static fn (Source $source3): File => (new Resolver())->resolve($parser1->parse(new Source(SourcesPath::normalize($source3->path), $source3->contents, $source3->declarationsOnly))), iterator_to_array($input2, false));
572        $program = new Index($snapshotId1, $trees1);
573        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
574        $source = new SourceRef('test', 'a.php', 0, 1);
575        $caller = new CallableGraph('target', [], [], $source, strict: true);
576        $state = new State();
577        $address = new Location('object:one', ['x']);
578        $before = Term::constant(1);
579        $state->memory->write($address, $before);
580        $argument = Term::parameter('input');
581        $state->registers['value'] = $argument;
582        $slot = new PropertySlot(new Term(TermKind::Object, 'one', attributes: ['class' => 'B']), 'x', 'B', new PropertyDeclaration('x', 'B', 'int'));
583        $instruction = new BoundInstruction('i', 'write', $source, 'result', ['address', 'value']);
584        $paths = (new PropertyTransfer(new Evaluator($context)))->write($caller, $instruction, $state, $slot, $address);
585        self::assertCount(2, $paths);
586        self::assertSame(CompletionKind::Normal, $paths[0]->completion->kind);
587        self::assertSame(TermKind::TypeRefinement, $paths[0]->memory->read($address)->kind);
588        self::assertSame([$argument], $paths[0]->memory->read($address)->operands);
589        self::assertSame('int', $paths[0]->memory->read($address)->attributes['type']);
590        self::assertSame($paths[0]->memory->read($address), $paths[0]->registers['result']);
591        self::assertSame(CompletionKind::Throw, $paths[1]->completion->kind);
592        self::assertSame('TypeError', $paths[1]->completion->value?->literal);
593        self::assertSame($before, $paths[1]->memory->read($address));
594        self::assertArrayNotHasKey('result', $paths[1]->registers);
595        self::assertNotSame($paths[0]->memory, $paths[1]->memory);
596    }
597    public function testWriteRejectsAnAbsentDeclarationWithoutTouchingStorage(): void
598    {
599        $source1 = '<?php function target(){return 1;}';
600        $budget = new Budget();
601        $configuration = new DeriverConfig();
602        $contributions = new Contributions();
603        $input = new Sources([new Source('fixture.php', $source1)]);
604        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
605        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
606        $contributions1 = $providers->contributions;
607        $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);
608        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
609        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
610        $snapshotId = $identity->id;
611        $input1 = $providers->input;
612        $parser = new Parser(new ParserConfig($target->version));
613        $trees = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input1, false));
614        $program1 = new Index($snapshotId, $trees);
615        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
616        $snapshotId1 = 'test';
617        $input2 = new Sources([new Source('fixture.php', $source1)]);
618        $profile = $execution->configuration->target;
619        $parser1 = new Parser(new ParserConfig($profile->version));
620        $trees1 = array_map(static fn (Source $source3): File => (new Resolver())->resolve($parser1->parse(new Source(SourcesPath::normalize($source3->path), $source3->contents, $source3->declarationsOnly))), iterator_to_array($input2, false));
621        $program = new Index($snapshotId1, $trees1);
622        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
623        $source = new SourceRef('test', 'a.php', 0, 1);
624        $caller = new CallableGraph('target', [], [], $source);
625        $state = new State();
626        $address = new Location('object:one', ['x']);
627        $slot = new PropertySlot(new Term(TermKind::Object, 'one', attributes: ['class' => 'B']), 'x', 'B', null);
628        $instruction = new BoundInstruction('i', 'write', $source, 'result', ['address', 'value']);
629        $paths = (new PropertyTransfer(new Evaluator($context)))->write($caller, $instruction, $state, $slot, $address);
630        self::assertSame([$state], $paths);
631        self::assertSame(CompletionKind::Throw, $paths[0]->completion->kind);
632        self::assertSame('Error', $paths[0]->completion->value?->literal);
633        self::assertSame([], $state->memory->cells);
634        self::assertSame([], $state->registers);
635    }
636    public function testWriteConsumesOnlyTheSuccessfulReadonlyCloneOpportunity(): void
637    {
638        $source1 = '<?php function target(){return 1;}';
639        $budget = new Budget();
640        $configuration = new DeriverConfig();
641        $contributions = new Contributions();
642        $input = new Sources([new Source('fixture.php', $source1)]);
643        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
644        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
645        $contributions1 = $providers->contributions;
646        $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);
647        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
648        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
649        $snapshotId = $identity->id;
650        $input1 = $providers->input;
651        $parser = new Parser(new ParserConfig($target->version));
652        $trees = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input1, false));
653        $program1 = new Index($snapshotId, $trees);
654        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
655        $snapshotId1 = 'test';
656        $input2 = new Sources([new Source('fixture.php', $source1)]);
657        $profile = $execution->configuration->target;
658        $parser1 = new Parser(new ParserConfig($profile->version));
659        $trees1 = array_map(static fn (Source $source3): File => (new Resolver())->resolve($parser1->parse(new Source(SourcesPath::normalize($source3->path), $source3->contents, $source3->declarationsOnly))), iterator_to_array($input2, false));
660        $program = new Index($snapshotId1, $trees1);
661        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
662        $source = new SourceRef('test', 'a.php', 0, 1);
663        $caller = new CallableGraph('target', [], [], $source, strict: true);
664        $state = new State();
665        $address = new Location('object:one', ['x']);
666        $state->memory->write($address, Term::constant(1));
667        $state->memory->cloneWrites[$address->root] = ['x' => true, 'other' => true];
668        $state->registers['value'] = Term::constant(2);
669        $slot = new PropertySlot(new Term(TermKind::Object, 'one', attributes: ['class' => 'B']), 'x', 'b', new PropertyDeclaration('x', 'B', 'int', readonly: true));
670        $instruction = new BoundInstruction('i', 'write', $source, 'result', ['address', 'value']);
671        $paths = (new PropertyTransfer(new Evaluator($context)))->write($caller, $instruction, $state, $slot, $address);
672        self::assertCount(1, $paths);
673        self::assertSame(CompletionKind::Normal, $paths[0]->completion->kind);
674        self::assertSame(2, $state->memory->read($address)->native());
675        self::assertSame(['other' => true], $state->memory->cloneWrites[$address->root]);
676        self::assertSame(2, $state->registers['result']->native());
677    }
678    #[DataProvider('providerUncertainProperty')]
679    public function testUncertainPreservesPresentAndAbsentPropertyStates(Term $value, string $reason): void
680    {
681        $source1 = '<?php function target(){return 1;}';
682        $budget = new Budget();
683        $configuration = new DeriverConfig();
684        $contributions = new Contributions();
685        $input = new Sources([new Source('fixture.php', $source1)]);
686        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
687        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
688        $contributions1 = $providers->contributions;
689        $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);
690        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
691        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
692        $snapshotId = $identity->id;
693        $input1 = $providers->input;
694        $parser = new Parser(new ParserConfig($target->version));
695        $trees = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input1, false));
696        $program1 = new Index($snapshotId, $trees);
697        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
698        $snapshotId1 = 'test';
699        $input2 = new Sources([new Source('fixture.php', $source1)]);
700        $profile = $execution->configuration->target;
701        $parser1 = new Parser(new ParserConfig($profile->version));
702        $trees1 = array_map(static fn (Source $source3): File => (new Resolver())->resolve($parser1->parse(new Source(SourcesPath::normalize($source3->path), $source3->contents, $source3->declarationsOnly))), iterator_to_array($input2, false));
703        $program = new Index($snapshotId1, $trees1);
704        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
705        $source = new SourceRef('test', 'a.php', 0, 1);
706        $caller = new CallableGraph('target', [], [], $source);
707        $state = new State();
708        $address = new Location('object:one', ['x']);
709        $state->memory->write($address, $value);
710        $state->addresses['address'] = $address;
711        $slot = new PropertySlot(new Term(TermKind::Object, 'one', attributes: ['class' => 'B']), 'x', 'B', new PropertyDeclaration('x', 'B', 'int'));
712        $instruction = new BoundInstruction('i', 'read', $source, 'result', ['address']);
713        $paths = (new PropertyTransfer(new Evaluator($context)))->uncertain($caller, $instruction, $state, $slot, $address);
714        self::assertNotNull($paths);
715        self::assertCount(2, $paths);
716        self::assertSame(CompletionKind::Normal, $paths[0]->completion->kind);
717        self::assertSame($reason, $paths[0]->registers['result']->literal);
718        self::assertSame($value->operands, $paths[0]->registers['result']->operands);
719        self::assertSame(['type' => 'int', 'origin' => 'custom'], $paths[0]->registers['result']->attributes);
720        self::assertSame(CompletionKind::Throw, $paths[1]->completion->kind);
721        self::assertSame('Error', $paths[1]->completion->value?->literal);
722        self::assertSame(TermKind::Uninitialized, $paths[1]->memory->read($address)->kind);
723        self::assertNotSame($paths[0]->memory, $paths[1]->memory);
724    }
725    /**
726     * @return iterable<string,array{Term,string}>
727     */
728    public static function providerUncertainProperty(): iterable
729    {
730        yield 'named' => [new Term(TermKind::Opaque, 'UNKNOWN_CALL', [Term::parameter('dependency')], ['type' => 'mixed', 'maybeUninitialized' => true, 'origin' => 'custom']), 'UNKNOWN_CALL'];
731        yield 'unnamed' => [new Term(TermKind::Opaque, attributes: ['type' => 'mixed', 'maybeUninitialized' => true, 'origin' => 'custom']), 'UNKNOWN_PROPERTY'];
732    }
733    public function testUncertainKeepsKnownPresenceWithoutForking(): void
734    {
735        $source1 = '<?php function target(){return 1;}';
736        $budget = new Budget();
737        $configuration = new DeriverConfig();
738        $contributions = new Contributions();
739        $input = new Sources([new Source('fixture.php', $source1)]);
740        $target = new TargetProfile($configuration->phpVersion, $configuration->integerBits, $configuration->floatPrecision);
741        $providers = new ProviderExpansion($input, array_map(Term::fromNative(...), $configuration->environment), $contributions);
742        $contributions1 = $providers->contributions;
743        $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);
744        $settings = new EvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators, array_map((new MicroEvaluatorConversion())->convert(...), $configuration->evaluators));
745        $identity = new SnapshotIdentity($providers->input, $settings, $evaluators, $providers->manifest);
746        $snapshotId = $identity->id;
747        $input1 = $providers->input;
748        $parser = new Parser(new ParserConfig($target->version));
749        $trees = array_map(static fn (Source $source2): File => (new Resolver())->resolve($parser->parse(new Source(SourcesPath::normalize($source2->path), $source2->contents, $source2->declarationsOnly))), iterator_to_array($input1, false));
750        $program1 = new Index($snapshotId, $trees);
751        $execution = new QueryExecution($program1, new ExecutionEvaluatorConfig($target, $providers->environment, $configuration->standardEvaluators), $evaluators, $identity->snapshot(array_map(Frontier::fromDiagnostic(...), $program1->diagnostics())));
752        $snapshotId1 = 'test';
753        $input2 = new Sources([new Source('fixture.php', $source1)]);
754        $profile = $execution->configuration->target;
755        $parser1 = new Parser(new ParserConfig($profile->version));
756        $trees1 = array_map(static fn (Source $source3): File => (new Resolver())->resolve($parser1->parse(new Source(SourcesPath::normalize($source3->path), $source3->contents, $source3->declarationsOnly))), iterator_to_array($input2, false));
757        $program = new Index($snapshotId1, $trees1);
758        $context = new Context($program, new ReturnQuery('target', budget: $budget), $execution->configuration, $execution->evaluators);
759        $source = new SourceRef('test', 'a.php', 0, 1);
760        $caller = new CallableGraph('target', [], [], $source);
761        $state = new State();
762        $address = new Location('object:one', ['x']);
763        $value = Term::constant(5);
764        $state->memory->write($address, $value);
765        $slot = new PropertySlot(new Term(TermKind::Object, 'one', attributes: ['class' => 'B']), 'x', 'B', new PropertyDeclaration('x', 'B', 'int'));
766        $instruction = new BoundInstruction('i', 'read', $source, 'result', ['address']);
767        $paths = (new PropertyTransfer(new Evaluator($context)))->uncertain($caller, $instruction, $state, $slot, $address);
768        self::assertNull($paths);
769        self::assertSame($value, $state->memory->read($address));
770        self::assertSame([], $state->registers);
771    }
772}
773