Function resolve_in_method_body

src/completion/variable/forward_walk.rs:2279–2410

Resolve the target variable from a method body using the forward walker. This is the main entry point called from `resolve_variable_in_members`. It seeds the scope with parameter types and walks the method body forward to the cursor.

(
    var_name: &str,
    parameters: impl Iterator<Item = &'b FunctionLikeParameter<'b>>,
    body_statements: impl Iterator<Item = &'b Statement<'b>>,
    method_span_start: u32,
    method_ctx: Opt

/// It seeds the scope with parameter types and walks the method body
/// forward to the cursor.
pub(crate) fn resolve_in_method_body<'b>(
    var_name: &str,
    parameters: impl Iterator<Item = &'b FunctionLikeParameter<'b>>,
    body_statements: impl Iterator<Item = &'b Statement<'b>>,
    method_span_start: u32,
    method_ctx: Option<(&str, bool)>,
    is_static: bool,
    ctx: &ForwardWalkCtx<'_>,
) -> Option<Vec<ResolvedType>> {
    // Collect iterators up front so they can be reused across the cache
    // populate path and the standard walk path without ownership issues.
    let params_vec: Vec<&'b FunctionLikeParameter<'b>> = parameters.collect();
    let stmts_vec: Vec<&'b Statement<'b>> = body_statements.collect();

    // ── Hover scope cache ────────────────────────────────────────────────
    // The hover scope cache records snapshots at each statement's START
    // offset (before the statement is processed).  This works well for
    // member-access resolution within a statement (which needs the scope
    // from before the statement), but returns the wrong type for variable
    // hover on the LHS of an assignment: hovering `$x` in `$x = new Foo()`
    // should show the post-assignment type (`Foo`), not the pre-assignment
    // type.  Detecting all edge cases (nudged offsets, nested blocks,
    // closures) is fragile, so variable resolution always uses the
    // standard walk which processes statements up to the cursor and
    // returns the correct post-assignment scope.
    //
    // The cache IS still populated here (if not yet present) so that
    // other consumers (diagnostics member-access lookups via
    // `lookup_diagnostic_scope`) benefit from it.
    if !is_diagnostic_scope_active()
        && is_hover_scope_cache_active()
        && !hover_scope_has_method(method_span_start)
    {
        // Activate a temporary diagnostic scope so that walk_body_forward
        // records snapshots at every statement boundary.
        let _diag_guard = with_diagnostic_scope_cache();

        // Build a full-walk context (cursor at u32::MAX = walk entire body).
        let full_ctx = ForwardWalkCtx {
            cursor_offset: u32::MAX,
            current_class: ctx.current_class,
            all_classes: ctx.all_classes,
            content: ctx.content,
            class_loader: ctx.class_loader,
            loaders: ctx.loaders,
            resolved_class_cache: ctx.resolved_class_cache,
            enclosing_return_type: ctx.enclosing_return_type.clone(),
            top_level_scope: ctx.top_level_scope.clone(),
        };

        let mut scope = ScopeState::new();
        if !is_static {
            seed_this(&mut scope, ctx.current_class);
        }
        let method_name = method_ctx.map(|(n, _)| n);
        let has_scope_attr = method_ctx.is_some_and(|(_, s)| s);

        seed_params(