Ekdohibs/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add compile error for ignoring return value

Browse Source 
also introduce the _ identifier which you can assign to
to discard a return value

closes #219
This commit is contained in:
Andrew Kelley 2017-02-24 15:00:47 -05:00
parent 3b40aaa01f
commit a665872e88
10 changed files with 102 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/all_types.hpp
View File

@ -117,6 +117,9 @@ enum ConstPtrSpecial {
// emit a binary with a compile time known address. // emit a binary with a compile time known address.
// In this case index is the numeric address value. // In this case index is the numeric address value.
ConstPtrSpecialHardCodedAddr, ConstPtrSpecialHardCodedAddr,
// This means that the pointer represents memory of assigning to _.
// That is, storing discards the data, and loading is invalid.
ConstPtrSpecialDiscard,
}; };
enum ConstPtrMut { enum ConstPtrMut {

8
src/analyze.cpp
View File

@ -3091,6 +3091,9 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
hash_val += 4048518294; hash_val += 4048518294;
hash_val += hash_size(const_val->data.x_ptr.data.hard_coded_addr.addr); hash_val += hash_size(const_val->data.x_ptr.data.hard_coded_addr.addr);
return hash_val; return hash_val;
case ConstPtrSpecialDiscard:
hash_val += 2010123162;
return hash_val;
} }
zig_unreachable(); zig_unreachable();
} }
@ -3601,6 +3604,8 @@ bool const_values_equal(ConstExprValue *a, ConstExprValue *b) {
if (a->data.x_ptr.data.hard_coded_addr.addr != b->data.x_ptr.data.hard_coded_addr.addr) if (a->data.x_ptr.data.hard_coded_addr.addr != b->data.x_ptr.data.hard_coded_addr.addr)
return false; return false;
return true; return true;
case ConstPtrSpecialDiscard:
return true;
} }
zig_unreachable(); zig_unreachable();
case TypeTableEntryIdArray: case TypeTableEntryIdArray:
@ -3785,6 +3790,9 @@ void render_const_value(Buf *buf, ConstExprValue *const_val) {
buf_appendf(buf, "(&%s)(%" PRIx64 ")", buf_ptr(&canon_type->data.pointer.child_type->name), buf_appendf(buf, "(&%s)(%" PRIx64 ")", buf_ptr(&canon_type->data.pointer.child_type->name),
const_val->data.x_ptr.data.hard_coded_addr.addr); const_val->data.x_ptr.data.hard_coded_addr.addr);
return; return;
case ConstPtrSpecialDiscard:
buf_append_str(buf, "&_");
return;
} }
zig_unreachable(); zig_unreachable();
case TypeTableEntryIdFn: case TypeTableEntryIdFn:

1
src/codegen.cpp
View File

