derive(SmartPointer): assume pointee from the single generic and better error messages

[dingxiangfei2009]

Fix #129465

Actually RFC says that #[pointee] can be inferred when there is no ambiguity, or there is only one generic type parameter so to say.

cc @Darksonn

r? @compiler-errors

[Darksonn]

@rustbot label F-derive_smart_pointer

[Darksonn]

I wonder if we can simplify these map operations with side effects by iterating multiple times. For example: (untested)

let self_params = generics
    .params
    .iter()
    .enumerate()
    .map(|(idx, p)| match p.kind {
        GenericParamKind::Lifetime => GenericArg::Lifetime(cx.lifetime(p.span(), p.ident)),
        GenericParamKind::Type { .. } => GenericArg::Type(cx.ty_ident(p.span(), p.ident)),
        GenericParamKind::Const { .. } => GenericArg::Const(cx.const_ident(p.span(), p.ident)),
    })
    .collect::<Vec<_>>();

let all_type_params = generics
    .params
    .iter()
    .enumerate()
    .filter_map(|(idx, p)| match p.kind {
        GenericParamKind::Type { .. } => Some((idx, p.span())),
        _ => None,
    })
    .collect::<Vec<(usize, Span)>>();

let pointee_params = generics
    .params
    .iter()
    .enumerate()
    .filter_map(|(idx, p)| match p.kind {
        GenericParamKind::Type { .. } if p.attrs().iter().any(|attr| attr.has_name(sym::pointee)) => Some((idx, p.span())),
        _ => None,
    })
    .collect::<Vec<(usize, Span)>>();

let pointee_param = match (pointee_params.as_slice(), all_type_params.as_slice()) {
    ([(idx, _span)], _) => idx,
    ([], [(idx, _span)]) => idx,
    ([], []) => {
        cx.dcx().struct_span_err(span, "`SmartPointer` requires a generic parameter").emit();
        return;
    }
    ([], _) => {
        let all_type_spans = all_type_params.into_iter().map(|(idx,span)| span).collect();
        cx.dcx().struct_span_err(all_type_spans, "you must use `#[pointee]` to specify which parameter is the `SmartPointer` pointee").emit();
        return;
    }
    (_, _) => {
        let pointee_spans = pointee_params.into_iter().map(|(idx,span)| span).collect();
        cx.dcx().struct_span_err(pointee_spans, "you can only use `#[pointee]` once").emit();
        return;
    }
};

[dingxiangfei2009]

Applied with slight adaptation

So now we one pass through the generics to get ourserlves the self_params. One more pass through the iterator is used to collect only the type parameters.

• If we find zero type parameters, err with diagnosis
• If we find exactly one type parameter, use it as #[pointee]
• Otherwise, filter through type parameters on whether there is #[pointee] designation and err when more than one such parameters are found

[compiler-errors]

diagnostics should not be capitalized

also this message could be tweaked:

exactly one generic type parameter must be marked as #[pointee] to derive SmartPointer traits

[compiler-errors]

also, there is no test for this message?

[dingxiangfei2009]

Oops. Added.

[dingxiangfei2009]

I forgot to add the hunk with the updated message as per your suggestion. It is checked in now.

[compiler-errors]

could you special case the == 0 case?

[dingxiangfei2009]

Applied. Moved the check above into here.

[compiler-errors]

Can you adjust this message?

only one type parameter can be marked as #[pointee] when deriving SmartPointer traits

sounds more natural that way

[dingxiangfei2009]

Applied

[compiler-errors]

@rustbot author

[dingxiangfei2009]

@rustbot ready

• Ran through the test and made sure that all diagnostic messages appeared, or have been used, at least once
• Applied suggestions on wording

[compiler-errors]

@bors r+ rollup

[bors]

📌 Commit 3914835 has been approved by compiler-errors

It is now in the queue for this repository.