srctree

"${CMAKE_SOURCE_DIR}/lib/std/unicode.zig"

"${CMAKE_SOURCE_DIR}/lib/std/zig.zig"

"${CMAKE_SOURCE_DIR}/lib/std/zig/Ast.zig"

"${CMAKE_SOURCE_DIR}/lib/std/zig/AstRlAnnotate.zig"

"${CMAKE_SOURCE_DIR}/lib/std/zig/c_builtins.zig"

"${CMAKE_SOURCE_DIR}/lib/std/zig/Parse.zig"

"${CMAKE_SOURCE_DIR}/lib/std/zig/system/NativePaths.zig"

"${CMAKE_SOURCE_DIR}/lib/std/zig/system/x86.zig"

"${CMAKE_SOURCE_DIR}/lib/std/zig/tokenizer.zig"

"${CMAKE_SOURCE_DIR}/src/Air.zig"

"${CMAKE_SOURCE_DIR}/src/Compilation.zig"

"${CMAKE_SOURCE_DIR}/src/Compilation/Config.zig"

"${CMAKE_SOURCE_DIR}/src/Liveness.zig"

"${CMAKE_SOURCE_DIR}/src/Sema.zig"

"${CMAKE_SOURCE_DIR}/src/TypedValue.zig"

"${CMAKE_SOURCE_DIR}/src/Value.zig"

"${CMAKE_SOURCE_DIR}/src/arch/aarch64/CodeGen.zig"

"${CMAKE_SOURCE_DIR}/src/arch/aarch64/Emit.zig"

"${CMAKE_SOURCE_DIR}/src/arch/aarch64/Mir.zig"

 

const skip_install_langref = b.option(bool, "no-langref", "skip copying of langref to the installation prefix") orelse skip_install_lib_files;

const skip_install_autodocs = b.option(bool, "no-autodocs", "skip copying of standard library autodocs to the installation prefix") orelse skip_install_lib_files;

const no_bin = b.option(bool, "no-bin", "skip emitting compiler binary") orelse false;

 

