diff --git a/cmd/tools/vdoc/html.v b/cmd/tools/vdoc/html.v index 40b9188294..41f09f73b6 100644 --- a/cmd/tools/vdoc/html.v +++ b/cmd/tools/vdoc/html.v @@ -266,9 +266,8 @@ fn (vd VDoc) gen_html(d doc.Doc) string { names := dc.head.name.split('.') submod_prefix = if names.len > 1 { names[0] } else { dc.head.name } mut href_name := './${dc.head.name}.html' - if (cfg.is_vlib && dc.head.name == 'builtin' && !cfg.include_readme) || - dc.head.name == 'README' - { + if (cfg.is_vlib && dc.head.name == 'builtin' && !cfg.include_readme) + || dc.head.name == 'README' { href_name = './index.html' } else if submod_prefix !in vd.docs.map(it.head.name) { href_name = '#' @@ -303,19 +302,19 @@ fn (vd VDoc) gen_html(d doc.Doc) string { header_name).replace('{{ version }}', version).replace('{{ light_icon }}', vd.assets['light_icon']).replace('{{ dark_icon }}', vd.assets['dark_icon']).replace('{{ menu_icon }}', vd.assets['menu_icon']).replace('{{ head_assets }}', if cfg.inline_assets { - '\n${tabs[0]}\n${tabs[0]}\n${tabs[0]}' + '\n${tabs[0]}\n${tabs[0]}\n${tabs[0]}' } else { - '\n${tabs[0]}\n${tabs[0]}\n${tabs[0]}' + '\n${tabs[0]}\n${tabs[0]}\n${tabs[0]}' }).replace('{{ toc_links }}', if cfg.is_multi || vd.docs.len > 1 { modules_toc_str } else { symbols_toc_str - }).replace('{{ contents }}', contents.str()).replace('{{ right_content }}', if cfg.is_multi && - vd.docs.len > 1 && d.head.name != 'README' - { + }).replace('{{ contents }}', contents.str()).replace('{{ right_content }}', if cfg.is_multi + && vd.docs.len > 1&& d.head.name != 'README' { '
' } else { '' @@ -405,9 +404,8 @@ fn html_highlight(code string, tb &table.Table) string { else { if token.is_key(tok.lit) || token.is_decl(tok.kind) { tok_typ = .keyword - } else if tok.kind == .decl_assign || tok.kind.is_assign() || tok.is_unary() || - tok.kind.is_relational() || tok.kind.is_infix() - { + } else if tok.kind == .decl_assign || tok.kind.is_assign() || tok.is_unary() + || tok.kind.is_relational()|| tok.kind.is_infix() { tok_typ = .operator } } diff --git a/cmd/tools/vdoc/vdoc.v b/cmd/tools/vdoc/vdoc.v index 86ceb708d4..70c2324215 100644 --- a/cmd/tools/vdoc/vdoc.v +++ b/cmd/tools/vdoc/vdoc.v @@ -467,8 +467,8 @@ fn parse_arguments(args []string) Config { } $else { cfg.input_path = cfg.input_path.replace('\\', os.path_separator) } - is_path := cfg.input_path.ends_with('.v') || cfg.input_path.split(os.path_separator).len > - 1 || cfg.input_path == '.' + is_path := cfg.input_path.ends_with('.v') || cfg.input_path.split(os.path_separator).len > 1 + || cfg.input_path == '.' if cfg.input_path.trim_right('/') == 'vlib' { cfg.is_vlib = true cfg.is_multi = true diff --git a/cmd/tools/vvet/vvet.v b/cmd/tools/vvet/vvet.v index 557a4420a9..e84664d41d 100644 --- a/cmd/tools/vvet/vvet.v +++ b/cmd/tools/vvet/vvet.v @@ -159,9 +159,8 @@ fn (mut vt Vet) vet_file(path string, is_regression_test bool) { // vet_line vets the contents of `line` from `vet.file`. fn (mut vet Vet) vet_line(lines []string, line string, lnumber int) { // Vet public functions - if line.starts_with('pub fn') || - (line.starts_with('fn ') && !(line.starts_with('fn C.') || line.starts_with('fn main'))) - { + if line.starts_with('pub fn') || (line.starts_with('fn ') && !(line.starts_with('fn C.') + || line.starts_with('fn main'))) { // Scan function declarations for missing documentation is_pub_fn := line.starts_with('pub fn') if lnumber > 0 { diff --git a/doc/docs.md b/doc/docs.md index 5e10d30262..b06597b989 100644 --- a/doc/docs.md +++ b/doc/docs.md @@ -2097,9 +2097,7 @@ fn (r Repo) find_user_by_id(id int) ?User { fn main() { repo := Repo{ - users: [User{1, 'Andrew'}, User{2, 'Bob'}, - User{10, 'Charles'}, - ] + users: [User{1, 'Andrew'}, User{2, 'Bob'}, User{10, 'Charles'}] } user := repo.find_user_by_id(10) or { // Option types must be handled by `or` blocks return diff --git a/vlib/benchmark/benchmark.v b/vlib/benchmark/benchmark.v index cb79b6c8ea..5c1c5f1d35 100644 --- a/vlib/benchmark/benchmark.v +++ b/vlib/benchmark/benchmark.v @@ -199,8 +199,7 @@ pub fn (b &Benchmark) total_message(msg string) string { if b.nskip > 0 { tmsg += term.colorize(term.bold, term.colorize(term.yellow, '$b.nskip skipped')) + ', ' } - tmsg += '$b.ntotal total. ${term.colorize(term.bold, 'Runtime:')} ${b.bench_timer.elapsed().microseconds() / - 1000} ms.\n' + tmsg += '$b.ntotal total. ${term.colorize(term.bold, 'Runtime:')} ${b.bench_timer.elapsed().microseconds() / 1000} ms.\n' tmsg += term.colorize(term.gray, msg) return tmsg } diff --git a/vlib/bitfield/bitfield.v b/vlib/bitfield/bitfield.v index c8cf9664d1..e12202e617 100644 --- a/vlib/bitfield/bitfield.v +++ b/vlib/bitfield/bitfield.v @@ -353,8 +353,8 @@ pub fn (input BitField) slice(_start int, _end int) BitField { if start_offset != 0 { for i in 0 .. output_slots - 1 { output.field[i] = u32(input.field[start_slot + i] >> u32(start_offset)) - output.field[i] = output.field[i] | u32(input.field[start_slot + i + 1] << u32(slot_size - - start_offset)) + output.field[i] = output.field[i] | u32(input.field[start_slot + i + + 1] << u32(slot_size - start_offset)) } } else { for i in 0 .. output_slots - 1 { @@ -458,8 +458,7 @@ fn (mut instance BitField) clear_tail() { // create a mask for the tail mask := u32((1 << tail) - 1) // clear the extra bits - instance.field[zbitnslots(instance.size) - 1] = instance.field[zbitnslots(instance.size) - - 1] & mask + instance.field[zbitnslots(instance.size) - 1] = instance.field[zbitnslots(instance.size) - 1] & mask } } diff --git a/vlib/builtin/array.v b/vlib/builtin/array.v index 4c95018a57..07214fad51 100644 --- a/vlib/builtin/array.v +++ b/vlib/builtin/array.v @@ -447,8 +447,8 @@ pub fn (mut a array) reverse_in_place() { mut tmp_value := malloc(a.element_size) for i in 0 .. a.len / 2 { C.memcpy(tmp_value, byteptr(a.data) + i * a.element_size, a.element_size) - C.memcpy(byteptr(a.data) + i * a.element_size, byteptr(a.data) + (a.len - 1 - i) * - a.element_size, a.element_size) + C.memcpy(byteptr(a.data) + i * a.element_size, byteptr(a.data) + + (a.len - 1 - i) * a.element_size, a.element_size) C.memcpy(byteptr(a.data) + (a.len - 1 - i) * a.element_size, tmp_value, a.element_size) } free(tmp_value) diff --git a/vlib/builtin/array_test.v b/vlib/builtin/array_test.v index abdab85c05..8e00a0af50 100644 --- a/vlib/builtin/array_test.v +++ b/vlib/builtin/array_test.v @@ -383,25 +383,20 @@ fn test_mutli_array_clone() { assert b2_1 == [['1', '0', '3'], ['4', '5', '6']] assert b2_2 == [['1', '2', '3'], ['0', '5', '6']] // 3d array_int - mut a3_1 := [[[1, 1], [2, 2], [3, 3]], - [[4, 4], [5, 5], [6, 6]], - ] + mut a3_1 := [[[1, 1], [2, 2], [3, 3]], [[4, 4], [5, 5], [6, 6]]] mut a3_2 := a3_1.clone() a3_1[0][0][1] = 0 a3_2[0][1][0] = 0 assert a3_1 == [[[1, 0], [2, 2], [3, 3]], [[4, 4], [5, 5], [6, 6]]] assert a3_2 == [[[1, 1], [0, 2], [3, 3]], [[4, 4], [5, 5], [6, 6]]] // 3d array_string - mut b3_1 := [[['1', '1'], ['2', '2'], - ['3', '3'], - ], [['4', '4'], ['5', '5'], ['6', '6']]] + mut b3_1 := [[['1', '1'], ['2', '2'], ['3', '3']], [['4', '4'], + ['5', '5'], ['6', '6']]] mut b3_2 := b3_1.clone() b3_1[0][0][1] = '0' b3_2[0][1][0] = '0' - assert b3_1 == - [[['1', '0'], ['2', '2'], ['3', '3']], [['4', '4'], ['5', '5'], ['6', '6']]] - assert b3_2 == - [[['1', '1'], ['0', '2'], ['3', '3']], [['4', '4'], ['5', '5'], ['6', '6']]] + assert b3_1 == [[['1', '0'], ['2', '2'], ['3', '3']], [['4', '4'], ['5', '5'], ['6', '6']]] + assert b3_2 == [[['1', '1'], ['0', '2'], ['3', '3']], [['4', '4'], ['5', '5'], ['6', '6']]] } fn test_doubling() { @@ -718,8 +713,7 @@ fn test_sort() { assert nums[3] == 67 assert nums[4] == 108 // - mut users := [User{22, 'Peter'}, - User{20, 'Bob'}, User{25, 'Alice'}] + mut users := [User{22, 'Peter'}, User{20, 'Bob'}, User{25, 'Alice'}] users.sort(a.age < b.age) assert (users[0].age == 20) assert (users[1].age == 22) diff --git a/vlib/cli/flag.v b/vlib/cli/flag.v index 31c5840fc1..5e5f265ca2 100644 --- a/vlib/cli/flag.v +++ b/vlib/cli/flag.v @@ -221,13 +221,13 @@ fn (mut flag Flag) parse(args []string, with_abbrev bool) ?[]string { // matches returns `true` if first arg in `args` matches this flag. fn (mut flag Flag) matches(args []string, with_abbrev bool) bool { if with_abbrev { - return (flag.name != '' && args[0] == '--$flag.name') || - (flag.name != '' && args[0].starts_with('--$flag.name=')) || - (flag.abbrev != '' && args[0] == '-$flag.abbrev') || - (flag.abbrev != '' && args[0].starts_with('-$flag.abbrev=')) + return (flag.name != '' && args[0] == '--$flag.name') + || (flag.name != '' && args[0].starts_with('--$flag.name=')) + || (flag.abbrev != '' && args[0] == '-$flag.abbrev') + || (flag.abbrev != '' && args[0].starts_with('-$flag.abbrev=')) } else { - return (flag.name != '' && args[0] == '-$flag.name') || - (flag.name != '' && args[0].starts_with('-$flag.name=')) + return (flag.name != '' && args[0] == '-$flag.name') + || (flag.name != '' && args[0].starts_with('-$flag.name=')) } } diff --git a/vlib/cli/help.v b/vlib/cli/help.v index 0a58f8e755..4a28e820f0 100644 --- a/vlib/cli/help.v +++ b/vlib/cli/help.v @@ -111,8 +111,8 @@ fn (cmd Command) help_message() string { } base_indent := ' '.repeat(base_indent_len) description_indent := ' '.repeat(name_len - flag_name.len) - help += '$base_indent$flag_name$description_indent' + pretty_description(flag.description + - required, base_indent_len + name_len) + '\n' + help += '$base_indent$flag_name$description_indent' + + pretty_description(flag.description + required, base_indent_len + name_len) + '\n' } } if cmd.commands.len > 0 { @@ -120,8 +120,8 @@ fn (cmd Command) help_message() string { for command in cmd.commands { base_indent := ' '.repeat(base_indent_len) description_indent := ' '.repeat(name_len - command.name.len) - help += '$base_indent$command.name$description_indent' + pretty_description(command.description, name_len) + - '\n' + help += '$base_indent$command.name$description_indent' + + pretty_description(command.description, name_len) + '\n' } } return help diff --git a/vlib/gg/text_rendering.v b/vlib/gg/text_rendering.v index da301a422b..5ef49f805e 100644 --- a/vlib/gg/text_rendering.v +++ b/vlib/gg/text_rendering.v @@ -184,8 +184,8 @@ pub fn (ctx &Context) text_width(s string) int { mut buf := [4]f32{} C.fonsTextBounds(ctx.ft.fons, 0, 0, s.str, 0, buf) if s.ends_with(' ') { - return int((buf[2] - buf[0]) / - ctx.scale) + ctx.text_width('i') // TODO fix this in fontstash? + return int((buf[2] - buf[0]) / ctx.scale) + + ctx.text_width('i') // TODO fix this in fontstash? } return int((buf[2] - buf[0]) / ctx.scale) } diff --git a/vlib/math/big/big_test.v b/vlib/math/big/big_test.v index 005b67d1b2..2a529777f3 100644 --- a/vlib/math/big/big_test.v +++ b/vlib/math/big/big_test.v @@ -117,14 +117,12 @@ fn test_str() { assert big.from_u64(4398046511104).str() == '4398046511104' assert big.from_int(4294967295).str() == '18446744073709551615' assert big.from_int(-1).str() == '18446744073709551615' - assert big.from_hex_string('e'.repeat(80)).str() == - '1993587900192849410235353592424915306962524220866209251950572167300738410728597846688097947807470' + assert big.from_hex_string('e'.repeat(80)).str() == '1993587900192849410235353592424915306962524220866209251950572167300738410728597846688097947807470' } fn test_factorial() { f5 := big.factorial(big.from_u64(5)) assert f5.hexstr() == '78' f100 := big.factorial(big.from_u64(100)) - assert f100.hexstr() == - '1b30964ec395dc24069528d54bbda40d16e966ef9a70eb21b5b2943a321cdf10391745570cca9420c6ecb3b72ed2ee8b02ea2735c61a000000000000000000000000' + assert f100.hexstr() == '1b30964ec395dc24069528d54bbda40d16e966ef9a70eb21b5b2943a321cdf10391745570cca9420c6ecb3b72ed2ee8b02ea2735c61a000000000000000000000000' } diff --git a/vlib/math/bits/bits.v b/vlib/math/bits/bits.v index 990eed8464..e7b59ba2f8 100644 --- a/vlib/math/bits/bits.v +++ b/vlib/math/bits/bits.v @@ -107,8 +107,8 @@ pub fn ones_count_16(x u16) int { // ones_count_32 returns the number of one bits ("population count") in x. pub fn ones_count_32(x u32) int { - return int(pop_8_tab[x >> 24] + pop_8_tab[x >> 16 & 0xff] + pop_8_tab[x >> 8 & 0xff] + pop_8_tab[x & - u32(0xff)]) + return int(pop_8_tab[x >> 24] + pop_8_tab[x >> 16 & 0xff] + pop_8_tab[x >> 8 & 0xff] + + pop_8_tab[x & u32(0xff)]) } // ones_count_64 returns the number of one bits ("population count") in x. diff --git a/vlib/os/os.v b/vlib/os/os.v index f33c8350fe..79f098e81c 100644 --- a/vlib/os/os.v +++ b/vlib/os/os.v @@ -396,7 +396,7 @@ pub fn is_file(path string) bool { // is_abs_path returns `true` if `path` is absolute. pub fn is_abs_path(path string) bool { $if windows { - return path[0] == `/` || // incase we're in MingGW bash + return path[0] == `/` || // incase we're in MingGW bash (path[0].is_letter() && path[1] == `:`) } return path[0] == `/` diff --git a/vlib/os/os_c.v b/vlib/os/os_c.v index e4fd1d73b4..9ad7e7d10b 100644 --- a/vlib/os/os_c.v +++ b/vlib/os/os_c.v @@ -771,9 +771,8 @@ fn normalize_drive_letter(path string) string { $if !windows { return path } - if path.len > 2 && - path[0] >= `a` && path[0] <= `z` && path[1] == `:` && path[2] == path_separator[0] - { + if path.len > 2 && path[0] >= `a` && path[0] <= `z` && path[1] == `:` + && path[2] == path_separator[0] { unsafe { x := &path.str[0] (*x) = *x - 32 diff --git a/vlib/os/os_nix.c.v b/vlib/os/os_nix.c.v index 048168b864..cccd975c70 100644 --- a/vlib/os/os_nix.c.v +++ b/vlib/os/os_nix.c.v @@ -92,10 +92,8 @@ pub fn ls(path string) ?[]string { } bptr := byteptr(ent.d_name) unsafe { - if bptr[0] == 0 || - (bptr[0] == `.` && bptr[1] == 0) || - (bptr[0] == `.` && bptr[1] == `.` && bptr[2] == 0) - { + if bptr[0] == 0 || (bptr[0] == `.` && bptr[1] == 0) + || (bptr[0] == `.` && bptr[1] == `.` && bptr[2] == 0) { continue } } diff --git a/vlib/os/os_windows.c.v b/vlib/os/os_windows.c.v index ccbcb2fffd..725bbc9c6b 100644 --- a/vlib/os/os_windows.c.v +++ b/vlib/os/os_windows.c.v @@ -135,7 +135,8 @@ pub fn mkdir(path string) ?bool { } apath := real_path(path) if !C.CreateDirectory(apath.to_wide(), 0) { - return error('mkdir failed for "$apath", because CreateDirectory returned ' + get_error_msg(int(C.GetLastError()))) + return error('mkdir failed for "$apath", because CreateDirectory returned ' + + get_error_msg(int(C.GetLastError()))) } return true } diff --git a/vlib/semver/compare.v b/vlib/semver/compare.v index 991994783a..0b51d299bc 100644 --- a/vlib/semver/compare.v +++ b/vlib/semver/compare.v @@ -8,8 +8,8 @@ fn version_satisfies(ver Version, input string) bool { } fn compare_eq(v1 Version, v2 Version) bool { - return v1.major == v2.major && - v1.minor == v2.minor && v1.patch == v2.patch && v1.prerelease == v2.prerelease + return v1.major == v2.major && v1.minor == v2.minor && v1.patch == v2.patch + && v1.prerelease == v2.prerelease } fn compare_gt(v1 Version, v2 Version) bool { diff --git a/vlib/semver/parse.v b/vlib/semver/parse.v index 9acbeaf6a6..ed46859c6d 100644 --- a/vlib/semver/parse.v +++ b/vlib/semver/parse.v @@ -43,8 +43,9 @@ fn (ver RawVersion) is_valid() bool { if ver.raw_ints.len != 3 { return false } - return is_valid_number(ver.raw_ints[ver_major]) && is_valid_number(ver.raw_ints[ver_minor]) && - is_valid_number(ver.raw_ints[ver_patch]) && is_valid_string(ver.prerelease) && is_valid_string(ver.metadata) + return is_valid_number(ver.raw_ints[ver_major]) && is_valid_number(ver.raw_ints[ver_minor]) + && is_valid_number(ver.raw_ints[ver_patch]) && is_valid_string(ver.prerelease) + && is_valid_string(ver.metadata) } fn (ver RawVersion) is_missing(typ int) bool { diff --git a/vlib/semver/range.v b/vlib/semver/range.v index 54c7f927fa..675b546427 100644 --- a/vlib/semver/range.v +++ b/vlib/semver/range.v @@ -139,8 +139,8 @@ fn parse_xrange(input string) ?Version { } fn can_expand(input string) bool { - return input[0] == `~` || - input[0] == `^` || input.contains(hyphen_range_sep) || input.index_any(x_range_symbols) > -1 + return input[0] == `~` || input[0] == `^` || input.contains(hyphen_range_sep) + || input.index_any(x_range_symbols) > -1 } fn expand_comparator_set(input string) ?ComparatorSet { diff --git a/vlib/term/term.v b/vlib/term/term.v index 0cb4b7f5a6..ae45794952 100644 --- a/vlib/term/term.v +++ b/vlib/term/term.v @@ -71,8 +71,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 { divider.repeat(1 + (cols / divider.len)) } else { ' '.repeat(1 + - cols) } + result := if divider.len > 0 { + divider.repeat(1 + (cols / divider.len)) + } else { + ' '.repeat(1 + cols) + } return result[0..cols] } @@ -85,12 +88,18 @@ pub fn header(text string, divider string) string { } xcols, _ := get_terminal_size() cols := imax(1, xcols) - tlimit := imax(1, if cols > text.len + 2 + 2 * divider.len { text.len } else { cols - 3 - - 2 * divider.len }) + tlimit := imax(1, if cols > text.len + 2 + 2 * divider.len { + text.len + } else { + cols - 3 - 2 * divider.len + }) tlimit_alligned := if (tlimit % 2) != (cols % 2) { tlimit + 1 } else { tlimit } tstart := imax(0, (cols - tlimit_alligned) / 2) - ln := if divider.len > 0 { divider.repeat(1 + cols / divider.len)[0..cols] } else { ' '.repeat(1 + - cols) } + ln := if divider.len > 0 { + divider.repeat(1 + cols / divider.len)[0..cols] + } else { + ' '.repeat(1 + cols) + } if ln.len == 1 { return ln + ' ' + text[0..tlimit] + ' ' + ln } diff --git a/vlib/time/parse_test.v b/vlib/time/parse_test.v index eeeeaca5b6..de7df377cc 100644 --- a/vlib/time/parse_test.v +++ b/vlib/time/parse_test.v @@ -6,8 +6,8 @@ fn test_parse() { assert false return } - assert t.year == 2018 && - t.month == 1 && t.day == 27 && t.hour == 12 && t.minute == 48 && t.second == 34 + assert t.year == 2018 && t.month == 1 && t.day == 27 && t.hour == 12 && t.minute == 48 + && t.second == 34 assert t.unix == 1517057314 } @@ -26,16 +26,16 @@ fn test_parse_rfc2822() { assert false return } - assert t1.year == 2019 && - t1.month == 12 && t1.day == 12 && t1.hour == 6 && t1.minute == 7 && t1.second == 45 + assert t1.year == 2019 && t1.month == 12 && t1.day == 12 && t1.hour == 6 && t1.minute == 7 + && t1.second == 45 assert t1.unix == 1576130865 s2 := 'Thu 12 Dec 2019 06:07:45 +0800' t2 := time.parse_rfc2822(s2) or { assert false return } - assert t2.year == 2019 && - t2.month == 12 && t2.day == 12 && t2.hour == 6 && t2.minute == 7 && t2.second == 45 + assert t2.year == 2019 && t2.month == 12 && t2.day == 12 && t2.hour == 6 && t2.minute == 7 + && t2.second == 45 assert t2.unix == 1576130865 } diff --git a/vlib/time/time_test.v b/vlib/time/time_test.v index 858a9231fc..19911c2e88 100644 --- a/vlib/time/time_test.v +++ b/vlib/time/time_test.v @@ -87,14 +87,12 @@ fn test_format_ss() { } fn test_format_ss_milli() { - assert '11.07.1980 21:23:42.123' == - time_to_test.get_fmt_str(.dot, .hhmmss24_milli, .ddmmyyyy) + assert '11.07.1980 21:23:42.123' == time_to_test.get_fmt_str(.dot, .hhmmss24_milli, .ddmmyyyy) assert '1980-07-11 21:23:42.123' == time_to_test.format_ss_milli() } fn test_format_ss_micro() { - assert '11.07.1980 21:23:42.123456' == - time_to_test.get_fmt_str(.dot, .hhmmss24_micro, .ddmmyyyy) + assert '11.07.1980 21:23:42.123456' == time_to_test.get_fmt_str(.dot, .hhmmss24_micro, .ddmmyyyy) assert '1980-07-11 21:23:42.123456' == time_to_test.format_ss_micro() } diff --git a/vlib/v/ast/str.v b/vlib/v/ast/str.v index be82f7f90e..266547a9ad 100644 --- a/vlib/v/ast/str.v +++ b/vlib/v/ast/str.v @@ -133,8 +133,9 @@ pub fn (node &FnDecl) stringify(t &table.Table, cur_mod string, m2a map[string]s // must be enclosed in braces. pub fn (lit &StringInterLiteral) get_fspec_braces(i int) (string, bool) { mut res := []string{} - needs_fspec := lit.need_fmts[i] || lit.pluss[i] || - (lit.fills[i] && lit.fwidths[i] >= 0) || lit.fwidths[i] != 0 || lit.precisions[i] != 987698 + needs_fspec := lit.need_fmts[i] || lit.pluss[i] + || (lit.fills[i] && lit.fwidths[i] >= 0) || lit.fwidths[i] != 0 + || lit.precisions[i] != 987698 mut needs_braces := needs_fspec if !needs_braces { if i + 1 < lit.vals.len && lit.vals[i + 1].len > 0 { diff --git a/vlib/v/builder/builder.v b/vlib/v/builder/builder.v index e61086b8d7..617b796d8c 100644 --- a/vlib/v/builder/builder.v +++ b/vlib/v/builder/builder.v @@ -239,9 +239,8 @@ pub fn (b &Builder) find_module_path(mod string, fpath string) ?string { vmod_file_location := mcache.get_by_file(fpath) mod_path := module_path(mod) mut module_lookup_paths := []string{} - if vmod_file_location.vmod_file.len != 0 && - vmod_file_location.vmod_folder !in b.module_search_paths - { + if vmod_file_location.vmod_file.len != 0 + && vmod_file_location.vmod_folder !in b.module_search_paths { module_lookup_paths << vmod_file_location.vmod_folder } module_lookup_paths << b.module_search_paths diff --git a/vlib/v/builder/cc.v b/vlib/v/builder/cc.v index 717d8a2102..dc789d5b5a 100644 --- a/vlib/v/builder/cc.v +++ b/vlib/v/builder/cc.v @@ -211,9 +211,8 @@ fn (mut v Builder) setup_ccompiler_options(ccompiler string) { // deliberately guessing only for -prod builds for performance reasons if ccversion := os.exec('cc --version') { if ccversion.exit_code == 0 { - if ccversion.output.contains('This is free software;') && - ccversion.output.contains('Free Software Foundation, Inc.') - { + if ccversion.output.contains('This is free software;') + && ccversion.output.contains('Free Software Foundation, Inc.') { ccoptions.guessed_compiler = 'gcc' } if ccversion.output.contains('clang version ') { @@ -353,9 +352,8 @@ fn (mut v Builder) setup_ccompiler_options(ccompiler string) { } // Without these libs compilation will fail on Linux // || os.user_os() == 'linux' - if !v.pref.is_bare && v.pref.build_mode != .build_module && v.pref.os in - [.linux, .freebsd, .openbsd, .netbsd, .dragonfly, .solaris, .haiku] - { + if !v.pref.is_bare && v.pref.build_mode != .build_module + && v.pref.os in [.linux, .freebsd, .openbsd, .netbsd, .dragonfly, .solaris, .haiku] { ccoptions.linker_flags << '-lm' ccoptions.linker_flags << '-lpthread' // -ldl is a Linux only thing. BSDs have it in libc. @@ -402,9 +400,8 @@ fn (ccoptions CcompilerOptions) thirdparty_object_args(middle []string) []string } fn (mut v Builder) setup_output_name() { - if !v.pref.is_shared && v.pref.build_mode != .build_module && os.user_os() == 'windows' && - !v.pref.out_name.ends_with('.exe') - { + if !v.pref.is_shared && v.pref.build_mode != .build_module && os.user_os() == 'windows' + && !v.pref.out_name.ends_with('.exe') { v.pref.out_name += '.exe' } // Output executable name @@ -658,8 +655,10 @@ fn (mut v Builder) cc() { if res.exit_code == 127 { verror('C compiler error, while attempting to run: \n' + '-----------------------------------------------------------\n' + '$cmd\n' + - '-----------------------------------------------------------\n' + 'Probably your C compiler is missing. \n' + - 'Please reinstall it, or make it available in your PATH.\n\n' + missing_compiler_info()) + '-----------------------------------------------------------\n' + + 'Probably your C compiler is missing. \n' + + 'Please reinstall it, or make it available in your PATH.\n\n' + + missing_compiler_info()) } } if !v.pref.show_c_output { @@ -716,8 +715,7 @@ fn (mut v Builder) cc() { println('install upx with `brew install upx`') } $if linux { - println('install upx\n' + - 'for example, on Debian/Ubuntu run `sudo apt install upx`') + println('install upx\n' + 'for example, on Debian/Ubuntu run `sudo apt install upx`') } $if windows { // :) diff --git a/vlib/v/builder/cflags.v b/vlib/v/builder/cflags.v index 8d6c0bdaaa..1486f692b0 100644 --- a/vlib/v/builder/cflags.v +++ b/vlib/v/builder/cflags.v @@ -14,15 +14,13 @@ fn (mut v Builder) get_os_cflags() []cflag.CFlag { if flag.value.ends_with('.o') { flag.cached = v.pref.cache_manager.postfix_with_key2cpath('.o', os.real_path(flag.value)) } - if flag.os == '' || - (flag.os == 'linux' && v.pref.os == .linux) || - (flag.os == 'macos' && v.pref.os == .macos) || - (flag.os == 'darwin' && v.pref.os == .macos) || - (flag.os == 'freebsd' && v.pref.os == .freebsd) || - (flag.os == 'windows' && v.pref.os == .windows) || - (flag.os == 'mingw' && v.pref.os == .windows && v.pref.ccompiler != 'msvc') || - (flag.os == 'solaris' && v.pref.os == .solaris) - { + if flag.os == '' || (flag.os == 'linux' && v.pref.os == .linux) + || (flag.os == 'macos' && v.pref.os == .macos) + || (flag.os == 'darwin' && v.pref.os == .macos) + || (flag.os == 'freebsd' && v.pref.os == .freebsd) + || (flag.os == 'windows' && v.pref.os == .windows) + || (flag.os == 'mingw' && v.pref.os == .windows && v.pref.ccompiler != 'msvc') + || (flag.os == 'solaris' && v.pref.os == .solaris) { flags << flag } if flag.os in ctimedefines { diff --git a/vlib/v/builder/compile.v b/vlib/v/builder/compile.v index b45ba0231f..780f99ff4d 100644 --- a/vlib/v/builder/compile.v +++ b/vlib/v/builder/compile.v @@ -15,7 +15,8 @@ fn (mut b Builder) get_vtmp_filename(base_file_name string, postfix string) stri if !b.pref.reuse_tmpc { uniq = '.$rand.u64()' } - return os.real_path(os.join_path(vtmp, os.file_name(os.real_path(base_file_name)) + '$uniq$postfix')) + return os.real_path(os.join_path(vtmp, os.file_name(os.real_path(base_file_name)) + + '$uniq$postfix')) } pub fn compile(command string, pref &pref.Preferences) { diff --git a/vlib/v/builder/msvc.v b/vlib/v/builder/msvc.v index 500b4228f0..c238182314 100644 --- a/vlib/v/builder/msvc.v +++ b/vlib/v/builder/msvc.v @@ -81,8 +81,8 @@ fn find_windows_kit_root(host_arch string) ?WindowsKit { $if windows { root_key := RegKey(0) path := 'SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots' - rc := C.RegOpenKeyEx(hkey_local_machine, path.to_wide(), 0, key_query_value | key_wow64_32key | - key_enumerate_sub_keys, &root_key) + rc := C.RegOpenKeyEx(hkey_local_machine, path.to_wide(), 0, key_query_value | key_wow64_32key | key_enumerate_sub_keys, + &root_key) // TODO: Fix defer inside ifs // defer { // C.RegCloseKey(root_key) diff --git a/vlib/v/builder/x64.v b/vlib/v/builder/x64.v index 03d30c4956..2b276d0610 100644 --- a/vlib/v/builder/x64.v +++ b/vlib/v/builder/x64.v @@ -8,7 +8,8 @@ import v.gen.x64 pub fn (mut b Builder) build_x64(v_files []string, out_file string) { $if !linux { println('v -x64 can only generate Linux binaries for now') - println('You are not on a Linux system, so you will not ' + 'be able to run the resulting executable') + println('You are not on a Linux system, so you will not ' + + 'be able to run the resulting executable') } b.timing_start('PARSE') b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope) diff --git a/vlib/v/checker/check_types.v b/vlib/v/checker/check_types.v index fad58f7766..7d4b2fdab8 100644 --- a/vlib/v/checker/check_types.v +++ b/vlib/v/checker/check_types.v @@ -56,26 +56,20 @@ pub fn (mut c Checker) check_basic(got table.Type, expected table.Type) bool { return true } // TODO i64 as int etc - if (exp_idx in table.pointer_type_idxs || - exp_idx in table.number_type_idxs) && - (got_idx in table.pointer_type_idxs || got_idx in table.number_type_idxs) - { + if (exp_idx in table.pointer_type_idxs || exp_idx in table.number_type_idxs) + && (got_idx in table.pointer_type_idxs || got_idx in table.number_type_idxs) { return true } // if exp_idx in pointer_type_idxs && got_idx in pointer_type_idxs { // return true // } // see hack in checker IndexExpr line #691 - if (got_idx == table.byte_type_idx && - exp_idx == table.byteptr_type_idx) || - (exp_idx == table.byte_type_idx && got_idx == table.byteptr_type_idx) - { + if (got_idx == table.byte_type_idx && exp_idx == table.byteptr_type_idx) + || (exp_idx == table.byte_type_idx && got_idx == table.byteptr_type_idx) { return true } - if (got_idx == table.char_type_idx && - exp_idx == table.charptr_type_idx) || - (exp_idx == table.char_type_idx && got_idx == table.charptr_type_idx) - { + if (got_idx == table.char_type_idx && exp_idx == table.charptr_type_idx) + || (exp_idx == table.char_type_idx && got_idx == table.charptr_type_idx) { return true } // TODO: this should no longer be needed @@ -110,16 +104,13 @@ pub fn (mut c Checker) check_basic(got table.Type, expected table.Type) bool { } // TODO // accept [] when an expected type is an array - if got_type_sym.kind == .array && - exp_type_sym.kind == .array && got_type_sym.name == 'array_void' - { + if got_type_sym.kind == .array && exp_type_sym.kind == .array + && got_type_sym.name == 'array_void' { return true } // type alias - if (got_type_sym.kind == .alias && - got_type_sym.parent_idx == exp_idx) || - (exp_type_sym.kind == .alias && exp_type_sym.parent_idx == got_idx) - { + if (got_type_sym.kind == .alias && got_type_sym.parent_idx == exp_idx) + || (exp_type_sym.kind == .alias && exp_type_sym.parent_idx == got_idx) { return true } // sum type @@ -242,9 +233,8 @@ fn (c &Checker) promote_num(left_type table.Type, right_type table.Type) table.T } } else if idx_lo >= table.byte_type_idx { // both operands are unsigned return type_hi - } else if idx_lo >= table.i8_type_idx && - (idx_hi <= table.i64_type_idx || idx_hi == table.rune_type_idx) - { // both signed + } else if idx_lo >= table.i8_type_idx + && (idx_hi <= table.i64_type_idx || idx_hi == table.rune_type_idx) { // both signed return if idx_lo == table.i64_type_idx { type_lo } else { @@ -363,11 +353,9 @@ pub fn (c &Checker) get_default_fmt(ftyp table.Type, typ table.Type) byte { if sym.kind == .function { return `s` } - if ftyp in [table.string_type, table.bool_type] || - sym.kind in - [.enum_, .array, .array_fixed, .struct_, .map, .multi_return, .sum_type, .none_] || - ftyp.has_flag(.optional) || sym.has_method('str') - { + if ftyp in [table.string_type, table.bool_type] + || sym.kind in [.enum_, .array, .array_fixed, .struct_, .map, .multi_return, .sum_type, .none_] + || ftyp.has_flag(.optional)|| sym.has_method('str') { return `s` } else { return `_` @@ -382,9 +370,7 @@ pub fn (mut c Checker) string_inter_lit(mut node ast.StringInterLiteral) table.T typ := c.table.unalias_num_type(ftyp) mut fmt := node.fmts[i] // analyze and validate format specifier - if fmt !in - [`E`, `F`, `G`, `e`, `f`, `g`, `d`, `u`, `x`, `X`, `o`, `c`, `s`, `p`, `_`] - { + if fmt !in [`E`, `F`, `G`, `e`, `f`, `g`, `d`, `u`, `x`, `X`, `o`, `c`, `s`, `p`, `_`] { c.error('unknown format specifier `${fmt:c}`', node.fmt_poss[i]) } if fmt == `_` { // set default representation for type if none has been given @@ -405,14 +391,13 @@ pub fn (mut c Checker) string_inter_lit(mut node ast.StringInterLiteral) table.T if node.pluss[i] && !typ.is_number() { c.error('plus prefix only allowed for numbers', node.fmt_poss[i]) } - if (typ.is_unsigned() && fmt !in [`u`, `x`, `X`, `o`, `c`]) || - (typ.is_signed() && fmt !in [`d`, `x`, `X`, `o`, `c`]) || - (typ.is_int_literal() && fmt !in [`d`, `c`, `x`, `X`, `o`, `u`, `x`, `X`, `o`]) || - (typ.is_float() && fmt !in [`E`, `F`, `G`, `e`, `f`, `g`]) || - (typ.is_pointer() && fmt !in [`p`, `x`, `X`]) || - (typ.is_string() && fmt != `s`) || - (typ.idx() in [table.i64_type_idx, table.f64_type_idx] && fmt == `c`) - { + if (typ.is_unsigned() && fmt !in [`u`, `x`, `X`, `o`, `c`]) + || (typ.is_signed() && fmt !in [`d`, `x`, `X`, `o`, `c`]) + || (typ.is_int_literal() && fmt !in [`d`, `c`, `x`, `X`, `o`, `u`, `x`, `X`, `o`]) + || (typ.is_float() && fmt !in [`E`, `F`, `G`, `e`, `f`, `g`]) + || (typ.is_pointer() && fmt !in [`p`, `x`, `X`]) + || (typ.is_string() && fmt != `s`) + || (typ.idx() in [table.i64_type_idx, table.f64_type_idx] && fmt == `c`) { c.error('illegal format specifier `${fmt:c}` for type `${c.table.get_type_name(ftyp)}`', node.fmt_poss[i]) } @@ -456,10 +441,8 @@ pub fn (mut c Checker) infer_fn_types(f table.Fn, mut call_expr ast.CallExpr) { mut arg_elem_sym := c.table.get_type_symbol(arg_elem_info.elem_type) mut param_elem_sym := c.table.get_type_symbol(param_elem_info.elem_type) for { - if arg_elem_sym.kind == .array && - param_elem_sym.kind == .array && c.cur_fn.generic_params.filter(it.name == - param_elem_sym.name).len == 0 - { + if arg_elem_sym.kind == .array && param_elem_sym.kind == .array + && c.cur_fn.generic_params.filter(it.name == param_elem_sym.name).len == 0 { arg_elem_info = arg_elem_sym.info as table.Array arg_elem_sym = c.table.get_type_symbol(arg_elem_info.elem_type) param_elem_info = param_elem_sym.info as table.Array diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v index 32a4c30451..433d4bf3bf 100644 --- a/vlib/v/checker/checker.v +++ b/vlib/v/checker/checker.v @@ -562,16 +562,15 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) table.Type { return table.void_type } } - if !type_sym.is_public && type_sym.kind != .placeholder && type_sym.mod != c.mod && - type_sym.language != .c - { + if !type_sym.is_public && type_sym.kind != .placeholder && type_sym.mod != c.mod + && type_sym.language != .c { c.error('type `$type_sym.name` is private', struct_init.pos) } if type_sym.kind == .struct_ { info := type_sym.info as table.Struct if info.attrs.len > 0 && info.attrs[0].name == 'noinit' && type_sym.mod != c.mod { - c.error('struct `$type_sym.name` is declared with a `[noinit]` attribute, so ' + 'it cannot be initialized with `$type_sym.name{}`', - struct_init.pos) + c.error('struct `$type_sym.name` is declared with a `[noinit]` attribute, so ' + + 'it cannot be initialized with `$type_sym.name{}`', struct_init.pos) } } if type_sym.name.len == 1 && c.cur_fn.generic_params.len == 0 { @@ -681,9 +680,8 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) table.Type { field.pos) } } - if info_field.typ.is_ptr() && !expr_type.is_ptr() && !expr_type.is_pointer() && - !expr_type.is_number() - { + if info_field.typ.is_ptr() && !expr_type.is_ptr() && !expr_type.is_pointer() + && !expr_type.is_number() { c.error('ref', field.pos) } struct_init.fields[i].typ = expr_type @@ -833,14 +831,12 @@ pub fn (mut c Checker) infix_expr(mut infix_expr ast.InfixExpr) table.Type { return table.bool_type } .plus, .minus, .mul, .div, .mod, .xor, .amp, .pipe { // binary operators that expect matching types - if right.info is table.Alias && - (right.info as table.Alias).language != .c && c.mod == c.table.type_to_str(right_type).split('.')[0] - { + if right.info is table.Alias + && (right.info as table.Alias).language != .c && c.mod == c.table.type_to_str(right_type).split('.')[0] { right = c.table.get_type_symbol((right.info as table.Alias).parent_type) } - if left.info is table.Alias && - (left.info as table.Alias).language != .c && c.mod == c.table.type_to_str(left_type).split('.')[0] - { + if left.info is table.Alias + && (left.info as table.Alias).language != .c && c.mod == c.table.type_to_str(left_type).split('.')[0] { left = c.table.get_type_symbol((left.info as table.Alias).parent_type) } if left.kind in [.array, .array_fixed, .map, .struct_] { @@ -944,9 +940,8 @@ pub fn (mut c Checker) infix_expr(mut infix_expr ast.InfixExpr) table.Type { // []T << T return table.void_type } - if right.kind == .array && - c.check_types(left_value_type, c.table.value_type(right_type)) - { + if right.kind == .array + && c.check_types(left_value_type, c.table.value_type(right_type)) { // []T << []T return table.void_type } @@ -1017,9 +1012,8 @@ pub fn (mut c Checker) infix_expr(mut infix_expr ast.InfixExpr) table.Type { if left_type == table.bool_type && infix_expr.op !in [.eq, .ne, .logical_or, .and] { c.error('bool types only have the following operators defined: `==`, `!=`, `||`, and `&&`', infix_expr.pos) - } else if left_type == table.string_type && - infix_expr.op !in [.plus, .eq, .ne, .lt, .gt, .le, .ge] - { + } else if left_type == table.string_type + && infix_expr.op !in [.plus, .eq, .ne, .lt, .gt, .le, .ge] { // TODO broken !in c.error('string types only have the following operators defined: `==`, `!=`, `<`, `>`, `<=`, `>=`, and `+`', infix_expr.pos) @@ -1221,15 +1215,15 @@ pub fn (mut c Checker) call_expr(mut call_expr ast.CallExpr) table.Type { // Now call `call_method` or `call_fn` for specific checks. typ := if call_expr.is_method { c.call_method(mut call_expr) } else { c.call_fn(mut call_expr) } // autofree: mark args that have to be freed (after saving them in tmp exprs) - free_tmp_arg_vars := c.pref.autofree && !c.is_builtin_mod && call_expr.args.len > 0 && !call_expr.args[0].typ.has_flag(.optional) + free_tmp_arg_vars := c.pref.autofree && !c.is_builtin_mod && call_expr.args.len > 0 + && !call_expr.args[0].typ.has_flag(.optional) if free_tmp_arg_vars && !c.inside_const { for i, arg in call_expr.args { if arg.typ != table.string_type { continue } - if arg.expr is ast.Ident || - arg.expr is ast.StringLiteral || arg.expr is ast.SelectorExpr - { + if arg.expr is ast.Ident || arg.expr is ast.StringLiteral + || arg.expr is ast.SelectorExpr { // Simple expressions like variables, string literals, selector expressions // (`x.field`) can't result in allocations and don't need to be assigned to // temporary vars. @@ -1239,9 +1233,9 @@ pub fn (mut c Checker) call_expr(mut call_expr ast.CallExpr) table.Type { call_expr.args[i].is_tmp_autofree = true } // TODO copy pasta from above - if call_expr.receiver_type == table.string_type && !(call_expr.left is ast.Ident || - call_expr.left is ast.StringLiteral || call_expr.left is ast.SelectorExpr) - { + if call_expr.receiver_type == table.string_type && !(call_expr.left is ast.Ident + || call_expr.left is ast.StringLiteral + || call_expr.left is ast.SelectorExpr) { call_expr.free_receiver = true } } @@ -1263,13 +1257,11 @@ fn (mut c Checker) check_map_and_filter(is_map bool, elem_typ table.Type, call_e ast.AnonFn { if arg_expr.decl.params.len > 1 { c.error('function needs exactly 1 argument', arg_expr.decl.pos) - } else if is_map && - (arg_expr.decl.return_type == table.void_type || arg_expr.decl.params[0].typ != elem_typ) - { + } else if is_map + && (arg_expr.decl.return_type == table.void_type || arg_expr.decl.params[0].typ != elem_typ) { c.error('type mismatch, should use `fn(a $elem_sym.name) T {...}`', arg_expr.decl.pos) - } else if !is_map && - (arg_expr.decl.return_type != table.bool_type || arg_expr.decl.params[0].typ != elem_typ) - { + } else if !is_map + && (arg_expr.decl.return_type != table.bool_type || arg_expr.decl.params[0].typ != elem_typ) { c.error('type mismatch, should use `fn(a $elem_sym.name) bool {...}`', arg_expr.decl.pos) } @@ -1282,14 +1274,12 @@ fn (mut c Checker) check_map_and_filter(is_map bool, elem_typ table.Type, call_e } if func.params.len > 1 { c.error('function needs exactly 1 argument', call_expr.pos) - } else if is_map && - (func.return_type == table.void_type || func.params[0].typ != elem_typ) - { + } else if is_map + && (func.return_type == table.void_type || func.params[0].typ != elem_typ) { c.error('type mismatch, should use `fn(a $elem_sym.name) T {...}`', arg_expr.pos) - } else if !is_map && - (func.return_type != table.bool_type || func.params[0].typ != elem_typ) - { + } else if !is_map + && (func.return_type != table.bool_type || func.params[0].typ != elem_typ) { c.error('type mismatch, should use `fn(a $elem_sym.name) bool {...}`', arg_expr.pos) } @@ -1357,7 +1347,8 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type { // Verify `.sort(a < b)` if call_expr.args.len > 0 { if call_expr.args[0].expr !is ast.InfixExpr { - c.error('`.sort()` requires a `<` or `>` comparison as the first and only argument' + + c.error( + '`.sort()` requires a `<` or `>` comparison as the first and only argument' + '\ne.g. `users.sort(a.id < b.id)`', call_expr.pos) } } @@ -1473,9 +1464,8 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type { } } if has_method { - if !method.is_pub && !c.is_builtin_mod && !c.pref.is_test && left_type_sym.mod != c.mod && - left_type_sym.mod != '' - { // method.mod != c.mod { + if !method.is_pub && !c.is_builtin_mod && !c.pref.is_test && left_type_sym.mod != c.mod + && left_type_sym.mod != '' { // method.mod != c.mod { // If a private method is called outside of the module // its receiver type is defined in, show an error. // println('warn $method_name lef.mod=$left_type_sym.mod c.mod=$c.mod') @@ -1485,14 +1475,16 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type { c.fail_if_immutable(call_expr.left) // call_expr.is_mut = true } - if method.return_type == table.void_type && - method.ctdefine.len > 0 && method.ctdefine !in c.pref.compile_defines - { + if method.return_type == table.void_type && method.ctdefine.len > 0 + && method.ctdefine !in c.pref.compile_defines { call_expr.should_be_skipped = true } nr_args := if method.params.len == 0 { 0 } else { method.params.len - 1 } - min_required_args := method.params.len - if method.is_variadic && method.params.len > - 1 { 2 } else { 1 } + min_required_args := method.params.len - if method.is_variadic && method.params.len > 1 { + 2 + } else { + 1 + } if call_expr.args.len < min_required_args { c.error('expected $min_required_args arguments, but got $call_expr.args.len', call_expr.pos) @@ -1508,8 +1500,11 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type { // call_expr.args << method.args[0].typ // call_expr.exp_arg_types << method.args[0].typ for i, arg in call_expr.args { - exp_arg_typ := if method.is_variadic && i >= method.params.len - 1 { method.params[method.params.len - - 1].typ } else { method.params[i + 1].typ } + exp_arg_typ := if method.is_variadic && i >= method.params.len - 1 { + method.params[method.params.len - 1].typ + } else { + method.params[i + 1].typ + } exp_arg_sym := c.table.get_type_symbol(exp_arg_typ) c.expected_type = exp_arg_typ got_arg_typ := c.expr(arg.expr) @@ -1537,8 +1532,11 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type { call_expr.pos) } } - param := if method.is_variadic && i >= method.params.len - 1 { method.params[method.params.len - - 1] } else { method.params[i + 1] } + param := if method.is_variadic && i >= method.params.len - 1 { + method.params[method.params.len - 1] + } else { + method.params[i + 1] + } if arg.is_mut { c.fail_if_immutable(arg.expr) if !param.is_mut { @@ -1551,8 +1549,8 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type { } else { if param.is_mut && (!arg.is_mut || param.typ.share() != arg.share) { tok := arg.share.str() - c.warn('`$call_expr.name` parameter `$param.name` is `$tok`, you need to provide `$tok` e.g. `$tok arg${i + - 1}`', arg.expr.position()) + c.warn('`$call_expr.name` parameter `$param.name` is `$tok`, you need to provide `$tok` e.g. `$tok arg${ + i + 1}`', arg.expr.position()) } } } @@ -1605,8 +1603,7 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type { elem_info := return_sym.info as table.Chan elem_sym := c.table.get_type_symbol(elem_info.elem_type) if elem_sym.name in method.generic_names { - idx := c.table.find_or_register_chan(elem_info.elem_type, elem_info.elem_type.nr_muls() > - 0) + idx := c.table.find_or_register_chan(elem_info.elem_type, elem_info.elem_type.nr_muls() > 0) return table.new_type(idx) } } @@ -1789,9 +1786,8 @@ pub fn (mut c Checker) call_fn(mut call_expr ast.CallExpr) table.Type { if f.is_deprecated { c.warn('function `$f.name` has been deprecated', call_expr.pos) } - if f.is_unsafe && !c.inside_unsafe && f.language == .c && f.name[2] in [`m`, `s`] && - f.mod == 'builtin' - { + if f.is_unsafe && !c.inside_unsafe && f.language == .c && f.name[2] in [`m`, `s`] + && f.mod == 'builtin' { // builtin C.m*, C.s* only - temp c.warn('function `$f.name` must be called from an `unsafe` block', call_expr.pos) } @@ -1817,9 +1813,8 @@ pub fn (mut c Checker) call_fn(mut call_expr ast.CallExpr) table.Type { } else { call_expr.return_type = f.return_type } - if f.return_type == table.void_type && - f.ctdefine.len > 0 && f.ctdefine !in c.pref.compile_defines - { + if f.return_type == table.void_type && f.ctdefine.len > 0 + && f.ctdefine !in c.pref.compile_defines { call_expr.should_be_skipped = true } if f.language != .v || call_expr.language != .v { @@ -1891,8 +1886,8 @@ pub fn (mut c Checker) call_fn(mut call_expr ast.CallExpr) table.Type { } else { if arg.is_mut && (!call_arg.is_mut || arg.typ.share() != call_arg.share) { tok := call_arg.share.str() - c.warn('`$call_expr.name` parameter `$arg.name` is `$tok`, you need to provide `$tok` e.g. `$tok arg${i + - 1}`', call_arg.expr.position()) + c.warn('`$call_expr.name` parameter `$arg.name` is `$tok`, you need to provide `$tok` e.g. `$tok arg${ + i + 1}`', call_arg.expr.position()) } } // Handle expected interface @@ -2036,8 +2031,8 @@ pub fn (mut c Checker) check_or_expr(or_expr ast.OrExpr, ret_type table.Type, ex c.expected_or_type = ret_type.clear_flag(.optional) last_stmt_typ := c.expr(last_stmt.expr) c.expected_or_type = table.void_type - type_fits := c.check_types(last_stmt_typ, ret_type) && last_stmt_typ.nr_muls() == - ret_type.nr_muls() + type_fits := c.check_types(last_stmt_typ, ret_type) + && last_stmt_typ.nr_muls() == ret_type.nr_muls() is_panic_or_exit := is_expr_panic_or_exit(last_stmt.expr) if type_fits || is_panic_or_exit { return @@ -2233,9 +2228,8 @@ pub fn (mut c Checker) return_stmt(mut return_stmt ast.Return) { c.error('too many arguments to return, current function does not return anything', return_stmt.pos) return - } else if return_stmt.exprs.len == 0 && !(c.expected_type == table.void_type || - expected_type_sym.kind == .void) - { + } else if return_stmt.exprs.len == 0 && !(c.expected_type == table.void_type + || expected_type_sym.kind == .void) { c.error('too few arguments to return', return_stmt.pos) return } @@ -2274,9 +2268,8 @@ pub fn (mut c Checker) return_stmt(mut return_stmt ast.Return) { } for i, exp_type in expected_types { got_typ := c.unwrap_generic(got_types[i]) - if got_typ.has_flag(.optional) && - (!exp_type.has_flag(.optional) || c.table.type_to_str(got_typ) != c.table.type_to_str(exp_type)) - { + if got_typ.has_flag(.optional) + && (!exp_type.has_flag(.optional) || c.table.type_to_str(got_typ) != c.table.type_to_str(exp_type)) { pos := return_stmt.exprs[i].position() c.error('cannot use `${c.table.type_to_str(got_typ)}` as type `${c.table.type_to_str(exp_type)}` in return argument', pos) @@ -2292,16 +2285,14 @@ pub fn (mut c Checker) return_stmt(mut return_stmt ast.Return) { c.error('cannot use `$got_typ_sym.name` as type `$exp_typ_sym.name` in return argument', pos) } - if (got_typ.is_ptr() || got_typ.is_pointer()) && - (!exp_type.is_ptr() && !exp_type.is_pointer()) - { + if (got_typ.is_ptr() || got_typ.is_pointer()) + && (!exp_type.is_ptr() && !exp_type.is_pointer()) { pos := return_stmt.exprs[i].position() c.error('fn `$c.cur_fn.name` expects you to return a non reference type `${c.table.type_to_str(exp_type)}`, but you are returning `${c.table.type_to_str(got_typ)}` instead', pos) } - if (exp_type.is_ptr() || exp_type.is_pointer()) && - (!got_typ.is_ptr() && !got_typ.is_pointer()) && got_typ != table.int_literal_type - { + if (exp_type.is_ptr() || exp_type.is_pointer()) + && (!got_typ.is_ptr() && !got_typ.is_pointer())&& got_typ != table.int_literal_type { pos := return_stmt.exprs[i].position() c.error('fn `$c.cur_fn.name` expects you to return a reference type `${c.table.type_to_str(exp_type)}`, but you are returning `${c.table.type_to_str(got_typ)}` instead', pos) @@ -2580,10 +2571,9 @@ pub fn (mut c Checker) assign_stmt(mut assign_stmt ast.AssignStmt) { // TODO replace all c.pref.translated checks with `$if !translated` for performance continue } - if left_sym.kind == .array && !c.inside_unsafe && assign_stmt.op in [.assign, .decl_assign] && - right_sym.kind == .array && - (left is ast.Ident && !left.is_blank_ident()) && right is ast.Ident - { + if left_sym.kind == .array && !c.inside_unsafe && assign_stmt.op in [.assign, .decl_assign] + && right_sym.kind == .array && (left is ast.Ident && !left.is_blank_ident()) + && right is ast.Ident { // Do not allow `a = b`, only `a = b.clone()` c.error('use `array2 = array1.clone()` instead of `array2 = array1` (or use `unsafe`)', assign_stmt.pos) @@ -2622,10 +2612,12 @@ pub fn (mut c Checker) assign_stmt(mut assign_stmt ast.AssignStmt) { c.error('invalid right operand: $left_sym.name $assign_stmt.op $right_sym.name', right.position()) } - } else if !left_sym.is_number() && left_sym.kind !in [.byteptr, .charptr, .struct_, .alias] { + } else if !left_sym.is_number() + && left_sym.kind !in [.byteptr, .charptr, .struct_, .alias] { c.error('operator `$assign_stmt.op` not defined on left operand type `$left_sym.name`', left.position()) - } else if !right_sym.is_number() && left_sym.kind !in [.byteptr, .charptr, .struct_, .alias] { + } else if !right_sym.is_number() + && left_sym.kind !in [.byteptr, .charptr, .struct_, .alias] { c.error('invalid right operand: $left_sym.name $assign_stmt.op $right_sym.name', right.position()) } else if right is ast.IntegerLiteral { @@ -2640,40 +2632,35 @@ pub fn (mut c Checker) assign_stmt(mut assign_stmt ast.AssignStmt) { } } .mult_assign, .div_assign { - if !left_sym.is_number() && - !c.table.get_final_type_symbol(left_type_unwrapped).is_int() && left_sym.kind !in - [.struct_, .alias] - { + if !left_sym.is_number() + && !c.table.get_final_type_symbol(left_type_unwrapped).is_int() + && left_sym.kind !in [.struct_, .alias] { c.error('operator $assign_stmt.op.str() not defined on left operand type `$left_sym.name`', left.position()) - } else if !right_sym.is_number() && - !c.table.get_final_type_symbol(left_type_unwrapped).is_int() && left_sym.kind !in - [.struct_, .alias] - { + } else if !right_sym.is_number() + && !c.table.get_final_type_symbol(left_type_unwrapped).is_int() + && left_sym.kind !in [.struct_, .alias] { c.error('operator $assign_stmt.op.str() not defined on right operand type `$right_sym.name`', right.position()) } } .and_assign, .or_assign, .xor_assign, .mod_assign, .left_shift_assign, .right_shift_assign { - if !left_sym.is_int() && - !c.table.get_final_type_symbol(left_type_unwrapped).is_int() - { + if !left_sym.is_int() + && !c.table.get_final_type_symbol(left_type_unwrapped).is_int() { c.error('operator $assign_stmt.op.str() not defined on left operand type `$left_sym.name`', left.position()) - } else if !right_sym.is_int() && - !c.table.get_final_type_symbol(right_type_unwrapped).is_int() - { + } else if !right_sym.is_int() + && !c.table.get_final_type_symbol(right_type_unwrapped).is_int() { c.error('operator $assign_stmt.op.str() not defined on right operand type `$right_sym.name`', right.position()) } } else {} } - if assign_stmt.op in - [.plus_assign, .minus_assign, .mod_assign, .mult_assign, .div_assign] && - ((left_sym.kind == .struct_ && right_sym.kind == .struct_) || left_sym.kind == .alias) - { + if assign_stmt.op in [.plus_assign, .minus_assign, .mod_assign, .mult_assign, .div_assign] + && ((left_sym.kind == .struct_ && right_sym.kind == .struct_) + || left_sym.kind == .alias) { left_name := c.table.type_to_str(left_type) right_name := c.table.type_to_str(right_type) parent_sym := c.table.get_final_type_symbol(left_type) @@ -2884,7 +2871,8 @@ pub fn (mut c Checker) array_init(mut array_init ast.ArrayInit) table.Type { array_init.typ = table.new_type(idx) } array_init.elem_type = elem_type - } else if array_init.is_fixed && array_init.exprs.len == 1 && array_init.elem_type != table.void_type { + } else if array_init.is_fixed && array_init.exprs.len == 1 + && array_init.elem_type != table.void_type { // [50]byte mut fixed_size := 0 init_expr := array_init.exprs[0] @@ -3070,7 +3058,8 @@ fn (mut c Checker) stmt(node ast.Stmt) { node.scope.update_var_type(node.val_var, val_type) } else { if sym.kind == .map && !(node.key_var.len > 0 && node.val_var.len > 0) { - c.error('declare a key and a value variable when ranging a map: `for key, val in map {`\n' + + c.error( + 'declare a key and a value variable when ranging a map: `for key, val in map {`\n' + 'use `_` if you do not need the variable', node.pos) } if node.key_var.len > 0 { @@ -3129,7 +3118,8 @@ fn (mut c Checker) stmt(node ast.Stmt) { arg.expr.position()) } } - if node.call_expr.is_method && node.call_expr.receiver_type.is_ptr() && !node.call_expr.left_type.is_ptr() { + if node.call_expr.is_method && node.call_expr.receiver_type.is_ptr() + && !node.call_expr.left_type.is_ptr() { c.error('method in `go` statement cannot have non-reference mutable receiver', node.call_expr.left.position()) } @@ -3195,9 +3185,8 @@ fn (mut c Checker) hash_stmt(mut node ast.HashStmt) { node.main = vroot } flag_no_comment := flag.all_before('//').trim_space() - if !((flag_no_comment.starts_with('"') && flag_no_comment.ends_with('"')) || - (flag_no_comment.starts_with('<') && flag_no_comment.ends_with('>'))) - { + if !((flag_no_comment.starts_with('"') && flag_no_comment.ends_with('"')) + || (flag_no_comment.starts_with('<') && flag_no_comment.ends_with('>'))) { c.error('including C files should use either `"header_file.h"` or `` quoting', node.pos) } @@ -3578,10 +3567,8 @@ pub fn (mut c Checker) cast_expr(mut node ast.CastExpr) table.Type { c.error('cannot convert type `$from_type_sym.name` to `$to_type_sym.name` (alias to `$parent_type_sym.name`)', node.pos) } - } else if node.typ == table.string_type && - (from_type_sym.kind in [.int_literal, .int, .byte, .byteptr, .bool] || - (from_type_sym.kind == .array && from_type_sym.name == 'array_byte')) - { + } else if node.typ == table.string_type + && (from_type_sym.kind in [.int_literal, .int, .byte, .byteptr, .bool] || (from_type_sym.kind == .array && from_type_sym.name == 'array_byte')) { type_name := c.table.type_to_str(node.expr_type) c.error('cannot cast type `$type_name` to string, use `x.str()` instead', node.pos) } else if node.expr_type == table.string_type { @@ -3594,13 +3581,13 @@ pub fn (mut c Checker) cast_expr(mut node ast.CastExpr) table.Type { } c.error(error_msg, node.pos) } - } else if to_type_sym.kind == .byte && - node.expr_type != table.voidptr_type && from_type_sym.kind != .enum_ && !node.expr_type.is_int() && - !node.expr_type.is_float() && !node.expr_type.is_ptr() - { + } else if to_type_sym.kind == .byte && node.expr_type != table.voidptr_type + && from_type_sym.kind != .enum_ && !node.expr_type.is_int() && !node.expr_type.is_float() + && !node.expr_type.is_ptr() { type_name := c.table.type_to_str(node.expr_type) c.error('cannot cast type `$type_name` to `byte`', node.pos) - } else if to_type_sym.kind == .struct_ && !node.typ.is_ptr() && !(to_type_sym.info as table.Struct).is_typedef { + } else if to_type_sym.kind == .struct_ && !node.typ.is_ptr() + && !(to_type_sym.info as table.Struct).is_typedef { // For now we ignore C typedef because of `C.Window(C.None)` in vlib/clipboard if from_type_sym.kind == .struct_ && !node.expr_type.is_ptr() { from_type_info := from_type_sym.info as table.Struct @@ -3790,7 +3777,8 @@ pub fn (mut c Checker) ident(mut ident ast.Ident) table.Type { c.error('undefined variable `$ident.name` (used before declaration)', ident.pos) } - is_sum_type_cast := obj.sum_type_casts.len != 0 && !c.prevent_sum_type_unwrapping_once + is_sum_type_cast := obj.sum_type_casts.len != 0 + && !c.prevent_sum_type_unwrapping_once c.prevent_sum_type_unwrapping_once = false mut typ := if is_sum_type_cast { obj.sum_type_casts.last() } else { obj.typ } if typ == 0 { @@ -4293,9 +4281,9 @@ pub fn (mut c Checker) select_expr(mut node ast.SelectExpr) table.Type { } } else { if branch.stmt.expr is ast.InfixExpr { - if branch.stmt.expr.left !is ast.Ident && - branch.stmt.expr.left !is ast.SelectorExpr && branch.stmt.expr.left !is ast.IndexExpr - { + if branch.stmt.expr.left !is ast.Ident + && branch.stmt.expr.left !is ast.SelectorExpr + && branch.stmt.expr.left !is ast.IndexExpr { c.error('channel in `select` key must be predefined', branch.stmt.expr.left.position()) } } else { @@ -4307,9 +4295,8 @@ pub fn (mut c Checker) select_expr(mut node ast.SelectExpr) table.Type { expr := branch.stmt.right[0] match expr { ast.PrefixExpr { - if expr.right !is ast.Ident && - expr.right !is ast.SelectorExpr && expr.right !is ast.IndexExpr - { + if expr.right !is ast.Ident && expr.right !is ast.SelectorExpr + && expr.right !is ast.IndexExpr { c.error('channel in `select` key must be predefined', expr.right.position()) } if expr.or_block.kind != .absent { @@ -4388,10 +4375,8 @@ fn (mut c Checker) for_stmt(mut node ast.ForStmt) { if node.cond is ast.InfixExpr { infix := node.cond if infix.op == .key_is { - if (infix.left is ast.Ident || - infix.left is ast.SelectorExpr) && - infix.right is ast.Type - { + if (infix.left is ast.Ident || infix.left is ast.SelectorExpr) + && infix.right is ast.Type { right_expr := infix.right as ast.Type is_variable := if mut infix.left is ast.Ident { infix.left.kind == .variable @@ -4440,7 +4425,8 @@ pub fn (mut c Checker) if_expr(mut node ast.IfExpr) table.Type { // check condition type is boolean c.expected_type = table.bool_type cond_typ := c.expr(branch.cond) - if cond_typ.idx() !in [table.bool_type_idx, table.void_type_idx] && !c.pref.translated { + if cond_typ.idx() !in [table.bool_type_idx, table.void_type_idx] + && !c.pref.translated { // void types are skipped, because they mean the var was initialized incorrectly // (via missing function etc) typ_sym := c.table.get_type_symbol(cond_typ) @@ -4462,10 +4448,8 @@ pub fn (mut c Checker) if_expr(mut node ast.IfExpr) table.Type { expr_str := c.table.type_to_str(expr_type) c.error('cannot use type `$expect_str` as type `$expr_str`', branch.pos) } - if (infix.left is ast.Ident || - infix.left is ast.SelectorExpr) && - infix.right is ast.Type - { + if (infix.left is ast.Ident || infix.left is ast.SelectorExpr) + && infix.right is ast.Type { is_variable := if mut infix.left is ast.Ident { infix.left.kind == .variable } else { @@ -4660,10 +4644,8 @@ fn (mut c Checker) comp_if_branch(cond ast.Expr, pos token.Position) bool { return l && r // skip (return true) only if both should be skipped } .key_is, .not_is { - if (cond.left is ast.SelectorExpr || - cond.left is ast.Type) && - cond.right is ast.Type - { + if (cond.left is ast.SelectorExpr || cond.left is ast.Type) + && cond.right is ast.Type { // $if method.@type is string } else { c.error('invalid `\$if` condition: $cond.left', cond.pos) @@ -4725,9 +4707,8 @@ fn (mut c Checker) comp_if_branch(cond ast.Expr, pos token.Position) bool { } else if cond.name !in c.pref.compile_defines_all { // `$if some_var {}` typ := c.expr(cond) - if cond.obj !is ast.Var && - cond.obj !is ast.ConstField && cond.obj !is ast.GlobalField - { + if cond.obj !is ast.Var && cond.obj !is ast.ConstField + && cond.obj !is ast.GlobalField { c.error('unknown var: `$cond.name`', pos) return false } @@ -4924,9 +4905,8 @@ pub fn (mut c Checker) index_expr(mut node ast.IndexExpr) table.Type { mut typ := c.expr(node.left) node.left_type = typ typ_sym := c.table.get_final_type_symbol(typ) - if typ_sym.kind !in [.array, .array_fixed, .string, .map] && !typ.is_ptr() && typ !in [table.byteptr_type, table.charptr_type] && - !typ.has_flag(.variadic) - { + if typ_sym.kind !in [.array, .array_fixed, .string, .map] && !typ.is_ptr() + && typ !in [table.byteptr_type, table.charptr_type]&& !typ.has_flag(.variadic) { c.error('type `$typ_sym.name` does not support indexing', node.pos) } if typ_sym.kind == .string && !typ.is_ptr() && node.is_setter { @@ -5275,8 +5255,8 @@ fn (mut c Checker) sql_stmt(mut node ast.SqlStmt) table.Type { } fn (mut c Checker) fetch_and_verify_orm_fields(info table.Struct, pos token.Position, table_name string) []table.Field { - fields := info.fields.filter(it.typ in - [table.string_type, table.int_type, table.bool_type] && !it.attrs.contains('skip')) + fields := info.fields.filter(it.typ in [table.string_type, table.int_type, table.bool_type] + && !it.attrs.contains('skip')) if fields.len == 0 { c.error('V orm: select: empty fields in `$table_name`', pos) return []table.Field{} @@ -5344,17 +5324,15 @@ fn (mut c Checker) fn_decl(mut node ast.FnDecl) { // Make sure all types are valid for arg in node.params { sym := c.table.get_type_symbol(arg.typ) - if sym.kind == .placeholder || - (sym.kind in [table.Kind.int_literal, .float_literal] && !c.is_builtin_mod) - { + if sym.kind == .placeholder + || (sym.kind in [table.Kind.int_literal, .float_literal] && !c.is_builtin_mod) { c.error('unknown type `$sym.name`', node.pos) } } } return_sym := c.table.get_type_symbol(node.return_type) - if node.language == .v && - return_sym.kind in [.placeholder, .int_literal, .float_literal] && return_sym.language == .v - { + if node.language == .v && return_sym.kind in [.placeholder, .int_literal, .float_literal] + && return_sym.language == .v { c.error('unknown type `$return_sym.name`', node.pos) } if node.language == .v && node.is_method && node.name == 'str' { @@ -5365,9 +5343,8 @@ fn (mut c Checker) fn_decl(mut node ast.FnDecl) { c.error('.str() methods should have 0 arguments', node.pos) } } - if node.language == .v && node.is_method && node.name in - ['+', '-', '*', '%', '/', '<', '>', '==', '!=', '>=', '<='] - { + if node.language == .v && node.is_method + && node.name in ['+', '-', '*', '%', '/', '<', '>', '==', '!=', '>=', '<='] { if node.params.len != 2 { c.error('operator methods should have exactly 1 argument', node.pos) } else { @@ -5385,9 +5362,8 @@ fn (mut c Checker) fn_decl(mut node ast.FnDecl) { } else if node.receiver.typ != node.params[1].typ { c.error('expected `$receiver_sym.name` not `$param_sym.name` - both operands must be the same type for operator overloading', node.params[1].type_pos) - } else if node.name in ['<', '>', '==', '!=', '>=', '<='] && - node.return_type != table.bool_type - { + } else if node.name in ['<', '>', '==', '!=', '>=', '<='] + && node.return_type != table.bool_type { c.error('operator comparison methods should return `bool`', node.pos) } else if parent_sym.is_primitive() { c.error('cannot define operator methods on type alias for `$parent_sym.name`', @@ -5397,7 +5373,8 @@ fn (mut c Checker) fn_decl(mut node ast.FnDecl) { } } // TODO c.pref.is_vet - if node.language == .v && !node.is_method && node.params.len == 0 && node.name.after('.').starts_with('test_') { + if node.language == .v && !node.is_method && node.params.len == 0 + && node.name.after('.').starts_with('test_') { if !c.file.path.ends_with('_test.v') { // simple heuristic for st in node.stmts { @@ -5416,9 +5393,8 @@ fn (mut c Checker) fn_decl(mut node ast.FnDecl) { c.expected_type = table.void_type c.cur_fn = node // Add return if `fn(...) ? {...}` have no return at end - if node.return_type != table.void_type && node.return_type.has_flag(.optional) && - (node.stmts.len == 0 || node.stmts[node.stmts.len - 1] !is ast.Return) - { + if node.return_type != table.void_type && node.return_type.has_flag(.optional) + && (node.stmts.len == 0 || node.stmts[node.stmts.len - 1] !is ast.Return) { sym := c.table.get_type_symbol(node.return_type) if sym.kind == .void { node.stmts << ast.Return{ @@ -5429,9 +5405,8 @@ fn (mut c Checker) fn_decl(mut node ast.FnDecl) { c.fn_scope = node.scope c.stmts(node.stmts) returns := c.returns || has_top_return(node.stmts) - if node.language == .v && !node.no_body && node.return_type != table.void_type && !returns && - node.name !in ['panic', 'exit'] - { + if node.language == .v && !node.no_body && node.return_type != table.void_type && !returns + && node.name !in ['panic', 'exit'] { c.error('missing return at end of function `$node.name`', node.pos) } c.returns = false @@ -5487,9 +5462,8 @@ fn (mut c Checker) verify_all_vweb_routes() { if isnil(f) { continue } - if f.return_type == typ_vweb_result && - f.receiver.typ == m.params[0].typ && f.name == m.name - { + if f.return_type == typ_vweb_result && f.receiver.typ == m.params[0].typ + && f.name == m.name { c.file = f.source_file // setup of file path for the warning c.warn('mismatched parameters count between vweb method `${sym_app.name}.$m.name` ($nargs) and route attribute $m.attrs ($nroute_attributes)', f.pos) diff --git a/vlib/v/doc/doc.v b/vlib/v/doc/doc.v index 63fc668ea4..6ab9546d6c 100644 --- a/vlib/v/doc/doc.v +++ b/vlib/v/doc/doc.v @@ -372,8 +372,7 @@ pub fn (mut d Doc) generate() ? { } filename := os.base(file_path) d.sources[filename] = util.read_file(file_path) or { '' } - file_asts << - parser.parse_file(file_path, d.table, comments_mode, d.prefs, global_scope) + file_asts << parser.parse_file(file_path, d.table, comments_mode, d.prefs, global_scope) } return d.file_asts(file_asts) } diff --git a/vlib/v/fmt/fmt.v b/vlib/v/fmt/fmt.v index 2005fad8aa..b722f88f7a 100644 --- a/vlib/v/fmt/fmt.v +++ b/vlib/v/fmt/fmt.v @@ -5,7 +5,6 @@ module fmt import v.ast import v.table -import v.token import strings import v.util @@ -15,7 +14,7 @@ const ( '\t\t\t\t\t\t\t\t', ] // when to break a line dependant on penalty - max_len = [0, 35, 85, 93, 100] + max_len = [0, 35, 60, 85, 93, 100] ) pub struct Fmt { @@ -27,13 +26,10 @@ pub mut: indent int empty_line bool line_len int - buffering bool // expressions will be analyzed later by adjust_complete_line() before finally written - expr_bufs []string // and stored here in the meantime (expr_bufs.len-1 = penalties.len = precedences.len) - penalties []int // how hard should it be to break line after each expression - precedences []int // operator/parenthese precedences for operator at end of each expression - par_level int // how many parentheses are put around the current expression - array_init_break []bool // line breaks after elements in hierarchy level of multi dimensional array - array_init_depth int // current level of hierarchie in array init + buffering bool // disables line wrapping for exprs that will be analyzed later + par_level int // how many parentheses are put around the current expression + array_init_break []bool // line breaks after elements in hierarchy level of multi dimensional array + array_init_depth int // current level of hierarchie in array init single_line_if bool cur_mod string file ast.File @@ -92,43 +88,19 @@ pub fn (mut f Fmt) process_file_imports(file &ast.File) { } pub fn (mut f Fmt) write(s string) { - if !f.buffering { - if f.indent > 0 && f.empty_line { - f.write_indent() - } - f.out.write(s) - f.line_len += s.len - f.empty_line = false - } else { - f.out.write(s) - } -} - -pub fn (mut f Fmt) writeln(s string) { - empty_fifo := f.buffering - if empty_fifo { - f.write(s) - f.expr_bufs << f.out.str() - f.out = f.out_save - f.adjust_complete_line() - f.buffering = false - for i, p in f.penalties { - f.write(f.expr_bufs[i]) - f.wrap_long_line(p, true) - } - f.write(f.expr_bufs[f.expr_bufs.len - 1]) - f.expr_bufs = []string{} - f.penalties = []int{} - f.precedences = []int{} - } if f.indent > 0 && f.empty_line { f.write_indent() } - f.out.writeln(if empty_fifo { - '' - } else { - s - }) + f.out.write(s) + f.line_len += s.len + f.empty_line = false +} + +pub fn (mut f Fmt) writeln(s string) { + if f.indent > 0 && f.empty_line { + f.write_indent() + } + f.out.writeln(s) f.empty_line = true f.line_len = 0 } @@ -145,52 +117,10 @@ fn (mut f Fmt) write_indent() { f.line_len += f.indent * 4 } -// adjustments that can only be done after full line is processed. For now -// only prevents line breaks if everything fits in max_len[last] by increasing -// penalties to maximum -fn (mut f Fmt) adjust_complete_line() { - for i, buf in f.expr_bufs { - // search for low penalties - if i == 0 || f.penalties[i - 1] <= 1 { - precedence := if i == 0 { -1 } else { f.precedences[i - 1] } - mut len_sub_expr := if i == 0 { buf.len + f.line_len } else { buf.len } - mut sub_expr_end_idx := f.penalties.len - // search for next position with low penalty and same precedence to form subexpression - for j in i .. f.penalties.len { - if f.penalties[j] <= 1 && - f.precedences[j] == precedence && len_sub_expr >= max_len[1] - { - sub_expr_end_idx = j - break - } else if f.precedences[j] < precedence { - // we cannot form a sensible subexpression - len_sub_expr = C.INT32_MAX - break - } else { - len_sub_expr += f.expr_bufs[j + 1].len - } - } - // if subexpression would fit in single line adjust penalties to actually do so - if len_sub_expr <= max_len[max_len.len - 1] { - for j in i .. sub_expr_end_idx { - f.penalties[j] = max_len.len - 1 - } - if i > 0 { - f.penalties[i - 1] = 0 - } - if sub_expr_end_idx < f.penalties.len { - f.penalties[sub_expr_end_idx] = 0 - } - } - } - // emergency fallback: decrease penalty in front of long unbreakable parts - if i > 0 && buf.len > 55 && f.penalties[i - 1] > 0 { - f.penalties[i - 1] = if buf.len >= 72 { 0 } else { 1 } - } - } -} - pub fn (mut f Fmt) wrap_long_line(penalty_idx int, add_indent bool) bool { + if f.buffering { + return false + } if f.line_len <= max_len[penalty_idx] { return false } @@ -493,8 +423,9 @@ pub fn (mut f Fmt) type_decl(node ast.TypeDecl) { } } is_last_arg := i == fn_info.params.len - 1 - should_add_type := true || is_last_arg || fn_info.params[i + 1].typ != arg.typ || - (fn_info.is_variadic && i == fn_info.params.len - 2) + should_add_type := true || is_last_arg + || fn_info.params[i + 1].typ != arg.typ + || (fn_info.is_variadic && i == fn_info.params.len - 2) if should_add_type { ns := if arg.name == '' { '' } else { ' ' } if fn_info.is_variadic && is_last_arg { @@ -532,7 +463,7 @@ pub fn (mut f Fmt) type_decl(node ast.TypeDecl) { f.write(' | ') } if i < sum_type_names.len - 1 { - f.wrap_long_line(2, true) + f.wrap_long_line(3, true) } } // f.write(sum_type_names.join(' | ')) @@ -762,7 +693,8 @@ pub fn (mut f Fmt) struct_decl(node ast.StructDecl) { comment_align_i++ align = comment_aligns[comment_align_i] } - pad_len := align.max_attrs_len - attrs_len + align.max_type_len - field_types[i].len + pad_len := align.max_attrs_len - attrs_len + + align.max_type_len - field_types[i].len f.write(strings.repeat(` `, pad_len)) } f.write(' ') @@ -1496,74 +1428,97 @@ pub fn (mut f Fmt) lock_expr(lex ast.LockExpr) { pub fn (mut f Fmt) infix_expr(node ast.InfixExpr) { buffering_save := f.buffering if !f.buffering { - f.out_save = f.out - f.out = strings.new_builder(60) f.buffering = true } + infix_start := f.out.len + start_len := f.line_len f.expr(node.left) - is_one_val_array_init := node.op in [.key_in, .not_in] && - node.right is ast.ArrayInit && (node.right as ast.ArrayInit).exprs.len == 1 + is_one_val_array_init := node.op in [.key_in, .not_in] && node.right is ast.ArrayInit + && (node.right as ast.ArrayInit).exprs.len == 1 if is_one_val_array_init { // `var in [val]` => `var == val` - f.write(if node.op == .key_in { - ' == ' - } else { - ' != ' - }) + op := if node.op == .key_in { ' == ' } else { ' != ' } + f.write(op) } else { f.write(' $node.op.str() ') } - f.expr_bufs << f.out.str() - mut penalty := 3 - match mut node.left { - ast.InfixExpr { - if int(token.precedences[node.left.op]) > int(token.precedences[node.op]) { - penalty-- - } - } - ast.ParExpr { - penalty = 1 - } - else {} - } - match node.right { - ast.InfixExpr { penalty-- } - ast.ParExpr { penalty = 1 } - else {} - } - f.penalties << penalty - // combine parentheses level with operator precedence to form effective precedence - f.precedences << int(token.precedences[node.op]) | (f.par_level << 16) - f.out = strings.new_builder(60) - f.buffering = true if is_one_val_array_init { // `var in [val]` => `var == val` f.expr((node.right as ast.ArrayInit).exprs[0]) } else { f.expr(node.right) } - if !buffering_save && f.buffering { // now decide if and where to break - f.expr_bufs << f.out.str() - f.out = f.out_save + if !buffering_save && f.buffering { f.buffering = false - f.adjust_complete_line() - for i, p in f.penalties { - f.write(f.expr_bufs[i]) - f.wrap_long_line(p, true) + if !f.single_line_if && f.line_len > max_len.last() { + f.wrap_infix(infix_start, start_len) } - f.write(f.expr_bufs[f.expr_bufs.len - 1]) - f.expr_bufs = []string{} - f.penalties = []int{} - f.precedences = []int{} } f.or_expr(node.or_block) } +pub fn (mut f Fmt) wrap_infix(start_pos int, start_len int) { + cut_span := f.out.len - start_pos + condstr := f.out.cut_last(cut_span) + is_cond_infix := condstr.contains_any_substr(['&&', '||']) + if !is_cond_infix && !condstr.contains('+') { + f.write(condstr) + return + } + f.line_len = start_len + if start_len == 0 { + f.empty_line = true + } + or_pen := if condstr.contains('&&') { 3 } else { 5 } + cond_parts := condstr.split(' ') + mut grouped_cond := false + mut conditions := [''] + mut penalties := [5] + mut index := 0 + for cp in cond_parts { + if is_cond_infix && cp in ['&&', '||'] { + if grouped_cond { + conditions[index] += '$cp ' + } else { + p := if cp == '||' { or_pen } else { 5 } + penalties << p + conditions << '$cp ' + index++ + } + } else if !is_cond_infix && cp == '+' { + penalties << 5 + conditions[index] += '$cp ' + conditions << '' + index++ + } else { + conditions[index] += '$cp ' + if cp.starts_with('(') { + grouped_cond = true + } else if cp.ends_with(')') { + grouped_cond = false + } + } + } + for i, c in conditions { + cnd := c.trim_space() + if f.line_len + cnd.len < max_len[penalties[i]] { + if i > 0 && (!is_cond_infix || i < conditions.len - 1) { + f.write(' ') + } + f.write(cnd) + } else { + f.writeln('') + f.indent++ + f.write(cnd) + f.indent-- + } + } +} + pub fn (mut f Fmt) if_expr(it ast.IfExpr) { dollar := if it.is_comptime { '$' } else { '' } - mut single_line := it.branches.len == 2 && it.has_else && branch_is_single_line(it.branches[0]) && - branch_is_single_line(it.branches[1]) && - (it.is_expr || f.is_assign) + mut single_line := it.branches.len == 2 && it.has_else && branch_is_single_line(it.branches[0]) + && branch_is_single_line(it.branches[1])&& (it.is_expr || f.is_assign) f.single_line_if = single_line if_start := f.line_len for { @@ -1583,15 +1538,8 @@ pub fn (mut f Fmt) if_expr(it ast.IfExpr) { } if i < it.branches.len - 1 || !it.has_else { f.write('${dollar}if ') - cur_pos := f.out.len f.expr(branch.cond) - cond_len := f.out.len - cur_pos - is_cond_wrapped := if cond_len > 0 { '\n' in f.out.last_n(cond_len) } else { false } - if is_cond_wrapped { - f.writeln('') - } else { - f.write(' ') - } + f.write(' ') } f.write('{') if single_line { @@ -1654,7 +1602,7 @@ pub fn (mut f Fmt) call_args(args []ast.CallArg) { f.write(arg.share.str() + ' ') } if i > 0 { - f.wrap_long_line(2, true) + f.wrap_long_line(3, true) } f.expr(arg.expr) if i < args.len - 1 { @@ -1790,7 +1738,7 @@ pub fn (mut f Fmt) match_expr(it ast.MatchExpr) { if j < branch.exprs.len - 1 { f.write(', ') } - f.wrap_long_line(3, false) + f.wrap_long_line(4, false) } f.is_mbranch_expr = false } else { @@ -1900,10 +1848,10 @@ pub fn (mut f Fmt) array_init(it ast.ArrayInit) { f.array_init_break << (last_line_nr < line_nr) } } - is_same_line_comment := i > 0 && - (expr is ast.Comment && line_nr == it.exprs[i - 1].position().line_nr) + is_same_line_comment := i > 0 + && (expr is ast.Comment && line_nr == it.exprs[i - 1].position().line_nr) line_break := f.array_init_break[f.array_init_depth - 1] - mut penalty := if line_break && !is_same_line_comment { 0 } else { 3 } + mut penalty := if line_break && !is_same_line_comment { 0 } else { 4 } if penalty > 0 { if i == 0 || should_decrease_arr_penalty(it.exprs[i - 1]) { penalty-- @@ -2066,10 +2014,9 @@ pub fn (mut f Fmt) struct_init(it ast.StructInit) { f.writeln('') } f.comments(field.next_comments, inline: false, has_nl: true, level: .keep) - if single_line_fields && - (field.comments.len > 0 || - field.next_comments.len > 0 || !expr_is_single_line(field.expr) || f.line_len > max_len.last()) - { + if single_line_fields + && (field.comments.len > 0 || field.next_comments.len > 0 || !expr_is_single_line(field.expr) + || f.line_len > max_len.last()) { single_line_fields = false f.out.go_back_to(fields_start) f.line_len = fields_start @@ -2389,7 +2336,7 @@ pub fn (mut f Fmt) sql_stmt(node ast.SqlStmt) { } else { f.write(' ') } - f.wrap_long_line(2, true) + f.wrap_long_line(3, true) } f.write('where ') f.expr(node.where_expr) diff --git a/vlib/v/fmt/tests/concat_expr_expected.vv b/vlib/v/fmt/tests/concat_expr_expected.vv index 0f05e80d75..c876ab8f7a 100644 --- a/vlib/v/fmt/tests/concat_expr_expected.vv +++ b/vlib/v/fmt/tests/concat_expr_expected.vv @@ -1,6 +1,17 @@ fn concatenation_of_strings() { _ := 'Simple' + 'Concat' _ := 'Hello' + ' ' + 'World' + '!' - _ := 'There' + ' ' + 'so' + ' ' + 'many' + ' ' + 'words' + ' ' + 'they' + ' ' + "don't" + - ' ' + 'fit' + ' ' + 'in' + ' ' + 'one' + ' ' + 'line' + _ := 'There' + ' ' + 'so' + ' ' + 'many' + ' ' + 'words' + ' ' + 'they' + ' ' + "don't" + ' ' + + 'fit' + ' ' + 'in' + ' ' + 'one' + ' ' + 'line' +} + +fn concat_inside_ternary() { + { // This block is needed to force line wrapping + cline := if iline == pos.line_nr { + sline[..start_column] + color(kind, sline[start_column..end_column]) + + sline[end_column..] + } else { + sline + } + } } diff --git a/vlib/v/fmt/tests/concat_expr_input.vv b/vlib/v/fmt/tests/concat_expr_input.vv index db42c2c99c..9ebe7d0065 100644 --- a/vlib/v/fmt/tests/concat_expr_input.vv +++ b/vlib/v/fmt/tests/concat_expr_input.vv @@ -5,3 +5,13 @@ _ := 'Simple' + 'Concat' 'World' + '!' _ := 'There' + ' ' + 'so' + ' ' + 'many' + ' ' + 'words' + ' ' + 'they' + ' ' + "don't" + ' ' + 'fit' + ' ' + 'in' + ' ' + 'one' + ' ' + 'line' } + +fn concat_inside_ternary() { + { // This block is needed to force line wrapping + cline := if iline == pos.line_nr { + sline[..start_column] + color(kind, sline[start_column..end_column]) + sline[end_column..] + } else { + sline + } + } +} diff --git a/vlib/v/fmt/tests/expressions_expected.vv b/vlib/v/fmt/tests/expressions_expected.vv index d0a13ca6f0..ccb23b46c4 100644 --- a/vlib/v/fmt/tests/expressions_expected.vv +++ b/vlib/v/fmt/tests/expressions_expected.vv @@ -11,9 +11,7 @@ fn string_inter_lit(mut c checker.Checker, mut node ast.StringInterLiteral) tabl typ := c.table.unalias_num_type(ftyp) mut fmt := node.fmts[i] // analyze and validate format specifier - if fmt !in - [`E`, `F`, `G`, `e`, `f`, `g`, `d`, `u`, `x`, `X`, `o`, `c`, `s`, `p`, `_`] - { + if fmt !in [`E`, `F`, `G`, `e`, `f`, `g`, `d`, `u`, `x`, `X`, `o`, `c`, `s`, `p`, `_`] { c.error('unknown format specifier `${fmt:c}`', node.fmt_poss[i]) } if node.precisions[i] != 987698 && !typ.is_float() { @@ -22,14 +20,13 @@ fn string_inter_lit(mut c checker.Checker, mut node ast.StringInterLiteral) tabl if node.pluss[i] && !typ.is_number() { c.error('plus prefix only allowd for numbers', node.fmt_poss[i]) } - if (typ.is_unsigned() && fmt !in [`u`, `x`, `X`, `o`, `c`]) || - (typ.is_signed() && fmt !in [`d`, `x`, `X`, `o`, `c`]) || - (typ.is_int_literal() && fmt !in [`d`, `c`, `x`, `X`, `o`, `u`, `x`, `X`, `o`]) || - (typ.is_float() && fmt !in [`E`, `F`, `G`, `e`, `f`, `g`]) || - (typ.is_pointer() && fmt !in [`p`, `x`, `X`]) || - (typ.is_string() && fmt != `s`) || - (typ.idx() in [table.i64_type_idx, table.f64_type_idx] && fmt == `c`) - { + if (typ.is_unsigned() && fmt !in [`u`, `x`, `X`, `o`, `c`]) + || (typ.is_signed() && fmt !in [`d`, `x`, `X`, `o`, `c`]) + || (typ.is_int_literal() && fmt !in [`d`, `c`, `x`, `X`, `o`, `u`, `x`, `X`, `o`]) + || (typ.is_float() && fmt !in [`E`, `F`, `G`, `e`, `f`, `g`]) + || (typ.is_pointer() && fmt !in [`p`, `x`, `X`]) + || (typ.is_string() && fmt != `s`) + || (typ.idx() in [table.i64_type_idx, table.f64_type_idx] && fmt == `c`) { c.error('illegal format specifier `${fmt:c}` for type `${c.table.get_type_name(ftyp)}`', node.fmt_poss[i]) } @@ -40,8 +37,8 @@ fn string_inter_lit(mut c checker.Checker, mut node ast.StringInterLiteral) tabl } fn get_some_val(a_test f64, b_test f64, c_test f64, d_test f64, e_test f64, f_test f64) f64 { - return a_test * b_test * c_test * d_test + - e_test * f_test * a_test * d_test + a_test * b_test * c_test + return a_test * b_test * c_test * d_test + e_test * f_test * a_test * d_test + + a_test * b_test * c_test } fn main() { @@ -55,10 +52,8 @@ fn main() { println(s) println('this is quite a long string' + ' that is followd by an even longer part that should go to another line') - if (a == b && b > r) || - (d > r) || (a < b) || (b < d && a + b > r) || - (a + b + d >= 0 && r < 0) || (a > b && d - r < b) - { + if (a == b && b > r) || (d > r) || (a < b) || (b < d && a + b > r) + || (a + b + d >= 0 && r < 0)|| (a > b && d - r < b) { println('ok') } } @@ -76,9 +71,8 @@ struct Parser { } fn (mut p Parser) name_expr() { - if p.peek_tok.kind == .lpar || - (p.peek_tok.kind == .lt && p.peek_tok2.kind == .name && p.peek_tok3.kind == .gt) - { + if p.peek_tok.kind == .lpar + || (p.peek_tok.kind == .lt && p.peek_tok2.kind == .name && p.peek_tok3.kind == .gt) { println(p.peek_tok.lit) } } diff --git a/vlib/v/fmt/tests/select_keep.vv b/vlib/v/fmt/tests/select_keep.vv index b901ae9819..3b44fa4328 100644 --- a/vlib/v/fmt/tests/select_keep.vv +++ b/vlib/v/fmt/tests/select_keep.vv @@ -108,8 +108,7 @@ fn test_select_blocks() { else { h = 2 } - } - { + } { panic('channel is still open') } else { is_open = false diff --git a/vlib/v/gen/auto_str_methods.v b/vlib/v/gen/auto_str_methods.v index bd13f84ca4..c97ca5d1d8 100644 --- a/vlib/v/gen/auto_str_methods.v +++ b/vlib/v/gen/auto_str_methods.v @@ -40,9 +40,7 @@ fn (g &Gen) type_to_fmt(typ table.Type) string { sym := g.table.get_type_symbol(typ) if typ.is_ptr() && (typ.is_int() || typ.is_float()) { return '%.*s\\000' - } else if sym.kind in - [.struct_, .array, .array_fixed, .map, .bool, .enum_, .interface_, .sum_type, .function] - { + } else if sym.kind in [.struct_, .array, .array_fixed, .map, .bool, .enum_, .interface_, .sum_type, .function] { return '%.*s\\000' } else if sym.kind == .string { return "'%.*s\\000'" @@ -184,8 +182,11 @@ fn (mut g Gen) gen_str_for_array(info table.Array, styp string, str_fn_name stri sym_has_str_method, str_method_expects_ptr, _ := sym.str_method_info() mut elem_str_fn_name := '' if sym_has_str_method { - elem_str_fn_name = if is_elem_ptr { field_styp.replace('*', '') + '_str' } else { field_styp + - '_str' } + elem_str_fn_name = if is_elem_ptr { + field_styp.replace('*', '') + '_str' + } else { + field_styp + '_str' + } if sym.kind == .byte { elem_str_fn_name = elem_str_fn_name + '_escaped' } @@ -263,8 +264,11 @@ fn (mut g Gen) gen_str_for_array_fixed(info table.ArrayFixed, styp string, str_f sym_has_str_method, str_method_expects_ptr, _ := sym.str_method_info() mut elem_str_fn_name := '' if sym_has_str_method { - elem_str_fn_name = if is_elem_ptr { field_styp.replace('*', '') + '_str' } else { field_styp + - '_str' } + elem_str_fn_name = if is_elem_ptr { + field_styp.replace('*', '') + '_str' + } else { + field_styp + '_str' + } } else { elem_str_fn_name = styp_to_str_fn_name(field_styp) } @@ -382,8 +386,11 @@ fn (mut g Gen) gen_str_for_multi_return(info table.MultiReturn, styp string, str sym_has_str_method, str_method_expects_ptr, _ := sym.str_method_info() mut arg_str_fn_name := '' if sym_has_str_method { - arg_str_fn_name = if is_arg_ptr { field_styp.replace('*', '') + '_str' } else { field_styp + - '_str' } + arg_str_fn_name = if is_arg_ptr { + field_styp.replace('*', '') + '_str' + } else { + field_styp + '_str' + } } else { arg_str_fn_name = styp_to_str_fn_name(field_styp) } @@ -440,8 +447,8 @@ fn (mut g Gen) gen_str_for_struct(info table.Struct, styp string, str_fn_name st if clean_struct_v_type_name.contains('_T_') { // TODO: this is a bit hacky. styp shouldn't be even parsed with _T_ // use something different than g.typ for styp - clean_struct_v_type_name = clean_struct_v_type_name.replace('_T_', '<').replace('_', ', ') + - '>' + clean_struct_v_type_name = + clean_struct_v_type_name.replace('_T_', '<').replace('_', ', ') + '>' } clean_struct_v_type_name = util.strip_main_name(clean_struct_v_type_name) // generate ident / indent length = 4 spaces diff --git a/vlib/v/gen/cgen.v b/vlib/v/gen/cgen.v index c0b89d6e71..a8eced4227 100644 --- a/vlib/v/gen/cgen.v +++ b/vlib/v/gen/cgen.v @@ -155,10 +155,8 @@ pub fn cgen(files []ast.File, table &table.Table, pref &pref.Preferences) string mut module_built := '' if pref.build_mode == .build_module { for file in files { - if pref.path in file.path && - file.mod.short_name == - pref.path.all_after_last(os.path_separator).trim_right(os.path_separator) - { + if pref.path in file.path + && file.mod.short_name == pref.path.all_after_last(os.path_separator).trim_right(os.path_separator) { module_built = file.mod.name break } @@ -408,8 +406,10 @@ pub fn (mut g Gen) init() { } if g.pref.compile_defines_all.len > 0 { g.comptime_defines.writeln('// V compile time defines by -d or -define flags:') - g.comptime_defines.writeln('// All custom defines : ' + g.pref.compile_defines_all.join(',')) - g.comptime_defines.writeln('// Turned ON custom defines: ' + g.pref.compile_defines.join(',')) + g.comptime_defines.writeln('// All custom defines : ' + + g.pref.compile_defines_all.join(',')) + g.comptime_defines.writeln('// Turned ON custom defines: ' + + g.pref.compile_defines.join(',')) for cdefine in g.pref.compile_defines { g.comptime_defines.writeln('#define CUSTOM_DEFINE_$cdefine') } @@ -1012,10 +1012,8 @@ fn (mut g Gen) stmt(node ast.Stmt) { // TODO true for not just "builtin" // TODO: clean this up mod := if g.is_builtin_mod { 'builtin' } else { node.name.all_before_last('.') } - if (mod != g.module_built && - node.mod != g.module_built.after('/')) || - should_bundle_module - { + if (mod != g.module_built && node.mod != g.module_built.after('/')) + || should_bundle_module { // Skip functions that don't have to be generated for this module. // println('skip bm $node.name mod=$node.mod module_built=$g.module_built') skip = true @@ -1030,10 +1028,8 @@ fn (mut g Gen) stmt(node ast.Stmt) { if g.pref.use_cache { // We are using prebuilt modules, we do not need to generate // their functions in main.c. - if node.mod != 'main' && - node.mod != 'help' && !should_bundle_module && !g.file.path.ends_with('_test.v') && - node.generic_params.len == 0 - { + if node.mod != 'main' && node.mod != 'help' && !should_bundle_module + && !g.file.path.ends_with('_test.v')&& node.generic_params.len == 0 { skip = true } } @@ -1042,15 +1038,13 @@ fn (mut g Gen) stmt(node ast.Stmt) { if node.name == 'main.main' { g.has_main = true } - if node.name == 'backtrace' || - node.name == 'backtrace_symbols' || node.name == 'backtrace_symbols_fd' - { + if node.name == 'backtrace' || node.name == 'backtrace_symbols' + || node.name == 'backtrace_symbols_fd' { g.write('\n#ifndef __cplusplus\n') } g.gen_fn_decl(node, skip) - if node.name == 'backtrace' || - node.name == 'backtrace_symbols' || node.name == 'backtrace_symbols_fd' - { + if node.name == 'backtrace' || node.name == 'backtrace_symbols' + || node.name == 'backtrace_symbols_fd' { g.write('\n#endif\n') } g.fn_decl = keep_fn_decl @@ -1504,7 +1498,8 @@ fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type_raw table.Type, expected_t got_is_ptr := got_type.is_ptr() expected_is_ptr := expected_type.is_ptr() neither_void := table.voidptr_type !in [got_type, expected_type] - if got_is_ptr && !expected_is_ptr && neither_void && expected_sym.kind !in [.interface_, .placeholder] { + if got_is_ptr && !expected_is_ptr && neither_void + && expected_sym.kind !in [.interface_, .placeholder] { got_deref_type := got_type.deref() deref_sym := g.table.get_type_symbol(got_deref_type) deref_will_match := expected_type in [got_type, got_deref_type, deref_sym.parent_idx] @@ -1671,9 +1666,9 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) { } // Free the old value assigned to this string var (only if it's `str = [new value]` // or `x.str = [new value]` ) - mut af := g.is_autofree && !g.is_builtin_mod && assign_stmt.op == .assign && assign_stmt.left_types.len == - 1 && - (assign_stmt.left[0] is ast.Ident || assign_stmt.left[0] is ast.SelectorExpr) + mut af := g.is_autofree && !g.is_builtin_mod && assign_stmt.op == .assign + && assign_stmt.left_types.len == 1 + && (assign_stmt.left[0] is ast.Ident || assign_stmt.left[0] is ast.SelectorExpr) // assign_stmt.left_types[0] in [table.string_type, table.array_type] && mut sref_name := '' mut type_to_free := '' @@ -1728,9 +1723,8 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) { // } // int pos = *(int*)_t190.data; mut tmp_opt := '' - is_optional := g.is_autofree && - (assign_stmt.op in [.decl_assign, .assign]) && assign_stmt.left_types.len == 1 && - assign_stmt.right[0] is ast.CallExpr + is_optional := g.is_autofree && (assign_stmt.op in [.decl_assign, .assign]) + && assign_stmt.left_types.len == 1&& assign_stmt.right[0] is ast.CallExpr if is_optional { // g.write('/* optional assignment */') call_expr := assign_stmt.right[0] as ast.CallExpr @@ -2035,12 +2029,9 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) { str_add = true } // Assignment Operator Overloading - if ((left_sym.kind == .struct_ && - right_sym.kind == .struct_) || - (left_sym.kind == .alias && - right_sym.kind == .alias)) && - assign_stmt.op in [.plus_assign, .minus_assign, .div_assign, .mult_assign, .mod_assign] - { + if ((left_sym.kind == .struct_ && right_sym.kind == .struct_) + || (left_sym.kind == .alias && right_sym.kind == .alias)) + && assign_stmt.op in [.plus_assign, .minus_assign, .div_assign, .mult_assign, .mod_assign] { extracted_op := match assign_stmt.op { .plus_assign { '+' } .minus_assign { '-' } @@ -2075,7 +2066,8 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) { g.prevent_sum_type_unwrapping_once = true } if !is_fixed_array_copy || is_decl { - if !is_decl && left is ast.Ident && g.for_in_mul_val_name == (left as ast.Ident).name { + if !is_decl && left is ast.Ident + && g.for_in_mul_val_name == (left as ast.Ident).name { g.write('*') } g.expr(left) @@ -2375,9 +2367,8 @@ fn (mut g Gen) autofree_scope_vars2(scope &ast.Scope, start_pos int, end_pos int // } // ``` // if !isnil(scope.parent) && line_nr > 0 { - if free_parent_scopes && !isnil(scope.parent) && - (stop_pos == -1 || scope.parent.start_pos >= stop_pos) - { + if free_parent_scopes && !isnil(scope.parent) + && (stop_pos == -1 || scope.parent.start_pos >= stop_pos) { g.writeln('// af parent scope:') g.autofree_scope_vars2(scope.parent, start_pos, end_pos, line_nr, true, stop_pos) } @@ -2535,9 +2526,8 @@ fn (mut g Gen) expr(node ast.Expr) { // if g.fileis('1.strings') { // println('before:' + node.autofree_pregen) // } - if g.is_autofree && !g.is_builtin_mod && !g.is_js_call && g.strs_to_free0.len == 0 && - !g.inside_lambda - { // && g.inside_ternary == + if g.is_autofree && !g.is_builtin_mod && !g.is_js_call && g.strs_to_free0.len == 0 + && !g.inside_lambda { // && g.inside_ternary == // if len != 0, that means we are handling call expr inside call expr (arg) // and it'll get messed up here, since it's handled recursively in autofree_call_pregen() // so just skip it @@ -2594,7 +2584,8 @@ fn (mut g Gen) expr(node ast.Expr) { g.write(')') } else if sym.kind == .sum_type { g.expr_with_cast(node.expr, node.expr_type, node.typ) - } else if sym.kind == .struct_ && !node.typ.is_ptr() && !(sym.info as table.Struct).is_typedef { + } else if sym.kind == .struct_ && !node.typ.is_ptr() + && !(sym.info as table.Struct).is_typedef { styp := g.typ(node.typ) g.write('*(($styp *)(&') g.expr(node.expr) @@ -2603,16 +2594,14 @@ fn (mut g Gen) expr(node ast.Expr) { styp := g.typ(node.typ) mut cast_label := '' // `table.string_type` is done for MSVC's bug - if sym.kind != .alias || - (sym.info as table.Alias).parent_type !in [node.expr_type, table.string_type] - { + if sym.kind != .alias + || (sym.info as table.Alias).parent_type !in [node.expr_type, table.string_type] { cast_label = '($styp)' } g.write('(${cast_label}(') g.expr(node.expr) - if node.expr is ast.IntegerLiteral && - node.typ in [table.u64_type, table.u32_type, table.u16_type] - { + if node.expr is ast.IntegerLiteral + && node.typ in [table.u64_type, table.u32_type, table.u16_type] { g.write('U') } g.write('))') @@ -3086,9 +3075,8 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) { g.write(')') } else if unaliased_left == table.string_type_idx && node.op !in [.key_in, .not_in] { // `str == ''` -> `str.len == 0` optimization - if node.op in [.eq, .ne] && - node.right is ast.StringLiteral && (node.right as ast.StringLiteral).val == '' - { + if node.op in [.eq, .ne] && node.right is ast.StringLiteral + && (node.right as ast.StringLiteral).val == '' { arrow := if left_type.is_ptr() { '->' } else { '.' } g.write('(') g.expr(node.left) @@ -3144,9 +3132,8 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) { } g.expr(node.right) g.write(')') - } else if node.op in [.eq, .ne] && - left_sym.kind == .array_fixed && right_sym.kind == .array_fixed - { + } else if node.op in [.eq, .ne] && left_sym.kind == .array_fixed + && right_sym.kind == .array_fixed { ptr_typ := g.gen_fixed_array_equality_fn(left_type) if node.op == .ne { g.write('!') @@ -3184,9 +3171,8 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) { } g.expr(node.right) g.write(')') - } else if node.op in [.eq, .ne] && - left_sym.kind == .struct_ && right_sym.kind == .struct_ && has_eq_overloaded && has_ne_overloaded - { + } else if node.op in [.eq, .ne] && left_sym.kind == .struct_ && right_sym.kind == .struct_ + && has_eq_overloaded&& has_ne_overloaded { ptr_typ := g.gen_struct_equality_fn(left_type) if node.op == .eq { g.write('${ptr_typ}_struct_eq(') @@ -3327,41 +3313,45 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) { if gen_or { g.or_block(tmp_opt, node.or_block, table.void_type) } - } else if unaliased_left.idx() in [table.u32_type_idx, table.u64_type_idx] && unaliased_right.is_signed() && - node.op in [.eq, .ne, .gt, .lt, .ge, .le] - { - bitsize := if unaliased_left.idx() == table.u32_type_idx && - unaliased_right.idx() != table.i64_type_idx - { 32 } else { 64 } + } else if unaliased_left.idx() in [table.u32_type_idx, table.u64_type_idx] + && unaliased_right.is_signed()&& node.op in [.eq, .ne, .gt, .lt, .ge, .le] { + bitsize := if unaliased_left.idx() == table.u32_type_idx + && unaliased_right.idx() != table.i64_type_idx { + 32 + } else { + 64 + } g.write('_us${bitsize}_${cmp_str[int(node.op) - int(token.Kind.eq)]}(') g.expr(node.left) g.write(',') g.expr(node.right) g.write(')') - } else if unaliased_right.idx() in [table.u32_type_idx, table.u64_type_idx] && unaliased_left.is_signed() && - node.op in [.eq, .ne, .gt, .lt, .ge, .le] - { - bitsize := if unaliased_right.idx() == table.u32_type_idx && - unaliased_left.idx() != table.i64_type_idx - { 32 } else { 64 } + } else if unaliased_right.idx() in [table.u32_type_idx, table.u64_type_idx] + && unaliased_left.is_signed()&& node.op in [.eq, .ne, .gt, .lt, .ge, .le] { + bitsize := if unaliased_right.idx() == table.u32_type_idx + && unaliased_left.idx() != table.i64_type_idx { + 32 + } else { + 64 + } g.write('_us${bitsize}_${cmp_rev[int(node.op) - int(token.Kind.eq)]}(') g.expr(node.right) g.write(',') g.expr(node.left) g.write(')') } else { - a := (left_sym.name[0].is_capital() || left_sym.name.contains('.')) && - left_sym.kind !in [.enum_, .function, .interface_, .sum_type] && left_sym.language != .c + a := (left_sym.name[0].is_capital() || left_sym.name.contains('.')) + && left_sym.kind !in [.enum_, .function, .interface_, .sum_type] + && left_sym.language != .c b := left_sym.kind != .alias c := left_sym.kind == .alias && (left_sym.info as table.Alias).language == .c // Check if aliased type is a struct - d := !b && - g.typ((left_sym.info as table.Alias).parent_type).split('__').last()[0].is_capital() + d := !b + && g.typ((left_sym.info as table.Alias).parent_type).split('__').last()[0].is_capital() // Do not generate operator overloading with these `right_sym.kind`. e := right_sym.kind !in [.voidptr, .int_literal, .int] - if node.op in [.plus, .minus, .mul, .div, .mod, .lt, .gt, .eq, .ne, .le, .ge] && - ((a && b && e) || c || d) - { + if node.op in [.plus, .minus, .mul, .div, .mod, .lt, .gt, .eq, .ne, .le, .ge] + && ((a && b && e) || c|| d) { // Overloaded operators g.write(g.typ(if !d { left_type @@ -3565,9 +3555,8 @@ fn (mut g Gen) match_expr_classic(node ast.MatchExpr, is_expr bool, cond_var str // if type is unsigned and low is 0, check is unneeded mut skip_low := false if expr.low is ast.IntegerLiteral { - if node.cond_type in [table.u16_type, table.u32_type, table.u64_type] && - expr.low.val == '0' - { + if node.cond_type in [table.u16_type, table.u32_type, table.u64_type] + && expr.low.val == '0' { skip_low = true } } @@ -3633,10 +3622,8 @@ fn (mut g Gen) select_expr(node ast.SelectExpr) { // send expression expr := branch.stmt.expr as ast.InfixExpr channels << expr.left - if expr.right is ast.Ident || - expr.right is ast.IndexExpr || expr.right is ast.SelectorExpr || expr.right is - ast.StructInit - { + if expr.right is ast.Ident || expr.right is ast.IndexExpr + || expr.right is ast.SelectorExpr|| expr.right is ast.StructInit { // addressable objects in the `C` output objs << expr.right tmp_objs << '' @@ -3656,9 +3643,8 @@ fn (mut g Gen) select_expr(node ast.SelectExpr) { channels << rec_expr.right is_push << false // create tmp unless the object with *exactly* the type we need exists already - if branch.stmt.op == .decl_assign || - branch.stmt.right_types[0] != branch.stmt.left_types[0] - { + if branch.stmt.op == .decl_assign + || branch.stmt.right_types[0] != branch.stmt.left_types[0] { tmp_obj := g.new_tmp_var() tmp_objs << tmp_obj el_stype := g.typ(branch.stmt.right_types[0]) @@ -3850,11 +3836,8 @@ fn (mut g Gen) if_expr(node ast.IfExpr) { // (as it used to be done). // Always use this in -autofree, since ?: can have tmp expressions that have to be freed. first_branch := node.branches[0] - needs_tmp_var := node.is_expr && - (g.is_autofree || (g.pref.experimental && - (first_branch.stmts.len > 1 || - (first_branch.stmts[0] is ast.ExprStmt && - (first_branch.stmts[0] as ast.ExprStmt).expr is ast.IfExpr)))) + needs_tmp_var := node.is_expr + && (g.is_autofree || (g.pref.experimental && (first_branch.stmts.len > 1 || (first_branch.stmts[0] is ast.ExprStmt && (first_branch.stmts[0] as ast.ExprStmt).expr is ast.IfExpr)))) /* needs_tmp_var := node.is_expr && (g.autofree || g.pref.experimental) && @@ -4108,8 +4091,8 @@ fn (mut g Gen) index_expr(node ast.IndexExpr) { .function { 'voidptr*' } else { '$elem_type_str*' } } - needs_clone := info.elem_type == table.string_type_idx && g.is_autofree && - !g.is_assign_lhs + needs_clone := info.elem_type == table.string_type_idx && g.is_autofree + && !g.is_assign_lhs is_gen_or_and_assign_rhs := gen_or && g.is_assign_rhs cur_line := if is_gen_or_and_assign_rhs { line := g.go_before_stmt(0) @@ -4228,9 +4211,9 @@ fn (mut g Gen) index_expr(node ast.IndexExpr) { zero := g.type_default(info.value_type) g.write('$zero })))') } - } else if g.inside_map_postfix || g.inside_map_infix || g.inside_map_index || - (g.is_assign_lhs && !g.is_array_set && get_and_set_types) - { + } else if g.inside_map_postfix || g.inside_map_infix + || g.inside_map_index + || (g.is_assign_lhs && !g.is_array_set && get_and_set_types) { zero := g.type_default(info.value_type) g.write('(*($elem_type_str*)map_get_and_set_1(') if !left_is_ptr { @@ -4733,9 +4716,8 @@ fn (mut g Gen) struct_init(struct_init ast.StructInit) { } } if !cloned { - if field.expected_type.is_ptr() && !(field.typ.is_ptr() || field.typ.is_pointer()) && - !field.typ.is_number() - { + if field.expected_type.is_ptr() && !(field.typ.is_ptr() + || field.typ.is_pointer())&& !field.typ.is_number() { g.write('/* autoref */&') } g.expr_with_cast(field.expr, field.typ, field.expected_type) @@ -4794,8 +4776,8 @@ fn (mut g Gen) struct_init(struct_init ast.StructInit) { expected_field_type_sym := g.table.get_type_symbol(sfield.expected_type) field_type_sym := g.table.get_type_symbol(sfield.typ) mut cloned := false - is_interface := expected_field_type_sym.kind == .interface_ && - field_type_sym.kind != .interface_ + is_interface := expected_field_type_sym.kind == .interface_ + && field_type_sym.kind != .interface_ if g.is_autofree && !sfield.typ.is_ptr() && field_type_sym.kind in [.array, .string] { g.write('/*clone1*/') if g.gen_clone_assignment(sfield.expr, field_type_sym, false) { @@ -4806,9 +4788,8 @@ fn (mut g Gen) struct_init(struct_init ast.StructInit) { if is_interface { g.interface_call(sfield.typ, sfield.expected_type) } - if sfield.expected_type.is_ptr() && !(sfield.typ.is_ptr() || sfield.typ.is_pointer()) && - !sfield.typ.is_number() - { + if sfield.expected_type.is_ptr() && !(sfield.typ.is_ptr() + || sfield.typ.is_pointer())&& !sfield.typ.is_number() { g.write('/* autoref */&') } g.expr_with_cast(sfield.expr, sfield.typ, sfield.expected_type) @@ -5187,7 +5168,8 @@ fn (g &Gen) sort_structs(typesa []table.TypeSymbol) []table.TypeSymbol { if !dep_graph_sorted.acyclic { // this should no longer be called since it's catched in the parser // TODO: should it be removed? - verror('cgen.sort_structs(): the following structs form a dependency cycle:\n' + dep_graph_sorted.display_cycles() + + verror('cgen.sort_structs(): the following structs form a dependency cycle:\n' + + dep_graph_sorted.display_cycles() + '\nyou can solve this by making one or both of the dependant struct fields references, eg: field &MyStruct' + '\nif you feel this is an error, please create a new issue here: https://github.com/vlang/v/issues and tag @joe-conigliaro') } @@ -5258,16 +5240,16 @@ fn (mut g Gen) or_block(var_name string, or_block ast.OrExpr, return_type table. g.inside_or_block = false } stmts := or_block.stmts - if stmts.len > 0 && stmts[or_block.stmts.len - 1] is ast.ExprStmt && (stmts[stmts.len - - 1] as ast.ExprStmt).typ != table.void_type - { + if stmts.len > 0 && stmts[or_block.stmts.len - 1] is ast.ExprStmt + && (stmts[stmts.len - 1] as ast.ExprStmt).typ != table.void_type { g.indent++ for i, stmt in stmts { if i == stmts.len - 1 { expr_stmt := stmt as ast.ExprStmt g.stmt_path_pos << g.out.len g.write('*($mr_styp*) ${cvar_name}.data = ') - is_opt_call := expr_stmt.expr is ast.CallExpr && expr_stmt.typ.has_flag(.optional) + is_opt_call := expr_stmt.expr is ast.CallExpr + && expr_stmt.typ.has_flag(.optional) if is_opt_call { g.write('*($mr_styp*) ') } @@ -5472,9 +5454,8 @@ fn (mut g Gen) comp_if_to_ifdef(name string, is_comptime_optional bool) ?string return 'TARGET_ORDER_IS_BIG' } else { - if is_comptime_optional || - (g.pref.compile_defines_all.len > 0 && name in g.pref.compile_defines_all) - { + if is_comptime_optional + || (g.pref.compile_defines_all.len > 0 && name in g.pref.compile_defines_all) { return 'CUSTOM_DEFINE_$name' } return error('bad os ifdef name "$name"') // should never happen, caught in the checker @@ -5928,7 +5909,8 @@ fn (mut g Gen) interface_table() string { // i.e. cctype is always just Cat, not Cat_ptr: cctype := g.cc_type(st) $if debug_interface_table ? { - eprintln('>> interface name: $ityp.name | concrete type: $st.debug() | st symname: ' + + eprintln( + '>> interface name: $ityp.name | concrete type: $st.debug() | st symname: ' + g.table.get_type_symbol(st).name) } // Speaker_Cat_index = 0 diff --git a/vlib/v/gen/comptime.v b/vlib/v/gen/comptime.v index f81f8fb019..e8c68b3c6a 100644 --- a/vlib/v/gen/comptime.v +++ b/vlib/v/gen/comptime.v @@ -17,9 +17,8 @@ fn (mut g Gen) comptime_selector(node ast.ComptimeSelector) { // check for field.name if node.field_expr is ast.SelectorExpr { if node.field_expr.expr is ast.Ident { - if node.field_expr.expr.name == g.comp_for_field_var && - node.field_expr.field_name == 'name' - { + if node.field_expr.expr.name == g.comp_for_field_var + && node.field_expr.field_name == 'name' { g.write(g.comp_for_field_value.name) return } @@ -316,7 +315,8 @@ fn (mut g Gen) comp_for(node ast.CompFor) { g.writeln('\t${node.val_var}.attrs = __new_array_with_default(0, 0, sizeof(string), 0);') } else { attrs := cgen_attrs(method.attrs) - g.writeln('\t${node.val_var}.attrs = new_array_from_c_array($attrs.len, $attrs.len, sizeof(string), _MOV((string[$attrs.len]){' + + g.writeln( + '\t${node.val_var}.attrs = new_array_from_c_array($attrs.len, $attrs.len, sizeof(string), _MOV((string[$attrs.len]){' + attrs.join(', ') + '}));') } if method.params.len < 2 { @@ -385,7 +385,8 @@ fn (mut g Gen) comp_for(node ast.CompFor) { g.writeln('\t${node.val_var}.attrs = __new_array_with_default(0, 0, sizeof(string), 0);') } else { attrs := cgen_attrs(field.attrs) - g.writeln('\t${node.val_var}.attrs = new_array_from_c_array($attrs.len, $attrs.len, sizeof(string), _MOV((string[$attrs.len]){' + + g.writeln( + '\t${node.val_var}.attrs = new_array_from_c_array($attrs.len, $attrs.len, sizeof(string), _MOV((string[$attrs.len]){' + attrs.join(', ') + '}));') } // field_sym := g.table.get_type_symbol(field.typ) diff --git a/vlib/v/gen/fn.v b/vlib/v/gen/fn.v index 1630a6f4e5..74deb3eb73 100644 --- a/vlib/v/gen/fn.v +++ b/vlib/v/gen/fn.v @@ -129,10 +129,8 @@ fn (mut g Gen) gen_fn_decl(it ast.FnDecl, skip bool) { arg_start_pos := g.out.len fargs, fargtypes := g.fn_args(it.params, it.is_variadic) arg_str := g.out.after(arg_start_pos) - if it.no_body || - ((g.pref.use_cache && g.pref.build_mode != .build_module) && it.is_builtin && !g.is_test) || - skip - { + if it.no_body || ((g.pref.use_cache && g.pref.build_mode != .build_module) && it.is_builtin + && !g.is_test)|| skip { // Just a function header. Builtin function bodies are defined in builtin.o g.definitions.writeln(');') // // NO BODY') g.writeln(');') @@ -295,9 +293,9 @@ fn (mut g Gen) call_expr(node ast.CallExpr) { g.write('$styp $tmp_opt = ') } if node.is_method && !node.is_field { - if node.name == 'writeln' && g.pref.experimental && node.args.len > 0 && node.args[0].expr is - ast.StringInterLiteral && g.table.get_type_symbol(node.receiver_type).name == 'strings.Builder' - { + if node.name == 'writeln' && g.pref.experimental && node.args.len > 0 + && node.args[0].expr is ast.StringInterLiteral + && g.table.get_type_symbol(node.receiver_type).name == 'strings.Builder' { g.string_inter_literal_sb_optimized(node) } else { g.method_call(node) @@ -413,9 +411,8 @@ fn (mut g Gen) method_call(node ast.CallExpr) { receiver_type_name = 'map' } // TODO performance, detect `array` method differently - if left_sym.kind == .array && node.name in - ['repeat', 'sort_with_compare', 'free', 'push_many', 'trim', 'first', 'last', 'pop', 'clone', 'reverse', 'slice'] - { + if left_sym.kind == .array + && node.name in ['repeat', 'sort_with_compare', 'free', 'push_many', 'trim', 'first', 'last', 'pop', 'clone', 'reverse', 'slice'] { // && rec_sym.name == 'array' { // && rec_sym.name == 'array' && receiver_name.starts_with('array') { // `array_byte_clone` => `array_clone` @@ -480,9 +477,8 @@ fn (mut g Gen) method_call(node ast.CallExpr) { if !is_range_slice { g.write('&') } - } else if !node.receiver_type.is_ptr() && node.left_type.is_ptr() && node.name != 'str' && - node.from_embed_type == 0 - { + } else if !node.receiver_type.is_ptr() && node.left_type.is_ptr() && node.name != 'str' + && node.from_embed_type == 0 { g.write('/*rec*/*') } if g.is_autofree && node.free_receiver && !g.inside_lambda && !g.is_builtin_mod { @@ -505,8 +501,8 @@ fn (mut g Gen) method_call(node ast.CallExpr) { if has_cast { g.write(')') } - is_variadic := node.expected_arg_types.len > 0 && node.expected_arg_types[node.expected_arg_types.len - - 1].has_flag(.variadic) + is_variadic := node.expected_arg_types.len > 0 + && node.expected_arg_types[node.expected_arg_types.len - 1].has_flag(.variadic) if node.args.len > 0 || is_variadic { g.write(', ') } @@ -672,8 +668,8 @@ fn (mut g Gen) autofree_call_pregen(node ast.CallExpr) { // g.writeln('// autofree_call_pregen()') // Create a temporary var before fn call for each argument in order to free it (only if it's a complex expression, // like `foo(get_string())` or `foo(a + b)` - mut free_tmp_arg_vars := g.is_autofree && !g.is_builtin_mod && node.args.len > 0 && - !node.args[0].typ.has_flag(.optional) // TODO copy pasta checker.v + mut free_tmp_arg_vars := g.is_autofree && !g.is_builtin_mod && node.args.len > 0 + && !node.args[0].typ.has_flag(.optional) // TODO copy pasta checker.v if !free_tmp_arg_vars { return } @@ -803,13 +799,14 @@ fn (mut g Gen) autofree_call_postgen(node_pos int) { fn (mut g Gen) call_args(node ast.CallExpr) { args := if g.is_js_call { node.args[1..] } else { node.args } expected_types := node.expected_arg_types - is_variadic := expected_types.len > 0 && expected_types[expected_types.len - 1].has_flag(.variadic) + is_variadic := expected_types.len > 0 + && expected_types[expected_types.len - 1].has_flag(.variadic) for i, arg in args { if is_variadic && i == expected_types.len - 1 { break } - use_tmp_var_autofree := g.is_autofree && arg.typ == table.string_type && arg.is_tmp_autofree && - !g.inside_const && !g.is_builtin_mod + use_tmp_var_autofree := g.is_autofree && arg.typ == table.string_type && arg.is_tmp_autofree + && !g.inside_const&& !g.is_builtin_mod // g.write('/* af=$arg.is_tmp_autofree */') mut is_interface := false // some c fn definitions dont have args (cfns.v) or are not updated in checker diff --git a/vlib/v/gen/json.v b/vlib/v/gen/json.v index 74ef1c8bfb..906d338af8 100644 --- a/vlib/v/gen/json.v +++ b/vlib/v/gen/json.v @@ -128,7 +128,8 @@ fn (mut g Gen) gen_struct_enc_dec(type_info table.TypeInfo, styp string, mut enc field_sym := g.table.get_type_symbol(field.typ) // First generate decoding if field.attrs.contains('raw') { - dec.writeln('\tres.${c_name(field.name)} = tos4(cJSON_PrintUnformatted(' + 'js_get(root, "$name")));') + dec.writeln('\tres.${c_name(field.name)} = tos4(cJSON_PrintUnformatted(' + + 'js_get(root, "$name")));') } else { // Now generate decoders for all field types in this struct // need to do it here so that these functions are generated first @@ -201,8 +202,7 @@ fn js_dec_name(typ string) string { } fn is_js_prim(typ string) bool { - return typ in - ['int', 'string', 'bool', 'f32', 'f64', 'i8', 'i16', 'i64', 'u16', 'u32', 'u64', 'byte'] + return typ in ['int', 'string', 'bool', 'f32', 'f64', 'i8', 'i16', 'i64', 'u16', 'u32', 'u64', 'byte'] } fn (mut g Gen) decode_array(value_type table.Type) string { diff --git a/vlib/v/gen/live.v b/vlib/v/gen/live.v index fdbbd48c67..fe11067bec 100644 --- a/vlib/v/gen/live.v +++ b/vlib/v/gen/live.v @@ -45,8 +45,7 @@ fn (mut g Gen) generate_hotcode_reloader_code() { phd = posix_hotcode_definitions_1 } else { for so_fn in g.hotcode_fn_names { - load_code << - 'impl_live_$so_fn = (void *)GetProcAddress(live_lib, "impl_live_$so_fn"); ' + load_code << 'impl_live_$so_fn = (void *)GetProcAddress(live_lib, "impl_live_$so_fn"); ' } phd = windows_hotcode_definitions_1 } diff --git a/vlib/v/gen/str.v b/vlib/v/gen/str.v index 0d0683d0ff..78e7b5aa8f 100644 --- a/vlib/v/gen/str.v +++ b/vlib/v/gen/str.v @@ -340,9 +340,8 @@ fn (mut g Gen) gen_expr_to_string(expr ast.Expr, etype table.Type) { g.enum_expr(expr) g.write('")') } - } else if sym_has_str_method || sym.kind in - [.array, .array_fixed, .map, .struct_, .multi_return, .sum_type, .interface_] - { + } else if sym_has_str_method + || sym.kind in [.array, .array_fixed, .map, .struct_, .multi_return, .sum_type, .interface_] { is_ptr := typ.is_ptr() str_fn_name := g.gen_str_for_type(typ) if is_ptr { diff --git a/vlib/v/parser/assign.v b/vlib/v/parser/assign.v index df49921e05..59f1cf3f86 100644 --- a/vlib/v/parser/assign.v +++ b/vlib/v/parser/assign.v @@ -65,7 +65,8 @@ fn (mut p Parser) check_cross_variables(exprs []ast.Expr, val ast.Expr) bool { } } ast.InfixExpr { - return p.check_cross_variables(exprs, val_.left) || p.check_cross_variables(exprs, val_.right) + return p.check_cross_variables(exprs, val_.left) + || p.check_cross_variables(exprs, val_.right) } ast.PrefixExpr { return p.check_cross_variables(exprs, val_.right) diff --git a/vlib/v/parser/fn.v b/vlib/v/parser/fn.v index 07de934bac..1aa2d7b781 100644 --- a/vlib/v/parser/fn.v +++ b/vlib/v/parser/fn.v @@ -275,9 +275,8 @@ fn (mut p Parser) fn_decl() ast.FnDecl { } } } - if p.tok.kind in [.plus, .minus, .mul, .div, .mod, .gt, .lt, .eq, .ne, .le, .ge] && - p.peek_tok.kind == .lpar - { + if p.tok.kind in [.plus, .minus, .mul, .div, .mod, .gt, .lt, .eq, .ne, .le, .ge] + && p.peek_tok.kind == .lpar { name = p.tok.kind.str() // op_to_fn_name() if rec_type == table.void_type { p.error_with_pos('cannot use operator overloading with normal functions', @@ -311,9 +310,8 @@ fn (mut p Parser) fn_decl() ast.FnDecl { mut end_pos := p.prev_tok.position() // Return type mut return_type := table.void_type - if p.tok.kind.is_start_of_type() || - (p.tok.kind == .key_fn && p.tok.line_nr == p.prev_tok.line_nr) - { + if p.tok.kind.is_start_of_type() + || (p.tok.kind == .key_fn && p.tok.line_nr == p.prev_tok.line_nr) { return_type = p.parse_type() } mut type_sym_method_idx := 0 @@ -327,8 +325,8 @@ fn (mut p Parser) fn_decl() ast.FnDecl { // check maps & arrays, must be defined in same module as the elem type if !is_non_local && type_sym.kind in [.array, .map] { elem_type_sym := p.table.get_type_symbol(p.table.value_type(rec_type)) - is_non_local = elem_type_sym.mod.len > 0 && - elem_type_sym.mod != p.mod && elem_type_sym.language == .v + is_non_local = elem_type_sym.mod.len > 0 && elem_type_sym.mod != p.mod + && elem_type_sym.language == .v } if is_non_local { p.error_with_pos('cannot define new methods on non-local type $type_sym.name', @@ -570,9 +568,9 @@ fn (mut p Parser) fn_args() ([]table.Param, bool, bool) { } else { p.tok.lit } - types_only := p.tok.kind in [.amp, .ellipsis, .key_fn] || - (p.peek_tok.kind == .comma && p.table.known_type(argname)) || p.peek_tok.kind == .dot || - p.peek_tok.kind == .rpar + types_only := p.tok.kind in [.amp, .ellipsis, .key_fn] + || (p.peek_tok.kind == .comma && p.table.known_type(argname)) + || p.peek_tok.kind == .dot|| p.peek_tok.kind == .rpar // TODO copy pasta, merge 2 branches if types_only { // p.warn('types only') @@ -668,7 +666,8 @@ fn (mut p Parser) fn_args() ([]table.Param, bool, bool) { // `a, b, c int` for p.tok.kind == .comma { if !p.pref.is_fmt { - p.warn('`fn f(x, y Type)` syntax has been deprecated and will soon be removed. ' + + p.warn( + '`fn f(x, y Type)` syntax has been deprecated and will soon be removed. ' + 'Use `fn f(x Type, y Type)` instead. You can run `v fmt -w "$p.scanner.file_path"` to automatically fix your code.') } p.next() @@ -746,11 +745,10 @@ fn (mut p Parser) fn_args() ([]table.Param, bool, bool) { fn (mut p Parser) check_fn_mutable_arguments(typ table.Type, pos token.Position) { sym := p.table.get_type_symbol(typ) - if sym.kind !in - [.array, .array_fixed, .interface_, .map, .placeholder, .struct_, .sum_type] && - !typ.is_ptr() && !typ.is_pointer() - { - p.error_with_pos('mutable arguments are only allowed for arrays, interfaces, maps, pointers and structs\n' + + if sym.kind !in [.array, .array_fixed, .interface_, .map, .placeholder, .struct_, .sum_type] + && !typ.is_ptr()&& !typ.is_pointer() { + p.error_with_pos( + 'mutable arguments are only allowed for arrays, interfaces, maps, pointers and structs\n' + 'return values instead: `fn foo(mut n $sym.name) {` => `fn foo(n $sym.name) $sym.name {`', pos) } diff --git a/vlib/v/parser/for.v b/vlib/v/parser/for.v index fb20053a10..175c8d50d5 100644 --- a/vlib/v/parser/for.v +++ b/vlib/v/parser/for.v @@ -78,9 +78,8 @@ fn (mut p Parser) for_stmt() ast.Stmt { } p.close_scope() return for_c_stmt - } else if p.peek_tok.kind in [.key_in, .comma] || - (p.tok.kind == .key_mut && p.peek_tok2.kind in [.key_in, .comma]) - { + } else if p.peek_tok.kind in [.key_in, .comma] + || (p.tok.kind == .key_mut && p.peek_tok2.kind in [.key_in, .comma]) { // `for i in vals`, `for i in start .. end`, `for mut user in users`, `for i, mut user in users` mut val_is_mut := p.tok.kind == .key_mut mut_pos := p.tok.position() diff --git a/vlib/v/parser/if_match.v b/vlib/v/parser/if_match.v index e878b9d566..546474dd17 100644 --- a/vlib/v/parser/if_match.v +++ b/vlib/v/parser/if_match.v @@ -179,13 +179,10 @@ fn (mut p Parser) match_expr() ast.MatchExpr { if p.tok.kind == .key_else { is_else = true p.next() - } else if (p.tok.kind == .name && !(p.tok.lit == 'C' && - p.peek_tok.kind == .dot) && - (p.tok.lit in table.builtin_type_names || p.tok.lit[0].is_capital() || - (p.peek_tok.kind == .dot && - p.peek_tok2.lit.len > 0 && p.peek_tok2.lit[0].is_capital()))) || - p.tok.kind == .lsbr - { + } else if (p.tok.kind == .name && !(p.tok.lit == 'C' && p.peek_tok.kind == .dot) + && (p.tok.lit in table.builtin_type_names || p.tok.lit[0].is_capital() + || (p.peek_tok.kind == .dot && p.peek_tok2.lit.len > 0 && p.peek_tok2.lit[0].is_capital()))) + || p.tok.kind == .lsbr { mut types := []table.Type{} for { // Sum type match diff --git a/vlib/v/parser/parse_type.v b/vlib/v/parser/parse_type.v index 2a3f1c92e6..3fe69718cf 100644 --- a/vlib/v/parser/parse_type.v +++ b/vlib/v/parser/parse_type.v @@ -77,9 +77,8 @@ pub fn (mut p Parser) parse_map_type() table.Type { // error is reported in parse_type return 0 } - if !(key_type in [table.string_type_idx, table.voidptr_type_idx] || - (key_type.is_int() && !key_type.is_ptr())) - { + if !(key_type in [table.string_type_idx, table.voidptr_type_idx] + || (key_type.is_int() && !key_type.is_ptr())) { s := p.table.type_to_str(key_type) p.error_with_pos('maps only support string, integer, rune or voidptr keys for now (not `$s`)', p.tok.position()) diff --git a/vlib/v/parser/parser.v b/vlib/v/parser/parser.v index 78a4540bd5..d889f401bf 100644 --- a/vlib/v/parser/parser.v +++ b/vlib/v/parser/parser.v @@ -125,11 +125,11 @@ pub fn (mut p Parser) set_path(path string) { p.file_name = path p.file_base = os.base(path) p.file_name_dir = os.dir(path) - if path.ends_with('_c.v') || path.ends_with('.c.v') || path.ends_with('.c.vv') || path.ends_with('.c.vsh') { + if path.ends_with('_c.v') || path.ends_with('.c.v') || path.ends_with('.c.vv') + || path.ends_with('.c.vsh') { p.file_backend_mode = .c - } else if path.ends_with('_js.v') || path.ends_with('.js.v') || path.ends_with('.js.vv') || - path.ends_with('.js.vsh') - { + } else if path.ends_with('_js.v') || path.ends_with('.js.v') || path.ends_with('.js.vv') + || path.ends_with('.js.vsh') { p.file_backend_mode = .js } else { p.file_backend_mode = .v @@ -677,9 +677,8 @@ pub fn (mut p Parser) stmt(is_top_level bool) ast.Stmt { } else if p.peek_tok.kind == .name { p.error_with_pos('unexpected name `$p.peek_tok.lit`', p.peek_tok.position()) return ast.Stmt{} - } else if !p.inside_if_expr && !p.inside_match_body && !p.inside_or_expr && - p.peek_tok.kind in [.rcbr, .eof] && !p.mark_var_as_used(p.tok.lit) - { + } else if !p.inside_if_expr && !p.inside_match_body && !p.inside_or_expr + && p.peek_tok.kind in [.rcbr, .eof]&& !p.mark_var_as_used(p.tok.lit) { p.error_with_pos('`$p.tok.lit` evaluated but not used', p.tok.position()) return ast.Stmt{} } @@ -1004,12 +1003,11 @@ fn (mut p Parser) parse_multi_expr(is_top_level bool) ast.Stmt { } if p.tok.kind in [.assign, .decl_assign] || p.tok.kind.is_assign() { return p.partial_assign_stmt(left, left_comments) - } else if tok.kind !in [.key_if, .key_match, .key_lock, .key_rlock, .key_select] && - left0 !is ast.CallExpr && (is_top_level || p.tok.kind != .rcbr) && left0 !is ast.PostfixExpr && - !(left0 is ast.InfixExpr && - (left0 as ast.InfixExpr).op in [.left_shift, .arrow]) && left0 !is ast.ComptimeCall && - left0 !is ast.SelectorExpr - { + } else if tok.kind !in [.key_if, .key_match, .key_lock, .key_rlock, .key_select] + && left0 !is ast.CallExpr && (is_top_level || p.tok.kind != .rcbr) + && left0 !is ast.PostfixExpr && !(left0 is ast.InfixExpr + && (left0 as ast.InfixExpr).op in [.left_shift, .arrow]) && left0 !is ast.ComptimeCall + && left0 !is ast.SelectorExpr { p.error_with_pos('expression evaluated but not used', left0.position()) return ast.Stmt{} } @@ -1100,9 +1098,7 @@ fn (p &Parser) is_generic_call() bool { return !lit0_is_capital && p.peek_tok.kind == .lt && (match p.peek_tok2.kind { .name { // maybe `f`, `f`, assume `var < []` is invalid @@ -1206,9 +1202,8 @@ pub fn (mut p Parser) name_expr() ast.Expr { } known_var := p.mark_var_as_used(p.tok.lit) mut is_mod_cast := false - if p.peek_tok.kind == .dot && !known_var && - (language != .v || p.known_import(p.tok.lit) || p.mod.all_after_last('.') == p.tok.lit) - { + if p.peek_tok.kind == .dot && !known_var && (language != .v || p.known_import(p.tok.lit) + || p.mod.all_after_last('.') == p.tok.lit) { // p.tok.lit has been recognized as a module if language == .c { mod = 'C' @@ -1218,13 +1213,11 @@ pub fn (mut p Parser) name_expr() ast.Expr { if p.tok.lit in p.imports { // mark the imported module as used p.register_used_import(p.tok.lit) - if p.peek_tok.kind == .dot && - p.peek_tok2.kind != .eof && p.peek_tok2.lit.len > 0 && p.peek_tok2.lit[0].is_capital() - { + if p.peek_tok.kind == .dot && p.peek_tok2.kind != .eof && p.peek_tok2.lit.len > 0 + && p.peek_tok2.lit[0].is_capital() { is_mod_cast = true - } else if p.peek_tok.kind == .dot && - p.peek_tok2.kind != .eof && p.peek_tok2.lit.len == 0 - { + } else if p.peek_tok.kind == .dot && p.peek_tok2.kind != .eof + && p.peek_tok2.lit.len == 0 { // incomplete module selector must be handled by dot_expr instead node = p.parse_ident(language) return node @@ -1256,10 +1249,9 @@ pub fn (mut p Parser) name_expr() ast.Expr { name_w_mod := p.prepend_mod(name) // type cast. TODO: finish // if name in table.builtin_type_names { - if (!known_var && (name in p.table.type_idxs || - name_w_mod in p.table.type_idxs) && name !in ['C.stat', 'C.sigaction']) || - is_mod_cast || (language == .v && name[0].is_capital()) - { + if (!known_var && (name in p.table.type_idxs || name_w_mod in p.table.type_idxs) + && name !in ['C.stat', 'C.sigaction']) || is_mod_cast + || (language == .v && name[0].is_capital()) { // MainLetter(x) is *always* a cast, as long as it is not `C.` // TODO handle C.stat() start_pos := p.tok.position() @@ -1299,13 +1291,10 @@ pub fn (mut p Parser) name_expr() ast.Expr { // println('calling $p.tok.lit') node = p.call_expr(language, mod) } - } else if (p.peek_tok.kind == .lcbr || - (p.peek_tok.kind == .lt && lit0_is_capital)) && - (!p.inside_match || (p.inside_select && prev_tok_kind == .arrow && lit0_is_capital)) && - !p.inside_match_case && - (!p.inside_if || p.inside_select) && - (!p.inside_for || p.inside_select) - { // && (p.tok.lit[0].is_capital() || p.builtin_mod) { + } else if (p.peek_tok.kind == .lcbr || (p.peek_tok.kind == .lt && lit0_is_capital)) + && (!p.inside_match || (p.inside_select && prev_tok_kind == .arrow && lit0_is_capital)) + && !p.inside_match_case && (!p.inside_if || p.inside_select) + && (!p.inside_for || p.inside_select) { // && (p.tok.lit[0].is_capital() || p.builtin_mod) { return p.struct_init(false) // short_syntax: false } else if p.peek_tok.kind == .dot && (lit0_is_capital && !known_var && language == .v) { // T.name @@ -2044,10 +2033,9 @@ const ( // left hand side of `=` or `:=` in `a,b,c := 1,2,3` fn (mut p Parser) global_decl() ast.GlobalDecl { - if !p.pref.translated && !p.pref.is_livemain && !p.builtin_mod && !p.pref.building_v && - p.mod != 'ui' && p.mod != 'gg2' && p.mod != 'uiold' && !p.pref.enable_globals && !p.pref.is_fmt && - p.mod !in global_enabled_mods - { + if !p.pref.translated && !p.pref.is_livemain && !p.builtin_mod && !p.pref.building_v + && p.mod != 'ui' && p.mod != 'gg2' && p.mod != 'uiold' && !p.pref.enable_globals + && !p.pref.is_fmt&& p.mod !in global_enabled_mods { p.error('use `v --enable-globals ...` to enable globals') return ast.GlobalDecl{} } diff --git a/vlib/v/parser/pratt.v b/vlib/v/parser/pratt.v index ad149ee2a3..ac4a14953e 100644 --- a/vlib/v/parser/pratt.v +++ b/vlib/v/parser/pratt.v @@ -385,9 +385,8 @@ fn (mut p Parser) infix_expr(left ast.Expr) ast.Expr { } right = p.expr(precedence) p.expecting_type = prev_expecting_type - if p.pref.is_vet && op in [.key_in, .not_in] && right is ast.ArrayInit && (right as ast.ArrayInit).exprs.len == - 1 - { + if p.pref.is_vet && op in [.key_in, .not_in] && right is ast.ArrayInit + && (right as ast.ArrayInit).exprs.len == 1 { p.vet_error('Use `var == value` instead of `var in [value]`', pos.line_nr, vet.FixKind.vfmt) } mut or_stmts := []ast.Stmt{} diff --git a/vlib/v/parser/struct.v b/vlib/v/parser/struct.v index fc82eed556..822187216f 100644 --- a/vlib/v/parser/struct.v +++ b/vlib/v/parser/struct.v @@ -65,7 +65,8 @@ fn (mut p Parser) struct_decl() ast.StructDecl { p.error('`$p.tok.lit` lacks body') return ast.StructDecl{} } - if language == .v && !p.builtin_mod && name.len > 0 && !name[0].is_capital() && !p.pref.translated { + if language == .v && !p.builtin_mod && name.len > 0 && !name[0].is_capital() + && !p.pref.translated { p.error_with_pos('struct name `$name` must begin with capital letter', name_pos) return ast.StructDecl{} } @@ -176,9 +177,8 @@ fn (mut p Parser) struct_decl() ast.StructDecl { } } field_start_pos := p.tok.position() - is_embed := ((p.tok.lit.len > 1 && p.tok.lit[0].is_capital()) || - p.peek_tok.kind == .dot) && - language == .v + is_embed := ((p.tok.lit.len > 1 && p.tok.lit[0].is_capital()) + || p.peek_tok.kind == .dot)&& language == .v is_on_top := ast_fields.len == 0 && !(is_field_mut || is_field_mut || is_field_global) mut field_name := '' mut typ := table.Type(0) @@ -385,8 +385,11 @@ fn (mut p Parser) struct_init(short_syntax bool) ast.StructInit { expr = p.expr(0) comments = p.eat_line_end_comments() last_field_pos := expr.position() - field_len := if last_field_pos.len > 0 { last_field_pos.pos - first_field_pos.pos + - last_field_pos.len } else { first_field_pos.len + 1 } + field_len := if last_field_pos.len > 0 { + last_field_pos.pos - first_field_pos.pos + last_field_pos.len + } else { + first_field_pos.len + 1 + } field_pos = token.Position{ line_nr: first_field_pos.line_nr pos: first_field_pos.pos diff --git a/vlib/v/pref/pref.v b/vlib/v/pref/pref.v index bea7d408f9..74d01ff9bf 100644 --- a/vlib/v/pref/pref.v +++ b/vlib/v/pref/pref.v @@ -481,9 +481,8 @@ pub fn parse_args(args []string) (&Preferences, string) { exit(tmp_result) } must_exist(res.path) - if !res.path.ends_with('.v') && os.is_executable(res.path) && os.is_file(res.path) && - os.is_file(res.path + '.v') - { + if !res.path.ends_with('.v') && os.is_executable(res.path) && os.is_file(res.path) + && os.is_file(res.path + '.v') { eprintln('It looks like you wanted to run "${res.path}.v", so we went ahead and did that since "$res.path" is an executable.') res.path += '.v' } @@ -569,7 +568,8 @@ fn parse_define(mut prefs Preferences, define string) { prefs.compile_defines << define_parts[0] } else { - println('V error: Unknown define argument value `${define_parts[1]}` for ${define_parts[0]}.' + + println( + 'V error: Unknown define argument value `${define_parts[1]}` for ${define_parts[0]}.' + ' Expected `0` or `1`.') exit(1) } diff --git a/vlib/v/scanner/scanner.v b/vlib/v/scanner/scanner.v index 0c1e258fe8..8177635db1 100644 --- a/vlib/v/scanner/scanner.v +++ b/vlib/v/scanner/scanner.v @@ -132,8 +132,8 @@ pub fn new_vet_scanner(text string, comments_mode CommentsMode, pref &pref.Prefe [inline] fn (s &Scanner) should_parse_comment() bool { - return (s.comments_mode == .parse_comments) || - (s.comments_mode == .toplevel_comments && !s.is_inside_toplvl_statement) + return (s.comments_mode == .parse_comments) + || (s.comments_mode == .toplevel_comments && !s.is_inside_toplvl_statement) } // NB: this is called by v's parser @@ -473,7 +473,8 @@ fn (mut s Scanner) end_of_file() token.Token { s.eofs++ if s.eofs > 50 { s.line_nr-- - panic('the end of file `$s.file_path` has been reached 50 times already, the v parser is probably stuck.\n' + + panic( + 'the end of file `$s.file_path` has been reached 50 times already, the v parser is probably stuck.\n' + 'This should not happen. Please report the bug here, and include the last 2-3 lines of your source code:\n' + 'https://github.com/vlang/v/issues/new?labels=Bug&template=bug_report.md') } @@ -603,7 +604,8 @@ fn (mut s Scanner) text_scan() token.Token { } // end of `$expr` // allow `'$a.b'` and `'$a.c()'` - if s.is_inter_start && next_char == `\\` && s.look_ahead(2) !in [`x`, `n`, `r`, `\\`, `t`, `e`] { + if s.is_inter_start && next_char == `\\` + && s.look_ahead(2) !in [`x`, `n`, `r`, `\\`, `t`, `e`] { s.warn('unknown escape sequence \\${s.look_ahead(2)}') } if s.is_inter_start && next_char == `(` { @@ -901,14 +903,12 @@ fn (mut s Scanner) text_scan() token.Token { if nextc == `=` { s.pos++ return s.new_token(.ne, '', 2) - } else if s.text.len > s.pos + 3 && - nextc == `i` && s.text[s.pos + 2] == `n` && s.text[s.pos + 3].is_space() - { + } else if s.text.len > s.pos + 3 && nextc == `i` && s.text[s.pos + 2] == `n` + && s.text[s.pos + 3].is_space() { s.pos += 2 return s.new_token(.not_in, '', 3) - } else if s.text.len > s.pos + 3 && - nextc == `i` && s.text[s.pos + 2] == `s` && s.text[s.pos + 3].is_space() - { + } else if s.text.len > s.pos + 3 && nextc == `i` && s.text[s.pos + 2] == `s` + && s.text[s.pos + 3].is_space() { s.pos += 2 return s.new_token(.not_is, '', 3) } else { @@ -1037,9 +1037,8 @@ fn (mut s Scanner) ident_string() string { // } mut n_cr_chars := 0 mut start := s.pos - if s.text[start] == s.quote || - (s.text[start] == s.inter_quote && (s.is_inter_start || s.is_enclosed_inter)) - { + if s.text[start] == s.quote + || (s.text[start] == s.inter_quote && (s.is_inter_start || s.is_enclosed_inter)) { start++ } s.is_inside_string = false @@ -1068,9 +1067,8 @@ fn (mut s Scanner) ident_string() string { } // Don't allow \0 if c == `0` && s.pos > 2 && prevc == slash { - if (s.pos < s.text.len - 1 && s.text[s.pos + 1].is_digit()) || - s.count_symbol_before(s.pos - 1, slash) % 2 == 0 - { + if (s.pos < s.text.len - 1 && s.text[s.pos + 1].is_digit()) + || s.count_symbol_before(s.pos - 1, slash) % 2 == 0 { } else if !is_cstr && !is_raw { s.error(r'cannot use `\0` (NULL character) in the string literal') } @@ -1089,11 +1087,11 @@ fn (mut s Scanner) ident_string() string { s.error(r'`\x` used with no following hex digits') } // Escape `\u` - if c == `u` && (s.text[s.pos + 1] == s.quote || - s.text[s.pos + 2] == s.quote || s.text[s.pos + 3] == s.quote || s.text[s.pos + - 4] == s.quote || !s.text[s.pos + 1].is_hex_digit() || !s.text[s.pos + 2].is_hex_digit() || - !s.text[s.pos + 3].is_hex_digit() || !s.text[s.pos + 4].is_hex_digit()) - { + if c == `u` + && (s.text[s.pos + 1] == s.quote || s.text[s.pos + 2] == s.quote || s.text[s.pos + 3] == s.quote || s.text[s.pos + 4] == s.quote || !s.text[s.pos + 1].is_hex_digit() + || !s.text[s.pos + 2].is_hex_digit() + || !s.text[s.pos + 3].is_hex_digit() + || !s.text[s.pos + 4].is_hex_digit()) { s.error(r'`\u` incomplete unicode character value') } } @@ -1106,9 +1104,8 @@ fn (mut s Scanner) ident_string() string { break } // $var - if prevc == `$` && util.is_name_char(c) && !is_raw && s.count_symbol_before(s.pos - 2, slash) % - 2 == 0 - { + if prevc == `$` && util.is_name_char(c) && !is_raw + && s.count_symbol_before(s.pos - 2, slash) % 2 == 0 { s.is_inside_string = true s.is_inter_start = true s.pos -= 2 @@ -1175,7 +1172,8 @@ fn (mut s Scanner) ident_char() string { if len != 1 { u := c.ustring() if u.len != 1 { - s.error('invalid character literal (more than one character)\n' + 'use quotes for strings, backticks for characters') + s.error('invalid character literal (more than one character)\n' + + 'use quotes for strings, backticks for characters') } } // Escapes a `'` character diff --git a/vlib/v/table/table.v b/vlib/v/table/table.v index e35eef2055..9022c71348 100644 --- a/vlib/v/table/table.v +++ b/vlib/v/table/table.v @@ -41,9 +41,10 @@ pub mut: } fn (f &Fn) method_equals(o &Fn) bool { - return f.params[1..].equals(o.params[1..]) && f.return_type == o.return_type && f.is_variadic == - o.is_variadic && f.language == o.language && f.generic_names == o.generic_names && - f.is_pub == o.is_pub && f.mod == o.mod && f.name == o.name + return f.params[1..].equals(o.params[1..]) && f.return_type == o.return_type + && f.is_variadic == o.is_variadic && f.language == o.language + && f.generic_names == o.generic_names && f.is_pub == o.is_pub && f.mod == o.mod + && f.name == o.name } pub struct Param { diff --git a/vlib/v/token/token.v b/vlib/v/token/token.v index bd84e95e89..d2bdf9ef95 100644 --- a/vlib/v/token/token.v +++ b/vlib/v/token/token.v @@ -409,14 +409,13 @@ pub fn (tok Token) is_scalar() bool { // is_unary returns true if the token can be in a unary expression pub fn (tok Token) is_unary() bool { - return tok.kind in - [ - /* `+` | `-` | `!` | `~` | `*` | `&` */.plus, .minus, .not, .bit_not, .mul, .amp, .arrow] + // `+` | `-` | `!` | `~` | `*` | `&` | `<-` + return tok.kind in [ .plus, .minus, .not, .bit_not, .mul, .amp, .arrow] } pub fn (tok Kind) is_relational() bool { - return tok in [ - /* `<` | `<=` | `>` | `>=` */.lt, .le, .gt, .ge, .eq, .ne] + // `<` | `<=` | `>` | `>=` | `==` | `!=` + return tok in [.lt, .le, .gt, .ge, .eq, .ne] } pub fn (k Kind) is_start_of_type() bool { @@ -429,7 +428,7 @@ pub fn (kind Kind) is_prefix() bool { pub fn (kind Kind) is_infix() bool { return kind in - [.plus, .minus, .mod, .mul, .div, .eq, .ne, .gt, .lt, .key_in, /* */.key_as, .ge, .le, .logical_or, .xor, .not_in, .key_is, .not_is, /* */.and, .dot, .pipe, .amp, .left_shift, .right_shift, .arrow] + [.plus, .minus, .mod, .mul, .div, .eq, .ne, .gt, .lt, .key_in, .key_as, .ge, .le, .logical_or, .xor, .not_in, .key_is, .not_is, .and, .dot, .pipe, .amp, .left_shift, .right_shift, .arrow] } // Pass table.builtin_type_names diff --git a/vlib/v/util/diff.v b/vlib/v/util/diff.v index 39d6d02c0a..55603cba56 100644 --- a/vlib/v/util/diff.v +++ b/vlib/v/util/diff.v @@ -12,8 +12,7 @@ pub fn find_working_diff_command() ?string { if env_difftool.len > 0 { known_diff_tools << env_difftool } - known_diff_tools << - ['colordiff', 'gdiff', 'diff', 'colordiff.exe', 'diff.exe', 'opendiff', 'code', 'code.cmd'] + known_diff_tools << ['colordiff', 'gdiff', 'diff', 'colordiff.exe', 'diff.exe', 'opendiff', 'code', 'code.cmd'] // NOTE: code.cmd is the Windows variant of the `code` cli tool for diffcmd in known_diff_tools { if diffcmd == 'opendiff' { // opendiff has no `--version` option diff --git a/vlib/v/util/errors.v b/vlib/v/util/errors.v index acd1f9a26e..a77dae6a9b 100644 --- a/vlib/v/util/errors.v +++ b/vlib/v/util/errors.v @@ -119,8 +119,12 @@ pub fn source_context(kind string, source string, column int, pos token.Position sline := source_lines[iline] start_column := imax(0, imin(column, sline.len)) end_column := imax(0, imin(column + imax(0, pos.len), sline.len)) - cline := if iline == pos.line_nr { sline[..start_column] + color(kind, sline[start_column..end_column]) + - sline[end_column..] } else { sline } + cline := if iline == pos.line_nr { + sline[..start_column] + color(kind, sline[start_column..end_column]) + + sline[end_column..] + } else { + sline + } clines << '${iline + 1:5d} | ' + cline.replace('\t', tab_spaces) // if iline == pos.line_nr { diff --git a/vlib/v/util/module.v b/vlib/v/util/module.v index 308803be3d..3f50bfe079 100644 --- a/vlib/v/util/module.v +++ b/vlib/v/util/module.v @@ -90,9 +90,8 @@ pub fn mod_path_to_full_name(mod string, path string) ?string { if ls := os.ls(parent) { // currently CI clones some modules into the v repo to test, the condition // after `'v.mod' in ls` can be removed once a proper solution is added - if 'v.mod' in ls && - (try_path_parts.len > i && try_path_parts[i] != 'v' && 'vlib' !in ls) - { + if 'v.mod' in ls + && (try_path_parts.len > i && try_path_parts[i] != 'v' && 'vlib' !in ls) { last_v_mod = j } continue diff --git a/vlib/v/util/util.v b/vlib/v/util/util.v index f56e54ed25..723b1b9034 100644 --- a/vlib/v/util/util.v +++ b/vlib/v/util/util.v @@ -157,8 +157,8 @@ pub fn launch_tool(is_verbose bool, tool_name string, args []string) { } disabling_file := recompilation.disabling_file(vroot) is_recompilation_disabled := os.exists(disabling_file) - should_compile := !is_recompilation_disabled && - should_recompile_tool(vexe, tool_source, tool_name, tool_exe) + should_compile := !is_recompilation_disabled + && should_recompile_tool(vexe, tool_source, tool_name, tool_exe) if is_verbose { println('launch_tool should_compile: $should_compile') } diff --git a/vlib/vweb/vweb.v b/vlib/vweb/vweb.v index e166e1ae53..2467562266 100644 --- a/vlib/vweb/vweb.v +++ b/vlib/vweb/vweb.v @@ -491,11 +491,9 @@ fn handle_conn(mut conn net.TcpConn, mut app T) { // since such methods have a priority. // For example URL `/register` matches route `/:user`, but `fn register()` // should be called first. - if (req_method_str == '' && - url_words[0] == method.name && url_words.len == 1) || - (req_method_str == req.method.str() && url_words[0] == method.name && url_words.len == - 1) - { + if (req_method_str == '' && url_words[0] == method.name && url_words.len == 1) + || (req_method_str == req.method.str() && url_words[0] == method.name + && url_words.len == 1) { $if debug { println('easy match method=$method.name') } @@ -521,9 +519,8 @@ fn handle_conn(mut conn net.TcpConn, mut app T) { if route_words.len == 1 && route_words[0] in methods_without_first { req_method << route_words[0] } - if url_words.len == route_words.len || - (url_words.len >= route_words.len - 1 && route_words.len > 0 && route_words.last().ends_with('...')) - { + if url_words.len == route_words.len + || (url_words.len >= route_words.len - 1 && route_words.len > 0 && route_words.last().ends_with('...')) { if req_method.len > 0 { if req_method_str.to_lower()[1..] !in req_method { continue diff --git a/vlib/x/websocket/handshake.v b/vlib/x/websocket/handshake.v index 13c9b3a591..f351ab17a5 100644 --- a/vlib/x/websocket/handshake.v +++ b/vlib/x/websocket/handshake.v @@ -118,9 +118,9 @@ fn (mut ws Client) read_handshake_str() ?string { } msg[total_bytes_read] = buffer[0] total_bytes_read++ - if total_bytes_read > 5 && msg[total_bytes_read - 1] == `\n` && msg[total_bytes_read - - 2] == `\r` && msg[total_bytes_read - 3] == `\n` && msg[total_bytes_read - 4] == `\r` - { + if total_bytes_read > 5 && msg[total_bytes_read - 1] == `\n` + && msg[total_bytes_read - 2] == `\r` && msg[total_bytes_read - 3] == `\n` + && msg[total_bytes_read - 4] == `\r` { break } } diff --git a/vlib/x/websocket/message.v b/vlib/x/websocket/message.v index 8dcb5fa0d4..9209ec1610 100644 --- a/vlib/x/websocket/message.v +++ b/vlib/x/websocket/message.v @@ -42,9 +42,8 @@ pub fn (mut ws Client) validate_frame(frame &Frame) ? { ws.close(1002, 'rsv cannot be other than 0, not negotiated') return error('rsv cannot be other than 0, not negotiated') } - if (int(frame.opcode) >= 3 && int(frame.opcode) <= 7) || - (int(frame.opcode) >= 11 && int(frame.opcode) <= 15) - { + if (int(frame.opcode) >= 3 && int(frame.opcode) <= 7) + || (int(frame.opcode) >= 11 && int(frame.opcode) <= 15) { ws.close(1002, 'use of reserved opcode') ? return error('use of reserved opcode') } diff --git a/vlib/x/websocket/websocket_client.v b/vlib/x/websocket/websocket_client.v index 23d4d1ebd0..c721ad80a3 100644 --- a/vlib/x/websocket/websocket_client.v +++ b/vlib/x/websocket/websocket_client.v @@ -232,7 +232,11 @@ pub fn (mut ws Client) write_ptr(bytes byteptr, payload_len int, code OPCode) ? // todo: send error here later return error('trying to write on a closed socket!') } - mut header_len := 2 + if payload_len > 125 { 2 } else { 0 } + if payload_len > 0xffff { 6 } else { 0 } + mut header_len := 2 + if payload_len > 125 { 2 } else { 0 } + if payload_len > 0xffff { + 6 + } else { + 0 + } if !ws.is_server { header_len += 4 }