Add phpIntSize parameter, infer 64bit from composer.json under bleeding edge

Author: zonuexe

conf/bleedingEdge.neon

@@ -22,3 +22,4 @@ parameters:
 		checkDynamicConstantNameValues: true
 		unusedLabel: true
 		newOnNonObject: true
+		composerPhp64Bit: true

conf/config.neon

@@ -49,6 +49,7 @@ parameters:
 		checkDynamicConstantNameValues: false
 		unusedLabel: false
 		newOnNonObject: false
+		composerPhp64Bit: false
 	fileExtensions:
 		- php
 	checkAdvancedIsset: false
@@ -103,6 +104,7 @@ parameters:
 		minimumNumberOfJobsPerProcess: 2
 		buffer: 134217728 # 128 MB
 		loadLimit: 1.0
+	phpIntSize: null
 	phpVersion: null
 	polluteScopeWithLoopInitialAssignments: true
 	polluteScopeWithAlwaysIterableForeach: true

conf/parametersSchema.neon

@@ -51,6 +51,7 @@ parametersSchema:
 		checkDynamicConstantNameValues: bool()
 		unusedLabel: bool()
 		newOnNonObject: bool()
+		composerPhp64Bit: bool()
 	])
 	fileExtensions: listOf(string())
 	checkAdvancedIsset: bool()
@@ -110,6 +111,7 @@ parametersSchema:
 		buffer: int(),
 		loadLimit: schema(float(), nullable())
 	])
