Fix namespace context for resolve_function_name

Author: AJenbo

docs/CHANGELOG.md

@@ -64,6 +64,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Blade files with raw `<?php ... ?>` tags no longer report false syntax errors.** PHP code embedded directly in a Blade template (outside `@php`/`@endphp`) is now recognized and passed through unmodified, so string literals that happen to start with `@` (e.g. a JSON-LD `'@context'` array key) are no longer misread as Blade directives.
 - **`@switch`/`@case` with a class-constant case value no longer reports a syntax error.** `@case (Some\Namespaced\Enum::VALUE)` now translates to a valid `case` arm instead of silently corrupting the rest of the file.
 - **Generated `@return` types infer the same rich type from multi-line array literals.** A function returning an array literal written across several lines now infers the precise type (for example `list<string>`) in its generated docblock, matching the single-line form. Previously breaking the literal onto multiple lines degraded the inferred type to `array<mixed>`.
+- **Calls to functions declared in another `namespace` block of the same file resolve their return type.** In a file that declares more than one `namespace`, a call to a function from a later block used to leave the returned value untyped unless the function carried an `@return` docblock. The call and its return type now resolve regardless, so completion, hover, and diagnostics see the value's type.
 
 ## [0.9.0] - 2026-07-20
 

docs/todo.md

