From a7f6e738122e7f1a5d2e502ee121700883fa3818 Mon Sep 17 00:00:00 2001
From: mlugg <mlugg@mlugg.co.uk>
Date: Thu, 7 Mar 2024 19:23:05 +0000
Subject: [PATCH] std.os.windows: eliminate usage of `usingnamespace`

Some of the structs I shuffled around might be better namespaced under
CONTEXT, I'm not sure. However, for now, this approach preserves
backwards compatibility.

Eliminates one more usage of `usingnamespace` from the standard library.
3 remain.
---
 lib/std/os/windows.zig | 558 +++++++++++++++++++++--------------------
 1 file changed, 284 insertions(+), 274 deletions(-)

diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index deb903b283..51fe924dc3 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -3796,290 +3796,300 @@ pub const EXCEPTION_RECORD = extern struct {
     ExceptionInformation: [15]usize,
 };
 
-pub usingnamespace switch (native_arch) {
-    .x86 => struct {
-        pub const FLOATING_SAVE_AREA = extern struct {
-            ControlWord: DWORD,
-            StatusWord: DWORD,
-            TagWord: DWORD,
-            ErrorOffset: DWORD,
-            ErrorSelector: DWORD,
-            DataOffset: DWORD,
-            DataSelector: DWORD,
-            RegisterArea: [80]BYTE,
-            Cr0NpxState: DWORD,
-        };
-
-        pub const CONTEXT = extern struct {
-            ContextFlags: DWORD,
-            Dr0: DWORD,
-            Dr1: DWORD,
-            Dr2: DWORD,
-            Dr3: DWORD,
-            Dr6: DWORD,
-            Dr7: DWORD,
-            FloatSave: FLOATING_SAVE_AREA,
-            SegGs: DWORD,
-            SegFs: DWORD,
-            SegEs: DWORD,
-            SegDs: DWORD,
-            Edi: DWORD,
-            Esi: DWORD,
-            Ebx: DWORD,
-            Edx: DWORD,
-            Ecx: DWORD,
-            Eax: DWORD,
-            Ebp: DWORD,
-            Eip: DWORD,
-            SegCs: DWORD,
-            EFlags: DWORD,
-            Esp: DWORD,
-            SegSs: DWORD,
-            ExtendedRegisters: [512]BYTE,
-
-            pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize } {
-                return .{ .bp = ctx.Ebp, .ip = ctx.Eip };
-            }
-        };
+pub const FLOATING_SAVE_AREA = switch (native_arch) {
+    .x86 => extern struct {
+        ControlWord: DWORD,
+        StatusWord: DWORD,
+        TagWord: DWORD,
+        ErrorOffset: DWORD,
+        ErrorSelector: DWORD,
+        DataOffset: DWORD,
+        DataSelector: DWORD,
+        RegisterArea: [80]BYTE,
+        Cr0NpxState: DWORD,
     },
-    .x86_64 => struct {
-        pub const M128A = extern struct {
+    else => @compileError("FLOATING_SAVE_AREA only defined on x86"),
+};
+
+pub const M128A = switch (native_arch) {
+    .x86_64 => extern struct {
+        Low: ULONGLONG,
+        High: LONGLONG,
+    },
+    else => @compileError("M128A only defined on x86_64"),
+};
+
+pub const XMM_SAVE_AREA32 = switch (native_arch) {
+    .x86_64 => extern struct {
+        ControlWord: WORD,
+        StatusWord: WORD,
+        TagWord: BYTE,
+        Reserved1: BYTE,
+        ErrorOpcode: WORD,
+        ErrorOffset: DWORD,
+        ErrorSelector: WORD,
+        Reserved2: WORD,
+        DataOffset: DWORD,
+        DataSelector: WORD,
+        Reserved3: WORD,
+        MxCsr: DWORD,
+        MxCsr_Mask: DWORD,
+        FloatRegisters: [8]M128A,
+        XmmRegisters: [16]M128A,
+        Reserved4: [96]BYTE,
+    },
+    else => @compileError("XMM_SAVE_AREA32 only defined on x86_64"),
+};
+
+pub const NEON128 = switch (native_arch) {
+    .aarch64 => extern union {
+        DUMMYSTRUCTNAME: extern struct {
             Low: ULONGLONG,
             High: LONGLONG,
-        };
-
-        pub const XMM_SAVE_AREA32 = extern struct {
-            ControlWord: WORD,
-            StatusWord: WORD,
-            TagWord: BYTE,
-            Reserved1: BYTE,
-            ErrorOpcode: WORD,
-            ErrorOffset: DWORD,
-            ErrorSelector: WORD,
-            Reserved2: WORD,
-            DataOffset: DWORD,
-            DataSelector: WORD,
-            Reserved3: WORD,
-            MxCsr: DWORD,
-            MxCsr_Mask: DWORD,
-            FloatRegisters: [8]M128A,
-            XmmRegisters: [16]M128A,
-            Reserved4: [96]BYTE,
-        };
-
-        pub const CONTEXT = extern struct {
-            P1Home: DWORD64 align(16),
-            P2Home: DWORD64,
-            P3Home: DWORD64,
-            P4Home: DWORD64,
-            P5Home: DWORD64,
-            P6Home: DWORD64,
-            ContextFlags: DWORD,
-            MxCsr: DWORD,
-            SegCs: WORD,
-            SegDs: WORD,
-            SegEs: WORD,
-            SegFs: WORD,
-            SegGs: WORD,
-            SegSs: WORD,
-            EFlags: DWORD,
-            Dr0: DWORD64,
-            Dr1: DWORD64,
-            Dr2: DWORD64,
-            Dr3: DWORD64,
-            Dr6: DWORD64,
-            Dr7: DWORD64,
-            Rax: DWORD64,
-            Rcx: DWORD64,
-            Rdx: DWORD64,
-            Rbx: DWORD64,
-            Rsp: DWORD64,
-            Rbp: DWORD64,
-            Rsi: DWORD64,
-            Rdi: DWORD64,
-            R8: DWORD64,
-            R9: DWORD64,
-            R10: DWORD64,
-            R11: DWORD64,
-            R12: DWORD64,
-            R13: DWORD64,
-            R14: DWORD64,
-            R15: DWORD64,
-            Rip: DWORD64,
-            DUMMYUNIONNAME: extern union {
-                FltSave: XMM_SAVE_AREA32,
-                FloatSave: XMM_SAVE_AREA32,
-                DUMMYSTRUCTNAME: extern struct {
-                    Header: [2]M128A,
-                    Legacy: [8]M128A,
-                    Xmm0: M128A,
-                    Xmm1: M128A,
-                    Xmm2: M128A,
-                    Xmm3: M128A,
-                    Xmm4: M128A,
-                    Xmm5: M128A,
-                    Xmm6: M128A,
-                    Xmm7: M128A,
-                    Xmm8: M128A,
-                    Xmm9: M128A,
-                    Xmm10: M128A,
-                    Xmm11: M128A,
-                    Xmm12: M128A,
-                    Xmm13: M128A,
-                    Xmm14: M128A,
-                    Xmm15: M128A,
-                },
-            },
-            VectorRegister: [26]M128A,
-            VectorControl: DWORD64,
-            DebugControl: DWORD64,
-            LastBranchToRip: DWORD64,
-            LastBranchFromRip: DWORD64,
-            LastExceptionToRip: DWORD64,
-            LastExceptionFromRip: DWORD64,
-
-            pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
-                return .{ .bp = ctx.Rbp, .ip = ctx.Rip, .sp = ctx.Rsp };
-            }
-
-            pub fn setIp(ctx: *CONTEXT, ip: usize) void {
-                ctx.Rip = ip;
-            }
-
-            pub fn setSp(ctx: *CONTEXT, sp: usize) void {
-                ctx.Rsp = sp;
-            }
-        };
-
-        pub const RUNTIME_FUNCTION = extern struct {
-            BeginAddress: DWORD,
-            EndAddress: DWORD,
-            UnwindData: DWORD,
-        };
-
-        pub const KNONVOLATILE_CONTEXT_POINTERS = extern struct {
-            FloatingContext: [16]?*M128A,
-            IntegerContext: [16]?*ULONG64,
-        };
+        },
+        D: [2]f64,
+        S: [4]f32,
+        H: [8]WORD,
+        B: [16]BYTE,
     },
-    .aarch64 => struct {
-        pub const NEON128 = extern union {
+    else => @compileError("NEON128 only defined on aarch64"),
+};
+
+pub const CONTEXT = switch (native_arch) {
+    .x86 => extern struct {
+        ContextFlags: DWORD,
+        Dr0: DWORD,
+        Dr1: DWORD,
+        Dr2: DWORD,
+        Dr3: DWORD,
+        Dr6: DWORD,
+        Dr7: DWORD,
+        FloatSave: FLOATING_SAVE_AREA,
+        SegGs: DWORD,
+        SegFs: DWORD,
+        SegEs: DWORD,
+        SegDs: DWORD,
+        Edi: DWORD,
+        Esi: DWORD,
+        Ebx: DWORD,
+        Edx: DWORD,
+        Ecx: DWORD,
+        Eax: DWORD,
+        Ebp: DWORD,
+        Eip: DWORD,
+        SegCs: DWORD,
+        EFlags: DWORD,
+        Esp: DWORD,
+        SegSs: DWORD,
+        ExtendedRegisters: [512]BYTE,
+
+        pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize } {
+            return .{ .bp = ctx.Ebp, .ip = ctx.Eip };
+        }
+    },
+    .x86_64 => extern struct {
+        P1Home: DWORD64 align(16),
+        P2Home: DWORD64,
+        P3Home: DWORD64,
+        P4Home: DWORD64,
+        P5Home: DWORD64,
+        P6Home: DWORD64,
+        ContextFlags: DWORD,
+        MxCsr: DWORD,
+        SegCs: WORD,
+        SegDs: WORD,
+        SegEs: WORD,
+        SegFs: WORD,
+        SegGs: WORD,
+        SegSs: WORD,
+        EFlags: DWORD,
+        Dr0: DWORD64,
+        Dr1: DWORD64,
+        Dr2: DWORD64,
+        Dr3: DWORD64,
+        Dr6: DWORD64,
+        Dr7: DWORD64,
+        Rax: DWORD64,
+        Rcx: DWORD64,
+        Rdx: DWORD64,
+        Rbx: DWORD64,
+        Rsp: DWORD64,
+        Rbp: DWORD64,
+        Rsi: DWORD64,
+        Rdi: DWORD64,
+        R8: DWORD64,
+        R9: DWORD64,
+        R10: DWORD64,
+        R11: DWORD64,
+        R12: DWORD64,
+        R13: DWORD64,
+        R14: DWORD64,
+        R15: DWORD64,
+        Rip: DWORD64,
+        DUMMYUNIONNAME: extern union {
+            FltSave: XMM_SAVE_AREA32,
+            FloatSave: XMM_SAVE_AREA32,
             DUMMYSTRUCTNAME: extern struct {
-                Low: ULONGLONG,
-                High: LONGLONG,
+                Header: [2]M128A,
+                Legacy: [8]M128A,
+                Xmm0: M128A,
+                Xmm1: M128A,
+                Xmm2: M128A,
+                Xmm3: M128A,
+                Xmm4: M128A,
+                Xmm5: M128A,
+                Xmm6: M128A,
+                Xmm7: M128A,
+                Xmm8: M128A,
+                Xmm9: M128A,
+                Xmm10: M128A,
+                Xmm11: M128A,
+                Xmm12: M128A,
+                Xmm13: M128A,
+                Xmm14: M128A,
+                Xmm15: M128A,
             },
-            D: [2]f64,
-            S: [4]f32,
-            H: [8]WORD,
-            B: [16]BYTE,
-        };
+        },
+        VectorRegister: [26]M128A,
+        VectorControl: DWORD64,
+        DebugControl: DWORD64,
+        LastBranchToRip: DWORD64,
+        LastBranchFromRip: DWORD64,
+        LastExceptionToRip: DWORD64,
+        LastExceptionFromRip: DWORD64,
 
-        pub const CONTEXT = extern struct {
-            ContextFlags: ULONG align(16),
-            Cpsr: ULONG,
-            DUMMYUNIONNAME: extern union {
-                DUMMYSTRUCTNAME: extern struct {
-                    X0: DWORD64,
-                    X1: DWORD64,
-                    X2: DWORD64,
-                    X3: DWORD64,
-                    X4: DWORD64,
-                    X5: DWORD64,
-                    X6: DWORD64,
-                    X7: DWORD64,
-                    X8: DWORD64,
-                    X9: DWORD64,
-                    X10: DWORD64,
-                    X11: DWORD64,
-                    X12: DWORD64,
-                    X13: DWORD64,
-                    X14: DWORD64,
-                    X15: DWORD64,
-                    X16: DWORD64,
-                    X17: DWORD64,
-                    X18: DWORD64,
-                    X19: DWORD64,
-                    X20: DWORD64,
-                    X21: DWORD64,
-                    X22: DWORD64,
-                    X23: DWORD64,
-                    X24: DWORD64,
-                    X25: DWORD64,
-                    X26: DWORD64,
-                    X27: DWORD64,
-                    X28: DWORD64,
-                    Fp: DWORD64,
-                    Lr: DWORD64,
-                },
-                X: [31]DWORD64,
-            },
-            Sp: DWORD64,
-            Pc: DWORD64,
-            V: [32]NEON128,
-            Fpcr: DWORD,
-            Fpsr: DWORD,
-            Bcr: [8]DWORD,
-            Bvr: [8]DWORD64,
-            Wcr: [2]DWORD,
-            Wvr: [2]DWORD64,
+        pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
+            return .{ .bp = ctx.Rbp, .ip = ctx.Rip, .sp = ctx.Rsp };
+        }
 
-            pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
-                return .{
-                    .bp = ctx.DUMMYUNIONNAME.DUMMYSTRUCTNAME.Fp,
-                    .ip = ctx.Pc,
-                    .sp = ctx.Sp,
-                };
-            }
+        pub fn setIp(ctx: *CONTEXT, ip: usize) void {
+            ctx.Rip = ip;
+        }
 
-            pub fn setIp(ctx: *CONTEXT, ip: usize) void {
-                ctx.Pc = ip;
-            }
-
-            pub fn setSp(ctx: *CONTEXT, sp: usize) void {
-                ctx.Sp = sp;
-            }
-        };
-
-        pub const RUNTIME_FUNCTION = extern struct {
-            BeginAddress: DWORD,
-            DUMMYUNIONNAME: extern union {
-                UnwindData: DWORD,
-                DUMMYSTRUCTNAME: packed struct {
-                    Flag: u2,
-                    FunctionLength: u11,
-                    RegF: u3,
-                    RegI: u4,
-                    H: u1,
-                    CR: u2,
-                    FrameSize: u9,
-                },
-            },
-        };
-
-        pub const KNONVOLATILE_CONTEXT_POINTERS = extern struct {
-            X19: ?*DWORD64,
-            X20: ?*DWORD64,
-            X21: ?*DWORD64,
-            X22: ?*DWORD64,
-            X23: ?*DWORD64,
-            X24: ?*DWORD64,
-            X25: ?*DWORD64,
-            X26: ?*DWORD64,
-            X27: ?*DWORD64,
-            X28: ?*DWORD64,
-            Fp: ?*DWORD64,
-            Lr: ?*DWORD64,
-            D8: ?*DWORD64,
-            D9: ?*DWORD64,
-            D10: ?*DWORD64,
-            D11: ?*DWORD64,
-            D12: ?*DWORD64,
-            D13: ?*DWORD64,
-            D14: ?*DWORD64,
-            D15: ?*DWORD64,
-        };
+        pub fn setSp(ctx: *CONTEXT, sp: usize) void {
+            ctx.Rsp = sp;
+        }
     },