const docgen_exe = b.addExecutable(.{

.name = "docgen",

exe_options.addOption(bool, "force_gpa", force_gpa);

exe_options.addOption(bool, "only_c", only_c);

exe_options.addOption(bool, "only_core_functionality", only_c);

 

if (link_libc) {

exe.linkLibC();

test_cases_options.addOption(bool, "force_gpa", force_gpa);

test_cases_options.addOption(bool, "only_c", only_c);

test_cases_options.addOption(bool, "only_core_functionality", true);

test_cases_options.addOption(bool, "enable_qemu", b.enable_qemu);

test_cases_options.addOption(bool, "enable_wine", b.enable_wine);

test_cases_options.addOption(bool, "enable_wasmtime", b.enable_wasmtime);

exe_options.addOption(bool, "enable_tracy_allocation", false);

exe_options.addOption(bool, "value_tracing", false);

exe_options.addOption(bool, "only_core_functionality", true);

 

const run_opt = b.addSystemCommand(&.{

"wasm-opt",

 

pub const dependencies = @import("@dependencies");

 

pub fn main() !void {

// one shot program. We don't need to waste time freeing memory and finding places to squish

// bytes into. So we free everything all at once at the very end.

var single_threaded_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);

 

 

const mem = std.mem;

const Allocator = std.mem.Allocator;

const assert = std.debug.assert;

const Ast = std.zig.Ast;

const Walk = @import("reduce/Walk.zig");

 

const usage =

\\zig reduce [options] ./checker root_source_file.zig [-- [argv]]

// - reduce flags sent to the compiler

// - integrate with the build system?

 

var opt_checker_path: ?[]const u8 = null;

var opt_root_source_file_path: ?[]const u8 = null;

var argv: []const []const u8 = &.{};

var skip_smoke_test = false;

 

{

while (i < args.len) : (i += 1) {

const arg = args[i];

if (mem.startsWith(u8, arg, "-")) {

 

return tree;

}

 

 

 

/// Constants and types representing the Wasm binary format.

pub const wasm = @import("wasm.zig");

 

pub const zig = @import("zig.zig");

 

pub const start = @import("start.zig");

 

pub const ErrorBundle = @import("zig/ErrorBundle.zig");

pub const Server = @import("zig/Server.zig");

pub const Client = @import("zig/Client.zig");

pub const Token = tokenizer.Token;

pub const Tokenizer = tokenizer.Tokenizer;

pub const string_literal = @import("zig/string_literal.zig");

pub const number_literal = @import("zig/number_literal.zig");

pub const primitives = @import("zig/primitives.zig");

pub const Ast = @import("zig/Ast.zig");

pub const system = @import("zig/system.zig");

/// Deprecated: use `std.Target.Query`.

pub const CrossTarget = std.Target.Query;

pub const SrcHasher = std.crypto.hash.Blake3;

pub const SrcHash = [16]u8;

 

pub fn hashSrc(src: []const u8) SrcHash {

var out: SrcHash = undefined;

SrcHasher.hash(src, &out, .{});

return buffer.toOwnedSlice();

}

 

const std = @import("std.zig");

const tokenizer = @import("zig/tokenizer.zig");

const assert = std.debug.assert;

const Allocator = std.mem.Allocator;

 

}

 

line_end: usize,

};

 

pub fn deinit(tree: *Ast, gpa: Allocator) void {

tree.tokens.deinit(gpa);

tree.nodes.deinit(gpa);

};

}

 

/// Caller owns the returned slice of bytes, allocated with `gpa`.

pub fn render(tree: Ast, gpa: Allocator) RenderError![]u8 {

var buffer = std.ArrayList(u8).init(gpa);

};

};

 

const std = @import("../std.zig");

const assert = std.debug.assert;

const testing = std.testing;

const private_render = @import("./render.zig");

 

test {

}

 

 

const isPrimitive = std.zig.primitives.isPrimitive;

 

const BuiltinFn = std.zig.BuiltinFn;

const AstRlAnnotate = std.zig.AstRlAnnotate;

 

 

return @intCast(wip.extra.items.len - notes_len);

}

 

fn addOtherMessage(wip: *Wip, other: ErrorBundle, msg_index: MessageIndex) !MessageIndex {

const other_msg = other.getErrorMessage(msg_index);

const src_loc = try wip.addOtherSourceLocation(other, other_msg.src_loc);

 

const BigIntMutable = std.math.big.int.Mutable;

const Ast = std.zig.Ast;

 

const Zir = @This();

 

instructions: std.MultiArrayList(Inst).Slice,

/// In order to store references to strings in fewer bytes, we copy all

/// ZIR is structured so that the outermost "main" struct of any file

/// is always at index 0.

main_struct_inst = 0,

_,

 

pub fn toRef(i: Index) Inst.Ref {

return @enumFromInt(@intFromEnum(Index.ref_start_index) + @intFromEnum(i));

}

/// ZIR is structured so that the outermost "main" struct of any file

/// is always at index 0.

main_struct_inst = 0,

none = std.math.maxInt(u32),

_,

 

/// The tag type is specified so that it is safe to bitcast between `[]u32`

/// and `[]Ref`.

pub const Ref = enum(u32) {

 

/// This tag is here to match Air and InternPool, however it is unused

/// for ZIR purposes.

/// This Ref does not correspond to any ZIR instruction or constant

/// value and may instead be used as a sentinel to indicate null.

_,

 

pub fn toIndex(inst: Ref) ?Index {

 

 

const Module = @import("Package.zig").Module;

const Tokenizer = std.zig.Tokenizer;

const InternPool = @import("InternPool.zig");

const Ref = Zir.Inst.Ref;

const log = std.log.scoped(.autodoc);

const renderer = @import("autodoc/render_source.zig");

 

const build_options = @import("build_options");

const Module = @import("Package/Module.zig");

const assert = std.debug.assert;

const File = @import("Module.zig").File;

const Compilation = @import("Compilation.zig");

const log = std.log.scoped(.builtin);

 

const Cache = std.Build.Cache;

const c_codegen = @import("codegen/c.zig");

const libtsan = @import("libtsan.zig");

const Autodoc = @import("Autodoc.zig");

const resinator = @import("resinator.zig");

const Builtin = @import("Builtin.zig");

assert(file.zir_loaded);

assert(file.tree_loaded);

assert(file.source_loaded);

const gpa = eb.gpa;

}

 

pub fn performAllTheWork(

 

const InternPool = @This();

const Module = @import("Module.zig");

const Zcu = Module;

 

const KeyAdapter = struct {

intern_pool: *const InternPool,

}

};

 

 

pub const NamespaceIndex = enum(u32) {

_,

/// This is specified with an integer literal and a corresponding comptime

/// assert below to break an unfortunate and arguably incorrect dependency loop

/// when compiling.

comptime {

//@compileLog(static_keys.len);

assert(static_len == static_keys.len);

 

const BigIntMutable = std.math.big.int.Mutable;

const Target = std.Target;

const Ast = std.zig.Ast;

 

/// Deprecated, use `Zcu`.

const Module = Zcu;

const Package = @import("Package.zig");

const link = @import("link.zig");

const Air = @import("Air.zig");

const trace = @import("tracy.zig").trace;

const Sema = @import("Sema.zig");

const target_util = @import("target.zig");

const build_options = @import("build_options");

if (decl.alignment != .none) return decl.alignment;

return decl.ty.abiAlignment(zcu);

}

};

 

/// This state is attached to every Decl when Module emit_h is non-null.

return @bitCast(offset + @as(i32, @bitCast(src_loc.parent_decl_node)));

}

 

 

pub fn span(src_loc: SrcLoc, gpa: Allocator) !Span {

switch (src_loc.lazy) {

},

.node_abs => |node| {

const tree = try src_loc.file_scope.getTree(gpa);

},

.byte_offset => |byte_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

assert(src_loc.file_scope.tree_loaded);

},

.node_offset_main_token => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

const main_token = tree.nodes.items(.main_token)[node];

},

.node_offset_bin_op => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

assert(src_loc.file_scope.tree_loaded);

},

.node_offset_initializer => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

tree.firstToken(node) - 3,

tree.lastToken(node),

tree.nodes.items(.main_token)[node] - 2,

=> tree.fullVarDecl(node).?,

.@"usingnamespace" => {

const node_data = tree.nodes.items(.data);

},

else => unreachable,

};

