Commit c6076a1360
Changed files (17)
src-self-hosted/arg.zig
@@ -119,9 +119,9 @@ pub const Args = struct {
// MergeN creation disallows 0 length flag entry (doesn't make sense)
switch (flag_args) {
- FlagArg.None => unreachable,
- FlagArg.Single => |inner| try prev.append(inner),
- FlagArg.Many => |inner| try prev.appendSlice(inner.toSliceConst()),
+ .None => unreachable,
+ .Single => |inner| try prev.append(inner),
+ .Many => |inner| try prev.appendSlice(inner.toSliceConst()),
}
_ = try parsed.flags.put(flag_name_trimmed, FlagArg{ .Many = prev });
@@ -158,7 +158,7 @@ pub const Args = struct {
pub fn single(self: *Args, name: []const u8) ?[]const u8 {
if (self.flags.get(name)) |entry| {
switch (entry.value) {
- FlagArg.Single => |inner| {
+ .Single => |inner| {
return inner;
},
else => @panic("attempted to retrieve flag with wrong type"),
@@ -172,7 +172,7 @@ pub const Args = struct {
pub fn many(self: *Args, name: []const u8) []const []const u8 {
if (self.flags.get(name)) |entry| {
switch (entry.value) {
- FlagArg.Many => |inner| {
+ .Many => |inner| {
return inner.toSliceConst();
},
else => @panic("attempted to retrieve flag with wrong type"),
src-self-hosted/c_int.zig
@@ -19,56 +19,56 @@ pub const CInt = struct {
pub const list = [_]CInt{
CInt{
- .id = Id.Short,
+ .id = .Short,
.zig_name = "c_short",
.c_name = "short",
.is_signed = true,
},
CInt{
- .id = Id.UShort,
+ .id = .UShort,
.zig_name = "c_ushort",
.c_name = "unsigned short",
.is_signed = false,
},
CInt{
- .id = Id.Int,
+ .id = .Int,
.zig_name = "c_int",
.c_name = "int",
.is_signed = true,
},
CInt{
- .id = Id.UInt,
+ .id = .UInt,
.zig_name = "c_uint",
.c_name = "unsigned int",
.is_signed = false,
},
CInt{
- .id = Id.Long,
+ .id = .Long,
.zig_name = "c_long",
.c_name = "long",
.is_signed = true,
},
CInt{
- .id = Id.ULong,
+ .id = .ULong,
.zig_name = "c_ulong",
.c_name = "unsigned long",
.is_signed = false,
},
CInt{
- .id = Id.LongLong,
+ .id = .LongLong,
.zig_name = "c_longlong",
.c_name = "long long",
.is_signed = true,
},
CInt{
- .id = Id.ULongLong,
+ .id = .ULongLong,
.zig_name = "c_ulonglong",
.c_name = "unsigned long long",
.is_signed = false,
},
};
- pub fn sizeInBits(id: CInt.Id, self: Target) u32 {
+ pub fn sizeInBits(id: Id, self: Target) u32 {
const arch = self.getArch();
switch (self.getOs()) {
.freestanding => switch (self.getArch()) {
src-self-hosted/codegen.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = @import("builtin");
const Compilation = @import("compilation.zig").Compilation;
const llvm = @import("llvm.zig");
const c = @import("c.zig");
@@ -31,7 +30,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
llvm.SetTarget(module, comp.llvm_triple.ptr());
llvm.SetDataLayout(module, comp.target_layout_str);
- if (comp.target.getObjectFormat() == builtin.ObjectFormat.coff) {
+ if (comp.target.getObjectFormat() == .coff) {
llvm.AddModuleCodeViewFlag(module);
} else {
llvm.AddModuleDebugInfoFlag(module);
@@ -59,7 +58,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
comp.name.ptr(),
comp.root_package.root_src_dir.ptr(),
) orelse return error.OutOfMemory;
- const is_optimized = comp.build_mode != builtin.Mode.Debug;
+ const is_optimized = comp.build_mode != .Debug;
const compile_unit = llvm.CreateCompileUnit(
dibuilder,
DW.LANG_C99,
@@ -105,8 +104,8 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
assert(comp.emit_file_type == Compilation.Emit.Binary); // TODO support other types
- const is_small = comp.build_mode == builtin.Mode.ReleaseSmall;
- const is_debug = comp.build_mode == builtin.Mode.Debug;
+ const is_small = comp.build_mode == .ReleaseSmall;
+ const is_debug = comp.build_mode == .Debug;
var err_msg: [*]u8 = undefined;
// TODO integrate this with evented I/O
@@ -114,7 +113,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
comp.target_machine,
module,
output_path.ptr(),
- llvm.EmitBinary,
+ .EmitBinary,
&err_msg,
is_debug,
is_small,
@@ -234,8 +233,8 @@ pub fn renderToLlvmModule(ofile: *ObjectFile, fn_val: *Value.Fn, code: *ir.Code)
// create debug variable declarations for variables and allocate all local variables
for (var_list) |var_scope, i| {
const var_type = switch (var_scope.data) {
- Scope.Var.Data.Const => unreachable,
- Scope.Var.Data.Param => |param| param.typ,
+ .Const => unreachable,
+ .Param => |param| param.typ,
};
// if (!type_has_bits(var->value->type)) {
// continue;
@@ -266,7 +265,7 @@ pub fn renderToLlvmModule(ofile: *ObjectFile, fn_val: *Value.Fn, code: *ir.Code)
var_scope.data.Param.llvm_value = llvm.GetParam(llvm_fn, @intCast(c_uint, i));
} else {
// gen_type = var->value->type;
- var_scope.data.Param.llvm_value = try renderAlloca(ofile, var_type, var_scope.name, Type.Pointer.Align.Abi);
+ var_scope.data.Param.llvm_value = try renderAlloca(ofile, var_type, var_scope.name, .Abi);
}
// if (var->decl_node) {
// var->di_loc_var = ZigLLVMCreateParameterVariable(g->dbuilder, get_di_scope(g, var->parent_scope),
@@ -300,8 +299,8 @@ pub fn renderToLlvmModule(ofile: *ObjectFile, fn_val: *Value.Fn, code: *ir.Code)
ofile,
llvm_param,
scope_var.data.Param.llvm_value,
- Type.Pointer.Align.Abi,
- Type.Pointer.Vol.Non,
+ .Abi,
+ .Non,
);
}
@@ -383,8 +382,8 @@ fn renderLoadUntyped(
) !*llvm.Value {
const result = llvm.BuildLoad(ofile.builder, ptr, name) orelse return error.OutOfMemory;
switch (vol) {
- Type.Pointer.Vol.Non => {},
- Type.Pointer.Vol.Volatile => llvm.SetVolatile(result, 1),
+ .Non => {},
+ .Volatile => llvm.SetVolatile(result, 1),
}
llvm.SetAlignment(result, resolveAlign(ofile, alignment, llvm.GetElementType(llvm.TypeOf(ptr))));
return result;
@@ -414,8 +413,8 @@ pub fn renderStoreUntyped(
) !*llvm.Value {
const result = llvm.BuildStore(ofile.builder, value, ptr) orelse return error.OutOfMemory;
switch (vol) {
- Type.Pointer.Vol.Non => {},
- Type.Pointer.Vol.Volatile => llvm.SetVolatile(result, 1),
+ .Non => {},
+ .Volatile => llvm.SetVolatile(result, 1),
}
llvm.SetAlignment(result, resolveAlign(ofile, alignment, llvm.TypeOf(value)));
return result;
@@ -445,7 +444,7 @@ pub fn renderAlloca(
pub fn resolveAlign(ofile: *ObjectFile, alignment: Type.Pointer.Align, llvm_type: *llvm.Type) u32 {
return switch (alignment) {
- Type.Pointer.Align.Abi => return llvm.ABIAlignmentOfType(ofile.comp.target_data_ref, llvm_type),
- Type.Pointer.Align.Override => |a| a,
+ .Abi => return llvm.ABIAlignmentOfType(ofile.comp.target_data_ref, llvm_type),
+ .Override => |a| a,
};
}
src-self-hosted/compilation.zig
@@ -5,7 +5,7 @@ const Allocator = mem.Allocator;
const Buffer = std.Buffer;
const llvm = @import("llvm.zig");
const c = @import("c.zig");
-const builtin = @import("builtin");
+const builtin = std.builtin;
const Target = std.Target;
const warn = std.debug.warn;
const Token = std.zig.Token;
@@ -481,7 +481,7 @@ pub const Compilation = struct {
comp.zig_std_dir = try std.fs.path.join(comp.arena(), [_][]const u8{ zig_lib_dir, "std" });
const opt_level = switch (build_mode) {
- builtin.Mode.Debug => llvm.CodeGenLevelNone,
+ .Debug => llvm.CodeGenLevelNone,
else => llvm.CodeGenLevelAggressive,
};
@@ -594,11 +594,11 @@ pub const Compilation = struct {
.base = Type{
.name = "type",
.base = Value{
- .id = Value.Id.Type,
+ .id = .Type,
.typ = undefined,
.ref_count = std.atomic.Int(usize).init(3), // 3 because it references itself twice
},
- .id = builtin.TypeId.Type,
+ .id = .Type,
.abi_alignment = Type.AbiAlignment.init(),
},
.value = undefined,
@@ -612,11 +612,11 @@ pub const Compilation = struct {
.base = Type{
.name = "void",
.base = Value{
- .id = Value.Id.Type,
+ .id = .Type,
.typ = &Type.MetaType.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
- .id = builtin.TypeId.Void,
+ .id = .Void,
.abi_alignment = Type.AbiAlignment.init(),
},
};
@@ -627,11 +627,11 @@ pub const Compilation = struct {
.base = Type{
.name = "noreturn",
.base = Value{
- .id = Value.Id.Type,
+ .id = .Type,
.typ = &Type.MetaType.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
- .id = builtin.TypeId.NoReturn,
+ .id = .NoReturn,
.abi_alignment = Type.AbiAlignment.init(),
},
};
@@ -642,11 +642,11 @@ pub const Compilation = struct {
.base = Type{
.name = "comptime_int",
.base = Value{
- .id = Value.Id.Type,
+ .id = .Type,
.typ = &Type.MetaType.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
- .id = builtin.TypeId.ComptimeInt,
+ .id = .ComptimeInt,
.abi_alignment = Type.AbiAlignment.init(),
},
};
@@ -657,11 +657,11 @@ pub const Compilation = struct {
.base = Type{
.name = "bool",
.base = Value{
- .id = Value.Id.Type,
+ .id = .Type,
.typ = &Type.MetaType.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
- .id = builtin.TypeId.Bool,
+ .id = .Bool,
.abi_alignment = Type.AbiAlignment.init(),
},
};
@@ -670,7 +670,7 @@ pub const Compilation = struct {
comp.void_value = try comp.arena().create(Value.Void);
comp.void_value.* = Value.Void{
.base = Value{
- .id = Value.Id.Void,
+ .id = .Void,
.typ = &Type.Void.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -679,7 +679,7 @@ pub const Compilation = struct {
comp.true_value = try comp.arena().create(Value.Bool);
comp.true_value.* = Value.Bool{
.base = Value{
- .id = Value.Id.Bool,
+ .id = .Bool,
.typ = &Type.Bool.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -689,7 +689,7 @@ pub const Compilation = struct {
comp.false_value = try comp.arena().create(Value.Bool);
comp.false_value.* = Value.Bool{
.base = Value{
- .id = Value.Id.Bool,
+ .id = .Bool,
.typ = &Type.Bool.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -699,7 +699,7 @@ pub const Compilation = struct {
comp.noreturn_value = try comp.arena().create(Value.NoReturn);
comp.noreturn_value.* = Value.NoReturn{
.base = Value{
- .id = Value.Id.NoReturn,
+ .id = .NoReturn,
.typ = &Type.NoReturn.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -711,11 +711,11 @@ pub const Compilation = struct {
.base = Type{
.name = cint.zig_name,
.base = Value{
- .id = Value.Id.Type,
+ .id = .Type,
.typ = &Type.MetaType.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
- .id = builtin.TypeId.Int,
+ .id = .Int,
.abi_alignment = Type.AbiAlignment.init(),
},
.key = Type.Int.Key{
@@ -732,11 +732,11 @@ pub const Compilation = struct {
.base = Type{
.name = "u8",
.base = Value{
- .id = Value.Id.Type,
+ .id = .Type,
.typ = &Type.MetaType.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
- .id = builtin.TypeId.Int,
+ .id = .Int,
.abi_alignment = Type.AbiAlignment.init(),
},
.key = Type.Int.Key{
@@ -884,15 +884,15 @@ pub const Compilation = struct {
while (ast_it.next()) |decl_ptr| {
const decl = decl_ptr.*;
switch (decl.id) {
- ast.Node.Id.Comptime => {
+ .Comptime => {
const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", decl);
// TODO connect existing comptime decls to updated source files
try self.prelink_group.call(addCompTimeBlock, self, tree_scope, &decl_scope.base, comptime_node);
},
- ast.Node.Id.VarDecl => @panic("TODO"),
- ast.Node.Id.FnProto => {
+ .VarDecl => @panic("TODO"),
+ .FnProto => {
const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
const name = if (fn_proto.name_token) |name_token| tree_scope.tree.tokenSlice(name_token) else {
@@ -945,7 +945,7 @@ pub const Compilation = struct {
try group.call(addTopLevelDecl, self, &fn_decl.base, locked_table);
}
},
- ast.Node.Id.TestDecl => @panic("TODO"),
+ .TestDecl => @panic("TODO"),
else => unreachable,
}
}
@@ -1285,12 +1285,12 @@ fn parseVisibToken(tree: *ast.Tree, optional_token_index: ?ast.TokenIndex) Visib
/// The function that actually does the generation.
async fn generateDecl(comp: *Compilation, decl: *Decl) !void {
switch (decl.id) {
- Decl.Id.Var => @panic("TODO"),
- Decl.Id.Fn => {
+ .Var => @panic("TODO"),
+ .Fn => {
const fn_decl = @fieldParentPtr(Decl.Fn, "base", decl);
return generateDeclFn(comp, fn_decl);
},
- Decl.Id.CompTime => @panic("TODO"),
+ .CompTime => @panic("TODO"),
}
}
@@ -1385,8 +1385,8 @@ async fn analyzeFnType(
fn_proto: *ast.Node.FnProto,
) !*Type.Fn {
const return_type_node = switch (fn_proto.return_type) {
- ast.Node.FnProto.ReturnType.Explicit => |n| n,
- ast.Node.FnProto.ReturnType.InferErrorSet => |n| n,
+ .Explicit => |n| n,
+ .InferErrorSet => |n| n,
};
const return_type = try comp.analyzeTypeExpr(tree_scope, scope, return_type_node);
return_type.base.deref(comp);
src-self-hosted/decl.zig
@@ -29,7 +29,7 @@ pub const Decl = struct {
pub fn isExported(base: *const Decl, tree: *ast.Tree) bool {
switch (base.id) {
- Id.Fn => {
+ .Fn => {
const fn_decl = @fieldParentPtr(Fn, "base", base);
return fn_decl.isExported(tree);
},
@@ -39,7 +39,7 @@ pub const Decl = struct {
pub fn getSpan(base: *const Decl) errmsg.Span {
switch (base.id) {
- Id.Fn => {
+ .Fn => {
const fn_decl = @fieldParentPtr(Fn, "base", base);
const fn_proto = fn_decl.fn_proto;
const start = fn_proto.fn_token;
@@ -69,21 +69,18 @@ pub const Decl = struct {
pub const Fn = struct {
base: Decl,
- value: Val,
- fn_proto: *ast.Node.FnProto,
-
- // TODO https://github.com/ziglang/zig/issues/683 and then make this anonymous
- pub const Val = union(enum) {
- Unresolved: void,
+ value: union(enum) {
+ Unresolved,
Fn: *Value.Fn,
FnProto: *Value.FnProto,
- };
+ },
+ fn_proto: *ast.Node.FnProto,
pub fn externLibName(self: Fn, tree: *ast.Tree) ?[]const u8 {
return if (self.fn_proto.extern_export_inline_token) |tok_index| x: {
const token = tree.tokens.at(tok_index);
break :x switch (token.id) {
- Token.Id.Extern => tree.tokenSlicePtr(token),
+ .Extern => tree.tokenSlicePtr(token),
else => null,
};
} else null;
@@ -92,7 +89,7 @@ pub const Decl = struct {
pub fn isExported(self: Fn, tree: *ast.Tree) bool {
if (self.fn_proto.extern_export_inline_token) |tok_index| {
const token = tree.tokens.at(tok_index);
- return token.id == Token.Id.Keyword_export;
+ return token.id == .Keyword_export;
} else {
return false;
}
src-self-hosted/errmsg.zig
@@ -62,17 +62,17 @@ pub const Msg = struct {
pub fn destroy(self: *Msg) void {
switch (self.data) {
- Data.Cli => |cli| {
+ .Cli => |cli| {
cli.allocator.free(self.text);
cli.allocator.free(self.realpath);
cli.allocator.destroy(self);
},
- Data.PathAndTree => |path_and_tree| {
+ .PathAndTree => |path_and_tree| {
path_and_tree.allocator.free(self.text);
path_and_tree.allocator.free(self.realpath);
path_and_tree.allocator.destroy(self);
},
- Data.ScopeAndComp => |scope_and_comp| {
+ .ScopeAndComp => |scope_and_comp| {
scope_and_comp.tree_scope.base.deref(scope_and_comp.compilation);
scope_and_comp.compilation.gpa().free(self.text);
scope_and_comp.compilation.gpa().free(self.realpath);
@@ -83,11 +83,11 @@ pub const Msg = struct {
fn getAllocator(self: *const Msg) *mem.Allocator {
switch (self.data) {
- Data.Cli => |cli| return cli.allocator,
- Data.PathAndTree => |path_and_tree| {
+ .Cli => |cli| return cli.allocator,
+ .PathAndTree => |path_and_tree| {
return path_and_tree.allocator;
},
- Data.ScopeAndComp => |scope_and_comp| {
+ .ScopeAndComp => |scope_and_comp| {
return scope_and_comp.compilation.gpa();
},
}
@@ -95,11 +95,11 @@ pub const Msg = struct {
pub fn getTree(self: *const Msg) *ast.Tree {
switch (self.data) {
- Data.Cli => unreachable,
- Data.PathAndTree => |path_and_tree| {
+ .Cli => unreachable,
+ .PathAndTree => |path_and_tree| {
return path_and_tree.tree;
},
- Data.ScopeAndComp => |scope_and_comp| {
+ .ScopeAndComp => |scope_and_comp| {
return scope_and_comp.tree_scope.tree;
},
}
@@ -107,9 +107,9 @@ pub const Msg = struct {
pub fn getSpan(self: *const Msg) Span {
return switch (self.data) {
- Data.Cli => unreachable,
- Data.PathAndTree => |path_and_tree| path_and_tree.span,
- Data.ScopeAndComp => |scope_and_comp| scope_and_comp.span,
+ .Cli => unreachable,
+ .PathAndTree => |path_and_tree| path_and_tree.span,
+ .ScopeAndComp => |scope_and_comp| scope_and_comp.span,
};
}
@@ -230,7 +230,7 @@ pub const Msg = struct {
pub fn printToStream(msg: *const Msg, stream: var, color_on: bool) !void {
switch (msg.data) {
- Data.Cli => {
+ .Cli => {
try stream.print("{}:-:-: error: {}\n", msg.realpath, msg.text);
return;
},
@@ -279,9 +279,9 @@ pub const Msg = struct {
pub fn printToFile(msg: *const Msg, file: fs.File, color: Color) !void {
const color_on = switch (color) {
- Color.Auto => file.isTty(),
- Color.On => true,
- Color.Off => false,
+ .Auto => file.isTty(),
+ .On => true,
+ .Off => false,
};
var stream = &file.outStream().stream;
return msg.printToStream(stream, color_on);
src-self-hosted/ir.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = @import("builtin");
const Compilation = @import("compilation.zig").Compilation;
const Scope = @import("scope.zig").Scope;
const ast = std.zig.ast;
@@ -33,13 +32,13 @@ pub const IrVal = union(enum) {
pub fn dump(self: IrVal) void {
switch (self) {
- IrVal.Unknown => std.debug.warn("Unknown"),
- IrVal.KnownType => |typ| {
+ .Unknown => std.debug.warn("Unknown"),
+ .KnownType => |typ| {
std.debug.warn("KnownType(");
typ.dump();
std.debug.warn(")");
},
- IrVal.KnownValue => |value| {
+ .KnownValue => |value| {
std.debug.warn("KnownValue(");
value.dump();
std.debug.warn(")");
@@ -113,37 +112,37 @@ pub const Inst = struct {
pub async fn analyze(base: *Inst, ira: *Analyze) Analyze.Error!*Inst {
switch (base.id) {
- Id.Return => return @fieldParentPtr(Return, "base", base).analyze(ira),
- Id.Const => return @fieldParentPtr(Const, "base", base).analyze(ira),
- Id.Call => return @fieldParentPtr(Call, "base", base).analyze(ira),
- Id.DeclRef => return @fieldParentPtr(DeclRef, "base", base).analyze(ira),
- Id.Ref => return @fieldParentPtr(Ref, "base", base).analyze(ira),
- Id.DeclVar => return @fieldParentPtr(DeclVar, "base", base).analyze(ira),
- Id.CheckVoidStmt => return @fieldParentPtr(CheckVoidStmt, "base", base).analyze(ira),
- Id.Phi => return @fieldParentPtr(Phi, "base", base).analyze(ira),
- Id.Br => return @fieldParentPtr(Br, "base", base).analyze(ira),
- Id.AddImplicitReturnType => return @fieldParentPtr(AddImplicitReturnType, "base", base).analyze(ira),
- Id.PtrType => return @fieldParentPtr(PtrType, "base", base).analyze(ira),
- Id.VarPtr => return @fieldParentPtr(VarPtr, "base", base).analyze(ira),
- Id.LoadPtr => return @fieldParentPtr(LoadPtr, "base", base).analyze(ira),
+ .Return => return @fieldParentPtr(Return, "base", base).analyze(ira),
+ .Const => return @fieldParentPtr(Const, "base", base).analyze(ira),
+ .Call => return @fieldParentPtr(Call, "base", base).analyze(ira),
+ .DeclRef => return @fieldParentPtr(DeclRef, "base", base).analyze(ira),
+ .Ref => return @fieldParentPtr(Ref, "base", base).analyze(ira),
+ .DeclVar => return @fieldParentPtr(DeclVar, "base", base).analyze(ira),
+ .CheckVoidStmt => return @fieldParentPtr(CheckVoidStmt, "base", base).analyze(ira),
+ .Phi => return @fieldParentPtr(Phi, "base", base).analyze(ira),
+ .Br => return @fieldParentPtr(Br, "base", base).analyze(ira),
+ .AddImplicitReturnType => return @fieldParentPtr(AddImplicitReturnType, "base", base).analyze(ira),
+ .PtrType => return @fieldParentPtr(PtrType, "base", base).analyze(ira),
+ .VarPtr => return @fieldParentPtr(VarPtr, "base", base).analyze(ira),
+ .LoadPtr => return @fieldParentPtr(LoadPtr, "base", base).analyze(ira),
}
}
pub fn render(base: *Inst, ofile: *ObjectFile, fn_val: *Value.Fn) (error{OutOfMemory}!?*llvm.Value) {
switch (base.id) {
- Id.Return => return @fieldParentPtr(Return, "base", base).render(ofile, fn_val),
- Id.Const => return @fieldParentPtr(Const, "base", base).render(ofile, fn_val),
- Id.Call => return @fieldParentPtr(Call, "base", base).render(ofile, fn_val),
- Id.VarPtr => return @fieldParentPtr(VarPtr, "base", base).render(ofile, fn_val),
- Id.LoadPtr => return @fieldParentPtr(LoadPtr, "base", base).render(ofile, fn_val),
- Id.DeclRef => unreachable,
- Id.PtrType => unreachable,
- Id.Ref => @panic("TODO"),
- Id.DeclVar => @panic("TODO"),
- Id.CheckVoidStmt => @panic("TODO"),
- Id.Phi => @panic("TODO"),
- Id.Br => @panic("TODO"),
- Id.AddImplicitReturnType => @panic("TODO"),
+ .Return => return @fieldParentPtr(Return, "base", base).render(ofile, fn_val),
+ .Const => return @fieldParentPtr(Const, "base", base).render(ofile, fn_val),
+ .Call => return @fieldParentPtr(Call, "base", base).render(ofile, fn_val),
+ .VarPtr => return @fieldParentPtr(VarPtr, "base", base).render(ofile, fn_val),
+ .LoadPtr => return @fieldParentPtr(LoadPtr, "base", base).render(ofile, fn_val),
+ .DeclRef => unreachable,
+ .PtrType => unreachable,
+ .Ref => @panic("TODO"),
+ .DeclVar => @panic("TODO"),
+ .CheckVoidStmt => @panic("TODO"),
+ .Phi => @panic("TODO"),
+ .Br => @panic("TODO"),
+ .AddImplicitReturnType => @panic("TODO"),
}
}
@@ -165,7 +164,7 @@ pub const Inst = struct {
param.ref_count -= 1;
const child = param.child orelse return error.SemanticAnalysisFailed;
switch (child.val) {
- IrVal.Unknown => return error.SemanticAnalysisFailed,
+ .Unknown => return error.SemanticAnalysisFailed,
else => return child,
}
}
@@ -213,9 +212,9 @@ pub const Inst = struct {
/// asserts that the type is known
fn getKnownType(self: *Inst) *Type {
switch (self.val) {
- IrVal.KnownType => |typ| return typ,
- IrVal.KnownValue => |value| return value.typ,
- IrVal.Unknown => unreachable,
+ .KnownType => |typ| return typ,
+ .KnownValue => |value| return value.typ,
+ .Unknown => unreachable,
}
}
@@ -225,14 +224,14 @@ pub const Inst = struct {
pub fn isNoReturn(base: *const Inst) bool {
switch (base.val) {
- IrVal.Unknown => return false,
- IrVal.KnownValue => |x| return x.typ.id == Type.Id.NoReturn,
- IrVal.KnownType => |typ| return typ.id == Type.Id.NoReturn,
+ .Unknown => return false,
+ .KnownValue => |x| return x.typ.id == .NoReturn,
+ .KnownType => |typ| return typ.id == .NoReturn,
}
}
pub fn isCompTime(base: *const Inst) bool {
- return base.val == IrVal.KnownValue;
+ return base.val == .KnownValue;
}
pub fn linkToParent(self: *Inst, parent: *Inst) void {
@@ -445,8 +444,8 @@ pub const Inst = struct {
.child_type = elem_type,
.mut = self.params.mut,
.vol = self.params.volatility,
- .size = Type.Pointer.Size.One,
- .alignment = Type.Pointer.Align.Abi,
+ .size = .One,
+ .alignment = .Abi,
});
// TODO: potentially set the hint that this is a stack pointer. But it might not be - this
// could be a ref of a global, for example
@@ -479,20 +478,20 @@ pub const Inst = struct {
else => return error.SemanticAnalysisFailed,
};
switch (self.params.decl.id) {
- Decl.Id.CompTime => unreachable,
- Decl.Id.Var => return error.Unimplemented,
- Decl.Id.Fn => {
+ .CompTime => unreachable,
+ .Var => return error.Unimplemented,
+ .Fn => {
const fn_decl = @fieldParentPtr(Decl.Fn, "base", self.params.decl);
const decl_val = switch (fn_decl.value) {
- Decl.Fn.Val.Unresolved => unreachable,
- Decl.Fn.Val.Fn => |fn_val| &fn_val.base,
- Decl.Fn.Val.FnProto => |fn_proto| &fn_proto.base,
+ .Unresolved => unreachable,
+ .Fn => |fn_val| &fn_val.base,
+ .FnProto => |fn_proto| &fn_proto.base,
};
switch (self.params.lval) {
- LVal.None => {
+ .None => {
return ira.irb.buildConstValue(self.base.scope, self.base.span, decl_val);
},
- LVal.Ptr => return error.Unimplemented,
+ .Ptr => return error.Unimplemented,
}
},
}
@@ -519,20 +518,20 @@ pub const Inst = struct {
pub async fn analyze(self: *const VarPtr, ira: *Analyze) !*Inst {
switch (self.params.var_scope.data) {
- Scope.Var.Data.Const => @panic("TODO"),
- Scope.Var.Data.Param => |param| {
+ .Const => @panic("TODO"),
+ .Param => |param| {
const new_inst = try ira.irb.build(
- Inst.VarPtr,
+ .VarPtr,
self.base.scope,
self.base.span,
Inst.VarPtr.Params{ .var_scope = self.params.var_scope },
);
const ptr_type = try Type.Pointer.get(ira.irb.comp, Type.Pointer.Key{
.child_type = param.typ,
- .mut = Type.Pointer.Mut.Const,
- .vol = Type.Pointer.Vol.Non,
- .size = Type.Pointer.Size.One,
- .alignment = Type.Pointer.Align.Abi,
+ .mut = .Const,
+ .vol = .Non,
+ .size = .One,
+ .alignment = .Abi,
});
new_inst.val = IrVal{ .KnownType = &ptr_type.base };
return new_inst;
@@ -542,8 +541,8 @@ pub const Inst = struct {
pub fn render(self: *VarPtr, ofile: *ObjectFile, fn_val: *Value.Fn) *llvm.Value {
switch (self.params.var_scope.data) {
- Scope.Var.Data.Const => unreachable, // turned into Inst.Const in analyze pass
- Scope.Var.Data.Param => |param| return param.llvm_value,
+ .Const => unreachable, // turned into Inst.Const in analyze pass
+ .Param => |param| return param.llvm_value,
}
}
};
@@ -567,7 +566,7 @@ pub const Inst = struct {
pub async fn analyze(self: *const LoadPtr, ira: *Analyze) !*Inst {
const target = try self.params.target.getAsParam();
const target_type = target.getKnownType();
- if (target_type.id != Type.Id.Pointer) {
+ if (target_type.id != .Pointer) {
try ira.addCompileError(self.base.span, "dereference of non pointer type '{}'", target_type.name);
return error.SemanticAnalysisFailed;
}
@@ -715,7 +714,7 @@ pub const Inst = struct {
pub fn analyze(self: *const CheckVoidStmt, ira: *Analyze) !*Inst {
const target = try self.params.target.getAsParam();
- if (target.getKnownType().id != Type.Id.Void) {
+ if (target.getKnownType().id != .Void) {
try ira.addCompileError(self.base.span, "expression value is ignored");
return error.SemanticAnalysisFailed;
}
@@ -838,7 +837,7 @@ pub const Inst = struct {
const target = try self.params.target.getAsParam();
const target_type = target.getKnownType();
switch (target_type.id) {
- Type.Id.ErrorUnion => {
+ .ErrorUnion => {
return error.Unimplemented;
// if (instr_is_comptime(value)) {
// ConstExprValue *err_union_val = ir_resolve_const(ira, value, UndefBad);
@@ -868,7 +867,7 @@ pub const Inst = struct {
// ir_build_test_err_from(&ira->new_irb, &instruction->base, value);
// return ira->codegen->builtin_types.entry_bool;
},
- Type.Id.ErrorSet => {
+ .ErrorSet => {
return ira.irb.buildConstBool(self.base.scope, self.base.span, true);
},
else => {
@@ -1081,120 +1080,120 @@ pub const Builder = struct {
pub async fn genNode(irb: *Builder, node: *ast.Node, scope: *Scope, lval: LVal) Error!*Inst {
switch (node.id) {
- ast.Node.Id.Root => unreachable,
- ast.Node.Id.Use => unreachable,
- ast.Node.Id.TestDecl => unreachable,
- ast.Node.Id.VarDecl => return error.Unimplemented,
- ast.Node.Id.Defer => return error.Unimplemented,
- ast.Node.Id.InfixOp => return error.Unimplemented,
- ast.Node.Id.PrefixOp => {
+ .Root => unreachable,
+ .Use => unreachable,
+ .TestDecl => unreachable,
+ .VarDecl => return error.Unimplemented,
+ .Defer => return error.Unimplemented,
+ .InfixOp => return error.Unimplemented,
+ .PrefixOp => {
const prefix_op = @fieldParentPtr(ast.Node.PrefixOp, "base", node);
switch (prefix_op.op) {
- ast.Node.PrefixOp.Op.AddressOf => return error.Unimplemented,
- ast.Node.PrefixOp.Op.ArrayType => |n| return error.Unimplemented,
- ast.Node.PrefixOp.Op.Await => return error.Unimplemented,
- ast.Node.PrefixOp.Op.BitNot => return error.Unimplemented,
- ast.Node.PrefixOp.Op.BoolNot => return error.Unimplemented,
- ast.Node.PrefixOp.Op.Cancel => return error.Unimplemented,
- ast.Node.PrefixOp.Op.OptionalType => return error.Unimplemented,
- ast.Node.PrefixOp.Op.Negation => return error.Unimplemented,
- ast.Node.PrefixOp.Op.NegationWrap => return error.Unimplemented,
- ast.Node.PrefixOp.Op.Resume => return error.Unimplemented,
- ast.Node.PrefixOp.Op.PtrType => |ptr_info| {
+ .AddressOf => return error.Unimplemented,
+ .ArrayType => |n| return error.Unimplemented,
+ .Await => return error.Unimplemented,
+ .BitNot => return error.Unimplemented,
+ .BoolNot => return error.Unimplemented,
+ .Cancel => return error.Unimplemented,
+ .OptionalType => return error.Unimplemented,
+ .Negation => return error.Unimplemented,
+ .NegationWrap => return error.Unimplemented,
+ .Resume => return error.Unimplemented,
+ .PtrType => |ptr_info| {
const inst = try irb.genPtrType(prefix_op, ptr_info, scope);
return irb.lvalWrap(scope, inst, lval);
},
- ast.Node.PrefixOp.Op.SliceType => |ptr_info| return error.Unimplemented,
- ast.Node.PrefixOp.Op.Try => return error.Unimplemented,
+ .SliceType => |ptr_info| return error.Unimplemented,
+ .Try => return error.Unimplemented,
}
},
- ast.Node.Id.SuffixOp => {
+ .SuffixOp => {
const suffix_op = @fieldParentPtr(ast.Node.SuffixOp, "base", node);
switch (suffix_op.op) {
- @TagType(ast.Node.SuffixOp.Op).Call => |*call| {
+ .Call => |*call| {
const inst = try irb.genCall(suffix_op, call, scope);
return irb.lvalWrap(scope, inst, lval);
},
- @TagType(ast.Node.SuffixOp.Op).ArrayAccess => |n| return error.Unimplemented,
- @TagType(ast.Node.SuffixOp.Op).Slice => |slice| return error.Unimplemented,
- @TagType(ast.Node.SuffixOp.Op).ArrayInitializer => |init_list| return error.Unimplemented,
- @TagType(ast.Node.SuffixOp.Op).StructInitializer => |init_list| return error.Unimplemented,
- @TagType(ast.Node.SuffixOp.Op).Deref => return error.Unimplemented,
- @TagType(ast.Node.SuffixOp.Op).UnwrapOptional => return error.Unimplemented,
+ .ArrayAccess => |n| return error.Unimplemented,
+ .Slice => |slice| return error.Unimplemented,
+ .ArrayInitializer => |init_list| return error.Unimplemented,
+ .StructInitializer => |init_list| return error.Unimplemented,
+ .Deref => return error.Unimplemented,
+ .UnwrapOptional => return error.Unimplemented,
}
},
- ast.Node.Id.Switch => return error.Unimplemented,
- ast.Node.Id.While => return error.Unimplemented,
- ast.Node.Id.For => return error.Unimplemented,
- ast.Node.Id.If => return error.Unimplemented,
- ast.Node.Id.ControlFlowExpression => {
+ .Switch => return error.Unimplemented,
+ .While => return error.Unimplemented,
+ .For => return error.Unimplemented,
+ .If => return error.Unimplemented,
+ .ControlFlowExpression => {
const control_flow_expr = @fieldParentPtr(ast.Node.ControlFlowExpression, "base", node);
return irb.genControlFlowExpr(control_flow_expr, scope, lval);
},
- ast.Node.Id.Suspend => return error.Unimplemented,
- ast.Node.Id.VarType => return error.Unimplemented,
- ast.Node.Id.ErrorType => return error.Unimplemented,
- ast.Node.Id.FnProto => return error.Unimplemented,
- ast.Node.Id.PromiseType => return error.Unimplemented,
- ast.Node.Id.IntegerLiteral => {
+ .Suspend => return error.Unimplemented,
+ .VarType => return error.Unimplemented,
+ .ErrorType => return error.Unimplemented,
+ .FnProto => return error.Unimplemented,
+ .PromiseType => return error.Unimplemented,
+ .IntegerLiteral => {
const int_lit = @fieldParentPtr(ast.Node.IntegerLiteral, "base", node);
return irb.lvalWrap(scope, try irb.genIntLit(int_lit, scope), lval);
},
- ast.Node.Id.FloatLiteral => return error.Unimplemented,
- ast.Node.Id.StringLiteral => {
+ .FloatLiteral => return error.Unimplemented,
+ .StringLiteral => {
const str_lit = @fieldParentPtr(ast.Node.StringLiteral, "base", node);
const inst = try irb.genStrLit(str_lit, scope);
return irb.lvalWrap(scope, inst, lval);
},
- ast.Node.Id.MultilineStringLiteral => return error.Unimplemented,
- ast.Node.Id.CharLiteral => return error.Unimplemented,
- ast.Node.Id.BoolLiteral => return error.Unimplemented,
- ast.Node.Id.NullLiteral => return error.Unimplemented,
- ast.Node.Id.UndefinedLiteral => return error.Unimplemented,
- ast.Node.Id.Unreachable => return error.Unimplemented,
- ast.Node.Id.Identifier => {
+ .MultilineStringLiteral => return error.Unimplemented,
+ .CharLiteral => return error.Unimplemented,
+ .BoolLiteral => return error.Unimplemented,
+ .NullLiteral => return error.Unimplemented,
+ .UndefinedLiteral => return error.Unimplemented,
+ .Unreachable => return error.Unimplemented,
+ .Identifier => {
const identifier = @fieldParentPtr(ast.Node.Identifier, "base", node);
return irb.genIdentifier(identifier, scope, lval);
},
- ast.Node.Id.GroupedExpression => {
+ .GroupedExpression => {
const grouped_expr = @fieldParentPtr(ast.Node.GroupedExpression, "base", node);
return irb.genNode(grouped_expr.expr, scope, lval);
},
- ast.Node.Id.BuiltinCall => return error.Unimplemented,
- ast.Node.Id.ErrorSetDecl => return error.Unimplemented,
- ast.Node.Id.ContainerDecl => return error.Unimplemented,
- ast.Node.Id.Asm => return error.Unimplemented,
- ast.Node.Id.Comptime => return error.Unimplemented,
- ast.Node.Id.Block => {
+ .BuiltinCall => return error.Unimplemented,
+ .ErrorSetDecl => return error.Unimplemented,
+ .ContainerDecl => return error.Unimplemented,
+ .Asm => return error.Unimplemented,
+ .Comptime => return error.Unimplemented,
+ .Block => {
const block = @fieldParentPtr(ast.Node.Block, "base", node);
const inst = try irb.genBlock(block, scope);
return irb.lvalWrap(scope, inst, lval);
},
- ast.Node.Id.DocComment => return error.Unimplemented,
- ast.Node.Id.SwitchCase => return error.Unimplemented,
- ast.Node.Id.SwitchElse => return error.Unimplemented,
- ast.Node.Id.Else => return error.Unimplemented,
- ast.Node.Id.Payload => return error.Unimplemented,
- ast.Node.Id.PointerPayload => return error.Unimplemented,
- ast.Node.Id.PointerIndexPayload => return error.Unimplemented,
- ast.Node.Id.ContainerField => return error.Unimplemented,
- ast.Node.Id.ErrorTag => return error.Unimplemented,
- ast.Node.Id.AsmInput => return error.Unimplemented,
- ast.Node.Id.AsmOutput => return error.Unimplemented,
- ast.Node.Id.ParamDecl => return error.Unimplemented,
- ast.Node.Id.FieldInitializer => return error.Unimplemented,
- ast.Node.Id.EnumLiteral => return error.Unimplemented,
+ .DocComment => return error.Unimplemented,
+ .SwitchCase => return error.Unimplemented,
+ .SwitchElse => return error.Unimplemented,
+ .Else => return error.Unimplemented,
+ .Payload => return error.Unimplemented,
+ .PointerPayload => return error.Unimplemented,
+ .PointerIndexPayload => return error.Unimplemented,
+ .ContainerField => return error.Unimplemented,
+ .ErrorTag => return error.Unimplemented,
+ .AsmInput => return error.Unimplemented,
+ .AsmOutput => return error.Unimplemented,
+ .ParamDecl => return error.Unimplemented,
+ .FieldInitializer => return error.Unimplemented,
+ .EnumLiteral => return error.Unimplemented,
}
}
async fn genCall(irb: *Builder, suffix_op: *ast.Node.SuffixOp, call: *ast.Node.SuffixOp.Op.Call, scope: *Scope) !*Inst {
- const fn_ref = try irb.genNode(suffix_op.lhs, scope, LVal.None);
+ const fn_ref = try irb.genNode(suffix_op.lhs, scope, .None);
const args = try irb.arena().alloc(*Inst, call.params.len);
var it = call.params.iterator(0);
var i: usize = 0;
while (it.next()) |arg_node_ptr| : (i += 1) {
- args[i] = try irb.genNode(arg_node_ptr.*, scope, LVal.None);
+ args[i] = try irb.genNode(arg_node_ptr.*, scope, .None);
}
//bool is_async = node->data.fn_call_expr.is_async;
@@ -1239,7 +1238,7 @@ pub const Builder = struct {
//} else {
// align_value = nullptr;
//}
- const child_type = try irb.genNode(prefix_op.rhs, scope, LVal.None);
+ const child_type = try irb.genNode(prefix_op.rhs, scope, .None);
//uint32_t bit_offset_start = 0;
//if (node->data.pointer_type.bit_offset_start != nullptr) {
@@ -1273,9 +1272,9 @@ pub const Builder = struct {
return irb.build(Inst.PtrType, scope, Span.node(&prefix_op.base), Inst.PtrType.Params{
.child_type = child_type,
- .mut = Type.Pointer.Mut.Mut,
- .vol = Type.Pointer.Vol.Non,
- .size = Type.Pointer.Size.Many,
+ .mut = .Mut,
+ .vol = .Non,
+ .size = .Many,
.alignment = null,
});
}
@@ -1287,15 +1286,15 @@ pub const Builder = struct {
var scope = target_scope;
while (true) {
switch (scope.id) {
- Scope.Id.CompTime => return true,
- Scope.Id.FnDef => return false,
- Scope.Id.Decls => unreachable,
- Scope.Id.Root => unreachable,
- Scope.Id.AstTree => unreachable,
- Scope.Id.Block,
- Scope.Id.Defer,
- Scope.Id.DeferExpr,
- Scope.Id.Var,
+ .CompTime => return true,
+ .FnDef => return false,
+ .Decls => unreachable,
+ .Root => unreachable,
+ .AstTree => unreachable,
+ .Block,
+ .Defer,
+ .DeferExpr,
+ .Var,
=> scope = scope.parent.?,
}
}
@@ -1374,8 +1373,8 @@ pub const Builder = struct {
const ptr_val = try Value.Ptr.createArrayElemPtr(
irb.comp,
array_val,
- Type.Pointer.Mut.Const,
- Type.Pointer.Size.Many,
+ .Const,
+ .Many,
0,
);
defer ptr_val.base.deref(irb.comp);
@@ -1438,7 +1437,7 @@ pub const Builder = struct {
child_scope = &defer_child_scope.base;
continue;
}
- const statement_value = try irb.genNode(statement_node, child_scope, LVal.None);
+ const statement_value = try irb.genNode(statement_node, child_scope, .None);
is_continuation_unreachable = statement_value.isNoReturn();
if (is_continuation_unreachable) {
@@ -1481,7 +1480,7 @@ pub const Builder = struct {
try block_scope.incoming_values.append(
try irb.buildConstVoid(parent_scope, Span.token(block.rbrace), true),
);
- _ = try irb.genDefersForBlock(child_scope, outer_block_scope, Scope.Defer.Kind.ScopeExit);
+ _ = try irb.genDefersForBlock(child_scope, outer_block_scope, .ScopeExit);
_ = try irb.buildGen(Inst.Br, parent_scope, Span.token(block.rbrace), Inst.Br.Params{
.dest_block = block_scope.end_block,
@@ -1496,7 +1495,7 @@ pub const Builder = struct {
});
}
- _ = try irb.genDefersForBlock(child_scope, outer_block_scope, Scope.Defer.Kind.ScopeExit);
+ _ = try irb.genDefersForBlock(child_scope, outer_block_scope, .ScopeExit);
return irb.buildConstVoid(child_scope, Span.token(block.rbrace), true);
}
@@ -1507,9 +1506,9 @@ pub const Builder = struct {
lval: LVal,
) !*Inst {
switch (control_flow_expr.kind) {
- ast.Node.ControlFlowExpression.Kind.Break => |arg| return error.Unimplemented,
- ast.Node.ControlFlowExpression.Kind.Continue => |arg| return error.Unimplemented,
- ast.Node.ControlFlowExpression.Kind.Return => {
+ .Break => |arg| return error.Unimplemented,
+ .Continue => |arg| return error.Unimplemented,
+ .Return => {
const src_span = Span.token(control_flow_expr.ltoken);
if (scope.findFnDef() == null) {
try irb.comp.addCompileError(
@@ -1534,7 +1533,7 @@ pub const Builder = struct {
const outer_scope = irb.begin_scope.?;
const return_value = if (control_flow_expr.rhs) |rhs| blk: {
- break :blk try irb.genNode(rhs, scope, LVal.None);
+ break :blk try irb.genNode(rhs, scope, .None);
} else blk: {
break :blk try irb.buildConstVoid(scope, src_span, true);
};
@@ -1545,7 +1544,7 @@ pub const Builder = struct {
const err_block = try irb.createBasicBlock(scope, c"ErrRetErr");
const ok_block = try irb.createBasicBlock(scope, c"ErrRetOk");
if (!have_err_defers) {
- _ = try irb.genDefersForBlock(scope, outer_scope, Scope.Defer.Kind.ScopeExit);
+ _ = try irb.genDefersForBlock(scope, outer_scope, .ScopeExit);
}
const is_err = try irb.build(
@@ -1568,7 +1567,7 @@ pub const Builder = struct {
try irb.setCursorAtEndAndAppendBlock(err_block);
if (have_err_defers) {
- _ = try irb.genDefersForBlock(scope, outer_scope, Scope.Defer.Kind.ErrorExit);
+ _ = try irb.genDefersForBlock(scope, outer_scope, .ErrorExit);
}
if (irb.comp.have_err_ret_tracing and !irb.isCompTime(scope)) {
_ = try irb.build(Inst.SaveErrRetAddr, scope, src_span, Inst.SaveErrRetAddr.Params{});
@@ -1580,7 +1579,7 @@ pub const Builder = struct {
try irb.setCursorAtEndAndAppendBlock(ok_block);
if (have_err_defers) {
- _ = try irb.genDefersForBlock(scope, outer_scope, Scope.Defer.Kind.ScopeExit);
+ _ = try irb.genDefersForBlock(scope, outer_scope, .ScopeExit);
}
_ = try irb.build(Inst.Br, scope, src_span, Inst.Br.Params{
.dest_block = ret_stmt_block,
@@ -1590,7 +1589,7 @@ pub const Builder = struct {
try irb.setCursorAtEndAndAppendBlock(ret_stmt_block);
return irb.genAsyncReturn(scope, src_span, return_value, false);
} else {
- _ = try irb.genDefersForBlock(scope, outer_scope, Scope.Defer.Kind.ScopeExit);
+ _ = try irb.genDefersForBlock(scope, outer_scope, .ScopeExit);
return irb.genAsyncReturn(scope, src_span, return_value, false);
}
},
@@ -1616,8 +1615,8 @@ pub const Builder = struct {
switch (lval) {
// if (lval == LValPtr) {
// return ir_build_ref(irb, scope, node, value, false, false);
- LVal.Ptr => return error.Unimplemented,
- LVal.None => return irb.buildConstValue(scope, src_span, &primitive_type.base),
+ .Ptr => return error.Unimplemented,
+ .None => return irb.buildConstValue(scope, src_span, &primitive_type.base),
}
}
} else |err| switch (err) {
@@ -1629,22 +1628,22 @@ pub const Builder = struct {
}
switch (irb.findIdent(scope, name)) {
- Ident.Decl => |decl| {
+ .Decl => |decl| {
return irb.build(Inst.DeclRef, scope, src_span, Inst.DeclRef.Params{
.decl = decl,
.lval = lval,
});
},
- Ident.VarScope => |var_scope| {
+ .VarScope => |var_scope| {
const var_ptr = try irb.build(Inst.VarPtr, scope, src_span, Inst.VarPtr.Params{ .var_scope = var_scope });
switch (lval) {
- LVal.Ptr => return var_ptr,
- LVal.None => {
+ .Ptr => return var_ptr,
+ .None => {
return irb.build(Inst.LoadPtr, scope, src_span, Inst.LoadPtr.Params{ .target = var_ptr });
},
}
},
- Ident.NotFound => {},
+ .NotFound => {},
}
//if (node->owner->any_imports_failed) {
@@ -1671,25 +1670,25 @@ pub const Builder = struct {
var scope = inner_scope;
while (scope != outer_scope) {
switch (scope.id) {
- Scope.Id.Defer => {
+ .Defer => {
const defer_scope = @fieldParentPtr(Scope.Defer, "base", scope);
switch (defer_scope.kind) {
- Scope.Defer.Kind.ScopeExit => result.scope_exit += 1,
- Scope.Defer.Kind.ErrorExit => result.error_exit += 1,
+ .ScopeExit => result.scope_exit += 1,
+ .ErrorExit => result.error_exit += 1,
}
scope = scope.parent orelse break;
},
- Scope.Id.FnDef => break,
+ .FnDef => break,
- Scope.Id.CompTime,
- Scope.Id.Block,
- Scope.Id.Decls,
- Scope.Id.Root,
- Scope.Id.Var,
+ .CompTime,
+ .Block,
+ .Decls,
+ .Root,
+ .Var,
=> scope = scope.parent orelse break,
- Scope.Id.DeferExpr => unreachable,
- Scope.Id.AstTree => unreachable,
+ .DeferExpr => unreachable,
+ .AstTree => unreachable,
}
}
return result;
@@ -1705,18 +1704,18 @@ pub const Builder = struct {
var is_noreturn = false;
while (true) {
switch (scope.id) {
- Scope.Id.Defer => {
+ .Defer => {
const defer_scope = @fieldParentPtr(Scope.Defer, "base", scope);
const generate = switch (defer_scope.kind) {
- Scope.Defer.Kind.ScopeExit => true,
- Scope.Defer.Kind.ErrorExit => gen_kind == Scope.Defer.Kind.ErrorExit,
+ .ScopeExit => true,
+ .ErrorExit => gen_kind == .ErrorExit,
};
if (generate) {
const defer_expr_scope = defer_scope.defer_expr_scope;
const instruction = try irb.genNode(
defer_expr_scope.expr_node,
&defer_expr_scope.base,
- LVal.None,
+ .None,
);
if (instruction.isNoReturn()) {
is_noreturn = true;
@@ -1730,32 +1729,32 @@ pub const Builder = struct {
}
}
},
- Scope.Id.FnDef,
- Scope.Id.Decls,
- Scope.Id.Root,
+ .FnDef,
+ .Decls,
+ .Root,
=> return is_noreturn,
- Scope.Id.CompTime,
- Scope.Id.Block,
- Scope.Id.Var,
+ .CompTime,
+ .Block,
+ .Var,
=> scope = scope.parent orelse return is_noreturn,
- Scope.Id.DeferExpr => unreachable,
- Scope.Id.AstTree => unreachable,
+ .DeferExpr => unreachable,
+ .AstTree => unreachable,
}
}
}
pub fn lvalWrap(irb: *Builder, scope: *Scope, instruction: *Inst, lval: LVal) !*Inst {
switch (lval) {
- LVal.None => return instruction,
- LVal.Ptr => {
+ .None => return instruction,
+ .Ptr => {
// We needed a pointer to a value, but we got a value. So we create
// an instruction which just makes a const pointer of it.
return irb.build(Inst.Ref, scope, instruction.span, Inst.Ref.Params{
.target = instruction,
- .mut = Type.Pointer.Mut.Const,
- .volatility = Type.Pointer.Vol.Non,
+ .mut = .Const,
+ .volatility = .Non,
});
},
}
@@ -1781,9 +1780,9 @@ pub const Builder = struct {
.scope = scope,
.debug_id = self.next_debug_id,
.val = switch (I.ir_val_init) {
- IrVal.Init.Unknown => IrVal.Unknown,
- IrVal.Init.NoReturn => IrVal{ .KnownValue = &Value.NoReturn.get(self.comp).base },
- IrVal.Init.Void => IrVal{ .KnownValue = &Value.Void.get(self.comp).base },
+ .Unknown => IrVal.Unknown,
+ .NoReturn => IrVal{ .KnownValue = &Value.NoReturn.get(self.comp).base },
+ .Void => IrVal{ .KnownValue = &Value.Void.get(self.comp).base },
},
.ref_count = 0,
.span = span,
@@ -1813,9 +1812,9 @@ pub const Builder = struct {
for (@field(inst.params, @memberName(I.Params, i))) |other|
other.ref(self);
},
- Type.Pointer.Mut,
- Type.Pointer.Vol,
- Type.Pointer.Size,
+ .Mut,
+ .Vol,
+ .Size,
LVal,
*Decl,
*Scope.Var,
@@ -1915,8 +1914,8 @@ pub const Builder = struct {
var s = scope;
while (true) {
switch (s.id) {
- Scope.Id.Root => return Ident.NotFound,
- Scope.Id.Decls => {
+ .Root => return .NotFound,
+ .Decls => {
const decls = @fieldParentPtr(Scope.Decls, "base", s);
const locked_table = decls.table.acquireRead();
defer locked_table.release();
@@ -1924,7 +1923,7 @@ pub const Builder = struct {
return Ident{ .Decl = entry.value };
}
},
- Scope.Id.Var => {
+ .Var => {
const var_scope = @fieldParentPtr(Scope.Var, "base", s);
if (mem.eql(u8, var_scope.name, name)) {
return Ident{ .VarScope = var_scope };
@@ -2047,7 +2046,7 @@ const Analyze = struct {
fn implicitCast(self: *Analyze, target: *Inst, optional_dest_type: ?*Type) Analyze.Error!*Inst {
const dest_type = optional_dest_type orelse return target;
const from_type = target.getKnownType();
- if (from_type == dest_type or from_type.id == Type.Id.NoReturn) return target;
+ if (from_type == dest_type or from_type.id == .NoReturn) return target;
return self.analyzeCast(target, target, dest_type);
}
@@ -2311,7 +2310,7 @@ const Analyze = struct {
//}
// cast from comptime-known integer to another integer where the value fits
- if (target.isCompTime() and (from_type.id == Type.Id.Int or from_type.id == Type.Id.ComptimeInt)) cast: {
+ if (target.isCompTime() and (from_type.id == .Int or from_type.id == .ComptimeInt)) cast: {
const target_val = target.val.KnownValue;
const from_int = &target_val.cast(Value.Int).?.big_int;
const fits = fits: {
@@ -2534,7 +2533,7 @@ pub async fn gen(
entry_block.ref(&irb); // Entry block gets a reference because we enter it to begin.
try irb.setCursorAtEndAndAppendBlock(entry_block);
- const result = try irb.genNode(body_node, scope, LVal.None);
+ const result = try irb.genNode(body_node, scope, .None);
if (!result.isNoReturn()) {
// no need for save_err_ret_addr because this cannot return error
_ = try irb.genAsyncReturn(scope, Span.token(body_node.lastToken()), result, true);
src-self-hosted/libc_installation.zig
@@ -73,7 +73,7 @@ pub const LibCInstallation = struct {
if (std.mem.eql(u8, name, key)) {
found_keys[i].found = true;
switch (@typeInfo(@typeOf(@field(self, key)))) {
- builtin.TypeId.Optional => {
+ .Optional => {
if (value.len == 0) {
@field(self, key) = null;
} else {
@@ -208,7 +208,7 @@ pub const LibCInstallation = struct {
}
switch (exec_result.term) {
- std.ChildProcess.Term.Exited => |code| {
+ .Exited => |code| {
if (code != 0) return error.CCompilerExitCode;
},
else => {
@@ -284,9 +284,9 @@ pub const LibCInstallation = struct {
const stream = &std.io.BufferOutStream.init(&result_buf).stream;
try stream.print("{}\\Lib\\{}\\ucrt\\", search.path, search.version);
switch (builtin.arch) {
- builtin.Arch.i386 => try stream.write("x86"),
- builtin.Arch.x86_64 => try stream.write("x64"),
- builtin.Arch.aarch64 => try stream.write("arm"),
+ .i386 => try stream.write("x86"),
+ .x86_64 => try stream.write("x64"),
+ .aarch64 => try stream.write("arm"),
else => return error.UnsupportedArchitecture,
}
const ucrt_lib_path = try fs.path.join(
@@ -362,9 +362,9 @@ pub const LibCInstallation = struct {
const stream = &std.io.BufferOutStream.init(&result_buf).stream;
try stream.print("{}\\Lib\\{}\\um\\", search.path, search.version);
switch (builtin.arch) {
- builtin.Arch.i386 => try stream.write("x86\\"),
- builtin.Arch.x86_64 => try stream.write("x64\\"),
- builtin.Arch.aarch64 => try stream.write("arm\\"),
+ .i386 => try stream.write("x86\\"),
+ .x86_64 => try stream.write("x64\\"),
+ .aarch64 => try stream.write("arm\\"),
else => return error.UnsupportedArchitecture,
}
const kernel32_path = try fs.path.join(
src-self-hosted/link.zig
@@ -1,10 +1,9 @@
const std = @import("std");
const mem = std.mem;
const c = @import("c.zig");
-const builtin = @import("builtin");
-const ObjectFormat = builtin.ObjectFormat;
const Compilation = @import("compilation.zig").Compilation;
const Target = std.Target;
+const ObjectFormat = Target.ObjectFormat;
const LibCInstallation = @import("libc_installation.zig").LibCInstallation;
const assert = std.debug.assert;
@@ -26,7 +25,7 @@ pub async fn link(comp: *Compilation) !void {
.comp = comp,
.arena = std.heap.ArenaAllocator.init(comp.gpa()),
.args = undefined,
- .link_in_crt = comp.haveLibC() and comp.kind == Compilation.Kind.Exe,
+ .link_in_crt = comp.haveLibC() and comp.kind == .Exe,
.link_err = {},
.link_msg = undefined,
.libc = undefined,
@@ -41,13 +40,13 @@ pub async fn link(comp: *Compilation) !void {
} else {
ctx.out_file_path = try std.Buffer.init(&ctx.arena.allocator, comp.name.toSliceConst());
switch (comp.kind) {
- Compilation.Kind.Exe => {
+ .Exe => {
try ctx.out_file_path.append(comp.target.exeFileExt());
},
- Compilation.Kind.Lib => {
+ .Lib => {
try ctx.out_file_path.append(comp.target.libFileExt(comp.is_static));
},
- Compilation.Kind.Obj => {
+ .Obj => {
try ctx.out_file_path.append(comp.target.objFileExt());
},
}
@@ -121,21 +120,21 @@ fn linkDiagCallbackErrorable(ctx: *Context, msg: []const u8) !void {
fn toExternObjectFormatType(ofmt: ObjectFormat) c.ZigLLVM_ObjectFormatType {
return switch (ofmt) {
- ObjectFormat.unknown => c.ZigLLVM_UnknownObjectFormat,
- ObjectFormat.coff => c.ZigLLVM_COFF,
- ObjectFormat.elf => c.ZigLLVM_ELF,
- ObjectFormat.macho => c.ZigLLVM_MachO,
- ObjectFormat.wasm => c.ZigLLVM_Wasm,
+ .unknown => c.ZigLLVM_UnknownObjectFormat,
+ .coff => c.ZigLLVM_COFF,
+ .elf => c.ZigLLVM_ELF,
+ .macho => c.ZigLLVM_MachO,
+ .wasm => c.ZigLLVM_Wasm,
};
}
fn constructLinkerArgs(ctx: *Context) !void {
switch (ctx.comp.target.getObjectFormat()) {
- ObjectFormat.unknown => unreachable,
- ObjectFormat.coff => return constructLinkerArgsCoff(ctx),
- ObjectFormat.elf => return constructLinkerArgsElf(ctx),
- ObjectFormat.macho => return constructLinkerArgsMachO(ctx),
- ObjectFormat.wasm => return constructLinkerArgsWasm(ctx),
+ .unknown => unreachable,
+ .coff => return constructLinkerArgsCoff(ctx),
+ .elf => return constructLinkerArgsElf(ctx),
+ .macho => return constructLinkerArgsMachO(ctx),
+ .wasm => return constructLinkerArgsWasm(ctx),
}
}
@@ -324,9 +323,9 @@ fn constructLinkerArgsCoff(ctx: *Context) !void {
}
switch (ctx.comp.target.getArch()) {
- builtin.Arch.i386 => try ctx.args.append(c"-MACHINE:X86"),
- builtin.Arch.x86_64 => try ctx.args.append(c"-MACHINE:X64"),
- builtin.Arch.aarch64 => try ctx.args.append(c"-MACHINE:ARM"),
+ .i386 => try ctx.args.append(c"-MACHINE:X86"),
+ .x86_64 => try ctx.args.append(c"-MACHINE:X64"),
+ .aarch64 => try ctx.args.append(c"-MACHINE:ARM"),
else => return error.UnsupportedLinkArchitecture,
}
@@ -336,7 +335,7 @@ fn constructLinkerArgsCoff(ctx: *Context) !void {
try ctx.args.append(c"/SUBSYSTEM:console");
}
- const is_library = ctx.comp.kind == Compilation.Kind.Lib;
+ const is_library = ctx.comp.kind == .Lib;
const out_arg = try std.fmt.allocPrint(&ctx.arena.allocator, "-OUT:{}\x00", ctx.out_file_path.toSliceConst());
try ctx.args.append(out_arg.ptr);
@@ -349,7 +348,7 @@ fn constructLinkerArgsCoff(ctx: *Context) !void {
if (ctx.link_in_crt) {
const lib_str = if (ctx.comp.is_static) "lib" else "";
- const d_str = if (ctx.comp.build_mode == builtin.Mode.Debug) "d" else "";
+ const d_str = if (ctx.comp.build_mode == .Debug) "d" else "";
if (ctx.comp.is_static) {
const cmt_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "libcmt{}.lib\x00", d_str);
@@ -400,7 +399,7 @@ fn constructLinkerArgsCoff(ctx: *Context) !void {
try addFnObjects(ctx);
switch (ctx.comp.kind) {
- Compilation.Kind.Exe, Compilation.Kind.Lib => {
+ .Exe, .Lib => {
if (!ctx.comp.haveLibC()) {
@panic("TODO");
//Buf *builtin_o_path = build_o(g, "builtin");
@@ -412,7 +411,7 @@ fn constructLinkerArgsCoff(ctx: *Context) !void {
//Buf *compiler_rt_o_path = build_compiler_rt(g);
//lj->args.append(buf_ptr(compiler_rt_o_path));
},
- Compilation.Kind.Obj => {},
+ .Obj => {},
}
//Buf *def_contents = buf_alloc();
@@ -469,7 +468,7 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
try ctx.args.append(c"-export_dynamic");
}
- const is_lib = ctx.comp.kind == Compilation.Kind.Lib;
+ const is_lib = ctx.comp.kind == .Lib;
const shared = !ctx.comp.is_static and is_lib;
if (ctx.comp.is_static) {
try ctx.args.append(c"-static");
@@ -512,14 +511,14 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
const platform = try DarwinPlatform.get(ctx.comp);
switch (platform.kind) {
- DarwinPlatform.Kind.MacOS => try ctx.args.append(c"-macosx_version_min"),
- DarwinPlatform.Kind.IPhoneOS => try ctx.args.append(c"-iphoneos_version_min"),
- DarwinPlatform.Kind.IPhoneOSSimulator => try ctx.args.append(c"-ios_simulator_version_min"),
+ .MacOS => try ctx.args.append(c"-macosx_version_min"),
+ .IPhoneOS => try ctx.args.append(c"-iphoneos_version_min"),
+ .IPhoneOSSimulator => try ctx.args.append(c"-ios_simulator_version_min"),
}
const ver_str = try std.fmt.allocPrint(&ctx.arena.allocator, "{}.{}.{}\x00", platform.major, platform.minor, platform.micro);
try ctx.args.append(ver_str.ptr);
- if (ctx.comp.kind == Compilation.Kind.Exe) {
+ if (ctx.comp.kind == .Exe) {
if (ctx.comp.is_static) {
try ctx.args.append(c"-no_pie");
} else {
@@ -542,7 +541,7 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
try ctx.args.append(c"-lcrt0.o");
} else {
switch (platform.kind) {
- DarwinPlatform.Kind.MacOS => {
+ .MacOS => {
if (platform.versionLessThan(10, 5)) {
try ctx.args.append(c"-lcrt1.o");
} else if (platform.versionLessThan(10, 6)) {
@@ -551,8 +550,8 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
try ctx.args.append(c"-lcrt1.10.6.o");
}
},
- DarwinPlatform.Kind.IPhoneOS => {
- if (ctx.comp.target.getArch() == builtin.Arch.aarch64) {
+ .IPhoneOS => {
+ if (ctx.comp.target.getArch() == .aarch64) {
// iOS does not need any crt1 files for arm64
} else if (platform.versionLessThan(3, 1)) {
try ctx.args.append(c"-lcrt1.o");
@@ -560,7 +559,7 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
try ctx.args.append(c"-lcrt1.3.1.o");
}
},
- DarwinPlatform.Kind.IPhoneOSSimulator => {}, // no crt1.o needed
+ .IPhoneOSSimulator => {}, // no crt1.o needed
}
}
@@ -605,7 +604,7 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
try ctx.args.append(c"dynamic_lookup");
}
- if (platform.kind == DarwinPlatform.Kind.MacOS) {
+ if (platform.kind == .MacOS) {
if (platform.versionLessThan(10, 5)) {
try ctx.args.append(c"-lgcc_s.10.4");
} else if (platform.versionLessThan(10, 6)) {
@@ -659,17 +658,17 @@ const DarwinPlatform = struct {
fn get(comp: *Compilation) !DarwinPlatform {
var result: DarwinPlatform = undefined;
const ver_str = switch (comp.darwin_version_min) {
- Compilation.DarwinVersionMin.MacOS => |ver| blk: {
- result.kind = Kind.MacOS;
+ .MacOS => |ver| blk: {
+ result.kind = .MacOS;
break :blk ver;
},
- Compilation.DarwinVersionMin.Ios => |ver| blk: {
- result.kind = Kind.IPhoneOS;
+ .Ios => |ver| blk: {
+ result.kind = .IPhoneOS;
break :blk ver;
},
- Compilation.DarwinVersionMin.None => blk: {
+ .None => blk: {
assert(comp.target.getOs() == .macosx);
- result.kind = Kind.MacOS;
+ result.kind = .MacOS;
break :blk "10.14";
},
};
@@ -686,11 +685,11 @@ const DarwinPlatform = struct {
return error.InvalidDarwinVersionString;
}
- if (result.kind == Kind.IPhoneOS) {
+ if (result.kind == .IPhoneOS) {
switch (comp.target.getArch()) {
- builtin.Arch.i386,
- builtin.Arch.x86_64,
- => result.kind = Kind.IPhoneOSSimulator,
+ .i386,
+ .x86_64,
+ => result.kind = .IPhoneOSSimulator,
else => {},
}
}
src-self-hosted/llvm.zig
@@ -1,4 +1,3 @@
-const builtin = @import("builtin");
const c = @import("c.zig");
const std = @import("std");
const assert = std.debug.assert;
@@ -269,7 +268,7 @@ pub const FnInline = extern enum {
};
fn removeNullability(comptime T: type) type {
- comptime assert(@typeInfo(T).Pointer.size == @import("builtin").TypeInfo.Pointer.Size.C);
+ comptime assert(@typeInfo(T).Pointer.size == .C);
return *T.Child;
}
src-self-hosted/main.zig
@@ -266,16 +266,16 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
const build_mode = blk: {
if (flags.single("mode")) |mode_flag| {
if (mem.eql(u8, mode_flag, "debug")) {
- break :blk builtin.Mode.Debug;
+ break :blk std.builtin.Mode.Debug;
} else if (mem.eql(u8, mode_flag, "release-fast")) {
- break :blk builtin.Mode.ReleaseFast;
+ break :blk std.builtin.Mode.ReleaseFast;
} else if (mem.eql(u8, mode_flag, "release-safe")) {
- break :blk builtin.Mode.ReleaseSafe;
+ break :blk std.builtin.Mode.ReleaseSafe;
} else if (mem.eql(u8, mode_flag, "release-small")) {
- break :blk builtin.Mode.ReleaseSmall;
+ break :blk std.builtin.Mode.ReleaseSmall;
} else unreachable;
} else {
- break :blk builtin.Mode.Debug;
+ break :blk std.builtin.Mode.Debug;
}
};
@@ -475,13 +475,13 @@ async fn processBuildEvents(comp: *Compilation, color: errmsg.Color) void {
count += 1;
switch (build_event) {
- Compilation.Event.Ok => {
+ .Ok => {
stderr.print("Build {} succeeded\n", count) catch process.exit(1);
},
- Compilation.Event.Error => |err| {
+ .Error => |err| {
stderr.print("Build {} failed: {}\n", count, @errorName(err)) catch process.exit(1);
},
- Compilation.Event.Fail => |msgs| {
+ .Fail => |msgs| {
stderr.print("Build {} compile errors:\n", count) catch process.exit(1);
for (msgs) |msg| {
defer msg.destroy();
@@ -795,8 +795,8 @@ fn cmdTargets(allocator: *Allocator, args: []const []const u8) !void {
try stdout.write("Operating Systems:\n");
{
comptime var i: usize = 0;
- inline while (i < @memberCount(builtin.Os)) : (i += 1) {
- comptime const os_tag = @memberName(builtin.Os, i);
+ inline while (i < @memberCount(Target.Os)) : (i += 1) {
+ comptime const os_tag = @memberName(Target.Os, i);
// NOTE: Cannot use empty string, see #918.
comptime const native_str = if (comptime mem.eql(u8, os_tag, @tagName(builtin.os))) " (native)\n" else "\n";
@@ -808,8 +808,8 @@ fn cmdTargets(allocator: *Allocator, args: []const []const u8) !void {
try stdout.write("C ABIs:\n");
{
comptime var i: usize = 0;
- inline while (i < @memberCount(builtin.Abi)) : (i += 1) {
- comptime const abi_tag = @memberName(builtin.Abi, i);
+ inline while (i < @memberCount(Target.Abi)) : (i += 1) {
+ comptime const abi_tag = @memberName(Target.Abi, i);
// NOTE: Cannot use empty string, see #918.
comptime const native_str = if (comptime mem.eql(u8, abi_tag, @tagName(builtin.abi))) " (native)\n" else "\n";
src-self-hosted/scope.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = @import("builtin");
const Allocator = mem.Allocator;
const Decl = @import("decl.zig").Decl;
const Compilation = @import("compilation.zig").Compilation;
@@ -28,15 +27,15 @@ pub const Scope = struct {
if (base.ref_count.decr() == 1) {
if (base.parent) |parent| parent.deref(comp);
switch (base.id) {
- Id.Root => @fieldParentPtr(Root, "base", base).destroy(comp),
- Id.Decls => @fieldParentPtr(Decls, "base", base).destroy(comp),
- Id.Block => @fieldParentPtr(Block, "base", base).destroy(comp),
- Id.FnDef => @fieldParentPtr(FnDef, "base", base).destroy(comp),
- Id.CompTime => @fieldParentPtr(CompTime, "base", base).destroy(comp),
- Id.Defer => @fieldParentPtr(Defer, "base", base).destroy(comp),
- Id.DeferExpr => @fieldParentPtr(DeferExpr, "base", base).destroy(comp),
- Id.Var => @fieldParentPtr(Var, "base", base).destroy(comp),
- Id.AstTree => @fieldParentPtr(AstTree, "base", base).destroy(comp),
+ .Root => @fieldParentPtr(Root, "base", base).destroy(comp),
+ .Decls => @fieldParentPtr(Decls, "base", base).destroy(comp),
+ .Block => @fieldParentPtr(Block, "base", base).destroy(comp),
+ .FnDef => @fieldParentPtr(FnDef, "base", base).destroy(comp),
+ .CompTime => @fieldParentPtr(CompTime, "base", base).destroy(comp),
+ .Defer => @fieldParentPtr(Defer, "base", base).destroy(comp),
+ .DeferExpr => @fieldParentPtr(DeferExpr, "base", base).destroy(comp),
+ .Var => @fieldParentPtr(Var, "base", base).destroy(comp),
+ .AstTree => @fieldParentPtr(AstTree, "base", base).destroy(comp),
}
}
}
@@ -46,7 +45,7 @@ pub const Scope = struct {
while (scope.parent) |parent| {
scope = parent;
}
- assert(scope.id == Id.Root);
+ assert(scope.id == .Root);
return @fieldParentPtr(Root, "base", scope);
}
@@ -54,17 +53,17 @@ pub const Scope = struct {
var scope = base;
while (true) {
switch (scope.id) {
- Id.FnDef => return @fieldParentPtr(FnDef, "base", scope),
- Id.Root, Id.Decls => return null,
-
- Id.Block,
- Id.Defer,
- Id.DeferExpr,
- Id.CompTime,
- Id.Var,
+ .FnDef => return @fieldParentPtr(FnDef, "base", scope),
+ .Root, .Decls => return null,
+
+ .Block,
+ .Defer,
+ .DeferExpr,
+ .CompTime,
+ .Var,
=> scope = scope.parent.?,
- Id.AstTree => unreachable,
+ .AstTree => unreachable,
}
}
}
@@ -73,20 +72,20 @@ pub const Scope = struct {
var scope = base;
while (true) {
switch (scope.id) {
- Id.DeferExpr => return @fieldParentPtr(DeferExpr, "base", scope),
+ .DeferExpr => return @fieldParentPtr(DeferExpr, "base", scope),
- Id.FnDef,
- Id.Decls,
+ .FnDef,
+ .Decls,
=> return null,
- Id.Block,
- Id.Defer,
- Id.CompTime,
- Id.Root,
- Id.Var,
+ .Block,
+ .Defer,
+ .CompTime,
+ .Root,
+ .Var,
=> scope = scope.parent orelse return null,
- Id.AstTree => unreachable,
+ .AstTree => unreachable,
}
}
}
@@ -123,7 +122,7 @@ pub const Scope = struct {
const self = try comp.gpa().create(Root);
self.* = Root{
.base = Scope{
- .id = Id.Root,
+ .id = .Root,
.parent = null,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -155,7 +154,7 @@ pub const Scope = struct {
.base = undefined,
.tree = tree,
};
- self.base.init(Id.AstTree, &root_scope.base);
+ self.base.init(.AstTree, &root_scope.base);
return self;
}
@@ -186,7 +185,7 @@ pub const Scope = struct {
.base = undefined,
.table = event.RwLocked(Decl.Table).init(Decl.Table.init(comp.gpa())),
};
- self.base.init(Id.Decls, parent);
+ self.base.init(.Decls, parent);
return self;
}
@@ -219,15 +218,15 @@ pub const Scope = struct {
fn get(self: Safety, comp: *Compilation) bool {
return switch (self) {
- Safety.Auto => switch (comp.build_mode) {
- builtin.Mode.Debug,
- builtin.Mode.ReleaseSafe,
+ .Auto => switch (comp.build_mode) {
+ .Debug,
+ .ReleaseSafe,
=> true,
- builtin.Mode.ReleaseFast,
- builtin.Mode.ReleaseSmall,
+ .ReleaseFast,
+ .ReleaseSmall,
=> false,
},
- @TagType(Safety).Manual => |man| man.enabled,
+ .Manual => |man| man.enabled,
};
}
};
@@ -243,7 +242,7 @@ pub const Scope = struct {
.is_comptime = undefined,
.safety = Safety.Auto,
};
- self.base.init(Id.Block, parent);
+ self.base.init(.Block, parent);
return self;
}
@@ -266,7 +265,7 @@ pub const Scope = struct {
.base = undefined,
.fn_val = null,
};
- self.base.init(Id.FnDef, parent);
+ self.base.init(.FnDef, parent);
return self;
}
@@ -282,7 +281,7 @@ pub const Scope = struct {
pub fn create(comp: *Compilation, parent: *Scope) !*CompTime {
const self = try comp.gpa().create(CompTime);
self.* = CompTime{ .base = undefined };
- self.base.init(Id.CompTime, parent);
+ self.base.init(.CompTime, parent);
return self;
}
@@ -314,7 +313,7 @@ pub const Scope = struct {
.defer_expr_scope = defer_expr_scope,
.kind = kind,
};
- self.base.init(Id.Defer, parent);
+ self.base.init(.Defer, parent);
defer_expr_scope.base.ref();
return self;
}
@@ -338,7 +337,7 @@ pub const Scope = struct {
.expr_node = expr_node,
.reported_err = false,
};
- self.base.init(Id.DeferExpr, parent);
+ self.base.init(.DeferExpr, parent);
return self;
}
@@ -404,14 +403,14 @@ pub const Scope = struct {
.src_node = src_node,
.data = undefined,
};
- self.base.init(Id.Var, parent);
+ self.base.init(.Var, parent);
return self;
}
pub fn destroy(self: *Var, comp: *Compilation) void {
switch (self.data) {
- Data.Param => {},
- Data.Const => |value| value.deref(comp),
+ .Param => {},
+ .Const => |value| value.deref(comp),
}
comp.gpa().destroy(self);
}
src-self-hosted/stage1.zig
@@ -1,7 +1,6 @@
// This is Zig code that is used by both stage1 and stage2.
// The prototypes in src/userland.h must match these definitions.
-const builtin = @import("builtin");
const std = @import("std");
const io = std.io;
const mem = std.mem;
@@ -358,9 +357,9 @@ fn printErrMsgToFile(
color: errmsg.Color,
) !void {
const color_on = switch (color) {
- errmsg.Color.Auto => file.isTty(),
- errmsg.Color.On => true,
- errmsg.Color.Off => false,
+ .Auto => file.isTty(),
+ .On => true,
+ .Off => false,
};
const lok_token = parse_error.loc();
const span = errmsg.Span{
@@ -425,8 +424,8 @@ export fn stage2_DepTokenizer_next(self: *stage2_DepTokenizer) stage2_DepNextRes
const textz = std.Buffer.init(&self.handle.arena.allocator, token.bytes) catch @panic("failed to create .d tokenizer token text");
return stage2_DepNextResult{
.type_id = switch (token.id) {
- .target => stage2_DepNextResult.TypeId.target,
- .prereq => stage2_DepNextResult.TypeId.prereq,
+ .target => .target,
+ .prereq => .prereq,
},
.textz = textz.toSlice().ptr,
};
src-self-hosted/test.zig
@@ -1,6 +1,5 @@
const std = @import("std");
const mem = std.mem;
-const builtin = @import("builtin");
const Target = std.Target;
const Compilation = @import("compilation.zig").Compilation;
const introspect = @import("introspect.zig");
@@ -45,7 +44,7 @@ pub const TestContext = struct {
errdefer self.zig_compiler.deinit();
self.group = std.event.Group(anyerror!void).init(allocator);
- errdefer self.group.deinit();
+ errdefer self.group.wait();
self.zig_lib_dir = try introspect.resolveZigLibDir(allocator);
errdefer allocator.free(self.zig_lib_dir);
@@ -95,7 +94,7 @@ pub const TestContext = struct {
file1_path,
Target.Native,
Compilation.Kind.Obj,
- builtin.Mode.Debug,
+ .Debug,
true, // is_static
self.zig_lib_dir,
);
@@ -129,7 +128,7 @@ pub const TestContext = struct {
file1_path,
Target.Native,
Compilation.Kind.Exe,
- builtin.Mode.Debug,
+ .Debug,
false,
self.zig_lib_dir,
);
@@ -154,7 +153,7 @@ pub const TestContext = struct {
const build_event = comp.events.get();
switch (build_event) {
- Compilation.Event.Ok => {
+ .Ok => {
const argv = []const []const u8{exe_file_2};
// TODO use event loop
const child = try std.ChildProcess.exec(allocator, argv, null, null, 1024 * 1024);
@@ -172,8 +171,8 @@ pub const TestContext = struct {
return error.OutputMismatch;
}
},
- Compilation.Event.Error => |err| return err,
- Compilation.Event.Fail => |msgs| {
+ .Error => |err| return err,
+ .Fail => |msgs| {
var stderr = try std.io.getStdErr();
try stderr.write("build incorrectly failed:\n");
for (msgs) |msg| {
@@ -196,13 +195,13 @@ pub const TestContext = struct {
const build_event = comp.events.get();
switch (build_event) {
- Compilation.Event.Ok => {
+ .Ok => {
@panic("build incorrectly succeeded");
},
- Compilation.Event.Error => |err| {
+ .Error => |err| {
@panic("build incorrectly failed");
},
- Compilation.Event.Fail => |msgs| {
+ .Fail => |msgs| {
testing.expect(msgs.len != 0);
for (msgs) |msg| {
if (mem.endsWith(u8, msg.realpath, path) and mem.eql(u8, msg.text, text)) {
src-self-hosted/translate_c.zig
@@ -2,7 +2,6 @@
// and stage2. Currently the only way it is used is with `zig translate-c-2`.
const std = @import("std");
-const builtin = @import("builtin");
const assert = std.debug.assert;
const ast = std.zig.ast;
const Token = std.zig.Token;
@@ -14,7 +13,7 @@ pub const Mode = enum {
};
// TODO merge with Type.Fn.CallingConvention
-const CallingConvention = builtin.TypeInfo.CallingConvention;
+const CallingConvention = std.builtin.TypeInfo.CallingConvention;
pub const ClangErrMsg = Stage2ErrorMsg;
src-self-hosted/type.zig
@@ -1,5 +1,5 @@
const std = @import("std");
-const builtin = @import("builtin");
+const builtin = std.builtin;
const Scope = @import("scope.zig").Scope;
const Compilation = @import("compilation.zig").Compilation;
const Value = @import("value.zig").Value;
@@ -20,32 +20,32 @@ pub const Type = struct {
pub fn destroy(base: *Type, comp: *Compilation) void {
switch (base.id) {
- Id.Struct => @fieldParentPtr(Struct, "base", base).destroy(comp),
- Id.Fn => @fieldParentPtr(Fn, "base", base).destroy(comp),
- Id.Type => @fieldParentPtr(MetaType, "base", base).destroy(comp),
- Id.Void => @fieldParentPtr(Void, "base", base).destroy(comp),
- Id.Bool => @fieldParentPtr(Bool, "base", base).destroy(comp),
- Id.NoReturn => @fieldParentPtr(NoReturn, "base", base).destroy(comp),
- Id.Int => @fieldParentPtr(Int, "base", base).destroy(comp),
- Id.Float => @fieldParentPtr(Float, "base", base).destroy(comp),
- Id.Pointer => @fieldParentPtr(Pointer, "base", base).destroy(comp),
- Id.Array => @fieldParentPtr(Array, "base", base).destroy(comp),
- Id.ComptimeFloat => @fieldParentPtr(ComptimeFloat, "base", base).destroy(comp),
- Id.ComptimeInt => @fieldParentPtr(ComptimeInt, "base", base).destroy(comp),
- Id.EnumLiteral => @fieldParentPtr(EnumLiteral, "base", base).destroy(comp),
- Id.Undefined => @fieldParentPtr(Undefined, "base", base).destroy(comp),
- Id.Null => @fieldParentPtr(Null, "base", base).destroy(comp),
- Id.Optional => @fieldParentPtr(Optional, "base", base).destroy(comp),
- Id.ErrorUnion => @fieldParentPtr(ErrorUnion, "base", base).destroy(comp),
- Id.ErrorSet => @fieldParentPtr(ErrorSet, "base", base).destroy(comp),
- Id.Enum => @fieldParentPtr(Enum, "base", base).destroy(comp),
- Id.Union => @fieldParentPtr(Union, "base", base).destroy(comp),
- Id.BoundFn => @fieldParentPtr(BoundFn, "base", base).destroy(comp),
- Id.ArgTuple => @fieldParentPtr(ArgTuple, "base", base).destroy(comp),
- Id.Opaque => @fieldParentPtr(Opaque, "base", base).destroy(comp),
- Id.Frame => @fieldParentPtr(Frame, "base", base).destroy(comp),
- Id.AnyFrame => @fieldParentPtr(AnyFrame, "base", base).destroy(comp),
- Id.Vector => @fieldParentPtr(Vector, "base", base).destroy(comp),
+ .Struct => @fieldParentPtr(Struct, "base", base).destroy(comp),
+ .Fn => @fieldParentPtr(Fn, "base", base).destroy(comp),
+ .Type => @fieldParentPtr(MetaType, "base", base).destroy(comp),
+ .Void => @fieldParentPtr(Void, "base", base).destroy(comp),
+ .Bool => @fieldParentPtr(Bool, "base", base).destroy(comp),
+ .NoReturn => @fieldParentPtr(NoReturn, "base", base).destroy(comp),
+ .Int => @fieldParentPtr(Int, "base", base).destroy(comp),
+ .Float => @fieldParentPtr(Float, "base", base).destroy(comp),
+ .Pointer => @fieldParentPtr(Pointer, "base", base).destroy(comp),
+ .Array => @fieldParentPtr(Array, "base", base).destroy(comp),
+ .ComptimeFloat => @fieldParentPtr(ComptimeFloat, "base", base).destroy(comp),
+ .ComptimeInt => @fieldParentPtr(ComptimeInt, "base", base).destroy(comp),
+ .EnumLiteral => @fieldParentPtr(EnumLiteral, "base", base).destroy(comp),
+ .Undefined => @fieldParentPtr(Undefined, "base", base).destroy(comp),
+ .Null => @fieldParentPtr(Null, "base", base).destroy(comp),
+ .Optional => @fieldParentPtr(Optional, "base", base).destroy(comp),
+ .ErrorUnion => @fieldParentPtr(ErrorUnion, "base", base).destroy(comp),
+ .ErrorSet => @fieldParentPtr(ErrorSet, "base", base).destroy(comp),
+ .Enum => @fieldParentPtr(Enum, "base", base).destroy(comp),
+ .Union => @fieldParentPtr(Union, "base", base).destroy(comp),
+ .BoundFn => @fieldParentPtr(BoundFn, "base", base).destroy(comp),
+ .ArgTuple => @fieldParentPtr(ArgTuple, "base", base).destroy(comp),
+ .Opaque => @fieldParentPtr(Opaque, "base", base).destroy(comp),
+ .Frame => @fieldParentPtr(Frame, "base", base).destroy(comp),
+ .AnyFrame => @fieldParentPtr(AnyFrame, "base", base).destroy(comp),
+ .Vector => @fieldParentPtr(Vector, "base", base).destroy(comp),
}
}
@@ -55,108 +55,108 @@ pub const Type = struct {
llvm_context: *llvm.Context,
) (error{OutOfMemory}!*llvm.Type) {
switch (base.id) {
- Id.Struct => return @fieldParentPtr(Struct, "base", base).getLlvmType(allocator, llvm_context),
- Id.Fn => return @fieldParentPtr(Fn, "base", base).getLlvmType(allocator, llvm_context),
- Id.Type => unreachable,
- Id.Void => unreachable,
- Id.Bool => return @fieldParentPtr(Bool, "base", base).getLlvmType(allocator, llvm_context),
- Id.NoReturn => unreachable,
- Id.Int => return @fieldParentPtr(Int, "base", base).getLlvmType(allocator, llvm_context),
- Id.Float => return @fieldParentPtr(Float, "base", base).getLlvmType(allocator, llvm_context),
- Id.Pointer => return @fieldParentPtr(Pointer, "base", base).getLlvmType(allocator, llvm_context),
- Id.Array => return @fieldParentPtr(Array, "base", base).getLlvmType(allocator, llvm_context),
- Id.ComptimeFloat => unreachable,
- Id.ComptimeInt => unreachable,
- Id.EnumLiteral => unreachable,
- Id.Undefined => unreachable,
- Id.Null => unreachable,
- Id.Optional => return @fieldParentPtr(Optional, "base", base).getLlvmType(allocator, llvm_context),
- Id.ErrorUnion => return @fieldParentPtr(ErrorUnion, "base", base).getLlvmType(allocator, llvm_context),
- Id.ErrorSet => return @fieldParentPtr(ErrorSet, "base", base).getLlvmType(allocator, llvm_context),
- Id.Enum => return @fieldParentPtr(Enum, "base", base).getLlvmType(allocator, llvm_context),
- Id.Union => return @fieldParentPtr(Union, "base", base).getLlvmType(allocator, llvm_context),
- Id.BoundFn => return @fieldParentPtr(BoundFn, "base", base).getLlvmType(allocator, llvm_context),
- Id.ArgTuple => unreachable,
- Id.Opaque => return @fieldParentPtr(Opaque, "base", base).getLlvmType(allocator, llvm_context),
- Id.Frame => return @fieldParentPtr(Frame, "base", base).getLlvmType(allocator, llvm_context),
- Id.AnyFrame => return @fieldParentPtr(AnyFrame, "base", base).getLlvmType(allocator, llvm_context),
- Id.Vector => return @fieldParentPtr(Vector, "base", base).getLlvmType(allocator, llvm_context),
+ .Struct => return @fieldParentPtr(Struct, "base", base).getLlvmType(allocator, llvm_context),
+ .Fn => return @fieldParentPtr(Fn, "base", base).getLlvmType(allocator, llvm_context),
+ .Type => unreachable,
+ .Void => unreachable,
+ .Bool => return @fieldParentPtr(Bool, "base", base).getLlvmType(allocator, llvm_context),
+ .NoReturn => unreachable,
+ .Int => return @fieldParentPtr(Int, "base", base).getLlvmType(allocator, llvm_context),
+ .Float => return @fieldParentPtr(Float, "base", base).getLlvmType(allocator, llvm_context),
+ .Pointer => return @fieldParentPtr(Pointer, "base", base).getLlvmType(allocator, llvm_context),
+ .Array => return @fieldParentPtr(Array, "base", base).getLlvmType(allocator, llvm_context),
+ .ComptimeFloat => unreachable,
+ .ComptimeInt => unreachable,
+ .EnumLiteral => unreachable,
+ .Undefined => unreachable,
+ .Null => unreachable,
+ .Optional => return @fieldParentPtr(Optional, "base", base).getLlvmType(allocator, llvm_context),
+ .ErrorUnion => return @fieldParentPtr(ErrorUnion, "base", base).getLlvmType(allocator, llvm_context),
+ .ErrorSet => return @fieldParentPtr(ErrorSet, "base", base).getLlvmType(allocator, llvm_context),
+ .Enum => return @fieldParentPtr(Enum, "base", base).getLlvmType(allocator, llvm_context),
+ .Union => return @fieldParentPtr(Union, "base", base).getLlvmType(allocator, llvm_context),
+ .BoundFn => return @fieldParentPtr(BoundFn, "base", base).getLlvmType(allocator, llvm_context),
+ .ArgTuple => unreachable,
+ .Opaque => return @fieldParentPtr(Opaque, "base", base).getLlvmType(allocator, llvm_context),
+ .Frame => return @fieldParentPtr(Frame, "base", base).getLlvmType(allocator, llvm_context),
+ .AnyFrame => return @fieldParentPtr(AnyFrame, "base", base).getLlvmType(allocator, llvm_context),
+ .Vector => return @fieldParentPtr(Vector, "base", base).getLlvmType(allocator, llvm_context),
}
}
pub fn handleIsPtr(base: *Type) bool {
switch (base.id) {
- Id.Type,
- Id.ComptimeFloat,
- Id.ComptimeInt,
- Id.EnumLiteral,
- Id.Undefined,
- Id.Null,
- Id.BoundFn,
- Id.ArgTuple,
- Id.Opaque,
+ .Type,
+ .ComptimeFloat,
+ .ComptimeInt,
+ .EnumLiteral,
+ .Undefined,
+ .Null,
+ .BoundFn,
+ .ArgTuple,
+ .Opaque,
=> unreachable,
- Id.NoReturn,
- Id.Void,
- Id.Bool,
- Id.Int,
- Id.Float,
- Id.Pointer,
- Id.ErrorSet,
- Id.Enum,
- Id.Fn,
- Id.Frame,
- Id.AnyFrame,
- Id.Vector,
+ .NoReturn,
+ .Void,
+ .Bool,
+ .Int,
+ .Float,
+ .Pointer,
+ .ErrorSet,
+ .Enum,
+ .Fn,
+ .Frame,
+ .AnyFrame,
+ .Vector,
=> return false,
- Id.Struct => @panic("TODO"),
- Id.Array => @panic("TODO"),
- Id.Optional => @panic("TODO"),
- Id.ErrorUnion => @panic("TODO"),
- Id.Union => @panic("TODO"),
+ .Struct => @panic("TODO"),
+ .Array => @panic("TODO"),
+ .Optional => @panic("TODO"),
+ .ErrorUnion => @panic("TODO"),
+ .Union => @panic("TODO"),
}
}
pub fn hasBits(base: *Type) bool {
switch (base.id) {
- Id.Type,
- Id.ComptimeFloat,
- Id.ComptimeInt,
- Id.EnumLiteral,
- Id.Undefined,
- Id.Null,
- Id.BoundFn,
- Id.ArgTuple,
- Id.Opaque,
+ .Type,
+ .ComptimeFloat,
+ .ComptimeInt,
+ .EnumLiteral,
+ .Undefined,
+ .Null,
+ .BoundFn,
+ .ArgTuple,
+ .Opaque,
=> unreachable,
- Id.Void,
- Id.NoReturn,
+ .Void,
+ .NoReturn,
=> return false,
- Id.Bool,
- Id.Int,
- Id.Float,
- Id.Fn,
- Id.Frame,
- Id.AnyFrame,
- Id.Vector,
+ .Bool,
+ .Int,
+ .Float,
+ .Fn,
+ .Frame,
+ .AnyFrame,
+ .Vector,
=> return true,
- Id.Pointer => {
+ .Pointer => {
const ptr_type = @fieldParentPtr(Pointer, "base", base);
return ptr_type.key.child_type.hasBits();
},
- Id.ErrorSet => @panic("TODO"),
- Id.Enum => @panic("TODO"),
- Id.Struct => @panic("TODO"),
- Id.Array => @panic("TODO"),
- Id.Optional => @panic("TODO"),
- Id.ErrorUnion => @panic("TODO"),
- Id.Union => @panic("TODO"),
+ .ErrorSet => @panic("TODO"),
+ .Enum => @panic("TODO"),
+ .Struct => @panic("TODO"),
+ .Array => @panic("TODO"),
+ .Optional => @panic("TODO"),
+ .ErrorUnion => @panic("TODO"),
+ .Union => @panic("TODO"),
}
}
@@ -172,7 +172,7 @@ pub const Type = struct {
fn init(base: *Type, comp: *Compilation, id: Id, name: []const u8) void {
base.* = Type{
.base = Value{
- .id = Value.Id.Type,
+ .id = .Type,
.typ = &MetaType.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -272,11 +272,11 @@ pub const Type = struct {
var result: u32 = 0;
result +%= hashAny(self.alignment, 0);
switch (self.data) {
- Kind.Generic => |generic| {
+ .Generic => |generic| {
result +%= hashAny(generic.param_count, 1);
result +%= hashAny(generic.cc, 3);
},
- Kind.Normal => |normal| {
+ .Normal => |normal| {
result +%= hashAny(normal.return_type, 4);
result +%= hashAny(normal.is_var_args, 5);
result +%= hashAny(normal.cc, 6);
@@ -294,14 +294,14 @@ pub const Type = struct {
if (self.alignment) |self_align| {
if (self_align != other.alignment.?) return false;
}
- if (@TagType(Data)(self.data) != @TagType(Data)(other.data)) return false;
+ if (self.data != other.data) return false;
switch (self.data) {
- Kind.Generic => |*self_generic| {
+ .Generic => |*self_generic| {
const other_generic = &other.data.Generic;
if (self_generic.param_count != other_generic.param_count) return false;
if (self_generic.cc != other_generic.cc) return false;
},
- Kind.Normal => |*self_normal| {
+ .Normal => |*self_normal| {
const other_normal = &other.data.Normal;
if (self_normal.cc != other_normal.cc) return false;
if (self_normal.is_var_args != other_normal.is_var_args) return false;
@@ -318,8 +318,8 @@ pub const Type = struct {
pub fn deref(key: Key, comp: *Compilation) void {
switch (key.data) {
- Kind.Generic => {},
- Kind.Normal => |normal| {
+ .Generic => {},
+ .Normal => |normal| {
normal.return_type.base.deref(comp);
for (normal.params) |param| {
param.typ.base.deref(comp);
@@ -330,8 +330,8 @@ pub const Type = struct {
pub fn ref(key: Key) void {
switch (key.data) {
- Kind.Generic => {},
- Kind.Normal => |normal| {
+ .Generic => {},
+ .Normal => |normal| {
normal.return_type.base.ref();
for (normal.params) |param| {
param.typ.base.ref();
@@ -361,8 +361,8 @@ pub const Type = struct {
pub fn paramCount(self: *Fn) usize {
return switch (self.key.data) {
- Kind.Generic => |generic| generic.param_count,
- Kind.Normal => |normal| normal.params.len,
+ .Generic => |generic| generic.param_count,
+ .Normal => |normal| normal.params.len,
};
}
@@ -396,7 +396,7 @@ pub const Type = struct {
const name_stream = &std.io.BufferOutStream.init(&name_buf).stream;
switch (key.data) {
- Kind.Generic => |generic| {
+ .Generic => |generic| {
self.non_key = NonKey{ .Generic = {} };
const cc_str = ccFnTypeStr(generic.cc);
try name_stream.write(cc_str);
@@ -412,7 +412,7 @@ pub const Type = struct {
}
try name_stream.write(" var");
},
- Kind.Normal => |normal| {
+ .Normal => |normal| {
self.non_key = NonKey{
.Normal = NonKey.Normal{ .variable_list = std.ArrayList(*Scope.Var).init(comp.gpa()) },
};
@@ -435,7 +435,7 @@ pub const Type = struct {
},
}
- self.base.init(comp, Id.Fn, name_buf.toOwnedSlice());
+ self.base.init(comp, .Fn, name_buf.toOwnedSlice());
{
const held = comp.fn_type_table.acquire();
@@ -449,8 +449,8 @@ pub const Type = struct {
pub fn destroy(self: *Fn, comp: *Compilation) void {
self.key.deref(comp);
switch (self.key.data) {
- Kind.Generic => {},
- Kind.Normal => {
+ .Generic => {},
+ .Normal => {
self.non_key.Normal.variable_list.deinit();
},
}
@@ -460,7 +460,7 @@ pub const Type = struct {
pub fn getLlvmType(self: *Fn, allocator: *Allocator, llvm_context: *llvm.Context) !*llvm.Type {
const normal = &self.key.data.Normal;
const llvm_return_type = switch (normal.return_type.id) {
- Type.Id.Void => llvm.VoidTypeInContext(llvm_context) orelse return error.OutOfMemory,
+ .Void => llvm.VoidTypeInContext(llvm_context) orelse return error.OutOfMemory,
else => try normal.return_type.getLlvmType(allocator, llvm_context),
};
const llvm_param_types = try allocator.alloc(*llvm.Type, normal.params.len);
@@ -588,7 +588,7 @@ pub const Type = struct {
const name = try std.fmt.allocPrint(comp.gpa(), "{c}{}", u_or_i, key.bit_count);
errdefer comp.gpa().free(name);
- self.base.init(comp, Id.Int, name);
+ self.base.init(comp, .Int, name);
{
const held = comp.int_type_table.acquire();
@@ -650,8 +650,8 @@ pub const Type = struct {
pub fn hash(self: *const Key) u32 {
var result: u32 = 0;
result +%= switch (self.alignment) {
- Align.Abi => 0xf201c090,
- Align.Override => |x| hashAny(x, 0),
+ .Abi => 0xf201c090,
+ .Override => |x| hashAny(x, 0),
};
result +%= hashAny(self.child_type, 1);
result +%= hashAny(self.mut, 2);
@@ -670,8 +670,8 @@ pub const Type = struct {
return false;
}
switch (self.alignment) {
- Align.Abi => return true,
- Align.Override => |x| return x == other.alignment.Override,
+ .Abi => return true,
+ .Override => |x| return x == other.alignment.Override,
}
}
};
@@ -714,8 +714,8 @@ pub const Type = struct {
pub async fn getAlignAsInt(self: *Pointer, comp: *Compilation) u32 {
switch (self.key.alignment) {
- Align.Abi => return self.key.child_type.getAbiAlignment(comp),
- Align.Override => |alignment| return alignment,
+ .Abi => return self.key.child_type.getAbiAlignment(comp),
+ .Override => |alignment| return alignment,
}
}
@@ -725,11 +725,11 @@ pub const Type = struct {
) !*Pointer {
var normal_key = key;
switch (key.alignment) {
- Align.Abi => {},
- Align.Override => |alignment| {
+ .Abi => {},
+ .Override => |alignment| {
const abi_align = try key.child_type.getAbiAlignment(comp);
if (abi_align == alignment) {
- normal_key.alignment = Align.Abi;
+ normal_key.alignment = .Abi;
}
},
}
@@ -752,21 +752,21 @@ pub const Type = struct {
errdefer comp.gpa().destroy(self);
const size_str = switch (self.key.size) {
- Size.One => "*",
- Size.Many => "[*]",
- Size.Slice => "[]",
- Size.C => "[*c]",
+ .One => "*",
+ .Many => "[*]",
+ .Slice => "[]",
+ .C => "[*c]",
};
const mut_str = switch (self.key.mut) {
- Mut.Const => "const ",
- Mut.Mut => "",
+ .Const => "const ",
+ .Mut => "",
};
const vol_str = switch (self.key.vol) {
- Vol.Volatile => "volatile ",
- Vol.Non => "",
+ .Volatile => "volatile ",
+ .Non => "",
};
const name = switch (self.key.alignment) {
- Align.Abi => try std.fmt.allocPrint(
+ .Abi => try std.fmt.allocPrint(
comp.gpa(),
"{}{}{}{}",
size_str,
@@ -774,7 +774,7 @@ pub const Type = struct {
vol_str,
self.key.child_type.name,
),
- Align.Override => |alignment| try std.fmt.allocPrint(
+ .Override => |alignment| try std.fmt.allocPrint(
comp.gpa(),
"{}align<{}> {}{}{}",
size_str,
@@ -786,7 +786,7 @@ pub const Type = struct {
};
errdefer comp.gpa().free(name);
- self.base.init(comp, Id.Pointer, name);
+ self.base.init(comp, .Pointer, name);
{
const held = comp.ptr_type_table.acquire();
@@ -854,7 +854,7 @@ pub const Type = struct {
const name = try std.fmt.allocPrint(comp.gpa(), "[{}]{}", key.len, key.elem_type.name);
errdefer comp.gpa().free(name);
- self.base.init(comp, Id.Array, name);
+ self.base.init(comp, .Array, name);
{
const held = comp.array_type_table.acquire();
@@ -1054,7 +1054,7 @@ pub const Type = struct {
fn hashAny(x: var, comptime seed: u64) u32 {
switch (@typeInfo(@typeOf(x))) {
- builtin.TypeId.Int => |info| {
+ .Int => |info| {
comptime var rng = comptime std.rand.DefaultPrng.init(seed);
const unsigned_x = @bitCast(@IntType(false, info.bits), x);
if (info.bits <= 32) {
@@ -1063,21 +1063,21 @@ fn hashAny(x: var, comptime seed: u64) u32 {
return @truncate(u32, unsigned_x *% comptime rng.random.scalar(@typeOf(unsigned_x)));
}
},
- builtin.TypeId.Pointer => |info| {
+ .Pointer => |info| {
switch (info.size) {
- builtin.TypeInfo.Pointer.Size.One => return hashAny(@ptrToInt(x), seed),
- builtin.TypeInfo.Pointer.Size.Many => @compileError("implement hash function"),
- builtin.TypeInfo.Pointer.Size.Slice => @compileError("implement hash function"),
- builtin.TypeInfo.Pointer.Size.C => unreachable,
+ .One => return hashAny(@ptrToInt(x), seed),
+ .Many => @compileError("implement hash function"),
+ .Slice => @compileError("implement hash function"),
+ .C => unreachable,
}
},
- builtin.TypeId.Enum => return hashAny(@enumToInt(x), seed),
- builtin.TypeId.Bool => {
+ .Enum => return hashAny(@enumToInt(x), seed),
+ .Bool => {
comptime var rng = comptime std.rand.DefaultPrng.init(seed);
const vals = comptime [2]u32{ rng.random.scalar(u32), rng.random.scalar(u32) };
return vals[@boolToInt(x)];
},
- builtin.TypeId.Optional => {
+ .Optional => {
if (x) |non_opt| {
return hashAny(non_opt, seed);
} else {
src-self-hosted/value.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = @import("builtin");
const Scope = @import("scope.zig").Scope;
const Compilation = @import("compilation.zig").Compilation;
const ObjectFile = @import("codegen.zig").ObjectFile;
@@ -24,15 +23,15 @@ pub const Value = struct {
if (base.ref_count.decr() == 1) {
base.typ.base.deref(comp);
switch (base.id) {
- Id.Type => @fieldParentPtr(Type, "base", base).destroy(comp),
- Id.Fn => @fieldParentPtr(Fn, "base", base).destroy(comp),
- Id.FnProto => @fieldParentPtr(FnProto, "base", base).destroy(comp),
- Id.Void => @fieldParentPtr(Void, "base", base).destroy(comp),
- Id.Bool => @fieldParentPtr(Bool, "base", base).destroy(comp),
- Id.NoReturn => @fieldParentPtr(NoReturn, "base", base).destroy(comp),
- Id.Ptr => @fieldParentPtr(Ptr, "base", base).destroy(comp),
- Id.Int => @fieldParentPtr(Int, "base", base).destroy(comp),
- Id.Array => @fieldParentPtr(Array, "base", base).destroy(comp),
+ .Type => @fieldParentPtr(Type, "base", base).destroy(comp),
+ .Fn => @fieldParentPtr(Fn, "base", base).destroy(comp),
+ .FnProto => @fieldParentPtr(FnProto, "base", base).destroy(comp),
+ .Void => @fieldParentPtr(Void, "base", base).destroy(comp),
+ .Bool => @fieldParentPtr(Bool, "base", base).destroy(comp),
+ .NoReturn => @fieldParentPtr(NoReturn, "base", base).destroy(comp),
+ .Ptr => @fieldParentPtr(Ptr, "base", base).destroy(comp),
+ .Int => @fieldParentPtr(Int, "base", base).destroy(comp),
+ .Array => @fieldParentPtr(Array, "base", base).destroy(comp),
}
}
}
@@ -59,15 +58,15 @@ pub const Value = struct {
pub fn getLlvmConst(base: *Value, ofile: *ObjectFile) (error{OutOfMemory}!?*llvm.Value) {
switch (base.id) {
- Id.Type => unreachable,
- Id.Fn => return @fieldParentPtr(Fn, "base", base).getLlvmConst(ofile),
- Id.FnProto => return @fieldParentPtr(FnProto, "base", base).getLlvmConst(ofile),
- Id.Void => return null,
- Id.Bool => return @fieldParentPtr(Bool, "base", base).getLlvmConst(ofile),
- Id.NoReturn => unreachable,
- Id.Ptr => return @fieldParentPtr(Ptr, "base", base).getLlvmConst(ofile),
- Id.Int => return @fieldParentPtr(Int, "base", base).getLlvmConst(ofile),
- Id.Array => return @fieldParentPtr(Array, "base", base).getLlvmConst(ofile),
+ .Type => unreachable,
+ .Fn => return @fieldParentPtr(Fn, "base", base).getLlvmConst(ofile),
+ .FnProto => return @fieldParentPtr(FnProto, "base", base).getLlvmConst(ofile),
+ .Void => return null,
+ .Bool => return @fieldParentPtr(Bool, "base", base).getLlvmConst(ofile),
+ .NoReturn => unreachable,
+ .Ptr => return @fieldParentPtr(Ptr, "base", base).getLlvmConst(ofile),
+ .Int => return @fieldParentPtr(Int, "base", base).getLlvmConst(ofile),
+ .Array => return @fieldParentPtr(Array, "base", base).getLlvmConst(ofile),
}
}
@@ -83,15 +82,15 @@ pub const Value = struct {
pub fn copy(base: *Value, comp: *Compilation) (error{OutOfMemory}!*Value) {
switch (base.id) {
- Id.Type => unreachable,
- Id.Fn => unreachable,
- Id.FnProto => unreachable,
- Id.Void => unreachable,
- Id.Bool => unreachable,
- Id.NoReturn => unreachable,
- Id.Ptr => unreachable,
- Id.Array => unreachable,
- Id.Int => return &(try @fieldParentPtr(Int, "base", base).copy(comp)).base,
+ .Type => unreachable,
+ .Fn => unreachable,
+ .FnProto => unreachable,
+ .Void => unreachable,
+ .Bool => unreachable,
+ .NoReturn => unreachable,
+ .Ptr => unreachable,
+ .Array => unreachable,
+ .Int => return &(try @fieldParentPtr(Int, "base", base).copy(comp)).base,
}
}
@@ -138,7 +137,7 @@ pub const Value = struct {
const self = try comp.gpa().create(FnProto);
self.* = FnProto{
.base = Value{
- .id = Value.Id.FnProto,
+ .id = .FnProto,
.typ = &fn_type.base,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -202,7 +201,7 @@ pub const Value = struct {
const self = try comp.gpa().create(Fn);
self.* = Fn{
.base = Value{
- .id = Value.Id.Fn,
+ .id = .Fn,
.typ = &fn_type.base,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -359,7 +358,7 @@ pub const Value = struct {
const self = try comp.gpa().create(Value.Ptr);
self.* = Value.Ptr{
.base = Value{
- .id = Value.Id.Ptr,
+ .id = .Ptr,
.typ = &ptr_type.base,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -385,8 +384,8 @@ pub const Value = struct {
const llvm_type = self.base.typ.getLlvmType(ofile.arena, ofile.context);
// TODO carefully port the logic from codegen.cpp:gen_const_val_ptr
switch (self.special) {
- Special.Scalar => |scalar| @panic("TODO"),
- Special.BaseArray => |base_array| {
+ .Scalar => |scalar| @panic("TODO"),
+ .BaseArray => |base_array| {
// TODO put this in one .o file only, and after that, generate extern references to it
const array_llvm_value = (try base_array.val.getLlvmConst(ofile)).?;
const ptr_bit_count = ofile.comp.target_ptr_bits;
@@ -401,9 +400,9 @@ pub const Value = struct {
@intCast(c_uint, indices.len),
) orelse return error.OutOfMemory;
},
- Special.BaseStruct => |base_struct| @panic("TODO"),
- Special.HardCodedAddr => |addr| @panic("TODO"),
- Special.Discard => unreachable,
+ .BaseStruct => |base_struct| @panic("TODO"),
+ .HardCodedAddr => |addr| @panic("TODO"),
+ .Discard => unreachable,
}
}
};
@@ -437,7 +436,7 @@ pub const Value = struct {
const self = try comp.gpa().create(Value.Array);
self.* = Value.Array{
.base = Value{
- .id = Value.Id.Array,
+ .id = .Array,
.typ = &array_type.base,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -450,22 +449,22 @@ pub const Value = struct {
pub fn destroy(self: *Array, comp: *Compilation) void {
switch (self.special) {
- Special.Undefined => {},
- Special.OwnedBuffer => |buf| {
+ .Undefined => {},
+ .OwnedBuffer => |buf| {
comp.gpa().free(buf);
},
- Special.Explicit => {},
+ .Explicit => {},
}
comp.gpa().destroy(self);
}
pub fn getLlvmConst(self: *Array, ofile: *ObjectFile) !?*llvm.Value {
switch (self.special) {
- Special.Undefined => {
+ .Undefined => {
const llvm_type = try self.base.typ.getLlvmType(ofile.arena, ofile.context);
return llvm.GetUndef(llvm_type);
},
- Special.OwnedBuffer => |buf| {
+ .OwnedBuffer => |buf| {
const dont_null_terminate = 1;
const llvm_str_init = llvm.ConstStringInContext(
ofile.context,
@@ -482,7 +481,7 @@ pub const Value = struct {
llvm.SetAlignment(global, llvm.ABIAlignmentOfType(ofile.comp.target_data_ref, str_init_type));
return global;
},
- Special.Explicit => @panic("TODO"),
+ .Explicit => @panic("TODO"),
}
//{
@@ -517,7 +516,7 @@ pub const Value = struct {
const self = try comp.gpa().create(Value.Int);
self.* = Value.Int{
.base = Value{
- .id = Value.Id.Int,
+ .id = .Int,
.typ = typ,
.ref_count = std.atomic.Int(usize).init(1),
},
@@ -536,7 +535,7 @@ pub const Value = struct {
pub fn getLlvmConst(self: *Int, ofile: *ObjectFile) !?*llvm.Value {
switch (self.base.typ.id) {
- Type.Id.Int => {
+ .Int => {
const type_ref = try self.base.typ.getLlvmType(ofile.arena, ofile.context);
if (self.big_int.len() == 0) {
return llvm.ConstNull(type_ref);
@@ -554,7 +553,7 @@ pub const Value = struct {
};
return if (self.big_int.isPositive()) unsigned_val else llvm.ConstNeg(unsigned_val);
},
- Type.Id.ComptimeInt => unreachable,
+ .ComptimeInt => unreachable,
else => unreachable,
}
}
@@ -566,7 +565,7 @@ pub const Value = struct {
const new = try comp.gpa().create(Value.Int);
new.* = Value.Int{
.base = Value{
- .id = Value.Id.Int,
+ .id = .Int,
.typ = old.base.typ,
.ref_count = std.atomic.Int(usize).init(1),
},