ast_result_t pass_flatten(ast_t** astp, pass_opt_t* options)
{
typecheck_t* t = &options->check;
ast_t* ast = *astp;
switch(ast_id(ast))
{
case TK_NEW:
{
switch(ast_id(t->frame->type))
{
case TK_CLASS:
return flatten_constructor(ast);
case TK_ACTOR:
return flatten_async(ast);
default: {}
}
break;
}
case TK_BE:
return flatten_async(ast);
case TK_UNIONTYPE:
if(!flatten_union(astp))
return AST_ERROR;
break;
case TK_ISECTTYPE:
if(!flatten_isect(astp))
return AST_ERROR;
break;
case TK_TUPLETYPE:
case TK_ARROW:
return flatten_noconstraint(t, ast);
case TK_TYPEPARAMREF:
return flatten_typeparamref(ast);
default: {}
}
return AST_OK;
}
bool expr_nominal(pass_opt_t* opt, ast_t** astp)
{
// Resolve typealiases and typeparam references.
if(!names_nominal(opt, *astp, astp))
return false;
ast_t* ast = *astp;
switch(ast_id(ast))
{
case TK_TYPEPARAMREF:
return flatten_typeparamref(ast) == AST_OK;
case TK_NOMINAL:
break;
default:
return true;
}
// If still nominal, check constraints.
ast_t* def = (ast_t*)ast_data(ast);
// Special case: don't check the constraint of a Pointer. This allows a
// Pointer[Pointer[A]], which is normally not allowed, as a Pointer[A] is
// not a subtype of Any.
ast_t* id = ast_child(def);
const char* name = ast_name(id);
if(!strcmp(name, "Pointer"))
return true;
ast_t* typeparams = ast_childidx(def, 1);
ast_t* typeargs = ast_childidx(ast, 2);
return check_constraints(typeargs, typeparams, typeargs, true);
}
bool expr_nominal(pass_opt_t* opt, ast_t** astp)
{
// Resolve type aliases and typeparam references.
if(!names_nominal(opt, *astp, astp, true))
return false;
ast_t* ast = *astp;
switch(ast_id(ast))
{
case TK_TYPEPARAMREF:
return flatten_typeparamref(ast) == AST_OK;
case TK_NOMINAL:
break;
default:
return true;
}
// If still nominal, check constraints.
ast_t* def = (ast_t*)ast_data(ast);
// Special case: don't check the constraint of a Pointer. This allows a
// Pointer[Pointer[A]], which is normally not allowed, as a Pointer[A] is
// not a subtype of Any.
ast_t* id = ast_child(def);
const char* name = ast_name(id);
if(!strcmp(name, "Pointer"))
return true;
ast_t* typeparams = ast_childidx(def, 1);
ast_t* typeargs = ast_childidx(ast, 2);
if(!reify_defaults(typeparams, typeargs, true))
return false;
if(!strcmp(name, "MaybePointer"))
{
// MaybePointer[A] must be bound to a struct.
assert(ast_childcount(typeargs) == 1);
ast_t* typeparam = ast_child(typeparams);
ast_t* typearg = ast_child(typeargs);
bool ok = false;
switch(ast_id(typearg))
{
case TK_NOMINAL:
{
ast_t* def = (ast_t*)ast_data(typearg);
ok = ast_id(def) == TK_STRUCT;
break;
}
case TK_TYPEPARAMREF:
{
ast_t* def = (ast_t*)ast_data(typearg);
ok = def == typeparam;
break;
}
default: {}
}
if(!ok)
{
ast_error(ast,
"%s is not allowed: the type argument to MaybePointer must be a struct",
ast_print_type(ast));
return false;
}
}
return check_constraints(typeargs, typeparams, typeargs, true);
}
bool expr_nominal(pass_opt_t* opt, ast_t** astp)
{
// Resolve type aliases and typeparam references.
if(!names_nominal(opt, *astp, astp, true))
return false;
ast_t* ast = *astp;
switch(ast_id(ast))
{
case TK_TYPEPARAMREF:
return flatten_typeparamref(opt, ast) == AST_OK;
case TK_NOMINAL:
break;
default:
return true;
}
// If still nominal, check constraints.
ast_t* def = (ast_t*)ast_data(ast);
// Special case: don't check the constraint of a Pointer or an Array. These
// builtin types have no contraint on their type parameter, and it is safe
// to bind a struct as a type argument (which is not safe on any user defined
// type, as that type might then be used for pattern matching).
if(is_pointer(ast) || is_literal(ast, "Array"))
return true;
ast_t* typeparams = ast_childidx(def, 1);
ast_t* typeargs = ast_childidx(ast, 2);
if(!reify_defaults(typeparams, typeargs, true, opt))
return false;
if(is_maybe(ast))
{
// MaybePointer[A] must be bound to a struct.
assert(ast_childcount(typeargs) == 1);
ast_t* typeparam = ast_child(typeparams);
ast_t* typearg = ast_child(typeargs);
bool ok = false;
switch(ast_id(typearg))
{
case TK_NOMINAL:
{
ast_t* def = (ast_t*)ast_data(typearg);
ok = ast_id(def) == TK_STRUCT;
break;
}
case TK_TYPEPARAMREF:
{
ast_t* def = (ast_t*)ast_data(typearg);
ok = def == typeparam;
break;
}
default: {}
}
if(!ok)
{
ast_error(opt->check.errors, ast,
"%s is not allowed: "
"the type argument to MaybePointer must be a struct",
ast_print_type(ast));
return false;
}
return true;
}
return check_constraints(typeargs, typeparams, typeargs, true, opt);
}
ast_result_t pass_flatten(ast_t** astp, pass_opt_t* options)
{
ast_t* ast = *astp;
switch(ast_id(ast))
{
case TK_UNIONTYPE:
return flatten_union(options, ast);
case TK_ISECTTYPE:
return flatten_isect(options, ast);
case TK_NEW:
{
switch(ast_id(options->check.frame->type))
{
case TK_CLASS:
return flatten_constructor(options, ast);
case TK_ACTOR:
return flatten_async(options, ast);
default: {}
}
break;
}
case TK_BE:
return flatten_async(options, ast);
case TK_ARROW:
return flatten_arrow(options, astp);
case TK_TYPEPARAMREF:
return flatten_typeparamref(options, ast);
case TK_EMBED:
{
// An embedded field must have a known, class type.
AST_GET_CHILDREN(ast, id, type, init);
bool ok = true;
if(ast_id(type) != TK_NOMINAL)
ok = false;
ast_t* def = (ast_t*)ast_data(type);
if(def == NULL)
{
ok = false;
} else {
switch(ast_id(def))
{
case TK_STRUCT:
case TK_CLASS:
break;
default:
ok = false;
break;
}
}
if(!ok)
{
ast_error(options->check.errors, type,
"embedded fields must be classes or structs");
return AST_ERROR;
}
if(cap_single(type) == TK_TAG)
{
ast_error(options->check.errors, type, "embedded fields cannot be tag");
return AST_ERROR;
}
return AST_OK;
}
case TK_ACTOR:
case TK_CLASS:
case TK_STRUCT:
case TK_PRIMITIVE:
case TK_TRAIT:
case TK_INTERFACE:
return flatten_provides_list(options, ast, 3);
default: {}
}
return AST_OK;
}