From 919910312d7d25fe8f894adbc9ff8a449ac26281 Mon Sep 17 00:00:00 2001 From: Josh Wolfe Date: Wed, 12 Apr 2017 16:49:47 -0700 Subject: [PATCH] make it an error to ignore a statement's value this makes {1;} an error. --- src/analyze.cpp | 17 ----------------- src/analyze.hpp | 1 - src/ir.cpp | 46 ++++++++++++++++++++++++++++++++++++---------- 3 files changed, 36 insertions(+), 28 deletions(-) diff --git a/src/analyze.cpp b/src/analyze.cpp index 1f2d01439..5a38f0c11 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -2987,23 +2987,6 @@ void semantic_analyze(CodeGen *g) { } } -bool is_node_void_expr(AstNode *node) { - if (node->type == NodeTypeContainerInitExpr && - node->data.container_init_expr.kind == ContainerInitKindArray) - { - AstNode *type_node = node->data.container_init_expr.type; - if (type_node->type == NodeTypeSymbol && - buf_eql_str(type_node->data.symbol_expr.symbol, "void")) - { - return true; - } - } else if (node->type == NodeTypeBlock && node->data.block.statements.length == 0) { - return true; - } - - return false; -} - TypeTableEntry **get_int_type_ptr(CodeGen *g, bool is_signed, uint32_t size_in_bits) { size_t index; if (size_in_bits == 8) { diff --git a/src/analyze.hpp b/src/analyze.hpp index e16ad0527..291aab7a4 100644 --- a/src/analyze.hpp +++ b/src/analyze.hpp @@ -17,7 +17,6 @@ TypeTableEntry *new_type_table_entry(TypeTableEntryId id); TypeTableEntry *get_pointer_to_type(CodeGen *g, TypeTableEntry *child_type, bool is_const); TypeTableEntry *get_pointer_to_type_extra(CodeGen *g, TypeTableEntry *child_type, bool is_const, bool is_volatile, uint32_t bit_offset, uint32_t unaligned_bit_count); -bool is_node_void_expr(AstNode *node); uint64_t type_size(CodeGen *g, TypeTableEntry *type_entry); uint64_t type_size_bits(CodeGen *g, TypeTableEntry *type_entry); TypeTableEntry **get_int_type_ptr(CodeGen *g, bool is_signed, uint32_t size_in_bits); diff --git a/src/ir.cpp b/src/ir.cpp index 53f324e37..2af3f1d0b 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -3344,6 +3344,7 @@ static IrInstruction *ir_gen_block(IrBuilder *irb, Scope *parent_scope, AstNode return ir_mark_gen(ir_build_const_void(irb, child_scope, block_node)); } + bool is_continuation_unreachable = false; IrInstruction *return_value = nullptr; for (size_t i = 0; i < block_node->data.block.statements.length; i += 1) { AstNode *statement_node = block_node->data.block.statements.at(i); @@ -3367,7 +3368,7 @@ static IrInstruction *ir_gen_block(IrBuilder *irb, Scope *parent_scope, AstNode scope_block->label_table.put(label_name, label); } - if (!(return_value && instr_is_unreachable(return_value))) { + if (!is_continuation_unreachable) { // fall through into new labeled basic block IrInstruction *is_comptime = ir_mark_gen(ir_build_const_bool(irb, child_scope, statement_node, ir_should_inline(irb->exec, child_scope))); @@ -3375,33 +3376,58 @@ static IrInstruction *ir_gen_block(IrBuilder *irb, Scope *parent_scope, AstNode } ir_set_cursor_at_end(irb, label_block); - return_value = nullptr; + // a label is an entry point + is_continuation_unreachable = false; continue; } - if (return_value && instr_is_unreachable(return_value)) { - if (is_node_void_expr(statement_node)) + if (is_continuation_unreachable) { + // if you put a semicolon after a return statement, + // then we get a void statement in the unreachable area. + // this is fine. ignore any void blocks we get from this happening. + if (statement_node->type == NodeTypeBlock && statement_node->data.block.statements.length == 0) continue; add_node_error(irb->codegen, statement_node, buf_sprintf("unreachable code")); } - return_value = ir_gen_node(irb, statement_node, child_scope); - if (statement_node->type == NodeTypeDefer && return_value != irb->codegen->invalid_instruction) { + IrInstruction *statement_value = ir_gen_node(irb, statement_node, child_scope); + is_continuation_unreachable = instr_is_unreachable(statement_value); + if (is_continuation_unreachable) + return_value = statement_value; + else + return_value = nullptr; + if (statement_node->type == NodeTypeDefer && statement_value != irb->codegen->invalid_instruction) { // defer starts a new scope child_scope = statement_node->data.defer.child_scope; assert(child_scope); - } else if (return_value->id == IrInstructionIdDeclVar) { + } else if (statement_value->id == IrInstructionIdDeclVar) { // variable declarations start a new scope - IrInstructionDeclVar *decl_var_instruction = (IrInstructionDeclVar *)return_value; + IrInstructionDeclVar *decl_var_instruction = (IrInstructionDeclVar *)statement_value; child_scope = decl_var_instruction->var->child_scope; + } else { + // label, defer, variable declaration will never be the last statement + if (i == block_node->data.block.statements.length - 1) { + // this is the result value statement + return_value = statement_value; + } else { + // there are more statements ahead of this one. this statement's value must be void + TypeTableEntry *instruction_type = statement_value->value.type; + if (instruction_type && + instruction_type->id != TypeTableEntryIdInvalid && + instruction_type->id != TypeTableEntryIdVoid && + instruction_type->id != TypeTableEntryIdUnreachable) { + add_node_error(irb->codegen, statement_node, buf_sprintf("expression valued ignored")); + } + } } } - // labels are never the last statement assert(return_value != nullptr); - if (!instr_is_unreachable(return_value)) + if (!is_continuation_unreachable) { + // control flow falls out of block ir_gen_defers_for_block(irb, child_scope, outer_block_scope, false, false); + } return return_value; }