Merge remote-tracking branch 'upstream/master' into handle-potential-first-class-callable

# Conflicts:
#	composer.json
#	src/Rules/UseSafeFunctionsRule.php

Author: spawnia

.github/workflows/tests.yaml

@@ -10,21 +10,19 @@ on:
 
 jobs:
   Tests:
-    runs-on: 'ubuntu-latest'
+    runs-on: "ubuntu-latest"
     strategy:
       matrix:
         php:
-          - '7.4'
-          - '8.0'
-          - '8.1'
-          - '8.2'
-          - '8.3'
-          - '8.4'
-        dependencies: ['highest']
+          - "8.1"
+          - "8.2"
+          - "8.3"
+          - "8.4"
+        dependencies: ["highest"]
         include:
-          - description: '(lowest)'
-            php: '7.4'
-            dependencies: 'lowest'
+          - description: "(lowest)"
+            php: "8.1"
+            dependencies: "lowest"
 
     name: PHP ${{ matrix.php }} ${{ matrix.description }}
     steps:
@@ -46,5 +44,7 @@ jobs:
       - name: "Upload test coverage"
         uses: codecov/codecov-action@v5
         with:
-          files: './coverage.xml'
+          files: "./coverage.xml"
           fail_ci_if_error: true
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

composer.json

@@ -10,13 +10,13 @@
         }
     ],
     "require": {
-        "php": "^7.4 || ^8.0",
+        "php": "^8.1",
         "phpstan/phpstan": "^2.0",
-        "thecodingmachine/safe": "^1.0 || ^2.0"
+        "thecodingmachine/safe": "^1.2 || ^2.0 || ^3.0",
+        "nikic/php-parser": "^5"
     },
     "require-dev": {
-        "nikic/php-parser": "^4.19.4",
-        "phpunit/phpunit": "^9.6",
+        "phpunit/phpunit": "^10.4",
         "php-coveralls/php-coveralls": "^2.1",
         "squizlabs/php_codesniffer": "^3.4"
     },
@@ -32,6 +32,7 @@
     },
     "scripts": {
         "phpstan": "phpstan analyse -c phpstan.neon --no-progress -vvv",
+        "test": "XDEBUG_MODE=coverage phpunit",
         "cs-fix": "phpcbf",
         "cs-check": "phpcs"
     },

phpcs.xml.dist

@@ -11,11 +11,13 @@
 
     <!-- Paths to check -->
     <file>src</file>
+    <file>tests</file>
+    <exclude-pattern>tests/**/data</exclude-pattern>
 
     <rule ref="Generic.Files.LineLength">
         <properties>
             <property name="lineLimit" value="300"/>
             <property name="absoluteLineLimit" value="500"/>
         </properties>
     </rule>
-</ruleset>
+</ruleset>

phpstan-safe-rule.neon

@@ -11,3 +11,11 @@ services:
     class: TheCodingMachine\Safe\PHPStan\Type\Php\ReplaceSafeFunctionsDynamicReturnTypeExtension
     tags:
       - phpstan.broker.dynamicFunctionReturnTypeExtension
+  -
+    class: TheCodingMachine\Safe\PHPStan\Type\Php\PregMatchParameterOutTypeExtension
+    tags:
+      - phpstan.functionParameterOutTypeExtension
+  -
+    class: TheCodingMachine\Safe\PHPStan\Type\Php\PregMatchTypeSpecifyingExtension
+    tags:
+      - phpstan.typeSpecifier.functionTypeSpecifyingExtension

phpstan.neon

@@ -2,6 +2,9 @@ parameters:
     level: max
     paths:
         - src
+        - tests
+    excludePaths:
+        - tests/Rules/data
     ignoreErrors:
         -
             message: '#^Implementing PHPStan\\Rules\\IdentifierRuleError is not covered by backward compatibility promise\. The interface might change in a minor PHPStan version\.$#'

phpunit.xml.dist

@@ -1,33 +1,35 @@
 <?xml version="1.0"?>
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd"
-         bootstrap="tests/bootstrap.php"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.5/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
          colors="true"
          backupGlobals="false"
