Zig 0.11

__attribute__((notnull(blablabla)))

fn create_code(ctxt: *GccJit.Context) void {
    // Let's try to inject the equivalent of following function:

    // C form:
    // void
    // greet (const char *name)
    // {
    //    printf ("hello %s\n", name);
    // }

    // C-in-Zig form:
    // fn greet(name: [*:0]const u8) callconv(.C) void {
    //    printf("hello %s\n", name);
    // }

    const void_type: *GccJit.Type = ctxt.getType(.void);
    const const_char_ptr_type: *GccJit.Type = ctxt.getType(.const_char_ptr);
    const param_name: *GccJit.Param = ctxt.newParam(.no_location, const_char_ptr_type, "name");
    const func: *GccJit.Function = ctxt.newFunction(.no_location, .exported, void_type, "greet", @constCast(&[_]*GccJit.Param{param_name}), .not_variadic);

    const param_format: *GccJit.Param = ctxt.newParam(.no_location, const_char_ptr_type, "format");
    const printf_func: *GccJit.Function = ctxt.newFunction(.no_location, .imported, ctxt.getType(.int), "printf", @constCast(&[_]*GccJit.Param{param_format}), .variadic);
    var args: [2]*GccJit.Rvalue = undefined;
    args[0] = ctxt.newStringLiteral("hello %s\n");
    args[1] = param_name.asRvalue();

    const block: *GccJit.Block = func.newBlock(.no_name);

    block.addEval(.no_location, ctxt.newCall(.no_location, printf_func, &args));
    block.endWithVoidReturn(.no_location);
}

  /* Let's try to inject the equivalent of:
     void
     greet (const char *name)
     {
        printf ("hello %s\n", name);
     }
  */
  gcc_jit_type *void_type =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
  gcc_jit_type *const_char_ptr_type =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_CONST_CHAR_PTR);
  gcc_jit_param *param_name =
    gcc_jit_context_new_param (ctxt, NULL, const_char_ptr_type, "name");
  gcc_jit_function *func =
    gcc_jit_context_new_function (ctxt, NULL,
                                  GCC_JIT_FUNCTION_EXPORTED,
                                  void_type,
                                  "greet",
                                  1, &param_name,
                                  0);

  gcc_jit_param *param_format =
    gcc_jit_context_new_param (ctxt, NULL, const_char_ptr_type, "format");
  gcc_jit_function *printf_func =
    gcc_jit_context_new_function (ctxt, NULL,
				  GCC_JIT_FUNCTION_IMPORTED,
				  gcc_jit_context_get_type (
				     ctxt, GCC_JIT_TYPE_INT),
				  "printf",
				  1, &param_format,
				  1);
  gcc_jit_rvalue *args[2];
  args[0] = gcc_jit_context_new_string_literal (ctxt, "hello %s\n");
  args[1] = gcc_jit_param_as_rvalue (param_name);

  gcc_jit_block *block = gcc_jit_function_new_block (func, NULL);

  gcc_jit_block_add_eval (
    block, NULL,
    gcc_jit_context_new_call (ctxt,
                              NULL,
                              printf_func,
                              2, args));
  gcc_jit_block_end_with_void_return (block, NULL);

pub fn mayFall(smth: bool) error{Fall}!u32 {
    return if (smth) 0 else error.Fall;
}

pub fn theBestU64() ?u64 {
    const optional_u32 = mayFall(false) catch null; // ошибку в опциональный тип
    const errored_u32 = optional_u32 orelse error.WhyNull; // и обратно
    const optional_u64: ?u64 = errored_u32 catch null; // и обратно
    return optional_u64;
}

const std = @import("std");

pub fn main() void {
    @compileLog(comptime theBestU64()); // вызвать во время компиляции
    @compileLog(theBestU64()); // простой вызов во время выполнения
}

test.zig:15:5: error: found compile log statement
    @compileLog(comptime theBestU64()); // вызвать во время компиляции
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Compile Log Output:
@as(?u32, null)
@as(?u32, [runtime value])

test.zig:15:5: error: found compile log statement
    @compileLog(comptime theBestU64()); // вызвать во время компиляции
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Compile Log Output:
@as(?u64, null)
@as(?u64, [runtime value])

_ = optional_node.?; // Здесь будет всунута проверка во время выполнения, что это не null, как Rust'овый unwrap при None.
// так как мы считаем указатель на нулевой адрес ошибкой и assert'аем, что её не произойдет.
_ = allowzero_node; // Здесь мы не считаем нулевой адрес ошибкой, а валидным значением, к примеру когда мы работаем над ядром ОС.

comptime {
    @compileLog(@sizeOf(u64));
    @compileLog(@sizeOf(?u64));
}

Выхлоп:
```zig
test.zig:2:5: error: found compile log statement
    @compileLog(@sizeOf(u64));
    ^~~~~~~~~~~~~~~~~~~~~~~~~

Compile Log Output:
@as(comptime_int, 8)
@as(comptime_int, 16)

comptime {
    @compileLog(@sizeOf(*u64));
    @compileLog(@sizeOf(?*u64));
    @compileLog(@sizeOf(*allowzero u64));
    @compileLog(@sizeOf(?*allowzero u64));
}

test.zig:2:5: error: found compile log statement
    @compileLog(@sizeOf(*u64));
    ^~~~~~~~~~~~~~~~~~~~~~~~~~

Compile Log Output:
@as(comptime_int, 8)
@as(comptime_int, 8)
@as(comptime_int, 8)
@as(comptime_int, 16)

test.zig:2:5: error: found compile log statement
    @compileLog(@sizeOf(*u64));
    ^~~~~~~~~~~~~~~~~~~~~~~~~~

Compile Log Output:
@as(comptime_int, 4)
@as(comptime_int, 4)
@as(comptime_int, 4)
@as(comptime_int, 8)