diff options
Diffstat (limited to 'src/Sema.zig')
| -rw-r--r-- | src/Sema.zig | 3869 |
1 files changed, 3869 insertions, 0 deletions
diff --git a/src/Sema.zig b/src/Sema.zig new file mode 100644 index 0000000000..1a37d466c7 --- /dev/null +++ b/src/Sema.zig @@ -0,0 +1,3869 @@ +//! Semantic analysis of ZIR instructions. +//! Shared to every Block. Stored on the stack. +//! State used for compiling a `zir.Code` into TZIR. +//! Transforms untyped ZIR instructions into semantically-analyzed TZIR instructions. +//! Does type checking, comptime control flow, and safety-check generation. +//! This is the the heart of the Zig compiler. + +mod: *Module, +/// Same as `mod.gpa`. +gpa: *Allocator, +/// Points to the arena allocator of the Decl. +arena: *Allocator, +code: zir.Code, +/// Maps ZIR to TZIR. +inst_map: []*const Inst, +/// When analyzing an inline function call, owner_decl is the Decl of the caller +/// and `src_decl` of `Scope.Block` is the `Decl` of the callee. +/// This `Decl` owns the arena memory of this `Sema`. +owner_decl: *Decl, +func: ?*Module.Fn, +/// For now, TZIR requires arg instructions to be the first N instructions in the +/// TZIR code. We store references here for the purpose of `resolveInst`. +/// This can get reworked with TZIR memory layout changes, into simply: +/// > Denormalized data to make `resolveInst` faster. This is 0 if not inside a function, +/// > otherwise it is the number of parameters of the function. +/// > param_count: u32 +param_inst_list: []const *ir.Inst, +branch_quota: u32 = 1000, +/// This field is updated when a new source location becomes active, so that +/// instructions which do not have explicitly mapped source locations still have +/// access to the source location set by the previous instruction which did +/// contain a mapped source location. +src: LazySrcLoc = .{ .token_offset = 0 }, + +const std = @import("std"); +const mem = std.mem; +const Allocator = std.mem.Allocator; +const assert = std.debug.assert; +const log = std.log.scoped(.sema); + +const Sema = @This(); +const Value = @import("value.zig").Value; +const Type = @import("type.zig").Type; +const TypedValue = @import("TypedValue.zig"); +const ir = @import("ir.zig"); +const zir = @import("zir.zig"); +const Module = @import("Module.zig"); +const Inst = ir.Inst; +const Body = ir.Body; +const trace = @import("tracy.zig").trace; +const Scope = Module.Scope; +const InnerError = Module.InnerError; +const Decl = Module.Decl; +const LazySrcLoc = Module.LazySrcLoc; + +// TODO when memory layout of TZIR is reworked, this can be simplified. +const const_tzir_inst_list = blk: { + var result: [zir.const_inst_list.len]ir.Inst.Const = undefined; + for (result) |*tzir_const, i| { + tzir_const.* = .{ + .base = .{ + .tag = .constant, + .ty = zir.const_inst_list[i].ty, + .src = 0, + }, + .val = zir.const_inst_list[i].val, + }; + } + break :blk result; +}; + +pub fn root(sema: *Sema, root_block: *Scope.Block) !void { + const root_body = sema.code.extra[sema.code.root_start..][0..sema.code.root_len]; + return sema.body(root_block, root_body); +} + +pub fn rootAsType( + sema: *Sema, + root_block: *Scope.Block, + zir_result_inst: zir.Inst.Index, + body: zir.Body, +) !Type { + const root_body = sema.code.extra[sema.code.root_start..][0..sema.code.root_len]; + try sema.body(root_block, root_body); + + const result_inst = sema.inst_map[zir_result_inst]; + // Source location is unneeded because resolveConstValue must have already + // been successfully called when coercing the value to a type, from the + // result location. + const val = try sema.resolveConstValue(root_block, .unneeded, result_inst); + return val.toType(root_block.arena); +} + +pub fn body(sema: *Sema, block: *Scope.Block, body: []const zir.Inst.Index) !void { + const tracy = trace(@src()); + defer tracy.end(); + + const map = block.sema.inst_map; + const tags = block.sema.code.instructions.items(.tag); + + // TODO: As an optimization, look into making these switch prongs directly jump + // to the next one, rather than detouring through the loop condition. + // Also, look into leaving only the "noreturn" loop break condition, and removing + // the iteration based one. Better yet, have an extra entry in the tags array as a + // sentinel, so that exiting the loop is just another jump table prong. + // Related: https://github.com/ziglang/zig/issues/8220 + for (body) |zir_inst| { + map[zir_inst] = switch (tags[zir_inst]) { + .alloc => try sema.zirAlloc(block, zir_inst), + .alloc_mut => try sema.zirAllocMut(block, zir_inst), + .alloc_inferred => try sema.zirAllocInferred(block, zir_inst, Type.initTag(.inferred_alloc_const)), + .alloc_inferred_mut => try sema.zirAllocInferred(block, zir_inst, Type.initTag(.inferred_alloc_mut)), + .bitcast_ref => try sema.zirBitcastRef(block, zir_inst), + .bitcast_result_ptr => try sema.zirBitcastResultPtr(block, zir_inst), + .block => try sema.zirBlock(block, zir_inst, false), + .block_comptime => try sema.zirBlock(block, zir_inst, true), + .block_flat => try sema.zirBlockFlat(block, zir_inst, false), + .block_comptime_flat => try sema.zirBlockFlat(block, zir_inst, true), + .@"break" => try sema.zirBreak(block, zir_inst), + .break_void_tok => try sema.zirBreakVoidTok(block, zir_inst), + .breakpoint => try sema.zirBreakpoint(block, zir_inst), + .call => try sema.zirCall(block, zir_inst, .auto), + .call_async_kw => try sema.zirCall(block, zir_inst, .async_kw), + .call_no_async => try sema.zirCall(block, zir_inst, .no_async), + .call_compile_time => try sema.zirCall(block, zir_inst, .compile_time), + .call_none => try sema.zirCallNone(block, zir_inst), + .coerce_result_ptr => try sema.zirCoerceResultPtr(block, zir_inst), + .compile_error => try sema.zirCompileError(block, zir_inst), + .compile_log => try sema.zirCompileLog(block, zir_inst), + .@"const" => try sema.zirConst(block, zir_inst), + .dbg_stmt_node => try sema.zirDbgStmtNode(block, zir_inst), + .decl_ref => try sema.zirDeclRef(block, zir_inst), + .decl_val => try sema.zirDeclVal(block, zir_inst), + .ensure_result_used => try sema.zirEnsureResultUsed(block, zir_inst), + .ensure_result_non_error => try sema.zirEnsureResultNonError(block, zir_inst), + .indexable_ptr_len => try sema.zirIndexablePtrLen(block, zir_inst), + .ref => try sema.zirRef(block, zir_inst), + .resolve_inferred_alloc => try sema.zirResolveInferredAlloc(block, zir_inst), + .ret_ptr => try sema.zirRetPtr(block, zir_inst), + .ret_type => try sema.zirRetType(block, zir_inst), + .store_to_block_ptr => try sema.zirStoreToBlockPtr(block, zir_inst), + .store_to_inferred_ptr => try sema.zirStoreToInferredPtr(block, zir_inst), + .ptr_type_simple => try sema.zirPtrTypeSimple(block, zir_inst), + .ptr_type => try sema.zirPtrType(block, zir_inst), + .store => try sema.zirStore(block, zir_inst), + .set_eval_branch_quota => try sema.zirSetEvalBranchQuota(block, zir_inst), + .str => try sema.zirStr(block, zir_inst), + .int => try sema.zirInt(block, zir_inst), + .int_type => try sema.zirIntType(block, zir_inst), + .loop => try sema.zirLoop(block, zir_inst), + .param_type => try sema.zirParamType(block, zir_inst), + .ptrtoint => try sema.zirPtrtoint(block, zir_inst), + .field_ptr => try sema.zirFieldPtr(block, zir_inst), + .field_val => try sema.zirFieldVal(block, zir_inst), + .field_ptr_named => try sema.zirFieldPtrNamed(block, zir_inst), + .field_val_named => try sema.zirFieldValNamed(block, zir_inst), + .deref => try sema.zirDeref(block, zir_inst), + .as => try sema.zirAs(block, zir_inst), + .@"asm" => try sema.zirAsm(block, zir_inst, false), + .asm_volatile => try sema.zirAsm(block, zir_inst, true), + .unreachable_safe => try sema.zirUnreachable(block, zir_inst, true), + .unreachable_unsafe => try sema.zirUnreachable(block, zir_inst, false), + .ret_tok => try sema.zirRetTok(block, zir_inst), + .ret_node => try sema.zirRetNode(block, zir_inst), + .fn_type => try sema.zirFnType(block, zir_inst), + .fn_type_cc => try sema.zirFnTypeCc(block, zir_inst), + .intcast => try sema.zirIntcast(block, zir_inst), + .bitcast => try sema.zirBitcast(block, zir_inst), + .floatcast => try sema.zirFloatcast(block, zir_inst), + .elem_ptr => try sema.zirElemPtr(block, zir_inst), + .elem_ptr_node => try sema.zirElemPtrNode(block, zir_inst), + .elem_val => try sema.zirElemVal(block, zir_inst), + .elem_val_node => try sema.zirElemValNode(block, zir_inst), + .add => try sema.zirArithmetic(block, zir_inst), + .addwrap => try sema.zirArithmetic(block, zir_inst), + .sub => try sema.zirArithmetic(block, zir_inst), + .subwrap => try sema.zirArithmetic(block, zir_inst), + .mul => try sema.zirArithmetic(block, zir_inst), + .mulwrap => try sema.zirArithmetic(block, zir_inst), + .div => try sema.zirArithmetic(block, zir_inst), + .mod_rem => try sema.zirArithmetic(block, zir_inst), + .array_cat => try sema.zirArrayCat(block, zir_inst), + .array_mul => try sema.zirArrayMul(block, zir_inst), + .bit_and => try sema.zirBitwise(block, zir_inst), + .bit_not => try sema.zirBitNot(block, zir_inst), + .bit_or => try sema.zirBitwise(block, zir_inst), + .xor => try sema.zirBitwise(block, zir_inst), + .shl => try sema.zirShl(block, zir_inst), + .shr => try sema.zirShr(block, zir_inst), + .cmp_lt => try sema.zirCmp(block, zir_inst, .lt), + .cmp_lte => try sema.zirCmp(block, zir_inst, .lte), + .cmp_eq => try sema.zirCmp(block, zir_inst, .eq), + .cmp_gte => try sema.zirCmp(block, zir_inst, .gte), + .cmp_gt => try sema.zirCmp(block, zir_inst, .gt), + .cmp_neq => try sema.zirCmp(block, zir_inst, .neq), + .condbr => try sema.zirCondbr(block, zir_inst), + .is_null => try sema.zirIsNull(block, zir_inst, false), + .is_non_null => try sema.zirIsNull(block, zir_inst, true), + .is_null_ptr => try sema.zirIsNullPtr(block, zir_inst, false), + .is_non_null_ptr => try sema.zirIsNullPtr(block, zir_inst, true), + .is_err => try sema.zirIsErr(block, zir_inst), + .is_err_ptr => try sema.zirIsErrPtr(block, zir_inst), + .bool_not => try sema.zirBoolNot(block, zir_inst), + .typeof => try sema.zirTypeof(block, zir_inst), + .typeof_peer => try sema.zirTypeofPeer(block, zir_inst), + .optional_type => try sema.zirOptionalType(block, zir_inst), + .optional_type_from_ptr_elem => try sema.zirOptionalTypeFromPtrElem(block, zir_inst), + .optional_payload_safe => try sema.zirOptionalPayload(block, zir_inst, true), + .optional_payload_unsafe => try sema.zirOptionalPayload(block, zir_inst, false), + .optional_payload_safe_ptr => try sema.zirOptionalPayloadPtr(block, zir_inst, true), + .optional_payload_unsafe_ptr => try sema.zirOptionalPayloadPtr(block, zir_inst, false), + .err_union_payload_safe => try sema.zirErrUnionPayload(block, zir_inst, true), + .err_union_payload_unsafe => try sema.zirErrUnionPayload(block, zir_inst, false), + .err_union_payload_safe_ptr => try sema.zirErrUnionPayloadPtr(block, zir_inst, true), + .err_union_payload_unsafe_ptr => try sema.zirErrUnionPayloadPtr(block, zir_inst, false), + .err_union_code => try sema.zirErrUnionCode(block, zir_inst), + .err_union_code_ptr => try sema.zirErrUnionCodePtr(block, zir_inst), + .ensure_err_payload_void => try sema.zirEnsureErrPayloadVoid(block, zir_inst), + .array_type => try sema.zirArrayType(block, zir_inst), + .array_type_sentinel => try sema.zirArrayTypeSentinel(block, zir_inst), + .enum_literal => try sema.zirEnumLiteral(block, zir_inst), + .merge_error_sets => try sema.zirMergeErrorSets(block, zir_inst), + .error_union_type => try sema.zirErrorUnionType(block, zir_inst), + .anyframe_type => try sema.zirAnyframeType(block, zir_inst), + .error_set => try sema.zirErrorSet(block, zir_inst), + .error_value => try sema.zirErrorValue(block, zir_inst), + .slice_start => try sema.zirSliceStart(block, zir_inst), + .slice_end => try sema.zirSliceEnd(block, zir_inst), + .slice_sentinel => try sema.zirSliceSentinel(block, zir_inst), + .import => try sema.zirImport(block, zir_inst), + .bool_and => try sema.zirBoolOp(block, zir_inst, false), + .bool_or => try sema.zirBoolOp(block, zir_inst, true), + .void_value => try sema.mod.constVoid(block.arena, .unneeded), + .switchbr => try sema.zirSwitchBr(block, zir_inst, false), + .switchbr_ref => try sema.zirSwitchBr(block, zir_inst, true), + .switch_range => try sema.zirSwitchRange(block, zir_inst), + }; + if (map[zir_inst].ty.isNoReturn()) { + break; + } + } +} + +fn resolveInst(sema: *Sema, block: *Scope.Block, zir_ref: zir.Inst.Ref) *const ir.Inst { + var i = zir_ref; + + // First section of indexes correspond to a set number of constant values. + if (i < const_tzir_inst_list.len) { + return &const_tzir_inst_list[i]; + } + i -= const_tzir_inst_list.len; + + // Next section of indexes correspond to function parameters, if any. + if (block.inlining) |inlining| { + if (i < inlining.casted_args.len) { + return inlining.casted_args[i]; + } + i -= inlining.casted_args.len; + } else { + if (i < sema.param_inst_list.len) { + return sema.param_inst_list[i]; + } + i -= sema.param_inst_list.len; + } + + // Finally, the last section of indexes refers to the map of ZIR=>TZIR. + return sema.inst_map[i]; +} + +fn resolveConstString( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + zir_ref: zir.Inst.Ref, +) ![]u8 { + const tzir_inst = sema.resolveInst(block, zir_ref); + const wanted_type = Type.initTag(.const_slice_u8); + const coerced_inst = try sema.coerce(block, wanted_type, tzir_inst); + const val = try sema.resolveConstValue(block, src, coerced_inst); + return val.toAllocatedBytes(block.arena); +} + +fn resolveType(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, zir_ref: zir.Inst.Ref) !Type { + const tzir_inst = sema.resolveInt(block, zir_ref); + const wanted_type = Type.initTag(.@"type"); + const coerced_inst = try sema.coerce(block, wanted_type, tzir_inst); + const val = try sema.resolveConstValue(block, src, coerced_inst); + return val.toType(sema.arena); +} + +fn resolveConstValue(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, base: *ir.Inst) !Value { + return (try sema.resolveDefinedValue(block, src, base)) orelse + return sema.mod.fail(&block.base, src, "unable to resolve comptime value", .{}); +} + +fn resolveDefinedValue(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, base: *ir.Inst) !?Value { + if (base.value()) |val| { + if (val.isUndef()) { + return sema.mod.fail(&block.base, src, "use of undefined value here causes undefined behavior", .{}); + } + return val; + } + return null; +} + +/// Appropriate to call when the coercion has already been done by result +/// location semantics. Asserts the value fits in the provided `Int` type. +/// Only supports `Int` types 64 bits or less. +fn resolveAlreadyCoercedInt( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + zir_ref: zir.Inst.Ref, + comptime Int: type, +) !Int { + comptime assert(@typeInfo(Int).Int.bits <= 64); + const tzir_inst = sema.resolveInst(block, zir_ref); + const val = try sema.resolveConstValue(block, src, tzir_inst); + switch (@typeInfo(Int).Int.signedness) { + .signed => return @intCast(Int, val.toSignedInt()), + .unsigned => return @intCast(Int, val.toUnsignedInt()), + } +} + +fn resolveInt( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + zir_ref: zir.Inst.Ref, + dest_type: Type, +) !u64 { + const tzir_inst = sema.resolveInst(block, zir_ref); + const coerced = try sema.coerce(scope, dest_type, tzir_inst); + const val = try sema.resolveConstValue(block, src, coerced); + + return val.toUnsignedInt(); +} + +fn resolveInstConst( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + zir_ref: zir.Inst.Ref, +) InnerError!TypedValue { + const tzir_inst = sema.resolveInst(block, zir_ref); + const val = try sema.resolveConstValue(block, src, tzir_inst); + return TypedValue{ + .ty = tzir_inst.ty, + .val = val, + }; +} + +fn zirConst(sema: *Sema, block: *Scope.Block, const_inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + // Move the TypedValue from old memory to new memory. This allows freeing the ZIR instructions + // after analysis. + const typed_value_copy = try const_inst.positionals.typed_value.copy(block.arena); + return sema.mod.constInst(scope, const_inst.base.src, typed_value_copy); +} + +fn zirBitcastRef(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + return sema.mod.fail(&block.base, inst.base.src, "TODO implement zir_sema.zirBitcastRef", .{}); +} + +fn zirBitcastResultPtr(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + return sema.mod.fail(&block.base, inst.base.src, "TODO implement zir_sema.zirBitcastResultPtr", .{}); +} + +fn zirCoerceResultPtr(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + return sema.mod.fail(&block.base, inst.base.src, "TODO implement zirCoerceResultPtr", .{}); +} + +fn zirRetPtr(sema: *Module, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + try sema.requireFunctionBlock(block, inst.base.src); + const fn_ty = block.func.?.owner_decl.typed_value.most_recent.typed_value.ty; + const ret_type = fn_ty.fnReturnType(); + const ptr_type = try sema.mod.simplePtrType(block.arena, ret_type, true, .One); + return block.addNoOp(inst.base.src, ptr_type, .alloc); +} + +fn zirRef(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const operand = sema.resolveInst(block, inst_data.operand); + return sema.analyzeRef(block, inst_data.src(), operand); +} + +fn zirRetType(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + try sema.requireFunctionBlock(block, inst.base.src); + const fn_ty = b.func.?.owner_decl.typed_value.most_recent.typed_value.ty; + const ret_type = fn_ty.fnReturnType(); + return sema.mod.constType(block.arena, inst.base.src, ret_type); +} + +fn zirEnsureResultUsed(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const operand = sema.resolveInst(block, inst_data.operand); + const src = inst_data.src(); + switch (operand.ty.zigTypeTag()) { + .Void, .NoReturn => return sema.mod.constVoid(block.arena, .unneeded), + else => return sema.mod.fail(&block.base, src, "expression value is ignored", .{}), + } +} + +fn zirEnsureResultNonError(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const operand = sema.resolveInst(block, inst_data.operand); + const src = inst_data.src(); + switch (operand.ty.zigTypeTag()) { + .ErrorSet, .ErrorUnion => return sema.mod.fail(&block.base, src, "error is discarded", .{}), + else => return sema.mod.constVoid(block.arena, .unneeded), + } +} + +fn zirIndexablePtrLen(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const array_ptr = sema.resolveInst(block, inst_data.operand); + + const elem_ty = array_ptr.ty.elemType(); + if (!elem_ty.isIndexable()) { + const cond_src: LazySrcLoc = .{ .node_offset_for_cond = inst_data.src_node }; + const msg = msg: { + const msg = try sema.mod.errMsg( + &block.base, + cond_src, + "type '{}' does not support indexing", + .{elem_ty}, + ); + errdefer msg.destroy(mod.gpa); + try sema.mod.errNote( + &block.base, + cond_src, + msg, + "for loop operand must be an array, slice, tuple, or vector", + .{}, + ); + break :msg msg; + }; + return mod.failWithOwnedErrorMsg(scope, msg); + } + const result_ptr = try sema.namedFieldPtr(block, inst.base.src, array_ptr, "len", inst.base.src); + return sema.analyzeDeref(block, inst.base.src, result_ptr, result_ptr.src); +} + +fn zirAlloc(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const ty_src: LazySrcLoc = .{ .node_offset_var_decl_ty = inst_data.src_node }; + const var_decl_src = inst_data.src(); + const var_type = try sema.resolveType(block, ty_src, inst_data.operand); + const ptr_type = try sema.mod.simplePtrType(block.arena, var_type, true, .One); + try sema.requireRuntimeBlock(block, var_decl_src); + return block.addNoOp(var_decl_src, ptr_type, .alloc); +} + +fn zirAllocMut(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const var_decl_src = inst_data.src(); + const ty_src: LazySrcLoc = .{ .node_offset_var_decl_ty = inst_data.src_node }; + const var_type = try sema.resolveType(block, ty_src, inst_data.operand); + try sema.validateVarType(block, ty_src, var_type); + const ptr_type = try sema.mod.simplePtrType(block.arena, var_type, true, .One); + try sema.requireRuntimeBlock(block, var_decl_src); + return block.addNoOp(var_decl_src, ptr_type, .alloc); +} + +fn zirAllocInferred( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, + inferred_alloc_ty: Type, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + const val_payload = try block.arena.create(Value.Payload.InferredAlloc); + val_payload.* = .{ + .data = .{}, + }; + // `Module.constInst` does not add the instruction to the block because it is + // not needed in the case of constant values. However here, we plan to "downgrade" + // to a normal instruction when we hit `resolve_inferred_alloc`. So we append + // to the block even though it is currently a `.constant`. + const result = try sema.mod.constInst(scope, inst.base.src, .{ + .ty = inferred_alloc_ty, + .val = Value.initPayload(&val_payload.base), + }); + try sema.requireFunctionBlock(block, inst.base.src); + try block.instructions.append(sema.gpa, result); + return result; +} + +fn zirResolveInferredAlloc( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const ty_src: LazySrcLoc = .{ .node_offset_var_decl_ty = inst_data.src_node }; + const ptr = sema.resolveInst(block, inst_data.operand); + const ptr_val = ptr.castTag(.constant).?.val; + const inferred_alloc = ptr_val.castTag(.inferred_alloc).?; + const peer_inst_list = inferred_alloc.data.stored_inst_list.items; + const final_elem_ty = try sema.resolvePeerTypes(block, peer_inst_list); + const var_is_mut = switch (ptr.ty.tag()) { + .inferred_alloc_const => false, + .inferred_alloc_mut => true, + else => unreachable, + }; + if (var_is_mut) { + try sema.validateVarType(block, ty_src, final_elem_ty); + } + const final_ptr_ty = try sema.mod.simplePtrType(block.arena, final_elem_ty, true, .One); + + // Change it to a normal alloc. + ptr.ty = final_ptr_ty; + ptr.tag = .alloc; + + return sema.mod.constVoid(block.arena, .unneeded); +} + +fn zirStoreToBlockPtr( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const ptr = sema.resolveInst(bin_inst.lhs); + const value = sema.resolveInst(bin_inst.rhs); + const ptr_ty = try sema.mod.simplePtrType(block.arena, value.ty, true, .One); + // TODO detect when this store should be done at compile-time. For example, + // if expressions should force it when the condition is compile-time known. + try sema.requireRuntimeBlock(block, src); + const bitcasted_ptr = try block.addUnOp(inst.base.src, ptr_ty, .bitcast, ptr); + return mod.storePtr(scope, inst.base.src, bitcasted_ptr, value); +} + +fn zirStoreToInferredPtr( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const ptr = sema.resolveInst(bin_inst.lhs); + const value = sema.resolveInst(bin_inst.rhs); + const inferred_alloc = ptr.castTag(.constant).?.val.castTag(.inferred_alloc).?; + // Add the stored instruction to the set we will use to resolve peer types + // for the inferred allocation. + try inferred_alloc.data.stored_inst_list.append(block.arena, value); + // Create a runtime bitcast instruction with exactly the type the pointer wants. + const ptr_ty = try sema.mod.simplePtrType(block.arena, value.ty, true, .One); + try sema.requireRuntimeBlock(block, src); + const bitcasted_ptr = try block.addUnOp(inst.base.src, ptr_ty, .bitcast, ptr); + return mod.storePtr(scope, inst.base.src, bitcasted_ptr, value); +} + +fn zirSetEvalBranchQuota( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, +) InnerError!*Inst { + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const src = inst_data.src(); + try sema.requireFunctionBlock(block, src); + const quota = try sema.resolveAlreadyCoercedInt(block, src, inst_data.operand, u32); + if (b.branch_quota.* < quota) + b.branch_quota.* = quota; + return sema.mod.constVoid(block.arena, .unneeded); +} + +fn zirStore(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const ptr = sema.resolveInst(bin_inst.lhs); + const value = sema.resolveInst(bin_inst.rhs); + return mod.storePtr(scope, inst.base.src, ptr, value); +} + +fn zirParamType(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].param_type; + const fn_inst = sema.resolveInst(inst_data.callee); + const param_index = inst_data.param_index; + + const fn_ty: Type = switch (fn_inst.ty.zigTypeTag()) { + .Fn => fn_inst.ty, + .BoundFn => { + return sema.mod.fail(&block.base, fn_inst.src, "TODO implement zirParamType for method call syntax", .{}); + }, + else => { + return sema.mod.fail(&block.base, fn_inst.src, "expected function, found '{}'", .{fn_inst.ty}); + }, + }; + + const param_count = fn_ty.fnParamLen(); + if (param_index >= param_count) { + if (fn_ty.fnIsVarArgs()) { + return sema.mod.constType(block.arena, inst.base.src, Type.initTag(.var_args_param)); + } + return sema.mod.fail(&block.base, inst.base.src, "arg index {d} out of bounds; '{}' has {d} argument(s)", .{ + param_index, + fn_ty, + param_count, + }); + } + + // TODO support generic functions + const param_type = fn_ty.fnParamType(param_index); + return sema.mod.constType(block.arena, inst.base.src, param_type); +} + +fn zirStr(sema: *Sema, block: *Scope.Block, str_inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + // The bytes references memory inside the ZIR module, which is fine. Multiple + // anonymous Decls may have strings which point to within the same ZIR module. + const bytes = sema.code.instructions.items(.data)[inst].str.get(sema.code); + + var new_decl_arena = std.heap.ArenaAllocator.init(sema.gpa); + errdefer new_decl_arena.deinit(); + + const decl_ty = try Type.Tag.array_u8_sentinel_0.create(&new_decl_arena.allocator, bytes.len); + const decl_val = try Value.Tag.bytes.create(&new_decl_arena.allocator, bytes); + + const new_decl = try sema.mod.createAnonymousDecl(&block.base, &new_decl_arena, .{ + .ty = decl_ty, + .val = decl_val, + }); + return sema.analyzeDeclRef(block, .unneeded, new_decl); +} + +fn zirInt(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + return mod.constIntBig(scope, inst.base.src, Type.initTag(.comptime_int), inst.positionals.int); +} + +fn zirCompileError(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const src = inst_data.src(); + const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node }; + const msg = try sema.resolveConstString(block, operand_src, inst_data.operand); + return sema.mod.fail(&block.base, src, "{s}", .{msg}); +} + +fn zirCompileLog(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + var managed = mod.compile_log_text.toManaged(mod.gpa); + defer mod.compile_log_text = managed.moveToUnmanaged(); + const writer = managed.writer(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const extra = sema.code.extraData(zir.Inst.MultiOp, inst_data.payload_index); + for (sema.code.extra[extra.end..][0..extra.data.operands_len]) |arg_ref, i| { + if (i != 0) try writer.print(", ", .{}); + + const arg = sema.resolveInst(block, arg_ref); + if (arg.value()) |val| { + try writer.print("@as({}, {})", .{ arg.ty, val }); + } else { + try writer.print("@as({}, [runtime value])", .{arg.ty}); + } + } + try writer.print("\n", .{}); + + const gop = try mod.compile_log_decls.getOrPut(mod.gpa, scope.ownerDecl().?); + if (!gop.found_existing) { + gop.entry.value = .{ + .file_scope = block.getFileScope(), + .lazy = inst_data.src(), + }; + } + return sema.mod.constVoid(block.arena, .unneeded); +} + +fn zirLoop(sema: *Sema, parent_block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + // Reserve space for a Loop instruction so that generated Break instructions can + // point to it, even if it doesn't end up getting used because the code ends up being + // comptime evaluated. + const loop_inst = try parent_block.arena.create(Inst.Loop); + loop_inst.* = .{ + .base = .{ + .tag = Inst.Loop.base_tag, + .ty = Type.initTag(.noreturn), + .src = inst.base.src, + }, + .body = undefined, + }; + + var child_block: Scope.Block = .{ + .parent = parent_block, + .inst_table = parent_block.inst_table, + .func = parent_block.func, + .owner_decl = parent_block.owner_decl, + .src_decl = parent_block.src_decl, + .instructions = .{}, + .arena = parent_block.arena, + .inlining = parent_block.inlining, + .is_comptime = parent_block.is_comptime, + .branch_quota = parent_block.branch_quota, + }; + defer child_block.instructions.deinit(mod.gpa); + + try sema.body(&child_block, inst.positionals.body); + + // Loop repetition is implied so the last instruction may or may not be a noreturn instruction. + + try parent_block.instructions.append(mod.gpa, &loop_inst.base); + loop_inst.body = .{ .instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items) }; + return &loop_inst.base; +} + +fn zirBlockFlat(sema: *Sema, parent_block: *Scope.Block, inst: zir.Inst.Index, is_comptime: bool) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + var child_block = parent_block.makeSubBlock(); + defer child_block.instructions.deinit(mod.gpa); + child_block.is_comptime = child_block.is_comptime or is_comptime; + + try sema.body(&child_block, inst.positionals.body); + + // Move the analyzed instructions into the parent block arena. + const copied_instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items); + try parent_block.instructions.appendSlice(mod.gpa, copied_instructions); + + // The result of a flat block is the last instruction. + const zir_inst_list = inst.positionals.body.instructions; + const last_zir_inst = zir_inst_list[zir_inst_list.len - 1]; + return sema.inst_map[last_zir_inst]; +} + +fn zirBlock( + sema: *Sema, + parent_block: *Scope.Block, + inst: zir.Inst.Index, + is_comptime: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + // Reserve space for a Block instruction so that generated Break instructions can + // point to it, even if it doesn't end up getting used because the code ends up being + // comptime evaluated. + const block_inst = try parent_block.arena.create(Inst.Block); + block_inst.* = .{ + .base = .{ + .tag = Inst.Block.base_tag, + .ty = undefined, // Set after analysis. + .src = inst.base.src, + }, + .body = undefined, + }; + + var child_block: Scope.Block = .{ + .parent = parent_block, + .inst_table = parent_block.inst_table, + .func = parent_block.func, + .owner_decl = parent_block.owner_decl, + .src_decl = parent_block.src_decl, + .instructions = .{}, + .arena = parent_block.arena, + // TODO @as here is working around a stage1 miscompilation bug :( + .label = @as(?Scope.Block.Label, Scope.Block.Label{ + .zir_block = inst, + .merges = .{ + .results = .{}, + .br_list = .{}, + .block_inst = block_inst, + }, + }), + .inlining = parent_block.inlining, + .is_comptime = is_comptime or parent_block.is_comptime, + .branch_quota = parent_block.branch_quota, + }; + const merges = &child_block.label.?.merges; + + defer child_block.instructions.deinit(mod.gpa); + defer merges.results.deinit(mod.gpa); + defer merges.br_list.deinit(mod.gpa); + + try sema.body(&child_block, inst.positionals.body); + + return analyzeBlockBody(mod, scope, &child_block, merges); +} + +fn analyzeBlockBody( + sema: *Sema, + parent_block: *Scope.Block, + child_block: *Scope.Block, + merges: *Scope.Block.Merges, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + // Blocks must terminate with noreturn instruction. + assert(child_block.instructions.items.len != 0); + assert(child_block.instructions.items[child_block.instructions.items.len - 1].ty.isNoReturn()); + + if (merges.results.items.len == 0) { + // No need for a block instruction. We can put the new instructions + // directly into the parent block. + const copied_instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items); + try parent_block.instructions.appendSlice(mod.gpa, copied_instructions); + return copied_instructions[copied_instructions.len - 1]; + } + if (merges.results.items.len == 1) { + const last_inst_index = child_block.instructions.items.len - 1; + const last_inst = child_block.instructions.items[last_inst_index]; + if (last_inst.breakBlock()) |br_block| { + if (br_block == merges.block_inst) { + // No need for a block instruction. We can put the new instructions directly + // into the parent block. Here we omit the break instruction. + const copied_instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items[0..last_inst_index]); + try parent_block.instructions.appendSlice(mod.gpa, copied_instructions); + return merges.results.items[0]; + } + } + } + // It is impossible to have the number of results be > 1 in a comptime scope. + assert(!child_block.is_comptime); // Should already got a compile error in the condbr condition. + + // Need to set the type and emit the Block instruction. This allows machine code generation + // to emit a jump instruction to after the block when it encounters the break. + try parent_block.instructions.append(mod.gpa, &merges.block_inst.base); + const resolved_ty = try sema.resolvePeerTypes(parent_block, merges.results.items); + merges.block_inst.base.ty = resolved_ty; + merges.block_inst.body = .{ + .instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items), + }; + // Now that the block has its type resolved, we need to go back into all the break + // instructions, and insert type coercion on the operands. + for (merges.br_list.items) |br| { + if (br.operand.ty.eql(resolved_ty)) { + // No type coercion needed. + continue; + } + var coerce_block = parent_block.makeSubBlock(); + defer coerce_block.instructions.deinit(mod.gpa); + const coerced_operand = try sema.coerce(&coerce_block.base, resolved_ty, br.operand); + // If no instructions were produced, such as in the case of a coercion of a + // constant value to a new type, we can simply point the br operand to it. + if (coerce_block.instructions.items.len == 0) { + br.operand = coerced_operand; + continue; + } + assert(coerce_block.instructions.items[coerce_block.instructions.items.len - 1] == coerced_operand); + // Here we depend on the br instruction having been over-allocated (if necessary) + // inide analyzeBreak so that it can be converted into a br_block_flat instruction. + const br_src = br.base.src; + const br_ty = br.base.ty; + const br_block_flat = @ptrCast(*Inst.BrBlockFlat, br); + br_block_flat.* = .{ + .base = .{ + .src = br_src, + .ty = br_ty, + .tag = .br_block_flat, + }, + .block = merges.block_inst, + .body = .{ + .instructions = try parent_block.arena.dupe(*Inst, coerce_block.instructions.items), + }, + }; + } + return &merges.block_inst.base; +} + +fn zirBreakpoint(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + try sema.requireRuntimeBlock(block, src); + return block.addNoOp(inst.base.src, Type.initTag(.void), .breakpoint); +} + +fn zirBreak(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const operand = sema.resolveInst(block, bin_inst.rhs); + const zir_block = bin_inst.lhs; + return analyzeBreak(mod, block, sema.src, zir_block, operand); +} + +fn zirBreakVoidTok(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const zir_block = inst_data.operand; + const void_inst = try sema.mod.constVoid(block.arena, .unneeded); + return analyzeBreak(mod, block, inst_data.src(), zir_block, void_inst); +} + +fn analyzeBreak( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + zir_block: zir.Inst.Index, + operand: *Inst, +) InnerError!*Inst { + var opt_block = scope.cast(Scope.Block); + while (opt_block) |block| { + if (block.label) |*label| { + if (label.zir_block == zir_block) { + try sema.requireFunctionBlock(block, src); + // Here we add a br instruction, but we over-allocate a little bit + // (if necessary) to make it possible to convert the instruction into + // a br_block_flat instruction later. + const br = @ptrCast(*Inst.Br, try b.arena.alignedAlloc( + u8, + Inst.convertable_br_align, + Inst.convertable_br_size, + )); + br.* = .{ + .base = .{ + .tag = .br, + .ty = Type.initTag(.noreturn), + .src = src, + }, + .operand = operand, + .block = label.merges.block_inst, + }; + try b.instructions.append(mod.gpa, &br.base); + try label.merges.results.append(mod.gpa, operand); + try label.merges.br_list.append(mod.gpa, br); + return &br.base; + } + } + opt_block = block.parent; + } else unreachable; +} + +fn zirDbgStmtNode(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + if (b.is_comptime) { + return sema.mod.constVoid(block.arena, .unneeded); + } + + const src_node = sema.code.instructions.items(.data)[inst].node; + const src: LazySrcLoc = .{ .node_offset = src_node }; + return block.addNoOp(src, Type.initTag(.void), .dbg_stmt); +} + +fn zirDeclRef(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const decl = sema.code.instructions.items(.data)[inst].decl; + return sema.analyzeDeclRef(block, .unneeded, decl); +} + +fn zirDeclVal(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const decl = sema.code.instructions.items(.data)[inst].decl; + return sema.analyzeDeclVal(block, .unneeded, decl); +} + +fn zirCallNone(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const func_src: LazySrcLoc = .{ .node_offset_call_func = inst_data.src_node }; + + return sema.analyzeCall(block, inst_data.operand, func_src, inst_data.src(), .auto, &.{}); +} + +fn zirCall( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, + modifier: std.builtin.CallOptions.Modifier, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const func_src: LazySrcLoc = .{ .node_offset_call_func = inst_data.src_node }; + const call_src = inst_data.src(); + const extra = sema.code.extraData(zir.Inst.Call, inst_data.payload_index); + const args = sema.code.extra[extra.end..][0..extra.data.args_len]; + + return sema.analyzeCall(block, extra.data.callee, func_src, call_src, modifier, args); +} + +fn analyzeCall( + sema: *Sema, + block: *Scope.Block, + zir_func: zir.Inst.Ref, + func_src: LazySrcLoc, + call_src: LazySrcLoc, + modifier: std.builtin.CallOptions.Modifier, + zir_args: []const Ref, +) InnerError!*ir.Inst { + const func = sema.resolveInst(zir_func); + + if (func.ty.zigTypeTag() != .Fn) + return sema.mod.fail(&block.base, func_src, "type '{}' not a function", .{func.ty}); + + const cc = func.ty.fnCallingConvention(); + if (cc == .Naked) { + // TODO add error note: declared here + return sema.mod.fail( + &block.base, + func_src, + "unable to call function with naked calling convention", + .{}, + ); + } + const fn_params_len = func.ty.fnParamLen(); + if (func.ty.fnIsVarArgs()) { + assert(cc == .C); + if (zir_args.len < fn_params_len) { + // TODO add error note: declared here + return sema.mod.fail( + &block.base, + func_src, + "expected at least {d} argument(s), found {d}", + .{ fn_params_len, zir_args.len }, + ); + } + } else if (fn_params_len != zir_args.len) { + // TODO add error note: declared here + return sema.mod.fail( + &block.base, + func_src, + "expected {d} argument(s), found {d}", + .{ fn_params_len, zir_args.len }, + ); + } + + if (modifier == .compile_time) { + return sema.mod.fail(&block.base, call_src, "TODO implement comptime function calls", .{}); + } + if (modifier != .auto) { + return sema.mod.fail(&block.base, call_src, "TODO implement call with modifier {}", .{inst.positionals.modifier}); + } + + // TODO handle function calls of generic functions + const casted_args = try block.arena.alloc(*Inst, zir_args.len); + for (zir_args) |zir_arg, i| { + // the args are already casted to the result of a param type instruction. + casted_args[i] = sema.resolveInst(block, zir_arg); + } + + const ret_type = func.ty.fnReturnType(); + + try sema.requireFunctionBlock(block, call_src); + const is_comptime_call = b.is_comptime or modifier == .compile_time; + const is_inline_call = is_comptime_call or modifier == .always_inline or + func.ty.fnCallingConvention() == .Inline; + if (is_inline_call) { + const func_val = try sema.resolveConstValue(block, func_src, func); + const module_fn = switch (func_val.tag()) { + .function => func_val.castTag(.function).?.data, + .extern_fn => return sema.mod.fail(&block.base, call_src, "{s} call of extern function", .{ + @as([]const u8, if (is_comptime_call) "comptime" else "inline"), + }), + else => unreachable, + }; + + // Analyze the ZIR. The same ZIR gets analyzed into a runtime function + // or an inlined call depending on what union tag the `label` field is + // set to in the `Scope.Block`. + // This block instruction will be used to capture the return value from the + // inlined function. + const block_inst = try block.arena.create(Inst.Block); + block_inst.* = .{ + .base = .{ + .tag = Inst.Block.base_tag, + .ty = ret_type, + .src = call_src, + }, + .body = undefined, + }; + // If this is the top of the inline/comptime call stack, we use this data. + // Otherwise we pass on the shared data from the parent scope. + var shared_inlining: Scope.Block.Inlining.Shared = .{ + .branch_count = 0, + .caller = b.func, + }; + // This one is shared among sub-blocks within the same callee, but not + // shared among the entire inline/comptime call stack. + var inlining: Scope.Block.Inlining = .{ + .shared = if (b.inlining) |inlining| inlining.shared else &shared_inlining, + .param_index = 0, + .casted_args = casted_args, + .merges = .{ + .results = .{}, + .br_list = .{}, + .block_inst = block_inst, + }, + }; + var inst_table = Scope.Block.InstTable.init(mod.gpa); + defer inst_table.deinit(); + + var child_block: Scope.Block = .{ + .parent = null, + .inst_table = &inst_table, + .func = module_fn, + .owner_decl = scope.ownerDecl().?, + .src_decl = module_fn.owner_decl, + .instructions = .{}, + .arena = block.arena, + .label = null, + .inlining = &inlining, + .is_comptime = is_comptime_call, + .branch_quota = b.branch_quota, + }; + + const merges = &child_block.inlining.?.merges; + + defer child_block.instructions.deinit(mod.gpa); + defer merges.results.deinit(mod.gpa); + defer merges.br_list.deinit(mod.gpa); + + try mod.emitBackwardBranch(&child_block, call_src); + + // This will have return instructions analyzed as break instructions to + // the block_inst above. + try sema.body(&child_block, module_fn.zir); + + return analyzeBlockBody(mod, scope, &child_block, merges); + } + + return block.addCall(call_src, ret_type, func, casted_args); +} + +fn zirIntType(sema: *Sema, block: *Scope.Block, inttype: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + return sema.mod.fail(&block.base, inttype.base.src, "TODO implement inttype", .{}); +} + +fn zirOptionalType(sema: *Sema, block: *Scope.Block, optional: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const child_type = try sema.resolveType(block, inst_data.operand); + const opt_type = try mod.optionalType(block.arena, child_type); + + return sema.mod.constType(block.arena, inst_data.src(), opt_type); +} + +fn zirOptionalTypeFromPtrElem(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const ptr = sema.resolveInst(block, inst_data.operand); + const elem_ty = ptr.ty.elemType(); + const opt_ty = try mod.optionalType(block.arena, elem_ty); + + return sema.mod.constType(block.arena, inst_data.src(), opt_ty); +} + +fn zirArrayType(sema: *Sema, block: *Scope.Block, array: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + // TODO these should be lazily evaluated + const len = try resolveInstConst(mod, scope, array.positionals.lhs); + const elem_type = try sema.resolveType(block, array.positionals.rhs); + + return sema.mod.constType(block.arena, array.base.src, try mod.arrayType(scope, len.val.toUnsignedInt(), null, elem_type)); +} + +fn zirArrayTypeSentinel(sema: *Sema, block: *Scope.Block, array: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + // TODO these should be lazily evaluated + const len = try resolveInstConst(mod, scope, array.positionals.len); + const sentinel = try resolveInstConst(mod, scope, array.positionals.sentinel); + const elem_type = try sema.resolveType(block, array.positionals.elem_type); + + return sema.mod.constType(block.arena, array.base.src, try mod.arrayType(scope, len.val.toUnsignedInt(), sentinel.val, elem_type)); +} + +fn zirErrorUnionType(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const error_union = try sema.resolveType(block, bin_inst.lhs); + const payload = try sema.resolveType(block, bin_inst.rhs); + + if (error_union.zigTypeTag() != .ErrorSet) { + return sema.mod.fail(&block.base, inst.base.src, "expected error set type, found {}", .{error_union.elemType()}); + } + + return sema.mod.constType(block.arena, inst.base.src, try mod.errorUnionType(scope, error_union, payload)); +} + +fn zirAnyframeType(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const src = inst_data.src(); + const operand_src: LazySrcLoc = .{ .node_offset_anyframe_type = inst_data.src_node }; + const return_type = try sema.resolveType(block, operand_src, inst_data.operand); + const anyframe_type = try sema.mod.anyframeType(block.arena, return_type); + + return sema.mod.constType(block.arena, src, anyframe_type); +} + +fn zirErrorSet(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + // The owner Decl arena will store the hashmap. + var new_decl_arena = std.heap.ArenaAllocator.init(mod.gpa); + errdefer new_decl_arena.deinit(); + + const payload = try new_decl_arena.allocator.create(Value.Payload.ErrorSet); + payload.* = .{ + .base = .{ .tag = .error_set }, + .data = .{ + .fields = .{}, + .decl = undefined, // populated below + }, + }; + try payload.data.fields.ensureCapacity(&new_decl_arena.allocator, @intCast(u32, inst.positionals.fields.len)); + + for (inst.positionals.fields) |field_name| { + const entry = try mod.getErrorValue(field_name); + if (payload.data.fields.fetchPutAssumeCapacity(entry.key, {})) |_| { + return sema.mod.fail(&block.base, inst.base.src, "duplicate error: '{s}'", .{field_name}); + } + } + // TODO create name in format "error:line:column" + const new_decl = try mod.createAnonymousDecl(scope, &new_decl_arena, .{ + .ty = Type.initTag(.type), + .val = Value.initPayload(&payload.base), + }); + payload.data.decl = new_decl; + return mod.analyzeDeclVal(scope, inst.base.src, new_decl); +} + +fn zirErrorValue(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + // Create an anonymous error set type with only this error value, and return the value. + const entry = try mod.getErrorValue(inst.positionals.name); + const result_type = try Type.Tag.error_set_single.create(block.arena, entry.key); + return sema.mod.constInst(scope, inst.base.src, .{ + .ty = result_type, + .val = try Value.Tag.@"error".create(block.arena, .{ + .name = entry.key, + }), + }); +} + +fn zirMergeErrorSets(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const lhs_ty = try sema.resolveType(block, bin_inst.lhs); + const rhs_ty = try sema.resolveType(block, bin_inst.rhs); + if (rhs_ty.zigTypeTag() != .ErrorSet) + return sema.mod.fail(&block.base, inst.positionals.rhs.src, "expected error set type, found {}", .{rhs_ty}); + if (lhs_ty.zigTypeTag() != .ErrorSet) + return sema.mod.fail(&block.base, inst.positionals.lhs.src, "expected error set type, found {}", .{lhs_ty}); + + // anything merged with anyerror is anyerror + if (lhs_ty.tag() == .anyerror or rhs_ty.tag() == .anyerror) + return sema.mod.constInst(scope, inst.base.src, .{ + .ty = Type.initTag(.type), + .val = Value.initTag(.anyerror_type), + }); + // The declarations arena will store the hashmap. + var new_decl_arena = std.heap.ArenaAllocator.init(mod.gpa); + errdefer new_decl_arena.deinit(); + + const payload = try new_decl_arena.allocator.create(Value.Payload.ErrorSet); + payload.* = .{ + .base = .{ .tag = .error_set }, + .data = .{ + .fields = .{}, + .decl = undefined, // populated below + }, + }; + try payload.data.fields.ensureCapacity(&new_decl_arena.allocator, @intCast(u32, switch (rhs_ty.tag()) { + .error_set_single => 1, + .error_set => rhs_ty.castTag(.error_set).?.data.typed_value.most_recent.typed_value.val.castTag(.error_set).?.data.fields.size, + else => unreachable, + } + switch (lhs_ty.tag()) { + .error_set_single => 1, + .error_set => lhs_ty.castTag(.error_set).?.data.typed_value.most_recent.typed_value.val.castTag(.error_set).?.data.fields.size, + else => unreachable, + })); + + switch (lhs_ty.tag()) { + .error_set_single => { + const name = lhs_ty.castTag(.error_set_single).?.data; + payload.data.fields.putAssumeCapacity(name, {}); + }, + .error_set => { + var multiple = lhs_ty.castTag(.error_set).?.data.typed_value.most_recent.typed_value.val.castTag(.error_set).?.data.fields; + var it = multiple.iterator(); + while (it.next()) |entry| { + payload.data.fields.putAssumeCapacity(entry.key, entry.value); + } + }, + else => unreachable, + } + + switch (rhs_ty.tag()) { + .error_set_single => { + const name = rhs_ty.castTag(.error_set_single).?.data; + payload.data.fields.putAssumeCapacity(name, {}); + }, + .error_set => { + var multiple = rhs_ty.castTag(.error_set).?.data.typed_value.most_recent.typed_value.val.castTag(.error_set).?.data.fields; + var it = multiple.iterator(); + while (it.next()) |entry| { + payload.data.fields.putAssumeCapacity(entry.key, entry.value); + } + }, + else => unreachable, + } + // TODO create name in format "error:line:column" + const new_decl = try mod.createAnonymousDecl(scope, &new_decl_arena, .{ + .ty = Type.initTag(.type), + .val = Value.initPayload(&payload.base), + }); + payload.data.decl = new_decl; + + return mod.analyzeDeclVal(scope, inst.base.src, new_decl); +} + +fn zirEnumLiteral(sema: *Sema, block: *Scope.Block, zir_inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const duped_name = try block.arena.dupe(u8, inst.positionals.name); + return sema.mod.constInst(scope, inst.base.src, .{ + .ty = Type.initTag(.enum_literal), + .val = try Value.Tag.enum_literal.create(block.arena, duped_name), + }); +} + +/// Pointer in, pointer out. +fn zirOptionalPayloadPtr( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, + safety_check: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const optional_ptr = sema.resolveInst(block, inst_data.operand); + assert(optional_ptr.ty.zigTypeTag() == .Pointer); + const src = inst_data.src(); + + const opt_type = optional_ptr.ty.elemType(); + if (opt_type.zigTypeTag() != .Optional) { + return sema.mod.fail(&block.base, src, "expected optional type, found {}", .{opt_type}); + } + + const child_type = try opt_type.optionalChildAlloc(block.arena); + const child_pointer = try sema.mod.simplePtrType(block.arena, child_type, !optional_ptr.ty.isConstPtr(), .One); + + if (optional_ptr.value()) |pointer_val| { + const val = try pointer_val.pointerDeref(block.arena); + if (val.isNull()) { + return sema.mod.fail(&block.base, src, "unable to unwrap null", .{}); + } + // The same Value represents the pointer to the optional and the payload. + return sema.mod.constInst(scope, src, .{ + .ty = child_pointer, + .val = pointer_val, + }); + } + + try sema.requireRuntimeBlock(block, src); + if (safety_check and block.wantSafety()) { + const is_non_null = try block.addUnOp(src, Type.initTag(.bool), .is_non_null_ptr, optional_ptr); + try mod.addSafetyCheck(b, is_non_null, .unwrap_null); + } + return block.addUnOp(src, child_pointer, .optional_payload_ptr, optional_ptr); +} + +/// Value in, value out. +fn zirOptionalPayload( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, + safety_check: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const src = inst_data.src(); + const operand = sema.resolveInst(block, inst_data.operand); + const opt_type = operand.ty; + if (opt_type.zigTypeTag() != .Optional) { + return sema.mod.fail(&block.base, src, "expected optional type, found {}", .{opt_type}); + } + + const child_type = try opt_type.optionalChildAlloc(block.arena); + + if (operand.value()) |val| { + if (val.isNull()) { + return sema.mod.fail(&block.base, src, "unable to unwrap null", .{}); + } + return sema.mod.constInst(scope, src, .{ + .ty = child_type, + .val = val, + }); + } + + try sema.requireRuntimeBlock(block, src); + if (safety_check and block.wantSafety()) { + const is_non_null = try block.addUnOp(src, Type.initTag(.bool), .is_non_null, operand); + try mod.addSafetyCheck(b, is_non_null, .unwrap_null); + } + return block.addUnOp(src, child_type, .optional_payload, operand); +} + +/// Value in, value out +fn zirErrUnionPayload( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, + safety_check: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const src = inst_data.src(); + const operand = sema.resolveInst(block, inst_data.operand); + if (operand.ty.zigTypeTag() != .ErrorUnion) + return sema.mod.fail(&block.base, operand.src, "expected error union type, found '{}'", .{operand.ty}); + + if (operand.value()) |val| { + if (val.getError()) |name| { + return sema.mod.fail(&block.base, src, "caught unexpected error '{s}'", .{name}); + } + const data = val.castTag(.error_union).?.data; + return sema.mod.constInst(scope, src, .{ + .ty = operand.ty.castTag(.error_union).?.data.payload, + .val = data, + }); + } + try sema.requireRuntimeBlock(block, src); + if (safety_check and block.wantSafety()) { + const is_non_err = try block.addUnOp(src, Type.initTag(.bool), .is_err, operand); + try mod.addSafetyCheck(b, is_non_err, .unwrap_errunion); + } + return block.addUnOp(src, operand.ty.castTag(.error_union).?.data.payload, .unwrap_errunion_payload, operand); +} + +/// Pointer in, pointer out. +fn zirErrUnionPayloadPtr( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, + safety_check: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const src = inst_data.src(); + const operand = sema.resolveInst(block, inst_data.operand); + assert(operand.ty.zigTypeTag() == .Pointer); + + if (operand.ty.elemType().zigTypeTag() != .ErrorUnion) + return sema.mod.fail(&block.base, src, "expected error union type, found {}", .{operand.ty.elemType()}); + + const operand_pointer_ty = try sema.mod.simplePtrType(block.arena, operand.ty.elemType().castTag(.error_union).?.data.payload, !operand.ty.isConstPtr(), .One); + + if (operand.value()) |pointer_val| { + const val = try pointer_val.pointerDeref(block.arena); + if (val.getError()) |name| { + return sema.mod.fail(&block.base, src, "caught unexpected error '{s}'", .{name}); + } + const data = val.castTag(.error_union).?.data; + // The same Value represents the pointer to the error union and the payload. + return sema.mod.constInst(scope, src, .{ + .ty = operand_pointer_ty, + .val = try Value.Tag.ref_val.create( + block.arena, + data, + ), + }); + } + + try sema.requireRuntimeBlock(block, src); + if (safety_check and block.wantSafety()) { + const is_non_err = try block.addUnOp(src, Type.initTag(.bool), .is_err, operand); + try mod.addSafetyCheck(b, is_non_err, .unwrap_errunion); + } + return block.addUnOp(src, operand_pointer_ty, .unwrap_errunion_payload_ptr, operand); +} + +/// Value in, value out +fn zirErrUnionCode(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const src = inst_data.src(); + const operand = sema.resolveInst(block, inst_data.operand); + if (operand.ty.zigTypeTag() != .ErrorUnion) + return sema.mod.fail(&block.base, src, "expected error union type, found '{}'", .{operand.ty}); + + if (operand.value()) |val| { + assert(val.getError() != null); + const data = val.castTag(.error_union).?.data; + return sema.mod.constInst(scope, src, .{ + .ty = operand.ty.castTag(.error_union).?.data.error_set, + .val = data, + }); + } + + try sema.requireRuntimeBlock(block, src); + return block.addUnOp(src, operand.ty.castTag(.error_union).?.data.payload, .unwrap_errunion_err, operand); +} + +/// Pointer in, value out +fn zirErrUnionCodePtr(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const src = inst_data.src(); + const operand = sema.resolveInst(block, inst_data.operand); + assert(operand.ty.zigTypeTag() == .Pointer); + + if (operand.ty.elemType().zigTypeTag() != .ErrorUnion) + return sema.mod.fail(&block.base, src, "expected error union type, found {}", .{operand.ty.elemType()}); + + if (operand.value()) |pointer_val| { + const val = try pointer_val.pointerDeref(block.arena); + assert(val.getError() != null); + const data = val.castTag(.error_union).?.data; + return sema.mod.constInst(scope, src, .{ + .ty = operand.ty.elemType().castTag(.error_union).?.data.error_set, + .val = data, + }); + } + + try sema.requireRuntimeBlock(block, src); + return block.addUnOp(src, operand.ty.castTag(.error_union).?.data.payload, .unwrap_errunion_err_ptr, operand); +} + +fn zirEnsureErrPayloadVoid(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const src = inst_data.src(); + const operand = sema.resolveInst(block, inst_data.operand); + if (operand.ty.zigTypeTag() != .ErrorUnion) + return sema.mod.fail(&block.base, src, "expected error union type, found '{}'", .{operand.ty}); + if (operand.ty.castTag(.error_union).?.data.payload.zigTypeTag() != .Void) { + return sema.mod.fail(&block.base, src, "expression value is ignored", .{}); + } + return sema.mod.constVoid(block.arena, .unneeded); +} + +fn zirFnType(sema: *Sema, block: *Scope.Block, fntype: zir.Inst.Index, var_args: bool) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + return fnTypeCommon( + mod, + scope, + &fntype.base, + fntype.positionals.param_types, + fntype.positionals.return_type, + .Unspecified, + var_args, + ); +} + +fn zirFnTypeCc(sema: *Sema, block: *Scope.Block, fntype: zir.Inst.Index, var_args: bool) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const cc_tv = try resolveInstConst(mod, scope, fntype.positionals.cc); + // TODO once we're capable of importing and analyzing decls from + // std.builtin, this needs to change + const cc_str = cc_tv.val.castTag(.enum_literal).?.data; + const cc = std.meta.stringToEnum(std.builtin.CallingConvention, cc_str) orelse + return sema.mod.fail(&block.base, fntype.positionals.cc.src, "Unknown calling convention {s}", .{cc_str}); + return fnTypeCommon( + mod, + scope, + &fntype.base, + fntype.positionals.param_types, + fntype.positionals.return_type, + cc, + var_args, + ); +} + +fn fnTypeCommon( + sema: *Sema, + block: *Scope.Block, + zir_inst: zir.Inst.Index, + zir_param_types: []zir.Inst.Index, + zir_return_type: zir.Inst.Index, + cc: std.builtin.CallingConvention, + var_args: bool, +) InnerError!*Inst { + const return_type = try sema.resolveType(block, zir_return_type); + + // Hot path for some common function types. + if (zir_param_types.len == 0 and !var_args) { + if (return_type.zigTypeTag() == .NoReturn and cc == .Unspecified) { + return sema.mod.constType(block.arena, zir_inst.src, Type.initTag(.fn_noreturn_no_args)); + } + + if (return_type.zigTypeTag() == .Void and cc == .Unspecified) { + return sema.mod.constType(block.arena, zir_inst.src, Type.initTag(.fn_void_no_args)); + } + + if (return_type.zigTypeTag() == .NoReturn and cc == .Naked) { + return sema.mod.constType(block.arena, zir_inst.src, Type.initTag(.fn_naked_noreturn_no_args)); + } + + if (return_type.zigTypeTag() == .Void and cc == .C) { + return sema.mod.constType(block.arena, zir_inst.src, Type.initTag(.fn_ccc_void_no_args)); + } + } + + const param_types = try block.arena.alloc(Type, zir_param_types.len); + for (zir_param_types) |param_type, i| { + const resolved = try sema.resolveType(block, param_type); + // TODO skip for comptime params + if (!resolved.isValidVarType(false)) { + return sema.mod.fail(&block.base, param_type.src, "parameter of type '{}' must be declared comptime", .{resolved}); + } + param_types[i] = resolved; + } + + const fn_ty = try Type.Tag.function.create(block.arena, .{ + .param_types = param_types, + .return_type = return_type, + .cc = cc, + .is_var_args = var_args, + }); + return sema.mod.constType(block.arena, zir_inst.src, fn_ty); +} + +fn zirAs(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const dest_type = try sema.resolveType(block, bin_inst.lhs); + const tzir_inst = sema.resolveInst(block, bin_inst.rhs); + return sema.coerce(scope, dest_type, tzir_inst); +} + +fn zirPtrtoint(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const ptr = sema.resolveInst(block, inst_data.operand); + if (ptr.ty.zigTypeTag() != .Pointer) { + const ptr_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node }; + return sema.mod.fail(&block.base, ptr_src, "expected pointer, found '{}'", .{ptr.ty}); + } + // TODO handle known-pointer-address + const src = inst_data.src(); + try sema.requireRuntimeBlock(block, src); + const ty = Type.initTag(.usize); + return block.addUnOp(src, ty, .ptrtoint, ptr); +} + +fn zirFieldVal(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const field_name_src: LazySrcLoc = .{ .node_offset_field_name = inst_data.src_node }; + const extra = sema.code.extraData(zir.Inst.Field, inst_data.payload_index).data; + const field_name = sema.code.string_bytes[extra.field_name_start..][0..extra.field_name_len]; + const object = sema.resolveInst(block, extra.lhs); + const object_ptr = try sema.analyzeRef(block, src, object); + const result_ptr = try sema.namedFieldPtr(block, src, object_ptr, field_name, field_name_src); + return sema.analyzeDeref(block, src, result_ptr, result_ptr.src); +} + +fn zirFieldPtr(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const field_name_src: LazySrcLoc = .{ .node_offset_field_name = inst_data.src_node }; + const extra = sema.code.extraData(zir.Inst.Field, inst_data.payload_index).data; + const field_name = sema.code.string_bytes[extra.field_name_start..][0..extra.field_name_len]; + const object_ptr = sema.resolveInst(block, extra.lhs); + return sema.namedFieldPtr(block, src, object_ptr, field_name, field_name_src); +} + +fn zirFieldValNamed(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const field_name_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node }; + const extra = sema.code.extraData(zir.Inst.FieldNamed, inst_data.payload_index).data; + const object = sema.resolveInst(block, extra.lhs); + const field_name = try sema.resolveConstString(block, field_name_src, extra.field_name); + const object_ptr = try sema.analyzeRef(block, src, object); + const result_ptr = try sema.namedFieldPtr(block, src, object_ptr, field_name, field_name_src); + return sema.analyzeDeref(block, src, result_ptr, src); +} + +fn zirFieldPtrNamed(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const field_name_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node }; + const extra = sema.code.extraData(zir.Inst.FieldNamed, inst_data.payload_index).data; + const object_ptr = sema.resolveInst(block, extra.lhs); + const field_name = try sema.resolveConstString(block, field_name_src, extra.field_name); + return sema.namedFieldPtr(block, src, object_ptr, field_name, field_name_src); +} + +fn zirIntcast(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const dest_type = try sema.resolveType(block, bin_inst.lhs); + const operand = sema.resolveInst(bin_inst.rhs); + + const dest_is_comptime_int = switch (dest_type.zigTypeTag()) { + .ComptimeInt => true, + .Int => false, + else => return mod.fail( + scope, + inst.positionals.lhs.src, + "expected integer type, found '{}'", + .{ + dest_type, + }, + ), + }; + + switch (operand.ty.zigTypeTag()) { + .ComptimeInt, .Int => {}, + else => return mod.fail( + scope, + inst.positionals.rhs.src, + "expected integer type, found '{}'", + .{operand.ty}, + ), + } + + if (operand.value() != null) { + return sema.coerce(scope, dest_type, operand); + } else if (dest_is_comptime_int) { + return sema.mod.fail(&block.base, inst.base.src, "unable to cast runtime value to 'comptime_int'", .{}); + } + + return sema.mod.fail(&block.base, inst.base.src, "TODO implement analyze widen or shorten int", .{}); +} + +fn zirBitcast(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const dest_type = try sema.resolveType(block, bin_inst.lhs); + const operand = sema.resolveInst(bin_inst.rhs); + return mod.bitcast(scope, dest_type, operand); +} + +fn zirFloatcast(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const dest_type = try sema.resolveType(block, bin_inst.lhs); + const operand = sema.resolveInst(bin_inst.rhs); + + const dest_is_comptime_float = switch (dest_type.zigTypeTag()) { + .ComptimeFloat => true, + .Float => false, + else => return mod.fail( + scope, + inst.positionals.lhs.src, + "expected float type, found '{}'", + .{ + dest_type, + }, + ), + }; + + switch (operand.ty.zigTypeTag()) { + .ComptimeFloat, .Float, .ComptimeInt => {}, + else => return mod.fail( + scope, + inst.positionals.rhs.src, + "expected float type, found '{}'", + .{operand.ty}, + ), + } + + if (operand.value() != null) { + return sema.coerce(scope, dest_type, operand); + } else if (dest_is_comptime_float) { + return sema.mod.fail(&block.base, inst.base.src, "unable to cast runtime value to 'comptime_float'", .{}); + } + + return sema.mod.fail(&block.base, inst.base.src, "TODO implement analyze widen or shorten float", .{}); +} + +fn zirElemVal(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const array = sema.resolveInst(block, bin_inst.lhs); + const array_ptr = try sema.analyzeRef(block, sema.src, array); + const elem_index = sema.resolveInst(block, bin_inst.rhs); + const result_ptr = try sema.elemPtr(block, sema.src, array_ptr, elem_index, sema.src); + return sema.analyzeDeref(block, sema.src, result_ptr, sema.src); +} + +fn zirElemValNode(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const elem_index_src: LazySrcLoc = .{ .node_offset_array_access_index = inst_data.src_node }; + const extra = sema.code.extraData(zir.Inst.Bin, inst_data.payload_index).data; + const array = sema.resolveInst(block, extra.lhs); + const array_ptr = try sema.analyzeRef(block, src, array); + const elem_index = sema.resolveInst(block, extra.rhs); + const result_ptr = try sema.elemPtr(block, src, array_ptr, elem_index, elem_index_src); + return sema.analyzeDeref(block, src, result_ptr, src); +} + +fn zirElemPtr(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const array_ptr = sema.resolveInst(block, bin_inst.lhs); + const elem_index = sema.resolveInst(block, bin_inst.rhs); + return sema.elemPtr(block, sema.src, array_ptr, elem_index, sema.src); +} + +fn zirElemPtrNode(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const elem_index_src: LazySrcLoc = .{ .node_offset_array_access_index = inst_data.src_node }; + const extra = sema.code.extraData(zir.Inst.Bin, inst_data.payload_index).data; + const array_ptr = sema.resolveInst(block, extra.lhs); + const elem_index = sema.resolveInst(block, extra.rhs); + return sema.elemPtr(block, src, array_ptr, elem_index, elem_index_src); +} + +fn zirSliceStart(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const extra = sema.code.extraData(zir.Inst.SliceStart, inst_data.payload_index).data; + const array_ptr = sema.resolveInst(extra.lhs); + const start = sema.resolveInst(extra.start); + + return sema.analyzeSlice(block, src, array_ptr, start, null, null, .unneeded); +} + +fn zirSliceEnd(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const extra = sema.code.extraData(zir.Inst.SliceEnd, inst_data.payload_index).data; + const array_ptr = sema.resolveInst(extra.lhs); + const start = sema.resolveInst(extra.start); + const end = sema.resolveInst(extra.end); + + return sema.analyzeSlice(block, src, array_ptr, start, end, null, .unneeded); +} + +fn zirSliceSentinel(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const sentinel_src: LazySrcLoc = .{ .node_offset_slice_sentinel = inst_data.src_node }; + const extra = sema.code.extraData(zir.Inst.SliceSentinel, inst_data.payload_index).data; + const array_ptr = sema.resolveInst(extra.lhs); + const start = sema.resolveInst(extra.start); + const end = sema.resolveInst(extra.end); + const sentinel = sema.resolveInst(extra.sentinel); + + return sema.analyzeSlice(block, inst.base.src, array_ptr, start, end, sentinel, sentinel_src); +} + +fn zirSwitchRange(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const start = sema.resolveInst(bin_inst.lhs); + const end = sema.resolveInst(bin_inst.rhs); + + switch (start.ty.zigTypeTag()) { + .Int, .ComptimeInt => {}, + else => return sema.mod.constVoid(block.arena, .unneeded), + } + switch (end.ty.zigTypeTag()) { + .Int, .ComptimeInt => {}, + else => return sema.mod.constVoid(block.arena, .unneeded), + } + // .switch_range must be inside a comptime scope + const start_val = start.value().?; + const end_val = end.value().?; + if (start_val.compare(.gte, end_val)) { + return sema.mod.fail(&block.base, inst.base.src, "range start value must be smaller than the end value", .{}); + } + return sema.mod.constVoid(block.arena, .unneeded); +} + +fn zirSwitchBr( + sema: *Sema, + parent_block: *Scope.Block, + inst: zir.Inst.Index, + ref: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + if (true) @panic("TODO rework with zir-memory-layout in mind"); + + const target_ptr = sema.resolveInst(block, inst.positionals.target); + const target = if (ref) + try sema.analyzeDeref(block, inst.base.src, target_ptr, inst.positionals.target.src) + else + target_ptr; + try validateSwitch(mod, scope, target, inst); + + if (try mod.resolveDefinedValue(scope, target)) |target_val| { + for (inst.positionals.cases) |case| { + const resolved = sema.resolveInst(block, case.item); + const casted = try sema.coerce(scope, target.ty, resolved); + const item = try sema.resolveConstValue(parent_block, case_src, casted); + + if (target_val.eql(item)) { + try sema.body(scope.cast(Scope.Block).?, case.body); + return mod.constNoReturn(scope, inst.base.src); + } + } + try sema.body(scope.cast(Scope.Block).?, inst.positionals.else_body); + return mod.constNoReturn(scope, inst.base.src); + } + + if (inst.positionals.cases.len == 0) { + // no cases just analyze else_branch + try sema.body(scope.cast(Scope.Block).?, inst.positionals.else_body); + return mod.constNoReturn(scope, inst.base.src); + } + + try sema.requireRuntimeBlock(parent_block, inst.base.src); + const cases = try parent_block.arena.alloc(Inst.SwitchBr.Case, inst.positionals.cases.len); + + var case_block: Scope.Block = .{ + .parent = parent_block, + .inst_table = parent_block.inst_table, + .func = parent_block.func, + .owner_decl = parent_block.owner_decl, + .src_decl = parent_block.src_decl, + .instructions = .{}, + .arena = parent_block.arena, + .inlining = parent_block.inlining, + .is_comptime = parent_block.is_comptime, + .branch_quota = parent_block.branch_quota, + }; + defer case_block.instructions.deinit(mod.gpa); + + for (inst.positionals.cases) |case, i| { + // Reset without freeing. + case_block.instructions.items.len = 0; + + const resolved = sema.resolveInst(block, case.item); + const casted = try sema.coerce(scope, target.ty, resolved); + const item = try sema.resolveConstValue(parent_block, case_src, casted); + + try sema.body(&case_block, case.body); + + cases[i] = .{ + .item = item, + .body = .{ .instructions = try parent_block.arena.dupe(*Inst, case_block.instructions.items) }, + }; + } + + case_block.instructions.items.len = 0; + try sema.body(&case_block, inst.positionals.else_body); + + const else_body: ir.Body = .{ + .instructions = try parent_block.arena.dupe(*Inst, case_block.instructions.items), + }; + + return mod.addSwitchBr(parent_block, inst.base.src, target, cases, else_body); +} + +fn validateSwitch(sema: *Sema, block: *Scope.Block, target: *Inst, inst: zir.Inst.Index) InnerError!void { + // validate usage of '_' prongs + if (inst.positionals.special_prong == .underscore and target.ty.zigTypeTag() != .Enum) { + return sema.mod.fail(&block.base, inst.base.src, "'_' prong only allowed when switching on non-exhaustive enums", .{}); + // TODO notes "'_' prong here" inst.positionals.cases[last].src + } + + // check that target type supports ranges + if (inst.positionals.range) |range_inst| { + switch (target.ty.zigTypeTag()) { + .Int, .ComptimeInt => {}, + else => { + return sema.mod.fail(&block.base, target.src, "ranges not allowed when switching on type {}", .{target.ty}); + // TODO notes "range used here" range_inst.src + }, + } + } + + // validate for duplicate items/missing else prong + switch (target.ty.zigTypeTag()) { + .Enum => return sema.mod.fail(&block.base, inst.base.src, "TODO validateSwitch .Enum", .{}), + .ErrorSet => return sema.mod.fail(&block.base, inst.base.src, "TODO validateSwitch .ErrorSet", .{}), + .Union => return sema.mod.fail(&block.base, inst.base.src, "TODO validateSwitch .Union", .{}), + .Int, .ComptimeInt => { + var range_set = @import("RangeSet.zig").init(mod.gpa); + defer range_set.deinit(); + + for (inst.positionals.items) |item| { + const maybe_src = if (item.castTag(.switch_range)) |range| blk: { + const start_resolved = sema.resolveInst(block, range.positionals.lhs); + const start_casted = try sema.coerce(scope, target.ty, start_resolved); + const end_resolved = sema.resolveInst(block, range.positionals.rhs); + const end_casted = try sema.coerce(scope, target.ty, end_resolved); + + break :blk try range_set.add( + try sema.resolveConstValue(block, range_start_src, start_casted), + try sema.resolveConstValue(block, range_end_src, end_casted), + item.src, + ); + } else blk: { + const resolved = sema.resolveInst(block, item); + const casted = try sema.coerce(scope, target.ty, resolved); + const value = try sema.resolveConstValue(block, item_src, casted); + break :blk try range_set.add(value, value, item.src); + }; + + if (maybe_src) |previous_src| { + return sema.mod.fail(&block.base, item.src, "duplicate switch value", .{}); + // TODO notes "previous value is here" previous_src + } + } + + if (target.ty.zigTypeTag() == .Int) { + var arena = std.heap.ArenaAllocator.init(mod.gpa); + defer arena.deinit(); + + const start = try target.ty.minInt(&arena, mod.getTarget()); + const end = try target.ty.maxInt(&arena, mod.getTarget()); + if (try range_set.spans(start, end)) { + if (inst.positionals.special_prong == .@"else") { + return sema.mod.fail(&block.base, inst.base.src, "unreachable else prong, all cases already handled", .{}); + } + return; + } + } + + if (inst.positionals.special_prong != .@"else") { + return sema.mod.fail(&block.base, inst.base.src, "switch must handle all possibilities", .{}); + } + }, + .Bool => { + var true_count: u8 = 0; + var false_count: u8 = 0; + for (inst.positionals.items) |item| { + const resolved = sema.resolveInst(block, item); + const casted = try sema.coerce(scope, Type.initTag(.bool), resolved); + if ((try sema.resolveConstValue(block, item_src, casted)).toBool()) { + true_count += 1; + } else { + false_count += 1; + } + + if (true_count + false_count > 2) { + return sema.mod.fail(&block.base, item.src, "duplicate switch value", .{}); + } + } + if ((true_count + false_count < 2) and inst.positionals.special_prong != .@"else") { + return sema.mod.fail(&block.base, inst.base.src, "switch must handle all possibilities", .{}); + } + if ((true_count + false_count == 2) and inst.positionals.special_prong == .@"else") { + return sema.mod.fail(&block.base, inst.base.src, "unreachable else prong, all cases already handled", .{}); + } + }, + .EnumLiteral, .Void, .Fn, .Pointer, .Type => { + if (inst.positionals.special_prong != .@"else") { + return sema.mod.fail(&block.base, inst.base.src, "else prong required when switching on type '{}'", .{target.ty}); + } + + var seen_values = std.HashMap(Value, usize, Value.hash, Value.eql, std.hash_map.DefaultMaxLoadPercentage).init(mod.gpa); + defer seen_values.deinit(); + + for (inst.positionals.items) |item| { + const resolved = sema.resolveInst(block, item); + const casted = try sema.coerce(scope, target.ty, resolved); + const val = try sema.resolveConstValue(block, item_src, casted); + + if (try seen_values.fetchPut(val, item.src)) |prev| { + return sema.mod.fail(&block.base, item.src, "duplicate switch value", .{}); + // TODO notes "previous value here" prev.value + } + } + }, + + .ErrorUnion, + .NoReturn, + .Array, + .Struct, + .Undefined, + .Null, + .Optional, + .BoundFn, + .Opaque, + .Vector, + .Frame, + .AnyFrame, + .ComptimeFloat, + .Float, + => { + return sema.mod.fail(&block.base, target.src, "invalid switch target type '{}'", .{target.ty}); + }, + } +} + +fn zirImport(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const src = inst_data.src(); + const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node }; + const operand = try sema.resolveConstString(block, operand_src, inst_data.operand); + + const file_scope = sema.analyzeImport(block, src, operand) catch |err| switch (err) { + error.ImportOutsidePkgPath => { + return sema.mod.fail(&block.base, src, "import of file outside package path: '{s}'", .{operand}); + }, + error.FileNotFound => { + return sema.mod.fail(&block.base, src, "unable to find '{s}'", .{operand}); + }, + else => { + // TODO: make sure this gets retried and not cached + return sema.mod.fail(&block.base, src, "unable to open '{s}': {s}", .{ operand, @errorName(err) }); + }, + }; + return sema.mod.constType(block.arena, src, file_scope.root_container.ty); +} + +fn zirShl(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + return sema.mod.fail(&block.base, inst.base.src, "TODO implement zirShl", .{}); +} + +fn zirShr(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + return sema.mod.fail(&block.base, inst.base.src, "TODO implement zirShr", .{}); +} + +fn zirBitwise(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const lhs = sema.resolveInst(bin_inst.lhs); + const rhs = sema.resolveInst(bin_inst.rhs); + + const instructions = &[_]*Inst{ lhs, rhs }; + const resolved_type = try sema.resolvePeerTypes(block, instructions); + const casted_lhs = try sema.coerce(scope, resolved_type, lhs); + const casted_rhs = try sema.coerce(scope, resolved_type, rhs); + + const scalar_type = if (resolved_type.zigTypeTag() == .Vector) + resolved_type.elemType() + else + resolved_type; + + const scalar_tag = scalar_type.zigTypeTag(); + + if (lhs.ty.zigTypeTag() == .Vector and rhs.ty.zigTypeTag() == .Vector) { + if (lhs.ty.arrayLen() != rhs.ty.arrayLen()) { + return sema.mod.fail(&block.base, inst.base.src, "vector length mismatch: {d} and {d}", .{ + lhs.ty.arrayLen(), + rhs.ty.arrayLen(), + }); + } + return sema.mod.fail(&block.base, inst.base.src, "TODO implement support for vectors in zirBitwise", .{}); + } else if (lhs.ty.zigTypeTag() == .Vector or rhs.ty.zigTypeTag() == .Vector) { + return sema.mod.fail(&block.base, inst.base.src, "mixed scalar and vector operands to binary expression: '{}' and '{}'", .{ + lhs.ty, + rhs.ty, + }); + } + + const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt; + + if (!is_int) { + return sema.mod.fail(&block.base, inst.base.src, "invalid operands to binary bitwise expression: '{s}' and '{s}'", .{ @tagName(lhs.ty.zigTypeTag()), @tagName(rhs.ty.zigTypeTag()) }); + } + + if (casted_lhs.value()) |lhs_val| { + if (casted_rhs.value()) |rhs_val| { + if (lhs_val.isUndef() or rhs_val.isUndef()) { + return sema.mod.constInst(scope, inst.base.src, .{ + .ty = resolved_type, + .val = Value.initTag(.undef), + }); + } + return sema.mod.fail(&block.base, inst.base.src, "TODO implement comptime bitwise operations", .{}); + } + } + + try sema.requireRuntimeBlock(block, inst.base.src); + const ir_tag = switch (inst.base.tag) { + .bit_and => Inst.Tag.bit_and, + .bit_or => Inst.Tag.bit_or, + .xor => Inst.Tag.xor, + else => unreachable, + }; + + return mod.addBinOp(b, inst.base.src, scalar_type, ir_tag, casted_lhs, casted_rhs); +} + +fn zirBitNot(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + return sema.mod.fail(&block.base, inst.base.src, "TODO implement zirBitNot", .{}); +} + +fn zirArrayCat(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + return sema.mod.fail(&block.base, inst.base.src, "TODO implement zirArrayCat", .{}); +} + +fn zirArrayMul(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + return sema.mod.fail(&block.base, inst.base.src, "TODO implement zirArrayMul", .{}); +} + +fn zirArithmetic(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const lhs = sema.resolveInst(bin_inst.lhs); + const rhs = sema.resolveInst(bin_inst.rhs); + + const instructions = &[_]*Inst{ lhs, rhs }; + const resolved_type = try sema.resolvePeerTypes(block, instructions); + const casted_lhs = try sema.coerce(scope, resolved_type, lhs); + const casted_rhs = try sema.coerce(scope, resolved_type, rhs); + + const scalar_type = if (resolved_type.zigTypeTag() == .Vector) + resolved_type.elemType() + else + resolved_type; + + const scalar_tag = scalar_type.zigTypeTag(); + + if (lhs.ty.zigTypeTag() == .Vector and rhs.ty.zigTypeTag() == .Vector) { + if (lhs.ty.arrayLen() != rhs.ty.arrayLen()) { + return sema.mod.fail(&block.base, inst.base.src, "vector length mismatch: {d} and {d}", .{ + lhs.ty.arrayLen(), + rhs.ty.arrayLen(), + }); + } + return sema.mod.fail(&block.base, inst.base.src, "TODO implement support for vectors in zirBinOp", .{}); + } else if (lhs.ty.zigTypeTag() == .Vector or rhs.ty.zigTypeTag() == .Vector) { + return sema.mod.fail(&block.base, inst.base.src, "mixed scalar and vector operands to binary expression: '{}' and '{}'", .{ + lhs.ty, + rhs.ty, + }); + } + + const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt; + const is_float = scalar_tag == .Float or scalar_tag == .ComptimeFloat; + + if (!is_int and !(is_float and floatOpAllowed(inst.base.tag))) { + return sema.mod.fail(&block.base, inst.base.src, "invalid operands to binary expression: '{s}' and '{s}'", .{ @tagName(lhs.ty.zigTypeTag()), @tagName(rhs.ty.zigTypeTag()) }); + } + + if (casted_lhs.value()) |lhs_val| { + if (casted_rhs.value()) |rhs_val| { + if (lhs_val.isUndef() or rhs_val.isUndef()) { + return sema.mod.constInst(scope, inst.base.src, .{ + .ty = resolved_type, + .val = Value.initTag(.undef), + }); + } + return analyzeInstComptimeOp(mod, scope, scalar_type, inst, lhs_val, rhs_val); + } + } + + try sema.requireRuntimeBlock(block, inst.base.src); + const ir_tag: Inst.Tag = switch (inst.base.tag) { + .add => .add, + .addwrap => .addwrap, + .sub => .sub, + .subwrap => .subwrap, + .mul => .mul, + .mulwrap => .mulwrap, + else => return sema.mod.fail(&block.base, inst.base.src, "TODO implement arithmetic for operand '{s}''", .{@tagName(inst.base.tag)}), + }; + + return mod.addBinOp(b, inst.base.src, scalar_type, ir_tag, casted_lhs, casted_rhs); +} + +/// Analyzes operands that are known at comptime +fn analyzeInstComptimeOp(sema: *Sema, block: *Scope.Block, res_type: Type, inst: zir.Inst.Index, lhs_val: Value, rhs_val: Value) InnerError!*Inst { + // incase rhs is 0, simply return lhs without doing any calculations + // TODO Once division is implemented we should throw an error when dividing by 0. + if (rhs_val.compareWithZero(.eq)) { + return sema.mod.constInst(scope, inst.base.src, .{ + .ty = res_type, + .val = lhs_val, + }); + } + const is_int = res_type.isInt() or res_type.zigTypeTag() == .ComptimeInt; + + const value = switch (inst.base.tag) { + .add => blk: { + const val = if (is_int) + try Module.intAdd(block.arena, lhs_val, rhs_val) + else + try mod.floatAdd(scope, res_type, inst.base.src, lhs_val, rhs_val); + break :blk val; + }, + .sub => blk: { + const val = if (is_int) + try Module.intSub(block.arena, lhs_val, rhs_val) + else + try mod.floatSub(scope, res_type, inst.base.src, lhs_val, rhs_val); + break :blk val; + }, + else => return sema.mod.fail(&block.base, inst.base.src, "TODO Implement arithmetic operand '{s}'", .{@tagName(inst.base.tag)}), + }; + + log.debug("{s}({}, {}) result: {}", .{ @tagName(inst.base.tag), lhs_val, rhs_val, value }); + + return sema.mod.constInst(scope, inst.base.src, .{ + .ty = res_type, + .val = value, + }); +} + +fn zirDeref(sema: *Sema, block: *Scope.Block, deref: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const src = inst_data.src(); + const ptr_src: LazySrcLoc = .{ .node_offset_deref_ptr = inst_data.src_node }; + const ptr = sema.resolveInst(block, inst_data.operand); + return sema.analyzeDeref(block, src, ptr, ptr_src); +} + +fn zirAsm( + sema: *Sema, + block: *Scope.Block, + assembly: zir.Inst.Index, + is_volatile: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const asm_source_src: LazySrcLoc = .{ .node_offset_asm_source = inst_data.src_node }; + const ret_ty_src: LazySrcLoc = .{ .node_offset_asm_ret_ty = inst_data.src_node }; + const extra = sema.code.extraData(zir.Inst.Asm, inst_data.payload_index); + const return_type = try sema.resolveType(block, ret_ty_src, extra.data.return_type); + const asm_source = try sema.resolveConstString(block, asm_source_src, extra.data.asm_source); + + var extra_i = extra.end; + const output = if (extra.data.output != 0) blk: { + const name = sema.code.nullTerminatedString(sema.code.extra[extra_i]); + extra_i += 1; + break :blk .{ + .name = name, + .inst = try sema.resolveInst(block, extra.data.output), + }; + } else null; + + const args = try block.arena.alloc(*Inst, extra.data.args.len); + const inputs = try block.arena.alloc([]const u8, extra.data.args_len); + const clobbers = try block.arena.alloc([]const u8, extra.data.clobbers_len); + + for (args) |*arg| { + const uncasted = sema.resolveInst(block, sema.code.extra[extra_i]); + extra_i += 1; + arg.* = try sema.coerce(block, Type.initTag(.usize), uncasted); + } + for (inputs) |*name| { + name.* = sema.code.nullTerminatedString(sema.code.extra[extra_i]); + extra_i += 1; + } + for (clobbers) |*name| { + name.* = sema.code.nullTerminatedString(sema.code.extra[extra_i]); + extra_i += 1; + } + + try sema.requireRuntimeBlock(block, src); + const inst = try block.arena.create(Inst.Assembly); + inst.* = .{ + .base = .{ + .tag = .assembly, + .ty = return_type, + .src = src, + }, + .asm_source = asm_source, + .is_volatile = is_volatile, + .output = if (output) |o| o.inst else null, + .output_name = if (output) |o| o.name else null, + .inputs = inputs, + .clobbers = clobbers, + .args = args, + }; + try block.instructions.append(mod.gpa, &inst.base); + return &inst.base; +} + +fn zirCmp( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, + op: std.math.CompareOperator, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const lhs = sema.resolveInst(bin_inst.lhs); + const rhs = sema.resolveInst(bin_inst.rhs); + + const is_equality_cmp = switch (op) { + .eq, .neq => true, + else => false, + }; + const lhs_ty_tag = lhs.ty.zigTypeTag(); + const rhs_ty_tag = rhs.ty.zigTypeTag(); + if (is_equality_cmp and lhs_ty_tag == .Null and rhs_ty_tag == .Null) { + // null == null, null != null + return mod.constBool(block.arena, inst.base.src, op == .eq); + } else if (is_equality_cmp and + ((lhs_ty_tag == .Null and rhs_ty_tag == .Optional) or + rhs_ty_tag == .Null and lhs_ty_tag == .Optional)) + { + // comparing null with optionals + const opt_operand = if (lhs_ty_tag == .Optional) lhs else rhs; + return sema.analyzeIsNull(block, inst.base.src, opt_operand, op == .neq); + } else if (is_equality_cmp and + ((lhs_ty_tag == .Null and rhs.ty.isCPtr()) or (rhs_ty_tag == .Null and lhs.ty.isCPtr()))) + { + return sema.mod.fail(&block.base, inst.base.src, "TODO implement C pointer cmp", .{}); + } else if (lhs_ty_tag == .Null or rhs_ty_tag == .Null) { + const non_null_type = if (lhs_ty_tag == .Null) rhs.ty else lhs.ty; + return sema.mod.fail(&block.base, inst.base.src, "comparison of '{}' with null", .{non_null_type}); + } else if (is_equality_cmp and + ((lhs_ty_tag == .EnumLiteral and rhs_ty_tag == .Union) or + (rhs_ty_tag == .EnumLiteral and lhs_ty_tag == .Union))) + { + return sema.mod.fail(&block.base, inst.base.src, "TODO implement equality comparison between a union's tag value and an enum literal", .{}); + } else if (lhs_ty_tag == .ErrorSet and rhs_ty_tag == .ErrorSet) { + if (!is_equality_cmp) { + return sema.mod.fail(&block.base, inst.base.src, "{s} operator not allowed for errors", .{@tagName(op)}); + } + if (rhs.value()) |rval| { + if (lhs.value()) |lval| { + // TODO optimisation oppurtunity: evaluate if std.mem.eql is faster with the names, or calling to Module.getErrorValue to get the values and then compare them is faster + return mod.constBool(block.arena, inst.base.src, std.mem.eql(u8, lval.castTag(.@"error").?.data.name, rval.castTag(.@"error").?.data.name) == (op == .eq)); + } + } + try sema.requireRuntimeBlock(block, inst.base.src); + return mod.addBinOp(b, inst.base.src, Type.initTag(.bool), if (op == .eq) .cmp_eq else .cmp_neq, lhs, rhs); + } else if (lhs.ty.isNumeric() and rhs.ty.isNumeric()) { + // This operation allows any combination of integer and float types, regardless of the + // signed-ness, comptime-ness, and bit-width. So peer type resolution is incorrect for + // numeric types. + return mod.cmpNumeric(scope, inst.base.src, lhs, rhs, op); + } else if (lhs_ty_tag == .Type and rhs_ty_tag == .Type) { + if (!is_equality_cmp) { + return sema.mod.fail(&block.base, inst.base.src, "{s} operator not allowed for types", .{@tagName(op)}); + } + return mod.constBool(block.arena, inst.base.src, lhs.value().?.eql(rhs.value().?) == (op == .eq)); + } + return sema.mod.fail(&block.base, inst.base.src, "TODO implement more cmp analysis", .{}); +} + +fn zirTypeof(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const operand = sema.resolveInst(block, inst_data.operand); + return sema.mod.constType(block.arena, inst_data.src(), operand.ty); +} + +fn zirTypeofPeer(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].pl_node; + const src = inst_data.src(); + const extra = sema.code.extraData(zir.Inst.MultiOp, inst_data.payload_index); + + const inst_list = try mod.gpa.alloc(*ir.Inst, extra.data.operands_len); + defer mod.gpa.free(inst_list); + + const src_list = try mod.gpa.alloc(LazySrcLoc, extra.data.operands_len); + defer mod.gpa.free(src_list); + + for (sema.code.extra[extra.end..][0..extra.data.operands_len]) |arg_ref, i| { + inst_list[i] = sema.resolveInst(block, arg_ref); + src_list[i] = .{ .node_offset_builtin_call_argn = inst_data.src_node }; + } + + const result_type = try sema.resolvePeerTypes(block, inst_list, src_list); + return sema.mod.constType(block.arena, src, result_type); +} + +fn zirBoolNot(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const src = inst_data.src(); + const uncasted_operand = sema.resolveInst(block, inst_data.operand); + + const bool_type = Type.initTag(.bool); + const operand = try sema.coerce(scope, bool_type, uncasted_operand); + if (try mod.resolveDefinedValue(scope, operand)) |val| { + return mod.constBool(block.arena, src, !val.toBool()); + } + try sema.requireRuntimeBlock(block, src); + return block.addUnOp(src, bool_type, .not, operand); +} + +fn zirBoolOp( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, + comptime is_bool_or: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const bool_type = Type.initTag(.bool); + const bin_inst = sema.code.instructions.items(.data)[inst].bin; + const uncasted_lhs = sema.resolveInst(bin_inst.lhs); + const lhs = try sema.coerce(scope, bool_type, uncasted_lhs); + const uncasted_rhs = sema.resolveInst(bin_inst.rhs); + const rhs = try sema.coerce(scope, bool_type, uncasted_rhs); + + if (lhs.value()) |lhs_val| { + if (rhs.value()) |rhs_val| { + if (is_bool_or) { + return mod.constBool(block.arena, inst.base.src, lhs_val.toBool() or rhs_val.toBool()); + } else { + return mod.constBool(block.arena, inst.base.src, lhs_val.toBool() and rhs_val.toBool()); + } + } + } + try sema.requireRuntimeBlock(block, inst.base.src); + const tag: ir.Inst.Tag = if (is_bool_or) .bool_or else .bool_and; + return mod.addBinOp(b, inst.base.src, bool_type, tag, lhs, rhs); +} + +fn zirIsNull( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, + invert_logic: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const src = inst_data.src(); + const operand = sema.resolveInst(block, inst_data.operand); + return sema.analyzeIsNull(block, src, operand, invert_logic); +} + +fn zirIsNullPtr( + sema: *Sema, + block: *Scope.Block, + inst: zir.Inst.Index, + invert_logic: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const src = inst_data.src(); + const ptr = sema.resolveInst(block, inst_data.operand); + const loaded = try sema.analyzeDeref(block, src, ptr, src); + return sema.analyzeIsNull(block, src, loaded, invert_logic); +} + +fn zirIsErr(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const operand = sema.resolveInst(block, inst_data.operand); + return mod.analyzeIsErr(scope, inst_data.src(), operand); +} + +fn zirIsErrPtr(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].un_tok; + const src = inst_data.src(); + const ptr = sema.resolveInst(block, inst_data.operand); + const loaded = try sema.analyzeDeref(block, src, ptr, src); + return mod.analyzeIsErr(scope, src, loaded); +} + +fn zirCondbr(sema: *Sema, parent_block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const uncasted_cond = sema.resolveInst(block, inst.positionals.condition); + const cond = try sema.coerce(scope, Type.initTag(.bool), uncasted_cond); + + if (try mod.resolveDefinedValue(scope, cond)) |cond_val| { + const body = if (cond_val.toBool()) &inst.positionals.then_body else &inst.positionals.else_body; + try sema.body(parent_block, body.*); + return mod.constNoReturn(scope, inst.base.src); + } + + var true_block: Scope.Block = .{ + .parent = parent_block, + .inst_table = parent_block.inst_table, + .func = parent_block.func, + .owner_decl = parent_block.owner_decl, + .src_decl = parent_block.src_decl, + .instructions = .{}, + .arena = parent_block.arena, + .inlining = parent_block.inlining, + .is_comptime = parent_block.is_comptime, + .branch_quota = parent_block.branch_quota, + }; + defer true_block.instructions.deinit(mod.gpa); + try sema.body(&true_block, inst.positionals.then_body); + + var false_block: Scope.Block = .{ + .parent = parent_block, + .inst_table = parent_block.inst_table, + .func = parent_block.func, + .owner_decl = parent_block.owner_decl, + .src_decl = parent_block.src_decl, + .instructions = .{}, + .arena = parent_block.arena, + .inlining = parent_block.inlining, + .is_comptime = parent_block.is_comptime, + .branch_quota = parent_block.branch_quota, + }; + defer false_block.instructions.deinit(mod.gpa); + try sema.body(&false_block, inst.positionals.else_body); + + const then_body: ir.Body = .{ .instructions = try block.arena.dupe(*Inst, true_block.instructions.items) }; + const else_body: ir.Body = .{ .instructions = try block.arena.dupe(*Inst, false_block.instructions.items) }; + return mod.addCondBr(parent_block, inst.base.src, cond, then_body, else_body); +} + +fn zirUnreachable( + sema: *Sema, + block: *Scope.Block, + zir_index: zir.Inst.Index, + safety_check: bool, +) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + try sema.requireRuntimeBlock(block, zir_index.base.src); + // TODO Add compile error for @optimizeFor occurring too late in a scope. + if (safety_check and block.wantSafety()) { + return mod.safetyPanic(b, zir_index.base.src, .unreach); + } else { + return block.addNoOp(zir_index.base.src, Type.initTag(.noreturn), .unreach); + } +} + +fn zirRetTok(sema: *Sema, block: *Scope.Block, zir_inst: zir.Inst.Index) InnerError!*Inst { + @compileError("TODO"); +} + +fn zirRetNode(sema: *Sema, block: *Scope.Block, zir_inst: zir.Inst.Index) InnerError!*Inst { + @compileError("TODO"); +} + +fn floatOpAllowed(tag: zir.Inst.Tag) bool { + // extend this swich as additional operators are implemented + return switch (tag) { + .add, .sub => true, + else => false, + }; +} + +fn zirPtrTypeSimple(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].ptr_type_simple; + const elem_type = try sema.resolveType(block, .unneeded, inst_data.elem_type); + const ty = try sema.mod.ptrType( + block.arena, + elem_type, + null, + 0, + 0, + 0, + inst_data.is_mutable, + inst_data.is_allowzero, + inst_data.is_volatile, + inst_data.size, + ); + return sema.mod.constType(block.arena, .unneeded, ty); +} + +fn zirPtrType(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst { + const tracy = trace(@src()); + defer tracy.end(); + + const inst_data = sema.code.instructions.items(.data)[inst].ptr_type; + const extra = sema.code.extraData(zir.Inst.PtrType, inst_data.payload_index); + + var extra_i = extra.end; + + const sentinel = if (inst_data.flags.has_sentinel) blk: { + const ref = sema.code.extra[extra_i]; + extra_i += 1; + break :blk (try sema.resolveInstConst(block, .unneeded, ref)).val; + } else null; + + const abi_align = if (inst_data.flags.has_align) blk: { + const ref = sema.code.extra[extra_i]; + extra_i += 1; + break :blk try sema.resolveAlreadyCoercedInt(block, .unneeded, ref, u32); + } else 0; + + const bit_start = if (inst_data.flags.has_bit_start) blk: { + const ref = sema.code.extra[extra_i]; + extra_i += 1; + break :blk try sema.resolveAlreadyCoercedInt(block, .unneeded, ref, u16); + } else 0; + + const bit_end = if (inst_data.flags.has_bit_end) blk: { + const ref = sema.code.extra[extra_i]; + extra_i += 1; + break :blk try sema.resolveAlreadyCoercedInt(block, .unneeded, ref, u16); + } else 0; + + if (bit_end != 0 and bit_offset >= bit_end * 8) + return sema.mod.fail(&block.base, inst.base.src, "bit offset starts after end of host integer", .{}); + + const elem_type = try sema.resolveType(block, extra.data.elem_type); + + const ty = try mod.ptrType( + scope, + elem_type, + sentinel, + abi_align, + bit_start, + bit_end, + inst_data.flags.is_mutable, + inst_data.flags.is_allowzero, + inst_data.flags.is_volatile, + inst_data.size, + ); + return sema.mod.constType(block.arena, .unneeded, ty); +} + +fn requireFunctionBlock(sema: *Sema, block: *Scope.Block, src: LazySrcLoc) !void { + if (sema.func == null) { + return sema.mod.fail(&block.base, src, "instruction illegal outside function body", .{}); + } +} + +fn requireRuntimeBlock(sema: *Sema, block: *Scope.Block, src: LazySrcLoc) !void { + try sema.requireFunctionBlock(scope, src); + if (block.is_comptime) { + return sema.mod.fail(&block.base, src, "unable to resolve comptime value", .{}); + } +} + +fn validateVarType(sema: *Module, block: *Scope.Block, src: LazySrcLoc, ty: Type) !void { + if (!ty.isValidVarType(false)) { + return mod.fail(&block.base, src, "variable of type '{}' must be const or comptime", .{ty}); + } +} + +pub const PanicId = enum { + unreach, + unwrap_null, + unwrap_errunion, +}; + +fn addSafetyCheck(sema: *Sema, parent_block: *Scope.Block, ok: *Inst, panic_id: PanicId) !void { + const block_inst = try parent_block.arena.create(Inst.Block); + block_inst.* = .{ + .base = .{ + .tag = Inst.Block.base_tag, + .ty = Type.initTag(.void), + .src = ok.src, + }, + .body = .{ + .instructions = try parent_block.arena.alloc(*Inst, 1), // Only need space for the condbr. + }, + }; + + const ok_body: ir.Body = .{ + .instructions = try parent_block.arena.alloc(*Inst, 1), // Only need space for the br_void. + }; + const br_void = try parent_block.arena.create(Inst.BrVoid); + br_void.* = .{ + .base = .{ + .tag = .br_void, + .ty = Type.initTag(.noreturn), + .src = ok.src, + }, + .block = block_inst, + }; + ok_body.instructions[0] = &br_void.base; + + var fail_block: Scope.Block = .{ + .parent = parent_block, + .inst_map = parent_block.inst_map, + .func = parent_block.func, + .owner_decl = parent_block.owner_decl, + .src_decl = parent_block.src_decl, + .instructions = .{}, + .arena = parent_block.arena, + .inlining = parent_block.inlining, + .is_comptime = parent_block.is_comptime, + .branch_quota = parent_block.branch_quota, + }; + + defer fail_block.instructions.deinit(mod.gpa); + + _ = try mod.safetyPanic(&fail_block, ok.src, panic_id); + + const fail_body: ir.Body = .{ .instructions = try parent_block.arena.dupe(*Inst, fail_block.instructions.items) }; + + const condbr = try parent_block.arena.create(Inst.CondBr); + condbr.* = .{ + .base = .{ + .tag = .condbr, + .ty = Type.initTag(.noreturn), + .src = ok.src, + }, + .condition = ok, + .then_body = ok_body, + .else_body = fail_body, + }; + block_inst.body.instructions[0] = &condbr.base; + + try parent_block.instructions.append(mod.gpa, &block_inst.base); +} + +fn safetyPanic(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, panic_id: PanicId) !*Inst { + // TODO Once we have a panic function to call, call it here instead of breakpoint. + _ = try mod.addNoOp(block, src, Type.initTag(.void), .breakpoint); + return mod.addNoOp(block, src, Type.initTag(.noreturn), .unreach); +} + +fn emitBackwardBranch(sema: *Sema, block: *Scope.Block, src: LazySrcLoc) !void { + const shared = block.inlining.?.shared; + shared.branch_count += 1; + if (shared.branch_count > block.branch_quota.*) { + // TODO show the "called from here" stack + return mod.fail(&block.base, src, "evaluation exceeded {d} backwards branches", .{ + block.branch_quota.*, + }); + } +} + +fn namedFieldPtr( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + object_ptr: *Inst, + field_name: []const u8, + field_name_src: LazySrcLoc, +) InnerError!*Inst { + const elem_ty = switch (object_ptr.ty.zigTypeTag()) { + .Pointer => object_ptr.ty.elemType(), + else => return sema.mod.fail(&block.base, object_ptr.src, "expected pointer, found '{}'", .{object_ptr.ty}), + }; + switch (elem_ty.zigTypeTag()) { + .Array => { + if (mem.eql(u8, field_name, "len")) { + return mod.constInst(scope, src, .{ + .ty = Type.initTag(.single_const_pointer_to_comptime_int), + .val = try Value.Tag.ref_val.create( + scope.arena(), + try Value.Tag.int_u64.create(scope.arena(), elem_ty.arrayLen()), + ), + }); + } else { + return mod.fail( + scope, + field_name_src, + "no member named '{s}' in '{}'", + .{ field_name, elem_ty }, + ); + } + }, + .Pointer => { + const ptr_child = elem_ty.elemType(); + switch (ptr_child.zigTypeTag()) { + .Array => { + if (mem.eql(u8, field_name, "len")) { + return mod.constInst(scope, src, .{ + .ty = Type.initTag(.single_const_pointer_to_comptime_int), + .val = try Value.Tag.ref_val.create( + scope.arena(), + try Value.Tag.int_u64.create(scope.arena(), ptr_child.arrayLen()), + ), + }); + } else { + return mod.fail( + scope, + field_name_src, + "no member named '{s}' in '{}'", + .{ field_name, elem_ty }, + ); + } + }, + else => {}, + } + }, + .Type => { + _ = try sema.resolveConstValue(scope, object_ptr.src, object_ptr); + const result = try sema.analyzeDeref(block, src, object_ptr, object_ptr.src); + const val = result.value().?; + const child_type = try val.toType(scope.arena()); + switch (child_type.zigTypeTag()) { + .ErrorSet => { + var name: []const u8 = undefined; + // TODO resolve inferred error sets + if (val.castTag(.error_set)) |payload| + name = (payload.data.fields.getEntry(field_name) orelse return sema.mod.fail(&block.base, src, "no error named '{s}' in '{}'", .{ field_name, child_type })).key + else + name = (try mod.getErrorValue(field_name)).key; + + const result_type = if (child_type.tag() == .anyerror) + try Type.Tag.error_set_single.create(scope.arena(), name) + else + child_type; + + return mod.constInst(scope, src, .{ + .ty = try mod.simplePtrType(scope.arena(), result_type, false, .One), + .val = try Value.Tag.ref_val.create( + scope.arena(), + try Value.Tag.@"error".create(scope.arena(), .{ + .name = name, + }), + ), + }); + }, + .Struct => { + const container_scope = child_type.getContainerScope(); + if (mod.lookupDeclName(&container_scope.base, field_name)) |decl| { + // TODO if !decl.is_pub and inDifferentFiles() "{} is private" + return sema.analyzeDeclRef(block, src, decl); + } + + if (container_scope.file_scope == mod.root_scope) { + return sema.mod.fail(&block.base, src, "root source file has no member called '{s}'", .{field_name}); + } else { + return sema.mod.fail(&block.base, src, "container '{}' has no member called '{s}'", .{ child_type, field_name }); + } + }, + else => return sema.mod.fail(&block.base, src, "type '{}' does not support field access", .{child_type}), + } + }, + else => {}, + } + return sema.mod.fail(&block.base, src, "type '{}' does not support field access", .{elem_ty}); +} + +fn elemPtr( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + array_ptr: *Inst, + elem_index: *Inst, + elem_index_src: LazySrcLoc, +) InnerError!*Inst { + const elem_ty = switch (array_ptr.ty.zigTypeTag()) { + .Pointer => array_ptr.ty.elemType(), + else => return sema.mod.fail(&block.base, array_ptr.src, "expected pointer, found '{}'", .{array_ptr.ty}), + }; + if (!elem_ty.isIndexable()) { + return sema.mod.fail(&block.base, src, "array access of non-array type '{}'", .{elem_ty}); + } + + if (elem_ty.isSinglePointer() and elem_ty.elemType().zigTypeTag() == .Array) { + // we have to deref the ptr operand to get the actual array pointer + const array_ptr_deref = try sema.analyzeDeref(block, src, array_ptr, array_ptr.src); + if (array_ptr_deref.value()) |array_ptr_val| { + if (elem_index.value()) |index_val| { + // Both array pointer and index are compile-time known. + const index_u64 = index_val.toUnsignedInt(); + // @intCast here because it would have been impossible to construct a value that + // required a larger index. + const elem_ptr = try array_ptr_val.elemPtr(scope.arena(), @intCast(usize, index_u64)); + const pointee_type = elem_ty.elemType().elemType(); + + return mod.constInst(scope, src, .{ + .ty = try Type.Tag.single_const_pointer.create(scope.arena(), pointee_type), + .val = elem_ptr, + }); + } + } + } + + return sema.mod.fail(&block.base, src, "TODO implement more analyze elemptr", .{}); +} + +fn coerce(sema: *Sema, block: *Scope.Block, dest_type: Type, inst: *Inst) InnerError!*Inst { + if (dest_type.tag() == .var_args_param) { + return sema.coerceVarArgParam(scope, inst); + } + // If the types are the same, we can return the operand. + if (dest_type.eql(inst.ty)) + return inst; + + const in_memory_result = coerceInMemoryAllowed(dest_type, inst.ty); + if (in_memory_result == .ok) { + return sema.bitcast(scope, dest_type, inst); + } + + // undefined to anything + if (inst.value()) |val| { + if (val.isUndef() or inst.ty.zigTypeTag() == .Undefined) { + return mod.constInst(scope.arena(), inst.src, .{ .ty = dest_type, .val = val }); + } + } + assert(inst.ty.zigTypeTag() != .Undefined); + + // null to ?T + if (dest_type.zigTypeTag() == .Optional and inst.ty.zigTypeTag() == .Null) { + return mod.constInst(scope.arena(), inst.src, .{ .ty = dest_type, .val = Value.initTag(.null_value) }); + } + + // T to ?T + if (dest_type.zigTypeTag() == .Optional) { + var buf: Type.Payload.ElemType = undefined; + const child_type = dest_type.optionalChild(&buf); + if (child_type.eql(inst.ty)) { + return mod.wrapOptional(scope, dest_type, inst); + } else if (try sema.coerceNum(scope, child_type, inst)) |some| { + return mod.wrapOptional(scope, dest_type, some); + } + } + + // T to E!T or E to E!T + if (dest_type.tag() == .error_union) { + return try mod.wrapErrorUnion(scope, dest_type, inst); + } + + // Coercions where the source is a single pointer to an array. + src_array_ptr: { + if (!inst.ty.isSinglePointer()) break :src_array_ptr; + const array_type = inst.ty.elemType(); + if (array_type.zigTypeTag() != .Array) break :src_array_ptr; + const array_elem_type = array_type.elemType(); + if (inst.ty.isConstPtr() and !dest_type.isConstPtr()) break :src_array_ptr; + if (inst.ty.isVolatilePtr() and !dest_type.isVolatilePtr()) break :src_array_ptr; + + const dst_elem_type = dest_type.elemType(); + switch (coerceInMemoryAllowed(dst_elem_type, array_elem_type)) { + .ok => {}, + .no_match => break :src_array_ptr, + } + + switch (dest_type.ptrSize()) { + .Slice => { + // *[N]T to []T + return sema.coerceArrayPtrToSlice(scope, dest_type, inst); + }, + .C => { + // *[N]T to [*c]T + return sema.coerceArrayPtrToMany(scope, dest_type, inst); + }, + .Many => { + // *[N]T to [*]T + // *[N:s]T to [*:s]T + const src_sentinel = array_type.sentinel(); + const dst_sentinel = dest_type.sentinel(); + if (src_sentinel == null and dst_sentinel == null) + return sema.coerceArrayPtrToMany(scope, dest_type, inst); + + if (src_sentinel) |src_s| { + if (dst_sentinel) |dst_s| { + if (src_s.eql(dst_s)) { + return sema.coerceArrayPtrToMany(scope, dest_type, inst); + } + } + } + }, + .One => {}, + } + } + + // comptime known number to other number + if (try sema.coerceNum(scope, dest_type, inst)) |some| + return some; + + // integer widening + if (inst.ty.zigTypeTag() == .Int and dest_type.zigTypeTag() == .Int) { + assert(inst.value() == null); // handled above + + const src_info = inst.ty.intInfo(mod.getTarget()); + const dst_info = dest_type.intInfo(mod.getTarget()); + if ((src_info.signedness == dst_info.signedness and dst_info.bits >= src_info.bits) or + // small enough unsigned ints can get casted to large enough signed ints + (src_info.signedness == .signed and dst_info.signedness == .unsigned and dst_info.bits > src_info.bits)) + { + try sema.requireRuntimeBlock(block, inst.src); + return mod.addUnOp(b, inst.src, dest_type, .intcast, inst); + } + } + + // float widening + if (inst.ty.zigTypeTag() == .Float and dest_type.zigTypeTag() == .Float) { + assert(inst.value() == null); // handled above + + const src_bits = inst.ty.floatBits(mod.getTarget()); + const dst_bits = dest_type.floatBits(mod.getTarget()); + if (dst_bits >= src_bits) { + try sema.requireRuntimeBlock(block, inst.src); + return mod.addUnOp(b, inst.src, dest_type, .floatcast, inst); + } + } + + return sema.mod.fail(&block.base, inst.src, "expected {}, found {}", .{ dest_type, inst.ty }); +} + +const InMemoryCoercionResult = enum { + ok, + no_match, +}; + +fn coerceInMemoryAllowed(dest_type: Type, src_type: Type) InMemoryCoercionResult { + if (dest_type.eql(src_type)) + return .ok; + + // TODO: implement more of this function + + return .no_match; +} + +fn coerceNum(sema: *Sema, block: *Scope.Block, dest_type: Type, inst: *Inst) InnerError!?*Inst { + const val = inst.value() orelse return null; + const src_zig_tag = inst.ty.zigTypeTag(); + const dst_zig_tag = dest_type.zigTypeTag(); + + if (dst_zig_tag == .ComptimeInt or dst_zig_tag == .Int) { + if (src_zig_tag == .Float or src_zig_tag == .ComptimeFloat) { + if (val.floatHasFraction()) { + return sema.mod.fail(&block.base, inst.src, "fractional component prevents float value {} from being casted to type '{}'", .{ val, inst.ty }); + } + return sema.mod.fail(&block.base, inst.src, "TODO float to int", .{}); + } else if (src_zig_tag == .Int or src_zig_tag == .ComptimeInt) { + if (!val.intFitsInType(dest_type, mod.getTarget())) { + return sema.mod.fail(&block.base, inst.src, "type {} cannot represent integer value {}", .{ inst.ty, val }); + } + return mod.constInst(scope, inst.src, .{ .ty = dest_type, .val = val }); + } + } else if (dst_zig_tag == .ComptimeFloat or dst_zig_tag == .Float) { + if (src_zig_tag == .Float or src_zig_tag == .ComptimeFloat) { + const res = val.floatCast(scope.arena(), dest_type, mod.getTarget()) catch |err| switch (err) { + error.Overflow => return mod.fail( + scope, + inst.src, + "cast of value {} to type '{}' loses information", + .{ val, dest_type }, + ), + error.OutOfMemory => return error.OutOfMemory, + }; + return mod.constInst(scope, inst.src, .{ .ty = dest_type, .val = res }); + } else if (src_zig_tag == .Int or src_zig_tag == .ComptimeInt) { + return sema.mod.fail(&block.base, inst.src, "TODO int to float", .{}); + } + } + return null; +} + +fn coerceVarArgParam(sema: *Sema, block: *Scope.Block, inst: *Inst) !*Inst { + switch (inst.ty.zigTypeTag()) { + .ComptimeInt, .ComptimeFloat => return sema.mod.fail(&block.base, inst.src, "integer and float literals in var args function must be casted", .{}), + else => {}, + } + // TODO implement more of this function. + return inst; +} + +fn storePtr(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, ptr: *Inst, uncasted_value: *Inst) !*Inst { + if (ptr.ty.isConstPtr()) + return sema.mod.fail(&block.base, src, "cannot assign to constant", .{}); + + const elem_ty = ptr.ty.elemType(); + const value = try sema.coerce(scope, elem_ty, uncasted_value); + if (elem_ty.onePossibleValue() != null) + return sema.mod.constVoid(block.arena, .unneeded); + + // TODO handle comptime pointer writes + // TODO handle if the element type requires comptime + + try sema.requireRuntimeBlock(block, src); + return mod.addBinOp(b, src, Type.initTag(.void), .store, ptr, value); +} + +fn bitcast(sema: *Sema, block: *Scope.Block, dest_type: Type, inst: *Inst) !*Inst { + if (inst.value()) |val| { + // Keep the comptime Value representation; take the new type. + return mod.constInst(scope, inst.src, .{ .ty = dest_type, .val = val }); + } + // TODO validate the type size and other compile errors + try sema.requireRuntimeBlock(block, inst.src); + return mod.addUnOp(b, inst.src, dest_type, .bitcast, inst); +} + +fn coerceArrayPtrToSlice(sema: *Sema, block: *Scope.Block, dest_type: Type, inst: *Inst) !*Inst { + if (inst.value()) |val| { + // The comptime Value representation is compatible with both types. + return mod.constInst(scope, inst.src, .{ .ty = dest_type, .val = val }); + } + return sema.mod.fail(&block.base, inst.src, "TODO implement coerceArrayPtrToSlice runtime instruction", .{}); +} + +fn coerceArrayPtrToMany(sema: *Sema, block: *Scope.Block, dest_type: Type, inst: *Inst) !*Inst { + if (inst.value()) |val| { + // The comptime Value representation is compatible with both types. + return mod.constInst(scope, inst.src, .{ .ty = dest_type, .val = val }); + } + return sema.mod.fail(&block.base, inst.src, "TODO implement coerceArrayPtrToMany runtime instruction", .{}); +} + +fn analyzeDeclVal(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, decl: *Decl) InnerError!*Inst { + const decl_ref = try sema.analyzeDeclRef(block, src, decl); + return sema.analyzeDeref(block, src, decl_ref, src); +} + +fn analyzeDeclRef(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, decl: *Decl) InnerError!*Inst { + const scope_decl = scope.ownerDecl().?; + try mod.declareDeclDependency(scope_decl, decl); + mod.ensureDeclAnalyzed(decl) catch |err| { + if (scope.cast(Scope.Block)) |block| { + if (block.func) |func| { + func.state = .dependency_failure; + } else { + block.owner_decl.analysis = .dependency_failure; + } + } else { + scope_decl.analysis = .dependency_failure; + } + return err; + }; + + const decl_tv = try decl.typedValue(); + if (decl_tv.val.tag() == .variable) { + return mod.analyzeVarRef(scope, src, decl_tv); + } + return mod.constInst(scope.arena(), src, .{ + .ty = try mod.simplePtrType(scope.arena(), decl_tv.ty, false, .One), + .val = try Value.Tag.decl_ref.create(scope.arena(), decl), + }); +} + +fn analyzeVarRef(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, tv: TypedValue) InnerError!*Inst { + const variable = tv.val.castTag(.variable).?.data; + + const ty = try mod.simplePtrType(scope.arena(), tv.ty, variable.is_mutable, .One); + if (!variable.is_mutable and !variable.is_extern) { + return mod.constInst(scope.arena(), src, .{ + .ty = ty, + .val = try Value.Tag.ref_val.create(scope.arena(), variable.init), + }); + } + + try sema.requireRuntimeBlock(block, src); + const inst = try b.arena.create(Inst.VarPtr); + inst.* = .{ + .base = .{ + .tag = .varptr, + .ty = ty, + .src = src, + }, + .variable = variable, + }; + try b.instructions.append(mod.gpa, &inst.base); + return &inst.base; +} + +fn analyzeRef( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + operand: *Inst, +) InnerError!*Inst { + const ptr_type = try mod.simplePtrType(scope.arena(), operand.ty, false, .One); + + if (operand.value()) |val| { + return mod.constInst(scope.arena(), src, .{ + .ty = ptr_type, + .val = try Value.Tag.ref_val.create(scope.arena(), val), + }); + } + + try sema.requireRuntimeBlock(block, src); + return block.addUnOp(src, ptr_type, .ref, operand); +} + +fn analyzeDeref( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + ptr: *Inst, + ptr_src: LazySrcLoc, +) InnerError!*Inst { + const elem_ty = switch (ptr.ty.zigTypeTag()) { + .Pointer => ptr.ty.elemType(), + else => return sema.mod.fail(&block.base, ptr_src, "expected pointer, found '{}'", .{ptr.ty}), + }; + if (ptr.value()) |val| { + return mod.constInst(scope.arena(), src, .{ + .ty = elem_ty, + .val = try val.pointerDeref(scope.arena()), + }); + } + + try sema.requireRuntimeBlock(block, src); + return mod.addUnOp(b, src, elem_ty, .load, ptr); +} + +fn analyzeIsNull( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + operand: *Inst, + invert_logic: bool, +) InnerError!*Inst { + if (operand.value()) |opt_val| { + const is_null = opt_val.isNull(); + const bool_value = if (invert_logic) !is_null else is_null; + return mod.constBool(block.arena, src, bool_value); + } + try sema.requireRuntimeBlock(block, src); + const inst_tag: Inst.Tag = if (invert_logic) .is_non_null else .is_null; + return mod.addUnOp(b, src, Type.initTag(.bool), inst_tag, operand); +} + +fn analyzeIsErr(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, operand: *Inst) InnerError!*Inst { + const ot = operand.ty.zigTypeTag(); + if (ot != .ErrorSet and ot != .ErrorUnion) return mod.constBool(block.arena, src, false); + if (ot == .ErrorSet) return mod.constBool(block.arena, src, true); + assert(ot == .ErrorUnion); + if (operand.value()) |err_union| { + return mod.constBool(block.arena, src, err_union.getError() != null); + } + try sema.requireRuntimeBlock(block, src); + return mod.addUnOp(b, src, Type.initTag(.bool), .is_err, operand); +} + +fn analyzeSlice( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + array_ptr: *Inst, + start: *Inst, + end_opt: ?*Inst, + sentinel_opt: ?*Inst, + sentinel_src: LazySrcLoc, +) InnerError!*Inst { + const ptr_child = switch (array_ptr.ty.zigTypeTag()) { + .Pointer => array_ptr.ty.elemType(), + else => return sema.mod.fail(&block.base, src, "expected pointer, found '{}'", .{array_ptr.ty}), + }; + + var array_type = ptr_child; + const elem_type = switch (ptr_child.zigTypeTag()) { + .Array => ptr_child.elemType(), + .Pointer => blk: { + if (ptr_child.isSinglePointer()) { + if (ptr_child.elemType().zigTypeTag() == .Array) { + array_type = ptr_child.elemType(); + break :blk ptr_child.elemType().elemType(); + } + + return sema.mod.fail(&block.base, src, "slice of single-item pointer", .{}); + } + break :blk ptr_child.elemType(); + }, + else => return sema.mod.fail(&block.base, src, "slice of non-array type '{}'", .{ptr_child}), + }; + + const slice_sentinel = if (sentinel_opt) |sentinel| blk: { + const casted = try sema.coerce(scope, elem_type, sentinel); + break :blk try sema.resolveConstValue(block, sentinel_src, casted); + } else null; + + var return_ptr_size: std.builtin.TypeInfo.Pointer.Size = .Slice; + var return_elem_type = elem_type; + if (end_opt) |end| { + if (end.value()) |end_val| { + if (start.value()) |start_val| { + const start_u64 = start_val.toUnsignedInt(); + const end_u64 = end_val.toUnsignedInt(); + if (start_u64 > end_u64) { + return sema.mod.fail(&block.base, src, "out of bounds slice", .{}); + } + + const len = end_u64 - start_u64; + const array_sentinel = if (array_type.zigTypeTag() == .Array and end_u64 == array_type.arrayLen()) + array_type.sentinel() + else + slice_sentinel; + return_elem_type = try mod.arrayType(scope, len, array_sentinel, elem_type); + return_ptr_size = .One; + } + } + } + const return_type = try mod.ptrType( + scope, + return_elem_type, + if (end_opt == null) slice_sentinel else null, + 0, // TODO alignment + 0, + 0, + !ptr_child.isConstPtr(), + ptr_child.isAllowzeroPtr(), + ptr_child.isVolatilePtr(), + return_ptr_size, + ); + + return sema.mod.fail(&block.base, src, "TODO implement analysis of slice", .{}); +} + +fn analyzeImport(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, target_string: []const u8) !*Scope.File { + const cur_pkg = scope.getFileScope().pkg; + const cur_pkg_dir_path = cur_pkg.root_src_directory.path orelse "."; + const found_pkg = cur_pkg.table.get(target_string); + + const resolved_path = if (found_pkg) |pkg| + try std.fs.path.resolve(mod.gpa, &[_][]const u8{ pkg.root_src_directory.path orelse ".", pkg.root_src_path }) + else + try std.fs.path.resolve(mod.gpa, &[_][]const u8{ cur_pkg_dir_path, target_string }); + errdefer mod.gpa.free(resolved_path); + + if (mod.import_table.get(resolved_path)) |some| { + mod.gpa.free(resolved_path); + return some; + } + + if (found_pkg == null) { + const resolved_root_path = try std.fs.path.resolve(mod.gpa, &[_][]const u8{cur_pkg_dir_path}); + defer mod.gpa.free(resolved_root_path); + + if (!mem.startsWith(u8, resolved_path, resolved_root_path)) { + return error.ImportOutsidePkgPath; + } + } + + // TODO Scope.Container arena for ty and sub_file_path + const file_scope = try mod.gpa.create(Scope.File); + errdefer mod.gpa.destroy(file_scope); + const struct_ty = try Type.Tag.empty_struct.create(mod.gpa, &file_scope.root_container); + errdefer mod.gpa.destroy(struct_ty.castTag(.empty_struct).?); + + file_scope.* = .{ + .sub_file_path = resolved_path, + .source = .{ .unloaded = {} }, + .tree = undefined, + .status = .never_loaded, + .pkg = found_pkg orelse cur_pkg, + .root_container = .{ + .file_scope = file_scope, + .decls = .{}, + .ty = struct_ty, + }, + }; + mod.analyzeContainer(&file_scope.root_container) catch |err| switch (err) { + error.AnalysisFail => { + assert(mod.comp.totalErrorCount() != 0); + }, + else => |e| return e, + }; + try mod.import_table.put(mod.gpa, file_scope.sub_file_path, file_scope); + return file_scope; +} + +/// Asserts that lhs and rhs types are both numeric. +fn cmpNumeric( + sema: *Sema, + block: *Scope.Block, + src: LazySrcLoc, + lhs: *Inst, + rhs: *Inst, + op: std.math.CompareOperator, +) InnerError!*Inst { + assert(lhs.ty.isNumeric()); + assert(rhs.ty.isNumeric()); + + const lhs_ty_tag = lhs.ty.zigTypeTag(); + const rhs_ty_tag = rhs.ty.zigTypeTag(); + + if (lhs_ty_tag == .Vector and rhs_ty_tag == .Vector) { + if (lhs.ty.arrayLen() != rhs.ty.arrayLen()) { + return sema.mod.fail(&block.base, src, "vector length mismatch: {d} and {d}", .{ + lhs.ty.arrayLen(), + rhs.ty.arrayLen(), + }); + } + return sema.mod.fail(&block.base, src, "TODO implement support for vectors in cmpNumeric", .{}); + } else if (lhs_ty_tag == .Vector or rhs_ty_tag == .Vector) { + return sema.mod.fail(&block.base, src, "mixed scalar and vector operands to comparison operator: '{}' and '{}'", .{ + lhs.ty, + rhs.ty, + }); + } + + if (lhs.value()) |lhs_val| { + if (rhs.value()) |rhs_val| { + return mod.constBool(block.arena, src, Value.compare(lhs_val, op, rhs_val)); + } + } + + // TODO handle comparisons against lazy zero values + // Some values can be compared against zero without being runtime known or without forcing + // a full resolution of their value, for example `@sizeOf(@Frame(function))` is known to + // always be nonzero, and we benefit from not forcing the full evaluation and stack frame layout + // of this function if we don't need to. + + // It must be a runtime comparison. + try sema.requireRuntimeBlock(block, src); + // For floats, emit a float comparison instruction. + const lhs_is_float = switch (lhs_ty_tag) { + .Float, .ComptimeFloat => true, + else => false, + }; + const rhs_is_float = switch (rhs_ty_tag) { + .Float, .ComptimeFloat => true, + else => false, + }; + if (lhs_is_float and rhs_is_float) { + // Implicit cast the smaller one to the larger one. + const dest_type = x: { + if (lhs_ty_tag == .ComptimeFloat) { + break :x rhs.ty; + } else if (rhs_ty_tag == .ComptimeFloat) { + break :x lhs.ty; + } + if (lhs.ty.floatBits(mod.getTarget()) >= rhs.ty.floatBits(mod.getTarget())) { + break :x lhs.ty; + } else { + break :x rhs.ty; + } + }; + const casted_lhs = try sema.coerce(scope, dest_type, lhs); + const casted_rhs = try sema.coerce(scope, dest_type, rhs); + return mod.addBinOp(b, src, dest_type, Inst.Tag.fromCmpOp(op), casted_lhs, casted_rhs); + } + // For mixed unsigned integer sizes, implicit cast both operands to the larger integer. + // For mixed signed and unsigned integers, implicit cast both operands to a signed + // integer with + 1 bit. + // For mixed floats and integers, extract the integer part from the float, cast that to + // a signed integer with mantissa bits + 1, and if there was any non-integral part of the float, + // add/subtract 1. + const lhs_is_signed = if (lhs.value()) |lhs_val| + lhs_val.compareWithZero(.lt) + else + (lhs.ty.isFloat() or lhs.ty.isSignedInt()); + const rhs_is_signed = if (rhs.value()) |rhs_val| + rhs_val.compareWithZero(.lt) + else + (rhs.ty.isFloat() or rhs.ty.isSignedInt()); + const dest_int_is_signed = lhs_is_signed or rhs_is_signed; + + var dest_float_type: ?Type = null; + + var lhs_bits: usize = undefined; + if (lhs.value()) |lhs_val| { + if (lhs_val.isUndef()) + return mod.constUndef(scope, src, Type.initTag(.bool)); + const is_unsigned = if (lhs_is_float) x: { + var bigint_space: Value.BigIntSpace = undefined; + var bigint = try lhs_val.toBigInt(&bigint_space).toManaged(mod.gpa); + defer bigint.deinit(); + const zcmp = lhs_val.orderAgainstZero(); + if (lhs_val.floatHasFraction()) { + switch (op) { + .eq => return mod.constBool(block.arena, src, false), + .neq => return mod.constBool(block.arena, src, true), + else => {}, + } + if (zcmp == .lt) { + try bigint.addScalar(bigint.toConst(), -1); + } else { + try bigint.addScalar(bigint.toConst(), 1); + } + } + lhs_bits = bigint.toConst().bitCountTwosComp(); + break :x (zcmp != .lt); + } else x: { + lhs_bits = lhs_val.intBitCountTwosComp(); + break :x (lhs_val.orderAgainstZero() != .lt); + }; + lhs_bits += @boolToInt(is_unsigned and dest_int_is_signed); + } else if (lhs_is_float) { + dest_float_type = lhs.ty; + } else { + const int_info = lhs.ty.intInfo(mod.getTarget()); + lhs_bits = int_info.bits + @boolToInt(int_info.signedness == .unsigned and dest_int_is_signed); + } + + var rhs_bits: usize = undefined; + if (rhs.value()) |rhs_val| { + if (rhs_val.isUndef()) + return mod.constUndef(scope, src, Type.initTag(.bool)); + const is_unsigned = if (rhs_is_float) x: { + var bigint_space: Value.BigIntSpace = undefined; + var bigint = try rhs_val.toBigInt(&bigint_space).toManaged(mod.gpa); + defer bigint.deinit(); + const zcmp = rhs_val.orderAgainstZero(); + if (rhs_val.floatHasFraction()) { + switch (op) { + .eq => return mod.constBool(block.arena, src, false), + .neq => return mod.constBool(block.arena, src, true), + else => {}, + } + if (zcmp == .lt) { + try bigint.addScalar(bigint.toConst(), -1); + } else { + try bigint.addScalar(bigint.toConst(), 1); + } + } + rhs_bits = bigint.toConst().bitCountTwosComp(); + break :x (zcmp != .lt); + } else x: { + rhs_bits = rhs_val.intBitCountTwosComp(); + break :x (rhs_val.orderAgainstZero() != .lt); + }; + rhs_bits += @boolToInt(is_unsigned and dest_int_is_signed); + } else if (rhs_is_float) { + dest_float_type = rhs.ty; + } else { + const int_info = rhs.ty.intInfo(mod.getTarget()); + rhs_bits = int_info.bits + @boolToInt(int_info.signedness == .unsigned and dest_int_is_signed); + } + + const dest_type = if (dest_float_type) |ft| ft else blk: { + const max_bits = std.math.max(lhs_bits, rhs_bits); + const casted_bits = std.math.cast(u16, max_bits) catch |err| switch (err) { + error.Overflow => return sema.mod.fail(&block.base, src, "{d} exceeds maximum integer bit count", .{max_bits}), + }; + break :blk try mod.makeIntType(scope, dest_int_is_signed, casted_bits); + }; + const casted_lhs = try sema.coerce(scope, dest_type, lhs); + const casted_rhs = try sema.coerce(scope, dest_type, rhs); + + return mod.addBinOp(b, src, Type.initTag(.bool), Inst.Tag.fromCmpOp(op), casted_lhs, casted_rhs); +} + +fn wrapOptional(sema: *Sema, block: *Scope.Block, dest_type: Type, inst: *Inst) !*Inst { + if (inst.value()) |val| { + return mod.constInst(scope.arena(), inst.src, .{ .ty = dest_type, .val = val }); + } + + try sema.requireRuntimeBlock(block, inst.src); + return mod.addUnOp(b, inst.src, dest_type, .wrap_optional, inst); +} + +fn wrapErrorUnion(sema: *Sema, block: *Scope.Block, dest_type: Type, inst: *Inst) !*Inst { + // TODO deal with inferred error sets + const err_union = dest_type.castTag(.error_union).?; + if (inst.value()) |val| { + const to_wrap = if (inst.ty.zigTypeTag() != .ErrorSet) blk: { + _ = try sema.coerce(scope, err_union.data.payload, inst); + break :blk val; + } else switch (err_union.data.error_set.tag()) { + .anyerror => val, + .error_set_single => blk: { + const n = err_union.data.error_set.castTag(.error_set_single).?.data; + if (!mem.eql(u8, val.castTag(.@"error").?.data.name, n)) + return sema.mod.fail(&block.base, inst.src, "expected type '{}', found type '{}'", .{ err_union.data.error_set, inst.ty }); + break :blk val; + }, + .error_set => blk: { + const f = err_union.data.error_set.castTag(.error_set).?.data.typed_value.most_recent.typed_value.val.castTag(.error_set).?.data.fields; + if (f.get(val.castTag(.@"error").?.data.name) == null) + return sema.mod.fail(&block.base, inst.src, "expected type '{}', found type '{}'", .{ err_union.data.error_set, inst.ty }); + break :blk val; + }, + else => unreachable, + }; + + return mod.constInst(scope.arena(), inst.src, .{ + .ty = dest_type, + // creating a SubValue for the error_union payload + .val = try Value.Tag.error_union.create( + scope.arena(), + to_wrap, + ), + }); + } + + try sema.requireRuntimeBlock(block, inst.src); + + // we are coercing from E to E!T + if (inst.ty.zigTypeTag() == .ErrorSet) { + var coerced = try sema.coerce(scope, err_union.data.error_set, inst); + return mod.addUnOp(b, inst.src, dest_type, .wrap_errunion_err, coerced); + } else { + var coerced = try sema.coerce(scope, err_union.data.payload, inst); + return mod.addUnOp(b, inst.src, dest_type, .wrap_errunion_payload, coerced); + } +} + +fn resolvePeerTypes(sema: *Sema, block: *Scope.Block, instructions: []*Inst) !Type { + if (instructions.len == 0) + return Type.initTag(.noreturn); + + if (instructions.len == 1) + return instructions[0].ty; + + var chosen = instructions[0]; + for (instructions[1..]) |candidate| { + if (candidate.ty.eql(chosen.ty)) + continue; + if (candidate.ty.zigTypeTag() == .NoReturn) + continue; + if (chosen.ty.zigTypeTag() == .NoReturn) { + chosen = candidate; + continue; + } + if (candidate.ty.zigTypeTag() == .Undefined) + continue; + if (chosen.ty.zigTypeTag() == .Undefined) { + chosen = candidate; + continue; + } + if (chosen.ty.isInt() and + candidate.ty.isInt() and + chosen.ty.isSignedInt() == candidate.ty.isSignedInt()) + { + if (chosen.ty.intInfo(mod.getTarget()).bits < candidate.ty.intInfo(mod.getTarget()).bits) { + chosen = candidate; + } + continue; + } + if (chosen.ty.isFloat() and candidate.ty.isFloat()) { + if (chosen.ty.floatBits(mod.getTarget()) < candidate.ty.floatBits(mod.getTarget())) { + chosen = candidate; + } + continue; + } + + if (chosen.ty.zigTypeTag() == .ComptimeInt and candidate.ty.isInt()) { + chosen = candidate; + continue; + } + + if (chosen.ty.isInt() and candidate.ty.zigTypeTag() == .ComptimeInt) { + continue; + } + + // TODO error notes pointing out each type + return sema.mod.fail(&block.base, candidate.src, "incompatible types: '{}' and '{}'", .{ chosen.ty, candidate.ty }); + } + + return chosen.ty; +} |