if (full.ast.type_node != 0) {

}

const tok_index = full.ast.mut_token + 1; // the name token

const start = tree.tokens.items(.start)[tok_index];

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

const full = tree.fullVarDecl(node).?;

},

.node_offset_var_decl_section => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

const full = tree.fullVarDecl(node).?;

},

.node_offset_var_decl_addrspace => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

const full = tree.fullVarDecl(node).?;

},

.node_offset_var_decl_init => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

const full = tree.fullVarDecl(node).?;

},

.node_offset_builtin_call_arg0 => |n| return src_loc.byteOffsetBuiltinCallArg(gpa, n, 0),

.node_offset_builtin_call_arg1 => |n| return src_loc.byteOffsetBuiltinCallArg(gpa, n, 1),

node = node_datas[node].lhs;

}

 

},

.node_offset_array_access_index => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node_datas = tree.nodes.items(.data);

const node = src_loc.declRelativeToNodeIndex(node_off);

},

.node_offset_slice_ptr,

.node_offset_slice_start,

.node_offset_slice_sentinel => full.ast.sentinel,

else => unreachable,

};

},

.node_offset_call_func => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

var buf: [1]Ast.Node.Index = undefined;

const full = tree.fullCall(&buf, node).?;

},

.node_offset_field_name => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

.node_offset_deref_ptr => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

},

.node_offset_asm_source => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

const full = tree.fullAsm(node).?;

},

.node_offset_asm_ret_ty => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const full = tree.fullAsm(node).?;

const asm_output = full.outputs[0];

const node_datas = tree.nodes.items(.data);

},

 

.node_offset_if_cond => |node_off| {

const inputs = tree.fullFor(node).?.ast.inputs;

const start = tree.firstToken(inputs[0]);

const end = tree.lastToken(inputs[inputs.len - 1]);

},

 

.@"orelse" => node,

.@"catch" => node,

else => unreachable,

};

},

.for_input => |for_input| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(for_input.for_node_offset);

const for_full = tree.fullFor(node).?;

const src_node = for_full.ast.inputs[for_input.input_index];

},

.for_capture_from_input => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

},

.identifier => {

if (count == 0)

tok += 1;

},

.asterisk => {

if (count == 0)

tok += 1;

},

else => unreachable,

.array_init_comma,

=> {

const full = tree.fullArrayInit(&buf, call_args_node).?.ast.elements;

},

.struct_init_one,

.struct_init_one_comma,

.struct_init_comma,

