// The subtype is a nominal, the super type is a typeparam.
static bool is_nominal_sub_typeparam(ast_t* sub, ast_t* super)
{
// Must be a subtype of the lower bounds of the constraint.
ast_t* def = (ast_t*)ast_data(super);
ast_t* constraint = ast_childidx(def, 1);
if(ast_id(constraint) == TK_NOMINAL)
{
ast_t* constraint_def = (ast_t*)ast_data(constraint);
switch(ast_id(constraint_def))
{
case TK_PRIMITIVE:
case TK_CLASS:
case TK_ACTOR:
{
// Constraint must be modified with super ephemerality.
AST_GET_CHILDREN(super, name, cap, eph);
ast_t* r_constraint = set_cap_and_ephemeral(constraint, TK_NONE,
ast_id(eph));
// Must be a subtype of the constraint.
bool ok = is_subtype(sub, constraint);
ast_free_unattached(r_constraint);
if(!ok)
return false;
// Capability must be a subtype of the lower bounds of the typeparam.
ast_t* lower = viewpoint_lower(super);
ok = is_sub_cap_and_ephemeral(sub, lower);
ast_free_unattached(lower);
return ok;
}
default: {}
}
}
return false;
}
static bool is_nominal_sub_trait(ast_t* sub, ast_t* super)
{
ast_t* sub_def = (ast_t*)ast_data(sub);
// Get our typeparams and typeargs.
ast_t* typeparams = ast_childidx(sub_def, 1);
ast_t* typeargs = ast_childidx(sub, 2);
// Check traits, depth first.
ast_t* traits = ast_childidx(sub_def, 3);
ast_t* trait = ast_child(traits);
while(trait != NULL)
{
// Reify the trait with our typeargs.
ast_t* r_trait = reify(typeargs, trait, typeparams, typeargs);
if(r_trait == NULL)
return false;
// Use the cap and ephemerality of the subtype.
AST_GET_CHILDREN(sub, pkg, name, typeparams, cap, eph);
ast_t* rr_trait = set_cap_and_ephemeral(r_trait, ast_id(cap), ast_id(eph));
if(rr_trait != r_trait)
{
ast_free_unattached(r_trait);
r_trait = rr_trait;
}
bool is_sub = is_subtype(r_trait, super);
ast_free_unattached(r_trait);
if(is_sub)
return true;
trait = ast_sibling(trait);
}
return false;
}
static ast_t* get_fun(ast_t* type, const char* name, ast_t* typeargs)
{
ast_t* this_type = set_cap_and_ephemeral(type, TK_REF, TK_NONE);
ast_t* fun = lookup(NULL, NULL, this_type, name);
ast_free_unattached(this_type);
assert(fun != NULL);
if(typeargs != NULL)
{
ast_t* typeparams = ast_childidx(fun, 2);
ast_t* r_fun = reify(fun, typeparams, typeargs);
ast_free_unattached(fun);
fun = r_fun;
assert(fun != NULL);
}
// No signature for any function with a tuple argument or return value, or
// any function that might raise an error.
AST_GET_CHILDREN(fun, cap, id, typeparams, params, result, can_error);
if(ast_id(can_error) == TK_QUESTION)
return NULL;
if(ast_id(result) == TK_TUPLETYPE)
return NULL;
ast_t* param = ast_child(params);
while(param != NULL)
{
AST_GET_CHILDREN(param, p_id, p_type);
if(ast_id(p_type) == TK_TUPLETYPE)
return NULL;
param = ast_sibling(param);
}
return fun;
}
static matchtype_t is_entity_match_trait(ast_t* operand, ast_t* pattern)
{
AST_GET_CHILDREN(operand, o_pkg, o_id, o_typeargs, o_cap, o_eph);
AST_GET_CHILDREN(pattern, p_pkg, p_id, p_typeargs, p_cap, p_eph);
token_id tcap = ast_id(p_cap);
token_id teph = ast_id(p_eph);
ast_t* r_operand = set_cap_and_ephemeral(operand, tcap, teph);
bool provides = is_subtype(r_operand, pattern, false);
ast_free_unattached(r_operand);
// If the operand doesn't provide the pattern (trait or interface), reject
// the match.
if(!provides)
return MATCHTYPE_REJECT;
// If the operand does provide the pattern, but the operand refcap can't
// match the pattern refcap, deny the match.
if(!is_cap_match_cap(ast_id(o_cap), ast_id(o_eph), tcap, teph))
return MATCHTYPE_DENY;
// Otherwise, accept the match.
return MATCHTYPE_ACCEPT;
}
static bool gen_field_init(compile_t* c, gentype_t* g)
{
LLVMValueRef this_ptr = LLVMGetParam(codegen_fun(c), 0);
ast_t* def = (ast_t*)ast_data(g->ast);
ast_t* members = ast_childidx(def, 4);
ast_t* member = ast_child(members);
// Struct index of the current field.
int index = 1;
if(ast_id(def) == TK_ACTOR)
index++;
// Iterate through all fields.
while(member != NULL)
{
switch(ast_id(member))
{
case TK_FVAR:
case TK_FLET:
{
// Skip this field if it has no initialiser.
AST_GET_CHILDREN(member, id, type, body);
if(ast_id(body) != TK_NONE)
{
// Reify the initialiser.
ast_t* this_type = set_cap_and_ephemeral(g->ast, TK_REF, TK_NONE);
ast_t* var = lookup(NULL, NULL, this_type, ast_name(id));
ast_free_unattached(this_type);
assert(var != NULL);
body = ast_childidx(var, 2);
// Get the field pointer.
dwarf_location(&c->dwarf, body);
LLVMValueRef l_value = LLVMBuildStructGEP(c->builder, this_ptr,
index, "");
// Cast the initialiser to the field type.
LLVMValueRef r_value = gen_expr(c, body);
if(r_value == NULL)
return false;
LLVMTypeRef l_type = LLVMGetElementType(LLVMTypeOf(l_value));
LLVMValueRef cast_value = gen_assign_cast(c, l_type, r_value,
ast_type(body));
if(cast_value == NULL)
return false;
// Store the result.
LLVMBuildStore(c->builder, cast_value, l_value);
}
index++;
break;
}
default: {}
}
member = ast_sibling(member);
}
return true;
}
bool expr_this(pass_opt_t* opt, ast_t* ast)
{
typecheck_t* t = &opt->check;
if(t->frame->def_arg != NULL)
{
ast_error(opt->check.errors, ast,
"can't reference 'this' in a default argument");
return false;
}
sym_status_t status;
ast_get(ast, stringtab("this"), &status);
if(status == SYM_CONSUMED)
{
ast_error(opt->check.errors, ast,
"can't use a consumed 'this' in an expression");
return false;
}
assert(status == SYM_NONE);
token_id cap = cap_for_this(t);
if(!cap_sendable(cap) && (t->frame->recover != NULL))
{
ast_t* parent = ast_parent(ast);
if(ast_id(parent) != TK_DOT)
cap = TK_TAG;
}
bool make_arrow = false;
if(cap == TK_BOX)
{
cap = TK_REF;
make_arrow = true;
}
ast_t* type = type_for_this(opt, ast, cap, TK_NONE, false);
if(make_arrow)
{
BUILD(arrow, ast, NODE(TK_ARROW, NODE(TK_THISTYPE) TREE(type)));
type = arrow;
}
// Get the nominal type, which may be the right side of an arrow type.
ast_t* nominal;
bool arrow;
if(ast_id(type) == TK_NOMINAL)
{
nominal = type;
arrow = false;
} else {
nominal = ast_childidx(type, 1);
arrow = true;
}
ast_t* typeargs = ast_childidx(nominal, 2);
ast_t* typearg = ast_child(typeargs);
while(typearg != NULL)
{
if(!expr_nominal(opt, &typearg))
{
ast_error(opt->check.errors, ast, "couldn't create a type for 'this'");
ast_free(type);
return false;
}
typearg = ast_sibling(typearg);
}
if(!expr_nominal(opt, &nominal))
{
ast_error(opt->check.errors, ast, "couldn't create a type for 'this'");
ast_free(type);
return false;
}
// Unless this is a field lookup, treat an incomplete `this` as a tag.
ast_t* parent = ast_parent(ast);
bool incomplete_ok = false;
if((ast_id(parent) == TK_DOT) && (ast_child(parent) == ast))
{
ast_t* right = ast_sibling(ast);
assert(ast_id(right) == TK_ID);
ast_t* find = lookup_try(opt, ast, nominal, ast_name(right));
if(find != NULL)
{
switch(ast_id(find))
{
case TK_FVAR:
case TK_FLET:
case TK_EMBED:
incomplete_ok = true;
break;
default: {}
}
}
}
if(!incomplete_ok && is_this_incomplete(t, ast))
{
ast_t* tag_type = set_cap_and_ephemeral(nominal, TK_TAG, TK_NONE);
ast_replace(&nominal, tag_type);
}
if(arrow)
type = ast_parent(nominal);
else
type = nominal;
ast_settype(ast, type);
return true;
}
static bool check_receiver_cap(pass_opt_t* opt, ast_t* ast, bool incomplete)
{
AST_GET_CHILDREN(ast, positional, namedargs, lhs);
ast_t* type = ast_type(lhs);
if(is_typecheck_error(type))
return false;
AST_GET_CHILDREN(type, cap, typeparams, params, result);
// Check receiver cap.
ast_t* receiver = ast_child(lhs);
// Dig through function qualification.
if(ast_id(receiver) == TK_FUNREF || ast_id(receiver) == TK_FUNAPP)
receiver = ast_child(receiver);
// Receiver type, alias of receiver type, and target type.
ast_t* r_type = ast_type(receiver);
if(is_typecheck_error(r_type))
return false;
ast_t* t_type = set_cap_and_ephemeral(r_type, ast_id(cap), TK_NONE);
ast_t* a_type;
// If we can recover the receiver, we don't alias it here.
bool can_recover = auto_recover_call(ast, r_type, positional, result);
bool cap_recover = false;
switch(ast_id(cap))
{
case TK_ISO:
case TK_TRN:
case TK_VAL:
case TK_TAG:
break;
case TK_REF:
case TK_BOX:
cap_recover = true;
break;
default:
assert(0);
}
if(can_recover && cap_recover)
a_type = r_type;
else
a_type = alias(r_type);
if(incomplete && (ast_id(receiver) == TK_THIS))
{
// If 'this' is incomplete and the arg is 'this', change the type to tag.
ast_t* tag_type = set_cap_and_ephemeral(a_type, TK_TAG, TK_NONE);
if(a_type != r_type)
ast_free_unattached(a_type);
a_type = tag_type;
} else {
incomplete = false;
}
errorframe_t info = NULL;
bool ok = is_subtype(a_type, t_type, &info, opt);
if(!ok)
{
errorframe_t frame = NULL;
ast_error_frame(&frame, ast,
"receiver type is not a subtype of target type");
ast_error_frame(&frame, receiver,
"receiver type: %s", ast_print_type(a_type));
ast_error_frame(&frame, cap,
"target type: %s", ast_print_type(t_type));
if(!can_recover && cap_recover && is_subtype(r_type, t_type, NULL, opt))
{
ast_error_frame(&frame, ast,
"this would be possible if the arguments and return value "
"were all sendable");
}
if(incomplete && is_subtype(r_type, t_type, NULL, opt))
{
ast_error_frame(&frame, ast,
"this would be possible if all the fields of 'this' were assigned to "
"at this point");
}
errorframe_append(&frame, &info);
errorframe_report(&frame, opt->check.errors);
}
if(a_type != r_type)
ast_free_unattached(a_type);
ast_free_unattached(r_type);
ast_free_unattached(t_type);
return ok;
}
static bool check_arg_types(pass_opt_t* opt, ast_t* params, ast_t* positional,
bool incomplete, bool partial)
{
// Check positional args vs params.
ast_t* param = ast_child(params);
ast_t* arg = ast_child(positional);
while(arg != NULL)
{
if(ast_id(arg) == TK_NONE)
{
if(partial)
{
// Don't check missing arguments for partial application.
arg = ast_sibling(arg);
param = ast_sibling(param);
continue;
} else {
// Pick up a default argument if we can.
if(!apply_default_arg(opt, param, arg))
return false;
}
}
ast_t* p_type = ast_childidx(param, 1);
if(!coerce_literals(&arg, p_type, opt))
return false;
ast_t* arg_type = ast_type(arg);
if(is_typecheck_error(arg_type))
return false;
if(is_control_type(arg_type))
{
ast_error(opt->check.errors, arg,
"can't use a control expression in an argument");
return false;
}
ast_t* a_type = alias(arg_type);
if(incomplete)
{
ast_t* expr = arg;
if(ast_id(arg) == TK_SEQ)
expr = ast_child(arg);
// If 'this' is incomplete and the arg is 'this', change the type to tag.
if((ast_id(expr) == TK_THIS) && (ast_sibling(expr) == NULL))
{
ast_t* tag_type = set_cap_and_ephemeral(a_type, TK_TAG, TK_NONE);
ast_free_unattached(a_type);
a_type = tag_type;
}
}
errorframe_t info = NULL;
if(!is_subtype(a_type, p_type, &info, opt))
{
errorframe_t frame = NULL;
ast_error_frame(&frame, arg, "argument not a subtype of parameter");
errorframe_append(&frame, &info);
errorframe_report(&frame, opt->check.errors);
ast_free_unattached(a_type);
return false;
}
ast_free_unattached(a_type);
arg = ast_sibling(arg);
param = ast_sibling(param);
}
return true;
}
static bool check_receiver_cap(pass_opt_t* opt, ast_t* ast, bool* recovered)
{
AST_GET_CHILDREN(ast, positional, namedargs, question, lhs);
ast_t* type = ast_type(lhs);
if(is_typecheck_error(type))
return false;
AST_GET_CHILDREN(type, cap, typeparams, params, result);
// Receiver type, alias of receiver type, and target type.
ast_t* r_type = method_receiver_type(lhs);
if(is_typecheck_error(r_type))
return false;
ast_t* t_type = set_cap_and_ephemeral(r_type, ast_id(cap), TK_NONE);
ast_t* a_type;
// If we can recover the receiver, we don't alias it here.
bool can_recover = auto_recover_call(lhs, r_type, positional, result);
bool cap_recover = false;
switch(ast_id(cap))
{
case TK_ISO:
case TK_TRN:
case TK_VAL:
case TK_TAG:
break;
case TK_REF:
case TK_BOX:
cap_recover = true;
break;
default:
pony_assert(0);
}
if(can_recover && cap_recover)
{
a_type = r_type;
if(recovered != NULL)
*recovered = true;
}
else
{
a_type = alias(r_type);
if(recovered != NULL)
*recovered = false;
}
errorframe_t info = NULL;
bool ok = is_subtype(a_type, t_type, &info, opt);
if(!ok)
{
errorframe_t frame = NULL;
ast_error_frame(&frame, ast,
"receiver type is not a subtype of target type");
ast_error_frame(&frame, ast_child(lhs),
"receiver type: %s", ast_print_type(a_type));
ast_error_frame(&frame, cap,
"target type: %s", ast_print_type(t_type));
errorframe_append(&frame, &info);
if(ast_checkflag(ast_type(method_receiver(lhs)), AST_FLAG_INCOMPLETE))
ast_error_frame(&frame, method_receiver(lhs),
"this might be possible if all fields were already defined");
if(!can_recover && cap_recover && is_subtype(r_type, t_type, NULL, opt))
{
ast_error_frame(&frame, ast,
"this would be possible if the arguments and return value "
"were all sendable");
}
errorframe_report(&frame, opt->check.errors);
}
if(a_type != r_type)
ast_free_unattached(a_type);
ast_free_unattached(r_type);
ast_free_unattached(t_type);
return ok;
}
static matchtype_t could_subtype_or_deny(ast_t* sub, ast_t* super)
{
// At this point, sub must be a subtype of super.
if(is_subtype(sub, super))
return MATCHTYPE_ACCEPT;
// If sub would be a subtype of super if it had super's capability and
// ephemerality, we deny other matches.
token_id cap, eph;
switch(ast_id(super))
{
case TK_NOMINAL:
{
AST_GET_CHILDREN(super, sup_pkg, sup_id, sup_typeargs, sup_cap, sup_eph);
cap = ast_id(sup_cap);
eph = ast_id(sup_eph);
break;
}
case TK_TYPEPARAMREF:
{
AST_GET_CHILDREN(super, sup_id, sup_cap, sup_eph);
cap = ast_id(sup_cap);
eph = ast_id(sup_eph);
break;
}
default:
assert(0);
return MATCHTYPE_DENY;
}
ast_t* sub_def = (ast_t*)ast_data(sub);
ast_t* super_def = (ast_t*)ast_data(super);
ast_t* r_type = set_cap_and_ephemeral(sub, cap, eph);
matchtype_t ok = MATCHTYPE_REJECT;
if(is_subtype(r_type, super))
{
// Sub would be a subtype of super if their capabilities were the same.
// Deny any match, since this would break capabilities.
ok = MATCHTYPE_DENY;
} else if(sub_def != super_def) {
// Sub and super are unrelated types and sub is not a subtype of super.
ok = MATCHTYPE_REJECT;
} else if((sub_def == super_def) && is_sub_cap_and_ephemeral(sub, super)) {
// Sub and super are the same base type, but have different type args.
// Only accept if sub's type args are typeparamrefs and they could be a
// subtype of super's type args.
assert(ast_id(sub) == TK_NOMINAL);
assert(ast_id(super) == TK_NOMINAL);
AST_GET_CHILDREN(sub, sub_pkg, sub_id, sub_typeargs);
AST_GET_CHILDREN(super, sup_pkg, sup_id, sup_typeargs);
ast_t* sub_typearg = ast_child(sub_typeargs);
ast_t* sup_typearg = ast_child(sup_typeargs);
ok = MATCHTYPE_ACCEPT;
while(sub_typearg != NULL)
{
if(!could_subtype_typearg(sub_typearg, sup_typearg))
{
ok = MATCHTYPE_REJECT;
break;
}
sub_typearg = ast_sibling(sub_typearg);
sup_typearg = ast_sibling(sup_typearg);
}
}
ast_free_unattached(r_type);
return ok;
}
ast_t* viewpoint_lower(ast_t* type)
{
// T = N | A
// s = {k}
// upper(s p'->T k p) = union[k' in s](T (k'->k) eph(s, p', p))
// eph(s, p', p) = { unalias(p) if p' = ^, exists k in s . k in {iso, trn}
// { p otherwise
assert(ast_id(type) == TK_ARROW);
AST_GET_CHILDREN(type, left, right);
ast_t* r_right = right;
switch(ast_id(right))
{
case TK_NOMINAL:
case TK_TYPEPARAMREF:
break;
case TK_ARROW:
// Arrow types are right associative.
r_right = viewpoint_lower(right);
if(r_right == NULL)
return NULL;
break;
default:
assert(0);
return NULL;
}
token_id l_cap = TK_NONE;
token_id l_eph = TK_NONE;
switch(ast_id(left))
{
case TK_ISO:
case TK_TRN:
case TK_REF:
case TK_VAL:
case TK_BOX:
case TK_TAG:
l_cap = ast_id(left);
break;
case TK_THISTYPE:
l_cap = TK_CAP_READ;
break;
case TK_NOMINAL:
case TK_TYPEPARAMREF:
{
ast_t* left_cap = cap_fetch(left);
ast_t* left_eph = ast_sibling(left_cap);
l_cap = ast_id(left_cap);
l_eph = ast_id(left_eph);
break;
}
default:
assert(0);
return NULL;
}
ast_t* right_cap = cap_fetch(r_right);
ast_t* right_eph = ast_sibling(right_cap);
token_id r_cap = ast_id(right_cap);
token_id r_eph = ast_id(right_eph);
// No result: left side could be a tag.
if(!cap_view_lower(l_cap, l_eph, &r_cap, &r_eph))
return NULL;
ast_t* rr_right = set_cap_and_ephemeral(r_right, r_cap, r_eph);
if(r_right != right)
ast_free_unattached(r_right);
return rr_right;
}
static bool is_valid_pattern(pass_opt_t* opt, ast_t* pattern)
{
if(ast_id(pattern) == TK_NONE)
{
ast_settype(pattern, ast_from(pattern, TK_DONTCARE));
return true;
}
ast_t* pattern_type = ast_type(pattern);
if(is_control_type(pattern_type))
{
ast_error(opt->check.errors, pattern, "not a matchable pattern");
return false;
}
switch(ast_id(pattern))
{
case TK_MATCH_CAPTURE:
// Captures are always OK.
return true;
case TK_TUPLE:
{
ast_t* pattern_child = ast_child(pattern);
// Treat a one element tuple as a normal expression.
if(ast_sibling(pattern_child) == NULL)
{
bool ok = is_valid_pattern(opt, pattern_child);
ast_settype(pattern, ast_type(pattern_child));
return ok;
}
// Check every element pairwise.
ast_t* pattern_type = ast_from(pattern, TK_TUPLETYPE);
bool ok = true;
while(pattern_child != NULL)
{
if(!is_valid_pattern(opt, pattern_child))
ok = false;
ast_append(pattern_type, ast_type(pattern_child));
pattern_child = ast_sibling(pattern_child);
}
ast_settype(pattern, pattern_type);
return ok;
}
case TK_SEQ:
if(ast_childcount(pattern) == 1) // This may be a just a capture.
return is_valid_pattern(opt, ast_child(pattern));
// Treat this like other nodes.
break;
case TK_DONTCARE:
// It's always ok not to care.
return true;
default:
break;
}
// Structural equality, pattern.eq(match).
ast_t* fun = lookup(opt, pattern, pattern_type, stringtab("eq"));
if(fun == NULL)
{
ast_error(opt->check.errors, pattern,
"this pattern element doesn't support structural equality");
return false;
}
if(ast_id(fun) != TK_FUN)
{
ast_error(opt->check.errors, pattern,
"eq is not a function on this pattern element");
ast_error_continue(opt->check.errors, fun,
"definition of eq is here");
ast_free_unattached(fun);
return false;
}
AST_GET_CHILDREN(fun, cap, id, typeparams, params, result, partial);
bool ok = true;
if(ast_id(typeparams) != TK_NONE)
{
ast_error(opt->check.errors, pattern,
"polymorphic eq not supported in pattern matching");
ok = false;
}
if(!is_bool(result))
{
ast_error(opt->check.errors, pattern,
"eq must return Bool when pattern matching");
ok = false;
}
if(ast_id(partial) != TK_NONE)
{
ast_error(opt->check.errors, pattern,
"eq cannot be partial when pattern matching");
ok = false;
}
ast_t* r_type = set_cap_and_ephemeral(pattern_type, ast_id(cap), TK_NONE);
ast_t* a_type = alias(pattern_type);
errorframe_t info = NULL;
if(!is_subtype(a_type, r_type, &info, opt))
{
errorframe_t frame = NULL;
ast_error_frame(&frame, pattern, "eq cannot be called on this pattern");
errorframe_append(&frame, &info);
errorframe_report(&frame, opt->check.errors);
ok = false;
}
ast_t* param = ast_child(params);
if(param == NULL || ast_sibling(param) != NULL)
{
ast_error(opt->check.errors, pattern,
"eq must take a single argument when pattern matching");
ok = false;
} else {
AST_GET_CHILDREN(param, param_id, param_type);
ast_settype(pattern, param_type);
}
ast_free_unattached(r_type);
ast_free_unattached(a_type);
ast_free_unattached(fun);
return ok;
}