Code change:
Given the example code: I get a really nice warning message about what I did wrong: However, if I change the main function to match multiple patterns: The error message is really confusing with no hint how to fix it: Please expand the error message for the second case to look a bit more like the first case.
Triage: no change. We need to supply the line in E0408.
so I thought I would implement the change you've proposed but have been thinking how best to restrict the kinds of cases where this help note would be appended to the error as I figured it may be rather noisy and/or confusing within the context of some false negatives. So during resolution we of course cannot look at the types to see if it's possible we're matching against an enum. But what do you think about having the help note kick in only if the binding starts with an upper case letter? I know this is a convention that should not really be a concern of the compiler but seeing that using it would only make the diagnostic note a bit more fine-grained, perhaps it's not a terrible idea?
we already do that in some places, like the parser to infer intent, but in this case how would you figure out that you want to suggest and without resolving ? I believe a more holistic solution would be to detect "variable not bound in all patterns" errors where all bindings are single idents, record that fact while throwing the current error and recovering as if there had been a single variable, and later when we have access to the machinery uses emit a warning suggesting and . It is a bit more involved but if we recover as if only had been present the current diagnostic should kick in suggesting (leaving without a suggestion). Edit: that won't work as things stand, as the warning won't be emitted today if there are errors, I think. That would also need to be changed to make it always be emitted :-/
no, I didn't mean to say we need to suggest possible variants. I too concluded that it's non-trivial with the current ordering of passes and the early bailout (indeed, type checking is impossible without resolution succeeding). I was going to add the help note you proposed back in May, just that I would make it dependent on bindings having a Variant-alike naming. From what you're saying there's a precedent in , so I guess this is an acceptable solution? I'll make a PR then.
sorry, I misunderstood. Go ahead, it sounds good.
no, it's likely me who wasn't clear enough. :) I submitted a PR.

Related discussion:
text: err } ResolutionError::VariableNotBoundInPattern(binding_error) => { <del> let target_sp = binding_error.target.iter().cloned().collect::<Vec<_>>(); </del> <ins> let BindingError { name, target, origin, could_be_path } = binding_error; let target_sp = target.iter().copied().collect::<Vec<_>>(); let origin_sp = origin.iter().copied().collect::<Vec<_>>(); </ins> let msp = MultiSpan::from_spans(target_sp.clone()); <del> let msg = format!("variable `{}` is not bound in all patterns", binding_error.name); </del> <ins> let msg = format!("variable `{}` is not bound in all patterns", name); </ins> let mut err = self.session.struct_span_err_with_code( msp, &msg, DiagnosticId::Error("E0408".into()), ); for sp in target_sp { <del> err.span_label(sp, format!("pattern doesn't bind `{}`", binding_error.name)); </del> <ins> err.span_label(sp, format!("pattern doesn't bind `{}`", name)); </ins> } <del> let origin_sp = binding_error.origin.iter().cloned(); </del> for sp in origin_sp { err.span_label(sp, "variable not in all patterns"); } <ins> if *could_be_path { let help_msg = format!( "if you meant to match on a variant or a `const` item, consider  making the path in the pattern qualified: `?::{}`", name, ); err.span_help(span, &help_msg); } </ins> err } ResolutionError::VariableBoundWithDifferentMode(variable_name,