Function build_function_plain

src/completion/phpdoc/generation.rs:1439–1544

(
    sym: &SymbolInfo,
    indent: &str,
    content: &str,
    position: Position,
    use_map: &HashMap<String, String>,
    file_namespace: &Option<String>,
    local_classes: &[Arc<ClassInfo>],
 

/// Same enrichment logic as the snippet builder, but without tab stops.
#[allow(clippy::too_many_arguments)]
fn build_function_plain(
    sym: &SymbolInfo,
    indent: &str,
    content: &str,
    position: Position,
    use_map: &HashMap<String, String>,
    file_namespace: &Option<String>,
    local_classes: &[Arc<ClassInfo>],
    class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
    function_loader: FunctionLoader<'_>,
) -> String {
    let throws_ctx = ThrowsContext {
        class_loader,
        function_loader,
        use_map,
        file_namespace,
    };
    let uncaught = throws_analysis::find_uncaught_throw_types_with_context(
        content,
        position,
        Some(&throws_ctx),
    );

    // Collect @param tags that need enrichment.
    let mut param_tags: Vec<(String, String)> = Vec::new();
    for (type_hint, name) in &sym.params {
        if let Some(enriched) = enrichment_plain(type_hint.as_ref(), class_loader) {
            param_tags.push((enriched, name.clone()));
        }
    }

    // Constructors never get @return.
    let is_constructor = sym
        .method_name
        .as_ref()
        .is_some_and(|n| n.eq_ignore_ascii_case("__construct"));
    let is_void = sym.return_type.as_ref().is_some_and(|r| r.is_void());
    let return_tag = if is_void || is_constructor {
        None
    } else {
        // Try body-based inference first (produces richer types like
        // `list<string>` instead of `array<mixed>`).
        let body_inferred = crate::code_actions::phpstan::fix_return_type::enrichment_return_type(
            content,
            position,
            local_classes,
            class_loader,
            function_loader,
        );
        // Filter out types that don't need a @return tag (void, scalars
        // that match the native hint exactly).
        let inferred = body_inferred.filter(|t| {
            !t.is_void()
                && !t.is_mixed()
                && sym.return_type.as_ref().is_none_or(|s| !t.equivalent(s))
        });
        // Fall back to signature-based enrichment when body inference
        // doesn't produce anything useful.