C++: use references for non-trivial types in accessors

[pwrobeldev]

The generated accessors used by-value return and parameter
types even for non-trivial types. This change is intended
to improve the situation by introducing usage of reference
for the mentioned non-trivial types.

This merge request:

• introduces usage of const l-references for non-trivial types
  in getters defined via accessors attribute for structures
  when it is called on l-value
• introduces usage of r-references for non-trivial types
  in getters defined via accessors attribute for structures
  when it is called on r-value
• introduces usage of references for non-trivial types in setters
  (two overloads are provided -- const lvalue ref and rvalue ref)
• strips constness and references from type used to select a hash
  in 'StructHashImpl.mustache' because std::hash does not
  accept references/constness for T
• updates output of smoke tests to show, that since this commit
  the generated accessors use const references for non-trivial
  types
• implements a new functional test for C++ accessors

Note: the following changes extend smoke tests to show that
accessors defined for non-trivial types use references,
whether accessors defined for trivial types use values.

[Hsilgos]

Suggested change

	{{resolveName typeRef}} {{resolveName this "" "getter"}}( ) const && { return {{resolveName}}; }{{/ifPredicate}}{{!!
	const {{resolveName typeRef}}&&{{resolveName this "" "getter"}}( ) const && { return std::move({{resolveName}}); }{{/ifPredicate}}{{!!

[pwrobeldev]

Returning by-value is intentional here.

The proposed patch of return type may lead to dangling reference -- please see the toy-example that reproduces the possible problem (via usage of auto&&):
https://godbolt.org/z/eMxMG3zEW

I would be tempted to apply std::move() on a member field, but return by-value to avoid dangling references and at the same time avoid copying (example). But it needs to be done on a non-const member function overload.

Because, if the const is applied, then std::move() will result in const RefType &&, which will anyway call copy-constructor instead of move constructor (example here). In case of some types it may even cause compilation error, because some types from the standard library explicitly delete this overload (e.g. std::thread).

However, providing only && overload without providing && const overload may lead to problems. Please see the following example.

So, as far as I understand, to avoid copying, but also prevent dangling references, three overloads of getter need to be provided:

    // Called for all l-values.
    const GType & get_g() const & {
        return g;
    }

    // If this overload is not present, then a function returning 'const GType'
    // will use the overload for l-value which causes dangling ref.
    GType get_g() const && {
        return g;
    }

    // Called on non-const rvalue.
    GType get_g() && {
        return std::move(g);
    }

[pwrobeldev]

Fixed the problem by introducing 3 overloads of getter for non-trivial types.

Moreover, for such types 2 overload of setters have been added -- const lvalue ref and rvalue ref.

[pwrobeldev]

The code was updated according to the offline discussion.

[pwrobeldev]

Note for reviewers -- the change is split into 3 commits:

• extension of smoke tests to show invalid behavior of generator of getters -- it is big, but contains mostly the generated code
• the actual fix for the problem -- it is not so big and that's the core change in logic
• implementation of a new functional test -- for further verification

[pwrobeldev]

Note: if these test cases used auto&&, then we would have dangling references.