static void add_field_to_object(pass_opt_t* opt, ast_t* field,
ast_t* class_members, ast_t* create_params, ast_t* create_body,
ast_t* call_args)
{
AST_GET_CHILDREN(field, id, type, init);
ast_t* p_id = ast_from_string(id, package_hygienic_id(&opt->check));
// The param is: $0: type
BUILD(param, field,
NODE(TK_PARAM,
TREE(p_id)
TREE(type)
NONE));
// The arg is: $seq init
BUILD(arg, init,
NODE(TK_SEQ,
TREE(init)));
// The body of create contains: id = consume $0
BUILD(assign, init,
NODE(TK_ASSIGN,
NODE(TK_CONSUME, NODE(TK_NONE) NODE(TK_REFERENCE, TREE(p_id)))
NODE(TK_REFERENCE, TREE(id))));
// Remove the initialiser from the field
ast_replace(&init, ast_from(init, TK_NONE));
ast_add(class_members, field);
ast_append(create_params, param);
ast_append(create_body, assign);
ast_append(call_args, arg);
}
static ast_result_t sugar_ffi(ast_t* ast)
{
AST_GET_CHILDREN(ast, id, typeargs, args, named_args);
const char* name = ast_name(id);
size_t len = ast_name_len(id);
// Check for \0 in ffi name (it may be a string literal)
if(memchr(name, '\0', len) != NULL)
{
ast_error(ast, "FFI function names cannot include nul characters");
return AST_ERROR;
}
// Prefix '@' to the name
char* new_name = (char*)pool_alloc_size(len + 2);
new_name[0] = '@';
memcpy(new_name + 1, name, len);
new_name[len + 1] = '\0';
ast_t* new_id = ast_from_string(id, stringtab_consume(new_name, len + 2));
ast_replace(&id, new_id);
if(ast_id(ast) == TK_FFIDECL)
return check_params(args);
return AST_OK;
}
static bool insert_apply(pass_opt_t* opt, ast_t** astp)
{
// Sugar .apply()
ast_t* ast = *astp;
AST_GET_CHILDREN(ast, positional, namedargs, lhs);
ast_t* dot = ast_from(ast, TK_DOT);
ast_add(dot, ast_from_string(ast, "apply"));
ast_swap(lhs, dot);
ast_add(dot, lhs);
if(!expr_dot(opt, &dot))
return false;
return expr_call(opt, astp);
}
bool expr_qualify(pass_opt_t* opt, ast_t** astp)
{
// Left is a postfix expression, right is a typeargs.
ast_t* ast = *astp;
AST_GET_CHILDREN(ast, left, right);
ast_t* type = ast_type(left);
assert(ast_id(right) == TK_TYPEARGS);
if(is_typecheck_error(type))
return false;
switch(ast_id(left))
{
case TK_TYPEREF:
{
// Qualify the type.
assert(ast_id(type) == TK_NOMINAL);
// If the type isn't polymorphic or the type is already qualified,
// sugar .apply().
ast_t* def = names_def(opt, type);
ast_t* typeparams = ast_childidx(def, 1);
if((ast_id(typeparams) == TK_NONE) ||
(ast_id(ast_childidx(type, 2)) != TK_NONE))
{
if(!expr_nominal(opt, &type))
return false;
break;
}
type = ast_dup(type);
ast_t* typeargs = ast_childidx(type, 2);
ast_replace(&typeargs, right);
ast_settype(ast, type);
ast_setid(ast, TK_TYPEREF);
return expr_typeref(opt, astp);
}
case TK_NEWREF:
case TK_NEWBEREF:
case TK_BEREF:
case TK_FUNREF:
case TK_NEWAPP:
case TK_BEAPP:
case TK_FUNAPP:
{
// Qualify the function.
assert(ast_id(type) == TK_FUNTYPE);
ast_t* typeparams = ast_childidx(type, 1);
if(!reify_defaults(typeparams, right, true, opt))
return false;
if(!check_constraints(left, typeparams, right, true, opt))
return false;
type = reify(type, typeparams, right, opt);
typeparams = ast_childidx(type, 1);
ast_replace(&typeparams, ast_from(typeparams, TK_NONE));
ast_settype(ast, type);
ast_setid(ast, ast_id(left));
ast_inheritflags(ast);
return true;
}
default: {}
}
// Sugar .apply()
ast_t* dot = ast_from(left, TK_DOT);
ast_add(dot, ast_from_string(left, "apply"));
ast_swap(left, dot);
ast_add(dot, left);
if(!expr_dot(opt, &dot))
return false;
return expr_qualify(opt, astp);
}
static bool type_access(pass_opt_t* opt, ast_t** astp)
{
ast_t* ast = *astp;
// Left is a typeref, right is an id.
ast_t* left = ast_child(ast);
ast_t* right = ast_sibling(left);
ast_t* type = ast_type(left);
if(is_typecheck_error(type))
return false;
assert(ast_id(left) == TK_TYPEREF);
assert(ast_id(right) == TK_ID);
ast_t* find = lookup(opt, ast, type, ast_name(right));
if(find == NULL)
return false;
bool ret = true;
switch(ast_id(find))
{
case TK_TYPEPARAM:
ast_error(opt->check.errors, right,
"can't look up a typeparam on a type");
ret = false;
break;
case TK_NEW:
ret = method_access(opt, ast, find);
break;
case TK_FVAR:
case TK_FLET:
case TK_EMBED:
case TK_BE:
case TK_FUN:
{
// Make this a lookup on a default constructed object.
ast_free_unattached(find);
if(!strcmp(ast_name(right), "create"))
{
ast_error(opt->check.errors, right,
"create is not a constructor on this type");
return false;
}
ast_t* dot = ast_from(ast, TK_DOT);
ast_add(dot, ast_from_string(ast, "create"));
ast_swap(left, dot);
ast_add(dot, left);
ast_t* call = ast_from(ast, TK_CALL);
ast_swap(dot, call);
ast_add(call, dot); // the LHS goes at the end, not the beginning
ast_add(call, ast_from(ast, TK_NONE)); // named
ast_add(call, ast_from(ast, TK_NONE)); // positional
if(!expr_dot(opt, &dot))
return false;
if(!expr_call(opt, &call))
return false;
return expr_dot(opt, astp);
}
default:
assert(0);
ret = false;
break;
}
ast_free_unattached(find);
return ret;
}
ast_t* package_id(ast_t* ast)
{
return ast_from_string(ast, package_name(ast));
}
bool expr_typeref(pass_opt_t* opt, ast_t** astp)
{
ast_t* ast = *astp;
assert(ast_id(ast) == TK_TYPEREF);
ast_t* type = ast_type(ast);
if(is_typecheck_error(type))
return false;
switch(ast_id(ast_parent(ast)))
{
case TK_QUALIFY:
// Doesn't have to be valid yet.
break;
case TK_DOT:
// Has to be valid.
if(!expr_nominal(opt, &type))
{
ast_settype(ast, ast_from(type, TK_ERRORTYPE));
ast_free_unattached(type);
return false;
}
break;
case TK_CALL:
{
// Has to be valid.
if(!expr_nominal(opt, &type))
{
ast_settype(ast, ast_from(type, TK_ERRORTYPE));
ast_free_unattached(type);
return false;
}
// Transform to a default constructor.
ast_t* dot = ast_from(ast, TK_DOT);
ast_add(dot, ast_from_string(ast, "create"));
ast_swap(ast, dot);
*astp = dot;
ast_add(dot, ast);
if(!expr_dot(opt, astp))
{
ast_settype(ast, ast_from(type, TK_ERRORTYPE));
ast_free_unattached(type);
return false;
}
ast_t* ast = *astp;
// If the default constructor has no parameters, transform to an apply
// call.
if((ast_id(ast) == TK_NEWREF) || (ast_id(ast) == TK_NEWBEREF))
{
type = ast_type(ast);
if(is_typecheck_error(type))
return false;
assert(ast_id(type) == TK_FUNTYPE);
AST_GET_CHILDREN(type, cap, typeparams, params, result);
if(ast_id(params) == TK_NONE)
{
// Add a call node.
ast_t* call = ast_from(ast, TK_CALL);
ast_add(call, ast_from(call, TK_NONE)); // Named
ast_add(call, ast_from(call, TK_NONE)); // Positional
ast_swap(ast, call);
ast_append(call, ast);
if(!expr_call(opt, &call))
{
ast_settype(ast, ast_from(type, TK_ERRORTYPE));
ast_free_unattached(type);
return false;
}
// Add a dot node.
ast_t* apply = ast_from(call, TK_DOT);
ast_add(apply, ast_from_string(call, "apply"));
ast_swap(call, apply);
ast_add(apply, call);
if(!expr_dot(opt, &apply))
{
ast_settype(ast, ast_from(type, TK_ERRORTYPE));
ast_free_unattached(type);
return false;
}
}
}
return true;
}
default:
{
// Has to be valid.
if(!expr_nominal(opt, &type))
{
ast_settype(ast, ast_from(type, TK_ERRORTYPE));
ast_free_unattached(type);
return false;
}
// Transform to a default constructor.
ast_t* dot = ast_from(ast, TK_DOT);
ast_add(dot, ast_from_string(ast, "create"));
ast_swap(ast, dot);
ast_add(dot, ast);
// Call the default constructor with no arguments.
ast_t* call = ast_from(ast, TK_CALL);
ast_swap(dot, call);
ast_add(call, dot); // Receiver comes last.
ast_add(call, ast_from(ast, TK_NONE)); // Named args.
ast_add(call, ast_from(ast, TK_NONE)); // Positional args.
*astp = call;
if(!expr_dot(opt, &dot))
{
ast_settype(ast, ast_from(type, TK_ERRORTYPE));
ast_free_unattached(type);
return false;
}
if(!expr_call(opt, astp))
{
ast_settype(ast, ast_from(type, TK_ERRORTYPE));
ast_free_unattached(type);
return false;
}
break;
}
}
return true;
}
static ast_result_t sugar_object(pass_opt_t* opt, ast_t** astp)
{
typecheck_t* t = &opt->check;
ast_t* ast = *astp;
ast_result_t r = AST_OK;
AST_GET_CHILDREN(ast, cap, provides, members);
ast_t* c_id = ast_from_string(ast, package_hygienic_id(t));
ast_t* t_params;
ast_t* t_args;
collect_type_params(ast, &t_params, &t_args);
// Create a new anonymous type.
BUILD(def, ast,
NODE(TK_CLASS, AST_SCOPE
TREE(c_id)
TREE(t_params)
NONE
TREE(provides)
NODE(TK_MEMBERS)
NONE
NONE));
// We will have a create method in the type.
BUILD_NO_DEBUG(create, members,
NODE(TK_NEW, AST_SCOPE
NONE
ID("create")
NONE
NONE
NONE
NONE
NODE(TK_SEQ)
NONE
NONE));
BUILD(type_ref, ast, NODE(TK_REFERENCE, TREE(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,
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:
{
AST_GET_CHILDREN(member, id, type, init);
ast_t* p_id = ast_from_string(id, package_hygienic_id(t));
// The field is: var/let/embed id: type
BUILD(field, member,
NODE(ast_id(member),
TREE(id)
TREE(type)
NONE
NONE));
// The param is: $0: type
BUILD(param, member,
NODE(TK_PARAM,
TREE(p_id)
TREE(type)
NONE));
// The arg is: $seq init
BUILD(arg, init,
NODE(TK_SEQ,
TREE(init)));
// The body of create contains: id = consume $0
BUILD_NO_DEBUG(assign, init,
NODE(TK_ASSIGN,
NODE(TK_CONSUME, NODE(TK_NONE) NODE(TK_REFERENCE, TREE(p_id)))
NODE(TK_REFERENCE, TREE(id))));
ast_setid(create_params, TK_PARAMS);
ast_setid(call_args, TK_POSITIONALARGS);
ast_append(class_members, field);
ast_append(create_params, param);
ast_append(create_body, assign);
ast_append(call_args, arg);
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);
}
if(!has_fields)
{
// End the constructor with 'true', since it has no parameters.
BUILD_NO_DEBUG(true_node, ast, NODE(TK_TRUE));
ast_append(create_body, true_node);
}
// 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(cap, "object literals with behaviours are actors and so must "
"have tag capability");
r = AST_ERROR;
}
}
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);
}
else
{
// Type is a class, set the create capability as specified
ast_setid(ast_child(create), cap_id);
}
// Add the create function at the end.
ast_append(class_members, create);
// Replace object..end with $0.create(...)
ast_replace(astp, call);
// 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);
if(!ast_passes_type(&def, opt))
return AST_FATAL;
// Sugar the call.
if(!ast_passes_subtree(astp, opt, PASS_SUGAR))
return AST_FATAL;
return r;
}
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;
}
