* [gentoo-commits] repo/proj/guru:dev commit in: dev-zig/zls/, dev-zig/zls/files/
@ 2023-02-09 5:07 Eric Joldasov
0 siblings, 0 replies; 2+ messages in thread
From: Eric Joldasov @ 2023-02-09 5:07 UTC (permalink / raw
To: gentoo-commits
commit: d707e5e6c31743c78502cd5608f17752eac5f328
Author: Eric Joldasov <bratishkaerik <AT> getgoogleoff <DOT> me>
AuthorDate: Thu Feb 9 05:07:03 2023 +0000
Commit: Eric Joldasov <bratishkaerik <AT> getgoogleoff <DOT> me>
CommitDate: Thu Feb 9 05:07:03 2023 +0000
URL: https://gitweb.gentoo.org/repo/proj/guru.git/commit/?id=d707e5e6
dev-zig/zls: add 0.10.0
Signed-off-by: Eric Joldasov <bratishkaerik <AT> getgoogleoff.me>
dev-zig/zls/Manifest | 3 +
...0.0-add-builtin-data-for-new-zig-versions.patch | 3764 ++++++++++++++++++++
dev-zig/zls/zls-0.10.0.ebuild | 56 +
3 files changed, 3823 insertions(+)
diff --git a/dev-zig/zls/Manifest b/dev-zig/zls/Manifest
new file mode 100644
index 000000000..1bb0f6d7b
--- /dev/null
+++ b/dev-zig/zls/Manifest
@@ -0,0 +1,3 @@
+DIST known-folders-24845b0103e611c108d6bc334231c464e699742c.tar.gz 6618 BLAKE2B cdfe56329edcf50a07eea919b1a753ce965eeaa3c1d9e08289d74704809e489a7a674fb41c0fa16115a406512477cfa99953d434d44c52429c241df7e7bb4f1d SHA512 4ac156ad51793a733d8fd5a24936bd7b0bb8a527b9d19d9cb7d43c9ec7ac983f37dfc00fdfec23147964689201cdbee213e66b4af0917b0bb324b02e8a3a7151
+DIST tracy-f493d4aa8ba8141d9680473fad007d8a6348628e.tar.gz 5401470 BLAKE2B 8a027bfe82842d6d3caeddcf03499a3671a99f2210a40b434e9893a60da88775c19738230e8d55cb1de020fe9f0d7d414df76f36f4a55b04a0c41c8c0de8232b SHA512 e8a844ff015b4c7a261e3251be33deced4f4a29a8fc8254244c125b391266e7a38bdf8d988ff4aac10bd0ee5538fca1e274a0d91dcde08d0bd021006cb326e6f
+DIST zls-0.10.0.tar.gz 320226 BLAKE2B fc9c7c6e37d9347710520ddf0bc90b704ff6115210e044e68a973a2edefe024d14cf410ed0fe74400c1bed8b57f8316dc4298561f78de3abe112bc38df70404b SHA512 16a55ef0ecfac1bf43c4d917741db8389dc835cfdd9e78e9853180dad7218656c6a09b67b7185e7d87ccb2196a4deb457c3d476300eff01ce8c9bfab597576ad
diff --git a/dev-zig/zls/files/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch b/dev-zig/zls/files/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch
new file mode 100644
index 000000000..1810aef35
--- /dev/null
+++ b/dev-zig/zls/files/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch
@@ -0,0 +1,3764 @@
+From 95f21d0d23fa67c3c1688cfbfa53905ab1f6a7d5 Mon Sep 17 00:00:00 2001
+From: BratishkaErik <25210740+BratishkaErik@users.noreply.github.com>
+Date: Thu, 3 Nov 2022 02:24:51 +0600
+Subject: [PATCH] Add builtin data for 0.9.1 and 0.10.0 (#735)
+
+* Add builtin data for 0.9.1
+
+* Add builtin data for 0.10.0
+
+* Update builtin data for master
+---
+ src/data/0.10.0.zig | 1805 +++++++++++++++++++++++++++++++++++++++++++
+ src/data/0.9.1.zig | 1777 ++++++++++++++++++++++++++++++++++++++++++
+ src/data/data.zig | 2 +
+ src/data/master.zig | 40 +-
+ src/shared.zig | 2 +
+ 5 files changed, 3609 insertions(+), 17 deletions(-)
+ create mode 100644 src/data/0.10.0.zig
+ create mode 100644 src/data/0.9.1.zig
+
+diff --git a/src/data/0.10.0.zig b/src/data/0.10.0.zig
+new file mode 100644
+index 00000000..82f7a25a
+--- /dev/null
++++ b/src/data/0.10.0.zig
+@@ -0,0 +1,1805 @@
++const Builtin = struct {
++ name: []const u8,
++ signature: []const u8,
++ snippet: []const u8,
++ documentation: []const u8,
++ arguments: []const []const u8,
++};
++
++pub const builtins = [_]Builtin{
++ .{
++ .name = "@addrSpaceCast",
++ .signature = "@addrSpaceCast(comptime addrspace: std.builtin.AddressSpace, ptr: anytype) anytype",
++ .snippet = "@addrSpaceCast(${1:comptime addrspace: std.builtin.AddressSpace}, ${2:ptr: anytype})",
++ .documentation =
++ \\Converts a pointer from one address space to another. Depending on the current target and address spaces, this cast may be a no-op, a complex operation, or illegal. If the cast is legal, then the resulting pointer points to the same memory location as the pointer operand. It is always valid to cast a pointer between the same address spaces.
++ ,
++ .arguments = &.{
++ "comptime addrspace: std.builtin.AddressSpace",
++ "ptr: anytype",
++ },
++ },
++ .{
++ .name = "@addWithOverflow",
++ .signature = "@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
++ .snippet = "@addWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
++ .documentation =
++ \\Performs `result.* = a + b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "a: T",
++ "b: T",
++ "result: *T",
++ },
++ },
++ .{
++ .name = "@alignCast",
++ .signature = "@alignCast(comptime alignment: u29, ptr: anytype) anytype",
++ .snippet = "@alignCast(${1:comptime alignment: u29}, ${2:ptr: anytype})",
++ .documentation =
++ \\`ptr` can be `*T`, `?*T`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value.
++ \\
++ \\A [pointer alignment safety check](https://ziglang.org/documentation/0.10.0/#Incorrect-Pointer-Alignment) is added to the generated code to make sure the pointer is aligned as promised.
++ ,
++ .arguments = &.{
++ "comptime alignment: u29",
++ "ptr: anytype",
++ },
++ },
++ .{
++ .name = "@alignOf",
++ .signature = "@alignOf(comptime T: type) comptime_int",
++ .snippet = "@alignOf(${1:comptime T: type})",
++ .documentation =
++ \\This function returns the number of bytes that this type should be aligned to for the current target to match the C ABI. When the child type of a pointer has this alignment, the alignment can be omitted from the type.
++ \\
++ \\```zig
++ \\const assert = @import("std").debug.assert;
++ \\comptime {
++ \\ assert(*u32 == *align(@alignOf(u32)) u32);
++ \\}
++ \\```
++ \\
++ \\The result is a target-specific compile time constant. It is guaranteed to be less than or equal to [@sizeOf(T)](https://ziglang.org/documentation/0.10.0/#@sizeOf).
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ },
++ },
++ .{
++ .name = "@as",
++ .signature = "@as(comptime T: type, expression) T",
++ .snippet = "@as(${1:comptime T: type}, ${2:expression})",
++ .documentation =
++ \\Performs [Type Coercion](https://ziglang.org/documentation/0.10.0/#Type-Coercion). This cast is allowed when the conversion is unambiguous and safe, and is the preferred way to convert between types, whenever possible.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "expression",
++ },
++ },
++ .{
++ .name = "@asyncCall",
++ .signature = "@asyncCall(frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8, result_ptr, function_ptr, args: anytype) anyframe->T",
++ .snippet = "@asyncCall(${1:frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8}, ${2:result_ptr}, ${3:function_ptr}, ${4:args: anytype})",
++ .documentation =
++ \\`@asyncCall` performs an `async` call on a function pointer, which may or may not be an [async function](https://ziglang.org/documentation/0.10.0/#Async-Functions).
++ \\
++ \\The provided `frame_buffer` must be large enough to fit the entire function frame. This size can be determined with [@frameSize](https://ziglang.org/documentation/0.10.0/#frameSize). To provide a too-small buffer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
++ \\
++ \\`result_ptr` is optional ([null](https://ziglang.org/documentation/0.10.0/#null) may be provided). If provided, the function call will write its result directly to the result pointer, which will be available to read after [await](https://ziglang.org/documentation/0.10.0/#Async-and-Await) completes. Any result location provided to `await` will copy the result from `result_ptr`.</p> {#code_begin|test|async_struct_field_fn_pointer#} {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; test "async fn pointer in a struct field" { var data: i32 = 1; const Foo = struct { bar: fn (*i32) callconv(.Async) void, }; var foo = Foo{ .bar = func }; var bytes: [64]u8 align(@alignOf(@Frame(func))) = undefined; const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); try expect(data == 2); resume f; try expect(data == 4); } fn func(y: *i32) void { defer y.* += 2; y.* += 1; suspend {} }`
++ ,
++ .arguments = &.{
++ "frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8",
++ "result_ptr",
++ "function_ptr",
++ "args: anytype",
++ },
++ },
++ .{
++ .name = "@atomicLoad",
++ .signature = "@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: builtin.AtomicOrder) T",
++ .snippet = "@atomicLoad(${1:comptime T: type}, ${2:ptr: *const T}, ${3:comptime ordering: builtin.AtomicOrder})",
++ .documentation =
++ \\This builtin function atomically dereferences a pointer and returns the value.
++ \\
++ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "ptr: *const T",
++ "comptime ordering: builtin.AtomicOrder",
++ },
++ },
++ .{
++ .name = "@atomicRmw",
++ .signature = "@atomicRmw(comptime T: type, ptr: *T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) T",
++ .snippet = "@atomicRmw(${1:comptime T: type}, ${2:ptr: *T}, ${3:comptime op: builtin.AtomicRmwOp}, ${4:operand: T}, ${5:comptime ordering: builtin.AtomicOrder})",
++ .documentation =
++ \\This builtin function atomically modifies memory and then returns the previous value.
++ \\
++ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
++ \\
++ \\Supported operations:
++ \\ - `.Xchg` - stores the operand unmodified. Supports enums, integers and floats.
++ \\ - `.Add` - for integers, twos complement wraparound addition. Also supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats).
++ \\ - `.Sub` - for integers, twos complement wraparound subtraction. Also supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats).
++ \\ - `.And` - bitwise and
++ \\ - `.Nand` - bitwise nand
++ \\ - `.Or` - bitwise or
++ \\ - `.Xor` - bitwise xor
++ \\ - `.Max` - stores the operand if it is larger. Supports integers and floats.
++ \\ - `.Min` - stores the operand if it is smaller. Supports integers and floats.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "ptr: *T",
++ "comptime op: builtin.AtomicRmwOp",
++ "operand: T",
++ "comptime ordering: builtin.AtomicOrder",
++ },
++ },
++ .{
++ .name = "@atomicStore",
++ .signature = "@atomicStore(comptime T: type, ptr: *T, value: T, comptime ordering: builtin.AtomicOrder) void",
++ .snippet = "@atomicStore(${1:comptime T: type}, ${2:ptr: *T}, ${3:value: T}, ${4:comptime ordering: builtin.AtomicOrder})",
++ .documentation =
++ \\This builtin function atomically stores a value.
++ \\
++ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "ptr: *T",
++ "value: T",
++ "comptime ordering: builtin.AtomicOrder",
++ },
++ },
++ .{
++ .name = "@bitCast",
++ .signature = "@bitCast(comptime DestType: type, value: anytype) DestType",
++ .snippet = "@bitCast(${1:comptime DestType: type}, ${2:value: anytype})",
++ .documentation =
++ \\Converts a value of one type to another type.
++ \\
++ \\Asserts that `@sizeOf(@TypeOf(value)) == @sizeOf(DestType)`.
++ \\
++ \\Asserts that `@typeInfo(DestType) != .Pointer`. Use `@ptrCast` or `@intToPtr` if you need this.
++ \\
++ \\Can be used for these things for example:
++ \\ - Convert `f32` to `u32` bits
++ \\ - Convert `i32` to `u32` preserving twos complement
++ \\
++ \\Works at compile-time if `value` is known at compile time. It's a compile error to bitcast a value of undefined layout; this means that, besides the restriction from types which possess dedicated casting builtins (enums, pointers, error sets), bare structs, error unions, slices, optionals, and any other type without a well-defined memory layout, also cannot be used in this operation.
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@bitOffsetOf",
++ .signature = "@bitOffsetOf(comptime T: type, comptime field_name: []const u8) comptime_int",
++ .snippet = "@bitOffsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})",
++ .documentation =
++ \\Returns the bit offset of a field relative to its containing struct.
++ \\
++ \\For non [packed structs](https://ziglang.org/documentation/0.10.0/#packed-struct), this will always be divisible by `8`. For packed structs, non-byte-aligned fields will share a byte offset, but they will have different bit offsets.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "comptime field_name: []const u8",
++ },
++ },
++ .{
++ .name = "@boolToInt",
++ .signature = "@boolToInt(value: bool) u1",
++ .snippet = "@boolToInt(${1:value: bool})",
++ .documentation =
++ \\Converts `true` to `@as(u1, 1)` and `false` to `@as(u1, 0)`.
++ \\
++ \\If the value is known at compile-time, the return type is `comptime_int` instead of `u1`.
++ ,
++ .arguments = &.{
++ "value: bool",
++ },
++ },
++ .{
++ .name = "@bitSizeOf",
++ .signature = "@bitSizeOf(comptime T: type) comptime_int",
++ .snippet = "@bitSizeOf(${1:comptime T: type})",
++ .documentation =
++ \\This function returns the number of bits it takes to store `T` in memory if the type were a field in a packed struct/union. The result is a target-specific compile time constant.
++ \\
++ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ },
++ },
++ .{
++ .name = "@breakpoint",
++ .signature = "@breakpoint()",
++ .snippet = "@breakpoint()",
++ .documentation =
++ \\This function inserts a platform-specific debug trap instruction which causes debuggers to break there.
++ \\
++ \\This function is only valid within function scope.
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@mulAdd",
++ .signature = "@mulAdd(comptime T: type, a: T, b: T, c: T) T",
++ .snippet = "@mulAdd(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:c: T})",
++ .documentation =
++ \\Fused multiply-add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "a: T",
++ "b: T",
++ "c: T",
++ },
++ },
++ .{
++ .name = "@byteSwap",
++ .signature = "@byteSwap(operand: anytype) T",
++ .snippet = "@byteSwap(${1:operand: anytype})",
++ .documentation =
++ \\`@TypeOf(operand)` must be an integer type or an integer vector type with bit count evenly divisible by 8.
++ \\
++ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors).
++ \\
++ \\Swaps the byte order of the integer. This converts a big endian integer to a little endian integer, and converts a little endian integer to a big endian integer.
++ \\
++ \\Note that for the purposes of memory layout with respect to endianness, the integer type should be related to the number of bytes reported by [@sizeOf](https://ziglang.org/documentation/0.10.0/#sizeOf) bytes. This is demonstrated with `u24`. `@sizeOf(u24) == 4`, which means that a `u24` stored in memory takes 4 bytes, and those 4 bytes are what are swapped on a little vs big endian system. On the other hand, if `T` is specified to be `u24`, then only 3 bytes are reversed.
++ ,
++ .arguments = &.{
++ "operand: anytype",
++ },
++ },
++ .{
++ .name = "@bitReverse",
++ .signature = "@bitReverse(integer: anytype) T",
++ .snippet = "@bitReverse(${1:integer: anytype})",
++ .documentation =
++ \\`@TypeOf(anytype)` accepts any integer type or integer vector type.
++ \\
++ \\Reverses the bitpattern of an integer value, including the sign bit if applicable.
++ \\
++ \\For example 0b10110110 (`u8 = 182`, `i8 = -74`) becomes 0b01101101 (`u8 = 109`, `i8 = 109`).
++ ,
++ .arguments = &.{
++ "integer: anytype",
++ },
++ },
++ .{
++ .name = "@offsetOf",
++ .signature = "@offsetOf(comptime T: type, comptime field_name: []const u8) comptime_int",
++ .snippet = "@offsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})",
++ .documentation =
++ \\Returns the byte offset of a field relative to its containing struct.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "comptime field_name: []const u8",
++ },
++ },
++ .{
++ .name = "@call",
++ .signature = "@call(options: std.builtin.CallOptions, function: anytype, args: anytype) anytype",
++ .snippet = "@call(${1:options: std.builtin.CallOptions}, ${2:function: anytype}, ${3:args: anytype})",
++ .documentation =
++ \\Calls a function, in the same way that invoking an expression with parentheses does:
++ \\
++ \\```zig
++ \\const expect = @import("std").testing.expect;
++ \\
++ \\test "noinline function call" {
++ \\ try expect(@call(.{}, add, .{3, 9}) == 12);
++ \\}
++ \\
++ \\fn add(a: i32, b: i32) i32 {
++ \\ return a + b;
++ \\}
++ \\```
++ \\
++ \\`@call` allows more flexibility than normal function call syntax does. The `CallOptions` struct is reproduced here:</p> {#syntax_block|zig|builtin.CallOptions struct#} pub const CallOptions = struct { modifier: Modifier = .auto, /// Only valid when `Modifier` is `Modifier.async_kw`. stack: ?[]align(std.Target.stack_align) u8 = null, pub const Modifier = enum { /// Equivalent to function call syntax. auto, /// Equivalent to async keyword used with function call syntax. async_kw, /// Prevents tail call optimization. This guarantees that the return /// address will point to the callsite, as opposed to the callsite's /// callsite. If the call is otherwise required to be tail-called /// or inlined, a compile error is emitted instead. never_tail, /// Guarantees that the call will not be inlined. If the call is /// otherwise required to be inlined, a compile error is emitted instead. never_inline, /// Asserts that the function call will not suspend. This allows a /// non-async f
unction to call an async function. no_async, /// Guarantees that the call will be generated with tail call optimization. /// If this is not possible, a compile error is emitted instead. always_tail, /// Guarantees that the call will inlined at the callsite. /// If this is not possible, a compile error is emitted instead. always_inline, /// Evaluates the call at compile-time. If the call cannot be completed at /// compile-time, a compile error is emitted instead. compile_time, }; }; {#end_syntax_block#}
++ ,
++ .arguments = &.{
++ "options: std.builtin.CallOptions",
++ "function: anytype",
++ "args: anytype",
++ },
++ },
++ .{
++ .name = "@cDefine",
++ .signature = "@cDefine(comptime name: []u8, value)",
++ .snippet = "@cDefine(${1:comptime name: []u8}, ${2:value})",
++ .documentation =
++ \\This function can only occur inside `@cImport`.
++ \\
++ \\This appends `#define $name $value` to the `@cImport` temporary buffer.
++ \\
++ \\To define without a value, like this:`#define _GNU_SOURCE`
++ \\
++ \\Use the void value, like this:
++ \\
++ \\```zig
++ \\@cDefine("_GNU_SOURCE", {})
++ \\```
++ ,
++ .arguments = &.{
++ "comptime name: []u8",
++ "value",
++ },
++ },
++ .{
++ .name = "@cImport",
++ .signature = "@cImport(expression) type",
++ .snippet = "@cImport(${1:expression})",
++ .documentation =
++ \\This function parses C code and imports the functions, types, variables, and compatible macro definitions into a new empty struct type, and then returns that type.
++ \\
++ \\`expression` is interpreted at compile time. The builtin functions `@cInclude`, `@cDefine`, and `@cUndef` work within this expression, appending to a temporary buffer which is then parsed as C code.
++ \\
++ \\Usually you should only have one `@cImport` in your entire application, because it saves the compiler from invoking clang multiple times, and prevents inline functions from being duplicated.
++ \\
++ \\Reasons for having multiple `@cImport` expressions would be:
++ \\ - To avoid a symbol collision, for example if foo.h and bar.h both `#define CONNECTION_COUNT`
++ \\ - To analyze the C code with different preprocessor defines
++ ,
++ .arguments = &.{
++ "expression",
++ },
++ },
++ .{
++ .name = "@cInclude",
++ .signature = "@cInclude(comptime path: []u8)",
++ .snippet = "@cInclude(${1:comptime path: []u8})",
++ .documentation =
++ \\This function can only occur inside `@cImport`.
++ \\
++ \\This appends `#include <$path>\n` to the `c_import` temporary buffer.
++ ,
++ .arguments = &.{
++ "comptime path: []u8",
++ },
++ },
++ .{
++ .name = "@clz",
++ .signature = "@clz(operand: anytype)",
++ .snippet = "@clz(${1:operand: anytype})",
++ .documentation =
++ \\`@TypeOf(operand)` must be an integer type or an integer vector type.
++ \\
++ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors).
++ \\
++ \\This function counts the number of most-significant (leading in a big-Endian sense) zeroes in an integer.
++ \\
++ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
++ \\
++ \\If `operand` is zero, `@clz` returns the bit width of integer type `T`.
++ ,
++ .arguments = &.{
++ "operand: anytype",
++ },
++ },
++ .{
++ .name = "@cmpxchgStrong",
++ .signature = "@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T",
++ .snippet = "@cmpxchgStrong(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})",
++ .documentation =
++ \\This function performs a strong atomic compare exchange operation. It's the equivalent of this code, except atomic:
++ \\
++ \\```zig
++ \\fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T {
++ \\ const old_value = ptr.*;
++ \\ if (old_value == expected_value) {
++ \\ ptr.* = new_value;
++ \\ return null;
++ \\ } else {
++ \\ return old_value;
++ \\ }
++ \\}
++ \\```
++ \\
++ \\If you are using cmpxchg in a loop, [@cmpxchgWeak](https://ziglang.org/documentation/0.10.0/#cmpxchgWeak) is the better choice, because it can be implemented more efficiently in machine instructions.
++ \\
++ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
++ \\
++ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).`
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "ptr: *T",
++ "expected_value: T",
++ "new_value: T",
++ "success_order: AtomicOrder",
++ "fail_order: AtomicOrder",
++ },
++ },
++ .{
++ .name = "@cmpxchgWeak",
++ .signature = "@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T",
++ .snippet = "@cmpxchgWeak(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})",
++ .documentation =
++ \\This function performs a weak atomic compare exchange operation. It's the equivalent of this code, except atomic:</p> {#syntax_block|zig|cmpxchgWeakButNotAtomic#} fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T { const old_value = ptr.*; if (old_value == expected_value and usuallyTrueButSometimesFalse()) { ptr.* = new_value; return null; } else { return old_value; } } {#end_syntax_block#}
++ \\
++ \\If you are using cmpxchg in a loop, the sporadic failure will be no problem, and `cmpxchgWeak` is the better choice, because it can be implemented more efficiently in machine instructions. However if you need a stronger guarantee, use [@cmpxchgStrong](https://ziglang.org/documentation/0.10.0/#cmpxchgStrong).
++ \\
++ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
++ \\
++ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).`
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "ptr: *T",
++ "expected_value: T",
++ "new_value: T",
++ "success_order: AtomicOrder",
++ "fail_order: AtomicOrder",
++ },
++ },
++ .{
++ .name = "@compileError",
++ .signature = "@compileError(comptime msg: []u8)",
++ .snippet = "@compileError(${1:comptime msg: []u8})",
++ .documentation =
++ \\This function, when semantically analyzed, causes a compile error with the message `msg`.
++ \\
++ \\There are several ways that code avoids being semantically checked, such as using `if` or `switch` with compile time constants, and `comptime` functions.
++ ,
++ .arguments = &.{
++ "comptime msg: []u8",
++ },
++ },
++ .{
++ .name = "@compileLog",
++ .signature = "@compileLog(args: ...)",
++ .snippet = "@compileLog(${1:args: ...})",
++ .documentation =
++ \\This function prints the arguments passed to it at compile-time.
++ \\
++ \\To prevent accidentally leaving compile log statements in a codebase, a compilation error is added to the build, pointing to the compile log statement. This error prevents code from being generated, but does not otherwise interfere with analysis.
++ \\
++ \\This function can be used to do "printf debugging" on compile-time executing code.
++ \\
++ \\```zig
++ \\const print = @import("std").debug.print;
++ \\
++ \\const num1 = blk: {
++ \\ var val1: i32 = 99;
++ \\ @compileLog("comptime val1 = ", val1);
++ \\ val1 = val1 + 1;
++ \\ break :blk val1;
++ \\};
++ \\
++ \\test "main" {
++ \\ @compileLog("comptime in main");
++ \\
++ \\ print("Runtime in main, num1 = {}.\n", .{num1});
++ \\}
++ \\```
++ \\
++ \\If all `@compileLog` calls are removed or not encountered by analysis, the program compiles successfully and the generated executable prints:</p> {#code_begin|test|without_compileLog#} const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; val1 = val1 + 1; break :blk val1; }; test "main" { print("Runtime in main, num1 = {}.\n", .{num1}); }`
++ ,
++ .arguments = &.{
++ "args: ...",
++ },
++ },
++ .{
++ .name = "@ctz",
++ .signature = "@ctz(operand: anytype)",
++ .snippet = "@ctz(${1:operand: anytype})",
++ .documentation =
++ \\`@TypeOf(operand)` must be an integer type or an integer vector type.
++ \\
++ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors).
++ \\
++ \\This function counts the number of least-significant (trailing in a big-Endian sense) zeroes in an integer.
++ \\
++ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
++ \\
++ \\If `operand` is zero, `@ctz` returns the bit width of integer type `T`.
++ ,
++ .arguments = &.{
++ "operand: anytype",
++ },
++ },
++ .{
++ .name = "@cUndef",
++ .signature = "@cUndef(comptime name: []u8)",
++ .snippet = "@cUndef(${1:comptime name: []u8})",
++ .documentation =
++ \\This function can only occur inside `@cImport`.
++ \\
++ \\This appends `#undef $name` to the `@cImport` temporary buffer.
++ ,
++ .arguments = &.{
++ "comptime name: []u8",
++ },
++ },
++ .{
++ .name = "@divExact",
++ .signature = "@divExact(numerator: T, denominator: T) T",
++ .snippet = "@divExact(${1:numerator: T}, ${2:denominator: T})",
++ .documentation =
++ \\Exact division. Caller guarantees `denominator != 0` and `@divTrunc(numerator, denominator) * denominator == numerator`.
++ \\ - `@divExact(6, 3) == 2`
++ \\ - `@divExact(a, b) * b == a`
++ \\
++ \\For a function that returns a possible error code, use `@import("std").math.divExact`.
++ ,
++ .arguments = &.{
++ "numerator: T",
++ "denominator: T",
++ },
++ },
++ .{
++ .name = "@divFloor",
++ .signature = "@divFloor(numerator: T, denominator: T) T",
++ .snippet = "@divFloor(${1:numerator: T}, ${2:denominator: T})",
++ .documentation =
++ \\Floored division. Rounds toward negative infinity. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`.
++ \\ - `@divFloor(-5, 3) == -2`
++ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a`
++ \\
++ \\For a function that returns a possible error code, use `@import("std").math.divFloor`.
++ ,
++ .arguments = &.{
++ "numerator: T",
++ "denominator: T",
++ },
++ },
++ .{
++ .name = "@divTrunc",
++ .signature = "@divTrunc(numerator: T, denominator: T) T",
++ .snippet = "@divTrunc(${1:numerator: T}, ${2:denominator: T})",
++ .documentation =
++ \\Truncated division. Rounds toward zero. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`.
++ \\ - `@divTrunc(-5, 3) == -1`
++ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a`
++ \\
++ \\For a function that returns a possible error code, use `@import("std").math.divTrunc`.
++ ,
++ .arguments = &.{
++ "numerator: T",
++ "denominator: T",
++ },
++ },
++ .{
++ .name = "@embedFile",
++ .signature = "@embedFile(comptime path: []const u8) *const [N:0]u8",
++ .snippet = "@embedFile(${1:comptime path: []const u8})",
++ .documentation =
++ \\This function returns a compile time constant pointer to null-terminated, fixed-size array with length equal to the byte count of the file given by `path`. The contents of the array are the contents of the file. This is equivalent to a [string literal](https://ziglang.org/documentation/0.10.0/#String-Literals-and-Unicode-Code-Point-Literals) with the file contents.
++ \\
++ \\`path` is absolute or relative to the current file, just like `@import`.
++ ,
++ .arguments = &.{
++ "comptime path: []const u8",
++ },
++ },
++ .{
++ .name = "@enumToInt",
++ .signature = "@enumToInt(enum_or_tagged_union: anytype) anytype",
++ .snippet = "@enumToInt(${1:enum_or_tagged_union: anytype})",
++ .documentation =
++ \\Converts an enumeration value into its integer tag type. When a tagged union is passed, the tag value is used as the enumeration value.
++ \\
++ \\If there is only one possible enum value, the result is a `comptime_int` known at [comptime](https://ziglang.org/documentation/0.10.0/#comptime).
++ ,
++ .arguments = &.{
++ "enum_or_tagged_union: anytype",
++ },
++ },
++ .{
++ .name = "@errorName",
++ .signature = "@errorName(err: anyerror) [:0]const u8",
++ .snippet = "@errorName(${1:err: anyerror})",
++ .documentation =
++ \\This function returns the string representation of an error. The string representation of `error.OutOfMem` is `"OutOfMem"`.
++ \\
++ \\If there are no calls to `@errorName` in an entire application, or all calls have a compile-time known value for `err`, then no error name table will be generated.
++ ,
++ .arguments = &.{
++ "err: anyerror",
++ },
++ },
++ .{
++ .name = "@errorReturnTrace",
++ .signature = "@errorReturnTrace() ?*builtin.StackTrace",
++ .snippet = "@errorReturnTrace()",
++ .documentation =
++ \\If the binary is built with error return tracing, and this function is invoked in a function that calls a function with an error or error union return type, returns a stack trace object. Otherwise returns [null](https://ziglang.org/documentation/0.10.0/#null).
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@errorToInt",
++ .signature = "@errorToInt(err: anytype) std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)",
++ .snippet = "@errorToInt(${1:err: anytype})",
++ .documentation =
++ \\Supports the following types:
++ \\ - [The Global Error Set](https://ziglang.org/documentation/0.10.0/#The-Global-Error-Set)
++ \\ - [Error Set Type](https://ziglang.org/documentation/0.10.0/#Error-Set-Type)
++ \\ - [Error Union Type](https://ziglang.org/documentation/0.10.0/#Error-Union-Type)
++ \\
++ \\Converts an error to the integer representation of an error.
++ \\
++ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes.
++ ,
++ .arguments = &.{
++ "err: anytype",
++ },
++ },
++ .{
++ .name = "@errSetCast",
++ .signature = "@errSetCast(comptime T: DestType, value: anytype) DestType",
++ .snippet = "@errSetCast(${1:comptime T: DestType}, ${2:value: anytype})",
++ .documentation =
++ \\Converts an error value from one error set to another error set. Attempting to convert an error which is not in the destination error set results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "comptime T: DestType",
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@export",
++ .signature = "@export(declaration, comptime options: std.builtin.ExportOptions) void",
++ .snippet = "@export(${1:declaration}, ${2:comptime options: std.builtin.ExportOptions})",
++ .documentation =
++ \\Creates a symbol in the output object file.
++ \\
++ \\`declaration` must be one of two things:
++ \\ - An identifier (`x`) identifying a [function](https://ziglang.org/documentation/0.10.0/#Functions) or a [variable](https://ziglang.org/documentation/0.10.0/#Container-Level-Variables).
++ \\ - Field access (`x.y`) looking up a [function](https://ziglang.org/documentation/0.10.0/#Functions) or a [variable](https://ziglang.org/documentation/0.10.0/#Container-Level-Variables).
++ \\
++ \\This builtin can be called from a [comptime](https://ziglang.org/documentation/0.10.0/#comptime) block to conditionally export symbols. When `declaration` is a function with the C calling convention and `options.linkage` is `Strong`, this is equivalent to the `export` keyword used on a function:
++ \\
++ \\```zig
++ \\comptime {
++ \\ @export(internalName, .{ .name = "foo", .linkage = .Strong });
++ \\}
++ \\
++ \\fn internalName() callconv(.C) void {}
++ \\```
++ \\
++ \\This is equivalent to:
++ \\
++ \\```zig
++ \\export fn foo() void {}
++ \\```
++ \\
++ \\Note that even when using `export`, the `@"foo"` syntax for [identifiers](https://ziglang.org/documentation/0.10.0/#Identifiers) can be used to choose any string for the symbol name:
++ \\
++ \\```zig
++ \\export fn @"A function name that is a complete sentence."() void {}
++ \\```
++ \\
++ \\When looking at the resulting object, you can see the symbol is used verbatim:
++ \\
++ \\```zig
++ \\00000000000001f0 T A function name that is a complete sentence.
++ \\```
++ ,
++ .arguments = &.{
++ "declaration",
++ "comptime options: std.builtin.ExportOptions",
++ },
++ },
++ .{
++ .name = "@extern",
++ .signature = "@extern(T: type, comptime options: std.builtin.ExternOptions) *T",
++ .snippet = "@extern(${1:T: type}, ${2:comptime options: std.builtin.ExternOptions})",
++ .documentation =
++ \\Creates a reference to an external symbol in the output object file.
++ ,
++ .arguments = &.{
++ "T: type",
++ "comptime options: std.builtin.ExternOptions",
++ },
++ },
++ .{
++ .name = "@fence",
++ .signature = "@fence(order: AtomicOrder)",
++ .snippet = "@fence(${1:order: AtomicOrder})",
++ .documentation =
++ \\The `fence` function is used to introduce happens-before edges between operations.
++ \\
++ \\`AtomicOrder` can be found with `@import("std").builtin.AtomicOrder`.
++ ,
++ .arguments = &.{
++ "order: AtomicOrder",
++ },
++ },
++ .{
++ .name = "@field",
++ .signature = "@field(lhs: anytype, comptime field_name: []const u8) (field)",
++ .snippet = "@field(${1:lhs: anytype}, ${2:comptime field_name: []const u8})",
++ .documentation =
++ \\Performs field access by a compile-time string. Works on both fields and declarations.</p> {#code_begin|test|field_decl_access_by_string#} const std = @import("std"); const Point = struct { x: u32, y: u32, pub var z: u32 = 1; }; test "field access by string" { const expect = std.testing.expect; var p = Point{ .x = 0, .y = 0 }; @field(p, "x") = 4; @field(p, "y") = @field(p, "x") + 1; try expect(@field(p, "x") == 4); try expect(@field(p, "y") == 5); } test "decl access by string" { const expect = std.testing.expect; try expect(@field(Point, "z") == 1); @field(Point, "z") = 2; try expect(@field(Point, "z") == 2); }`
++ ,
++ .arguments = &.{
++ "lhs: anytype",
++ "comptime field_name: []const u8",
++ },
++ },
++ .{
++ .name = "@fieldParentPtr",
++ .signature = "@fieldParentPtr(comptime ParentType: type, comptime field_name: []const u8, field_ptr: *T) *ParentType",
++ .snippet = "@fieldParentPtr(${1:comptime ParentType: type}, ${2:comptime field_name: []const u8}, ${3:field_ptr: *T})",
++ .documentation =
++ \\Given a pointer to a field, returns the base pointer of a struct.
++ ,
++ .arguments = &.{
++ "comptime ParentType: type",
++ "comptime field_name: []const u8",
++ "field_ptr: *T",
++ },
++ },
++ .{
++ .name = "@floatCast",
++ .signature = "@floatCast(comptime DestType: type, value: anytype) DestType",
++ .snippet = "@floatCast(${1:comptime DestType: type}, ${2:value: anytype})",
++ .documentation =
++ \\Convert from one float type to another. This cast is safe, but may cause the numeric value to lose precision.
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@floatToInt",
++ .signature = "@floatToInt(comptime DestType: type, float: anytype) DestType",
++ .snippet = "@floatToInt(${1:comptime DestType: type}, ${2:float: anytype})",
++ .documentation =
++ \\Converts the integer part of a floating point number to the destination type.
++ \\
++ \\If the integer part of the floating point number cannot fit in the destination type, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "float: anytype",
++ },
++ },
++ .{
++ .name = "@frame",
++ .signature = "@frame() *@Frame(func)",
++ .snippet = "@frame()",
++ .documentation =
++ \\This function returns a pointer to the frame for a given function. This type can be [coerced](https://ziglang.org/documentation/0.10.0/#Type-Coercion) to `anyframe->T` and to `anyframe`, where `T` is the return type of the function in scope.
++ \\
++ \\This function does not mark a suspension point, but it does cause the function in scope to become an [async function](https://ziglang.org/documentation/0.10.0/#Async-Functions).
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@Frame",
++ .signature = "@Frame(func: anytype) type",
++ .snippet = "@Frame(${1:func: anytype})",
++ .documentation =
++ \\This function returns the frame type of a function. This works for [Async Functions](https://ziglang.org/documentation/0.10.0/#Async-Functions) as well as any function without a specific calling convention.
++ \\
++ \\This type is suitable to be used as the return type of [async](https://ziglang.org/documentation/0.10.0/#Async-and-Await) which allows one to, for example, heap-allocate an async function frame:</p> {#code_begin|test|heap_allocated_frame#} {#backend_stage1#} const std = @import("std"); test "heap allocated frame" { const frame = try std.heap.page_allocator.create(@Frame(func)); frame.* = async func(); } fn func() void { suspend {} }`
++ ,
++ .arguments = &.{
++ "func: anytype",
++ },
++ },
++ .{
++ .name = "@frameAddress",
++ .signature = "@frameAddress() usize",
++ .snippet = "@frameAddress()",
++ .documentation =
++ \\This function returns the base pointer of the current stack frame.
++ \\
++ \\The implications of this are target-specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations.
++ \\
++ \\This function is only valid within function scope.
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@frameSize",
++ .signature = "@frameSize(func: anytype) usize",
++ .snippet = "@frameSize(${1:func: anytype})",
++ .documentation =
++ \\This is the same as `@sizeOf(@Frame(func))`, where `func` may be runtime-known.
++ \\
++ \\This function is typically used in conjunction with [@asyncCall](https://ziglang.org/documentation/0.10.0/#asyncCall).
++ ,
++ .arguments = &.{
++ "func: anytype",
++ },
++ },
++ .{
++ .name = "@hasDecl",
++ .signature = "@hasDecl(comptime Container: type, comptime name: []const u8) bool",
++ .snippet = "@hasDecl(${1:comptime Container: type}, ${2:comptime name: []const u8})",
++ .documentation =
++ \\Returns whether or not a [struct](https://ziglang.org/documentation/0.10.0/#struct), [enum](https://ziglang.org/documentation/0.10.0/#enum), or [union](https://ziglang.org/documentation/0.10.0/#union) has a declaration matching `name`.</p> {#code_begin|test|hasDecl#} const std = @import("std"); const expect = std.testing.expect; const Foo = struct { nope: i32, pub var blah = "xxx"; const hi = 1; }; test "@hasDecl" { try expect(@hasDecl(Foo, "blah")); // Even though `hi` is private, @hasDecl returns true because this test is // in the same file scope as Foo. It would return false if Foo was declared // in a different file. try expect(@hasDecl(Foo, "hi")); // @hasDecl is for declarations; not fields. try expect(!@hasDecl(Foo, "nope")); try expect(!@hasDecl(Foo, "nope1234")); }`
++ ,
++ .arguments = &.{
++ "comptime Container: type",
++ "comptime name: []const u8",
++ },
++ },
++ .{
++ .name = "@hasField",
++ .signature = "@hasField(comptime Container: type, comptime name: []const u8) bool",
++ .snippet = "@hasField(${1:comptime Container: type}, ${2:comptime name: []const u8})",
++ .documentation =
++ \\Returns whether the field name of a struct, union, or enum exists.
++ \\
++ \\The result is a compile time constant.
++ \\
++ \\It does not include functions, variables, or constants.
++ ,
++ .arguments = &.{
++ "comptime Container: type",
++ "comptime name: []const u8",
++ },
++ },
++ .{
++ .name = "@import",
++ .signature = "@import(comptime path: []u8) type",
++ .snippet = "@import(${1:comptime path: []u8})",
++ .documentation =
++ \\This function finds a zig file corresponding to `path` and adds it to the build, if it is not already added.
++ \\
++ \\Zig source files are implicitly structs, with a name equal to the file's basename with the extension truncated. `@import` returns the struct type corresponding to the file.
++ \\
++ \\Declarations which have the `pub` keyword may be referenced from a different source file than the one they are declared in.
++ \\
++ \\`path` can be a relative path or it can be the name of a package. If it is a relative path, it is relative to the file that contains the `@import` function call.
++ \\
++ \\The following packages are always available:
++ \\ - `@import("std")` - Zig Standard Library
++ \\ - `@import("builtin")` - Target-specific information. The command `zig build-exe --show-builtin` outputs the source to stdout for reference.
++ \\ - `@import("root")` - Points to the root source file. This is usually `src/main.zig` but it depends on what file is chosen to be built.
++ ,
++ .arguments = &.{
++ "comptime path: []u8",
++ },
++ },
++ .{
++ .name = "@intCast",
++ .signature = "@intCast(comptime DestType: type, int: anytype) DestType",
++ .snippet = "@intCast(${1:comptime DestType: type}, ${2:int: anytype})",
++ .documentation =
++ \\Converts an integer to another integer while keeping the same numerical value. Attempting to convert a number which is out of range of the destination type results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
++ \\
++ \\```zig
++ \\test "integer cast panic" {
++ \\ var a: u16 = 0xabcd;
++ \\ var b: u8 = @intCast(u8, a);
++ \\ _ = b;
++ \\}
++ \\```
++ \\
++ \\To truncate the significant bits of a number out of range of the destination type, use [@truncate](https://ziglang.org/documentation/0.10.0/#truncate).
++ \\
++ \\If `T` is `comptime_int`, then this is semantically equivalent to [Type Coercion](https://ziglang.org/documentation/0.10.0/#Type-Coercion).
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "int: anytype",
++ },
++ },
++ .{
++ .name = "@intToEnum",
++ .signature = "@intToEnum(comptime DestType: type, integer: anytype) DestType",
++ .snippet = "@intToEnum(${1:comptime DestType: type}, ${2:integer: anytype})",
++ .documentation =
++ \\Converts an integer into an [enum](https://ziglang.org/documentation/0.10.0/#enum) value.
++ \\
++ \\Attempting to convert an integer which represents no value in the chosen enum type invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "integer: anytype",
++ },
++ },
++ .{
++ .name = "@intToError",
++ .signature = "@intToError(value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)) anyerror",
++ .snippet = "@intToError(${1:value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)})",
++ .documentation =
++ \\Converts from the integer representation of an error into [The Global Error Set](https://ziglang.org/documentation/0.10.0/#The-Global-Error-Set) type.
++ \\
++ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes.
++ \\
++ \\Attempting to convert an integer that does not correspond to any error results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)",
++ },
++ },
++ .{
++ .name = "@intToFloat",
++ .signature = "@intToFloat(comptime DestType: type, int: anytype) DestType",
++ .snippet = "@intToFloat(${1:comptime DestType: type}, ${2:int: anytype})",
++ .documentation =
++ \\Converts an integer to the closest floating point representation. To convert the other way, use [@floatToInt](https://ziglang.org/documentation/0.10.0/#floatToInt). This cast is always safe.
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "int: anytype",
++ },
++ },
++ .{
++ .name = "@intToPtr",
++ .signature = "@intToPtr(comptime DestType: type, address: usize) DestType",
++ .snippet = "@intToPtr(${1:comptime DestType: type}, ${2:address: usize})",
++ .documentation =
++ \\Converts an integer to a [pointer](https://ziglang.org/documentation/0.10.0/#Pointers). To convert the other way, use [@ptrToInt](https://ziglang.org/documentation/0.10.0/#ptrToInt). Casting an address of 0 to a destination type which in not [optional](https://ziglang.org/documentation/0.10.0/#Optional-Pointers) and does not have the `allowzero` attribute will result in a [Pointer Cast Invalid Null](https://ziglang.org/documentation/0.10.0/#Pointer-Cast-Invalid-Null) panic when runtime safety checks are enabled.
++ \\
++ \\If the destination pointer type does not allow address zero and `address` is zero, this invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "address: usize",
++ },
++ },
++ .{
++ .name = "@max",
++ .signature = "@max(a: T, b: T) T",
++ .snippet = "@max(${1:a: T}, ${2:b: T})",
++ .documentation =
++ \\Returns the maximum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
++ \\
++ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
++ ,
++ .arguments = &.{
++ "a: T",
++ "b: T",
++ },
++ },
++ .{
++ .name = "@memcpy",
++ .signature = "@memcpy(noalias dest: [*]u8, noalias source: [*]const u8, byte_count: usize)",
++ .snippet = "@memcpy(${1:noalias dest: [*]u8}, ${2:noalias source: [*]const u8}, ${3:byte_count: usize})",
++ .documentation =
++ \\This function copies bytes from one region of memory to another. `dest` and `source` are both pointers and must not overlap.
++ \\
++ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this:
++ \\
++ \\```zig
++ \\for (source[0..byte_count]) |b, i| dest[i] = b;
++ \\```
++ \\
++ \\The optimizer is intelligent enough to turn the above snippet into a memcpy.
++ \\
++ \\There is also a standard library function for this:
++ \\
++ \\```zig
++ \\const mem = @import("std").mem;
++ \\mem.copy(u8, dest[0..byte_count], source[0..byte_count]);
++ \\```
++ ,
++ .arguments = &.{
++ "noalias dest: [*]u8",
++ "noalias source: [*]const u8",
++ "byte_count: usize",
++ },
++ },
++ .{
++ .name = "@memset",
++ .signature = "@memset(dest: [*]u8, c: u8, byte_count: usize)",
++ .snippet = "@memset(${1:dest: [*]u8}, ${2:c: u8}, ${3:byte_count: usize})",
++ .documentation =
++ \\This function sets a region of memory to `c`. `dest` is a pointer.
++ \\
++ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this:
++ \\
++ \\```zig
++ \\for (dest[0..byte_count]) |*b| b.* = c;
++ \\```
++ \\
++ \\The optimizer is intelligent enough to turn the above snippet into a memset.
++ \\
++ \\There is also a standard library function for this:
++ \\
++ \\```zig
++ \\const mem = @import("std").mem;
++ \\mem.set(u8, dest, c);
++ \\```
++ ,
++ .arguments = &.{
++ "dest: [*]u8",
++ "c: u8",
++ "byte_count: usize",
++ },
++ },
++ .{
++ .name = "@min",
++ .signature = "@min(a: T, b: T) T",
++ .snippet = "@min(${1:a: T}, ${2:b: T})",
++ .documentation =
++ \\Returns the minimum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
++ \\
++ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
++ ,
++ .arguments = &.{
++ "a: T",
++ "b: T",
++ },
++ },
++ .{
++ .name = "@wasmMemorySize",
++ .signature = "@wasmMemorySize(index: u32) u32",
++ .snippet = "@wasmMemorySize(${1:index: u32})",
++ .documentation =
++ \\This function returns the size of the Wasm memory identified by `index` as an unsigned value in units of Wasm pages. Note that each Wasm page is 64KB in size.
++ \\
++ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.
++ ,
++ .arguments = &.{
++ "index: u32",
++ },
++ },
++ .{
++ .name = "@wasmMemoryGrow",
++ .signature = "@wasmMemoryGrow(index: u32, delta: u32) i32",
++ .snippet = "@wasmMemoryGrow(${1:index: u32}, ${2:delta: u32})",
++ .documentation =
++ \\This function increases the size of the Wasm memory identified by `index` by `delta` in units of unsigned number of Wasm pages. Note that each Wasm page is 64KB in size. On success, returns previous memory size; on failure, if the allocation fails, returns -1.
++ \\
++ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.</p> {#code_begin|test|wasmMemoryGrow#} const std = @import("std"); const native_arch = @import("builtin").target.cpu.arch; const expect = std.testing.expect; test "@wasmMemoryGrow" { if (native_arch != .wasm32) return error.SkipZigTest; var prev = @wasmMemorySize(0); try expect(prev == @wasmMemoryGrow(0, 1)); try expect(prev + 1 == @wasmMemorySize(0)); }`
++ ,
++ .arguments = &.{
++ "index: u32",
++ "delta: u32",
++ },
++ },
++ .{
++ .name = "@mod",
++ .signature = "@mod(numerator: T, denominator: T) T",
++ .snippet = "@mod(${1:numerator: T}, ${2:denominator: T})",
++ .documentation =
++ \\Modulus division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.10.0/#Remainder-Division-by-Zero) when runtime safety checks are enabled.
++ \\ - `@mod(-5, 3) == 1`
++ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a`
++ \\
++ \\For a function that returns an error code, see `@import("std").math.mod`.
++ ,
++ .arguments = &.{
++ "numerator: T",
++ "denominator: T",
++ },
++ },
++ .{
++ .name = "@mulWithOverflow",
++ .signature = "@mulWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
++ .snippet = "@mulWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
++ .documentation =
++ \\Performs `result.* = a * b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "a: T",
++ "b: T",
++ "result: *T",
++ },
++ },
++ .{
++ .name = "@panic",
++ .signature = "@panic(message: []const u8) noreturn",
++ .snippet = "@panic(${1:message: []const u8})",
++ .documentation =
++ \\Invokes the panic handler function. By default the panic handler function calls the public `panic` function exposed in the root source file, or if there is not one specified, the `std.builtin.default_panic` function from `std/builtin.zig`.
++ \\
++ \\Generally it is better to use `@import("std").debug.panic`. However, `@panic` can be useful for 2 scenarios:
++ \\ - From library code, calling the programmer's panic function if they exposed one in the root source file.
++ \\ - When mixing C and Zig code, calling the canonical panic implementation across multiple .o files.
++ ,
++ .arguments = &.{
++ "message: []const u8",
++ },
++ },
++ .{
++ .name = "@popCount",
++ .signature = "@popCount(operand: anytype)",
++ .snippet = "@popCount(${1:operand: anytype})",
++ .documentation =
++ \\`@TypeOf(operand)` must be an integer type.
++ \\
++ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors).
++ \\
++ \\Counts the number of bits set in an integer.
++ \\
++ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
++ ,
++ .arguments = &.{
++ "operand: anytype",
++ },
++ },
++ .{
++ .name = "@prefetch",
++ .signature = "@prefetch(ptr: anytype, comptime options: std.builtin.PrefetchOptions)",
++ .snippet = "@prefetch(${1:ptr: anytype}, ${2:comptime options: std.builtin.PrefetchOptions})",
++ .documentation =
++ \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a no-op. This function has no effect on the behavior of the program, only on the performance characteristics.
++ \\
++ \\The `ptr` argument may be any pointer type and determines the memory address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no illegal behavior will result.
++ \\
++ \\The `options` argument is the following struct:</p> {#code_begin|syntax|builtin#} /// This data structure is used by the Zig language code generation and /// therefore must be kept in sync with the compiler implementation. pub const PrefetchOptions = struct { /// Whether the prefetch should prepare for a read or a write. rw: Rw = .read, /// 0 means no temporal locality. That is, the data can be immediately /// dropped from the cache after it is accessed. /// /// 3 means high temporal locality. That is, the data should be kept in /// the cache as it is likely to be accessed again soon. locality: u2 = 3, /// The cache that the prefetch should be preformed on. cache: Cache = .data, pub const Rw = enum { read, write, }; pub const Cache = enum { instruction, data, }; };`
++ ,
++ .arguments = &.{
++ "ptr: anytype",
++ "comptime options: std.builtin.PrefetchOptions",
++ },
++ },
++ .{
++ .name = "@ptrCast",
++ .signature = "@ptrCast(comptime DestType: type, value: anytype) DestType",
++ .snippet = "@ptrCast(${1:comptime DestType: type}, ${2:value: anytype})",
++ .documentation =
++ \\Converts a pointer of one type to a pointer of another type.
++ \\
++ \\[Optional Pointers](https://ziglang.org/documentation/0.10.0/#Optional-Pointers) are allowed. Casting an optional pointer which is [null](https://ziglang.org/documentation/0.10.0/#null) to a non-optional pointer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@ptrToInt",
++ .signature = "@ptrToInt(value: anytype) usize",
++ .snippet = "@ptrToInt(${1:value: anytype})",
++ .documentation =
++ \\Converts `value` to a `usize` which is the address of the pointer. `value` can be `*T` or `?*T`.
++ \\
++ \\To convert the other way, use [@intToPtr](https://ziglang.org/documentation/0.10.0/#intToPtr)
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@rem",
++ .signature = "@rem(numerator: T, denominator: T) T",
++ .snippet = "@rem(${1:numerator: T}, ${2:denominator: T})",
++ .documentation =
++ \\Remainder division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.10.0/#Remainder-Division-by-Zero) when runtime safety checks are enabled.
++ \\ - `@rem(-5, 3) == -2`
++ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a`
++ \\
++ \\For a function that returns an error code, see `@import("std").math.rem`.
++ ,
++ .arguments = &.{
++ "numerator: T",
++ "denominator: T",
++ },
++ },
++ .{
++ .name = "@returnAddress",
++ .signature = "@returnAddress() usize",
++ .snippet = "@returnAddress()",
++ .documentation =
++ \\This function returns the address of the next machine code instruction that will be executed when the current function returns.
++ \\
++ \\The implications of this are target-specific and not consistent across all platforms.
++ \\
++ \\This function is only valid within function scope. If the function gets inlined into a calling function, the returned address will apply to the calling function.
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@select",
++ .signature = "@select(comptime T: type, pred: @Vector(len, bool), a: @Vector(len, T), b: @Vector(len, T)) @Vector(len, T)",
++ .snippet = "@select(${1:comptime T: type}, ${2:pred: @Vector(len, bool)}, ${3:a: @Vector(len, T)}, ${4:b: @Vector(len, T)})",
++ .documentation =
++ \\Selects values element-wise from `a` or `b` based on `pred`. If `pred[i]` is `true`, the corresponding element in the result will be `a[i]` and otherwise `b[i]`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "pred: @Vector(len, bool)",
++ "a: @Vector(len, T)",
++ "b: @Vector(len, T)",
++ },
++ },
++ .{
++ .name = "@setAlignStack",
++ .signature = "@setAlignStack(comptime alignment: u29)",
++ .snippet = "@setAlignStack(${1:comptime alignment: u29})",
++ .documentation =
++ \\Ensures that a function will have a stack alignment of at least `alignment` bytes.
++ ,
++ .arguments = &.{
++ "comptime alignment: u29",
++ },
++ },
++ .{
++ .name = "@setCold",
++ .signature = "@setCold(comptime is_cold: bool)",
++ .snippet = "@setCold(${1:comptime is_cold: bool})",
++ .documentation =
++ \\Tells the optimizer that a function is rarely called.
++ ,
++ .arguments = &.{
++ "comptime is_cold: bool",
++ },
++ },
++ .{
++ .name = "@setEvalBranchQuota",
++ .signature = "@setEvalBranchQuota(comptime new_quota: u32)",
++ .snippet = "@setEvalBranchQuota(${1:comptime new_quota: u32})",
++ .documentation =
++ \\Changes the maximum number of backwards branches that compile-time code execution can use before giving up and making a compile error.
++ \\
++ \\If the `new_quota` is smaller than the default quota (`1000`) or a previously explicitly set quota, it is ignored.
++ \\
++ \\Example:
++ \\
++ \\```zig
++ \\test "foo" {
++ \\ comptime {
++ \\ var i = 0;
++ \\ while (i < 1001) : (i += 1) {}
++ \\ }
++ \\}
++ \\```
++ \\
++ \\Now we use `@setEvalBranchQuota`:</p> {#code_begin|test|setEvalBranchQuota#} test "foo" { comptime { @setEvalBranchQuota(1001); var i = 0; while (i < 1001) : (i += 1) {} } }`
++ ,
++ .arguments = &.{
++ "comptime new_quota: u32",
++ },
++ },
++ .{
++ .name = "@setFloatMode",
++ .signature = "@setFloatMode(comptime mode: @import(\"std\").builtin.FloatMode)",
++ .snippet = "@setFloatMode(${1:comptime mode: @import(\"std\").builtin.FloatMode})",
++ .documentation =
++ \\Sets the floating point mode of the current scope. Possible values are:
++ \\
++ \\```zig
++ \\pub const FloatMode = enum {
++ \\ Strict,
++ \\ Optimized,
++ \\};
++ \\```
++ \\
++ \\ - `Strict` (default) - Floating point operations follow strict IEEE compliance.
++ \\ - `Optimized` - Floating point operations may do all of the following: <ul>
++ \\ - Assume the arguments and result are not NaN. Optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined.
++ \\ - Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined.
++ \\ - Treat the sign of a zero argument or result as insignificant.
++ \\ - Use the reciprocal of an argument rather than perform division.
++ \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-add).
++ \\ - Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate). This is equivalent to `-ffast-math` in GCC.</ul>
++ \\
++ \\The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block.
++ ,
++ .arguments = &.{
++ "comptime mode: @import(\"std\").builtin.FloatMode",
++ },
++ },
++ .{
++ .name = "@setRuntimeSafety",
++ .signature = "@setRuntimeSafety(comptime safety_on: bool) void",
++ .snippet = "@setRuntimeSafety(${1:comptime safety_on: bool})",
++ .documentation =
++ \\Sets whether runtime safety checks are enabled for the scope that contains the function call.
++ \\
++ \\```zig
++ \\test "@setRuntimeSafety" {
++ \\ // The builtin applies to the scope that it is called in. So here, integer overflow
++ \\ // will not be caught in ReleaseFast and ReleaseSmall modes:
++ \\ // var x: u8 = 255;
++ \\ // x += 1; // undefined behavior in ReleaseFast/ReleaseSmall modes.
++ \\ {
++ \\ // However this block has safety enabled, so safety checks happen here,
++ \\ // even in ReleaseFast and ReleaseSmall modes.
++ \\ @setRuntimeSafety(true);
++ \\ var x: u8 = 255;
++ \\ x += 1;
++ \\
++ \\ {
++ \\ // The value can be overridden at any scope. So here integer overflow
++ \\ // would not be caught in any build mode.
++ \\ @setRuntimeSafety(false);
++ \\ // var x: u8 = 255;
++ \\ // x += 1; // undefined behavior in all build modes.
++ \\ }
++ \\ }
++ \\}
++ \\```
++ \\
++ \\Note: it is [planned](https://github.com/ziglang/zig/issues/978) to replace `@setRuntimeSafety` with `@optimizeFor`
++ ,
++ .arguments = &.{
++ "comptime safety_on: bool",
++ },
++ },
++ .{
++ .name = "@shlExact",
++ .signature = "@shlExact(value: T, shift_amt: Log2T) T",
++ .snippet = "@shlExact(${1:value: T}, ${2:shift_amt: Log2T})",
++ .documentation =
++ \\Performs the left shift operation (`<<`). For unsigned integers, the result is [undefined](https://ziglang.org/documentation/0.10.0/#undefined) if any 1 bits are shifted out. For signed integers, the result is [undefined](https://ziglang.org/documentation/0.10.0/#undefined) if any bits that disagree with the resultant sign bit are shifted out.
++ \\
++ \\The type of `shift_amt` is an unsigned integer with `log2(@typeInfo(T).Int.bits)` bits. This is because `shift_amt >= @typeInfo(T).Int.bits` is undefined behavior.
++ ,
++ .arguments = &.{
++ "value: T",
++ "shift_amt: Log2T",
++ },
++ },
++ .{
++ .name = "@shlWithOverflow",
++ .signature = "@shlWithOverflow(comptime T: type, a: T, shift_amt: Log2T, result: *T) bool",
++ .snippet = "@shlWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:shift_amt: Log2T}, ${4:result: *T})",
++ .documentation =
++ \\Performs `result.* = a << b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
++ \\
++ \\The type of `shift_amt` is an unsigned integer with `log2(@typeInfo(T).Int.bits)` bits. This is because `shift_amt >= @typeInfo(T).Int.bits` is undefined behavior.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "a: T",
++ "shift_amt: Log2T",
++ "result: *T",
++ },
++ },
++ .{
++ .name = "@shrExact",
++ .signature = "@shrExact(value: T, shift_amt: Log2T) T",
++ .snippet = "@shrExact(${1:value: T}, ${2:shift_amt: Log2T})",
++ .documentation =
++ \\Performs the right shift operation (`>>`). Caller guarantees that the shift will not shift any 1 bits out.
++ \\
++ \\The type of `shift_amt` is an unsigned integer with `log2(@typeInfo(T).Int.bits)` bits. This is because `shift_amt >= @typeInfo(T).Int.bits` is undefined behavior.
++ ,
++ .arguments = &.{
++ "value: T",
++ "shift_amt: Log2T",
++ },
++ },
++ .{
++ .name = "@shuffle",
++ .signature = "@shuffle(comptime E: type, a: @Vector(a_len, E), b: @Vector(b_len, E), comptime mask: @Vector(mask_len, i32)) @Vector(mask_len, E)",
++ .snippet = "@shuffle(${1:comptime E: type}, ${2:a: @Vector(a_len, E)}, ${3:b: @Vector(b_len, E)}, ${4:comptime mask: @Vector(mask_len, i32)})",
++ .documentation =
++ \\Constructs a new [vector](https://ziglang.org/documentation/0.10.0/#Vectors) by selecting elements from `a` and `b` based on `mask`.
++ \\
++ \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator for indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`).
++ \\
++ \\For each element of `mask`, if it or the selected value from `a` or `b` is `undefined`, then the resulting element is `undefined`.
++ \\
++ \\`a_len` and `b_len` may differ in length. Out-of-bounds element indexes in `mask` result in compile errors.
++ \\
++ \\If `a` or `b` is `undefined`, it is equivalent to a vector of all `undefined` with the same length as the other vector. If both vectors are `undefined`, `@shuffle` returns a vector with all elements `undefined`.
++ \\
++ \\`E` must be an [integer](https://ziglang.org/documentation/0.10.0/#Integers), [float](https://ziglang.org/documentation/0.10.0/#Floats), [pointer](https://ziglang.org/documentation/0.10.0/#Pointers), or `bool`. The mask may be any vector length, and its length determines the result length.</p> {#code_begin|test|vector_shuffle#} const std = @import("std"); const expect = std.testing.expect; test "vector @shuffle" { const a = @Vector(7, u8){ 'o', 'l', 'h', 'e', 'r', 'z', 'w' }; const b = @Vector(4, u8){ 'w', 'd', '!', 'x' }; // To shuffle within a single vector, pass undefined as the second argument. // Notice that we can re-order, duplicate, or omit elements of the input vector const mask1 = @Vector(5, i32){ 2, 3, 1, 1, 0 }; const res1: @Vector(5, u8) = @shuffle(u8, a, undefined, mask1); try expect(std.mem.eql(u8, &@as([5]u8, res1), "hello")); // Combining two vectors const mask2 = @Vector(6, i32){ -1, 0, 4, 1, -2, -3 }; const res2: @Vector(6, u8) = @shuffle(u8, a, b, mask
2); try expect(std.mem.eql(u8, &@as([6]u8, res2), "world!")); }`
++ ,
++ .arguments = &.{
++ "comptime E: type",
++ "a: @Vector(a_len, E)",
++ "b: @Vector(b_len, E)",
++ "comptime mask: @Vector(mask_len, i32)",
++ },
++ },
++ .{
++ .name = "@sizeOf",
++ .signature = "@sizeOf(comptime T: type) comptime_int",
++ .snippet = "@sizeOf(${1:comptime T: type})",
++ .documentation =
++ \\This function returns the number of bytes it takes to store `T` in memory. The result is a target-specific compile time constant.
++ \\
++ \\This size may contain padding bytes. If there were two consecutive T in memory, this would be the offset in bytes between element at index 0 and the element at index 1. For [integer](https://ziglang.org/documentation/0.10.0/#Integers), consider whether you want to use `@sizeOf(T)` or `@typeInfo(T).Int.bits`.
++ \\
++ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ },
++ },
++ .{
++ .name = "@splat",
++ .signature = "@splat(comptime len: u32, scalar: anytype) @Vector(len, @TypeOf(scalar))",
++ .snippet = "@splat(${1:comptime len: u32}, ${2:scalar: anytype})",
++ .documentation =
++ \\Produces a vector of length `len` where each element is the value `scalar`:</p> {#code_begin|test|vector_splat#} const std = @import("std"); const expect = std.testing.expect; test "vector @splat" { const scalar: u32 = 5; const result = @splat(4, scalar); comptime try expect(@TypeOf(result) == @Vector(4, u32)); try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 })); }`
++ \\
++ \\`scalar` must be an [integer](https://ziglang.org/documentation/0.10.0/#Integers), [bool](https://ziglang.org/documentation/0.10.0/#Primitive-Types), [float](https://ziglang.org/documentation/0.10.0/#Floats), or [pointer](https://ziglang.org/documentation/0.10.0/#Pointers).
++ ,
++ .arguments = &.{
++ "comptime len: u32",
++ "scalar: anytype",
++ },
++ },
++ .{
++ .name = "@reduce",
++ .signature = "@reduce(comptime op: std.builtin.ReduceOp, value: anytype) E",
++ .snippet = "@reduce(${1:comptime op: std.builtin.ReduceOp}, ${2:value: anytype})",
++ .documentation =
++ \\Transforms a [vector](https://ziglang.org/documentation/0.10.0/#Vectors) into a scalar value (of type `E`) by performing a sequential horizontal reduction of its elements using the specified operator `op`.
++ \\
++ \\Not every operator is available for every vector element type:
++ \\ - Every operator is available for [integer](https://ziglang.org/documentation/0.10.0/#Integers) vectors.
++ \\ - `.And`, `.Or`, `.Xor` are additionally available for `bool` vectors,
++ \\ - `.Min`, `.Max`, `.Add`, `.Mul` are additionally available for [floating point](https://ziglang.org/documentation/0.10.0/#Floats) vectors,
++ \\
++ \\Note that `.Add` and `.Mul` reductions on integral types are wrapping; when applied on floating point types the operation associativity is preserved, unless the float mode is set to `Optimized`.</p> {#code_begin|test|vector_reduce#} const std = @import("std"); const expect = std.testing.expect; test "vector @reduce" { const value = @Vector(4, i32){ 1, -1, 1, -1 }; const result = value > @splat(4, @as(i32, 0)); // result is { true, false, true, false }; comptime try expect(@TypeOf(result) == @Vector(4, bool)); const is_all_true = @reduce(.And, result); comptime try expect(@TypeOf(is_all_true) == bool); try expect(is_all_true == false); }`
++ ,
++ .arguments = &.{
++ "comptime op: std.builtin.ReduceOp",
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@src",
++ .signature = "@src() std.builtin.SourceLocation",
++ .snippet = "@src()",
++ .documentation =
++ \\Returns a `SourceLocation` struct representing the function's name and location in the source code. This must be called in a function.</p> {#code_begin|test|source_location#} const std = @import("std"); const expect = std.testing.expect; test "@src" { try doTheTest(); } fn doTheTest() !void { const src = @src(); try expect(src.line == 9); try expect(src.column == 17); try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest")); try expect(std.mem.endsWith(u8, src.file, "source_location.zig")); }`
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@sqrt",
++ .signature = "@sqrt(value: anytype) @TypeOf(value)",
++ .snippet = "@sqrt(${1:value: anytype})",
++ .documentation =
++ \\Performs the square root of a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@sin",
++ .signature = "@sin(value: anytype) @TypeOf(value)",
++ .snippet = "@sin(${1:value: anytype})",
++ .documentation =
++ \\Sine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@cos",
++ .signature = "@cos(value: anytype) @TypeOf(value)",
++ .snippet = "@cos(${1:value: anytype})",
++ .documentation =
++ \\Cosine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@tan",
++ .signature = "@tan(value: anytype) @TypeOf(value)",
++ .snippet = "@tan(${1:value: anytype})",
++ .documentation =
++ \\Tangent trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@exp",
++ .signature = "@exp(value: anytype) @TypeOf(value)",
++ .snippet = "@exp(${1:value: anytype})",
++ .documentation =
++ \\Base-e exponential function on a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@exp2",
++ .signature = "@exp2(value: anytype) @TypeOf(value)",
++ .snippet = "@exp2(${1:value: anytype})",
++ .documentation =
++ \\Base-2 exponential function on a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@log",
++ .signature = "@log(value: anytype) @TypeOf(value)",
++ .snippet = "@log(${1:value: anytype})",
++ .documentation =
++ \\Returns the natural logarithm of a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@log2",
++ .signature = "@log2(value: anytype) @TypeOf(value)",
++ .snippet = "@log2(${1:value: anytype})",
++ .documentation =
++ \\Returns the logarithm to the base 2 of a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@log10",
++ .signature = "@log10(value: anytype) @TypeOf(value)",
++ .snippet = "@log10(${1:value: anytype})",
++ .documentation =
++ \\Returns the logarithm to the base 10 of a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@fabs",
++ .signature = "@fabs(value: anytype) @TypeOf(value)",
++ .snippet = "@fabs(${1:value: anytype})",
++ .documentation =
++ \\Returns the absolute value of a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@floor",
++ .signature = "@floor(value: anytype) @TypeOf(value)",
++ .snippet = "@floor(${1:value: anytype})",
++ .documentation =
++ \\Returns the largest integral value not greater than the given floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@ceil",
++ .signature = "@ceil(value: anytype) @TypeOf(value)",
++ .snippet = "@ceil(${1:value: anytype})",
++ .documentation =
++ \\Returns the smallest integral value not less than the given floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@trunc",
++ .signature = "@trunc(value: anytype) @TypeOf(value)",
++ .snippet = "@trunc(${1:value: anytype})",
++ .documentation =
++ \\Rounds the given floating point number to an integer, towards zero. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@round",
++ .signature = "@round(value: anytype) @TypeOf(value)",
++ .snippet = "@round(${1:value: anytype})",
++ .documentation =
++ \\Rounds the given floating point number to an integer, away from zero. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@subWithOverflow",
++ .signature = "@subWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
++ .snippet = "@subWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
++ .documentation =
++ \\Performs `result.* = a - b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "a: T",
++ "b: T",
++ "result: *T",
++ },
++ },
++ .{
++ .name = "@tagName",
++ .signature = "@tagName(value: anytype) [:0]const u8",
++ .snippet = "@tagName(${1:value: anytype})",
++ .documentation =
++ \\Converts an enum value or union value to a string literal representing the name.
++ \\
++ \\If the enum is non-exhaustive and the tag value does not map to a name, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@This",
++ .signature = "@This() type",
++ .snippet = "@This()",
++ .documentation =
++ \\Returns the innermost struct, enum, or union that this function call is inside. This can be useful for an anonymous struct that needs to refer to itself:</p> {#code_begin|test|this_innermost#} const std = @import("std"); const expect = std.testing.expect; test "@This()" { var items = [_]i32{ 1, 2, 3, 4 }; const list = List(i32){ .items = items[0..] }; try expect(list.length() == 4); } fn List(comptime T: type) type { return struct { const Self = @This(); items: []T, fn length(self: Self) usize { return self.items.len; } }; }`
++ \\
++ \\When `@This()` is used at file scope, it returns a reference to the struct that corresponds to the current file.
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@truncate",
++ .signature = "@truncate(comptime T: type, integer: anytype) T",
++ .snippet = "@truncate(${1:comptime T: type}, ${2:integer: anytype})",
++ .documentation =
++ \\This function truncates bits from an integer type, resulting in a smaller or same-sized integer type.
++ \\
++ \\This function always truncates the significant bits of the integer, regardless of endianness on the target platform.
++ \\
++ \\Calling `@truncate` on a number out of range of the destination type is well defined and working code:
++ \\
++ \\```zig
++ \\const std = @import("std");
++ \\const expect = std.testing.expect;
++ \\
++ \\test "integer truncation" {
++ \\ var a: u16 = 0xabcd;
++ \\ var b: u8 = @truncate(u8, a);
++ \\ try expect(b == 0xcd);
++ \\}
++ \\```
++ \\
++ \\Use [@intCast](https://ziglang.org/documentation/0.10.0/#intCast) to convert numbers guaranteed to fit the destination type.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "integer: anytype",
++ },
++ },
++ .{
++ .name = "@Type",
++ .signature = "@Type(comptime info: std.builtin.Type) type",
++ .snippet = "@Type(${1:comptime info: std.builtin.Type})",
++ .documentation =
++ \\This function is the inverse of [@typeInfo](https://ziglang.org/documentation/0.10.0/#typeInfo). It reifies type information into a `type`.
++ \\
++ \\It is available for the following types:
++ \\ - `type`
++ \\ - `noreturn`
++ \\ - `void`
++ \\ - `bool`
++ \\ - [Integers](https://ziglang.org/documentation/0.10.0/#Integers) - The maximum bit count for an integer type is `65535`.
++ \\ - [Floats](https://ziglang.org/documentation/0.10.0/#Floats)
++ \\ - [Pointers](https://ziglang.org/documentation/0.10.0/#Pointers)
++ \\ - `comptime_int`
++ \\ - `comptime_float`
++ \\ - `@TypeOf(undefined)`
++ \\ - `@TypeOf(null)`
++ \\ - [Arrays](https://ziglang.org/documentation/0.10.0/#Arrays)
++ \\ - [Optionals](https://ziglang.org/documentation/0.10.0/#Optionals)
++ \\ - [Error Set Type](https://ziglang.org/documentation/0.10.0/#Error-Set-Type)
++ \\ - [Error Union Type](https://ziglang.org/documentation/0.10.0/#Error-Union-Type)
++ \\ - [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors)
++ \\ - [opaque](https://ziglang.org/documentation/0.10.0/#opaque)
++ \\ - [@Frame](https://ziglang.org/documentation/0.10.0/#Frame)
++ \\ - `anyframe`
++ \\ - [struct](https://ziglang.org/documentation/0.10.0/#struct)
++ \\ - [enum](https://ziglang.org/documentation/0.10.0/#enum)
++ \\ - [Enum Literals](https://ziglang.org/documentation/0.10.0/#Enum-Literals)
++ \\ - [union](https://ziglang.org/documentation/0.10.0/#union)
++ \\
++ \\For these types, `@Type` is not available:
++ \\ - [Functions](https://ziglang.org/documentation/0.10.0/#Functions)
++ \\ - BoundFn
++ ,
++ .arguments = &.{
++ "comptime info: std.builtin.Type",
++ },
++ },
++ .{
++ .name = "@typeInfo",
++ .signature = "@typeInfo(comptime T: type) std.builtin.Type",
++ .snippet = "@typeInfo(${1:comptime T: type})",
++ .documentation =
++ \\Provides type reflection.
++ \\
++ \\Type information of [structs](https://ziglang.org/documentation/0.10.0/#struct), [unions](https://ziglang.org/documentation/0.10.0/#union), [enums](https://ziglang.org/documentation/0.10.0/#enum), and [error sets](https://ziglang.org/documentation/0.10.0/#Error-Set-Type) has fields which are guaranteed to be in the same order as appearance in the source file.
++ \\
++ \\Type information of [structs](https://ziglang.org/documentation/0.10.0/#struct), [unions](https://ziglang.org/documentation/0.10.0/#union), [enums](https://ziglang.org/documentation/0.10.0/#enum), and [opaques](https://ziglang.org/documentation/0.10.0/#opaque) has declarations, which are also guaranteed to be in the same order as appearance in the source file.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ },
++ },
++ .{
++ .name = "@typeName",
++ .signature = "@typeName(T: type) *const [N:0]u8",
++ .snippet = "@typeName(${1:T: type})",
++ .documentation =
++ \\This function returns the string representation of a type, as an array. It is equivalent to a string literal of the type name. The returned type name is fully qualified with the parent namespace included as part of the type name with a series of dots.
++ ,
++ .arguments = &.{
++ "T: type",
++ },
++ },
++ .{
++ .name = "@TypeOf",
++ .signature = "@TypeOf(...) type",
++ .snippet = "@TypeOf(${1:...})",
++ .documentation =
++ \\`@TypeOf` is a special builtin function that takes any (nonzero) number of expressions as parameters and returns the type of the result, using [Peer Type Resolution](https://ziglang.org/documentation/0.10.0/#Peer-Type-Resolution).
++ \\
++ \\The expressions are evaluated, however they are guaranteed to have no *runtime* side-effects:</p> {#code_begin|test|no_runtime_side_effects#} const std = @import("std"); const expect = std.testing.expect; test "no runtime side effects" { var data: i32 = 0; const T = @TypeOf(foo(i32, &data)); comptime try expect(T == i32); try expect(data == 0); } fn foo(comptime T: type, ptr: *T) T { ptr.* += 1; return ptr.*; }`
++ ,
++ .arguments = &.{
++ "...",
++ },
++ },
++ .{
++ .name = "@unionInit",
++ .signature = "@unionInit(comptime Union: type, comptime active_field_name: []const u8, init_expr) Union",
++ .snippet = "@unionInit(${1:comptime Union: type}, ${2:comptime active_field_name: []const u8}, ${3:init_expr})",
++ .documentation =
++ \\This is the same thing as [union](https://ziglang.org/documentation/0.10.0/#union) initialization syntax, except that the field name is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known value rather than an identifier token.
++ \\
++ \\`@unionInit` forwards its [result location](https://ziglang.org/documentation/0.10.0/#Result-Location-Semantics) to `init_expr`.
++ ,
++ .arguments = &.{
++ "comptime Union: type",
++ "comptime active_field_name: []const u8",
++ "init_expr",
++ },
++ },
++ .{
++ .name = "@Vector",
++ .signature = "@Vector(len: comptime_int, Element: type) type",
++ .snippet = "@Vector(${1:len: comptime_int}, ${2:Element: type})",
++ .documentation =
++ \\Creates [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors).
++ ,
++ .arguments = &.{
++ "len: comptime_int",
++ "Element: type",
++ },
++ },
++};
+diff --git a/src/data/0.9.1.zig b/src/data/0.9.1.zig
+new file mode 100644
+index 00000000..da1eddd5
+--- /dev/null
++++ b/src/data/0.9.1.zig
+@@ -0,0 +1,1777 @@
++const Builtin = struct {
++ name: []const u8,
++ signature: []const u8,
++ snippet: []const u8,
++ documentation: []const u8,
++ arguments: []const []const u8,
++};
++
++pub const builtins = [_]Builtin{
++ .{
++ .name = "@addWithOverflow",
++ .signature = "@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
++ .snippet = "@addWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
++ .documentation =
++ \\Performs `result.* = a + b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "a: T",
++ "b: T",
++ "result: *T",
++ },
++ },
++ .{
++ .name = "@alignCast",
++ .signature = "@alignCast(comptime alignment: u29, ptr: anytype) anytype",
++ .snippet = "@alignCast(${1:comptime alignment: u29}, ${2:ptr: anytype})",
++ .documentation =
++ \\`ptr` can be `*T`, `fn()`, `?*T`, `?fn()`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value.
++ \\
++ \\A [pointer alignment safety check](https://ziglang.org/documentation/0.9.1/#Incorrect-Pointer-Alignment) is added to the generated code to make sure the pointer is aligned as promised.
++ ,
++ .arguments = &.{
++ "comptime alignment: u29",
++ "ptr: anytype",
++ },
++ },
++ .{
++ .name = "@alignOf",
++ .signature = "@alignOf(comptime T: type) comptime_int",
++ .snippet = "@alignOf(${1:comptime T: type})",
++ .documentation =
++ \\This function returns the number of bytes that this type should be aligned to for the current target to match the C ABI. When the child type of a pointer has this alignment, the alignment can be omitted from the type.
++ \\
++ \\```zig
++ \\const expect = @import("std").debug.assert;
++ \\comptime {
++ \\ assert(*u32 == *align(@alignOf(u32)) u32);
++ \\}
++ \\```
++ \\
++ \\The result is a target-specific compile time constant. It is guaranteed to be less than or equal to [@sizeOf(T)](https://ziglang.org/documentation/0.9.1/#@sizeOf).
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ },
++ },
++ .{
++ .name = "@as",
++ .signature = "@as(comptime T: type, expression) T",
++ .snippet = "@as(${1:comptime T: type}, ${2:expression})",
++ .documentation =
++ \\Performs [Type Coercion](https://ziglang.org/documentation/0.9.1/#Type-Coercion). This cast is allowed when the conversion is unambiguous and safe, and is the preferred way to convert between types, whenever possible.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "expression",
++ },
++ },
++ .{
++ .name = "@asyncCall",
++ .signature = "@asyncCall(frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8, result_ptr, function_ptr, args: anytype) anyframe->T",
++ .snippet = "@asyncCall(${1:frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8}, ${2:result_ptr}, ${3:function_ptr}, ${4:args: anytype})",
++ .documentation =
++ \\`@asyncCall` performs an `async` call on a function pointer, which may or may not be an [async function](https://ziglang.org/documentation/0.9.1/#Async-Functions).
++ \\
++ \\The provided `frame_buffer` must be large enough to fit the entire function frame. This size can be determined with [@frameSize](https://ziglang.org/documentation/0.9.1/#frameSize). To provide a too-small buffer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
++ \\
++ \\`result_ptr` is optional ([null](https://ziglang.org/documentation/0.9.1/#null) may be provided). If provided, the function call will write its result directly to the result pointer, which will be available to read after [await](https://ziglang.org/documentation/0.9.1/#Async-and-Await) completes. Any result location provided to `await` will copy the result from `result_ptr`.</p> {#code_begin|test|async_struct_field_fn_pointer#} const std = @import("std"); const expect = std.testing.expect; test "async fn pointer in a struct field" { var data: i32 = 1; const Foo = struct { bar: fn (*i32) callconv(.Async) void, }; var foo = Foo{ .bar = func }; var bytes: [64]u8 align(@alignOf(@Frame(func))) = undefined; const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); try expect(data == 2); resume f; try expect(data == 4); } fn func(y: *i32) void { defer y.* += 2; y.* += 1; suspend {} }`
++ ,
++ .arguments = &.{
++ "frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8",
++ "result_ptr",
++ "function_ptr",
++ "args: anytype",
++ },
++ },
++ .{
++ .name = "@atomicLoad",
++ .signature = "@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: builtin.AtomicOrder) T",
++ .snippet = "@atomicLoad(${1:comptime T: type}, ${2:ptr: *const T}, ${3:comptime ordering: builtin.AtomicOrder})",
++ .documentation =
++ \\This builtin function atomically dereferences a pointer and returns the value.
++ \\
++ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "ptr: *const T",
++ "comptime ordering: builtin.AtomicOrder",
++ },
++ },
++ .{
++ .name = "@atomicRmw",
++ .signature = "@atomicRmw(comptime T: type, ptr: *T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) T",
++ .snippet = "@atomicRmw(${1:comptime T: type}, ${2:ptr: *T}, ${3:comptime op: builtin.AtomicRmwOp}, ${4:operand: T}, ${5:comptime ordering: builtin.AtomicOrder})",
++ .documentation =
++ \\This builtin function atomically modifies memory and then returns the previous value.
++ \\
++ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
++ \\
++ \\Supported operations:
++ \\ - `.Xchg` - stores the operand unmodified. Supports enums, integers and floats.
++ \\ - `.Add` - for integers, twos complement wraparound addition. Also supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats).
++ \\ - `.Sub` - for integers, twos complement wraparound subtraction. Also supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats).
++ \\ - `.And` - bitwise and
++ \\ - `.Nand` - bitwise nand
++ \\ - `.Or` - bitwise or
++ \\ - `.Xor` - bitwise xor
++ \\ - `.Max` - stores the operand if it is larger. Supports integers and floats.
++ \\ - `.Min` - stores the operand if it is smaller. Supports integers and floats.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "ptr: *T",
++ "comptime op: builtin.AtomicRmwOp",
++ "operand: T",
++ "comptime ordering: builtin.AtomicOrder",
++ },
++ },
++ .{
++ .name = "@atomicStore",
++ .signature = "@atomicStore(comptime T: type, ptr: *T, value: T, comptime ordering: builtin.AtomicOrder) void",
++ .snippet = "@atomicStore(${1:comptime T: type}, ${2:ptr: *T}, ${3:value: T}, ${4:comptime ordering: builtin.AtomicOrder})",
++ .documentation =
++ \\This builtin function atomically stores a value.
++ \\
++ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "ptr: *T",
++ "value: T",
++ "comptime ordering: builtin.AtomicOrder",
++ },
++ },
++ .{
++ .name = "@bitCast",
++ .signature = "@bitCast(comptime DestType: type, value: anytype) DestType",
++ .snippet = "@bitCast(${1:comptime DestType: type}, ${2:value: anytype})",
++ .documentation =
++ \\Converts a value of one type to another type.
++ \\
++ \\Asserts that `@sizeOf(@TypeOf(value)) == @sizeOf(DestType)`.
++ \\
++ \\Asserts that `@typeInfo(DestType) != .Pointer`. Use `@ptrCast` or `@intToPtr` if you need this.
++ \\
++ \\Can be used for these things for example:
++ \\ - Convert `f32` to `u32` bits
++ \\ - Convert `i32` to `u32` preserving twos complement
++ \\
++ \\Works at compile-time if `value` is known at compile time. It's a compile error to bitcast a struct to a scalar type of the same size since structs have undefined layout. However if the struct is packed then it works.
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@bitOffsetOf",
++ .signature = "@bitOffsetOf(comptime T: type, comptime field_name: []const u8) comptime_int",
++ .snippet = "@bitOffsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})",
++ .documentation =
++ \\Returns the bit offset of a field relative to its containing struct.
++ \\
++ \\For non [packed structs](https://ziglang.org/documentation/0.9.1/#packed-struct), this will always be divisible by `8`. For packed structs, non-byte-aligned fields will share a byte offset, but they will have different bit offsets.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "comptime field_name: []const u8",
++ },
++ },
++ .{
++ .name = "@boolToInt",
++ .signature = "@boolToInt(value: bool) u1",
++ .snippet = "@boolToInt(${1:value: bool})",
++ .documentation =
++ \\Converts `true` to `@as(u1, 1)` and `false` to `@as(u1, 0)`.
++ \\
++ \\If the value is known at compile-time, the return type is `comptime_int` instead of `u1`.
++ ,
++ .arguments = &.{
++ "value: bool",
++ },
++ },
++ .{
++ .name = "@bitSizeOf",
++ .signature = "@bitSizeOf(comptime T: type) comptime_int",
++ .snippet = "@bitSizeOf(${1:comptime T: type})",
++ .documentation =
++ \\This function returns the number of bits it takes to store `T` in memory if the type were a field in a packed struct/union. The result is a target-specific compile time constant.
++ \\
++ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ },
++ },
++ .{
++ .name = "@breakpoint",
++ .signature = "@breakpoint()",
++ .snippet = "@breakpoint()",
++ .documentation =
++ \\This function inserts a platform-specific debug trap instruction which causes debuggers to break there.
++ \\
++ \\This function is only valid within function scope.
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@mulAdd",
++ .signature = "@mulAdd(comptime T: type, a: T, b: T, c: T) T",
++ .snippet = "@mulAdd(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:c: T})",
++ .documentation =
++ \\Fused multiply add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate.
++ \\
++ \\Supports Floats and Vectors of floats.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "a: T",
++ "b: T",
++ "c: T",
++ },
++ },
++ .{
++ .name = "@byteSwap",
++ .signature = "@byteSwap(comptime T: type, operand: T) T",
++ .snippet = "@byteSwap(${1:comptime T: type}, ${2:operand: T})",
++ .documentation =
++ \\`T` must be an integer type with bit count evenly divisible by 8.
++ \\
++ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
++ \\
++ \\Swaps the byte order of the integer. This converts a big endian integer to a little endian integer, and converts a little endian integer to a big endian integer.
++ \\
++ \\Note that for the purposes of memory layout with respect to endianness, the integer type should be related to the number of bytes reported by [@sizeOf](https://ziglang.org/documentation/0.9.1/#sizeOf) bytes. This is demonstrated with `u24`. `@sizeOf(u24) == 4`, which means that a `u24` stored in memory takes 4 bytes, and those 4 bytes are what are swapped on a little vs big endian system. On the other hand, if `T` is specified to be `u24`, then only 3 bytes are reversed.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "operand: T",
++ },
++ },
++ .{
++ .name = "@bitReverse",
++ .signature = "@bitReverse(comptime T: type, integer: T) T",
++ .snippet = "@bitReverse(${1:comptime T: type}, ${2:integer: T})",
++ .documentation =
++ \\`T` accepts any integer type.
++ \\
++ \\Reverses the bitpattern of an integer value, including the sign bit if applicable.
++ \\
++ \\For example 0b10110110 (`u8 = 182`, `i8 = -74`) becomes 0b01101101 (`u8 = 109`, `i8 = 109`).
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "integer: T",
++ },
++ },
++ .{
++ .name = "@offsetOf",
++ .signature = "@offsetOf(comptime T: type, comptime field_name: []const u8) comptime_int",
++ .snippet = "@offsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})",
++ .documentation =
++ \\Returns the byte offset of a field relative to its containing struct.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "comptime field_name: []const u8",
++ },
++ },
++ .{
++ .name = "@call",
++ .signature = "@call(options: std.builtin.CallOptions, function: anytype, args: anytype) anytype",
++ .snippet = "@call(${1:options: std.builtin.CallOptions}, ${2:function: anytype}, ${3:args: anytype})",
++ .documentation =
++ \\Calls a function, in the same way that invoking an expression with parentheses does:
++ \\
++ \\```zig
++ \\const expect = @import("std").testing.expect;
++ \\
++ \\test "noinline function call" {
++ \\ try expect(@call(.{}, add, .{3, 9}) == 12);
++ \\}
++ \\
++ \\fn add(a: i32, b: i32) i32 {
++ \\ return a + b;
++ \\}
++ \\```
++ \\
++ \\`@call` allows more flexibility than normal function call syntax does. The `CallOptions` struct is reproduced here:</p> {#syntax_block|zig|builtin.CallOptions struct#} pub const CallOptions = struct { modifier: Modifier = .auto, /// Only valid when `Modifier` is `Modifier.async_kw`. stack: ?[]align(std.Target.stack_align) u8 = null, pub const Modifier = enum { /// Equivalent to function call syntax. auto, /// Equivalent to async keyword used with function call syntax. async_kw, /// Prevents tail call optimization. This guarantees that the return /// address will point to the callsite, as opposed to the callsite's /// callsite. If the call is otherwise required to be tail-called /// or inlined, a compile error is emitted instead. never_tail, /// Guarantees that the call will not be inlined. If the call is /// otherwise required to be inlined, a compile error is emitted instead. never_inline, /// Asserts that the function call will not suspend. This allows a /// non-async f
unction to call an async function. no_async, /// Guarantees that the call will be generated with tail call optimization. /// If this is not possible, a compile error is emitted instead. always_tail, /// Guarantees that the call will inlined at the callsite. /// If this is not possible, a compile error is emitted instead. always_inline, /// Evaluates the call at compile-time. If the call cannot be completed at /// compile-time, a compile error is emitted instead. compile_time, }; }; {#end_syntax_block#}
++ ,
++ .arguments = &.{
++ "options: std.builtin.CallOptions",
++ "function: anytype",
++ "args: anytype",
++ },
++ },
++ .{
++ .name = "@cDefine",
++ .signature = "@cDefine(comptime name: []u8, value)",
++ .snippet = "@cDefine(${1:comptime name: []u8}, ${2:value})",
++ .documentation =
++ \\This function can only occur inside `@cImport`.
++ \\
++ \\This appends `#define $name $value` to the `@cImport` temporary buffer.
++ \\
++ \\To define without a value, like this:`#define _GNU_SOURCE`
++ \\
++ \\Use the void value, like this:
++ \\
++ \\```zig
++ \\@cDefine("_GNU_SOURCE", {})
++ \\```
++ ,
++ .arguments = &.{
++ "comptime name: []u8",
++ "value",
++ },
++ },
++ .{
++ .name = "@cImport",
++ .signature = "@cImport(expression) type",
++ .snippet = "@cImport(${1:expression})",
++ .documentation =
++ \\This function parses C code and imports the functions, types, variables, and compatible macro definitions into a new empty struct type, and then returns that type.
++ \\
++ \\`expression` is interpreted at compile time. The builtin functions `@cInclude`, `@cDefine`, and `@cUndef` work within this expression, appending to a temporary buffer which is then parsed as C code.
++ \\
++ \\Usually you should only have one `@cImport` in your entire application, because it saves the compiler from invoking clang multiple times, and prevents inline functions from being duplicated.
++ \\
++ \\Reasons for having multiple `@cImport` expressions would be:
++ \\ - To avoid a symbol collision, for example if foo.h and bar.h both `#define CONNECTION_COUNT`
++ \\ - To analyze the C code with different preprocessor defines
++ ,
++ .arguments = &.{
++ "expression",
++ },
++ },
++ .{
++ .name = "@cInclude",
++ .signature = "@cInclude(comptime path: []u8)",
++ .snippet = "@cInclude(${1:comptime path: []u8})",
++ .documentation =
++ \\This function can only occur inside `@cImport`.
++ \\
++ \\This appends `#include <$path>\n` to the `c_import` temporary buffer.
++ ,
++ .arguments = &.{
++ "comptime path: []u8",
++ },
++ },
++ .{
++ .name = "@clz",
++ .signature = "@clz(comptime T: type, operand: T)",
++ .snippet = "@clz(${1:comptime T: type}, ${2:operand: T})",
++ .documentation =
++ \\`T` must be an integer type.
++ \\
++ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
++ \\
++ \\This function counts the number of most-significant (leading in a big-Endian sense) zeroes in an integer.
++ \\
++ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
++ \\
++ \\If `operand` is zero, `@clz` returns the bit width of integer type `T`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "operand: T",
++ },
++ },
++ .{
++ .name = "@cmpxchgStrong",
++ .signature = "@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T",
++ .snippet = "@cmpxchgStrong(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})",
++ .documentation =
++ \\This function performs a strong atomic compare exchange operation. It's the equivalent of this code, except atomic:
++ \\
++ \\```zig
++ \\fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T {
++ \\ const old_value = ptr.*;
++ \\ if (old_value == expected_value) {
++ \\ ptr.* = new_value;
++ \\ return null;
++ \\ } else {
++ \\ return old_value;
++ \\ }
++ \\}
++ \\```
++ \\
++ \\If you are using cmpxchg in a loop, [@cmpxchgWeak](https://ziglang.org/documentation/0.9.1/#cmpxchgWeak) is the better choice, because it can be implemented more efficiently in machine instructions.
++ \\
++ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
++ \\
++ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).`
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "ptr: *T",
++ "expected_value: T",
++ "new_value: T",
++ "success_order: AtomicOrder",
++ "fail_order: AtomicOrder",
++ },
++ },
++ .{
++ .name = "@cmpxchgWeak",
++ .signature = "@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T",
++ .snippet = "@cmpxchgWeak(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})",
++ .documentation =
++ \\This function performs a weak atomic compare exchange operation. It's the equivalent of this code, except atomic:</p> {#syntax_block|zig|cmpxchgWeakButNotAtomic#} fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T { const old_value = ptr.*; if (old_value == expected_value and usuallyTrueButSometimesFalse()) { ptr.* = new_value; return null; } else { return old_value; } } {#end_syntax_block#}
++ \\
++ \\If you are using cmpxchg in a loop, the sporadic failure will be no problem, and `cmpxchgWeak` is the better choice, because it can be implemented more efficiently in machine instructions. However if you need a stronger guarantee, use [@cmpxchgStrong](https://ziglang.org/documentation/0.9.1/#cmpxchgStrong).
++ \\
++ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
++ \\
++ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).`
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "ptr: *T",
++ "expected_value: T",
++ "new_value: T",
++ "success_order: AtomicOrder",
++ "fail_order: AtomicOrder",
++ },
++ },
++ .{
++ .name = "@compileError",
++ .signature = "@compileError(comptime msg: []u8)",
++ .snippet = "@compileError(${1:comptime msg: []u8})",
++ .documentation =
++ \\This function, when semantically analyzed, causes a compile error with the message `msg`.
++ \\
++ \\There are several ways that code avoids being semantically checked, such as using `if` or `switch` with compile time constants, and `comptime` functions.
++ ,
++ .arguments = &.{
++ "comptime msg: []u8",
++ },
++ },
++ .{
++ .name = "@compileLog",
++ .signature = "@compileLog(args: ...)",
++ .snippet = "@compileLog(${1:args: ...})",
++ .documentation =
++ \\This function prints the arguments passed to it at compile-time.
++ \\
++ \\To prevent accidentally leaving compile log statements in a codebase, a compilation error is added to the build, pointing to the compile log statement. This error prevents code from being generated, but does not otherwise interfere with analysis.
++ \\
++ \\This function can be used to do "printf debugging" on compile-time executing code.
++ \\
++ \\```zig
++ \\const print = @import("std").debug.print;
++ \\
++ \\const num1 = blk: {
++ \\ var val1: i32 = 99;
++ \\ @compileLog("comptime val1 = ", val1);
++ \\ val1 = val1 + 1;
++ \\ break :blk val1;
++ \\};
++ \\
++ \\test "main" {
++ \\ @compileLog("comptime in main");
++ \\
++ \\ print("Runtime in main, num1 = {}.\n", .{num1});
++ \\}
++ \\```
++ \\
++ \\will output:
++ \\
++ \\If all `@compileLog` calls are removed or not encountered by analysis, the program compiles successfully and the generated executable prints:</p> {#code_begin|test|without_compileLog#} const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; val1 = val1 + 1; break :blk val1; }; test "main" { print("Runtime in main, num1 = {}.\n", .{num1}); }`
++ ,
++ .arguments = &.{
++ "args: ...",
++ },
++ },
++ .{
++ .name = "@ctz",
++ .signature = "@ctz(comptime T: type, operand: T)",
++ .snippet = "@ctz(${1:comptime T: type}, ${2:operand: T})",
++ .documentation =
++ \\`T` must be an integer type.
++ \\
++ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
++ \\
++ \\This function counts the number of least-significant (trailing in a big-Endian sense) zeroes in an integer.
++ \\
++ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
++ \\
++ \\If `operand` is zero, `@ctz` returns the bit width of integer type `T`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "operand: T",
++ },
++ },
++ .{
++ .name = "@cUndef",
++ .signature = "@cUndef(comptime name: []u8)",
++ .snippet = "@cUndef(${1:comptime name: []u8})",
++ .documentation =
++ \\This function can only occur inside `@cImport`.
++ \\
++ \\This appends `#undef $name` to the `@cImport` temporary buffer.
++ ,
++ .arguments = &.{
++ "comptime name: []u8",
++ },
++ },
++ .{
++ .name = "@divExact",
++ .signature = "@divExact(numerator: T, denominator: T) T",
++ .snippet = "@divExact(${1:numerator: T}, ${2:denominator: T})",
++ .documentation =
++ \\Exact division. Caller guarantees `denominator != 0` and `@divTrunc(numerator, denominator) * denominator == numerator`.
++ \\ - `@divExact(6, 3) == 2`
++ \\ - `@divExact(a, b) * b == a`
++ \\
++ \\For a function that returns a possible error code, use `@import("std").math.divExact`.
++ ,
++ .arguments = &.{
++ "numerator: T",
++ "denominator: T",
++ },
++ },
++ .{
++ .name = "@divFloor",
++ .signature = "@divFloor(numerator: T, denominator: T) T",
++ .snippet = "@divFloor(${1:numerator: T}, ${2:denominator: T})",
++ .documentation =
++ \\Floored division. Rounds toward negative infinity. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`.
++ \\ - `@divFloor(-5, 3) == -2`
++ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a`
++ \\
++ \\For a function that returns a possible error code, use `@import("std").math.divFloor`.
++ ,
++ .arguments = &.{
++ "numerator: T",
++ "denominator: T",
++ },
++ },
++ .{
++ .name = "@divTrunc",
++ .signature = "@divTrunc(numerator: T, denominator: T) T",
++ .snippet = "@divTrunc(${1:numerator: T}, ${2:denominator: T})",
++ .documentation =
++ \\Truncated division. Rounds toward zero. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`.
++ \\ - `@divTrunc(-5, 3) == -1`
++ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a`
++ \\
++ \\For a function that returns a possible error code, use `@import("std").math.divTrunc`.
++ ,
++ .arguments = &.{
++ "numerator: T",
++ "denominator: T",
++ },
++ },
++ .{
++ .name = "@embedFile",
++ .signature = "@embedFile(comptime path: []const u8) *const [N:0]u8",
++ .snippet = "@embedFile(${1:comptime path: []const u8})",
++ .documentation =
++ \\This function returns a compile time constant pointer to null-terminated, fixed-size array with length equal to the byte count of the file given by `path`. The contents of the array are the contents of the file. This is equivalent to a [string literal](https://ziglang.org/documentation/0.9.1/#String-Literals-and-Unicode-Code-Point-Literals) with the file contents.
++ \\
++ \\`path` is absolute or relative to the current file, just like `@import`.
++ ,
++ .arguments = &.{
++ "comptime path: []const u8",
++ },
++ },
++ .{
++ .name = "@enumToInt",
++ .signature = "@enumToInt(enum_or_tagged_union: anytype) anytype",
++ .snippet = "@enumToInt(${1:enum_or_tagged_union: anytype})",
++ .documentation =
++ \\Converts an enumeration value into its integer tag type. When a tagged union is passed, the tag value is used as the enumeration value.
++ \\
++ \\If there is only one possible enum value, the result is a `comptime_int` known at [comptime](https://ziglang.org/documentation/0.9.1/#comptime).
++ ,
++ .arguments = &.{
++ "enum_or_tagged_union: anytype",
++ },
++ },
++ .{
++ .name = "@errorName",
++ .signature = "@errorName(err: anyerror) [:0]const u8",
++ .snippet = "@errorName(${1:err: anyerror})",
++ .documentation =
++ \\This function returns the string representation of an error. The string representation of `error.OutOfMem` is `"OutOfMem"`.
++ \\
++ \\If there are no calls to `@errorName` in an entire application, or all calls have a compile-time known value for `err`, then no error name table will be generated.
++ ,
++ .arguments = &.{
++ "err: anyerror",
++ },
++ },
++ .{
++ .name = "@errorReturnTrace",
++ .signature = "@errorReturnTrace() ?*builtin.StackTrace",
++ .snippet = "@errorReturnTrace()",
++ .documentation =
++ \\If the binary is built with error return tracing, and this function is invoked in a function that calls a function with an error or error union return type, returns a stack trace object. Otherwise returns [null](https://ziglang.org/documentation/0.9.1/#null).
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@errorToInt",
++ .signature = "@errorToInt(err: anytype) std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)",
++ .snippet = "@errorToInt(${1:err: anytype})",
++ .documentation =
++ \\Supports the following types:
++ \\ - [The Global Error Set](https://ziglang.org/documentation/0.9.1/#The-Global-Error-Set)
++ \\ - [Error Set Type](https://ziglang.org/documentation/0.9.1/#Error-Set-Type)
++ \\ - [Error Union Type](https://ziglang.org/documentation/0.9.1/#Error-Union-Type)
++ \\
++ \\Converts an error to the integer representation of an error.
++ \\
++ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes.
++ ,
++ .arguments = &.{
++ "err: anytype",
++ },
++ },
++ .{
++ .name = "@errSetCast",
++ .signature = "@errSetCast(comptime T: DestType, value: anytype) DestType",
++ .snippet = "@errSetCast(${1:comptime T: DestType}, ${2:value: anytype})",
++ .documentation =
++ \\Converts an error value from one error set to another error set. Attempting to convert an error which is not in the destination error set results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "comptime T: DestType",
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@export",
++ .signature = "@export(declaration, comptime options: std.builtin.ExportOptions) void",
++ .snippet = "@export(${1:declaration}, ${2:comptime options: std.builtin.ExportOptions})",
++ .documentation =
++ \\Creates a symbol in the output object file.
++ \\
++ \\`declaration` must be one of two things:
++ \\ - An identifier (`x`) identifying a [function](https://ziglang.org/documentation/0.9.1/#Functions) or a [variable](https://ziglang.org/documentation/0.9.1/#Container-Level-Variables).
++ \\ - Field access (`x.y`) looking up a [function](https://ziglang.org/documentation/0.9.1/#Functions) or a [variable](https://ziglang.org/documentation/0.9.1/#Container-Level-Variables).
++ \\
++ \\This builtin can be called from a [comptime](https://ziglang.org/documentation/0.9.1/#comptime) block to conditionally export symbols. When `declaration` is a function with the C calling convention and `options.linkage` is `Strong`, this is equivalent to the `export` keyword used on a function:
++ \\
++ \\```zig
++ \\comptime {
++ \\ @export(internalName, .{ .name = "foo", .linkage = .Strong });
++ \\}
++ \\
++ \\fn internalName() callconv(.C) void {}
++ \\```
++ \\
++ \\This is equivalent to:
++ \\
++ \\```zig
++ \\export fn foo() void {}
++ \\```
++ \\
++ \\Note that even when using `export`, the `@"foo"` syntax for [identifiers](https://ziglang.org/documentation/0.9.1/#Identifiers) can be used to choose any string for the symbol name:
++ \\
++ \\```zig
++ \\export fn @"A function name that is a complete sentence."() void {}
++ \\```
++ \\
++ \\When looking at the resulting object, you can see the symbol is used verbatim:
++ \\
++ \\```zig
++ \\00000000000001f0 T A function name that is a complete sentence.
++ \\```
++ ,
++ .arguments = &.{
++ "declaration",
++ "comptime options: std.builtin.ExportOptions",
++ },
++ },
++ .{
++ .name = "@extern",
++ .signature = "@extern(T: type, comptime options: std.builtin.ExternOptions) *T",
++ .snippet = "@extern(${1:T: type}, ${2:comptime options: std.builtin.ExternOptions})",
++ .documentation =
++ \\Creates a reference to an external symbol in the output object file.
++ ,
++ .arguments = &.{
++ "T: type",
++ "comptime options: std.builtin.ExternOptions",
++ },
++ },
++ .{
++ .name = "@fence",
++ .signature = "@fence(order: AtomicOrder)",
++ .snippet = "@fence(${1:order: AtomicOrder})",
++ .documentation =
++ \\The `fence` function is used to introduce happens-before edges between operations.
++ \\
++ \\`AtomicOrder` can be found with `@import("std").builtin.AtomicOrder`.
++ ,
++ .arguments = &.{
++ "order: AtomicOrder",
++ },
++ },
++ .{
++ .name = "@field",
++ .signature = "@field(lhs: anytype, comptime field_name: []const u8) (field)",
++ .snippet = "@field(${1:lhs: anytype}, ${2:comptime field_name: []const u8})",
++ .documentation =
++ \\Performs field access by a compile-time string. Works on both fields and declarations.</p> {#code_begin|test|field_decl_access_by_string#} const std = @import("std"); const Point = struct { x: u32, y: u32, pub var z: u32 = 1; }; test "field access by string" { const expect = std.testing.expect; var p = Point{ .x = 0, .y = 0 }; @field(p, "x") = 4; @field(p, "y") = @field(p, "x") + 1; try expect(@field(p, "x") == 4); try expect(@field(p, "y") == 5); } test "decl access by string" { const expect = std.testing.expect; try expect(@field(Point, "z") == 1); @field(Point, "z") = 2; try expect(@field(Point, "z") == 2); }`
++ ,
++ .arguments = &.{
++ "lhs: anytype",
++ "comptime field_name: []const u8",
++ },
++ },
++ .{
++ .name = "@fieldParentPtr",
++ .signature = "@fieldParentPtr(comptime ParentType: type, comptime field_name: []const u8, field_ptr: *T) *ParentType",
++ .snippet = "@fieldParentPtr(${1:comptime ParentType: type}, ${2:comptime field_name: []const u8}, ${3:field_ptr: *T})",
++ .documentation =
++ \\Given a pointer to a field, returns the base pointer of a struct.
++ ,
++ .arguments = &.{
++ "comptime ParentType: type",
++ "comptime field_name: []const u8",
++ "field_ptr: *T",
++ },
++ },
++ .{
++ .name = "@floatCast",
++ .signature = "@floatCast(comptime DestType: type, value: anytype) DestType",
++ .snippet = "@floatCast(${1:comptime DestType: type}, ${2:value: anytype})",
++ .documentation =
++ \\Convert from one float type to another. This cast is safe, but may cause the numeric value to lose precision.
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@floatToInt",
++ .signature = "@floatToInt(comptime DestType: type, float: anytype) DestType",
++ .snippet = "@floatToInt(${1:comptime DestType: type}, ${2:float: anytype})",
++ .documentation =
++ \\Converts the integer part of a floating point number to the destination type.
++ \\
++ \\If the integer part of the floating point number cannot fit in the destination type, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "float: anytype",
++ },
++ },
++ .{
++ .name = "@frame",
++ .signature = "@frame() *@Frame(func)",
++ .snippet = "@frame()",
++ .documentation =
++ \\This function returns a pointer to the frame for a given function. This type can be [coerced](https://ziglang.org/documentation/0.9.1/#Type-Coercion) to `anyframe->T` and to `anyframe`, where `T` is the return type of the function in scope.
++ \\
++ \\This function does not mark a suspension point, but it does cause the function in scope to become an [async function](https://ziglang.org/documentation/0.9.1/#Async-Functions).
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@Frame",
++ .signature = "@Frame(func: anytype) type",
++ .snippet = "@Frame(${1:func: anytype})",
++ .documentation =
++ \\This function returns the frame type of a function. This works for [Async Functions](https://ziglang.org/documentation/0.9.1/#Async-Functions) as well as any function without a specific calling convention.
++ \\
++ \\This type is suitable to be used as the return type of [async](https://ziglang.org/documentation/0.9.1/#Async-and-Await) which allows one to, for example, heap-allocate an async function frame:</p> {#code_begin|test|heap_allocated_frame#} const std = @import("std"); test "heap allocated frame" { const frame = try std.heap.page_allocator.create(@Frame(func)); frame.* = async func(); } fn func() void { suspend {} }`
++ ,
++ .arguments = &.{
++ "func: anytype",
++ },
++ },
++ .{
++ .name = "@frameAddress",
++ .signature = "@frameAddress() usize",
++ .snippet = "@frameAddress()",
++ .documentation =
++ \\This function returns the base pointer of the current stack frame.
++ \\
++ \\The implications of this are target specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations.
++ \\
++ \\This function is only valid within function scope.
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@frameSize",
++ .signature = "@frameSize() usize",
++ .snippet = "@frameSize()",
++ .documentation =
++ \\This is the same as `@sizeOf(@Frame(func))`, where `func` may be runtime-known.
++ \\
++ \\This function is typically used in conjunction with [@asyncCall](https://ziglang.org/documentation/0.9.1/#asyncCall).
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@hasDecl",
++ .signature = "@hasDecl(comptime Container: type, comptime name: []const u8) bool",
++ .snippet = "@hasDecl(${1:comptime Container: type}, ${2:comptime name: []const u8})",
++ .documentation =
++ \\Returns whether or not a [struct](https://ziglang.org/documentation/0.9.1/#struct), [enum](https://ziglang.org/documentation/0.9.1/#enum), or [union](https://ziglang.org/documentation/0.9.1/#union) has a declaration matching `name`.</p> {#code_begin|test|hasDecl#} const std = @import("std"); const expect = std.testing.expect; const Foo = struct { nope: i32, pub var blah = "xxx"; const hi = 1; }; test "@hasDecl" { try expect(@hasDecl(Foo, "blah")); // Even though `hi` is private, @hasDecl returns true because this test is // in the same file scope as Foo. It would return false if Foo was declared // in a different file. try expect(@hasDecl(Foo, "hi")); // @hasDecl is for declarations; not fields. try expect(!@hasDecl(Foo, "nope")); try expect(!@hasDecl(Foo, "nope1234")); }`
++ ,
++ .arguments = &.{
++ "comptime Container: type",
++ "comptime name: []const u8",
++ },
++ },
++ .{
++ .name = "@hasField",
++ .signature = "@hasField(comptime Container: type, comptime name: []const u8) bool",
++ .snippet = "@hasField(${1:comptime Container: type}, ${2:comptime name: []const u8})",
++ .documentation =
++ \\Returns whether the field name of a struct, union, or enum exists.
++ \\
++ \\The result is a compile time constant.
++ \\
++ \\It does not include functions, variables, or constants.
++ ,
++ .arguments = &.{
++ "comptime Container: type",
++ "comptime name: []const u8",
++ },
++ },
++ .{
++ .name = "@import",
++ .signature = "@import(comptime path: []u8) type",
++ .snippet = "@import(${1:comptime path: []u8})",
++ .documentation =
++ \\This function finds a zig file corresponding to `path` and adds it to the build, if it is not already added.
++ \\
++ \\Zig source files are implicitly structs, with a name equal to the file's basename with the extension truncated. `@import` returns the struct type corresponding to the file.
++ \\
++ \\Declarations which have the `pub` keyword may be referenced from a different source file than the one they are declared in.
++ \\
++ \\`path` can be a relative path or it can be the name of a package. If it is a relative path, it is relative to the file that contains the `@import` function call.
++ \\
++ \\The following packages are always available:
++ \\ - `@import("std")` - Zig Standard Library
++ \\ - `@import("builtin")` - Target-specific information The command `zig build-exe --show-builtin` outputs the source to stdout for reference.
++ \\ - `@import("root")` - Points to the root source file This is usually `src/main.zig` but it depends on what file is chosen to be built.
++ ,
++ .arguments = &.{
++ "comptime path: []u8",
++ },
++ },
++ .{
++ .name = "@intCast",
++ .signature = "@intCast(comptime DestType: type, int: anytype) DestType",
++ .snippet = "@intCast(${1:comptime DestType: type}, ${2:int: anytype})",
++ .documentation =
++ \\Converts an integer to another integer while keeping the same numerical value. Attempting to convert a number which is out of range of the destination type results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
++ \\
++ \\```zig
++ \\test "integer cast panic" {
++ \\ var a: u16 = 0xabcd;
++ \\ var b: u8 = @intCast(u8, a);
++ \\ _ = b;
++ \\}
++ \\```
++ \\
++ \\To truncate the significant bits of a number out of range of the destination type, use [@truncate](https://ziglang.org/documentation/0.9.1/#truncate).
++ \\
++ \\If `T` is `comptime_int`, then this is semantically equivalent to [Type Coercion](https://ziglang.org/documentation/0.9.1/#Type-Coercion).
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "int: anytype",
++ },
++ },
++ .{
++ .name = "@intToEnum",
++ .signature = "@intToEnum(comptime DestType: type, integer: anytype) DestType",
++ .snippet = "@intToEnum(${1:comptime DestType: type}, ${2:integer: anytype})",
++ .documentation =
++ \\Converts an integer into an [enum](https://ziglang.org/documentation/0.9.1/#enum) value.
++ \\
++ \\Attempting to convert an integer which represents no value in the chosen enum type invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "integer: anytype",
++ },
++ },
++ .{
++ .name = "@intToError",
++ .signature = "@intToError(value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)) anyerror",
++ .snippet = "@intToError(${1:value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)})",
++ .documentation =
++ \\Converts from the integer representation of an error into [The Global Error Set](https://ziglang.org/documentation/0.9.1/#The-Global-Error-Set) type.
++ \\
++ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes.
++ \\
++ \\Attempting to convert an integer that does not correspond to any error results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)",
++ },
++ },
++ .{
++ .name = "@intToFloat",
++ .signature = "@intToFloat(comptime DestType: type, int: anytype) DestType",
++ .snippet = "@intToFloat(${1:comptime DestType: type}, ${2:int: anytype})",
++ .documentation =
++ \\Converts an integer to the closest floating point representation. To convert the other way, use [@floatToInt](https://ziglang.org/documentation/0.9.1/#floatToInt). This cast is always safe.
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "int: anytype",
++ },
++ },
++ .{
++ .name = "@intToPtr",
++ .signature = "@intToPtr(comptime DestType: type, address: usize) DestType",
++ .snippet = "@intToPtr(${1:comptime DestType: type}, ${2:address: usize})",
++ .documentation =
++ \\Converts an integer to a [pointer](https://ziglang.org/documentation/0.9.1/#Pointers). To convert the other way, use [@ptrToInt](https://ziglang.org/documentation/0.9.1/#ptrToInt). Casting an address of 0 to a destination type which in not [optional](https://ziglang.org/documentation/0.9.1/#Optional-Pointers) and does not have the `allowzero` attribute will result in a [Pointer Cast Invalid Null](https://ziglang.org/documentation/0.9.1/#Pointer-Cast-Invalid-Null) panic when runtime safety checks are enabled.
++ \\
++ \\If the destination pointer type does not allow address zero and `address` is zero, this invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "address: usize",
++ },
++ },
++ .{
++ .name = "@maximum",
++ .signature = "@maximum(a: T, b: T) T",
++ .snippet = "@maximum(${1:a: T}, ${2:b: T})",
++ .documentation =
++ \\Returns the maximum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
++ \\
++ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
++ ,
++ .arguments = &.{
++ "a: T",
++ "b: T",
++ },
++ },
++ .{
++ .name = "@memcpy",
++ .signature = "@memcpy(noalias dest: [*]u8, noalias source: [*]const u8, byte_count: usize)",
++ .snippet = "@memcpy(${1:noalias dest: [*]u8}, ${2:noalias source: [*]const u8}, ${3:byte_count: usize})",
++ .documentation =
++ \\This function copies bytes from one region of memory to another. `dest` and `source` are both pointers and must not overlap.
++ \\
++ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this:
++ \\
++ \\```zig
++ \\for (source[0..byte_count]) |b, i| dest[i] = b;
++ \\```
++ \\
++ \\The optimizer is intelligent enough to turn the above snippet into a memcpy.
++ \\
++ \\There is also a standard library function for this:
++ \\
++ \\```zig
++ \\const mem = @import("std").mem;
++ \\mem.copy(u8, dest[0..byte_count], source[0..byte_count]);
++ \\```
++ ,
++ .arguments = &.{
++ "noalias dest: [*]u8",
++ "noalias source: [*]const u8",
++ "byte_count: usize",
++ },
++ },
++ .{
++ .name = "@memset",
++ .signature = "@memset(dest: [*]u8, c: u8, byte_count: usize)",
++ .snippet = "@memset(${1:dest: [*]u8}, ${2:c: u8}, ${3:byte_count: usize})",
++ .documentation =
++ \\This function sets a region of memory to `c`. `dest` is a pointer.
++ \\
++ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this:
++ \\
++ \\```zig
++ \\for (dest[0..byte_count]) |*b| b.* = c;
++ \\```
++ \\
++ \\The optimizer is intelligent enough to turn the above snippet into a memset.
++ \\
++ \\There is also a standard library function for this:
++ \\
++ \\```zig
++ \\const mem = @import("std").mem;
++ \\mem.set(u8, dest, c);
++ \\```
++ ,
++ .arguments = &.{
++ "dest: [*]u8",
++ "c: u8",
++ "byte_count: usize",
++ },
++ },
++ .{
++ .name = "@minimum",
++ .signature = "@minimum(a: T, b: T) T",
++ .snippet = "@minimum(${1:a: T}, ${2:b: T})",
++ .documentation =
++ \\Returns the minimum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
++ \\
++ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
++ ,
++ .arguments = &.{
++ "a: T",
++ "b: T",
++ },
++ },
++ .{
++ .name = "@wasmMemorySize",
++ .signature = "@wasmMemorySize(index: u32) u32",
++ .snippet = "@wasmMemorySize(${1:index: u32})",
++ .documentation =
++ \\This function returns the size of the Wasm memory identified by `index` as an unsigned value in units of Wasm pages. Note that each Wasm page is 64KB in size.
++ \\
++ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.
++ ,
++ .arguments = &.{
++ "index: u32",
++ },
++ },
++ .{
++ .name = "@wasmMemoryGrow",
++ .signature = "@wasmMemoryGrow(index: u32, delta: u32) i32",
++ .snippet = "@wasmMemoryGrow(${1:index: u32}, ${2:delta: u32})",
++ .documentation =
++ \\This function increases the size of the Wasm memory identified by `index` by `delta` in units of unsigned number of Wasm pages. Note that each Wasm page is 64KB in size. On success, returns previous memory size; on failure, if the allocation fails, returns -1.
++ \\
++ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.</p> {#code_begin|test|wasmMemoryGrow#} const std = @import("std"); const native_arch = @import("builtin").target.cpu.arch; const expect = std.testing.expect; test "@wasmMemoryGrow" { if (native_arch != .wasm32) return error.SkipZigTest; var prev = @wasmMemorySize(0); try expect(prev == @wasmMemoryGrow(0, 1)); try expect(prev + 1 == @wasmMemorySize(0)); }`
++ ,
++ .arguments = &.{
++ "index: u32",
++ "delta: u32",
++ },
++ },
++ .{
++ .name = "@mod",
++ .signature = "@mod(numerator: T, denominator: T) T",
++ .snippet = "@mod(${1:numerator: T}, ${2:denominator: T})",
++ .documentation =
++ \\Modulus division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.9.1/#Remainder-Division-by-Zero) when runtime safety checks are enabled.
++ \\ - `@mod(-5, 3) == 1`
++ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a`
++ \\
++ \\For a function that returns an error code, see `@import("std").math.mod`.
++ ,
++ .arguments = &.{
++ "numerator: T",
++ "denominator: T",
++ },
++ },
++ .{
++ .name = "@mulWithOverflow",
++ .signature = "@mulWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
++ .snippet = "@mulWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
++ .documentation =
++ \\Performs `result.* = a * b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "a: T",
++ "b: T",
++ "result: *T",
++ },
++ },
++ .{
++ .name = "@panic",
++ .signature = "@panic(message: []const u8) noreturn",
++ .snippet = "@panic(${1:message: []const u8})",
++ .documentation =
++ \\Invokes the panic handler function. By default the panic handler function calls the public `panic` function exposed in the root source file, or if there is not one specified, the `std.builtin.default_panic` function from `std/builtin.zig`.
++ \\
++ \\Generally it is better to use `@import("std").debug.panic`. However, `@panic` can be useful for 2 scenarios:
++ \\ - From library code, calling the programmer's panic function if they exposed one in the root source file.
++ \\ - When mixing C and Zig code, calling the canonical panic implementation across multiple .o files.
++ ,
++ .arguments = &.{
++ "message: []const u8",
++ },
++ },
++ .{
++ .name = "@popCount",
++ .signature = "@popCount(comptime T: type, operand: T)",
++ .snippet = "@popCount(${1:comptime T: type}, ${2:operand: T})",
++ .documentation =
++ \\`T` must be an integer type.
++ \\
++ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
++ \\
++ \\Counts the number of bits set in an integer.
++ \\
++ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "operand: T",
++ },
++ },
++ .{
++ .name = "@prefetch",
++ .signature = "@prefetch(ptr: anytype, comptime options: std.builtin.PrefetchOptions)",
++ .snippet = "@prefetch(${1:ptr: anytype}, ${2:comptime options: std.builtin.PrefetchOptions})",
++ .documentation =
++ \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a noop. This function has no effect on the behavior of the program, only on the performance characteristics.
++ \\
++ \\The `ptr` argument may be any pointer type and determines the memory address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no illegal behavior will result.
++ \\
++ \\The `options` argument is the following struct:</p> {#code_begin|syntax|builtin#} /// This data structure is used by the Zig language code generation and /// therefore must be kept in sync with the compiler implementation. pub const PrefetchOptions = struct { /// Whether the prefetch should prepare for a read or a write. rw: Rw = .read, /// 0 means no temporal locality. That is, the data can be immediately /// dropped from the cache after it is accessed. /// /// 3 means high temporal locality. That is, the data should be kept in /// the cache as it is likely to be accessed again soon. locality: u2 = 3, /// The cache that the prefetch should be preformed on. cache: Cache = .data, pub const Rw = enum { read, write, }; pub const Cache = enum { instruction, data, }; };`
++ ,
++ .arguments = &.{
++ "ptr: anytype",
++ "comptime options: std.builtin.PrefetchOptions",
++ },
++ },
++ .{
++ .name = "@ptrCast",
++ .signature = "@ptrCast(comptime DestType: type, value: anytype) DestType",
++ .snippet = "@ptrCast(${1:comptime DestType: type}, ${2:value: anytype})",
++ .documentation =
++ \\Converts a pointer of one type to a pointer of another type.
++ \\
++ \\[Optional Pointers](https://ziglang.org/documentation/0.9.1/#Optional-Pointers) are allowed. Casting an optional pointer which is [null](https://ziglang.org/documentation/0.9.1/#null) to a non-optional pointer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "comptime DestType: type",
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@ptrToInt",
++ .signature = "@ptrToInt(value: anytype) usize",
++ .snippet = "@ptrToInt(${1:value: anytype})",
++ .documentation =
++ \\Converts `value` to a `usize` which is the address of the pointer. `value` can be one of these types:
++ \\ - `*T`
++ \\ - `?*T`
++ \\ - `fn()`
++ \\ - `?fn()`
++ \\
++ \\To convert the other way, use [@intToPtr](https://ziglang.org/documentation/0.9.1/#intToPtr)
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@rem",
++ .signature = "@rem(numerator: T, denominator: T) T",
++ .snippet = "@rem(${1:numerator: T}, ${2:denominator: T})",
++ .documentation =
++ \\Remainder division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.9.1/#Remainder-Division-by-Zero) when runtime safety checks are enabled.
++ \\ - `@rem(-5, 3) == -2`
++ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a`
++ \\
++ \\For a function that returns an error code, see `@import("std").math.rem`.
++ ,
++ .arguments = &.{
++ "numerator: T",
++ "denominator: T",
++ },
++ },
++ .{
++ .name = "@returnAddress",
++ .signature = "@returnAddress() usize",
++ .snippet = "@returnAddress()",
++ .documentation =
++ \\This function returns the address of the next machine code instruction that will be executed when the current function returns.
++ \\
++ \\The implications of this are target specific and not consistent across all platforms.
++ \\
++ \\This function is only valid within function scope. If the function gets inlined into a calling function, the returned address will apply to the calling function.
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@select",
++ .signature = "@select(comptime T: type, pred: std.meta.Vector(len, bool), a: std.meta.Vector(len, T), b: std.meta.Vector(len, T)) std.meta.Vector(len, T)",
++ .snippet = "@select(${1:comptime T: type}, ${2:pred: std.meta.Vector(len, bool)}, ${3:a: std.meta.Vector(len, T)}, ${4:b: std.meta.Vector(len, T)})",
++ .documentation =
++ \\Selects values element-wise from `a` or `b` based on `pred`. If `pred[i]` is `true`, the corresponding element in the result will be `a[i]` and otherwise `b[i]`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "pred: std.meta.Vector(len, bool)",
++ "a: std.meta.Vector(len, T)",
++ "b: std.meta.Vector(len, T)",
++ },
++ },
++ .{
++ .name = "@setAlignStack",
++ .signature = "@setAlignStack(comptime alignment: u29)",
++ .snippet = "@setAlignStack(${1:comptime alignment: u29})",
++ .documentation =
++ \\Ensures that a function will have a stack alignment of at least `alignment` bytes.
++ ,
++ .arguments = &.{
++ "comptime alignment: u29",
++ },
++ },
++ .{
++ .name = "@setCold",
++ .signature = "@setCold(comptime is_cold: bool)",
++ .snippet = "@setCold(${1:comptime is_cold: bool})",
++ .documentation =
++ \\Tells the optimizer that a function is rarely called.
++ ,
++ .arguments = &.{
++ "comptime is_cold: bool",
++ },
++ },
++ .{
++ .name = "@setEvalBranchQuota",
++ .signature = "@setEvalBranchQuota(comptime new_quota: u32)",
++ .snippet = "@setEvalBranchQuota(${1:comptime new_quota: u32})",
++ .documentation =
++ \\Changes the maximum number of backwards branches that compile-time code execution can use before giving up and making a compile error.
++ \\
++ \\If the `new_quota` is smaller than the default quota (`1000`) or a previously explicitly set quota, it is ignored.
++ \\
++ \\Example:
++ \\
++ \\```zig
++ \\test "foo" {
++ \\ comptime {
++ \\ var i = 0;
++ \\ while (i < 1001) : (i += 1) {}
++ \\ }
++ \\}
++ \\```
++ \\
++ \\Now we use `@setEvalBranchQuota`:</p> {#code_begin|test|setEvalBranchQuota#} test "foo" { comptime { @setEvalBranchQuota(1001); var i = 0; while (i < 1001) : (i += 1) {} } }`
++ ,
++ .arguments = &.{
++ "comptime new_quota: u32",
++ },
++ },
++ .{
++ .name = "@setFloatMode",
++ .signature = "@setFloatMode(comptime mode: @import(\"std\").builtin.FloatMode)",
++ .snippet = "@setFloatMode(${1:comptime mode: @import(\"std\").builtin.FloatMode})",
++ .documentation =
++ \\Sets the floating point mode of the current scope. Possible values are:
++ \\
++ \\```zig
++ \\pub const FloatMode = enum {
++ \\ Strict,
++ \\ Optimized,
++ \\};
++ \\```
++ \\
++ \\ - `Strict` (default) - Floating point operations follow strict IEEE compliance.
++ \\ - `Optimized` - Floating point operations may do all of the following: <ul>
++ \\ - Assume the arguments and result are not NaN. Optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined.
++ \\ - Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined.
++ \\ - Treat the sign of a zero argument or result as insignificant.
++ \\ - Use the reciprocal of an argument rather than perform division.
++ \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add).
++ \\ - Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate). This is equivalent to `-ffast-math` in GCC.</ul>
++ \\
++ \\The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block.
++ ,
++ .arguments = &.{
++ "comptime mode: @import(\"std\").builtin.FloatMode",
++ },
++ },
++ .{
++ .name = "@setRuntimeSafety",
++ .signature = "@setRuntimeSafety(comptime safety_on: bool) void",
++ .snippet = "@setRuntimeSafety(${1:comptime safety_on: bool})",
++ .documentation =
++ \\Sets whether runtime safety checks are enabled for the scope that contains the function call.
++ \\
++ \\```zig
++ \\test "@setRuntimeSafety" {
++ \\ // The builtin applies to the scope that it is called in. So here, integer overflow
++ \\ // will not be caught in ReleaseFast and ReleaseSmall modes:
++ \\ // var x: u8 = 255;
++ \\ // x += 1; // undefined behavior in ReleaseFast/ReleaseSmall modes.
++ \\ {
++ \\ // However this block has safety enabled, so safety checks happen here,
++ \\ // even in ReleaseFast and ReleaseSmall modes.
++ \\ @setRuntimeSafety(true);
++ \\ var x: u8 = 255;
++ \\ x += 1;
++ \\
++ \\ {
++ \\ // The value can be overridden at any scope. So here integer overflow
++ \\ // would not be caught in any build mode.
++ \\ @setRuntimeSafety(false);
++ \\ // var x: u8 = 255;
++ \\ // x += 1; // undefined behavior in all build modes.
++ \\ }
++ \\ }
++ \\}
++ \\```
++ \\
++ \\Note: it is [planned](https://github.com/ziglang/zig/issues/978) to replace `@setRuntimeSafety` with `@optimizeFor`
++ ,
++ .arguments = &.{
++ "comptime safety_on: bool",
++ },
++ },
++ .{
++ .name = "@shlExact",
++ .signature = "@shlExact(value: T, shift_amt: Log2T) T",
++ .snippet = "@shlExact(${1:value: T}, ${2:shift_amt: Log2T})",
++ .documentation =
++ \\Performs the left shift operation (`<<`). For unsigned integers, the result is [undefined](https://ziglang.org/documentation/0.9.1/#undefined) if any 1 bits are shifted out. For signed integers, the result is [undefined](https://ziglang.org/documentation/0.9.1/#undefined) if any bits that disagree with the resultant sign bit are shifted out.
++ \\
++ \\The type of `shift_amt` is an unsigned integer with `log2(T.bit_count)` bits. This is because `shift_amt >= T.bit_count` is undefined behavior.
++ ,
++ .arguments = &.{
++ "value: T",
++ "shift_amt: Log2T",
++ },
++ },
++ .{
++ .name = "@shlWithOverflow",
++ .signature = "@shlWithOverflow(comptime T: type, a: T, shift_amt: Log2T, result: *T) bool",
++ .snippet = "@shlWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:shift_amt: Log2T}, ${4:result: *T})",
++ .documentation =
++ \\Performs `result.* = a << b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
++ \\
++ \\The type of `shift_amt` is an unsigned integer with `log2(T.bit_count)` bits. This is because `shift_amt >= T.bit_count` is undefined behavior.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "a: T",
++ "shift_amt: Log2T",
++ "result: *T",
++ },
++ },
++ .{
++ .name = "@shrExact",
++ .signature = "@shrExact(value: T, shift_amt: Log2T) T",
++ .snippet = "@shrExact(${1:value: T}, ${2:shift_amt: Log2T})",
++ .documentation =
++ \\Performs the right shift operation (`>>`). Caller guarantees that the shift will not shift any 1 bits out.
++ \\
++ \\The type of `shift_amt` is an unsigned integer with `log2(T.bit_count)` bits. This is because `shift_amt >= T.bit_count` is undefined behavior.
++ ,
++ .arguments = &.{
++ "value: T",
++ "shift_amt: Log2T",
++ },
++ },
++ .{
++ .name = "@shuffle",
++ .signature = "@shuffle(comptime E: type, a: std.meta.Vector(a_len, E), b: std.meta.Vector(b_len, E), comptime mask: std.meta.Vector(mask_len, i32)) std.meta.Vector(mask_len, E)",
++ .snippet = "@shuffle(${1:comptime E: type}, ${2:a: std.meta.Vector(a_len, E)}, ${3:b: std.meta.Vector(b_len, E)}, ${4:comptime mask: std.meta.Vector(mask_len, i32)})",
++ .documentation =
++ \\Constructs a new [vector](https://ziglang.org/documentation/0.9.1/#Vectors) by selecting elements from `a` and `b` based on `mask`.
++ \\
++ \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator from indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`).
++ \\
++ \\For each element of `mask`, if it or the selected value from `a` or `b` is `undefined`, then the resulting element is `undefined`.
++ \\
++ \\`a_len` and `b_len` may differ in length. Out-of-bounds element indexes in `mask` result in compile errors.
++ \\
++ \\If `a` or `b` is `undefined`, it is equivalent to a vector of all `undefined` with the same length as the other vector. If both vectors are `undefined`, `@shuffle` returns a vector with all elements `undefined`.
++ \\
++ \\`E` must be an [integer](https://ziglang.org/documentation/0.9.1/#Integers), [float](https://ziglang.org/documentation/0.9.1/#Floats), [pointer](https://ziglang.org/documentation/0.9.1/#Pointers), or `bool`. The mask may be any vector length, and its length determines the result length.</p> {#code_begin|test|vector_shuffle#} const std = @import("std"); const Vector = std.meta.Vector; const expect = std.testing.expect; test "vector @shuffle" { const a: Vector(7, u8) = [_]u8{ 'o', 'l', 'h', 'e', 'r', 'z', 'w' }; const b: Vector(4, u8) = [_]u8{ 'w', 'd', '!', 'x' }; // To shuffle within a single vector, pass undefined as the second argument. // Notice that we can re-order, duplicate, or omit elements of the input vector const mask1: Vector(5, i32) = [_]i32{ 2, 3, 1, 1, 0 }; const res1: Vector(5, u8) = @shuffle(u8, a, undefined, mask1); try expect(std.mem.eql(u8, &@as([5]u8, res1), "hello")); // Combining two vectors const mask2: Vector(6, i32) = [_]i32{ -1, 0, 4, 1, -2, -3 }
; const res2: Vector(6, u8) = @shuffle(u8, a, b, mask2); try expect(std.mem.eql(u8, &@as([6]u8, res2), "world!")); }`
++ ,
++ .arguments = &.{
++ "comptime E: type",
++ "a: std.meta.Vector(a_len, E)",
++ "b: std.meta.Vector(b_len, E)",
++ "comptime mask: std.meta.Vector(mask_len, i32)",
++ },
++ },
++ .{
++ .name = "@sizeOf",
++ .signature = "@sizeOf(comptime T: type) comptime_int",
++ .snippet = "@sizeOf(${1:comptime T: type})",
++ .documentation =
++ \\This function returns the number of bytes it takes to store `T` in memory. The result is a target-specific compile time constant.
++ \\
++ \\This size may contain padding bytes. If there were two consecutive T in memory, this would be the offset in bytes between element at index 0 and the element at index 1. For [integer](https://ziglang.org/documentation/0.9.1/#Integers), consider whether you want to use `@sizeOf(T)` or `@typeInfo(T).Int.bits`.
++ \\
++ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ },
++ },
++ .{
++ .name = "@splat",
++ .signature = "@splat(comptime len: u32, scalar: anytype) std.meta.Vector(len, @TypeOf(scalar))",
++ .snippet = "@splat(${1:comptime len: u32}, ${2:scalar: anytype})",
++ .documentation =
++ \\Produces a vector of length `len` where each element is the value `scalar`:</p> {#code_begin|test|vector_splat#} const std = @import("std"); const expect = std.testing.expect; test "vector @splat" { const scalar: u32 = 5; const result = @splat(4, scalar); comptime try expect(@TypeOf(result) == std.meta.Vector(4, u32)); try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 })); }`
++ \\
++ \\`scalar` must be an [integer](https://ziglang.org/documentation/0.9.1/#Integers), [bool](https://ziglang.org/documentation/0.9.1/#Primitive-Types), [float](https://ziglang.org/documentation/0.9.1/#Floats), or [pointer](https://ziglang.org/documentation/0.9.1/#Pointers).
++ ,
++ .arguments = &.{
++ "comptime len: u32",
++ "scalar: anytype",
++ },
++ },
++ .{
++ .name = "@reduce",
++ .signature = "@reduce(comptime op: std.builtin.ReduceOp, value: anytype) std.meta.Child(value)",
++ .snippet = "@reduce(${1:comptime op: std.builtin.ReduceOp}, ${2:value: anytype})",
++ .documentation =
++ \\Transforms a [vector](https://ziglang.org/documentation/0.9.1/#Vectors) into a scalar value by performing a sequential horizontal reduction of its elements using the specified operator `op`.
++ \\
++ \\Not every operator is available for every vector element type:
++ \\ - `.And`, `.Or`, `.Xor` are available for `bool` vectors,
++ \\ - `.Min`, `.Max`, `.Add`, `.Mul` are available for [floating point](https://ziglang.org/documentation/0.9.1/#Floats) vectors,
++ \\ - Every operator is available for [integer](https://ziglang.org/documentation/0.9.1/#Integers) vectors.
++ \\
++ \\Note that `.Add` and `.Mul` reductions on integral types are wrapping; when applied on floating point types the operation associativity is preserved, unless the float mode is set to `Optimized`.</p> {#code_begin|test|vector_reduce#} const std = @import("std"); const expect = std.testing.expect; test "vector @reduce" { const value: std.meta.Vector(4, i32) = [_]i32{ 1, -1, 1, -1 }; const result = value > @splat(4, @as(i32, 0)); // result is { true, false, true, false }; comptime try expect(@TypeOf(result) == std.meta.Vector(4, bool)); const is_all_true = @reduce(.And, result); comptime try expect(@TypeOf(is_all_true) == bool); try expect(is_all_true == false); }`
++ ,
++ .arguments = &.{
++ "comptime op: std.builtin.ReduceOp",
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@src",
++ .signature = "@src() std.builtin.SourceLocation",
++ .snippet = "@src()",
++ .documentation =
++ \\Returns a `SourceLocation` struct representing the function's name and location in the source code. This must be called in a function.</p> {#code_begin|test|source_location#} const std = @import("std"); const expect = std.testing.expect; test "@src" { try doTheTest(); } fn doTheTest() !void { const src = @src(); try expect(src.line == 9); try expect(src.column == 17); try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest")); try expect(std.mem.endsWith(u8, src.file, "source_location.zig")); }`
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@sqrt",
++ .signature = "@sqrt(value: anytype) @TypeOf(value)",
++ .snippet = "@sqrt(${1:value: anytype})",
++ .documentation =
++ \\Performs the square root of a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@sin",
++ .signature = "@sin(value: anytype) @TypeOf(value)",
++ .snippet = "@sin(${1:value: anytype})",
++ .documentation =
++ \\Sine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@cos",
++ .signature = "@cos(value: anytype) @TypeOf(value)",
++ .snippet = "@cos(${1:value: anytype})",
++ .documentation =
++ \\Cosine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@exp",
++ .signature = "@exp(value: anytype) @TypeOf(value)",
++ .snippet = "@exp(${1:value: anytype})",
++ .documentation =
++ \\Base-e exponential function on a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@exp2",
++ .signature = "@exp2(value: anytype) @TypeOf(value)",
++ .snippet = "@exp2(${1:value: anytype})",
++ .documentation =
++ \\Base-2 exponential function on a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@log",
++ .signature = "@log(value: anytype) @TypeOf(value)",
++ .snippet = "@log(${1:value: anytype})",
++ .documentation =
++ \\Returns the natural logarithm of a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@log2",
++ .signature = "@log2(value: anytype) @TypeOf(value)",
++ .snippet = "@log2(${1:value: anytype})",
++ .documentation =
++ \\Returns the logarithm to the base 2 of a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@log10",
++ .signature = "@log10(value: anytype) @TypeOf(value)",
++ .snippet = "@log10(${1:value: anytype})",
++ .documentation =
++ \\Returns the logarithm to the base 10 of a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@fabs",
++ .signature = "@fabs(value: anytype) @TypeOf(value)",
++ .snippet = "@fabs(${1:value: anytype})",
++ .documentation =
++ \\Returns the absolute value of a floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@floor",
++ .signature = "@floor(value: anytype) @TypeOf(value)",
++ .snippet = "@floor(${1:value: anytype})",
++ .documentation =
++ \\Returns the largest integral value not greater than the given floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@ceil",
++ .signature = "@ceil(value: anytype) @TypeOf(value)",
++ .snippet = "@ceil(${1:value: anytype})",
++ .documentation =
++ \\Returns the smallest integral value not less than the given floating point number. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@trunc",
++ .signature = "@trunc(value: anytype) @TypeOf(value)",
++ .snippet = "@trunc(${1:value: anytype})",
++ .documentation =
++ \\Rounds the given floating point number to an integer, towards zero. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@round",
++ .signature = "@round(value: anytype) @TypeOf(value)",
++ .snippet = "@round(${1:value: anytype})",
++ .documentation =
++ \\Rounds the given floating point number to an integer, away from zero. Uses a dedicated hardware instruction when available.
++ \\
++ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@subWithOverflow",
++ .signature = "@subWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
++ .snippet = "@subWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
++ .documentation =
++ \\Performs `result.* = a - b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "a: T",
++ "b: T",
++ "result: *T",
++ },
++ },
++ .{
++ .name = "@tagName",
++ .signature = "@tagName(value: anytype) [:0]const u8",
++ .snippet = "@tagName(${1:value: anytype})",
++ .documentation =
++ \\Converts an enum value or union value to a string literal representing the name.
++ \\
++ \\If the enum is non-exhaustive and the tag value does not map to a name, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
++ ,
++ .arguments = &.{
++ "value: anytype",
++ },
++ },
++ .{
++ .name = "@This",
++ .signature = "@This() type",
++ .snippet = "@This()",
++ .documentation =
++ \\Returns the innermost struct, enum, or union that this function call is inside. This can be useful for an anonymous struct that needs to refer to itself:</p> {#code_begin|test|this_innermost#} const std = @import("std"); const expect = std.testing.expect; test "@This()" { var items = [_]i32{ 1, 2, 3, 4 }; const list = List(i32){ .items = items[0..] }; try expect(list.length() == 4); } fn List(comptime T: type) type { return struct { const Self = @This(); items: []T, fn length(self: Self) usize { return self.items.len; } }; }`
++ \\
++ \\When `@This()` is used at file scope, it returns a reference to the struct that corresponds to the current file.
++ ,
++ .arguments = &.{},
++ },
++ .{
++ .name = "@truncate",
++ .signature = "@truncate(comptime T: type, integer: anytype) T",
++ .snippet = "@truncate(${1:comptime T: type}, ${2:integer: anytype})",
++ .documentation =
++ \\This function truncates bits from an integer type, resulting in a smaller or same-sized integer type.
++ \\
++ \\This function always truncates the significant bits of the integer, regardless of endianness on the target platform.
++ \\
++ \\Calling `@truncate` on a number out of range of the destination type is well defined and working code:
++ \\
++ \\```zig
++ \\const std = @import("std");
++ \\const expect = std.testing.expect;
++ \\
++ \\test "integer truncation" {
++ \\ var a: u16 = 0xabcd;
++ \\ var b: u8 = @truncate(u8, a);
++ \\ try expect(b == 0xcd);
++ \\}
++ \\```
++ \\
++ \\Use [@intCast](https://ziglang.org/documentation/0.9.1/#intCast) to convert numbers guaranteed to fit the destination type.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ "integer: anytype",
++ },
++ },
++ .{
++ .name = "@Type",
++ .signature = "@Type(comptime info: std.builtin.TypeInfo) type",
++ .snippet = "@Type(${1:comptime info: std.builtin.TypeInfo})",
++ .documentation =
++ \\This function is the inverse of [@typeInfo](https://ziglang.org/documentation/0.9.1/#typeInfo). It reifies type information into a `type`.
++ \\
++ \\It is available for the following types:
++ \\ - `type`
++ \\ - `noreturn`
++ \\ - `void`
++ \\ - `bool`
++ \\ - [Integers](https://ziglang.org/documentation/0.9.1/#Integers) - The maximum bit count for an integer type is `65535`.
++ \\ - [Floats](https://ziglang.org/documentation/0.9.1/#Floats)
++ \\ - [Pointers](https://ziglang.org/documentation/0.9.1/#Pointers)
++ \\ - `comptime_int`
++ \\ - `comptime_float`
++ \\ - `@TypeOf(undefined)`
++ \\ - `@TypeOf(null)`
++ \\ - [Arrays](https://ziglang.org/documentation/0.9.1/#Arrays)
++ \\ - [Optionals](https://ziglang.org/documentation/0.9.1/#Optionals)
++ \\ - [Error Set Type](https://ziglang.org/documentation/0.9.1/#Error-Set-Type)
++ \\ - [Error Union Type](https://ziglang.org/documentation/0.9.1/#Error-Union-Type)
++ \\ - [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors)
++ \\ - [opaque](https://ziglang.org/documentation/0.9.1/#opaque)
++ \\ - [@Frame](https://ziglang.org/documentation/0.9.1/#Frame)
++ \\ - `anyframe`
++ \\ - [struct](https://ziglang.org/documentation/0.9.1/#struct)
++ \\ - [enum](https://ziglang.org/documentation/0.9.1/#enum)
++ \\ - [Enum Literals](https://ziglang.org/documentation/0.9.1/#Enum-Literals)
++ \\ - [union](https://ziglang.org/documentation/0.9.1/#union)
++ \\
++ \\For these types, `@Type` is not available:
++ \\ - [Functions](https://ziglang.org/documentation/0.9.1/#Functions)
++ \\ - BoundFn
++ ,
++ .arguments = &.{
++ "comptime info: std.builtin.TypeInfo",
++ },
++ },
++ .{
++ .name = "@typeInfo",
++ .signature = "@typeInfo(comptime T: type) std.builtin.TypeInfo",
++ .snippet = "@typeInfo(${1:comptime T: type})",
++ .documentation =
++ \\Provides type reflection.
++ \\
++ \\Type information of [structs](https://ziglang.org/documentation/0.9.1/#struct), [unions](https://ziglang.org/documentation/0.9.1/#union), [enums](https://ziglang.org/documentation/0.9.1/#enum), and [error sets](https://ziglang.org/documentation/0.9.1/#Error-Set-Type) has fields which are are guaranteed to be in the same order as appearance in the source file.
++ \\
++ \\Type information of [structs](https://ziglang.org/documentation/0.9.1/#struct), [unions](https://ziglang.org/documentation/0.9.1/#union), [enums](https://ziglang.org/documentation/0.9.1/#enum), and [opaques](https://ziglang.org/documentation/0.9.1/#opaque) has declarations, which are also guaranteed to be in the same order as appearance in the source file.
++ ,
++ .arguments = &.{
++ "comptime T: type",
++ },
++ },
++ .{
++ .name = "@typeName",
++ .signature = "@typeName(T: type) *const [N:0]u8",
++ .snippet = "@typeName(${1:T: type})",
++ .documentation =
++ \\This function returns the string representation of a type, as an array. It is equivalent to a string literal of the type name.
++ ,
++ .arguments = &.{
++ "T: type",
++ },
++ },
++ .{
++ .name = "@TypeOf",
++ .signature = "@TypeOf(...) type",
++ .snippet = "@TypeOf(${1:...})",
++ .documentation =
++ \\`@TypeOf` is a special builtin function that takes any (nonzero) number of expressions as parameters and returns the type of the result, using [Peer Type Resolution](https://ziglang.org/documentation/0.9.1/#Peer-Type-Resolution).
++ \\
++ \\The expressions are evaluated, however they are guaranteed to have no *runtime* side-effects:</p> {#code_begin|test|no_runtime_side_effects#} const std = @import("std"); const expect = std.testing.expect; test "no runtime side effects" { var data: i32 = 0; const T = @TypeOf(foo(i32, &data)); comptime try expect(T == i32); try expect(data == 0); } fn foo(comptime T: type, ptr: *T) T { ptr.* += 1; return ptr.*; }`
++ ,
++ .arguments = &.{
++ "...",
++ },
++ },
++ .{
++ .name = "@unionInit",
++ .signature = "@unionInit(comptime Union: type, comptime active_field_name: []const u8, init_expr) Union",
++ .snippet = "@unionInit(${1:comptime Union: type}, ${2:comptime active_field_name: []const u8}, ${3:init_expr})",
++ .documentation =
++ \\This is the same thing as [union](https://ziglang.org/documentation/0.9.1/#union) initialization syntax, except that the field name is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known value rather than an identifier token.
++ \\
++ \\`@unionInit` forwards its [result location](https://ziglang.org/documentation/0.9.1/#Result-Location-Semantics) to `init_expr`.
++ ,
++ .arguments = &.{
++ "comptime Union: type",
++ "comptime active_field_name: []const u8",
++ "init_expr",
++ },
++ },
++};
+diff --git a/src/data/data.zig b/src/data/data.zig
+index f6e3b049..21257bfe 100644
+--- a/src/data/data.zig
++++ b/src/data/data.zig
+@@ -7,4 +7,6 @@ pub usingnamespace switch (build_options.data_version) {
+ .@"0.8.0" => @import("0.8.0.zig"),
+ .@"0.8.1" => @import("0.8.1.zig"),
+ .@"0.9.0" => @import("0.9.0.zig"),
++ .@"0.9.1" => @import("0.9.1.zig"),
++ .@"0.10.0" => @import("0.10.0.zig"),
+ };
+diff --git a/src/data/master.zig b/src/data/master.zig
+index 917d3fe2..9eacf7b5 100644
+--- a/src/data/master.zig
++++ b/src/data/master.zig
+@@ -7,6 +7,18 @@ const Builtin = struct {
+ };
+
+ pub const builtins = [_]Builtin{
++ .{
++ .name = "@addrSpaceCast",
++ .signature = "@addrSpaceCast(comptime addrspace: std.builtin.AddressSpace, ptr: anytype) anytype",
++ .snippet = "@addrSpaceCast(${1:comptime addrspace: std.builtin.AddressSpace}, ${2:ptr: anytype})",
++ .documentation =
++ \\Converts a pointer from one address space to another. Depending on the current target and address spaces, this cast may be a no-op, a complex operation, or illegal. If the cast is legal, then the resulting pointer points to the same memory location as the pointer operand. It is always valid to cast a pointer between the same address spaces.
++ ,
++ .arguments = &.{
++ "comptime addrspace: std.builtin.AddressSpace",
++ "ptr: anytype",
++ },
++ },
+ .{
+ .name = "@addWithOverflow",
+ .signature = "@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
+@@ -26,7 +38,7 @@ pub const builtins = [_]Builtin{
+ .signature = "@alignCast(comptime alignment: u29, ptr: anytype) anytype",
+ .snippet = "@alignCast(${1:comptime alignment: u29}, ${2:ptr: anytype})",
+ .documentation =
+- \\`ptr` can be `*T`, `fn()`, `?*T`, `?fn()`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value.
++ \\`ptr` can be `*T`, `?*T`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value.
+ \\
+ \\A [pointer alignment safety check](https://ziglang.org/documentation/master/#Incorrect-Pointer-Alignment) is added to the generated code to make sure the pointer is aligned as promised.
+ ,
+@@ -222,7 +234,7 @@ pub const builtins = [_]Builtin{
+ .signature = "@mulAdd(comptime T: type, a: T, b: T, c: T) T",
+ .snippet = "@mulAdd(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:c: T})",
+ .documentation =
+- \\Fused multiply add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate.
++ \\Fused multiply-add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate.
+ \\
+ \\Supports [Floats](https://ziglang.org/documentation/master/#Floats) and [Vectors](https://ziglang.org/documentation/master/#Vectors) of floats.
+ ,
+@@ -474,8 +486,6 @@ pub const builtins = [_]Builtin{
+ \\}
+ \\```
+ \\
+- \\will output:
+- \\
+ \\If all `@compileLog` calls are removed or not encountered by analysis, the program compiles successfully and the generated executable prints:</p> {#code_begin|test|without_compileLog#} const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; val1 = val1 + 1; break :blk val1; }; test "main" { print("Runtime in main, num1 = {}.\n", .{num1}); }`
+ ,
+ .arguments = &.{
+@@ -791,7 +801,7 @@ pub const builtins = [_]Builtin{
+ .documentation =
+ \\This function returns the base pointer of the current stack frame.
+ \\
+- \\The implications of this are target specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations.
++ \\The implications of this are target-specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations.
+ \\
+ \\This function is only valid within function scope.
+ ,
+@@ -853,8 +863,8 @@ pub const builtins = [_]Builtin{
+ \\
+ \\The following packages are always available:
+ \\ - `@import("std")` - Zig Standard Library
+- \\ - `@import("builtin")` - Target-specific information The command `zig build-exe --show-builtin` outputs the source to stdout for reference.
+- \\ - `@import("root")` - Points to the root source file This is usually `src/main.zig` but it depends on what file is chosen to be built.
++ \\ - `@import("builtin")` - Target-specific information. The command `zig build-exe --show-builtin` outputs the source to stdout for reference.
++ \\ - `@import("root")` - Points to the root source file. This is usually `src/main.zig` but it depends on what file is chosen to be built.
+ ,
+ .arguments = &.{
+ "comptime path: []u8",
+@@ -1117,7 +1127,7 @@ pub const builtins = [_]Builtin{
+ .signature = "@prefetch(ptr: anytype, comptime options: std.builtin.PrefetchOptions)",
+ .snippet = "@prefetch(${1:ptr: anytype}, ${2:comptime options: std.builtin.PrefetchOptions})",
+ .documentation =
+- \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a noop. This function has no effect on the behavior of the program, only on the performance characteristics.
++ \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a no-op. This function has no effect on the behavior of the program, only on the performance characteristics.
+ \\
+ \\The `ptr` argument may be any pointer type and determines the memory address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no illegal behavior will result.
+ \\
+@@ -1147,11 +1157,7 @@ pub const builtins = [_]Builtin{
+ .signature = "@ptrToInt(value: anytype) usize",
+ .snippet = "@ptrToInt(${1:value: anytype})",
+ .documentation =
+- \\Converts `value` to a `usize` which is the address of the pointer. `value` can be one of these types:
+- \\ - `*T`
+- \\ - `?*T`
+- \\ - `fn()`
+- \\ - `?fn()`
++ \\Converts `value` to a `usize` which is the address of the pointer. `value` can be `*T` or `?*T`.
+ \\
+ \\To convert the other way, use [@intToPtr](https://ziglang.org/documentation/master/#intToPtr)
+ ,
+@@ -1182,7 +1188,7 @@ pub const builtins = [_]Builtin{
+ .documentation =
+ \\This function returns the address of the next machine code instruction that will be executed when the current function returns.
+ \\
+- \\The implications of this are target specific and not consistent across all platforms.
++ \\The implications of this are target-specific and not consistent across all platforms.
+ \\
+ \\This function is only valid within function scope. If the function gets inlined into a calling function, the returned address will apply to the calling function.
+ ,
+@@ -1270,7 +1276,7 @@ pub const builtins = [_]Builtin{
+ \\ - Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined.
+ \\ - Treat the sign of a zero argument or result as insignificant.
+ \\ - Use the reciprocal of an argument rather than perform division.
+- \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add).
++ \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-add).
+ \\ - Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate). This is equivalent to `-ffast-math` in GCC.</ul>
+ \\
+ \\The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block.
+@@ -1367,7 +1373,7 @@ pub const builtins = [_]Builtin{
+ .documentation =
+ \\Constructs a new [vector](https://ziglang.org/documentation/master/#Vectors) by selecting elements from `a` and `b` based on `mask`.
+ \\
+- \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator from indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`).
++ \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator for indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`).
+ \\
+ \\For each element of `mask`, if it or the selected value from `a` or `b` is `undefined`, then the resulting element is `undefined`.
+ \\
+@@ -1737,7 +1743,7 @@ pub const builtins = [_]Builtin{
+ .documentation =
+ \\Provides type reflection.
+ \\
+- \\Type information of [structs](https://ziglang.org/documentation/master/#struct), [unions](https://ziglang.org/documentation/master/#union), [enums](https://ziglang.org/documentation/master/#enum), and [error sets](https://ziglang.org/documentation/master/#Error-Set-Type) has fields which are are guaranteed to be in the same order as appearance in the source file.
++ \\Type information of [structs](https://ziglang.org/documentation/master/#struct), [unions](https://ziglang.org/documentation/master/#union), [enums](https://ziglang.org/documentation/master/#enum), and [error sets](https://ziglang.org/documentation/master/#Error-Set-Type) has fields which are guaranteed to be in the same order as appearance in the source file.
+ \\
+ \\Type information of [structs](https://ziglang.org/documentation/master/#struct), [unions](https://ziglang.org/documentation/master/#union), [enums](https://ziglang.org/documentation/master/#enum), and [opaques](https://ziglang.org/documentation/master/#opaque) has declarations, which are also guaranteed to be in the same order as appearance in the source file.
+ ,
+diff --git a/src/shared.zig b/src/shared.zig
+index 25212203..fac7994a 100644
+--- a/src/shared.zig
++++ b/src/shared.zig
+@@ -7,4 +7,6 @@ pub const ZigVersion = enum {
+ @"0.8.0",
+ @"0.8.1",
+ @"0.9.0",
++ @"0.9.1",
++ @"0.10.0",
+ };
diff --git a/dev-zig/zls/zls-0.10.0.ebuild b/dev-zig/zls/zls-0.10.0.ebuild
new file mode 100644
index 000000000..3333f5a03
--- /dev/null
+++ b/dev-zig/zls/zls-0.10.0.ebuild
@@ -0,0 +1,56 @@
+# Copyright 2023 Gentoo Authors
+# Distributed under the terms of the GNU General Public License v2
+
+EAPI=8
+
+HOMEPAGE="https://github.com/zigtools/zls"
+DESCRIPTION="The officially unofficial Ziglang language server"
+
+KNOWN_FOLDERS_COMMIT="24845b0103e611c108d6bc334231c464e699742c"
+TRACY_COMMIT="f493d4aa8ba8141d9680473fad007d8a6348628e"
+SRC_URI="
+ https://github.com/ziglibs/known-folders/archive/${KNOWN_FOLDERS_COMMIT}.tar.gz -> known-folders-${KNOWN_FOLDERS_COMMIT}.tar.gz
+ https://github.com/wolfpld/tracy/archive/${TRACY_COMMIT}.tar.gz -> tracy-${TRACY_COMMIT}.tar.gz
+ https://github.com/zigtools/zls/archive/refs/tags/${PV}.tar.gz -> zls-${PV}.tar.gz
+"
+KEYWORDS="~amd64"
+
+LICENSE="MIT"
+SLOT="0"
+
+DEPEND="|| ( ~dev-lang/zig-0.10.1 ~dev-lang/zig-bin-0.10.1 )"
+RDEPEND="${DEPEND}"
+
+# see https://github.com/ziglang/zig/issues/3382
+# For now, Zig Build System doesn't support CFLAGS/LDFLAGS/etc.
+QA_FLAGS_IGNORED="usr/bin/zls"
+
+PATCHES=(
+ "${FILESDIR}/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch"
+)
+
+src_prepare() {
+ rm -r src/known-folders || die
+ mv "../known-folders-${KNOWN_FOLDERS_COMMIT}" src/known-folders || die
+ rm -r src/tracy || die
+ mv "../tracy-${TRACY_COMMIT}" src/zinput || die
+
+ default
+}
+
+src_compile() {
+ zig build -Drelease-safe -Ddata_version=0.10.0 --verbose || die
+}
+
+src_test() {
+ zig build test -Drelease-safe -Ddata_version=0.10.0 --verbose || die
+}
+
+src_install() {
+ DESTDIR="${ED}" zig build install --prefix /usr -Drelease-safe -Ddata_version=0.10.0 --verbose || die
+ dodoc README.md
+}
+
+pkg_postinst() {
+ elog "You can find more information about options here https://github.com/zigtools/zls#configuration-options"
+}
^ permalink raw reply related [flat|nested] 2+ messages in thread
* [gentoo-commits] repo/proj/guru:dev commit in: dev-zig/zls/, dev-zig/zls/files/
@ 2024-08-01 19:34 Eric Joldasov
0 siblings, 0 replies; 2+ messages in thread
From: Eric Joldasov @ 2024-08-01 19:34 UTC (permalink / raw
To: gentoo-commits
commit: 0e150278382ef29fe1efc9f8bae52cd37cb91348
Author: Eric Joldasov <bratishkaerik <AT> landless-city <DOT> net>
AuthorDate: Thu Aug 1 19:34:14 2024 +0000
Commit: Eric Joldasov <bratishkaerik <AT> getgoogleoff <DOT> me>
CommitDate: Thu Aug 1 19:34:20 2024 +0000
URL: https://gitweb.gentoo.org/repo/proj/guru.git/commit/?id=0e150278
dev-zig/zls: drop 0.10.0-r1
Fixes SizeViolation and TotalSizeViolation errors.
Signed-off-by: Eric Joldasov <bratishkaerik <AT> landless-city.net>
...0.0-add-builtin-data-for-new-zig-versions.patch | 3764 --------------------
dev-zig/zls/zls-0.10.0-r1.ebuild | 141 -
2 files changed, 3905 deletions(-)
diff --git a/dev-zig/zls/files/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch b/dev-zig/zls/files/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch
deleted file mode 100644
index 1810aef35..000000000
--- a/dev-zig/zls/files/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch
+++ /dev/null
@@ -1,3764 +0,0 @@
-From 95f21d0d23fa67c3c1688cfbfa53905ab1f6a7d5 Mon Sep 17 00:00:00 2001
-From: BratishkaErik <25210740+BratishkaErik@users.noreply.github.com>
-Date: Thu, 3 Nov 2022 02:24:51 +0600
-Subject: [PATCH] Add builtin data for 0.9.1 and 0.10.0 (#735)
-
-* Add builtin data for 0.9.1
-
-* Add builtin data for 0.10.0
-
-* Update builtin data for master
----
- src/data/0.10.0.zig | 1805 +++++++++++++++++++++++++++++++++++++++++++
- src/data/0.9.1.zig | 1777 ++++++++++++++++++++++++++++++++++++++++++
- src/data/data.zig | 2 +
- src/data/master.zig | 40 +-
- src/shared.zig | 2 +
- 5 files changed, 3609 insertions(+), 17 deletions(-)
- create mode 100644 src/data/0.10.0.zig
- create mode 100644 src/data/0.9.1.zig
-
-diff --git a/src/data/0.10.0.zig b/src/data/0.10.0.zig
-new file mode 100644
-index 00000000..82f7a25a
---- /dev/null
-+++ b/src/data/0.10.0.zig
-@@ -0,0 +1,1805 @@
-+const Builtin = struct {
-+ name: []const u8,
-+ signature: []const u8,
-+ snippet: []const u8,
-+ documentation: []const u8,
-+ arguments: []const []const u8,
-+};
-+
-+pub const builtins = [_]Builtin{
-+ .{
-+ .name = "@addrSpaceCast",
-+ .signature = "@addrSpaceCast(comptime addrspace: std.builtin.AddressSpace, ptr: anytype) anytype",
-+ .snippet = "@addrSpaceCast(${1:comptime addrspace: std.builtin.AddressSpace}, ${2:ptr: anytype})",
-+ .documentation =
-+ \\Converts a pointer from one address space to another. Depending on the current target and address spaces, this cast may be a no-op, a complex operation, or illegal. If the cast is legal, then the resulting pointer points to the same memory location as the pointer operand. It is always valid to cast a pointer between the same address spaces.
-+ ,
-+ .arguments = &.{
-+ "comptime addrspace: std.builtin.AddressSpace",
-+ "ptr: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@addWithOverflow",
-+ .signature = "@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
-+ .snippet = "@addWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
-+ .documentation =
-+ \\Performs `result.* = a + b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "a: T",
-+ "b: T",
-+ "result: *T",
-+ },
-+ },
-+ .{
-+ .name = "@alignCast",
-+ .signature = "@alignCast(comptime alignment: u29, ptr: anytype) anytype",
-+ .snippet = "@alignCast(${1:comptime alignment: u29}, ${2:ptr: anytype})",
-+ .documentation =
-+ \\`ptr` can be `*T`, `?*T`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value.
-+ \\
-+ \\A [pointer alignment safety check](https://ziglang.org/documentation/0.10.0/#Incorrect-Pointer-Alignment) is added to the generated code to make sure the pointer is aligned as promised.
-+ ,
-+ .arguments = &.{
-+ "comptime alignment: u29",
-+ "ptr: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@alignOf",
-+ .signature = "@alignOf(comptime T: type) comptime_int",
-+ .snippet = "@alignOf(${1:comptime T: type})",
-+ .documentation =
-+ \\This function returns the number of bytes that this type should be aligned to for the current target to match the C ABI. When the child type of a pointer has this alignment, the alignment can be omitted from the type.
-+ \\
-+ \\```zig
-+ \\const assert = @import("std").debug.assert;
-+ \\comptime {
-+ \\ assert(*u32 == *align(@alignOf(u32)) u32);
-+ \\}
-+ \\```
-+ \\
-+ \\The result is a target-specific compile time constant. It is guaranteed to be less than or equal to [@sizeOf(T)](https://ziglang.org/documentation/0.10.0/#@sizeOf).
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ },
-+ },
-+ .{
-+ .name = "@as",
-+ .signature = "@as(comptime T: type, expression) T",
-+ .snippet = "@as(${1:comptime T: type}, ${2:expression})",
-+ .documentation =
-+ \\Performs [Type Coercion](https://ziglang.org/documentation/0.10.0/#Type-Coercion). This cast is allowed when the conversion is unambiguous and safe, and is the preferred way to convert between types, whenever possible.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "expression",
-+ },
-+ },
-+ .{
-+ .name = "@asyncCall",
-+ .signature = "@asyncCall(frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8, result_ptr, function_ptr, args: anytype) anyframe->T",
-+ .snippet = "@asyncCall(${1:frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8}, ${2:result_ptr}, ${3:function_ptr}, ${4:args: anytype})",
-+ .documentation =
-+ \\`@asyncCall` performs an `async` call on a function pointer, which may or may not be an [async function](https://ziglang.org/documentation/0.10.0/#Async-Functions).
-+ \\
-+ \\The provided `frame_buffer` must be large enough to fit the entire function frame. This size can be determined with [@frameSize](https://ziglang.org/documentation/0.10.0/#frameSize). To provide a too-small buffer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
-+ \\
-+ \\`result_ptr` is optional ([null](https://ziglang.org/documentation/0.10.0/#null) may be provided). If provided, the function call will write its result directly to the result pointer, which will be available to read after [await](https://ziglang.org/documentation/0.10.0/#Async-and-Await) completes. Any result location provided to `await` will copy the result from `result_ptr`.</p> {#code_begin|test|async_struct_field_fn_pointer#} {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; test "async fn pointer in a struct field" { var data: i32 = 1; const Foo = struct { bar: fn (*i32) callconv(.Async) void, }; var foo = Foo{ .bar = func }; var bytes: [64]u8 align(@alignOf(@Frame(func))) = undefined; const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); try expect(data == 2); resume f; try expect(data == 4); } fn func(y: *i32) void { defer y.* += 2; y.* += 1; suspend {} }`
-+ ,
-+ .arguments = &.{
-+ "frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8",
-+ "result_ptr",
-+ "function_ptr",
-+ "args: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@atomicLoad",
-+ .signature = "@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: builtin.AtomicOrder) T",
-+ .snippet = "@atomicLoad(${1:comptime T: type}, ${2:ptr: *const T}, ${3:comptime ordering: builtin.AtomicOrder})",
-+ .documentation =
-+ \\This builtin function atomically dereferences a pointer and returns the value.
-+ \\
-+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "ptr: *const T",
-+ "comptime ordering: builtin.AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@atomicRmw",
-+ .signature = "@atomicRmw(comptime T: type, ptr: *T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) T",
-+ .snippet = "@atomicRmw(${1:comptime T: type}, ${2:ptr: *T}, ${3:comptime op: builtin.AtomicRmwOp}, ${4:operand: T}, ${5:comptime ordering: builtin.AtomicOrder})",
-+ .documentation =
-+ \\This builtin function atomically modifies memory and then returns the previous value.
-+ \\
-+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
-+ \\
-+ \\Supported operations:
-+ \\ - `.Xchg` - stores the operand unmodified. Supports enums, integers and floats.
-+ \\ - `.Add` - for integers, twos complement wraparound addition. Also supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats).
-+ \\ - `.Sub` - for integers, twos complement wraparound subtraction. Also supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats).
-+ \\ - `.And` - bitwise and
-+ \\ - `.Nand` - bitwise nand
-+ \\ - `.Or` - bitwise or
-+ \\ - `.Xor` - bitwise xor
-+ \\ - `.Max` - stores the operand if it is larger. Supports integers and floats.
-+ \\ - `.Min` - stores the operand if it is smaller. Supports integers and floats.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "ptr: *T",
-+ "comptime op: builtin.AtomicRmwOp",
-+ "operand: T",
-+ "comptime ordering: builtin.AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@atomicStore",
-+ .signature = "@atomicStore(comptime T: type, ptr: *T, value: T, comptime ordering: builtin.AtomicOrder) void",
-+ .snippet = "@atomicStore(${1:comptime T: type}, ${2:ptr: *T}, ${3:value: T}, ${4:comptime ordering: builtin.AtomicOrder})",
-+ .documentation =
-+ \\This builtin function atomically stores a value.
-+ \\
-+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "ptr: *T",
-+ "value: T",
-+ "comptime ordering: builtin.AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@bitCast",
-+ .signature = "@bitCast(comptime DestType: type, value: anytype) DestType",
-+ .snippet = "@bitCast(${1:comptime DestType: type}, ${2:value: anytype})",
-+ .documentation =
-+ \\Converts a value of one type to another type.
-+ \\
-+ \\Asserts that `@sizeOf(@TypeOf(value)) == @sizeOf(DestType)`.
-+ \\
-+ \\Asserts that `@typeInfo(DestType) != .Pointer`. Use `@ptrCast` or `@intToPtr` if you need this.
-+ \\
-+ \\Can be used for these things for example:
-+ \\ - Convert `f32` to `u32` bits
-+ \\ - Convert `i32` to `u32` preserving twos complement
-+ \\
-+ \\Works at compile-time if `value` is known at compile time. It's a compile error to bitcast a value of undefined layout; this means that, besides the restriction from types which possess dedicated casting builtins (enums, pointers, error sets), bare structs, error unions, slices, optionals, and any other type without a well-defined memory layout, also cannot be used in this operation.
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@bitOffsetOf",
-+ .signature = "@bitOffsetOf(comptime T: type, comptime field_name: []const u8) comptime_int",
-+ .snippet = "@bitOffsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})",
-+ .documentation =
-+ \\Returns the bit offset of a field relative to its containing struct.
-+ \\
-+ \\For non [packed structs](https://ziglang.org/documentation/0.10.0/#packed-struct), this will always be divisible by `8`. For packed structs, non-byte-aligned fields will share a byte offset, but they will have different bit offsets.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "comptime field_name: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@boolToInt",
-+ .signature = "@boolToInt(value: bool) u1",
-+ .snippet = "@boolToInt(${1:value: bool})",
-+ .documentation =
-+ \\Converts `true` to `@as(u1, 1)` and `false` to `@as(u1, 0)`.
-+ \\
-+ \\If the value is known at compile-time, the return type is `comptime_int` instead of `u1`.
-+ ,
-+ .arguments = &.{
-+ "value: bool",
-+ },
-+ },
-+ .{
-+ .name = "@bitSizeOf",
-+ .signature = "@bitSizeOf(comptime T: type) comptime_int",
-+ .snippet = "@bitSizeOf(${1:comptime T: type})",
-+ .documentation =
-+ \\This function returns the number of bits it takes to store `T` in memory if the type were a field in a packed struct/union. The result is a target-specific compile time constant.
-+ \\
-+ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ },
-+ },
-+ .{
-+ .name = "@breakpoint",
-+ .signature = "@breakpoint()",
-+ .snippet = "@breakpoint()",
-+ .documentation =
-+ \\This function inserts a platform-specific debug trap instruction which causes debuggers to break there.
-+ \\
-+ \\This function is only valid within function scope.
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@mulAdd",
-+ .signature = "@mulAdd(comptime T: type, a: T, b: T, c: T) T",
-+ .snippet = "@mulAdd(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:c: T})",
-+ .documentation =
-+ \\Fused multiply-add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "a: T",
-+ "b: T",
-+ "c: T",
-+ },
-+ },
-+ .{
-+ .name = "@byteSwap",
-+ .signature = "@byteSwap(operand: anytype) T",
-+ .snippet = "@byteSwap(${1:operand: anytype})",
-+ .documentation =
-+ \\`@TypeOf(operand)` must be an integer type or an integer vector type with bit count evenly divisible by 8.
-+ \\
-+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors).
-+ \\
-+ \\Swaps the byte order of the integer. This converts a big endian integer to a little endian integer, and converts a little endian integer to a big endian integer.
-+ \\
-+ \\Note that for the purposes of memory layout with respect to endianness, the integer type should be related to the number of bytes reported by [@sizeOf](https://ziglang.org/documentation/0.10.0/#sizeOf) bytes. This is demonstrated with `u24`. `@sizeOf(u24) == 4`, which means that a `u24` stored in memory takes 4 bytes, and those 4 bytes are what are swapped on a little vs big endian system. On the other hand, if `T` is specified to be `u24`, then only 3 bytes are reversed.
-+ ,
-+ .arguments = &.{
-+ "operand: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@bitReverse",
-+ .signature = "@bitReverse(integer: anytype) T",
-+ .snippet = "@bitReverse(${1:integer: anytype})",
-+ .documentation =
-+ \\`@TypeOf(anytype)` accepts any integer type or integer vector type.
-+ \\
-+ \\Reverses the bitpattern of an integer value, including the sign bit if applicable.
-+ \\
-+ \\For example 0b10110110 (`u8 = 182`, `i8 = -74`) becomes 0b01101101 (`u8 = 109`, `i8 = 109`).
-+ ,
-+ .arguments = &.{
-+ "integer: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@offsetOf",
-+ .signature = "@offsetOf(comptime T: type, comptime field_name: []const u8) comptime_int",
-+ .snippet = "@offsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})",
-+ .documentation =
-+ \\Returns the byte offset of a field relative to its containing struct.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "comptime field_name: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@call",
-+ .signature = "@call(options: std.builtin.CallOptions, function: anytype, args: anytype) anytype",
-+ .snippet = "@call(${1:options: std.builtin.CallOptions}, ${2:function: anytype}, ${3:args: anytype})",
-+ .documentation =
-+ \\Calls a function, in the same way that invoking an expression with parentheses does:
-+ \\
-+ \\```zig
-+ \\const expect = @import("std").testing.expect;
-+ \\
-+ \\test "noinline function call" {
-+ \\ try expect(@call(.{}, add, .{3, 9}) == 12);
-+ \\}
-+ \\
-+ \\fn add(a: i32, b: i32) i32 {
-+ \\ return a + b;
-+ \\}
-+ \\```
-+ \\
-+ \\`@call` allows more flexibility than normal function call syntax does. The `CallOptions` struct is reproduced here:</p> {#syntax_block|zig|builtin.CallOptions struct#} pub const CallOptions = struct { modifier: Modifier = .auto, /// Only valid when `Modifier` is `Modifier.async_kw`. stack: ?[]align(std.Target.stack_align) u8 = null, pub const Modifier = enum { /// Equivalent to function call syntax. auto, /// Equivalent to async keyword used with function call syntax. async_kw, /// Prevents tail call optimization. This guarantees that the return /// address will point to the callsite, as opposed to the callsite's /// callsite. If the call is otherwise required to be tail-called /// or inlined, a compile error is emitted instead. never_tail, /// Guarantees that the call will not be inlined. If the call is /// otherwise required to be inlined, a compile error is emitted instead. never_inline, /// Asserts that the function call will not suspend. This allows a /// non-async f
unction to call an async function. no_async, /// Guarantees that the call will be generated with tail call optimization. /// If this is not possible, a compile error is emitted instead. always_tail, /// Guarantees that the call will inlined at the callsite. /// If this is not possible, a compile error is emitted instead. always_inline, /// Evaluates the call at compile-time. If the call cannot be completed at /// compile-time, a compile error is emitted instead. compile_time, }; }; {#end_syntax_block#}
-+ ,
-+ .arguments = &.{
-+ "options: std.builtin.CallOptions",
-+ "function: anytype",
-+ "args: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@cDefine",
-+ .signature = "@cDefine(comptime name: []u8, value)",
-+ .snippet = "@cDefine(${1:comptime name: []u8}, ${2:value})",
-+ .documentation =
-+ \\This function can only occur inside `@cImport`.
-+ \\
-+ \\This appends `#define $name $value` to the `@cImport` temporary buffer.
-+ \\
-+ \\To define without a value, like this:`#define _GNU_SOURCE`
-+ \\
-+ \\Use the void value, like this:
-+ \\
-+ \\```zig
-+ \\@cDefine("_GNU_SOURCE", {})
-+ \\```
-+ ,
-+ .arguments = &.{
-+ "comptime name: []u8",
-+ "value",
-+ },
-+ },
-+ .{
-+ .name = "@cImport",
-+ .signature = "@cImport(expression) type",
-+ .snippet = "@cImport(${1:expression})",
-+ .documentation =
-+ \\This function parses C code and imports the functions, types, variables, and compatible macro definitions into a new empty struct type, and then returns that type.
-+ \\
-+ \\`expression` is interpreted at compile time. The builtin functions `@cInclude`, `@cDefine`, and `@cUndef` work within this expression, appending to a temporary buffer which is then parsed as C code.
-+ \\
-+ \\Usually you should only have one `@cImport` in your entire application, because it saves the compiler from invoking clang multiple times, and prevents inline functions from being duplicated.
-+ \\
-+ \\Reasons for having multiple `@cImport` expressions would be:
-+ \\ - To avoid a symbol collision, for example if foo.h and bar.h both `#define CONNECTION_COUNT`
-+ \\ - To analyze the C code with different preprocessor defines
-+ ,
-+ .arguments = &.{
-+ "expression",
-+ },
-+ },
-+ .{
-+ .name = "@cInclude",
-+ .signature = "@cInclude(comptime path: []u8)",
-+ .snippet = "@cInclude(${1:comptime path: []u8})",
-+ .documentation =
-+ \\This function can only occur inside `@cImport`.
-+ \\
-+ \\This appends `#include <$path>\n` to the `c_import` temporary buffer.
-+ ,
-+ .arguments = &.{
-+ "comptime path: []u8",
-+ },
-+ },
-+ .{
-+ .name = "@clz",
-+ .signature = "@clz(operand: anytype)",
-+ .snippet = "@clz(${1:operand: anytype})",
-+ .documentation =
-+ \\`@TypeOf(operand)` must be an integer type or an integer vector type.
-+ \\
-+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors).
-+ \\
-+ \\This function counts the number of most-significant (leading in a big-Endian sense) zeroes in an integer.
-+ \\
-+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
-+ \\
-+ \\If `operand` is zero, `@clz` returns the bit width of integer type `T`.
-+ ,
-+ .arguments = &.{
-+ "operand: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@cmpxchgStrong",
-+ .signature = "@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T",
-+ .snippet = "@cmpxchgStrong(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})",
-+ .documentation =
-+ \\This function performs a strong atomic compare exchange operation. It's the equivalent of this code, except atomic:
-+ \\
-+ \\```zig
-+ \\fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T {
-+ \\ const old_value = ptr.*;
-+ \\ if (old_value == expected_value) {
-+ \\ ptr.* = new_value;
-+ \\ return null;
-+ \\ } else {
-+ \\ return old_value;
-+ \\ }
-+ \\}
-+ \\```
-+ \\
-+ \\If you are using cmpxchg in a loop, [@cmpxchgWeak](https://ziglang.org/documentation/0.10.0/#cmpxchgWeak) is the better choice, because it can be implemented more efficiently in machine instructions.
-+ \\
-+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
-+ \\
-+ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).`
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "ptr: *T",
-+ "expected_value: T",
-+ "new_value: T",
-+ "success_order: AtomicOrder",
-+ "fail_order: AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@cmpxchgWeak",
-+ .signature = "@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T",
-+ .snippet = "@cmpxchgWeak(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})",
-+ .documentation =
-+ \\This function performs a weak atomic compare exchange operation. It's the equivalent of this code, except atomic:</p> {#syntax_block|zig|cmpxchgWeakButNotAtomic#} fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T { const old_value = ptr.*; if (old_value == expected_value and usuallyTrueButSometimesFalse()) { ptr.* = new_value; return null; } else { return old_value; } } {#end_syntax_block#}
-+ \\
-+ \\If you are using cmpxchg in a loop, the sporadic failure will be no problem, and `cmpxchgWeak` is the better choice, because it can be implemented more efficiently in machine instructions. However if you need a stronger guarantee, use [@cmpxchgStrong](https://ziglang.org/documentation/0.10.0/#cmpxchgStrong).
-+ \\
-+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
-+ \\
-+ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).`
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "ptr: *T",
-+ "expected_value: T",
-+ "new_value: T",
-+ "success_order: AtomicOrder",
-+ "fail_order: AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@compileError",
-+ .signature = "@compileError(comptime msg: []u8)",
-+ .snippet = "@compileError(${1:comptime msg: []u8})",
-+ .documentation =
-+ \\This function, when semantically analyzed, causes a compile error with the message `msg`.
-+ \\
-+ \\There are several ways that code avoids being semantically checked, such as using `if` or `switch` with compile time constants, and `comptime` functions.
-+ ,
-+ .arguments = &.{
-+ "comptime msg: []u8",
-+ },
-+ },
-+ .{
-+ .name = "@compileLog",
-+ .signature = "@compileLog(args: ...)",
-+ .snippet = "@compileLog(${1:args: ...})",
-+ .documentation =
-+ \\This function prints the arguments passed to it at compile-time.
-+ \\
-+ \\To prevent accidentally leaving compile log statements in a codebase, a compilation error is added to the build, pointing to the compile log statement. This error prevents code from being generated, but does not otherwise interfere with analysis.
-+ \\
-+ \\This function can be used to do "printf debugging" on compile-time executing code.
-+ \\
-+ \\```zig
-+ \\const print = @import("std").debug.print;
-+ \\
-+ \\const num1 = blk: {
-+ \\ var val1: i32 = 99;
-+ \\ @compileLog("comptime val1 = ", val1);
-+ \\ val1 = val1 + 1;
-+ \\ break :blk val1;
-+ \\};
-+ \\
-+ \\test "main" {
-+ \\ @compileLog("comptime in main");
-+ \\
-+ \\ print("Runtime in main, num1 = {}.\n", .{num1});
-+ \\}
-+ \\```
-+ \\
-+ \\If all `@compileLog` calls are removed or not encountered by analysis, the program compiles successfully and the generated executable prints:</p> {#code_begin|test|without_compileLog#} const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; val1 = val1 + 1; break :blk val1; }; test "main" { print("Runtime in main, num1 = {}.\n", .{num1}); }`
-+ ,
-+ .arguments = &.{
-+ "args: ...",
-+ },
-+ },
-+ .{
-+ .name = "@ctz",
-+ .signature = "@ctz(operand: anytype)",
-+ .snippet = "@ctz(${1:operand: anytype})",
-+ .documentation =
-+ \\`@TypeOf(operand)` must be an integer type or an integer vector type.
-+ \\
-+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors).
-+ \\
-+ \\This function counts the number of least-significant (trailing in a big-Endian sense) zeroes in an integer.
-+ \\
-+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
-+ \\
-+ \\If `operand` is zero, `@ctz` returns the bit width of integer type `T`.
-+ ,
-+ .arguments = &.{
-+ "operand: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@cUndef",
-+ .signature = "@cUndef(comptime name: []u8)",
-+ .snippet = "@cUndef(${1:comptime name: []u8})",
-+ .documentation =
-+ \\This function can only occur inside `@cImport`.
-+ \\
-+ \\This appends `#undef $name` to the `@cImport` temporary buffer.
-+ ,
-+ .arguments = &.{
-+ "comptime name: []u8",
-+ },
-+ },
-+ .{
-+ .name = "@divExact",
-+ .signature = "@divExact(numerator: T, denominator: T) T",
-+ .snippet = "@divExact(${1:numerator: T}, ${2:denominator: T})",
-+ .documentation =
-+ \\Exact division. Caller guarantees `denominator != 0` and `@divTrunc(numerator, denominator) * denominator == numerator`.
-+ \\ - `@divExact(6, 3) == 2`
-+ \\ - `@divExact(a, b) * b == a`
-+ \\
-+ \\For a function that returns a possible error code, use `@import("std").math.divExact`.
-+ ,
-+ .arguments = &.{
-+ "numerator: T",
-+ "denominator: T",
-+ },
-+ },
-+ .{
-+ .name = "@divFloor",
-+ .signature = "@divFloor(numerator: T, denominator: T) T",
-+ .snippet = "@divFloor(${1:numerator: T}, ${2:denominator: T})",
-+ .documentation =
-+ \\Floored division. Rounds toward negative infinity. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`.
-+ \\ - `@divFloor(-5, 3) == -2`
-+ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a`
-+ \\
-+ \\For a function that returns a possible error code, use `@import("std").math.divFloor`.
-+ ,
-+ .arguments = &.{
-+ "numerator: T",
-+ "denominator: T",
-+ },
-+ },
-+ .{
-+ .name = "@divTrunc",
-+ .signature = "@divTrunc(numerator: T, denominator: T) T",
-+ .snippet = "@divTrunc(${1:numerator: T}, ${2:denominator: T})",
-+ .documentation =
-+ \\Truncated division. Rounds toward zero. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`.
-+ \\ - `@divTrunc(-5, 3) == -1`
-+ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a`
-+ \\
-+ \\For a function that returns a possible error code, use `@import("std").math.divTrunc`.
-+ ,
-+ .arguments = &.{
-+ "numerator: T",
-+ "denominator: T",
-+ },
-+ },
-+ .{
-+ .name = "@embedFile",
-+ .signature = "@embedFile(comptime path: []const u8) *const [N:0]u8",
-+ .snippet = "@embedFile(${1:comptime path: []const u8})",
-+ .documentation =
-+ \\This function returns a compile time constant pointer to null-terminated, fixed-size array with length equal to the byte count of the file given by `path`. The contents of the array are the contents of the file. This is equivalent to a [string literal](https://ziglang.org/documentation/0.10.0/#String-Literals-and-Unicode-Code-Point-Literals) with the file contents.
-+ \\
-+ \\`path` is absolute or relative to the current file, just like `@import`.
-+ ,
-+ .arguments = &.{
-+ "comptime path: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@enumToInt",
-+ .signature = "@enumToInt(enum_or_tagged_union: anytype) anytype",
-+ .snippet = "@enumToInt(${1:enum_or_tagged_union: anytype})",
-+ .documentation =
-+ \\Converts an enumeration value into its integer tag type. When a tagged union is passed, the tag value is used as the enumeration value.
-+ \\
-+ \\If there is only one possible enum value, the result is a `comptime_int` known at [comptime](https://ziglang.org/documentation/0.10.0/#comptime).
-+ ,
-+ .arguments = &.{
-+ "enum_or_tagged_union: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@errorName",
-+ .signature = "@errorName(err: anyerror) [:0]const u8",
-+ .snippet = "@errorName(${1:err: anyerror})",
-+ .documentation =
-+ \\This function returns the string representation of an error. The string representation of `error.OutOfMem` is `"OutOfMem"`.
-+ \\
-+ \\If there are no calls to `@errorName` in an entire application, or all calls have a compile-time known value for `err`, then no error name table will be generated.
-+ ,
-+ .arguments = &.{
-+ "err: anyerror",
-+ },
-+ },
-+ .{
-+ .name = "@errorReturnTrace",
-+ .signature = "@errorReturnTrace() ?*builtin.StackTrace",
-+ .snippet = "@errorReturnTrace()",
-+ .documentation =
-+ \\If the binary is built with error return tracing, and this function is invoked in a function that calls a function with an error or error union return type, returns a stack trace object. Otherwise returns [null](https://ziglang.org/documentation/0.10.0/#null).
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@errorToInt",
-+ .signature = "@errorToInt(err: anytype) std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)",
-+ .snippet = "@errorToInt(${1:err: anytype})",
-+ .documentation =
-+ \\Supports the following types:
-+ \\ - [The Global Error Set](https://ziglang.org/documentation/0.10.0/#The-Global-Error-Set)
-+ \\ - [Error Set Type](https://ziglang.org/documentation/0.10.0/#Error-Set-Type)
-+ \\ - [Error Union Type](https://ziglang.org/documentation/0.10.0/#Error-Union-Type)
-+ \\
-+ \\Converts an error to the integer representation of an error.
-+ \\
-+ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes.
-+ ,
-+ .arguments = &.{
-+ "err: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@errSetCast",
-+ .signature = "@errSetCast(comptime T: DestType, value: anytype) DestType",
-+ .snippet = "@errSetCast(${1:comptime T: DestType}, ${2:value: anytype})",
-+ .documentation =
-+ \\Converts an error value from one error set to another error set. Attempting to convert an error which is not in the destination error set results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "comptime T: DestType",
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@export",
-+ .signature = "@export(declaration, comptime options: std.builtin.ExportOptions) void",
-+ .snippet = "@export(${1:declaration}, ${2:comptime options: std.builtin.ExportOptions})",
-+ .documentation =
-+ \\Creates a symbol in the output object file.
-+ \\
-+ \\`declaration` must be one of two things:
-+ \\ - An identifier (`x`) identifying a [function](https://ziglang.org/documentation/0.10.0/#Functions) or a [variable](https://ziglang.org/documentation/0.10.0/#Container-Level-Variables).
-+ \\ - Field access (`x.y`) looking up a [function](https://ziglang.org/documentation/0.10.0/#Functions) or a [variable](https://ziglang.org/documentation/0.10.0/#Container-Level-Variables).
-+ \\
-+ \\This builtin can be called from a [comptime](https://ziglang.org/documentation/0.10.0/#comptime) block to conditionally export symbols. When `declaration` is a function with the C calling convention and `options.linkage` is `Strong`, this is equivalent to the `export` keyword used on a function:
-+ \\
-+ \\```zig
-+ \\comptime {
-+ \\ @export(internalName, .{ .name = "foo", .linkage = .Strong });
-+ \\}
-+ \\
-+ \\fn internalName() callconv(.C) void {}
-+ \\```
-+ \\
-+ \\This is equivalent to:
-+ \\
-+ \\```zig
-+ \\export fn foo() void {}
-+ \\```
-+ \\
-+ \\Note that even when using `export`, the `@"foo"` syntax for [identifiers](https://ziglang.org/documentation/0.10.0/#Identifiers) can be used to choose any string for the symbol name:
-+ \\
-+ \\```zig
-+ \\export fn @"A function name that is a complete sentence."() void {}
-+ \\```
-+ \\
-+ \\When looking at the resulting object, you can see the symbol is used verbatim:
-+ \\
-+ \\```zig
-+ \\00000000000001f0 T A function name that is a complete sentence.
-+ \\```
-+ ,
-+ .arguments = &.{
-+ "declaration",
-+ "comptime options: std.builtin.ExportOptions",
-+ },
-+ },
-+ .{
-+ .name = "@extern",
-+ .signature = "@extern(T: type, comptime options: std.builtin.ExternOptions) *T",
-+ .snippet = "@extern(${1:T: type}, ${2:comptime options: std.builtin.ExternOptions})",
-+ .documentation =
-+ \\Creates a reference to an external symbol in the output object file.
-+ ,
-+ .arguments = &.{
-+ "T: type",
-+ "comptime options: std.builtin.ExternOptions",
-+ },
-+ },
-+ .{
-+ .name = "@fence",
-+ .signature = "@fence(order: AtomicOrder)",
-+ .snippet = "@fence(${1:order: AtomicOrder})",
-+ .documentation =
-+ \\The `fence` function is used to introduce happens-before edges between operations.
-+ \\
-+ \\`AtomicOrder` can be found with `@import("std").builtin.AtomicOrder`.
-+ ,
-+ .arguments = &.{
-+ "order: AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@field",
-+ .signature = "@field(lhs: anytype, comptime field_name: []const u8) (field)",
-+ .snippet = "@field(${1:lhs: anytype}, ${2:comptime field_name: []const u8})",
-+ .documentation =
-+ \\Performs field access by a compile-time string. Works on both fields and declarations.</p> {#code_begin|test|field_decl_access_by_string#} const std = @import("std"); const Point = struct { x: u32, y: u32, pub var z: u32 = 1; }; test "field access by string" { const expect = std.testing.expect; var p = Point{ .x = 0, .y = 0 }; @field(p, "x") = 4; @field(p, "y") = @field(p, "x") + 1; try expect(@field(p, "x") == 4); try expect(@field(p, "y") == 5); } test "decl access by string" { const expect = std.testing.expect; try expect(@field(Point, "z") == 1); @field(Point, "z") = 2; try expect(@field(Point, "z") == 2); }`
-+ ,
-+ .arguments = &.{
-+ "lhs: anytype",
-+ "comptime field_name: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@fieldParentPtr",
-+ .signature = "@fieldParentPtr(comptime ParentType: type, comptime field_name: []const u8, field_ptr: *T) *ParentType",
-+ .snippet = "@fieldParentPtr(${1:comptime ParentType: type}, ${2:comptime field_name: []const u8}, ${3:field_ptr: *T})",
-+ .documentation =
-+ \\Given a pointer to a field, returns the base pointer of a struct.
-+ ,
-+ .arguments = &.{
-+ "comptime ParentType: type",
-+ "comptime field_name: []const u8",
-+ "field_ptr: *T",
-+ },
-+ },
-+ .{
-+ .name = "@floatCast",
-+ .signature = "@floatCast(comptime DestType: type, value: anytype) DestType",
-+ .snippet = "@floatCast(${1:comptime DestType: type}, ${2:value: anytype})",
-+ .documentation =
-+ \\Convert from one float type to another. This cast is safe, but may cause the numeric value to lose precision.
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@floatToInt",
-+ .signature = "@floatToInt(comptime DestType: type, float: anytype) DestType",
-+ .snippet = "@floatToInt(${1:comptime DestType: type}, ${2:float: anytype})",
-+ .documentation =
-+ \\Converts the integer part of a floating point number to the destination type.
-+ \\
-+ \\If the integer part of the floating point number cannot fit in the destination type, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "float: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@frame",
-+ .signature = "@frame() *@Frame(func)",
-+ .snippet = "@frame()",
-+ .documentation =
-+ \\This function returns a pointer to the frame for a given function. This type can be [coerced](https://ziglang.org/documentation/0.10.0/#Type-Coercion) to `anyframe->T` and to `anyframe`, where `T` is the return type of the function in scope.
-+ \\
-+ \\This function does not mark a suspension point, but it does cause the function in scope to become an [async function](https://ziglang.org/documentation/0.10.0/#Async-Functions).
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@Frame",
-+ .signature = "@Frame(func: anytype) type",
-+ .snippet = "@Frame(${1:func: anytype})",
-+ .documentation =
-+ \\This function returns the frame type of a function. This works for [Async Functions](https://ziglang.org/documentation/0.10.0/#Async-Functions) as well as any function without a specific calling convention.
-+ \\
-+ \\This type is suitable to be used as the return type of [async](https://ziglang.org/documentation/0.10.0/#Async-and-Await) which allows one to, for example, heap-allocate an async function frame:</p> {#code_begin|test|heap_allocated_frame#} {#backend_stage1#} const std = @import("std"); test "heap allocated frame" { const frame = try std.heap.page_allocator.create(@Frame(func)); frame.* = async func(); } fn func() void { suspend {} }`
-+ ,
-+ .arguments = &.{
-+ "func: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@frameAddress",
-+ .signature = "@frameAddress() usize",
-+ .snippet = "@frameAddress()",
-+ .documentation =
-+ \\This function returns the base pointer of the current stack frame.
-+ \\
-+ \\The implications of this are target-specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations.
-+ \\
-+ \\This function is only valid within function scope.
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@frameSize",
-+ .signature = "@frameSize(func: anytype) usize",
-+ .snippet = "@frameSize(${1:func: anytype})",
-+ .documentation =
-+ \\This is the same as `@sizeOf(@Frame(func))`, where `func` may be runtime-known.
-+ \\
-+ \\This function is typically used in conjunction with [@asyncCall](https://ziglang.org/documentation/0.10.0/#asyncCall).
-+ ,
-+ .arguments = &.{
-+ "func: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@hasDecl",
-+ .signature = "@hasDecl(comptime Container: type, comptime name: []const u8) bool",
-+ .snippet = "@hasDecl(${1:comptime Container: type}, ${2:comptime name: []const u8})",
-+ .documentation =
-+ \\Returns whether or not a [struct](https://ziglang.org/documentation/0.10.0/#struct), [enum](https://ziglang.org/documentation/0.10.0/#enum), or [union](https://ziglang.org/documentation/0.10.0/#union) has a declaration matching `name`.</p> {#code_begin|test|hasDecl#} const std = @import("std"); const expect = std.testing.expect; const Foo = struct { nope: i32, pub var blah = "xxx"; const hi = 1; }; test "@hasDecl" { try expect(@hasDecl(Foo, "blah")); // Even though `hi` is private, @hasDecl returns true because this test is // in the same file scope as Foo. It would return false if Foo was declared // in a different file. try expect(@hasDecl(Foo, "hi")); // @hasDecl is for declarations; not fields. try expect(!@hasDecl(Foo, "nope")); try expect(!@hasDecl(Foo, "nope1234")); }`
-+ ,
-+ .arguments = &.{
-+ "comptime Container: type",
-+ "comptime name: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@hasField",
-+ .signature = "@hasField(comptime Container: type, comptime name: []const u8) bool",
-+ .snippet = "@hasField(${1:comptime Container: type}, ${2:comptime name: []const u8})",
-+ .documentation =
-+ \\Returns whether the field name of a struct, union, or enum exists.
-+ \\
-+ \\The result is a compile time constant.
-+ \\
-+ \\It does not include functions, variables, or constants.
-+ ,
-+ .arguments = &.{
-+ "comptime Container: type",
-+ "comptime name: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@import",
-+ .signature = "@import(comptime path: []u8) type",
-+ .snippet = "@import(${1:comptime path: []u8})",
-+ .documentation =
-+ \\This function finds a zig file corresponding to `path` and adds it to the build, if it is not already added.
-+ \\
-+ \\Zig source files are implicitly structs, with a name equal to the file's basename with the extension truncated. `@import` returns the struct type corresponding to the file.
-+ \\
-+ \\Declarations which have the `pub` keyword may be referenced from a different source file than the one they are declared in.
-+ \\
-+ \\`path` can be a relative path or it can be the name of a package. If it is a relative path, it is relative to the file that contains the `@import` function call.
-+ \\
-+ \\The following packages are always available:
-+ \\ - `@import("std")` - Zig Standard Library
-+ \\ - `@import("builtin")` - Target-specific information. The command `zig build-exe --show-builtin` outputs the source to stdout for reference.
-+ \\ - `@import("root")` - Points to the root source file. This is usually `src/main.zig` but it depends on what file is chosen to be built.
-+ ,
-+ .arguments = &.{
-+ "comptime path: []u8",
-+ },
-+ },
-+ .{
-+ .name = "@intCast",
-+ .signature = "@intCast(comptime DestType: type, int: anytype) DestType",
-+ .snippet = "@intCast(${1:comptime DestType: type}, ${2:int: anytype})",
-+ .documentation =
-+ \\Converts an integer to another integer while keeping the same numerical value. Attempting to convert a number which is out of range of the destination type results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
-+ \\
-+ \\```zig
-+ \\test "integer cast panic" {
-+ \\ var a: u16 = 0xabcd;
-+ \\ var b: u8 = @intCast(u8, a);
-+ \\ _ = b;
-+ \\}
-+ \\```
-+ \\
-+ \\To truncate the significant bits of a number out of range of the destination type, use [@truncate](https://ziglang.org/documentation/0.10.0/#truncate).
-+ \\
-+ \\If `T` is `comptime_int`, then this is semantically equivalent to [Type Coercion](https://ziglang.org/documentation/0.10.0/#Type-Coercion).
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "int: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@intToEnum",
-+ .signature = "@intToEnum(comptime DestType: type, integer: anytype) DestType",
-+ .snippet = "@intToEnum(${1:comptime DestType: type}, ${2:integer: anytype})",
-+ .documentation =
-+ \\Converts an integer into an [enum](https://ziglang.org/documentation/0.10.0/#enum) value.
-+ \\
-+ \\Attempting to convert an integer which represents no value in the chosen enum type invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "integer: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@intToError",
-+ .signature = "@intToError(value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)) anyerror",
-+ .snippet = "@intToError(${1:value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)})",
-+ .documentation =
-+ \\Converts from the integer representation of an error into [The Global Error Set](https://ziglang.org/documentation/0.10.0/#The-Global-Error-Set) type.
-+ \\
-+ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes.
-+ \\
-+ \\Attempting to convert an integer that does not correspond to any error results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)",
-+ },
-+ },
-+ .{
-+ .name = "@intToFloat",
-+ .signature = "@intToFloat(comptime DestType: type, int: anytype) DestType",
-+ .snippet = "@intToFloat(${1:comptime DestType: type}, ${2:int: anytype})",
-+ .documentation =
-+ \\Converts an integer to the closest floating point representation. To convert the other way, use [@floatToInt](https://ziglang.org/documentation/0.10.0/#floatToInt). This cast is always safe.
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "int: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@intToPtr",
-+ .signature = "@intToPtr(comptime DestType: type, address: usize) DestType",
-+ .snippet = "@intToPtr(${1:comptime DestType: type}, ${2:address: usize})",
-+ .documentation =
-+ \\Converts an integer to a [pointer](https://ziglang.org/documentation/0.10.0/#Pointers). To convert the other way, use [@ptrToInt](https://ziglang.org/documentation/0.10.0/#ptrToInt). Casting an address of 0 to a destination type which in not [optional](https://ziglang.org/documentation/0.10.0/#Optional-Pointers) and does not have the `allowzero` attribute will result in a [Pointer Cast Invalid Null](https://ziglang.org/documentation/0.10.0/#Pointer-Cast-Invalid-Null) panic when runtime safety checks are enabled.
-+ \\
-+ \\If the destination pointer type does not allow address zero and `address` is zero, this invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "address: usize",
-+ },
-+ },
-+ .{
-+ .name = "@max",
-+ .signature = "@max(a: T, b: T) T",
-+ .snippet = "@max(${1:a: T}, ${2:b: T})",
-+ .documentation =
-+ \\Returns the maximum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
-+ \\
-+ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
-+ ,
-+ .arguments = &.{
-+ "a: T",
-+ "b: T",
-+ },
-+ },
-+ .{
-+ .name = "@memcpy",
-+ .signature = "@memcpy(noalias dest: [*]u8, noalias source: [*]const u8, byte_count: usize)",
-+ .snippet = "@memcpy(${1:noalias dest: [*]u8}, ${2:noalias source: [*]const u8}, ${3:byte_count: usize})",
-+ .documentation =
-+ \\This function copies bytes from one region of memory to another. `dest` and `source` are both pointers and must not overlap.
-+ \\
-+ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this:
-+ \\
-+ \\```zig
-+ \\for (source[0..byte_count]) |b, i| dest[i] = b;
-+ \\```
-+ \\
-+ \\The optimizer is intelligent enough to turn the above snippet into a memcpy.
-+ \\
-+ \\There is also a standard library function for this:
-+ \\
-+ \\```zig
-+ \\const mem = @import("std").mem;
-+ \\mem.copy(u8, dest[0..byte_count], source[0..byte_count]);
-+ \\```
-+ ,
-+ .arguments = &.{
-+ "noalias dest: [*]u8",
-+ "noalias source: [*]const u8",
-+ "byte_count: usize",
-+ },
-+ },
-+ .{
-+ .name = "@memset",
-+ .signature = "@memset(dest: [*]u8, c: u8, byte_count: usize)",
-+ .snippet = "@memset(${1:dest: [*]u8}, ${2:c: u8}, ${3:byte_count: usize})",
-+ .documentation =
-+ \\This function sets a region of memory to `c`. `dest` is a pointer.
-+ \\
-+ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this:
-+ \\
-+ \\```zig
-+ \\for (dest[0..byte_count]) |*b| b.* = c;
-+ \\```
-+ \\
-+ \\The optimizer is intelligent enough to turn the above snippet into a memset.
-+ \\
-+ \\There is also a standard library function for this:
-+ \\
-+ \\```zig
-+ \\const mem = @import("std").mem;
-+ \\mem.set(u8, dest, c);
-+ \\```
-+ ,
-+ .arguments = &.{
-+ "dest: [*]u8",
-+ "c: u8",
-+ "byte_count: usize",
-+ },
-+ },
-+ .{
-+ .name = "@min",
-+ .signature = "@min(a: T, b: T) T",
-+ .snippet = "@min(${1:a: T}, ${2:b: T})",
-+ .documentation =
-+ \\Returns the minimum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
-+ \\
-+ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
-+ ,
-+ .arguments = &.{
-+ "a: T",
-+ "b: T",
-+ },
-+ },
-+ .{
-+ .name = "@wasmMemorySize",
-+ .signature = "@wasmMemorySize(index: u32) u32",
-+ .snippet = "@wasmMemorySize(${1:index: u32})",
-+ .documentation =
-+ \\This function returns the size of the Wasm memory identified by `index` as an unsigned value in units of Wasm pages. Note that each Wasm page is 64KB in size.
-+ \\
-+ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.
-+ ,
-+ .arguments = &.{
-+ "index: u32",
-+ },
-+ },
-+ .{
-+ .name = "@wasmMemoryGrow",
-+ .signature = "@wasmMemoryGrow(index: u32, delta: u32) i32",
-+ .snippet = "@wasmMemoryGrow(${1:index: u32}, ${2:delta: u32})",
-+ .documentation =
-+ \\This function increases the size of the Wasm memory identified by `index` by `delta` in units of unsigned number of Wasm pages. Note that each Wasm page is 64KB in size. On success, returns previous memory size; on failure, if the allocation fails, returns -1.
-+ \\
-+ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.</p> {#code_begin|test|wasmMemoryGrow#} const std = @import("std"); const native_arch = @import("builtin").target.cpu.arch; const expect = std.testing.expect; test "@wasmMemoryGrow" { if (native_arch != .wasm32) return error.SkipZigTest; var prev = @wasmMemorySize(0); try expect(prev == @wasmMemoryGrow(0, 1)); try expect(prev + 1 == @wasmMemorySize(0)); }`
-+ ,
-+ .arguments = &.{
-+ "index: u32",
-+ "delta: u32",
-+ },
-+ },
-+ .{
-+ .name = "@mod",
-+ .signature = "@mod(numerator: T, denominator: T) T",
-+ .snippet = "@mod(${1:numerator: T}, ${2:denominator: T})",
-+ .documentation =
-+ \\Modulus division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.10.0/#Remainder-Division-by-Zero) when runtime safety checks are enabled.
-+ \\ - `@mod(-5, 3) == 1`
-+ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a`
-+ \\
-+ \\For a function that returns an error code, see `@import("std").math.mod`.
-+ ,
-+ .arguments = &.{
-+ "numerator: T",
-+ "denominator: T",
-+ },
-+ },
-+ .{
-+ .name = "@mulWithOverflow",
-+ .signature = "@mulWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
-+ .snippet = "@mulWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
-+ .documentation =
-+ \\Performs `result.* = a * b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "a: T",
-+ "b: T",
-+ "result: *T",
-+ },
-+ },
-+ .{
-+ .name = "@panic",
-+ .signature = "@panic(message: []const u8) noreturn",
-+ .snippet = "@panic(${1:message: []const u8})",
-+ .documentation =
-+ \\Invokes the panic handler function. By default the panic handler function calls the public `panic` function exposed in the root source file, or if there is not one specified, the `std.builtin.default_panic` function from `std/builtin.zig`.
-+ \\
-+ \\Generally it is better to use `@import("std").debug.panic`. However, `@panic` can be useful for 2 scenarios:
-+ \\ - From library code, calling the programmer's panic function if they exposed one in the root source file.
-+ \\ - When mixing C and Zig code, calling the canonical panic implementation across multiple .o files.
-+ ,
-+ .arguments = &.{
-+ "message: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@popCount",
-+ .signature = "@popCount(operand: anytype)",
-+ .snippet = "@popCount(${1:operand: anytype})",
-+ .documentation =
-+ \\`@TypeOf(operand)` must be an integer type.
-+ \\
-+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors).
-+ \\
-+ \\Counts the number of bits set in an integer.
-+ \\
-+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
-+ ,
-+ .arguments = &.{
-+ "operand: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@prefetch",
-+ .signature = "@prefetch(ptr: anytype, comptime options: std.builtin.PrefetchOptions)",
-+ .snippet = "@prefetch(${1:ptr: anytype}, ${2:comptime options: std.builtin.PrefetchOptions})",
-+ .documentation =
-+ \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a no-op. This function has no effect on the behavior of the program, only on the performance characteristics.
-+ \\
-+ \\The `ptr` argument may be any pointer type and determines the memory address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no illegal behavior will result.
-+ \\
-+ \\The `options` argument is the following struct:</p> {#code_begin|syntax|builtin#} /// This data structure is used by the Zig language code generation and /// therefore must be kept in sync with the compiler implementation. pub const PrefetchOptions = struct { /// Whether the prefetch should prepare for a read or a write. rw: Rw = .read, /// 0 means no temporal locality. That is, the data can be immediately /// dropped from the cache after it is accessed. /// /// 3 means high temporal locality. That is, the data should be kept in /// the cache as it is likely to be accessed again soon. locality: u2 = 3, /// The cache that the prefetch should be preformed on. cache: Cache = .data, pub const Rw = enum { read, write, }; pub const Cache = enum { instruction, data, }; };`
-+ ,
-+ .arguments = &.{
-+ "ptr: anytype",
-+ "comptime options: std.builtin.PrefetchOptions",
-+ },
-+ },
-+ .{
-+ .name = "@ptrCast",
-+ .signature = "@ptrCast(comptime DestType: type, value: anytype) DestType",
-+ .snippet = "@ptrCast(${1:comptime DestType: type}, ${2:value: anytype})",
-+ .documentation =
-+ \\Converts a pointer of one type to a pointer of another type.
-+ \\
-+ \\[Optional Pointers](https://ziglang.org/documentation/0.10.0/#Optional-Pointers) are allowed. Casting an optional pointer which is [null](https://ziglang.org/documentation/0.10.0/#null) to a non-optional pointer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@ptrToInt",
-+ .signature = "@ptrToInt(value: anytype) usize",
-+ .snippet = "@ptrToInt(${1:value: anytype})",
-+ .documentation =
-+ \\Converts `value` to a `usize` which is the address of the pointer. `value` can be `*T` or `?*T`.
-+ \\
-+ \\To convert the other way, use [@intToPtr](https://ziglang.org/documentation/0.10.0/#intToPtr)
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@rem",
-+ .signature = "@rem(numerator: T, denominator: T) T",
-+ .snippet = "@rem(${1:numerator: T}, ${2:denominator: T})",
-+ .documentation =
-+ \\Remainder division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.10.0/#Remainder-Division-by-Zero) when runtime safety checks are enabled.
-+ \\ - `@rem(-5, 3) == -2`
-+ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a`
-+ \\
-+ \\For a function that returns an error code, see `@import("std").math.rem`.
-+ ,
-+ .arguments = &.{
-+ "numerator: T",
-+ "denominator: T",
-+ },
-+ },
-+ .{
-+ .name = "@returnAddress",
-+ .signature = "@returnAddress() usize",
-+ .snippet = "@returnAddress()",
-+ .documentation =
-+ \\This function returns the address of the next machine code instruction that will be executed when the current function returns.
-+ \\
-+ \\The implications of this are target-specific and not consistent across all platforms.
-+ \\
-+ \\This function is only valid within function scope. If the function gets inlined into a calling function, the returned address will apply to the calling function.
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@select",
-+ .signature = "@select(comptime T: type, pred: @Vector(len, bool), a: @Vector(len, T), b: @Vector(len, T)) @Vector(len, T)",
-+ .snippet = "@select(${1:comptime T: type}, ${2:pred: @Vector(len, bool)}, ${3:a: @Vector(len, T)}, ${4:b: @Vector(len, T)})",
-+ .documentation =
-+ \\Selects values element-wise from `a` or `b` based on `pred`. If `pred[i]` is `true`, the corresponding element in the result will be `a[i]` and otherwise `b[i]`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "pred: @Vector(len, bool)",
-+ "a: @Vector(len, T)",
-+ "b: @Vector(len, T)",
-+ },
-+ },
-+ .{
-+ .name = "@setAlignStack",
-+ .signature = "@setAlignStack(comptime alignment: u29)",
-+ .snippet = "@setAlignStack(${1:comptime alignment: u29})",
-+ .documentation =
-+ \\Ensures that a function will have a stack alignment of at least `alignment` bytes.
-+ ,
-+ .arguments = &.{
-+ "comptime alignment: u29",
-+ },
-+ },
-+ .{
-+ .name = "@setCold",
-+ .signature = "@setCold(comptime is_cold: bool)",
-+ .snippet = "@setCold(${1:comptime is_cold: bool})",
-+ .documentation =
-+ \\Tells the optimizer that a function is rarely called.
-+ ,
-+ .arguments = &.{
-+ "comptime is_cold: bool",
-+ },
-+ },
-+ .{
-+ .name = "@setEvalBranchQuota",
-+ .signature = "@setEvalBranchQuota(comptime new_quota: u32)",
-+ .snippet = "@setEvalBranchQuota(${1:comptime new_quota: u32})",
-+ .documentation =
-+ \\Changes the maximum number of backwards branches that compile-time code execution can use before giving up and making a compile error.
-+ \\
-+ \\If the `new_quota` is smaller than the default quota (`1000`) or a previously explicitly set quota, it is ignored.
-+ \\
-+ \\Example:
-+ \\
-+ \\```zig
-+ \\test "foo" {
-+ \\ comptime {
-+ \\ var i = 0;
-+ \\ while (i < 1001) : (i += 1) {}
-+ \\ }
-+ \\}
-+ \\```
-+ \\
-+ \\Now we use `@setEvalBranchQuota`:</p> {#code_begin|test|setEvalBranchQuota#} test "foo" { comptime { @setEvalBranchQuota(1001); var i = 0; while (i < 1001) : (i += 1) {} } }`
-+ ,
-+ .arguments = &.{
-+ "comptime new_quota: u32",
-+ },
-+ },
-+ .{
-+ .name = "@setFloatMode",
-+ .signature = "@setFloatMode(comptime mode: @import(\"std\").builtin.FloatMode)",
-+ .snippet = "@setFloatMode(${1:comptime mode: @import(\"std\").builtin.FloatMode})",
-+ .documentation =
-+ \\Sets the floating point mode of the current scope. Possible values are:
-+ \\
-+ \\```zig
-+ \\pub const FloatMode = enum {
-+ \\ Strict,
-+ \\ Optimized,
-+ \\};
-+ \\```
-+ \\
-+ \\ - `Strict` (default) - Floating point operations follow strict IEEE compliance.
-+ \\ - `Optimized` - Floating point operations may do all of the following: <ul>
-+ \\ - Assume the arguments and result are not NaN. Optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined.
-+ \\ - Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined.
-+ \\ - Treat the sign of a zero argument or result as insignificant.
-+ \\ - Use the reciprocal of an argument rather than perform division.
-+ \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-add).
-+ \\ - Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate). This is equivalent to `-ffast-math` in GCC.</ul>
-+ \\
-+ \\The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block.
-+ ,
-+ .arguments = &.{
-+ "comptime mode: @import(\"std\").builtin.FloatMode",
-+ },
-+ },
-+ .{
-+ .name = "@setRuntimeSafety",
-+ .signature = "@setRuntimeSafety(comptime safety_on: bool) void",
-+ .snippet = "@setRuntimeSafety(${1:comptime safety_on: bool})",
-+ .documentation =
-+ \\Sets whether runtime safety checks are enabled for the scope that contains the function call.
-+ \\
-+ \\```zig
-+ \\test "@setRuntimeSafety" {
-+ \\ // The builtin applies to the scope that it is called in. So here, integer overflow
-+ \\ // will not be caught in ReleaseFast and ReleaseSmall modes:
-+ \\ // var x: u8 = 255;
-+ \\ // x += 1; // undefined behavior in ReleaseFast/ReleaseSmall modes.
-+ \\ {
-+ \\ // However this block has safety enabled, so safety checks happen here,
-+ \\ // even in ReleaseFast and ReleaseSmall modes.
-+ \\ @setRuntimeSafety(true);
-+ \\ var x: u8 = 255;
-+ \\ x += 1;
-+ \\
-+ \\ {
-+ \\ // The value can be overridden at any scope. So here integer overflow
-+ \\ // would not be caught in any build mode.
-+ \\ @setRuntimeSafety(false);
-+ \\ // var x: u8 = 255;
-+ \\ // x += 1; // undefined behavior in all build modes.
-+ \\ }
-+ \\ }
-+ \\}
-+ \\```
-+ \\
-+ \\Note: it is [planned](https://github.com/ziglang/zig/issues/978) to replace `@setRuntimeSafety` with `@optimizeFor`
-+ ,
-+ .arguments = &.{
-+ "comptime safety_on: bool",
-+ },
-+ },
-+ .{
-+ .name = "@shlExact",
-+ .signature = "@shlExact(value: T, shift_amt: Log2T) T",
-+ .snippet = "@shlExact(${1:value: T}, ${2:shift_amt: Log2T})",
-+ .documentation =
-+ \\Performs the left shift operation (`<<`). For unsigned integers, the result is [undefined](https://ziglang.org/documentation/0.10.0/#undefined) if any 1 bits are shifted out. For signed integers, the result is [undefined](https://ziglang.org/documentation/0.10.0/#undefined) if any bits that disagree with the resultant sign bit are shifted out.
-+ \\
-+ \\The type of `shift_amt` is an unsigned integer with `log2(@typeInfo(T).Int.bits)` bits. This is because `shift_amt >= @typeInfo(T).Int.bits` is undefined behavior.
-+ ,
-+ .arguments = &.{
-+ "value: T",
-+ "shift_amt: Log2T",
-+ },
-+ },
-+ .{
-+ .name = "@shlWithOverflow",
-+ .signature = "@shlWithOverflow(comptime T: type, a: T, shift_amt: Log2T, result: *T) bool",
-+ .snippet = "@shlWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:shift_amt: Log2T}, ${4:result: *T})",
-+ .documentation =
-+ \\Performs `result.* = a << b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
-+ \\
-+ \\The type of `shift_amt` is an unsigned integer with `log2(@typeInfo(T).Int.bits)` bits. This is because `shift_amt >= @typeInfo(T).Int.bits` is undefined behavior.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "a: T",
-+ "shift_amt: Log2T",
-+ "result: *T",
-+ },
-+ },
-+ .{
-+ .name = "@shrExact",
-+ .signature = "@shrExact(value: T, shift_amt: Log2T) T",
-+ .snippet = "@shrExact(${1:value: T}, ${2:shift_amt: Log2T})",
-+ .documentation =
-+ \\Performs the right shift operation (`>>`). Caller guarantees that the shift will not shift any 1 bits out.
-+ \\
-+ \\The type of `shift_amt` is an unsigned integer with `log2(@typeInfo(T).Int.bits)` bits. This is because `shift_amt >= @typeInfo(T).Int.bits` is undefined behavior.
-+ ,
-+ .arguments = &.{
-+ "value: T",
-+ "shift_amt: Log2T",
-+ },
-+ },
-+ .{
-+ .name = "@shuffle",
-+ .signature = "@shuffle(comptime E: type, a: @Vector(a_len, E), b: @Vector(b_len, E), comptime mask: @Vector(mask_len, i32)) @Vector(mask_len, E)",
-+ .snippet = "@shuffle(${1:comptime E: type}, ${2:a: @Vector(a_len, E)}, ${3:b: @Vector(b_len, E)}, ${4:comptime mask: @Vector(mask_len, i32)})",
-+ .documentation =
-+ \\Constructs a new [vector](https://ziglang.org/documentation/0.10.0/#Vectors) by selecting elements from `a` and `b` based on `mask`.
-+ \\
-+ \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator for indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`).
-+ \\
-+ \\For each element of `mask`, if it or the selected value from `a` or `b` is `undefined`, then the resulting element is `undefined`.
-+ \\
-+ \\`a_len` and `b_len` may differ in length. Out-of-bounds element indexes in `mask` result in compile errors.
-+ \\
-+ \\If `a` or `b` is `undefined`, it is equivalent to a vector of all `undefined` with the same length as the other vector. If both vectors are `undefined`, `@shuffle` returns a vector with all elements `undefined`.
-+ \\
-+ \\`E` must be an [integer](https://ziglang.org/documentation/0.10.0/#Integers), [float](https://ziglang.org/documentation/0.10.0/#Floats), [pointer](https://ziglang.org/documentation/0.10.0/#Pointers), or `bool`. The mask may be any vector length, and its length determines the result length.</p> {#code_begin|test|vector_shuffle#} const std = @import("std"); const expect = std.testing.expect; test "vector @shuffle" { const a = @Vector(7, u8){ 'o', 'l', 'h', 'e', 'r', 'z', 'w' }; const b = @Vector(4, u8){ 'w', 'd', '!', 'x' }; // To shuffle within a single vector, pass undefined as the second argument. // Notice that we can re-order, duplicate, or omit elements of the input vector const mask1 = @Vector(5, i32){ 2, 3, 1, 1, 0 }; const res1: @Vector(5, u8) = @shuffle(u8, a, undefined, mask1); try expect(std.mem.eql(u8, &@as([5]u8, res1), "hello")); // Combining two vectors const mask2 = @Vector(6, i32){ -1, 0, 4, 1, -2, -3 }; const res2: @Vector(6, u8) = @shuffle(u8, a, b, mask
2); try expect(std.mem.eql(u8, &@as([6]u8, res2), "world!")); }`
-+ ,
-+ .arguments = &.{
-+ "comptime E: type",
-+ "a: @Vector(a_len, E)",
-+ "b: @Vector(b_len, E)",
-+ "comptime mask: @Vector(mask_len, i32)",
-+ },
-+ },
-+ .{
-+ .name = "@sizeOf",
-+ .signature = "@sizeOf(comptime T: type) comptime_int",
-+ .snippet = "@sizeOf(${1:comptime T: type})",
-+ .documentation =
-+ \\This function returns the number of bytes it takes to store `T` in memory. The result is a target-specific compile time constant.
-+ \\
-+ \\This size may contain padding bytes. If there were two consecutive T in memory, this would be the offset in bytes between element at index 0 and the element at index 1. For [integer](https://ziglang.org/documentation/0.10.0/#Integers), consider whether you want to use `@sizeOf(T)` or `@typeInfo(T).Int.bits`.
-+ \\
-+ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ },
-+ },
-+ .{
-+ .name = "@splat",
-+ .signature = "@splat(comptime len: u32, scalar: anytype) @Vector(len, @TypeOf(scalar))",
-+ .snippet = "@splat(${1:comptime len: u32}, ${2:scalar: anytype})",
-+ .documentation =
-+ \\Produces a vector of length `len` where each element is the value `scalar`:</p> {#code_begin|test|vector_splat#} const std = @import("std"); const expect = std.testing.expect; test "vector @splat" { const scalar: u32 = 5; const result = @splat(4, scalar); comptime try expect(@TypeOf(result) == @Vector(4, u32)); try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 })); }`
-+ \\
-+ \\`scalar` must be an [integer](https://ziglang.org/documentation/0.10.0/#Integers), [bool](https://ziglang.org/documentation/0.10.0/#Primitive-Types), [float](https://ziglang.org/documentation/0.10.0/#Floats), or [pointer](https://ziglang.org/documentation/0.10.0/#Pointers).
-+ ,
-+ .arguments = &.{
-+ "comptime len: u32",
-+ "scalar: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@reduce",
-+ .signature = "@reduce(comptime op: std.builtin.ReduceOp, value: anytype) E",
-+ .snippet = "@reduce(${1:comptime op: std.builtin.ReduceOp}, ${2:value: anytype})",
-+ .documentation =
-+ \\Transforms a [vector](https://ziglang.org/documentation/0.10.0/#Vectors) into a scalar value (of type `E`) by performing a sequential horizontal reduction of its elements using the specified operator `op`.
-+ \\
-+ \\Not every operator is available for every vector element type:
-+ \\ - Every operator is available for [integer](https://ziglang.org/documentation/0.10.0/#Integers) vectors.
-+ \\ - `.And`, `.Or`, `.Xor` are additionally available for `bool` vectors,
-+ \\ - `.Min`, `.Max`, `.Add`, `.Mul` are additionally available for [floating point](https://ziglang.org/documentation/0.10.0/#Floats) vectors,
-+ \\
-+ \\Note that `.Add` and `.Mul` reductions on integral types are wrapping; when applied on floating point types the operation associativity is preserved, unless the float mode is set to `Optimized`.</p> {#code_begin|test|vector_reduce#} const std = @import("std"); const expect = std.testing.expect; test "vector @reduce" { const value = @Vector(4, i32){ 1, -1, 1, -1 }; const result = value > @splat(4, @as(i32, 0)); // result is { true, false, true, false }; comptime try expect(@TypeOf(result) == @Vector(4, bool)); const is_all_true = @reduce(.And, result); comptime try expect(@TypeOf(is_all_true) == bool); try expect(is_all_true == false); }`
-+ ,
-+ .arguments = &.{
-+ "comptime op: std.builtin.ReduceOp",
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@src",
-+ .signature = "@src() std.builtin.SourceLocation",
-+ .snippet = "@src()",
-+ .documentation =
-+ \\Returns a `SourceLocation` struct representing the function's name and location in the source code. This must be called in a function.</p> {#code_begin|test|source_location#} const std = @import("std"); const expect = std.testing.expect; test "@src" { try doTheTest(); } fn doTheTest() !void { const src = @src(); try expect(src.line == 9); try expect(src.column == 17); try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest")); try expect(std.mem.endsWith(u8, src.file, "source_location.zig")); }`
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@sqrt",
-+ .signature = "@sqrt(value: anytype) @TypeOf(value)",
-+ .snippet = "@sqrt(${1:value: anytype})",
-+ .documentation =
-+ \\Performs the square root of a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@sin",
-+ .signature = "@sin(value: anytype) @TypeOf(value)",
-+ .snippet = "@sin(${1:value: anytype})",
-+ .documentation =
-+ \\Sine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@cos",
-+ .signature = "@cos(value: anytype) @TypeOf(value)",
-+ .snippet = "@cos(${1:value: anytype})",
-+ .documentation =
-+ \\Cosine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@tan",
-+ .signature = "@tan(value: anytype) @TypeOf(value)",
-+ .snippet = "@tan(${1:value: anytype})",
-+ .documentation =
-+ \\Tangent trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@exp",
-+ .signature = "@exp(value: anytype) @TypeOf(value)",
-+ .snippet = "@exp(${1:value: anytype})",
-+ .documentation =
-+ \\Base-e exponential function on a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@exp2",
-+ .signature = "@exp2(value: anytype) @TypeOf(value)",
-+ .snippet = "@exp2(${1:value: anytype})",
-+ .documentation =
-+ \\Base-2 exponential function on a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@log",
-+ .signature = "@log(value: anytype) @TypeOf(value)",
-+ .snippet = "@log(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the natural logarithm of a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@log2",
-+ .signature = "@log2(value: anytype) @TypeOf(value)",
-+ .snippet = "@log2(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the logarithm to the base 2 of a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@log10",
-+ .signature = "@log10(value: anytype) @TypeOf(value)",
-+ .snippet = "@log10(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the logarithm to the base 10 of a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@fabs",
-+ .signature = "@fabs(value: anytype) @TypeOf(value)",
-+ .snippet = "@fabs(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the absolute value of a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@floor",
-+ .signature = "@floor(value: anytype) @TypeOf(value)",
-+ .snippet = "@floor(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the largest integral value not greater than the given floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@ceil",
-+ .signature = "@ceil(value: anytype) @TypeOf(value)",
-+ .snippet = "@ceil(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the smallest integral value not less than the given floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@trunc",
-+ .signature = "@trunc(value: anytype) @TypeOf(value)",
-+ .snippet = "@trunc(${1:value: anytype})",
-+ .documentation =
-+ \\Rounds the given floating point number to an integer, towards zero. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@round",
-+ .signature = "@round(value: anytype) @TypeOf(value)",
-+ .snippet = "@round(${1:value: anytype})",
-+ .documentation =
-+ \\Rounds the given floating point number to an integer, away from zero. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@subWithOverflow",
-+ .signature = "@subWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
-+ .snippet = "@subWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
-+ .documentation =
-+ \\Performs `result.* = a - b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "a: T",
-+ "b: T",
-+ "result: *T",
-+ },
-+ },
-+ .{
-+ .name = "@tagName",
-+ .signature = "@tagName(value: anytype) [:0]const u8",
-+ .snippet = "@tagName(${1:value: anytype})",
-+ .documentation =
-+ \\Converts an enum value or union value to a string literal representing the name.
-+ \\
-+ \\If the enum is non-exhaustive and the tag value does not map to a name, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@This",
-+ .signature = "@This() type",
-+ .snippet = "@This()",
-+ .documentation =
-+ \\Returns the innermost struct, enum, or union that this function call is inside. This can be useful for an anonymous struct that needs to refer to itself:</p> {#code_begin|test|this_innermost#} const std = @import("std"); const expect = std.testing.expect; test "@This()" { var items = [_]i32{ 1, 2, 3, 4 }; const list = List(i32){ .items = items[0..] }; try expect(list.length() == 4); } fn List(comptime T: type) type { return struct { const Self = @This(); items: []T, fn length(self: Self) usize { return self.items.len; } }; }`
-+ \\
-+ \\When `@This()` is used at file scope, it returns a reference to the struct that corresponds to the current file.
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@truncate",
-+ .signature = "@truncate(comptime T: type, integer: anytype) T",
-+ .snippet = "@truncate(${1:comptime T: type}, ${2:integer: anytype})",
-+ .documentation =
-+ \\This function truncates bits from an integer type, resulting in a smaller or same-sized integer type.
-+ \\
-+ \\This function always truncates the significant bits of the integer, regardless of endianness on the target platform.
-+ \\
-+ \\Calling `@truncate` on a number out of range of the destination type is well defined and working code:
-+ \\
-+ \\```zig
-+ \\const std = @import("std");
-+ \\const expect = std.testing.expect;
-+ \\
-+ \\test "integer truncation" {
-+ \\ var a: u16 = 0xabcd;
-+ \\ var b: u8 = @truncate(u8, a);
-+ \\ try expect(b == 0xcd);
-+ \\}
-+ \\```
-+ \\
-+ \\Use [@intCast](https://ziglang.org/documentation/0.10.0/#intCast) to convert numbers guaranteed to fit the destination type.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "integer: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@Type",
-+ .signature = "@Type(comptime info: std.builtin.Type) type",
-+ .snippet = "@Type(${1:comptime info: std.builtin.Type})",
-+ .documentation =
-+ \\This function is the inverse of [@typeInfo](https://ziglang.org/documentation/0.10.0/#typeInfo). It reifies type information into a `type`.
-+ \\
-+ \\It is available for the following types:
-+ \\ - `type`
-+ \\ - `noreturn`
-+ \\ - `void`
-+ \\ - `bool`
-+ \\ - [Integers](https://ziglang.org/documentation/0.10.0/#Integers) - The maximum bit count for an integer type is `65535`.
-+ \\ - [Floats](https://ziglang.org/documentation/0.10.0/#Floats)
-+ \\ - [Pointers](https://ziglang.org/documentation/0.10.0/#Pointers)
-+ \\ - `comptime_int`
-+ \\ - `comptime_float`
-+ \\ - `@TypeOf(undefined)`
-+ \\ - `@TypeOf(null)`
-+ \\ - [Arrays](https://ziglang.org/documentation/0.10.0/#Arrays)
-+ \\ - [Optionals](https://ziglang.org/documentation/0.10.0/#Optionals)
-+ \\ - [Error Set Type](https://ziglang.org/documentation/0.10.0/#Error-Set-Type)
-+ \\ - [Error Union Type](https://ziglang.org/documentation/0.10.0/#Error-Union-Type)
-+ \\ - [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors)
-+ \\ - [opaque](https://ziglang.org/documentation/0.10.0/#opaque)
-+ \\ - [@Frame](https://ziglang.org/documentation/0.10.0/#Frame)
-+ \\ - `anyframe`
-+ \\ - [struct](https://ziglang.org/documentation/0.10.0/#struct)
-+ \\ - [enum](https://ziglang.org/documentation/0.10.0/#enum)
-+ \\ - [Enum Literals](https://ziglang.org/documentation/0.10.0/#Enum-Literals)
-+ \\ - [union](https://ziglang.org/documentation/0.10.0/#union)
-+ \\
-+ \\For these types, `@Type` is not available:
-+ \\ - [Functions](https://ziglang.org/documentation/0.10.0/#Functions)
-+ \\ - BoundFn
-+ ,
-+ .arguments = &.{
-+ "comptime info: std.builtin.Type",
-+ },
-+ },
-+ .{
-+ .name = "@typeInfo",
-+ .signature = "@typeInfo(comptime T: type) std.builtin.Type",
-+ .snippet = "@typeInfo(${1:comptime T: type})",
-+ .documentation =
-+ \\Provides type reflection.
-+ \\
-+ \\Type information of [structs](https://ziglang.org/documentation/0.10.0/#struct), [unions](https://ziglang.org/documentation/0.10.0/#union), [enums](https://ziglang.org/documentation/0.10.0/#enum), and [error sets](https://ziglang.org/documentation/0.10.0/#Error-Set-Type) has fields which are guaranteed to be in the same order as appearance in the source file.
-+ \\
-+ \\Type information of [structs](https://ziglang.org/documentation/0.10.0/#struct), [unions](https://ziglang.org/documentation/0.10.0/#union), [enums](https://ziglang.org/documentation/0.10.0/#enum), and [opaques](https://ziglang.org/documentation/0.10.0/#opaque) has declarations, which are also guaranteed to be in the same order as appearance in the source file.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ },
-+ },
-+ .{
-+ .name = "@typeName",
-+ .signature = "@typeName(T: type) *const [N:0]u8",
-+ .snippet = "@typeName(${1:T: type})",
-+ .documentation =
-+ \\This function returns the string representation of a type, as an array. It is equivalent to a string literal of the type name. The returned type name is fully qualified with the parent namespace included as part of the type name with a series of dots.
-+ ,
-+ .arguments = &.{
-+ "T: type",
-+ },
-+ },
-+ .{
-+ .name = "@TypeOf",
-+ .signature = "@TypeOf(...) type",
-+ .snippet = "@TypeOf(${1:...})",
-+ .documentation =
-+ \\`@TypeOf` is a special builtin function that takes any (nonzero) number of expressions as parameters and returns the type of the result, using [Peer Type Resolution](https://ziglang.org/documentation/0.10.0/#Peer-Type-Resolution).
-+ \\
-+ \\The expressions are evaluated, however they are guaranteed to have no *runtime* side-effects:</p> {#code_begin|test|no_runtime_side_effects#} const std = @import("std"); const expect = std.testing.expect; test "no runtime side effects" { var data: i32 = 0; const T = @TypeOf(foo(i32, &data)); comptime try expect(T == i32); try expect(data == 0); } fn foo(comptime T: type, ptr: *T) T { ptr.* += 1; return ptr.*; }`
-+ ,
-+ .arguments = &.{
-+ "...",
-+ },
-+ },
-+ .{
-+ .name = "@unionInit",
-+ .signature = "@unionInit(comptime Union: type, comptime active_field_name: []const u8, init_expr) Union",
-+ .snippet = "@unionInit(${1:comptime Union: type}, ${2:comptime active_field_name: []const u8}, ${3:init_expr})",
-+ .documentation =
-+ \\This is the same thing as [union](https://ziglang.org/documentation/0.10.0/#union) initialization syntax, except that the field name is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known value rather than an identifier token.
-+ \\
-+ \\`@unionInit` forwards its [result location](https://ziglang.org/documentation/0.10.0/#Result-Location-Semantics) to `init_expr`.
-+ ,
-+ .arguments = &.{
-+ "comptime Union: type",
-+ "comptime active_field_name: []const u8",
-+ "init_expr",
-+ },
-+ },
-+ .{
-+ .name = "@Vector",
-+ .signature = "@Vector(len: comptime_int, Element: type) type",
-+ .snippet = "@Vector(${1:len: comptime_int}, ${2:Element: type})",
-+ .documentation =
-+ \\Creates [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors).
-+ ,
-+ .arguments = &.{
-+ "len: comptime_int",
-+ "Element: type",
-+ },
-+ },
-+};
-diff --git a/src/data/0.9.1.zig b/src/data/0.9.1.zig
-new file mode 100644
-index 00000000..da1eddd5
---- /dev/null
-+++ b/src/data/0.9.1.zig
-@@ -0,0 +1,1777 @@
-+const Builtin = struct {
-+ name: []const u8,
-+ signature: []const u8,
-+ snippet: []const u8,
-+ documentation: []const u8,
-+ arguments: []const []const u8,
-+};
-+
-+pub const builtins = [_]Builtin{
-+ .{
-+ .name = "@addWithOverflow",
-+ .signature = "@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
-+ .snippet = "@addWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
-+ .documentation =
-+ \\Performs `result.* = a + b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "a: T",
-+ "b: T",
-+ "result: *T",
-+ },
-+ },
-+ .{
-+ .name = "@alignCast",
-+ .signature = "@alignCast(comptime alignment: u29, ptr: anytype) anytype",
-+ .snippet = "@alignCast(${1:comptime alignment: u29}, ${2:ptr: anytype})",
-+ .documentation =
-+ \\`ptr` can be `*T`, `fn()`, `?*T`, `?fn()`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value.
-+ \\
-+ \\A [pointer alignment safety check](https://ziglang.org/documentation/0.9.1/#Incorrect-Pointer-Alignment) is added to the generated code to make sure the pointer is aligned as promised.
-+ ,
-+ .arguments = &.{
-+ "comptime alignment: u29",
-+ "ptr: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@alignOf",
-+ .signature = "@alignOf(comptime T: type) comptime_int",
-+ .snippet = "@alignOf(${1:comptime T: type})",
-+ .documentation =
-+ \\This function returns the number of bytes that this type should be aligned to for the current target to match the C ABI. When the child type of a pointer has this alignment, the alignment can be omitted from the type.
-+ \\
-+ \\```zig
-+ \\const expect = @import("std").debug.assert;
-+ \\comptime {
-+ \\ assert(*u32 == *align(@alignOf(u32)) u32);
-+ \\}
-+ \\```
-+ \\
-+ \\The result is a target-specific compile time constant. It is guaranteed to be less than or equal to [@sizeOf(T)](https://ziglang.org/documentation/0.9.1/#@sizeOf).
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ },
-+ },
-+ .{
-+ .name = "@as",
-+ .signature = "@as(comptime T: type, expression) T",
-+ .snippet = "@as(${1:comptime T: type}, ${2:expression})",
-+ .documentation =
-+ \\Performs [Type Coercion](https://ziglang.org/documentation/0.9.1/#Type-Coercion). This cast is allowed when the conversion is unambiguous and safe, and is the preferred way to convert between types, whenever possible.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "expression",
-+ },
-+ },
-+ .{
-+ .name = "@asyncCall",
-+ .signature = "@asyncCall(frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8, result_ptr, function_ptr, args: anytype) anyframe->T",
-+ .snippet = "@asyncCall(${1:frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8}, ${2:result_ptr}, ${3:function_ptr}, ${4:args: anytype})",
-+ .documentation =
-+ \\`@asyncCall` performs an `async` call on a function pointer, which may or may not be an [async function](https://ziglang.org/documentation/0.9.1/#Async-Functions).
-+ \\
-+ \\The provided `frame_buffer` must be large enough to fit the entire function frame. This size can be determined with [@frameSize](https://ziglang.org/documentation/0.9.1/#frameSize). To provide a too-small buffer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
-+ \\
-+ \\`result_ptr` is optional ([null](https://ziglang.org/documentation/0.9.1/#null) may be provided). If provided, the function call will write its result directly to the result pointer, which will be available to read after [await](https://ziglang.org/documentation/0.9.1/#Async-and-Await) completes. Any result location provided to `await` will copy the result from `result_ptr`.</p> {#code_begin|test|async_struct_field_fn_pointer#} const std = @import("std"); const expect = std.testing.expect; test "async fn pointer in a struct field" { var data: i32 = 1; const Foo = struct { bar: fn (*i32) callconv(.Async) void, }; var foo = Foo{ .bar = func }; var bytes: [64]u8 align(@alignOf(@Frame(func))) = undefined; const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); try expect(data == 2); resume f; try expect(data == 4); } fn func(y: *i32) void { defer y.* += 2; y.* += 1; suspend {} }`
-+ ,
-+ .arguments = &.{
-+ "frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8",
-+ "result_ptr",
-+ "function_ptr",
-+ "args: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@atomicLoad",
-+ .signature = "@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: builtin.AtomicOrder) T",
-+ .snippet = "@atomicLoad(${1:comptime T: type}, ${2:ptr: *const T}, ${3:comptime ordering: builtin.AtomicOrder})",
-+ .documentation =
-+ \\This builtin function atomically dereferences a pointer and returns the value.
-+ \\
-+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "ptr: *const T",
-+ "comptime ordering: builtin.AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@atomicRmw",
-+ .signature = "@atomicRmw(comptime T: type, ptr: *T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) T",
-+ .snippet = "@atomicRmw(${1:comptime T: type}, ${2:ptr: *T}, ${3:comptime op: builtin.AtomicRmwOp}, ${4:operand: T}, ${5:comptime ordering: builtin.AtomicOrder})",
-+ .documentation =
-+ \\This builtin function atomically modifies memory and then returns the previous value.
-+ \\
-+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
-+ \\
-+ \\Supported operations:
-+ \\ - `.Xchg` - stores the operand unmodified. Supports enums, integers and floats.
-+ \\ - `.Add` - for integers, twos complement wraparound addition. Also supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats).
-+ \\ - `.Sub` - for integers, twos complement wraparound subtraction. Also supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats).
-+ \\ - `.And` - bitwise and
-+ \\ - `.Nand` - bitwise nand
-+ \\ - `.Or` - bitwise or
-+ \\ - `.Xor` - bitwise xor
-+ \\ - `.Max` - stores the operand if it is larger. Supports integers and floats.
-+ \\ - `.Min` - stores the operand if it is smaller. Supports integers and floats.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "ptr: *T",
-+ "comptime op: builtin.AtomicRmwOp",
-+ "operand: T",
-+ "comptime ordering: builtin.AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@atomicStore",
-+ .signature = "@atomicStore(comptime T: type, ptr: *T, value: T, comptime ordering: builtin.AtomicOrder) void",
-+ .snippet = "@atomicStore(${1:comptime T: type}, ${2:ptr: *T}, ${3:value: T}, ${4:comptime ordering: builtin.AtomicOrder})",
-+ .documentation =
-+ \\This builtin function atomically stores a value.
-+ \\
-+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "ptr: *T",
-+ "value: T",
-+ "comptime ordering: builtin.AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@bitCast",
-+ .signature = "@bitCast(comptime DestType: type, value: anytype) DestType",
-+ .snippet = "@bitCast(${1:comptime DestType: type}, ${2:value: anytype})",
-+ .documentation =
-+ \\Converts a value of one type to another type.
-+ \\
-+ \\Asserts that `@sizeOf(@TypeOf(value)) == @sizeOf(DestType)`.
-+ \\
-+ \\Asserts that `@typeInfo(DestType) != .Pointer`. Use `@ptrCast` or `@intToPtr` if you need this.
-+ \\
-+ \\Can be used for these things for example:
-+ \\ - Convert `f32` to `u32` bits
-+ \\ - Convert `i32` to `u32` preserving twos complement
-+ \\
-+ \\Works at compile-time if `value` is known at compile time. It's a compile error to bitcast a struct to a scalar type of the same size since structs have undefined layout. However if the struct is packed then it works.
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@bitOffsetOf",
-+ .signature = "@bitOffsetOf(comptime T: type, comptime field_name: []const u8) comptime_int",
-+ .snippet = "@bitOffsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})",
-+ .documentation =
-+ \\Returns the bit offset of a field relative to its containing struct.
-+ \\
-+ \\For non [packed structs](https://ziglang.org/documentation/0.9.1/#packed-struct), this will always be divisible by `8`. For packed structs, non-byte-aligned fields will share a byte offset, but they will have different bit offsets.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "comptime field_name: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@boolToInt",
-+ .signature = "@boolToInt(value: bool) u1",
-+ .snippet = "@boolToInt(${1:value: bool})",
-+ .documentation =
-+ \\Converts `true` to `@as(u1, 1)` and `false` to `@as(u1, 0)`.
-+ \\
-+ \\If the value is known at compile-time, the return type is `comptime_int` instead of `u1`.
-+ ,
-+ .arguments = &.{
-+ "value: bool",
-+ },
-+ },
-+ .{
-+ .name = "@bitSizeOf",
-+ .signature = "@bitSizeOf(comptime T: type) comptime_int",
-+ .snippet = "@bitSizeOf(${1:comptime T: type})",
-+ .documentation =
-+ \\This function returns the number of bits it takes to store `T` in memory if the type were a field in a packed struct/union. The result is a target-specific compile time constant.
-+ \\
-+ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ },
-+ },
-+ .{
-+ .name = "@breakpoint",
-+ .signature = "@breakpoint()",
-+ .snippet = "@breakpoint()",
-+ .documentation =
-+ \\This function inserts a platform-specific debug trap instruction which causes debuggers to break there.
-+ \\
-+ \\This function is only valid within function scope.
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@mulAdd",
-+ .signature = "@mulAdd(comptime T: type, a: T, b: T, c: T) T",
-+ .snippet = "@mulAdd(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:c: T})",
-+ .documentation =
-+ \\Fused multiply add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate.
-+ \\
-+ \\Supports Floats and Vectors of floats.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "a: T",
-+ "b: T",
-+ "c: T",
-+ },
-+ },
-+ .{
-+ .name = "@byteSwap",
-+ .signature = "@byteSwap(comptime T: type, operand: T) T",
-+ .snippet = "@byteSwap(${1:comptime T: type}, ${2:operand: T})",
-+ .documentation =
-+ \\`T` must be an integer type with bit count evenly divisible by 8.
-+ \\
-+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
-+ \\
-+ \\Swaps the byte order of the integer. This converts a big endian integer to a little endian integer, and converts a little endian integer to a big endian integer.
-+ \\
-+ \\Note that for the purposes of memory layout with respect to endianness, the integer type should be related to the number of bytes reported by [@sizeOf](https://ziglang.org/documentation/0.9.1/#sizeOf) bytes. This is demonstrated with `u24`. `@sizeOf(u24) == 4`, which means that a `u24` stored in memory takes 4 bytes, and those 4 bytes are what are swapped on a little vs big endian system. On the other hand, if `T` is specified to be `u24`, then only 3 bytes are reversed.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "operand: T",
-+ },
-+ },
-+ .{
-+ .name = "@bitReverse",
-+ .signature = "@bitReverse(comptime T: type, integer: T) T",
-+ .snippet = "@bitReverse(${1:comptime T: type}, ${2:integer: T})",
-+ .documentation =
-+ \\`T` accepts any integer type.
-+ \\
-+ \\Reverses the bitpattern of an integer value, including the sign bit if applicable.
-+ \\
-+ \\For example 0b10110110 (`u8 = 182`, `i8 = -74`) becomes 0b01101101 (`u8 = 109`, `i8 = 109`).
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "integer: T",
-+ },
-+ },
-+ .{
-+ .name = "@offsetOf",
-+ .signature = "@offsetOf(comptime T: type, comptime field_name: []const u8) comptime_int",
-+ .snippet = "@offsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})",
-+ .documentation =
-+ \\Returns the byte offset of a field relative to its containing struct.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "comptime field_name: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@call",
-+ .signature = "@call(options: std.builtin.CallOptions, function: anytype, args: anytype) anytype",
-+ .snippet = "@call(${1:options: std.builtin.CallOptions}, ${2:function: anytype}, ${3:args: anytype})",
-+ .documentation =
-+ \\Calls a function, in the same way that invoking an expression with parentheses does:
-+ \\
-+ \\```zig
-+ \\const expect = @import("std").testing.expect;
-+ \\
-+ \\test "noinline function call" {
-+ \\ try expect(@call(.{}, add, .{3, 9}) == 12);
-+ \\}
-+ \\
-+ \\fn add(a: i32, b: i32) i32 {
-+ \\ return a + b;
-+ \\}
-+ \\```
-+ \\
-+ \\`@call` allows more flexibility than normal function call syntax does. The `CallOptions` struct is reproduced here:</p> {#syntax_block|zig|builtin.CallOptions struct#} pub const CallOptions = struct { modifier: Modifier = .auto, /// Only valid when `Modifier` is `Modifier.async_kw`. stack: ?[]align(std.Target.stack_align) u8 = null, pub const Modifier = enum { /// Equivalent to function call syntax. auto, /// Equivalent to async keyword used with function call syntax. async_kw, /// Prevents tail call optimization. This guarantees that the return /// address will point to the callsite, as opposed to the callsite's /// callsite. If the call is otherwise required to be tail-called /// or inlined, a compile error is emitted instead. never_tail, /// Guarantees that the call will not be inlined. If the call is /// otherwise required to be inlined, a compile error is emitted instead. never_inline, /// Asserts that the function call will not suspend. This allows a /// non-async f
unction to call an async function. no_async, /// Guarantees that the call will be generated with tail call optimization. /// If this is not possible, a compile error is emitted instead. always_tail, /// Guarantees that the call will inlined at the callsite. /// If this is not possible, a compile error is emitted instead. always_inline, /// Evaluates the call at compile-time. If the call cannot be completed at /// compile-time, a compile error is emitted instead. compile_time, }; }; {#end_syntax_block#}
-+ ,
-+ .arguments = &.{
-+ "options: std.builtin.CallOptions",
-+ "function: anytype",
-+ "args: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@cDefine",
-+ .signature = "@cDefine(comptime name: []u8, value)",
-+ .snippet = "@cDefine(${1:comptime name: []u8}, ${2:value})",
-+ .documentation =
-+ \\This function can only occur inside `@cImport`.
-+ \\
-+ \\This appends `#define $name $value` to the `@cImport` temporary buffer.
-+ \\
-+ \\To define without a value, like this:`#define _GNU_SOURCE`
-+ \\
-+ \\Use the void value, like this:
-+ \\
-+ \\```zig
-+ \\@cDefine("_GNU_SOURCE", {})
-+ \\```
-+ ,
-+ .arguments = &.{
-+ "comptime name: []u8",
-+ "value",
-+ },
-+ },
-+ .{
-+ .name = "@cImport",
-+ .signature = "@cImport(expression) type",
-+ .snippet = "@cImport(${1:expression})",
-+ .documentation =
-+ \\This function parses C code and imports the functions, types, variables, and compatible macro definitions into a new empty struct type, and then returns that type.
-+ \\
-+ \\`expression` is interpreted at compile time. The builtin functions `@cInclude`, `@cDefine`, and `@cUndef` work within this expression, appending to a temporary buffer which is then parsed as C code.
-+ \\
-+ \\Usually you should only have one `@cImport` in your entire application, because it saves the compiler from invoking clang multiple times, and prevents inline functions from being duplicated.
-+ \\
-+ \\Reasons for having multiple `@cImport` expressions would be:
-+ \\ - To avoid a symbol collision, for example if foo.h and bar.h both `#define CONNECTION_COUNT`
-+ \\ - To analyze the C code with different preprocessor defines
-+ ,
-+ .arguments = &.{
-+ "expression",
-+ },
-+ },
-+ .{
-+ .name = "@cInclude",
-+ .signature = "@cInclude(comptime path: []u8)",
-+ .snippet = "@cInclude(${1:comptime path: []u8})",
-+ .documentation =
-+ \\This function can only occur inside `@cImport`.
-+ \\
-+ \\This appends `#include <$path>\n` to the `c_import` temporary buffer.
-+ ,
-+ .arguments = &.{
-+ "comptime path: []u8",
-+ },
-+ },
-+ .{
-+ .name = "@clz",
-+ .signature = "@clz(comptime T: type, operand: T)",
-+ .snippet = "@clz(${1:comptime T: type}, ${2:operand: T})",
-+ .documentation =
-+ \\`T` must be an integer type.
-+ \\
-+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
-+ \\
-+ \\This function counts the number of most-significant (leading in a big-Endian sense) zeroes in an integer.
-+ \\
-+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
-+ \\
-+ \\If `operand` is zero, `@clz` returns the bit width of integer type `T`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "operand: T",
-+ },
-+ },
-+ .{
-+ .name = "@cmpxchgStrong",
-+ .signature = "@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T",
-+ .snippet = "@cmpxchgStrong(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})",
-+ .documentation =
-+ \\This function performs a strong atomic compare exchange operation. It's the equivalent of this code, except atomic:
-+ \\
-+ \\```zig
-+ \\fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T {
-+ \\ const old_value = ptr.*;
-+ \\ if (old_value == expected_value) {
-+ \\ ptr.* = new_value;
-+ \\ return null;
-+ \\ } else {
-+ \\ return old_value;
-+ \\ }
-+ \\}
-+ \\```
-+ \\
-+ \\If you are using cmpxchg in a loop, [@cmpxchgWeak](https://ziglang.org/documentation/0.9.1/#cmpxchgWeak) is the better choice, because it can be implemented more efficiently in machine instructions.
-+ \\
-+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
-+ \\
-+ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).`
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "ptr: *T",
-+ "expected_value: T",
-+ "new_value: T",
-+ "success_order: AtomicOrder",
-+ "fail_order: AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@cmpxchgWeak",
-+ .signature = "@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T",
-+ .snippet = "@cmpxchgWeak(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})",
-+ .documentation =
-+ \\This function performs a weak atomic compare exchange operation. It's the equivalent of this code, except atomic:</p> {#syntax_block|zig|cmpxchgWeakButNotAtomic#} fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T { const old_value = ptr.*; if (old_value == expected_value and usuallyTrueButSometimesFalse()) { ptr.* = new_value; return null; } else { return old_value; } } {#end_syntax_block#}
-+ \\
-+ \\If you are using cmpxchg in a loop, the sporadic failure will be no problem, and `cmpxchgWeak` is the better choice, because it can be implemented more efficiently in machine instructions. However if you need a stronger guarantee, use [@cmpxchgStrong](https://ziglang.org/documentation/0.9.1/#cmpxchgStrong).
-+ \\
-+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum.
-+ \\
-+ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).`
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "ptr: *T",
-+ "expected_value: T",
-+ "new_value: T",
-+ "success_order: AtomicOrder",
-+ "fail_order: AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@compileError",
-+ .signature = "@compileError(comptime msg: []u8)",
-+ .snippet = "@compileError(${1:comptime msg: []u8})",
-+ .documentation =
-+ \\This function, when semantically analyzed, causes a compile error with the message `msg`.
-+ \\
-+ \\There are several ways that code avoids being semantically checked, such as using `if` or `switch` with compile time constants, and `comptime` functions.
-+ ,
-+ .arguments = &.{
-+ "comptime msg: []u8",
-+ },
-+ },
-+ .{
-+ .name = "@compileLog",
-+ .signature = "@compileLog(args: ...)",
-+ .snippet = "@compileLog(${1:args: ...})",
-+ .documentation =
-+ \\This function prints the arguments passed to it at compile-time.
-+ \\
-+ \\To prevent accidentally leaving compile log statements in a codebase, a compilation error is added to the build, pointing to the compile log statement. This error prevents code from being generated, but does not otherwise interfere with analysis.
-+ \\
-+ \\This function can be used to do "printf debugging" on compile-time executing code.
-+ \\
-+ \\```zig
-+ \\const print = @import("std").debug.print;
-+ \\
-+ \\const num1 = blk: {
-+ \\ var val1: i32 = 99;
-+ \\ @compileLog("comptime val1 = ", val1);
-+ \\ val1 = val1 + 1;
-+ \\ break :blk val1;
-+ \\};
-+ \\
-+ \\test "main" {
-+ \\ @compileLog("comptime in main");
-+ \\
-+ \\ print("Runtime in main, num1 = {}.\n", .{num1});
-+ \\}
-+ \\```
-+ \\
-+ \\will output:
-+ \\
-+ \\If all `@compileLog` calls are removed or not encountered by analysis, the program compiles successfully and the generated executable prints:</p> {#code_begin|test|without_compileLog#} const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; val1 = val1 + 1; break :blk val1; }; test "main" { print("Runtime in main, num1 = {}.\n", .{num1}); }`
-+ ,
-+ .arguments = &.{
-+ "args: ...",
-+ },
-+ },
-+ .{
-+ .name = "@ctz",
-+ .signature = "@ctz(comptime T: type, operand: T)",
-+ .snippet = "@ctz(${1:comptime T: type}, ${2:operand: T})",
-+ .documentation =
-+ \\`T` must be an integer type.
-+ \\
-+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
-+ \\
-+ \\This function counts the number of least-significant (trailing in a big-Endian sense) zeroes in an integer.
-+ \\
-+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
-+ \\
-+ \\If `operand` is zero, `@ctz` returns the bit width of integer type `T`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "operand: T",
-+ },
-+ },
-+ .{
-+ .name = "@cUndef",
-+ .signature = "@cUndef(comptime name: []u8)",
-+ .snippet = "@cUndef(${1:comptime name: []u8})",
-+ .documentation =
-+ \\This function can only occur inside `@cImport`.
-+ \\
-+ \\This appends `#undef $name` to the `@cImport` temporary buffer.
-+ ,
-+ .arguments = &.{
-+ "comptime name: []u8",
-+ },
-+ },
-+ .{
-+ .name = "@divExact",
-+ .signature = "@divExact(numerator: T, denominator: T) T",
-+ .snippet = "@divExact(${1:numerator: T}, ${2:denominator: T})",
-+ .documentation =
-+ \\Exact division. Caller guarantees `denominator != 0` and `@divTrunc(numerator, denominator) * denominator == numerator`.
-+ \\ - `@divExact(6, 3) == 2`
-+ \\ - `@divExact(a, b) * b == a`
-+ \\
-+ \\For a function that returns a possible error code, use `@import("std").math.divExact`.
-+ ,
-+ .arguments = &.{
-+ "numerator: T",
-+ "denominator: T",
-+ },
-+ },
-+ .{
-+ .name = "@divFloor",
-+ .signature = "@divFloor(numerator: T, denominator: T) T",
-+ .snippet = "@divFloor(${1:numerator: T}, ${2:denominator: T})",
-+ .documentation =
-+ \\Floored division. Rounds toward negative infinity. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`.
-+ \\ - `@divFloor(-5, 3) == -2`
-+ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a`
-+ \\
-+ \\For a function that returns a possible error code, use `@import("std").math.divFloor`.
-+ ,
-+ .arguments = &.{
-+ "numerator: T",
-+ "denominator: T",
-+ },
-+ },
-+ .{
-+ .name = "@divTrunc",
-+ .signature = "@divTrunc(numerator: T, denominator: T) T",
-+ .snippet = "@divTrunc(${1:numerator: T}, ${2:denominator: T})",
-+ .documentation =
-+ \\Truncated division. Rounds toward zero. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`.
-+ \\ - `@divTrunc(-5, 3) == -1`
-+ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a`
-+ \\
-+ \\For a function that returns a possible error code, use `@import("std").math.divTrunc`.
-+ ,
-+ .arguments = &.{
-+ "numerator: T",
-+ "denominator: T",
-+ },
-+ },
-+ .{
-+ .name = "@embedFile",
-+ .signature = "@embedFile(comptime path: []const u8) *const [N:0]u8",
-+ .snippet = "@embedFile(${1:comptime path: []const u8})",
-+ .documentation =
-+ \\This function returns a compile time constant pointer to null-terminated, fixed-size array with length equal to the byte count of the file given by `path`. The contents of the array are the contents of the file. This is equivalent to a [string literal](https://ziglang.org/documentation/0.9.1/#String-Literals-and-Unicode-Code-Point-Literals) with the file contents.
-+ \\
-+ \\`path` is absolute or relative to the current file, just like `@import`.
-+ ,
-+ .arguments = &.{
-+ "comptime path: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@enumToInt",
-+ .signature = "@enumToInt(enum_or_tagged_union: anytype) anytype",
-+ .snippet = "@enumToInt(${1:enum_or_tagged_union: anytype})",
-+ .documentation =
-+ \\Converts an enumeration value into its integer tag type. When a tagged union is passed, the tag value is used as the enumeration value.
-+ \\
-+ \\If there is only one possible enum value, the result is a `comptime_int` known at [comptime](https://ziglang.org/documentation/0.9.1/#comptime).
-+ ,
-+ .arguments = &.{
-+ "enum_or_tagged_union: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@errorName",
-+ .signature = "@errorName(err: anyerror) [:0]const u8",
-+ .snippet = "@errorName(${1:err: anyerror})",
-+ .documentation =
-+ \\This function returns the string representation of an error. The string representation of `error.OutOfMem` is `"OutOfMem"`.
-+ \\
-+ \\If there are no calls to `@errorName` in an entire application, or all calls have a compile-time known value for `err`, then no error name table will be generated.
-+ ,
-+ .arguments = &.{
-+ "err: anyerror",
-+ },
-+ },
-+ .{
-+ .name = "@errorReturnTrace",
-+ .signature = "@errorReturnTrace() ?*builtin.StackTrace",
-+ .snippet = "@errorReturnTrace()",
-+ .documentation =
-+ \\If the binary is built with error return tracing, and this function is invoked in a function that calls a function with an error or error union return type, returns a stack trace object. Otherwise returns [null](https://ziglang.org/documentation/0.9.1/#null).
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@errorToInt",
-+ .signature = "@errorToInt(err: anytype) std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)",
-+ .snippet = "@errorToInt(${1:err: anytype})",
-+ .documentation =
-+ \\Supports the following types:
-+ \\ - [The Global Error Set](https://ziglang.org/documentation/0.9.1/#The-Global-Error-Set)
-+ \\ - [Error Set Type](https://ziglang.org/documentation/0.9.1/#Error-Set-Type)
-+ \\ - [Error Union Type](https://ziglang.org/documentation/0.9.1/#Error-Union-Type)
-+ \\
-+ \\Converts an error to the integer representation of an error.
-+ \\
-+ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes.
-+ ,
-+ .arguments = &.{
-+ "err: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@errSetCast",
-+ .signature = "@errSetCast(comptime T: DestType, value: anytype) DestType",
-+ .snippet = "@errSetCast(${1:comptime T: DestType}, ${2:value: anytype})",
-+ .documentation =
-+ \\Converts an error value from one error set to another error set. Attempting to convert an error which is not in the destination error set results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "comptime T: DestType",
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@export",
-+ .signature = "@export(declaration, comptime options: std.builtin.ExportOptions) void",
-+ .snippet = "@export(${1:declaration}, ${2:comptime options: std.builtin.ExportOptions})",
-+ .documentation =
-+ \\Creates a symbol in the output object file.
-+ \\
-+ \\`declaration` must be one of two things:
-+ \\ - An identifier (`x`) identifying a [function](https://ziglang.org/documentation/0.9.1/#Functions) or a [variable](https://ziglang.org/documentation/0.9.1/#Container-Level-Variables).
-+ \\ - Field access (`x.y`) looking up a [function](https://ziglang.org/documentation/0.9.1/#Functions) or a [variable](https://ziglang.org/documentation/0.9.1/#Container-Level-Variables).
-+ \\
-+ \\This builtin can be called from a [comptime](https://ziglang.org/documentation/0.9.1/#comptime) block to conditionally export symbols. When `declaration` is a function with the C calling convention and `options.linkage` is `Strong`, this is equivalent to the `export` keyword used on a function:
-+ \\
-+ \\```zig
-+ \\comptime {
-+ \\ @export(internalName, .{ .name = "foo", .linkage = .Strong });
-+ \\}
-+ \\
-+ \\fn internalName() callconv(.C) void {}
-+ \\```
-+ \\
-+ \\This is equivalent to:
-+ \\
-+ \\```zig
-+ \\export fn foo() void {}
-+ \\```
-+ \\
-+ \\Note that even when using `export`, the `@"foo"` syntax for [identifiers](https://ziglang.org/documentation/0.9.1/#Identifiers) can be used to choose any string for the symbol name:
-+ \\
-+ \\```zig
-+ \\export fn @"A function name that is a complete sentence."() void {}
-+ \\```
-+ \\
-+ \\When looking at the resulting object, you can see the symbol is used verbatim:
-+ \\
-+ \\```zig
-+ \\00000000000001f0 T A function name that is a complete sentence.
-+ \\```
-+ ,
-+ .arguments = &.{
-+ "declaration",
-+ "comptime options: std.builtin.ExportOptions",
-+ },
-+ },
-+ .{
-+ .name = "@extern",
-+ .signature = "@extern(T: type, comptime options: std.builtin.ExternOptions) *T",
-+ .snippet = "@extern(${1:T: type}, ${2:comptime options: std.builtin.ExternOptions})",
-+ .documentation =
-+ \\Creates a reference to an external symbol in the output object file.
-+ ,
-+ .arguments = &.{
-+ "T: type",
-+ "comptime options: std.builtin.ExternOptions",
-+ },
-+ },
-+ .{
-+ .name = "@fence",
-+ .signature = "@fence(order: AtomicOrder)",
-+ .snippet = "@fence(${1:order: AtomicOrder})",
-+ .documentation =
-+ \\The `fence` function is used to introduce happens-before edges between operations.
-+ \\
-+ \\`AtomicOrder` can be found with `@import("std").builtin.AtomicOrder`.
-+ ,
-+ .arguments = &.{
-+ "order: AtomicOrder",
-+ },
-+ },
-+ .{
-+ .name = "@field",
-+ .signature = "@field(lhs: anytype, comptime field_name: []const u8) (field)",
-+ .snippet = "@field(${1:lhs: anytype}, ${2:comptime field_name: []const u8})",
-+ .documentation =
-+ \\Performs field access by a compile-time string. Works on both fields and declarations.</p> {#code_begin|test|field_decl_access_by_string#} const std = @import("std"); const Point = struct { x: u32, y: u32, pub var z: u32 = 1; }; test "field access by string" { const expect = std.testing.expect; var p = Point{ .x = 0, .y = 0 }; @field(p, "x") = 4; @field(p, "y") = @field(p, "x") + 1; try expect(@field(p, "x") == 4); try expect(@field(p, "y") == 5); } test "decl access by string" { const expect = std.testing.expect; try expect(@field(Point, "z") == 1); @field(Point, "z") = 2; try expect(@field(Point, "z") == 2); }`
-+ ,
-+ .arguments = &.{
-+ "lhs: anytype",
-+ "comptime field_name: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@fieldParentPtr",
-+ .signature = "@fieldParentPtr(comptime ParentType: type, comptime field_name: []const u8, field_ptr: *T) *ParentType",
-+ .snippet = "@fieldParentPtr(${1:comptime ParentType: type}, ${2:comptime field_name: []const u8}, ${3:field_ptr: *T})",
-+ .documentation =
-+ \\Given a pointer to a field, returns the base pointer of a struct.
-+ ,
-+ .arguments = &.{
-+ "comptime ParentType: type",
-+ "comptime field_name: []const u8",
-+ "field_ptr: *T",
-+ },
-+ },
-+ .{
-+ .name = "@floatCast",
-+ .signature = "@floatCast(comptime DestType: type, value: anytype) DestType",
-+ .snippet = "@floatCast(${1:comptime DestType: type}, ${2:value: anytype})",
-+ .documentation =
-+ \\Convert from one float type to another. This cast is safe, but may cause the numeric value to lose precision.
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@floatToInt",
-+ .signature = "@floatToInt(comptime DestType: type, float: anytype) DestType",
-+ .snippet = "@floatToInt(${1:comptime DestType: type}, ${2:float: anytype})",
-+ .documentation =
-+ \\Converts the integer part of a floating point number to the destination type.
-+ \\
-+ \\If the integer part of the floating point number cannot fit in the destination type, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "float: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@frame",
-+ .signature = "@frame() *@Frame(func)",
-+ .snippet = "@frame()",
-+ .documentation =
-+ \\This function returns a pointer to the frame for a given function. This type can be [coerced](https://ziglang.org/documentation/0.9.1/#Type-Coercion) to `anyframe->T` and to `anyframe`, where `T` is the return type of the function in scope.
-+ \\
-+ \\This function does not mark a suspension point, but it does cause the function in scope to become an [async function](https://ziglang.org/documentation/0.9.1/#Async-Functions).
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@Frame",
-+ .signature = "@Frame(func: anytype) type",
-+ .snippet = "@Frame(${1:func: anytype})",
-+ .documentation =
-+ \\This function returns the frame type of a function. This works for [Async Functions](https://ziglang.org/documentation/0.9.1/#Async-Functions) as well as any function without a specific calling convention.
-+ \\
-+ \\This type is suitable to be used as the return type of [async](https://ziglang.org/documentation/0.9.1/#Async-and-Await) which allows one to, for example, heap-allocate an async function frame:</p> {#code_begin|test|heap_allocated_frame#} const std = @import("std"); test "heap allocated frame" { const frame = try std.heap.page_allocator.create(@Frame(func)); frame.* = async func(); } fn func() void { suspend {} }`
-+ ,
-+ .arguments = &.{
-+ "func: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@frameAddress",
-+ .signature = "@frameAddress() usize",
-+ .snippet = "@frameAddress()",
-+ .documentation =
-+ \\This function returns the base pointer of the current stack frame.
-+ \\
-+ \\The implications of this are target specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations.
-+ \\
-+ \\This function is only valid within function scope.
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@frameSize",
-+ .signature = "@frameSize() usize",
-+ .snippet = "@frameSize()",
-+ .documentation =
-+ \\This is the same as `@sizeOf(@Frame(func))`, where `func` may be runtime-known.
-+ \\
-+ \\This function is typically used in conjunction with [@asyncCall](https://ziglang.org/documentation/0.9.1/#asyncCall).
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@hasDecl",
-+ .signature = "@hasDecl(comptime Container: type, comptime name: []const u8) bool",
-+ .snippet = "@hasDecl(${1:comptime Container: type}, ${2:comptime name: []const u8})",
-+ .documentation =
-+ \\Returns whether or not a [struct](https://ziglang.org/documentation/0.9.1/#struct), [enum](https://ziglang.org/documentation/0.9.1/#enum), or [union](https://ziglang.org/documentation/0.9.1/#union) has a declaration matching `name`.</p> {#code_begin|test|hasDecl#} const std = @import("std"); const expect = std.testing.expect; const Foo = struct { nope: i32, pub var blah = "xxx"; const hi = 1; }; test "@hasDecl" { try expect(@hasDecl(Foo, "blah")); // Even though `hi` is private, @hasDecl returns true because this test is // in the same file scope as Foo. It would return false if Foo was declared // in a different file. try expect(@hasDecl(Foo, "hi")); // @hasDecl is for declarations; not fields. try expect(!@hasDecl(Foo, "nope")); try expect(!@hasDecl(Foo, "nope1234")); }`
-+ ,
-+ .arguments = &.{
-+ "comptime Container: type",
-+ "comptime name: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@hasField",
-+ .signature = "@hasField(comptime Container: type, comptime name: []const u8) bool",
-+ .snippet = "@hasField(${1:comptime Container: type}, ${2:comptime name: []const u8})",
-+ .documentation =
-+ \\Returns whether the field name of a struct, union, or enum exists.
-+ \\
-+ \\The result is a compile time constant.
-+ \\
-+ \\It does not include functions, variables, or constants.
-+ ,
-+ .arguments = &.{
-+ "comptime Container: type",
-+ "comptime name: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@import",
-+ .signature = "@import(comptime path: []u8) type",
-+ .snippet = "@import(${1:comptime path: []u8})",
-+ .documentation =
-+ \\This function finds a zig file corresponding to `path` and adds it to the build, if it is not already added.
-+ \\
-+ \\Zig source files are implicitly structs, with a name equal to the file's basename with the extension truncated. `@import` returns the struct type corresponding to the file.
-+ \\
-+ \\Declarations which have the `pub` keyword may be referenced from a different source file than the one they are declared in.
-+ \\
-+ \\`path` can be a relative path or it can be the name of a package. If it is a relative path, it is relative to the file that contains the `@import` function call.
-+ \\
-+ \\The following packages are always available:
-+ \\ - `@import("std")` - Zig Standard Library
-+ \\ - `@import("builtin")` - Target-specific information The command `zig build-exe --show-builtin` outputs the source to stdout for reference.
-+ \\ - `@import("root")` - Points to the root source file This is usually `src/main.zig` but it depends on what file is chosen to be built.
-+ ,
-+ .arguments = &.{
-+ "comptime path: []u8",
-+ },
-+ },
-+ .{
-+ .name = "@intCast",
-+ .signature = "@intCast(comptime DestType: type, int: anytype) DestType",
-+ .snippet = "@intCast(${1:comptime DestType: type}, ${2:int: anytype})",
-+ .documentation =
-+ \\Converts an integer to another integer while keeping the same numerical value. Attempting to convert a number which is out of range of the destination type results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
-+ \\
-+ \\```zig
-+ \\test "integer cast panic" {
-+ \\ var a: u16 = 0xabcd;
-+ \\ var b: u8 = @intCast(u8, a);
-+ \\ _ = b;
-+ \\}
-+ \\```
-+ \\
-+ \\To truncate the significant bits of a number out of range of the destination type, use [@truncate](https://ziglang.org/documentation/0.9.1/#truncate).
-+ \\
-+ \\If `T` is `comptime_int`, then this is semantically equivalent to [Type Coercion](https://ziglang.org/documentation/0.9.1/#Type-Coercion).
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "int: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@intToEnum",
-+ .signature = "@intToEnum(comptime DestType: type, integer: anytype) DestType",
-+ .snippet = "@intToEnum(${1:comptime DestType: type}, ${2:integer: anytype})",
-+ .documentation =
-+ \\Converts an integer into an [enum](https://ziglang.org/documentation/0.9.1/#enum) value.
-+ \\
-+ \\Attempting to convert an integer which represents no value in the chosen enum type invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "integer: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@intToError",
-+ .signature = "@intToError(value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)) anyerror",
-+ .snippet = "@intToError(${1:value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)})",
-+ .documentation =
-+ \\Converts from the integer representation of an error into [The Global Error Set](https://ziglang.org/documentation/0.9.1/#The-Global-Error-Set) type.
-+ \\
-+ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes.
-+ \\
-+ \\Attempting to convert an integer that does not correspond to any error results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)",
-+ },
-+ },
-+ .{
-+ .name = "@intToFloat",
-+ .signature = "@intToFloat(comptime DestType: type, int: anytype) DestType",
-+ .snippet = "@intToFloat(${1:comptime DestType: type}, ${2:int: anytype})",
-+ .documentation =
-+ \\Converts an integer to the closest floating point representation. To convert the other way, use [@floatToInt](https://ziglang.org/documentation/0.9.1/#floatToInt). This cast is always safe.
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "int: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@intToPtr",
-+ .signature = "@intToPtr(comptime DestType: type, address: usize) DestType",
-+ .snippet = "@intToPtr(${1:comptime DestType: type}, ${2:address: usize})",
-+ .documentation =
-+ \\Converts an integer to a [pointer](https://ziglang.org/documentation/0.9.1/#Pointers). To convert the other way, use [@ptrToInt](https://ziglang.org/documentation/0.9.1/#ptrToInt). Casting an address of 0 to a destination type which in not [optional](https://ziglang.org/documentation/0.9.1/#Optional-Pointers) and does not have the `allowzero` attribute will result in a [Pointer Cast Invalid Null](https://ziglang.org/documentation/0.9.1/#Pointer-Cast-Invalid-Null) panic when runtime safety checks are enabled.
-+ \\
-+ \\If the destination pointer type does not allow address zero and `address` is zero, this invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "address: usize",
-+ },
-+ },
-+ .{
-+ .name = "@maximum",
-+ .signature = "@maximum(a: T, b: T) T",
-+ .snippet = "@maximum(${1:a: T}, ${2:b: T})",
-+ .documentation =
-+ \\Returns the maximum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
-+ \\
-+ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
-+ ,
-+ .arguments = &.{
-+ "a: T",
-+ "b: T",
-+ },
-+ },
-+ .{
-+ .name = "@memcpy",
-+ .signature = "@memcpy(noalias dest: [*]u8, noalias source: [*]const u8, byte_count: usize)",
-+ .snippet = "@memcpy(${1:noalias dest: [*]u8}, ${2:noalias source: [*]const u8}, ${3:byte_count: usize})",
-+ .documentation =
-+ \\This function copies bytes from one region of memory to another. `dest` and `source` are both pointers and must not overlap.
-+ \\
-+ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this:
-+ \\
-+ \\```zig
-+ \\for (source[0..byte_count]) |b, i| dest[i] = b;
-+ \\```
-+ \\
-+ \\The optimizer is intelligent enough to turn the above snippet into a memcpy.
-+ \\
-+ \\There is also a standard library function for this:
-+ \\
-+ \\```zig
-+ \\const mem = @import("std").mem;
-+ \\mem.copy(u8, dest[0..byte_count], source[0..byte_count]);
-+ \\```
-+ ,
-+ .arguments = &.{
-+ "noalias dest: [*]u8",
-+ "noalias source: [*]const u8",
-+ "byte_count: usize",
-+ },
-+ },
-+ .{
-+ .name = "@memset",
-+ .signature = "@memset(dest: [*]u8, c: u8, byte_count: usize)",
-+ .snippet = "@memset(${1:dest: [*]u8}, ${2:c: u8}, ${3:byte_count: usize})",
-+ .documentation =
-+ \\This function sets a region of memory to `c`. `dest` is a pointer.
-+ \\
-+ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this:
-+ \\
-+ \\```zig
-+ \\for (dest[0..byte_count]) |*b| b.* = c;
-+ \\```
-+ \\
-+ \\The optimizer is intelligent enough to turn the above snippet into a memset.
-+ \\
-+ \\There is also a standard library function for this:
-+ \\
-+ \\```zig
-+ \\const mem = @import("std").mem;
-+ \\mem.set(u8, dest, c);
-+ \\```
-+ ,
-+ .arguments = &.{
-+ "dest: [*]u8",
-+ "c: u8",
-+ "byte_count: usize",
-+ },
-+ },
-+ .{
-+ .name = "@minimum",
-+ .signature = "@minimum(a: T, b: T) T",
-+ .snippet = "@minimum(${1:a: T}, ${2:b: T})",
-+ .documentation =
-+ \\Returns the minimum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
-+ \\
-+ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
-+ ,
-+ .arguments = &.{
-+ "a: T",
-+ "b: T",
-+ },
-+ },
-+ .{
-+ .name = "@wasmMemorySize",
-+ .signature = "@wasmMemorySize(index: u32) u32",
-+ .snippet = "@wasmMemorySize(${1:index: u32})",
-+ .documentation =
-+ \\This function returns the size of the Wasm memory identified by `index` as an unsigned value in units of Wasm pages. Note that each Wasm page is 64KB in size.
-+ \\
-+ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.
-+ ,
-+ .arguments = &.{
-+ "index: u32",
-+ },
-+ },
-+ .{
-+ .name = "@wasmMemoryGrow",
-+ .signature = "@wasmMemoryGrow(index: u32, delta: u32) i32",
-+ .snippet = "@wasmMemoryGrow(${1:index: u32}, ${2:delta: u32})",
-+ .documentation =
-+ \\This function increases the size of the Wasm memory identified by `index` by `delta` in units of unsigned number of Wasm pages. Note that each Wasm page is 64KB in size. On success, returns previous memory size; on failure, if the allocation fails, returns -1.
-+ \\
-+ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.</p> {#code_begin|test|wasmMemoryGrow#} const std = @import("std"); const native_arch = @import("builtin").target.cpu.arch; const expect = std.testing.expect; test "@wasmMemoryGrow" { if (native_arch != .wasm32) return error.SkipZigTest; var prev = @wasmMemorySize(0); try expect(prev == @wasmMemoryGrow(0, 1)); try expect(prev + 1 == @wasmMemorySize(0)); }`
-+ ,
-+ .arguments = &.{
-+ "index: u32",
-+ "delta: u32",
-+ },
-+ },
-+ .{
-+ .name = "@mod",
-+ .signature = "@mod(numerator: T, denominator: T) T",
-+ .snippet = "@mod(${1:numerator: T}, ${2:denominator: T})",
-+ .documentation =
-+ \\Modulus division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.9.1/#Remainder-Division-by-Zero) when runtime safety checks are enabled.
-+ \\ - `@mod(-5, 3) == 1`
-+ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a`
-+ \\
-+ \\For a function that returns an error code, see `@import("std").math.mod`.
-+ ,
-+ .arguments = &.{
-+ "numerator: T",
-+ "denominator: T",
-+ },
-+ },
-+ .{
-+ .name = "@mulWithOverflow",
-+ .signature = "@mulWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
-+ .snippet = "@mulWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
-+ .documentation =
-+ \\Performs `result.* = a * b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "a: T",
-+ "b: T",
-+ "result: *T",
-+ },
-+ },
-+ .{
-+ .name = "@panic",
-+ .signature = "@panic(message: []const u8) noreturn",
-+ .snippet = "@panic(${1:message: []const u8})",
-+ .documentation =
-+ \\Invokes the panic handler function. By default the panic handler function calls the public `panic` function exposed in the root source file, or if there is not one specified, the `std.builtin.default_panic` function from `std/builtin.zig`.
-+ \\
-+ \\Generally it is better to use `@import("std").debug.panic`. However, `@panic` can be useful for 2 scenarios:
-+ \\ - From library code, calling the programmer's panic function if they exposed one in the root source file.
-+ \\ - When mixing C and Zig code, calling the canonical panic implementation across multiple .o files.
-+ ,
-+ .arguments = &.{
-+ "message: []const u8",
-+ },
-+ },
-+ .{
-+ .name = "@popCount",
-+ .signature = "@popCount(comptime T: type, operand: T)",
-+ .snippet = "@popCount(${1:comptime T: type}, ${2:operand: T})",
-+ .documentation =
-+ \\`T` must be an integer type.
-+ \\
-+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
-+ \\
-+ \\Counts the number of bits set in an integer.
-+ \\
-+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "operand: T",
-+ },
-+ },
-+ .{
-+ .name = "@prefetch",
-+ .signature = "@prefetch(ptr: anytype, comptime options: std.builtin.PrefetchOptions)",
-+ .snippet = "@prefetch(${1:ptr: anytype}, ${2:comptime options: std.builtin.PrefetchOptions})",
-+ .documentation =
-+ \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a noop. This function has no effect on the behavior of the program, only on the performance characteristics.
-+ \\
-+ \\The `ptr` argument may be any pointer type and determines the memory address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no illegal behavior will result.
-+ \\
-+ \\The `options` argument is the following struct:</p> {#code_begin|syntax|builtin#} /// This data structure is used by the Zig language code generation and /// therefore must be kept in sync with the compiler implementation. pub const PrefetchOptions = struct { /// Whether the prefetch should prepare for a read or a write. rw: Rw = .read, /// 0 means no temporal locality. That is, the data can be immediately /// dropped from the cache after it is accessed. /// /// 3 means high temporal locality. That is, the data should be kept in /// the cache as it is likely to be accessed again soon. locality: u2 = 3, /// The cache that the prefetch should be preformed on. cache: Cache = .data, pub const Rw = enum { read, write, }; pub const Cache = enum { instruction, data, }; };`
-+ ,
-+ .arguments = &.{
-+ "ptr: anytype",
-+ "comptime options: std.builtin.PrefetchOptions",
-+ },
-+ },
-+ .{
-+ .name = "@ptrCast",
-+ .signature = "@ptrCast(comptime DestType: type, value: anytype) DestType",
-+ .snippet = "@ptrCast(${1:comptime DestType: type}, ${2:value: anytype})",
-+ .documentation =
-+ \\Converts a pointer of one type to a pointer of another type.
-+ \\
-+ \\[Optional Pointers](https://ziglang.org/documentation/0.9.1/#Optional-Pointers) are allowed. Casting an optional pointer which is [null](https://ziglang.org/documentation/0.9.1/#null) to a non-optional pointer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "comptime DestType: type",
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@ptrToInt",
-+ .signature = "@ptrToInt(value: anytype) usize",
-+ .snippet = "@ptrToInt(${1:value: anytype})",
-+ .documentation =
-+ \\Converts `value` to a `usize` which is the address of the pointer. `value` can be one of these types:
-+ \\ - `*T`
-+ \\ - `?*T`
-+ \\ - `fn()`
-+ \\ - `?fn()`
-+ \\
-+ \\To convert the other way, use [@intToPtr](https://ziglang.org/documentation/0.9.1/#intToPtr)
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@rem",
-+ .signature = "@rem(numerator: T, denominator: T) T",
-+ .snippet = "@rem(${1:numerator: T}, ${2:denominator: T})",
-+ .documentation =
-+ \\Remainder division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.9.1/#Remainder-Division-by-Zero) when runtime safety checks are enabled.
-+ \\ - `@rem(-5, 3) == -2`
-+ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a`
-+ \\
-+ \\For a function that returns an error code, see `@import("std").math.rem`.
-+ ,
-+ .arguments = &.{
-+ "numerator: T",
-+ "denominator: T",
-+ },
-+ },
-+ .{
-+ .name = "@returnAddress",
-+ .signature = "@returnAddress() usize",
-+ .snippet = "@returnAddress()",
-+ .documentation =
-+ \\This function returns the address of the next machine code instruction that will be executed when the current function returns.
-+ \\
-+ \\The implications of this are target specific and not consistent across all platforms.
-+ \\
-+ \\This function is only valid within function scope. If the function gets inlined into a calling function, the returned address will apply to the calling function.
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@select",
-+ .signature = "@select(comptime T: type, pred: std.meta.Vector(len, bool), a: std.meta.Vector(len, T), b: std.meta.Vector(len, T)) std.meta.Vector(len, T)",
-+ .snippet = "@select(${1:comptime T: type}, ${2:pred: std.meta.Vector(len, bool)}, ${3:a: std.meta.Vector(len, T)}, ${4:b: std.meta.Vector(len, T)})",
-+ .documentation =
-+ \\Selects values element-wise from `a` or `b` based on `pred`. If `pred[i]` is `true`, the corresponding element in the result will be `a[i]` and otherwise `b[i]`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "pred: std.meta.Vector(len, bool)",
-+ "a: std.meta.Vector(len, T)",
-+ "b: std.meta.Vector(len, T)",
-+ },
-+ },
-+ .{
-+ .name = "@setAlignStack",
-+ .signature = "@setAlignStack(comptime alignment: u29)",
-+ .snippet = "@setAlignStack(${1:comptime alignment: u29})",
-+ .documentation =
-+ \\Ensures that a function will have a stack alignment of at least `alignment` bytes.
-+ ,
-+ .arguments = &.{
-+ "comptime alignment: u29",
-+ },
-+ },
-+ .{
-+ .name = "@setCold",
-+ .signature = "@setCold(comptime is_cold: bool)",
-+ .snippet = "@setCold(${1:comptime is_cold: bool})",
-+ .documentation =
-+ \\Tells the optimizer that a function is rarely called.
-+ ,
-+ .arguments = &.{
-+ "comptime is_cold: bool",
-+ },
-+ },
-+ .{
-+ .name = "@setEvalBranchQuota",
-+ .signature = "@setEvalBranchQuota(comptime new_quota: u32)",
-+ .snippet = "@setEvalBranchQuota(${1:comptime new_quota: u32})",
-+ .documentation =
-+ \\Changes the maximum number of backwards branches that compile-time code execution can use before giving up and making a compile error.
-+ \\
-+ \\If the `new_quota` is smaller than the default quota (`1000`) or a previously explicitly set quota, it is ignored.
-+ \\
-+ \\Example:
-+ \\
-+ \\```zig
-+ \\test "foo" {
-+ \\ comptime {
-+ \\ var i = 0;
-+ \\ while (i < 1001) : (i += 1) {}
-+ \\ }
-+ \\}
-+ \\```
-+ \\
-+ \\Now we use `@setEvalBranchQuota`:</p> {#code_begin|test|setEvalBranchQuota#} test "foo" { comptime { @setEvalBranchQuota(1001); var i = 0; while (i < 1001) : (i += 1) {} } }`
-+ ,
-+ .arguments = &.{
-+ "comptime new_quota: u32",
-+ },
-+ },
-+ .{
-+ .name = "@setFloatMode",
-+ .signature = "@setFloatMode(comptime mode: @import(\"std\").builtin.FloatMode)",
-+ .snippet = "@setFloatMode(${1:comptime mode: @import(\"std\").builtin.FloatMode})",
-+ .documentation =
-+ \\Sets the floating point mode of the current scope. Possible values are:
-+ \\
-+ \\```zig
-+ \\pub const FloatMode = enum {
-+ \\ Strict,
-+ \\ Optimized,
-+ \\};
-+ \\```
-+ \\
-+ \\ - `Strict` (default) - Floating point operations follow strict IEEE compliance.
-+ \\ - `Optimized` - Floating point operations may do all of the following: <ul>
-+ \\ - Assume the arguments and result are not NaN. Optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined.
-+ \\ - Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined.
-+ \\ - Treat the sign of a zero argument or result as insignificant.
-+ \\ - Use the reciprocal of an argument rather than perform division.
-+ \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add).
-+ \\ - Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate). This is equivalent to `-ffast-math` in GCC.</ul>
-+ \\
-+ \\The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block.
-+ ,
-+ .arguments = &.{
-+ "comptime mode: @import(\"std\").builtin.FloatMode",
-+ },
-+ },
-+ .{
-+ .name = "@setRuntimeSafety",
-+ .signature = "@setRuntimeSafety(comptime safety_on: bool) void",
-+ .snippet = "@setRuntimeSafety(${1:comptime safety_on: bool})",
-+ .documentation =
-+ \\Sets whether runtime safety checks are enabled for the scope that contains the function call.
-+ \\
-+ \\```zig
-+ \\test "@setRuntimeSafety" {
-+ \\ // The builtin applies to the scope that it is called in. So here, integer overflow
-+ \\ // will not be caught in ReleaseFast and ReleaseSmall modes:
-+ \\ // var x: u8 = 255;
-+ \\ // x += 1; // undefined behavior in ReleaseFast/ReleaseSmall modes.
-+ \\ {
-+ \\ // However this block has safety enabled, so safety checks happen here,
-+ \\ // even in ReleaseFast and ReleaseSmall modes.
-+ \\ @setRuntimeSafety(true);
-+ \\ var x: u8 = 255;
-+ \\ x += 1;
-+ \\
-+ \\ {
-+ \\ // The value can be overridden at any scope. So here integer overflow
-+ \\ // would not be caught in any build mode.
-+ \\ @setRuntimeSafety(false);
-+ \\ // var x: u8 = 255;
-+ \\ // x += 1; // undefined behavior in all build modes.
-+ \\ }
-+ \\ }
-+ \\}
-+ \\```
-+ \\
-+ \\Note: it is [planned](https://github.com/ziglang/zig/issues/978) to replace `@setRuntimeSafety` with `@optimizeFor`
-+ ,
-+ .arguments = &.{
-+ "comptime safety_on: bool",
-+ },
-+ },
-+ .{
-+ .name = "@shlExact",
-+ .signature = "@shlExact(value: T, shift_amt: Log2T) T",
-+ .snippet = "@shlExact(${1:value: T}, ${2:shift_amt: Log2T})",
-+ .documentation =
-+ \\Performs the left shift operation (`<<`). For unsigned integers, the result is [undefined](https://ziglang.org/documentation/0.9.1/#undefined) if any 1 bits are shifted out. For signed integers, the result is [undefined](https://ziglang.org/documentation/0.9.1/#undefined) if any bits that disagree with the resultant sign bit are shifted out.
-+ \\
-+ \\The type of `shift_amt` is an unsigned integer with `log2(T.bit_count)` bits. This is because `shift_amt >= T.bit_count` is undefined behavior.
-+ ,
-+ .arguments = &.{
-+ "value: T",
-+ "shift_amt: Log2T",
-+ },
-+ },
-+ .{
-+ .name = "@shlWithOverflow",
-+ .signature = "@shlWithOverflow(comptime T: type, a: T, shift_amt: Log2T, result: *T) bool",
-+ .snippet = "@shlWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:shift_amt: Log2T}, ${4:result: *T})",
-+ .documentation =
-+ \\Performs `result.* = a << b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
-+ \\
-+ \\The type of `shift_amt` is an unsigned integer with `log2(T.bit_count)` bits. This is because `shift_amt >= T.bit_count` is undefined behavior.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "a: T",
-+ "shift_amt: Log2T",
-+ "result: *T",
-+ },
-+ },
-+ .{
-+ .name = "@shrExact",
-+ .signature = "@shrExact(value: T, shift_amt: Log2T) T",
-+ .snippet = "@shrExact(${1:value: T}, ${2:shift_amt: Log2T})",
-+ .documentation =
-+ \\Performs the right shift operation (`>>`). Caller guarantees that the shift will not shift any 1 bits out.
-+ \\
-+ \\The type of `shift_amt` is an unsigned integer with `log2(T.bit_count)` bits. This is because `shift_amt >= T.bit_count` is undefined behavior.
-+ ,
-+ .arguments = &.{
-+ "value: T",
-+ "shift_amt: Log2T",
-+ },
-+ },
-+ .{
-+ .name = "@shuffle",
-+ .signature = "@shuffle(comptime E: type, a: std.meta.Vector(a_len, E), b: std.meta.Vector(b_len, E), comptime mask: std.meta.Vector(mask_len, i32)) std.meta.Vector(mask_len, E)",
-+ .snippet = "@shuffle(${1:comptime E: type}, ${2:a: std.meta.Vector(a_len, E)}, ${3:b: std.meta.Vector(b_len, E)}, ${4:comptime mask: std.meta.Vector(mask_len, i32)})",
-+ .documentation =
-+ \\Constructs a new [vector](https://ziglang.org/documentation/0.9.1/#Vectors) by selecting elements from `a` and `b` based on `mask`.
-+ \\
-+ \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator from indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`).
-+ \\
-+ \\For each element of `mask`, if it or the selected value from `a` or `b` is `undefined`, then the resulting element is `undefined`.
-+ \\
-+ \\`a_len` and `b_len` may differ in length. Out-of-bounds element indexes in `mask` result in compile errors.
-+ \\
-+ \\If `a` or `b` is `undefined`, it is equivalent to a vector of all `undefined` with the same length as the other vector. If both vectors are `undefined`, `@shuffle` returns a vector with all elements `undefined`.
-+ \\
-+ \\`E` must be an [integer](https://ziglang.org/documentation/0.9.1/#Integers), [float](https://ziglang.org/documentation/0.9.1/#Floats), [pointer](https://ziglang.org/documentation/0.9.1/#Pointers), or `bool`. The mask may be any vector length, and its length determines the result length.</p> {#code_begin|test|vector_shuffle#} const std = @import("std"); const Vector = std.meta.Vector; const expect = std.testing.expect; test "vector @shuffle" { const a: Vector(7, u8) = [_]u8{ 'o', 'l', 'h', 'e', 'r', 'z', 'w' }; const b: Vector(4, u8) = [_]u8{ 'w', 'd', '!', 'x' }; // To shuffle within a single vector, pass undefined as the second argument. // Notice that we can re-order, duplicate, or omit elements of the input vector const mask1: Vector(5, i32) = [_]i32{ 2, 3, 1, 1, 0 }; const res1: Vector(5, u8) = @shuffle(u8, a, undefined, mask1); try expect(std.mem.eql(u8, &@as([5]u8, res1), "hello")); // Combining two vectors const mask2: Vector(6, i32) = [_]i32{ -1, 0, 4, 1, -2, -3 }
; const res2: Vector(6, u8) = @shuffle(u8, a, b, mask2); try expect(std.mem.eql(u8, &@as([6]u8, res2), "world!")); }`
-+ ,
-+ .arguments = &.{
-+ "comptime E: type",
-+ "a: std.meta.Vector(a_len, E)",
-+ "b: std.meta.Vector(b_len, E)",
-+ "comptime mask: std.meta.Vector(mask_len, i32)",
-+ },
-+ },
-+ .{
-+ .name = "@sizeOf",
-+ .signature = "@sizeOf(comptime T: type) comptime_int",
-+ .snippet = "@sizeOf(${1:comptime T: type})",
-+ .documentation =
-+ \\This function returns the number of bytes it takes to store `T` in memory. The result is a target-specific compile time constant.
-+ \\
-+ \\This size may contain padding bytes. If there were two consecutive T in memory, this would be the offset in bytes between element at index 0 and the element at index 1. For [integer](https://ziglang.org/documentation/0.9.1/#Integers), consider whether you want to use `@sizeOf(T)` or `@typeInfo(T).Int.bits`.
-+ \\
-+ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ },
-+ },
-+ .{
-+ .name = "@splat",
-+ .signature = "@splat(comptime len: u32, scalar: anytype) std.meta.Vector(len, @TypeOf(scalar))",
-+ .snippet = "@splat(${1:comptime len: u32}, ${2:scalar: anytype})",
-+ .documentation =
-+ \\Produces a vector of length `len` where each element is the value `scalar`:</p> {#code_begin|test|vector_splat#} const std = @import("std"); const expect = std.testing.expect; test "vector @splat" { const scalar: u32 = 5; const result = @splat(4, scalar); comptime try expect(@TypeOf(result) == std.meta.Vector(4, u32)); try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 })); }`
-+ \\
-+ \\`scalar` must be an [integer](https://ziglang.org/documentation/0.9.1/#Integers), [bool](https://ziglang.org/documentation/0.9.1/#Primitive-Types), [float](https://ziglang.org/documentation/0.9.1/#Floats), or [pointer](https://ziglang.org/documentation/0.9.1/#Pointers).
-+ ,
-+ .arguments = &.{
-+ "comptime len: u32",
-+ "scalar: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@reduce",
-+ .signature = "@reduce(comptime op: std.builtin.ReduceOp, value: anytype) std.meta.Child(value)",
-+ .snippet = "@reduce(${1:comptime op: std.builtin.ReduceOp}, ${2:value: anytype})",
-+ .documentation =
-+ \\Transforms a [vector](https://ziglang.org/documentation/0.9.1/#Vectors) into a scalar value by performing a sequential horizontal reduction of its elements using the specified operator `op`.
-+ \\
-+ \\Not every operator is available for every vector element type:
-+ \\ - `.And`, `.Or`, `.Xor` are available for `bool` vectors,
-+ \\ - `.Min`, `.Max`, `.Add`, `.Mul` are available for [floating point](https://ziglang.org/documentation/0.9.1/#Floats) vectors,
-+ \\ - Every operator is available for [integer](https://ziglang.org/documentation/0.9.1/#Integers) vectors.
-+ \\
-+ \\Note that `.Add` and `.Mul` reductions on integral types are wrapping; when applied on floating point types the operation associativity is preserved, unless the float mode is set to `Optimized`.</p> {#code_begin|test|vector_reduce#} const std = @import("std"); const expect = std.testing.expect; test "vector @reduce" { const value: std.meta.Vector(4, i32) = [_]i32{ 1, -1, 1, -1 }; const result = value > @splat(4, @as(i32, 0)); // result is { true, false, true, false }; comptime try expect(@TypeOf(result) == std.meta.Vector(4, bool)); const is_all_true = @reduce(.And, result); comptime try expect(@TypeOf(is_all_true) == bool); try expect(is_all_true == false); }`
-+ ,
-+ .arguments = &.{
-+ "comptime op: std.builtin.ReduceOp",
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@src",
-+ .signature = "@src() std.builtin.SourceLocation",
-+ .snippet = "@src()",
-+ .documentation =
-+ \\Returns a `SourceLocation` struct representing the function's name and location in the source code. This must be called in a function.</p> {#code_begin|test|source_location#} const std = @import("std"); const expect = std.testing.expect; test "@src" { try doTheTest(); } fn doTheTest() !void { const src = @src(); try expect(src.line == 9); try expect(src.column == 17); try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest")); try expect(std.mem.endsWith(u8, src.file, "source_location.zig")); }`
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@sqrt",
-+ .signature = "@sqrt(value: anytype) @TypeOf(value)",
-+ .snippet = "@sqrt(${1:value: anytype})",
-+ .documentation =
-+ \\Performs the square root of a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@sin",
-+ .signature = "@sin(value: anytype) @TypeOf(value)",
-+ .snippet = "@sin(${1:value: anytype})",
-+ .documentation =
-+ \\Sine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@cos",
-+ .signature = "@cos(value: anytype) @TypeOf(value)",
-+ .snippet = "@cos(${1:value: anytype})",
-+ .documentation =
-+ \\Cosine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@exp",
-+ .signature = "@exp(value: anytype) @TypeOf(value)",
-+ .snippet = "@exp(${1:value: anytype})",
-+ .documentation =
-+ \\Base-e exponential function on a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@exp2",
-+ .signature = "@exp2(value: anytype) @TypeOf(value)",
-+ .snippet = "@exp2(${1:value: anytype})",
-+ .documentation =
-+ \\Base-2 exponential function on a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@log",
-+ .signature = "@log(value: anytype) @TypeOf(value)",
-+ .snippet = "@log(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the natural logarithm of a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@log2",
-+ .signature = "@log2(value: anytype) @TypeOf(value)",
-+ .snippet = "@log2(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the logarithm to the base 2 of a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@log10",
-+ .signature = "@log10(value: anytype) @TypeOf(value)",
-+ .snippet = "@log10(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the logarithm to the base 10 of a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@fabs",
-+ .signature = "@fabs(value: anytype) @TypeOf(value)",
-+ .snippet = "@fabs(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the absolute value of a floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@floor",
-+ .signature = "@floor(value: anytype) @TypeOf(value)",
-+ .snippet = "@floor(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the largest integral value not greater than the given floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@ceil",
-+ .signature = "@ceil(value: anytype) @TypeOf(value)",
-+ .snippet = "@ceil(${1:value: anytype})",
-+ .documentation =
-+ \\Returns the smallest integral value not less than the given floating point number. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@trunc",
-+ .signature = "@trunc(value: anytype) @TypeOf(value)",
-+ .snippet = "@trunc(${1:value: anytype})",
-+ .documentation =
-+ \\Rounds the given floating point number to an integer, towards zero. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@round",
-+ .signature = "@round(value: anytype) @TypeOf(value)",
-+ .snippet = "@round(${1:value: anytype})",
-+ .documentation =
-+ \\Rounds the given floating point number to an integer, away from zero. Uses a dedicated hardware instruction when available.
-+ \\
-+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@subWithOverflow",
-+ .signature = "@subWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
-+ .snippet = "@subWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})",
-+ .documentation =
-+ \\Performs `result.* = a - b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "a: T",
-+ "b: T",
-+ "result: *T",
-+ },
-+ },
-+ .{
-+ .name = "@tagName",
-+ .signature = "@tagName(value: anytype) [:0]const u8",
-+ .snippet = "@tagName(${1:value: anytype})",
-+ .documentation =
-+ \\Converts an enum value or union value to a string literal representing the name.
-+ \\
-+ \\If the enum is non-exhaustive and the tag value does not map to a name, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
-+ ,
-+ .arguments = &.{
-+ "value: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@This",
-+ .signature = "@This() type",
-+ .snippet = "@This()",
-+ .documentation =
-+ \\Returns the innermost struct, enum, or union that this function call is inside. This can be useful for an anonymous struct that needs to refer to itself:</p> {#code_begin|test|this_innermost#} const std = @import("std"); const expect = std.testing.expect; test "@This()" { var items = [_]i32{ 1, 2, 3, 4 }; const list = List(i32){ .items = items[0..] }; try expect(list.length() == 4); } fn List(comptime T: type) type { return struct { const Self = @This(); items: []T, fn length(self: Self) usize { return self.items.len; } }; }`
-+ \\
-+ \\When `@This()` is used at file scope, it returns a reference to the struct that corresponds to the current file.
-+ ,
-+ .arguments = &.{},
-+ },
-+ .{
-+ .name = "@truncate",
-+ .signature = "@truncate(comptime T: type, integer: anytype) T",
-+ .snippet = "@truncate(${1:comptime T: type}, ${2:integer: anytype})",
-+ .documentation =
-+ \\This function truncates bits from an integer type, resulting in a smaller or same-sized integer type.
-+ \\
-+ \\This function always truncates the significant bits of the integer, regardless of endianness on the target platform.
-+ \\
-+ \\Calling `@truncate` on a number out of range of the destination type is well defined and working code:
-+ \\
-+ \\```zig
-+ \\const std = @import("std");
-+ \\const expect = std.testing.expect;
-+ \\
-+ \\test "integer truncation" {
-+ \\ var a: u16 = 0xabcd;
-+ \\ var b: u8 = @truncate(u8, a);
-+ \\ try expect(b == 0xcd);
-+ \\}
-+ \\```
-+ \\
-+ \\Use [@intCast](https://ziglang.org/documentation/0.9.1/#intCast) to convert numbers guaranteed to fit the destination type.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ "integer: anytype",
-+ },
-+ },
-+ .{
-+ .name = "@Type",
-+ .signature = "@Type(comptime info: std.builtin.TypeInfo) type",
-+ .snippet = "@Type(${1:comptime info: std.builtin.TypeInfo})",
-+ .documentation =
-+ \\This function is the inverse of [@typeInfo](https://ziglang.org/documentation/0.9.1/#typeInfo). It reifies type information into a `type`.
-+ \\
-+ \\It is available for the following types:
-+ \\ - `type`
-+ \\ - `noreturn`
-+ \\ - `void`
-+ \\ - `bool`
-+ \\ - [Integers](https://ziglang.org/documentation/0.9.1/#Integers) - The maximum bit count for an integer type is `65535`.
-+ \\ - [Floats](https://ziglang.org/documentation/0.9.1/#Floats)
-+ \\ - [Pointers](https://ziglang.org/documentation/0.9.1/#Pointers)
-+ \\ - `comptime_int`
-+ \\ - `comptime_float`
-+ \\ - `@TypeOf(undefined)`
-+ \\ - `@TypeOf(null)`
-+ \\ - [Arrays](https://ziglang.org/documentation/0.9.1/#Arrays)
-+ \\ - [Optionals](https://ziglang.org/documentation/0.9.1/#Optionals)
-+ \\ - [Error Set Type](https://ziglang.org/documentation/0.9.1/#Error-Set-Type)
-+ \\ - [Error Union Type](https://ziglang.org/documentation/0.9.1/#Error-Union-Type)
-+ \\ - [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors)
-+ \\ - [opaque](https://ziglang.org/documentation/0.9.1/#opaque)
-+ \\ - [@Frame](https://ziglang.org/documentation/0.9.1/#Frame)
-+ \\ - `anyframe`
-+ \\ - [struct](https://ziglang.org/documentation/0.9.1/#struct)
-+ \\ - [enum](https://ziglang.org/documentation/0.9.1/#enum)
-+ \\ - [Enum Literals](https://ziglang.org/documentation/0.9.1/#Enum-Literals)
-+ \\ - [union](https://ziglang.org/documentation/0.9.1/#union)
-+ \\
-+ \\For these types, `@Type` is not available:
-+ \\ - [Functions](https://ziglang.org/documentation/0.9.1/#Functions)
-+ \\ - BoundFn
-+ ,
-+ .arguments = &.{
-+ "comptime info: std.builtin.TypeInfo",
-+ },
-+ },
-+ .{
-+ .name = "@typeInfo",
-+ .signature = "@typeInfo(comptime T: type) std.builtin.TypeInfo",
-+ .snippet = "@typeInfo(${1:comptime T: type})",
-+ .documentation =
-+ \\Provides type reflection.
-+ \\
-+ \\Type information of [structs](https://ziglang.org/documentation/0.9.1/#struct), [unions](https://ziglang.org/documentation/0.9.1/#union), [enums](https://ziglang.org/documentation/0.9.1/#enum), and [error sets](https://ziglang.org/documentation/0.9.1/#Error-Set-Type) has fields which are are guaranteed to be in the same order as appearance in the source file.
-+ \\
-+ \\Type information of [structs](https://ziglang.org/documentation/0.9.1/#struct), [unions](https://ziglang.org/documentation/0.9.1/#union), [enums](https://ziglang.org/documentation/0.9.1/#enum), and [opaques](https://ziglang.org/documentation/0.9.1/#opaque) has declarations, which are also guaranteed to be in the same order as appearance in the source file.
-+ ,
-+ .arguments = &.{
-+ "comptime T: type",
-+ },
-+ },
-+ .{
-+ .name = "@typeName",
-+ .signature = "@typeName(T: type) *const [N:0]u8",
-+ .snippet = "@typeName(${1:T: type})",
-+ .documentation =
-+ \\This function returns the string representation of a type, as an array. It is equivalent to a string literal of the type name.
-+ ,
-+ .arguments = &.{
-+ "T: type",
-+ },
-+ },
-+ .{
-+ .name = "@TypeOf",
-+ .signature = "@TypeOf(...) type",
-+ .snippet = "@TypeOf(${1:...})",
-+ .documentation =
-+ \\`@TypeOf` is a special builtin function that takes any (nonzero) number of expressions as parameters and returns the type of the result, using [Peer Type Resolution](https://ziglang.org/documentation/0.9.1/#Peer-Type-Resolution).
-+ \\
-+ \\The expressions are evaluated, however they are guaranteed to have no *runtime* side-effects:</p> {#code_begin|test|no_runtime_side_effects#} const std = @import("std"); const expect = std.testing.expect; test "no runtime side effects" { var data: i32 = 0; const T = @TypeOf(foo(i32, &data)); comptime try expect(T == i32); try expect(data == 0); } fn foo(comptime T: type, ptr: *T) T { ptr.* += 1; return ptr.*; }`
-+ ,
-+ .arguments = &.{
-+ "...",
-+ },
-+ },
-+ .{
-+ .name = "@unionInit",
-+ .signature = "@unionInit(comptime Union: type, comptime active_field_name: []const u8, init_expr) Union",
-+ .snippet = "@unionInit(${1:comptime Union: type}, ${2:comptime active_field_name: []const u8}, ${3:init_expr})",
-+ .documentation =
-+ \\This is the same thing as [union](https://ziglang.org/documentation/0.9.1/#union) initialization syntax, except that the field name is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known value rather than an identifier token.
-+ \\
-+ \\`@unionInit` forwards its [result location](https://ziglang.org/documentation/0.9.1/#Result-Location-Semantics) to `init_expr`.
-+ ,
-+ .arguments = &.{
-+ "comptime Union: type",
-+ "comptime active_field_name: []const u8",
-+ "init_expr",
-+ },
-+ },
-+};
-diff --git a/src/data/data.zig b/src/data/data.zig
-index f6e3b049..21257bfe 100644
---- a/src/data/data.zig
-+++ b/src/data/data.zig
-@@ -7,4 +7,6 @@ pub usingnamespace switch (build_options.data_version) {
- .@"0.8.0" => @import("0.8.0.zig"),
- .@"0.8.1" => @import("0.8.1.zig"),
- .@"0.9.0" => @import("0.9.0.zig"),
-+ .@"0.9.1" => @import("0.9.1.zig"),
-+ .@"0.10.0" => @import("0.10.0.zig"),
- };
-diff --git a/src/data/master.zig b/src/data/master.zig
-index 917d3fe2..9eacf7b5 100644
---- a/src/data/master.zig
-+++ b/src/data/master.zig
-@@ -7,6 +7,18 @@ const Builtin = struct {
- };
-
- pub const builtins = [_]Builtin{
-+ .{
-+ .name = "@addrSpaceCast",
-+ .signature = "@addrSpaceCast(comptime addrspace: std.builtin.AddressSpace, ptr: anytype) anytype",
-+ .snippet = "@addrSpaceCast(${1:comptime addrspace: std.builtin.AddressSpace}, ${2:ptr: anytype})",
-+ .documentation =
-+ \\Converts a pointer from one address space to another. Depending on the current target and address spaces, this cast may be a no-op, a complex operation, or illegal. If the cast is legal, then the resulting pointer points to the same memory location as the pointer operand. It is always valid to cast a pointer between the same address spaces.
-+ ,
-+ .arguments = &.{
-+ "comptime addrspace: std.builtin.AddressSpace",
-+ "ptr: anytype",
-+ },
-+ },
- .{
- .name = "@addWithOverflow",
- .signature = "@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool",
-@@ -26,7 +38,7 @@ pub const builtins = [_]Builtin{
- .signature = "@alignCast(comptime alignment: u29, ptr: anytype) anytype",
- .snippet = "@alignCast(${1:comptime alignment: u29}, ${2:ptr: anytype})",
- .documentation =
-- \\`ptr` can be `*T`, `fn()`, `?*T`, `?fn()`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value.
-+ \\`ptr` can be `*T`, `?*T`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value.
- \\
- \\A [pointer alignment safety check](https://ziglang.org/documentation/master/#Incorrect-Pointer-Alignment) is added to the generated code to make sure the pointer is aligned as promised.
- ,
-@@ -222,7 +234,7 @@ pub const builtins = [_]Builtin{
- .signature = "@mulAdd(comptime T: type, a: T, b: T, c: T) T",
- .snippet = "@mulAdd(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:c: T})",
- .documentation =
-- \\Fused multiply add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate.
-+ \\Fused multiply-add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate.
- \\
- \\Supports [Floats](https://ziglang.org/documentation/master/#Floats) and [Vectors](https://ziglang.org/documentation/master/#Vectors) of floats.
- ,
-@@ -474,8 +486,6 @@ pub const builtins = [_]Builtin{
- \\}
- \\```
- \\
-- \\will output:
-- \\
- \\If all `@compileLog` calls are removed or not encountered by analysis, the program compiles successfully and the generated executable prints:</p> {#code_begin|test|without_compileLog#} const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; val1 = val1 + 1; break :blk val1; }; test "main" { print("Runtime in main, num1 = {}.\n", .{num1}); }`
- ,
- .arguments = &.{
-@@ -791,7 +801,7 @@ pub const builtins = [_]Builtin{
- .documentation =
- \\This function returns the base pointer of the current stack frame.
- \\
-- \\The implications of this are target specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations.
-+ \\The implications of this are target-specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations.
- \\
- \\This function is only valid within function scope.
- ,
-@@ -853,8 +863,8 @@ pub const builtins = [_]Builtin{
- \\
- \\The following packages are always available:
- \\ - `@import("std")` - Zig Standard Library
-- \\ - `@import("builtin")` - Target-specific information The command `zig build-exe --show-builtin` outputs the source to stdout for reference.
-- \\ - `@import("root")` - Points to the root source file This is usually `src/main.zig` but it depends on what file is chosen to be built.
-+ \\ - `@import("builtin")` - Target-specific information. The command `zig build-exe --show-builtin` outputs the source to stdout for reference.
-+ \\ - `@import("root")` - Points to the root source file. This is usually `src/main.zig` but it depends on what file is chosen to be built.
- ,
- .arguments = &.{
- "comptime path: []u8",
-@@ -1117,7 +1127,7 @@ pub const builtins = [_]Builtin{
- .signature = "@prefetch(ptr: anytype, comptime options: std.builtin.PrefetchOptions)",
- .snippet = "@prefetch(${1:ptr: anytype}, ${2:comptime options: std.builtin.PrefetchOptions})",
- .documentation =
-- \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a noop. This function has no effect on the behavior of the program, only on the performance characteristics.
-+ \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a no-op. This function has no effect on the behavior of the program, only on the performance characteristics.
- \\
- \\The `ptr` argument may be any pointer type and determines the memory address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no illegal behavior will result.
- \\
-@@ -1147,11 +1157,7 @@ pub const builtins = [_]Builtin{
- .signature = "@ptrToInt(value: anytype) usize",
- .snippet = "@ptrToInt(${1:value: anytype})",
- .documentation =
-- \\Converts `value` to a `usize` which is the address of the pointer. `value` can be one of these types:
-- \\ - `*T`
-- \\ - `?*T`
-- \\ - `fn()`
-- \\ - `?fn()`
-+ \\Converts `value` to a `usize` which is the address of the pointer. `value` can be `*T` or `?*T`.
- \\
- \\To convert the other way, use [@intToPtr](https://ziglang.org/documentation/master/#intToPtr)
- ,
-@@ -1182,7 +1188,7 @@ pub const builtins = [_]Builtin{
- .documentation =
- \\This function returns the address of the next machine code instruction that will be executed when the current function returns.
- \\
-- \\The implications of this are target specific and not consistent across all platforms.
-+ \\The implications of this are target-specific and not consistent across all platforms.
- \\
- \\This function is only valid within function scope. If the function gets inlined into a calling function, the returned address will apply to the calling function.
- ,
-@@ -1270,7 +1276,7 @@ pub const builtins = [_]Builtin{
- \\ - Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined.
- \\ - Treat the sign of a zero argument or result as insignificant.
- \\ - Use the reciprocal of an argument rather than perform division.
-- \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add).
-+ \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-add).
- \\ - Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate). This is equivalent to `-ffast-math` in GCC.</ul>
- \\
- \\The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block.
-@@ -1367,7 +1373,7 @@ pub const builtins = [_]Builtin{
- .documentation =
- \\Constructs a new [vector](https://ziglang.org/documentation/master/#Vectors) by selecting elements from `a` and `b` based on `mask`.
- \\
-- \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator from indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`).
-+ \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator for indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`).
- \\
- \\For each element of `mask`, if it or the selected value from `a` or `b` is `undefined`, then the resulting element is `undefined`.
- \\
-@@ -1737,7 +1743,7 @@ pub const builtins = [_]Builtin{
- .documentation =
- \\Provides type reflection.
- \\
-- \\Type information of [structs](https://ziglang.org/documentation/master/#struct), [unions](https://ziglang.org/documentation/master/#union), [enums](https://ziglang.org/documentation/master/#enum), and [error sets](https://ziglang.org/documentation/master/#Error-Set-Type) has fields which are are guaranteed to be in the same order as appearance in the source file.
-+ \\Type information of [structs](https://ziglang.org/documentation/master/#struct), [unions](https://ziglang.org/documentation/master/#union), [enums](https://ziglang.org/documentation/master/#enum), and [error sets](https://ziglang.org/documentation/master/#Error-Set-Type) has fields which are guaranteed to be in the same order as appearance in the source file.
- \\
- \\Type information of [structs](https://ziglang.org/documentation/master/#struct), [unions](https://ziglang.org/documentation/master/#union), [enums](https://ziglang.org/documentation/master/#enum), and [opaques](https://ziglang.org/documentation/master/#opaque) has declarations, which are also guaranteed to be in the same order as appearance in the source file.
- ,
-diff --git a/src/shared.zig b/src/shared.zig
-index 25212203..fac7994a 100644
---- a/src/shared.zig
-+++ b/src/shared.zig
-@@ -7,4 +7,6 @@ pub const ZigVersion = enum {
- @"0.8.0",
- @"0.8.1",
- @"0.9.0",
-+ @"0.9.1",
-+ @"0.10.0",
- };
diff --git a/dev-zig/zls/zls-0.10.0-r1.ebuild b/dev-zig/zls/zls-0.10.0-r1.ebuild
deleted file mode 100644
index da659404c..000000000
--- a/dev-zig/zls/zls-0.10.0-r1.ebuild
+++ /dev/null
@@ -1,141 +0,0 @@
-# Copyright 2022-2023 Gentoo Authors
-# Distributed under the terms of the GNU General Public License v2
-
-EAPI=8
-
-inherit edo
-
-DESCRIPTION="The officially unofficial Ziglang language server"
-HOMEPAGE="https://github.com/zigtools/zls"
-
-KNOWN_FOLDERS_COMMIT="24845b0103e611c108d6bc334231c464e699742c"
-TRACY_COMMIT="f493d4aa8ba8141d9680473fad007d8a6348628e"
-SRC_URI="
- https://github.com/ziglibs/known-folders/archive/${KNOWN_FOLDERS_COMMIT}.tar.gz -> known-folders-${KNOWN_FOLDERS_COMMIT}.tar.gz
- https://github.com/wolfpld/tracy/archive/${TRACY_COMMIT}.tar.gz -> tracy-${TRACY_COMMIT}.tar.gz
- https://github.com/zigtools/zls/archive/refs/tags/${PV}.tar.gz -> zls-${PV}.tar.gz
-"
-
-LICENSE="MIT"
-SLOT="0"
-KEYWORDS="~amd64"
-
-EZIG_MIN="0.10"
-EZIG_MAX_EXCLUSIVE="0.11"
-
-DEPEND="|| ( dev-lang/zig:${EZIG_MIN} dev-lang/zig-bin:${EZIG_MIN} )"
-RDEPEND="${DEPEND}"
-
-# see https://github.com/ziglang/zig/issues/3382
-# For now, Zig Build System doesn't support CFLAGS/LDFLAGS/etc.
-QA_FLAGS_IGNORED="usr/bin/zls"
-
-PATCHES=(
- "${FILESDIR}/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch"
-)
-
-# : copied from sys-fs/ncdu :
-# Many thanks to Florian Schmaus (Flowdalic)!
-# Adapted from https://github.com/gentoo/gentoo/pull/28986
-# Set the EZIG environment variable.
-zig-set_EZIG() {
- [[ -n ${EZIG} ]] && return
-
- if [[ -n ${EZIG_OVERWRITE} ]]; then
- export EZIG="${EZIG_OVERWRITE}"
- return
- fi
-
- local candidates candidate selected selected_ver
-
- candidates=$(compgen -c zig-)
-
- for candidate in ${candidates}; do
- if [[ ! ${candidate} =~ zig(-bin)?-([.0-9]+) ]]; then
- continue
- fi
-
- local ver
- if (( ${#BASH_REMATCH[@]} == 3 )); then
- ver="${BASH_REMATCH[2]}"
- else
- ver="${BASH_REMATCH[1]}"
- fi
-
- if [[ -n ${EZIG_EXACT_VER} ]]; then
- ver_test "${ver}" -ne "${EZIG_EXACT_VER}" && continue
-
- selected="${candidate}"
- selected_ver="${ver}"
- break
- fi
-
- if [[ -n ${EZIG_MIN} ]] \
- && ver_test "${ver}" -lt "${EZIG_MIN}"; then
- # Candidate does not satisfy EZIG_MIN condition.
- continue
- fi
-
- if [[ -n ${EZIG_MAX_EXCLUSIVE} ]] \
- && ver_test "${ver}" -ge "${EZIG_MAX_EXCLUSIVE}"; then
- # Candidate does not satisfy EZIG_MAX_EXCLUSIVE condition.
- continue
- fi
-
- if [[ -n ${selected_ver} ]] \
- && ver_test "${selected_ver}" -gt "${ver}"; then
- # Candidate is older than the currently selected candidate.
- continue
- fi
-
- selected="${candidate}"
- selected_ver="${ver}"
- done
-
- if [[ -z ${selected} ]]; then
- die "Could not find (suitable) zig installation in PATH"
- fi
-
- export EZIG="${selected}"
- export EZIG_VER="${ver}"
-}
-
-# Invoke zig with the optionally provided arguments.
-ezig() {
- zig-set_EZIG
-
- # Unfortunately, we cannot add more args here, since syntax is different
- # for every subcommands. Yes, even target/cpu :( f.i. :
- # -target/-mcpu for zig build-exe vs -Dtarget/-Dcpu for zig build-
- # -OReleaseSafe for zig build-exe vs -DReleaseSafe for zig build
- # (or even none, if hardcoded by upstream so choice is -Drelease=true/false)
- # Ofc we can patch this, but still...
-
- edo "${EZIG}" "${@}"
-}
-
-src_prepare() {
- rm -r src/known-folders || die
- mv "../known-folders-${KNOWN_FOLDERS_COMMIT}" src/known-folders || die
- rm -r src/tracy || die
- mv "../tracy-${TRACY_COMMIT}" src/zinput || die
-
- default
-}
-
-src_compile() {
- ezig build -Drelease-safe -Ddata_version=0.10.0 --verbose || die
-}
-
-src_test() {
- ezig build test -Drelease-safe -Ddata_version=0.10.0 --verbose || die
-}
-
-src_install() {
- DESTDIR="${ED}" ezig build install --prefix /usr -Drelease-safe -Ddata_version=0.10.0 --verbose || die
- dodoc README.md
-}
-
-pkg_postinst() {
- elog "You can find more information about options here https://github.com/zigtools/zls#configuration-options"
-}
^ permalink raw reply related [flat|nested] 2+ messages in thread
end of thread, other threads:[~2024-08-01 19:35 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2024-08-01 19:34 [gentoo-commits] repo/proj/guru:dev commit in: dev-zig/zls/, dev-zig/zls/files/ Eric Joldasov
-- strict thread matches above, loose matches on Subject: below --
2023-02-09 5:07 Eric Joldasov
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox