shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 20:11:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Function referencing in @return? for simplified fault declarations. Check @return? eagerly #2340.

Browse Source
This commit is contained in:
Christoffer Lerno
2025-11-03 23:49:35 +01:00
parent d43d7100af
commit 4a25bcc5ee
10 changed files with 200 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/compiler/compiler_internal.h
View File

@@ -600,6 +600,12 @@ typedef struct
};
} FuncDecl;
typedef struct
{
Signature signature;
AstId docs;
} FnTypeDecl;
typedef struct
{
@@ -740,7 +746,7 @@ typedef struct Decl_
EnumConstantDecl enum_constant;
ExecDecl exec_decl;
Expr* expand_decl;
Signature fntype_decl;
FnTypeDecl fntype_decl;
FuncDecl func_decl;
ImportDecl import;
IncludeDecl include;
@@ -1527,6 +1533,7 @@ typedef struct
typedef struct
{
bool resolved;
bool expanding;
union
{
Expr *expr;
@@ -2296,6 +2303,7 @@ bool may_cast(SemaContext *context, Expr *expr, Type *to_type, bool is_explicit,
void cast_no_check(Expr *expr, Type *to_type, bool add_optional);
bool cast_to_index_len(SemaContext *context, Expr *index, bool is_len);
const char *llvm_codegen(void *context);

5
src/compiler/copying.c
View File

@@ -686,7 +686,7 @@ RETRY:
case AST_CONTRACT_FAULT:
if (ast->contract_fault.resolved)
{
MACRO_COPY_DECL(ast->contract_fault.decl);
fixup_decl(c, &ast->contract_fault.decl);
}
else
{
@@ -1097,7 +1097,8 @@ Decl *copy_decl(CopyStruct *c, Decl *decl)
MACRO_COPY_DECL_LIST(copy->enums.values);
break;
case DECL_FNTYPE:
copy_signature_deep(c, &copy->fntype_decl);
copy_signature_deep(c, &copy->fntype_decl.signature);
MACRO_COPY_ASTID(copy->fntype_decl.docs);
break;
case DECL_FUNC:
copy_decl_type(copy);

27
src/compiler/parse_global.c
View File

@@ -2181,13 +2181,15 @@ static inline void decl_add_type(Decl *decl, TypeKind kind)
type->decl = decl;
decl->type = type;
}
/**
* typedef_declaration ::= ALIAS TYPE_IDENT attributes? '=' typedef_type ';'
*
* typedef_type ::= func_typedef | type generic_params?
* func_typedef ::= 'fn' optional_type parameter_type_list
*/
static inline Decl *parse_alias_type(ParseContext *c)
static inline Decl *parse_alias_type(ParseContext *c, AstId contracts, bool has_real_contracts)
{
advance_and_verify(c, TOKEN_ALIAS);
@@ -2198,7 +2200,7 @@ static inline Decl *parse_alias_type(ParseContext *c)
if (token_is_any_type(c->tok))
{
PRINT_ERROR_HERE("'%s' is the name of a built-in type and can't be used as an alias.",
token_type_to_string(c->tok));
token_type_to_string(c->tok));
return poisoned_decl;
}
if (token_is_some_ident(c->tok))
@@ -2223,8 +2225,9 @@ static inline Decl *parse_alias_type(ParseContext *c)
Decl *decl_type = decl_new(DECL_FNTYPE, decl->name, c->prev_span);
decl->type_alias_decl.decl = decl_type;
ASSIGN_TYPE_OR_RET(TypeInfo *type_info, parse_optional_type(c), poisoned_decl);
decl_type->fntype_decl.rtype = type_infoid(type_info);
if (!parse_fn_parameter_list(c, &(decl_type->fntype_decl)))
decl_type->fntype_decl.signature.rtype = type_infoid(type_info);
decl_type->fntype_decl.docs = contracts;
if (!parse_fn_parameter_list(c, &(decl_type->fntype_decl.signature)))
{
return poisoned_decl;
}
@@ -2235,6 +2238,11 @@ static inline Decl *parse_alias_type(ParseContext *c)
return decl;
}
if (has_real_contracts)
{
RETURN_PRINT_ERROR_AT(poisoned_decl, astptr(contracts), "Contracts are only used for modules, functions and macros.");
}
// 2. Now parse the type which we know is here.
ASSIGN_EXPR_OR_RET(Expr *expr, parse_expr(c), poisoned_decl);
@@ -2413,13 +2421,17 @@ static inline Decl *parse_attrdef(ParseContext *c)
/**
* define_decl ::= ALIAS define_type_body
*/
static inline Decl *parse_alias(ParseContext *c)
static inline Decl *parse_alias(ParseContext *c, AstId contracts, bool has_real_contracts)
{
switch (peek(c))
{
case TOKEN_TYPE_IDENT:
return parse_alias_type(c);
return parse_alias_type(c, contracts, has_real_contracts);
default:
if (has_real_contracts)
{
RETURN_PRINT_ERROR_AT(poisoned_decl, astptr(contracts), "Contracts are only used for modules, functions and macros.");
}
return parse_alias_ident(c);
}
}
@@ -3335,8 +3347,7 @@ Decl *parse_top_level_statement(ParseContext *c, ParseContext **context_out)
PRINT_ERROR_HERE("There are more than one doc comment in a row, that is not allowed.");
return poisoned_decl;
case TOKEN_ALIAS:
if (has_real_contracts) goto CONTRACT_NOT_ALLOWED;
decl = parse_alias(c);
decl = parse_alias(c, contracts, has_real_contracts);
if (decl->decl_kind == DECL_ALIAS_PATH)
{
if (!context_out)

87
src/compiler/sema_decls.c
View File

@@ -1492,8 +1492,12 @@ static inline bool sema_analyse_fntype(SemaContext *context, Decl *decl, bool *e
{
if (!sema_analyse_attributes(context, decl, decl->attributes, ATTR_FNTYPE, erase_decl)) return decl_poison(decl);
if (*erase_decl) return true;
Signature *sig = &decl->fntype_decl;
return sema_analyse_function_signature(context, decl, NULL, sig->abi, sig);
Signature *sig = &decl->fntype_decl.signature;
if (!sema_analyse_function_signature(context, decl, NULL, sig->abi, sig)) return false;
bool pure = false;
if (!sema_analyse_doc_header(context, decl->fntype_decl.docs, sig->params, NULL, &pure)) return false;
sig->attrs.is_pure = pure;
return true;
}
static inline bool sema_analyse_type_alias(SemaContext *context, Decl *decl, bool *erase_decl)
@@ -1507,7 +1511,7 @@ static inline bool sema_analyse_type_alias(SemaContext *context, Decl *decl, boo
Decl *fn_decl = decl->type_alias_decl.decl;
fn_decl->is_export = is_export;
fn_decl->unit = decl->unit;
fn_decl->type = type_new_func(fn_decl, &fn_decl->fntype_decl);
fn_decl->type = type_new_func(fn_decl, &fn_decl->fntype_decl.signature);
decl->type->canonical = type_get_func_ptr(fn_decl->type);
return true;
}
@@ -3035,7 +3039,7 @@ INLINE bool update_abi(Decl *decl, CallABI abi)
{
if (decl->decl_kind == DECL_FNTYPE)
{
decl->fntype_decl.abi = abi;
decl->fntype_decl.signature.abi = abi;
return true;
}
decl->func_decl.signature.abi = abi;
@@ -3403,8 +3407,8 @@ static bool sema_analyse_attribute(SemaContext *context, ResolvedAttrData *attr_
decl->func_decl.signature.attrs.format = val + 1;
return true;
case DECL_FNTYPE:
if (decl->fntype_decl.attrs.format) break;
decl->fntype_decl.attrs.format = val + 1;
if (decl->fntype_decl.signature.attrs.format) break;
decl->fntype_decl.signature.attrs.format = val + 1;
return true;
default:
UNREACHABLE
@@ -3764,8 +3768,72 @@ bool sema_analyse_attributes(SemaContext *context, Decl *decl, Attr **attrs, Att
return true;
}
static bool sema_analyse_optional_returns(SemaContext *context, Ast *directive)
{
FOREACH(Ast *, ret, directive->contract_stmt.faults)
{
if (ret->contract_fault.expanding) continue;
if (ret->contract_fault.resolved)
{
continue;
}
Expr *expr = ret->contract_fault.expr;
if (expr->expr_kind == EXPR_RETHROW)
{
Expr *inner = expr->rethrow_expr.inner;
if (!sema_analyse_expr(context, inner)) return false;
Decl *decl;
switch (inner->expr_kind)
{
case EXPR_IDENTIFIER:
decl = inner->ident_expr;
break;
case EXPR_TYPEINFO:
{
Type *type = inner->type_expr->type;
if (type->type_kind != TYPE_ALIAS) goto IS_FAULT;
decl = type->decl;
ASSERT(decl->decl_kind == DECL_TYPE_ALIAS);
if (!decl->type_alias_decl.is_func) goto IS_FAULT;
decl = decl->type_alias_decl.decl;
break;
}
default:
goto IS_FAULT;;
}
decl = decl_flatten(decl);
if (decl->decl_kind != DECL_FNTYPE && decl->decl_kind != DECL_FUNC) goto IS_FAULT;
if (!sema_analyse_decl(context, decl)) return false;
AstId docs = decl->decl_kind == DECL_FNTYPE ? decl->fntype_decl.docs : decl->func_decl.docs;
while (docs)
{
Ast *doc = astptr(docs);
docs = doc->next;
if (doc->contract_stmt.kind != CONTRACT_OPTIONALS) continue;
ret->contract_fault.expanding = true;
bool success = sema_analyse_optional_returns(context, doc);
ret->contract_fault.expanding = false;
if (!success) false;
}
continue;
}
IS_FAULT:;
if (!sema_analyse_expr_rvalue(context, expr)) return false;
if (expr->type->canonical != type_fault)
{
RETURN_SEMA_ERROR(expr, "Expected a fault here.");
}
if (!expr_is_const_fault(expr)) RETURN_SEMA_ERROR(expr, "A constant fault is required.");
Decl *decl = expr->const_expr.fault;
if (!decl) RETURN_SEMA_ERROR(expr, "A non-null fault is required.");
ret->contract_fault.decl = decl;
ret->contract_fault.resolved = true;
}
return true;
}
static inline bool sema_analyse_doc_header(SemaContext *context, AstId doc,
Decl **params, Decl **extra_params, bool *pure_ref)
Decl **params, Decl **extra_params, bool *pure_ref)
{
while (doc)
{
@@ -3782,6 +3850,10 @@ static inline bool sema_analyse_doc_header(SemaContext *context, AstId doc,
*pure_ref = true;
continue;
}
if (directive_kind == CONTRACT_OPTIONALS)
{
if (!sema_analyse_optional_returns(context, directive)) return false;
}
if (directive_kind != CONTRACT_PARAM) continue;
const char *param_name = directive->contract_stmt.param.name;
Decl *param = NULL;
@@ -4258,6 +4330,7 @@ CHECK_DONE:
"'extern' or place it in an .c3i file.");
}
bool pure = false;
if (!sema_analyse_doc_header(context, decl->func_decl.docs, decl->func_decl.signature.params, NULL,
&pure)) return false;
decl->func_decl.signature.attrs.is_pure = pure;

11
src/compiler/sema_expr.c
View File

@@ -2463,7 +2463,16 @@ static inline bool sema_call_analyse_func_invocation(SemaContext *context, Decl
*any_val = *(any_val->inner_expr);
}
expr->call_expr.function_contracts = 0;
AstId docs = decl->func_decl.docs;
AstId docs;
if (decl->decl_kind == DECL_FNTYPE)
{
docs = decl->fntype_decl.docs;
}
else
{
docs = decl->func_decl.docs;
}
if (!safe_mode_enabled() || !sema_has_require(docs)) goto SKIP_CONTRACTS;
SemaContext temp_context;
bool success = false;

2
src/compiler/sema_liveness.c
View File

@@ -636,7 +636,7 @@ RETRY:
case DECL_MACRO:
UNREACHABLE_VOID
case DECL_FNTYPE:
sema_trace_func_liveness(&decl->fntype_decl);
sema_trace_func_liveness(&decl->fntype_decl.signature);
return;
case DECL_FUNC:
sema_trace_func_liveness(&decl->func_decl.signature);

60
src/compiler/sema_stmts.c
View File

@@ -494,6 +494,11 @@ static inline bool sema_check_return_matches_opt_returns(SemaContext *context, E
if (opt == fault) return true;
}
// No match
FOREACH(Decl *, opt, context->call_env.opt_returns)
{
assert(opt->decl_kind == DECL_FAULT);
if (opt == fault) return true;
}
RETURN_SEMA_ERROR(ret_expr, "This value does not match declared optional returns, it needs to be declared with the other optional returns.");
}
@@ -3283,14 +3288,59 @@ static bool sema_analyse_optional_returns(SemaContext *context, Ast *directive)
{
FOREACH(Ast *, ret, directive->contract_stmt.faults)
{
if (ret->contract_fault.resolved) continue;
Expr *expr = ret->contract_fault.expr;
if (expr->expr_kind != EXPR_UNRESOLVED_IDENTIFIER && !expr->unresolved_ident_expr.is_const)
if (ret->contract_fault.expanding) continue;
if (ret->contract_fault.resolved)
{
RETURN_SEMA_ERROR(expr, "Expected a fault name here.");
vec_add(context->call_env.opt_returns, ret->contract_fault.decl);
continue;
}
Expr *expr = ret->contract_fault.expr;
if (expr->expr_kind == EXPR_RETHROW)
{
Expr *inner = expr->rethrow_expr.inner;
if (!sema_analyse_expr(context, inner)) return false;
Decl *decl;
switch (inner->expr_kind)
{
case EXPR_IDENTIFIER:
decl = inner->ident_expr;
break;
case EXPR_TYPEINFO:
{
Type *type = inner->type_expr->type;
if (type->type_kind != TYPE_ALIAS) goto IS_FAULT;
decl = type->decl;
ASSERT(decl->decl_kind == DECL_TYPE_ALIAS);
if (!decl->type_alias_decl.is_func) goto IS_FAULT;
decl = decl->type_alias_decl.decl;
break;
}
default:
goto IS_FAULT;;
}
decl = decl_flatten(decl);
if (decl->decl_kind != DECL_FNTYPE && decl->decl_kind != DECL_FUNC) goto IS_FAULT;
if (!sema_analyse_decl(context, decl)) return false;
AstId docs = decl->decl_kind == DECL_FNTYPE ? decl->fntype_decl.docs : decl->func_decl.docs;
while (docs)
{
Ast *doc = astptr(docs);
docs = doc->next;
if (doc->contract_stmt.kind != CONTRACT_OPTIONALS) continue;
ret->contract_fault.expanding = true;
bool success = sema_analyse_optional_returns(context, doc);
ret->contract_fault.expanding = false;
if (!success) false;
}
continue;
}
IS_FAULT:;
if (!sema_analyse_expr_rvalue(context, expr)) return false;
if (!expr_is_const_fault(expr)) RETURN_SEMA_ERROR(expr, "A fault is required.");
if (expr->type->canonical != type_fault)
{
RETURN_SEMA_ERROR(expr, "Expected a fault here.");
}
if (!expr_is_const_fault(expr)) RETURN_SEMA_ERROR(expr, "A constant fault is required.");
Decl *decl = expr->const_expr.fault;
if (!decl) RETURN_SEMA_ERROR(expr, "A non-null fault is required.");
ret->contract_fault.decl = decl;