| ... | @@ -5217,7 +5217,7 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Zir.I | ... | @@ -5217,7 +5217,7 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Zir.I |
| 5217 | if (block.is_comptime) { | 5217 | if (block.is_comptime) { |
| 5218 | return sema.fail(block, src, "encountered @panic at comptime", .{}); | 5218 | return sema.fail(block, src, "encountered @panic at comptime", .{}); |
| 5219 | } | 5219 | } |
| 5220 | try sema.panicWithMsg(block, src, msg_inst); | 5220 | try sema.panicWithMsg(block, msg_inst); |
| 5221 | return always_noreturn; | 5221 | return always_noreturn; |
| 5222 | } | 5222 | } |
| 5223 | | 5223 | |
| ... | @@ -6295,7 +6295,6 @@ fn zirCall( | ... | @@ -6295,7 +6295,6 @@ fn zirCall( |
| 6295 | } else { | 6295 | } else { |
| 6296 | resolved_args = try sema.arena.alloc(Air.Inst.Ref, args_len); | 6296 | resolved_args = try sema.arena.alloc(Air.Inst.Ref, args_len); |
| 6297 | } | 6297 | } |
| 6298 | const total_args = args_len + @boolToInt(bound_arg_src != null); | | |
| 6299 | | 6298 | |
| 6300 | const callee_ty = sema.typeOf(func); | 6299 | const callee_ty = sema.typeOf(func); |
| 6301 | const func_ty = func_ty: { | 6300 | const func_ty = func_ty: { |
| ... | @@ -6311,45 +6310,16 @@ fn zirCall( | ... | @@ -6311,45 +6310,16 @@ fn zirCall( |
| 6311 | } | 6310 | } |
| 6312 | return sema.fail(block, func_src, "type '{}' not a function", .{callee_ty.fmt(sema.mod)}); | 6311 | return sema.fail(block, func_src, "type '{}' not a function", .{callee_ty.fmt(sema.mod)}); |
| 6313 | }; | 6312 | }; |
| 6314 | const func_ty_info = func_ty.fnInfo(); | 6313 | const total_args = args_len + @boolToInt(bound_arg_src != null); |
| 6315 | | 6314 | try sema.checkCallArgumentCount(block, func, func_src, func_ty, total_args, bound_arg_src != null); |
| 6316 | const fn_params_len = func_ty_info.param_types.len; | | |
| 6317 | check_args: { | | |
| 6318 | if (func_ty_info.is_var_args) { | | |
| 6319 | assert(func_ty_info.cc == .C); | | |
| 6320 | if (total_args >= fn_params_len) break :check_args; | | |
| 6321 | } else if (fn_params_len == total_args) { | | |
| 6322 | break :check_args; | | |
| 6323 | } | | |
| 6324 | | | |
| 6325 | const maybe_decl = try sema.funcDeclSrc(func); | | |
| 6326 | const member_str = if (bound_arg_src != null) "member function " else ""; | | |
| 6327 | const variadic_str = if (func_ty_info.is_var_args) "at least " else ""; | | |
| 6328 | const msg = msg: { | | |
| 6329 | const msg = try sema.errMsg( | | |
| 6330 | block, | | |
| 6331 | func_src, | | |
| 6332 | "{s}expected {s}{d} argument(s), found {d}", | | |
| 6333 | .{ | | |
| 6334 | member_str, | | |
| 6335 | variadic_str, | | |
| 6336 | fn_params_len - @boolToInt(bound_arg_src != null), | | |
| 6337 | args_len, | | |
| 6338 | }, | | |
| 6339 | ); | | |
| 6340 | errdefer msg.destroy(sema.gpa); | | |
| 6341 | | | |
| 6342 | if (maybe_decl) |fn_decl| try sema.mod.errNoteNonLazy(fn_decl.srcLoc(), msg, "function declared here", .{}); | | |
| 6343 | break :msg msg; | | |
| 6344 | }; | | |
| 6345 | return sema.failWithOwnedErrorMsg(msg); | | |
| 6346 | } | | |
| 6347 | | 6315 | |
| 6348 | const args_body = sema.code.extra[extra.end..]; | 6316 | const args_body = sema.code.extra[extra.end..]; |
| 6349 | | 6317 | |
| 6350 | var input_is_error = false; | 6318 | var input_is_error = false; |
| 6351 | const block_index = @intCast(Air.Inst.Index, block.instructions.items.len); | 6319 | const block_index = @intCast(Air.Inst.Index, block.instructions.items.len); |
| 6352 | | 6320 | |
| | 6321 | const func_ty_info = func_ty.fnInfo(); |
| | 6322 | const fn_params_len = func_ty_info.param_types.len; |
| 6353 | const parent_comptime = block.is_comptime; | 6323 | const parent_comptime = block.is_comptime; |
| 6354 | // `extra_index` and `arg_index` are separate since the bound function is passed as the first argument. | 6324 | // `extra_index` and `arg_index` are separate since the bound function is passed as the first argument. |
| 6355 | var extra_index: usize = 0; | 6325 | var extra_index: usize = 0; |
| ... | @@ -6398,7 +6368,7 @@ fn zirCall( | ... | @@ -6398,7 +6368,7 @@ fn zirCall( |
| 6398 | !block.is_comptime and !block.is_typeof and (input_is_error or pop_error_return_trace)) | 6368 | !block.is_comptime and !block.is_typeof and (input_is_error or pop_error_return_trace)) |
| 6399 | { | 6369 | { |
| 6400 | const call_inst: Air.Inst.Ref = if (modifier == .always_tail) undefined else b: { | 6370 | const call_inst: Air.Inst.Ref = if (modifier == .always_tail) undefined else b: { |
| 6401 | break :b try sema.analyzeCall(block, func, func_src, call_src, modifier, ensure_result_used, resolved_args, bound_arg_src, call_dbg_node); | 6371 | break :b try sema.analyzeCall(block, func, func_ty, func_src, call_src, modifier, ensure_result_used, resolved_args, bound_arg_src, call_dbg_node); |
| 6402 | }; | 6372 | }; |
| 6403 | | 6373 | |
| 6404 | const return_ty = sema.typeOf(call_inst); | 6374 | const return_ty = sema.typeOf(call_inst); |
| ... | @@ -6427,12 +6397,84 @@ fn zirCall( | ... | @@ -6427,12 +6397,84 @@ fn zirCall( |
| 6427 | } | 6397 | } |
| 6428 | | 6398 | |
| 6429 | if (modifier == .always_tail) // Perform the call *after* the restore, so that a tail call is possible. | 6399 | if (modifier == .always_tail) // Perform the call *after* the restore, so that a tail call is possible. |
| 6430 | return sema.analyzeCall(block, func, func_src, call_src, modifier, ensure_result_used, resolved_args, bound_arg_src, call_dbg_node); | 6400 | return sema.analyzeCall(block, func, func_ty, func_src, call_src, modifier, ensure_result_used, resolved_args, bound_arg_src, call_dbg_node); |
| 6431 | | 6401 | |
| 6432 | return call_inst; | 6402 | return call_inst; |
| 6433 | } else { | 6403 | } else { |
| 6434 | return sema.analyzeCall(block, func, func_src, call_src, modifier, ensure_result_used, resolved_args, bound_arg_src, call_dbg_node); | 6404 | return sema.analyzeCall(block, func, func_ty, func_src, call_src, modifier, ensure_result_used, resolved_args, bound_arg_src, call_dbg_node); |
| | 6405 | } |
| | 6406 | } |
| | 6407 | |
| | 6408 | fn checkCallArgumentCount( |
| | 6409 | sema: *Sema, |
| | 6410 | block: *Block, |
| | 6411 | func: Air.Inst.Ref, |
| | 6412 | func_src: LazySrcLoc, |
| | 6413 | func_ty: Type, |
| | 6414 | total_args: usize, |
| | 6415 | member_fn: bool, |
| | 6416 | ) !void { |
| | 6417 | const func_ty_info = func_ty.fnInfo(); |
| | 6418 | const fn_params_len = func_ty_info.param_types.len; |
| | 6419 | const args_len = total_args - @boolToInt(member_fn); |
| | 6420 | if (func_ty_info.is_var_args) { |
| | 6421 | assert(func_ty_info.cc == .C); |
| | 6422 | if (total_args >= fn_params_len) return; |
| | 6423 | } else if (fn_params_len == total_args) { |
| | 6424 | return; |
| 6435 | } | 6425 | } |
| | 6426 | |
| | 6427 | const maybe_decl = try sema.funcDeclSrc(func); |
| | 6428 | const member_str = if (member_fn) "member function " else ""; |
| | 6429 | const variadic_str = if (func_ty_info.is_var_args) "at least " else ""; |
| | 6430 | const msg = msg: { |
| | 6431 | const msg = try sema.errMsg( |
| | 6432 | block, |
| | 6433 | func_src, |
| | 6434 | "{s}expected {s}{d} argument(s), found {d}", |
| | 6435 | .{ |
| | 6436 | member_str, |
| | 6437 | variadic_str, |
| | 6438 | fn_params_len - @boolToInt(member_fn), |
| | 6439 | args_len, |
| | 6440 | }, |
| | 6441 | ); |
| | 6442 | errdefer msg.destroy(sema.gpa); |
| | 6443 | |
| | 6444 | if (maybe_decl) |fn_decl| try sema.mod.errNoteNonLazy(fn_decl.srcLoc(), msg, "function declared here", .{}); |
| | 6445 | break :msg msg; |
| | 6446 | }; |
| | 6447 | return sema.failWithOwnedErrorMsg(msg); |
| | 6448 | } |
| | 6449 | |
| | 6450 | fn callBuiltin( |
| | 6451 | sema: *Sema, |
| | 6452 | block: *Block, |
| | 6453 | builtin_fn: Air.Inst.Ref, |
| | 6454 | modifier: std.builtin.CallModifier, |
| | 6455 | args: []const Air.Inst.Ref, |
| | 6456 | ) !void { |
| | 6457 | const callee_ty = sema.typeOf(builtin_fn); |
| | 6458 | const func_ty = func_ty: { |
| | 6459 | switch (callee_ty.zigTypeTag()) { |
| | 6460 | .Fn => break :func_ty callee_ty, |
| | 6461 | .Pointer => { |
| | 6462 | const ptr_info = callee_ty.ptrInfo().data; |
| | 6463 | if (ptr_info.size == .One and ptr_info.pointee_type.zigTypeTag() == .Fn) { |
| | 6464 | break :func_ty ptr_info.pointee_type; |
| | 6465 | } |
| | 6466 | }, |
| | 6467 | else => {}, |
| | 6468 | } |
| | 6469 | std.debug.panic("type '{}' is not a function calling builtin fn", .{callee_ty.fmt(sema.mod)}); |
| | 6470 | }; |
| | 6471 | |
| | 6472 | const func_ty_info = func_ty.fnInfo(); |
| | 6473 | const fn_params_len = func_ty_info.param_types.len; |
| | 6474 | if (args.len != fn_params_len or (func_ty_info.is_var_args and args.len < fn_params_len)) { |
| | 6475 | std.debug.panic("parameter count mismatch calling builtin fn, expected {d}, found {d}", .{ fn_params_len, args.len }); |
| | 6476 | } |
| | 6477 | _ = try sema.analyzeCall(block, builtin_fn, func_ty, sema.src, sema.src, modifier, false, args, null, null); |
| 6436 | } | 6478 | } |
| 6437 | | 6479 | |
| 6438 | const GenericCallAdapter = struct { | 6480 | const GenericCallAdapter = struct { |
| ... | @@ -6509,6 +6551,7 @@ fn analyzeCall( | ... | @@ -6509,6 +6551,7 @@ fn analyzeCall( |
| 6509 | sema: *Sema, | 6551 | sema: *Sema, |
| 6510 | block: *Block, | 6552 | block: *Block, |
| 6511 | func: Air.Inst.Ref, | 6553 | func: Air.Inst.Ref, |
| | 6554 | func_ty: Type, |
| 6512 | func_src: LazySrcLoc, | 6555 | func_src: LazySrcLoc, |
| 6513 | call_src: LazySrcLoc, | 6556 | call_src: LazySrcLoc, |
| 6514 | modifier: std.builtin.CallModifier, | 6557 | modifier: std.builtin.CallModifier, |
| ... | @@ -6519,22 +6562,10 @@ fn analyzeCall( | ... | @@ -6519,22 +6562,10 @@ fn analyzeCall( |
| 6519 | ) CompileError!Air.Inst.Ref { | 6562 | ) CompileError!Air.Inst.Ref { |
| 6520 | const mod = sema.mod; | 6563 | const mod = sema.mod; |
| 6521 | | 6564 | |
| 6522 | const callee_ty = sema.typeOf(func); | | |
| 6523 | const func_ty = func_ty: { | | |
| 6524 | switch (callee_ty.zigTypeTag()) { | | |
| 6525 | .Fn => break :func_ty callee_ty, | | |
| 6526 | .Pointer => { | | |
| 6527 | const ptr_info = callee_ty.ptrInfo().data; | | |
| 6528 | if (ptr_info.size == .One and ptr_info.pointee_type.zigTypeTag() == .Fn) { | | |
| 6529 | break :func_ty ptr_info.pointee_type; | | |
| 6530 | } | | |
| 6531 | }, | | |
| 6532 | else => {}, | | |
| 6533 | } | | |
| 6534 | return sema.fail(block, func_src, "type '{}' is not a function", .{callee_ty.fmt(sema.mod)}); | | |
| 6535 | }; | | |
| 6536 | | 6565 | |
| | 6566 | const callee_ty = sema.typeOf(func); |
| 6537 | const func_ty_info = func_ty.fnInfo(); | 6567 | const func_ty_info = func_ty.fnInfo(); |
| | 6568 | const fn_params_len = func_ty_info.param_types.len; |
| 6538 | const cc = func_ty_info.cc; | 6569 | const cc = func_ty_info.cc; |
| 6539 | if (cc == .Naked) { | 6570 | if (cc == .Naked) { |
| 6540 | const maybe_decl = try sema.funcDeclSrc(func); | 6571 | const maybe_decl = try sema.funcDeclSrc(func); |
| ... | @@ -6552,27 +6583,6 @@ fn analyzeCall( | ... | @@ -6552,27 +6583,6 @@ fn analyzeCall( |
| 6552 | }; | 6583 | }; |
| 6553 | return sema.failWithOwnedErrorMsg(msg); | 6584 | return sema.failWithOwnedErrorMsg(msg); |
| 6554 | } | 6585 | } |
| 6555 | const fn_params_len = func_ty_info.param_types.len; | | |
| 6556 | if (func_ty_info.is_var_args) { | | |
| 6557 | assert(cc == .C); | | |
| 6558 | if (uncasted_args.len < fn_params_len) { | | |
| 6559 | // TODO add error note: declared here | | |
| 6560 | return sema.fail( | | |
| 6561 | block, | | |
| 6562 | func_src, | | |
| 6563 | "expected at least {d} argument(s), found {d}", | | |
| 6564 | .{ fn_params_len, uncasted_args.len }, | | |
| 6565 | ); | | |
| 6566 | } | | |
| 6567 | } else if (fn_params_len != uncasted_args.len) { | | |
| 6568 | // TODO add error note: declared here | | |
| 6569 | return sema.fail( | | |
| 6570 | block, | | |
| 6571 | call_src, | | |
| 6572 | "expected {d} argument(s), found {d}", | | |
| 6573 | .{ fn_params_len, uncasted_args.len }, | | |
| 6574 | ); | | |
| 6575 | } | | |
| 6576 | | 6586 | |
| 6577 | const call_tag: Air.Inst.Tag = switch (modifier) { | 6587 | const call_tag: Air.Inst.Tag = switch (modifier) { |
| 6578 | .auto, | 6588 | .auto, |
| ... | @@ -11822,9 +11832,6 @@ fn maybeErrorUnwrap(sema: *Sema, block: *Block, body: []const Zir.Inst.Index, op | ... | @@ -11822,9 +11832,6 @@ fn maybeErrorUnwrap(sema: *Sema, block: *Block, body: []const Zir.Inst.Index, op |
| 11822 | .as_node => try sema.zirAsNode(block, inst), | 11832 | .as_node => try sema.zirAsNode(block, inst), |
| 11823 | .field_val => try sema.zirFieldVal(block, inst), | 11833 | .field_val => try sema.zirFieldVal(block, inst), |
| 11824 | .@"unreachable" => { | 11834 | .@"unreachable" => { |
| 11825 | const inst_data = sema.code.instructions.items(.data)[inst].@"unreachable"; | | |
| 11826 | const src = inst_data.src(); | | |
| 11827 | | | |
| 11828 | if (!sema.mod.comp.formatted_panics) { | 11835 | if (!sema.mod.comp.formatted_panics) { |
| 11829 | try sema.safetyPanic(block, .unwrap_error); | 11836 | try sema.safetyPanic(block, .unwrap_error); |
| 11830 | return true; | 11837 | return true; |
| ... | @@ -11833,18 +11840,17 @@ fn maybeErrorUnwrap(sema: *Sema, block: *Block, body: []const Zir.Inst.Index, op | ... | @@ -11833,18 +11840,17 @@ fn maybeErrorUnwrap(sema: *Sema, block: *Block, body: []const Zir.Inst.Index, op |
| 11833 | const panic_fn = try sema.getBuiltin("panicUnwrapError"); | 11840 | const panic_fn = try sema.getBuiltin("panicUnwrapError"); |
| 11834 | const err_return_trace = try sema.getErrorReturnTrace(block); | 11841 | const err_return_trace = try sema.getErrorReturnTrace(block); |
| 11835 | const args: [2]Air.Inst.Ref = .{ err_return_trace, operand }; | 11842 | const args: [2]Air.Inst.Ref = .{ err_return_trace, operand }; |
| 11836 | _ = try sema.analyzeCall(block, panic_fn, src, src, .auto, false, &args, null, null); | 11843 | try sema.callBuiltin(block, panic_fn, .auto, &args); |
| 11837 | return true; | 11844 | return true; |
| 11838 | }, | 11845 | }, |
| 11839 | .panic => { | 11846 | .panic => { |
| 11840 | const inst_data = sema.code.instructions.items(.data)[inst].un_node; | 11847 | const inst_data = sema.code.instructions.items(.data)[inst].un_node; |
| 11841 | const src = inst_data.src(); | | |
| 11842 | const msg_inst = try sema.resolveInst(inst_data.operand); | 11848 | const msg_inst = try sema.resolveInst(inst_data.operand); |
| 11843 | | 11849 | |
| 11844 | const panic_fn = try sema.getBuiltin("panic"); | 11850 | const panic_fn = try sema.getBuiltin("panic"); |
| 11845 | const err_return_trace = try sema.getErrorReturnTrace(block); | 11851 | const err_return_trace = try sema.getErrorReturnTrace(block); |
| 11846 | const args: [3]Air.Inst.Ref = .{ msg_inst, err_return_trace, .null_value }; | 11852 | const args: [3]Air.Inst.Ref = .{ msg_inst, err_return_trace, .null_value }; |
| 11847 | _ = try sema.analyzeCall(block, panic_fn, src, src, .auto, false, &args, null, null); | 11853 | try sema.callBuiltin(block, panic_fn, .auto, &args); |
| 11848 | return true; | 11854 | return true; |
| 11849 | }, | 11855 | }, |
| 11850 | else => unreachable, | 11856 | else => unreachable, |
| ... | @@ -17258,7 +17264,7 @@ fn zirRetLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Zir | ... | @@ -17258,7 +17264,7 @@ fn zirRetLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Zir |
| 17258 | | 17264 | |
| 17259 | if (sema.wantErrorReturnTracing(sema.fn_ret_ty)) { | 17265 | if (sema.wantErrorReturnTracing(sema.fn_ret_ty)) { |
| 17260 | const is_non_err = try sema.analyzePtrIsNonErr(block, src, ret_ptr); | 17266 | const is_non_err = try sema.analyzePtrIsNonErr(block, src, ret_ptr); |
| 17261 | return sema.retWithErrTracing(block, src, is_non_err, .ret_load, ret_ptr); | 17267 | return sema.retWithErrTracing(block, is_non_err, .ret_load, ret_ptr); |
| 17262 | } | 17268 | } |
| 17263 | | 17269 | |
| 17264 | _ = try block.addUnOp(.ret_load, ret_ptr); | 17270 | _ = try block.addUnOp(.ret_load, ret_ptr); |
| ... | @@ -17268,7 +17274,6 @@ fn zirRetLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Zir | ... | @@ -17268,7 +17274,6 @@ fn zirRetLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Zir |
| 17268 | fn retWithErrTracing( | 17274 | fn retWithErrTracing( |
| 17269 | sema: *Sema, | 17275 | sema: *Sema, |
| 17270 | block: *Block, | 17276 | block: *Block, |
| 17271 | src: LazySrcLoc, | | |
| 17272 | is_non_err: Air.Inst.Ref, | 17277 | is_non_err: Air.Inst.Ref, |
| 17273 | ret_tag: Air.Inst.Tag, | 17278 | ret_tag: Air.Inst.Tag, |
| 17274 | operand: Air.Inst.Ref, | 17279 | operand: Air.Inst.Ref, |
| ... | @@ -17290,7 +17295,7 @@ fn retWithErrTracing( | ... | @@ -17290,7 +17295,7 @@ fn retWithErrTracing( |
| 17290 | const args: [1]Air.Inst.Ref = .{err_return_trace}; | 17295 | const args: [1]Air.Inst.Ref = .{err_return_trace}; |
| 17291 | | 17296 | |
| 17292 | if (!need_check) { | 17297 | if (!need_check) { |
| 17293 | _ = try sema.analyzeCall(block, return_err_fn, src, src, .never_inline, false, &args, null, null); | 17298 | try sema.callBuiltin(block, return_err_fn, .never_inline, &args); |
| 17294 | _ = try block.addUnOp(ret_tag, operand); | 17299 | _ = try block.addUnOp(ret_tag, operand); |
| 17295 | return always_noreturn; | 17300 | return always_noreturn; |
| 17296 | } | 17301 | } |
| ... | @@ -17301,7 +17306,7 @@ fn retWithErrTracing( | ... | @@ -17301,7 +17306,7 @@ fn retWithErrTracing( |
| 17301 | | 17306 | |
| 17302 | var else_block = block.makeSubBlock(); | 17307 | var else_block = block.makeSubBlock(); |
| 17303 | defer else_block.instructions.deinit(gpa); | 17308 | defer else_block.instructions.deinit(gpa); |
| 17304 | _ = try sema.analyzeCall(&else_block, return_err_fn, src, src, .never_inline, false, &args, null, null); | 17309 | try sema.callBuiltin(&else_block, return_err_fn, .never_inline, &args); |
| 17305 | _ = try else_block.addUnOp(ret_tag, operand); | 17310 | _ = try else_block.addUnOp(ret_tag, operand); |
| 17306 | | 17311 | |
| 17307 | try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.CondBr).Struct.fields.len + | 17312 | try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.CondBr).Struct.fields.len + |
| ... | @@ -17447,7 +17452,7 @@ fn analyzeRet( | ... | @@ -17447,7 +17452,7 @@ fn analyzeRet( |
| 17447 | // Avoid adding a frame to the error return trace in case the value is comptime-known | 17452 | // Avoid adding a frame to the error return trace in case the value is comptime-known |
| 17448 | // to be not an error. | 17453 | // to be not an error. |
| 17449 | const is_non_err = try sema.analyzeIsNonErr(block, src, operand); | 17454 | const is_non_err = try sema.analyzeIsNonErr(block, src, operand); |
| 17450 | return sema.retWithErrTracing(block, src, is_non_err, .ret, operand); | 17455 | return sema.retWithErrTracing(block, is_non_err, .ret, operand); |
| 17451 | } | 17456 | } |
| 17452 | | 17457 | |
| 17453 | _ = try block.addUnOp(.ret, operand); | 17458 | _ = try block.addUnOp(.ret, operand); |
| ... | @@ -21657,8 +21662,25 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError | ... | @@ -21657,8 +21662,25 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError |
| 21657 | resolved.* = try sema.tupleFieldValByIndex(block, args_src, args, @intCast(u32, i), args_ty); | 21662 | resolved.* = try sema.tupleFieldValByIndex(block, args_src, args, @intCast(u32, i), args_ty); |
| 21658 | } | 21663 | } |
| 21659 | } | 21664 | } |
| | 21665 | |
| | 21666 | const callee_ty = sema.typeOf(func); |
| | 21667 | const func_ty = func_ty: { |
| | 21668 | switch (callee_ty.zigTypeTag()) { |
| | 21669 | .Fn => break :func_ty callee_ty, |
| | 21670 | .Pointer => { |
| | 21671 | const ptr_info = callee_ty.ptrInfo().data; |
| | 21672 | if (ptr_info.size == .One and ptr_info.pointee_type.zigTypeTag() == .Fn) { |
| | 21673 | break :func_ty ptr_info.pointee_type; |
| | 21674 | } |
| | 21675 | }, |
| | 21676 | else => {}, |
| | 21677 | } |
| | 21678 | return sema.fail(block, func_src, "type '{}' not a function", .{callee_ty.fmt(sema.mod)}); |
| | 21679 | }; |
| | 21680 | try sema.checkCallArgumentCount(block, func, func_src, func_ty, resolved_args.len, bound_arg_src != null); |
| | 21681 | |
| 21660 | const ensure_result_used = extra.flags.ensure_result_used; | 21682 | const ensure_result_used = extra.flags.ensure_result_used; |
| 21661 | return sema.analyzeCall(block, func, func_src, call_src, modifier, ensure_result_used, resolved_args, bound_arg_src, null); | 21683 | return sema.analyzeCall(block, func, func_ty, func_src, call_src, modifier, ensure_result_used, resolved_args, bound_arg_src, null); |
| 21662 | } | 21684 | } |
| 21663 | | 21685 | |
| 21664 | fn zirFieldParentPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { | 21686 | fn zirFieldParentPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { |
| ... | @@ -23469,7 +23491,6 @@ fn addSafetyCheckExtra( | ... | @@ -23469,7 +23491,6 @@ fn addSafetyCheckExtra( |
| 23469 | fn panicWithMsg( | 23491 | fn panicWithMsg( |
| 23470 | sema: *Sema, | 23492 | sema: *Sema, |
| 23471 | block: *Block, | 23493 | block: *Block, |
| 23472 | src: LazySrcLoc, | | |
| 23473 | msg_inst: Air.Inst.Ref, | 23494 | msg_inst: Air.Inst.Ref, |
| 23474 | ) !void { | 23495 | ) !void { |
| 23475 | const mod = sema.mod; | 23496 | const mod = sema.mod; |
| ... | @@ -23492,7 +23513,7 @@ fn panicWithMsg( | ... | @@ -23492,7 +23513,7 @@ fn panicWithMsg( |
| 23492 | Value.null, | 23513 | Value.null, |
| 23493 | ); | 23514 | ); |
| 23494 | const args: [3]Air.Inst.Ref = .{ msg_inst, null_stack_trace, .null_value }; | 23515 | const args: [3]Air.Inst.Ref = .{ msg_inst, null_stack_trace, .null_value }; |
| 23495 | _ = try sema.analyzeCall(block, panic_fn, src, src, .auto, false, &args, null, null); | 23516 | try sema.callBuiltin(block, panic_fn, .auto, &args); |
| 23496 | } | 23517 | } |
| 23497 | | 23518 | |
| 23498 | fn panicUnwrapError( | 23519 | fn panicUnwrapError( |
| ... | @@ -23530,7 +23551,7 @@ fn panicUnwrapError( | ... | @@ -23530,7 +23551,7 @@ fn panicUnwrapError( |
| 23530 | const err = try fail_block.addTyOp(unwrap_err_tag, Type.anyerror, operand); | 23551 | const err = try fail_block.addTyOp(unwrap_err_tag, Type.anyerror, operand); |
| 23531 | const err_return_trace = try sema.getErrorReturnTrace(&fail_block); | 23552 | const err_return_trace = try sema.getErrorReturnTrace(&fail_block); |
| 23532 | const args: [2]Air.Inst.Ref = .{ err_return_trace, err }; | 23553 | const args: [2]Air.Inst.Ref = .{ err_return_trace, err }; |
| 23533 | _ = try sema.analyzeCall(&fail_block, panic_fn, sema.src, sema.src, .auto, false, &args, null, null); | 23554 | try sema.callBuiltin(&fail_block, panic_fn, .auto, &args); |
| 23534 | } | 23555 | } |
| 23535 | } | 23556 | } |
| 23536 | try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); | 23557 | try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); |
| ... | @@ -23615,7 +23636,7 @@ fn panicSentinelMismatch( | ... | @@ -23615,7 +23636,7 @@ fn panicSentinelMismatch( |
| 23615 | else { | 23636 | else { |
| 23616 | const panic_fn = try sema.getBuiltin("checkNonScalarSentinel"); | 23637 | const panic_fn = try sema.getBuiltin("checkNonScalarSentinel"); |
| 23617 | const args: [2]Air.Inst.Ref = .{ expected_sentinel, actual_sentinel }; | 23638 | const args: [2]Air.Inst.Ref = .{ expected_sentinel, actual_sentinel }; |
| 23618 | _ = try sema.analyzeCall(parent_block, panic_fn, sema.src, sema.src, .auto, false, &args, null, null); | 23639 | try sema.callBuiltin(parent_block, panic_fn, .auto, &args); |
| 23619 | return; | 23640 | return; |
| 23620 | }; | 23641 | }; |
| 23621 | | 23642 | |
| ... | @@ -23652,7 +23673,7 @@ fn safetyCheckFormatted( | ... | @@ -23652,7 +23673,7 @@ fn safetyCheckFormatted( |
| 23652 | _ = try fail_block.addNoOp(.trap); | 23673 | _ = try fail_block.addNoOp(.trap); |
| 23653 | } else { | 23674 | } else { |
| 23654 | const panic_fn = try sema.getBuiltin(func); | 23675 | const panic_fn = try sema.getBuiltin(func); |
| 23655 | _ = try sema.analyzeCall(&fail_block, panic_fn, sema.src, sema.src, .auto, false, args, null, null); | 23676 | try sema.callBuiltin(&fail_block, panic_fn, .auto, args); |
| 23656 | } | 23677 | } |
| 23657 | try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); | 23678 | try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); |
| 23658 | } | 23679 | } |
| ... | @@ -23671,7 +23692,7 @@ fn safetyPanic( | ... | @@ -23671,7 +23692,7 @@ fn safetyPanic( |
| 23671 | )).?; | 23692 | )).?; |
| 23672 | | 23693 | |
| 23673 | const msg_inst = try sema.analyzeDeclVal(block, sema.src, msg_decl_index); | 23694 | const msg_inst = try sema.analyzeDeclVal(block, sema.src, msg_decl_index); |
| 23674 | try sema.panicWithMsg(block, sema.src, msg_inst); | 23695 | try sema.panicWithMsg(block, msg_inst); |
| 23675 | } | 23696 | } |
| 23676 | | 23697 | |
| 23677 | fn emitBackwardBranch(sema: *Sema, block: *Block, src: LazySrcLoc) !void { | 23698 | fn emitBackwardBranch(sema: *Sema, block: *Block, src: LazySrcLoc) !void { |
Veikka Tuominen <git@vexu.eu> 2023-05-10 12:27:59+03:00
src