Auto conversions

[bvdberg]

The idea is to allow conversion from Struct to its first member instead of forcing the user to use 'cast'.
So

type Outer struct {
   Inner i;
}
..
Outer o1 = ..
Inner i1 = o1;

Outer* o2 = ..
Inner* i2 = o2;

There are 2 situations:

• full member (Inner i)
• pointer member (Inner* i)

Also 2 conversions:

• Outer
• Outer*

Things to consider:

• const keyword
• unions
• if member is Inner* (not Inner).
• Q: allow A.B.C -> A -> C?
• Q: allow passing an Outer* to a call expecting an Inner* ? (eg. printInner(o_ptr); )

Advantages of this would be:

• Inner* i = o_ptr; instead of Inner* i = cast<Inner*>(o_ptr);
• more type safety, since not using cast

Disadvantages:

• none I can think of.

[chqrlie]

I would definitely support Outer *o = ...; Inner* i = o; for assignment and function argument passing. This should also be accepted recursively, implicitly casting a pointer to a struct as one to the first member of its first member etc.

Supporting it for type functions would make sense and be consistent. but in case of ambiguity (eg: expression structures have an Expr member which itself has a Stmt first member, both of which might have a type function by the same name) the cast should be explicit rather than implicit ?

For actual structures, I don't think an implicit cast is palatable, but I might be wrong, I just can't think of good examples.

Regarding a.base.base.c, what about making the base class an unnamed member and allow a.c directly ? this introduces a constraint on member names which must not conflict with unnamed substructures' members.

Expr would become:

public type Expr struct @(opaque) {
    Stmt;
    SrcLoc loc;
    QualType qt;
}

and UnaryOperator:

public type UnaryOperator struct @(opaque) {
    Expr;
    Expr* inner;
}

C3 has inline struct members for this. C2 could use local for this purpose and keep a member name:

public type Expr struct @(opaque) {
    Stmt stmt local;  // local after the declaration as in `module`
    SrcLoc loc;
    QualType qt;
}

public type UnaryOperator struct @(opaque) {
    Expr expr local;
    Expr* inner;
}

[bvdberg]

What we are talking about here is some sort of inheritance structure , so is a relation. That would mean we should only these conversions for full members and not pointer members (since pointers imply a has a relation).

I would like to focus on the conversions first, whether we want anonymous members is another discussion ;)
I'll implement the most basic conversion first, then I'll see what issues pop up.

Update: WOW that didn't take long before an issue popped up!

type Foo struct {
  i32 x;
}

An implicit conversion between Foo and i32 is not what you would want. This could cause lots of weird bugs.
For now i'll only accept struct -> struct conversions, since the idea is 'inheritance'

[chqrlie]

I'm not too confortable with this approach, derived types are not really converted to the base type, but implicitly converting a pointer as a pointer to the base type seems OK (except for builtin types).