@@ -105,7 +105,6 @@ unlikely to move the needle for most users.
 | D5  | [External tool diagnostic suppression actions](todo/diagnostics.md#d5-external-tool-diagnostic-suppression-actions)                                                         | Low         | Low         |
 | D15 | [Unused parameter diagnostic](todo/diagnostics.md#d15-unused-parameter-diagnostic)                                                                                          | Low         | Low         |
 |     | **[Bug Fixes](todo/bugs.md)**                                                                                                                                               |             |             |
-| B1  | [`resolve_function_name` guesses a single namespace, missing same-file multi-namespace declarations](todo/bugs.md#b1-resolve_function_name-guesses-a-single-namespace-missing-same-file-multi-namespace-declarations) | Low-Medium  | Medium      |
 |     | **[Code Actions](todo/actions.md)**                                                                                                                                         |             |             |
 | A40 | [Generate method from call](todo/actions.md#a40-generate-method-from-call)                                                                                                  | Medium-High | Medium      |
 | A41 | [Create class from non-existing name](todo/actions.md#a41-create-class-from-non-existing-name)                                                                              | Medium      | Medium      |

docs/todo/bugs.md

@@ -7,36 +7,4 @@ pipeline so it produces correct data. Downstream consumers
 (diagnostics, hover, completion, definition) should never need
 to second-guess upstream output.
 
-## B1. `resolve_function_name` guesses a single namespace, missing same-file multi-namespace declarations
-
-`resolve_function_name` (`src/resolution.rs`) builds its candidate
-list from a single `file_namespace` — the *call site's* namespace
-block (`FileContext::namespace` / `namespace_at_offset`). In a file
-that declares multiple `namespace` blocks, a function declared under
-a namespace other than the call site's does not match any candidate,
-even though it is already sitting in `global_functions` under its own
-FQN.
-
-`FileContext::resolve_name_at` (`src/types/mod.rs`) already solves
-this correctly for other identifiers by consulting `resolved_names`
-(mago-names' per-offset resolution, which understands multiple
-namespace blocks in one file). `resolve_function_name` should try
-`ctx.resolve_name_at(name, offset)` as a candidate before falling
-back to the single-namespace guess.
-
-This is why `src/completion/source/helpers.rs::
-extract_function_return_from_source` still exists: it is a same-file
-backward-text scanner for a function's `@return` docblock, used as a
-fallback in `rhs_resolution.rs` (guarded by `!loader_found`) exactly
-when `resolve_function_name` fails on this multi-namespace case. Once
-`resolve_function_name` is offset-aware, this text scanner becomes
-dead code and should be deleted along with its call site.
-
-**Scope note:** `function_loader`/`function_loader_with`
-(`src/resolution.rs`) are `Fn(&str) -> Option<FunctionInfo>` closures
-bound once per `FileContext`, with no offset parameter, across ~30
-call sites (completion, hover, definition, references, code actions).
-Fixing this requires either threading the call expression's byte
-offset through to `resolve_function_name` or adding an offset-aware
-variant of the loader closure. Size the fix accordingly — this is not
-a one-line change.
+No outstanding items.

src/blade/mod.rs

@@ -195,8 +195,8 @@ impl crate::Backend {
     fn blade_e_hover(&self, start: Position, len: u32) -> Hover {
         // Try to resolve the actual `e()` function from the project/stubs.
         let empty_use_map = std::collections::HashMap::new();
-        let loader = self.function_loader_with(&empty_use_map, &None);
-        let content = if let Some(func) = loader("e") {
+        let loader = self.function_loader_with(None, &empty_use_map, &None);
+        let content = if let Some(func) = loader("e", 0) {
             crate::hover::hover_for_function(&func, None, None, false).contents
         } else {
             HoverContents::Markup(MarkupContent {

src/code_actions/extract_function/scope.rs

@@ -30,7 +30,7 @@ pub(crate) fn resolve_var_type(
     let constant_loader = backend.constant_loader();
     let loaders = Loaders {
         function_loader: Some(
-            &function_loader as &dyn Fn(&str) -> Option<crate::types::FunctionInfo>,
+            &function_loader as &dyn Fn(&str, u32) -> Option<crate::types::FunctionInfo>,
         ),
         constant_loader: Some(&constant_loader),
     };

src/code_actions/phpstan/fix_return_type/inference.rs

@@ -69,7 +69,7 @@ impl Backend {
         let file_use_map: HashMap<String, String> = self.file_use_map(uri);
         let file_namespace: Option<String> = self.first_file_namespace(uri);
         let class_loader = self.class_loader_with(&local_classes, &file_use_map, &file_namespace);
-        let function_loader = self.function_loader_with(&file_use_map, &file_namespace);
+        let function_loader = self.function_loader_with(None, &file_use_map, &file_namespace);
 
         infer_return_type(
             content,

src/code_actions/replace_deprecated.rs

@@ -501,7 +501,7 @@ fn resolve_subject_to_class(
     backend: &Backend,
 ) -> Option<ClassInfo> {
     let class_loader = backend.class_loader_with(ctx.local_classes, ctx.use_map, ctx.namespace);
-    let function_loader = backend.function_loader_with(ctx.use_map, ctx.namespace);
+    let function_loader = backend.function_loader_with(None, ctx.use_map, ctx.namespace);
     let res_ctx = crate::subject_resolution::SubjectResolutionCtx {
         local_classes: ctx.local_classes,
         use_map: ctx.use_map,

src/completion/call_resolution/return_types.rs

@@ -615,7 +615,7 @@ impl Backend {
 
                 // Regular function lookup.
                 if let Some(fl) = ctx.function_loader
-                    && let Some(func_info) = fl(func_name)
+                    && let Some(func_info) = fl(func_name, 0)
                 {
                     if let Some(ref cond) = func_info.conditional_return {
                         let var_resolver = build_var_resolver(ctx);

src/completion/handler/phpdoc.rs

@@ -45,7 +45,10 @@ impl Backend {
                     position,
                     &ctx.classes,
                     &class_loader,
-                    Some(&function_loader as &dyn Fn(&str) -> Option<crate::types::FunctionInfo>),
+                    Some(
+                        &function_loader
+                            as &dyn Fn(&str, u32) -> Option<crate::types::FunctionInfo>,
+                    ),
                 )
             } else {
                 None

src/completion/phpdoc/mod.rs

@@ -55,7 +55,7 @@ pub type ClassLoaderFn<'a> = &'a dyn Fn(&str) -> Option<Arc<ClassInfo>>;
 ///
 /// Used by [`SmartContext`] for cross-file `@throws` propagation from
 /// standalone function calls.
-pub type FunctionLoaderFn<'a> = &'a dyn Fn(&str) -> Option<crate::types::FunctionInfo>;
+pub type FunctionLoaderFn<'a> = &'a dyn Fn(&str, u32) -> Option<crate::types::FunctionInfo>;
 
 // Re-export comment-position helpers so existing consumers (tests,
 // handler, catch_completion) that import from `phpdoc::` keep working.