Unclear error message when using `Result` instead of `Ok`

[joepie91]

I made the mistake of trying to do if let Result(foo) = bar instead of if let Ok(foo) = bar, and got a confusing error like the following:

error[E0532]: expected tuple struct/variant, found enum `Result`
  --> src/service/prime.rs:18:16
   |
18 |         if let Result(parsed_number) = request.parse::<u64>() {
   |                ^^^^^^ not a tuple struct/variant

It took me a while to figure out what was wrong here; the error index entry for this error code was not very helpful either. Part of the problem is that the error tells me what it isn't, but not how what it is relates to that. To a beginner, the relationship between an Enum and one of its variants won't be intuitively obvious.

Perhaps the compiler feedback could also be improved here by suggesting Ok/Err (for Result) and Some/None (for Option), as these are common cases where this might occur. A more generic approach would be to simply list expected/valid variants for the specified Enum.

(As an aside, the contributing guidelines claimed that there would be an issue template, but there doesn't seem to be. I'm not sure whether that is intentional or not.)

[estebank]

check_pat_tuple_struct should look at the def.kind and if it is an enum, it should suggest using one of the enum's variants:

error[E0532]: expected tuple struct/variant, found enum `Result`
  --> src/service/prime.rs:18:16
   |
18 |         if let Result(parsed_number) = request.parse::<u64>() {
   |                ^^^^^^ not a tuple struct/variant
   = note: did you mean to use one of the following variants?
           - `Ok(T)`
           - `Err(E)`

[Menschenkindlein]

Hello, I'd like to take this one.

[estebank]

@Menschenkindlein feel free to reach out if you need any help!

[Menschenkindlein]

@estebank I could not reproduce the error E0164, that is reported by check_pat_tuple_struct.
However, I found that the error in the topic is a base error, reported by smart_resolve_path_fragment. I added a case (Def::Enum(defId), PathSource::TupleStruct) to the match, but I cannot find how to get hir::Item from DefId in this context. I hope, it will give me access to the enum's variants.

[estebank]

self.tcx.hir.get_if_local(def_id) will give you a Node if this DefId is part of the current crate, which has a NodeItem variant that holds a hir::Item and from there you can get the vec of variants you're looking for.

[Menschenkindlein]

Could you, please, explain to me what this magic tcx field really is? I saw its usage in check_pat_tuple_struct, but there was other self - FnCtxt. Both it and Resolver doesn't have this field in their definition.

[estebank]

@Menschenkindlein you have the following code:

impl<'a, 'gcx, 'tcx> Deref for TyCtxt<'a, 'gcx, 'tcx> {
    type Target = &'a GlobalCtxt<'gcx>;
    fn deref(&self) -> &Self::Target {
        &self.gcx
    }
}

As TyCtxt implements Deref for GlobalCtxt, when accessing a field of a borrow of tcx you can also access the methods and fields of tcx.gcx. You can think of it as a way of having inheritance (with caveats) in rust.

[Menschenkindlein]

rustc_resolver::Resolver doesn't have access to GlobalCtxt as far as I see. I think the change should be made in some of the calling functions. It is too difficult for me to find in which one, though.