=> {

const full = tree.fullStructInit(&buf, call_args_node).?.ast.fields;

},

}

};

},

.fn_proto_param => |fn_proto_param| {

const tree = try src_loc.file_scope.getTree(gpa);

var i: usize = 0;

while (it.next()) |param| : (i += 1) {

if (i == fn_proto_param.param_index) {

const first_token = param.comptime_noalias orelse

param.name_token orelse

tree.firstToken(param.type_expr);

first_token,

tree.lastToken(param.type_expr),

first_token,

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

const node_datas = tree.nodes.items(.data);

},

.node_offset_bin_rhs => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

const node_datas = tree.nodes.items(.data);

},

.array_cat_lhs, .array_cat_rhs => |cat| {

const tree = try src_loc.file_scope.getTree(gpa);

.array_init_comma,

=> {

const full = tree.fullArrayInit(&buf, arr_node).?.ast.elements;

},

}

},

 

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

const node_datas = tree.nodes.items(.data);

},

 

.node_offset_switch_special_prong => |node_off| {

mem.eql(u8, tree.tokenSlice(main_tokens[case.ast.values[0]]), "_"));

if (!is_special) continue;

 

} else unreachable;

},

 

 

for (case.ast.values) |item_node| {

if (node_tags[item_node] == .switch_range) {

}

}

} else unreachable;

const node = src_loc.declRelativeToNodeIndex(node_off);

var buf: [1]Ast.Node.Index = undefined;

const full = tree.fullFnProto(&buf, node).?;

},

.node_offset_fn_type_addrspace => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

var buf: [1]Ast.Node.Index = undefined;

const full = tree.fullFnProto(&buf, node).?;

},

.node_offset_fn_type_section => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

var buf: [1]Ast.Node.Index = undefined;

const full = tree.fullFnProto(&buf, node).?;

},

.node_offset_fn_type_cc => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node = src_loc.declRelativeToNodeIndex(node_off);

var buf: [1]Ast.Node.Index = undefined;

const full = tree.fullFnProto(&buf, node).?;

},

 

.node_offset_fn_type_ret_ty => |node_off| {

const node = src_loc.declRelativeToNodeIndex(node_off);

var buf: [1]Ast.Node.Index = undefined;

const full = tree.fullFnProto(&buf, node).?;

},

.node_offset_param => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

.colon, .identifier, .keyword_comptime, .keyword_noalias => first_tok -= 1,

else => break,

};

first_tok,

tree.lastToken(node),

first_tok,

.colon, .identifier, .keyword_comptime, .keyword_noalias => first_tok -= 1,

else => break,

};

first_tok,

tok_index,

first_tok,

const tree = try src_loc.file_scope.getTree(gpa);

const node_datas = tree.nodes.items(.data);

const parent_node = src_loc.declRelativeToNodeIndex(node_off);

},

 

.node_offset_lib_name => |node_off| {

const parent_node = src_loc.declRelativeToNodeIndex(node_off);

 

const full = tree.fullArrayType(parent_node).?;

},

.node_offset_array_type_sentinel => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const parent_node = src_loc.declRelativeToNodeIndex(node_off);

 

const full = tree.fullArrayType(parent_node).?;

},

.node_offset_array_type_elem => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const parent_node = src_loc.declRelativeToNodeIndex(node_off);

 

const full = tree.fullArrayType(parent_node).?;

},

.node_offset_un_op => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const node_datas = tree.nodes.items(.data);

const node = src_loc.declRelativeToNodeIndex(node_off);

 

},

.node_offset_ptr_elem => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const parent_node = src_loc.declRelativeToNodeIndex(node_off);

 

const full = tree.fullPtrType(parent_node).?;

},

.node_offset_ptr_sentinel => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const parent_node = src_loc.declRelativeToNodeIndex(node_off);

 

const full = tree.fullPtrType(parent_node).?;

},

.node_offset_ptr_align => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const parent_node = src_loc.declRelativeToNodeIndex(node_off);

 

const full = tree.fullPtrType(parent_node).?;

},

.node_offset_ptr_addrspace => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const parent_node = src_loc.declRelativeToNodeIndex(node_off);

 

const full = tree.fullPtrType(parent_node).?;

},

.node_offset_ptr_bitoffset => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const parent_node = src_loc.declRelativeToNodeIndex(node_off);

 

