static bool package_access(pass_opt_t* opt, ast_t** astp)
{
ast_t* ast = *astp;
// Left is a packageref, 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_PACKAGEREF);
assert(ast_id(right) == TK_ID);
// Must be a type in a package.
const char* package_name = ast_name(ast_child(left));
ast_t* package = ast_get(left, package_name, NULL);
if(package == NULL)
{
ast_error(right, "can't access package '%s'", package_name);
return false;
}
assert(ast_id(package) == TK_PACKAGE);
const char* type_name = ast_name(right);
type = ast_get(package, type_name, NULL);
if(type == NULL)
{
ast_error(right, "can't find type '%s' in package '%s'",
type_name, package_name);
return false;
}
ast_settype(ast, type_sugar(ast, package_name, type_name));
ast_setid(ast, TK_TYPEREF);
return expr_typeref(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);
}
bool expr_reference(pass_opt_t* opt, ast_t** astp)
{
typecheck_t* t = &opt->check;
ast_t* ast = *astp;
// Everything we reference must be in scope.
const char* name = ast_name(ast_child(ast));
sym_status_t status;
ast_t* def = ast_get(ast, name, &status);
if(def == NULL)
{
const char* alt_name = suggest_alt_name(ast, name);
if(alt_name == NULL)
ast_error(ast, "can't find declaration of '%s'", name);
else
ast_error(ast, "can't find declaration of '%s', did you mean '%s'?",
name, alt_name);
return false;
}
switch(ast_id(def))
{
case TK_PACKAGE:
{
// Only allowed if in a TK_DOT with a type.
if(ast_id(ast_parent(ast)) != TK_DOT)
{
ast_error(ast, "a package can only appear as a prefix to a type");
return false;
}
ast_setid(ast, TK_PACKAGEREF);
return true;
}
case TK_INTERFACE:
case TK_TRAIT:
case TK_TYPE:
case TK_TYPEPARAM:
case TK_PRIMITIVE:
case TK_STRUCT:
case TK_CLASS:
case TK_ACTOR:
{
// It's a type name. This may not be a valid type, since it may need
// type arguments.
ast_t* id = ast_child(def);
const char* name = ast_name(id);
ast_t* type = type_sugar(ast, NULL, name);
ast_settype(ast, type);
ast_setid(ast, TK_TYPEREF);
return expr_typeref(opt, astp);
}
case TK_FVAR:
case TK_FLET:
case TK_EMBED:
{
// Transform to "this.f".
if(!def_before_use(def, ast, name))
return false;
ast_t* dot = ast_from(ast, TK_DOT);
ast_add(dot, ast_child(ast));
ast_t* self = ast_from(ast, TK_THIS);
ast_add(dot, self);
ast_replace(astp, dot);
if(!expr_this(opt, self))
return false;
return expr_dot(opt, astp);
}
case TK_PARAM:
{
if(t->frame->def_arg != NULL)
{
ast_error(ast, "can't reference a parameter in a default argument");
return false;
}
if(!def_before_use(def, ast, name))
return false;
ast_t* type = ast_type(def);
if(is_typecheck_error(type))
return false;
if(!valid_reference(opt, ast, type, status))
return false;
if(!sendable(type) && (t->frame->recover != NULL))
{
ast_error(ast,
"can't access a non-sendable parameter from inside a recover "
"expression");
return false;
}
// Get the type of the parameter and attach it to our reference.
// Automatically consume a parameter if the function is done.
ast_t* r_type = type;
if(is_method_return(t, ast))
r_type = consume_type(type, TK_NONE);
ast_settype(ast, r_type);
ast_setid(ast, TK_PARAMREF);
return true;
}
case TK_NEW:
case TK_BE:
case TK_FUN:
{
// Transform to "this.f".
ast_t* dot = ast_from(ast, TK_DOT);
ast_add(dot, ast_child(ast));
ast_t* self = ast_from(ast, TK_THIS);
ast_add(dot, self);
ast_replace(astp, dot);
if(!expr_this(opt, self))
return false;
return expr_dot(opt, astp);
}
case TK_ID:
{
if(!def_before_use(def, ast, name))
return false;
ast_t* type = ast_type(def);
if(type != NULL && ast_id(type) == TK_INFERTYPE)
{
ast_error(ast, "cannot infer type of %s\n", ast_nice_name(def));
ast_settype(def, ast_from(def, TK_ERRORTYPE));
ast_settype(ast, ast_from(ast, TK_ERRORTYPE));
return false;
}
if(is_typecheck_error(type))
return false;
if(!valid_reference(opt, ast, type, status))
return false;
ast_t* var = ast_parent(def);
switch(ast_id(var))
{
case TK_VAR:
ast_setid(ast, TK_VARREF);
break;
case TK_LET:
case TK_MATCH_CAPTURE:
ast_setid(ast, TK_LETREF);
break;
default:
assert(0);
return false;
}
if(!sendable(type))
{
if(t->frame->recover != NULL)
{
ast_t* def_recover = ast_nearest(def, TK_RECOVER);
if(t->frame->recover != def_recover)
{
ast_error(ast, "can't access a non-sendable local defined outside "
"of a recover expression from within that recover expression");
return false;
}
}
}
// Get the type of the local and attach it to our reference.
// Automatically consume a local if the function is done.
ast_t* r_type = type;
if(is_method_return(t, ast))
r_type = consume_type(type, TK_NONE);
ast_settype(ast, r_type);
return true;
}
default: {}
}
assert(0);
return false;
}
bool expr_qualify(pass_opt_t* opt, ast_t** astp)
{
// Left is a postfix expression, right is a typeargs.
ast_t* ast = *astp;
ast_t* left = ast_child(ast);
ast_t* right = ast_sibling(left);
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(ast_id(ast_childidx(type, 2)) != TK_NONE)
{
ast_error(ast, "can't qualify an already qualified type");
return false;
}
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(!check_constraints(left, typeparams, right, true))
return false;
type = reify(left, type, typeparams, right);
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: {}
}
assert(0);
return false;
}