-    else => struct {},
+    .aarch64 => extern struct {
+        ContextFlags: ULONG align(16),
+        Cpsr: ULONG,
+        DUMMYUNIONNAME: extern union {
+            DUMMYSTRUCTNAME: extern struct {
+                X0: DWORD64,
+                X1: DWORD64,
+                X2: DWORD64,
+                X3: DWORD64,
+                X4: DWORD64,
+                X5: DWORD64,
+                X6: DWORD64,
+                X7: DWORD64,
+                X8: DWORD64,
+                X9: DWORD64,
+                X10: DWORD64,
+                X11: DWORD64,
+                X12: DWORD64,
+                X13: DWORD64,
+                X14: DWORD64,
+                X15: DWORD64,
+                X16: DWORD64,
+                X17: DWORD64,
+                X18: DWORD64,
+                X19: DWORD64,
+                X20: DWORD64,
+                X21: DWORD64,
+                X22: DWORD64,
+                X23: DWORD64,
+                X24: DWORD64,
+                X25: DWORD64,
+                X26: DWORD64,
+                X27: DWORD64,
+                X28: DWORD64,
+                Fp: DWORD64,
+                Lr: DWORD64,
+            },
+            X: [31]DWORD64,
+        },
+        Sp: DWORD64,
+        Pc: DWORD64,
+        V: [32]NEON128,
+        Fpcr: DWORD,
+        Fpsr: DWORD,
+        Bcr: [8]DWORD,
+        Bvr: [8]DWORD64,
+        Wcr: [2]DWORD,
+        Wvr: [2]DWORD64,
+
+        pub fn getRegs(ctx: *const CONTEXT) struct { bp: usize, ip: usize, sp: usize } {
+            return .{
+                .bp = ctx.DUMMYUNIONNAME.DUMMYSTRUCTNAME.Fp,
+                .ip = ctx.Pc,
+                .sp = ctx.Sp,
+            };
+        }
+
+        pub fn setIp(ctx: *CONTEXT, ip: usize) void {
+            ctx.Pc = ip;
+        }
+
+        pub fn setSp(ctx: *CONTEXT, sp: usize) void {
+            ctx.Sp = sp;
+        }
+    },
+    else => @compileError("CONTEXT is not defined for this architecture"),
+};
+
+pub const RUNTIME_FUNCTION = switch (native_arch) {
+    .x86_64 => extern struct {
+        BeginAddress: DWORD,
+        EndAddress: DWORD,
+        UnwindData: DWORD,
+    },
+    .aarch64 => extern struct {
+        BeginAddress: DWORD,
+        DUMMYUNIONNAME: extern union {
+            UnwindData: DWORD,
+            DUMMYSTRUCTNAME: packed struct {
+                Flag: u2,
+                FunctionLength: u11,
+                RegF: u3,
+                RegI: u4,
+                H: u1,
+                CR: u2,
+                FrameSize: u9,
+            },
+        },
+    },
+    else => @compileError("RUNTIME_FUNCTION is not defined for this architecture"),
+};
+
+pub const KNONVOLATILE_CONTEXT_POINTERS = switch (native_arch) {
+    .x86_64 => extern struct {
+        FloatingContext: [16]?*M128A,
+        IntegerContext: [16]?*ULONG64,
+    },
+    .aarch64 => extern struct {
+        X19: ?*DWORD64,
+        X20: ?*DWORD64,
+        X21: ?*DWORD64,
+        X22: ?*DWORD64,
+        X23: ?*DWORD64,
+        X24: ?*DWORD64,
+        X25: ?*DWORD64,
+        X26: ?*DWORD64,
+        X27: ?*DWORD64,
+        X28: ?*DWORD64,
+        Fp: ?*DWORD64,
+        Lr: ?*DWORD64,
+        D8: ?*DWORD64,
+        D9: ?*DWORD64,
+        D10: ?*DWORD64,
+        D11: ?*DWORD64,
+        D12: ?*DWORD64,
+        D13: ?*DWORD64,
+        D14: ?*DWORD64,
+        D15: ?*DWORD64,
+    },
+    else => @compileError("KNONVOLATILE_CONTEXT_POINTERS is not defined for this architecture"),
 };
 
 pub const EXCEPTION_POINTERS = extern struct {