-         backupStaticAttributes="false"
          beStrictAboutChangesToGlobalState="true"
          beStrictAboutOutputDuringTests="true"
          beStrictAboutTestsThatDoNotTestAnything="true"
-         beStrictAboutTodoAnnotatedTests="true"
          failOnRisky="true"
          failOnWarning="true"
-         convertErrorsToExceptions="true"
-         convertNoticesToExceptions="true"
-         convertWarningsToExceptions="true"
->
+         cacheDirectory=".phpunit.cache"
+         backupStaticProperties="false">
   <testsuites>
     <testsuite name="Test suite">
       <directory>./tests/</directory>
     </testsuite>
   </testsuites>
   <coverage>
-    <include>
-      <directory suffix=".php">./src</directory>
-    </include>
     <report>
       <clover outputFile="build/logs/clover.xml"/>
       <html outputDirectory="build/coverage"/>
       <text outputFile="php://stdout" showUncoveredFiles="true" showOnlySummary="true"/>
     </report>
   </coverage>
+  <source>
+    <include>
+      <directory suffix=".php">./src</directory>
+    </include>
+    <exclude>
+      <!-- type checking doesn't count towards coverage for some reason -->
+      <directory>src/Type/Php/</directory>
+    </exclude>
+  </source>
 </phpunit>

src/Rules/Error/SafeFunctionRuleError.php

@@ -18,6 +18,6 @@ public function __construct(Name $nodeName, int $line)
 
     public function getIdentifier(): string
     {
-        return self::IDENTIFIER_PREFIX . 'class';
+        return self::IDENTIFIER_PREFIX . 'function';
     }
 }

src/Rules/UseSafeFunctionsRule.php

