Language: eval() — compile and execute code string at runtime (zend_execute_API.c parity)

[PurHur]

Category

language

Status (refreshed 2026-06-02 — VM done, JIT/AOT tracked in #4652)

VM eval() is implemented (#3358 closed): ext/standard/VmEval.php compiles and executes strings in the caller scope. This issue remains the umbrella for remaining eval parity; workers should claim #4652 for JIT/AOT lowering.

Tier	State
VM	✅ repro below prints 42
JIT/AOT	❌ LogicException: eval() is VM-only — #4652

Problem

Zend eval() compiles and executes PHP source in the current scope, with ParseError on syntax failures. Native tiers must match or emit Zend-compatible fatals — not LogicException stubs.

php-src reference

• php/php-src ext/standard/basic_functions.c — zif_eval
• php/php-src Zend/zend_execute.c — zend_eval_stringl, zend_eval_string_ex
• php/php-src Zend/zend_compile.c — runtime compilation

Repro — VM (passes today)

Save as repro_eval_vm.php:

<?php
$x = 1;
eval('$x = $x + 41;');
echo $x, "\n";

./script/docker-exec.sh -- bash -lc 'source script/php-env.sh
php bin/vm.php repro_eval_vm.php    # 42
php repro_eval_vm.php               # Zend: 42
'

Repro — JIT/AOT (fails — #4652)

./script/docker-exec.sh -- bash -lc 'source script/php-env.sh
php bin/jit.php repro_eval_vm.php
php bin/compile.php repro_eval_vm.php /tmp/eval-test && /tmp/eval-test
'

Expected after #4652: 42 on all tiers.

Repro — parse error shape

<?php
try {
    eval('class {');
} catch (Throwable $e) {
    echo get_class($e), ':', $e->getMessage(), "\n";
}

Engine	Expected
Zend	ParseError: ...
VM	must be ParseError, not LogicException

Scope (this repo)

Area	Files
VM	ext/standard/VmEval.php, eval_.php — done (#3358)
JIT/AOT	#4652 — eval_.php::call(), AOT runtime bridge
Tests	test/compliance/cases/language/eval_*.phpt

Done when

• Language: eval() — JIT/AOT lowering in caller scope (phase 2 of #4410 / #3358) #4652 merged — JIT/AOT repro prints 42
• Parse-error repro throws ParseError on VM/JIT/AOT
• ./script/ci-fast.sh --filter eval_ green
• Close this umbrella when Language: eval() — JIT/AOT lowering in caller scope (phase 2 of #4410 / #3358) #4652 is green

Links

• Language: eval() — JIT/AOT lowering in caller scope (phase 2 of #4410 / #3358) #4652 — JIT/AOT worker issue (claim this for implementation)
• Runtime: eval() — dynamic PHP execution (ext/standard/basic_functions.c parity) #3358 — closed VM path
• North star: Epic: Self-host critical path — compiler compiles itself (M3→M5) #1492

[PurHur]

Add’l parity notes (to make this fully implementation-ready):

php-src tests to mirror

• Zend/tests/eval/*.phpt
• Zend/tests/bug*eval*.phpt (scattered eval regressions)

Extra repro cases (Zend behavior)

eval return value / last expression

<?php
var_dump(eval('1+2;'));       // NULL (statement; eval returns NULL unless `return` used)
var_dump(eval('return 7;'));  // int(7)

scope + variables

<?php
function f() {
  $x = 1;
  eval('$x += 41;');
  return $x;
}
var_dump(f()); // int(42)

parse error shape

<?php
try { eval('function {'); } catch (Throwable $e) { echo get_class($e), "\n"; }

Zend: parse errors from eval are ParseError (message/location formatting matters).

$this binding

<?php
class C { function g(){ $x=1; eval('var_dump(isset($this), $x);'); } }
(new C)->g();

Done-when extension

• Match Zend for return inside eval, function-scope variable mutation, and ParseError type.
• Ensure eval’d chunk uses the correct file/line metadata format (php-src uses something like eval()'d code / eval()'d code on line X).

[PurHur]

Addendum: acceptance criteria for eval() should cover parse errors + return value + scope.

Extra repro cases

1. Return value:

<?php
var_dump(eval('return 2 + 40;'));

Expected (Zend): int(42)

2. Parse error shape:

<?php
try {
  eval('this is not php');
} catch (ParseError $e) {
  echo 'parse_error', "\n";
}

Expected (Zend): prints parse_error

3. Local scope capture already in issue body; ensure both $x read and write work.

php-src pointers

• Zend/zend_execute_API.c — zend_eval_stringl* error handling / return value
• Zend/zend_exceptions.c / error classes for ParseError

Done when (tightened)

• All three repro cases match Zend under phpc run (VM)

[PurHur]

Spec expansion (make this more implementation-ready)

Additional php-src references

• Zend/zend_language_parser.y / Zend/zend_language_scanner.l — parse errors surfaced by eval
• Zend/zend_compile.c — compile_string() / zend_compile_string() pathways used by eval

Edge-case repros to match Zend

1. Return value of eval

<?php
var_dump(eval('return 2 + 3;'));
var_dump(eval('$x = 1;'));

Expected (Zend):

• First is int(5)
• Second is NULL

2. ParseError classification + message shape

<?php
try {
  eval('function () {');
} catch (Throwable $e) {
  echo get_class($e), "\n";
  echo $e->getMessage(), "\n";
}

Expected (Zend): ParseError with a message that includes syntax error.

3. Scope behavior (eval runs in caller scope; $this available inside methods)

<?php
class C {
  public int $x = 1;
  public function run(): void {
    eval('$this->x = $this->x + 41;');
    echo $this->x, "\n";
  }
}
(new C())->run();

Expected (Zend): prints 42.

Done-when additions

• Return-value + ParseError + $this scope repros match Zend
• eval’d code participates in require_once/class/function table like Zend (no duplicate declarations across runs)

[PurHur]

claim: cursor-agent-lane-a — starting this run

[PurHur]

Handoff: VM + JIT eval compliance green (26/26 filter except 2 AOT fixtures). AOT compile fails module-wide on master (even echo 42 LLVM verify) — not eval-specific; blocked until LLVM regressions land (see open PR #7635). Pivoting lane A to #5046.

[PurHur]

claim: cursor-agent-lane-a — continuing AOT eval compile failures (2 AOT fixtures red)

[PurHur]

Merged via #7653.

Verification (docker-exec tar-fallback):
```bash
./script/docker-exec.sh -- bash -lc 'source script/php-env.sh
vendor/bin/phpunit --filter "EvalBuiltinTest|EvalJitTest"
'
```
`OK (9 tests, 9 assertions)` — VM + JIT eval compliance including ParseError throw, eval()'d code file metadata, and $this scope.

Remaining gap: AOT `eval_*` link fixtures still hit LLVM module-verify failures under docker-exec tar-fallback on this harness (pre-existing all-AOT regression). VM/JIT eval parity for #4410 is green.