Generate the expected turbo extension version on autoloader dump

TurboExtensionEnabler no longer carries the expected version as a
hand-maintained constant. build/generate-turbo-manifest.php writes it into
vendor/turbo-extension-version.php from the same git computation the
extension's Makefile bakes into the binary (the short SHA of the last
commit touching turbo-ext/src), so a binary built from a checkout matches
that checkout by construction. The phar compilation dumps the autoloader
too and packs the file, so the phar carries the version of the commit it
was compiled from.

`make build-turbo` regenerates the file, so a rebuild after a
turbo-ext/src commit needs no extra dump. The `bump-turbo` target, the
follow-up "Bump expected turbo version" commits and the CI check of the
constant are gone; the workflows compare the built binaries against
`php build/turbo-extension-version.php`, and the compiler job checks the
version packed in the phar.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013qRnM7saDyd5yKXxJAnR7o

Author: ondrejmirtes

.github/workflows/phar.yml

@@ -120,6 +120,16 @@ jobs:
         working-directory: "compiler"
         run: "../tmp/phpstan.phar list"
 
+      # The autoloader dump generates the version TurboExtensionEnabler
+      # activates from git; without it in the phar, no turbo binary would
+      # ever activate.
+      - name: "Check the PHAR carries the expected turbo extension version"
+        run: |
+          BAKED="$(php -r 'echo require "phar://" . getcwd() . "/tmp/phpstan.phar/vendor/turbo-extension-version.php";')"
+          EXPECTED="$(php build/turbo-extension-version.php)"
+          echo "PHAR expects: $BAKED, last commit touching turbo-ext/src: $EXPECTED"
+          [ "$BAKED" = "$EXPECTED" ]
+
       - name: "Delete PHAR"
         run: "rm tmp/phpstan.phar"
 
@@ -244,7 +254,7 @@ jobs:
           echo "composer.lock: $INSTALLED, native engine ported against: $SUPPORTED_PHP_PARSER_VERSION"
           if [ "$INSTALLED" != "$SUPPORTED_PHP_PARSER_VERSION" ]; then
             echo "::error::nikic/php-parser was updated to $INSTALLED but turbo-ext/src/parser/ was ported against $SUPPORTED_PHP_PARSER_VERSION."
-            echo "::error::Update procedure: diff ParserAbstract.php helpers between the two versions (grammar tables need nothing — they are read at run time), run turbo-ext/bin/generate-parser-actions.php and port any flagged closure bodies via action-overrides/, run turbo-ext/tests/parser-corpus.php and turbo-ext/tests/parser-upstream-corpus.php until byte-identical, run the full suite, then bump SUPPORTED_PHP_PARSER_VERSION here and the extension version pin."
+            echo "::error::Update procedure: diff ParserAbstract.php helpers between the two versions (grammar tables need nothing — they are read at run time), run turbo-ext/bin/generate-parser-actions.php and port any flagged closure bodies via action-overrides/, run turbo-ext/tests/parser-corpus.php and turbo-ext/tests/parser-upstream-corpus.php until byte-identical, run the full suite, then bump SUPPORTED_PHP_PARSER_VERSION here."
             exit 1
           fi
 
@@ -253,17 +263,8 @@ jobs:
           php turbo-ext/bin/generate-parser-actions.php
           git diff --exit-code turbo-ext/src/parser/
 
-      - name: "Check TurboExtensionEnabler::EXPECTED_EXTENSION_VERSION against the last commit touching turbo-ext/src"
+      - name: "Check turbo-ext/VERSION.txt is not committed"
         run: |
-          EXPECTED_SHA="$(git log -1 --format=%H -- turbo-ext/src | cut -c1-7)"
-          ENABLER="$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"
-          echo "last commit touching turbo-ext/src:                $EXPECTED_SHA"
-          echo "TurboExtensionEnabler::EXPECTED_EXTENSION_VERSION: $ENABLER"
-          if [ "$ENABLER" != "$EXPECTED_SHA" ]; then
-            echo "::error::TurboExtensionEnabler::EXPECTED_EXTENSION_VERSION must be the short SHA of the last commit touching turbo-ext/src/."
-            echo "::error::After changing the native side, verify the implementations still match and add a follow-up commit setting the constant to that commit's short SHA (the binary bakes its version from git at build time). Compute it only after the change lands on the target branch — a pull request commit gets a new SHA when rebased."
-            exit 1
-          fi
           # VERSION.txt is generated into the phpstan/turbo-ext subsplit by
           # subsplit-turbo-ext.yml; a copy committed here would go stale and
           # silently win over git in phpize builds.
