bool verify_fun(pass_opt_t* opt, ast_t* ast)
{
assert((ast_id(ast) == TK_BE) || (ast_id(ast) == TK_FUN) ||
(ast_id(ast) == TK_NEW));
AST_GET_CHILDREN(ast, cap, id, typeparams, params, type, can_error, body);
// Run checks tailored to specific kinds of methods, if any apply.
if(!verify_main_create(opt, ast) ||
!verify_primitive_init(opt, ast) ||
!verify_any_final(opt, ast))
return false;
// Check partial functions.
if(ast_id(can_error) == TK_QUESTION)
{
// If the function is marked as partial, it must have the potential
// to raise an error somewhere in the body. This check is skipped for
// traits and interfaces - they are allowed to give a default implementation
// of the method that does or does not have the potential to raise an error.
bool is_trait =
(ast_id(opt->check.frame->type) == TK_TRAIT) ||
(ast_id(opt->check.frame->type) == TK_INTERFACE) ||
(ast_id((ast_t*)ast_data(ast)) == TK_TRAIT) ||
(ast_id((ast_t*)ast_data(ast)) == TK_INTERFACE);
if(!is_trait &&
!ast_canerror(body) &&
(ast_id(ast_type(body)) != TK_COMPILE_INTRINSIC))
{
ast_error(opt->check.errors, can_error, "function signature is marked as "
"partial but the function body cannot raise an error");
return false;
}
} else {
// If the function is not marked as partial, it must never raise an error.
if(ast_canerror(body))
{
if(ast_id(ast) == TK_BE)
{
ast_error(opt->check.errors, can_error, "a behaviour must handle any "
"potential error");
} else if((ast_id(ast) == TK_NEW) &&
(ast_id(opt->check.frame->type) == TK_ACTOR)) {
ast_error(opt->check.errors, can_error, "an actor constructor must "
"handle any potential error");
} else {
ast_error(opt->check.errors, can_error, "function signature is not "
"marked as partial but the function body can raise an error");
}
show_partiality(opt, body);
return false;
}
}
return true;
}
bool expr_fun(pass_opt_t* opt, ast_t* ast)
{
typecheck_t* t = &opt->check;
AST_GET_CHILDREN(ast,
cap, id, typeparams, params, type, can_error, body);
if(ast_id(body) == TK_NONE)
return true;
if(!coerce_literals(&body, type, opt))
return false;
bool is_trait =
(ast_id(t->frame->type) == TK_TRAIT) ||
(ast_id(t->frame->type) == TK_INTERFACE) ||
(ast_id((ast_t*)ast_data(ast)) == TK_TRAIT) ||
(ast_id((ast_t*)ast_data(ast)) == TK_INTERFACE);
// Check partial functions.
if(ast_id(can_error) == TK_QUESTION)
{
// If a partial function, check that we might actually error.
if(!is_trait && !ast_canerror(body))
{
ast_error(can_error, "function body is not partial but the function is");
return false;
}
} else {
// If not a partial function, check that we can't error.
if(ast_canerror(body))
{
ast_error(can_error, "function body is partial but the function is not");
show_partiality(body);
return false;
}
}
if(!check_primitive_init(t, ast) || !check_finaliser(ast))
return false;
switch(ast_id(ast))
{
case TK_NEW:
return check_fields_defined(ast) && check_main_create(t, ast);
case TK_FUN:
return check_return_type(ast);
default:
{}
}
return true;
}
static bool show_partiality(ast_t* ast)
{
ast_t* child = ast_child(ast);
bool found = false;
while(child != NULL)
{
if(ast_canerror(child))
found |= show_partiality(child);
child = ast_sibling(child);
}
if(found)
return true;
if(ast_canerror(ast))
{
ast_error(ast, "an error can be raised here");
return true;
}
return false;
}
static bool show_partiality(pass_opt_t* opt, ast_t* ast)
{
ast_t* child = ast_child(ast);
bool found = false;
while(child != NULL)
{
if(ast_canerror(child))
found |= show_partiality(opt, child);
child = ast_sibling(child);
}
if(found)
return true;
if(ast_canerror(ast))
{
ast_error_continue(opt->check.errors, ast, "an error can be raised here");
return true;
}
return false;
}
bool expr_fun(pass_opt_t* opt, ast_t* ast)
{
typecheck_t* t = &opt->check;
AST_GET_CHILDREN(ast,
cap, id, typeparams, params, type, can_error, body);
if(ast_id(body) == TK_NONE)
return true;
if(!coerce_literals(&body, type, opt))
return false;
bool is_trait =
(ast_id(t->frame->type) == TK_TRAIT) ||
(ast_id(t->frame->type) == TK_INTERFACE) ||
(ast_id((ast_t*)ast_data(ast)) == TK_TRAIT) ||
(ast_id((ast_t*)ast_data(ast)) == TK_INTERFACE);
// Check partial functions.
if(ast_id(can_error) == TK_QUESTION)
{
// If a partial function, check that we might actually error.
ast_t* body_type = ast_type(body);
if(body_type == NULL)
{
// An error has already occurred.
assert(get_error_count() > 0);
return false;
}
if(!is_trait &&
!ast_canerror(body) &&
(ast_id(body_type) != TK_COMPILE_INTRINSIC))
{
ast_error(can_error, "function body is not partial but the function is");
return false;
}
} else {
// If not a partial function, check that we can't error.
if(ast_canerror(body))
{
ast_error(can_error, "function body is partial but the function is not");
show_partiality(body);
return false;
}
}
if(!check_primitive_init(t, ast) || !check_finaliser(t, ast))
return false;
switch(ast_id(ast))
{
case TK_NEW:
{
bool ok = true;
if(is_machine_word(type))
{
if(!check_return_type(ast))
ok = false;
}
if(!check_fields_defined(ast))
ok = false;
if(!check_main_create(t, ast))
ok = false;
return ok;
}
case TK_FUN:
return check_return_type(ast);
default: {}
}
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
* 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);
}
LLVMValueRef gen_call(compile_t* c, ast_t* ast)
{
// Special case calls.
LLVMValueRef special;
if(special_case_call(c, ast, &special))
return special;
AST_GET_CHILDREN(ast, positional, named, postfix);
AST_GET_CHILDREN(postfix, receiver, method);
ast_t* typeargs = NULL;
// Dig through function qualification.
switch(ast_id(receiver))
{
case TK_NEWREF:
case TK_NEWBEREF:
case TK_BEREF:
case TK_FUNREF:
case TK_BECHAIN:
case TK_FUNCHAIN:
typeargs = method;
AST_GET_CHILDREN_NO_DECL(receiver, receiver, method);
break;
default: {}
}
// Get the receiver type.
const char* method_name = ast_name(method);
ast_t* type = ast_type(receiver);
reach_type_t* t = reach_type(c->reach, type);
pony_assert(t != NULL);
// Generate the arguments.
size_t count = ast_childcount(positional) + 1;
size_t buf_size = count * sizeof(void*);
LLVMValueRef* args = (LLVMValueRef*)ponyint_pool_alloc_size(buf_size);
ast_t* arg = ast_child(positional);
int i = 1;
while(arg != NULL)
{
LLVMValueRef value = gen_expr(c, arg);
if(value == NULL)
{
ponyint_pool_free_size(buf_size, args);
return NULL;
}
args[i] = value;
arg = ast_sibling(arg);
i++;
}
bool is_new_call = false;
// Generate the receiver. Must be done after the arguments because the args
// could change things in the receiver expression that must be accounted for.
if(call_needs_receiver(postfix, t))
{
switch(ast_id(postfix))
{
case TK_NEWREF:
case TK_NEWBEREF:
{
call_tuple_indices_t tuple_indices = {NULL, 0, 4};
tuple_indices.data =
(size_t*)ponyint_pool_alloc_size(4 * sizeof(size_t));
ast_t* current = ast;
ast_t* parent = ast_parent(current);
while((parent != NULL) && (ast_id(parent) != TK_ASSIGN) &&
(ast_id(parent) != TK_CALL))
{
if(ast_id(parent) == TK_TUPLE)
{
size_t index = 0;
ast_t* child = ast_child(parent);
while(current != child)
{
++index;
child = ast_sibling(child);
}
tuple_indices_push(&tuple_indices, index);
}
current = parent;
parent = ast_parent(current);
}
// If we're constructing an embed field, pass a pointer to the field
// as the receiver. Otherwise, allocate an object.
if((parent != NULL) && (ast_id(parent) == TK_ASSIGN))
{
size_t index = 1;
current = ast_childidx(parent, 1);
while((ast_id(current) == TK_TUPLE) || (ast_id(current) == TK_SEQ))
{
parent = current;
if(ast_id(current) == TK_TUPLE)
{
// If there are no indices left, we're destructuring a tuple.
// Errors in those cases have already been catched by the expr
// pass.
if(tuple_indices.count == 0)
break;
index = tuple_indices_pop(&tuple_indices);
current = ast_childidx(parent, index);
} else {
current = ast_childlast(parent);
}
}
if(ast_id(current) == TK_EMBEDREF)
{
args[0] = gen_fieldptr(c, current);
set_descriptor(c, t, args[0]);
} else {
args[0] = gencall_alloc(c, t);
}
} else {
args[0] = gencall_alloc(c, t);
}
is_new_call = true;
ponyint_pool_free_size(tuple_indices.alloc * sizeof(size_t),
tuple_indices.data);
break;
}
case TK_BEREF:
case TK_FUNREF:
case TK_BECHAIN:
case TK_FUNCHAIN:
args[0] = gen_expr(c, receiver);
break;
default:
pony_assert(0);
return NULL;
}
} else {
// Use a null for the receiver type.
args[0] = LLVMConstNull(t->use_type);
}
// Static or virtual dispatch.
token_id cap = cap_dispatch(type);
reach_method_t* m = reach_method(t, cap, method_name, typeargs);
LLVMValueRef func = dispatch_function(c, t, m, args[0]);
bool is_message = false;
if((ast_id(postfix) == TK_NEWBEREF) || (ast_id(postfix) == TK_BEREF) ||
(ast_id(postfix) == TK_BECHAIN))
{
switch(t->underlying)
{
case TK_ACTOR:
is_message = true;
break;
case TK_UNIONTYPE:
case TK_ISECTTYPE:
case TK_INTERFACE:
case TK_TRAIT:
if(m->cap == TK_TAG)
is_message = can_inline_message_send(t, m, method_name);
break;
default: {}
}
}
// Cast the arguments to the parameter types.
LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(func));
LLVMTypeRef* params = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetParamTypes(f_type, params);
arg = ast_child(positional);
i = 1;
LLVMValueRef r = NULL;
if(is_message)
{
// If we're sending a message, trace and send here instead of calling the
// sender to trace the most specific types possible.
LLVMValueRef* cast_args = (LLVMValueRef*)ponyint_pool_alloc_size(buf_size);
cast_args[0] = args[0];
while(arg != NULL)
{
cast_args[i] = gen_assign_cast(c, params[i], args[i], ast_type(arg));
arg = ast_sibling(arg);
i++;
}
token_id cap = cap_dispatch(type);
reach_method_t* m = reach_method(t, cap, method_name, typeargs);
codegen_debugloc(c, ast);
gen_send_message(c, m, args, cast_args, positional);
codegen_debugloc(c, NULL);
switch(ast_id(postfix))
{
case TK_NEWREF:
case TK_NEWBEREF:
r = args[0];
break;
default:
r = c->none_instance;
break;
}
ponyint_pool_free_size(buf_size, cast_args);
} else {
while(arg != NULL)
{
args[i] = gen_assign_cast(c, params[i], args[i], ast_type(arg));
arg = ast_sibling(arg);
i++;
}
if(func != NULL)
{
// If we can error out and we have an invoke target, generate an invoke
// instead of a call.
codegen_debugloc(c, ast);
if(ast_canerror(ast) && (c->frame->invoke_target != NULL))
r = invoke_fun(c, func, args, i, "", true);
else
r = codegen_call(c, func, args, i);
if(is_new_call)
{
LLVMValueRef md = LLVMMDNodeInContext(c->context, NULL, 0);
LLVMSetMetadataStr(r, "pony.newcall", md);
}
codegen_debugloc(c, NULL);
}
}
// Class constructors return void, expression result is the receiver.
if(((ast_id(postfix) == TK_NEWREF) || (ast_id(postfix) == TK_NEWBEREF)) &&
(t->underlying == TK_CLASS))
r = args[0];
// Chained methods forward their receiver.
if((ast_id(postfix) == TK_BECHAIN) || (ast_id(postfix) == TK_FUNCHAIN))
r = args[0];
ponyint_pool_free_size(buf_size, args);
ponyint_pool_free_size(buf_size, params);
return r;
}
bool expr_try(pass_opt_t* opt, ast_t* ast)
{
AST_GET_CHILDREN(ast, body, else_clause, then_clause);
// It has to be possible for the left side to result in an error.
if((ast_id(ast) == TK_TRY) && !ast_canerror(body))
{
ast_error(body, "try expression never results in an error");
return false;
}
ast_t* body_type = ast_type(body);
ast_t* else_type = ast_type(else_clause);
ast_t* then_type = ast_type(then_clause);
if(is_typecheck_error(body_type) ||
is_typecheck_error(else_type) ||
is_typecheck_error(then_type))
return false;
ast_t* type = NULL;
if(!is_control_type(body_type))
type = control_type_add_branch(type, body);
if(!is_control_type(else_type))
type = control_type_add_branch(type, else_clause);
if(type == NULL)
{
if(ast_sibling(ast) != NULL)
{
ast_error(ast_sibling(ast), "unreachable code");
return false;
}
type = ast_from(ast, TK_TRY);
}
// The then clause does not affect the type of the expression.
if(is_control_type(then_type))
{
ast_error(then_clause, "then clause always terminates the function");
return false;
}
if(is_type_literal(then_type))
{
ast_error(then_clause, "Cannot infer type of unused literal");
return false;
}
ast_settype(ast, type);
// Doesn't inherit error from the body.
if(ast_canerror(else_clause) || ast_canerror(then_clause))
ast_seterror(ast);
if(ast_cansend(body) || ast_cansend(else_clause) || ast_cansend(then_clause))
ast_setsend(ast);
if(ast_mightsend(body) || ast_mightsend(else_clause) ||
ast_mightsend(then_clause))
ast_setmightsend(ast);
literal_unify_control(ast, opt);
// Push the symbol status from the then clause to our parent scope.
ast_inheritstatus(ast_parent(ast), then_clause);
return true;
}
LLVMValueRef gen_call(compile_t* c, ast_t* ast)
{
// Special case calls.
LLVMValueRef special;
if(special_case_call(c, ast, &special))
return special;
AST_GET_CHILDREN(ast, positional, named, postfix);
AST_GET_CHILDREN(postfix, receiver, method);
ast_t* typeargs = NULL;
// Dig through function qualification.
switch(ast_id(receiver))
{
case TK_NEWREF:
case TK_NEWBEREF:
case TK_BEREF:
case TK_FUNREF:
typeargs = method;
AST_GET_CHILDREN_NO_DECL(receiver, receiver, method);
break;
default: {}
}
// Generate the receiver type.
const char* method_name = ast_name(method);
ast_t* type = ast_type(receiver);
gentype_t g;
if(!gentype(c, type, &g))
return NULL;
// Generate the arguments.
LLVMTypeRef f_type = genfun_sig(c, &g, method_name, typeargs);
if(f_type == NULL)
{
ast_error(ast, "couldn't create a signature for '%s'", method_name);
return NULL;
}
size_t count = ast_childcount(positional) + 1;
size_t buf_size = count * sizeof(void*);
LLVMValueRef* args = (LLVMValueRef*)ponyint_pool_alloc_size(buf_size);
LLVMTypeRef* params = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetParamTypes(f_type, params);
ast_t* arg = ast_child(positional);
int i = 1;
while(arg != NULL)
{
LLVMValueRef value = make_arg(c, params[i], arg);
if(value == NULL)
{
ponyint_pool_free_size(buf_size, args);
ponyint_pool_free_size(buf_size, params);
return NULL;
}
args[i] = value;
arg = ast_sibling(arg);
i++;
}
// Generate the receiver. Must be done after the arguments because the args
// could change things in the receiver expression that must be accounted for.
if(call_needs_receiver(postfix, &g))
{
switch(ast_id(postfix))
{
case TK_NEWREF:
case TK_NEWBEREF:
{
ast_t* parent = ast_parent(ast);
ast_t* sibling = ast_sibling(ast);
// If we're constructing an embed field, pass a pointer to the field
// as the receiver. Otherwise, allocate an object.
if((ast_id(parent) == TK_ASSIGN) && (ast_id(sibling) == TK_EMBEDREF))
args[0] = gen_fieldptr(c, sibling);
else
args[0] = gencall_alloc(c, &g);
break;
}
case TK_BEREF:
case TK_FUNREF:
args[0] = gen_expr(c, receiver);
break;
default:
assert(0);
return NULL;
}
} else {
// Use a null for the receiver type.
args[0] = LLVMConstNull(g.use_type);
}
// Always emit location info for a call, to prevent inlining errors. This may
// be disabled in dispatch_function, if the target function has no debug
// info set.
ast_setdebug(ast, true);
dwarf_location(&c->dwarf, ast);
// Static or virtual dispatch.
LLVMValueRef func = dispatch_function(c, ast, &g, args[0], method_name,
typeargs);
LLVMValueRef r = NULL;
if(func != NULL)
{
// If we can error out and we have an invoke target, generate an invoke
// instead of a call.
if(ast_canerror(ast) && (c->frame->invoke_target != NULL))
r = invoke_fun(c, func, args, i, "", true);
else
r = codegen_call(c, func, args, i);
}
ponyint_pool_free_size(buf_size, args);
ponyint_pool_free_size(buf_size, params);
return r;
}
LLVMValueRef gen_call(compile_t* c, ast_t* ast)
{
// Special case calls.
LLVMValueRef special;
if(special_case_call(c, ast, &special))
return special;
AST_GET_CHILDREN(ast, postfix, positional, named, question);
AST_GET_CHILDREN(postfix, receiver, method);
ast_t* typeargs = NULL;
deferred_reification_t* reify = c->frame->reify;
// Dig through function qualification.
switch(ast_id(receiver))
{
case TK_NEWREF:
case TK_NEWBEREF:
case TK_BEREF:
case TK_FUNREF:
case TK_BECHAIN:
case TK_FUNCHAIN:
typeargs = deferred_reify(reify, method, c->opt);
AST_GET_CHILDREN_NO_DECL(receiver, receiver, method);
break;
default: {}
}
// Get the receiver type.
const char* method_name = ast_name(method);
ast_t* type = deferred_reify(reify, ast_type(receiver), c->opt);
reach_type_t* t = reach_type(c->reach, type);
pony_assert(t != NULL);
token_id cap = cap_dispatch(type);
reach_method_t* m = reach_method(t, cap, method_name, typeargs);
ast_free_unattached(type);
ast_free_unattached(typeargs);
// Generate the arguments.
size_t count = m->param_count + 1;
size_t buf_size = count * sizeof(void*);
LLVMValueRef* args = (LLVMValueRef*)ponyint_pool_alloc_size(buf_size);
ast_t* arg = ast_child(positional);
int i = 1;
while(arg != NULL)
{
LLVMValueRef value = gen_expr(c, arg);
if(value == NULL)
{
ponyint_pool_free_size(buf_size, args);
return NULL;
}
args[i] = value;
arg = ast_sibling(arg);
i++;
}
bool is_new_call = false;
// Generate the receiver. Must be done after the arguments because the args
// could change things in the receiver expression that must be accounted for.
if(call_needs_receiver(postfix, t))
{
switch(ast_id(postfix))
{
case TK_NEWREF:
case TK_NEWBEREF:
args[0] = gen_constructor_receiver(c, t, ast);
is_new_call = true;
break;
case TK_BEREF:
case TK_FUNREF:
case TK_BECHAIN:
case TK_FUNCHAIN:
args[0] = gen_expr(c, receiver);
break;
default:
pony_assert(0);
return NULL;
}
} else {
// Use a null for the receiver type.
args[0] = LLVMConstNull(((compile_type_t*)t->c_type)->use_type);
}
// Static or virtual dispatch.
LLVMValueRef func = dispatch_function(c, t, m, args[0]);
bool is_message = false;
if((ast_id(postfix) == TK_NEWBEREF) || (ast_id(postfix) == TK_BEREF) ||
(ast_id(postfix) == TK_BECHAIN))
{
switch(t->underlying)
{
case TK_ACTOR:
is_message = true;
break;
case TK_UNIONTYPE:
case TK_ISECTTYPE:
case TK_INTERFACE:
case TK_TRAIT:
if(m->cap == TK_TAG)
is_message = can_inline_message_send(t, m, method_name);
break;
default: {}
}
}
bool bare = m->cap == TK_AT;
LLVMValueRef r = NULL;
if(is_message)
{
// If we're sending a message, trace and send here instead of calling the
// sender to trace the most specific types possible.
codegen_debugloc(c, ast);
gen_send_message(c, m, args, positional);
codegen_debugloc(c, NULL);
switch(ast_id(postfix))
{
case TK_NEWREF:
case TK_NEWBEREF:
r = args[0];
break;
default:
r = c->none_instance;
break;
}
} else {
LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(func));
LLVMTypeRef* params = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetParamTypes(f_type, params + (bare ? 1 : 0));
arg = ast_child(positional);
i = 1;
while(arg != NULL)
{
ast_t* arg_type = deferred_reify(reify, ast_type(arg), c->opt);
args[i] = gen_assign_cast(c, params[i], args[i], arg_type);
ast_free_unattached(arg_type);
arg = ast_sibling(arg);
i++;
}
uintptr_t arg_offset = 0;
if(bare)
{
arg_offset = 1;
i--;
}
if(func != NULL)
{
// If we can error out and we have an invoke target, generate an invoke
// instead of a call.
codegen_debugloc(c, ast);
if(ast_canerror(ast) && (c->frame->invoke_target != NULL))
r = invoke_fun(c, func, args + arg_offset, i, "", !bare);
else
r = codegen_call(c, func, args + arg_offset, i, !bare);
if(is_new_call)
{
LLVMValueRef md = LLVMMDNodeInContext(c->context, NULL, 0);
LLVMSetMetadataStr(r, "pony.newcall", md);
}
codegen_debugloc(c, NULL);
ponyint_pool_free_size(buf_size, params);
}
}
// Bare methods with None return type return void, special case a None return
// value.
if(bare && is_none(m->result->ast))
r = c->none_instance;
// Class constructors return void, expression result is the receiver.
if(((ast_id(postfix) == TK_NEWREF) || (ast_id(postfix) == TK_NEWBEREF)) &&
(t->underlying == TK_CLASS))
r = args[0];
// Chained methods forward their receiver.
if((ast_id(postfix) == TK_BECHAIN) || (ast_id(postfix) == TK_FUNCHAIN))
r = args[0];
ponyint_pool_free_size(buf_size, args);
return r;
}
LLVMValueRef gen_ffi(compile_t* c, ast_t* ast)
{
AST_GET_CHILDREN(ast, id, typeargs, args);
// Get the function name, +1 to skip leading @
const char* f_name = ast_name(id) + 1;
// Generate the return type.
ast_t* type = ast_type(ast);
gentype_t g;
// Emit dwarf location of ffi call
dwarf_location(&c->dwarf, ast);
if(!gentype(c, type, &g))
return NULL;
// Get the function.
LLVMValueRef func = LLVMGetNamedFunction(c->module, f_name);
if(func == NULL)
{
// If we have no prototype, declare one.
if(!strncmp(f_name, "llvm.", 5))
{
// Intrinsic, so use the exact types we supply.
int count = (int)ast_childcount(args);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* f_params = (LLVMTypeRef*)pool_alloc_size(buf_size);
count = 0;
ast_t* arg = ast_child(args);
while(arg != NULL)
{
ast_t* p_type = ast_type(arg);
gentype_t param_g;
if(!gentype(c, p_type, ¶m_g))
return NULL;
f_params[count++] = param_g.use_type;
arg = ast_sibling(arg);
}
// We may have generated the function by generating a parameter type.
func = LLVMGetNamedFunction(c->module, f_name);
if(func == NULL)
{
LLVMTypeRef r_type;
if(g.underlying == TK_TUPLETYPE)
{
// Can't use the named type. Build an unnamed type with the same
// elements.
unsigned int count = LLVMCountStructElementTypes(g.use_type);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* e_types = (LLVMTypeRef*)pool_alloc_size(buf_size);
LLVMGetStructElementTypes(g.use_type, e_types);
r_type = LLVMStructTypeInContext(c->context, e_types, count, false);
pool_free_size(buf_size, e_types);
} else {
r_type = g.use_type;
}
LLVMTypeRef f_type = LLVMFunctionType(r_type, f_params, count,
false);
func = LLVMAddFunction(c->module, f_name, f_type);
if(!ast_canerror(ast))
LLVMAddFunctionAttr(func, LLVMNoUnwindAttribute);
}
pool_free_size(buf_size, f_params);
} else {
// Make it varargs.
LLVMTypeRef f_type = LLVMFunctionType(g.use_type, NULL, 0, true);
func = LLVMAddFunction(c->module, f_name, f_type);
if(!ast_canerror(ast))
LLVMAddFunctionAttr(func, LLVMNoUnwindAttribute);
}
}
// Generate the arguments.
int count = (int)ast_childcount(args);
size_t buf_size = count * sizeof(LLVMValueRef);
LLVMValueRef* f_args = (LLVMValueRef*)pool_alloc_size(buf_size);
ast_t* arg = ast_child(args);
for(int i = 0; i < count; i++)
{
f_args[i] = gen_expr(c, arg);
if(f_args[i] == NULL)
{
pool_free_size(buf_size, f_args);
return NULL;
}
arg = ast_sibling(arg);
}
// If we can error out and we have an invoke target, generate an invoke
// instead of a call.
LLVMValueRef result;
if(ast_canerror(ast) && (c->frame->invoke_target != NULL))
result = invoke_fun(c, func, f_args, count, "", false);
else
result = LLVMBuildCall(c->builder, func, f_args, count, "");
pool_free_size(buf_size, f_args);
// Special case a None return value, which is used for void functions.
if(is_none(type))
return g.instance;
return result;
}
static bool partial_application(pass_opt_t* opt, ast_t** astp)
{
ast_t* ast = *astp;
typecheck_t* t = &opt->check;
if(!method_application(opt, ast, true))
return false;
AST_GET_CHILDREN(ast, positional, namedargs, lhs);
// LHS must be a TK_TILDE, possibly contained in a TK_QUALIFY.
AST_GET_CHILDREN(lhs, receiver, method);
switch(ast_id(receiver))
{
case TK_NEWAPP:
case TK_BEAPP:
case TK_FUNAPP:
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(type, receiver, positional);
AST_GET_CHILDREN(type, cap, typeparams, params, result);
// Create a new anonymous type.
ast_t* c_id = ast_from_string(ast, package_hygienic_id(t));
BUILD(def, ast,
NODE(TK_CLASS, AST_SCOPE
TREE(c_id)
NONE
NONE
NONE
NODE(TK_MEMBERS)
NONE
NONE));
// We will have a create method in the type.
BUILD(create, ast,
NODE(TK_NEW, AST_SCOPE
NONE
ID("create")
NONE
NODE(TK_PARAMS)
NONE
NONE
NODE(TK_SEQ)
NONE));
// We will have an apply method in the type.
token_id can_error = ast_canerror(lhs) ? TK_QUESTION : TK_NONE;
BUILD(apply, ast,
NODE(TK_FUN, AST_SCOPE
NODE(apply_cap)
ID("apply")
NONE
NODE(TK_PARAMS)
TREE(result)
NODE(can_error)
NODE(TK_SEQ)
NONE));
// We will replace partial application with $0.create(...)
BUILD(call_receiver, ast, NODE(TK_REFERENCE, TREE(c_id)));
BUILD(call_dot, ast, NODE(TK_DOT, TREE(call_receiver) ID("create")));
BUILD(call, ast,
NODE(TK_CALL,
NONE
NODE(TK_NAMEDARGS)
TREE(call_dot)));
ast_t* class_members = ast_childidx(def, 4);
ast_t* create_params = ast_childidx(create, 3);
ast_t* create_body = ast_childidx(create, 6);
ast_t* apply_params = ast_childidx(apply, 3);
ast_t* apply_body = ast_childidx(apply, 6);
ast_t* call_namedargs = ast_childidx(call, 1);
// Add the receiver to the anonymous type.
ast_t* r_id = ast_from_string(receiver, package_hygienic_id(t));
ast_t* r_field_id = ast_from_string(receiver, package_hygienic_id(t));
ast_t* r_type = ast_type(receiver);
if(is_typecheck_error(r_type))
return false;
// A field in the type.
BUILD(r_field, receiver, NODE(TK_FLET, TREE(r_field_id) TREE(r_type) NONE));
// A parameter of the constructor.
BUILD(r_ctor_param, receiver, NODE(TK_PARAM, TREE(r_id) TREE(r_type) NONE));
// An assignment in the constructor body.
BUILD(r_assign, receiver,
NODE(TK_ASSIGN,
NODE(TK_CONSUME, NODE(TK_NONE) NODE(TK_REFERENCE, TREE(r_id)))
NODE(TK_REFERENCE, TREE(r_field_id))));
// A named argument at the call site.
BUILD(r_call_seq, receiver, NODE(TK_SEQ, TREE(receiver)));
BUILD(r_call_arg, receiver, NODE(TK_NAMEDARG, TREE(r_id) TREE(r_call_seq)));
ast_settype(r_call_seq, r_type);
ast_append(class_members, r_field);
ast_append(create_params, r_ctor_param);
ast_append(create_body, r_assign);
ast_append(call_namedargs, r_call_arg);
// Add a call to the original method to the apply body.
BUILD(apply_call, ast,
NODE(TK_CALL,
NODE(TK_POSITIONALARGS)
NONE
NODE(TK_DOT, NODE(TK_REFERENCE, TREE(r_field_id)) TREE(method))));
ast_append(apply_body, apply_call);
ast_t* apply_args = ast_child(apply_call);
// Add the arguments to the anonymous type.
ast_t* arg = ast_child(positional);
ast_t* param = ast_child(params);
while(arg != NULL)
{
AST_GET_CHILDREN(param, id, p_type);
if(ast_id(arg) == TK_NONE)
{
// A parameter of the apply method, using the same name, type and default
// argument.
ast_append(apply_params, param);
// An arg in the call to the original method.
BUILD(apply_arg, param,
NODE(TK_SEQ,
NODE(TK_CONSUME,
NODE(TK_NONE)
NODE(TK_REFERENCE, TREE(id)))));
ast_append(apply_args, apply_arg);
} else {
ast_t* p_id = ast_from_string(id, package_hygienic_id(t));
// A field in the type.
BUILD(field, arg, NODE(TK_FLET, TREE(id) TREE(p_type) NONE));
// A parameter of the constructor.
BUILD(ctor_param, arg, NODE(TK_PARAM, TREE(p_id) TREE(p_type) NONE));
// An assignment in the constructor body.
BUILD(assign, arg,
NODE(TK_ASSIGN,
NODE(TK_CONSUME, NODE(TK_NONE) NODE(TK_REFERENCE, TREE(p_id)))
NODE(TK_REFERENCE, TREE(id))));
// A named argument at the call site.
BUILD(call_arg, arg, NODE(TK_NAMEDARG, TREE(p_id) TREE(arg)));
// An arg in the call to the original method.
BUILD(apply_arg, arg, NODE(TK_SEQ, NODE(TK_REFERENCE, TREE(id))));
ast_append(class_members, field);
ast_append(create_params, ctor_param);
ast_append(create_body, assign);
ast_append(call_namedargs, call_arg);
ast_append(apply_args, apply_arg);
}
arg = ast_sibling(arg);
param = ast_sibling(param);
}
// Add create and apply to the anonymous type.
ast_append(class_members, create);
ast_append(class_members, apply);
// Typecheck the anonymous type.
ast_add(t->frame->module, def);
if(!type_passes(def, opt))
return false;
// Typecheck the create call.
if(!expr_reference(opt, &call_receiver))
return false;
if(!expr_dot(opt, &call_dot))
return false;
if(!expr_call(opt, &call))
return false;
// Replace the partial application with the create call.
ast_replace(astp, call);
return true;
}
