[BUG] public non-this data member has no effect

[JohelEGP]

public this: is disallowed. But before a this data member, a public non-this data member is not diagnosed, and has no effect.

Minimal reproducer:

x: type = { }
y: type = { }
z: type = {
  public a: x = x();
  this: y = ();
  operator=: (out this) = { }
}
w: x = z().a;

Commands:

cppfront x.cpp2
clang++17 -std=c++2b -stdlib=libc++ -I $CPPFRONT_INCLUDE_DIR x.cpp

Expected result: A well-formed program, or a diagnostic.

Actual result and error:

Generated C++1

//=== Cpp2 type declarations ====================================================


#include "cpp2util.h"

#line 1 "x.cpp2"
class x;
class y;
class z;

//=== Cpp2 type definitions and function declarations ===========================

#line 1 "x.cpp2"
class x {};
class y {};
class z: private cpp2::store_as_base<"a",x>, public y {

#line 6 "x.cpp2"
  public: z();
};
extern x w;
//=== Cpp2 function definitions =================================================


#line 6 "x.cpp2"
  z::z()
                            : cpp2::store_as_base<"a",x>{ x() }
#line 6 "x.cpp2"
  {}

x w {z().a}; 

x.cpp2:8:10: error: no member named 'a' in 'z'
x w {z().a}; 
     ~~~ ^
1 error generated.

[JohelEGP]

If the position of a non-this data member, with respect to a this data member, shouldn't change behavior, perhaps the generation of a base class is the answer:

struct cpp2_a_for_z {
  x a;
};
class z : public cpp2_a_for_z // ...

[JohelEGP]

I noticed that public does affect the following data member.

  public a: x = x();
  this: y = ();

class z: private cpp2::store_as_base<"a",x>, public y {

[hsutter]

[Updated]

Thanks!

perhaps the generation of a base class is the answer:

Hmm, you may have something there. I thought of several ways to implement this, but didn't think of that one -- thank you.

[ETA] On second thought, I wonder if I would then have to echo the constructors the same way again, and that would lead to a lot more generated code. For now, perhaps simpler is to disallow non-private data members before base types... that should be a weird combination.

I noticed that public does affect the following data member.

No, that one is just because my current experiment is to require that all base types are public, so this: y is implicitly public (and can't be declared with any other accessibility).

[JohelEGP]

On second thought, I wonder if I would then have to echo the constructors the same way again, and that would lead to a lot more generated code.

How about using an aggregate base class that holds a T? cpp2::store_as_base, as currently specified, introduces an extra indirection in the initialization:

a: type = {
  b: int = 0;
}
// Directly initializes `b` from `0`.
c: a = ();

// If we could make an aggregate:
// d: type = {
//   public e: int;
// }
// // Directly initializes `e` from `0`.
// f: d = (0);

g: type = {
  h: int;
  operator=: (out this, x: int) = h = x;
}
// Initializes `x` from `0`, then `h` from `x`.
i: g = 0;

j: type = { }
k: type = {
  l: int = 0;
  this: j = ();
  m: int = 0;
  operator=: (out this) = { }
  operator=: (out this, x: int, y: int) = {
    l = x;
    m = y;
  }
}
// Initializes `QoI` from `0`, then `l` from `std::move(QoI)`.
// Directly initializes `m` from `0`.
n: k = ();
// Initializes `x` from `0`, then `QoI` from `x`, then `l` from `std::move(QoI)`.
// Initializes `y` from `1`, then `m` from `y`.
o: k = (0, 1);

[hsutter]

Thanks @JohelEGP for that aggregate base suggestion, that's nicer -- done in the commit I just pushed