#[salsa::tracked(return_ref)]
fn items_in_scope_impl<'db>(
    db: &'db dyn HirAnalysisDb,
    i_scope: ItemScope<'db>,
) -> IndexMap<String, NameRes<'db>> {
    let scope = i_scope.scope_kind(db).to_scope();
    let domain = i_scope.domain(db);
    let mut items: IndexMap<String, NameResBucket<'db>> = IndexMap::default();

    let mut resolver = NameResolver::new(db, &DefaultImporter);
    let local_resolutions =
        resolver.collect_all_resolutions_for_glob(scope, scope, FxHashSet::default());

    // Local definitions + imports (named then glob) with resolver precedence.
    for (ident, resolutions) in local_resolutions {
        let name = ident.data(db).to_string();
        let bucket = items.entry(name).or_default();
        for name_res in resolutions {
            if name_res.domain & domain != NameDomain::Invalid {
                bucket.push(&name_res);
            }
        }
    }

    // Collect unnamed/prelude imports (treated like named imports).
    let imports = &resolve_imports(db, scope.ingot(db)).1;
    if let Some(unnamed) = imports.unnamed_resolved.get(&scope) {
        for bucket in unnamed {
            for name_res in bucket.iter_ok() {
                if name_res.domain & domain != NameDomain::Invalid
                    && let Some(res_scope) = name_res.scope()
                    && let Some(name) = res_scope.name(db)
                    && name_res.is_visible(db, scope)
                {
                    items
                        .entry(name.data(db).to_string())
                        .or_default()
                        .push(name_res);
                }
            }
        }
    }

    // Recursively collect from parent scope (lexical shadowing handled via derivation).
    if let Some(parent) = scope.parent(db) {
        let parent_items = items_in_scope(db, parent, domain);
        for (name, name_res) in parent_items {
            let mut inherited = name_res.clone();
            inherited.derivation.lexed();
            items.entry(name.clone()).or_default().push(&inherited);
        }
    }

    // External ingots (lowest before primitives).
    for (ext_name, ingot) in scope.top_mod(db).ingot(db).resolved_external_ingots(db) {
        let res = NameRes::new_from_scope(
            ScopeId::from_item((ingot.root_mod(db)).into()),
            NameDomain::TYPE,
            NameDerivation::External,
        );

        if res.domain & domain != NameDomain::Invalid {
            items
                .entry(ext_name.data(db).to_string())
                .or_default()
                .push(&res);
        }
    }

    // Builtin primitive types (lowest precedence).
    if domain & NameDomain::TYPE != NameDomain::Invalid {
        for &prim in PrimTy::all_types() {
            let res = NameRes {
                kind: NameResKind::Prim(prim),
                domain: NameDomain::TYPE,
                derivation: NameDerivation::Prim,
            };

            items
                .entry(prim.name(db).data(db).to_string())
                .or_default()
                .push(&res);
        }
    }

    // Pick the best resolution per requested domain using resolver ordering.
    let mut flattened = IndexMap::default();
    for (name, bucket) in items {
        match bucket.pick(domain) {
            Ok(res) => {
                flattened.insert(name, res.clone());
            }
            Err(NameResolutionError::Ambiguous(cands)) => {
                if let Some(first) = cands.first() {
                    flattened.insert(name, first.clone());
                }
            }
            Err(_) => {}
        }
    }

    flattened
}