Function build_union_completion_items

src/completion/builder.rs:607–680

Build completion items from multiple candidate classes (union types), resolving each through full inheritance and deduplicating across them. This is the high-level entry point that combines per-candidate item building with union-aware merging. For each candidate: 1. Resolves the class fully (own + traits + parents + virtual members). 2. Determines whether the cursor is inside the target class or

(
    candidates: &[Arc<ClassInfo>],
    effective_access: AccessKind,
    current_class: Option<&ClassInfo>,
    class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
    cache: &crate::virtual_memb

/// The collected items are then passed to [`merge_union_completion_items`]
/// for deduplication and sort-tier assignment.
pub(crate) fn build_union_completion_items(
    candidates: &[Arc<ClassInfo>],
    effective_access: AccessKind,
    current_class: Option<&ClassInfo>,
    class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
    cache: &crate::virtual_members::ResolvedClassCache,
    uri: &str,
) -> Vec<CompletionItem> {
    let current_class_name = current_class.map(|cc| cc.name.as_str());
    let num_candidates = candidates.len();

    // Track how many candidate classes contributed each label so we can
    // distinguish intersection vs branch-only members.
    let mut all_items: Vec<CompletionItem> = Vec::new();
    let mut occurrence_count: HashMap<String, usize> = HashMap::new();

    for target_class in candidates {
        let resolved =
            crate::virtual_members::resolve_class_fully_cached(target_class, class_loader, cache);

        // Scope methods (and @method virtual methods from the model) are
        // injected onto the candidate ClassInfo by `resolve_named_type`
        // after generic substitution.  `resolve_class_fully_cached` uses
        // a cache key without generic args, so a prior cache entry for
        // the same class without generics will lack those injected
        // methods.  Merge back any instance methods from the candidate
        // that are missing from the resolved result so that scopes
        // survive the re-resolution.
        let merged = if target_class.methods.len() > resolved.methods.len() {
            let mut patched = (*resolved).clone();
            for method in target_class.methods.iter() {
                if !patched
                    .methods
                    .iter()
                    .any(|m| m.name == method.name && m.is_static == method.is_static)
                {
                    patched.methods.push(method.clone());
                }
            }
            std::sync::Arc::new(patched)
        } else {
            resolved
        };

        let self_or_ancestor = is_ancestor_of(current_class, target_class, class_loader);

        let items = build_completion_items(
            &merged,
            effective_access,
            current_class_name,
            self_or_ancestor,
            uri,
        );

        for item in items {
            if let Some(existing) = all_items
                .iter_mut()
                .find(|existing| existing.label == item.label)