// Copyright 2022-2024 Herb Sutter

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

// Part of the Cppfront Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://github.com/hsutter/cppfront/blob/main/LICENSE for license information.

//===========================================================================

// Reflection and meta

//===========================================================================

#include "parse.h"

#include "cpp2regex.h"

using namespace cpp2::regex;

cpp2: namespace = {

meta: namespace = {

//-----------------------------------------------------------------------

//

// Compiler services

//

//-----------------------------------------------------------------------

//

compiler_services: @polymorphic_base @copyable type =

{

// Common data members

//

errors : *std::vector<error_entry>;

includes : *std::set<std::string>;

errors_original_size : int;

generated_tokens : *stable_vector<token>;

parser : cpp2::parser;

metafunction_name : std::string = ();

metafunction_args : std::vector<std::string> = ();

metafunctions_used : bool = false;

// Constructor

//

operator=: (

out this,

errors_ : *std::vector<error_entry>,

includes_ : *std::set<std::string>,

generated_tokens_: *stable_vector<token>

)

= {

errors = errors_;

includes = includes_;

errors_original_size = cpp2::unchecked_narrow<int>(std::ssize(errors*));

generated_tokens = generated_tokens_;

parser = (errors*, includes*);

}

// Common API

//

set_metafunction_name: (inout this, name: std::string_view, args: std::vector<std::string>) = {

metafunction_name = name;

metafunction_args = args;

metafunctions_used = args.empty();

}

get_metafunction_name: (this) -> std::string_view = metafunction_name;

get_argument: (inout this, index: int) -> std::string = {

metafunctions_used = true;

if (0 <= index < metafunction_args.ssize()) {

return metafunction_args[index];

}

return "";

}

get_arguments: (inout this) -> std::vector<std::string> = {

metafunctions_used = true;

return metafunction_args;

}

arguments_were_used: (this) -> bool = metafunctions_used;

protected parse_statement: (

inout this,

copy source: std::string_view

)

-> (ret: std::unique_ptr<statement_node>)

= {

original_source := source;

generated_lines.push_back( std::vector<source_line>() );

lines := generated_lines.back()&;

add_line := :(s: std::string_view) = {

_ = lines$*.emplace_back( s, source_line::category::cpp2 );

};

// First split this string into source_lines

//

(copy newline_pos := source.find('\n'))

if source.ssize() > 1

&& newline_pos != source.npos

{

while newline_pos != source.npos

{

add_line( source.substr(0, newline_pos) );

source.remove_prefix( newline_pos+1 );

newline_pos = source.find('\n');

}

}

if !source.empty() {

add_line( source );

}

// Now lex this source fragment to generate

// a single grammar_map entry, whose .second

// is the vector of tokens

_ = generated_lexers.emplace_back( errors* );

tokens := generated_lexers.back()&;

tokens*.lex( lines*, true );

assert( std::ssize(tokens* .get_map()) == 1 );

// Now parse this single declaration from

// the lexed tokens

ret = parser.parse_one_declaration(

tokens*.get_map().begin()*.second,

generated_tokens*

);

if !ret {

error( "parse failed - the source string is not a valid statement:\n(original_source)$");

}

}

add_runtime_support_include: (inout this, s: std::string_view) = _=includes*.emplace( s );

position: (virtual this)

-> source_position

= {

return ();

}

// Error diagnosis and handling, integrated with compiler output

// Unlike a contract violation, .requires continues further processing

//

require:(

this,

b : bool,

msg : std::string_view

)

= {

if !b {

error( msg );

}

}

error: (this, msg: std::string_view)

= {

message := msg as std::string;

if !metafunction_name.empty() {

message = "while applying @(metafunction_name)$ - (message)$";

}

_ = errors*.emplace_back( position(), message);

}

// Enable custom contracts on this object, integrated with compiler output

// Unlike .requires, a contract violation stops further processing

//

report_violation: (this, msg) = {

error(msg);

throw( std::runtime_error(

" ==> programming bug found in metafunction @(metafunction_name)$ "

"- contract violation - see previous errors"

) );

}

is_active:(this) = true;

}

//-----------------------------------------------------------------------

//

// All reflection types are wrappers around a pointer to node

//

//-----------------------------------------------------------------------

//

reflection_base: @polymorphic_base @copyable <T> type =

{

this: compiler_services = ();

protected n: *T;

protected operator=: (

out this,

n_: *T,

s : compiler_services

)

= {

compiler_services = s;

n = n_;

assert( n, "a meta:: reflection must point to a valid node, not null" );

}

position: (override this) -> source_position = n*.position();

print: (this) -> std::string = n*.pretty_print_visualize(0);

}

//-----------------------------------------------------------------------

//

// Declarations

//

//-----------------------------------------------------------------------

//

//-----------------------------------------------------------------------

// All declarations

//

declaration: @polymorphic_base @copyable type =

{

this: reflection_base<declaration_node> = ();

operator=: (

out this,

n_: *declaration_node,

s : compiler_services

)

= {

reflection_base<declaration_node> = (n_, s);

}

is_public : (this) -> bool = n*.is_public();

is_protected : (this) -> bool = n*.is_protected();

is_private : (this) -> bool = n*.is_private();

is_default_access: (this) -> bool = n*.is_default_access();

default_to_public : (inout this) = _ = n*.make_public();

default_to_protected: (inout this) = _ = n*.make_protected();

default_to_private : (inout this) = _ = n*.make_private();

make_public : (inout this) -> bool = n*.make_public();

make_protected : (inout this) -> bool = n*.make_protected();

make_private : (inout this) -> bool = n*.make_private();

has_name : (this) -> bool = n*.has_name();

has_name : (this, s: std::string_view) -> bool = n*.has_name(s);

name: (this) -> std::string_view = {

if has_name() { return n*.name()*.as_string_view(); }

else { return ""; }

}

has_initializer: (this) -> bool = n*.has_initializer();

is_global : (this) -> bool = n*.is_global();

is_function : (this) -> bool = n*.is_function();

is_object : (this) -> bool = n*.is_object();

is_base_object : (this) -> bool = n*.is_base_object();

is_member_object : (this) -> bool = n*.is_member_object();

is_type : (this) -> bool = n*.is_type();

is_namespace : (this) -> bool = n*.is_namespace();

is_alias : (this) -> bool = n*.is_alias();

is_type_alias : (this) -> bool = n*.is_type_alias();

is_namespace_alias : (this) -> bool = n*.is_namespace_alias();

is_object_alias : (this) -> bool = n*.is_object_alias();

is_function_expression : (this) -> bool = n*.is_function_expression();

as_function : (this) -> function_declaration = (n, this);

as_object : (this) -> object_declaration = (n, this);

as_type : (this) -> type_declaration = (n, this);

as_alias : (this) -> alias_declaration = (n, this);

get_parent : (this) -> declaration = declaration(n*.parent_declaration, this);

parent_is_function : (this) -> bool = n*.parent_is_function();

parent_is_object : (this) -> bool = n*.parent_is_object();

parent_is_type : (this) -> bool = n*.parent_is_type();

parent_is_namespace : (this) -> bool = n*.parent_is_namespace();

parent_is_alias : (this) -> bool = n*.parent_is_alias();

parent_is_type_alias : (this) -> bool = n*.parent_is_type_alias();

parent_is_namespace_alias : (this) -> bool = n*.parent_is_namespace_alias();

parent_is_object_alias : (this) -> bool = n*.parent_is_object_alias();

parent_is_polymorphic: (this) -> bool = n*.parent_is_polymorphic();

mark_for_removal_from_enclosing_type: (inout this)

pre<type_safety>( parent_is_type() ) // this precondition should be sufficient ...

= {

test := n*.type_member_mark_for_removal();

assert( test ); // ... to ensure this assert is true

}

}

//-----------------------------------------------------------------------

// Function declarations

//

function_declaration: @copyable type =

{

this: declaration = ();

operator=: (

out this,

n_: *declaration_node,

s : compiler_services

) =

{

declaration = (n_, s);

assert( n*.is_function() );

}

index_of_parameter_named : (this, s: std::string_view) -> int = n*.index_of_parameter_named(s);

has_parameter_named : (this, s: std::string_view) -> bool = n*.has_parameter_named(s);

has_in_parameter_named : (this, s: std::string_view) -> bool = n*.has_in_parameter_named(s);

has_in_ref_parameter_named : (this, s: std::string_view) -> bool = n*.has_in_ref_parameter_named(s);

has_copy_parameter_named : (this, s: std::string_view) -> bool = n*.has_copy_parameter_named(s);

has_inout_parameter_named : (this, s: std::string_view) -> bool = n*.has_inout_parameter_named(s);

has_out_parameter_named : (this, s: std::string_view) -> bool = n*.has_out_parameter_named(s);

has_move_parameter_named : (this, s: std::string_view) -> bool = n*.has_move_parameter_named(s);

has_forward_parameter_named : (this, s: std::string_view) -> bool = n*.has_forward_parameter_named(s);

first_parameter_name : (this) -> std::string = n*.first_parameter_name();

has_parameter_with_name_and_pass: (this, s: std::string_view, pass: passing_style) -> bool

= n*.has_parameter_with_name_and_pass(s, pass);

is_function_with_this : (this) -> bool = n*.is_function_with_this();

is_virtual : (this) -> bool = n*.is_virtual_function();

is_defaultable : (this) -> bool = n*.is_defaultable_function();

is_constructor : (this) -> bool = n*.is_constructor();

is_default_constructor : (this) -> bool = n*.is_default_constructor();

is_move : (this) -> bool = n*.is_move();

is_swap : (this) -> bool = n*.is_swap();

is_constructor_with_that : (this) -> bool = n*.is_constructor_with_that();

is_constructor_with_in_that : (this) -> bool = n*.is_constructor_with_in_that();

is_constructor_with_move_that: (this) -> bool = n*.is_constructor_with_move_that();

is_assignment : (this) -> bool = n*.is_assignment();

is_assignment_with_that : (this) -> bool = n*.is_assignment_with_that();

is_assignment_with_in_that : (this) -> bool = n*.is_assignment_with_in_that();

is_assignment_with_move_that : (this) -> bool = n*.is_assignment_with_move_that();

is_destructor : (this) -> bool = n*.is_destructor();

is_copy_or_move : (this) -> bool = is_constructor_with_that() || is_assignment_with_that();

has_declared_return_type : (this) -> bool = n*.has_declared_return_type();

has_deduced_return_type : (this) -> bool = n*.has_deduced_return_type();

has_bool_return_type : (this) -> bool = n*.has_bool_return_type();

has_non_void_return_type : (this) -> bool = n*.has_non_void_return_type();

has_compound_body : (this) -> bool = n*.is_function_with_compound_body();

get_compound_body : (this) -> compound_statement = (n*.get_compound_initializer(), this);

get_unnamed_return_type : (this) -> std::string = n*.unnamed_return_type_to_string();

get_signature : (this) -> std::string = n*.signature_to_string();

is_binary_comparison_function: (this) -> bool = n*.is_binary_comparison_function();

get_parameters: (this)

-> std::vector<object_declaration>

= {

ret: std::vector<object_declaration> = ();

for n*.get_function_parameters() do (param) {

_ = ret.emplace_back( param*.declaration.get(), this );

}

return ret;

}

// Modifying operations

//

default_to_virtual : (inout this) = _ = n*.make_function_virtual();

make_virtual : (inout this) -> bool = n*.make_function_virtual();

add_initializer: (inout this, source: std::string_view)

pre<this> (!has_initializer(), "cannot add an initializer to a function that already has one")

pre<this> (parent_is_type(), "cannot add an initializer to a function that isn't in a type scope")

= {

stmt := parse_statement(source);

if !(stmt as bool) {

error( "cannot add an initializer that is not a valid statement");

return;

}

require (n*.add_function_initializer(move stmt),

std::string("unexpected error while attempting to add initializer"));

}

}

//-----------------------------------------------------------------------

// Object declarations

//

object_declaration: @copyable type =

{

this: declaration = ();

operator=: (

out this,

n_: *declaration_node,

s : compiler_services

) =

{

declaration = (n_, s);

assert( n*.is_object() );

}

is_const : (this) -> bool = n*.is_const();

has_wildcard_type: (this) -> bool = n*.has_wildcard_type();

type: (this) -> std::string = {

ret := n*.object_type();

require( !contains(ret, "(*ERROR*)"),

"cannot to_string this type: " + ret);

return ret;

}

initializer: (this) -> std::string = {

ret := n*.object_initializer();

require( !contains(ret, "(*ERROR*)"),

"cannot to_string this initializer: " + ret);

return ret;

}

}

//-----------------------------------------------------------------------

// Type declarations

//

type_declaration: @copyable type =

{

this: declaration = ();

operator=: (

out this,

n_: *declaration_node,

s : compiler_services

) =

{

declaration = (n_, s);

assert( n*.is_type() );

}

reserve_names: (this, name: std::string_view, forward etc...) =

{ // etc is not declared ':string_view' for compatibility with GCC 10.x

for get_members()

do (m) {

m.require( !m.has_name( name ),

"in a '(get_metafunction_name())$' type, the name '(name)$' "

"is reserved for use by the '(get_metafunction_name())$' implementation"

);

}

if constexpr !CPP2_PACK_EMPTY(etc) {

reserve_names( etc... );

}

}

is_polymorphic: (this) -> bool = n*.is_polymorphic();

is_final : (this) -> bool = n*.is_type_final();

make_final : (inout this) -> bool = n*.make_type_final();

get_member_functions: (this)

-> std::vector<function_declaration>

= {

ret: std::vector<function_declaration> = ();

for n*.get_type_scope_declarations(declaration_node::functions)

do (d) {

_ = ret.emplace_back( d, this );

}

return ret;

}

get_member_functions_needing_initializer: (this)

-> std::vector<function_declaration>

= {

ret: std::vector<function_declaration> = ();

for n*.get_type_scope_declarations(declaration_node::functions)

do (d)

if !d*.has_initializer()

&& !d*.is_virtual_function()

&& !d*.is_defaultable_function()

{

_ = ret.emplace_back( d, this );

}

return ret;

}

get_member_objects: (this)

-> std::vector<object_declaration>

= {

ret: std::vector<object_declaration> = ();

for n*.get_type_scope_declarations(declaration_node::objects) do (d) {

_ = ret.emplace_back( d, this );

}

return ret;

}

get_member_types: (this)

-> std::vector<type_declaration>

= {

ret: std::vector<type_declaration> = ();

for n*.get_type_scope_declarations(declaration_node::types) do (d) {

_ = ret.emplace_back( d, this );

}

return ret;

}

get_member_aliases: (this)

-> std::vector<alias_declaration>

= {

ret: std::vector<alias_declaration> = ();

for n*.get_type_scope_declarations(declaration_node::aliases) do (d) {

_ = ret.emplace_back( d, this );

}

return ret;

}

get_members: (this)

-> std::vector<declaration>

= {

ret: std::vector<declaration> = ();

for n*.get_type_scope_declarations(declaration_node::all) do (d) {

_ = ret.emplace_back( d, this );

}

return ret;

}

query_declared_value_set_functions: (this)

-> (

out_this_in_that : bool,

out_this_move_that : bool,

inout_this_in_that : bool,

inout_this_move_that : bool

)

= {

declared := n*.find_declared_value_set_functions();

out_this_in_that = declared.out_this_in_that != nullptr;

out_this_move_that = declared.out_this_move_that != nullptr;

inout_this_in_that = declared.inout_this_in_that != nullptr;

inout_this_move_that = declared.inout_this_move_that != nullptr;

// NOLINT(performance-move-const-arg)

}

add_member: (inout this, source: std::string_view)

= {

decl := parse_statement(source);

if !(decl as bool) {

error("the provided source string is not a valid statement");

return;

}

if !decl*.is_declaration() {

error("cannot add a member that is not a declaration");

}

require( n*.add_type_member(move decl),

std::string("unexpected error while attempting to add member:\n") + source );

}

remove_marked_members: (inout this) = n*.type_remove_marked_members();

remove_all_members : (inout this) = n*.type_remove_all_members();

disable_member_function_generation: (inout this) = n*.type_disable_member_function_generation();

}

//-----------------------------------------------------------------------

// Alias declarations

//

alias_declaration: @copyable type =

{

this: declaration = ();

operator=: (

out this,

n_: *declaration_node,

s : compiler_services

) =

{

declaration = (n_, s);

assert( n*.is_alias() );

}

}

//-----------------------------------------------------------------------

//

// Statements

//

//-----------------------------------------------------------------------

//

//-----------------------------------------------------------------------

// General statement

//

statement: @polymorphic_base @copyable type =

{

this: reflection_base<statement_node> = ();

operator=: (

out this,

n_: *statement_node,

s : compiler_services

)

= {

reflection_base<statement_node> = (n_, s);

}

is_expression_statement : (this) -> bool = n*.is_expression();

is_compound_statement : (this) -> bool = n*.is_compound();

is_selection_statement : (this) -> bool = n*.is_selection();

is_declaration_statement: (this) -> bool = n*.is_declaration();

is_return_statement : (this) -> bool = n*.is_return();

is_iteration_statement : (this) -> bool = n*.is_iteration();

is_using_statement : (this) -> bool = n*.is_using();

is_contract : (this) -> bool = n*.is_contract();

is_inspect_expression : (this) -> bool = n*.is_inspect();

is_jump_statement : (this) -> bool = n*.is_jump();

//as_expression_statement : (this) -> expression_statement = expression_statement (n*.get_if<expression_statement_node>(), this);

as_compound_statement : (this) -> compound_statement = (n*.get_if<compound_statement_node>(), this);

//as_selection_statement : (this) -> selection_statement = selection_statement (n*.get_if<selection_statement_node>(), this);

//as_declaration_statement: (this) -> declaration_statement = declaration_statement(n*.get_if<declaration_statement_node>(), this);

//as_return_statement : (this) -> return_statement = return_statement (n*.get_if<return_statement_node>(), this);

//as_iteration_statement : (this) -> iteration_statement = iteration_statement (n*.get_if<iteration_statement_node>(), this);

//as_using_statement : (this) -> using_statement = using_statement (n*.get_if<using_statement_node>(), this);

//as_contract : (this) -> contract = contract (n*.get_if<contract_node>(), this);

//as_inspect_expression : (this) -> inspect_expression = inspect_expression (n*.get_if<inspect_expression_node>(), this);

//as_jump_statement : (this) -> jump_statement = jump_statement (n*.get_if<jump_statement_node>(), this);

to_string : (this) -> std::string = n*.to_string();

}

//-----------------------------------------------------------------------

// Compound statements

//

compound_statement: @copyable type =

{

this: reflection_base<compound_statement_node> = ();

operator=: (

out this,

n_: *compound_statement_node,

s : compiler_services

)

= {

reflection_base<compound_statement_node> = (n_, s);

}

get_statements: (this)

-> std::vector<statement>

= {

ret: std::vector<statement> = ();

for n*.get_statements() do (stmt) {

_ = ret.emplace_back( stmt, this );

}

return ret;

}

add_statement: (inout this, source: std::string_view, before_position: int = 0)

= {

stmt := parse_statement(source);

if !(stmt as bool) {

error("the provided source string is not a valid statement");

return;

}

require( n*.add_statement(move stmt, before_position),

std::string("unexpected error while attempting to add statement:\n") + source );

}

}

//-----------------------------------------------------------------------

//

// Metafunctions - these are hardwired for now until we get to the

// step of writing a Cpp2 interpreter to run inside the compiler

//

//-----------------------------------------------------------------------

//

//-----------------------------------------------------------------------

// Some common metafunction helpers (metafunctions are just functions,

// so they can be factored as usual)

//

add_virtual_destructor: (inout t: meta::type_declaration) =

{

t.add_member( "operator=: (virtual move this) = { }");

}

//-----------------------------------------------------------------------

//

// "... an abstract base class defines an interface ..."

//

// -- Stroustrup (The Design and Evolution of C++, 12.3.1)

//

//-----------------------------------------------------------------------

//

// interface

//

// an abstract base class having only pure virtual functions

//

interface: (inout t: meta::type_declaration) =

{

has_dtor := false;

for t.get_members() do (inout m)

{

m.require( !m.is_object(),

"interfaces may not contain data objects");

if m.is_function() {

mf := m.as_function();

mf.require( !mf.is_copy_or_move(),

"interfaces may not copy or move; consider a virtual clone() instead");

mf.require( !mf.has_initializer(),

"interface functions must not have a function body; remove the '=' initializer");

mf.require( mf.make_public(),

"interface functions must be public");

mf.default_to_virtual();

has_dtor |= mf.is_destructor();

}

}

if !has_dtor {

t.add_virtual_destructor();

}

}

//-----------------------------------------------------------------------

//

// "C.35: A base class destructor should be either public and

// virtual, or protected and non-virtual."

//

// "[C.43] ... a base class should not be copyable, and so does not

// necessarily need a default constructor."

//

// -- Stroustrup, Sutter, et al. (C++ Core Guidelines)

//

//-----------------------------------------------------------------------

//

// polymorphic_base

//

// A pure polymorphic base type that is not copyable, and whose

// destructor is either public and virtual or protected and nonvirtual.

//

// Unlike an interface, it can have nonpublic and nonvirtual functions.

//

polymorphic_base: (inout t: meta::type_declaration) =

{

has_dtor := false;

for t.get_member_functions() do (inout mf)

{

if mf.is_default_access() {

mf.default_to_public();

}

mf.require( !mf.is_copy_or_move(),

"polymorphic base types may not copy or move; consider a virtual clone() instead");

if mf.is_destructor() {

has_dtor = true;

mf.require( ((mf.is_public() || mf.is_default_access()) && mf.is_virtual())

|| (mf.is_protected() && !mf.is_virtual()),

"a polymorphic base type destructor must be public and virtual, or protected and nonvirtual");

}

}

if !has_dtor {

t.add_virtual_destructor();

}

}

//-----------------------------------------------------------------------

//

// "... A totally ordered type ... requires operator<=> that

// returns std::strong_ordering. If the function is not

// user-written, a lexicographical memberwise implementation

// is generated by default..."

//

// -- P0707R4, section 3

//

// Note: This feature derived from Cpp2 was already adopted

// into Standard C++ via paper P0515, so most of the

// heavy lifting is done by the Cpp1 C++20/23 compiler,

// including the memberwise default semantics

// (In contrast, cppfront has to do the work itself for

// default memberwise semantics for operator= assignment

// as those aren't yet part of Standard C++)

//

//-----------------------------------------------------------------------

//

ordered_impl: (

inout t: meta::type_declaration,

ordering: std::string_view // must be "strong_ordering" etc.

) =

{

has_spaceship := false;

for t.get_member_functions() do (inout mf)

{

if mf.has_name("operator<=>") {

has_spaceship = true;

return_name := mf.get_unnamed_return_type();

if return_name.find(ordering) == return_name.npos

{

mf.error( "operator<=> must return std::" + ordering as std::string );

}

}

}

if !has_spaceship {

t.add_member( "operator<=>: (this, that) -> std::" + (ordering as std::string) + ";" );

}

}

//-----------------------------------------------------------------------

// ordered - a totally ordered type

//

// Note: the ordering that should be encouraged as default gets the nice name

//

ordered: (inout t: meta::type_declaration) =

{

ordered_impl( t, "strong_ordering" );

}

//-----------------------------------------------------------------------

// weakly_ordered - a weakly ordered type

//

weakly_ordered: (inout t: meta::type_declaration) =

{

ordered_impl( t, "weak_ordering" );

}

//-----------------------------------------------------------------------

// partially_ordered - a partially ordered type

//

partially_ordered: (inout t: meta::type_declaration) =

{

ordered_impl( t, "partial_ordering" );

}

//-----------------------------------------------------------------------

//

// "A value is ... a regular type. It must have all public

// default construction, copy/move construction/assignment,

// and destruction, all of which are generated by default

// if not user-written; and it must not have any protected

// or virtual functions (including the destructor)."

//

// -- P0707R4, section 3

//

//-----------------------------------------------------------------------

//

// copyable

//

// A type with (copy and move) x (construction and assignment)

//

copyable: (inout t: meta::type_declaration) =

{

// If the user explicitly wrote any of the copy/move functions,

// they must also have written the most general one - we can't

// assume we can safely generate it for them since they've opted

// into customized semantics

smfs := t.query_declared_value_set_functions();

if !smfs.out_this_in_that

&& (

smfs.out_this_move_that

|| smfs.inout_this_in_that

|| smfs.inout_this_move_that

)

{

t.error(

"this type is partially copyable/movable - when you provide "

"any of the more-specific operator= signatures, you must also provide "

"the one with the general signature (out this, that); alternatively, "

"consider removing all the operator= functions and let them all be "

"generated for you with default memberwise semantics"

);

}

else if !smfs.out_this_in_that {

t.add_member( "operator=: (out this, that) = { }");

}

}

//-----------------------------------------------------------------------

//

// hashable

//

// A memberwise hashable type

//

hashable: (inout t: meta::type_declaration) =

{

t.require( !t.get_member_objects().empty(),

"a hashable type must have at least one data member");

hash: std::string = " hash: (this) -> size_t = {\n"

" ret: size_t = 0;";

for t.get_member_objects()

do (o)

{

o_hash: std::string;

if o.name() == "this" {

o_hash = "(o.type())$::hash()";

}

else {

o_hash = "std::hash<(o.type())$>()((o.name())$)";

}

hash += "\n cpp2::hash_combine( ret, (o_hash)$ );";

}

t.add_member(hash + "\n return ret;\n }");

}

//-----------------------------------------------------------------------

//

// basic_value

//

// A regular type: copyable, plus has public default construction

// and no protected or virtual functions

//

basic_value: (inout t: meta::type_declaration) =

{

t.copyable();

has_default_ctor := false;

for t.get_member_functions() do (inout mf) {

has_default_ctor |= mf.is_default_constructor();

mf.require( !mf.is_protected() && !mf.is_virtual(),

"a value type may not have a protected or virtual function");

mf.require( !mf.is_destructor() || mf.is_public() || mf.is_default_access(),

"a value type may not have a non-public destructor");

}

if !has_default_ctor {

t.add_member( "operator=: (out this) = { }");

}

}

//-----------------------------------------------------------------------

//

// "A 'value' is a totally ordered basic_value..."

//

// -- P0707R4, section 3

//

// value - a value type that is totally ordered

//

// Note: the ordering that should be encouraged as default gets the nice name

//

value: (inout t: meta::type_declaration) =

{

t.ordered();

t.basic_value();

}

weakly_ordered_value: (inout t: meta::type_declaration) =

{

t.weakly_ordered();

t.basic_value();

}

partially_ordered_value: (inout t: meta::type_declaration) =

{

t.partially_ordered();

t.basic_value();

}

//-----------------------------------------------------------------------

//

// C.20: If you can avoid defining default operations, do

//

// ##### Reason

//

// It's the simplest and gives the cleanest semantics.

//

// ...

//

// This is known as "the rule of zero".

//

// -- C++ Core Guidelines

// C.20: If you can avoid defining any default operations, do

// <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rc-zero>

//

//-----------------------------------------------------------------------

//

// cpp1_rule_of_zero

//

// a type without declared copy/move/destructor functions

//

cpp1_rule_of_zero: (inout t: meta::type_declaration) =

{

for t.get_member_functions() do (inout mf)

{