From d72917320449f449bcdeb6a20d5a98b1dfb901d4 Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Tue, 12 Jul 2022 16:08:23 +0300 Subject: [PATCH] stage2: better pointer source location --- src/AstGen.zig | 47 ++------ src/Module.zig | 108 ++++++++++++++++++ src/Sema.zig | 93 +++++++-------- src/Zir.zig | 21 ++-- src/print_zir.zig | 23 +--- ..._ABI_compatible_type_or_has_align_attr.zig | 14 +++ .../obj => }/C_pointer_to_anyopaque.zig | 4 +- .../compile_errors/c_pointer_to_void.zig | 4 +- .../container_init_with_non-type.zig | 2 +- .../{stage1/obj => }/pointer_to_noreturn.zig | 4 +- ...e_passed_as_array_init_type_with_elems.zig | 4 +- ...attempt_to_use_0_bit_type_in_extern_fn.zig | 0 ..._from_undefined_array_pointer_to_slice.zig | 0 ..._ABI_compatible_type_or_has_align_attr.zig | 12 -- .../obj/unknown_length_pointer_to_opaque.zig | 7 -- .../unknown_length_pointer_to_opaque.zig | 7 ++ ..._unknown_len_ptr_type_instead_of_array.zig | 4 +- 17 files changed, 202 insertions(+), 152 deletions(-) create mode 100644 test/cases/compile_errors/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig rename test/cases/compile_errors/{stage1/obj => }/C_pointer_to_anyopaque.zig (61%) rename test/cases/compile_errors/{stage1/obj => }/pointer_to_noreturn.zig (54%) rename test/cases/compile_errors/stage1/{obj => }/attempt_to_use_0_bit_type_in_extern_fn.zig (100%) rename test/cases/compile_errors/stage1/{obj => }/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig (100%) delete mode 100644 test/cases/compile_errors/stage1/obj/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig delete mode 100644 test/cases/compile_errors/stage1/obj/unknown_length_pointer_to_opaque.zig create mode 100644 test/cases/compile_errors/unknown_length_pointer_to_opaque.zig rename test/cases/compile_errors/{stage1/obj => }/using_an_unknown_len_ptr_type_instead_of_array.zig (56%) diff --git a/src/AstGen.zig b/src/AstGen.zig index 252610aeeb..9941fe54e8 100644 --- a/src/AstGen.zig +++ b/src/AstGen.zig @@ -1347,7 +1347,7 @@ fn arrayInitExpr( } } const array_type_inst = try typeExpr(gz, scope, array_init.ast.type_expr); - _ = try gz.addUnNode(.validate_array_init_ty, array_type_inst, node); + _ = try gz.addUnNode(.validate_array_init_ty, array_type_inst, array_init.ast.type_expr); break :inst .{ .array = array_type_inst, .elem = .none, @@ -2332,7 +2332,7 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: Ast.Node.Index) Inner .err_union_code, .err_union_code_ptr, .ptr_type, - .ptr_type_simple, + .overflow_arithmetic_ptr, .enum_literal, .merge_error_sets, .error_union_type, @@ -3110,24 +3110,6 @@ fn ptrType( const elem_type = try typeExpr(gz, scope, ptr_info.ast.child_type); - const simple = ptr_info.ast.align_node == 0 and - ptr_info.ast.addrspace_node == 0 and - ptr_info.ast.sentinel == 0 and - ptr_info.ast.bit_range_start == 0; - - if (simple) { - const result = try gz.add(.{ .tag = .ptr_type_simple, .data = .{ - .ptr_type_simple = .{ - .is_allowzero = ptr_info.allowzero_token != null, - .is_mutable = ptr_info.const_token == null, - .is_volatile = ptr_info.volatile_token != null, - .size = ptr_info.size, - .elem_type = elem_type, - }, - } }); - return rvalue(gz, rl, result, node); - } - var sentinel_ref: Zir.Inst.Ref = .none; var align_ref: Zir.Inst.Ref = .none; var addrspace_ref: Zir.Inst.Ref = .none; @@ -3160,7 +3142,10 @@ fn ptrType( try gz.astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.PtrType).Struct.fields.len + trailing_count); - const payload_index = gz.astgen.addExtraAssumeCapacity(Zir.Inst.PtrType{ .elem_type = elem_type }); + const payload_index = gz.astgen.addExtraAssumeCapacity(Zir.Inst.PtrType{ + .elem_type = elem_type, + .src_node = gz.nodeIndexToRelative(node), + }); if (sentinel_ref != .none) { gz.astgen.extra.appendAssumeCapacity(@enumToInt(sentinel_ref)); } @@ -7588,15 +7573,7 @@ fn builtinCall( .shl_with_overflow => { const int_type = try typeExpr(gz, scope, params[0]); const log2_int_type = try gz.addUnNode(.log2_int_type, int_type, params[0]); - const ptr_type = try gz.add(.{ .tag = .ptr_type_simple, .data = .{ - .ptr_type_simple = .{ - .is_allowzero = false, - .is_mutable = true, - .is_volatile = false, - .size = .One, - .elem_type = int_type, - }, - } }); + const ptr_type = try gz.addUnNode(.overflow_arithmetic_ptr, int_type, params[0]); const lhs = try expr(gz, scope, .{ .ty = int_type }, params[1]); const rhs = try expr(gz, scope, .{ .ty = log2_int_type }, params[2]); const ptr = try expr(gz, scope, .{ .ty = ptr_type }, params[3]); @@ -7987,15 +7964,7 @@ fn overflowArithmetic( tag: Zir.Inst.Extended, ) InnerError!Zir.Inst.Ref { const int_type = try typeExpr(gz, scope, params[0]); - const ptr_type = try gz.add(.{ .tag = .ptr_type_simple, .data = .{ - .ptr_type_simple = .{ - .is_allowzero = false, - .is_mutable = true, - .is_volatile = false, - .size = .One, - .elem_type = int_type, - }, - } }); + const ptr_type = try gz.addUnNode(.overflow_arithmetic_ptr, int_type, params[0]); const lhs = try expr(gz, scope, .{ .ty = int_type }, params[1]); const rhs = try expr(gz, scope, .{ .ty = int_type }, params[2]); const ptr = try expr(gz, scope, .{ .ty = ptr_type }, params[3]); diff --git a/src/Module.zig b/src/Module.zig index 4a5257a4f3..0f38da13e9 100644 --- a/src/Module.zig +++ b/src/Module.zig @@ -2466,6 +2466,90 @@ pub const SrcLoc = struct { return nodeToSpan(tree, node_datas[node].lhs); }, + .node_offset_ptr_elem => |node_off| { + const tree = try src_loc.file_scope.getTree(gpa); + const node_tags = tree.nodes.items(.tag); + const parent_node = src_loc.declRelativeToNodeIndex(node_off); + + const full: Ast.full.PtrType = switch (node_tags[parent_node]) { + .ptr_type_aligned => tree.ptrTypeAligned(parent_node), + .ptr_type_sentinel => tree.ptrTypeSentinel(parent_node), + .ptr_type => tree.ptrType(parent_node), + .ptr_type_bit_range => tree.ptrTypeBitRange(parent_node), + else => unreachable, + }; + return nodeToSpan(tree, full.ast.child_type); + }, + .node_offset_ptr_sentinel => |node_off| { + const tree = try src_loc.file_scope.getTree(gpa); + const node_tags = tree.nodes.items(.tag); + const parent_node = src_loc.declRelativeToNodeIndex(node_off); + + const full: Ast.full.PtrType = switch (node_tags[parent_node]) { + .ptr_type_aligned => tree.ptrTypeAligned(parent_node), + .ptr_type_sentinel => tree.ptrTypeSentinel(parent_node), + .ptr_type => tree.ptrType(parent_node), + .ptr_type_bit_range => tree.ptrTypeBitRange(parent_node), + else => unreachable, + }; + return nodeToSpan(tree, full.ast.sentinel); + }, + .node_offset_ptr_align => |node_off| { + const tree = try src_loc.file_scope.getTree(gpa); + const node_tags = tree.nodes.items(.tag); + const parent_node = src_loc.declRelativeToNodeIndex(node_off); + + const full: Ast.full.PtrType = switch (node_tags[parent_node]) { + .ptr_type_aligned => tree.ptrTypeAligned(parent_node), + .ptr_type_sentinel => tree.ptrTypeSentinel(parent_node), + .ptr_type => tree.ptrType(parent_node), + .ptr_type_bit_range => tree.ptrTypeBitRange(parent_node), + else => unreachable, + }; + return nodeToSpan(tree, full.ast.align_node); + }, + .node_offset_ptr_addrspace => |node_off| { + const tree = try src_loc.file_scope.getTree(gpa); + const node_tags = tree.nodes.items(.tag); + const parent_node = src_loc.declRelativeToNodeIndex(node_off); + + const full: Ast.full.PtrType = switch (node_tags[parent_node]) { + .ptr_type_aligned => tree.ptrTypeAligned(parent_node), + .ptr_type_sentinel => tree.ptrTypeSentinel(parent_node), + .ptr_type => tree.ptrType(parent_node), + .ptr_type_bit_range => tree.ptrTypeBitRange(parent_node), + else => unreachable, + }; + return nodeToSpan(tree, full.ast.addrspace_node); + }, + .node_offset_ptr_bitoffset => |node_off| { + const tree = try src_loc.file_scope.getTree(gpa); + const node_tags = tree.nodes.items(.tag); + const parent_node = src_loc.declRelativeToNodeIndex(node_off); + + const full: Ast.full.PtrType = switch (node_tags[parent_node]) { + .ptr_type_aligned => tree.ptrTypeAligned(parent_node), + .ptr_type_sentinel => tree.ptrTypeSentinel(parent_node), + .ptr_type => tree.ptrType(parent_node), + .ptr_type_bit_range => tree.ptrTypeBitRange(parent_node), + else => unreachable, + }; + return nodeToSpan(tree, full.ast.bit_range_start); + }, + .node_offset_ptr_hostsize => |node_off| { + const tree = try src_loc.file_scope.getTree(gpa); + const node_tags = tree.nodes.items(.tag); + const parent_node = src_loc.declRelativeToNodeIndex(node_off); + + const full: Ast.full.PtrType = switch (node_tags[parent_node]) { + .ptr_type_aligned => tree.ptrTypeAligned(parent_node), + .ptr_type_sentinel => tree.ptrTypeSentinel(parent_node), + .ptr_type => tree.ptrType(parent_node), + .ptr_type_bit_range => tree.ptrTypeBitRange(parent_node), + else => unreachable, + }; + return nodeToSpan(tree, full.ast.bit_range_end); + }, } } @@ -2739,6 +2823,24 @@ pub const LazySrcLoc = union(enum) { /// The source location points to the operand of an unary expression. /// The Decl is determined contextually. node_offset_un_op: i32, + /// The source location points to the elem type of a pointer. + /// The Decl is determined contextually. + node_offset_ptr_elem: i32, + /// The source location points to the sentinel of a pointer. + /// The Decl is determined contextually. + node_offset_ptr_sentinel: i32, + /// The source location points to the align expr of a pointer. + /// The Decl is determined contextually. + node_offset_ptr_align: i32, + /// The source location points to the addrspace expr of a pointer. + /// The Decl is determined contextually. + node_offset_ptr_addrspace: i32, + /// The source location points to the bit-offset of a pointer. + /// The Decl is determined contextually. + node_offset_ptr_bitoffset: i32, + /// The source location points to the host size of a pointer. + /// The Decl is determined contextually. + node_offset_ptr_hostsize: i32, pub const nodeOffset = if (TracedOffset.want_tracing) nodeOffsetDebug else nodeOffsetRelease; @@ -2803,6 +2905,12 @@ pub const LazySrcLoc = union(enum) { .node_offset_array_type_sentinel, .node_offset_array_type_elem, .node_offset_un_op, + .node_offset_ptr_elem, + .node_offset_ptr_sentinel, + .node_offset_ptr_align, + .node_offset_ptr_addrspace, + .node_offset_ptr_bitoffset, + .node_offset_ptr_hostsize, => .{ .file_scope = decl.getFileScope(), .parent_decl_node = decl.src_node, diff --git a/src/Sema.zig b/src/Sema.zig index b821a32fc7..94909de78c 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -768,7 +768,7 @@ fn analyzeBodyInner( .optional_type => try sema.zirOptionalType(block, inst), .param_type => try sema.zirParamType(block, inst), .ptr_type => try sema.zirPtrType(block, inst), - .ptr_type_simple => try sema.zirPtrTypeSimple(block, inst), + .overflow_arithmetic_ptr => try sema.zirOverflowArithmeticPtr(block, inst), .ref => try sema.zirRef(block, inst), .ret_err_value_code => try sema.zirRetErrValueCode(inst), .shr => try sema.zirShr(block, inst, .shr), @@ -13835,22 +13835,21 @@ fn floatOpAllowed(tag: Zir.Inst.Tag) bool { }; } -fn zirPtrTypeSimple(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { +fn zirOverflowArithmeticPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const tracy = trace(@src()); defer tracy.end(); - const inst_data = sema.code.instructions.items(.data)[inst].ptr_type_simple; - const elem_ty_src = sema.src; // TODO better source location - const elem_type = try sema.resolveType(block, elem_ty_src, inst_data.elem_type); + const inst_data = sema.code.instructions.items(.data)[inst].un_node; + const elem_ty_src = inst_data.src(); + const elem_type = try sema.resolveType(block, elem_ty_src, inst_data.operand); const ty = try Type.ptr(sema.arena, sema.mod, .{ .pointee_type = elem_type, .@"addrspace" = .generic, - .mutable = inst_data.is_mutable, - .@"allowzero" = inst_data.is_allowzero or inst_data.size == .C, - .@"volatile" = inst_data.is_volatile, - .size = inst_data.size, + .mutable = true, + .@"allowzero" = false, + .@"volatile" = false, + .size = .One, }); - try sema.validatePtrTy(block, elem_ty_src, ty); return sema.addType(ty); } @@ -13858,14 +13857,15 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air const tracy = trace(@src()); defer tracy.end(); - const src: LazySrcLoc = sema.src; // TODO better source location - const elem_ty_src: LazySrcLoc = sema.src; // TODO better source location - const sentinel_src: LazySrcLoc = sema.src; // TODO better source location - const addrspace_src: LazySrcLoc = sema.src; // TODO better source location - const bitoffset_src: LazySrcLoc = sema.src; // TODO better source location - const hostsize_src: LazySrcLoc = sema.src; // TODO better source location const inst_data = sema.code.instructions.items(.data)[inst].ptr_type; const extra = sema.code.extraData(Zir.Inst.PtrType, inst_data.payload_index); + const elem_ty_src: LazySrcLoc = .{ .node_offset_ptr_elem = extra.data.src_node }; + const sentinel_src: LazySrcLoc = .{ .node_offset_ptr_sentinel = extra.data.src_node }; + const align_src: LazySrcLoc = .{ .node_offset_ptr_align = extra.data.src_node }; + const addrspace_src: LazySrcLoc = .{ .node_offset_ptr_addrspace = extra.data.src_node }; + const bitoffset_src: LazySrcLoc = .{ .node_offset_ptr_bitoffset = extra.data.src_node }; + const hostsize_src: LazySrcLoc = .{ .node_offset_ptr_hostsize = extra.data.src_node }; + const unresolved_elem_ty = try sema.resolveType(block, elem_ty_src, extra.data.elem_type); const target = sema.mod.getTarget(); @@ -13880,8 +13880,8 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air const abi_align: u32 = if (inst_data.flags.has_align) blk: { const ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_i]); extra_i += 1; - const coerced = try sema.coerce(block, Type.u32, try sema.resolveInst(ref), src); - const val = try sema.resolveConstValue(block, src, coerced); + const coerced = try sema.coerce(block, Type.u32, try sema.resolveInst(ref), align_src); + const val = try sema.resolveConstValue(block, align_src, coerced); // Check if this happens to be the lazy alignment of our element type, in // which case we can make this 0 without resolving it. if (val.castTag(.lazy_align)) |payload| { @@ -13889,7 +13889,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air break :blk 0; } } - const abi_align = (try val.getUnsignedIntAdvanced(target, sema.kit(block, src))).?; + const abi_align = (try val.getUnsignedIntAdvanced(target, sema.kit(block, align_src))).?; break :blk @intCast(u32, abi_align); } else 0; @@ -13914,7 +13914,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air } else 0; if (host_size != 0 and bit_offset >= host_size * 8) { - return sema.fail(block, src, "bit offset starts after end of host integer", .{}); + return sema.fail(block, bitoffset_src, "bit offset starts after end of host integer", .{}); } const elem_ty = if (abi_align == 0) @@ -13924,6 +13924,30 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air try sema.resolveTypeLayout(block, elem_ty_src, elem_ty); break :t elem_ty; }; + + if (elem_ty.zigTypeTag() == .NoReturn) { + return sema.fail(block, elem_ty_src, "pointer to noreturn not allowed", .{}); + } else if (inst_data.size == .Many and elem_ty.zigTypeTag() == .Opaque) { + return sema.fail(block, elem_ty_src, "unknown-length pointer to opaque not allowed", .{}); + } else if (inst_data.size == .C) { + if (!(try sema.validateExternType(elem_ty, .other))) { + const msg = msg: { + const msg = try sema.errMsg(block, elem_ty_src, "C pointers cannot point to non-C-ABI-compatible type '{}'", .{elem_ty.fmt(sema.mod)}); + errdefer msg.destroy(sema.gpa); + + const src_decl = sema.mod.declPtr(block.src_decl); + try sema.explainWhyTypeIsNotExtern(block, elem_ty_src, msg, elem_ty_src.toSrcLoc(src_decl), elem_ty, .other); + + try sema.addDeclaredHereNote(msg, elem_ty); + break :msg msg; + }; + return sema.failWithOwnedErrorMsg(block, msg); + } + if (elem_ty.zigTypeTag() == .Opaque) { + return sema.fail(block, elem_ty_src, "C pointers cannot point to opaque types", .{}); + } + } + const ty = try Type.ptr(sema.arena, sema.mod, .{ .pointee_type = elem_ty, .sentinel = sentinel, @@ -13936,38 +13960,9 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air .@"volatile" = inst_data.flags.is_volatile, .size = inst_data.size, }); - try sema.validatePtrTy(block, elem_ty_src, ty); return sema.addType(ty); } -fn validatePtrTy(sema: *Sema, block: *Block, elem_src: LazySrcLoc, ty: Type) CompileError!void { - const ptr_info = ty.ptrInfo().data; - const pointee_tag = ptr_info.pointee_type.zigTypeTag(); - if (pointee_tag == .NoReturn) { - return sema.fail(block, elem_src, "pointer to noreturn not allowed", .{}); - } else if (ptr_info.size == .Many and pointee_tag == .Opaque) { - return sema.fail(block, elem_src, "unknown-length pointer to opaque not allowed", .{}); - } else if (ptr_info.size == .C) { - const elem_ty = ptr_info.pointee_type; - if (!(try sema.validateExternType(elem_ty, .other))) { - const msg = msg: { - const msg = try sema.errMsg(block, elem_src, "C pointers cannot point to non-C-ABI-compatible type '{}'", .{elem_ty.fmt(sema.mod)}); - errdefer msg.destroy(sema.gpa); - - const src_decl = sema.mod.declPtr(block.src_decl); - try sema.explainWhyTypeIsNotExtern(block, elem_src, msg, elem_src.toSrcLoc(src_decl), elem_ty, .other); - - try sema.addDeclaredHereNote(msg, elem_ty); - break :msg msg; - }; - return sema.failWithOwnedErrorMsg(block, msg); - } - if (pointee_tag == .Opaque) { - return sema.fail(block, elem_src, "C pointers cannot point to opaque types", .{}); - } - } -} - fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const tracy = trace(@src()); defer tracy.end(); diff --git a/src/Zir.zig b/src/Zir.zig index b3126ea2f3..73ba396e75 100644 --- a/src/Zir.zig +++ b/src/Zir.zig @@ -534,9 +534,9 @@ pub const Inst = struct { /// Obtains the return type of the in-scope function. /// Uses the `node` union field. ret_type, - /// Create a pointer type that does not have a sentinel, alignment, address space, or bit range specified. - /// Uses the `ptr_type_simple` union field. - ptr_type_simple, + /// Create a pointer type for overflow arithmetic. + /// TODO remove when doing https://github.com/ziglang/zig/issues/10248 + overflow_arithmetic_ptr, /// Create a pointer type which can have a sentinel, alignment, address space, and/or bit range. /// Uses the `ptr_type` union field. ptr_type, @@ -1121,7 +1121,7 @@ pub const Inst = struct { .err_union_code, .err_union_code_ptr, .ptr_type, - .ptr_type_simple, + .overflow_arithmetic_ptr, .ensure_err_payload_void, .enum_literal, .merge_error_sets, @@ -1417,7 +1417,7 @@ pub const Inst = struct { .err_union_code, .err_union_code_ptr, .ptr_type, - .ptr_type_simple, + .overflow_arithmetic_ptr, .enum_literal, .merge_error_sets, .error_union_type, @@ -1659,7 +1659,7 @@ pub const Inst = struct { .ret_err_value_code = .str_tok, .ret_ptr = .node, .ret_type = .node, - .ptr_type_simple = .ptr_type_simple, + .overflow_arithmetic_ptr = .un_node, .ptr_type = .ptr_type, .slice_start = .pl_node, .slice_end = .pl_node, @@ -2499,13 +2499,6 @@ pub const Inst = struct { node: i32, int: u64, float: f64, - ptr_type_simple: struct { - is_allowzero: bool, - is_mutable: bool, - is_volatile: bool, - size: std.builtin.Type.Pointer.Size, - elem_type: Ref, - }, ptr_type: struct { flags: packed struct { is_allowzero: bool, @@ -2608,7 +2601,6 @@ pub const Inst = struct { node, int, float, - ptr_type_simple, ptr_type, int_type, bool_br, @@ -2869,6 +2861,7 @@ pub const Inst = struct { /// 4. host_size: Ref // if `has_bit_range` flag is set pub const PtrType = struct { elem_type: Ref, + src_node: i32, }; pub const ArrayTypeSentinel = struct { diff --git a/src/print_zir.zig b/src/print_zir.zig index 878fa0c14c..96923c6d86 100644 --- a/src/print_zir.zig +++ b/src/print_zir.zig @@ -233,6 +233,7 @@ const Writer = struct { .validate_struct_init_ty, .make_ptr_const, .validate_deref, + .overflow_arithmetic_ptr, => try self.writeUnNode(stream, inst), .ref, @@ -247,7 +248,6 @@ const Writer = struct { .array_type_sentinel => try self.writeArrayTypeSentinel(stream, inst), .param_type => try self.writeParamType(stream, inst), - .ptr_type_simple => try self.writePtrTypeSimple(stream, inst), .ptr_type => try self.writePtrType(stream, inst), .int => try self.writeInt(stream, inst), .int_big => try self.writeIntBig(stream, inst), @@ -601,24 +601,6 @@ const Writer = struct { try stream.print(", {d})", .{inst_data.param_index}); } - fn writePtrTypeSimple( - self: *Writer, - stream: anytype, - inst: Zir.Inst.Index, - ) (@TypeOf(stream).Error || error{OutOfMemory})!void { - const inst_data = self.code.instructions.items(.data)[inst].ptr_type_simple; - const str_allowzero = if (inst_data.is_allowzero) "allowzero, " else ""; - const str_const = if (!inst_data.is_mutable) "const, " else ""; - const str_volatile = if (inst_data.is_volatile) "volatile, " else ""; - try self.writeInstRef(stream, inst_data.elem_type); - try stream.print(", {s}{s}{s}{s})", .{ - str_allowzero, - str_const, - str_volatile, - @tagName(inst_data.size), - }); - } - fn writePtrType( self: *Writer, stream: anytype, @@ -660,7 +642,8 @@ const Writer = struct { try self.writeInstRef(stream, @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index])); try stream.writeAll(")"); } - try stream.writeAll(")"); + try stream.writeAll(") "); + try self.writeSrc(stream, LazySrcLoc.nodeOffset(extra.data.src_node)); } fn writeInt(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void { diff --git a/test/cases/compile_errors/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig b/test/cases/compile_errors/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig new file mode 100644 index 0000000000..1b9118aa64 --- /dev/null +++ b/test/cases/compile_errors/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig @@ -0,0 +1,14 @@ +const Foo = struct {}; +export fn a() void { + const T = [*c]Foo; + var t: T = undefined; + _ = t; +} + +// error +// backend=stage2 +// target=native +// +// :3:19: error: C pointers cannot point to non-C-ABI-compatible type 'tmp.Foo' +// :3:19: note: only structs with packed or extern layout are extern compatible +// :1:13: note: struct declared here diff --git a/test/cases/compile_errors/stage1/obj/C_pointer_to_anyopaque.zig b/test/cases/compile_errors/C_pointer_to_anyopaque.zig similarity index 61% rename from test/cases/compile_errors/stage1/obj/C_pointer_to_anyopaque.zig rename to test/cases/compile_errors/C_pointer_to_anyopaque.zig index 36c9789d20..c2a0ad088d 100644 --- a/test/cases/compile_errors/stage1/obj/C_pointer_to_anyopaque.zig +++ b/test/cases/compile_errors/C_pointer_to_anyopaque.zig @@ -5,7 +5,7 @@ export fn a() void { } // error -// backend=stage1 +// backend=stage2 // target=native // -// tmp.zig:3:16: error: C pointers cannot point to opaque types +// :3:16: error: C pointers cannot point to opaque types diff --git a/test/cases/compile_errors/c_pointer_to_void.zig b/test/cases/compile_errors/c_pointer_to_void.zig index aeb5f42dec..116f5a8948 100644 --- a/test/cases/compile_errors/c_pointer_to_void.zig +++ b/test/cases/compile_errors/c_pointer_to_void.zig @@ -7,5 +7,5 @@ export fn entry() void { // backend=stage2 // target=native // -// :1:1: error: C pointers cannot point to non-C-ABI-compatible type 'void' -// :1:1: note: 'void' is a zero bit type; for C 'void' use 'anyopaque' +// :2:16: error: C pointers cannot point to non-C-ABI-compatible type 'void' +// :2:16: note: 'void' is a zero bit type; for C 'void' use 'anyopaque' diff --git a/test/cases/compile_errors/container_init_with_non-type.zig b/test/cases/compile_errors/container_init_with_non-type.zig index ea23020611..aa62be6dc5 100644 --- a/test/cases/compile_errors/container_init_with_non-type.zig +++ b/test/cases/compile_errors/container_init_with_non-type.zig @@ -7,4 +7,4 @@ export fn entry() usize { return @sizeOf(@TypeOf(a)); } // backend=stage2 // target=native // -// :2:15: error: expected type 'type', found 'i32' +// :2:11: error: expected type 'type', found 'i32' diff --git a/test/cases/compile_errors/stage1/obj/pointer_to_noreturn.zig b/test/cases/compile_errors/pointer_to_noreturn.zig similarity index 54% rename from test/cases/compile_errors/stage1/obj/pointer_to_noreturn.zig rename to test/cases/compile_errors/pointer_to_noreturn.zig index 5afcaacaad..0891fd3699 100644 --- a/test/cases/compile_errors/stage1/obj/pointer_to_noreturn.zig +++ b/test/cases/compile_errors/pointer_to_noreturn.zig @@ -2,7 +2,7 @@ fn a() *noreturn {} export fn entry() void { _ = a(); } // error -// backend=stage1 +// backend=stage2 // target=native // -// tmp.zig:1:9: error: pointer to noreturn not allowed +// :1:9: error: pointer to noreturn not allowed diff --git a/test/cases/compile_errors/slice_passed_as_array_init_type_with_elems.zig b/test/cases/compile_errors/slice_passed_as_array_init_type_with_elems.zig index e336d2d05e..7af505e20d 100644 --- a/test/cases/compile_errors/slice_passed_as_array_init_type_with_elems.zig +++ b/test/cases/compile_errors/slice_passed_as_array_init_type_with_elems.zig @@ -7,5 +7,5 @@ export fn entry() void { // backend=stage2 // target=native // -// :2:19: error: type '[]u8' does not support array initialization syntax -// :2:19: note: inferred array length is specified with an underscore: '[_]u8' +// :2:15: error: type '[]u8' does not support array initialization syntax +// :2:15: note: inferred array length is specified with an underscore: '[_]u8' diff --git a/test/cases/compile_errors/stage1/obj/attempt_to_use_0_bit_type_in_extern_fn.zig b/test/cases/compile_errors/stage1/attempt_to_use_0_bit_type_in_extern_fn.zig similarity index 100% rename from test/cases/compile_errors/stage1/obj/attempt_to_use_0_bit_type_in_extern_fn.zig rename to test/cases/compile_errors/stage1/attempt_to_use_0_bit_type_in_extern_fn.zig diff --git a/test/cases/compile_errors/stage1/obj/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig b/test/cases/compile_errors/stage1/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig similarity index 100% rename from test/cases/compile_errors/stage1/obj/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig rename to test/cases/compile_errors/stage1/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig diff --git a/test/cases/compile_errors/stage1/obj/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig b/test/cases/compile_errors/stage1/obj/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig deleted file mode 100644 index 72c58adbd6..0000000000 --- a/test/cases/compile_errors/stage1/obj/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig +++ /dev/null @@ -1,12 +0,0 @@ -const Foo = struct {}; -export fn a() void { - const T = [*c]Foo; - var t: T = undefined; - _ = t; -} - -// error -// backend=stage1 -// target=native -// -// tmp.zig:3:19: error: C pointers cannot point to non-C-ABI-compatible type 'Foo' diff --git a/test/cases/compile_errors/stage1/obj/unknown_length_pointer_to_opaque.zig b/test/cases/compile_errors/stage1/obj/unknown_length_pointer_to_opaque.zig deleted file mode 100644 index d155b986d7..0000000000 --- a/test/cases/compile_errors/stage1/obj/unknown_length_pointer_to_opaque.zig +++ /dev/null @@ -1,7 +0,0 @@ -export const T = [*]opaque {}; - -// error -// backend=stage1 -// target=native -// -// tmp.zig:1:21: error: unknown-length pointer to opaque diff --git a/test/cases/compile_errors/unknown_length_pointer_to_opaque.zig b/test/cases/compile_errors/unknown_length_pointer_to_opaque.zig new file mode 100644 index 0000000000..2d2d116ec5 --- /dev/null +++ b/test/cases/compile_errors/unknown_length_pointer_to_opaque.zig @@ -0,0 +1,7 @@ +export const T = [*]opaque {}; + +// error +// backend=stage2 +// target=native +// +// :1:21: error: unknown-length pointer to opaque not allowed diff --git a/test/cases/compile_errors/stage1/obj/using_an_unknown_len_ptr_type_instead_of_array.zig b/test/cases/compile_errors/using_an_unknown_len_ptr_type_instead_of_array.zig similarity index 56% rename from test/cases/compile_errors/stage1/obj/using_an_unknown_len_ptr_type_instead_of_array.zig rename to test/cases/compile_errors/using_an_unknown_len_ptr_type_instead_of_array.zig index 3124b057a8..c1f593b9bd 100644 --- a/test/cases/compile_errors/stage1/obj/using_an_unknown_len_ptr_type_instead_of_array.zig +++ b/test/cases/compile_errors/using_an_unknown_len_ptr_type_instead_of_array.zig @@ -7,7 +7,7 @@ comptime { } // error -// backend=stage1 +// backend=stage2 // target=native // -// tmp.zig:1:21: error: expected array type or [_], found '[*][*]const u8' +// :1:22: error: type '[*][*]const u8' does not support array initialization syntax