zig: std.builtin becomes std.lang, ready for 0.18

app/automation/overlay.zig

@@ -70,7 +70,7 @@ const plain_fade_ms = (plain.Options{}).fade_ms;
 /// (`core.screens.markMain`): the captions, keys and bar are the stage's, and stay on it while a
 /// dialog or a menu is open in a window of its own over it. Only the pointer, and a callout beside
 /// what it acts on (`drawCallout`), go into those windows. Every part goes through this.
-fn layer(src: std.builtin.SourceLocation, opts: dvui.Options, init: dvui.FloatingWidget.InitOptions) *dvui.FloatingWidget {
+fn layer(src: std.lang.SourceLocation, opts: dvui.Options, init: dvui.FloatingWidget.InitOptions) *dvui.FloatingWidget {
     const fw = plain.layer(src, opts, init);
     core.screens.markMain(fw.data().id);
     return fw;

app/layout/Chooser.zig

@@ -111,7 +111,7 @@ const Kept = struct {
 
 /// A chooser for `place`: a declared region, or `.{ .keywords = … }` for the place with those
 /// keywords. Draw items with `item`, then `deinit`.
-pub fn init(src: std.builtin.SourceLocation, f: *Layout, place: Region, opts: Options) Chooser {
+pub fn init(src: std.lang.SourceLocation, f: *Layout, place: Region, opts: Options) Chooser {
     const key = place.selectionKey();
     const id_extra = opts.id_extra ^ @as(usize, @truncate(key));
     const kept = dvui.dataGetPtrDefault(null, dvui.parentGet().extendId(src, id_extra), "_chooser", Kept, .{});
@@ -161,7 +161,7 @@ pub fn views(self: *const Chooser) []const *Layout.Surface {
 }
 
 /// One item. Draw what it looks like between this and `Item.deinit`.
-pub fn item(self: *Chooser, src: std.builtin.SourceLocation, view: *const Layout.Surface, opts: ItemOptions) Item {
+pub fn item(self: *Chooser, src: std.lang.SourceLocation, view: *const Layout.Surface, opts: ItemOptions) Item {
     const index = self.drawn.items.len;
     if (self.kept.slot_at) |at| if (at == index) self.openSlot();
     self.drawn.append(self.layout.arena, view.id) catch {};

app/layout/Layout.zig

@@ -178,7 +178,7 @@ depth: usize = 0,
 plugin_regions: [max_nesting]Region = undefined,
 plugin_depth: usize = 0,
 
-pub const PendingSplit = struct { src: std.builtin.SourceLocation, opts: Split.Options };
+pub const PendingSplit = struct { src: std.lang.SourceLocation, opts: Split.Options };
 
 pub const Container = struct {
     dir: dvui.enums.Direction,
@@ -1090,7 +1090,7 @@ pub const placeVisible = ViewDrag.place;
 /// seed into a live `DockLayout`; after that the persisted tree is what is walked.
 pub fn tree(
     self: *Layout,
-    src: std.builtin.SourceLocation,
+    src: std.lang.SourceLocation,
     seed: *const Seed,
     opts: dvui.Options,
 ) !Tree {
@@ -1298,7 +1298,7 @@ pub const State = @import("State.zig");
 /// so a plugin can draw one without a `Layout` at all, and everything this adds — finding the
 /// neighbour to resize, and the container constraint to resolve against — is layout state that
 /// `core` cannot see.
-pub fn split(self: *Layout, src: std.builtin.SourceLocation, opts: Split.Options) void {
+pub fn split(self: *Layout, src: std.lang.SourceLocation, opts: Split.Options) void {
     const c = self.innermost() orelse {
         dvui.log.err("split() outside a region does nothing", .{});
         return;
@@ -1337,7 +1337,7 @@ pub fn drawPendingSplit(self: *Layout, after: ?dvui.Id) void {
 /// region's Options.margin is never a sash, and a card cannot paint over it.
 pub fn packSplit(
     self: *Layout,
-    src: std.builtin.SourceLocation,
+    src: std.lang.SourceLocation,
     id_extra: usize,
     target: dvui.Id,
     sign: f32,
@@ -1349,7 +1349,7 @@ pub fn packSplit(
 /// `packSplit` with the gap given a width, for a sash closing along with the place beside it.
 pub fn packSplitSized(
     self: *Layout,
-    src: std.builtin.SourceLocation,
+    src: std.lang.SourceLocation,
     id_extra: usize,
     target: dvui.Id,
     sign: f32,

app/layout/Picker.zig

@@ -752,7 +752,7 @@ fn drawLifted(self: *Picker, f: *Layout) void {
 /// Published as `region.menu.<action>:<place>` while it can be pressed — a dimmed one swallows the
 /// click, and a driver waiting for the name should wait for the action, not for the button.
 /// Delete wears the theme's error colour. Disabled, it keeps its place (dimmed, no hover).
-fn controlButton(src: std.builtin.SourceLocation, c: place_commands.Command, place: []const u8, enabled: bool, id_extra: usize) bool {
+fn controlButton(src: std.lang.SourceLocation, c: place_commands.Command, place: []const u8, enabled: bool, id_extra: usize) bool {
     const theme = dvui.themeGet();
     const tint = if (c.action == .delete) theme.color(.err, .text) else theme.color(.control, .text);
     var bw: dvui.ButtonWidget = undefined;

app/layout/Region.zig

@@ -327,7 +327,7 @@ pub const InitOptions = struct {
 /// }
 /// f.split(@src(), .{});
 /// ```
-pub fn init(self: *Layout, src: std.builtin.SourceLocation, init_opts: InitOptions, opts_given: dvui.Options) anyerror!Region {
+pub fn init(self: *Layout, src: std.lang.SourceLocation, init_opts: InitOptions, opts_given: dvui.Options) anyerror!Region {
     const opts = withCard(self, init_opts, opts_given);
     if (self.depth >= Layout.max_nesting) {
         dvui.log.err("layout nests deeper than {d} regions; \"{s}\" ignored", .{ Layout.max_nesting, init_opts.name });
@@ -1284,7 +1284,7 @@ fn idOf(state: *Layout.State, name: []const u8) ?dvui.Id {
 
 fn initTree(
     self: *Layout,
-    src: std.builtin.SourceLocation,
+    src: std.lang.SourceLocation,
     init_opts: InitOptions,
     opts: dvui.Options,
     node: *SplitTree.Node,
@@ -1394,7 +1394,7 @@ fn initTree(
 
 fn drawTreeChildren(
     self: *Layout,
-    src: std.builtin.SourceLocation,
+    src: std.lang.SourceLocation,
     shape: InitOptions,
     shape_opts: dvui.Options,
     branch: SplitTree.Branch,
@@ -1415,7 +1415,7 @@ fn drawTreeChildren(
     try drawTreeNode(self, src, shape, shape_opts, branch.b, omit_b, leftover_b);
 }
 
-fn packTreeSplit(self: *Layout, src: std.builtin.SourceLocation, branch: SplitTree.Branch) void {
+fn packTreeSplit(self: *Layout, src: std.lang.SourceLocation, branch: SplitTree.Branch) void {
     const new_name = SplitTree.newNameOf(branch);
     const leading = SplitTree.newIsLeading(branch.side);
     const sign: f32 = if (leading) 1 else -1;
@@ -1505,7 +1505,7 @@ fn placeVisual(opts: dvui.Options) dvui.Options {
 
 fn drawTreeNode(
     self: *Layout,
-    src: std.builtin.SourceLocation,
+    src: std.lang.SourceLocation,
     shape: InitOptions,
     shape_opts: dvui.Options,
     node: *SplitTree.Node,

app/layout/ViewDrag.zig

@@ -1452,7 +1452,7 @@ pub fn drawOverlay(l: *Layout) void {
 /// its glass — and is re-added as a window of its own and raised, as the demo overlay's layers are
 /// (`automation/overlay.zig`). It takes no pointer events: what is under it still takes them, the
 /// drag's hold on the pointer included.
-fn layerOver(layer: *dvui.FloatingWidget, src: std.builtin.SourceLocation) void {
+fn layerOver(layer: *dvui.FloatingWidget, src: std.lang.SourceLocation) void {
     layer.init(src, .{ .mouse_events = false }, .{ .rect = .cast(dvui.windowRect()), .background = false });
     const wd = layer.data();
     dvui.subwindowAdd(wd.id, wd.rect, wd.rectScale().r, false, null, false);
@@ -1466,7 +1466,7 @@ fn layerOver(layer: *dvui.FloatingWidget, src: std.builtin.SourceLocation) void
 /// glass, and nothing in the app's own windows follows it. A copy there — its glass, a drop's tail,
 /// the drop it ran into — was drawn at another moment than the window server moved the window, and
 /// trailed behind it. Whether it is; the layer is the caller's to `deinit` then.
-fn ownWindowLayer(layer: *dvui.FloatingWidget, src: std.builtin.SourceLocation) bool {
+fn ownWindowLayer(layer: *dvui.FloatingWidget, src: std.lang.SourceLocation) bool {
     if (!core.dialogs.carry_windows) return false;
     layerOver(layer, src);
     core.screens.markCarried(layer.data().id);

app/store/PluginStore.zig

@@ -668,7 +668,7 @@ fn drawAuthorLine(entry: StoreEntry, muted: dvui.Color) void {
 /// `Font.withUnderline` + `color(.highlight, .fill)`, so every clickable bit of prose in the app
 /// reads the same way. A name with nowhere to go stays deliberately unstyled — underlining
 /// something unclickable is worse than leaving it plain.
-fn drawCreditLink(src: std.builtin.SourceLocation, text: []const u8, url: ?[]const u8, muted: dvui.Color) void {
+fn drawCreditLink(src: std.lang.SourceLocation, text: []const u8, url: ?[]const u8, muted: dvui.Color) void {
     const body = dvui.Font.theme(.body);
     const target = url orelse {
         dvui.labelNoFmt(src, text, .{}, .{
@@ -696,7 +696,7 @@ fn drawCreditLink(src: std.builtin.SourceLocation, text: []const u8, url: ?[]con
 /// separate bar), regular body text, and the selected tab marked by a `window`-text-colored
 /// underline rather than a filled pill. No drag/drop and no scroll area — there are only ever
 /// two tabs here.
-fn tabButton(src: std.builtin.SourceLocation, label: []const u8, id_extra: usize, selected: bool) bool {
+fn tabButton(src: std.lang.SourceLocation, label: []const u8, id_extra: usize, selected: bool) bool {
     const theme = dvui.themeGet();
 
     // Sized to the label's own width (no expand), so the underline drawn below — which does
@@ -2231,7 +2231,7 @@ const card_stagger_cap: usize = 10;
 /// re-triggers whenever `dvui.firstFrame` sees a new widget id, so indexing by position would
 /// replay the whole cascade every time re-ranking moved a card (i.e. on every filter keystroke).
 /// Keyed by id, each plugin animates exactly once, no matter how the list is later sorted.
-fn cardAnimator(src: std.builtin.SourceLocation, entry: StoreEntry, index: usize) *dvui.AnimateWidget {
+fn cardAnimator(src: std.lang.SourceLocation, entry: StoreEntry, index: usize) *dvui.AnimateWidget {
     const stagger = @min(index, card_stagger_cap);
     return dvui.animate(src, .{
         .kind = .horizontal,

backend/build.zig

@@ -23,7 +23,7 @@ pub fn build(b: *std.Build) void {
     // harness, against the patched library. Arguments after `--` reach the runner:
     // `--filter <suite|test>`, `--require-gpu <driver>`.
     const test_sdl_step = b.step("test-sdl", "Build and run the suites for fizzy's SDL patches");
-    const sdl_optimize: std.builtin.OptimizeMode = if (optimize == .debug) .fast else optimize;
+    const sdl_optimize: std.lang.OptimizeMode = if (optimize == .debug) .fast else optimize;
     if (sdlDependency(b, target, sdl_optimize, null)) |sdl| {
         const source = patchedSdl(b).?;
         const sdl_test = b.addLibrary(.{
@@ -86,7 +86,7 @@ pub const MacosSdk = struct {
 
 pub const Options = struct {
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     /// Null on a native build.
     macos_sdk: ?MacosSdk = null,
 };
@@ -139,7 +139,7 @@ pub fn backendModule(dep: *std.Build.Dependency, dvui_mod: *std.Build.Module, op
     // device, every window's present. A Debug frame spent much of itself there (`sample`), and a
     // window's way into full screen ran at half the display's rate in Debug alone. The app's own
     // code stays Debug; stepping into SDL's C is what a Debug app gives up.
-    const sdl_optimize: std.builtin.OptimizeMode = if (opts.optimize == .debug) .fast else opts.optimize;
+    const sdl_optimize: std.lang.OptimizeMode = if (opts.optimize == .debug) .fast else opts.optimize;
     const sdl_dep = sdlDependency(b, opts.target, sdl_optimize, opts.macos_sdk);
 
     const sdl_translate_c = b.addTranslateC(.{
@@ -209,7 +209,7 @@ fn patchedSdl(b: *std.Build) ?std.Build.LazyPath {
 fn sdlDependency(
     b: *std.Build,
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     macos_sdk: ?MacosSdk,
 ) ?*std.Build.Dependency {
     const source = patchedSdl(b) orelse return null;

backend/src/glass/BlurBackdrop.zig

@@ -108,7 +108,7 @@ const max_levels = 24;
 /// Safe to call every frame, any time before `init`/`deinit` - in
 /// particular, before other same-frame code needs to mutate fields on the
 /// returned pointer (e.g. a slider bound to `&backdrop.radius_px`).
-pub fn get(src: std.builtin.SourceLocation) *BlurBackdrop {
+pub fn get(src: std.lang.SourceLocation) *BlurBackdrop {
     const id = dvui.parentGet().extendId(src, 0);
     const self = dvui.dataGetPtrDefault(null, id, "blur_backdrop", BlurBackdrop, .{});
     dvui.dataSetDeinitFunction(null, id, "blur_backdrop", &releaseTexture);

build.zig

@@ -83,7 +83,7 @@ pub fn build(b: *std.Build) !void {
 /// standard options on the same builder.
 var deferred: ?struct {
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     base: @import("build/app.zig").Options,
     cfg: @import("build/app.zig").Config,
     /// `buildApp` has run (`addPackageSteps` needs its steps).

build/app.zig

@@ -52,7 +52,7 @@ pub const Options = struct {
     macos_sdk: ?[]const u8 = null,
 };
 
-pub fn build(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, opts: Options) !void {
+pub fn build(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.lang.OptimizeMode, opts: Options) !void {
     const cfg = try readConfig(b, target, opts);
     try construct(b, target, optimize, opts, cfg);
 }
@@ -490,7 +490,7 @@ pub fn readConfig(b: *std.Build, target: std.Build.ResolvedTarget, opts: Options
 }
 
 /// Phase two of `build`: the executables, the web build, tests, packaging.
-pub fn construct(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, opts: Options, cfg: Config) !void {
+pub fn construct(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.lang.OptimizeMode, opts: Options, cfg: Config) !void {
     const common = @import("common.zig");
     const plugins = @import("plugins.zig");
     const sdk = @import("sdk.zig");

build/exe.zig

@@ -103,7 +103,7 @@ pub fn nativeDvui(
     b: *std.Build,
     native_backend: NativeBackend,
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     accesskit: dvui.AccesskitOptions,
     macos_sdl_paths: ?MacosSdlPaths,
 ) NativeDvui {
@@ -133,7 +133,7 @@ pub fn nativeDvui(
 fn fizzyNativeDvui(
     b: *std.Build,
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     accesskit: dvui.AccesskitOptions,
     macos_sdl_paths: ?MacosSdlPaths,
 ) NativeDvui {
@@ -158,7 +158,7 @@ pub fn backendDependency(b: *std.Build) *std.Build.Dependency {
     return b.dependency("fizzy_backend", .{});
 }
 
-pub fn backendOptions(target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, macos_sdl_paths: ?MacosSdlPaths) fizzy_backend.Options {
+pub fn backendOptions(target: std.Build.ResolvedTarget, optimize: std.lang.OptimizeMode, macos_sdl_paths: ?MacosSdlPaths) fizzy_backend.Options {
     return .{
         .target = target,
         .optimize = optimize,
@@ -172,7 +172,7 @@ pub fn platformModule(
     b: *std.Build,
     native: NativeDvui,
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     macos_sdl_paths: ?MacosSdlPaths,
 ) *std.Build.Module {
     return fizzy_backend.platformModule(backendDependency(b), native.dvui, native.backend, backendOptions(target, optimize, macos_sdl_paths));
@@ -183,7 +183,7 @@ pub fn addFizzyExecutableForTarget(
     /// Null on the configure pass that fetches Velopack (`app.readConfig`).
     vz: ?velopack.Dep,
     resolved_target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     accesskit: dvui.AccesskitOptions,
     native_backend: NativeBackend,
     build_opts: *std.Build.Step.Options,

build/package.zig

@@ -8,7 +8,7 @@ pub const Options = struct {
     b: *std.Build,
     vz: velopack.Dep,
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     app_version: []const u8,
     /// `--packId`, and the executable's name (`--mainExe`).
     app_name: []const u8,

build/plugins.zig

@@ -41,7 +41,7 @@ pub fn linksFizzys(plugins: []const BundledPlugin, name: []const u8) bool {
 /// What one executable gives the plugins it links.
 pub const Wiring = struct {
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     dvui: *std.Build.Module,
     core: *std.Build.Module,
     sdk: *std.Build.Module,

build/sdk.zig

@@ -27,7 +27,7 @@ pub fn dvuiDependency(b: *std.Build, args: anytype) *std.Build.Dependency {
 pub fn addProxyBridgeModule(
     b: *std.Build,
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     dvui_dep: *std.Build.Dependency,
     dvui_module: *std.Build.Module,
 ) *std.Build.Module {
@@ -43,7 +43,7 @@ pub fn addProxyBridgeModule(
 pub fn wireSdkModule(
     b: *std.Build,
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     dvui_module: *std.Build.Module,
     proxy_bridge_module: *std.Build.Module,
     core_module: *std.Build.Module,
@@ -80,7 +80,7 @@ pub fn wireSdkModule(
 pub fn wireAppModule(
     b: *std.Build,
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     dvui_module: *std.Build.Module,
     core_module: *std.Build.Module,
     sdk_module: *std.Build.Module,
@@ -126,7 +126,7 @@ pub fn wireAppModule(
 
 /// Crash reports (`app/crash/`): std-only, a module of its own so the plugin loader reaches it
 /// from a test rooted at the loader as well as from the app.
-pub fn crashModule(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode) *std.Build.Module {
+pub fn crashModule(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.lang.OptimizeMode) *std.Build.Module {
     return b.createModule(.{
         .target = target,
         .optimize = optimize,
@@ -164,7 +164,7 @@ pub const BundledPlugin = struct {
 pub fn bundledPluginsModule(
     b: *std.Build,
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     plugins: []const BundledPlugin,
 ) *std.Build.Module {
     var src = std.ArrayList(u8).empty;

build/velopack.zig

@@ -78,7 +78,7 @@ pub fn addVpkRun(b: *std.Build, vz: Dep, target: std.Build.ResolvedTarget) !*std
 
 /// `Velopack.h` as a Zig module, through translate-c: Zig 0.17 removed `@cImport`. Imported as
 /// `velopack_c` by the modules `linkVelopack` is given.
-fn velopackCModule(b: *std.Build, vz: Dep, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode) *std.Build.Module {
+fn velopackCModule(b: *std.Build, vz: Dep, target: std.Build.ResolvedTarget, optimize: std.lang.OptimizeMode) *std.Build.Module {
     const tc = b.addTranslateC(.{
         .root_source_file = vz.builder.dependency("velopack", .{}).path("include/Velopack.h"),
         .target = target,
@@ -89,7 +89,7 @@ fn velopackCModule(b: *std.Build, vz: Dep, target: std.Build.ResolvedTarget, opt
 
 pub const LinkVelopackOptions = struct {
     target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     /// Modules that call Velopack's C API (the `app` module's updater does): each gets
     /// `Velopack.h` as the `velopack_c` import.
     c_modules: []const *std.Build.Module = &.{},

build/web.zig

@@ -7,7 +7,7 @@ const sdk = @import("sdk.zig");
 
 pub fn addSteps(
     b: *std.Build,
-    optimize: std.builtin.OptimizeMode,
+    optimize: std.lang.OptimizeMode,
     build_opts: *std.Build.Step.Options,
     workbench_opts: *std.Build.Step.Options,
     assets_module: *std.Build.Module,

core/Sprite.zig

@@ -13,7 +13,7 @@ source: [4]u32,
 /// Draw this sprite from `atlas_source` as a dvui widget (static textured quad).
 pub fn draw(
     self: Sprite,
-    src: std.builtin.SourceLocation,
+    src: std.lang.SourceLocation,
     atlas_source: dvui.ImageSource,
     scale: f32,
     opts: dvui.Options,