Merge pull request #90 from dozn/main

Remove Instances of 'do', and Added `#no_nil` to `Body_Type`

Author: laytan

allocator.odin

@@ -150,7 +150,7 @@ allocator_alloc_zerod :: proc(a: ^Allocator, size: int, alignment: int, loc := #
 }
 
 allocator_alloc_non_zerod :: proc(a: ^Allocator, size: int, alignment: int, loc := #caller_location) -> (bytes: []byte, err: mem.Allocator_Error) {
-	if size == 0 do return
+	if size == 0 { return }
 
 	block := a.curr
 	data := ([^]byte)(&block.data)

client/client.odin

@@ -39,7 +39,7 @@ request_destroy :: proc(r: ^Request) {
 }
 
 with_json :: proc(r: ^Request, v: any, opt: json.Marshal_Options = {}) -> json.Marshal_Error {
-	if r.method == .Get do r.method = .Post
+	if r.method == .Get { r.method = .Post }
 	http.headers_set_content_type(&r.headers, http.mime_to_content_type(.Json))
 
 	stream := bytes.buffer_to_stream(&r.body)
@@ -198,7 +198,7 @@ Body_Plain :: string
 // And should be deleted by you.
 Body_Url_Encoded :: map[string]string
 
-Body_Type :: union {
+Body_Type :: union #no_nil {
 	Body_Plain,
 	Body_Url_Encoded,
 	Body_Error, // TODO: why is this here if we also return an error?
@@ -209,7 +209,7 @@ Body_Type :: union {
 body_destroy :: proc(body: Body_Type, was_allocation: bool) {
 	switch b in body {
 	case Body_Plain:
-		if was_allocation do delete(b)
+		if was_allocation { delete(b) }
 	case Body_Url_Encoded:
 		for k, v in b {
 			delete(k)
@@ -267,7 +267,7 @@ _parse_body :: proc(
 	// Automatically decode url encoded bodies.
 	if typ, ok := http.headers_get_unsafe(headers^, "content-type"); ok && typ == "application/x-www-form-urlencoded" {
 		plain := body.(Body_Plain)
-		defer if was_allocation do delete(plain)
+		defer if was_allocation { delete(plain) }
 
 		keyvalues := strings.split(plain, "&", allocator)
 		defer delete(keyvalues, allocator)
@@ -394,7 +394,7 @@ _response_body_chunked :: proc(
 	body_buff: bytes.Buffer
 
 	bytes.buffer_init_allocator(&body_buff, 0, 0, allocator)
-	defer if err != nil do bytes.buffer_destroy(&body_buff)
+	defer if err != nil { bytes.buffer_destroy(&body_buff) }
 
 	for {
 		if !bufio.scanner_scan(_body) {
@@ -414,7 +414,7 @@ _response_body_chunked :: proc(
 			err = .Invalid_Chunk_Size
 			return
 		}
-		if size == 0 do break
+		if size == 0 { break }
 
 		if max_length > -1 && bytes.buffer_length(&body_buff) + size > max_length {
 			return "", .Too_Long

client/communication.odin

@@ -85,7 +85,7 @@ format_request :: proc(target: http.URL, request: ^Request, allocator := context
 		// Escape newlines in headers, if we don't, an attacker can find an endpoint
 		// that returns a header with user input, and inject headers into the response.
 		esc_value, was_allocation := strings.replace_all(value, "\n", "\\n", allocator)
-		defer if was_allocation do delete(esc_value)
+		defer if was_allocation { delete(esc_value) }
 
 		bytes.buffer_write_string(&buf, esc_value)
 		bytes.buffer_write_string(&buf, "\r\n")
@@ -178,7 +178,7 @@ parse_response :: proc(socket: Communication, allocator := context.allocator) ->
 
 		line := bufio.scanner_text(&scanner)
 		// Empty line means end of headers.
-		if line == "" do break
+		if line == "" { break }
 
 		key, hok := http.header_parse(&res.headers, line, allocator)
 		if !hok {

nbio/_io_uring/os.odin

@@ -96,7 +96,7 @@ io_uring_init :: proc(ring: ^IO_Uring, entries: u32, params: ^io_uring_params) -
 	assert((params.flags & IORING_SETUP_SQE128) == 0)
 
 	sq, ok := submission_queue_make(fd, params)
-	if !ok do return .System_Resources
+	if !ok { return .System_Resources }
 
 	ring.fd = fd
 	ring.sq = sq
@@ -241,7 +241,7 @@ flush_sq :: proc(ring: ^IO_Uring) -> (n_pending: u32) {
 // Matches the implementation of sq_ring_needs_enter() in liburing.
 sq_ring_needs_enter :: proc(ring: ^IO_Uring, flags: ^u32) -> bool {
 	assert(flags^ == 0)
-	if ring.flags & IORING_SETUP_SQPOLL == 0 do return true
+	if ring.flags & IORING_SETUP_SQPOLL == 0 { return true }
 	if sync.atomic_load_explicit(ring.sq.flags, .Relaxed) & IORING_SQ_NEED_WAKEUP != 0 {
 		flags^ |= IORING_ENTER_SQ_WAKEUP
 		return true
@@ -267,7 +267,7 @@ cq_ready :: proc(ring: ^IO_Uring) -> (n_ready: u32) {
 // Provides all the wait/peek methods found in liburing, but with batching and a single method.
 copy_cqes :: proc(ring: ^IO_Uring, cqes: []io_uring_cqe, wait_nr: u32) -> (n_copied: u32, err: IO_Uring_Error) {
 	n_copied = copy_cqes_ready(ring, cqes)
-	if n_copied > 0 do return
+	if n_copied > 0 { return }
 	if wait_nr > 0 || cq_ring_needs_flush(ring) {
 		_ = enter(ring, 0, wait_nr, IORING_ENTER_GETEVENTS) or_return
 		n_copied = copy_cqes_ready(ring, cqes)
@@ -307,7 +307,7 @@ cqe_seen :: proc(ring: ^IO_Uring) {
 // For advanced use cases only that implement custom completion queue methods.
 // Matches the implementation of cq_advance() in liburing.
 cq_advance :: proc(ring: ^IO_Uring, count: u32) {
-	if count == 0 do return
+	if count == 0 { return }
 	sync.atomic_store_explicit(ring.cq.head, ring.cq.head^ + count, .Release)
 }
 
@@ -669,8 +669,8 @@ submission_queue_make :: proc(fd: os.Handle, params: ^io_uring_params) -> (sq: S
 		int(fd),
 		IORING_OFF_SQ_RING,
 	)
-	if mmap_result < 0 do return
-	defer if !ok do unix.sys_munmap(rawptr(uintptr(mmap_result)), uint(size))
+	if mmap_result < 0 { return }
+	defer if !ok { unix.sys_munmap(rawptr(uintptr(mmap_result)), uint(size)) }
 
 	mmap := transmute([^]u8)uintptr(mmap_result)
 
@@ -684,7 +684,7 @@ submission_queue_make :: proc(fd: os.Handle, params: ^io_uring_params) -> (sq: S
 		int(fd),
 		IORING_OFF_SQES,
 	)
-	if mmap_sqes_result < 0 do return
+	if mmap_sqes_result < 0 { return }
 
 	array := cast([^]u32)&mmap[params.sq_off.array]
 	sqes := cast([^]io_uring_sqe)uintptr(mmap_sqes_result)

nbio/nbio_internal_darwin.odin

@@ -165,7 +165,7 @@ flush :: proc(io: ^IO) -> os.Errno {
 flush_io :: proc(io: ^IO, events: []kqueue.KEvent) -> int {
 	events := events
 	events_loop: for &event, i in events {
-		if len(io.io_pending) <= i do return i
+		if len(io.io_pending) <= i { return i }
 		completion := io.io_pending[i]
 
 		switch op in completion.operation {
@@ -230,13 +230,13 @@ flush_io :: proc(io: ^IO, events: []kqueue.KEvent) -> int {
 flush_timeouts :: proc(io: ^IO) -> (min_timeout: Maybe(i64)) {
 	now: time.Time
 	// PERF: is there a faster way to compare time? Or time since program start and compare that?
-	if len(io.timeouts) > 0 do now = time.now()
+	if len(io.timeouts) > 0 { now = time.now() }
 
 	for i := len(io.timeouts) - 1; i >= 0; i -= 1 {
 		completion := io.timeouts[i]
 
 		timeout, ok := &completion.operation.(Op_Timeout)
-		if !ok do panic("non-timeout operation found in the timeouts queue")
+		if !ok { panic("non-timeout operation found in the timeouts queue") }
 
 		unow := time.to_unix_nanoseconds(now)
 		expires := time.to_unix_nanoseconds(timeout.expires)

nbio/nbio_internal_linux.odin

@@ -112,10 +112,10 @@ Op_Poll_Remove :: struct {
 
 flush :: proc(io: ^IO, wait_nr: u32, timeouts: ^uint, etime: ^bool) -> os.Errno {
 	err := flush_submissions(io, wait_nr, timeouts, etime)
-	if err != os.ERROR_NONE do return err
+	if err != os.ERROR_NONE { return err }
 
 	err = flush_completions(io, 0, timeouts, etime)
-	if err != os.ERROR_NONE do return err
+	if err != os.ERROR_NONE { return err }
 
 	// Store length at this time, so we don't infinite loop if any of the enqueue
 	// procs below then add to the queue again.
@@ -169,7 +169,7 @@ flush_completions :: proc(io: ^IO, wait_nr: u32, timeouts: ^uint, etime: ^bool)
 	wait_remaining := wait_nr
 	for {
 		completed, err := io_uring.copy_cqes(&io.ring, cqes[:], wait_remaining)
-		if err != .None do return ring_err_to_os_err(err)
+		if err != .None { return ring_err_to_os_err(err) }
 
 		if wait_remaining < completed {
 			wait_remaining = 0
@@ -198,7 +198,7 @@ flush_completions :: proc(io: ^IO, wait_nr: u32, timeouts: ^uint, etime: ^bool)
 			}
 		}
 
-		if completed < len(cqes) do break
+		if completed < len(cqes) { break }
 	}
 
 	return os.ERROR_NONE
@@ -214,7 +214,7 @@ flush_submissions :: proc(io: ^IO, wait_nr: u32, timeouts: ^uint, etime: ^bool)
 			continue
 		case .Completion_Queue_Overcommitted, .System_Resources:
 			ferr := flush_completions(io, 1, timeouts, etime)
-			if ferr != os.ERROR_NONE do return ferr
+			if ferr != os.ERROR_NONE { return ferr }
 			continue
 		case:
 			return ring_err_to_os_err(err)

nbio/nbio_linux.odin

@@ -64,18 +64,18 @@ _tick :: proc(io: ^IO) -> os.Errno {
 
 			sqe, err = io_uring.timeout(&io.ring, 0, &t, 1, 0)
 		}
-		if err != nil do return ring_err_to_os_err(err)
+		if err != nil { return ring_err_to_os_err(err) }
 
 		timeouts += 1
 		io.ios_queued += 1
 
 		ferr := flush(io, 1, &timeouts, &etime)
-		if ferr != os.ERROR_NONE do return ferr
+		if ferr != os.ERROR_NONE { return ferr }
 	}
 
 	for timeouts > 0 {
 		fcerr := flush_completions(io, 0, &timeouts, &etime)
-		if fcerr != os.ERROR_NONE do return fcerr
+		if fcerr != os.ERROR_NONE { return fcerr }
 	}
 
 	return os.ERROR_NONE

nbio/nbio_unix.odin

@@ -7,10 +7,10 @@ import "core:os"
 
 _open :: proc(_: ^IO, path: string, mode, perm: int) -> (handle: os.Handle, errno: os.Errno) {
 	handle, errno = os.open(path, mode, perm)
-	if errno != os.ERROR_NONE do return
+	if errno != os.ERROR_NONE { return }
 
 	errno = _prepare_handle(handle)
-	if errno != os.ERROR_NONE do os.close(handle)
+	if errno != os.ERROR_NONE { os.close(handle) }
 	return
 }
 
@@ -36,10 +36,10 @@ _open_socket :: proc(
 	err: net.Network_Error,
 ) {
 	socket, err = net.create_socket(family, protocol)
-	if err != nil do return
+	if err != nil { return }
 
 	err = _prepare_socket(socket)
-	if err != nil do net.close(socket)
+	if err != nil { net.close(socket) }
 	return
 }