authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2015-11-27 10:52:31-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2015-11-27 10:52:31-07:00
log9ca9a2c5540683a54bae597c59152d06d095beef
tree6a0b9c01c5bfaeaeaa230ea184baf9561f3ed03c
parent821907317eb77a96dc53adf20ac705b4501e2ab8

allow empty function and return with no expression

4 files changed, 107 insertions(+), 23 deletions(-)

README.md+4-2
......@@ -31,7 +31,9 @@ readable, safe, optimal, and concise code to solve any computing problem.
3131
3232## Roadmap
3333
34 * empty function and return with no expression
34 * pub/private/export functions
35 * make sure that release mode optimizes out empty private functions
36 * test framework to test for compile errors
3537 * Simple .so library
3638 * Multiple files
3739 * figure out integers
......@@ -87,7 +89,7 @@ Statement : ExpressionStatement | ReturnStatement
8789
8890ExpressionStatement : Expression token(Semicolon)
8991
90ReturnStatement : token(Return) Expression token(Semicolon)
92ReturnStatement : token(Return) option(Expression) token(Semicolon)
9193
9294Expression : token(Number) | token(String) | token(Unreachable) | FnCall
9395
src/codegen.cpp+81-6
......@@ -80,9 +80,14 @@ struct TypeNode {
8080 TypeTableEntry *entry;
8181};
8282
83struct FnDefNode {
84 bool add_implicit_return;
85};
86
8387struct CodeGenNode {
8488 union {
8589 TypeNode type_node; // for NodeTypeType
90 FnDefNode fn_def_node; // for NodeTypeFnDef
8691 } data;
8792};
8893
......@@ -275,6 +280,60 @@ static void find_declarations(CodeGen *g, AstNode *node) {
275280 }
276281}
277282
283static void check_fn_def_control_flow(CodeGen *g, AstNode *node) {
284 // Follow the execution flow and make sure the code returns appropriately.
285 // * A `return` statement in an unreachable type function should be an error.
286 // * Control flow should not be able to reach the end of an unreachable type function.
287 // * Functions that have a type other than void should not return without a value.
288 // * void functions without explicit return statements at the end need the
289 // add_implicit_return flag set on the codegen node.
290 assert(node->type == NodeTypeFnDef);
291 AstNode *proto_node = node->data.fn_def.fn_proto;
292 assert(proto_node->type == NodeTypeFnProto);
293 AstNode *return_type_node = proto_node->data.fn_proto.return_type;
294 assert(return_type_node->type == NodeTypeType);
295
296 node->codegen_node = allocate<CodeGenNode>(1);
297 FnDefNode *codegen_fn_def = &node->codegen_node->data.fn_def_node;
298
299 assert(return_type_node->codegen_node);
300 TypeTableEntry *type_entry = return_type_node->codegen_node->data.type_node.entry;
301 assert(type_entry);
302 TypeId type_id = type_entry->id;
303
304 AstNode *body_node = node->data.fn_def.body;
305 assert(body_node->type == NodeTypeBlock);
306
307 // TODO once we understand types, do this pass after type checking, and
308 // if an expression has an unreachable value then stop looking at statements after
309 // it. then we can remove the check to `unreachable` in the end of this function.
310 bool prev_statement_return = false;
311 for (int i = 0; i < body_node->data.block.statements.length; i += 1) {
312 AstNode *statement_node = body_node->data.block.statements.at(i);
313 if (statement_node->type == NodeTypeStatementReturn) {
314 if (type_id == TypeIdUnreachable) {
315 add_node_error(g, statement_node,
316 buf_sprintf("return statement in function with unreachable return type"));
317 return;
318 } else {
319 prev_statement_return = true;
320 }
321 } else if (prev_statement_return) {
322 add_node_error(g, statement_node,
323 buf_sprintf("unreachable code"));
324 }
325 }
326
327 if (!prev_statement_return) {
328 if (type_id == TypeIdVoid) {
329 codegen_fn_def->add_implicit_return = true;
330 } else if (type_id != TypeIdUnreachable) {
331 add_node_error(g, node,
332 buf_sprintf("control reaches end of non-void function"));
333 }
334 }
335}
336
278337static void analyze_node(CodeGen *g, AstNode *node) {
279338 switch (node->type) {
280339 case NodeTypeRoot:
......@@ -299,6 +358,8 @@ static void analyze_node(CodeGen *g, AstNode *node) {
299358 AstNode *proto_node = node->data.fn_def.fn_proto;
300359 assert(proto_node->type == NodeTypeFnProto);
301360 analyze_node(g, proto_node);
361
362 check_fn_def_control_flow(g, node);
302363 break;
303364 }
304365 case NodeTypeFnDecl:
......@@ -331,7 +392,9 @@ static void analyze_node(CodeGen *g, AstNode *node) {
331392 }
332393 break;
333394 case NodeTypeStatementReturn:
334 analyze_node(g, node->data.statement_return.expression);
395 if (node->data.statement_return.expression) {
396 analyze_node(g, node->data.statement_return.expression);
397 }
335398 break;
336399 case NodeTypeExpression:
337400 switch (node->data.expression.type) {
......@@ -545,7 +608,7 @@ static LLVMValueRef gen_expr(CodeGen *g, AstNode *expr_node) {
545608 zig_unreachable();
546609}
547610
548static void gen_block(CodeGen *g, AstNode *block_node) {
611static void gen_block(CodeGen *g, AstNode *block_node, bool add_implicit_return) {
549612 assert(block_node->type == NodeTypeBlock);
550613
551614 llvm::DILexicalBlock *di_block = g->dbuilder->createLexicalBlock(g->block_scopes.last(),
......@@ -558,10 +621,15 @@ static void gen_block(CodeGen *g, AstNode *block_node) {
558621 case NodeTypeStatementReturn:
559622 {
560623 AstNode *expr_node = statement_node->data.statement_return.expression;
561 LLVMValueRef value = gen_expr(g, expr_node);
624 if (expr_node) {
625 LLVMValueRef value = gen_expr(g, expr_node);
562626
563 add_debug_source_node(g, statement_node);
564 LLVMBuildRet(g->builder, value);
627 add_debug_source_node(g, statement_node);
628 LLVMBuildRet(g->builder, value);
629 } else {
630 add_debug_source_node(g, statement_node);
631 LLVMBuildRetVoid(g->builder);
632 }
565633 break;
566634 }
567635 case NodeTypeExpression:
......@@ -583,6 +651,10 @@ static void gen_block(CodeGen *g, AstNode *block_node) {
583651 }
584652 }
585653
654 if (add_implicit_return) {
655 LLVMBuildRetVoid(g->builder);
656 }
657
586658 g->block_scopes.pop();
587659}
588660
......@@ -685,7 +757,10 @@ void code_gen(CodeGen *g) {
685757 LLVMBasicBlockRef entry_block = LLVMAppendBasicBlock(fn, "entry");
686758 LLVMPositionBuilderAtEnd(g->builder, entry_block);
687759
688 gen_block(g, fn_def_node->data.fn_def.body);
760 CodeGenNode *codegen_node = fn_def_node->codegen_node;
761 assert(codegen_node);
762 bool add_implicit_return = codegen_node->data.fn_def_node.add_implicit_return;
763 gen_block(g, fn_def_node->data.fn_def.body, add_implicit_return);
689764
690765 g->block_scopes.pop();
691766 }
src/parser.cpp+16-14
......@@ -128,7 +128,8 @@ void ast_print(AstNode *node, int indent) {
128128 break;
129129 case NodeTypeStatementReturn:
130130 fprintf(stderr, "ReturnStatement\n");
131 ast_print(node->data.statement_return.expression, indent + 2);
131 if (node->data.statement_return.expression)
132 ast_print(node->data.statement_return.expression, indent + 2);
132133 break;
133134 case NodeTypeExternBlock:
134135 {
......@@ -258,7 +259,7 @@ void ast_invalid_token_error(ParseContext *pc, Token *token) {
258259 ast_error(token, "invalid token: '%s'", buf_ptr(&token_value));
259260}
260261
261static AstNode *ast_parse_expression(ParseContext *pc, int token_index, int *new_token_index);
262static AstNode *ast_parse_expression(ParseContext *pc, int *token_index, bool mandatory);
262263
263264
264265static void ast_expect_token(ParseContext *pc, Token *token, TokenId token_id) {
......@@ -374,7 +375,7 @@ static void ast_parse_fn_call_param_list(ParseContext *pc, int token_index, int
374375 }
375376
376377 for (;;) {
377 AstNode *expr = ast_parse_expression(pc, token_index, &token_index);
378 AstNode *expr = ast_parse_expression(pc, &token_index, true);
378379 params->append(expr);
379380
380381 Token *token = &pc->tokens->at(token_index);
......@@ -411,28 +412,29 @@ static AstNode *ast_parse_fn_call(ParseContext *pc, int token_index, int *new_to
411412/*
412413Expression : token(Number) | token(String) | token(Unreachable) | FnCall
413414*/
414static AstNode *ast_parse_expression(ParseContext *pc, int token_index, int *new_token_index) {
415 Token *token = &pc->tokens->at(token_index);
415static AstNode *ast_parse_expression(ParseContext *pc, int *token_index, bool mandatory) {
416 Token *token = &pc->tokens->at(*token_index);
416417 AstNode *node = ast_create_node(NodeTypeExpression, token);
417418 if (token->id == TokenIdKeywordUnreachable) {
418419 node->data.expression.type = AstNodeExpressionTypeUnreachable;
419 token_index += 1;
420 *token_index += 1;
420421 } else if (token->id == TokenIdSymbol) {
421422 node->data.expression.type = AstNodeExpressionTypeFnCall;
422 node->data.expression.data.fn_call = ast_parse_fn_call(pc, token_index, &token_index);
423 node->data.expression.data.fn_call = ast_parse_fn_call(pc, *token_index, token_index);
423424 } else if (token->id == TokenIdNumberLiteral) {
424425 node->data.expression.type = AstNodeExpressionTypeNumber;
425426 ast_buf_from_token(pc, token, &node->data.expression.data.number);
426 token_index += 1;
427 *token_index += 1;
427428 } else if (token->id == TokenIdStringLiteral) {
428429 node->data.expression.type = AstNodeExpressionTypeString;
429430 parse_string_literal(pc, token, &node->data.expression.data.string);
430 token_index += 1;
431 } else {
431 *token_index += 1;
432 } else if (mandatory) {
432433 ast_invalid_token_error(pc, token);
434 } else {
435 return nullptr;
433436 }
434437
435 *new_token_index = token_index;
436438 return node;
437439}
438440
......@@ -441,14 +443,14 @@ Statement : ExpressionStatement | ReturnStatement ;
441443
442444ExpressionStatement : Expression token(Semicolon) ;
443445
444ReturnStatement : token(Return) Expression token(Semicolon) ;
446ReturnStatement : token(Return) option(Expression) token(Semicolon) ;
445447*/
446448static AstNode *ast_parse_statement(ParseContext *pc, int token_index, int *new_token_index) {
447449 Token *token = &pc->tokens->at(token_index);
448450 if (token->id == TokenIdKeywordReturn) {
449451 AstNode *node = ast_create_node(NodeTypeStatementReturn, token);
450452 token_index += 1;
451 node->data.statement_return.expression = ast_parse_expression(pc, token_index, &token_index);
453 node->data.statement_return.expression = ast_parse_expression(pc, &token_index, false);
452454
453455 Token *semicolon = &pc->tokens->at(token_index);
454456 token_index += 1;
......@@ -460,7 +462,7 @@ static AstNode *ast_parse_statement(ParseContext *pc, int token_index, int *new_
460462 token->id == TokenIdKeywordUnreachable ||
461463 token->id == TokenIdNumberLiteral)
462464 {
463 AstNode *node = ast_parse_expression(pc, token_index, &token_index);
465 AstNode *node = ast_parse_expression(pc, &token_index, true);
464466
465467 Token *semicolon = &pc->tokens->at(token_index);
466468 token_index += 1;
test/standalone.cpp+6-1
......@@ -66,7 +66,12 @@ static void add_all_test_cases(void) {
6666 fn exit(code: i32) -> unreachable;
6767 }
6868
69 fn empty_function_1() {}
70 fn empty_function_2() { return; }
71
6972 fn _start() -> unreachable {
73 empty_function_1();
74 empty_function_2();
7075 this_is_a_function();
7176 }
7277
......@@ -86,7 +91,7 @@ static void add_all_test_cases(void) {
8691 /**
8792 * multi line doc comment
8893 */
89 fn another_function() -> i32 { return 0; }
94 fn another_function() {}
9095
9196 /// this is a documentation comment
9297 /// doc comment line 2