| ... | ... | @@ -1915,6 +1915,18 @@ fn resolveConstValue( |
| 1915 | 1915 | return sema.failWithNeededComptime(block, src, reason); |
| 1916 | 1916 | } |
| 1917 | 1917 | |
| 1918 | /// Will not return Value Tags: `variable`, `undef`. Instead they will emit compile errors. |
| 1919 | /// Lazy values are recursively resolved. |
| 1920 | fn resolveConstLazyValue( |
| 1921 | sema: *Sema, |
| 1922 | block: *Block, |
| 1923 | src: LazySrcLoc, |
| 1924 | air_ref: Air.Inst.Ref, |
| 1925 | reason: []const u8, |
| 1926 | ) CompileError!Value { |
| 1927 | return sema.resolveLazyValue(try sema.resolveConstValue(block, src, air_ref, reason)); |
| 1928 | } |
| 1929 | |
| 1918 | 1930 | /// Value Tag `variable` causes this function to return `null`. |
| 1919 | 1931 | /// Value Tag `undef` causes this function to return a compile error. |
| 1920 | 1932 | fn resolveDefinedValue( |
| ... | ... | @@ -1952,10 +1964,22 @@ fn resolveMaybeUndefVal( |
| 1952 | 1964 | } |
| 1953 | 1965 | } |
| 1954 | 1966 | |
| 1967 | /// Value Tag `variable` causes this function to return `null`. |
| 1968 | /// Value Tag `undef` causes this function to return the Value. |
| 1969 | /// Value Tag `generic_poison` causes `error.GenericPoison` to be returned. |
| 1970 | /// Lazy values are recursively resolved. |
| 1971 | fn resolveMaybeUndefLazyVal( |
| 1972 | sema: *Sema, |
| 1973 | inst: Air.Inst.Ref, |
| 1974 | ) CompileError!?Value { |
| 1975 | return try sema.resolveLazyValue((try sema.resolveMaybeUndefVal(inst)) orelse return null); |
| 1976 | } |
| 1977 | |
| 1955 | 1978 | /// Value Tag `variable` results in `null`. |
| 1956 | 1979 | /// Value Tag `undef` results in the Value. |
| 1957 | 1980 | /// Value Tag `generic_poison` causes `error.GenericPoison` to be returned. |
| 1958 | 1981 | /// Value Tag `decl_ref` and `decl_ref_mut` or any nested such value results in `null`. |
| 1982 | /// Lazy values are recursively resolved. |
| 1959 | 1983 | fn resolveMaybeUndefValIntable( |
| 1960 | 1984 | sema: *Sema, |
| 1961 | 1985 | inst: Air.Inst.Ref, |
| ... | ... | @@ -1976,8 +2000,7 @@ fn resolveMaybeUndefValIntable( |
| 1976 | 2000 | else => break, |
| 1977 | 2001 | }, |
| 1978 | 2002 | }; |
| 1979 | | try sema.resolveLazyValue(val); |
| 1980 | | return val; |
| 2003 | return try sema.resolveLazyValue(val); |
| 1981 | 2004 | } |
| 1982 | 2005 | |
| 1983 | 2006 | /// Returns all Value tags including `variable` and `undef`. |
| ... | ... | @@ -5257,8 +5280,7 @@ fn zirCompileLog( |
| 5257 | 5280 | |
| 5258 | 5281 | const arg = try sema.resolveInst(arg_ref); |
| 5259 | 5282 | const arg_ty = sema.typeOf(arg); |
| 5260 | | if (try sema.resolveMaybeUndefVal(arg)) |val| { |
| 5261 | | try sema.resolveLazyValue(val); |
| 5283 | if (try sema.resolveMaybeUndefLazyVal(arg)) |val| { |
| 5262 | 5284 | try writer.print("@as({}, {})", .{ |
| 5263 | 5285 | arg_ty.fmt(sema.mod), val.fmtValue(arg_ty, sema.mod), |
| 5264 | 5286 | }); |
| ... | ... | @@ -7266,15 +7288,14 @@ fn analyzeInlineCallArg( |
| 7266 | 7288 | // parameter or return type. |
| 7267 | 7289 | return error.GenericPoison; |
| 7268 | 7290 | }, |
| 7269 | | else => { |
| 7270 | | // Needed so that lazy values do not trigger |
| 7271 | | // assertion due to type not being resolved |
| 7272 | | // when the hash function is called. |
| 7273 | | try sema.resolveLazyValue(arg_val); |
| 7274 | | }, |
| 7291 | else => {}, |
| 7275 | 7292 | } |
| 7276 | | should_memoize.* = should_memoize.* and !arg_val.canMutateComptimeVarState(mod); |
| 7277 | | memoized_arg_values[arg_i.*] = try arg_val.intern(param_ty.toType(), mod); |
| 7293 | // Needed so that lazy values do not trigger |
| 7294 | // assertion due to type not being resolved |
| 7295 | // when the hash function is called. |
| 7296 | const resolved_arg_val = try sema.resolveLazyValue(arg_val); |
| 7297 | should_memoize.* = should_memoize.* and !resolved_arg_val.canMutateComptimeVarState(mod); |
| 7298 | memoized_arg_values[arg_i.*] = try resolved_arg_val.intern(param_ty.toType(), mod); |
| 7278 | 7299 | } else { |
| 7279 | 7300 | sema.inst_map.putAssumeCapacityNoClobber(inst, casted_arg); |
| 7280 | 7301 | } |
| ... | ... | @@ -7302,15 +7323,14 @@ fn analyzeInlineCallArg( |
| 7302 | 7323 | // parameter or return type. |
| 7303 | 7324 | return error.GenericPoison; |
| 7304 | 7325 | }, |
| 7305 | | else => { |
| 7306 | | // Needed so that lazy values do not trigger |
| 7307 | | // assertion due to type not being resolved |
| 7308 | | // when the hash function is called. |
| 7309 | | try sema.resolveLazyValue(arg_val); |
| 7310 | | }, |
| 7326 | else => {}, |
| 7311 | 7327 | } |
| 7312 | | should_memoize.* = should_memoize.* and !arg_val.canMutateComptimeVarState(mod); |
| 7313 | | memoized_arg_values[arg_i.*] = try arg_val.intern(sema.typeOf(uncasted_arg), mod); |
| 7328 | // Needed so that lazy values do not trigger |
| 7329 | // assertion due to type not being resolved |
| 7330 | // when the hash function is called. |
| 7331 | const resolved_arg_val = try sema.resolveLazyValue(arg_val); |
| 7332 | should_memoize.* = should_memoize.* and !resolved_arg_val.canMutateComptimeVarState(mod); |
| 7333 | memoized_arg_values[arg_i.*] = try resolved_arg_val.intern(sema.typeOf(uncasted_arg), mod); |
| 7314 | 7334 | } else { |
| 7315 | 7335 | if (zir_tags[inst] == .param_anytype_comptime) { |
| 7316 | 7336 | _ = try sema.resolveConstMaybeUndefVal(arg_block, arg_src, uncasted_arg, "parameter is comptime"); |
| ... | ... | @@ -7369,9 +7389,7 @@ fn analyzeGenericCallArg( |
| 7369 | 7389 | } |
| 7370 | 7390 | |
| 7371 | 7391 | fn analyzeGenericCallArgVal(sema: *Sema, block: *Block, arg_src: LazySrcLoc, uncasted_arg: Air.Inst.Ref) !Value { |
| 7372 | | const arg_val = try sema.resolveValue(block, arg_src, uncasted_arg, "parameter is comptime"); |
| 7373 | | try sema.resolveLazyValue(arg_val); |
| 7374 | | return arg_val; |
| 7392 | return sema.resolveLazyValue(try sema.resolveValue(block, arg_src, uncasted_arg, "parameter is comptime")); |
| 7375 | 7393 | } |
| 7376 | 7394 | |
| 7377 | 7395 | fn instantiateGenericCall( |
| ... | ... | @@ -7903,7 +7921,8 @@ fn resolveTupleLazyValues(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) |
| 7903 | 7921 | for (tuple.types, tuple.values) |field_ty, field_val| { |
| 7904 | 7922 | try sema.resolveTupleLazyValues(block, src, field_ty.toType()); |
| 7905 | 7923 | if (field_val == .none) continue; |
| 7906 | | try sema.resolveLazyValue(field_val.toValue()); |
| 7924 | // TODO: mutate in intern pool |
| 7925 | _ = try sema.resolveLazyValue(field_val.toValue()); |
| 7907 | 7926 | } |
| 7908 | 7927 | } |
| 7909 | 7928 | |
| ... | ... | @@ -10104,8 +10123,9 @@ fn zirSwitchCapture( |
| 10104 | 10123 | |
| 10105 | 10124 | if (block.inline_case_capture != .none) { |
| 10106 | 10125 | const item_val = sema.resolveConstValue(block, .unneeded, block.inline_case_capture, undefined) catch unreachable; |
| 10126 | const resolved_item_val = try sema.resolveLazyValue(item_val); |
| 10107 | 10127 | if (operand_ty.zigTypeTag(mod) == .Union) { |
| 10108 | | const field_index = @intCast(u32, operand_ty.unionTagFieldIndex(item_val, sema.mod).?); |
| 10128 | const field_index = @intCast(u32, operand_ty.unionTagFieldIndex(resolved_item_val, sema.mod).?); |
| 10109 | 10129 | const union_obj = mod.typeToUnion(operand_ty).?; |
| 10110 | 10130 | const field_ty = union_obj.fields.values()[field_index].ty; |
| 10111 | 10131 | if (try sema.resolveDefinedValue(block, sema.src, operand_ptr)) |union_val| { |
| ... | ... | @@ -10141,7 +10161,7 @@ fn zirSwitchCapture( |
| 10141 | 10161 | return block.addStructFieldVal(operand_ptr, field_index, field_ty); |
| 10142 | 10162 | } |
| 10143 | 10163 | } else if (is_ref) { |
| 10144 | | return sema.addConstantMaybeRef(block, operand_ty, item_val, true); |
| 10164 | return sema.addConstantMaybeRef(block, operand_ty, resolved_item_val, true); |
| 10145 | 10165 | } else { |
| 10146 | 10166 | return block.inline_case_capture; |
| 10147 | 10167 | } |
| ... | ... | @@ -10249,7 +10269,7 @@ fn zirSwitchCapture( |
| 10249 | 10269 | for (items) |item| { |
| 10250 | 10270 | const item_ref = try sema.resolveInst(item); |
| 10251 | 10271 | // Previous switch validation ensured this will succeed |
| 10252 | | const item_val = sema.resolveConstValue(block, .unneeded, item_ref, "") catch unreachable; |
| 10272 | const item_val = sema.resolveConstLazyValue(block, .unneeded, item_ref, "") catch unreachable; |
| 10253 | 10273 | const name_ip = try mod.intern_pool.getOrPutString(gpa, item_val.getError(mod).?); |
| 10254 | 10274 | names.putAssumeCapacityNoClobber(name_ip, {}); |
| 10255 | 10275 | } |
| ... | ... | @@ -10259,7 +10279,7 @@ fn zirSwitchCapture( |
| 10259 | 10279 | } else { |
| 10260 | 10280 | const item_ref = try sema.resolveInst(items[0]); |
| 10261 | 10281 | // Previous switch validation ensured this will succeed |
| 10262 | | const item_val = sema.resolveConstValue(block, .unneeded, item_ref, "") catch unreachable; |
| 10282 | const item_val = sema.resolveConstLazyValue(block, .unneeded, item_ref, "") catch unreachable; |
| 10263 | 10283 | |
| 10264 | 10284 | const item_ty = try mod.singleErrorSetType(item_val.getError(mod).?); |
| 10265 | 10285 | return sema.bitCast(block, item_ty, operand, operand_src, null); |
| ... | ... | @@ -10993,6 +11013,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError |
| 10993 | 11013 | defer merges.deinit(gpa); |
| 10994 | 11014 | |
| 10995 | 11015 | if (try sema.resolveDefinedValue(&child_block, src, operand)) |operand_val| { |
| 11016 | const resolved_operand_val = try sema.resolveLazyValue(operand_val); |
| 10996 | 11017 | var extra_index: usize = special.end; |
| 10997 | 11018 | { |
| 10998 | 11019 | var scalar_i: usize = 0; |
| ... | ... | @@ -11007,8 +11028,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError |
| 11007 | 11028 | |
| 11008 | 11029 | const item = try sema.resolveInst(item_ref); |
| 11009 | 11030 | // Validation above ensured these will succeed. |
| 11010 | | const item_val = sema.resolveConstValue(&child_block, .unneeded, item, "") catch unreachable; |
| 11011 | | if (operand_val.eql(item_val, operand_ty, mod)) { |
| 11031 | const item_val = sema.resolveConstLazyValue(&child_block, .unneeded, item, "") catch unreachable; |
| 11032 | if (resolved_operand_val.eql(item_val, operand_ty, mod)) { |
| 11012 | 11033 | if (is_inline) child_block.inline_case_capture = operand; |
| 11013 | 11034 | |
| 11014 | 11035 | if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, body, operand); |
| ... | ... | @@ -11033,8 +11054,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError |
| 11033 | 11054 | for (items) |item_ref| { |
| 11034 | 11055 | const item = try sema.resolveInst(item_ref); |
| 11035 | 11056 | // Validation above ensured these will succeed. |
| 11036 | | const item_val = sema.resolveConstValue(&child_block, .unneeded, item, "") catch unreachable; |
| 11037 | | if (operand_val.eql(item_val, operand_ty, mod)) { |
| 11057 | const item_val = sema.resolveConstLazyValue(&child_block, .unneeded, item, "") catch unreachable; |
| 11058 | if (resolved_operand_val.eql(item_val, operand_ty, mod)) { |
| 11038 | 11059 | if (is_inline) child_block.inline_case_capture = operand; |
| 11039 | 11060 | |
| 11040 | 11061 | if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, body, operand); |
| ... | ... | @@ -11052,8 +11073,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError |
| 11052 | 11073 | // Validation above ensured these will succeed. |
| 11053 | 11074 | const first_tv = sema.resolveInstConst(&child_block, .unneeded, item_first, "") catch unreachable; |
| 11054 | 11075 | const last_tv = sema.resolveInstConst(&child_block, .unneeded, item_last, "") catch unreachable; |
| 11055 | | if ((try sema.compareAll(operand_val, .gte, first_tv.val, operand_ty)) and |
| 11056 | | (try sema.compareAll(operand_val, .lte, last_tv.val, operand_ty))) |
| 11076 | if ((try sema.compareAll(resolved_operand_val, .gte, first_tv.val, operand_ty)) and |
| 11077 | (try sema.compareAll(resolved_operand_val, .lte, last_tv.val, operand_ty))) |
| 11057 | 11078 | { |
| 11058 | 11079 | if (is_inline) child_block.inline_case_capture = operand; |
| 11059 | 11080 | if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, body, operand); |
| ... | ... | @@ -11135,7 +11156,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError |
| 11135 | 11156 | // `item` is already guaranteed to be constant known. |
| 11136 | 11157 | |
| 11137 | 11158 | const analyze_body = if (union_originally) blk: { |
| 11138 | | const item_val = sema.resolveConstValue(block, .unneeded, item, "") catch unreachable; |
| 11159 | const item_val = sema.resolveConstLazyValue(block, .unneeded, item, "") catch unreachable; |
| 11139 | 11160 | const field_ty = maybe_union_ty.unionFieldType(item_val, mod); |
| 11140 | 11161 | break :blk field_ty.zigTypeTag(mod) != .NoReturn; |
| 11141 | 11162 | } else true; |
| ... | ... | @@ -11683,8 +11704,7 @@ fn resolveSwitchItemVal( |
| 11683 | 11704 | // Constructing a LazySrcLoc is costly because we only have the switch AST node. |
| 11684 | 11705 | // Only if we know for sure we need to report a compile error do we resolve the |
| 11685 | 11706 | // full source locations. |
| 11686 | | if (sema.resolveConstValue(block, .unneeded, item, "")) |val| { |
| 11687 | | try sema.resolveLazyValue(val); |
| 11707 | if (sema.resolveConstLazyValue(block, .unneeded, item, "")) |val| { |
| 11688 | 11708 | return val.toIntern(); |
| 11689 | 11709 | } else |err| switch (err) { |
| 11690 | 11710 | error.NeededSourceLocation => { |
| ... | ... | @@ -20634,9 +20654,8 @@ fn zirBitCount( |
| 20634 | 20654 | } |
| 20635 | 20655 | }, |
| 20636 | 20656 | .Int => { |
| 20637 | | if (try sema.resolveMaybeUndefVal(operand)) |val| { |
| 20657 | if (try sema.resolveMaybeUndefLazyVal(operand)) |val| { |
| 20638 | 20658 | if (val.isUndef(mod)) return sema.addConstUndef(result_scalar_ty); |
| 20639 | | try sema.resolveLazyValue(val); |
| 20640 | 20659 | return sema.addIntUnsigned(result_scalar_ty, comptimeOp(val, operand_ty, mod)); |
| 20641 | 20660 | } else { |
| 20642 | 20661 | try sema.requireRuntimeBlock(block, src, operand_src); |
| ... | ... | @@ -22311,18 +22330,18 @@ fn analyzeMinMax( |
| 22311 | 22330 | continue; |
| 22312 | 22331 | } |
| 22313 | 22332 | |
| 22314 | | try sema.resolveLazyValue(cur_val); |
| 22315 | | try sema.resolveLazyValue(operand_val); |
| 22333 | const resolved_cur_val = try sema.resolveLazyValue(cur_val); |
| 22334 | const resolved_operand_val = try sema.resolveLazyValue(operand_val); |
| 22316 | 22335 | |
| 22317 | 22336 | const vec_len = simd_op.len orelse { |
| 22318 | | const result_val = opFunc(cur_val, operand_val, mod); |
| 22337 | const result_val = opFunc(resolved_cur_val, resolved_operand_val, mod); |
| 22319 | 22338 | cur_minmax = try sema.addConstant(simd_op.result_ty, result_val); |
| 22320 | 22339 | continue; |
| 22321 | 22340 | }; |
| 22322 | 22341 | const elems = try sema.arena.alloc(InternPool.Index, vec_len); |
| 22323 | 22342 | for (elems, 0..) |*elem, i| { |
| 22324 | | const lhs_elem_val = try cur_val.elemValue(mod, i); |
| 22325 | | const rhs_elem_val = try operand_val.elemValue(mod, i); |
| 22343 | const lhs_elem_val = try resolved_cur_val.elemValue(mod, i); |
| 22344 | const rhs_elem_val = try resolved_operand_val.elemValue(mod, i); |
| 22326 | 22345 | elem.* = try opFunc(lhs_elem_val, rhs_elem_val, mod).intern(simd_op.scalar_ty, mod); |
| 22327 | 22346 | } |
| 22328 | 22347 | cur_minmax = try sema.addConstant(simd_op.result_ty, (try mod.intern(.{ .aggregate = .{ |
| ... | ... | @@ -30360,13 +30379,11 @@ fn cmpNumeric( |
| 30360 | 30379 | if (try sema.resolveMaybeUndefVal(rhs)) |rhs_val| { |
| 30361 | 30380 | // Compare ints: const vs. undefined (or vice versa) |
| 30362 | 30381 | if (!lhs_val.isUndef(mod) and (lhs_ty.isInt(mod) or lhs_ty_tag == .ComptimeInt) and rhs_ty.isInt(mod) and rhs_val.isUndef(mod)) { |
| 30363 | | try sema.resolveLazyValue(lhs_val); |
| 30364 | | if (try sema.compareIntsOnlyPossibleResult(lhs_val, op, rhs_ty)) |res| { |
| 30382 | if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(lhs_val), op, rhs_ty)) |res| { |
| 30365 | 30383 | return if (res) Air.Inst.Ref.bool_true else Air.Inst.Ref.bool_false; |
| 30366 | 30384 | } |
| 30367 | 30385 | } else if (!rhs_val.isUndef(mod) and (rhs_ty.isInt(mod) or rhs_ty_tag == .ComptimeInt) and lhs_ty.isInt(mod) and lhs_val.isUndef(mod)) { |
| 30368 | | try sema.resolveLazyValue(rhs_val); |
| 30369 | | if (try sema.compareIntsOnlyPossibleResult(rhs_val, op.reverse(), lhs_ty)) |res| { |
| 30386 | if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(rhs_val), op.reverse(), lhs_ty)) |res| { |
| 30370 | 30387 | return if (res) Air.Inst.Ref.bool_true else Air.Inst.Ref.bool_false; |
| 30371 | 30388 | } |
| 30372 | 30389 | } |
| ... | ... | @@ -30389,19 +30406,17 @@ fn cmpNumeric( |
| 30389 | 30406 | } else { |
| 30390 | 30407 | if (!lhs_val.isUndef(mod) and (lhs_ty.isInt(mod) or lhs_ty_tag == .ComptimeInt) and rhs_ty.isInt(mod)) { |
| 30391 | 30408 | // Compare ints: const vs. var |
| 30392 | | try sema.resolveLazyValue(lhs_val); |
| 30393 | | if (try sema.compareIntsOnlyPossibleResult(lhs_val, op, rhs_ty)) |res| { |
| 30409 | if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(lhs_val), op, rhs_ty)) |res| { |
| 30394 | 30410 | return if (res) Air.Inst.Ref.bool_true else Air.Inst.Ref.bool_false; |
| 30395 | 30411 | } |
| 30396 | 30412 | } |
| 30397 | 30413 | break :src rhs_src; |
| 30398 | 30414 | } |
| 30399 | 30415 | } else { |
| 30400 | | if (try sema.resolveMaybeUndefVal(rhs)) |rhs_val| { |
| 30416 | if (try sema.resolveMaybeUndefLazyVal(rhs)) |rhs_val| { |
| 30401 | 30417 | if (!rhs_val.isUndef(mod) and (rhs_ty.isInt(mod) or rhs_ty_tag == .ComptimeInt) and lhs_ty.isInt(mod)) { |
| 30402 | 30418 | // Compare ints: var vs. const |
| 30403 | | try sema.resolveLazyValue(rhs_val); |
| 30404 | | if (try sema.compareIntsOnlyPossibleResult(rhs_val, op.reverse(), lhs_ty)) |res| { |
| 30419 | if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(rhs_val), op.reverse(), lhs_ty)) |res| { |
| 30405 | 30420 | return if (res) Air.Inst.Ref.bool_true else Air.Inst.Ref.bool_false; |
| 30406 | 30421 | } |
| 30407 | 30422 | } |
| ... | ... | @@ -30465,8 +30480,7 @@ fn cmpNumeric( |
| 30465 | 30480 | var dest_float_type: ?Type = null; |
| 30466 | 30481 | |
| 30467 | 30482 | var lhs_bits: usize = undefined; |
| 30468 | | if (try sema.resolveMaybeUndefVal(lhs)) |lhs_val| { |
| 30469 | | try sema.resolveLazyValue(lhs_val); |
| 30483 | if (try sema.resolveMaybeUndefLazyVal(lhs)) |lhs_val| { |
| 30470 | 30484 | if (lhs_val.isUndef(mod)) |
| 30471 | 30485 | return sema.addConstUndef(Type.bool); |
| 30472 | 30486 | if (lhs_val.isNan(mod)) switch (op) { |
| ... | ... | @@ -30524,8 +30538,7 @@ fn cmpNumeric( |
| 30524 | 30538 | } |
| 30525 | 30539 | |
| 30526 | 30540 | var rhs_bits: usize = undefined; |
| 30527 | | if (try sema.resolveMaybeUndefVal(rhs)) |rhs_val| { |
| 30528 | | try sema.resolveLazyValue(rhs_val); |
| 30541 | if (try sema.resolveMaybeUndefLazyVal(rhs)) |rhs_val| { |
| 30529 | 30542 | if (rhs_val.isUndef(mod)) |
| 30530 | 30543 | return sema.addConstUndef(Type.bool); |
| 30531 | 30544 | if (rhs_val.isNan(mod)) switch (op) { |
| ... | ... | @@ -31467,32 +31480,133 @@ pub fn resolveFnTypes(sema: *Sema, fn_info: InternPool.Key.FuncType) CompileErro |
| 31467 | 31480 | |
| 31468 | 31481 | /// Make it so that calling hash() and eql() on `val` will not assert due |
| 31469 | 31482 | /// to a type not having its layout resolved. |
| 31470 | | fn resolveLazyValue(sema: *Sema, val: Value) CompileError!void { |
| 31471 | | switch (sema.mod.intern_pool.indexToKey(val.toIntern())) { |
| 31483 | fn resolveLazyValue(sema: *Sema, val: Value) CompileError!Value { |
| 31484 | const mod = sema.mod; |
| 31485 | switch (mod.intern_pool.indexToKey(val.toIntern())) { |
| 31472 | 31486 | .int => |int| switch (int.storage) { |
| 31473 | | .u64, .i64, .big_int => {}, |
| 31474 | | .lazy_align, .lazy_size => |lazy_ty| try sema.resolveTypeLayout(lazy_ty.toType()), |
| 31487 | .u64, .i64, .big_int => return val, |
| 31488 | .lazy_align, .lazy_size => return (try mod.intern(.{ .int = .{ |
| 31489 | .ty = int.ty, |
| 31490 | .storage = .{ .u64 = (try val.getUnsignedIntAdvanced(mod, sema)).? }, |
| 31491 | } })).toValue(), |
| 31475 | 31492 | }, |
| 31476 | 31493 | .ptr => |ptr| { |
| 31494 | const resolved_len = switch (ptr.len) { |
| 31495 | .none => .none, |
| 31496 | else => (try sema.resolveLazyValue(ptr.len.toValue())).toIntern(), |
| 31497 | }; |
| 31477 | 31498 | switch (ptr.addr) { |
| 31478 | | .decl, .mut_decl => {}, |
| 31479 | | .int => |int| try sema.resolveLazyValue(int.toValue()), |
| 31480 | | .eu_payload, .opt_payload => |base| try sema.resolveLazyValue(base.toValue()), |
| 31481 | | .comptime_field => |comptime_field| try sema.resolveLazyValue(comptime_field.toValue()), |
| 31482 | | .elem, .field => |base_index| try sema.resolveLazyValue(base_index.base.toValue()), |
| 31499 | .decl, .mut_decl => return if (resolved_len == ptr.len) |
| 31500 | val |
| 31501 | else |
| 31502 | (try mod.intern(.{ .ptr = .{ |
| 31503 | .ty = ptr.ty, |
| 31504 | .addr = switch (ptr.addr) { |
| 31505 | .decl => |decl| .{ .decl = decl }, |
| 31506 | .mut_decl => |mut_decl| .{ .mut_decl = mut_decl }, |
| 31507 | else => unreachable, |
| 31508 | }, |
| 31509 | .len = resolved_len, |
| 31510 | } })).toValue(), |
| 31511 | .comptime_field => |field_val| { |
| 31512 | const resolved_field_val = |
| 31513 | (try sema.resolveLazyValue(field_val.toValue())).toIntern(); |
| 31514 | return if (resolved_field_val == field_val and resolved_len == ptr.len) |
| 31515 | val |
| 31516 | else |
| 31517 | (try mod.intern(.{ .ptr = .{ |
| 31518 | .ty = ptr.ty, |
| 31519 | .addr = .{ .comptime_field = resolved_field_val }, |
| 31520 | .len = resolved_len, |
| 31521 | } })).toValue(); |
| 31522 | }, |
| 31523 | .int => |int| { |
| 31524 | const resolved_int = (try sema.resolveLazyValue(int.toValue())).toIntern(); |
| 31525 | return if (resolved_int == int and resolved_len == ptr.len) |
| 31526 | val |
| 31527 | else |
| 31528 | (try mod.intern(.{ .ptr = .{ |
| 31529 | .ty = ptr.ty, |
| 31530 | .addr = .{ .int = resolved_int }, |
| 31531 | .len = resolved_len, |
| 31532 | } })).toValue(); |
| 31533 | }, |
| 31534 | .eu_payload, .opt_payload => |base| { |
| 31535 | const resolved_base = (try sema.resolveLazyValue(base.toValue())).toIntern(); |
| 31536 | return if (resolved_base == base and resolved_len == ptr.len) |
| 31537 | val |
| 31538 | else |
| 31539 | (try mod.intern(.{ .ptr = .{ |
| 31540 | .ty = ptr.ty, |
| 31541 | .addr = switch (ptr.addr) { |
| 31542 | .eu_payload => .{ .eu_payload = resolved_base }, |
| 31543 | .opt_payload => .{ .opt_payload = resolved_base }, |
| 31544 | else => unreachable, |
| 31545 | }, |
| 31546 | .len = ptr.len, |
| 31547 | } })).toValue(); |
| 31548 | }, |
| 31549 | .elem, .field => |base_index| { |
| 31550 | const resolved_base = (try sema.resolveLazyValue(base_index.base.toValue())).toIntern(); |
| 31551 | return if (resolved_base == base_index.base and resolved_len == ptr.len) |
| 31552 | val |
| 31553 | else |
| 31554 | (try mod.intern(.{ .ptr = .{ |
| 31555 | .ty = ptr.ty, |
| 31556 | .addr = switch (ptr.addr) { |
| 31557 | .elem => .{ .elem = .{ |
| 31558 | .base = resolved_base, |
| 31559 | .index = base_index.index, |
| 31560 | } }, |
| 31561 | .field => .{ .field = .{ |
| 31562 | .base = resolved_base, |
| 31563 | .index = base_index.index, |
| 31564 | } }, |
| 31565 | else => unreachable, |
| 31566 | }, |
| 31567 | .len = ptr.len, |
| 31568 | } })).toValue(); |
| 31569 | }, |
| 31483 | 31570 | } |
| 31484 | | if (ptr.len != .none) try sema.resolveLazyValue(ptr.len.toValue()); |
| 31485 | 31571 | }, |
| 31486 | 31572 | .aggregate => |aggregate| switch (aggregate.storage) { |
| 31487 | | .bytes => {}, |
| 31488 | | .elems => |elems| for (elems) |elem| try sema.resolveLazyValue(elem.toValue()), |
| 31489 | | .repeated_elem => |elem| try sema.resolveLazyValue(elem.toValue()), |
| 31573 | .bytes => return val, |
| 31574 | .elems => |elems| { |
| 31575 | var resolved_elems: []InternPool.Index = &.{}; |
| 31576 | for (elems, 0..) |elem, i| { |
| 31577 | const resolved_elem = (try sema.resolveLazyValue(elem.toValue())).toIntern(); |
| 31578 | if (resolved_elems.len == 0 and resolved_elem != elem) { |
| 31579 | resolved_elems = try sema.arena.alloc(InternPool.Index, elems.len); |
| 31580 | @memcpy(resolved_elems[0..i], elems[0..i]); |
| 31581 | } |
| 31582 | if (resolved_elems.len > 0) resolved_elems[i] = resolved_elem; |
| 31583 | } |
| 31584 | return if (resolved_elems.len == 0) val else (try mod.intern(.{ .aggregate = .{ |
| 31585 | .ty = aggregate.ty, |
| 31586 | .storage = .{ .elems = resolved_elems }, |
| 31587 | } })).toValue(); |
| 31588 | }, |
| 31589 | .repeated_elem => |elem| { |
| 31590 | const resolved_elem = (try sema.resolveLazyValue(elem.toValue())).toIntern(); |
| 31591 | return if (resolved_elem == elem) val else (try mod.intern(.{ .aggregate = .{ |
| 31592 | .ty = aggregate.ty, |
| 31593 | .storage = .{ .repeated_elem = resolved_elem }, |
| 31594 | } })).toValue(); |
| 31595 | }, |
| 31490 | 31596 | }, |
| 31491 | 31597 | .un => |un| { |
| 31492 | | try sema.resolveLazyValue(un.tag.toValue()); |
| 31493 | | try sema.resolveLazyValue(un.val.toValue()); |
| 31598 | const resolved_tag = (try sema.resolveLazyValue(un.tag.toValue())).toIntern(); |
| 31599 | const resolved_val = (try sema.resolveLazyValue(un.val.toValue())).toIntern(); |
| 31600 | return if (resolved_tag == un.tag and resolved_val == un.val) |
| 31601 | val |
| 31602 | else |
| 31603 | (try mod.intern(.{ .un = .{ |
| 31604 | .ty = un.ty, |
| 31605 | .tag = resolved_tag, |
| 31606 | .val = resolved_val, |
| 31607 | } })).toValue(); |
| 31494 | 31608 | }, |
| 31495 | | else => {}, |
| 31609 | else => return val, |
| 31496 | 31610 | } |
| 31497 | 31611 | } |
| 31498 | 31612 | |
Jacob Young <jacobly@ziglang.org> 2023-05-30 02:18:07-04:00
Andrew Kelley <andrew@ziglang.org> 2023-06-10 20:47:57-07:00
src