Aggregate constructors for wrapper classes

[HertzDevil]

With this PR, wrapper classes of aggregate types may be created using a familiar record syntax, like lib structs:

struct Point3D {
  int x, y, z;
};

class Point3D
  def initialize(*, x : Int32, y : Int32, z : Int32)
    # this calls `new (UseGC) Point3D {x, y, z}`
  end
end

pt = Point3D.new x: 1, y: 2, z: 4

Some aggregate types in Qt are QPainterPath::Element and the QStyleOption hierarchy. Wrapping these types as Crystal classes rather than lib structs means their methods no longer have to be reimplemented on the Crystal side (this is generally true for "structs" in many C++ APIs).

The rules for aggregate initialization have changed in every C++ version. This PR follows the C++11 rules. The rules can be relaxed if Bindgen uses a more recent C++ standard requirement:

• C++14: Aggregate initialization is permitted when any of the fields has a default value. This means the NSDMIs from the previous patch could be put to good use:

  struct Point {
  int x = 0, y = 1;
  };

  class Point
  def initialize(*, x : Int32 = 0, y : Int32 = 1)
    # this calls `new (UseGC) Point {x, y}`
    # the actual C++ call doesn't rely on any default values
  end
  end

  I ran the tests with the default value check disabled and -std=c++14 added to the spec runner options, and this seemed to work out of the box.

• C++17: Public, non-polymorphic base classes are allowed in aggregate types; if these bases are aggregates themselves, all fields can be initialized from a single aggregate constructor.
• C++20 / C99: Using designated initializers, e.g. Point {.y = 2}, it is possible to initialize C++ unions from any variant member other than the first. Without this, unions wouldn't really benefit much from aggregate initialization.

[Papierkorb]

Sorry for the delay! Will look into this today or tomorrow at last. I think the feature itself is awesome 👍

[Papierkorb]

Does this work with copied structs?

[HertzDevil]

lib structs come with this capability already, as do record structs. The major difference is that lib structs permit zero initialization if some of the fields are omitted, because their constructors are implemented as macros:

lib Binding
  struct Point
    x : Int32
    y : Int32
  end
end
# the following expands to:
# __temp_123 = Binding::Point.new
# __temp_123.x = 1
# __temp_123
Binding::Point.new(x: 1).y # => 0

# the following expands to:
# struct RecPoint
#   def initialize(@x, @y = 5) end
# end
record RecPoint, x : Int32, y : Int32 = 5

# this PR would generate: (provided C++14 rules are used)
struct MyPoint
  def initialize(*, x : Int32, y : Int32 = 5) end
end

The second difference is both lib structs and this PR require named arguments, whereas record allows positional ones.

[Papierkorb]

Thank you 👍