@@ -328,7 +329,7 @@ jobs:
       - name: "Verify the built extension reports the expected version"
         run: |
           REPORTED="$(php -d extension="$RUNNER_TEMP/turbo-ext/modules/phpstan_turbo.so" -r 'echo phpversion("phpstan_turbo");')"
-          EXPECTED="$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"
+          EXPECTED="$(php build/turbo-extension-version.php)"
           echo "built extension reports: $REPORTED, enabler expects: $EXPECTED"
           [ "$REPORTED" = "$EXPECTED" ]
 
@@ -646,7 +647,7 @@ jobs:
         if: env.ORIGIN_RUN_ID == ''
         run: |
           REPORTED="$(php -d extension="$PWD/turbo-ext/phpstan_turbo.so" -r 'echo phpversion("phpstan_turbo");')"
-          EXPECTED="$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"
+          EXPECTED="$(php build/turbo-extension-version.php)"
           echo "core + extension report: $REPORTED, enabler expects: $EXPECTED"
           [ "$REPORTED" = "$EXPECTED" ]
 
@@ -759,7 +760,7 @@ jobs:
         run: |
           docker exec -i alpine-build sh -e <<'EOF'
           REPORTED="$(php -d extension="$PWD/turbo-ext/phpstan_turbo.so" -r 'echo phpversion("phpstan_turbo");')"
-          EXPECTED="$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"
+          EXPECTED="$(php build/turbo-extension-version.php)"
           echo "core + extension report: $REPORTED, enabler expects: $EXPECTED"
           [ "$REPORTED" = "$EXPECTED" ]
           EOF
@@ -954,7 +955,7 @@ jobs:
       - name: "Verify the built extension reports the expected version"
         run: |
           REPORTED="$(php -d extension="$PWD/turbo-ext/phpstan_turbo.so" -r 'echo phpversion("phpstan_turbo");')"
-          EXPECTED="$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"
+          EXPECTED="$(php build/turbo-extension-version.php)"
           echo "built extension reports: $REPORTED, enabler expects: $EXPECTED"
           [ "$REPORTED" = "$EXPECTED" ]
           # the loader rejects a ts-mismatched binary, so php loading it above
@@ -1070,7 +1071,7 @@ jobs:
         run: |
           docker exec -i alpine-build sh -e <<'EOF'
           REPORTED="$(php -d extension="$PWD/turbo-ext/phpstan_turbo.so" -r 'echo phpversion("phpstan_turbo");')"
-          EXPECTED="$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"
+          EXPECTED="$(php build/turbo-extension-version.php)"
           echo "built extension reports: $REPORTED, enabler expects: $EXPECTED"
           [ "$REPORTED" = "$EXPECTED" ]
           [ "$(php -r 'echo (int) ((bool) PHP_ZTS);')" = "$PHP_ZTS" ]
@@ -1669,7 +1670,7 @@ jobs:
             cp "turbo-ext/$CORE" ext-out/
           fi
           REPORTED="$(php -d extension="$(cygpath -w "$PWD/ext-out/php_phpstan_turbo.dll")" -r 'echo phpversion("phpstan_turbo");')"
-          EXPECTED="$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"
+          EXPECTED="$(php build/turbo-extension-version.php)"
           echo "built extension reports: $REPORTED, enabler expects: $EXPECTED"
           [ "$REPORTED" = "$EXPECTED" ]
           # the loader rejects a ts-mismatched DLL, so php loading it above
@@ -1980,7 +1981,7 @@ jobs:
           MATRIX_TS: ${{ matrix.ts }}
         run: |
           REPORTED="$(php -d extension="$TURBO_DLL" -r 'echo phpversion("phpstan_turbo");')"
