std lib API deprecations for the upcoming 0.9.0 release

See #3811

21 files changed, 66 insertions, 82 deletions

diff --git a/src/AstGen.zig b/src/AstGen.zig
index e132900c68..c7fe1e7872 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -8399,7 +8399,7 @@ fn parseStrLit(
     const raw_string = bytes[offset..];
     var buf_managed = buf.toManaged(astgen.gpa);
     const result = std.zig.string_literal.parseAppend(&buf_managed, raw_string);
-    buf.* = buf_managed.toUnmanaged();
+    buf.* = buf_managed.moveToUnmanaged();
     switch (try result) {
         .success => return,
         .invalid_character => |bad_index| {
@@ -8472,11 +8472,7 @@ fn failNodeNotes(
     @setCold(true);
     const string_bytes = &astgen.string_bytes;
     const msg = @intCast(u32, string_bytes.items.len);
-    {
-        var managed = string_bytes.toManaged(astgen.gpa);
-        defer string_bytes.* = managed.toUnmanaged();
-        try managed.writer().print(format ++ "\x00", args);
-    }
+    try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);
     const notes_index: u32 = if (notes.len != 0) blk: {
         const notes_start = astgen.extra.items.len;
         try astgen.extra.ensureTotalCapacity(astgen.gpa, notes_start + 1 + notes.len);
@@ -8513,11 +8509,7 @@ fn failTokNotes(
     @setCold(true);
     const string_bytes = &astgen.string_bytes;
     const msg = @intCast(u32, string_bytes.items.len);
-    {
-        var managed = string_bytes.toManaged(astgen.gpa);
-        defer string_bytes.* = managed.toUnmanaged();
-        try managed.writer().print(format ++ "\x00", args);
-    }
+    try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);
     const notes_index: u32 = if (notes.len != 0) blk: {
         const notes_start = astgen.extra.items.len;
         try astgen.extra.ensureTotalCapacity(astgen.gpa, notes_start + 1 + notes.len);
@@ -8546,11 +8538,7 @@ fn failOff(
     @setCold(true);
     const string_bytes = &astgen.string_bytes;
     const msg = @intCast(u32, string_bytes.items.len);
-    {
-        var managed = string_bytes.toManaged(astgen.gpa);
-        defer string_bytes.* = managed.toUnmanaged();
-        try managed.writer().print(format ++ "\x00", args);
-    }
+    try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);
     try astgen.compile_errors.append(astgen.gpa, .{
         .msg = msg,
         .node = 0,
@@ -8570,11 +8558,7 @@ fn errNoteTok(
     @setCold(true);
     const string_bytes = &astgen.string_bytes;
     const msg = @intCast(u32, string_bytes.items.len);
-    {
-        var managed = string_bytes.toManaged(astgen.gpa);
-        defer string_bytes.* = managed.toUnmanaged();
-        try managed.writer().print(format ++ "\x00", args);
-    }
+    try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);
     return astgen.addExtra(Zir.Inst.CompileErrors.Item{
         .msg = msg,
         .node = 0,
@@ -8593,11 +8577,7 @@ fn errNoteNode(
     @setCold(true);
     const string_bytes = &astgen.string_bytes;
     const msg = @intCast(u32, string_bytes.items.len);
-    {
-        var managed = string_bytes.toManaged(astgen.gpa);
-        defer string_bytes.* = managed.toUnmanaged();
-        try managed.writer().print(format ++ "\x00", args);
-    }
+    try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);
     return astgen.addExtra(Zir.Inst.CompileErrors.Item{
         .msg = msg,
         .node = node,
diff --git a/src/Module.zig b/src/Module.zig
index 78c05c1183..805d02b650 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -470,7 +470,7 @@ pub const Decl = struct {
     pub const DepsTable = std.AutoArrayHashMapUnmanaged(*Decl, void);
 
     pub fn clearName(decl: *Decl, gpa: *Allocator) void {
-        gpa.free(mem.spanZ(decl.name));
+        gpa.free(mem.sliceTo(decl.name, 0));
         decl.name = undefined;
     }
 
@@ -627,12 +627,12 @@ pub const Decl = struct {
     }
 
     pub fn renderFullyQualifiedName(decl: Decl, writer: anytype) !void {
-        const unqualified_name = mem.spanZ(decl.name);
+        const unqualified_name = mem.sliceTo(decl.name, 0);
         return decl.src_namespace.renderFullyQualifiedName(unqualified_name, writer);
     }
 
     pub fn renderFullyQualifiedDebugName(decl: Decl, writer: anytype) !void {
-        const unqualified_name = mem.spanZ(decl.name);
+        const unqualified_name = mem.sliceTo(decl.name, 0);
         return decl.src_namespace.renderFullyQualifiedDebugName(unqualified_name, writer);
     }
 
@@ -737,7 +737,7 @@ pub const Decl = struct {
             decl.scope.sub_file_path,
             loc.line + 1,
             loc.column + 1,
-            mem.spanZ(decl.name),
+            mem.sliceTo(decl.name, 0),
             @tagName(decl.analysis),
         });
         if (decl.has_tv) {
@@ -1342,7 +1342,7 @@ pub const Namespace = struct {
     ) @TypeOf(writer).Error!void {
         if (ns.parent) |parent| {
             const decl = ns.getDecl();
-            try parent.renderFullyQualifiedName(mem.spanZ(decl.name), writer);
+            try parent.renderFullyQualifiedName(mem.sliceTo(decl.name, 0), writer);
         } else {
             try ns.file_scope.renderFullyQualifiedName(writer);
         }
@@ -1361,7 +1361,7 @@ pub const Namespace = struct {
         var separator_char: u8 = '.';
         if (ns.parent) |parent| {
             const decl = ns.getDecl();
-            try parent.renderFullyQualifiedDebugName(mem.spanZ(decl.name), writer);
+            try parent.renderFullyQualifiedDebugName(mem.sliceTo(decl.name, 0), writer);
         } else {
             try ns.file_scope.renderFullyQualifiedDebugName(writer);
             separator_char = ':';
@@ -3432,7 +3432,7 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
                     return sema.fail(&block_scope, export_src, "export of inline function", .{});
                 }
                 // The scope needs to have the decl in it.
-                const options: std.builtin.ExportOptions = .{ .name = mem.spanZ(decl.name) };
+                const options: std.builtin.ExportOptions = .{ .name = mem.sliceTo(decl.name, 0) };
                 try sema.analyzeExport(&block_scope, export_src, options, decl);
             }
             return type_changed or is_inline != prev_is_inline;
@@ -3501,7 +3501,7 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
     if (decl.is_exported) {
         const export_src = src; // TODO point to the export token
         // The scope needs to have the decl in it.
-        const options: std.builtin.ExportOptions = .{ .name = mem.spanZ(decl.name) };
+        const options: std.builtin.ExportOptions = .{ .name = mem.sliceTo(decl.name, 0) };
         try sema.analyzeExport(&block_scope, export_src, options, decl);
     }
 
@@ -4675,7 +4675,7 @@ pub fn processOutdatedAndDeletedDecls(mod: *Module) !void {
 
             // Remove from the namespace it resides in, preserving declaration order.
             assert(decl.zir_decl_index != 0);
-            _ = decl.src_namespace.decls.orderedRemove(mem.spanZ(decl.name));
+            _ = decl.src_namespace.decls.orderedRemove(mem.sliceTo(decl.name, 0));
 
             try mod.clearDecl(decl, &outdated_decls);
             decl.destroy(mod);
diff --git a/src/Package.zig b/src/Package.zig
index f5380aaacb..976e92d096 100644
--- a/src/Package.zig
+++ b/src/Package.zig
@@ -115,7 +115,7 @@ pub fn deinitTable(pkg: *Package, gpa: *Allocator) void {
 
 pub fn add(pkg: *Package, gpa: *Allocator, name: []const u8, package: *Package) !void {
     try pkg.table.ensureUnusedCapacity(gpa, 1);
-    const name_dupe = try mem.dupe(gpa, u8, name);
+    const name_dupe = try gpa.dupe(u8, name);
     pkg.table.putAssumeCapacityNoClobber(name_dupe, package);
 }
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 9597447865..c88841e0d2 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1639,7 +1639,7 @@ fn createTypeName(sema: *Sema, block: *Block, name_strategy: Zir.Inst.NameStrate
                 block.src_decl.name, name_index,
             });
         },
-        .parent => return sema.gpa.dupeZ(u8, mem.spanZ(block.src_decl.name)),
+        .parent => return sema.gpa.dupeZ(u8, mem.sliceTo(block.src_decl.name, 0)),
         .func => {
             const name_index = sema.mod.getNextAnonNameIndex();
             const name = try std.fmt.allocPrintZ(sema.gpa, "{s}__anon_{d}", .{
diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index 010588f6cf..84996410f1 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -1501,7 +1501,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index) !void {
                 });
             } else if (func_value.castTag(.extern_fn)) |func_payload| {
                 const decl = func_payload.data;
-                const n_strx = try macho_file.addExternFn(mem.spanZ(decl.name));
+                const n_strx = try macho_file.addExternFn(mem.sliceTo(decl.name, 0));
 
                 _ = try self.addInst(.{
                     .tag = .call_extern,
diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 077e7a4a62..55e51dcc00 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -1966,7 +1966,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index) !void {
                 });
             } else if (func_value.castTag(.extern_fn)) |func_payload| {
                 const decl = func_payload.data;
-                const n_strx = try macho_file.addExternFn(mem.spanZ(decl.name));
+                const n_strx = try macho_file.addExternFn(mem.sliceTo(decl.name, 0));
                 _ = try self.addInst(.{
                     .tag = .call_extern,
                     .ops = undefined,
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 5e3e8bd56d..11c899bdd2 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -981,7 +981,7 @@ pub const DeclGen = struct {
         if (dg.module.decl_exports.get(decl)) |exports| {
             return writer.writeAll(exports[0].options.name);
         } else if (decl.val.tag() == .extern_fn) {
-            return writer.writeAll(mem.spanZ(decl.name));
+            return writer.writeAll(mem.sliceTo(decl.name, 0));
         } else {
             const gpa = dg.module.gpa;
             const name = try decl.getFullyQualifiedName(gpa);
diff --git a/src/libc_installation.zig b/src/libc_installation.zig
index 615f9436e6..be0abe301b 100644
--- a/src/libc_installation.zig
+++ b/src/libc_installation.zig
@@ -76,7 +76,7 @@ pub const LibCInstallation = struct {
                     if (value.len == 0) {
                         @field(self, field.name) = null;
                     } else {
-                        found_keys[i].allocated = try std.mem.dupeZ(allocator, u8, value);
+                        found_keys[i].allocated = try allocator.dupeZ(u8, value);
                         @field(self, field.name) = found_keys[i].allocated;
                     }
                     break;
@@ -213,7 +213,7 @@ pub const LibCInstallation = struct {
                 errdefer batch.wait() catch {};
                 batch.add(&async self.findNativeIncludeDirPosix(args));
                 batch.add(&async self.findNativeCrtBeginDirHaiku(args));
-                self.crt_dir = try std.mem.dupeZ(args.allocator, u8, "/system/develop/lib");
+                self.crt_dir = try args.allocator.dupeZ(u8, "/system/develop/lib");
                 break :blk batch.wait();
             };
         } else {
@@ -222,8 +222,8 @@ pub const LibCInstallation = struct {
                 errdefer batch.wait() catch {};
                 batch.add(&async self.findNativeIncludeDirPosix(args));
                 switch (builtin.target.os.tag) {
-                    .freebsd, .netbsd, .openbsd, .dragonfly => self.crt_dir = try std.mem.dupeZ(args.allocator, u8, "/usr/lib"),
-                    .solaris => self.crt_dir = try std.mem.dupeZ(args.allocator, u8, "/usr/lib/64"),
+                    .freebsd, .netbsd, .openbsd, .dragonfly => self.crt_dir = try args.allocator.dupeZ(u8, "/usr/lib"),
+                    .solaris => self.crt_dir = try args.allocator.dupeZ(u8, "/usr/lib/64"),
                     .linux => batch.add(&async self.findNativeCrtDirPosix(args)),
                     else => {},
                 }
@@ -344,7 +344,7 @@ pub const LibCInstallation = struct {
 
             if (self.include_dir == null) {
                 if (search_dir.accessZ(include_dir_example_file, .{})) |_| {
-                    self.include_dir = try std.mem.dupeZ(allocator, u8, search_path);
+                    self.include_dir = try allocator.dupeZ(u8, search_path);
                 } else |err| switch (err) {
                     error.FileNotFound => {},
                     else => return error.FileSystem,
@@ -353,7 +353,7 @@ pub const LibCInstallation = struct {
 
             if (self.sys_include_dir == null) {
                 if (search_dir.accessZ(sys_include_dir_example_file, .{})) |_| {
-                    self.sys_include_dir = try std.mem.dupeZ(allocator, u8, search_path);
+                    self.sys_include_dir = try allocator.dupeZ(u8, search_path);
                 } else |err| switch (err) {
                     error.FileNotFound => {},
                     else => return error.FileSystem,
@@ -557,7 +557,7 @@ pub const LibCInstallation = struct {
     ) FindError!void {
         const allocator = args.allocator;
         const msvc_lib_dir_ptr = sdk.msvc_lib_dir_ptr orelse return error.LibCRuntimeNotFound;
-        self.msvc_lib_dir = try std.mem.dupeZ(allocator, u8, msvc_lib_dir_ptr[0..sdk.msvc_lib_dir_len]);
+        self.msvc_lib_dir = try allocator.dupeZ(u8, msvc_lib_dir_ptr[0..sdk.msvc_lib_dir_len]);
     }
 };
 
@@ -631,10 +631,10 @@ fn ccPrintFileName(args: CCPrintFileNameOptions) ![:0]u8 {
     // So we detect failure by checking if the output matches exactly the input.
     if (std.mem.eql(u8, line, args.search_basename)) return error.LibCRuntimeNotFound;
     switch (args.want_dirname) {
-        .full_path => return std.mem.dupeZ(allocator, u8, line),
+        .full_path => return allocator.dupeZ(u8, line),
         .only_dir => {
             const dirname = fs.path.dirname(line) orelse return error.LibCRuntimeNotFound;
-            return std.mem.dupeZ(allocator, u8, dirname);
+            return allocator.dupeZ(u8, dirname);
         },
     }
 }
@@ -648,17 +648,17 @@ fn printVerboseInvocation(
     if (!verbose) return;
 
     if (search_basename) |s| {
-        std.debug.warn("Zig attempted to find the file '{s}' by executing this command:\n", .{s});
+        std.debug.print("Zig attempted to find the file '{s}' by executing this command:\n", .{s});
     } else {
-        std.debug.warn("Zig attempted to find the path to native system libc headers by executing this command:\n", .{});
+        std.debug.print("Zig attempted to find the path to native system libc headers by executing this command:\n", .{});
     }
     for (argv) |arg, i| {
-        if (i != 0) std.debug.warn(" ", .{});
-        std.debug.warn("{s}", .{arg});
+        if (i != 0) std.debug.print(" ", .{});
+        std.debug.print("{s}", .{arg});
     }
-    std.debug.warn("\n", .{});
+    std.debug.print("\n", .{});
     if (stderr) |s| {
-        std.debug.warn("Output:\n==========\n{s}\n==========\n", .{s});
+        std.debug.print("Output:\n==========\n{s}\n==========\n", .{s});
     }
 }
 
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 55bd912bef..c5ed618895 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -752,7 +752,7 @@ fn finishUpdateDecl(self: *Coff, module: *Module, decl: *Module.Decl, code: []co
     } else {
         const vaddr = try self.allocateTextBlock(&decl.link.coff, code.len, required_alignment);
         log.debug("allocated text block for {s} at 0x{x} (size: {Bi})\n", .{
-            mem.spanZ(decl.name),
+            mem.sliceTo(decl.name, 0),
             vaddr,
             std.fmt.fmtIntSizeDec(code.len),
         });
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index 58bb482ef0..fd615bc109 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -429,7 +429,7 @@ fn makeDebugString(self: *Elf, bytes: []const u8) !u32 {
 
 fn getString(self: *Elf, str_off: u32) []const u8 {
     assert(str_off < self.shstrtab.items.len);
-    return mem.spanZ(@ptrCast([*:0]const u8, self.shstrtab.items.ptr + str_off));
+    return mem.sliceTo(@ptrCast([*:0]const u8, self.shstrtab.items.ptr + str_off), 0);
 }
 
 fn updateString(self: *Elf, old_str_off: u32, new_name: []const u8) !u32 {
@@ -2236,14 +2236,14 @@ fn updateDeclCode(self: *Elf, decl: *Module.Decl, code: []const u8, stt_bits: u8
             self.shrinkTextBlock(&decl.link.elf, code.len);
         }
         local_sym.st_size = code.len;
-        local_sym.st_name = try self.updateString(local_sym.st_name, mem.spanZ(decl.name));
+        local_sym.st_name = try self.updateString(local_sym.st_name, mem.sliceTo(decl.name, 0));
         local_sym.st_info = (elf.STB_LOCAL << 4) | stt_bits;
         local_sym.st_other = 0;
         local_sym.st_shndx = self.text_section_index.?;
         // TODO this write could be avoided if no fields of the symbol were changed.
         try self.writeSymbol(decl.link.elf.local_sym_index);
     } else {
-        const decl_name = mem.spanZ(decl.name);
+        const decl_name = mem.sliceTo(decl.name, 0);
         const name_str_index = try self.makeString(decl_name);
         const vaddr = try self.allocateTextBlock(&decl.link.elf, code.len, required_alignment);
         log.debug("allocated text block for {s} at 0x{x}", .{ decl_name, vaddr });
@@ -2371,7 +2371,7 @@ pub fn updateFunc(self: *Elf, module: *Module, func: *Module.Fn, air: Air, liven
     dbg_line_buffer.appendAssumeCapacity(DW.LNS.copy);
 
     // .debug_info subprogram
-    const decl_name_with_null = decl.name[0 .. mem.lenZ(decl.name) + 1];
+    const decl_name_with_null = decl.name[0 .. mem.sliceTo(decl.name, 0).len + 1];
     try dbg_info_buffer.ensureUnusedCapacity(25 + decl_name_with_null.len);
 
     const fn_ret_type = decl.ty.fnReturnType();
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 2508b61a38..2d363f2759 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -3439,7 +3439,9 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64
         decl.link.macho.size = code_len;
         decl.link.macho.dirty = true;
 
-        const new_name = try std.fmt.allocPrint(self.base.allocator, "_{s}", .{mem.spanZ(decl.name)});
+        const new_name = try std.fmt.allocPrint(self.base.allocator, "_{s}", .{
+            mem.sliceTo(decl.name, 0),
+        });
         defer self.base.allocator.free(new_name);
 
         symbol.n_strx = try self.makeString(new_name);
@@ -3447,7 +3449,9 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64
         symbol.n_sect = @intCast(u8, self.text_section_index.?) + 1;
         symbol.n_desc = 0;
     } else {
-        const decl_name = try std.fmt.allocPrint(self.base.allocator, "_{s}", .{mem.spanZ(decl.name)});
+        const decl_name = try std.fmt.allocPrint(self.base.allocator, "_{s}", .{
+            mem.sliceTo(decl.name, 0),
+        });
         defer self.base.allocator.free(decl_name);
 
         const name_str_index = try self.makeString(decl_name);
@@ -4045,7 +4049,7 @@ pub fn populateMissingMetadata(self: *MachO) !void {
         self.dylinker_cmd_index = @intCast(u16, self.load_commands.items.len);
         const cmdsize = @intCast(u32, mem.alignForwardGeneric(
             u64,
-            @sizeOf(macho.dylinker_command) + mem.lenZ(default_dyld_path),
+            @sizeOf(macho.dylinker_command) + mem.sliceTo(default_dyld_path, 0).len,
             @sizeOf(u64),
         ));
         var dylinker_cmd = commands.emptyGenericCommandWithData(macho.dylinker_command{
@@ -4055,7 +4059,7 @@ pub fn populateMissingMetadata(self: *MachO) !void {
         });
         dylinker_cmd.data = try self.base.allocator.alloc(u8, cmdsize - dylinker_cmd.inner.name);
         mem.set(u8, dylinker_cmd.data, 0);
-        mem.copy(u8, dylinker_cmd.data, mem.spanZ(default_dyld_path));
+        mem.copy(u8, dylinker_cmd.data, mem.sliceTo(default_dyld_path, 0));
         try self.load_commands.append(self.base.allocator, .{ .Dylinker = dylinker_cmd });
         self.load_commands_dirty = true;
     }
@@ -5292,7 +5296,7 @@ pub fn makeString(self: *MachO, string: []const u8) !u32 {
 
 pub fn getString(self: *MachO, off: u32) []const u8 {
     assert(off < self.strtab.items.len);
-    return mem.spanZ(@ptrCast([*:0]const u8, self.strtab.items.ptr + off));
+    return mem.sliceTo(@ptrCast([*:0]const u8, self.strtab.items.ptr + off), 0);
 }
 
 pub fn symbolIsStab(sym: macho.nlist_64) bool {
diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig
index 2441a0b181..0d17f305b9 100644
--- a/src/link/MachO/Archive.zig
+++ b/src/link/MachO/Archive.zig
@@ -175,7 +175,7 @@ fn parseTableOfContents(self: *Archive, allocator: *Allocator, reader: anytype)
         };
         const object_offset = try symtab_reader.readIntLittle(u32);
 
-        const sym_name = mem.spanZ(@ptrCast([*:0]const u8, strtab.ptr + n_strx));
+        const sym_name = mem.sliceTo(@ptrCast([*:0]const u8, strtab.ptr + n_strx), 0);
         const owned_name = try allocator.dupe(u8, sym_name);
         const res = try self.toc.getOrPut(allocator, owned_name);
         defer if (res.found_existing) allocator.free(owned_name);
diff --git a/src/link/MachO/DebugSymbols.zig b/src/link/MachO/DebugSymbols.zig
index 06fff9721b..1aa63f60d0 100644
--- a/src/link/MachO/DebugSymbols.zig
+++ b/src/link/MachO/DebugSymbols.zig
@@ -884,7 +884,7 @@ pub fn initDeclDebugBuffers(
             dbg_line_buffer.appendAssumeCapacity(DW.LNS.copy);
 
             // .debug_info subprogram
-            const decl_name_with_null = decl.name[0 .. mem.lenZ(decl.name) + 1];
+            const decl_name_with_null = decl.name[0 .. mem.sliceTo(decl.name, 0).len + 1];
             try dbg_info_buffer.ensureUnusedCapacity(27 + decl_name_with_null.len);
 
             const fn_ret_type = decl.ty.fnReturnType();
diff --git a/src/link/MachO/Dylib.zig b/src/link/MachO/Dylib.zig
index b213687193..a0517eb4c5 100644
--- a/src/link/MachO/Dylib.zig
+++ b/src/link/MachO/Dylib.zig
@@ -56,7 +56,7 @@ pub const Id = struct {
     pub fn fromLoadCommand(allocator: *Allocator, lc: commands.GenericCommandWithData(macho.dylib_command)) !Id {
         const dylib = lc.inner.dylib;
         const dylib_name = @ptrCast([*:0]const u8, lc.data[dylib.name - @sizeOf(macho.dylib_command) ..]);
-        const name = try allocator.dupe(u8, mem.spanZ(dylib_name));
+        const name = try allocator.dupe(u8, mem.sliceTo(dylib_name, 0));
 
         return Id{
             .name = name,
@@ -230,7 +230,7 @@ fn parseSymbols(self: *Dylib, allocator: *Allocator) !void {
 
         if (!add_to_symtab) continue;
 
-        const sym_name = mem.spanZ(@ptrCast([*:0]const u8, strtab.ptr + sym.n_strx));
+        const sym_name = mem.sliceTo(@ptrCast([*:0]const u8, strtab.ptr + sym.n_strx), 0);
         const name = try allocator.dupe(u8, sym_name);
         try self.symbols.putNoClobber(allocator, name, {});
     }
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 7b4828c740..472c529cd3 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -633,5 +633,5 @@ fn readSection(self: Object, allocator: *Allocator, index: u16) ![]u8 {
 
 pub fn getString(self: Object, off: u32) []const u8 {
     assert(off < self.strtab.items.len);
-    return mem.spanZ(@ptrCast([*:0]const u8, self.strtab.items.ptr + off));
+    return mem.sliceTo(@ptrCast([*:0]const u8, self.strtab.items.ptr + off), 0);
 }
diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig
index cab563ba1d..b25f095326 100644
--- a/src/link/Plan9.zig
+++ b/src/link/Plan9.zig
@@ -299,7 +299,7 @@ pub fn updateDecl(self: *Plan9, module: *Module, decl: *Module.Decl) !void {
             return;
         },
     };
-    var duped_code = try std.mem.dupe(self.base.allocator, u8, code);
+    var duped_code = try self.base.allocator.dupe(u8, code);
     errdefer self.base.allocator.free(duped_code);
     try self.data_decl_table.put(self.base.allocator, decl, duped_code);
     return self.updateFinish(decl);
diff --git a/src/main.zig b/src/main.zig
index 9d21de53f5..b28d01a51a 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -1282,7 +1282,7 @@ fn buildOutputType(
                         try clang_argv.appendSlice(it.other_args);
                     },
                     .positional => {
-                        const file_ext = Compilation.classifyFileExt(mem.spanZ(it.only_arg));
+                        const file_ext = Compilation.classifyFileExt(mem.sliceTo(it.only_arg, 0));
                         switch (file_ext) {
                             .assembly, .c, .cpp, .ll, .bc, .h, .m, .mm => try c_source_files.append(.{ .src_path = it.only_arg }),
                             .unknown, .shared_library, .object, .static_library => {
@@ -4117,7 +4117,7 @@ pub const ClangArgIterator = struct {
                     }
                 }
                 while (it.next()) |token| {
-                    const dupe_token = try mem.dupeZ(allocator, u8, token);
+                    const dupe_token = try allocator.dupeZ(u8, token);
                     errdefer allocator.free(dupe_token);
                     try resp_arg_list.append(dupe_token);
                 }
diff --git a/src/stage1.zig b/src/stage1.zig
index 467f0e69d7..942be66889 100644
--- a/src/stage1.zig
+++ b/src/stage1.zig
@@ -42,7 +42,7 @@ pub fn main(argc: c_int, argv: [*][*:0]u8) callconv(.C) c_int {
 
     const args = arena.alloc([]const u8, @intCast(usize, argc)) catch fatal("{s}", .{"OutOfMemory"});
     for (args) |*arg, i| {
-        arg.* = mem.spanZ(argv[i]);
+        arg.* = mem.sliceTo(argv[i], 0);
     }
     if (builtin.mode == .Debug) {
         stage2.mainArgs(gpa, arena, args) catch unreachable;
@@ -434,14 +434,14 @@ export fn stage2_add_link_lib(
         return null;
     }
     if (!target.isWasm() and !comp.bin_file.options.pic) {
-        return std.fmt.allocPrint0(
+        return std.fmt.allocPrintZ(
             comp.gpa,
             "dependency on dynamic library '{s}' requires enabling Position Independent Code. Fixed by `-l{s}` or `-fPIC`.",
             .{ lib_name, lib_name },
         ) catch "out of memory";
     }
     comp.stage1AddLinkLib(lib_name) catch |err| {
-        return std.fmt.allocPrint0(comp.gpa, "unable to add link lib '{s}': {s}", .{
+        return std.fmt.allocPrintZ(comp.gpa, "unable to add link lib '{s}': {s}", .{
             lib_name, @errorName(err),
         }) catch "out of memory";
     };
diff --git a/src/translate_c.zig b/src/translate_c.zig
index b76bb59300..627f7e5250 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -335,7 +335,7 @@ pub const Context = struct {
 
     /// Convert a null-terminated C string to a slice allocated in the arena
     fn str(c: *Context, s: [*:0]const u8) ![]u8 {
-        return mem.dupe(c.arena, u8, mem.spanZ(s));
+        return c.arena.dupe(u8, mem.sliceTo(s, 0));
     }
 
     /// Convert a clang source location to a file:line:column string
@@ -2553,7 +2553,7 @@ fn transInitListExprRecord(
         var raw_name = try c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin());
         if (field_decl.isAnonymousStructOrUnion()) {
             const name = c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?;
-            raw_name = try mem.dupe(c.arena, u8, name);
+            raw_name = try c.arena.dupe(u8, name);
         }
 
         var init_expr = try transExpr(c, scope, elem_expr, .used);
@@ -3318,7 +3318,7 @@ fn transMemberExpr(c: *Context, scope: *Scope, stmt: *const clang.MemberExpr, re
             const field_decl = @ptrCast(*const clang.FieldDecl, member_decl);
             if (field_decl.isAnonymousStructOrUnion()) {
                 const name = c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?;
-                break :blk try mem.dupe(c.arena, u8, name);
+                break :blk try c.arena.dupe(u8, name);
             }
         }
         const decl = @ptrCast(*const clang.NamedDecl, member_decl);
diff --git a/src/type.zig b/src/type.zig
index bea07781e7..33add3e0d1 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -1179,7 +1179,7 @@ pub const Type = extern union {
                 },
                 .error_set => {
                     const error_set = ty.castTag(.error_set).?.data;
-                    return writer.writeAll(std.mem.spanZ(error_set.owner_decl.name));
+                    return writer.writeAll(std.mem.sliceTo(error_set.owner_decl.name, 0));
                 },
                 .error_set_inferred => {
                     const func = ty.castTag(.error_set_inferred).?.data.func;
diff --git a/src/value.zig b/src/value.zig
index cc030faaae..1f08a8e336 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -753,9 +753,9 @@ pub const Value = extern union {
                 const bytes = val.castTag(.bytes).?.data;
                 const adjusted_len = bytes.len - @boolToInt(ty.sentinel() != null);
                 const adjusted_bytes = bytes[0..adjusted_len];
-                return std.mem.dupe(allocator, u8, adjusted_bytes);
+                return allocator.dupe(u8, adjusted_bytes);
             },
-            .enum_literal => return std.mem.dupe(allocator, u8, val.castTag(.enum_literal).?.data),
+            .enum_literal => return allocator.dupe(u8, val.castTag(.enum_literal).?.data),
             .repeated => @panic("TODO implement toAllocatedBytes for this Value tag"),
             .decl_ref => {
                 const decl = val.castTag(.decl_ref).?.data;