@ -2928,6 +2928,7 @@ static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val) {
render_const_val_global(g, const_val, ""); render_const_val_global(g, const_val, "");
switch (const_val->data.x_ptr.special) { switch (const_val->data.x_ptr.special) {
case ConstPtrSpecialInvalid: case ConstPtrSpecialInvalid:
case ConstPtrSpecialDiscard:
zig_unreachable(); zig_unreachable();
case ConstPtrSpecialRef: case ConstPtrSpecialRef:
{ {

31
src/ir.cpp
View File

@ -77,6 +77,8 @@ ConstExprValue *const_ptr_pointee(ConstExprValue *const_val) {
const_val->data.x_ptr.data.base_struct.field_index]; const_val->data.x_ptr.data.base_struct.field_index];
case ConstPtrSpecialHardCodedAddr: case ConstPtrSpecialHardCodedAddr:
zig_unreachable(); zig_unreachable();
case ConstPtrSpecialDiscard:
zig_unreachable();
} }
zig_unreachable(); zig_unreachable();
} }
@ -3656,6 +3658,15 @@ static IrInstruction *ir_gen_symbol(IrBuilder *irb, Scope *scope, AstNode *node,
Buf *variable_name = node->data.symbol_expr.symbol; Buf *variable_name = node->data.symbol_expr.symbol;
if (buf_eql_str(variable_name, "_") && lval.is_ptr) {
IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, node);
const_instruction->base.value.type = get_pointer_to_type(irb->codegen,
irb->codegen->builtin_types.entry_void, false);
const_instruction->base.value.special = ConstValSpecialStatic;
const_instruction->base.value.data.x_ptr.special = ConstPtrSpecialDiscard;
return &const_instruction->base;
}
auto primitive_table_entry = irb->codegen->primitive_type_table.maybe_get(variable_name); auto primitive_table_entry = irb->codegen->primitive_type_table.maybe_get(variable_name);
if (primitive_table_entry) { if (primitive_table_entry) {
IrInstruction *value = ir_build_const_type(irb, scope, node, primitive_table_entry->value); IrInstruction *value = ir_build_const_type(irb, scope, node, primitive_table_entry->value);
@ -8927,6 +8938,7 @@ static TypeTableEntry *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruc
size_t old_size; size_t old_size;
switch (array_ptr_val->data.x_ptr.special) { switch (array_ptr_val->data.x_ptr.special) {
case ConstPtrSpecialInvalid: case ConstPtrSpecialInvalid:
case ConstPtrSpecialDiscard:
zig_unreachable(); zig_unreachable();
case ConstPtrSpecialRef: case ConstPtrSpecialRef:
mem_size = 1; mem_size = 1;
@ -8977,6 +8989,7 @@ static TypeTableEntry *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruc
out_val->data.x_ptr.mut = ptr_field->data.x_ptr.mut; out_val->data.x_ptr.mut = ptr_field->data.x_ptr.mut;
switch (ptr_field->data.x_ptr.special) { switch (ptr_field->data.x_ptr.special) {
case ConstPtrSpecialInvalid: case ConstPtrSpecialInvalid:
case ConstPtrSpecialDiscard:
zig_unreachable(); zig_unreachable();
case ConstPtrSpecialRef: case ConstPtrSpecialRef:
out_val->data.x_ptr.special = ConstPtrSpecialRef; out_val->data.x_ptr.special = ConstPtrSpecialRef;
@ -9384,6 +9397,10 @@ static TypeTableEntry *ir_analyze_instruction_store_ptr(IrAnalyze *ira, IrInstru
return value->value.type; return value->value.type;
assert(ptr->value.type->id == TypeTableEntryIdPointer); assert(ptr->value.type->id == TypeTableEntryIdPointer);
if (ptr->value.data.x_ptr.special == ConstPtrSpecialDiscard) {
return ir_analyze_void(ira, &store_ptr_instruction->base);
}
if (ptr->value.type->data.pointer.is_const && !store_ptr_instruction->base.is_gen) { if (ptr->value.type->data.pointer.is_const && !store_ptr_instruction->base.is_gen) {
ir_add_error(ira, &store_ptr_instruction->base, buf_sprintf("cannot assign to constant")); ir_add_error(ira, &store_ptr_instruction->base, buf_sprintf("cannot assign to constant"));
return ira->codegen->builtin_types.entry_invalid; return ira->codegen->builtin_types.entry_invalid;
@ -11365,6 +11382,7 @@ static TypeTableEntry *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructi
size_t bound_end; size_t bound_end;
switch (dest_ptr_val->data.x_ptr.special) { switch (dest_ptr_val->data.x_ptr.special) {
case ConstPtrSpecialInvalid: case ConstPtrSpecialInvalid:
case ConstPtrSpecialDiscard:
zig_unreachable(); zig_unreachable();
case ConstPtrSpecialRef: case ConstPtrSpecialRef:
dest_elements = dest_ptr_val->data.x_ptr.data.ref.pointee; dest_elements = dest_ptr_val->data.x_ptr.data.ref.pointee;
@ -11455,6 +11473,7 @@ static TypeTableEntry *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructi
size_t dest_end; size_t dest_end;
switch (dest_ptr_val->data.x_ptr.special) { switch (dest_ptr_val->data.x_ptr.special) {
case ConstPtrSpecialInvalid: case ConstPtrSpecialInvalid:
case ConstPtrSpecialDiscard:
zig_unreachable(); zig_unreachable();
case ConstPtrSpecialRef: case ConstPtrSpecialRef:
dest_elements = dest_ptr_val->data.x_ptr.data.ref.pointee; dest_elements = dest_ptr_val->data.x_ptr.data.ref.pointee;
@ -11487,6 +11506,7 @@ static TypeTableEntry *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructi
switch (src_ptr_val->data.x_ptr.special) { switch (src_ptr_val->data.x_ptr.special) {
case ConstPtrSpecialInvalid: case ConstPtrSpecialInvalid:
case ConstPtrSpecialDiscard:
zig_unreachable(); zig_unreachable();
case ConstPtrSpecialRef: case ConstPtrSpecialRef:
src_elements = src_ptr_val->data.x_ptr.data.ref.pointee; src_elements = src_ptr_val->data.x_ptr.data.ref.pointee;
@ -11595,6 +11615,7 @@ static TypeTableEntry *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructio
parent_ptr = const_ptr_pointee(&ptr_ptr->value); parent_ptr = const_ptr_pointee(&ptr_ptr->value);
switch (parent_ptr->data.x_ptr.special) { switch (parent_ptr->data.x_ptr.special) {
case ConstPtrSpecialInvalid: case ConstPtrSpecialInvalid:
case ConstPtrSpecialDiscard:
zig_unreachable(); zig_unreachable();
case ConstPtrSpecialRef: case ConstPtrSpecialRef:
array_val = nullptr; array_val = nullptr;
@ -11619,6 +11640,7 @@ static TypeTableEntry *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructio
switch (parent_ptr->data.x_ptr.special) { switch (parent_ptr->data.x_ptr.special) {
case ConstPtrSpecialInvalid: case ConstPtrSpecialInvalid:
case ConstPtrSpecialDiscard:
zig_unreachable(); zig_unreachable();
case ConstPtrSpecialRef: case ConstPtrSpecialRef:
array_val = nullptr; array_val = nullptr;
@ -11676,6 +11698,7 @@ static TypeTableEntry *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructio
} else { } else {
switch (parent_ptr->data.x_ptr.special) { switch (parent_ptr->data.x_ptr.special) {
case ConstPtrSpecialInvalid: case ConstPtrSpecialInvalid:
case ConstPtrSpecialDiscard:
zig_unreachable(); zig_unreachable();
case ConstPtrSpecialRef: case ConstPtrSpecialRef:
init_const_ptr_ref(ira->codegen, ptr_val, init_const_ptr_ref(ira->codegen, ptr_val,
@ -12302,6 +12325,14 @@ static TypeTableEntry *ir_analyze_instruction(IrAnalyze *ira, IrInstruction *ins
instruction_type->id == TypeTableEntryIdUnreachable); instruction_type->id == TypeTableEntryIdUnreachable);
instruction->other = instruction; instruction->other = instruction;
} }
if (instruction_type->id != TypeTableEntryIdInvalid &&
instruction_type->id != TypeTableEntryIdVoid &&
instruction_type->id != TypeTableEntryIdUnreachable &&
instruction->ref_count == 0)
{
ir_add_error(ira, instruction, buf_sprintf("return value ignored"));
}
return instruction_type; return instruction_type;
} }

2
std/compiler_rt.zig
View File

@ -218,7 +218,7 @@ export fn __umoddi3(a: du_int, b: du_int) -> du_int {
@setDebugSafety(this, false); @setDebugSafety(this, false);
var r: du_int = undefined; var r: du_int = undefined;
__udivmoddi4(a, b, &r); _ = __udivmoddi4(a, b, &r);
return r; return r;
} }

6
std/io.zig
View File

@ -170,7 +170,7 @@ pub const OutStream = struct {
}, },
State.Integer => switch (c) { State.Integer => switch (c) {
'}' => { '}' => {
self.printInt(args[next_arg], radix, uppercase, width); %return self.printInt(args[next_arg], radix, uppercase, width);
next_arg += 1; next_arg += 1;
state = State.Start; state = State.Start;
start_index = i + 1; start_index = i + 1;
@ -184,7 +184,7 @@ pub const OutStream = struct {
State.IntegerWidth => switch (c) { State.IntegerWidth => switch (c) {
'}' => { '}' => {
width = comptime %%parseUnsigned(usize, format[width_start...i], 10); width = comptime %%parseUnsigned(usize, format[width_start...i], 10);
self.printInt(args[next_arg], radix, uppercase, width); %return self.printInt(args[next_arg], radix, uppercase, width);
next_arg += 1; next_arg += 1;
state = State.Start; state = State.Start;
start_index = i + 1; start_index = i + 1;
@ -194,7 +194,7 @@ pub const OutStream = struct {
}, },
State.Character => switch (c) { State.Character => switch (c) {
'}' => { '}' => {
self.printAsciiChar(args[next_arg]); %return self.printAsciiChar(args[next_arg]);
next_arg += 1; next_arg += 1;
state = State.Start; state = State.Start;
start_index = i + 1; start_index = i + 1;

12
std/linux.zig
View File

@ -298,7 +298,7 @@ pub fn lseek(fd: i32, offset: usize, ref_pos: usize) -> usize {
} }
pub fn exit(status: i32) -> unreachable { pub fn exit(status: i32) -> unreachable {
arch.syscall1(arch.SYS_exit, usize(status)); _ = arch.syscall1(arch.SYS_exit, usize(status));
@unreachable() @unreachable()
} }
@ -325,15 +325,15 @@ pub fn raise(sig: i32) -> i32 {
} }
fn blockAllSignals(set: &sigset_t) { fn blockAllSignals(set: &sigset_t) {
arch.syscall4(arch.SYS_rt_sigprocmask, SIG_BLOCK, usize(&all_mask), usize(set), NSIG/8); _ = arch.syscall4(arch.SYS_rt_sigprocmask, SIG_BLOCK, usize(&all_mask), usize(set), NSIG/8);
} }
fn blockAppSignals(set: &sigset_t) { fn blockAppSignals(set: &sigset_t) {
arch.syscall4(arch.SYS_rt_sigprocmask, SIG_BLOCK, usize(&app_mask), usize(set), NSIG/8); _ = arch.syscall4(arch.SYS_rt_sigprocmask, SIG_BLOCK, usize(&app_mask), usize(set), NSIG/8);
} }
fn restoreSignals(set: &sigset_t) { fn restoreSignals(set: &sigset_t) {
arch.syscall4(arch.SYS_rt_sigprocmask, SIG_SETMASK, usize(set), 0, NSIG/8); _ = arch.syscall4(arch.SYS_rt_sigprocmask, SIG_SETMASK, usize(set), 0, NSIG/8);
} }
@ -432,8 +432,8 @@ pub fn shutdown(fd: i32, how: i32) -> usize {
arch.syscall2(arch.SYS_shutdown, usize(fd), usize(how)) arch.syscall2(arch.SYS_shutdown, usize(fd), usize(how))
} }
pub fn bind(fd: i32, addr: &const sockaddr, len: socklen_t) { pub fn bind(fd: i32, addr: &const sockaddr, len: socklen_t) -> usize {
arch.syscall3(arch.SYS_bind, usize(fd), usize(addr), usize(len)); arch.syscall3(arch.SYS_bind, usize(fd), usize(addr), usize(len))
} }
pub fn listen(fd: i32, backlog: i32) -> usize { pub fn listen(fd: i32, backlog: i32) -> usize {

4
std/os.zig
View File

@ -30,8 +30,8 @@ pub fn getRandomBytes(buf: []u8) -> %void {
pub coldcc fn abort() -> unreachable { pub coldcc fn abort() -> unreachable {
switch (@compileVar("os")) { switch (@compileVar("os")) {
Os.linux, Os.darwin => { Os.linux, Os.darwin => {
system.raise(system.SIGABRT); _ = system.raise(system.SIGABRT);
system.raise(system.SIGKILL); _ = system.raise(system.SIGKILL);
while (true) {} while (true) {}
}, },
else => @compileError("unsupported os"), else => @compileError("unsupported os"),

2
test/cases/struct.zig
View File

@ -193,7 +193,7 @@ const EmptyStruct = struct {
fn returnEmptyStructFromFn() { fn returnEmptyStructFromFn() {
@setFnTest(this); @setFnTest(this);
testReturnEmptyStructFromFn(); _ = testReturnEmptyStructFromFn();
} }
const EmptyStruct2 = struct {}; const EmptyStruct2 = struct {};
fn testReturnEmptyStructFromFn() -> EmptyStruct2 { fn testReturnEmptyStructFromFn() -> EmptyStruct2 {

86
test/run_tests.cpp
View File

@ -230,7 +230,7 @@ static void add_compiling_test_cases(void) {
add_simple_case_libc("hello world with libc", R"SOURCE( add_simple_case_libc("hello world with libc", R"SOURCE(
const c = @cImport(@cInclude("stdio.h")); const c = @cImport(@cInclude("stdio.h"));
export fn main(argc: c_int, argv: &&u8) -> c_int { export fn main(argc: c_int, argv: &&u8) -> c_int {
c.puts(c"Hello, world!"); _ = c.puts(c"Hello, world!");
return 0; return 0;
} }
)SOURCE", "Hello, world!" NL); )SOURCE", "Hello, world!" NL);
@ -344,84 +344,84 @@ pub fn main(args: [][]u8) -> %void {
const c = @cImport(@cInclude("stdio.h")); const c = @cImport(@cInclude("stdio.h"));
export fn main(argc: c_int, argv: &&u8) -> c_int { export fn main(argc: c_int, argv: &&u8) -> c_int {
c.printf(c"\n"); _ = c.printf(c"\n");
c.printf(c"0: %llu\n", _ = c.printf(c"0: %llu\n",
u64(0)); u64(0));
c.printf(c"320402575052271: %llu\n", _ = c.printf(c"320402575052271: %llu\n",
u64(320402575052271)); u64(320402575052271));
c.printf(c"0x01236789abcdef: %llu\n", _ = c.printf(c"0x01236789abcdef: %llu\n",
u64(0x01236789abcdef)); u64(0x01236789abcdef));
c.printf(c"0xffffffffffffffff: %llu\n", _ = c.printf(c"0xffffffffffffffff: %llu\n",
u64(0xffffffffffffffff)); u64(0xffffffffffffffff));
c.printf(c"0x000000ffffffffffffffff: %llu\n", _ = c.printf(c"0x000000ffffffffffffffff: %llu\n",
u64(0x000000ffffffffffffffff)); u64(0x000000ffffffffffffffff));
c.printf(c"0o1777777777777777777777: %llu\n", _ = c.printf(c"0o1777777777777777777777: %llu\n",
u64(0o1777777777777777777777)); u64(0o1777777777777777777777));
c.printf(c"0o0000001777777777777777777777: %llu\n", _ = c.printf(c"0o0000001777777777777777777777: %llu\n",
u64(0o0000001777777777777777777777)); u64(0o0000001777777777777777777777));
c.printf(c"0b1111111111111111111111111111111111111111111111111111111111111111: %llu\n", _ = c.printf(c"0b1111111111111111111111111111111111111111111111111111111111111111: %llu\n",
u64(0b1111111111111111111111111111111111111111111111111111111111111111)); u64(0b1111111111111111111111111111111111111111111111111111111111111111));
c.printf(c"0b0000001111111111111111111111111111111111111111111111111111111111111111: %llu\n", _ = c.printf(c"0b0000001111111111111111111111111111111111111111111111111111111111111111: %llu\n",
u64(0b0000001111111111111111111111111111111111111111111111111111111111111111)); u64(0b0000001111111111111111111111111111111111111111111111111111111111111111));
c.printf(c"\n"); _ = c.printf(c"\n");
c.printf(c"0.0: %a\n", _ = c.printf(c"0.0: %a\n",
f64(0.0)); f64(0.0));
c.printf(c"0e0: %a\n", _ = c.printf(c"0e0: %a\n",
f64(0e0)); f64(0e0));
c.printf(c"0.0e0: %a\n", _ = c.printf(c"0.0e0: %a\n",
f64(0.0e0)); f64(0.0e0));
c.printf(c"000000000000000000000000000000000000000000000000000000000.0e0: %a\n", _ = c.printf(c"000000000000000000000000000000000000000000000000000000000.0e0: %a\n",
f64(000000000000000000000000000000000000000000000000000000000.0e0)); f64(000000000000000000000000000000000000000000000000000000000.0e0));
c.printf(c"0.000000000000000000000000000000000000000000000000000000000e0: %a\n", _ = c.printf(c"0.000000000000000000000000000000000000000000000000000000000e0: %a\n",
f64(0.000000000000000000000000000000000000000000000000000000000e0)); f64(0.000000000000000000000000000000000000000000000000000000000e0));
c.printf(c"0.0e000000000000000000000000000000000000000000000000000000000: %a\n", _ = c.printf(c"0.0e000000000000000000000000000000000000000000000000000000000: %a\n",
f64(0.0e000000000000000000000000000000000000000000000000000000000)); f64(0.0e000000000000000000000000000000000000000000000000000000000));
c.printf(c"1.0: %a\n", _ = c.printf(c"1.0: %a\n",
f64(1.0)); f64(1.0));
c.printf(c"10.0: %a\n", _ = c.printf(c"10.0: %a\n",
f64(10.0)); f64(10.0));
c.printf(c"10.5: %a\n", _ = c.printf(c"10.5: %a\n",
f64(10.5)); f64(10.5));
c.printf(c"10.5e5: %a\n", _ = c.printf(c"10.5e5: %a\n",
f64(10.5e5)); f64(10.5e5));
c.printf(c"10.5e+5: %a\n", _ = c.printf(c"10.5e+5: %a\n",
f64(10.5e+5)); f64(10.5e+5));
c.printf(c"50.0e-2: %a\n", _ = c.printf(c"50.0e-2: %a\n",
f64(50.0e-2)); f64(50.0e-2));
c.printf(c"50e-2: %a\n", _ = c.printf(c"50e-2: %a\n",
f64(50e-2)); f64(50e-2));
c.printf(c"\n"); _ = c.printf(c"\n");
c.printf(c"0x1.0: %a\n", _ = c.printf(c"0x1.0: %a\n",
f64(0x1.0)); f64(0x1.0));
c.printf(c"0x10.0: %a\n", _ = c.printf(c"0x10.0: %a\n",
f64(0x10.0)); f64(0x10.0));
c.printf(c"0x100.0: %a\n", _ = c.printf(c"0x100.0: %a\n",
f64(0x100.0)); f64(0x100.0));
c.printf(c"0x103.0: %a\n", _ = c.printf(c"0x103.0: %a\n",
f64(0x103.0)); f64(0x103.0));
c.printf(c"0x103.7: %a\n", _ = c.printf(c"0x103.7: %a\n",
f64(0x103.7)); f64(0x103.7));
c.printf(c"0x103.70: %a\n", _ = c.printf(c"0x103.70: %a\n",
f64(0x103.70)); f64(0x103.70));
c.printf(c"0x103.70p4: %a\n", _ = c.printf(c"0x103.70p4: %a\n",
f64(0x103.70p4)); f64(0x103.70p4));
c.printf(c"0x103.70p5: %a\n", _ = c.printf(c"0x103.70p5: %a\n",
f64(0x103.70p5)); f64(0x103.70p5));
c.printf(c"0x103.70p+5: %a\n", _ = c.printf(c"0x103.70p+5: %a\n",
f64(0x103.70p+5)); f64(0x103.70p+5));
c.printf(c"0x103.70p-5: %a\n", _ = c.printf(c"0x103.70p-5: %a\n",
f64(0x103.70p-5)); f64(0x103.70p-5));
c.printf(c"\n"); _ = c.printf(c"\n");
c.printf(c"0b10100.00010e0: %a\n", _ = c.printf(c"0b10100.00010e0: %a\n",
f64(0b10100.00010e0)); f64(0b10100.00010e0));
c.printf(c"0o10700.00010e0: %a\n", _ = c.printf(c"0o10700.00010e0: %a\n",
f64(0o10700.00010e0)); f64(0o10700.00010e0));
return 0; return 0;
@ -520,7 +520,7 @@ export fn main(argc: c_int, argv: &&u8) -> c_int {
const x: f64 = small; const x: f64 = small;
const y = i32(x); const y = i32(x);
const z = f64(y); const z = f64(y);
c.printf(c"%.2f\n%d\n%.2f\n%.2f\n", x, y, z, f64(-0.4)); _ = c.printf(c"%.2f\n%d\n%.2f\n%.2f\n", x, y, z, f64(-0.4));
return 0; return 0;
} }
)SOURCE", "3.25\n3\n3.00\n-0.40\n"); )SOURCE", "3.25\n3\n3.00\n-0.40\n");
@ -1691,6 +1691,12 @@ fn bar() { }
".tmp_source.zig:4:5: error: control flow attempts to use compile-time variable at runtime", ".tmp_source.zig:4:5: error: control flow attempts to use compile-time variable at runtime",
".tmp_source.zig:4:21: note: compile-time variable assigned here"); ".tmp_source.zig:4:21: note: compile-time variable assigned here");
add_compile_fail_case("ignored return value", R"SOURCE(
fn foo() {
bar();
}
fn bar() -> i32 { 0 }
)SOURCE", 1, ".tmp_source.zig:3:8: error: return value ignored");
} }
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////