fix(analyzer): template parameters with compatible constraints should be allowed

closes #739

Signed-off-by: azjezz <[email protected]>

Author: azjezz

crates/analyzer/src/invocation/resolver.rs

@@ -44,27 +44,52 @@ pub fn resolve_invocation_type<'ctx, 'ast, 'arena>(
                 }
             };
 
-            if let Some(template_types) = invocation.target.get_template_types()
-                && !template_types.is_empty()
-            {
-                for (template_name, _) in template_types {
-                    let has_bound_for_this_parent = template_result
-                        .lower_bounds
-                        .get(template_name)
-                        .and_then(|bounds| bounds.get(&generic_parent))
-                        .is_some_and(|bounds| !bounds.is_empty());
+            let method_templates = invocation.target.get_template_types().unwrap_or(&[]);
+
+            let all_template_names: Vec<_> = method_templates
+                .iter()
+                .map(|(name, _)| *name)
+                .chain(template_result.template_types.keys().copied())
+                .collect();
+
+            for template_name in all_template_names {
+                let has_bound_for_method = template_result
+                    .lower_bounds
+                    .get(&template_name)
+                    .and_then(|bounds| bounds.get(&generic_parent))
+                    .is_some_and(|bounds| !bounds.is_empty());
+
+                let method_parents: Vec<_> = method_templates
+                    .iter()
+                    .filter(|(name, _)| name == &template_name)
+                    .flat_map(|(_, constraints)| constraints.iter().map(|(parent, _)| parent))
+                    .collect();
+
+                let result_parents: Vec<_> = template_result
+                    .template_types
+                    .get(&template_name)
+                    .map(|v| v.iter().map(|(parent, _)| parent).collect())
+                    .unwrap_or_default();
+
+                let has_bound_for_template_parent =
+                    method_parents.iter().chain(result_parents.iter()).any(|constraint_parent| {
+                        template_result
+                            .lower_bounds
+                            .get(&template_name)
+                            .and_then(|bounds| bounds.get(*constraint_parent))
+                            .is_some_and(|bounds| !bounds.is_empty())
+                    });
 
-                    if !has_bound_for_this_parent {
-                        let mut owned_template_result = template_result.into_owned();
+                if !has_bound_for_method && !has_bound_for_template_parent {
+                    let mut owned_template_result = template_result.into_owned();
 
-                        owned_template_result
-                            .lower_bounds
-                            .entry(*template_name)
-                            .or_default()
-                            .insert(generic_parent, vec![TemplateBound::new(get_never(), 1, None, None)]);
+                    owned_template_result
+                        .lower_bounds
+                        .entry(template_name)
+                        .or_default()
+                        .insert(generic_parent, vec![TemplateBound::new(get_never(), 1, None, None)]);
 
-                        template_result = Cow::Owned(owned_template_result);
-                    }
+                    template_result = Cow::Owned(owned_template_result);
                 }
             }
         }

crates/analyzer/tests/cases/issue_739.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @template-covariant T
+ */
+interface TypeInterface
+{
+    /**
+     * @return T
+     *
+     * @phpstan-assert T $value
+     */
+    public function assert(mixed $value): mixed;
+
+    /**
+     * @phpstan-assert-if-true T $value
+     */
+    public function isValid(mixed $value): bool;
+}
+
+/**
+ * @template TLeft
+ * @template TRight
+ *
+ * @implements TypeInterface<TLeft|TRight>
+ */
+final class UnionType implements TypeInterface
+{
+    /**
+     * @param TypeInterface<TLeft> $left
+     * @param TypeInterface<TRight> $right
+     */
+    public function __construct(
+        private TypeInterface $left,
+        private TypeInterface $right,
+    ) {}
+
+    #[Override]
+    public function assert(mixed $value): mixed
+    {
+        if ($this->left->isValid($value)) {
+            return $value;
+        }
+
+        if ($this->right->isValid($value)) {
+            return $value;
+        }
+
+        die('invalid');
+    }
+
+    #[Override]
+    public function isValid(mixed $value): bool
+    {
+        return $this->left->isValid($value) || $this->right->isValid($value);
+    }
+}

crates/analyzer/tests/mod.rs

@@ -442,6 +442,7 @@ test_case!(issue_725);
 test_case!(issue_728_symfony_reference);
 test_case!(issue_736);
 test_case!(issue_737);
+test_case!(issue_739);
 
 #[test]
 fn test_all_test_cases_are_ran() {

crates/codex/src/ttype/comparator/atomic_comparator.rs

@@ -110,6 +110,24 @@ pub fn is_contained_by(
         }
     }
 
+    if inside_assertion
+        && let TAtomic::GenericParameter(TGenericParameter {
+            parameter_name: container_param_name,
+            defining_entity: container_entity,
+            ..
+        }) = container_type_part
+        && let TAtomic::GenericParameter(TGenericParameter {
+            parameter_name: input_param_name,
+            defining_entity: input_entity,
+            ..
+        }) = input_type_part
+    {
+        // Different template parameters are not contained by each other during assertion reconciliation
+        if input_param_name != container_param_name || input_entity != container_entity {
+            return false;
+        }
+    }
+
     if container_type_part.is_vanilla_mixed() || container_type_part.is_templated_as_vanilla_mixed() {
         return true;
     }
@@ -372,9 +390,23 @@ pub fn is_contained_by(
         return false;
     }
 
-    if let TAtomic::GenericParameter(TGenericParameter { constraint: container_constraint, .. }) = container_type_part
-        && let TAtomic::GenericParameter(TGenericParameter { constraint: input_constraint, .. }) = input_type_part
+    if let TAtomic::GenericParameter(TGenericParameter {
+        parameter_name: container_param_name,
+        defining_entity: container_entity,
+        constraint: container_constraint,
+        ..
+    }) = container_type_part
+        && let TAtomic::GenericParameter(TGenericParameter {
+            parameter_name: input_param_name,
+            defining_entity: input_entity,
+            constraint: input_constraint,
+            ..
+        }) = input_type_part
     {
+        if inside_assertion && (input_param_name != container_param_name || input_entity != container_entity) {
+            return false;
+        }
+
         return union_comparator::is_contained_by(
             codebase,
             input_constraint,