fix(scanner): include class template parameters in static method type resolution context

closes #764

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

Author: azjezz

crates/analyzer/src/statement/class_like/mod.rs

@@ -13,6 +13,9 @@ use mago_codex::metadata::property::PropertyMetadata;
 use mago_codex::misc::GenericParent;
 use mago_codex::ttype::TType;
 use mago_codex::ttype::atomic::TAtomic;
+use mago_codex::ttype::atomic::generic::TGenericParameter;
+use mago_codex::ttype::atomic::scalar::TScalar;
+use mago_codex::ttype::atomic::scalar::class_like_string::TClassLikeString;
 use mago_codex::ttype::comparator::ComparisonResult;
 use mago_codex::ttype::comparator::union_comparator;
 use mago_codex::ttype::expander::TypeExpansionOptions;
@@ -131,10 +134,24 @@ fn type_contains_template_param(type_union: &TUnion, param_name: Atom, defining_
     use mago_codex::ttype::TypeRef;
 
     type_union.types.iter().any(|atomic| {
-        if let TAtomic::GenericParameter(gp) = atomic
-            && gp.parameter_name == param_name
-            && let GenericParent::ClassLike(class_name) = gp.defining_entity
-            && class_name == defining_class
+        if let TAtomic::GenericParameter(TGenericParameter {
+            parameter_name,
+            defining_entity: GenericParent::ClassLike(class_name),
+            ..
+        }) = atomic
+            && *parameter_name == param_name
+            && *class_name == defining_class
+        {
+            return true;
+        }
+
+        if let TAtomic::Scalar(TScalar::ClassLikeString(TClassLikeString::Generic {
+            parameter_name,
+            defining_entity: GenericParent::ClassLike(class_name),
+            ..
+        })) = atomic
+            && *parameter_name == param_name
+            && *class_name == defining_class
         {
             return true;
         }
@@ -144,6 +161,14 @@ fn type_contains_template_param(type_union: &TUnion, param_name: Atom, defining_
                 gp.parameter_name == param_name
                     && matches!(gp.defining_entity, GenericParent::ClassLike(c) if c == defining_class)
             }
+            TypeRef::Atomic(TAtomic::Scalar(TScalar::ClassLikeString(TClassLikeString::Generic {
+                parameter_name,
+                defining_entity,
+                ..
+            }))) => {
+                *parameter_name == param_name
+                    && matches!(defining_entity, GenericParent::ClassLike(c) if *c == defining_class)
+            }
             TypeRef::Union(u) => type_contains_template_param(u, param_name, defining_class),
             _ => false,
         })

crates/analyzer/tests/cases/issue_764.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+abstract class AbstractController
+{
+}
+
+/**
+ * @template TEntity of object
+ */
+interface CrudControllerInterface
+{
+    /**
+     * @return class-string<TEntity>
+     */
+    public static function getEntityFqcn(): string;
+}
+
+/**
+ * @template TEntity of object
+ * @implements CrudControllerInterface<TEntity>
+ */
+abstract class AbstractCrudController extends AbstractController implements CrudControllerInterface
+{
+    abstract public static function getEntityFqcn(): string;
+}
+
+/**
+ * @extends AbstractCrudController<stdClass>
+ */
+final class CrudController1 extends AbstractCrudController
+{
+    public static function getEntityFqcn(): string
+    {
+        return stdClass::class;
+    }
+}
+
+/**
+ * @extends AbstractCrudController<stdClass>
+ */
+final class CrudController2 extends AbstractCrudController
+{
+    /**
+     * {@inheritDoc}
+     */
+    public static function getEntityFqcn(): string
+    {
+        return stdClass::class;
+    }
+}
+
+/**
+ * @extends AbstractCrudController<stdClass>
+ */
+final class CrudController3 extends AbstractCrudController
+{
+    /**
+     * @inheritDoc
+     */
+    public static function getEntityFqcn(): string
+    {
+        return stdClass::class;
+    }
+}
+
+/**
+ * @extends AbstractCrudController<stdClass>
+ */
+final class CrudController4 extends AbstractCrudController
+{
+    /** @return class-string<stdClass> */
+    public static function getEntityFqcn(): string
+    {
+        return stdClass::class;
+    }
+}

crates/analyzer/tests/mod.rs

@@ -465,6 +465,7 @@ test_case!(issue_752);
 test_case!(issue_754);
 test_case!(issue_755);
 test_case!(issue_756);
+test_case!(issue_764);
 
 #[test]
 fn test_all_test_cases_are_ran() {

crates/codex/src/scanner/mod.rs

@@ -399,28 +399,29 @@ impl<'ctx, 'arena> MutWalker<'arena, 'arena, Context<'ctx, 'arena>> for Scanner
         }
 
         let method_id = (class_like_metadata.name, name);
-        let type_resolution = if method.is_static() {
-            if !class_like_metadata.type_aliases.is_empty() || !class_like_metadata.imported_type_aliases.is_empty() {
-                let mut context = TypeResolutionContext::new();
+        let type_resolution_context = {
+            let mut context = self.get_current_type_resolution_context();
 
-                for alias_name in class_like_metadata.type_aliases.keys() {
-                    context = context.with_type_alias(*alias_name);
-                }
-
-                for (alias_name, (source_class, original_name, _span)) in &class_like_metadata.imported_type_aliases {
-                    context = context.with_imported_type_alias(*alias_name, *source_class, *original_name);
-                }
+            for alias_name in class_like_metadata.type_aliases.keys() {
+                context = context.with_type_alias(*alias_name);
+            }
 
-                Some(context)
-            } else {
-                None
+            for (alias_name, (source_class, original_name, _span)) in &class_like_metadata.imported_type_aliases {
+                context = context.with_imported_type_alias(*alias_name, *source_class, *original_name);
             }
-        } else {
-            Some(self.get_current_type_resolution_context())
+
+            context
         };
 
-        let mut function_like_metadata =
-            scan_method(method_id, method, &class_like_metadata, context, &mut self.scope, type_resolution);
+        let mut function_like_metadata = scan_method(
+            method_id,
+            method,
+            &class_like_metadata,
+            context,
+            &mut self.scope,
+            Some(type_resolution_context),
+        );
+
         let Some(method_metadata) = &function_like_metadata.method_metadata else {
             unreachable!("Method info should be present for method.",);
         };