Merge pull request #5846 from Vexu/anytype

Rename 'var' type to 'anytype'

23 files changed, 93 insertions, 82 deletions

diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index df2e759bf1..fb4428fbc6 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -42,7 +42,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn foo() Foo {
         \\    return .{ .x = 42 };
         \\}
-        \\fn bar(val: var) Foo {
+        \\fn bar(val: anytype) Foo {
         \\    return .{ .x = val };
         \\}
         \\export fn entry() void {
@@ -1034,7 +1034,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    storev(&v[i], 42);
         \\}
         \\
-        \\fn storev(ptr: var, val: i32) void {
+        \\fn storev(ptr: anytype, val: i32) void {
         \\    ptr.* = val;
         \\}
     , &[_][]const u8{
@@ -1049,7 +1049,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x = loadv(&v[i]);
         \\}
         \\
-        \\fn loadv(ptr: var) i32 {
+        \\fn loadv(ptr: anytype) i32 {
         \\    return ptr.*;
         \\}
     , &[_][]const u8{
@@ -1832,7 +1832,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    while (true) {}
         \\}
     , &[_][]const u8{
-        "error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn([]const u8,var) var'",
+        "error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn([]const u8,anytype) anytype'",
         "note: only one of the functions is generic",
     });
 
@@ -2032,11 +2032,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
 
     cases.add("export generic function",
-        \\export fn foo(num: var) i32 {
+        \\export fn foo(num: anytype) i32 {
         \\    return 0;
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:15: error: parameter of type 'var' not allowed in function with calling convention 'C'",
+        "tmp.zig:1:15: error: parameter of type 'anytype' not allowed in function with calling convention 'C'",
     });
 
     cases.add("C pointer to c_void",
@@ -2836,7 +2836,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
 
     cases.add("missing parameter name of generic function",
-        \\fn dump(var) void {}
+        \\fn dump(anytype) void {}
         \\export fn entry() void {
         \\    var a: u8 = 9;
         \\    dump(a);
@@ -2859,13 +2859,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
 
     cases.add("generic fn as parameter without comptime keyword",
-        \\fn f(_: fn (var) void) void {}
-        \\fn g(_: var) void {}
+        \\fn f(_: fn (anytype) void) void {}
+        \\fn g(_: anytype) void {}
         \\export fn entry() void {
         \\    f(g);
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:9: error: parameter of type 'fn(var) var' must be declared comptime",
+        "tmp.zig:1:9: error: parameter of type 'fn(anytype) anytype' must be declared comptime",
     });
 
     cases.add("optional pointer to void in extern struct",
@@ -3165,7 +3165,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
 
     cases.add("var makes structs required to be comptime known",
         \\export fn entry() void {
-        \\   const S = struct{v: var};
+        \\   const S = struct{v: anytype};
         \\   var s = S{.v=@as(i32, 10)};
         \\}
     , &[_][]const u8{
@@ -6072,10 +6072,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
 
     cases.add("calling a generic function only known at runtime",
-        \\var foos = [_]fn(var) void { foo1, foo2 };
+        \\var foos = [_]fn(anytype) void { foo1, foo2 };
         \\
-        \\fn foo1(arg: var) void {}
-        \\fn foo2(arg: var) void {}
+        \\fn foo1(arg: anytype) void {}
+        \\fn foo2(arg: anytype) void {}
         \\
         \\pub fn main() !void {
         \\    foos[0](true);
@@ -6920,12 +6920,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
 
     cases.add("getting return type of generic function",
-        \\fn generic(a: var) void {}
+        \\fn generic(a: anytype) void {}
         \\comptime {
         \\    _ = @TypeOf(generic).ReturnType;
         \\}
     , &[_][]const u8{
-        "tmp.zig:3:25: error: ReturnType has not been resolved because 'fn(var) var' is generic",
+        "tmp.zig:3:25: error: ReturnType has not been resolved because 'fn(anytype) anytype' is generic",
     });
 
     cases.add("unsupported modifier at start of asm output constraint",
@@ -7493,7 +7493,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
 
     cases.add("issue #5221: invalid struct init type referenced by @typeInfo and passed into function",
-        \\fn ignore(comptime param: var) void {}
+        \\fn ignore(comptime param: anytype) void {}
         \\
         \\export fn foo() void {
         \\    const MyStruct = struct {
diff --git a/test/stage1/behavior/async_fn.zig b/test/stage1/behavior/async_fn.zig
index 4214ed84d2..807e4c6275 100644
--- a/test/stage1/behavior/async_fn.zig
+++ b/test/stage1/behavior/async_fn.zig
@@ -1016,7 +1016,7 @@ test "@asyncCall using the result location inside the frame" {
 
 test "@TypeOf an async function call of generic fn with error union type" {
     const S = struct {
-        fn func(comptime x: var) anyerror!i32 {
+        fn func(comptime x: anytype) anyerror!i32 {
             const T = @TypeOf(async func(x));
             comptime expect(T == @TypeOf(@frame()).Child);
             return undefined;
@@ -1032,7 +1032,7 @@ test "using @TypeOf on a generic function call" {
 
         var buf: [100]u8 align(16) = undefined;
 
-        fn amain(x: var) void {
+        fn amain(x: anytype) void {
             if (x == 0) {
                 global_ok = true;
                 return;
@@ -1057,7 +1057,7 @@ test "recursive call of await @asyncCall with struct return type" {
 
         var buf: [100]u8 align(16) = undefined;
 
-        fn amain(x: var) Foo {
+        fn amain(x: anytype) Foo {
             if (x == 0) {
                 global_ok = true;
                 return Foo{ .x = 1, .y = 2, .z = 3 };
@@ -1336,7 +1336,7 @@ test "async function passed 0-bit arg after non-0-bit arg" {
             bar(1, .{}) catch unreachable;
         }
 
-        fn bar(x: i32, args: var) anyerror!void {
+        fn bar(x: i32, args: anytype) anyerror!void {
             global_frame = @frame();
             suspend;
             global_int = x;
@@ -1357,7 +1357,7 @@ test "async function passed align(16) arg after align(8) arg" {
             bar(10, .{a}) catch unreachable;
         }
 
-        fn bar(x: u64, args: var) anyerror!void {
+        fn bar(x: u64, args: anytype) anyerror!void {
             expect(x == 10);
             global_frame = @frame();
             suspend;
diff --git a/test/stage1/behavior/bitcast.zig b/test/stage1/behavior/bitcast.zig
index 009f4544ba..2a86044dc1 100644
--- a/test/stage1/behavior/bitcast.zig
+++ b/test/stage1/behavior/bitcast.zig
@@ -171,7 +171,7 @@ test "nested bitcast" {
 
 test "bitcast passed as tuple element" {
     const S = struct {
-        fn foo(args: var) void {
+        fn foo(args: anytype) void {
             comptime expect(@TypeOf(args[0]) == f32);
             expect(args[0] == 12.34);
         }
@@ -181,7 +181,7 @@ test "bitcast passed as tuple element" {
 
 test "triple level result location with bitcast sandwich passed as tuple element" {
     const S = struct {
-        fn foo(args: var) void {
+        fn foo(args: anytype) void {
             comptime expect(@TypeOf(args[0]) == f64);
             expect(args[0] > 12.33 and args[0] < 12.35);
         }
diff --git a/test/stage1/behavior/bugs/2114.zig b/test/stage1/behavior/bugs/2114.zig
index ab32a22cf3..1034a256d3 100644
--- a/test/stage1/behavior/bugs/2114.zig
+++ b/test/stage1/behavior/bugs/2114.zig
@@ -2,7 +2,7 @@ const std = @import("std");
 const expect = std.testing.expect;
 const math = std.math;
 
-fn ctz(x: var) usize {
+fn ctz(x: anytype) usize {
     return @ctz(@TypeOf(x), x);
 }
 
diff --git a/test/stage1/behavior/bugs/3742.zig b/test/stage1/behavior/bugs/3742.zig
index f09127a66f..bf6e1f5207 100644
--- a/test/stage1/behavior/bugs/3742.zig
+++ b/test/stage1/behavior/bugs/3742.zig
@@ -23,7 +23,7 @@ pub fn isCommand(comptime T: type) bool {
 }
 
 pub const ArgSerializer = struct {
-    pub fn serializeCommand(command: var) void {
+    pub fn serializeCommand(command: anytype) void {
         const CmdT = @TypeOf(command);
 
         if (comptime isCommand(CmdT)) {
diff --git a/test/stage1/behavior/bugs/4328.zig b/test/stage1/behavior/bugs/4328.zig
index 0196af1748..98ab7bd155 100644
--- a/test/stage1/behavior/bugs/4328.zig
+++ b/test/stage1/behavior/bugs/4328.zig
@@ -17,11 +17,11 @@ const S = extern struct {
 
 test "Extern function calls in @TypeOf" {
     const Test = struct {
-        fn test_fn_1(a: var, b: var) @TypeOf(printf("%d %s\n", a, b)) {
+        fn test_fn_1(a: anytype, b: anytype) @TypeOf(printf("%d %s\n", a, b)) {
             return 0;
         }
 
-        fn test_fn_2(a: var) @TypeOf((S{ .state = 0 }).s_do_thing(a)) {
+        fn test_fn_2(a: anytype) @TypeOf((S{ .state = 0 }).s_do_thing(a)) {
             return 1;
         }
 
@@ -56,7 +56,7 @@ test "Extern function calls, dereferences and field access in @TypeOf" {
             return .{ .dummy_field = 0 };
         }
 
-        fn test_fn_2(a: var) @TypeOf(fopen("test", "r").*.dummy_field) {
+        fn test_fn_2(a: anytype) @TypeOf(fopen("test", "r").*.dummy_field) {
             return 255;
         }
 
@@ -68,4 +68,4 @@ test "Extern function calls, dereferences and field access in @TypeOf" {
 
     Test.doTheTest();
     comptime Test.doTheTest();
-}
\ No newline at end of file
+}
diff --git a/test/stage1/behavior/bugs/4769_a.zig b/test/stage1/behavior/bugs/4769_a.zig
index ab0c01417a..8337712ea5 100644
--- a/test/stage1/behavior/bugs/4769_a.zig
+++ b/test/stage1/behavior/bugs/4769_a.zig
@@ -1 +1 @@
-//
\ No newline at end of file
+//
diff --git a/test/stage1/behavior/bugs/4769_b.zig b/test/stage1/behavior/bugs/4769_b.zig
index 23b2513f17..9d0f028e57 100644
--- a/test/stage1/behavior/bugs/4769_b.zig
+++ b/test/stage1/behavior/bugs/4769_b.zig
@@ -1 +1 @@
-//!
\ No newline at end of file
+//!
diff --git a/test/stage1/behavior/byval_arg_var.zig b/test/stage1/behavior/byval_arg_var.zig
index 3794a965c6..ec3d18a532 100644
--- a/test/stage1/behavior/byval_arg_var.zig
+++ b/test/stage1/behavior/byval_arg_var.zig
@@ -13,11 +13,11 @@ fn start() void {
     foo("string literal");
 }
 
-fn foo(x: var) void {
+fn foo(x: anytype) void {
     bar(x);
 }
 
-fn bar(x: var) void {
+fn bar(x: anytype) void {
     result = x;
 }
 
diff --git a/test/stage1/behavior/call.zig b/test/stage1/behavior/call.zig
index 40b5be4cd3..4d05a83a39 100644
--- a/test/stage1/behavior/call.zig
+++ b/test/stage1/behavior/call.zig
@@ -57,7 +57,7 @@ test "tuple parameters" {
 
 test "comptime call with bound function as parameter" {
     const S = struct {
-        fn ReturnType(func: var) type {
+        fn ReturnType(func: anytype) type {
             return switch (@typeInfo(@TypeOf(func))) {
                 .BoundFn => |info| info,
                 else => unreachable,
diff --git a/test/stage1/behavior/enum.zig b/test/stage1/behavior/enum.zig
index b6cb86a363..765828f5ce 100644
--- a/test/stage1/behavior/enum.zig
+++ b/test/stage1/behavior/enum.zig
@@ -208,7 +208,7 @@ test "@tagName non-exhaustive enum" {
     comptime expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
 }
 
-fn testEnumTagNameBare(n: var) []const u8 {
+fn testEnumTagNameBare(n: anytype) []const u8 {
     return @tagName(n);
 }
 
diff --git a/test/stage1/behavior/error.zig b/test/stage1/behavior/error.zig
index def7fd679d..975e08b04f 100644
--- a/test/stage1/behavior/error.zig
+++ b/test/stage1/behavior/error.zig
@@ -227,7 +227,7 @@ test "error: Infer error set from literals" {
     _ = comptime intLiteral("n") catch |err| handleErrors(err);
 }
 
-fn handleErrors(err: var) noreturn {
+fn handleErrors(err: anytype) noreturn {
     switch (err) {
         error.T => {},
     }
diff --git a/test/stage1/behavior/eval.zig b/test/stage1/behavior/eval.zig
index 2af34eaf7e..17d5aafe06 100644
--- a/test/stage1/behavior/eval.zig
+++ b/test/stage1/behavior/eval.zig
@@ -670,10 +670,10 @@ fn loopNTimes(comptime n: usize) void {
 }
 
 test "variable inside inline loop that has different types on different iterations" {
-    testVarInsideInlineLoop(.{true, @as(u32, 42)});
+    testVarInsideInlineLoop(.{ true, @as(u32, 42) });
 }
 
-fn testVarInsideInlineLoop(args: var) void {
+fn testVarInsideInlineLoop(args: anytype) void {
     comptime var i = 0;
     inline while (i < args.len) : (i += 1) {
         const x = args[i];
@@ -814,17 +814,16 @@ test "two comptime calls with array default initialized to undefined" {
             dynamic_linker: DynamicLinker = DynamicLinker{},
 
             pub fn parse() void {
-                var result: CrossTarget = .{ };
+                var result: CrossTarget = .{};
                 result.getCpuArch();
             }
 
-            pub fn getCpuArch(self: CrossTarget) void { }
+            pub fn getCpuArch(self: CrossTarget) void {}
         };
 
         const DynamicLinker = struct {
             buffer: [255]u8 = undefined,
         };
-
     };
 
     comptime {
diff --git a/test/stage1/behavior/fn.zig b/test/stage1/behavior/fn.zig
index c1e5459378..c9f7477ecf 100644
--- a/test/stage1/behavior/fn.zig
+++ b/test/stage1/behavior/fn.zig
@@ -104,7 +104,7 @@ test "number literal as an argument" {
     comptime numberLiteralArg(3);
 }
 
-fn numberLiteralArg(a: var) void {
+fn numberLiteralArg(a: anytype) void {
     expect(a == 3);
 }
 
@@ -132,7 +132,7 @@ test "pass by non-copying value through var arg" {
     expect(addPointCoordsVar(Point{ .x = 1, .y = 2 }) == 3);
 }
 
-fn addPointCoordsVar(pt: var) i32 {
+fn addPointCoordsVar(pt: anytype) i32 {
     comptime expect(@TypeOf(pt) == Point);
     return pt.x + pt.y;
 }
@@ -267,7 +267,7 @@ test "ability to give comptime types and non comptime types to same parameter" {
             expect(foo(i32) == 20);
         }
 
-        fn foo(arg: var) i32 {
+        fn foo(arg: anytype) i32 {
             if (@typeInfo(@TypeOf(arg)) == .Type and arg == i32) return 20;
             return 9 + arg;
         }
diff --git a/test/stage1/behavior/generics.zig b/test/stage1/behavior/generics.zig
index a5d2f9dabe..6b584e381d 100644
--- a/test/stage1/behavior/generics.zig
+++ b/test/stage1/behavior/generics.zig
@@ -47,7 +47,7 @@ comptime {
     expect(max_f64(1.2, 3.4) == 3.4);
 }
 
-fn max_var(a: var, b: var) @TypeOf(a + b) {
+fn max_var(a: anytype, b: anytype) @TypeOf(a + b) {
     return if (a > b) a else b;
 }
 
@@ -133,15 +133,15 @@ fn getFirstByte(comptime T: type, mem: []const T) u8 {
     return getByte(@ptrCast(*const u8, &mem[0]));
 }
 
-const foos = [_]fn (var) bool{
+const foos = [_]fn (anytype) bool{
     foo1,
     foo2,
 };
 
-fn foo1(arg: var) bool {
+fn foo1(arg: anytype) bool {
     return arg;
 }
-fn foo2(arg: var) bool {
+fn foo2(arg: anytype) bool {
     return !arg;
 }
 
diff --git a/test/stage1/behavior/optional.zig b/test/stage1/behavior/optional.zig
index 0003bb86e1..1dc33eb8ea 100644
--- a/test/stage1/behavior/optional.zig
+++ b/test/stage1/behavior/optional.zig
@@ -67,8 +67,20 @@ fn test_cmp_optional_non_optional() void {
     // test evaluation is always lexical
     // ensure that the optional isn't always computed before the non-optional
     var mutable_state: i32 = 0;
-    _ = blk1: { mutable_state += 1; break :blk1 @as(?f64, 10.0); } != blk2: { expect(mutable_state == 1); break :blk2 @as(f64, 5.0); };
-    _ = blk1: { mutable_state += 1; break :blk1 @as(f64, 10.0); } != blk2: { expect(mutable_state == 2); break :blk2 @as(?f64, 5.0); };
+    _ = blk1: {
+        mutable_state += 1;
+        break :blk1 @as(?f64, 10.0);
+    } != blk2: {
+        expect(mutable_state == 1);
+        break :blk2 @as(f64, 5.0);
+    };
+    _ = blk1: {
+        mutable_state += 1;
+        break :blk1 @as(f64, 10.0);
+    } != blk2: {
+        expect(mutable_state == 2);
+        break :blk2 @as(?f64, 5.0);
+    };
 }
 
 test "passing an optional integer as a parameter" {
diff --git a/test/stage1/behavior/struct.zig b/test/stage1/behavior/struct.zig
index 7b8690d604..2d83bd23bb 100644
--- a/test/stage1/behavior/struct.zig
+++ b/test/stage1/behavior/struct.zig
@@ -713,7 +713,7 @@ test "packed struct field passed to generic function" {
             a: u1,
         };
 
-        fn genericReadPackedField(ptr: var) u5 {
+        fn genericReadPackedField(ptr: anytype) u5 {
             return ptr.*;
         }
     };
@@ -754,7 +754,7 @@ test "fully anonymous struct" {
                 .s = "hi",
             });
         }
-        fn dump(args: var) void {
+        fn dump(args: anytype) void {
             expect(args.int == 1234);
             expect(args.float == 12.34);
             expect(args.b);
@@ -771,7 +771,7 @@ test "fully anonymous list literal" {
         fn doTheTest() void {
             dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
         }
-        fn dump(args: var) void {
+        fn dump(args: anytype) void {
             expect(args.@"0" == 1234);
             expect(args.@"1" == 12.34);
             expect(args.@"2");
@@ -792,8 +792,8 @@ test "anonymous struct literal assigned to variable" {
 
 test "struct with var field" {
     const Point = struct {
-        x: var,
-        y: var,
+        x: anytype,
+        y: anytype,
     };
     const pt = Point{
         .x = 1,
diff --git a/test/stage1/behavior/tuple.zig b/test/stage1/behavior/tuple.zig
index 0b2fdfe4e0..299abec3c9 100644
--- a/test/stage1/behavior/tuple.zig
+++ b/test/stage1/behavior/tuple.zig
@@ -42,7 +42,7 @@ test "tuple multiplication" {
     comptime S.doTheTest();
 
     const T = struct {
-        fn consume_tuple(tuple: var, len: usize) void {
+        fn consume_tuple(tuple: anytype, len: usize) void {
             expect(tuple.len == len);
         }
 
@@ -82,7 +82,7 @@ test "tuple multiplication" {
 
 test "pass tuple to comptime var parameter" {
     const S = struct {
-        fn Foo(comptime args: var) void {
+        fn Foo(comptime args: anytype) void {
             expect(args[0] == 1);
         }
 
diff --git a/test/stage1/behavior/type_info.zig b/test/stage1/behavior/type_info.zig
index 9da1da6e87..d4c8cec977 100644
--- a/test/stage1/behavior/type_info.zig
+++ b/test/stage1/behavior/type_info.zig
@@ -385,7 +385,7 @@ test "@typeInfo does not force declarations into existence" {
 }
 
 test "defaut value for a var-typed field" {
-    const S = struct { x: var };
+    const S = struct { x: anytype };
     expect(@typeInfo(S).Struct.fields[0].default_value == null);
 }
 
diff --git a/test/stage1/behavior/union.zig b/test/stage1/behavior/union.zig
index 8555e712dd..da898347b9 100644
--- a/test/stage1/behavior/union.zig
+++ b/test/stage1/behavior/union.zig
@@ -296,7 +296,7 @@ const TaggedUnionWithAVoid = union(enum) {
     B: i32,
 };
 
-fn testTaggedUnionInit(x: var) bool {
+fn testTaggedUnionInit(x: anytype) bool {
     const y = TaggedUnionWithAVoid{ .A = x };
     return @as(@TagType(TaggedUnionWithAVoid), y) == TaggedUnionWithAVoid.A;
 }
diff --git a/test/stage1/behavior/var_args.zig b/test/stage1/behavior/var_args.zig
index 0c8674a7fb..eae8f8f888 100644
--- a/test/stage1/behavior/var_args.zig
+++ b/test/stage1/behavior/var_args.zig
@@ -1,6 +1,6 @@
 const expect = @import("std").testing.expect;
 
-fn add(args: var) i32 {
+fn add(args: anytype) i32 {
     var sum = @as(i32, 0);
     {
         comptime var i: usize = 0;
@@ -17,7 +17,7 @@ test "add arbitrary args" {
     expect(add(.{}) == 0);
 }
 
-fn readFirstVarArg(args: var) void {
+fn readFirstVarArg(args: anytype) void {
     const value = args[0];
 }
 
@@ -31,7 +31,7 @@ test "pass args directly" {
     expect(addSomeStuff(.{}) == 0);
 }
 
-fn addSomeStuff(args: var) i32 {
+fn addSomeStuff(args: anytype) i32 {
     return add(args);
 }
 
@@ -47,7 +47,7 @@ test "runtime parameter before var args" {
     }
 }
 
-fn extraFn(extra: u32, args: var) usize {
+fn extraFn(extra: u32, args: anytype) usize {
     if (args.len >= 1) {
         expect(args[0] == false);
     }
@@ -57,15 +57,15 @@ fn extraFn(extra: u32, args: var) usize {
     return args.len;
 }
 
-const foos = [_]fn (var) bool{
+const foos = [_]fn (anytype) bool{
     foo1,
     foo2,
 };
 
-fn foo1(args: var) bool {
+fn foo1(args: anytype) bool {
     return true;
 }
-fn foo2(args: var) bool {
+fn foo2(args: anytype) bool {
     return false;
 }
 
@@ -78,6 +78,6 @@ test "pass zero length array to var args param" {
     doNothingWithFirstArg(.{""});
 }
 
-fn doNothingWithFirstArg(args: var) void {
+fn doNothingWithFirstArg(args: anytype) void {
     const a = args[0];
 }
diff --git a/test/stage1/behavior/vector.zig b/test/stage1/behavior/vector.zig
index 851074e0d1..8bdffcd500 100644
--- a/test/stage1/behavior/vector.zig
+++ b/test/stage1/behavior/vector.zig
@@ -171,7 +171,7 @@ test "load vector elements via comptime index" {
             expect(v[1] == 2);
             expect(loadv(&v[2]) == 3);
         }
-        fn loadv(ptr: var) i32 {
+        fn loadv(ptr: anytype) i32 {
             return ptr.*;
         }
     };
@@ -194,7 +194,7 @@ test "store vector elements via comptime index" {
             storev(&v[0], 100);
             expect(v[0] == 100);
         }
-        fn storev(ptr: var, x: i32) void {
+        fn storev(ptr: anytype, x: i32) void {
             ptr.* = x;
         }
     };
@@ -392,7 +392,7 @@ test "vector shift operators" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
     const S = struct {
-        fn doTheTestShift(x: var, y: var) void {
+        fn doTheTestShift(x: anytype, y: anytype) void {
             const N = @typeInfo(@TypeOf(x)).Array.len;
             const TX = @typeInfo(@TypeOf(x)).Array.child;
             const TY = @typeInfo(@TypeOf(y)).Array.child;
@@ -409,7 +409,7 @@ test "vector shift operators" {
                 expectEqual(x[i] << y[i], v);
             }
         }
-        fn doTheTestShiftExact(x: var, y: var, dir: enum { Left, Right }) void {
+        fn doTheTestShiftExact(x: anytype, y: anytype, dir: enum { Left, Right }) void {
             const N = @typeInfo(@TypeOf(x)).Array.len;
             const TX = @typeInfo(@TypeOf(x)).Array.child;
             const TY = @typeInfo(@TypeOf(y)).Array.child;
diff --git a/test/translate_c.zig b/test/translate_c.zig
index a4e2a33000..738f9523ad 100644
--- a/test/translate_c.zig
+++ b/test/translate_c.zig
@@ -21,7 +21,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     cases.add("correct semicolon after infixop",
         \\#define __ferror_unlocked_body(_fp) (((_fp)->_flags & _IO_ERR_SEEN) != 0)
     , &[_][]const u8{
-        \\pub inline fn __ferror_unlocked_body(_fp: var) @TypeOf(((_fp.*._flags) & _IO_ERR_SEEN) != 0) {
+        \\pub inline fn __ferror_unlocked_body(_fp: anytype) @TypeOf(((_fp.*._flags) & _IO_ERR_SEEN) != 0) {
         \\    return ((_fp.*._flags) & _IO_ERR_SEEN) != 0;
         \\}
     });
@@ -30,7 +30,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\#define FOO(x) ((x >= 0) + (x >= 0))
         \\#define BAR 1 && 2 > 4
     , &[_][]const u8{
-        \\pub inline fn FOO(x: var) @TypeOf(@boolToInt(x >= 0) + @boolToInt(x >= 0)) {
+        \\pub inline fn FOO(x: anytype) @TypeOf(@boolToInt(x >= 0) + @boolToInt(x >= 0)) {
         \\    return @boolToInt(x >= 0) + @boolToInt(x >= 0);
         \\}
     ,
@@ -81,7 +81,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    break :blk bar;
         \\};
     ,
-        \\pub inline fn bar(x: var) @TypeOf(baz(1, 2)) {
+        \\pub inline fn bar(x: anytype) @TypeOf(baz(1, 2)) {
         \\    return blk: {
         \\        _ = &x;
         \\        _ = 3;
@@ -1483,11 +1483,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     , &[_][]const u8{
         \\pub extern var c: c_int;
     ,
-        \\pub inline fn BASIC(c_1: var) @TypeOf(c_1 * 2) {
+        \\pub inline fn BASIC(c_1: anytype) @TypeOf(c_1 * 2) {
         \\    return c_1 * 2;
         \\}
     ,
-        \\pub inline fn FOO(L: var, b: var) @TypeOf(L + b) {
+        \\pub inline fn FOO(L: anytype, b: anytype) @TypeOf(L + b) {
         \\    return L + b;
         \\}
     });
@@ -2123,7 +2123,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     cases.add("macro call",
         \\#define CALL(arg) bar(arg)
     , &[_][]const u8{
-        \\pub inline fn CALL(arg: var) @TypeOf(bar(arg)) {
+        \\pub inline fn CALL(arg: anytype) @TypeOf(bar(arg)) {
         \\    return bar(arg);
         \\}
     });
@@ -2683,7 +2683,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\#define FOO(bar) baz((void *)(baz))
         \\#define BAR (void*) a
     , &[_][]const u8{
-        \\pub inline fn FOO(bar: var) @TypeOf(baz((@import("std").meta.cast(?*c_void, baz)))) {
+        \\pub inline fn FOO(bar: anytype) @TypeOf(baz((@import("std").meta.cast(?*c_void, baz)))) {
         \\    return baz((@import("std").meta.cast(?*c_void, baz)));
         \\}
     ,
@@ -2713,11 +2713,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\#define MIN(a, b) ((b) < (a) ? (b) : (a))
         \\#define MAX(a, b) ((b) > (a) ? (b) : (a))
     , &[_][]const u8{
-        \\pub inline fn MIN(a: var, b: var) @TypeOf(if (b < a) b else a) {
+        \\pub inline fn MIN(a: anytype, b: anytype) @TypeOf(if (b < a) b else a) {
         \\    return if (b < a) b else a;
         \\}
     ,
-        \\pub inline fn MAX(a: var, b: var) @TypeOf(if (b > a) b else a) {
+        \\pub inline fn MAX(a: anytype, b: anytype) @TypeOf(if (b > a) b else a) {
         \\    return if (b > a) b else a;
         \\}
     });
@@ -2905,7 +2905,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\#define DefaultScreen(dpy) (((_XPrivDisplay)(dpy))->default_screen)
         \\
     , &[_][]const u8{
-        \\pub inline fn DefaultScreen(dpy: var) @TypeOf((@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen) {
+        \\pub inline fn DefaultScreen(dpy: anytype) @TypeOf((@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen) {
         \\    return (@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen;
         \\}
     });