@@ -39,6 +39,19 @@ public function processNode(Node $node, Scope $scope): array
 
         if (isset($unsafeFunctions[$functionName])) {
             if (! $node->isFirstClassCallable()) {
+                if ($functionName === "json_decode" || $functionName === "json_encode") {
+                    foreach ($node->args as $arg) {
+                        if ($arg instanceof Node\Arg &&
+                            $arg->name instanceof Node\Identifier &&
+                            $arg->name->toLowerString() === "flags"
+                        ) {
+                            if ($this->argValueIncludeJSONTHROWONERROR($arg)) {
+                                return [];
+                            }
+                        }
+                    }
+                }
+
                 if ($functionName === "json_decode"
                     && $this->argValueIncludeJSONTHROWONERROR($node->getArgs()[3] ?? null)
                 ) {

src/Type/Php/PregMatchParameterOutTypeExtension.php

@@ -0,0 +1,57 @@
+<?php declare(strict_types = 1);
+
+/*
+Blatantly copy-pasted from PHPStan's source code but with isFunctionSupported changed
+
+https://github.com/phpstan/phpstan-src/blob/e664bed7b62e2a58d571fb631ddf47030914a2b5/src/Type/Php/PregMatchParameterOutTypeExtension.php
+*/
+namespace TheCodingMachine\Safe\PHPStan\Type\Php;
+
+use PHPStan\Type\Php\RegexArrayShapeMatcher;
+use PhpParser\Node\Expr\FuncCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Reflection\ParameterReflection;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\FunctionParameterOutTypeExtension;
+use PHPStan\Type\Type;
+use function in_array;
+
+final class PregMatchParameterOutTypeExtension implements FunctionParameterOutTypeExtension
+{
+
+    public function __construct(
+        private RegexArrayShapeMatcher $regexShapeMatcher,
+    ) {
+    }
+
+    public function isFunctionSupported(FunctionReflection $functionReflection, ParameterReflection $parameter): bool
+    {
+        return in_array($functionReflection->getName(), ['Safe\preg_match', 'Safe\preg_match_all'], true)
+            // the parameter is named different, depending on PHP version.
+            && in_array($parameter->getName(), ['subpatterns', 'matches'], true);
+    }
+
+    public function getParameterOutTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $funcCall, ParameterReflection $parameter, Scope $scope): ?Type
+    {
+        $args = $funcCall->getArgs();
+        $patternArg = $args[0] ?? null;
+        $matchesArg = $args[2] ?? null;
+        $flagsArg = $args[3] ?? null;
+
+        if ($patternArg === null || $matchesArg === null
+        ) {
+            return null;
+        }
+
+        $flagsType = null;
+        if ($flagsArg !== null) {
+            $flagsType = $scope->getType($flagsArg->value);
+        }
+
+        if ($functionReflection->getName() === 'Safe\preg_match') {
+            return $this->regexShapeMatcher->matchExpr($patternArg->value, $flagsType, TrinaryLogic::createMaybe(), $scope);
+        }
+        return $this->regexShapeMatcher->matchAllExpr($patternArg->value, $flagsType, TrinaryLogic::createMaybe(), $scope);
+    }
+}

src/Type/Php/PregMatchTypeSpecifyingExtension.php

@@ -0,0 +1,85 @@
+<?php declare(strict_types = 1);
+
+/*
+Blatantly copy-pasted from PHPStan's source code but with isFunctionSupported changed
+*/
+namespace TheCodingMachine\Safe\PHPStan\Type\Php;
+
+use PHPStan\Type\Php\RegexArrayShapeMatcher;
+use PhpParser\Node\Expr\FuncCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Analyser\SpecifiedTypes;
+use PHPStan\Analyser\TypeSpecifier;
+use PHPStan\Analyser\TypeSpecifierAwareExtension;
+use PHPStan\Analyser\TypeSpecifierContext;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\FunctionTypeSpecifyingExtension;
+use function in_array;
+use function strtolower;
+
+final class PregMatchTypeSpecifyingExtension implements FunctionTypeSpecifyingExtension, TypeSpecifierAwareExtension
+{
+
+    private TypeSpecifier $typeSpecifier;
+
+    public function __construct(
+        private RegexArrayShapeMatcher $regexShapeMatcher,
+    ) {
+    }
+
+    public function setTypeSpecifier(TypeSpecifier $typeSpecifier): void
+    {
+        $this->typeSpecifier = $typeSpecifier;
+    }
+
+    public function isFunctionSupported(FunctionReflection $functionReflection, FuncCall $node, TypeSpecifierContext $context): bool
+    {
+        return in_array(strtolower($functionReflection->getName()), ['safe\preg_match', 'safe\preg_match_all'], true) && !$context->null();
+    }
+
+    public function specifyTypes(FunctionReflection $functionReflection, FuncCall $node, Scope $scope, TypeSpecifierContext $context): SpecifiedTypes
+    {
+        $args = $node->getArgs();
+        $patternArg = $args[0] ?? null;
+        $matchesArg = $args[2] ?? null;
+        $flagsArg = $args[3] ?? null;
+
+        if ($patternArg === null || $matchesArg === null
+        ) {
+            return new SpecifiedTypes();
+        }
+
+        $flagsType = null;
+        if ($flagsArg !== null) {
+            $flagsType = $scope->getType($flagsArg->value);
+        }
+
+        if ($functionReflection->getName() === 'Safe\preg_match') {
+            $matchedType = $this->regexShapeMatcher->matchExpr($patternArg->value, $flagsType, TrinaryLogic::createFromBoolean($context->true()), $scope);
+        } else {
+            $matchedType = $this->regexShapeMatcher->matchAllExpr($patternArg->value, $flagsType, TrinaryLogic::createFromBoolean($context->true()), $scope);
+        }
+        if ($matchedType === null) {
+            return new SpecifiedTypes();
+        }
+
+        $overwrite = false;
+        if ($context->false()) {
+            $overwrite = true;
+            $context = $context->negate();
+        }
+
+        $types = $this->typeSpecifier->create(
+            $matchesArg->value,
+            $matchedType,
+            $context,
+            $scope,
+        )->setRootExpr($node);
+        if ($overwrite) {
+            $types = $types->setAlwaysOverwriteTypes();
+        }
+
+        return $types;
+    }
+}