mirror of
https://github.com/ziglang/zig.git
synced 2026-02-21 16:54:52 +00:00
Merge branch 'kristate-stdmem-replace-create-with-construct'
This commit is contained in:
Andrew Kelley
commit
4eca75c53b
@ -35,7 +35,7 @@ pub fn createFromParseError(
|
||||
var out_stream = &std.io.BufferOutStream.init(&text_buf).stream;
|
||||
try parse_error.render(&tree.tokens, out_stream);
|
||||
|
||||
const msg = try allocator.construct(Msg{
|
||||
const msg = try allocator.create(Msg{
|
||||
.tree = tree,
|
||||
.path = path,
|
||||
.text = text_buf.toOwnedSlice(),
|
||||
|
||||
@ -707,7 +707,7 @@ const Fmt = struct {
|
||||
|
||||
// file_path must outlive Fmt
|
||||
fn addToQueue(self: *Fmt, file_path: []const u8) !void {
|
||||
const new_node = try self.seen.allocator.construct(std.LinkedList([]const u8).Node{
|
||||
const new_node = try self.seen.allocator.create(std.LinkedList([]const u8).Node{
|
||||
.prev = undefined,
|
||||
.next = undefined,
|
||||
.data = file_path,
|
||||
|
||||
@ -110,11 +110,12 @@ pub const Module = struct {
|
||||
parent: ?*CliPkg,
|
||||
|
||||
pub fn init(allocator: *mem.Allocator, name: []const u8, path: []const u8, parent: ?*CliPkg) !*CliPkg {
|
||||
var pkg = try allocator.create(CliPkg);
|
||||
pkg.name = name;
|
||||
pkg.path = path;
|
||||
pkg.children = ArrayList(*CliPkg).init(allocator);
|
||||
pkg.parent = parent;
|
||||
var pkg = try allocator.create(CliPkg{
|
||||
.name = name,
|
||||
.path = path,
|
||||
.children = ArrayList(*CliPkg).init(allocator),
|
||||
.parent = parent,
|
||||
});
|
||||
return pkg;
|
||||
}
|
||||
|
||||
@ -126,7 +127,16 @@ pub const Module = struct {
|
||||
}
|
||||
};
|
||||
|
||||
pub fn create(allocator: *mem.Allocator, name: []const u8, root_src_path: ?[]const u8, target: *const Target, kind: Kind, build_mode: builtin.Mode, zig_lib_dir: []const u8, cache_dir: []const u8) !*Module {
|
||||
pub fn create(
|
||||
allocator: *mem.Allocator,
|
||||
name: []const u8,
|
||||
root_src_path: ?[]const u8,
|
||||
target: *const Target,
|
||||
kind: Kind,
|
||||
build_mode: builtin.Mode,
|
||||
zig_lib_dir: []const u8,
|
||||
cache_dir: []const u8,
|
||||
) !*Module {
|
||||
var name_buffer = try Buffer.init(allocator, name);
|
||||
errdefer name_buffer.deinit();
|
||||
|
||||
@ -139,10 +149,7 @@ pub const Module = struct {
|
||||
const builder = c.LLVMCreateBuilderInContext(context) orelse return error.OutOfMemory;
|
||||
errdefer c.LLVMDisposeBuilder(builder);
|
||||
|
||||
const module_ptr = try allocator.create(Module);
|
||||
errdefer allocator.destroy(module_ptr);
|
||||
|
||||
module_ptr.* = Module{
|
||||
const module_ptr = try allocator.create(Module{
|
||||
.allocator = allocator,
|
||||
.name = name_buffer,
|
||||
.root_src_path = root_src_path,
|
||||
@ -196,7 +203,8 @@ pub const Module = struct {
|
||||
.test_filters = [][]const u8{},
|
||||
.test_name_prefix = null,
|
||||
.emit_file_type = Emit.Binary,
|
||||
};
|
||||
});
|
||||
errdefer allocator.destroy(module_ptr);
|
||||
return module_ptr;
|
||||
}
|
||||
|
||||
@ -279,13 +287,12 @@ pub const Module = struct {
|
||||
}
|
||||
}
|
||||
|
||||
const link_lib = try self.allocator.create(LinkLib);
|
||||
link_lib.* = LinkLib{
|
||||
const link_lib = try self.allocator.create(LinkLib{
|
||||
.name = name,
|
||||
.path = null,
|
||||
.provided_explicitly = provided_explicitly,
|
||||
.symbols = ArrayList([]u8).init(self.allocator),
|
||||
};
|
||||
});
|
||||
try self.link_libs_list.append(link_lib);
|
||||
if (is_libc) {
|
||||
self.libc_link_lib = link_lib;
|
||||
|
||||
@ -114,8 +114,10 @@ fn startPuts(ctx: *Context) u8 {
|
||||
while (put_count != 0) : (put_count -= 1) {
|
||||
std.os.time.sleep(0, 1); // let the os scheduler be our fuzz
|
||||
const x = @bitCast(i32, r.random.scalar(u32));
|
||||
const node = ctx.allocator.create(Queue(i32).Node) catch unreachable;
|
||||
node.data = x;
|
||||
const node = ctx.allocator.create(Queue(i32).Node{
|
||||
.next = undefined,
|
||||
.data = x,
|
||||
}) catch unreachable;
|
||||
ctx.queue.put(node);
|
||||
_ = @atomicRmw(isize, &ctx.put_sum, builtin.AtomicRmwOp.Add, x, AtomicOrder.SeqCst);
|
||||
}
|
||||
|
||||
@ -117,8 +117,10 @@ fn startPuts(ctx: *Context) u8 {
|
||||
while (put_count != 0) : (put_count -= 1) {
|
||||
std.os.time.sleep(0, 1); // let the os scheduler be our fuzz
|
||||
const x = @bitCast(i32, r.random.scalar(u32));
|
||||
const node = ctx.allocator.create(Stack(i32).Node) catch unreachable;
|
||||
node.data = x;
|
||||
const node = ctx.allocator.create(Stack(i32).Node{
|
||||
.next = undefined,
|
||||
.data = x,
|
||||
}) catch unreachable;
|
||||
ctx.stack.push(node);
|
||||
_ = @atomicRmw(isize, &ctx.put_sum, builtin.AtomicRmwOp.Add, x, AtomicOrder.SeqCst);
|
||||
}
|
||||
|
||||
@ -158,8 +158,7 @@ pub const Builder = struct {
|
||||
}
|
||||
|
||||
pub fn addTest(self: *Builder, root_src: []const u8) *TestStep {
|
||||
const test_step = self.allocator.create(TestStep) catch unreachable;
|
||||
test_step.* = TestStep.init(self, root_src);
|
||||
const test_step = self.allocator.create(TestStep.init(self, root_src)) catch unreachable;
|
||||
return test_step;
|
||||
}
|
||||
|
||||
@ -191,21 +190,18 @@ pub const Builder = struct {
|
||||
}
|
||||
|
||||
pub fn addWriteFile(self: *Builder, file_path: []const u8, data: []const u8) *WriteFileStep {
|
||||
const write_file_step = self.allocator.create(WriteFileStep) catch unreachable;
|
||||
write_file_step.* = WriteFileStep.init(self, file_path, data);
|
||||
const write_file_step = self.allocator.create(WriteFileStep.init(self, file_path, data)) catch unreachable;
|
||||
return write_file_step;
|
||||
}
|
||||
|
||||
pub fn addLog(self: *Builder, comptime format: []const u8, args: ...) *LogStep {
|
||||
const data = self.fmt(format, args);
|
||||
const log_step = self.allocator.create(LogStep) catch unreachable;
|
||||
log_step.* = LogStep.init(self, data);
|
||||
const log_step = self.allocator.create(LogStep.init(self, data)) catch unreachable;
|
||||
return log_step;
|
||||
}
|
||||
|
||||
pub fn addRemoveDirTree(self: *Builder, dir_path: []const u8) *RemoveDirStep {
|
||||
const remove_dir_step = self.allocator.create(RemoveDirStep) catch unreachable;
|
||||
remove_dir_step.* = RemoveDirStep.init(self, dir_path);
|
||||
const remove_dir_step = self.allocator.create(RemoveDirStep.init(self, dir_path)) catch unreachable;
|
||||
return remove_dir_step;
|
||||
}
|
||||
|
||||
@ -404,11 +400,10 @@ pub const Builder = struct {
|
||||
}
|
||||
|
||||
pub fn step(self: *Builder, name: []const u8, description: []const u8) *Step {
|
||||
const step_info = self.allocator.create(TopLevelStep) catch unreachable;
|
||||
step_info.* = TopLevelStep{
|
||||
const step_info = self.allocator.create(TopLevelStep{
|
||||
.step = Step.initNoOp(name, self.allocator),
|
||||
.description = description,
|
||||
};
|
||||
}) catch unreachable;
|
||||
self.top_level_steps.append(step_info) catch unreachable;
|
||||
return &step_info.step;
|
||||
}
|
||||
@ -598,8 +593,7 @@ pub const Builder = struct {
|
||||
const full_dest_path = os.path.resolve(self.allocator, self.prefix, dest_rel_path) catch unreachable;
|
||||
self.pushInstalledFile(full_dest_path);
|
||||
|
||||
const install_step = self.allocator.create(InstallFileStep) catch unreachable;
|
||||
install_step.* = InstallFileStep.init(self, src_path, full_dest_path);
|
||||
const install_step = self.allocator.create(InstallFileStep.init(self, src_path, full_dest_path)) catch unreachable;
|
||||
return install_step;
|
||||
}
|
||||
|
||||
@ -837,51 +831,43 @@ pub const LibExeObjStep = struct {
|
||||
};
|
||||
|
||||
pub fn createSharedLibrary(builder: *Builder, name: []const u8, root_src: ?[]const u8, ver: *const Version) *LibExeObjStep {
|
||||
const self = builder.allocator.create(LibExeObjStep) catch unreachable;
|
||||
self.* = initExtraArgs(builder, name, root_src, Kind.Lib, false, ver);
|
||||
const self = builder.allocator.create(initExtraArgs(builder, name, root_src, Kind.Lib, false, ver)) catch unreachable;
|
||||
return self;
|
||||
}
|
||||
|
||||
pub fn createCSharedLibrary(builder: *Builder, name: []const u8, version: *const Version) *LibExeObjStep {
|
||||
const self = builder.allocator.create(LibExeObjStep) catch unreachable;
|
||||
self.* = initC(builder, name, Kind.Lib, version, false);
|
||||
const self = builder.allocator.create(initC(builder, name, Kind.Lib, version, false)) catch unreachable;
|
||||
return self;
|
||||
}
|
||||
|
||||
pub fn createStaticLibrary(builder: *Builder, name: []const u8, root_src: ?[]const u8) *LibExeObjStep {
|
||||
const self = builder.allocator.create(LibExeObjStep) catch unreachable;
|
||||
self.* = initExtraArgs(builder, name, root_src, Kind.Lib, true, builder.version(0, 0, 0));
|
||||
const self = builder.allocator.create(initExtraArgs(builder, name, root_src, Kind.Lib, true, builder.version(0, 0, 0))) catch unreachable;
|
||||
return self;
|
||||
}
|
||||
|
||||
pub fn createCStaticLibrary(builder: *Builder, name: []const u8) *LibExeObjStep {
|
||||
const self = builder.allocator.create(LibExeObjStep) catch unreachable;
|
||||
self.* = initC(builder, name, Kind.Lib, builder.version(0, 0, 0), true);
|
||||
const self = builder.allocator.create(initC(builder, name, Kind.Lib, builder.version(0, 0, 0), true)) catch unreachable;
|
||||
return self;
|
||||
}
|
||||
|
||||
pub fn createObject(builder: *Builder, name: []const u8, root_src: []const u8) *LibExeObjStep {
|
||||
const self = builder.allocator.create(LibExeObjStep) catch unreachable;
|
||||
self.* = initExtraArgs(builder, name, root_src, Kind.Obj, false, builder.version(0, 0, 0));
|
||||
const self = builder.allocator.create(initExtraArgs(builder, name, root_src, Kind.Obj, false, builder.version(0, 0, 0))) catch unreachable;
|
||||
return self;
|
||||
}
|
||||
|
||||
pub fn createCObject(builder: *Builder, name: []const u8, src: []const u8) *LibExeObjStep {
|
||||
const self = builder.allocator.create(LibExeObjStep) catch unreachable;
|
||||
self.* = initC(builder, name, Kind.Obj, builder.version(0, 0, 0), false);
|
||||
const self = builder.allocator.create(initC(builder, name, Kind.Obj, builder.version(0, 0, 0), false)) catch unreachable;
|
||||
self.object_src = src;
|
||||
return self;
|
||||
}
|
||||
|
||||
pub fn createExecutable(builder: *Builder, name: []const u8, root_src: ?[]const u8) *LibExeObjStep {
|
||||
const self = builder.allocator.create(LibExeObjStep) catch unreachable;
|
||||
self.* = initExtraArgs(builder, name, root_src, Kind.Exe, false, builder.version(0, 0, 0));
|
||||
const self = builder.allocator.create(initExtraArgs(builder, name, root_src, Kind.Exe, false, builder.version(0, 0, 0))) catch unreachable;
|
||||
return self;
|
||||
}
|
||||
|
||||
pub fn createCExecutable(builder: *Builder, name: []const u8) *LibExeObjStep {
|
||||
const self = builder.allocator.create(LibExeObjStep) catch unreachable;
|
||||
self.* = initC(builder, name, Kind.Exe, builder.version(0, 0, 0), false);
|
||||
const self = builder.allocator.create(initC(builder, name, Kind.Exe, builder.version(0, 0, 0), false)) catch unreachable;
|
||||
return self;
|
||||
}
|
||||
|
||||
@ -1748,14 +1734,14 @@ pub const CommandStep = struct {
|
||||
|
||||
/// ::argv is copied.
|
||||
pub fn create(builder: *Builder, cwd: ?[]const u8, env_map: *const BufMap, argv: []const []const u8) *CommandStep {
|
||||
const self = builder.allocator.create(CommandStep) catch unreachable;
|
||||
self.* = CommandStep{
|
||||
const self = builder.allocator.create(CommandStep{
|
||||
.builder = builder,
|
||||
.step = Step.init(argv[0], builder.allocator, make),
|
||||
.argv = builder.allocator.alloc([]u8, argv.len) catch unreachable,
|
||||
.cwd = cwd,
|
||||
.env_map = env_map,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
mem.copy([]const u8, self.argv, argv);
|
||||
self.step.name = self.argv[0];
|
||||
return self;
|
||||
@ -1778,18 +1764,17 @@ const InstallArtifactStep = struct {
|
||||
const Self = this;
|
||||
|
||||
pub fn create(builder: *Builder, artifact: *LibExeObjStep) *Self {
|
||||
const self = builder.allocator.create(Self) catch unreachable;
|
||||
const dest_dir = switch (artifact.kind) {
|
||||
LibExeObjStep.Kind.Obj => unreachable,
|
||||
LibExeObjStep.Kind.Exe => builder.exe_dir,
|
||||
LibExeObjStep.Kind.Lib => builder.lib_dir,
|
||||
};
|
||||
self.* = Self{
|
||||
const self = builder.allocator.create(Self{
|
||||
.builder = builder,
|
||||
.step = Step.init(builder.fmt("install {}", artifact.step.name), builder.allocator, make),
|
||||
.artifact = artifact,
|
||||
.dest_file = os.path.join(builder.allocator, dest_dir, artifact.out_filename) catch unreachable,
|
||||
};
|
||||
}) catch unreachable;
|
||||
self.step.dependOn(&artifact.step);
|
||||
builder.pushInstalledFile(self.dest_file);
|
||||
if (self.artifact.kind == LibExeObjStep.Kind.Lib and !self.artifact.static) {
|
||||
|
||||
@ -249,9 +249,7 @@ fn printSourceAtAddress(debug_info: *ElfStackTrace, out_stream: var, address: us
|
||||
pub fn openSelfDebugInfo(allocator: *mem.Allocator) !*ElfStackTrace {
|
||||
switch (builtin.object_format) {
|
||||
builtin.ObjectFormat.elf => {
|
||||
const st = try allocator.create(ElfStackTrace);
|
||||
errdefer allocator.destroy(st);
|
||||
st.* = ElfStackTrace{
|
||||
const st = try allocator.create(ElfStackTrace{
|
||||
.self_exe_file = undefined,
|
||||
.elf = undefined,
|
||||
.debug_info = undefined,
|
||||
@ -261,7 +259,8 @@ pub fn openSelfDebugInfo(allocator: *mem.Allocator) !*ElfStackTrace {
|
||||
.debug_ranges = null,
|
||||
.abbrev_table_list = ArrayList(AbbrevTableHeader).init(allocator),
|
||||
.compile_unit_list = ArrayList(CompileUnit).init(allocator),
|
||||
};
|
||||
});
|
||||
errdefer allocator.destroy(st);
|
||||
st.self_exe_file = try os.openSelfExe();
|
||||
errdefer st.self_exe_file.close();
|
||||
|
||||
@ -280,11 +279,8 @@ pub fn openSelfDebugInfo(allocator: *mem.Allocator) !*ElfStackTrace {
|
||||
var exe_file = try os.openSelfExe();
|
||||
defer exe_file.close();
|
||||
|
||||
const st = try allocator.create(ElfStackTrace);
|
||||
const st = try allocator.create(ElfStackTrace{ .symbol_table = try macho.loadSymbols(allocator, &io.FileInStream.init(&exe_file)) });
|
||||
errdefer allocator.destroy(st);
|
||||
|
||||
st.* = ElfStackTrace{ .symbol_table = try macho.loadSymbols(allocator, &io.FileInStream.init(&exe_file)) };
|
||||
|
||||
return st;
|
||||
},
|
||||
builtin.ObjectFormat.coff => {
|
||||
@ -974,8 +970,7 @@ fn scanAllCompileUnits(st: *ElfStackTrace) !void {
|
||||
|
||||
try st.self_exe_file.seekTo(compile_unit_pos);
|
||||
|
||||
const compile_unit_die = try st.allocator().create(Die);
|
||||
compile_unit_die.* = try parseDie(st, abbrev_table, is_64);
|
||||
const compile_unit_die = try st.allocator().create(try parseDie(st, abbrev_table, is_64));
|
||||
|
||||
if (compile_unit_die.tag_id != DW.TAG_compile_unit) return error.InvalidDebugInfo;
|
||||
|
||||
|
||||
@ -407,8 +407,7 @@ fn testAllocator(allocator: *mem.Allocator) !void {
|
||||
var slice = try allocator.alloc(*i32, 100);
|
||||
|
||||
for (slice) |*item, i| {
|
||||
item.* = try allocator.create(i32);
|
||||
item.*.* = @intCast(i32, i);
|
||||
item.* = try allocator.create(@intCast(i32, i));
|
||||
}
|
||||
|
||||
for (slice) |item, i| {
|
||||
|
||||
@ -414,14 +414,12 @@ pub const BufferedAtomicFile = struct {
|
||||
|
||||
pub fn create(allocator: *mem.Allocator, dest_path: []const u8) !*BufferedAtomicFile {
|
||||
// TODO with well defined copy elision we don't need this allocation
|
||||
var self = try allocator.create(BufferedAtomicFile);
|
||||
errdefer allocator.destroy(self);
|
||||
|
||||
self.* = BufferedAtomicFile{
|
||||
var self = try allocator.create(BufferedAtomicFile{
|
||||
.atomic_file = undefined,
|
||||
.file_stream = undefined,
|
||||
.buffered_stream = undefined,
|
||||
};
|
||||
});
|
||||
errdefer allocator.destroy(self);
|
||||
|
||||
self.atomic_file = try os.AtomicFile.init(allocator, dest_path, os.default_file_mode);
|
||||
errdefer self.atomic_file.deinit();
|
||||
|
||||
@ -193,7 +193,7 @@ fn BaseLinkedList(comptime T: type, comptime ParentType: type, comptime field_na
|
||||
/// A pointer to the new node.
|
||||
pub fn allocateNode(list: *Self, allocator: *Allocator) !*Node {
|
||||
comptime assert(!isIntrusive());
|
||||
return allocator.create(Node);
|
||||
return allocator.create(Node(undefined));
|
||||
}
|
||||
|
||||
/// Deallocate a node.
|
||||
|
||||
14
std/mem.zig
14
std/mem.zig
@ -31,16 +31,8 @@ pub const Allocator = struct {
|
||||
/// Guaranteed: `old_mem.len` is the same as what was returned from `allocFn` or `reallocFn`
|
||||
freeFn: fn (self: *Allocator, old_mem: []u8) void,
|
||||
|
||||
/// Call destroy with the result
|
||||
pub fn create(self: *Allocator, comptime T: type) !*T {
|
||||
if (@sizeOf(T) == 0) return *{};
|
||||
const slice = try self.alloc(T, 1);
|
||||
return &slice[0];
|
||||
}
|
||||
|
||||
/// Call destroy with the result
|
||||
/// TODO once #733 is solved, this will replace create
|
||||
pub fn construct(self: *Allocator, init: var) Error!*@typeOf(init) {
|
||||
/// Call `destroy` with the result
|
||||
pub fn create(self: *Allocator, init: var) Error!*@typeOf(init) {
|
||||
const T = @typeOf(init);
|
||||
if (@sizeOf(T) == 0) return &{};
|
||||
const slice = try self.alloc(T, 1);
|
||||
@ -49,7 +41,7 @@ pub const Allocator = struct {
|
||||
return ptr;
|
||||
}
|
||||
|
||||
/// `ptr` should be the return value of `construct` or `create`
|
||||
/// `ptr` should be the return value of `create`
|
||||
pub fn destroy(self: *Allocator, ptr: var) void {
|
||||
const non_const_ptr = @intToPtr([*]u8, @ptrToInt(ptr));
|
||||
self.freeFn(self, non_const_ptr[0..@sizeOf(@typeOf(ptr).Child)]);
|
||||
|
||||
@ -85,10 +85,7 @@ pub const ChildProcess = struct {
|
||||
/// First argument in argv is the executable.
|
||||
/// On success must call deinit.
|
||||
pub fn init(argv: []const []const u8, allocator: *mem.Allocator) !*ChildProcess {
|
||||
const child = try allocator.create(ChildProcess);
|
||||
errdefer allocator.destroy(child);
|
||||
|
||||
child.* = ChildProcess{
|
||||
const child = try allocator.create(ChildProcess{
|
||||
.allocator = allocator,
|
||||
.argv = argv,
|
||||
.pid = undefined,
|
||||
@ -109,8 +106,8 @@ pub const ChildProcess = struct {
|
||||
.stdin_behavior = StdIo.Inherit,
|
||||
.stdout_behavior = StdIo.Inherit,
|
||||
.stderr_behavior = StdIo.Inherit,
|
||||
};
|
||||
|
||||
});
|
||||
errdefer allocator.destroy(child);
|
||||
return child;
|
||||
}
|
||||
|
||||
|
||||
@ -2468,7 +2468,7 @@ pub const Thread = struct {
|
||||
data: Data,
|
||||
|
||||
pub const use_pthreads = is_posix and builtin.link_libc;
|
||||
const Data = if (use_pthreads)
|
||||
pub const Data = if (use_pthreads)
|
||||
struct {
|
||||
handle: c.pthread_t,
|
||||
stack_addr: usize,
|
||||
@ -2582,10 +2582,16 @@ pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!*Thread
|
||||
const bytes_ptr = windows.HeapAlloc(heap_handle, 0, byte_count) orelse return SpawnThreadError.OutOfMemory;
|
||||
errdefer assert(windows.HeapFree(heap_handle, 0, bytes_ptr) != 0);
|
||||
const bytes = @ptrCast([*]u8, bytes_ptr)[0..byte_count];
|
||||
const outer_context = std.heap.FixedBufferAllocator.init(bytes).allocator.create(WinThread.OuterContext) catch unreachable;
|
||||
outer_context.inner = context;
|
||||
outer_context.thread.data.heap_handle = heap_handle;
|
||||
outer_context.thread.data.alloc_start = bytes_ptr;
|
||||
const outer_context = std.heap.FixedBufferAllocator.init(bytes).allocator.create(WinThread.OuterContext{
|
||||
.thread = Thread{
|
||||
.data = Thread.Data{
|
||||
.heap_handle = heap_handle,
|
||||
.alloc_start = bytes_ptr,
|
||||
.handle = undefined,
|
||||
},
|
||||
},
|
||||
.inner = context,
|
||||
}) catch unreachable;
|
||||
|
||||
const parameter = if (@sizeOf(Context) == 0) null else @ptrCast(*c_void, &outer_context.inner);
|
||||
outer_context.thread.data.handle = windows.CreateThread(null, default_stack_size, WinThread.threadMain, parameter, 0, null) orelse {
|
||||
|
||||
@ -17,7 +17,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
defer stack.deinit();
|
||||
|
||||
const arena = &tree_arena.allocator;
|
||||
const root_node = try arena.construct(ast.Node.Root{
|
||||
const root_node = try arena.create(ast.Node.Root{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Root },
|
||||
.decls = ast.Node.Root.DeclList.init(arena),
|
||||
.doc_comments = null,
|
||||
@ -65,14 +65,14 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
Token.Id.Keyword_test => {
|
||||
stack.append(State.TopLevel) catch unreachable;
|
||||
|
||||
const block = try arena.construct(ast.Node.Block{
|
||||
const block = try arena.create(ast.Node.Block{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Block },
|
||||
.label = null,
|
||||
.lbrace = undefined,
|
||||
.statements = ast.Node.Block.StatementList.init(arena),
|
||||
.rbrace = undefined,
|
||||
});
|
||||
const test_node = try arena.construct(ast.Node.TestDecl{
|
||||
const test_node = try arena.create(ast.Node.TestDecl{
|
||||
.base = ast.Node{ .id = ast.Node.Id.TestDecl },
|
||||
.doc_comments = comments,
|
||||
.test_token = token_index,
|
||||
@ -109,14 +109,14 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_comptime => {
|
||||
const block = try arena.construct(ast.Node.Block{
|
||||
const block = try arena.create(ast.Node.Block{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Block },
|
||||
.label = null,
|
||||
.lbrace = undefined,
|
||||
.statements = ast.Node.Block.StatementList.init(arena),
|
||||
.rbrace = undefined,
|
||||
});
|
||||
const node = try arena.construct(ast.Node.Comptime{
|
||||
const node = try arena.create(ast.Node.Comptime{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Comptime },
|
||||
.comptime_token = token_index,
|
||||
.expr = &block.base,
|
||||
@ -225,7 +225,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
return tree;
|
||||
}
|
||||
|
||||
const node = try arena.construct(ast.Node.Use{
|
||||
const node = try arena.create(ast.Node.Use{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Use },
|
||||
.use_token = token_index,
|
||||
.visib_token = ctx.visib_token,
|
||||
@ -266,7 +266,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_fn, Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc, Token.Id.Keyword_async => {
|
||||
const fn_proto = try arena.construct(ast.Node.FnProto{
|
||||
const fn_proto = try arena.create(ast.Node.FnProto{
|
||||
.base = ast.Node{ .id = ast.Node.Id.FnProto },
|
||||
.doc_comments = ctx.comments,
|
||||
.visib_token = ctx.visib_token,
|
||||
@ -298,7 +298,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_async => {
|
||||
const async_node = try arena.construct(ast.Node.AsyncAttribute{
|
||||
const async_node = try arena.create(ast.Node.AsyncAttribute{
|
||||
.base = ast.Node{ .id = ast.Node.Id.AsyncAttribute },
|
||||
.async_token = token_index,
|
||||
.allocator_type = null,
|
||||
@ -330,7 +330,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
},
|
||||
State.TopLevelExternOrField => |ctx| {
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Identifier)) |identifier| {
|
||||
const node = try arena.construct(ast.Node.StructField{
|
||||
const node = try arena.create(ast.Node.StructField{
|
||||
.base = ast.Node{ .id = ast.Node.Id.StructField },
|
||||
.doc_comments = ctx.comments,
|
||||
.visib_token = ctx.visib_token,
|
||||
@ -375,7 +375,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token = nextToken(&tok_it, &tree);
|
||||
const token_index = token.index;
|
||||
const token_ptr = token.ptr;
|
||||
const node = try arena.construct(ast.Node.ContainerDecl{
|
||||
const node = try arena.create(ast.Node.ContainerDecl{
|
||||
.base = ast.Node{ .id = ast.Node.Id.ContainerDecl },
|
||||
.layout_token = ctx.layout_token,
|
||||
.kind_token = switch (token_ptr.id) {
|
||||
@ -448,7 +448,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
Token.Id.Identifier => {
|
||||
switch (tree.tokens.at(container_decl.kind_token).id) {
|
||||
Token.Id.Keyword_struct => {
|
||||
const node = try arena.construct(ast.Node.StructField{
|
||||
const node = try arena.create(ast.Node.StructField{
|
||||
.base = ast.Node{ .id = ast.Node.Id.StructField },
|
||||
.doc_comments = comments,
|
||||
.visib_token = null,
|
||||
@ -464,7 +464,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_union => {
|
||||
const node = try arena.construct(ast.Node.UnionTag{
|
||||
const node = try arena.create(ast.Node.UnionTag{
|
||||
.base = ast.Node{ .id = ast.Node.Id.UnionTag },
|
||||
.name_token = token_index,
|
||||
.type_expr = null,
|
||||
@ -480,7 +480,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_enum => {
|
||||
const node = try arena.construct(ast.Node.EnumTag{
|
||||
const node = try arena.create(ast.Node.EnumTag{
|
||||
.base = ast.Node{ .id = ast.Node.Id.EnumTag },
|
||||
.name_token = token_index,
|
||||
.value = null,
|
||||
@ -562,7 +562,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
},
|
||||
|
||||
State.VarDecl => |ctx| {
|
||||
const var_decl = try arena.construct(ast.Node.VarDecl{
|
||||
const var_decl = try arena.create(ast.Node.VarDecl{
|
||||
.base = ast.Node{ .id = ast.Node.Id.VarDecl },
|
||||
.doc_comments = ctx.comments,
|
||||
.visib_token = ctx.visib_token,
|
||||
@ -660,7 +660,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_ptr = token.ptr;
|
||||
switch (token_ptr.id) {
|
||||
Token.Id.LBrace => {
|
||||
const block = try arena.construct(ast.Node.Block{
|
||||
const block = try arena.create(ast.Node.Block{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Block },
|
||||
.label = null,
|
||||
.lbrace = token_index,
|
||||
@ -712,7 +712,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
// TODO: this is a special case. Remove this when #760 is fixed
|
||||
if (token_ptr.id == Token.Id.Keyword_error) {
|
||||
if (tok_it.peek().?.id == Token.Id.LBrace) {
|
||||
const error_type_node = try arena.construct(ast.Node.ErrorType{
|
||||
const error_type_node = try arena.create(ast.Node.ErrorType{
|
||||
.base = ast.Node{ .id = ast.Node.Id.ErrorType },
|
||||
.token = token_index,
|
||||
});
|
||||
@ -733,7 +733,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
if (eatToken(&tok_it, &tree, Token.Id.RParen)) |_| {
|
||||
continue;
|
||||
}
|
||||
const param_decl = try arena.construct(ast.Node.ParamDecl{
|
||||
const param_decl = try arena.create(ast.Node.ParamDecl{
|
||||
.base = ast.Node{ .id = ast.Node.Id.ParamDecl },
|
||||
.comptime_token = null,
|
||||
.noalias_token = null,
|
||||
@ -819,7 +819,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_ptr = token.ptr;
|
||||
switch (token_ptr.id) {
|
||||
Token.Id.LBrace => {
|
||||
const block = try arena.construct(ast.Node.Block{
|
||||
const block = try arena.create(ast.Node.Block{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Block },
|
||||
.label = ctx.label,
|
||||
.lbrace = token_index,
|
||||
@ -853,7 +853,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_suspend => {
|
||||
const node = try arena.construct(ast.Node.Suspend{
|
||||
const node = try arena.create(ast.Node.Suspend{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Suspend },
|
||||
.label = ctx.label,
|
||||
.suspend_token = token_index,
|
||||
@ -925,7 +925,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
}
|
||||
},
|
||||
State.While => |ctx| {
|
||||
const node = try arena.construct(ast.Node.While{
|
||||
const node = try arena.create(ast.Node.While{
|
||||
.base = ast.Node{ .id = ast.Node.Id.While },
|
||||
.label = ctx.label,
|
||||
.inline_token = ctx.inline_token,
|
||||
@ -954,7 +954,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
State.For => |ctx| {
|
||||
const node = try arena.construct(ast.Node.For{
|
||||
const node = try arena.create(ast.Node.For{
|
||||
.base = ast.Node{ .id = ast.Node.Id.For },
|
||||
.label = ctx.label,
|
||||
.inline_token = ctx.inline_token,
|
||||
@ -975,7 +975,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
},
|
||||
State.Else => |dest| {
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Keyword_else)) |else_token| {
|
||||
const node = try arena.construct(ast.Node.Else{
|
||||
const node = try arena.create(ast.Node.Else{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Else },
|
||||
.else_token = else_token,
|
||||
.payload = null,
|
||||
@ -1038,7 +1038,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_defer, Token.Id.Keyword_errdefer => {
|
||||
const node = try arena.construct(ast.Node.Defer{
|
||||
const node = try arena.create(ast.Node.Defer{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Defer },
|
||||
.defer_token = token_index,
|
||||
.kind = switch (token_ptr.id) {
|
||||
@ -1056,7 +1056,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.LBrace => {
|
||||
const inner_block = try arena.construct(ast.Node.Block{
|
||||
const inner_block = try arena.create(ast.Node.Block{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Block },
|
||||
.label = null,
|
||||
.lbrace = token_index,
|
||||
@ -1124,7 +1124,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
}
|
||||
|
||||
const node = try arena.construct(ast.Node.AsmOutput{
|
||||
const node = try arena.create(ast.Node.AsmOutput{
|
||||
.base = ast.Node{ .id = ast.Node.Id.AsmOutput },
|
||||
.lbracket = lbracket_index,
|
||||
.symbolic_name = undefined,
|
||||
@ -1178,7 +1178,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
}
|
||||
|
||||
const node = try arena.construct(ast.Node.AsmInput{
|
||||
const node = try arena.create(ast.Node.AsmInput{
|
||||
.base = ast.Node{ .id = ast.Node.Id.AsmInput },
|
||||
.lbracket = lbracket_index,
|
||||
.symbolic_name = undefined,
|
||||
@ -1243,7 +1243,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
}
|
||||
|
||||
const node = try arena.construct(ast.Node.FieldInitializer{
|
||||
const node = try arena.create(ast.Node.FieldInitializer{
|
||||
.base = ast.Node{ .id = ast.Node.Id.FieldInitializer },
|
||||
.period_token = undefined,
|
||||
.name_token = undefined,
|
||||
@ -1332,7 +1332,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
}
|
||||
|
||||
const comments = try eatDocComments(arena, &tok_it, &tree);
|
||||
const node = try arena.construct(ast.Node.SwitchCase{
|
||||
const node = try arena.create(ast.Node.SwitchCase{
|
||||
.base = ast.Node{ .id = ast.Node.Id.SwitchCase },
|
||||
.items = ast.Node.SwitchCase.ItemList.init(arena),
|
||||
.payload = null,
|
||||
@ -1369,7 +1369,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_index = token.index;
|
||||
const token_ptr = token.ptr;
|
||||
if (token_ptr.id == Token.Id.Keyword_else) {
|
||||
const else_node = try arena.construct(ast.Node.SwitchElse{
|
||||
const else_node = try arena.create(ast.Node.SwitchElse{
|
||||
.base = ast.Node{ .id = ast.Node.Id.SwitchElse },
|
||||
.token = token_index,
|
||||
});
|
||||
@ -1468,7 +1468,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
|
||||
State.ExternType => |ctx| {
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Keyword_fn)) |fn_token| {
|
||||
const fn_proto = try arena.construct(ast.Node.FnProto{
|
||||
const fn_proto = try arena.create(ast.Node.FnProto{
|
||||
.base = ast.Node{ .id = ast.Node.Id.FnProto },
|
||||
.doc_comments = ctx.comments,
|
||||
.visib_token = null,
|
||||
@ -1641,7 +1641,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
}
|
||||
|
||||
const node = try arena.construct(ast.Node.Payload{
|
||||
const node = try arena.create(ast.Node.Payload{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Payload },
|
||||
.lpipe = token_index,
|
||||
.error_symbol = undefined,
|
||||
@ -1677,7 +1677,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
}
|
||||
|
||||
const node = try arena.construct(ast.Node.PointerPayload{
|
||||
const node = try arena.create(ast.Node.PointerPayload{
|
||||
.base = ast.Node{ .id = ast.Node.Id.PointerPayload },
|
||||
.lpipe = token_index,
|
||||
.ptr_token = null,
|
||||
@ -1720,7 +1720,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
}
|
||||
|
||||
const node = try arena.construct(ast.Node.PointerIndexPayload{
|
||||
const node = try arena.create(ast.Node.PointerIndexPayload{
|
||||
.base = ast.Node{ .id = ast.Node.Id.PointerIndexPayload },
|
||||
.lpipe = token_index,
|
||||
.ptr_token = null,
|
||||
@ -1754,7 +1754,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_ptr = token.ptr;
|
||||
switch (token_ptr.id) {
|
||||
Token.Id.Keyword_return, Token.Id.Keyword_break, Token.Id.Keyword_continue => {
|
||||
const node = try arena.construct(ast.Node.ControlFlowExpression{
|
||||
const node = try arena.create(ast.Node.ControlFlowExpression{
|
||||
.base = ast.Node{ .id = ast.Node.Id.ControlFlowExpression },
|
||||
.ltoken = token_index,
|
||||
.kind = undefined,
|
||||
@ -1783,7 +1783,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_try, Token.Id.Keyword_cancel, Token.Id.Keyword_resume => {
|
||||
const node = try arena.construct(ast.Node.PrefixOp{
|
||||
const node = try arena.create(ast.Node.PrefixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.PrefixOp },
|
||||
.op_token = token_index,
|
||||
.op = switch (token_ptr.id) {
|
||||
@ -1817,7 +1817,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const lhs = opt_ctx.get() orelse continue;
|
||||
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Ellipsis3)) |ellipsis3| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = ellipsis3,
|
||||
@ -1842,7 +1842,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_index = token.index;
|
||||
const token_ptr = token.ptr;
|
||||
if (tokenIdToAssignment(token_ptr.id)) |ass_id| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = token_index,
|
||||
@ -1872,7 +1872,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_index = token.index;
|
||||
const token_ptr = token.ptr;
|
||||
if (tokenIdToUnwrapExpr(token_ptr.id)) |unwrap_id| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = token_index,
|
||||
@ -1904,7 +1904,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const lhs = opt_ctx.get() orelse continue;
|
||||
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Keyword_or)) |or_token| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = or_token,
|
||||
@ -1928,7 +1928,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const lhs = opt_ctx.get() orelse continue;
|
||||
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Keyword_and)) |and_token| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = and_token,
|
||||
@ -1955,7 +1955,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_index = token.index;
|
||||
const token_ptr = token.ptr;
|
||||
if (tokenIdToComparison(token_ptr.id)) |comp_id| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = token_index,
|
||||
@ -1982,7 +1982,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const lhs = opt_ctx.get() orelse continue;
|
||||
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Pipe)) |pipe| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = pipe,
|
||||
@ -2006,7 +2006,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const lhs = opt_ctx.get() orelse continue;
|
||||
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Caret)) |caret| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = caret,
|
||||
@ -2030,7 +2030,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const lhs = opt_ctx.get() orelse continue;
|
||||
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Ampersand)) |ampersand| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = ampersand,
|
||||
@ -2057,7 +2057,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_index = token.index;
|
||||
const token_ptr = token.ptr;
|
||||
if (tokenIdToBitShift(token_ptr.id)) |bitshift_id| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = token_index,
|
||||
@ -2087,7 +2087,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_index = token.index;
|
||||
const token_ptr = token.ptr;
|
||||
if (tokenIdToAddition(token_ptr.id)) |add_id| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = token_index,
|
||||
@ -2117,7 +2117,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_index = token.index;
|
||||
const token_ptr = token.ptr;
|
||||
if (tokenIdToMultiply(token_ptr.id)) |mult_id| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = token_index,
|
||||
@ -2145,7 +2145,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const lhs = opt_ctx.get() orelse continue;
|
||||
|
||||
if (tok_it.peek().?.id == Token.Id.Period) {
|
||||
const node = try arena.construct(ast.Node.SuffixOp{
|
||||
const node = try arena.create(ast.Node.SuffixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.SuffixOp },
|
||||
.lhs = lhs,
|
||||
.op = ast.Node.SuffixOp.Op{ .StructInitializer = ast.Node.SuffixOp.Op.InitList.init(arena) },
|
||||
@ -2164,7 +2164,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
}
|
||||
|
||||
const node = try arena.construct(ast.Node.SuffixOp{
|
||||
const node = try arena.create(ast.Node.SuffixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.SuffixOp },
|
||||
.lhs = lhs,
|
||||
.op = ast.Node.SuffixOp.Op{ .ArrayInitializer = ast.Node.SuffixOp.Op.InitList.init(arena) },
|
||||
@ -2193,7 +2193,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const lhs = opt_ctx.get() orelse continue;
|
||||
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Bang)) |bang| {
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = bang,
|
||||
@ -2212,7 +2212,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_index = token.index;
|
||||
const token_ptr = token.ptr;
|
||||
if (tokenIdToPrefixOp(token_ptr.id)) |prefix_id| {
|
||||
var node = try arena.construct(ast.Node.PrefixOp{
|
||||
var node = try arena.create(ast.Node.PrefixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.PrefixOp },
|
||||
.op_token = token_index,
|
||||
.op = prefix_id,
|
||||
@ -2222,7 +2222,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
|
||||
// Treat '**' token as two pointer types
|
||||
if (token_ptr.id == Token.Id.AsteriskAsterisk) {
|
||||
const child = try arena.construct(ast.Node.PrefixOp{
|
||||
const child = try arena.create(ast.Node.PrefixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.PrefixOp },
|
||||
.op_token = token_index,
|
||||
.op = prefix_id,
|
||||
@ -2246,7 +2246,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
|
||||
State.SuffixOpExpressionBegin => |opt_ctx| {
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Keyword_async)) |async_token| {
|
||||
const async_node = try arena.construct(ast.Node.AsyncAttribute{
|
||||
const async_node = try arena.create(ast.Node.AsyncAttribute{
|
||||
.base = ast.Node{ .id = ast.Node.Id.AsyncAttribute },
|
||||
.async_token = async_token,
|
||||
.allocator_type = null,
|
||||
@ -2277,7 +2277,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
const token_ptr = token.ptr;
|
||||
switch (token_ptr.id) {
|
||||
Token.Id.LParen => {
|
||||
const node = try arena.construct(ast.Node.SuffixOp{
|
||||
const node = try arena.create(ast.Node.SuffixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.SuffixOp },
|
||||
.lhs = lhs,
|
||||
.op = ast.Node.SuffixOp.Op{
|
||||
@ -2301,7 +2301,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.LBracket => {
|
||||
const node = try arena.construct(ast.Node.SuffixOp{
|
||||
const node = try arena.create(ast.Node.SuffixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.SuffixOp },
|
||||
.lhs = lhs,
|
||||
.op = ast.Node.SuffixOp.Op{ .ArrayAccess = undefined },
|
||||
@ -2316,7 +2316,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
},
|
||||
Token.Id.Period => {
|
||||
if (eatToken(&tok_it, &tree, Token.Id.Asterisk)) |asterisk_token| {
|
||||
const node = try arena.construct(ast.Node.SuffixOp{
|
||||
const node = try arena.create(ast.Node.SuffixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.SuffixOp },
|
||||
.lhs = lhs,
|
||||
.op = ast.Node.SuffixOp.Op.Deref,
|
||||
@ -2327,7 +2327,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
}
|
||||
if (eatToken(&tok_it, &tree, Token.Id.QuestionMark)) |question_token| {
|
||||
const node = try arena.construct(ast.Node.SuffixOp{
|
||||
const node = try arena.create(ast.Node.SuffixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.SuffixOp },
|
||||
.lhs = lhs,
|
||||
.op = ast.Node.SuffixOp.Op.UnwrapOptional,
|
||||
@ -2337,7 +2337,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
stack.append(State{ .SuffixOpExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
|
||||
continue;
|
||||
}
|
||||
const node = try arena.construct(ast.Node.InfixOp{
|
||||
const node = try arena.create(ast.Node.InfixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.InfixOp },
|
||||
.lhs = lhs,
|
||||
.op_token = token_index,
|
||||
@ -2397,7 +2397,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_promise => {
|
||||
const node = try arena.construct(ast.Node.PromiseType{
|
||||
const node = try arena.create(ast.Node.PromiseType{
|
||||
.base = ast.Node{ .id = ast.Node.Id.PromiseType },
|
||||
.promise_token = token.index,
|
||||
.result = null,
|
||||
@ -2423,7 +2423,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.LParen => {
|
||||
const node = try arena.construct(ast.Node.GroupedExpression{
|
||||
const node = try arena.create(ast.Node.GroupedExpression{
|
||||
.base = ast.Node{ .id = ast.Node.Id.GroupedExpression },
|
||||
.lparen = token.index,
|
||||
.expr = undefined,
|
||||
@ -2441,7 +2441,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Builtin => {
|
||||
const node = try arena.construct(ast.Node.BuiltinCall{
|
||||
const node = try arena.create(ast.Node.BuiltinCall{
|
||||
.base = ast.Node{ .id = ast.Node.Id.BuiltinCall },
|
||||
.builtin_token = token.index,
|
||||
.params = ast.Node.BuiltinCall.ParamList.init(arena),
|
||||
@ -2460,7 +2460,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.LBracket => {
|
||||
const node = try arena.construct(ast.Node.PrefixOp{
|
||||
const node = try arena.create(ast.Node.PrefixOp{
|
||||
.base = ast.Node{ .id = ast.Node.Id.PrefixOp },
|
||||
.op_token = token.index,
|
||||
.op = undefined,
|
||||
@ -2519,7 +2519,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_fn => {
|
||||
const fn_proto = try arena.construct(ast.Node.FnProto{
|
||||
const fn_proto = try arena.create(ast.Node.FnProto{
|
||||
.base = ast.Node{ .id = ast.Node.Id.FnProto },
|
||||
.doc_comments = null,
|
||||
.visib_token = null,
|
||||
@ -2540,7 +2540,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {
|
||||
const fn_proto = try arena.construct(ast.Node.FnProto{
|
||||
const fn_proto = try arena.create(ast.Node.FnProto{
|
||||
.base = ast.Node{ .id = ast.Node.Id.FnProto },
|
||||
.doc_comments = null,
|
||||
.visib_token = null,
|
||||
@ -2567,7 +2567,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
},
|
||||
Token.Id.Keyword_asm => {
|
||||
const node = try arena.construct(ast.Node.Asm{
|
||||
const node = try arena.create(ast.Node.Asm{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Asm },
|
||||
.asm_token = token.index,
|
||||
.volatile_token = null,
|
||||
@ -2629,7 +2629,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
continue;
|
||||
}
|
||||
|
||||
const node = try arena.construct(ast.Node.ErrorSetDecl{
|
||||
const node = try arena.create(ast.Node.ErrorSetDecl{
|
||||
.base = ast.Node{ .id = ast.Node.Id.ErrorSetDecl },
|
||||
.error_token = ctx.error_token,
|
||||
.decls = ast.Node.ErrorSetDecl.DeclList.init(arena),
|
||||
@ -2695,7 +2695,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
|
||||
return tree;
|
||||
}
|
||||
|
||||
const node = try arena.construct(ast.Node.ErrorTag{
|
||||
const node = try arena.create(ast.Node.ErrorTag{
|
||||
.base = ast.Node{ .id = ast.Node.Id.ErrorTag },
|
||||
.doc_comments = comments,
|
||||
.name_token = ident_token_index,
|
||||
@ -3032,7 +3032,7 @@ fn pushDocComment(arena: *mem.Allocator, line_comment: TokenIndex, result: *?*as
|
||||
if (result.*) |comment_node| {
|
||||
break :blk comment_node;
|
||||
} else {
|
||||
const comment_node = try arena.construct(ast.Node.DocComment{
|
||||
const comment_node = try arena.create(ast.Node.DocComment{
|
||||
.base = ast.Node{ .id = ast.Node.Id.DocComment },
|
||||
.lines = ast.Node.DocComment.LineList.init(arena),
|
||||
});
|
||||
@ -3061,7 +3061,7 @@ fn parseStringLiteral(arena: *mem.Allocator, tok_it: *ast.Tree.TokenList.Iterato
|
||||
return &(try createLiteral(arena, ast.Node.StringLiteral, token_index)).base;
|
||||
},
|
||||
Token.Id.MultilineStringLiteralLine => {
|
||||
const node = try arena.construct(ast.Node.MultilineStringLiteral{
|
||||
const node = try arena.create(ast.Node.MultilineStringLiteral{
|
||||
.base = ast.Node{ .id = ast.Node.Id.MultilineStringLiteral },
|
||||
.lines = ast.Node.MultilineStringLiteral.LineList.init(arena),
|
||||
});
|
||||
@ -3089,7 +3089,7 @@ fn parseStringLiteral(arena: *mem.Allocator, tok_it: *ast.Tree.TokenList.Iterato
|
||||
fn parseBlockExpr(stack: *std.ArrayList(State), arena: *mem.Allocator, ctx: *const OptionalCtx, token_ptr: *const Token, token_index: TokenIndex) !bool {
|
||||
switch (token_ptr.id) {
|
||||
Token.Id.Keyword_suspend => {
|
||||
const node = try arena.construct(ast.Node.Suspend{
|
||||
const node = try arena.create(ast.Node.Suspend{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Suspend },
|
||||
.label = null,
|
||||
.suspend_token = token_index,
|
||||
@ -3103,7 +3103,7 @@ fn parseBlockExpr(stack: *std.ArrayList(State), arena: *mem.Allocator, ctx: *con
|
||||
return true;
|
||||
},
|
||||
Token.Id.Keyword_if => {
|
||||
const node = try arena.construct(ast.Node.If{
|
||||
const node = try arena.create(ast.Node.If{
|
||||
.base = ast.Node{ .id = ast.Node.Id.If },
|
||||
.if_token = token_index,
|
||||
.condition = undefined,
|
||||
@ -3144,7 +3144,7 @@ fn parseBlockExpr(stack: *std.ArrayList(State), arena: *mem.Allocator, ctx: *con
|
||||
return true;
|
||||
},
|
||||
Token.Id.Keyword_switch => {
|
||||
const node = try arena.construct(ast.Node.Switch{
|
||||
const node = try arena.create(ast.Node.Switch{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Switch },
|
||||
.switch_token = token_index,
|
||||
.expr = undefined,
|
||||
@ -3166,7 +3166,7 @@ fn parseBlockExpr(stack: *std.ArrayList(State), arena: *mem.Allocator, ctx: *con
|
||||
return true;
|
||||
},
|
||||
Token.Id.Keyword_comptime => {
|
||||
const node = try arena.construct(ast.Node.Comptime{
|
||||
const node = try arena.create(ast.Node.Comptime{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Comptime },
|
||||
.comptime_token = token_index,
|
||||
.expr = undefined,
|
||||
@ -3178,7 +3178,7 @@ fn parseBlockExpr(stack: *std.ArrayList(State), arena: *mem.Allocator, ctx: *con
|
||||
return true;
|
||||
},
|
||||
Token.Id.LBrace => {
|
||||
const block = try arena.construct(ast.Node.Block{
|
||||
const block = try arena.create(ast.Node.Block{
|
||||
.base = ast.Node{ .id = ast.Node.Id.Block },
|
||||
.label = null,
|
||||
.lbrace = token_index,
|
||||
@ -3318,7 +3318,7 @@ fn tokenIdToPrefixOp(id: @TagType(Token.Id)) ?ast.Node.PrefixOp.Op {
|
||||
}
|
||||
|
||||
fn createLiteral(arena: *mem.Allocator, comptime T: type, token_index: TokenIndex) !*T {
|
||||
return arena.construct(T{
|
||||
return arena.create(T{
|
||||
.base = ast.Node{ .id = ast.Node.typeToId(T) },
|
||||
.token = token_index,
|
||||
});
|
||||
|
||||
@ -146,7 +146,7 @@ test "null with default unwrap" {
|
||||
|
||||
test "optional types" {
|
||||
comptime {
|
||||
const opt_type_struct = StructWithOptionalType { .t=u8, };
|
||||
const opt_type_struct = StructWithOptionalType{ .t = u8 };
|
||||
assert(opt_type_struct.t != null and opt_type_struct.t.? == u8);
|
||||
}
|
||||
}
|
||||
|
||||
@ -48,13 +48,12 @@ const test_targets = []TestTarget{
|
||||
const max_stdout_size = 1 * 1024 * 1024; // 1 MB
|
||||
|
||||
pub fn addCompareOutputTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
|
||||
const cases = b.allocator.create(CompareOutputContext) catch unreachable;
|
||||
cases.* = CompareOutputContext{
|
||||
const cases = b.allocator.create(CompareOutputContext{
|
||||
.b = b,
|
||||
.step = b.step("test-compare-output", "Run the compare output tests"),
|
||||
.test_index = 0,
|
||||
.test_filter = test_filter,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
compare_output.addCases(cases);
|
||||
|
||||
@ -62,13 +61,12 @@ pub fn addCompareOutputTests(b: *build.Builder, test_filter: ?[]const u8) *build
|
||||
}
|
||||
|
||||
pub fn addRuntimeSafetyTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
|
||||
const cases = b.allocator.create(CompareOutputContext) catch unreachable;
|
||||
cases.* = CompareOutputContext{
|
||||
const cases = b.allocator.create(CompareOutputContext{
|
||||
.b = b,
|
||||
.step = b.step("test-runtime-safety", "Run the runtime safety tests"),
|
||||
.test_index = 0,
|
||||
.test_filter = test_filter,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
runtime_safety.addCases(cases);
|
||||
|
||||
@ -76,13 +74,12 @@ pub fn addRuntimeSafetyTests(b: *build.Builder, test_filter: ?[]const u8) *build
|
||||
}
|
||||
|
||||
pub fn addCompileErrorTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
|
||||
const cases = b.allocator.create(CompileErrorContext) catch unreachable;
|
||||
cases.* = CompileErrorContext{
|
||||
const cases = b.allocator.create(CompileErrorContext{
|
||||
.b = b,
|
||||
.step = b.step("test-compile-errors", "Run the compile error tests"),
|
||||
.test_index = 0,
|
||||
.test_filter = test_filter,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
compile_errors.addCases(cases);
|
||||
|
||||
@ -90,13 +87,12 @@ pub fn addCompileErrorTests(b: *build.Builder, test_filter: ?[]const u8) *build.
|
||||
}
|
||||
|
||||
pub fn addBuildExampleTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
|
||||
const cases = b.allocator.create(BuildExamplesContext) catch unreachable;
|
||||
cases.* = BuildExamplesContext{
|
||||
const cases = b.allocator.create(BuildExamplesContext{
|
||||
.b = b,
|
||||
.step = b.step("test-build-examples", "Build the examples"),
|
||||
.test_index = 0,
|
||||
.test_filter = test_filter,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
build_examples.addCases(cases);
|
||||
|
||||
@ -104,13 +100,12 @@ pub fn addBuildExampleTests(b: *build.Builder, test_filter: ?[]const u8) *build.
|
||||
}
|
||||
|
||||
pub fn addAssembleAndLinkTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
|
||||
const cases = b.allocator.create(CompareOutputContext) catch unreachable;
|
||||
cases.* = CompareOutputContext{
|
||||
const cases = b.allocator.create(CompareOutputContext{
|
||||
.b = b,
|
||||
.step = b.step("test-asm-link", "Run the assemble and link tests"),
|
||||
.test_index = 0,
|
||||
.test_filter = test_filter,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
assemble_and_link.addCases(cases);
|
||||
|
||||
@ -118,13 +113,12 @@ pub fn addAssembleAndLinkTests(b: *build.Builder, test_filter: ?[]const u8) *bui
|
||||
}
|
||||
|
||||
pub fn addTranslateCTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
|
||||
const cases = b.allocator.create(TranslateCContext) catch unreachable;
|
||||
cases.* = TranslateCContext{
|
||||
const cases = b.allocator.create(TranslateCContext{
|
||||
.b = b,
|
||||
.step = b.step("test-translate-c", "Run the C transation tests"),
|
||||
.test_index = 0,
|
||||
.test_filter = test_filter,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
translate_c.addCases(cases);
|
||||
|
||||
@ -132,13 +126,12 @@ pub fn addTranslateCTests(b: *build.Builder, test_filter: ?[]const u8) *build.St
|
||||
}
|
||||
|
||||
pub fn addGenHTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
|
||||
const cases = b.allocator.create(GenHContext) catch unreachable;
|
||||
cases.* = GenHContext{
|
||||
const cases = b.allocator.create(GenHContext{
|
||||
.b = b,
|
||||
.step = b.step("test-gen-h", "Run the C header file generation tests"),
|
||||
.test_index = 0,
|
||||
.test_filter = test_filter,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
gen_h.addCases(cases);
|
||||
|
||||
@ -240,8 +233,7 @@ pub const CompareOutputContext = struct {
|
||||
|
||||
pub fn create(context: *CompareOutputContext, exe_path: []const u8, name: []const u8, expected_output: []const u8, cli_args: []const []const u8) *RunCompareOutputStep {
|
||||
const allocator = context.b.allocator;
|
||||
const ptr = allocator.create(RunCompareOutputStep) catch unreachable;
|
||||
ptr.* = RunCompareOutputStep{
|
||||
const ptr = allocator.create(RunCompareOutputStep{
|
||||
.context = context,
|
||||
.exe_path = exe_path,
|
||||
.name = name,
|
||||
@ -249,7 +241,7 @@ pub const CompareOutputContext = struct {
|
||||
.test_index = context.test_index,
|
||||
.step = build.Step.init("RunCompareOutput", allocator, make),
|
||||
.cli_args = cli_args,
|
||||
};
|
||||
}) catch unreachable;
|
||||
context.test_index += 1;
|
||||
return ptr;
|
||||
}
|
||||
@ -328,14 +320,14 @@ pub const CompareOutputContext = struct {
|
||||
|
||||
pub fn create(context: *CompareOutputContext, exe_path: []const u8, name: []const u8) *RuntimeSafetyRunStep {
|
||||
const allocator = context.b.allocator;
|
||||
const ptr = allocator.create(RuntimeSafetyRunStep) catch unreachable;
|
||||
ptr.* = RuntimeSafetyRunStep{
|
||||
const ptr = allocator.create(RuntimeSafetyRunStep{
|
||||
.context = context,
|
||||
.exe_path = exe_path,
|
||||
.name = name,
|
||||
.test_index = context.test_index,
|
||||
.step = build.Step.init("RuntimeSafetyRun", allocator, make),
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
context.test_index += 1;
|
||||
return ptr;
|
||||
}
|
||||
@ -543,15 +535,15 @@ pub const CompileErrorContext = struct {
|
||||
|
||||
pub fn create(context: *CompileErrorContext, name: []const u8, case: *const TestCase, build_mode: Mode) *CompileCmpOutputStep {
|
||||
const allocator = context.b.allocator;
|
||||
const ptr = allocator.create(CompileCmpOutputStep) catch unreachable;
|
||||
ptr.* = CompileCmpOutputStep{
|
||||
const ptr = allocator.create(CompileCmpOutputStep{
|
||||
.step = build.Step.init("CompileCmpOutput", allocator, make),
|
||||
.context = context,
|
||||
.name = name,
|
||||
.test_index = context.test_index,
|
||||
.case = case,
|
||||
.build_mode = build_mode,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
context.test_index += 1;
|
||||
return ptr;
|
||||
}
|
||||
@ -662,14 +654,14 @@ pub const CompileErrorContext = struct {
|
||||
}
|
||||
|
||||
pub fn create(self: *CompileErrorContext, name: []const u8, source: []const u8, expected_lines: ...) *TestCase {
|
||||
const tc = self.b.allocator.create(TestCase) catch unreachable;
|
||||
tc.* = TestCase{
|
||||
const tc = self.b.allocator.create(TestCase{
|
||||
.name = name,
|
||||
.sources = ArrayList(TestCase.SourceFile).init(self.b.allocator),
|
||||
.expected_errors = ArrayList([]const u8).init(self.b.allocator),
|
||||
.link_libc = false,
|
||||
.is_exe = false,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
tc.addSourceFile(".tmp_source.zig", source);
|
||||
comptime var arg_i = 0;
|
||||
inline while (arg_i < expected_lines.len) : (arg_i += 1) {
|
||||
@ -829,14 +821,14 @@ pub const TranslateCContext = struct {
|
||||
|
||||
pub fn create(context: *TranslateCContext, name: []const u8, case: *const TestCase) *TranslateCCmpOutputStep {
|
||||
const allocator = context.b.allocator;
|
||||
const ptr = allocator.create(TranslateCCmpOutputStep) catch unreachable;
|
||||
ptr.* = TranslateCCmpOutputStep{
|
||||
const ptr = allocator.create(TranslateCCmpOutputStep{
|
||||
.step = build.Step.init("ParseCCmpOutput", allocator, make),
|
||||
.context = context,
|
||||
.name = name,
|
||||
.test_index = context.test_index,
|
||||
.case = case,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
context.test_index += 1;
|
||||
return ptr;
|
||||
}
|
||||
@ -936,13 +928,13 @@ pub const TranslateCContext = struct {
|
||||
}
|
||||
|
||||
pub fn create(self: *TranslateCContext, allow_warnings: bool, filename: []const u8, name: []const u8, source: []const u8, expected_lines: ...) *TestCase {
|
||||
const tc = self.b.allocator.create(TestCase) catch unreachable;
|
||||
tc.* = TestCase{
|
||||
const tc = self.b.allocator.create(TestCase{
|
||||
.name = name,
|
||||
.sources = ArrayList(TestCase.SourceFile).init(self.b.allocator),
|
||||
.expected_lines = ArrayList([]const u8).init(self.b.allocator),
|
||||
.allow_warnings = allow_warnings,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
tc.addSourceFile(filename, source);
|
||||
comptime var arg_i = 0;
|
||||
inline while (arg_i < expected_lines.len) : (arg_i += 1) {
|
||||
@ -1023,15 +1015,15 @@ pub const GenHContext = struct {
|
||||
|
||||
pub fn create(context: *GenHContext, h_path: []const u8, name: []const u8, case: *const TestCase) *GenHCmpOutputStep {
|
||||
const allocator = context.b.allocator;
|
||||
const ptr = allocator.create(GenHCmpOutputStep) catch unreachable;
|
||||
ptr.* = GenHCmpOutputStep{
|
||||
const ptr = allocator.create(GenHCmpOutputStep{
|
||||
.step = build.Step.init("ParseCCmpOutput", allocator, make),
|
||||
.context = context,
|
||||
.h_path = h_path,
|
||||
.name = name,
|
||||
.test_index = context.test_index,
|
||||
.case = case,
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
context.test_index += 1;
|
||||
return ptr;
|
||||
}
|
||||
@ -1070,12 +1062,12 @@ pub const GenHContext = struct {
|
||||
}
|
||||
|
||||
pub fn create(self: *GenHContext, filename: []const u8, name: []const u8, source: []const u8, expected_lines: ...) *TestCase {
|
||||
const tc = self.b.allocator.create(TestCase) catch unreachable;
|
||||
tc.* = TestCase{
|
||||
const tc = self.b.allocator.create(TestCase{
|
||||
.name = name,
|
||||
.sources = ArrayList(TestCase.SourceFile).init(self.b.allocator),
|
||||
.expected_lines = ArrayList([]const u8).init(self.b.allocator),
|
||||
};
|
||||
}) catch unreachable;
|
||||
|
||||
tc.addSourceFile(filename, source);
|
||||
comptime var arg_i = 0;
|
||||
inline while (arg_i < expected_lines.len) : (arg_i += 1) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user