Implement feature(more_qualified_paths)

[WaffleLapkin]

Example:

struct T;
struct S {
    a: u32,
}

trait Trait {
    type Assoc;
}

impl Trait for T {
    type Assoc = S;
}

let <T as Trait>::Assoc { a } = <T as Trait>::Assoc { a: 0 };

[WaffleLapkin]

This is mostly copied from the SelfType branch above and this feels very weird. For example the loop always does a single iteration...

[ChayimFriedman2]

The loop does not always do a single iteration, in the case Self::AssocType::EnumVariant it does two. However it seems you copied that incorrectly?

[WaffleLapkin]

Rrright. The reason I copied it like that is that I couldn't find a way to get the type (E in <E as Trait>::Assoc::ES) for the ty variable on first iteration.

I found a way to get the type, but you'll probably know a better one ^^'

[ChayimFriedman2]

Hmm... It seems your logic should indeed be different from Self, and you don't need a loop. Since there is no sense to code like Trait::EnumVariant, you can have straight control flow: lower assoc types (lower_partly_resolved_path(), but it expects no unresolved segments so you may need to adapt it or ignore_last_segment()), then check if you have an addition segment, in which case try to resolve an enum variant from the type (ty.as_adt() then extract an enum out of it).

[WaffleLapkin]

What I can't so far figure out is how to make this work for enums. Example:

enum E {
    ES { a: u32 },
    ET(u32),
}

impl Trait for E {
    type Assoc = Self;
}

let <E>::ES { a } = (<E>::ES { a: 0 }) else { panic!() };
let <E>::ET(a) = <E>::ET(0) else { panic!() };
let <E as Trait>::Assoc::ES { a } = (<E as Trait>::Assoc::ES { a: 0 }) else { panic!() };
let <E as Trait>::Assoc::ET(a) = <E as Trait>::Assoc::ET(0) else { panic!() };

Out of all these r-a can only resolve ET(0) in expressions (makes sense, this is equivalent to assoc functions), but no other variants...

[ChayimFriedman2]

The reason <E as Trait>::Assoc::ES does not work is because, as I said in a comment, you copied the loop incorrectly.

To resolve <E>::Variant, you need, at the top of the function to check if let Some(type_anchor) = path.type_anchor() (the type anchor is the E). If yes, you need to extract an enum out of it and match the variant. So something like:

        if let Some(type_anchor) = path.type_anchor() {
            let segments = path.segments();
            if segments.len() != 1 {
                return (self.err_ty(), None);
            }
            let ty = ctx.lower_ty(type_anchor);
            if let Some((AdtId::EnumId(id), _)) = ty.as_adt() {
                let enum_data = self.db.enum_variants(id);
                if let Some(variant) = enum_data.variant(segments.first().unwrap().name) {
                    // FIXME: Report error if there are generics on the variant.
                    return (ty, Some(variant.into()));
                }
            } else {
                // FIXME: Report an error.
                return (self.err_ty(), None);
            }
        }

Also, I'll be happy if you could deduplicate the code for handling Self and this.

[ChayimFriedman2]

Don't be afraid to ask for help should you need it!

[WaffleLapkin]

@ChayimFriedman2 thanks for your advise! I think I was able to implement the feature in a way which doesn't look that bad ^^'

Do you know where I could add tests for this?

[ChayimFriedman2]

Do you know where I could add tests for this?

crates/hir-ty/src/tests/traits.rs, you can look at existing tests there.

[Veykril]

This probably needs some adjustment for pattern path completions as well. Not necessary for this PR, just a note, can give pointers if you want to add that to this PR though. Seems like we complete the Assoc part in the struct constructor, but not in the deconstructor.

[WaffleLapkin]

@ChayimFriedman2 I'm currently a bit stuck. While adding tests I figured out that <Self>::Assoc { a: 0 } should work, provided it's in an impl of the trait which provides Assoc (this is specific to Self -- for any other type/syntax you need <T as Trait>).

I can check if the type ancor is Self and do something similar to what handles Self::. However, for <Self>::Assoc, path_ctx.resolve_path_in_type_ns() return None, so we early return from resolve_variant. Do you have an idea of what is a proper solution here?

[ChayimFriedman2]

Use lower_ty_ext() instead of lower_ty() for the type anchor. It provides you, in addition to the Ty, its TypeNs resolution. Check if it is SelfType and extract the ImplId. Then you can extract the trait of that impl with db.impl_trait(), and construct a projection to the associated type in the trait (basically, take the trait substitution from the TraitRef in the impl_trait(), add to it the associated type substitution lowered from the path, that'll be the substitution for the projection). Don't forget to normalize the projection if possible.