-          EXPECTED="$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"
+          EXPECTED="$(php build/turbo-extension-version.php)"
           echo "extension reports: $REPORTED, enabler expects: $EXPECTED"
           [ "$REPORTED" = "$EXPECTED" ]
           # the loader rejects a ts-mismatched binary, so php loading it above
@@ -2090,7 +2091,7 @@ jobs:
         run: |
           docker exec -i alpine-test sh -e <<'EOF'
           REPORTED="$(php -d extension=/work/turbo-ext/phpstan_turbo.so -r 'echo phpversion("phpstan_turbo");')"
-          EXPECTED="$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"
+          EXPECTED="$(php build/turbo-extension-version.php)"
           echo "extension reports: $REPORTED, enabler expects: $EXPECTED"
           [ "$REPORTED" = "$EXPECTED" ]
           [ "$(php -r 'echo (int) ((bool) PHP_ZTS);')" = "$PHP_ZTS" ]
@@ -2644,11 +2645,11 @@ jobs:
   commit:
     name: "Commit PHAR"
     if: "github.repository_owner == 'phpstan' && (github.ref == 'refs/heads/2.3.x' || startsWith(github.ref, 'refs/tags/'))"
-    # Gated on every job that produces the committed bits or the version
-    # constant they are staged by: the compile jobs build the staged
-    # binaries (or carry over ones compiled from identical build inputs,
-    # see turbo-origins) and check the version they report; turbo-version
-    # guards the version constant the staging logic compares. The jobs
+    # Gated on every job that produces the committed bits or checks them
+    # against their sources: the compile jobs build the staged binaries (or
+    # carry over ones compiled from identical build inputs, see
+    # turbo-origins) and check the version they report; turbo-version
+    # guards the parity of the native and PHP implementations. The jobs
     # that only test those bits are deliberately not gates: the
     # "Run with Turbo Extension" jobs (turbo-differential,
     # turbo-differential-musl, turbo-run, turbo-docker-run), the shared-core
@@ -2747,7 +2748,7 @@ jobs:
       - name: "Check turbo extension version and binary set"
         id: turbo-difference
         run: |
-          EXPECTED="$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" phpstan-src/src/Turbo/TurboExtensionEnabler.php)"
+          EXPECTED="$(php phpstan-src/build/turbo-extension-version.php)"
           CURRENT="$(cat phpstan-dist/turbo-ext/.version 2>/dev/null || echo none)"
           echo "enabler expects: $EXPECTED, dist carries: $CURRENT"
           RESULT=same

.typos.toml

@@ -4,12 +4,6 @@ extend-exclude = [
 ]
 ignore-hidden = false
 
-[default]
-# TurboExtensionEnabler::EXPECTED_EXTENSION_VERSION is a git short SHA, not a
-# word. It changes on every turbo-ext/src commit, and a hex SHA occasionally
-# spells a dictionary word fragment - '873ede9' reads as "ede" -> "edge".
-extend-ignore-re = ["EXPECTED_EXTENSION_VERSION = '[0-9a-f]+'"]
-
 [default.extend-identifiers]
 # Known typos
 NonRemoveableTypeTrait = "NonRemoveableTypeTrait"

CLAUDE.md

@@ -262,7 +262,7 @@ Every threshold, fan-out cap, recursion bound, or collection-size limit must be
 
 ### Classes marked with `#[ShadowedByTurboExtension]` have a native C++ mirror
 
