all: simplify `return if ...` constructs to make more code compatible with -autofree

cmd/tools/vcomplete.v

@@ -49,7 +49,7 @@ const (
 // Snooped from cmd/v/v.v, vlib/v/pref/pref.v
 const (
 	auto_complete_commands    = [
-		/* simple_cmd */
+		// simple_cmd
 		'fmt',
 		'up',
 		'vet',
@@ -69,7 +69,7 @@ const (
 		'setup-freetype',
 		'doc',
 		'doctor',
-		/* commands */
+		// commands
 		'help',
 		'new',
 		'init',
@@ -219,7 +219,8 @@ fn auto_complete(args []string) {
 			shell := sub_args[1]
 			mut setup := ''
 			match shell {
-				'bash' { setup = '
+				'bash' {
+					setup = '
 _v_completions() {
 	local src
 	local limit
@@ -233,15 +234,19 @@ _v_completions() {
 }
 
 complete -o nospace -F _v_completions v
-' }
+'
-				'fish' { setup = '
+				}
+				'fish' {
+					setup = '
 function __v_completions
 	# Send all words up to the one before the cursor
 	$vexe complete fish (commandline -cop)
 end
 complete -f -c v -a "(__v_completions)"
-' }
+'
-				'zsh' { setup = '
+				}
+				'zsh' {
+					setup = '
 #compdef v
 _v() {
 	local src
@@ -253,15 +258,18 @@ _v() {
 	fi
 }
 compdef _v v
-' }
+'
-				'powershell' { setup = '
+				}
+				'powershell' {
+					setup = '
 Register-ArgumentCompleter -Native -CommandName v -ScriptBlock {
 	param(\$commandName, \$wordToComplete, \$cursorPosition)
 		$vexe complete powershell "\$wordToComplete" | ForEach-Object {
 			[System.Management.Automation.CompletionResult]::new(\$_, \$_, \'ParameterValue\', \$_)
 		}
 }
-' }
+'
+				}
 				else {}
 			}
 			println(setup)
@@ -307,11 +315,10 @@ Register-ArgumentCompleter -Native -CommandName v -ScriptBlock {
 // append_separator_if_dir is a utility function.that returns the input `path` appended an
 // OS dependant path separator if the `path` is a directory.
 fn append_separator_if_dir(path string) string {
-	return if os.is_dir(path) && !path.ends_with(os.path_separator) {
+	if os.is_dir(path) && !path.ends_with(os.path_separator) {
-		path + os.path_separator
+		return path + os.path_separator
-	} else {
-		path
 	}
+	return path
 }
 
 // auto_complete_request retuns a list of completions resolved from a full argument list.

cmd/tools/vdoc/html.v

@@ -356,7 +356,10 @@ fn html_highlight(code string, tb &table.Table) string {
 		} else {
 			tok.lit
 		}
-		return if typ in [.unone, .name] { lit } else { '<span class="token $typ">$lit</span>' }
+		if typ in [.unone, .name] {
+			return lit
+		}
+		return '<span class="token $typ">$lit</span>'
 	}
 	mut s := scanner.new_scanner(code, .parse_comments, &pref.Preferences{})
 	mut tok := s.scan()

vlib/builtin/string.v

@@ -982,10 +982,15 @@ pub fn (s string) capitalize() string {
 	if s.len == 0 {
 		return ''
 	}
-	return s[0].ascii_str().to_upper() + s[1..]
+	s0 := s[0]
-	// sl := s.to_lower()
+	letter := s0.ascii_str()
-	// cap := sl[0].str().to_upper() + sl[1..]
+	uletter := letter.to_upper()
-	// return cap
+	if s.len == 1 {
+		return uletter
+	}
+	srest := s[1..]
+	res := uletter + srest
+	return res
 }
 
 // is_capital returns `true` if the first character in the string is a capital letter.
@@ -1042,16 +1047,6 @@ pub fn (s string) find_between(start string, end string) string {
 	return val[..end_pos]
 }
 
-/*
-pub fn (a []string) to_c() voidptr {
-	mut res := malloc(sizeof(byteptr) * a.len)
-	for i in 0..a.len {
-		val := a[i]
-		res[i] = val.str
-	}
-	return res
-}
-*/
 // is_space returns `true` if the byte is a white space character.
 // The following list is considered white space characters: ` `, `\n`, `\t`, `\v`, `\f`, `\r`, 0x85, 0xa0
 // Example: assert byte(` `).is_space() == true
@@ -1141,7 +1136,10 @@ pub fn (s string) trim_right(cutset string) string {
 		}
 		pos--
 	}
-	return if pos < 0 { '' } else { s[..pos + 1] }
+	if pos < 0 {
+		return ''
+	}
+	return s[..pos + 1]
 }
 
 // trim_prefix strips `str` from the start of the string.

vlib/readline/readline_linux.c.v

@@ -12,6 +12,7 @@ import os
 
 #include <termios.h>
 #include <sys/ioctl.h>
+
 fn C.tcgetattr(fd int, termios_p &Termios) int
 
 fn C.tcsetattr(fd int, optional_actions int, termios_p &Termios) int
@@ -172,19 +173,36 @@ pub fn read_line(prompt string) ?string {
 // analyse returns an `Action` based on the type of input byte given in `c`.
 fn (r Readline) analyse(c int) Action {
 	match byte(c) {
-		`\0`, 0x3, 0x4, 255 { return .eof } // NUL, End of Text, End of Transmission
+		`\0`, 0x3, 0x4, 255 {
-		`\n`, `\r` { return .commit_line }
+			return .eof
-		`\f` { return .clear_screen } // CTRL + L
+		} // NUL, End of Text, End of Transmission
-		`\b`, 127 { return .delete_left } // BS, DEL
+		`\n`, `\r` {
-		27 { return r.analyse_control() } // ESC
+			return .commit_line
-		1 { return .move_cursor_begining } // ^A
+		}
-		5 { return .move_cursor_end } // ^E
+		`\f` {
-		26 { return .suspend } // CTRL + Z, SUB
+			return .clear_screen
-		else { return if c >= ` ` {
+		} // CTRL + L
-				Action.insert_character
+		`\b`, 127 {
-			} else {
+			return .delete_left
-				Action.nothing
+		} // BS, DEL
-			} }
+		27 {
+			return r.analyse_control()
+		} // ESC
+		1 {
+			return .move_cursor_begining
+		} // ^A
+		5 {
+			return .move_cursor_end
+		} // ^E
+		26 {
+			return .suspend
+		} // CTRL + Z, SUB
+		else {
+			if c >= ` ` {
+				return Action.insert_character
+			}
+			return Action.nothing
+		}
 	}
 }
 
@@ -318,8 +336,11 @@ fn calculate_screen_position(x_in int, y_in int, screen_columns int, char_count
 	out[0] = x
 	out[1] = y
 	for chars_remaining := char_count; chars_remaining > 0; {
-		chars_this_row := if (x + chars_remaining) < screen_columns { chars_remaining } else { screen_columns -
+		chars_this_row := if (x + chars_remaining) < screen_columns {
-				x }
+			chars_remaining
+		} else {
+			screen_columns - x
+		}
 		out[0] = x + chars_this_row
 		out[1] = y
 		chars_remaining -= chars_this_row
@@ -382,8 +403,8 @@ fn (mut r Readline) insert_character(c int) {
 	if !r.overwrite || r.cursor == r.current.len {
 		r.current = r.current.left(r.cursor).ustring().add(utf32_to_str(u32(c)).ustring()).add(r.current.right(r.cursor).ustring())
 	} else {
-		r.current = r.current.left(r.cursor).ustring().add(utf32_to_str(u32(c)).ustring()).add(r.current.right(r.cursor +
+		r.current = r.current.left(r.cursor).ustring().add(utf32_to_str(u32(c)).ustring()).add(r.current.right(
-			1).ustring())
+			r.cursor + 1).ustring())
 	}
 	r.cursor++
 	// Refresh the line to add the new character
@@ -445,6 +466,7 @@ fn (mut r Readline) move_cursor_begining() {
 	r.cursor = 0
 	r.refresh_line()
 }
+
 // move_cursor_end moves the cursor to the end of the current line.
 fn (mut r Readline) move_cursor_end() {
 	r.cursor = r.current.len

vlib/term/term.v

@@ -29,19 +29,28 @@ pub fn can_show_color_on_stderr() bool {
 // ok_message returns a colored string with green color.
 // If colors are not allowed, returns a given string.
 pub fn ok_message(s string) string {
-	return if can_show_color_on_stdout() { green(' $s ') } else { s }
+	if can_show_color_on_stdout() {
+		return green(' $s ')
+	}
+	return s
 }
 
 // fail_message returns a colored string with red color.
 // If colors are not allowed, returns a given string.
 pub fn fail_message(s string) string {
-	return if can_show_color_on_stdout() { inverse(bg_white(bold(red(' $s ')))) } else { s }
+	if can_show_color_on_stdout() {
+		return inverse(bg_white(bold(red(' $s '))))
+	}
+	return s
 }
 
 // warn_message returns a colored string with yellow color.
 // If colors are not allowed, returns a given string.
 pub fn warn_message(s string) string {
-	return if can_show_color_on_stdout() { bright_yellow(' $s ') } else { s }
+	if can_show_color_on_stdout() {
+		return bright_yellow(' $s ')
+	}
+	return s
 }
 
 // colorize returns a colored string by running the specified `cfn` over
@@ -59,10 +68,11 @@ pub fn colorize(cfn fn (string) string, s string) string {
 // If an empty string is passed in, print enough spaces to make a new line
 pub fn h_divider(divider string) string {
 	cols, _ := get_terminal_size()
-	result := if divider.len > 0 {
+	mut result := ''
-		divider.repeat(1 + (cols / divider.len))
+	if divider.len > 0 {
+		result = divider.repeat(1 + (cols / divider.len))
 	} else {
-		' '.repeat(1 + cols)
+		result = ' '.repeat(1 + cols)
 	}
 	return result[0..cols]
 }
@@ -83,10 +93,11 @@ pub fn header(text string, divider string) string {
 	})
 	tlimit_alligned := if (tlimit % 2) != (cols % 2) { tlimit + 1 } else { tlimit }
 	tstart := imax(0, (cols - tlimit_alligned) / 2)
-	ln := if divider.len > 0 {
+	mut ln := ''
-		divider.repeat(1 + cols / divider.len)[0..cols]
+	if divider.len > 0 {
+		ln = divider.repeat(1 + cols / divider.len)[0..cols]
 	} else {
-		' '.repeat(1 + cols)
+		ln = ' '.repeat(1 + cols)
 	}
 	if ln.len == 1 {
 		return ln + ' ' + text[0..tlimit] + ' ' + ln

vlib/v/scanner/scanner.v

@@ -1262,7 +1262,10 @@ fn (mut s Scanner) ident_char() string {
 		}
 	}
 	// Escapes a `'` character
-	return if c == "'" { '\\' + c } else { c }
+	if c == "'" {
+		return '\\' + c
+	}
+	return c
 }
 
 [inline]

vlib/v/table/table.v

@@ -705,11 +705,10 @@ pub fn (mut t Table) find_or_register_array(elem_type Type) int {
 }
 
 pub fn (mut t Table) find_or_register_array_with_dims(elem_type Type, nr_dims int) int {
-	return if nr_dims == 1 {
+	if nr_dims == 1 {
-		t.find_or_register_array(elem_type)
+		return t.find_or_register_array(elem_type)
-	} else {
-		t.find_or_register_array(t.find_or_register_array_with_dims(elem_type, nr_dims - 1))
 	}
+	return t.find_or_register_array(t.find_or_register_array_with_dims(elem_type, nr_dims - 1))
 }
 
 pub fn (mut t Table) find_or_register_array_fixed(elem_type Type, size int) int {

vlib/x/json2/decoder.v

@@ -98,18 +98,27 @@ fn (mut p Parser) decode_value() ?Any {
 			kind := p.tok.kind
 			p.next_with_err() ?
 			if p.convert_type {
-				return if kind == .float { Any(tl.f64()) } else { Any(tl.i64()) }
+				if kind == .float {
+					return Any(tl.f64())
+				}
+				return Any(tl.i64())
 			}
 			return Any(tl)
 		}
 		.bool_ {
 			lit := p.tok.lit.bytestr()
 			p.next_with_err() ?
-			return if p.convert_type { Any(lit.bool()) } else { Any(lit) }
+			if p.convert_type {
+				return Any(lit.bool())
+			}
+			return Any(lit)
 		}
 		.null {
 			p.next_with_err() ?
-			return if p.convert_type { Any(null) } else { Any('null') }
+			if p.convert_type {
+				return Any(null)
+			}
+			return Any('null')
 		}
 		.str_ {
 			str := p.tok.lit.bytestr()

vlib/x/json2/encoder.v

@@ -75,11 +75,17 @@ pub fn (f Any) json_str() string {
 		}
 		f32 {
 			str_f32 := f.str()
-			return if str_f32.ends_with('.') { '${str_f32}0' } else { str_f32 }
+			if str_f32.ends_with('.') {
+				return '${str_f32}0'
+			}
+			return str_f32
 		}
 		f64 {
 			str_f64 := f.str()
-			return if str_f64.ends_with('.') { '${str_f64}0' } else { str_f64 }
+			if str_f64.ends_with('.') {
+				return '${str_f64}0'
+			}
+			return str_f64
 		}
 		bool {
 			return f.str()
@@ -135,10 +141,10 @@ fn json_string(s string) string {
 	for char_len in char_lens {
 		if char_len == 1 {
 			chr := s[i]
-			if chr in json2.important_escapable_chars {
+			if chr in important_escapable_chars {
-				for j := 0 ; j < json2.important_escapable_chars.len; j++ {
+				for j := 0; j < important_escapable_chars.len; j++ {
-					if chr == json2.important_escapable_chars[j] {
+					if chr == important_escapable_chars[j] {
-						sb.write_string(escaped_chars[j])
+						sb.write_string(json2.escaped_chars[j])
 						break
 					}
 				}
@@ -148,7 +154,7 @@ fn json_string(s string) string {
 				sb.write_b(chr)
 			}
 		} else {
-			slice := s[i .. i + char_len]
+			slice := s[i..i + char_len]
 			hex_code := slice.utf32_code().hex()
 			if hex_code.len == 4 {
 				sb.write_string('\\u$hex_code')