Right now, this doesn't change much except the
behavior in the event that `Eq` is not properly
implemented. In the future, it will enable
the use of references and slices and things.

This is a step towards the goal of keep a pointer
in the structs themselves.

There are 3 call-sites to this function:

* One of them has already marked the outputs
* One of them has no outputs
* The third does need to mark the outputs

In particular, the ingredient and the database
have the same lifetime.
This will be useful later for safety conditions.

The internal API is now based around providing
references to the `TrackedStructValue`.

Documenting the invariants led to one interesting
case, which is that we sometimes verify a tracked
struct as not having changed (and even create
`&`-ref to it!) but then re-execute the function
around it.

We now guarantee that, in this case, the data
does not change, even if it has leaked values.
This is required to ensure soundness.
Add a test case about it.

We need a cheap way to compute field indices.

This reverts commit 43b1b8e.

Just use salsa::Id for the most part.

tracked structs with `'db` carry a pointer
and not an id.

is there a nicer way to do this?!

It will be shared between tracked structs and
interned structs.

Salsa struct is already a grab-bag, best to keep
it to shared functionality.

This will permit GATs so that interned values
can carry lifetimes.

also fix name of a fn in one case

We'll need these for use with tracked functions

Previously tracked structs relied on an
interned ingredient to intern their keys.
But really it has more complex logic than we
need. Simpler to just remove it and duplicate
the basic concept.

this will let us use different packages
but the same struct name from salsa struct

We are going to need it for tracked functions.

We are going to need it for tracked functions.

We now have AsId (always present)
and FromId/LookupId (sometimes present).

AsId is no longer part of the
salsa public interface.

Replace the ad-hoc `salsa_id` etc methods with
calls to `AsId::as_id`.

It works! Huzzah.

and add dedicated tests for that

And a test for it. This is required if you
want to have structures in your tracked structs.

Looks we need one for salsa::DebugWithDb, too.

This leads less representation information
and in particular avoids serializing pointers.

to avoid uniqueness guarantees

This reverts commit a7b2805.

In old code, we converted to a `&'db` when
creating a new tracked struct or interning,
but this value in fact persisted beyond the end
of `'db` (i.e., into the new revision).

We now refactor so that we create the `Foo<'db>`
from a `NonNull<T>` instead of a `&'db T`, and
then only create safe references when users
access fields.

This makes miri happy.

This...seems dated. We have `specify` which is
a more correct and principled version. Not sure
what `set` was meant to be but I don't see any
tests for it so...kill it.

tracked structs only support `'db` lifetimes

This was not obvious to me initially.

Still debating the best structure, so the contents
are rather scattershot.

I may have found a hole, but it's...obscure
and I'm comfortable with it for the time being,
though I think we want to close it eventually.

Co-authored-by: Micha Reiser <micha@reiser.io>
Co-authored-by: Ryan Cumming <etaoins@gmail.com>
Co-authored-by: David Barsky <me@davidbarsky.com>