const full = tree.fullPtrType(parent_node).?;

},

.node_offset_ptr_hostsize => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

const parent_node = src_loc.declRelativeToNodeIndex(node_off);

 

const full = tree.fullPtrType(parent_node).?;

},

.node_offset_container_tag => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

switch (node_tags[parent_node]) {

.container_decl_arg, .container_decl_arg_trailing => {

const full = tree.containerDeclArg(parent_node);

},

.tagged_union_enum_tag, .tagged_union_enum_tag_trailing => {

const full = tree.taggedUnionEnumTag(parent_node);

 

tree.firstToken(full.ast.arg) - 2,

tree.lastToken(full.ast.arg) + 1,

tree.nodes.items(.main_token)[full.ast.arg],

.container_field_init => tree.containerFieldInit(parent_node),

else => unreachable,

};

},

.node_offset_init_ty => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

 

var buf: [2]Ast.Node.Index = undefined;

const full = tree.fullArrayInit(&buf, parent_node).?;

},

.node_offset_store_ptr => |node_off| {

const tree = try src_loc.file_scope.getTree(gpa);

 

switch (node_tags[node]) {

.assign => {

},

}

},

.node_offset_store_operand => |node_off| {

 

switch (node_tags[node]) {

.assign => {

},

}

},

.node_offset_return_operand => |node_off| {

const node_tags = tree.nodes.items(.tag);

const node_datas = tree.nodes.items(.data);

if (node_tags[node] == .@"return" and node_datas[node].lhs != 0) {

}

},

}

}

.builtin_call, .builtin_call_comma => tree.extra_data[node_datas[node].lhs + arg_index],

else => unreachable,

};

}

};

 

 

) !void {

if (fmt_string.len == 1) {

// Quote-escape the string.

const f = switch (fmt_string[0]) {

'q' => "",

'\'' => '\'',

 

 

if (ast.errors.len > 0) {

const file_path = try std.fmt.allocPrint(arena, "{}" ++ Manifest.basename, .{pkg_root});

return error.FetchFailed;

}

 

const ThreadPool = std.Thread.Pool;

const WaitGroup = std.Thread.WaitGroup;

const Fetch = @This();

const git = @import("Fetch/git.zig");

const Package = @import("../Package.zig");

const Manifest = Package.Manifest;

 

const Type = @import("type.zig").Type;

const TypedValue = @import("TypedValue.zig");

const Air = @import("Air.zig");

const Module = @import("Module.zig");

const trace = @import("tracy.zig").trace;

const Namespace = Module.Namespace;

const SemaError = Module.SemaError;

const Decl = Module.Decl;

const CaptureScope = Module.CaptureScope;

const RangeSet = @import("RangeSet.zig");

const target_util = @import("target.zig");

const Package = @import("Package.zig");

break :blk src_loc;

} else blk: {

const src_decl = mod.declPtr(rt.block.src_decl);

};

if (rt.return_ty.isGenericPoison()) {

return mod.errNoteNonLazy(src_loc, parent, prefix ++ "the generic function was instantiated with a comptime-only return type", .{});

) error{OutOfMemory}!void {

const mod = sema.mod;

const src_decl = mod.declPtr(block.src_decl);

}

 

fn addFieldErrNote(

const mod = sema.mod;

if (src == .unneeded) return error.NeededSourceLocation;

const src_decl = mod.declPtr(block.src_decl);

}

 

pub fn fail(

const decl = mod.declPtr(ref.referencer);

try reference_stack.append(.{

.decl = decl.name,

});

}

referenced_by = ref.referencer;

) !void {

const mod = sema.mod;

const src_decl = mod.declPtr(block.src_decl);

const msg_str = try std.fmt.allocPrint(mod.gpa, format, args);

 

const orig_notes = msg.notes.len;

errdefer msg.destroy(sema.gpa);

 

const src_decl = mod.declPtr(block.src_decl);

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

var child_block = parent_block.makeSubBlock();

child_block.label = &label;

child_block.runtime_cond = null;

child_block.runtime_index.increment();

const merges = &child_block.label.?.merges;

 

try mod.errNoteNonLazy(runtime_src, msg, "runtime control flow here", .{});

 

const child_src_decl = mod.declPtr(child_block.src_decl);

 

break :msg msg;

};

errdefer msg.destroy(gpa);

 

const src_decl = mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, exported_decl.ty);

