-> bool

{

assert(n.is_type());

// Get the reflection state ready to pass to the function

auto cs = meta::compiler_services{ &errors, &includes, generated_tokens };

auto rtype = meta::type_declaration{ &n, cs };

return apply_metafunctions(

n,

rtype,

[&](std::string const& msg) { error( msg, false ); }

);

bool start = false;

declaration_node const* declaration = {};

token const* identifier = {};

statement_node const* initializer = {};

parameter_declaration_node const* parameter = {};

bool member = false;

bool return_param = false;

declaration_sym(

bool s = false,

declaration_node const* decl = {},

token const* id = {},

statement_node const* init = {},

parameter_declaration_node const* param = {},

bool mem = false,

bool ret = false

)

: start{s}

, declaration{decl}

, identifier{id}

, initializer{init}

, parameter{param}

, member{mem}

, return_param{ret}

{ }

auto position() const

-> source_position

{

assert (declaration);

return declaration->position();

}

auto get_token() const

-> token const*

{

return identifier;

}

enum kind: u8 { use, using_declaration, deactivation } kind_ = use;

bool standalone_assignment_to = false;

bool is_captured = false;

bool is_after_dot = false;

bool safe_to_move = true;

int safe_to_move_context = 0;

token const* identifier = {};

identifier_sym(

bool a,

token const* id,

kind k = use,

bool mv = true,

int mvc = 0,

bool after_dot = false

)

: kind_{k}

, standalone_assignment_to{a}

, is_after_dot{after_dot}

, safe_to_move{mv}

, safe_to_move_context{mvc}

, identifier{id}

{ }

auto position() const

-> source_position

{

assert (identifier);

return identifier->position();

}

auto get_token() const

-> token const*

{

return identifier;

}

auto is_use() const

-> bool

{

return kind_ == use;

}

auto is_using_declaration() const

-> bool

{

return kind_ == using_declaration;

}

auto is_deactivation() const

-> bool

{

return kind_ == deactivation;

}

bool start = false;

selection_statement_node const* selection = {};

selection_sym(

bool s,

selection_statement_node const* sel

)

: start{s}

, selection{sel}

{ }

auto position() const

-> source_position

{

assert (selection);

return selection->position();

}

auto get_token() const

-> token const*

{

assert (selection);

return selection->identifier;

}

bool start = false;

compound_statement_node const* compound = {};

enum kind : u8 { is_scope, is_true, is_false, is_loop } kind_ = is_scope;

compound_sym(

bool s,

compound_statement_node const* c,

kind k

)

: start{s}

, compound{c}

, kind_{k}

{ }

auto position() const

-> source_position

{

assert (compound);

return compound->position();

}

auto get_token() const

-> token const*

{

return nullptr;

}

enum active : u8 { declaration=0, identifier, selection, compound };

std::variant <

declaration_sym,

identifier_sym,

selection_sym,

compound_sym

> sym;

int depth = -1;

bool start = true;

symbol(int depth, declaration_sym const& sym) : sym{sym}, depth{depth}, start{sym.start} { }

symbol(int depth, identifier_sym const& sym) : sym{sym}, depth{depth}, start{!sym.is_deactivation()} { }

symbol(int depth, selection_sym const& sym) : sym{sym}, depth{depth}, start{sym.start} { }

symbol(int depth, compound_sym const& sym) : sym{sym}, depth{depth}, start{sym.start} { }

auto is_declaration() const -> bool { return sym.index() == declaration; }

auto is_identifier () const -> bool { return sym.index() == identifier ; }

auto is_selection () const -> bool { return sym.index() == selection ; }

auto is_compound () const -> bool { return sym.index() == compound ; }

auto as_declaration() const -> auto& { return std::get<declaration>(sym); }

auto as_identifier () const -> auto& { return std::get<identifier >(sym); }

auto as_selection () const -> auto& { return std::get<selection >(sym); }

auto as_compound () const -> auto& { return std::get<compound >(sym); }

auto position() const

-> source_position

{

switch (sym.index())

{

break;case declaration: {

auto const& s = std::get<declaration>(sym);

return s.position();

}

break;case identifier: {

auto const& s = std::get<identifier>(sym);

return s.position();

}

break;case selection: {

auto const& s = std::get<selection>(sym);

return s.position();

}

break;case compound: {

auto const& s = std::get<compound>(sym);

return s.position();

}

break;default:

assert (false && "ICE: illegal symbol state");

return { 0, 0 };

}

}

auto get_token() const

-> token const*

{

switch (sym.index())

{

break;case declaration: {

auto const& s = std::get<declaration>(sym);

return s.get_token();

}

break;case identifier: {

auto const& s = std::get<identifier>(sym);

return s.get_token();

}

break;case selection: {

auto const& s = std::get<selection>(sym);

return s.get_token();

}

break;case compound: {

auto const& s = std::get<compound>(sym);

return s.get_token();

}

break;default:

assert (false && "ICE: illegal symbol state");

return nullptr;

}

}

auto get_global_token_order() const

-> index_t

{

if (auto t = get_token()) {

return t->get_global_token_order();

}

return 0;

}

-> bool

{

return

std::find(

definite_initializations.begin(),

definite_initializations.end(),

t

)

!= definite_initializations.end();

token const* t;

bool is_forward;

bool safe_to_move;

last_use(

token const* t_,

bool is_forward_ = false,

bool safe_to_move_ = true

)

: t{t_}

, is_forward{is_forward_}

, safe_to_move{safe_to_move_}

{ }

bool operator==(last_use const& that) { return t == that.t; }

-> last_use const*

{

auto iter = std::find(

definite_last_uses.begin(),

definite_last_uses.end(),

t

);

if (iter != definite_last_uses.end()) {

return &*iter;

}

else {

return {};

}

{

std::vector<error_entry>& errors;

stable_vector<symbol> symbols;

index_t global_token_counter = 1;

std::vector<selection_statement_node const*> active_selections;

std::vector<iteration_statement_node const*> active_iterations;

std::vector<declaration_sym const*> current_declarations;

struct declaration_of_t {

declaration_sym const* sym;

bool in_current_function;

bool prev_token_was_this = false;

declaration_sym const* this_param_sym = {};

};

std::unordered_map< token const*, declaration_of_t > declaration_of;

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

// Constructor

//

// errors error list

//

sema(

std::vector<error_entry>& errors_

)

: errors{ errors_ }

{

}

// Get the declaration of t within the same named function or beyond it

// For a this parameter, optionally include uses of implicit this

//

auto get_declaration_of(

token const* t,

bool look_beyond_current_function = false,

bool include_implicit_this = false

) const

-> declaration_sym const*

{

if (!t) {

return {};

}

return get_declaration_of(*t, look_beyond_current_function, include_implicit_this );

}

auto get_declaration_of(

token const& t,

bool look_beyond_current_function = false,

bool include_implicit_this = false

) const

-> declaration_sym const*

{

// Calculate result using declaration_of[]

auto result = static_cast<declaration_sym const*>(nullptr);

{

auto d = declaration_of.find(&t);

if (d != declaration_of.cend())

{

// If we're asked to include implicit this,

// and t itself is not 'this' and not qualified with 'this.`,

// and there's a 'this' result available, then use that

if (

include_implicit_this

&& t != "this"

&& !d->second.prev_token_was_this

&& d->second.this_param_sym

)

{

result = d->second.this_param_sym;

}

// Otherwise just use the main result

else

{

//assert( d->second.sym && d->second.sym->declaration->has_name(t) );

result = d->second.sym;

}

}

// Now we have the lookup result, but based on lookup constraints flags

// we may decide it's unsuitable for this lookup and not use it...

if (

result

// If we were told not to look beyond the current function

&& !look_beyond_current_function

// And we're not already using the 'this' parameter which is local

&& result != d->second.this_param_sym

// And this result isn't our own function-local object declaration

&& !(

d->second.sym->declaration->identifier->get_token() == &t

&& d->second.sym->declaration->is_object()

&& d->second.sym->declaration->parent_is_function()

)

// And this result is not in the current function

// or we weren't in a function to begin with

&& (

!d->second.in_current_function

|| !d->second.sym->declaration->parent_is_function()

)

)

{

// Then don't use the result, return 'not found' instead

result = nullptr;

}

}

return result;

}

auto is_captured(token const& t) const

-> bool

{

// TODO Use 'std::lower_bound' by filtering final positions of 0.

auto it = std::find_if(

symbols.begin(),

symbols.end(),

[&](symbol const& s) -> bool {

return s.get_global_token_order() == t.get_global_token_order();

});

if (identifier_sym const* sym = nullptr;

it != symbols.end()

&& (sym = std::get_if<symbol::active::identifier>(&it->sym))

&& sym->is_use()

)

{

return sym->is_captured;

}

return false;

}

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

// Factor out the uninitialized var decl test

//

auto is_uninitialized_decl(declaration_sym const& sym) const

-> bool

{

return

sym.start

&& !(sym.identifier && *sym.identifier == "this")

&& !sym.initializer

&& !(sym.parameter && sym.parameter->pass != passing_style::out)

;

}

auto debug_print(std::ostream& o) const

-> void

{

o << "---------------------------------------------------------------------------\n";

o << "declaration_of: size " << declaration_of.size() << "\n";

o << " & tok #tok & sym identifier #tok in_curr_fn prev_was_this & this_param_sym\n";

for (auto& e : declaration_of) {

o << " " << static_cast<void const*>(e.first)

<< " " << std::setw(4) << std::right << e.first->get_global_token_order()

<< " -> " << static_cast<void const*>(e.second.sym)

<< " " << std::setw(16) << (e.second.sym && e.second.sym->identifier ? e.second.sym->identifier->as_string_view() : "(null)")

<< std::setw(4) << std::right << (e.second.sym && e.second.sym->identifier ? e.second.sym->identifier->get_global_token_order() : 0)

<< " " << std::setw(10) << std::left << e.second.in_current_function

<< " " << std::setw(13) << e.second.prev_token_was_this

<< " " << static_cast<void const*>(e.second.this_param_sym)

<< "\n";

}

o << "\n---------------------------------------------------------------------------\n";

o << "symbols: size " << symbols.size() << "\n";

o << " idx tok# & symbol dep\n";

for (auto i = 0; auto const& s : symbols)

{

o << std::setw( 6) << std::right << i++ << " | ";

o << std::setw( 6) << std::right << s.get_global_token_order() << " | ";

o << std::setw(16) << std::right << static_cast<void const*>(&s) << " | ";

o << std::setw( 3) << std::right << s.depth << " | ";

o << std::setw(s.depth*2+1) << " ";

switch (s.sym.index()) {

break;case symbol::active::declaration: {

auto const& sym = std::get<symbol::active::declaration>(s.sym);

assert (sym.declaration);

if (sym.declaration->is_function()) {

if (sym.start) {

o << "function ";

}

else {

o << "/function ";

}

}

else if (sym.declaration->is_object()) {

if (sym.start) {

o << "var ";

}

else {

o << "/var ";

}

}

else if (sym.declaration->is_type()) {

if (sym.start) {

o << "type ";

}

else {

o << "/type ";

}

}

else if (sym.declaration->is_namespace()) {

if (sym.start) {

o << "namespace ";

}

else {

o << "/namespace ";

}

}

if (/*sym.start &&*/ sym.identifier) {

o << sym.identifier->to_string();

}

if (is_uninitialized_decl(sym)) {

o << " *** UNINITIALIZED";

}

}

break;case symbol::active::identifier: {

auto const& sym = std::get<symbol::active::identifier>(s.sym);

assert (sym.identifier);

if (last_use const* use = nullptr;

sym.is_use()

&& (use = is_definite_last_use(sym.identifier))

)

{

o << "*** " << sym.identifier->position().to_string()

<< " DEFINITE LAST "

<< (use->is_forward ? "FORWARDING" : "POTENTIALLY MOVING")

<< " USE OF ";

}

if (

sym.is_use()

&& is_definite_initialization(sym.identifier)

)

{

o << "*** " << sym.identifier->position().to_string()

<< " DEFINITE INITIALIZATION OF ";

}

else if (sym.standalone_assignment_to) {

o << "*** assignment to ";

}

else {

o << "*** use of ";

}

o << sym.identifier->to_string();

}

break;case symbol::active::selection: {

auto const& sym = std::get<symbol::active::selection>(s.sym);

if (!sym.start) {

o << "/";

}

o << "selection";

}

break;case symbol::active::compound: {

auto const& sym = std::get<symbol::active::compound>(s.sym);

if (!sym.start) {

o << "/";

//--scope_depth;

}

if (sym.kind_ == sym.is_true) {

o << "true branch";

}

else if (sym.kind_ == sym.is_false) {

o << "false branch";

}

else if (sym.kind_ == sym.is_loop) {

o << "loop";

}

else {

o << "scope";

}

}

break;default:

o << "ERROR";

}

o << "\n";

}

}

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

// Apply local first- and last-use rules

//

auto apply_local_rules()

-> bool

{

auto ret = true;

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

// Helpers for readability

// It's an uninitialized variable (incl. named return values) if it's

// a non-namespace-scope non-parameter object with no initializer

//

auto is_uninitialized_variable_decl = [&](symbol const& s)

-> declaration_sym const*

{

if (auto const* sym = std::get_if<symbol::active::declaration>(&s.sym)) {

assert (sym);

if (is_uninitialized_decl(*sym)) {

if (

sym->declaration->is_object()

&& !sym->declaration->parent_is_namespace()

)

{

return sym;

}

else {

return {};

}

}

}

return {};

};

// It's a local (incl. named return value or copy or move or forward parameter)

//

auto is_local_declaration = [&](symbol const& s)

-> declaration_sym const*

{

if (auto const* sym = std::get_if<symbol::active::declaration>(&s.sym)) {

if (

sym->start

&& sym->declaration->is_object()

)

{

// Must be in function scope

if (sym->declaration->parent_is_function()) {

return sym;

}

else {

return {};

}

}

}

return {};

};

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

// Function logic: For each entry in the table...

//

for (auto sympos = unchecked_narrow<int>(std::ssize(symbols) - 1); sympos >= 0; --sympos)

{

// If this is an uninitialized local variable,

// ensure it is definitely initialized and tag those initializations

//

if (auto decl = is_uninitialized_variable_decl(symbols[sympos])) {

assert(

decl->identifier

&& !decl->initializer

);

ret = ret

&& ensure_definitely_initialized(decl, sympos+1, symbols[sympos].depth)

;

}

// If this is a copy, move, or forward parameter or a local variable,

// identify and tag its definite last uses to `std::move` from them

// If it's some other parameter, just check that it is used

//

if (auto decl = is_local_declaration(symbols[sympos])) {

assert (decl->identifier);

find_definite_last_uses(

decl->identifier,

sympos,

decl->parameter ? std::optional{decl->parameter->pass} : std::optional<passing_style>{},

decl->parameter

);

}

}

return ret;

}

// Find the definite last uses for local variable *id starting at the

// given position and depth in the symbol/scope table

//

auto find_definite_last_uses(

token const* id,

int pos,

std::optional<passing_style> pass,

bool is_parameter

) const

-> void

{

auto is_a_use = [&](identifier_sym const* sym) -> bool {

assert(!sym || sym->identifier);

declaration_sym const* decl = nullptr;

return sym

&& sym->is_use()

&& (

*sym->identifier == *id

// For 'this', do include member names with implicit 'this.'

|| (

*id == "this"

&& (decl = get_declaration_of(sym->get_token(), false, true))

&& decl->identifier

&& *decl->identifier == "this"

)

);

};

auto i = pos + 1;

struct pos_range

{

bool is_loop;

int first;

int last = 0;

pos_range (bool l, int f) : is_loop{l}, first{f} { }

bool within(int x) const { return first <= x && x <= last; }

bool skip () const { return !is_loop; }

};

// Ranges of positions which includes non-nested

// 1. Iteration statements (a use isn't a last use)

// 2. Ranges to skip (a last use can't be found in these)

// - Function expressions (except in a capture)

// - Where id is hidden by another declaration

auto pos_ranges = std::vector<pos_range>{{false, 0}}; // Keep sentinel for simpler code

auto skip_hidden_name = [&](bool record_pos_range) -> bool {

auto skip_to = [&](token const* identifier_end)

{

// Can afford to just skip id and not member names

// because in Cpp2 you can't shadow member names

//

// TODO When local types are supported

// consider where 'this' is implicitly declared

// For example, see https://cpp2.godbolt.org/z/onfW6hns1

if (record_pos_range) {

pos_ranges.emplace_back(false, i - 1);

}

++i;

identifier_sym const* sym = nullptr;

while (

i < std::ssize(symbols)

&& (

!(sym = std::get_if<symbol::active::identifier>(&symbols[i].sym))

|| sym->identifier != identifier_end

)

)

{

++i;

}

assert(sym->identifier == identifier_end && sym->is_deactivation());

if (record_pos_range) {

pos_ranges.back().last = i;

}

};

if (auto decl = std::get_if<symbol::active::declaration>(&symbols[i].sym);

decl

&& decl->start

&& decl->identifier

&& *decl->identifier == *id

&& *decl->identifier != "_"

)

{

skip_to(decl->identifier);

return true;

}

else if (auto sym = std::get_if<symbol::active::identifier>(&symbols[i].sym);

sym

&& sym->is_using_declaration()

&& sym->identifier

&& *sym->identifier == *id

)

{

skip_to(sym->identifier);

return true;

}

return false;

};

auto skip_function_expression = [&]() -> bool {

if (auto decl = std::get_if<symbol::active::declaration>(&symbols[i].sym);

decl

&& decl->start

&& decl->declaration->is_function_expression()

)

{

// Record the skipped subranges without captures

auto function_expression_end = decl->declaration;

pos_ranges.emplace_back(false, i - 1);

++i;

while (

i < std::ssize(symbols)

&& (

!(decl = std::get_if<symbol::active::declaration>(&symbols[i].sym))

|| decl->declaration != function_expression_end

)

)

{

if (skip_hidden_name(false)) {

continue;

}

else if (

auto sym = std::get_if<symbol::active::identifier>(&symbols[i].sym);

is_a_use(sym)

&& sym->is_captured

)

{

pos_ranges.back().last = i - 1;

pos_ranges.emplace_back(false, i + 1);

}

++i;

}

assert(decl && decl->declaration == function_expression_end && !decl->start);

pos_ranges.back().last = i;

return true;

}

return false;

};

// Scan forward to the end of this scope

auto found_end_of_our_initialization = false;

for (auto start_depth = symbols[pos].depth;

i < std::ssize(symbols)

&& symbols[i].depth >= start_depth;

++i

)

{

// While we're here, if this is a non-parameter local, check for

// any uses before the end of the initializer

if (

!is_parameter

&& !found_end_of_our_initialization

)

{

if (symbols[i].depth == start_depth)

{

if (auto decl = std::get_if<symbol::active::declaration>(&symbols[i].sym);

decl

&& decl->declaration->is_object()

&& decl->declaration->has_name(*id)

&& !decl->start

)

{

found_end_of_our_initialization = true;

}

}

if (auto sym = std::get_if<symbol::active::identifier>(&symbols[i].sym);

sym

&& !sym->is_after_dot

&& is_a_use(sym)

)

{

assert(sym->identifier);

errors.emplace_back(

sym->identifier->position(),

"local variable " + sym->identifier->to_string()

+ " cannot be used in its own initializer");

}

}

if (

skip_function_expression()

|| skip_hidden_name(true)

)

{

continue;

}

// Record the loops

else if (auto sym = std::get_if<symbol::active::identifier>(&symbols[i].sym);

sym

&& sym->identifier

&& (

*sym->identifier == "for"

|| *sym->identifier == "while"

|| *sym->identifier == "do"

)

)

{

auto loop_depth = symbols[i].depth;

auto loop_id = sym->identifier;

// If id is the loop parameter, this is its end

if (

*loop_id == "for"

&& sym->is_deactivation()

)

{

assert(symbols[i].depth == start_depth && "Messed up in a nested loop");

++i;

break;

}

assert(symbols[i].start);

pos_ranges.emplace_back(true, i);

// Scan forward to the end of this loop

++i;

while (

i < std::ssize(symbols)

&& (

symbols[i].depth > loop_depth

|| !(sym = std::get_if<symbol::active::identifier>(&symbols[i].sym))

|| sym->identifier != loop_id

)

)

{

if (

skip_function_expression()

|| skip_hidden_name(true)

)

{

continue;

}

++i;

}

assert(sym && sym->identifier == loop_id && sym->is_deactivation());