Distinguish "declared" and "inferred" `Place`s

[sharkdp]

A Place is currently either Place::Unbound, Place::Type(type, Boundness::PossiblyUnbound or Place::Type(type, Boundness::Bound):

pub(crate) enum Boundness {
    Bound,
    PossiblyUnbound,
}

pub(crate) enum Place<'db> {
    Type(Type<'db>, Boundness),
    Unbound,
}

There is currently no way of tracking if a Place originated from a declaration or if its type has been inferred. However, we still use e.g. Place::Type(type, Boundness::Bound) to mean "definitely declared" in various places. For example, the place_from_declarations query also returns a Place (wrapped in PlaceFromDeclarationsResult -> PlaceAndQualifiers -> Place).

Similarly, the Member return type of various member-access functions currently tracks the "declared vs inferred" information separately.

We should attempt to refactor Place to generally contain metadata about the origin of a particular type.

Related issue: #1051

[mtshiba]

I remember considering the related issue during astral-sh/ruff#18041. At the time, it was associated with #229.
The new API for Place I was considering at the time was as follows:

// Boundness renamed
pub(crate) enum Definedness {
    Defined, // Bound renamed
    PossiblyUndefined, // PossiblyUnbound renamed
}

pub(crate) enum Place<'db> {
    // If there is both a declaration and a binding, `Place::Bound` will be used.
    Bound(Type<'db>, Definedness),
    Declared(Type<'db>, Definedness),
    Undefined,
}

If no one has started working on this yet, I'll get to it.
Please let me know if you have any comments on the direction of the new API.

[sharkdp]

The new API for Place I was considering at the time was as follows:

Sounds reasonable.

Please let me know if you have any comments on the direction of the new API.

Another idea would be something like the following with just a single variant that holds a Type.

pub(crate) enum TypeOrigin {
    Declared,
    Inferred,
}

pub(crate) enum Place<'db> {
    // If there is both a declaration and a binding, `Place::Bound` will be used.
    Defined(Type<'db>, TypeOrigin, Definedness),
    Undefined,
}

I guess it depends on which representation feels the most ergonomic when actually doing the refactor.

If no one has started working on this yet, I'll get to it.

That would be great. If it turns out to be a huge change that affects several other open PRs, maybe it would be better to do this after the beta release? Or maybe there is a smart way of doing this in several smaller steps, where the first step would keep the API of Place mostly intact?

[mtshiba]

That would be great. If it turns out to be a huge change that affects several other open PRs, maybe it would be better to do this after the beta release? Or maybe there is a smart way of doing this in several smaller steps, where the first step would keep the API of Place mostly intact?

I think we can start by adding Place::Declared and replacing all current Place::Type with Place::Bound (Place::Inferred would be a better name than Place::Bound for consistency with other existing types such as DeclaredAndInferredType), allowing us to introduce the new API without changing behavior.
Place::Declared will be used in the next step.

Alternatively, if we will use Place::{Defined, Undefined} and TypeOrigin, all TypeOrigins will initially be set to Inferred.