Merge pull request #7228 from klimick/contextual-inference-for-closur…

…e-param-types
vimeo · Dec 27, 2021 · 33466d8 · 33466d8
2 parents 910c34f + 87deb19
commit 33466d8
Show file tree

Hide file tree

Showing 3 changed files with 111 additions and 2 deletions.
diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArgumentsAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/ArgumentsAnalyzer.php
@@ -231,6 +231,23 @@ public static function analyze(
                 );
             }
 
+            $inferred_arg_type = $statements_analyzer->node_data->getType($arg->value);
+
+            if (null !== $inferred_arg_type && null !== $template_result && null !== $param && null !== $param->type) {
+                $codebase = $statements_analyzer->getCodebase();
+
+                TemplateStandinTypeReplacer::replace(
+                    clone $param->type,
+                    $template_result,
+                    $codebase,
+                    $statements_analyzer,
+                    $inferred_arg_type,
+                    $argument_offset,
+                    $context->self,
+                    $context->calling_method_id ?: $context->calling_function_id
+                );
+            }
+
             if ($toggled_class_exists) {
                 $context->inside_class_exists = false;
             }

diff --git a/src/Psalm/Internal/Analyzer/Statements/Expression/Call/FunctionCallAnalyzer.php b/src/Psalm/Internal/Analyzer/Statements/Expression/Call/FunctionCallAnalyzer.php
@@ -10,7 +10,6 @@
 use Psalm\Internal\Algebra\FormulaGenerator;
 use Psalm\Internal\Analyzer\AlgebraAnalyzer;
 use Psalm\Internal\Analyzer\FunctionLikeAnalyzer;
-use Psalm\Internal\Analyzer\Statements\Expression\Call\MethodCallAnalyzer;
 use Psalm\Internal\Analyzer\Statements\Expression\CallAnalyzer;
 use Psalm\Internal\Analyzer\Statements\ExpressionAnalyzer;
 use Psalm\Internal\Analyzer\StatementsAnalyzer;
@@ -165,13 +164,20 @@ public static function analyze(
         }
 
         if (!$is_first_class_callable) {
+            $template_result = null;
+
+            if (isset($function_call_info->function_storage->template_types)) {
+                $template_result = new TemplateResult($function_call_info->function_storage->template_types ?: [], []);
+            }
+
             ArgumentsAnalyzer::analyze(
                 $statements_analyzer,
                 $stmt->getArgs(),
                 $function_call_info->function_params,
                 $function_call_info->function_id,
                 $function_call_info->allow_named_args,
-                $context
+                $context,
+                $template_result
             );
         }
 

diff --git a/tests/CallableTest.php b/tests/CallableTest.php
@@ -147,6 +147,92 @@ function asTupled(ArrayList $list): ArrayList
                     '$b' => 'ArrayList<array{int}>',
                 ],
             ],
+            'inferArgByPreviousFunctionArg' => [
+                '<?php
+                    /**
+                     * @template A
+                     * @template B
+                     *
+                     * @param iterable<array-key, A> $_collection
+                     * @param callable(A): B $_ab
+                     * @return list<B>
+                     */
+                    function map(iterable $_collection, callable $_ab) { return []; }
+
+                    /** @template T */
+                    final class Foo
+                    {
+                        /** @return Foo<int> */
+                        public function toInt() { throw new RuntimeException("???"); }
+                    }
+
+                    /** @var list<Foo<string>> */
+                    $items = [];
+
+                    $inferred = map($items, function ($i) {
+                        return $i->toInt();
+                    });',
+                'assertions' => [
+                    '$inferred' => 'list<Foo<int>>',
+                ],
+            ],
+            'inferTemplateForExplicitlyTypedArgByPreviousFunctionArg' => [
+                '<?php
+                    /**
+                     * @template A
+                     * @template B
+                     *
+                     * @param iterable<array-key, A> $_collection
+                     * @param callable(A): B $_ab
+                     * @return list<B>
+                     */
+                    function map(iterable $_collection, callable $_ab) { return []; }
+
+                    /** @template T */
+                    final class Foo
+                    {
+                        /** @return Foo<int> */
+                        public function toInt() { throw new RuntimeException("???"); }
+                    }
+
+                    /** @var list<Foo<string>> */
+                    $items = [];
+
+                    $inferred = map($items, function (Foo $i) {
+                        return $i->toInt();
+                    });',
+                'assertions' => [
+                    '$inferred' => 'list<Foo<int>>',
+                ],
+            ],
+            'doNotInferTemplateForExplicitlyTypedWithPhpdocArgByPreviousFunctionArg' => [
+                '<?php
+                    /**
+                     * @template A
+                     * @template B
+                     *
+                     * @param iterable<array-key, A> $_collection
+                     * @param callable(A): B $_ab
+                     * @return list<B>
+                     */
+                    function map(iterable $_collection, callable $_ab) { return []; }
+
+                    /** @template T */
+                    final class Foo { }
+
+                    /** @var list<Foo<string>> */
+                    $items = [];
+
+                    $inferred = map($items,
+                        /** @param Foo $i */
+                        function ($i) {
+                            return $i;
+                        }
+                    );',
+                'assertions' => [
+                    '$inferred' => 'list<Foo>',
+                ],
+            ],
             'varReturnType' => [
                 '<?php
                     $add_one = function(int $a) : int {