RegisterPassable should be a trait

[lsh]

Right now register passable types are defined using a decorator: @register_passable("trivial"). However, if instead we had a marker trait RegisterPassable, we would have cleaner options for composition. The main benefit would be clear with wrapper and container types like Optional and Variant. Ideally this would look something like (bikeshed syntax for extensions):

trait RegisterPassable:
    pass

extension Optional[T: RegisterPassable](RegisterPassable):
    pass

That way, if a type is register passable, or in the case of Variant all types within it are, then the container itself can be marked that way as well.

[lattner]

+1 conceptually, but I'm not sure what practical value we'd get out of that. Swift, for reference, has three different levels of types: "trivial register types", "pointer sized values managed by arc" and "general things". The reason for the middle thing is that Swift doesn't always instantiate generics like Mojo/Rust do, owned object pointers are very common, and knowing the size of something allows a bunch of optimizations.

What would "knowing something is register passable" enable in practice? I'm not sure you example is the best motivation. We don't have conditional conformance yet (e.g. array is copyable if all members are) so we can't do your example quite yet. Even when we can, it isn't actually an optimization - after instantiation, Optional will get converted to a nice representation if T is register passable.

[lsh]

From what I understand via my conversation with Jeff, Optional will not get optimized after instantiation of T into a register-passable form because by definition it is memory-only. And therefore that memory-only-ness becomes a sticky property of generics.

E.g. it is impossible to have a register-passable type that transitively contains a generic, such as:

@register_passable
struct WantToBeRegPassable:
    var value: Optional[Int] # not reg-passable

[Moosems]

Might help in defining clearly that a function only takes register passable types? I could see this coming in handy if one wants to have a function that creates a register passable class instance that holds a register passable variable in it taken as an argument.

[Brian-M-J]

Would making RegisterPassable a trait obviate the need for OptionalReg and AnyRegType?