fix(analyzer): track symbol references from partial applications

Signed-off-by: azjezz <azjezz@protonmail.com>

Author: azjezz

crates/analyzer/src/expression/partial_application/function_partial_application.rs

@@ -1,6 +1,7 @@
 use std::borrow::Cow;
 
 use mago_atom::AtomMap;
+use mago_atom::ascii_lowercase_atom;
 use mago_atom::atom;
 use mago_codex::identifier::function_like::FunctionLikeIdentifier;
 use mago_codex::ttype::TType;
@@ -171,6 +172,14 @@ fn resolve_function_callable_types<'ctx, 'arena, 'artifacts>(
             return Ok(vec![]);
         };
 
+        if let FunctionLikeIdentifier::Function(function_name) = identifier {
+            artifacts.symbol_references.add_reference_to_symbol(
+                &block_context.scope,
+                ascii_lowercase_atom(function_name.as_ref()),
+                false,
+            );
+        }
+
         return Ok(vec![Cow::Owned(TCallable::Alias(identifier))]);
     }
 

crates/analyzer/src/expression/partial_application/method_partial_application.rs

@@ -1,4 +1,5 @@
 use mago_atom::AtomMap;
+use mago_atom::ascii_lowercase_atom;
 use mago_codex::identifier::function_like::FunctionLikeIdentifier;
 use mago_codex::ttype::atomic::TAtomic;
 use mago_codex::ttype::atomic::callable::TCallable;
@@ -34,22 +35,29 @@ impl<'ast, 'arena> Analyzable<'ast, 'arena> for MethodPartialApplication<'arena>
         let method_resolution =
             resolve_method_targets(context, block_context, artifacts, self.object, &self.method, false, self.span())?;
 
+        let mut identifiers = vec![];
+        for resolved_method in &method_resolution.resolved_methods {
+            let class_name = ascii_lowercase_atom(resolved_method.method_identifier.get_class_name().as_ref());
+            let method_name = *resolved_method.method_identifier.get_method_name();
+            artifacts.symbol_references.add_reference_to_class_member(
+                &block_context.scope,
+                (class_name, method_name),
+                false,
+            );
+
+            identifiers.push(FunctionLikeIdentifier::Method(
+                *resolved_method.method_identifier.get_class_name(),
+                *resolved_method.method_identifier.get_method_name(),
+            ));
+        }
+
         let resulting_type = if self.argument_list.is_first_class_callable() {
-            let callable_types: Vec<TAtomic> = method_resolution
-                .resolved_methods
-                .into_iter()
-                .map(|resolved_method| {
-                    TAtomic::Callable(TCallable::Alias(FunctionLikeIdentifier::Method(
-                        *resolved_method.method_identifier.get_class_name(),
-                        *resolved_method.method_identifier.get_method_name(),
-                    )))
-                })
-                .collect();
-
-            if callable_types.is_empty() {
+            if identifiers.is_empty() {
                 if method_resolution.has_invalid_target { get_never() } else { get_mixed_closure() }
             } else {
-                TUnion::from_vec(callable_types)
+                TUnion::from_vec(
+                    identifiers.into_iter().map(|identifier| TAtomic::Callable(TCallable::Alias(identifier))).collect(),
+                )
             }
         } else {
             let mut closure_types = Vec::new();

crates/analyzer/src/expression/partial_application/static_method_partial_application.rs

@@ -1,4 +1,5 @@
 use mago_atom::AtomMap;
+use mago_atom::ascii_lowercase_atom;
 use mago_codex::identifier::function_like::FunctionLikeIdentifier;
 use mago_codex::ttype::atomic::TAtomic;
 use mago_codex::ttype::atomic::callable::TCallable;
@@ -33,22 +34,29 @@ impl<'ast, 'arena> Analyzable<'ast, 'arena> for StaticMethodPartialApplication<'
         let method_resolution =
             resolve_static_method_targets(context, block_context, artifacts, self.class, &self.method, self.span())?;
 
+        let mut identifiers = vec![];
+        for resolved_method in &method_resolution.resolved_methods {
+            let class_name = ascii_lowercase_atom(resolved_method.classname.as_ref());
+            let method_name = *resolved_method.method_identifier.get_method_name();
+            artifacts.symbol_references.add_reference_to_class_member(
+                &block_context.scope,
+                (class_name, method_name),
+                false,
+            );
+
+            identifiers.push(FunctionLikeIdentifier::Method(
+                *resolved_method.method_identifier.get_class_name(),
+                *resolved_method.method_identifier.get_method_name(),
+            ));
+        }
+
         let resulting_type = if self.argument_list.is_first_class_callable() {
-            let callable_types: Vec<TAtomic> = method_resolution
-                .resolved_methods
-                .into_iter()
-                .map(|resolved_method| {
-                    TAtomic::Callable(TCallable::Alias(FunctionLikeIdentifier::Method(
-                        resolved_method.classname,
-                        *resolved_method.method_identifier.get_method_name(),
-                    )))
-                })
-                .collect();
-
-            if callable_types.is_empty() {
+            if identifiers.is_empty() {
                 if method_resolution.has_invalid_target { get_never() } else { get_mixed_closure() }
             } else {
-                TUnion::from_vec(callable_types)
+                TUnion::from_vec(
+                    identifiers.into_iter().map(|identifier| TAtomic::Callable(TCallable::Alias(identifier))).collect(),
+                )
             }
         } else {
             let mut closure_types = Vec::new();

crates/analyzer/tests/cases/unused_method.php

@@ -50,3 +50,59 @@ public function unused(): void
     {
     }
 }
+
+class UsedViaFirstClassCallable
+{
+    private function helper(string $name): string
+    {
+        return "Hello, $name";
+    }
+
+    public function main(): void
+    {
+        $closure = $this->helper(...);
+        $closure("World");
+    }
+}
+
+class UsedViaPartialApplication
+{
+    private function greet(string $greeting, string $name): string
+    {
+        return "$greeting, $name";
+    }
+
+    public function main(): void
+    {
+        $sayHello = $this->greet("Hello", ?);
+        $sayHello("World");
+    }
+}
+
+class UsedStaticViaFirstClassCallable
+{
+    private static function helper(int $x): int
+    {
+        return $x * 2;
+    }
+
+    public function main(): void
+    {
+        $closure = self::helper(...);
+        $closure(5);
+    }
+}
+
+class UsedStaticViaPartialApplication
+{
+    private static function add(int $a, int $b): int
+    {
+        return $a + $b;
+    }
+
+    public function main(): void
+    {
+        $addFive = self::add(5, ?);
+        $addFive(10);
+    }
+}