From 8788512c4d432870059043103ee6189dfbfbce0d Mon Sep 17 00:00:00 2001 From: Delyan Angelov Date: Tue, 12 Apr 2022 13:38:40 +0300 Subject: [PATCH] checker: make using err.msg and err.code produce an *actual* notice, even with the present compatibility hack (will be *removed* in 2022-06-01) --- cmd/tools/vbin2v.v | 6 ++-- cmd/tools/vbuild-tools.v | 5 +-- cmd/tools/vdoc/vdoc.v | 6 ++-- cmd/tools/vfmt.v | 2 +- cmd/tools/vgret.v | 2 +- cmd/tools/vpm.v | 4 +-- cmd/tools/vself.v | 8 ++--- cmd/tools/vsymlink.v | 4 +-- cmd/tools/vtest-parser.v | 2 +- cmd/tools/vup.v | 4 +-- doc/docs.md | 6 ++-- examples/v_script.vsh | 4 +-- vlib/crypto/ed25519/ed25519.v | 2 +- vlib/crypto/ed25519/examples/example.v | 6 ++-- vlib/crypto/ed25519/internal/ed25519_test.v | 16 ++++----- .../internal/edwards25519/element_test.v | 4 +-- .../internal/edwards25519/extra_test.v | 24 +++++++------- .../ed25519/internal/edwards25519/point.v | 8 ++--- .../internal/edwards25519/scalar_test.v | 26 +++++++-------- .../internal/edwards25519/scalarmult_test.v | 12 +++---- vlib/net/common.v | 2 +- vlib/net/websocket/io.v | 6 ++-- vlib/os/signal_test.v | 2 +- vlib/v/checker/checker.v | 33 +++++++++++-------- vlib/v/tests/option_print_errors_test.v | 2 +- vlib/v/tests/option_test.v | 4 +-- .../or_expr_with_nested_match_expr_test.v | 4 +-- vlib/vweb/vweb.v | 3 +- 28 files changed, 107 insertions(+), 100 deletions(-) diff --git a/cmd/tools/vbin2v.v b/cmd/tools/vbin2v.v index c1ab6e09da..ed1b776db2 100644 --- a/cmd/tools/vbin2v.v +++ b/cmd/tools/vbin2v.v @@ -77,7 +77,7 @@ fn (context Context) bname_and_bytes(file string) ?(string, []byte) { fname := os.file_name(file) fname_escaped := fname.replace_each(['.', '_', '-', '_']) byte_name := '$context.prefix$fname_escaped'.to_lower() - fbytes := os.read_bytes(file) or { return error('Error: $err.msg') } + fbytes := os.read_bytes(file) or { return error('Error: $err.msg()') } return byte_name, fbytes } @@ -108,7 +108,7 @@ fn main() { exit(0) } files := fp.finalize() or { - eprintln('Error: $err.msg') + eprintln('Error: $err.msg()') exit(1) } real_files := files.filter(it != 'bin2v') @@ -123,7 +123,7 @@ fn main() { mut file_byte_map := map[string][]byte{} for file in real_files { bname, fbytes := context.bname_and_bytes(file) or { - eprintln(err.msg) + eprintln(err.msg()) exit(1) } file_byte_map[bname] = fbytes diff --git a/cmd/tools/vbuild-tools.v b/cmd/tools/vbuild-tools.v index b13f1a1ad2..6138612b9d 100644 --- a/cmd/tools/vbuild-tools.v +++ b/cmd/tools/vbuild-tools.v @@ -66,8 +66,9 @@ fn main() { } target_path := os.join_path(tfolder, texe) os.mv_by_cp(tpath, target_path) or { - if !err.msg.contains('vbuild-tools') && !err.msg.contains('vtest-all') { - eprintln('error while moving $tpath to $target_path: $err.msg') + emsg := err.msg() + if !emsg.contains('vbuild-tools') && !emsg.contains('vtest-all') { + eprintln('error while moving $tpath to $target_path: $emsg') } continue } diff --git a/cmd/tools/vdoc/vdoc.v b/cmd/tools/vdoc/vdoc.v index bdc02589bc..db1e4d39b4 100644 --- a/cmd/tools/vdoc/vdoc.v +++ b/cmd/tools/vdoc/vdoc.v @@ -244,8 +244,8 @@ fn (vd VDoc) get_readme(path string) string { fn (vd VDoc) emit_generate_err(err IError) { cfg := vd.cfg - mut err_msg := err.msg - if err.code == 1 { + mut err_msg := err.msg() + if err.code() == 1 { mod_list := get_modules_list(cfg.input_path, []string{}) println('Available modules:\n==================') for mod in mod_list { @@ -467,7 +467,7 @@ fn parse_arguments(args []string) Config { exit(1) } selected_platform := doc.platform_from_string(platform_str) or { - eprintln(err.msg) + eprintln(err.msg()) exit(1) } cfg.platform = selected_platform diff --git a/cmd/tools/vfmt.v b/cmd/tools/vfmt.v index fbf22de893..932651fbf6 100644 --- a/cmd/tools/vfmt.v +++ b/cmd/tools/vfmt.v @@ -82,7 +82,7 @@ fn main() { eprintln('vfmt possible_files: ' + possible_files.str()) } files := util.find_all_v_files(possible_files) or { - verror(err.msg) + verror(err.msg()) return } if os.is_atty(0) == 0 && files.len == 0 { diff --git a/cmd/tools/vgret.v b/cmd/tools/vgret.v index b9f575ec62..fbeceeb220 100644 --- a/cmd/tools/vgret.v +++ b/cmd/tools/vgret.v @@ -211,7 +211,7 @@ fn generate_screenshots(mut opt Options, output_path string) ? { app_config.screenshots_path = screenshot_path app_config.screenshots = take_screenshots(opt, app_config) or { - return error('Failed taking screenshots of `$app_path`:\n$err.msg') + return error('Failed taking screenshots of `$app_path`:\n$err.msg()') } } } diff --git a/cmd/tools/vpm.v b/cmd/tools/vpm.v index 260a24e283..b116ad91ed 100644 --- a/cmd/tools/vpm.v +++ b/cmd/tools/vpm.v @@ -485,7 +485,7 @@ fn vpm_remove(module_names []string) { println('Removing module "$name" ...') verbose_println('removing folder $final_module_path') os.rmdir_all(final_module_path) or { - verbose_println('error while removing "$final_module_path": $err.msg') + verbose_println('error while removing "$final_module_path": $err.msg()') } // delete author directory if it is empty author := name.split('.')[0] @@ -496,7 +496,7 @@ fn vpm_remove(module_names []string) { if os.is_dir_empty(author_dir) { verbose_println('removing author folder $author_dir') os.rmdir(author_dir) or { - verbose_println('error while removing "$author_dir": $err.msg') + verbose_println('error while removing "$author_dir": $err.msg()') } } } diff --git a/cmd/tools/vself.v b/cmd/tools/vself.v index 6f6f8f0991..7774fc6ff4 100644 --- a/cmd/tools/vself.v +++ b/cmd/tools/vself.v @@ -30,7 +30,7 @@ fn main() { // The user just wants an independent copy of v, and so we are done. return } - backup_old_version_and_rename_newer(short_v_name) or { panic(err.msg) } + backup_old_version_and_rename_newer(short_v_name) or { panic(err.msg()) } println('V built successfully as executable "$vexe_name".') } @@ -71,17 +71,17 @@ fn backup_old_version_and_rename_newer(short_v_name string) ?bool { list_folder(short_v_name, 'before:', 'removing $bak_file ...') if os.exists(bak_file) { - os.rm(bak_file) or { errors << 'failed removing $bak_file: $err.msg' } + os.rm(bak_file) or { errors << 'failed removing $bak_file: $err.msg()' } } list_folder(short_v_name, '', 'moving $v_file to $bak_file ...') - os.mv(v_file, bak_file) or { errors << err.msg } + os.mv(v_file, bak_file) or { errors << err.msg() } list_folder(short_v_name, '', 'removing $v_file ...') os.rm(v_file) or {} list_folder(short_v_name, '', 'moving $v2_file to $v_file ...') - os.mv_by_cp(v2_file, v_file) or { panic(err.msg) } + os.mv_by_cp(v2_file, v_file) or { panic(err.msg()) } list_folder(short_v_name, 'after:', '') diff --git a/cmd/tools/vsymlink.v b/cmd/tools/vsymlink.v index a45c120070..dba5b26959 100644 --- a/cmd/tools/vsymlink.v +++ b/cmd/tools/vsymlink.v @@ -106,7 +106,7 @@ fn setup_symlink_windows(vexe string) { println('Symlink $vsymlink to $vexe created.') println('Checking system %PATH%...') reg_sys_env_handle := get_reg_sys_env_handle() or { - warn_and_exit(err.msg) + warn_and_exit(err.msg()) return } // TODO: Fix defers inside ifs @@ -133,7 +133,7 @@ fn setup_symlink_windows(vexe string) { println('Adding symlink directory to system %PATH%...') set_reg_value(reg_sys_env_handle, 'Path', new_sys_env_path) or { C.RegCloseKey(reg_sys_env_handle) - warn_and_exit(err.msg) + warn_and_exit(err.msg()) } println('Done.') } diff --git a/cmd/tools/vtest-parser.v b/cmd/tools/vtest-parser.v index e3650f653c..0e41a98013 100644 --- a/cmd/tools/vtest-parser.v +++ b/cmd/tools/vtest-parser.v @@ -121,7 +121,7 @@ fn process_cli_args() &Context { exit(0) } context.all_paths = fp.finalize() or { - context.error(err.msg) + context.error(err.msg()) exit(1) } if !context.is_worker && context.all_paths.len == 0 { diff --git a/cmd/tools/vup.v b/cmd/tools/vup.v index ba1ad1b8cf..89bda387f9 100644 --- a/cmd/tools/vup.v +++ b/cmd/tools/vup.v @@ -124,9 +124,9 @@ fn (app App) show_current_v_version() { fn (app App) backup(file string) { backup_file := '${file}_old.exe' if os.exists(backup_file) { - os.rm(backup_file) or { eprintln('failed removing $backup_file: $err.msg') } + os.rm(backup_file) or { eprintln('failed removing $backup_file: $err.msg()') } } - os.mv(file, backup_file) or { eprintln('failed moving $file: $err.msg') } + os.mv(file, backup_file) or { eprintln('failed moving $file: $err.msg()') } } fn (app App) git_command(command string) { diff --git a/doc/docs.md b/doc/docs.md index c07bd51d1b..89cea74cbe 100644 --- a/doc/docs.md +++ b/doc/docs.md @@ -1863,7 +1863,7 @@ import os fn read_log() { mut ok := false - mut f := os.open('log.txt') or { panic(err.msg) } + mut f := os.open('log.txt') or { panic(err) } defer { f.close() } @@ -3452,7 +3452,7 @@ to break from the current block. Note that `break` and `continue` can only be used inside a `for` loop. V does not have a way to forcibly "unwrap" an optional (as other languages do, -for instance Rust's `unwrap()` or Swift's `!`). To do this, use `or { panic(err.msg) }` instead. +for instance Rust's `unwrap()` or Swift's `!`). To do this, use `or { panic(err) }` instead. --- The third method is to provide a default value at the end of the `or` block. @@ -5536,7 +5536,7 @@ eprintln('file: ' + @FILE + ' | line: ' + @LINE + ' | fn: ' + @MOD + '.' + @FN) Another example, is if you want to embed the version/name from v.mod *inside* your executable: ```v ignore import v.vmod -vm := vmod.decode( @VMOD_FILE ) or { panic(err.msg) } +vm := vmod.decode( @VMOD_FILE ) or { panic(err) } eprintln('$vm.name $vm.version\n $vm.description') ``` diff --git a/examples/v_script.vsh b/examples/v_script.vsh index fb76d9fa34..89f033b779 100755 --- a/examples/v_script.vsh +++ b/examples/v_script.vsh @@ -13,14 +13,14 @@ mkdir('v_script_dir') ? println("\nEntering into v_script_dir and listing it's files.") chdir('v_script_dir') ? -files := ls('.') or { panic(err.msg) } +files := ls('.') or { panic(err) } println(files) println('\nCreating foo.txt') create('foo.txt') ? println('\nFiles:') -again_ls := ls('.') or { panic(err.msg) } +again_ls := ls('.') or { panic(err) } println(again_ls) println('\nRemoving foo.txt and v_script_dir') diff --git a/vlib/crypto/ed25519/ed25519.v b/vlib/crypto/ed25519/ed25519.v index 9a3c7d415c..b9643c46c8 100644 --- a/vlib/crypto/ed25519/ed25519.v +++ b/vlib/crypto/ed25519/ed25519.v @@ -170,7 +170,7 @@ fn new_key_from_seed_generic(mut privatekey []byte, seed []byte) { mut h := sha512.sum512(seed) mut s := edwards25519.new_scalar() - s.set_bytes_with_clamping(h[..32]) or { panic(err.msg) } + s.set_bytes_with_clamping(h[..32]) or { panic(err) } mut aa := edwards25519.Point{} aa.scalar_base_mult(mut s) diff --git a/vlib/crypto/ed25519/examples/example.v b/vlib/crypto/ed25519/examples/example.v index 32a358ee12..02919accaf 100644 --- a/vlib/crypto/ed25519/examples/example.v +++ b/vlib/crypto/ed25519/examples/example.v @@ -8,11 +8,11 @@ import crypto.ed25519 fn main() { msg := 'Hello Girl' - publ, priv := ed25519.generate_key() or { panic(err.msg) } + publ, priv := ed25519.generate_key() ? m := msg.bytes() - sig := ed25519.sign(priv, m) or { panic(err.msg) } + sig := ed25519.sign(priv, m) ? println('=== Message ===') println('Msg: $msg \nHash: $m') @@ -31,7 +31,7 @@ fn main() { println('signature: R=${sig[0..32].hex()} s=${sig[32..64].hex()}') println(' signature (Base64)=${base64.encode(sig)}') - rtn := ed25519.verify(publ, m, sig) or { panic(err.msg) } + rtn := ed25519.verify(publ, m, sig) ? if rtn { println('Signature verified :$rtn') diff --git a/vlib/crypto/ed25519/internal/ed25519_test.v b/vlib/crypto/ed25519/internal/ed25519_test.v index 412bb0a776..af154656b0 100644 --- a/vlib/crypto/ed25519/internal/ed25519_test.v +++ b/vlib/crypto/ed25519/internal/ed25519_test.v @@ -85,10 +85,10 @@ fn works_check_on_sign_input_string(item string) bool { return false } // assert parts.len == 5 - privbytes := hex.decode(parts[0]) or { panic(err.msg) } - pubkey := hex.decode(parts[1]) or { panic(err.msg) } - msg := hex.decode(parts[2]) or { panic(err.msg) } - mut sig := hex.decode(parts[3]) or { panic(err.msg) } + privbytes := hex.decode(parts[0]) or { panic(err) } + pubkey := hex.decode(parts[1]) or { panic(err) } + msg := hex.decode(parts[2]) or { panic(err) } + mut sig := hex.decode(parts[3]) or { panic(err) } if pubkey.len != ed25519.public_key_size { return false @@ -100,12 +100,12 @@ fn works_check_on_sign_input_string(item string) bool { copy(mut priv[..], privbytes) copy(mut priv[32..], pubkey) - sig2 := ed25519.sign(priv[..], msg) or { panic(err.msg) } + sig2 := ed25519.sign(priv[..], msg) or { panic(err) } if sig != sig2[..] { return false } - res := ed25519.verify(pubkey, msg, sig2) or { panic(err.msg) } + res := ed25519.verify(pubkey, msg, sig2) or { panic(err) } // assert res == true if !res { return false @@ -150,7 +150,7 @@ mut: // so, maybe need a long time to finish. // be quiet and patient fn test_input_from_djb_ed25519_crypto_sign_input_with_syncpool() ? { - // contents := os.read_lines('testdata/sign.input') or { panic(err.msg) } //[]string + // contents := os.read_lines('testdata/sign.input') or { panic(err) } //[]string mut pool_s := pool.new_pool_processor( callback: worker_for_string_content maxjobs: 4 @@ -165,7 +165,7 @@ fn test_input_from_djb_ed25519_crypto_sign_input_with_syncpool() ? { // same as above, but without sync.pool /* fn test_input_from_djb_ed25519_crypto_sign_input_without_syncpool() ? { - // contents := os.read_lines('testdata/sign.input') or { panic(err.msg) } //[]string + // contents := os.read_lines('testdata/sign.input') or { panic(err) } //[]string for i, item in ed25519.contents { parts := item.split(':') // []string // println(parts) diff --git a/vlib/crypto/ed25519/internal/edwards25519/element_test.v b/vlib/crypto/ed25519/internal/edwards25519/element_test.v index a0dbf43b68..3036a4fa88 100644 --- a/vlib/crypto/ed25519/internal/edwards25519/element_test.v +++ b/vlib/crypto/ed25519/internal/edwards25519/element_test.v @@ -387,11 +387,11 @@ fn test_bytes_big_equivalence() ? { mut fe := el.generate_element() mut fe1 := el.generate_element() - fe.set_bytes(inp) or { panic(err.msg) } + fe.set_bytes(inp) or { panic(err) } inp[inp.len - 1] &= (1 << 7) - 1 // mask the most significant bit mut b := big.integer_from_bytes(swap_endianness(mut inp)) // need swap_endianness - fe1.from_big_integer(b) or { panic(err.msg) } // do swap_endianness internally + fe1.from_big_integer(b) or { panic(err) } // do swap_endianness internally assert fe == fe1 diff --git a/vlib/crypto/ed25519/internal/edwards25519/extra_test.v b/vlib/crypto/ed25519/internal/edwards25519/extra_test.v index 957f01f63b..f6548f3c10 100644 --- a/vlib/crypto/ed25519/internal/edwards25519/extra_test.v +++ b/vlib/crypto/ed25519/internal/edwards25519/extra_test.v @@ -67,20 +67,20 @@ fn test_bytes_montgomery_infinity() { const ( loworder_string = '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85' - loworder_bytes = hex.decode(loworder_string) or { panic(err.msg) } + loworder_bytes = hex.decode(loworder_string) or { panic(err) } ) fn fn_cofactor(mut data []byte) bool { if data.len != 64 { - panic('err.msg') + panic('data.len should be 64') } mut loworder := Point{} - loworder.set_bytes(edwards25519.loworder_bytes) or { panic(err.msg) } + loworder.set_bytes(edwards25519.loworder_bytes) or { panic(err) } mut s := new_scalar() mut p := Point{} mut p8 := Point{} - s.set_uniform_bytes(data) or { panic(err.msg) } + s.set_uniform_bytes(data) or { panic(err) } p.scalar_base_mult(mut s) p8.mult_by_cofactor(p) @@ -128,8 +128,8 @@ fn invert_works(mut xinv Scalar, x NotZeroScalar) bool { } fn test_scalar_invert() { - nsc := generate_notzero_scalar(5) or { panic(err.msg) } - mut xsc := generate_scalar(5) or { panic(err.msg) } + nsc := generate_notzero_scalar(5) or { panic(err) } + mut xsc := generate_scalar(5) or { panic(err) } assert invert_works(mut xsc, nsc) == true mut zero := new_scalar() @@ -140,9 +140,9 @@ fn test_scalar_invert() { fn test_multiscalarmultmatchesbasemult() { for i in 0 .. 6 { - x := generate_scalar(100) or { panic(err.msg) } - y := generate_scalar(5) or { panic(err.msg) } - z := generate_scalar(2) or { panic(err.msg) } + x := generate_scalar(100) or { panic(err) } + y := generate_scalar(5) or { panic(err) } + z := generate_scalar(2) or { panic(err) } assert multiscalarmultmatchesbasemult(x, y, z) == true } } @@ -196,9 +196,9 @@ fn vartime_multiscala_rmultmatches_basemult(xx Scalar, yy Scalar, zz Scalar) boo fn test_vartimemultiscalarmultmatchesbasemult() { for i in 0 .. 5 { - x := generate_scalar(100) or { panic(err.msg) } - y := generate_scalar(5) or { panic(err.msg) } - z := generate_scalar(2) or { panic(err.msg) } + x := generate_scalar(100) or { panic(err) } + y := generate_scalar(5) or { panic(err) } + z := generate_scalar(2) or { panic(err) } assert vartime_multiscala_rmultmatches_basemult(x, y, z) == true } } diff --git a/vlib/crypto/ed25519/internal/edwards25519/point.v b/vlib/crypto/ed25519/internal/edwards25519/point.v index 4bf085d87e..ba815668e2 100644 --- a/vlib/crypto/ed25519/internal/edwards25519/point.v +++ b/vlib/crypto/ed25519/internal/edwards25519/point.v @@ -10,12 +10,12 @@ const ( gen_bytes = [byte(0x58), 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66] - d_const = d_const_generate() or { panic(err.msg) } - d2_const = d2_const_generate() or { panic(err.msg) } + d_const = d_const_generate() or { panic(err) } + d2_const = d2_const_generate() or { panic(err) } // id_point is the point at infinity. - id_point = id_point_generate() or { panic(err.msg) } + id_point = id_point_generate() or { panic(err) } // generator point - gen_point = generator() or { panic(err.msg) } + gen_point = generator() or { panic(err) } ) fn d_const_generate() ?Element { diff --git a/vlib/crypto/ed25519/internal/edwards25519/scalar_test.v b/vlib/crypto/ed25519/internal/edwards25519/scalar_test.v index 12d1c6fcf6..9a5ab90eed 100644 --- a/vlib/crypto/ed25519/internal/edwards25519/scalar_test.v +++ b/vlib/crypto/ed25519/internal/edwards25519/scalar_test.v @@ -58,8 +58,8 @@ fn addlike_subneg(x Scalar, y Scalar) bool { fn test_scalar_add_like_subneg() { for i in 0 .. 15 { - x := generate_scalar(1000) or { panic(err.msg) } - y := generate_scalar(1000) or { panic(err.msg) } + x := generate_scalar(1000) or { panic(err) } + y := generate_scalar(1000) or { panic(err) } assert addlike_subneg(x, y) == true } } @@ -70,7 +70,7 @@ fn fg(sc Scalar) bool { fn test_scalar_generate() ? { for i in 0 .. 15 { - sc := generate_scalar(1000) or { panic(err.msg) } + sc := generate_scalar(1000) or { panic(err) } assert fg(sc) == true } @@ -79,10 +79,10 @@ fn test_scalar_generate() ? { // fn test_scalar_set_canonical_bytes() ? { for i in 0 .. 10 { - mut buf := rand.bytes(32) or { panic(err.msg) } - mut sc := generate_scalar(1000) or { panic(err.msg) } + mut buf := rand.bytes(32) or { panic(err) } + mut sc := generate_scalar(1000) or { panic(err) } buf[buf.len - 1] &= (1 << 4) - 1 - sc = sc.set_canonical_bytes(buf) or { panic(err.msg) } + sc = sc.set_canonical_bytes(buf) or { panic(err) } assert buf[..] == sc.bytes() assert is_reduced(sc) @@ -93,7 +93,7 @@ fn test_scalar_set_canonical_bytes_round_trip() ? { for i in 0 .. 10 { mut sc1 := generate_scalar(2) ? mut sc2 := generate_scalar(6) ? - sc2.set_canonical_bytes(sc1.bytes()) or { panic(err.msg) } + sc2.set_canonical_bytes(sc1.bytes()) or { panic(err) } assert sc1 == sc2 } @@ -152,10 +152,10 @@ fn test_scalar_set_bytes_with_clamping() { t.Errorf("random: got %q, want %q", got, want) }*/ random := '633d368491364dc9cd4c1bf891b1d59460face1644813240a313e61f2c88216e' - random_bytes := hex.decode(random) or { panic(err.msg) } + random_bytes := hex.decode(random) or { panic(err) } mut s0 := Scalar{} - s0.set_bytes_with_clamping(random_bytes) or { panic(err.msg) } + s0.set_bytes_with_clamping(random_bytes) or { panic(err) } mut p0 := Point{} p0.scalar_base_mult(mut s0) @@ -167,8 +167,8 @@ fn test_scalar_set_bytes_with_clamping() { zero := '0000000000000000000000000000000000000000000000000000000000000000' mut s1 := Scalar{} - zero_bytes := hex.decode(zero) or { panic(err.msg) } - s1.set_bytes_with_clamping(zero_bytes) or { panic(err.msg) } + zero_bytes := hex.decode(zero) or { panic(err) } + s1.set_bytes_with_clamping(zero_bytes) or { panic(err) } mut p1 := Point{} p1.scalar_base_mult(mut s1) @@ -178,8 +178,8 @@ fn test_scalar_set_bytes_with_clamping() { one := 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff' mut s2 := Scalar{} - mut one_bytes := hex.decode(one) or { panic(err.msg) } - s2.set_bytes_with_clamping(one_bytes) or { panic(err.msg) } + mut one_bytes := hex.decode(one) or { panic(err) } + s2.set_bytes_with_clamping(one_bytes) or { panic(err) } mut p2 := Point{} p2.scalar_base_mult(mut s2) diff --git a/vlib/crypto/ed25519/internal/edwards25519/scalarmult_test.v b/vlib/crypto/ed25519/internal/edwards25519/scalarmult_test.v index a68bfe58b7..e976141dd7 100644 --- a/vlib/crypto/ed25519/internal/edwards25519/scalarmult_test.v +++ b/vlib/crypto/ed25519/internal/edwards25519/scalarmult_test.v @@ -10,7 +10,7 @@ const ( fn dalek_scalar_basepoint() Point { mut p := Point{} - p.set_bytes(edwards25519.dsc_basepoint) or { panic(err.msg) } + p.set_bytes(edwards25519.dsc_basepoint) or { panic(err) } return p } @@ -70,8 +70,8 @@ fn test_vartime_double_basemult_vs_dalek() { } fn test_scalar_mult_distributes_over_add() { - mut x := generate_scalar(100) or { panic(err.msg) } - mut y := generate_scalar(100) or { panic(err.msg) } + mut x := generate_scalar(100) or { panic(err) } + mut y := generate_scalar(100) or { panic(err) } mut z := Scalar{} z.add(x, y) @@ -142,7 +142,7 @@ fn test_basepoint_table_generation() { } fn test_scalar_mult_matches_base_mult() { - mut x := generate_scalar(100) or { panic(err.msg) } + mut x := generate_scalar(100) or { panic(err) } b := new_generator_point() mut p := Point{} mut q := Point{} @@ -165,8 +165,8 @@ fn test_basepoint_naf_table_generation() { } fn test_vartime_double_scalar_base_mult() { - mut x := generate_scalar(100) or { panic(err.msg) } - mut y := generate_scalar(100) or { panic(err.msg) } + mut x := generate_scalar(100) or { panic(err) } + mut y := generate_scalar(100) or { panic(err) } b := new_generator_point() mut p := Point{} diff --git a/vlib/net/common.v b/vlib/net/common.v index aab8f166b4..99dd1bcff9 100644 --- a/vlib/net/common.v +++ b/vlib/net/common.v @@ -74,7 +74,7 @@ fn select_with_retry(handle int, test Select, timeout time.Duration) ?bool { mut retries := 10 for retries > 0 { ready := @select(handle, test, timeout) or { - if err.code == 4 { + if err.code() == 4 { // signal! lets retry max 10 times // suspend thread with sleep to let the gc get // cycles in the case the Bohem gc is interupting diff --git a/vlib/net/websocket/io.v b/vlib/net/websocket/io.v index 2ef7870a80..3d0f5fc832 100644 --- a/vlib/net/websocket/io.v +++ b/vlib/net/websocket/io.v @@ -15,7 +15,7 @@ fn (mut ws Client) socket_read(mut buffer []byte) ?int { } else { for { r := ws.conn.read(mut buffer) or { - if err.code == net.err_timed_out_code { + if err.code() == net.err_timed_out_code { continue } return err @@ -39,7 +39,7 @@ fn (mut ws Client) socket_read_ptr(buf_ptr &byte, len int) ?int { } else { for { r := ws.conn.read_ptr(buf_ptr, len) or { - if err.code == net.err_timed_out_code { + if err.code() == net.err_timed_out_code { continue } return err @@ -63,7 +63,7 @@ fn (mut ws Client) socket_write(bytes []byte) ?int { } else { for { n := ws.conn.write(bytes) or { - if err.code == net.err_timed_out_code { + if err.code() == net.err_timed_out_code { continue } return err diff --git a/vlib/os/signal_test.v b/vlib/os/signal_test.v index 87f5b9b2aa..5e6158fc85 100644 --- a/vlib/os/signal_test.v +++ b/vlib/os/signal_test.v @@ -21,7 +21,7 @@ fn test_signal_opt_invalid_argument() { } os.signal_opt(.kill, default_handler) or { assert err.msg() == 'Invalid argument' - assert err.code == 22 + assert err.code() == 22 } } diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v index 75f99cf3cb..44c413cf44 100644 --- a/vlib/v/checker/checker.v +++ b/vlib/v/checker/checker.v @@ -82,6 +82,7 @@ pub mut: returns bool scope_returns bool is_builtin_mod bool // true inside the 'builtin', 'os' or 'strconv' modules; TODO: remove the need for special casing this + is_just_builtin_mod bool // true only inside 'builtin' is_generated bool // true for `[generated] module xyz` .v files inside_unsafe bool // true inside `unsafe {}` blocks inside_const bool // true inside `const ( ... )` blocks @@ -149,6 +150,7 @@ fn (mut c Checker) reset_checker_state_at_start_of_new_file() { c.scope_returns = false c.mod = '' c.is_builtin_mod = false + c.is_just_builtin_mod = false c.inside_unsafe = false c.inside_const = false c.inside_anon_fn = false @@ -1721,6 +1723,21 @@ pub fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type { } } } + + // >> Hack to allow old style custom error implementations + // TODO: remove once deprecation period for `IError` methods has ended + if sym.idx == ast.error_type_idx && !c.is_just_builtin_mod + && (field_name == 'msg' || field_name == 'code') { + method := c.table.find_method(sym, field_name) or { + c.error('invalid `IError` interface implementation: $err', node.pos) + return ast.void_type + } + c.note('the `.$field_name` field on `IError` is deprecated, and will be removed after 2022-06-01, use `.${field_name}()` instead.', + node.pos) + return method.return_type + } + // <<< + if has_field { if sym.mod != c.mod && !field.is_pub && sym.language != .c { unwrapped_sym := c.table.sym(c.unwrap_generic(typ)) @@ -1758,19 +1775,6 @@ pub fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type { c.error(suggestion.say(unknown_field_msg), node.pos) return ast.void_type } - - // >> Hack to allow old style custom error implementations - // TODO: remove once deprecation period for `IError` methods has ended - if sym.name == 'IError' && (field_name == 'msg' || field_name == 'code') { - method := c.table.find_method(sym, field_name) or { - c.error('invalid `IError` interface implementation: $err', node.pos) - return ast.void_type - } - c.note('the `.$field_name` field on `IError` is deprecated, use `.${field_name}()` instead.', - node.pos) - return method.return_type - } - // <<< if c.smartcast_mut_pos != token.Pos{} { c.note('smartcasting requires either an immutable value, or an explicit mut keyword before the value', c.smartcast_mut_pos) @@ -2041,7 +2045,8 @@ fn (mut c Checker) stmt(node_ ast.Stmt) { } ast.Module { c.mod = node.name - c.is_builtin_mod = node.name in ['builtin', 'os', 'strconv'] + c.is_just_builtin_mod = node.name == 'builtin' + c.is_builtin_mod = c.is_just_builtin_mod || node.name in ['os', 'strconv'] c.check_valid_snake_case(node.name, 'module name', node.pos) } ast.Return { diff --git a/vlib/v/tests/option_print_errors_test.v b/vlib/v/tests/option_print_errors_test.v index 42fbfec1a1..8e22e97332 100644 --- a/vlib/v/tests/option_print_errors_test.v +++ b/vlib/v/tests/option_print_errors_test.v @@ -4,7 +4,7 @@ fn test_error_can_be_converted_to_string() { fn test_error_can_be_assigned_to_a_variable() { f := error('an error') - assert 'an error' == f.msg + assert 'an error' == f.msg() } fn test_error_can_be_printed() { diff --git a/vlib/v/tests/option_test.v b/vlib/v/tests/option_test.v index 3d3126793d..dfa0c5e26a 100644 --- a/vlib/v/tests/option_test.v +++ b/vlib/v/tests/option_test.v @@ -8,11 +8,11 @@ fn test_err_with_code() { _ := w } else { assert err.msg() == 'hi' - assert err.code == 137 + assert err.code() == 137 } v := opt_err_with_code() or { assert err.msg() == 'hi' - assert err.code == 137 + assert err.code() == 137 return } assert false diff --git a/vlib/v/tests/or_expr_with_nested_match_expr_test.v b/vlib/v/tests/or_expr_with_nested_match_expr_test.v index b28f386d65..3dacc7e456 100644 --- a/vlib/v/tests/or_expr_with_nested_match_expr_test.v +++ b/vlib/v/tests/or_expr_with_nested_match_expr_test.v @@ -5,7 +5,7 @@ pub mut: fn delete_secret_v1() API_error { response := req_do() or { - match err.msg { + match err.msg() { 'dial_tcp failed' { return API_error{ errors: ['Vault server not started'] @@ -13,7 +13,7 @@ fn delete_secret_v1() API_error { } else { return API_error{ - errors: [err.msg] + errors: [err.msg()] } } } diff --git a/vlib/vweb/vweb.v b/vlib/vweb/vweb.v index 69f3b998a6..8c131f6e81 100644 --- a/vlib/vweb/vweb.v +++ b/vlib/vweb/vweb.v @@ -393,7 +393,8 @@ pub struct RunParams { [manualfree] pub fn run_at(global_app &T, params RunParams) ? { mut l := net.listen_tcp(params.family, '$params.host:$params.port') or { - return error('failed to listen $err.code $err') + ecode := err.code() + return error('failed to listen $ecode $err') } // Parsing methods attributes