break :msg msg;

};

try child_sema.errNote(&child_block, param_src, msg, "declared here", .{});

const src_decl = mod.declPtr(block.src_decl);

break :msg msg;

}),

 

errdefer msg.destroy(sema.gpa);

 

const src_decl = mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, param_ty);

break :msg msg;

errdefer msg.destroy(sema.gpa);

 

const src_decl = mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, param_ty);

break :msg msg;

errdefer msg.destroy(gpa);

 

const src_decl = mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, return_type);

break :msg msg;

"function with comptime-only return type '{}' requires all parameters to be comptime",

.{return_type.fmt(mod)},

);

 

const tags = sema.code.instructions.items(.tag);

const data = sema.code.instructions.items(.data);

const msg = try sema.errMsg(block, ptr_src, "comptime-only type '{}' has no pointer address", .{pointee_ty.fmt(mod)});

errdefer msg.destroy(sema.gpa);

const src_decl = mod.declPtr(block.src_decl);

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

 

var sub_block = child_block.makeSubBlock();

sub_block.runtime_loop = null;

sub_block.runtime_index.increment();

defer sub_block.instructions.deinit(gpa);

 

 

var case_block = child_block.makeSubBlock();

case_block.runtime_loop = null;

case_block.runtime_index.increment();

defer case_block.instructions.deinit(gpa);

 

return sema.fail(block, operand_src, "file path name cannot be empty", .{});

}

 

const val = mod.embedFile(block.getFileScope(mod), name, src_loc) catch |err| switch (err) {

error.ImportOutsideModulePath => {

return sema.fail(block, operand_src, "embed of file outside package path: '{s}'", .{name});

 

var child_block = parent_block.makeSubBlock();

child_block.runtime_loop = null;

child_block.runtime_index.increment();

defer child_block.instructions.deinit(gpa);

 

// instructions array in between using it for the then block and else block.

var sub_block = parent_block.makeSubBlock();

sub_block.runtime_loop = null;

sub_block.runtime_index.increment();

defer sub_block.instructions.deinit(gpa);

 

 

if (sema.fn_ret_ty.isError(mod) and ret_val.getErrorName(mod) != .none) {

const src_decl = mod.declPtr(block.src_decl);

try sema.comptime_err_ret_trace.append(src_loc);

}

return error.ComptimeReturn;

errdefer msg.destroy(sema.gpa);

 

const src_decl = mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, elem_ty);

break :msg msg;

errdefer msg.destroy(gpa);

 

const src_decl = mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, elem_ty);

break :msg msg;

errdefer msg.destroy(gpa);

 

const src_decl = mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, field_ty);

break :msg msg;

errdefer msg.destroy(gpa);

 

const src_decl = mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, field_ty);

break :msg msg;

errdefer msg.destroy(gpa);

 

const src_decl = sema.mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, field_ty);

break :msg msg;

errdefer msg.destroy(gpa);

 

const src_decl = sema.mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, field_ty);

break :msg msg;

errdefer msg.destroy(sema.gpa);

 

const src_decl = sema.mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, arg_ty);

break :msg msg;

const msg = try sema.errMsg(block, ty_src, "extern symbol cannot have type '{}'", .{ty.fmt(mod)});

errdefer msg.destroy(sema.gpa);

const src_decl = sema.mod.declPtr(block.src_decl);

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

const msg = try sema.errMsg(block, src, "extern variable cannot have type '{}'", .{var_ty.fmt(mod)});

errdefer msg.destroy(sema.gpa);

const src_decl = mod.declPtr(block.src_decl);

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

errdefer msg.destroy(sema.gpa);

 

const src_decl = mod.declPtr(block.src_decl);

if (var_ty.zigTypeTag(mod) == .ComptimeInt or var_ty.zigTypeTag(mod) == .ComptimeFloat) {

try sema.errNote(block, src, msg, "to modify this variable at runtime, it must be given an explicit fixed-size number type", .{});

}

errdefer msg.destroy(sema.gpa);

 

const src_decl = mod.declPtr(block.src_decl);

 

break :msg msg;

};

.lazy = LazySrcLoc.nodeOffset(param_src.node_offset_param),

};

}

}

} = .{},

};

 

const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = 0 };

const src_decl = mod.funcOwnerDeclPtr(sema.func_index);

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = 0 };

