bool expr_lambda(pass_opt_t* opt, ast_t** astp)
{
assert(astp != NULL);
ast_t* ast = *astp;
assert(ast != NULL);
AST_GET_CHILDREN(ast, cap, t_params, params, captures, ret_type, raises,
body);
ast_t* members = ast_from(ast, TK_MEMBERS);
ast_t* last_member = NULL;
bool failed = false;
// Process captures
for(ast_t* p = ast_child(captures); p != NULL; p = ast_sibling(p))
{
ast_t* field = make_capture_field(p);
if(field != NULL)
ast_list_append(members, &last_member, field);
else // 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);
// Make the apply function
BUILD(apply, ast,
NODE(TK_FUN, AST_SCOPE
NONE // Capability
ID("apply")
TREE(t_params)
TREE(params)
TREE(ret_type)
TREE(raises)
TREE(body)
NONE)); // Doc string
ast_list_append(members, &last_member, apply);
// Replace lambda with object literal
REPLACE(astp,
NODE(TK_OBJECT,
TREE(cap);
NONE // Provides list
TREE(members)));
// Catch up passes
return ast_passes_subtree(astp, opt, PASS_EXPR);
}
// 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;
}
// Sanitise the given type (sub)AST, which has already been copied
static void sanitise(ast_t** astp)
{
assert(astp != NULL);
ast_t* type = *astp;
assert(type != NULL);
ast_clearflag(*astp, AST_FLAG_PASS_MASK);
if(ast_id(type) == TK_TYPEPARAMREF)
{
// We have a type param reference, convert to a nominal
ast_t* def = (ast_t*)ast_data(type);
assert(def != NULL);
const char* name = ast_name(ast_child(def));
assert(name != NULL);
REPLACE(astp,
NODE(TK_NOMINAL,
NONE // Package name
ID(name)
NONE // Type args
NONE // Capability
NONE)); // Ephemeral
return;
}
// Process all our children
for(ast_t* p = ast_child(type); p != NULL; p = ast_sibling(p))
sanitise(&p);
}
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;
}
// Set both the parent and scope for the given node
static void set_scope_and_parent(ast_t* ast, ast_t* parent)
{
assert(ast != NULL);
ast->parent = parent;
ast_clearflag(ast, AST_ORPHAN);
}
// 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_resetpass(ast_t* ast)
{
if(ast == NULL)
return;
ast_clearflag(ast, AST_FLAG_PASS_MASK);
ast_resetpass(ast->type);
for(ast_t* p = ast_child(ast); p != NULL; p = ast_sibling(p))
ast_resetpass(p);
}
bool expr_lambda(pass_opt_t* opt, ast_t** astp)
{
assert(astp != NULL);
ast_t* ast = *astp;
assert(ast != NULL);
AST_GET_CHILDREN(ast, cap, name, t_params, params, captures, ret_type,
raises, body);
ast_t* members = ast_from(ast, TK_MEMBERS);
ast_t* last_member = NULL;
bool failed = false;
// Process captures
for(ast_t* p = ast_child(captures); p != NULL; p = ast_sibling(p))
{
ast_t* field = make_capture_field(opt, p);
if(field != NULL)
ast_list_append(members, &last_member, field);
else // 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
TREE(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);
printbuf_t* buf = printbuf_new();
printbuf(buf, "lambda(");
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, " end");
// Replace lambda with object literal
REPLACE(astp,
NODE(TK_OBJECT, DATA(stringtab(buf->m))
NONE
NONE // Provides list
TREE(members)));
printbuf_free(buf);
// 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);
}
void ast_clearmightsend(ast_t* ast)
{
ast_clearflag(ast, AST_FLAG_MIGHT_SEND);
}
bool expr_object(pass_opt_t* opt, ast_t** astp)
{
ast_t* ast = *astp;
bool ok = true;
AST_GET_CHILDREN(ast, cap, provides, members);
ast_clearflag(cap, AST_FLAG_PRESERVE);
ast_clearflag(provides, AST_FLAG_PRESERVE);
ast_clearflag(members, AST_FLAG_PRESERVE);
ast_t* annotation = ast_consumeannotation(ast);
const char* c_id = package_hygienic_id(&opt->check);
ast_t* t_params;
ast_t* t_args;
collect_type_params(ast, &t_params, &t_args);
const char* nice_id = (const char*)ast_data(ast);
if(nice_id == NULL)
nice_id = "object literal";
// Create a new anonymous type.
BUILD(def, ast,
NODE(TK_CLASS, AST_SCOPE
ANNOTATE(annotation)
NICE_ID(c_id, nice_id)
TREE(t_params)
NONE
TREE(provides)
NODE(TK_MEMBERS)
NONE
NONE));
// We will have a create method in the type.
BUILD(create, members,
NODE(TK_NEW, AST_SCOPE
NONE
ID("create")
NONE
NODE(TK_PARAMS)
NONE
NONE
NODE(TK_SEQ,
NODE(TK_TRUE))
NONE
NONE));
BUILD(type_ref, ast, NODE(TK_REFERENCE, ID(c_id)));
if(ast_id(t_args) != TK_NONE)
{
// Need to add type args to our type reference
BUILD(t, ast, NODE(TK_QUALIFY, TREE(type_ref) TREE(t_args)));
type_ref = t;
}
ast_free_unattached(t_args);
// We will replace object..end with $0.create(...)
BUILD(call, ast,
NODE(TK_CALL,
NODE(TK_POSITIONALARGS)
NONE
NONE
NODE(TK_DOT,
TREE(type_ref)
ID("create"))));
ast_t* create_params = ast_childidx(create, 3);
ast_t* create_body = ast_childidx(create, 6);
ast_t* call_args = ast_child(call);
ast_t* class_members = ast_childidx(def, 4);
ast_t* member = ast_child(members);
bool has_fields = false;
bool has_behaviours = false;
while(member != NULL)
{
switch(ast_id(member))
{
case TK_FVAR:
case TK_FLET:
case TK_EMBED:
{
add_field_to_object(opt, member, class_members, create_params,
create_body, call_args);
has_fields = true;
break;
}
case TK_BE:
// If we have behaviours, we must be an actor.
ast_append(class_members, member);
has_behaviours = true;
break;
default:
// Keep all the methods as they are.
ast_append(class_members, member);
break;
}
member = ast_sibling(member);
}
// Add the create function at the end.
ast_append(class_members, create);
// Add new type to current module and bring it up to date with passes.
ast_t* module = ast_nearest(ast, TK_MODULE);
ast_append(module, def);
// Turn any free variables into fields.
ast_t* captures = ast_from(ast, TK_MEMBERS);
ast_t* last_capture = NULL;
if(!capture_from_type(opt, *astp, &def, captures, &last_capture))
ok = false;
for(ast_t* p = ast_child(captures); p != NULL; p = ast_sibling(p))
{
add_field_to_object(opt, p, class_members, create_params, create_body,
call_args);
has_fields = true;
}
ast_free_unattached(captures);
ast_resetpass(def, PASS_SUGAR);
// Handle capability and whether the anonymous type is a class, primitive or
// actor.
token_id cap_id = ast_id(cap);
if(has_behaviours)
{
// Change the type to an actor.
ast_setid(def, TK_ACTOR);
if(cap_id != TK_NONE && cap_id != TK_TAG)
{
ast_error(opt->check.errors, cap, "object literals with behaviours are "
"actors and so must have tag capability");
ok = false;
}
cap_id = TK_TAG;
}
else if(!has_fields && (cap_id == TK_NONE || cap_id == TK_TAG ||
cap_id == TK_BOX || cap_id == TK_VAL))
{
// Change the type from a class to a primitive.
ast_setid(def, TK_PRIMITIVE);
cap_id = TK_VAL;
}
if(ast_id(def) != TK_PRIMITIVE)
pony_assert(!ast_has_annotation(def, "ponyint_bare"));
// Reset constructor to pick up the correct defaults.
ast_setid(ast_child(create), cap_id);
ast_t* result = ast_childidx(create, 4);
ast_replace(&result,
type_for_class(opt, def, result, cap_id, TK_EPHEMERAL, false));
// Catch up provides before catching up the entire type.
if(!catch_up_provides(opt, provides))
return false;
// Type check the anonymous type.
if(!ast_passes_type(&def, opt, PASS_EXPR))
return false;
// Replace object..end with $0.create(...)
ast_replace(astp, call);
if(ast_visit(astp, pass_syntax, NULL, opt, PASS_SYNTAX) != AST_OK)
return false;
if(!ast_passes_subtree(astp, opt, PASS_EXPR))
return false;
return ok;
}
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);
}
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);
}