Resolve argument types for builtin function calls

`@branchHint`, `@atomicLoad`, `@atomicRmw`, `@atomicStore`,
`@cmpxchgStrong`, `@cmpxchgWeak`, `@call`, `@export`, `@extern`,
`@reduce`, `@Type`

Author: FnControlOption

src/analysis.zig

@@ -5491,6 +5491,78 @@ pub fn resolveExpressionTypeFromAncestors(
                 const ty = try analyser.resolveTypeOfNode(.of(params[0], handle)) orelse return null;
                 return ty.instanceTypeVal(analyser);
             }
+
+            if (std.mem.eql(u8, call_name, "@branchHint")) {
+                if (params.len == 0) return null;
+                if (params[0] != node) return null;
+                return analyser.instanceStdBuiltinType("BranchHint");
+            }
+
+            if (std.mem.eql(u8, call_name, "@atomicLoad")) {
+                if (params.len <= 2) return null;
+                if (params[2] != node) return null;
+                return analyser.instanceStdBuiltinType("AtomicOrder");
+            }
+
+            if (std.mem.eql(u8, call_name, "@atomicRmw")) {
+                if (params.len > 2 and params[2] == node)
+                    return analyser.instanceStdBuiltinType("AtomicRmwOp");
+                if (params.len > 4 and params[4] == node)
+                    return analyser.instanceStdBuiltinType("AtomicOrder");
+                return null;
+            }
+
+            if (std.mem.eql(u8, call_name, "@atomicStore")) {
+                if (params.len <= 3) return null;
+                if (params[3] != node) return null;
+                return analyser.instanceStdBuiltinType("AtomicOrder");
+            }
+
+            if (std.mem.eql(u8, call_name, "@cmpxchgStrong")) {
+                if (params.len > 4 and params[4] == node)
+                    return analyser.instanceStdBuiltinType("AtomicOrder");
+                if (params.len > 5 and params[5] == node)
+                    return analyser.instanceStdBuiltinType("AtomicOrder");
+                return null;
+            }
+
+            if (std.mem.eql(u8, call_name, "@cmpxchgWeak")) {
+                if (params.len > 4 and params[4] == node)
+                    return analyser.instanceStdBuiltinType("AtomicOrder");
+                if (params.len > 5 and params[5] == node)
+                    return analyser.instanceStdBuiltinType("AtomicOrder");
+                return null;
+            }
+
+            if (std.mem.eql(u8, call_name, "@call")) {
+                if (params.len == 0) return null;
+                if (params[0] != node) return null;
+                return analyser.instanceStdBuiltinType("CallModifier");
+            }
+
+            if (std.mem.eql(u8, call_name, "@export")) {
+                if (params.len <= 1) return null;
+                if (params[1] != node) return null;
+                return analyser.instanceStdBuiltinType("ExportOptions");
+            }
+
+            if (std.mem.eql(u8, call_name, "@extern")) {
+                if (params.len <= 1) return null;
+                if (params[1] != node) return null;
+                return analyser.instanceStdBuiltinType("ExternOptions");
+            }
+
+            if (std.mem.eql(u8, call_name, "@reduce")) {
+                if (params.len == 0) return null;
+                if (params[0] != node) return null;
+                return analyser.instanceStdBuiltinType("ReduceOp");
+            }
+
+            if (std.mem.eql(u8, call_name, "@Type")) {
+                if (params.len == 0) return null;
+                if (params[0] != node) return null;
+                return analyser.instanceStdBuiltinType("Type");
+            }
         },
 
         .@"orelse" => {

tests/analysis/builtins.zig

@@ -134,3 +134,31 @@ comptime {
     // Use @compileLog to verify the expected type with the compiler
     // @compileLog(vector_builtin_13);
 }
+
+fn builtin_calls() void {
+    @branchHint(.none);
+    //          ^^^^^ (BranchHint)()
+    @atomicLoad(undefined, undefined, .unordered);
+    //                                ^^^^^^^^^^ (AtomicOrder)()
+    @atomicRmw(undefined, undefined, .Xchg, undefined, .unordered);
+    //                               ^^^^^ (AtomicRmwOp)()
+    //                                                 ^^^^^^^^^^ (AtomicOrder)()
+    @atomicStore(undefined, undefined, undefined, .unordered);
+    //                                            ^^^^^^^^^^ (AtomicOrder)()
+    @cmpxchgStrong(undefined, undefined, undefined, undefined, .unordered, .unordered);
+    //                                                         ^^^^^^^^^^ (AtomicOrder)()
+    //                                                                     ^^^^^^^^^^ (AtomicOrder)()
+    @cmpxchgWeak(undefined, undefined, undefined, undefined, .unordered, .unordered);
+    //                                                       ^^^^^^^^^^ (AtomicOrder)()
+    //                                                                   ^^^^^^^^^^ (AtomicOrder)()
+    @call(.always_inline, undefined, undefined);
+    //    ^^^^^^^^^^^^^^ (CallModifier)()
+    @export(undefined, .{ .name = undefined });
+    //                    ^^^^^ ([]const u8)()
+    @extern(undefined, .{ .name = undefined });
+    //                    ^^^^^ ([]const u8)()
+    @reduce(.And, undefined);
+    //      ^^^^ (ReduceOp)()
+    @Type(.type);
+    //    ^^^^^ (void)()
+}