-Classes carrying the `PHPStan\Turbo\ShadowedByTurboExtension` attribute are reimplemented natively by the phpstan_turbo extension; the attribute names the `.cpp` file implementing it (`build/generate-turbo-manifest.php` derives the full map into `vendor/turbo-shadowed-classes.json` on composer dump-autoload). The two implementations must behave identically — analysis output is bit-for-bit identical with the extension on or off. When editing such a class, always check whether the `.cpp` mirror in `turbo-ext/` needs the same change; if it does, port it following `turbo-ext/CLAUDE.md` (method parity check, differential smoke test, full test suite with the extension loaded). Any commit touching `turbo-ext/src/` requires the follow-up commit bumping `TurboExtensionEnabler::EXPECTED_EXTENSION_VERSION` to that commit's short SHA — run `make bump-turbo`.
+Classes carrying the `PHPStan\Turbo\ShadowedByTurboExtension` attribute are reimplemented natively by the phpstan_turbo extension; the attribute names the `.cpp` file implementing it (`build/generate-turbo-manifest.php` derives the full map into `vendor/turbo-shadowed-classes.json` on composer dump-autoload). The two implementations must behave identically — analysis output is bit-for-bit identical with the extension on or off. When editing such a class, always check whether the `.cpp` mirror in `turbo-ext/` needs the same change; if it does, port it following `turbo-ext/CLAUDE.md` (method parity check, differential smoke test, full test suite with the extension loaded). The extension version is the short SHA of the last commit touching `turbo-ext/src/`, baked into the binary at build time and written into `vendor/turbo-extension-version.php` on composer dump-autoload (and by `make build-turbo`) — there is nothing to bump.
 
 New introduced classes in these categories should be shadowed with a native C++ mirror in the same commit:
 

Makefile

@@ -232,49 +232,22 @@ TURBO_JOBS ?= $(shell getconf _NPROCESSORS_ONLN 2>/dev/null || echo 4)
 build-turbo:
 	$(MAKE) -C turbo-ext -j$(TURBO_JOBS)
 	@# The binary bakes its version from `git log -- turbo-ext/src`, and
-	@# TurboExtensionEnabler activates only the version it expects — a build
-	@# from a shallow clone ("dev"), or one made between a turbo-ext/src
-	@# commit and its `make bump-turbo`, loads but stays inactive, which
-	@# otherwise only shows up as "nothing got faster".
+	@# TurboExtensionEnabler activates only the version the last autoloader
+	@# dump wrote into vendor/turbo-extension-version.php from the same git
+	@# log — regenerate it, so that a build after a turbo-ext/src commit is
+	@# expected without another `composer dump-autoload`.
+	@php build/generate-turbo-manifest.php > /dev/null
+	@# A build from a checkout without git history ("dev") still loads but
+	@# stays inactive, which otherwise only shows up as "nothing got faster".
 	@# -n: the machine's php.ini usually loads the extension already, and
 	@# the "Module is already loaded" warning that a second -d then prints
 	@# goes to stdout, i.e. into the version being read. An ini-less probe
 	@# also guarantees the version reported is the binary just built.
 	@BUILT="$$(php -n -d display_errors=stderr -d extension="$(CURDIR)/turbo-ext/phpstan_turbo.so" -r 'echo phpversion("phpstan_turbo");' 2>/dev/null)"; \
-	EXPECTED="$$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"; \
+	EXPECTED="$$(php -r 'echo require "vendor/turbo-extension-version.php";')"; \
 	echo "built $(CURDIR)/turbo-ext/phpstan_turbo.so$${BUILT:+ (version $$BUILT)}"; \
 	if [ -n "$$BUILT" ] && [ "$$BUILT" != "$$EXPECTED" ]; then \