+	phpIntSize: schema(anyOf(8), nullable())
 	phpVersion: schema(anyOf(
 		schema(int(), min(70100), max(80599)),
 		structure([

src/Analyser/ConstantResolver.php

@@ -5,6 +5,7 @@
 use PhpParser\Node\Name;
 use PHPStan\DependencyInjection\AutowiredService;
 use PHPStan\DependencyInjection\Container;
+use PHPStan\Php\ConfiguredPhpIntSizeHelper;
 use PHPStan\Php\ConfiguredPhpVersionRangeHelper;
 use PHPStan\PhpDoc\TypeStringResolver;
 use PHPStan\Reflection\NamespaceAnswerer;
@@ -51,6 +52,7 @@ public function __construct(
 		private ReflectionProviderProvider $reflectionProviderProvider,
 		private array $dynamicConstantNames,
 		private ConfiguredPhpVersionRangeHelper $configuredPhpVersionRangeHelper,
+		private ConfiguredPhpIntSizeHelper $configuredPhpIntSizeHelper,
 		private ?Container $container,
 	)
 	{
@@ -219,17 +221,30 @@ public function resolvePredefinedConstant(string $resolvedConstantName): ?Type
 			]);
 		}
 		if ($resolvedConstantName === 'PHP_INT_MAX') {
-			return PHP_INT_SIZE === 8
-				? new UnionType([new ConstantIntegerType(2147483647), new ConstantIntegerType(9223372036854775807)])
-				: new ConstantIntegerType(2147483647);
+			// The 64bit literals below cannot be constructed when PHPStan itself runs on 32bit,
+			// so they stay inside branches that are never taken there.
+			if (PHP_INT_SIZE !== 8) {
+				return new ConstantIntegerType(2147483647);
+			}
+			if ($this->configuredPhpIntSizeHelper->getIntSize() === 8) {
+				return new ConstantIntegerType(9223372036854775807);
+			}
+			return new UnionType([new ConstantIntegerType(2147483647), new ConstantIntegerType(9223372036854775807)]);
 		}
 		if ($resolvedConstantName === 'PHP_INT_MIN') {
 			// Why the -1 you might wonder, the answer is to fit it into an int :/ see https://3v4l.org/4SHIQ
-			return PHP_INT_SIZE === 8
-				? new UnionType([new ConstantIntegerType(-9223372036854775807 - 1), new ConstantIntegerType(-2147483647 - 1)])
-				: new ConstantIntegerType(-2147483647 - 1);
+			if (PHP_INT_SIZE !== 8) {
+				return new ConstantIntegerType(-2147483647 - 1);
+			}
+			if ($this->configuredPhpIntSizeHelper->getIntSize() === 8) {
+				return new ConstantIntegerType(-9223372036854775807 - 1);
+			}
+			return new UnionType([new ConstantIntegerType(-9223372036854775807 - 1), new ConstantIntegerType(-2147483647 - 1)]);
 		}
 		if ($resolvedConstantName === 'PHP_INT_SIZE') {
+			if ($this->configuredPhpIntSizeHelper->getIntSize() === 8) {
+				return new ConstantIntegerType(8);
+			}
 			return new UnionType([
 				new ConstantIntegerType(4),
 				new ConstantIntegerType(8),

src/Analyser/ConstantResolverFactory.php

@@ -5,6 +5,7 @@
 use PHPStan\DependencyInjection\AutowiredService;
 use PHPStan\DependencyInjection\Container;
 use PHPStan\Php\ComposerPhpVersionFactory;
+use PHPStan\Php\ConfiguredPhpIntSizeHelper;
 use PHPStan\Php\ConfiguredPhpVersionRangeHelper;
 use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider;
 
@@ -30,6 +31,7 @@ public function create(): ConstantResolver
 				$this->container->getParameter('phpVersion'),
 				$composerFactory,
 			),
+			$this->container->getByType(ConfiguredPhpIntSizeHelper::class),
 			$this->container,
 		);
 	}

src/DependencyInjection/ValidateIgnoredErrorsExtension.php

@@ -15,6 +15,7 @@
 use PHPStan\DependencyInjection\Type\UnaryOperatorTypeSpecifyingExtensionRegistryProvider;
 use PHPStan\File\FileExcluder;
 use PHPStan\Php\ComposerPhpVersionFactory;
+use PHPStan\Php\ConfiguredPhpIntSizeHelper;
 use PHPStan\Php\ConfiguredPhpVersionRangeHelper;
 use PHPStan\Php\PhpVersion;
 use PHPStan\PhpDoc\DirectTypeNodeResolverExtensionRegistryProvider;
@@ -91,7 +92,7 @@ public function loadConfiguration(): void
 
 		try {
 			$composerPhpVersionFactory = new ComposerPhpVersionFactory([]);
-			$constantResolver = new ConstantResolver($reflectionProviderProvider, [], new ConfiguredPhpVersionRangeHelper(null, $composerPhpVersionFactory), container: null);
+			$constantResolver = new ConstantResolver($reflectionProviderProvider, [], new ConfiguredPhpVersionRangeHelper(null, $composerPhpVersionFactory), new ConfiguredPhpIntSizeHelper(null, false, []), container: null);
 
 			$phpDocParserConfig = new ParserConfig([]);
 			$ignoredRegexValidator = new IgnoredRegexValidator(

src/Php/ComposerPhpVersionFactory.php

@@ -26,6 +26,8 @@ final class ComposerPhpVersionFactory
 	public function __construct(
 		#[AutowiredParameter]
 		private array $composerAutoloaderProjectPaths,
+		#[AutowiredParameter(ref: '%featureToggles.composerPhp64Bit%')]
+		private bool $composerPhp64Bit = false,
 	)
 	{
 	}
@@ -37,14 +39,14 @@ private function initializeVersions(): void
 		// don't limit minVersion... PHPStan can analyze even PHP5
 		$this->maxVersion = new PhpVersion(PhpVersionFactory::MAX_PHP_VERSION);
 
-		// fallback to composer.json based php-version constraint
-		$composerPhpVersion = $this->getComposerRequireVersion();
-		if ($composerPhpVersion === null) {
+		// fallback to composer.json based php-version constraints
+		$composerPhpVersions = $this->getComposerRequireVersions();
+		if (count($composerPhpVersions) === 0) {
 			return;
 		}
 
 		$parser = new ComposerPhpVersionParser();
-		[$minVersion, $maxVersion] = $parser->parse($composerPhpVersion, static function (string $version, int $versionId, bool $isMaxVersion): PhpVersion {
+		[$minVersion, $maxVersion] = $parser->parse($composerPhpVersions, static function (string $version, int $versionId, bool $isMaxVersion): PhpVersion {
 			if ($isMaxVersion && $version === '6.0.0.0-dev') {
 				$versionId = min($versionId, PhpVersionFactory::MAX_PHP5_VERSION);
 			} elseif ($isMaxVersion && $version === '8.0.0.0-dev') {
@@ -83,22 +85,34 @@ public function getMaxVersion(): ?PhpVersion
 		return $this->maxVersion;
 	}
 
-	private function getComposerRequireVersion(): ?string
+	/**
+	 * Composer registers php-64bit as a virtual package carrying the very same version as php,
+	 * so a requirement on either one constrains the PHP version, and requiring both means
+	 * both constraints have to hold at once.
+	 *
+	 * @return list<string>
+	 */
+	private function getComposerRequireVersions(): array
 	{
-		$composerPhpVersion = null;
+		$packageNames = $this->composerPhp64Bit ? ['php', 'php-64bit'] : ['php'];
+		$composerPhpVersions = [];
 
 		if (count($this->composerAutoloaderProjectPaths) > 0) {
 			$composer = ComposerHelper::getComposerConfig(end($this->composerAutoloaderProjectPaths));
 			if ($composer !== null) {
-				$requiredVersion = $composer['require']['php'] ?? null;
+				foreach ($packageNames as $packageName) {
+					$requiredVersion = $composer['require'][$packageName] ?? null;
+
+					if (!is_string($requiredVersion)) {
+						continue;
+					}
 
-				if (is_string($requiredVersion)) {
-					$composerPhpVersion = $requiredVersion;
+					$composerPhpVersions[] = $requiredVersion;
 				}
 			}
 		}
 
-		return $composerPhpVersion;
+		return $composerPhpVersions;
 	}
 
 }

src/Php/ComposerPhpVersionParser.php

@@ -2,24 +2,31 @@
 
 namespace PHPStan\Php;
 
+use Composer\Semver\Constraint\MultiConstraint;
 use Composer\Semver\VersionParser;
 use Nette\Utils\Strings;
+use function array_map;
 use function sprintf;
 
 final class ComposerPhpVersionParser
 {
 
 	/**
+	 * @param non-empty-list<string> $versions constraints that all have to be satisfied at once,
+	 *                                         like Composer's `php` and `php-64bit` requirements
 	 * @param callable(string, int, bool):PhpVersion $buildPhpVersion
 	 *
 	 * @return array{PhpVersion|null, PhpVersion|null}
 	 */
-	public function parse(string $version, callable $buildPhpVersion): array
+	public function parse(array $versions, callable $buildPhpVersion): array
 	{
 		$minVersion = null;
 
 		$parser = new VersionParser();
-		$constraint = $parser->parseConstraints($version);
+		$constraint = MultiConstraint::create(
+			array_map(static fn (string $version) => $parser->parseConstraints($version), $versions),
+			true,
+		);
 
 		if (!$constraint->getLowerBound()->isZero()) {
 			$minVersion = $this->buildVersion($constraint->getLowerBound()->getVersion(), false, $buildPhpVersion);

src/Php/ConfiguredPhpIntSizeHelper.php

@@ -0,0 +1,84 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Php;
+
+use PHPStan\DependencyInjection\AutowiredParameter;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Internal\ComposerHelper;
+use function count;
+use function end;
+use function is_string;
+
+/**
+ * Tells whether the analysed code is guaranteed to run on a 64bit platform.
+ *
+ * The source is either the NEON config phpIntSize value, or a `php-64bit` requirement
+ * in the project's composer.json. Composer only provides the `php-64bit` virtual package
+ * when PHP_INT_SIZE === 8, so requiring it makes the assumption enforceable at install time.
+ *
+ * Reading composer.json turns the assumption on for projects that never asked for it,
+ * so it only happens under the composerPhp64Bit feature toggle. Setting phpIntSize is
+ * explicit and always wins.
+ */
+#[AutowiredService]
+final class ConfiguredPhpIntSizeHelper
+{
+
+	/** The only int size that can be assumed. 32bit semantics are not modelled anywhere else. */
+	private const SUPPORTED_INT_SIZE = 8;
+
+	/** @var self::SUPPORTED_INT_SIZE|null */
+	private ?int $intSize = null;
+
+	private bool $initialized = false;
+
+	/**
+	 * @param self::SUPPORTED_INT_SIZE|null $configPhpIntSize
+	 * @param string[] $composerAutoloaderProjectPaths
+	 */
+	public function __construct(
+		#[AutowiredParameter(ref: '%phpIntSize%')]
+		private ?int $configPhpIntSize,
+		#[AutowiredParameter(ref: '%featureToggles.composerPhp64Bit%')]
+		private bool $composerPhp64Bit,
+		#[AutowiredParameter]
+		private array $composerAutoloaderProjectPaths,
+	)
+	{
+	}
+
+	/**
+	 * Size of an integer in bytes on the analysed platform,
+	 * or null when both 32bit and 64bit have to be taken into account.
+	 *
+	 * @return self::SUPPORTED_INT_SIZE|null
+	 */
+	public function getIntSize(): ?int
+	{
+		if (!$this->initialized) {
+			$this->initialized = true;
+			$this->intSize = $this->configPhpIntSize ?? ($this->composerRequiresPhp64Bit() ? self::SUPPORTED_INT_SIZE : null);
+		}
+
+		return $this->intSize;
+	}
+
+	private function composerRequiresPhp64Bit(): bool
+	{
+		if (!$this->composerPhp64Bit) {
+			return false;
+		}
+
+		if (count($this->composerAutoloaderProjectPaths) === 0) {
+			return false;
+		}
+
+		$composer = ComposerHelper::getComposerConfig(end($this->composerAutoloaderProjectPaths));
+		if ($composer === null) {
+			return false;
+		}
+
+		return is_string($composer['require']['php-64bit'] ?? null);
+	}
+
+}

src/Testing/PHPStanTestCase.php

@@ -16,6 +16,7 @@
 use PHPStan\Node\Printer\ExprPrinter;
 use PHPStan\Parser\Parser;
 use PHPStan\Php\ComposerPhpVersionFactory;
+use PHPStan\Php\ConfiguredPhpIntSizeHelper;
 use PHPStan\Php\ConfiguredPhpVersionRangeHelper;
 use PHPStan\Php\PhpVersion;
 use PHPStan\PhpDoc\TypeNodeResolver;
@@ -96,7 +97,7 @@ public static function createScopeFactory(ReflectionProvider $reflectionProvider
 
 		$reflectionProviderProvider = new DirectReflectionProviderProvider($reflectionProvider);
 		$composerPhpVersionFactory = $container->getByType(ComposerPhpVersionFactory::class);
-		$constantResolver = new ConstantResolver($reflectionProviderProvider, $dynamicConstantNames, new ConfiguredPhpVersionRangeHelper(null, $composerPhpVersionFactory), container: $container);
+		$constantResolver = new ConstantResolver($reflectionProviderProvider, $dynamicConstantNames, new ConfiguredPhpVersionRangeHelper(null, $composerPhpVersionFactory), $container->getByType(ConfiguredPhpIntSizeHelper::class), container: $container);
 
 		$initializerExprTypeResolver = new InitializerExprTypeResolver(
 			$constantResolver,