const src_decl = mod.funcOwnerDeclPtr(sema.func_index);

if (inst_ty.isError(mod) and !dest_ty.isError(mod)) {

} else {

}

}

 

errdefer msg.destroy(sema.gpa);

 

const src_decl = sema.mod.declPtr(block.src_decl);

 

try sema.addDeclaredHereNote(msg, coerced_ty);

break :msg msg;

});

errdefer msg.destroy(sema.gpa);

const decl_ptr = mod.declPtr(tag_info.decl);

break :msg msg;

};

return sema.failWithOwnedErrorMsg(&block_scope, msg);

 

const Type = @import("../../type.zig").Type;

const Value = @import("../../Value.zig");

const Compilation = @import("../../Compilation.zig");

const link = @import("../../link.zig");

const TypedValue = @import("../../TypedValue.zig");

const Air = @import("../../Air.zig");

/// Sets `err_msg` on `CodeGen` and returns `error.CodegenFail` which is caught in link/Wasm.zig

fn fail(func: *CodeGen, comptime fmt: []const u8, args: anytype) InnerError {

const mod = func.bin_file.base.comp.module.?;

func.err_msg = try Module.ErrorMsg.create(func.gpa, src_loc, fmt, args);

return error.CodegenFail;

}

 

const Type = @import("type.zig").Type;

const TypedValue = @import("TypedValue.zig");

const Value = @import("Value.zig");

const Alignment = InternPool.Alignment;

 

pub const Result = union(enum) {

 

const C = link.File.C;

const Decl = Module.Decl;

const trace = @import("../tracy.zig").trace;

const Air = @import("../Air.zig");

const Liveness = @import("../Liveness.zig");

const InternPool = @import("../InternPool.zig");

const mod = dg.module;

const decl_index = dg.pass.decl;

const decl = mod.declPtr(decl_index);

dg.error_msg = try Module.ErrorMsg.create(dg.gpa, src_loc, format, args);

return error.AnalysisFail;

}

 

const Liveness = @import("../Liveness.zig");

const Value = @import("../Value.zig");

const Type = @import("../type.zig").Type;

const x86_64_abi = @import("../arch/x86_64/abi.zig");

const wasm_c_abi = @import("../arch/wasm/abi.zig");

const aarch64_c_abi = @import("../arch/aarch64/abi.zig");

const o = dg.object;

const gpa = o.gpa;

const mod = o.module;

dg.err_msg = try Module.ErrorMsg.create(gpa, src_loc, "TODO (LLVM): " ++ format, args);

return error.CodegenFail;

}

 

const Decl = Module.Decl;

const Type = @import("../type.zig").Type;

const Value = @import("../Value.zig");

const Air = @import("../Air.zig");

const Liveness = @import("../Liveness.zig");

const InternPool = @import("../InternPool.zig");

 

pub fn fail(self: *DeclGen, comptime format: []const u8, args: anytype) Error {

@setCold(true);

const mod = self.module;

assert(self.error_msg == null);

self.error_msg = try Module.ErrorMsg.create(self.module.gpa, src_loc, format, args);

return error.CodegenFail;

// TODO: Translate proper error locations.

assert(as.errors.items.len != 0);

assert(self.error_msg == null);

self.error_msg = try Module.ErrorMsg.create(self.module.gpa, src_loc, "failed to assemble SPIR-V inline assembly", .{});

const notes = try self.module.gpa.alloc(Module.ErrorMsg, as.errors.items.len);

 

 

 

const Module = @import("Module.zig");

const Sema = @import("Sema.zig");

const Decl = Module.Decl;

 

pub const is_enabled = builtin.mode == .Debug;

 

ZIG_VERBOSE_LINK,

ZIG_VERBOSE_CC,

ZIG_BTRFS_WORKAROUND,

CC,

NO_COLOR,

XDG_CACHE_HOME,

 

const Allocator = mem.Allocator;

const ArrayList = std.ArrayList;

const Ast = std.zig.Ast;

const warn = std.log.warn;

const ThreadPool = std.Thread.Pool;

const cleanExit = std.process.cleanExit;

const target_util = @import("target.zig");

const crash_report = @import("crash_report.zig");

const Module = @import("Module.zig");

const mingw = @import("mingw.zig");

const Server = std.zig.Server;

 

process.exit(1);

}

 

