// Check that embed fields are not recursive.
static bool embed_fields(ast_t* entity, pass_opt_t* opt)
{
assert(entity != NULL);
int state = ast_checkflag(entity,
AST_FLAG_RECURSE_2 | AST_FLAG_DONE_2 | AST_FLAG_ERROR_2);
// Check for recursive embeds
switch(state)
{
case 0:
ast_setflag(entity, AST_FLAG_RECURSE_2);
break;
case AST_FLAG_RECURSE_2:
ast_error(opt->check.errors, entity,
"embedded fields can't be recursive");
ast_clearflag(entity, AST_FLAG_RECURSE_2);
ast_setflag(entity, AST_FLAG_ERROR_2);
return false;
case AST_FLAG_DONE_2:
return true;
case AST_FLAG_ERROR_2:
return false;
default:
assert(0);
return false;
}
AST_GET_CHILDREN(entity, id, typeparams, cap, provides, members);
ast_t* member = ast_child(members);
while(member != NULL)
{
if(ast_id(member) == TK_EMBED)
{
AST_GET_CHILDREN(member, f_id, f_type);
ast_t* def = (ast_t*)ast_data(f_type);
assert(def != NULL);
if(!embed_fields(def, opt))
return false;
}
member = ast_sibling(member);
}
ast_clearflag(entity, AST_FLAG_RECURSE_2);
ast_setflag(entity, AST_FLAG_DONE_2);
return true;
}
static int check_body_send(ast_t* ast, bool in_final)
{
if(ast_checkflag(ast, AST_FLAG_RECURSE_1))
return FINAL_RECURSE;
if(ast_cansend(ast))
return FINAL_CAN_SEND;
if(!ast_mightsend(ast))
return FINAL_NO_SEND;
ast_setflag(ast, AST_FLAG_RECURSE_1);
int r = check_expr_send(ast, in_final);
if(r == FINAL_NO_SEND)
{
// Mark the body as no send.
ast_clearmightsend(ast);
} else if((r & FINAL_CAN_SEND) != 0) {
// Mark the body as can send.
ast_setsend(ast);
}
ast_clearflag(ast, AST_FLAG_RECURSE_1);
return r;
}
void ast_inheritflags(ast_t* ast)
{
assert(ast != NULL);
for(ast_t* child = ast->child; child != NULL; child = ast_sibling(child))
ast_setflag(ast, child->flags & AST_INHERIT_FLAGS);
}
// Set the scope for the given node, but set it no have no parent
static void set_scope_no_parent(ast_t* ast, ast_t* scope)
{
assert(ast != NULL);
ast->parent = scope;
ast_setflag(ast, AST_ORPHAN);
}
static ast_t* consume_token(parser_t* parser)
{
ast_t* ast = ast_token(parser->token);
ast_setflag(ast, parser->next_flags);
parser->next_flags = 0;
fetch_next_lexer_token(parser, false);
return ast;
}
// Add provided methods to the given entity
static bool trait_entity(ast_t* entity, pass_opt_t* options)
{
assert(entity != NULL);
int state = ast_checkflag(entity,
AST_FLAG_RECURSE_1 | AST_FLAG_DONE_1 | AST_FLAG_ERROR_1);
// Check for recursive definitions
switch(state)
{
case 0:
ast_setflag(entity, AST_FLAG_RECURSE_1);
break;
case AST_FLAG_RECURSE_1:
ast_error(entity, "traits and interfaces can't be recursive");
ast_clearflag(entity, AST_FLAG_RECURSE_1);
ast_setflag(entity, AST_FLAG_ERROR_1);
return false;
case AST_FLAG_DONE_1:
return true;
case AST_FLAG_ERROR_1:
return false;
default:
assert(0);
return false;
}
setup_local_methods(entity);
bool r =
provides_list(entity, options) && // Stage 1
provided_methods(options, entity) && // Stage 2
field_delegations(entity) && // Stage 3
resolve_methods(entity, options); // Stage 4
tidy_up(entity);
ast_clearflag(entity, AST_FLAG_RECURSE_1);
ast_setflag(entity, AST_FLAG_DONE_1);
return r;
}
// Add provided and delegated methods to the given entity.
static bool trait_entity(ast_t* entity, pass_opt_t* opt)
{
assert(entity != NULL);
int state = ast_checkflag(entity,
AST_FLAG_RECURSE_1 | AST_FLAG_DONE_1 | AST_FLAG_ERROR_1);
// Check for recursive definitions
switch(state)
{
case 0:
ast_setflag(entity, AST_FLAG_RECURSE_1);
break;
case AST_FLAG_RECURSE_1:
ast_error(opt->check.errors, entity,
"traits and interfaces can't be recursive");
ast_clearflag(entity, AST_FLAG_RECURSE_1);
ast_setflag(entity, AST_FLAG_ERROR_1);
return false;
case AST_FLAG_DONE_1:
return true;
case AST_FLAG_ERROR_1:
return false;
default:
assert(0);
return false;
}
setup_local_methods(entity);
bool r =
delegated_methods(entity, opt) &&
provided_methods(entity, opt) &&
check_concrete_bodies(entity, opt);
tidy_up(entity);
ast_clearflag(entity, AST_FLAG_RECURSE_1);
ast_setflag(entity, AST_FLAG_DONE_1);
return r;
}
static void record_ast_pass(ast_t* ast, pass_id pass)
{
assert(ast != NULL);
if(pass == PASS_ALL)
return;
ast_clearflag(ast, AST_FLAG_PASS_MASK);
ast_setflag(ast, (int)pass);
}
void ast_setmightsend(ast_t* ast)
{
ast_setflag(ast, AST_FLAG_MIGHT_SEND);
}
void ast_setsend(ast_t* ast)
{
ast_setflag(ast, AST_FLAG_CAN_SEND);
}
void ast_seterror(ast_t* ast)
{
ast_setflag(ast, AST_FLAG_CAN_ERROR);
}
// Remove the given node's parent without changing its scope (if any)
static void make_orphan_leave_scope(ast_t* ast)
{
ast_setflag(ast, AST_ORPHAN);
}
bool expr_lambda(pass_opt_t* opt, ast_t** astp)
{
pony_assert(astp != NULL);
ast_t* ast = *astp;
pony_assert(ast != NULL);
AST_GET_CHILDREN(ast, receiver_cap, name, t_params, params, captures,
ret_type, raises, body, reference_cap);
ast_t* annotation = ast_consumeannotation(ast);
bool bare = ast_id(ast) == TK_BARELAMBDA;
ast_t* members = ast_from(ast, TK_MEMBERS);
ast_t* last_member = NULL;
bool failed = false;
if(bare)
pony_assert(ast_id(captures) == TK_NONE);
// Process captures
for(ast_t* p = ast_child(captures); p != NULL; p = ast_sibling(p))
{
ast_t* field = NULL;
bool ok = make_capture_field(opt, p, &field);
if(field != NULL)
ast_list_append(members, &last_member, field);
else if(!ok)
// An error occurred, just keep going to potentially find more errors
failed = true;
}
if(failed)
{
ast_free(members);
return false;
}
// Stop the various elements being marked as preserve
ast_clearflag(t_params, AST_FLAG_PRESERVE);
ast_clearflag(params, AST_FLAG_PRESERVE);
ast_clearflag(ret_type, AST_FLAG_PRESERVE);
ast_clearflag(body, AST_FLAG_PRESERVE);
const char* fn_name = "apply";
if(ast_id(name) == TK_ID)
fn_name = ast_name(name);
// Make the apply function
BUILD(apply, ast,
NODE(TK_FUN, AST_SCOPE
ANNOTATE(annotation)
TREE(receiver_cap)
ID(fn_name)
TREE(t_params)
TREE(params)
TREE(ret_type)
TREE(raises)
TREE(body)
NONE // Doc string
NONE)); // Guard
ast_list_append(members, &last_member, apply);
ast_setflag(members, AST_FLAG_PRESERVE);
printbuf_t* buf = printbuf_new();
printbuf(buf, bare ? "@{(" : "{(");
bool first = true;
for(ast_t* p = ast_child(params); p != NULL; p = ast_sibling(p))
{
if(first)
first = false;
else
printbuf(buf, ", ");
printbuf(buf, "%s", ast_print_type(ast_childidx(p, 1)));
}
printbuf(buf, ")");
if(ast_id(ret_type) != TK_NONE)
printbuf(buf, ": %s", ast_print_type(ret_type));
if(ast_id(raises) != TK_NONE)
printbuf(buf, " ?");
printbuf(buf, "}");
// Replace lambda with object literal
REPLACE(astp,
NODE(TK_OBJECT, DATA(stringtab(buf->m))
TREE(reference_cap)
NONE // Provides list
TREE(members)));
printbuf_free(buf);
if(bare)
{
BUILD(bare_annotation, *astp,
NODE(TK_ANNOTATION,
ID("ponyint_bare")));
// Record the syntax pass as done to avoid the error about internal
// annotations.
ast_pass_record(bare_annotation, PASS_SYNTAX);
ast_setannotation(*astp, bare_annotation);
}
// Catch up passes
if(ast_visit(astp, pass_syntax, NULL, opt, PASS_SYNTAX) != AST_OK)
return false;
return ast_passes_subtree(astp, opt, PASS_EXPR);
}
// Sugar for partial application, which we convert to a lambda.
static bool partial_application(pass_opt_t* opt, ast_t** astp)
{
/* Example that we refer to throughout this function.
* ```pony
* class C
* fun f[T](a: A, b: B = b_default): R
*
* let recv: T = ...
* recv~f[T2](foo)
* ```
*
* Partial call is converted to:
* ```pony
* lambda(b: B = b_default)($0 = recv, a = foo): R => $0.f[T2](a, consume b)
* ```
*/
ast_t* ast = *astp;
typecheck_t* t = &opt->check;
if(!method_application(opt, ast, true))
return false;
AST_GET_CHILDREN(ast, positional, namedargs, lhs);
assert(ast_id(lhs) == TK_FUNAPP || ast_id(lhs) == TK_BEAPP ||
ast_id(lhs) == TK_NEWAPP);
// LHS must be a TK_TILDE, possibly contained in a TK_QUALIFY.
AST_GET_CHILDREN(lhs, receiver, method);
ast_t* type_args = NULL;
switch(ast_id(receiver))
{
case TK_NEWAPP:
case TK_BEAPP:
case TK_FUNAPP:
type_args = method;
AST_GET_CHILDREN_NO_DECL(receiver, receiver, method);
break;
default: {}
}
// The TK_FUNTYPE of the LHS.
ast_t* type = ast_type(lhs);
if(is_typecheck_error(type))
return false;
token_id apply_cap = partial_application_cap(opt, type, receiver,
positional);
AST_GET_CHILDREN(type, cap, type_params, target_params, result);
token_id can_error = ast_canerror(lhs) ? TK_QUESTION : TK_NONE;
const char* recv_name = package_hygienic_id(t);
// Build captures. We always have at least one capture, for receiver.
// Capture: `$0 = recv`
BUILD(captures, receiver,
NODE(TK_LAMBDACAPTURES,
NODE(TK_LAMBDACAPTURE,
ID(recv_name)
NONE // Infer type.
TREE(receiver))));
// Process arguments.
ast_t* given_arg = ast_child(positional);
ast_t* target_param = ast_child(target_params);
ast_t* lambda_params = ast_from(target_params, TK_NONE);
ast_t* lambda_call_args = ast_from(positional, TK_NONE);
while(given_arg != NULL)
{
assert(target_param != NULL);
const char* target_p_name = ast_name(ast_child(target_param));
if(ast_id(given_arg) == TK_NONE)
{
// This argument is not supplied already, must be a lambda parameter.
// Like `b` in example above.
// Build a new a new TK_PARAM node rather than copying the target one,
// since the target has already been processed to expr pass, and we need
// a clean one.
AST_GET_CHILDREN(target_param, p_id, p_type, p_default);
// Parameter: `b: B = b_default`
BUILD(lambda_param, target_param,
NODE(TK_PARAM,
TREE(p_id)
TREE(sanitise_type(p_type))
TREE(p_default)));
ast_append(lambda_params, lambda_param);
ast_setid(lambda_params, TK_PARAMS);
// Argument: `consume b`
BUILD(target_arg, lambda_param,
NODE(TK_SEQ,
NODE(TK_CONSUME,
NONE
NODE(TK_REFERENCE, ID(target_p_name)))));
ast_append(lambda_call_args, target_arg);
ast_setid(lambda_call_args, TK_POSITIONALARGS);
}
else
{
// This argument is supplied to the partial, capture it.
// Like `a` in example above.
// Capture: `a = foo`
BUILD(capture, given_arg,
NODE(TK_LAMBDACAPTURE,
ID(target_p_name)
NONE
TREE(given_arg)));
ast_append(captures, capture);
// Argument: `a`
BUILD(target_arg, given_arg,
NODE(TK_SEQ,
NODE(TK_REFERENCE, ID(target_p_name))));
ast_append(lambda_call_args, target_arg);
ast_setid(lambda_call_args, TK_POSITIONALARGS);
}
given_arg = ast_sibling(given_arg);
target_param = ast_sibling(target_param);
}
assert(target_param == NULL);
// Build lambda expression.
// `$0.f`
BUILD(call_receiver, ast,
NODE(TK_DOT,
NODE(TK_REFERENCE, ID(recv_name))
TREE(method)));
if(type_args != NULL)
{
// The partial call has type args, add them to the actual call in apply().
// `$0.f[T2]`
BUILD(qualified, type_args,
NODE(TK_QUALIFY,
TREE(call_receiver)
TREE(type_args)));
call_receiver = qualified;
}
REPLACE(astp,
NODE(TK_LAMBDA,
NODE(apply_cap)
NONE // Lambda function name.
NONE // Lambda type params.
TREE(lambda_params)
TREE(captures)
TREE(sanitise_type(result))
NODE(can_error)
NODE(TK_SEQ,
NODE(TK_CALL,
TREE(lambda_call_args)
NONE // Named args.
TREE(call_receiver)))));
// Need to preserve various lambda children.
ast_setflag(ast_childidx(*astp, 2), AST_FLAG_PRESERVE); // Type params.
ast_setflag(ast_childidx(*astp, 3), AST_FLAG_PRESERVE); // Parameters.
ast_setflag(ast_childidx(*astp, 5), AST_FLAG_PRESERVE); // Return type.
ast_setflag(ast_childidx(*astp, 7), AST_FLAG_PRESERVE); // Body.
// Catch up to this pass.
return ast_passes_subtree(astp, opt, PASS_EXPR);
}
// Combine the given inherited method with the existing one, if any, in the
// given entity.
// The provided method must already be reified.
// The trait_ref is the entry in the provides list that causes this method
// inclusion. Needed for error reporting.
// Returns true on success, false on failure in which case an error will have
// been reported.
static bool add_method_from_trait(ast_t* entity, ast_t* method,
ast_t* trait_ref, pass_opt_t* opt)
{
assert(entity != NULL);
assert(method != NULL);
assert(trait_ref != NULL);
AST_GET_CHILDREN(method, cap, id, t_params, params, result, error,
method_body);
const char* method_name = ast_name(id);
ast_t* existing_method = find_method(entity, method_name);
if(existing_method == NULL)
{
// We don't have a method yet with this name, add the one from this trait.
ast_t* m = add_method(entity, trait_ref, method, "provided", opt);
if(m == NULL)
return false;
if(ast_id(ast_childidx(m, 6)) != TK_NONE)
ast_visit(&m, rescope, NULL, opt, PASS_ALL);
return true;
}
// A method with this name already exists.
method_t* info = (method_t*)ast_data(existing_method);
assert(info != NULL);
// Method has already caused an error, do nothing.
if(info->failed)
return false;
if(info->local_define || info->delegated_field != NULL)
return true;
// Existing method is also provided, signatures must match exactly.
if(!compare_signatures(existing_method, method))
{
assert(info->trait_ref != NULL);
ast_error(opt->check.errors, trait_ref,
"clashing definitions for method '%s' provided, local disambiguation "
"required",
method_name);
ast_error_continue(opt->check.errors, trait_ref,
"provided here, type: %s",
ast_print_type(method));
ast_error_continue(opt->check.errors, info->trait_ref,
"and here, type: %s",
ast_print_type(existing_method));
info->failed = true;
return false;
}
// Resolve bodies, if any.
ast_t* existing_body = ast_childidx(existing_method, 6);
bool multiple_bodies =
(info->body_donor != NULL) &&
(ast_id(method_body) != TK_NONE) &&
(info->body_donor != (ast_t*)ast_data(method));
if(multiple_bodies ||
ast_checkflag(existing_method, AST_FLAG_AMBIGUOUS) ||
ast_checkflag(method, AST_FLAG_AMBIGUOUS))
{
// This method body ambiguous, which is not necessarily an error.
ast_setflag(existing_method, AST_FLAG_AMBIGUOUS);
if(ast_id(existing_body) != TK_NONE) // Ditch existing body.
ast_replace(&existing_body, ast_from(existing_method, TK_NONE));
info->body_donor = NULL;
return true;
}
// No new body to resolve.
if((ast_id(method_body) == TK_NONE) ||
(info->body_donor == (ast_t*)ast_data(method)))
return true;
// Trait provides default body. Use it and patch up symbol tables.
assert(ast_id(existing_body) == TK_NONE);
ast_replace(&existing_body, method_body);
ast_visit(&method_body, rescope, NULL, opt, PASS_ALL);
info->body_donor = (ast_t*)ast_data(method);
info->trait_ref = trait_ref;
return true;
}
// Sugar for partial application, which we convert to a lambda.
static bool partial_application(pass_opt_t* opt, ast_t** astp)
{
/* Example that we refer to throughout this function.
* ```pony
* class C
* fun f[T](a: A, b: B = b_default): R
*
* let recv: T = ...
* recv~f[T2](foo)
* ```
*
* Partial call is converted to:
* ```pony
* {(b: B = b_default)($0 = recv, a = foo): R => $0.f[T2](a, consume b) }
* ```
*/
ast_t* ast = *astp;
typecheck_t* t = &opt->check;
if(!method_application(opt, ast, true))
return false;
AST_GET_CHILDREN(ast, positional, namedargs, question, lhs);
// LHS must be an application, possibly wrapped in another application
// if the method had type parameters for qualification.
pony_assert(ast_id(lhs) == TK_FUNAPP || ast_id(lhs) == TK_BEAPP ||
ast_id(lhs) == TK_NEWAPP);
AST_GET_CHILDREN(lhs, receiver, method);
ast_t* type_args = NULL;
if(ast_id(receiver) == ast_id(lhs))
{
type_args = method;
AST_GET_CHILDREN_NO_DECL(receiver, receiver, method);
}
// Look up the original method definition for this method call.
ast_t* method_def = lookup(opt, lhs, ast_type(receiver), ast_name(method));
pony_assert(ast_id(method_def) == TK_FUN || ast_id(method_def) == TK_BE ||
ast_id(method_def) == TK_NEW);
// The TK_FUNTYPE of the LHS.
ast_t* type = ast_type(lhs);
pony_assert(ast_id(type) == TK_FUNTYPE);
if(is_typecheck_error(type))
return false;
AST_GET_CHILDREN(type, cap, type_params, target_params, result);
bool bare = ast_id(cap) == TK_AT;
token_id apply_cap = TK_AT;
if(!bare)
apply_cap = partial_application_cap(opt, type, receiver, positional);
token_id can_error = ast_id(ast_childidx(method_def, 5));
const char* recv_name = package_hygienic_id(t);
// Build lambda expression.
ast_t* call_receiver = NULL;
if(bare)
{
ast_t* arg = ast_child(positional);
while(arg != NULL)
{
if(ast_id(arg) != TK_NONE)
{
ast_error(opt->check.errors, arg, "the partial application of a bare "
"method cannot take arguments");
return false;
}
arg = ast_sibling(arg);
}
ast_t* receiver_type = ast_type(receiver);
if(is_bare(receiver_type))
{
// Partial application on a bare object, simply return the object itself.
ast_replace(astp, receiver);
return true;
}
AST_GET_CHILDREN(receiver_type, recv_type_package, recv_type_name);
const char* recv_package_str = ast_name(recv_type_package);
const char* recv_name_str = ast_name(recv_type_name);
ast_t* module = ast_nearest(ast, TK_MODULE);
ast_t* package = ast_parent(module);
ast_t* pkg_id = package_id(package);
const char* pkg_str = ast_name(pkg_id);
const char* pkg_alias = NULL;
if(recv_package_str != pkg_str)
pkg_alias = package_alias_from_id(module, recv_package_str);
ast_free_unattached(pkg_id);
if(pkg_alias != NULL)
{
// `package.Type.f`
BUILD_NO_DECL(call_receiver, ast,
NODE(TK_DOT,
NODE(TK_DOT,
NODE(TK_REFERENCE, ID(pkg_alias))
ID(recv_name_str))
TREE(method)));
} else {
// `Type.f`
BUILD_NO_DECL(call_receiver, ast,
NODE(TK_DOT,
NODE(TK_REFERENCE, ID(recv_name_str))
TREE(method)));
}
} else {
// `$0.f`
BUILD_NO_DECL(call_receiver, ast,
NODE(TK_DOT,
NODE(TK_REFERENCE, ID(recv_name))
TREE(method)));
}
ast_t* captures = NULL;
if(bare)
{
captures = ast_from(receiver, TK_NONE);
} else {
// Build captures. We always have at least one capture, for receiver.
// Capture: `$0 = recv`
BUILD_NO_DECL(captures, receiver,
NODE(TK_LAMBDACAPTURES,
NODE(TK_LAMBDACAPTURE,
ID(recv_name)
NONE // Infer type.
TREE(receiver))));
}
// Process arguments.
ast_t* target_param = ast_child(target_params);
ast_t* lambda_params = ast_from(target_params, TK_NONE);
ast_t* lambda_call_args = ast_from(positional, TK_NONE);
ast_t* given_arg = ast_child(positional);
while(given_arg != NULL)
{
pony_assert(target_param != NULL);
const char* target_p_name = ast_name(ast_child(target_param));
if(ast_id(given_arg) == TK_NONE)
{
// This argument is not supplied already, must be a lambda parameter.
// Like `b` in example above.
// Build a new a new TK_PARAM node rather than copying the target one,
// since the target has already been processed to expr pass, and we need
// a clean one.
AST_GET_CHILDREN(target_param, p_id, p_type, p_default);
// Parameter: `b: B = b_default`
BUILD(lambda_param, target_param,
NODE(TK_PARAM,
TREE(p_id)
TREE(sanitise_type(p_type))
TREE(p_default)));
ast_append(lambda_params, lambda_param);
ast_setid(lambda_params, TK_PARAMS);
// Argument: `consume b`
BUILD(target_arg, lambda_param,
NODE(TK_SEQ,
NODE(TK_CONSUME,
NONE
NODE(TK_REFERENCE, ID(target_p_name)))));
ast_append(lambda_call_args, target_arg);
ast_setid(lambda_call_args, TK_POSITIONALARGS);
}
else
{
// This argument is supplied to the partial, capture it.
// Like `a` in example above.
// Capture: `a = foo`
BUILD(capture, given_arg,
NODE(TK_LAMBDACAPTURE,
ID(target_p_name)
NONE
TREE(given_arg)));
ast_append(captures, capture);
// Argument: `a`
BUILD(target_arg, given_arg,
NODE(TK_SEQ,
NODE(TK_REFERENCE, ID(target_p_name))));
ast_append(lambda_call_args, target_arg);
ast_setid(lambda_call_args, TK_POSITIONALARGS);
}
given_arg = ast_sibling(given_arg);
target_param = ast_sibling(target_param);
}
pony_assert(target_param == NULL);
if(type_args != NULL)
{
// The partial call has type args, add them to the actual call in apply().
// `$0.f[T2]`
BUILD(qualified, type_args,
NODE(TK_QUALIFY,
TREE(call_receiver)
TREE(type_args)));
call_receiver = qualified;
}
REPLACE(astp,
NODE((bare ? TK_BARELAMBDA : TK_LAMBDA),
NODE(apply_cap)
NONE // Lambda function name.
NONE // Lambda type params.
TREE(lambda_params)
TREE(captures)
TREE(sanitise_type(result))
NODE(can_error)
NODE(TK_SEQ,
NODE(TK_CALL,
TREE(lambda_call_args)
NONE // Named args.
NODE(can_error)
TREE(call_receiver)))
NONE)); // Lambda reference capability.
// Need to preserve various lambda children.
ast_setflag(ast_childidx(*astp, 2), AST_FLAG_PRESERVE); // Type params.
ast_setflag(ast_childidx(*astp, 3), AST_FLAG_PRESERVE); // Parameters.
ast_setflag(ast_childidx(*astp, 5), AST_FLAG_PRESERVE); // Return type.
ast_setflag(ast_childidx(*astp, 7), AST_FLAG_PRESERVE); // Body.
// Catch up to this pass.
return ast_passes_subtree(astp, opt, PASS_EXPR);
}
ast_t* package_load(ast_t* from, const char* path, pass_opt_t* opt)
{
pony_assert(from != NULL);
magic_package_t* magic = find_magic_package(path, opt);
const char* full_path = path;
const char* qualified_name = path;
ast_t* program = ast_nearest(from, TK_PROGRAM);
if(magic == NULL)
{
// Lookup (and hence normalise) path
bool is_relative = false;
bool found_notdir = false;
full_path = find_path(from, path, &is_relative, &found_notdir, opt);
if(full_path == NULL)
{
errorf(opt->check.errors, path, "couldn't locate this path");
if(found_notdir)
errorf_continue(opt->check.errors, path, "note that a compiler "
"invocation or a 'use' directive must refer to a directory");
return NULL;
}
if((from != program) && is_relative)
{
// Package to load is relative to from, build the qualified name
// The qualified name should be relative to the program being built
package_t* from_pkg = (package_t*)ast_data(ast_child(program));
if(from_pkg != NULL)
{
const char* base_name = from_pkg->qualified_name;
size_t base_name_len = strlen(base_name);
size_t path_len = strlen(path);
size_t len = base_name_len + path_len + 2;
char* q_name = (char*)ponyint_pool_alloc_size(len);
memcpy(q_name, base_name, base_name_len);
q_name[base_name_len] = '/';
memcpy(q_name + base_name_len + 1, path, path_len);
q_name[len - 1] = '\0';
qualified_name = stringtab_consume(q_name, len);
}
}
// we are loading the package specified as program dir
if(from == program)
{
// construct the qualified name from the basename of the full path
const char* basepath = strrchr(full_path, '/');
if(basepath == NULL)
{
basepath = full_path;
} else {
basepath = basepath + 1;
}
qualified_name = basepath;
}
}
ast_t* package = ast_get(program, full_path, NULL);
// Package already loaded
if(package != NULL)
return package;
package = create_package(program, full_path, qualified_name, opt);
if(opt->verbosity >= VERBOSITY_INFO)
fprintf(stderr, "Building %s -> %s\n", path, full_path);
if(magic != NULL)
{
if(magic->src != NULL)
{
if(!parse_source_code(package, magic->src, opt))
return NULL;
} else if(magic->mapped_path != NULL) {
if(!parse_files_in_dir(package, magic->mapped_path, opt))
return NULL;
} else {
return NULL;
}
}
else
{
if(!parse_files_in_dir(package, full_path, opt))
return NULL;
}
if(ast_child(package) == NULL)
{
ast_error(opt->check.errors, package,
"no source files in package '%s'", path);
return NULL;
}
if(!ast_passes_subtree(&package, opt, opt->program_pass))
{
// If these passes failed, don't run future passes.
ast_setflag(package, AST_FLAG_PRESERVE);
return NULL;
}
return package;
}
ast_t* package_load(ast_t* from, const char* path, pass_opt_t* options)
{
assert(from != NULL);
const char* magic = find_magic_package(path);
const char* full_path = path;
const char* qualified_name = path;
ast_t* program = ast_nearest(from, TK_PROGRAM);
if(magic == NULL)
{
// Lookup (and hence normalise) path
bool is_relative = false;
full_path = find_path(from, path, &is_relative);
if(full_path == NULL)
return NULL;
if((from != program) && is_relative)
{
// Package to load is relative to from, build the qualified name
// The qualified name should be relative to the program being built
package_t* from_pkg = (package_t*)ast_data(ast_child(program));
if(from_pkg != NULL)
{
const char* base_name = from_pkg->qualified_name;
size_t base_name_len = strlen(base_name);
size_t path_len = strlen(path);
size_t len = base_name_len + path_len + 2;
char* q_name = (char*)pool_alloc_size(len);
memcpy(q_name, base_name, base_name_len);
q_name[base_name_len] = '/';
memcpy(q_name + base_name_len + 1, path, path_len);
q_name[len - 1] = '\0';
qualified_name = stringtab_consume(q_name, len);
}
}
}
ast_t* package = ast_get(program, full_path, NULL);
// Package already loaded
if(package != NULL)
return package;
package = create_package(program, full_path, qualified_name);
if(report_build)
printf("Building %s -> %s\n", path, full_path);
if(magic != NULL)
{
if(!parse_source_code(package, magic, options))
return NULL;
}
else
{
if(!parse_files_in_dir(package, full_path, options))
return NULL;
}
if(ast_child(package) == NULL)
{
ast_error(package, "no source files in package '%s'", path);
return NULL;
}
if(!ast_passes_subtree(&package, options, options->program_pass))
{
// If these passes failed, don't run future passes.
ast_setflag(package, AST_FLAG_PRESERVE);
return NULL;
}
return package;
}
bool expr_lambda(pass_opt_t* opt, ast_t** astp)
{
pony_assert(astp != NULL);
ast_t* ast = *astp;
pony_assert(ast != NULL);
AST_GET_CHILDREN(ast, receiver_cap, name, t_params, params, captures,
ret_type, raises, body, obj_cap);
ast_t* annotation = ast_consumeannotation(ast);
// Try to find an antecedent type, and find possible lambda interfaces in it.
ast_t* antecedent_type = find_antecedent_type(opt, ast, NULL);
astlist_t* possible_fun_defs = NULL;
astlist_t* possible_obj_caps = NULL;
if(!is_typecheck_error(antecedent_type))
find_possible_fun_defs(opt, antecedent_type, &possible_fun_defs,
&possible_obj_caps);
// If there's more than one possible fun defs, rule out impossible ones by
// comparing each fun def by some basic criteria against the lambda,
// creating a new list containing only the remaining possibilities.
if(astlist_length(possible_fun_defs) > 1)
{
astlist_t* new_fun_defs = NULL;
astlist_t* new_obj_caps = NULL;
astlist_t* fun_def_cursor = possible_fun_defs;
astlist_t* obj_cap_cursor = possible_obj_caps;
for(; (fun_def_cursor != NULL) && (obj_cap_cursor != NULL);
fun_def_cursor = astlist_next(fun_def_cursor),
obj_cap_cursor = astlist_next(obj_cap_cursor))
{
ast_t* fun_def = astlist_data(fun_def_cursor);
ast_t* def_obj_cap = astlist_data(obj_cap_cursor);
if(is_typecheck_error(fun_def))
continue;
AST_GET_CHILDREN(fun_def, def_receiver_cap, def_name, def_t_params,
def_params, def_ret_type, def_raises);
// Must have the same number of parameters.
if(ast_childcount(params) != ast_childcount(def_params))
continue;
// Must have a supercap of the def's receiver cap (if present).
if((ast_id(receiver_cap) != TK_NONE) && !is_cap_sub_cap(
ast_id(def_receiver_cap), TK_NONE, ast_id(receiver_cap), TK_NONE)
)
continue;
// Must have a supercap of the def's object cap (if present).
if((ast_id(obj_cap) != TK_NONE) &&
!is_cap_sub_cap(ast_id(obj_cap), TK_NONE, ast_id(def_obj_cap), TK_NONE))
continue;
// TODO: This logic could potentially be expanded to do deeper
// compatibility checks, but checks involving subtyping here would be
// difficult, because the lambda's AST is not caught up yet in the passes.
new_fun_defs = astlist_push(new_fun_defs, fun_def);
new_obj_caps = astlist_push(new_obj_caps, def_obj_cap);
}
astlist_free(possible_fun_defs);
astlist_free(possible_obj_caps);
possible_fun_defs = new_fun_defs;
possible_obj_caps = new_obj_caps;
}
if(astlist_length(possible_fun_defs) == 1)
{
ast_t* fun_def = astlist_data(possible_fun_defs);
ast_t* def_obj_cap = astlist_data(possible_obj_caps);
// Try to complete the lambda's type info by inferring from the lambda type.
if(!is_typecheck_error(fun_def))
{
// Infer the object cap, receiver cap, and return type if unspecified.
if(ast_id(obj_cap) == TK_NONE)
ast_replace(&obj_cap, def_obj_cap);
if(ast_id(receiver_cap) == TK_NONE)
ast_replace(&receiver_cap, ast_child(fun_def));
if(ast_id(ret_type) == TK_NONE)
ast_replace(&ret_type, ast_childidx(fun_def, 4));
// Infer the type of any parameters that were left unspecified.
ast_t* param = ast_child(params);
ast_t* def_param = ast_child(ast_childidx(fun_def, 3));
while((param != NULL) && (def_param != NULL))
{
ast_t* param_id = ast_child(param);
ast_t* param_type = ast_sibling(param_id);
// Convert a "_" parameter to whatever the expected parameter is.
if(is_name_dontcare(ast_name(param_id)))
{
ast_replace(¶m_id, ast_child(def_param));
ast_replace(¶m_type, ast_childidx(def_param, 1));
}
// Give a type-unspecified parameter the type of the expected parameter.
else if(ast_id(param_type) == TK_NONE)
{
ast_replace(¶m_type, ast_childidx(def_param, 1));
}
param = ast_sibling(param);
def_param = ast_sibling(def_param);
}
}
ast_free_unattached(fun_def);
}
astlist_free(possible_obj_caps);
// If any parameters still have no type specified, it's an error.
ast_t* param = ast_child(params);
while(param != NULL)
{
if(ast_id(ast_childidx(param, 1)) == TK_NONE)
{
ast_error(opt->check.errors, param,
"a lambda parameter must specify a type or be inferable from context");
if(astlist_length(possible_fun_defs) > 1)
{
for(astlist_t* fun_def_cursor = possible_fun_defs;
fun_def_cursor != NULL;
fun_def_cursor = astlist_next(fun_def_cursor))
{
ast_error_continue(opt->check.errors, astlist_data(fun_def_cursor),
"this lambda interface is inferred, but it's not the only one");
}
}
astlist_free(possible_fun_defs);
return false;
}
param = ast_sibling(param);
}
astlist_free(possible_fun_defs);
bool bare = ast_id(ast) == TK_BARELAMBDA;
ast_t* members = ast_from(ast, TK_MEMBERS);
ast_t* last_member = NULL;
bool failed = false;
if(bare)
pony_assert(ast_id(captures) == TK_NONE);
// Process captures
for(ast_t* p = ast_child(captures); p != NULL; p = ast_sibling(p))
{
ast_t* field = NULL;
bool ok = make_capture_field(opt, p, &field);
if(field != NULL)
ast_list_append(members, &last_member, field);
else if(!ok)
// An error occurred, just keep going to potentially find more errors
failed = true;
}
if(failed)
{
ast_free(members);
return false;
}
// Stop the various elements being marked as preserve
ast_clearflag(t_params, AST_FLAG_PRESERVE);
ast_clearflag(params, AST_FLAG_PRESERVE);
ast_clearflag(ret_type, AST_FLAG_PRESERVE);
ast_clearflag(body, AST_FLAG_PRESERVE);
const char* fn_name = "apply";
if(ast_id(name) == TK_ID)
fn_name = ast_name(name);
// Make the apply function
BUILD(apply, ast,
NODE(TK_FUN, AST_SCOPE
ANNOTATE(annotation)
TREE(receiver_cap)
ID(fn_name)
TREE(t_params)
TREE(params)
TREE(ret_type)
TREE(raises)
TREE(body)
NONE)); // Doc string
ast_list_append(members, &last_member, apply);
ast_setflag(members, AST_FLAG_PRESERVE);
printbuf_t* buf = printbuf_new();
printbuf(buf, bare ? "@{(" : "{(");
bool first = true;
for(ast_t* p = ast_child(params); p != NULL; p = ast_sibling(p))
{
if(first)
first = false;
else
printbuf(buf, ", ");
printbuf(buf, "%s", ast_print_type(ast_childidx(p, 1)));
}
printbuf(buf, ")");
if(ast_id(ret_type) != TK_NONE)
printbuf(buf, ": %s", ast_print_type(ret_type));
if(ast_id(raises) != TK_NONE)
printbuf(buf, " ?");
printbuf(buf, "}");
// Replace lambda with object literal
REPLACE(astp,
NODE(TK_OBJECT, DATA(stringtab(buf->m))
TREE(obj_cap)
NONE // Provides list
TREE(members)));
printbuf_free(buf);
if(bare)
{
BUILD(bare_annotation, *astp,
NODE(TK_ANNOTATION,
ID("ponyint_bare")));
// Record the syntax pass as done to avoid the error about internal
// annotations.
ast_pass_record(bare_annotation, PASS_SYNTAX);
ast_setannotation(*astp, bare_annotation);
}
// Catch up passes
if(ast_visit(astp, pass_syntax, NULL, opt, PASS_SYNTAX) != AST_OK)
return false;
return ast_passes_subtree(astp, opt, PASS_EXPR);
}
