// Process the given provided method for the given entity.
// The method passed should be reified already and will be freed by this
// function.
static bool provided_method(ast_t* entity, ast_t* reified_method,
ast_t* raw_method, ast_t** last_method)
{
assert(entity != NULL);
assert(reified_method != NULL);
assert(last_method != NULL);
const char* entity_name = ast_name(ast_child(entity));
if(ast_id(reified_method) == TK_BE || ast_id(reified_method) == TK_NEW)
{
// Modify return type to the inheritting type
ast_t* ret_type = ast_childidx(reified_method, 4);
assert(ast_id(ret_type) == TK_NOMINAL);
const char* pkg_name = package_name(ast_nearest(entity, TK_PACKAGE));
ast_set_name(ast_childidx(ret_type, 0), pkg_name);
ast_set_name(ast_childidx(ret_type, 1), entity_name);
}
// Ignore docstring
ast_t* doc = ast_childidx(reified_method, 7);
if(ast_id(doc) == TK_STRING)
{
ast_set_name(doc, "");
ast_setid(doc, TK_NONE);
}
// Check for existing method of the same name
const char* name = ast_name(ast_childidx(reified_method, 1));
assert(name != NULL);
ast_t* existing = ast_get(entity, name, NULL);
if(existing != NULL && is_field(existing))
{
ast_error(existing, "field '%s' clashes with provided method", name);
ast_error(raw_method, "method is defined here");
ast_free_unattached(reified_method);
return false;
}
existing = add_method(entity, existing, reified_method, last_method);
if(existing == NULL)
{
ast_free_unattached(reified_method);
return false;
}
method_t* info = (method_t*)ast_data(existing);
assert(info != NULL);
if(!record_default_body(reified_method, raw_method, info))
ast_free_unattached(reified_method);
return true;
}
// Process the given provided method for the given entity.
// The method passed should be reified already and will be freed by this
// function.
static bool provided_method(pass_opt_t* opt, ast_t* entity,
ast_t* reified_method, ast_t* raw_method, ast_t** last_method)
{
assert(entity != NULL);
assert(reified_method != NULL);
assert(last_method != NULL);
AST_GET_CHILDREN(reified_method, cap, id, typeparams, params, result,
can_error, body, doc);
if(ast_id(reified_method) == TK_BE || ast_id(reified_method) == TK_NEW)
{
// Modify return type to the inheriting type
ast_t* this_type = type_for_this(opt, entity, ast_id(cap),
TK_EPHEMERAL, true);
ast_replace(&result, this_type);
}
// Ignore docstring
if(ast_id(doc) == TK_STRING)
{
ast_set_name(doc, "");
ast_setid(doc, TK_NONE);
}
// Check for existing method of the same name
const char* name = ast_name(id);
assert(name != NULL);
ast_t* existing = ast_get(entity, name, NULL);
if(existing != NULL && is_field(existing))
{
ast_error(existing, "field '%s' clashes with provided method", name);
ast_error(raw_method, "method is defined here");
ast_free_unattached(reified_method);
return false;
}
existing = add_method(entity, existing, reified_method, last_method);
if(existing == NULL)
{
ast_free_unattached(reified_method);
return false;
}
method_t* info = (method_t*)ast_data(existing);
assert(info != NULL);
if(!record_default_body(reified_method, raw_method, info))
ast_free_unattached(reified_method);
return true;
}
static ast_result_t sugar_let(typecheck_t* t, ast_t* ast)
{
ast_t* id = ast_child(ast);
if(ast_id(id) == TK_DONTCARE)
{
// Replace "_" with "$1" in with and for variable lists
ast_setid(id, TK_ID);
ast_set_name(id, package_hygienic_id(t));
}
return AST_OK;
}
// Add the given method to the relevant name list in the given symbol table
static bool add_method_to_list(ast_t* method, methods_t* method_info,
const char *entity_name)
{
assert(method != NULL);
assert(method_info != NULL);
assert(entity_name != NULL);
const char* name = ast_name(ast_childidx(method, 1));
assert(name != NULL);
symtab_t* symtab = method_info->symtab;
assert(symtab != NULL);
// Entity doesn't yet have method, add it to our list for later
ast_t* list = (ast_t*)symtab_find(symtab, name, NULL);
if(list == NULL)
{
ast_t* case_clash = (ast_t*)symtab_find_case(symtab, name, NULL);
if(case_clash != NULL)
{
ast_error(case_clash, "in %s method name differs only in case",
entity_name);
ast_error(method, "previous definition is here");
return false;
}
// First instance of this name
list = ast_blank(TK_ID);
ast_set_name(list, name);
symtab_add(symtab, name, (void*)list, SYM_NONE);
if(method_info->last_list == NULL)
ast_add(method_info->name_lists, list);
else
ast_add_sibling(method_info->last_list, list);
method_info->last_list = list;
}
ast_add(list, method);
return true;
}
// Add all methods from the provides list of the given entity into lists in the
// given symbol table.
static bool collate_provided(ast_t* entity, methods_t* method_info)
{
assert(entity != NULL);
bool r = true;
ast_t* traits = ast_childidx(entity, 3);
for(ast_t* t = ast_child(traits); t != NULL; t = ast_sibling(t))
{
assert(ast_id(t) == TK_NOMINAL);
ast_t* trait_def = (ast_t*)ast_data(t);
assert(trait_def != NULL);
// TODO: Check whether we need an error here
if((ast_id(trait_def) != TK_TRAIT) && (ast_id(trait_def) != TK_INTERFACE))
return false;
// Check for duplicates in our provides list
// This is just simple compare of each entry against all the other. This is
// clearly O(n^2), but since provides lists are likely to be small that
// should be OK. If it turns out to be a problem it can be changed later.
for(ast_t* p = ast_child(traits); p != t; p = ast_sibling(p))
{
if(trait_def == (ast_t*)ast_data(p))
{
ast_error(t, "duplicate entry in provides list");
ast_error(p, "previous entry here");
}
}
if(!build_entity_def(trait_def))
return false;
ast_t* type_params = ast_childidx(trait_def, 1);
ast_t* type_args = ast_childidx(t, 2);
ast_t* trait_methods = ast_childidx(trait_def, 4);
for(ast_t* m = ast_child(trait_methods); m != NULL; m = ast_sibling(m))
{
// Reify the method with the type parameters from trait definition and
// the reified type arguments from trait reference
ast_t* r_method = reify(m, type_params, type_args);
const char* entity_name = ast_name(ast_child(entity));
if(ast_id(r_method) == TK_BE || ast_id(r_method) == TK_NEW)
{
// Modify return type to the inheritting type
ast_t* ret_type = ast_childidx(r_method, 4);
assert(ast_id(ret_type) == TK_NOMINAL);
const char* pkg_name = package_name(ast_nearest(entity, TK_PACKAGE));
ast_set_name(ast_childidx(ret_type, 0), pkg_name);
ast_set_name(ast_childidx(ret_type, 1), entity_name);
}
if(!add_method_to_list(r_method, method_info, entity_name))
r = false;
}
}
return r;
}
// Add a new method to the given entity, based on the specified method from
// the specified type.
// The trait_ref is the entry in the provides / delegates list that causes this
// method inclusion. Needed for error reporting.
// The basis_method is the reified method in the trait to add.
// The adjective parameter is used for error reporting and should be "provided"
// or similar.
// Return the newly added method or NULL on error.
static ast_t* add_method(ast_t* entity, ast_t* trait_ref, ast_t* basis_method,
const char* adjective, pass_opt_t* opt)
{
assert(entity != NULL);
assert(trait_ref != NULL);
assert(basis_method != NULL);
assert(adjective != NULL);
const char* name = ast_name(ast_childidx(basis_method, 1));
// Check behaviour compatability.
if(ast_id(basis_method) == TK_BE)
{
switch(ast_id(entity))
{
case TK_PRIMITIVE:
ast_error(opt->check.errors, trait_ref,
"cannot add a behaviour (%s) to a primitive", name);
return NULL;
case TK_STRUCT:
ast_error(opt->check.errors, trait_ref,
"cannot add a behaviour (%s) to a struct", name);
return NULL;
case TK_CLASS:
ast_error(opt->check.errors, trait_ref,
"cannot add a behaviour (%s) to a class", name);
return NULL;
default:
break;
}
}
// Check for existing method of the same name.
ast_t* existing = ast_get(entity, name, NULL);
if(existing != NULL)
{
assert(is_field(existing)); // Should already have checked for methods.
ast_error(opt->check.errors, trait_ref,
"%s method '%s' clashes with field", adjective, name);
ast_error_continue(opt->check.errors, basis_method,
"method is defined here");
return NULL;
}
// Check for clash with existing method.
ast_t* case_clash = ast_get_case(entity, name, NULL);
if(case_clash != NULL)
{
const char* clash_name = "";
switch(ast_id(case_clash))
{
case TK_FUN:
case TK_BE:
case TK_NEW:
clash_name = ast_name(ast_childidx(case_clash, 1));
break;
case TK_LET:
case TK_VAR:
case TK_EMBED:
clash_name = ast_name(ast_child(case_clash));
break;
default:
assert(0);
break;
}
ast_error(opt->check.errors, trait_ref,
"%s method '%s' differs only in case from '%s'",
adjective, name, clash_name);
ast_error_continue(opt->check.errors, basis_method,
"clashing method is defined here");
return NULL;
}
AST_GET_CHILDREN(basis_method, cap, id, typeparams, params, result,
can_error, body, doc);
// Ignore docstring.
if(ast_id(doc) == TK_STRING)
{
ast_set_name(doc, "");
ast_setid(doc, TK_NONE);
}
ast_t* local = ast_append(ast_childidx(entity, 4), basis_method);
ast_set(entity, name, local, SYM_DEFINED, false);
ast_t* body_donor = (ast_t*)ast_data(basis_method);
method_t* info = attach_method_t(local);
info->trait_ref = trait_ref;
if(ast_id(body) != TK_NONE)
info->body_donor = body_donor;
return local;
}
