Function is_caught_by

src/completion/source/throws_analysis.rs:1059–1101

Check whether a throw at `offset` in the function body is caught by one of the `catches`, given the exception type.

(
        catches: &[CatchInfo],
        offset: usize,
        exc_type: &PhpType,
        use_map: &HashMap<String, String>,
        file_namespace: &Option<String>,
        class_loader: OptClassLo

    /// Check whether a throw at `offset` in the function body is caught
    /// by one of the `catches`, given the exception type.
    fn is_caught_by(
        catches: &[CatchInfo],
        offset: usize,
        exc_type: &PhpType,
        use_map: &HashMap<String, String>,
        file_namespace: &Option<String>,
        class_loader: OptClassLoader<'_>,
    ) -> bool {
        let exc_name = exc_type.base_name().unwrap_or("");
        // Resolve exception type to FQN via class loader if available.
        let exc_fqn = if let Some(loader) = class_loader {
            loader(exc_name)
                .map(|cls| cls.fqn().to_string())
                .unwrap_or_else(|| exc_name.to_string())
        } else {
            exc_name.to_string()
        };
        catches.iter().any(|c| {
            offset > c.try_start
                && offset < c.try_end
                && c.type_names.iter().any(|ct| {
                    let ct_name = ct.base_name().unwrap_or("");
                    // Resolve the catch type to FQN
                    let resolved_ct = crate::util::resolve_to_fqn(ct_name, use_map, file_namespace);
                    // Also try through the class loader for root-namespace classes.
                    let resolved_ct = if let Some(loader) = class_loader {
                        loader(&resolved_ct)
                            .or_else(|| loader(ct_name))
                            .map(|cls| cls.fqn().to_string())
                            .unwrap_or(resolved_ct)
                    } else {
                        resolved_ct
                    };
                    // Check for Throwable/Exception (catches everything).
                    let resolved_lower = resolved_ct.to_ascii_lowercase();
                    if resolved_lower == "throwable" || resolved_lower == "exception" {
                        return true;
                    }
                    // Exact FQN comparison (case-insensitive)
                    resolved_ct.eq_ignore_ascii_case(&exc_fqn)
                })
        })
    }

    /// Normalize a ThrowInfo's type_name into a PhpType::Named,
    /// resolving short names to FQN when use_map/namespace are available.