-		echo "warning: TurboExtensionEnabler expects $$EXPECTED, so this build would load but stay inactive (run 'make bump-turbo' once the turbo-ext/src commit is in)"; \
-	fi
-
-# The expected turbo version is the short SHA of the last commit touching
-# turbo-ext/src (enforced by the phar.yml turbo-version job), so the bump can
-# never be part of the commit it points at. Refreshes an unpushed bump commit
-# in place — after a rebase gives the watched commit a new SHA, rerunning
-# this amends instead of stacking a second bump commit.
-.PHONY: bump-turbo
-bump-turbo:
-	@if [ -n "$$(git status --porcelain -- turbo-ext/src)" ]; then \
-		echo "turbo-ext/src has uncommitted changes — commit them first, the expected version is the short SHA of the last commit touching turbo-ext/src"; \
-		exit 1; \
-	fi; \
-	if ! git diff --quiet HEAD -- src/Turbo/TurboExtensionEnabler.php; then \
-		echo "src/Turbo/TurboExtensionEnabler.php has uncommitted changes — commit or stash them first"; \
-		exit 1; \
-	fi; \
-	EXPECTED="$$(git log -1 --format=%H -- turbo-ext/src | cut -c1-7)"; \
-	CURRENT="$$(sed -n "s/.*EXPECTED_EXTENSION_VERSION = '\([^']*\)'.*/\1/p" src/Turbo/TurboExtensionEnabler.php)"; \
-	if [ "$$EXPECTED" = "$$CURRENT" ]; then \
-		echo "TurboExtensionEnabler::EXPECTED_EXTENSION_VERSION is already $$EXPECTED"; \
-		exit 0; \
-	fi; \
-	sed -i '' -e "s/EXPECTED_EXTENSION_VERSION = '$$CURRENT'/EXPECTED_EXTENSION_VERSION = '$$EXPECTED'/" src/Turbo/TurboExtensionEnabler.php; \
-	if [ "$$(git log -1 --format=%s)" = "Bump expected turbo version" ] && [ -z "$$(git branch -r --contains HEAD)" ]; then \
-		git commit --amend --no-edit -- src/Turbo/TurboExtensionEnabler.php; \
-		echo "amended the unpushed bump commit: $$CURRENT -> $$EXPECTED"; \
-	else \
-		git commit -m "Bump expected turbo version" -- src/Turbo/TurboExtensionEnabler.php; \
-		echo "bumped: $$CURRENT -> $$EXPECTED"; \
+		echo "warning: TurboExtensionEnabler expects $${EXPECTED:-no version (no git history)}, so this build would load but stay inactive"; \
 	fi
 
 # Static analysis of the native extension's hand-written C++ sources. The

build/PHPStan/Build/TurboExtensionVersion.php

@@ -0,0 +1,78 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Build;
+
+use function fclose;
+use function is_resource;
+use function preg_match;
+use function proc_close;
+use function proc_open;
+use function sprintf;
+use function stream_get_contents;
+use function substr;
+use function trim;
+use function var_export;
+
+/**
+ * The phpstan_turbo version this checkout of PHPStan expects: the short SHA
+ * of the last commit touching turbo-ext/src — the same computation the
+ * extension's Makefile bakes into the binary, so a binary built from this
+ * checkout matches by construction. build/generate-turbo-manifest.php writes
+ * it into vendor/turbo-extension-version.php on every autoloader dump (the
+ * phar carries that file too); build/turbo-extension-version.php prints it
+ * for the workflows.
+ */
+final class TurboExtensionVersion
+{
+
+	/**
+	 * Null without a usable git checkout — the enabler then expects nothing,
+	 * and the extension stays inactive.
+	 */
+	public static function resolve(string $root): ?string
+	{
+		// an argument list rather than a command line: no shell, so no
+		// quoting and no /dev/null that would not exist on Windows
+		$process = proc_open(
+			['git', '-C', $root, 'log', '-1', '--format=%H', '--', 'turbo-ext/src'],
+			[1 => ['pipe', 'w'], 2 => ['pipe', 'w']],
+			$pipes,
+		);
+		if (!is_resource($process)) {
+			return null;
+		}
+
+		$output = stream_get_contents($pipes[1]);
+		fclose($pipes[1]);
+		fclose($pipes[2]);
+		if (proc_close($process) !== 0 || $output === false) {
+			return null;
+		}
+
+		$sha = trim($output);
+		if (preg_match('~^[0-9a-f]{40,}$~', $sha) !== 1) {
+			return null;
+		}
+
+		return substr($sha, 0, 7);
+	}
+
+	public static function render(?string $version): string
+	{
+		return sprintf(
+			<<<'PHP'
+<?php declare(strict_types = 1);
+
+// turbo-extension-version.php @generated by build/generate-turbo-manifest.php
+// — do not edit. The phpstan_turbo version PHPStan\Turbo\TurboExtensionEnabler
+// activates: the short SHA of the last commit touching turbo-ext/src (null
+// without a git checkout to read it from).
+
+return %s;
+
+PHP,
+			var_export($version, true),
+		);
+	}
+
+}