const debug_extensions_enabled = builtin.mode == .Debug;

 

const normal_usage =

\\Usage: zig [command] [options]

\\

}

}

 

return mainArgs(gpa, arena, args);

}

 

} else if (mem.eql(u8, cmd, "rc")) {

return cmdRc(gpa, arena, args[1..]);

} else if (mem.eql(u8, cmd, "fmt")) {

} else if (mem.eql(u8, cmd, "objcopy")) {

return @import("objcopy.zig").cmdObjCopy(gpa, arena, cmd_args);

} else if (mem.eql(u8, cmd, "fetch")) {

verifyLibcxxCorrectlyLinked();

return @import("print_env.zig").cmdEnv(arena, cmd_args, io.getStdOut().writer());

} else if (mem.eql(u8, cmd, "reduce")) {

} else if (mem.eql(u8, cmd, "zen")) {

return io.getStdOut().writeAll(info_zen);

} else if (mem.eql(u8, cmd, "help") or mem.eql(u8, cmd, "-h") or mem.eql(u8, cmd, "--help")) {

.paths = .{

.root = .{

.root_dir = zig_lib_directory,

},

.root_src_path = "test_runner.zig",

},

defer errors.deinit(comp.gpa);

 

if (errors.errorMessageCount() > 0) {

return error.SemanticAnalyzeFail;

}

}

p.errors = errors;

return;

} else {

process.exit(1);

}

},

},

.root_src_path = fs.path.basename(runner),

} else .{

.root_src_path = "build_runner.zig",

};

 

 

if (fetch.error_bundle.root_list.items.len > 0) {

var errors = try fetch.error_bundle.toOwnedBundle("");

process.exit(1);

}

 

}

}

 

gpa: Allocator,

arena: Allocator,

 

};

 

 

 

 

},

};

 

 

 

 

},

};

 

});

 

.fully_qualified_name = "root",

 

 

}

 

const info_zen =

arena: Allocator,

args: []const []const u8,

) !void {

 

var color: Color = .auto;

var want_output_text = false;

 

const stat = try f.stat();

 

return error.FileTooBig;

 

const source = try arena.allocSentinel(u8, @as(usize, @intCast(stat.size)), 0);

};

} else {

const stdin = io.getStdIn();

fatal("unable to read stdin: {}", .{err});

};

file.sub_file_path = "<stdin>";

try Compilation.addZirErrorMessages(&wip_errors, &file);

var error_bundle = try wip_errors.toOwnedBundle("");

defer error_bundle.deinit(gpa);

process.exit(1);

}

 

args: []const []const u8,

) !void {

_ = arena;

 

const cache_file = args[0];

 

args: []const []const u8,

) !void {

const color: Color = .auto;

 

const old_source_file = args[0];

const new_source_file = args[1];

 

const stat = try f.stat();

 

return error.FileTooBig;

 

var file: Module.File = .{

try Compilation.addZirErrorMessages(&wip_errors, &file);

var error_bundle = try wip_errors.toOwnedBundle("");

defer error_bundle.deinit(gpa);

process.exit(1);

}

 

 

const new_stat = try new_f.stat();

 

return error.FileTooBig;

 

const new_source = try arena.allocSentinel(u8, @as(usize, @intCast(new_stat.size)), 0);

try Compilation.addZirErrorMessages(&wip_errors, &file);

var error_bundle = try wip_errors.toOwnedBundle("");

defer error_bundle.deinit(gpa);

process.exit(1);

}

 

};

};

 

fn accessLibPath(

test_path: *std.ArrayList(u8),

checked_paths: *std.ArrayList(u8),

 

if (fetch.error_bundle.root_list.items.len > 0) {

var errors = try fetch.error_bundle.toOwnedBundle("");

process.exit(1);

}

 

errdefer ast.deinit(gpa);

 

if (ast.errors.len > 0) {

process.exit(2);

}

 

 

var error_bundle = try wip_errors.toOwnedBundle("");

defer error_bundle.deinit(gpa);

 

process.exit(2);

}

 

const Ast = std.zig.Ast;

const InternPool = @import("InternPool.zig");

 

const Module = @import("Module.zig");

 

/// Write human-readable, debug formatted ZIR code to a file.

pub fn renderAsTextToFile(

 

pub const only_c = false;

pub const force_gpa = false;

pub const only_core_functionality = true;