From d6a6fd570d5631a3919207c9e200777da2ce68e2 Mon Sep 17 00:00:00 2001 From: Alex Snezhko Date: Tue, 13 Aug 2024 22:02:30 -0700 Subject: [PATCH] feat(compiler): Introduce warning if non-void expression value not used or ignored --- compiler/src/typed/typecore.re | 5 +- compiler/src/utils/warnings.re | 2 +- compiler/test/input/wasiPolyfill.gr | 4 +- compiler/test/runner.re | 2 + compiler/test/stdlib/array.test.gr | 2 +- compiler/test/stdlib/char.test.gr | 2 +- compiler/test/stdlib/path.test.gr | 4 +- compiler/test/stdlib/queue.test.gr | 32 ++-- compiler/test/stdlib/set.test.gr | 4 +- compiler/test/stdlib/stack.test.gr | 2 +- compiler/test/stdlib/wasi.file.test.gr | 14 +- compiler/test/stdlib/wasi.process.test.gr | 2 +- compiler/test/suites/arrays.re | 16 +- compiler/test/suites/basic_functionality.re | 6 +- compiler/test/suites/expressions.re | 60 ++++++++ compiler/test/suites/gc.re | 2 + compiler/test/suites/linking.re | 7 +- compiler/test/suites/optimizations.re | 8 +- compiler/test/suites/pattern_matching.re | 2 +- compiler/test/suites/records.re | 4 +- docs/contributor/memory_management.md | 8 +- stdlib/exception.gr | 2 +- stdlib/json.gr | 18 +-- stdlib/map.gr | 2 +- stdlib/marshal.gr | 2 +- stdlib/runtime/atoi/parse.gr | 10 +- stdlib/runtime/bigint.gr | 114 +++++++------- stdlib/runtime/debugPrint.gr | 2 +- stdlib/runtime/exception.gr | 2 +- stdlib/runtime/gc.gr | 2 +- stdlib/runtime/numbers.gr | 162 ++++++++++---------- stdlib/runtime/string.gr | 12 +- stdlib/runtime/utils/printing.gr | 4 +- 33 files changed, 295 insertions(+), 225 deletions(-) create mode 100644 compiler/test/suites/expressions.re diff --git a/compiler/src/typed/typecore.re b/compiler/src/typed/typecore.re index 1e14d79a3..6247a4eb0 100644 --- a/compiler/src/typed/typecore.re +++ b/compiler/src/typed/typecore.re @@ -2231,11 +2231,10 @@ and type_statement_expr = (~explanation=?, ~in_function=?, env, sexp) => { /*| Tarrow _ -> [not really applicable with our syntax] Location.prerr_warning loc Warnings.Partial_application*/ | TTyConstr(p, _, _) when Path.same(p, Builtin_types.path_void) => () + | TTyVar(None) => () /*| Tvar _ -> add_delayed_check (fun () -> check_application_result env true exp)*/ - | _ => () - /* This isn't quite relevant to Grain mechanics - Location.prerr_warning loc Grain_utils.Warnings.StatementType */ + | _ => Location.prerr_warning(loc, Grain_utils.Warnings.StatementType) }; unify_var(env, tv, ty); exp; diff --git a/compiler/src/utils/warnings.re b/compiler/src/utils/warnings.re index fd513fddf..77bfd42ca 100644 --- a/compiler/src/utils/warnings.re +++ b/compiler/src/utils/warnings.re @@ -101,7 +101,7 @@ let message = "these field labels belong to several types: " ++ String.concat(" ", tl) ++ "\nThe first one was selected. Please disambiguate if this is wrong." - | StatementType => "this expression should have type void." + | StatementType => "this expression should have type void. Use `ignore` to ignore the result of the expression" | NonreturningStatement => "this statement never returns (or has an unsound type)." | AllClausesGuarded => "this pattern-matching is not exhaustive.\nAll clauses in this pattern-matching are guarded." | PartialMatch("") => "this pattern-matching is not exhaustive." diff --git a/compiler/test/input/wasiPolyfill.gr b/compiler/test/input/wasiPolyfill.gr index a5eb6c890..ace9c951d 100644 --- a/compiler/test/input/wasiPolyfill.gr +++ b/compiler/test/input/wasiPolyfill.gr @@ -14,8 +14,8 @@ provide let fd_write: (WasmI32, WasmI32, WasmI32, WasmI32) => WasmI32 = iovs_len, nwritten, ) => { - fd_write(fd, iovs, iovs_len, nwritten) - fd_write(fd, iovs, iovs_len, nwritten) + let _ = fd_write(fd, iovs, iovs_len, nwritten) + let _ = fd_write(fd, iovs, iovs_len, nwritten) fd_write(fd, iovs, iovs_len, nwritten) } diff --git a/compiler/test/runner.re b/compiler/test/runner.re index b1b64cff2..e1e2d6833 100644 --- a/compiler/test/runner.re +++ b/compiler/test/runner.re @@ -206,6 +206,7 @@ let makeSnapshotRunner = (~config_fn=?, test, ~module_header=module_header, name, prog) => { test(name, ({expect}) => { Config.preserve_all_configs(() => { + Config.print_warnings := false; ignore @@ compile( ~hook=stop_after_object_file_emitted, @@ -234,6 +235,7 @@ let makeFilesizeRunner = let makeSnapshotFileRunner = (test, ~config_fn=?, name, filename) => { test(name, ({expect}) => { Config.preserve_all_configs(() => { + Config.print_warnings := false; let infile = grainfile(filename); let outfile = wasmfile(name); ignore @@ diff --git a/compiler/test/stdlib/array.test.gr b/compiler/test/stdlib/array.test.gr index 9757f120f..3ff9a2a04 100644 --- a/compiler/test/stdlib/array.test.gr +++ b/compiler/test/stdlib/array.test.gr @@ -835,7 +835,7 @@ module Immutable { // Array.rotate let arr1 = fromList([1, 2, 3, 4, 5]) - Array.rotate(0, arr1) + ignore(Array.rotate(0, arr1)) assert arr1 == fromList([1, 2, 3, 4, 5]) let arr2 = fromList([1, 2, 3, 4, 5]) diff --git a/compiler/test/stdlib/char.test.gr b/compiler/test/stdlib/char.test.gr index e2e55645a..2c3e420fe 100644 --- a/compiler/test/stdlib/char.test.gr +++ b/compiler/test/stdlib/char.test.gr @@ -51,7 +51,7 @@ while (!done) { break } - Char.code(chars[charPosition]) + ignore(Char.code(chars[charPosition])) charPosition += 1 } diff --git a/compiler/test/stdlib/path.test.gr b/compiler/test/stdlib/path.test.gr index 99ae14769..a788edf9f 100644 --- a/compiler/test/stdlib/path.test.gr +++ b/compiler/test/stdlib/path.test.gr @@ -216,8 +216,8 @@ List.forEach(({ base, toAppend, final }) => { assert append == Ok(expPath) }, appendTests) -Path.append(fs("file"), fs("f")) == Err(Path.AppendToFile) -Path.append(fs("/d/"), fs("/f")) == Err(Path.AppendAbsolute) +assert Path.append(fs("file"), fs("f")) == Err(Path.AppendToFile) +assert Path.append(fs("/d/"), fs("/f")) == Err(Path.AppendAbsolute) record RelativeToDirTestData { source: String, diff --git a/compiler/test/stdlib/queue.test.gr b/compiler/test/stdlib/queue.test.gr index d31a91482..caec75d2f 100644 --- a/compiler/test/stdlib/queue.test.gr +++ b/compiler/test/stdlib/queue.test.gr @@ -29,7 +29,7 @@ Queue.push(4, queue) assert Queue.size(queue) == 3 assert Queue.peek(queue) == Some(2) let copy = Queue.copy(queue) -Queue.pop(copy) +ignore(Queue.pop(copy)) assert Queue.size(copy) == 2 assert Queue.size(queue) == 3 Queue.clear(queue) @@ -61,11 +61,11 @@ Queue.push(1, queue) Queue.push(2, queue) Queue.push(3, queue) assert Queue.toList(queue) == [0, 1, 2, 3] -Queue.pop(queue) +ignore(Queue.pop(queue)) assert Queue.toList(queue) == [1, 2, 3] Queue.push(3, queue) assert Queue.toList(queue) == [1, 2, 3, 3] -Queue.pop(queue) +ignore(Queue.pop(queue)) Queue.push(4, queue) Queue.push(5, queue) assert Queue.toList(queue) == [2, 3, 3, 4, 5] @@ -121,12 +121,12 @@ Queue.push(1, queue2) Queue.push(2, queue2) Queue.push(3, queue2) Queue.push(4, queue2) -Queue.pop(queue2) -Queue.pop(queue2) +ignore(Queue.pop(queue2)) +ignore(Queue.pop(queue2)) Queue.push(5, queue2) -Queue.pop(queue2) -Queue.pop(queue2) -Queue.pop(queue2) +ignore(Queue.pop(queue2)) +ignore(Queue.pop(queue2)) +ignore(Queue.pop(queue2)) Queue.push(6, queue2) Queue.push(7, queue2) Queue.push(8, queue2) @@ -149,7 +149,7 @@ Queue.push(2, queue3) Queue.push(3, queue3) assert Queue.toArray(queue3) == [> 1, 2, 3] let queue4 = Queue.copy(queue3) -Queue.pop(queue4) +ignore(Queue.pop(queue4)) assert Queue.toArray(queue4) == [> 2, 3] // Queue.fromArray @@ -169,12 +169,12 @@ Queue.push(1, queue2) Queue.push(2, queue2) Queue.push(3, queue2) Queue.push(4, queue2) -Queue.pop(queue2) -Queue.pop(queue2) +ignore(Queue.pop(queue2)) +ignore(Queue.pop(queue2)) Queue.push(5, queue2) -Queue.pop(queue2) -Queue.pop(queue2) -Queue.pop(queue2) +ignore(Queue.pop(queue2)) +ignore(Queue.pop(queue2)) +ignore(Queue.pop(queue2)) Queue.push(6, queue2) Queue.push(7, queue2) Queue.push(8, queue2) @@ -194,7 +194,7 @@ Queue.push(1, queue3) Queue.push(2, queue3) Queue.push(3, queue3) let queue4 = Queue.copy(queue3) -Queue.pop(queue4) +ignore(Queue.pop(queue4)) let queue5 = Queue.make() Queue.push(6, queue5) Queue.push(7, queue5) @@ -222,7 +222,7 @@ Queue.push(3, queue7) assert queue4 == queue7 let queue8 = Queue.make() Queue.push(1, queue8) -Queue.pop(queue8) +ignore(Queue.pop(queue8)) assert queue8 == queue1 assert !(queue2 == queue3) diff --git a/compiler/test/stdlib/set.test.gr b/compiler/test/stdlib/set.test.gr index ff73fd737..e8abf4e78 100644 --- a/compiler/test/stdlib/set.test.gr +++ b/compiler/test/stdlib/set.test.gr @@ -327,7 +327,7 @@ module Immutable { let mut filterTestSet = makeTestSet() - Set.filter(key => fail "Shouldn't be called", Set.empty) + ignore(Set.filter(key => fail "Shouldn't be called", Set.empty)) filterTestSet = Set.filter(key => key == Sheep, filterTestSet) assert !Set.contains(Grain, filterTestSet) @@ -338,7 +338,7 @@ module Immutable { let mut rejectTestSet = makeTestSet() - Set.reject(key => fail "Shouldn't be called", Set.empty) + ignore(Set.reject(key => fail "Shouldn't be called", Set.empty)) rejectTestSet = Set.reject(key => key == Sheep, rejectTestSet) assert Set.contains(Grain, rejectTestSet) diff --git a/compiler/test/stdlib/stack.test.gr b/compiler/test/stdlib/stack.test.gr index 8f56a3ae9..cc4477d5c 100644 --- a/compiler/test/stdlib/stack.test.gr +++ b/compiler/test/stdlib/stack.test.gr @@ -28,7 +28,7 @@ Stack.push(4, stack) assert Stack.size(stack) == 3 assert Stack.peek(stack) == Some(4) let copy = Stack.copy(stack) -Stack.pop(copy) +ignore(Stack.pop(copy)) assert Stack.size(copy) == 2 assert Stack.size(stack) == 3 Stack.clear(stack) diff --git a/compiler/test/stdlib/wasi.file.test.gr b/compiler/test/stdlib/wasi.file.test.gr index 90432f389..6c1968a39 100644 --- a/compiler/test/stdlib/wasi.file.test.gr +++ b/compiler/test/stdlib/wasi.file.test.gr @@ -11,7 +11,7 @@ let foo = Result.unwrap( let (buf, nread) = Result.unwrap(Fs.fdRead(foo, 40)) -Fs.fdClose(foo) +ignore(Fs.fdClose(foo)) assert buf == Bytes.fromString("foo, bar, & baz") assert nread == 15 @@ -23,7 +23,7 @@ let foo = Result.unwrap( let (buf, nread) = Result.unwrap(Fs.fdRead(foo, 40)) -Fs.fdClose(foo) +ignore(Fs.fdClose(foo)) assert buf == Bytes.fromString("foo, bar, & baz") assert nread == 15 @@ -35,7 +35,7 @@ let foo = Result.unwrap( let (buf, nread) = Result.unwrap(Fs.fdRead(foo, 40)) -Fs.fdClose(foo) +ignore(Fs.fdClose(foo)) assert buf == Bytes.fromString("foo, bar, & baz") assert nread == 15 @@ -53,7 +53,7 @@ let foo = Result.unwrap( let (buf, nread) = Result.unwrap(Fs.fdRead(foo, 40)) -Fs.fdClose(foo) +ignore(Fs.fdClose(foo)) assert buf == Bytes.fromString("foo, bar, & baz") assert nread == 15 @@ -71,13 +71,13 @@ let foo = Result.unwrap( assert Fs.fdWrite(foo, Bytes.fromString("this and that")) == Ok(13) -Fs.fdSeek(foo, 0L, Fs.Set) +ignore(Fs.fdSeek(foo, 0L, Fs.Set)) let (buf, nread) = Result.unwrap(Fs.fdRead(foo, 40)) -Fs.fdSetSize(foo, 0L) +ignore(Fs.fdSetSize(foo, 0L)) -Fs.fdClose(foo) +ignore(Fs.fdClose(foo)) assert buf == Bytes.fromString("this and that") assert nread == 13 diff --git a/compiler/test/stdlib/wasi.process.test.gr b/compiler/test/stdlib/wasi.process.test.gr index a9a9b8128..ad868570f 100644 --- a/compiler/test/stdlib/wasi.process.test.gr +++ b/compiler/test/stdlib/wasi.process.test.gr @@ -15,4 +15,4 @@ match (Process.env()) { Err(err) => throw err, } -Process.exit(5) +let _ = Process.exit(5) diff --git a/compiler/test/suites/arrays.re b/compiler/test/suites/arrays.re index bb4c8387b..cd3bad5c8 100644 --- a/compiler/test/suites/arrays.re +++ b/compiler/test/suites/arrays.re @@ -30,42 +30,42 @@ describe("arrays", ({test, testSkip}) => { assertSnapshot("array_access5", "[> 1, 2, 3][-3]"); assertRunError( "array_access_err", - "let x = [> 1, 2, 3]; x[3]", + "let x = [> 1, 2, 3]; ignore(x[3])", "Index out of bounds", ); assertRunError( "array_access_err2", - "let x = [> 1, 2, 3]; x[-4]", + "let x = [> 1, 2, 3]; ignore(x[-4])", "Index out of bounds", ); assertRunError( "array_access_err3", - "let x = [> 1, 2, 3]; x[99]", + "let x = [> 1, 2, 3]; ignore(x[99])", "Index out of bounds", ); assertRunError( "array_access_err4", - "let x = [> 1, 2, 3]; x[-99]", + "let x = [> 1, 2, 3]; ignore(x[-99])", "Index out of bounds", ); assertRunError( "array_access_err5", - "let x = [> 1, 2, 3]; let i = 1.5; x[i]", + "let x = [> 1, 2, 3]; let i = 1.5; ignore(x[i])", "Index not an integer", ); assertRunError( "array_access_err6", - "let x = [> 1, 2, 3]; let i = 1/3; x[i]", + "let x = [> 1, 2, 3]; let i = 1/3; ignore(x[i])", "Index not an integer", ); assertRunError( "array_access_err7", - "let x = [> 1, 2, 3]; x[987654321987654321]", + "let x = [> 1, 2, 3]; ignore(x[987654321987654321])", "Index out of bounds", ); assertCompileError( "array_access_err8", - "let x = [> 1, 2, 3]; x[false]", + "let x = [> 1, 2, 3]; ignore(x[false])", "has type Bool but", ); assertRun( diff --git a/compiler/test/suites/basic_functionality.re b/compiler/test/suites/basic_functionality.re index 4607d3967..9d3e1fd93 100644 --- a/compiler/test/suites/basic_functionality.re +++ b/compiler/test/suites/basic_functionality.re @@ -78,10 +78,10 @@ describe("basic functionality", ({test, testSkip}) => { assertSnapshot("binop6", "9 % 5"); assertRunError( "division_by_zero", - "let nine = 9; nine / 0", + "let nine = 9; ignore(nine / 0)", "Division by zero", ); - assertRunError("modulo_by_zero", "9 % 0", "Modulo by zero"); + assertRunError("modulo_by_zero", "ignore(9 % 0)", "Modulo by zero"); assertSnapshot("division1", "5 / 2"); assertSnapshot("modulo1", "-17 % 4"); assertSnapshot("modulo2", "17 % -4"); @@ -240,7 +240,7 @@ describe("basic functionality", ({test, testSkip}) => { assertRunError("fail1", "ignore(fail \"boo\")", "Failure: boo"); assertRunError( "fail2", - "if (false) { 3 } else { fail \"boo\" }", + "ignore(if (false) { 3 } else { fail \"boo\" })", "Failure: boo", ); assertSnapshotFile("toplevel_statements", "toplevelStatements"); diff --git a/compiler/test/suites/expressions.re b/compiler/test/suites/expressions.re new file mode 100644 index 000000000..9cb6759ba --- /dev/null +++ b/compiler/test/suites/expressions.re @@ -0,0 +1,60 @@ +open Grain_tests.TestFramework; +open Grain_tests.Runner; + +let {describe} = + describeConfig |> withCustomMatchers(customMatchers) |> build; + +describe("expressions", ({test, testSkip}) => { + let assertNoWarning = makeNoWarningRunner(test); + let assertWarning = makeWarningRunner(test); + + assertWarning( + "non_void_non_returning_expression1", + {| + 1 + print(2) + |}, + Grain_utils.Warnings.StatementType, + ); + + assertWarning( + "non_void_non_returning_expression2", + {| + let f = () => { + 1 + print(2) + } + |}, + Grain_utils.Warnings.StatementType, + ); + + assertNoWarning( + "non_void_non_returning_expression3", + {| + ignore(1) + print(2) + |}, + ); + + assertNoWarning( + "non_void_non_returning_expression4", + {| + let f = () => { + ignore(1) + print(2) + } + |}, + ); + + assertNoWarning( + "non_void_non_returning_expression5", + {| + let rec f = () => { + if (true) { + f() + void + } + } + |}, + ); +}); diff --git a/compiler/test/suites/gc.re b/compiler/test/suites/gc.re index 0d1555618..23be71ea2 100644 --- a/compiler/test/suites/gc.re +++ b/compiler/test/suites/gc.re @@ -43,6 +43,7 @@ describe("garbage collection", ({test, testSkip}) => { let assertMemoryLimitedFileRun = makeFileRunner(~num_pages=1, test_or_skip); let assertRunGC = (name, heapSize, prog, expected) => makeRunner( + ~config_fn=() => {Grain_utils.Config.print_warnings := false}, ~num_pages=1, ~max_pages=2, test_or_skip, @@ -52,6 +53,7 @@ describe("garbage collection", ({test, testSkip}) => { ); let assertRunGCError = (name, heapSize, prog, expected) => makeErrorRunner( + ~config_fn=() => {Grain_utils.Config.print_warnings := false}, test_or_skip, ~num_pages=1, ~max_pages=2, diff --git a/compiler/test/suites/linking.re b/compiler/test/suites/linking.re index 9ff4975ce..749820c4b 100644 --- a/compiler/test/suites/linking.re +++ b/compiler/test/suites/linking.re @@ -23,7 +23,12 @@ describe("linking", ({test, testSkip}) => { {|from "list" include List; print(List.map(n => n + 1, [1, 2, 3]))|}, "[2, 3, 4]\n", ); - assertRun("link_issue_994_no_generated_code", {|0|}, ""); + assertRun( + ~config_fn=() => {Grain_utils.Config.print_warnings := false}, + "link_issue_994_no_generated_code", + {|0|}, + "", + ); assertRun( "link_issue_994_unexported_type", {|record Foo { foo: String }|}, diff --git a/compiler/test/suites/optimizations.re b/compiler/test/suites/optimizations.re index f2041a3fb..30ef8c2cc 100644 --- a/compiler/test/suites/optimizations.re +++ b/compiler/test/suites/optimizations.re @@ -27,6 +27,7 @@ describe("optimizations", ({test, testSkip}) => { ) => { test(outfile, ({expect}) => { Config.preserve_all_configs(() => { + Config.print_warnings := false; switch (config_fn) { | None => () | Some(fn) => fn() @@ -64,7 +65,7 @@ describe("optimizations", ({test, testSkip}) => { ); assertRun( "regression_no_elim_impure_call", - "let foo = (f) => { let g = print(f(5)); 5 }; foo(toString)", + "let foo = (f) => { let g = print(f(5)); 5 }; let _ = foo(toString)", "5\n", ); assertAnf( @@ -510,6 +511,7 @@ describe("optimizations", ({test, testSkip}) => { ); // Binaryen optimizations disabled assertBinaryenOptimizationsDisabledFileRun( + ~config_fn=() => {Grain_utils.Config.print_warnings := false}, "test_binaryen_optimizations_disabled", "toplevelStatements", "1\n2\n3\n4\n5\n", @@ -524,8 +526,8 @@ describe("optimizations", ({test, testSkip}) => { from "runtime/unsafe/wasmi32" include WasmI32 @disableGC provide let foo = (x, y, z) => { - Memory.incRef(WasmI32.fromGrain((+))) - Memory.incRef(WasmI32.fromGrain((+))) + let _ = Memory.incRef(WasmI32.fromGrain((+))) + let _ = Memory.incRef(WasmI32.fromGrain((+))) // x, y, and z will get decRef'd by `+` x + y + z } diff --git a/compiler/test/suites/pattern_matching.re b/compiler/test/suites/pattern_matching.re index 8171d7f0a..ec53f3896 100644 --- a/compiler/test/suites/pattern_matching.re +++ b/compiler/test/suites/pattern_matching.re @@ -403,7 +403,7 @@ describe("pattern matching", ({test, testSkip}) => { () => b } - run() + ignore(run()) |}, "2\n", ); diff --git a/compiler/test/suites/records.re b/compiler/test/suites/records.re index c11947ddd..57387931e 100644 --- a/compiler/test/suites/records.re +++ b/compiler/test/suites/records.re @@ -244,7 +244,7 @@ describe("records", ({test, testSkip}) => { {| record A { field: Number } record B { field: Number } - (x: A) => x.field + let _ = (x: A) => x.field |}, ); assertNoWarning( @@ -252,7 +252,7 @@ describe("records", ({test, testSkip}) => { {| record A { field: Number } record B { field: Number } - (x: B) => x.field + let _ = (x: B) => x.field |}, ); // well_formedness field omission warning diff --git a/docs/contributor/memory_management.md b/docs/contributor/memory_management.md index de54e0af5..5bd5bdbd0 100644 --- a/docs/contributor/memory_management.md +++ b/docs/contributor/memory_management.md @@ -142,8 +142,8 @@ When calling function from inside a GC-disabled function: // @disableGC-safe wrapper @disableGC let wasmSafeLength = (s: String) => { - Memory.incRef(WasmI32.fromGrain(length)) // <- incRef closure being invoked - Memory.incRef(WasmI32.fromGrain(s)) // <- incRef argument before call + let _ = Memory.incRef(WasmI32.fromGrain(length)) // <- incRef closure being invoked + let _ = Memory.incRef(WasmI32.fromGrain(s)) // <- incRef argument before call length(s) } ``` @@ -156,8 +156,8 @@ Before returning from a GC-disabled function which follows the Grain calling con export let rec sqrt = (x: Number) => { // ... let ret = ... - Memory.decRef(WasmI32.fromGrain(x)) // <- decrement argument - Memory.decRef(WasmI32.fromGrain(sqrt)) // <- decrement closure (note that this function needs to be recursive) + let _ = Memory.decRef(WasmI32.fromGrain(x)) // <- decrement argument + let _ = Memory.decRef(WasmI32.fromGrain(sqrt)) // <- decrement closure (note that this function needs to be recursive) ret } ``` diff --git a/stdlib/exception.gr b/stdlib/exception.gr index d4c784f02..5a0ecb4b1 100644 --- a/stdlib/exception.gr +++ b/stdlib/exception.gr @@ -46,6 +46,6 @@ provide let rec registerPrinter = (printer: Exception => Option) => { // no need to increment refcount on f; we just don't decRef it at the end of the function Exception.printers = WasmI32.fromGrain((printer, Exception.printers)) - Memory.decRef(WasmI32.fromGrain(registerPrinter)) + let _ = Memory.decRef(WasmI32.fromGrain(registerPrinter)) void } diff --git a/stdlib/json.gr b/stdlib/json.gr index ad6d40a5c..3f78cb9a7 100644 --- a/stdlib/json.gr +++ b/stdlib/json.gr @@ -1367,7 +1367,7 @@ let skipWhiteSpace = (parserState: JsonParserState) => { isInterTokenWhiteSpace(parserState.currentCodePoint) && !isAtEndOfInput(parserState) ) { - next(parserState) + ignore(next(parserState)) void } } @@ -1423,7 +1423,7 @@ let expectCodePointAndAdvance = ( ) => { let c = parserState.currentCodePoint if (c == expectedCodePoint) { - next(parserState) + ignore(next(parserState)) None } else { let detail = "expected " ++ @@ -1569,7 +1569,7 @@ and parseString = (parserState: JsonParserState) => { while (true) { match (parserState.currentCodePoint) { 0x22 => { // '"' - next(parserState) + ignore(next(parserState)) break }, -1 => { // EOF @@ -1584,7 +1584,7 @@ and parseString = (parserState: JsonParserState) => { // Keep the starting position for better error reporting. let escapeStartPos = parserState.pos - next(parserState) + ignore(next(parserState)) match (parserState.currentCodePoint) { 0x22 => { // '"' @@ -1625,7 +1625,7 @@ and parseString = (parserState: JsonParserState) => { ignore(next(parserState)) }, 0x75 => { // 'u' (start of hexadecimal UTF-16 escape sequence) - next(parserState) + ignore(next(parserState)) // The escape sequence can either be a standalone code point or // a UTF-16 surrogate pair made of two code units that have to @@ -1758,7 +1758,7 @@ and parseString = (parserState: JsonParserState) => { ) } // Finally the happy case of a simple unescaped code point. - next(parserState) + ignore(next(parserState)) Buffer.addCharFromCodePoint(c, buffer) }, } @@ -1918,11 +1918,11 @@ and parseArray = (parserState: JsonParserState) => { ) } trailingComma = true - next(parserState) + ignore(next(parserState)) skipWhiteSpace(parserState) }, 0x5D => { // ']' - next(parserState) + ignore(next(parserState)) break }, -1 => { // EOF @@ -1989,7 +1989,7 @@ and parseObject = (parserState: JsonParserState) => { let detail = "unexpected trailing comma in object" return Err(buildUnexpectedTokenError(parserState, detail)) } - next(parserState) + ignore(next(parserState)) break }, _ => { diff --git a/stdlib/map.gr b/stdlib/map.gr index 4ec222da9..974b8686b 100644 --- a/stdlib/map.gr +++ b/stdlib/map.gr @@ -446,7 +446,7 @@ provide let toArray = (map: Map) => { ignore(array) i + 1 } - reduce(reducer, 0, map) + ignore(reduce(reducer, 0, map)) array: Array<(a, b)> } diff --git a/stdlib/marshal.gr b/stdlib/marshal.gr index 2873bcfc8..76c0180d7 100644 --- a/stdlib/marshal.gr +++ b/stdlib/marshal.gr @@ -433,7 +433,7 @@ provide let marshal = value => { let size = size(valuePtr) let buf = allocateBytes(size) Memory.fill(buf + 8n, 0n, size) - marshal(valuePtr, buf + 8n) + let _ = marshal(valuePtr, buf + 8n) ignore(value) toGrain(buf): Bytes } diff --git a/stdlib/runtime/atoi/parse.gr b/stdlib/runtime/atoi/parse.gr index fd5f05781..0aa4cb4d8 100644 --- a/stdlib/runtime/atoi/parse.gr +++ b/stdlib/runtime/atoi/parse.gr @@ -166,10 +166,10 @@ provide let parseInt = (string: String, radix: Number) => { valueBigInt = BI.makeWrappedUint64(prevValue * -1N) radixBigInt = BI.makeWrappedUint64(radix) let newvalue = BI.mul(valueBigInt, radixBigInt) - Memory.decRef(valueBigInt) + let _ = Memory.decRef(valueBigInt) valueBigInt = newvalue let newvalue = BI.addInt(valueBigInt, digit) - Memory.decRef(valueBigInt) + let _ = Memory.decRef(valueBigInt) valueBigInt = newvalue } else { use WasmI64.{ (-) } @@ -185,10 +185,10 @@ provide let parseInt = (string: String, radix: Number) => { } } else { let newvalue = BI.mul(valueBigInt, radixBigInt) - Memory.decRef(valueBigInt) + let _ = Memory.decRef(valueBigInt) valueBigInt = newvalue let newvalue = BI.addInt(valueBigInt, digit) - Memory.decRef(valueBigInt) + let _ = Memory.decRef(valueBigInt) valueBigInt = newvalue } } @@ -205,7 +205,7 @@ provide let parseInt = (string: String, radix: Number) => { // BigInt number is accumulated in positive form if (negative) { let newvalue = BI.negate(valueBigInt) - Memory.decRef(valueBigInt) + let _ = Memory.decRef(valueBigInt) return Ok(WasmI32.toGrain(newvalue)) } diff --git a/stdlib/runtime/bigint.gr b/stdlib/runtime/bigint.gr index bc2d94b29..43b0f4778 100644 --- a/stdlib/runtime/bigint.gr +++ b/stdlib/runtime/bigint.gr @@ -845,7 +845,7 @@ provide let bigIntToString = (num: WasmI32, base: WasmI32) => { c = tmpInner % d } } - Memory.decRef(tmpCopy) + let _ = Memory.decRef(tmpCopy) tmp = trimNumberInPlace(tmp) result = [ DS.tagChar(getDigit(WasmI32.wrapI64(WasmI64.remU(c, base)))), @@ -1126,7 +1126,7 @@ provide let addInt = (num1: WasmI32, int: WasmI64) => { } else { unsignedSubInt(num1, int) } - negateInPlace(ret) + let _ = negateInPlace(ret) ret } else { if (int < 0N) { @@ -1173,7 +1173,7 @@ provide let subInt = (num1: WasmI32, int: WasmI64) => { } else { unsignedAddInt(num1, int) } - negateInPlace(ret) + let _ = negateInPlace(ret) ret } else { if (int < 0N) { @@ -1366,7 +1366,7 @@ provide let shrS = (num: WasmI32, places: WasmI32) => { } if (underflow) { let newRet = decr(ret) - Memory.decRef(ret) + let _ = Memory.decRef(ret) newRet } else { ret @@ -1462,7 +1462,7 @@ provide let bitwiseNot = (num: WasmI32) => { // ~x == -x - 1 let numNegated = negate(num) let result = decr(numNegated) - Memory.decRef(numNegated) + let _ = Memory.decRef(numNegated) result } @@ -1478,11 +1478,11 @@ provide let bitwiseAnd = (num1: WasmI32, num2: WasmI32) => { // A & -B == A & ~(B-1) let num2Neg = negate(num2) let num2Sub1 = decr(num2Neg) - Memory.decRef(num2Neg) + let _ = Memory.decRef(num2Neg) let notNum2Sub1 = bitwiseNotUnsigned(num2Sub1) - Memory.decRef(num2Sub1) + let _ = Memory.decRef(num2Sub1) let combined = bitwiseAndPositive(num1, notNum2Sub1, 1n) - Memory.decRef(notNum2Sub1) + let _ = Memory.decRef(notNum2Sub1) combined } } else { @@ -1490,11 +1490,11 @@ provide let bitwiseAnd = (num1: WasmI32, num2: WasmI32) => { // -A & B == ~(A-1) & B let num1Neg = negate(num1) // A let num1Sub1 = decr(num1Neg) // A-1 - Memory.decRef(num1Neg) + let _ = Memory.decRef(num1Neg) let notNum1Sub1 = bitwiseNotUnsigned(num1Sub1) // ~(A-1) - Memory.decRef(num1Sub1) + let _ = Memory.decRef(num1Sub1) let combined = bitwiseAndPositive(notNum1Sub1, num2, 2n) // ~(A-1) & B - Memory.decRef(notNum1Sub1) + let _ = Memory.decRef(notNum1Sub1) combined } else { // -A & -B == -((A-1) | (B-1) + 1) @@ -1504,11 +1504,11 @@ provide let bitwiseAnd = (num1: WasmI32, num2: WasmI32) => { let num2Sub1 = decr(num2Neg) let orResult = bitwiseOrPositive(num1Sub1, num2Sub1) let ret = incr(orResult) - Memory.decRef(num1Neg) - Memory.decRef(num2Neg) - Memory.decRef(num1Sub1) - Memory.decRef(num2Sub1) - Memory.decRef(orResult) + let _ = Memory.decRef(num1Neg) + let _ = Memory.decRef(num2Neg) + let _ = Memory.decRef(num1Sub1) + let _ = Memory.decRef(num2Sub1) + let _ = Memory.decRef(orResult) // avoid extra allocation on negate() setFlag(ret, _IS_NEGATIVE, 1n) ret @@ -1529,14 +1529,14 @@ provide let bitwiseOr = (num1: WasmI32, num2: WasmI32) => { // A | -B == -(((B-1) & ~A) + 1) let num2Neg = negate(num2) // B let num2Sub1 = decr(num2Neg) // B-1 - Memory.decRef(num2Neg) + let _ = Memory.decRef(num2Neg) let notNum1 = bitwiseNotUnsigned(num1) // ~A let retSub1 = bitwiseAndPositive(notNum1, num2Sub1, 2n) // (B-1) & ~A - Memory.decRef(num2Sub1) - Memory.decRef(notNum1) + let _ = Memory.decRef(num2Sub1) + let _ = Memory.decRef(notNum1) let ret = incr(retSub1) - Memory.decRef(retSub1) - negateInPlace(ret) + let _ = Memory.decRef(retSub1) + let _ = negateInPlace(ret) ret } } else { @@ -1544,14 +1544,14 @@ provide let bitwiseOr = (num1: WasmI32, num2: WasmI32) => { // A | -B == -(((A-1) & ~B) + 1) let num1Neg = negate(num1) // A let num1Sub1 = decr(num1Neg) // A-1 - Memory.decRef(num1Neg) + let _ = Memory.decRef(num1Neg) let notNum2 = bitwiseNotUnsigned(num2) // ~B let retSub1 = bitwiseAndPositive(num1Sub1, notNum2, 1n) // (A-1) & ~B - Memory.decRef(num1Sub1) - Memory.decRef(notNum2) + let _ = Memory.decRef(num1Sub1) + let _ = Memory.decRef(notNum2) let ret = incr(retSub1) - Memory.decRef(retSub1) - negateInPlace(ret) + let _ = Memory.decRef(retSub1) + let _ = negateInPlace(ret) ret } else { // -A | -B == -((A-1) & (B-1) + 1) @@ -1561,11 +1561,11 @@ provide let bitwiseOr = (num1: WasmI32, num2: WasmI32) => { let num2Sub1 = decr(num2Neg) // (B-1) let andResult = bitwiseAndPositive(num1Sub1, num2Sub1, 0n) // (A-1) & (B-1) let ret = incr(andResult) // ((A-1) & (B-1)) + 1 - Memory.decRef(num1Neg) - Memory.decRef(num2Neg) - Memory.decRef(num1Sub1) - Memory.decRef(num2Sub1) - Memory.decRef(andResult) + let _ = Memory.decRef(num1Neg) + let _ = Memory.decRef(num2Neg) + let _ = Memory.decRef(num1Sub1) + let _ = Memory.decRef(num2Sub1) + let _ = Memory.decRef(andResult) // avoid extra allocation on negate() setFlag(ret, _IS_NEGATIVE, 1n) ret @@ -1586,11 +1586,11 @@ provide let bitwiseXor = (num1: WasmI32, num2: WasmI32) => { // A ^ -B == A ^ (B-1)+1 let num2Neg = negate(num2) // B let num2Sub1 = decr(num2Neg) // B-1 - Memory.decRef(num2Neg) + let _ = Memory.decRef(num2Neg) let retSub1 = bitwiseXorPositive(num2Sub1, num1) // (A^(B-1)) - Memory.decRef(num2Sub1) + let _ = Memory.decRef(num2Sub1) let ret = incr(retSub1) - Memory.decRef(retSub1) + let _ = Memory.decRef(retSub1) // avoid extra allocation on negate() setFlag(ret, _IS_NEGATIVE, 1n) ret @@ -1600,11 +1600,11 @@ provide let bitwiseXor = (num1: WasmI32, num2: WasmI32) => { // -A ^ B == (B^(A-1))+1 let num1Neg = negate(num1) // A let num1Sub1 = decr(num1Neg) // A-1 - Memory.decRef(num1Neg) + let _ = Memory.decRef(num1Neg) let retSub1 = bitwiseXorPositive(num1Sub1, num2) // (B^(A-1)) - Memory.decRef(num1Sub1) + let _ = Memory.decRef(num1Sub1) let ret = incr(retSub1) - Memory.decRef(retSub1) + let _ = Memory.decRef(retSub1) // avoid extra allocation on negate() setFlag(ret, _IS_NEGATIVE, 1n) ret @@ -1615,10 +1615,10 @@ provide let bitwiseXor = (num1: WasmI32, num2: WasmI32) => { let num1Sub1 = decr(num1Neg) let num2Sub1 = decr(num2Neg) let ret = bitwiseXorPositive(num1Sub1, num2Sub1) - Memory.decRef(num1Neg) - Memory.decRef(num2Neg) - Memory.decRef(num1Sub1) - Memory.decRef(num2Sub1) + let _ = Memory.decRef(num1Neg) + let _ = Memory.decRef(num2Neg) + let _ = Memory.decRef(num1Sub1) + let _ = Memory.decRef(num2Sub1) ret } } @@ -1694,8 +1694,8 @@ provide let gcd = (num1: WasmI32, num2: WasmI32) => { let k = minu32(i, j) let mut newu = shrS(u, i) let mut newv = shrS(v, j) - Memory.decRef(u) - Memory.decRef(v) + let _ = Memory.decRef(u) + let _ = Memory.decRef(v) u = newu v = newv while (true) { @@ -1705,13 +1705,13 @@ provide let gcd = (num1: WasmI32, num2: WasmI32) => { u = tmp } newv = sub(v, u) - Memory.decRef(v) + let _ = Memory.decRef(v) v = newv if (eqz(v)) { return shl(u, k) } newv = shrS(v, countTrailingZeroBits(v)) - Memory.decRef(v) + let _ = Memory.decRef(v) v = newv } return 0n @@ -1753,7 +1753,7 @@ let baseCaseDivRem = (a: WasmI32, b: WasmI32, result: WasmI32) => { // (clone for sane reference management) a = clone(aOrig) } - Memory.decRef(bTimesBetaM) + let _ = Memory.decRef(bTimesBetaM) for (let mut j = m - 1n; j >= 0n; j -= 1n) { use WasmI64.{ divU as (/), (|), (<<) } let anjBeta = WasmI64.extendI32U(getHalfLimb(a, n + j)) << 32N // a_{n+j}\beta @@ -1764,17 +1764,17 @@ let baseCaseDivRem = (a: WasmI32, b: WasmI32, result: WasmI32) => { let bTimesBetaJ = shl(b, j * 32n) // b * \beta^j == b * (2^32)^j == b*2^(32*j) let qjWrapped = makeWrappedUint32(qj) let qjTimesBTimesBetaJ = mul(bTimesBetaJ, qjWrapped) - Memory.decRef(qjWrapped) + let _ = Memory.decRef(qjWrapped) let anew = sub(a, qjTimesBTimesBetaJ) - Memory.decRef(a) + let _ = Memory.decRef(a) a = anew while (flagIsSet(a, _IS_NEGATIVE)) { qj -= 1n let anew = add(a, bTimesBetaJ) - Memory.decRef(a) + let _ = Memory.decRef(a) a = anew } - Memory.decRef(bTimesBetaJ) + let _ = Memory.decRef(bTimesBetaJ) setHalfLimb(q, j, qj) } WasmI32.store(result, trimNumberInPlace(q), 0n) // Q := q @@ -1795,11 +1795,11 @@ let baseCaseDivRemUnnormalized = (a: WasmI32, b: WasmI32, result: WasmI32) => { let anew = shl(a, k) let bnew = shl(b, k) baseCaseDivRem(anew, bnew, result) - Memory.decRef(anew) - Memory.decRef(bnew) + let _ = Memory.decRef(anew) + let _ = Memory.decRef(bnew) let rold = WasmI32.load(result, 4n) let rnew = shrS(rold, k) - Memory.decRef(rold) + let _ = Memory.decRef(rold) WasmI32.store(result, rnew, 4n) // R := R' / 2^k } else { baseCaseDivRem(a, b, result) @@ -1849,8 +1849,8 @@ let division = ( let num1abs = abs(num1) let num2abs = abs(num2) baseCaseDivRemUnnormalized(num1abs, num2abs, result) - Memory.decRef(num1abs) - Memory.decRef(num2abs) + let _ = Memory.decRef(num1abs) + let _ = Memory.decRef(num2abs) q = WasmI32.load(result, 0n) r = WasmI32.load(result, 4n) Memory.free(result) @@ -1880,9 +1880,9 @@ let division = ( ) ) { let newr = add(r, num2) - Memory.decRef(r) + let _ = Memory.decRef(r) let newq = decr(q) - Memory.decRef(q) + let _ = Memory.decRef(q) r = newr q = newq } diff --git a/stdlib/runtime/debugPrint.gr b/stdlib/runtime/debugPrint.gr index 194a7d1af..eec9b0a15 100644 --- a/stdlib/runtime/debugPrint.gr +++ b/stdlib/runtime/debugPrint.gr @@ -24,7 +24,7 @@ provide let print = (s: String) => { WasmI32.store8(lf, 10n, 0n) WasmI32.store(iov, lf, 8n) WasmI32.store(iov, 1n, 12n) - fd_write(1n, iov, 2n, written) + let _ = fd_write(1n, iov, 2n, written) Memory.free(buf) void } diff --git a/stdlib/runtime/exception.gr b/stdlib/runtime/exception.gr index e0a35e7fb..cf89ba38d 100644 --- a/stdlib/runtime/exception.gr +++ b/stdlib/runtime/exception.gr @@ -83,7 +83,7 @@ provide let panic = (msg: String) => { WasmI32.store8(lf, 10n, 0n) WasmI32.store(iov, lf, 8n) WasmI32.store(iov, 1n, 12n) - fd_write(2n, iov, 2n, written) + let _ = fd_write(2n, iov, 2n, written) unreachable() } diff --git a/stdlib/runtime/gc.gr b/stdlib/runtime/gc.gr index a9c764ef0..2a09a4895 100644 --- a/stdlib/runtime/gc.gr +++ b/stdlib/runtime/gc.gr @@ -96,7 +96,7 @@ let rec decRef = (userPtr: WasmI32, ignoreZeros: Bool) => { setRefCount(userPtr, refCount) if (WasmI32.eqz(refCount)) { - decRefChildren(userPtr) + let _ = decRefChildren(userPtr) free(userPtr) } diff --git a/stdlib/runtime/numbers.gr b/stdlib/runtime/numbers.gr index fde3e2336..60498383c 100644 --- a/stdlib/runtime/numbers.gr +++ b/stdlib/runtime/numbers.gr @@ -271,7 +271,7 @@ let reducedBigInteger = x => { // the original input is no longer used after // this function returns. let ret = reducedInteger(BI.toInt64(x)) - Memory.decRef(x) + let _ = Memory.decRef(x) ret } else { x @@ -305,23 +305,23 @@ let reducedFractionBigInt = (x, y, keepRational) => { let ret = if (!keepRational && BI.eqz(r)) { // if remainder is zero, then return the quotient. // We decRef the remainder, since we no longer need it - Memory.decRef(r) + let _ = Memory.decRef(r) reducedBigInteger(q) } else { // remainder is nonzero. we don't need the quotient and // remainder anymore, so we discard them. - Memory.decRef(q) - Memory.decRef(r) + let _ = Memory.decRef(q) + let _ = Memory.decRef(r) let factor = BI.gcd(x, y) let xdiv = BI.div(x, factor) let ydiv = BI.div(y, factor) let ret = newRational(xdiv, ydiv) - Memory.decRef(factor) + let _ = Memory.decRef(factor) ret } if (needsDecref) { - Memory.decRef(x) - Memory.decRef(y) + let _ = Memory.decRef(x) + let _ = Memory.decRef(y) void } ret @@ -602,7 +602,7 @@ let coerceNumberToBigInt = (x: Number) => { BI.makeWrappedInt64(boxedInt64Number(xVal)) }, t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => { - Memory.incRef(xVal) + let _ = Memory.incRef(xVal) xVal }, _ => { @@ -890,8 +890,8 @@ let numberAddSubSimpleHelp = (x, y, isSub) => { } else { BI.add(xBig, yBig) } - Memory.decRef(xBig) - Memory.decRef(yBig) + let _ = Memory.decRef(xBig) + let _ = Memory.decRef(yBig) reducedBigInteger(res) } else { reducedInteger(result) @@ -901,7 +901,7 @@ let numberAddSubSimpleHelp = (x, y, isSub) => { // Promote x to bigint and do operation let xBig = BI.makeWrappedInt32(xval) let result = if (isSub) BI.sub(xBig, y) else BI.add(xBig, y) - Memory.decRef(xBig) + let _ = Memory.decRef(xBig) reducedBigInteger(result) }, t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => { @@ -909,14 +909,14 @@ let numberAddSubSimpleHelp = (x, y, isSub) => { let yNumerator = boxedRationalNumerator(y) let yDenominator = boxedRationalDenominator(y) let expandedXNumerator = BI.mul(xBig, yDenominator) - Memory.decRef(xBig) + let _ = Memory.decRef(xBig) let result = if (isSub) BI.sub(expandedXNumerator, yNumerator) else BI.add(expandedXNumerator, yNumerator) let ret = reducedFractionBigInt(result, yDenominator, false) - Memory.decRef(expandedXNumerator) - Memory.decRef(result) + let _ = Memory.decRef(expandedXNumerator) + let _ = Memory.decRef(result) ret }, t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => { @@ -948,8 +948,8 @@ let numberAddSubInt64Help = (xval, y, isSub) => { } else { BI.add(xBig, yBig) } - Memory.decRef(xBig) - Memory.decRef(yBig) + let _ = Memory.decRef(xBig) + let _ = Memory.decRef(yBig) reducedBigInteger(res) } else { reducedInteger(result) @@ -973,8 +973,8 @@ let numberAddSubInt64Help = (xval, y, isSub) => { } else { BI.add(xBig, yBig) } - Memory.decRef(xBig) - Memory.decRef(yBig) + let _ = Memory.decRef(xBig) + let _ = Memory.decRef(yBig) reducedBigInteger(res) } else { reducedInteger(result) @@ -984,7 +984,7 @@ let numberAddSubInt64Help = (xval, y, isSub) => { // Promote x to bigint and do operation let xBig = BI.makeWrappedInt64(xval) let result = if (isSub) BI.sub(xBig, y) else BI.add(xBig, y) - Memory.decRef(xBig) + let _ = Memory.decRef(xBig) reducedBigInteger(result) }, t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => { @@ -992,14 +992,14 @@ let numberAddSubInt64Help = (xval, y, isSub) => { let yNumerator = boxedRationalNumerator(y) let yDenominator = boxedRationalDenominator(y) let expandedXNumerator = BI.mul(xBig, yDenominator) - Memory.decRef(xBig) + let _ = Memory.decRef(xBig) let result = if (isSub) BI.sub(expandedXNumerator, yNumerator) else BI.add(expandedXNumerator, yNumerator) let ret = reducedFractionBigInt(result, yDenominator, false) - Memory.decRef(expandedXNumerator) - Memory.decRef(result) + let _ = Memory.decRef(expandedXNumerator) + let _ = Memory.decRef(result) ret }, t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => { @@ -1020,7 +1020,7 @@ let numberAddSubInt64Help = (xval, y, isSub) => { let numberAddSubFloat64Help = (xval, y, isSub) => { use WasmF64.{ (+), (-) } // incRef y to reuse it via WasmI32.toGrain - Memory.incRef(y) + let _ = Memory.incRef(y) let yval = coerceNumberToWasmF64(WasmI32.toGrain(y): Number) let result = if (isSub) xval - yval else xval + yval newFloat64(result) @@ -1036,7 +1036,7 @@ let numberAddSubBigIntHelp = (x, y, isSub) => { } else { BI.add(x, yBig) } - Memory.decRef(yBig) + let _ = Memory.decRef(yBig) reducedBigInteger(res) } else { let yBoxedNumberTag = boxedNumberTag(y) @@ -1049,7 +1049,7 @@ let numberAddSubBigIntHelp = (x, y, isSub) => { } else { BI.add(x, yBig) } - Memory.decRef(yBig) + let _ = Memory.decRef(yBig) reducedBigInteger(res) }, t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => { @@ -1068,9 +1068,9 @@ let numberAddSubBigIntHelp = (x, y, isSub) => { BI.sub(expandedXNumerator, yNumerator) else BI.add(expandedXNumerator, yNumerator) - Memory.decRef(expandedXNumerator) + let _ = Memory.decRef(expandedXNumerator) let ret = reducedFractionBigInt(result, yDenominator, false) - Memory.decRef(result) + let _ = Memory.decRef(result) ret }, t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => { @@ -1099,7 +1099,7 @@ provide let addSubRational = (x, y, isSub, keepRational) => { else BI.add(xNumerator, yNumerator) let ret = reducedFractionBigInt(newNumerator, xDenominator, keepRational) - Memory.decRef(newNumerator) + let _ = Memory.decRef(newNumerator) ret } else { let numerator1 = BI.mul(xNumerator, yDenominator) @@ -1110,9 +1110,9 @@ provide let addSubRational = (x, y, isSub, keepRational) => { BI.add(numerator1, numerator2) let denominator = BI.mul(xDenominator, yDenominator) let ret = reducedFractionBigInt(numerator, denominator, keepRational) - Memory.decRef(numerator1) - Memory.decRef(numerator2) - Memory.decRef(numerator) + let _ = Memory.decRef(numerator1) + let _ = Memory.decRef(numerator2) + let _ = Memory.decRef(numerator) ret } } @@ -1182,7 +1182,7 @@ provide let rationalNumerator = (x: Rational) => { let xVal = WasmI32.fromGrain(x) let num = boxedRationalNumerator(xVal) ignore(x) - Memory.incRef(num) + let _ = Memory.incRef(num) WasmI32.toGrain(reducedBigInteger(num)): Number } @@ -1199,7 +1199,7 @@ provide let rationalDenominator = (x: Rational) => { let xVal = WasmI32.fromGrain(x) let num = boxedRationalDenominator(xVal) ignore(x) - Memory.incRef(num) + let _ = Memory.incRef(num) WasmI32.toGrain(reducedBigInteger(num)): Number } @@ -1215,10 +1215,10 @@ let numberAddSubRationalHelp = (x, y, isSub) => { BI.sub(xNumerator, expandedYNumerator) else BI.add(xNumerator, expandedYNumerator) - Memory.decRef(expandedYNumerator) - Memory.decRef(yBig) + let _ = Memory.decRef(expandedYNumerator) + let _ = Memory.decRef(yBig) let ret = reducedFractionBigInt(result, xDenominator, false) - Memory.decRef(result) + let _ = Memory.decRef(result) ret } else { let ytag = boxedNumberTag(y) @@ -1230,14 +1230,14 @@ let numberAddSubRationalHelp = (x, y, isSub) => { t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => { let yBig = BI.makeWrappedInt64(boxedInt64Number(y)) let expandedYNumerator = BI.mul(yBig, xDenominator) - Memory.decRef(yBig) + let _ = Memory.decRef(yBig) let result = if (isSub) BI.sub(xNumerator, expandedYNumerator) else BI.add(xNumerator, expandedYNumerator) let ret = reducedFractionBigInt(result, xDenominator, false) - Memory.decRef(expandedYNumerator) - Memory.decRef(result) + let _ = Memory.decRef(expandedYNumerator) + let _ = Memory.decRef(result) ret }, t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => { @@ -1246,9 +1246,9 @@ let numberAddSubRationalHelp = (x, y, isSub) => { BI.sub(xNumerator, expandedYNumerator) else BI.add(xNumerator, expandedYNumerator) - Memory.decRef(expandedYNumerator) + let _ = Memory.decRef(expandedYNumerator) let ret = reducedFractionBigInt(result, xDenominator, false) - Memory.decRef(result) + let _ = Memory.decRef(result) ret }, t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => { @@ -1318,8 +1318,8 @@ let safeI64Multiply = (x, y) => { let xBig = BI.makeWrappedInt64(x) let yBig = BI.makeWrappedInt64(y) let result = BI.mul(xBig, yBig) - Memory.decRef(xBig) - Memory.decRef(yBig) + let _ = Memory.decRef(xBig) + let _ = Memory.decRef(yBig) result } else { reducedInteger(prod) @@ -1355,7 +1355,7 @@ let numberTimesDivideInt64Help = (xval, y, isDivide) => { } else { reducedBigInteger(BI.mul(xBig, y)) } - Memory.decRef(xBig) + let _ = Memory.decRef(xBig) ret }, t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => { @@ -1366,16 +1366,16 @@ let numberTimesDivideInt64Help = (xval, y, isDivide) => { // x / (a / b) == (x * b) / a let numerator = BI.mul(xBig, yDenominator) let ret = reducedFractionBigInt(numerator, yNumerator, false) - Memory.decRef(numerator) + let _ = Memory.decRef(numerator) ret } else { // x * (a / b) == (x * a) / b let numerator = BI.mul(xBig, yNumerator) let ret = reducedFractionBigInt(numerator, yDenominator, false) - Memory.decRef(numerator) + let _ = Memory.decRef(numerator) ret } - Memory.decRef(xBig) + let _ = Memory.decRef(xBig) ret }, t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => { @@ -1404,7 +1404,7 @@ let numberTimesDivideBigIntHelp = (x, y, isDivide) => { } else { reducedBigInteger(BI.mul(x, yBig)) } - Memory.decRef(yBig) + let _ = Memory.decRef(yBig) ret } else { let yBoxedNumberTag = boxedNumberTag(y) @@ -1417,7 +1417,7 @@ let numberTimesDivideBigIntHelp = (x, y, isDivide) => { } else { reducedBigInteger(BI.mul(x, yBig)) } - Memory.decRef(yBig) + let _ = Memory.decRef(yBig) ret }, t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => { @@ -1434,13 +1434,13 @@ let numberTimesDivideBigIntHelp = (x, y, isDivide) => { // x / (a / b) == (x * b) / a let numerator = BI.mul(x, yDenominator) let ret = reducedFractionBigInt(numerator, yNumerator, false) - Memory.decRef(numerator) + let _ = Memory.decRef(numerator) ret } else { // x * (a / b) == (x * a) / b let numerator = BI.mul(x, yNumerator) let ret = reducedFractionBigInt(numerator, yDenominator, false) - Memory.decRef(numerator) + let _ = Memory.decRef(numerator) ret } }, @@ -1480,17 +1480,17 @@ let numberTimesDivideRationalHelp = (x, y, isDivide) => { // (a / b) / y == a / (b * y) let denominator = BI.mul(xDenominator, yBig) let ret = reducedFractionBigInt(xNumerator, denominator, false) - Memory.decRef(denominator) + let _ = Memory.decRef(denominator) ret } else { // (a / b) * y == (a * y) / b let numerator = BI.mul(xNumerator, yBig) let ret = reducedFractionBigInt(numerator, xDenominator, false) - Memory.decRef(numerator) + let _ = Memory.decRef(numerator) ret } if (yBig != ret) { - Memory.decRef(yBig) + let _ = Memory.decRef(yBig) void } ret @@ -1504,16 +1504,16 @@ let numberTimesDivideRationalHelp = (x, y, isDivide) => { // (a / b) / y == a / (b * y) let denominator = BI.mul(xDenominator, yBig) let ret = reducedFractionBigInt(xNumerator, denominator, false) - Memory.decRef(denominator) + let _ = Memory.decRef(denominator) ret } else { // (a / b) * y == (a * y) / b let numerator = BI.mul(xNumerator, yBig) let ret = reducedFractionBigInt(numerator, xDenominator, false) - Memory.decRef(numerator) + let _ = Memory.decRef(numerator) ret } - Memory.decRef(yBig) + let _ = Memory.decRef(yBig) ret }, t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => { @@ -1521,13 +1521,13 @@ let numberTimesDivideRationalHelp = (x, y, isDivide) => { // (a / b) / y == a / (b * y) let denominator = BI.mul(xDenominator, y) let ret = reducedFractionBigInt(xNumerator, denominator, false) - Memory.decRef(denominator) + let _ = Memory.decRef(denominator) ret } else { // (a / b) * y == (a * y) / b let numerator = BI.mul(xNumerator, y) let ret = reducedFractionBigInt(numerator, xDenominator, false) - Memory.decRef(numerator) + let _ = Memory.decRef(numerator) ret } }, @@ -1555,7 +1555,7 @@ let numberTimesDivideRationalHelp = (x, y, isDivide) => { let numberTimesDivideFloat64Help = (x, y, isDivide) => { use WasmF64.{ (/), (*) } // incRef y to reuse it via WasmI32.toGrain - Memory.incRef(y) + let _ = Memory.incRef(y) let yAsFloat = coerceNumberToWasmF64(WasmI32.toGrain(y): Number) if (isDivide) { newFloat64(x / yAsFloat) @@ -1615,8 +1615,8 @@ let i64abs = x => { let numberMod = (x, y) => { use WasmI64.{ (!=), (-), (*), (<), (>) } // incRef x and y to reuse them via WasmI32.toGrain - Memory.incRef(x) - Memory.incRef(y) + let _ = Memory.incRef(x) + let _ = Memory.incRef(y) if (isFloat(x) || isFloat(y) || isRational(x) || isRational(y)) { use WasmF64.{ (==), (/), (*), (-) } let xval = coerceNumberToWasmF64(WasmI32.toGrain(x): Number) @@ -1681,7 +1681,7 @@ let cmpBigInt = (x: WasmI32, y: WasmI32) => { t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => { let tmp = BI.mul(x, boxedRationalDenominator(y)) let ret = BI.cmp(tmp, boxedRationalNumerator(y)) - Memory.decRef(tmp) + let _ = Memory.decRef(tmp) ret }, t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => { @@ -2131,11 +2131,11 @@ provide let (&) = (value1: Number, value2: Number) => { let ret = WasmI32.toGrain(reducedBigInteger(BI.bitwiseAnd(xval, yval))): Number if (!(xw32 == xval)) { - Memory.decRef(xval) + let _ = Memory.decRef(xval) void } if (!(yw32 == yval)) { - Memory.decRef(yval) + let _ = Memory.decRef(yval) void } ret @@ -2171,11 +2171,11 @@ provide let (|) = (value1: Number, value2: Number) => { let ret = WasmI32.toGrain(reducedBigInteger(BI.bitwiseOr(xval, yval))): Number if (!(xw32 == xval)) { - Memory.decRef(xval) + let _ = Memory.decRef(xval) void } if (!(yw32 == yval)) { - Memory.decRef(yval) + let _ = Memory.decRef(yval) void } ret @@ -2212,11 +2212,11 @@ provide let (^) = (value1: Number, value2: Number) => { let ret = WasmI32.toGrain(reducedBigInteger(BI.bitwiseXor(xval, yval))): Number if (!(xw32 == xval)) { - Memory.decRef(xval) + let _ = Memory.decRef(xval) void } if (!(yw32 == yval)) { - Memory.decRef(yval) + let _ = Memory.decRef(yval) void } ret @@ -2430,11 +2430,11 @@ provide let coerceNumberToInt64 = (number: Number) => { boxedNumberTag(x) == Tags._GRAIN_INT64_BOXED_NUM_TAG ) { // avoid extra malloc and prevent x from being freed - Memory.incRef(x) + let _ = Memory.incRef(x) x } else { // incRef x to reuse it via WasmI32.toGrain - Memory.incRef(x) + let _ = Memory.incRef(x) newInt64(coerceNumberToWasmI64(WasmI32.toGrain(x): Number)) } ignore(number) @@ -2471,11 +2471,11 @@ provide let coerceNumberToRational = (number: Number) => { let tag = boxedNumberTag(x) if (tag == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) { // avoid extra malloc and prevent x from being freed - Memory.incRef(x) + let _ = Memory.incRef(x) x } else if (tag == Tags._GRAIN_INT64_BOXED_NUM_TAG) { // incRef x to reuse it via WasmI32.toGrain - Memory.incRef(x) + let _ = Memory.incRef(x) newRational( BI.makeWrappedInt32(coerceNumberToWasmI32(WasmI32.toGrain(x): Number)), BI.makeWrappedInt32(1n) @@ -2518,11 +2518,11 @@ provide let coerceNumberToFloat64 = (number: Number) => { boxedNumberTag(x) == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG ) { // avoid extra malloc and prevent x from being freed - Memory.incRef(x) + let _ = Memory.incRef(x) x } else { // incRef x to reuse it via WasmI32.toGrain - Memory.incRef(x) + let _ = Memory.incRef(x) newFloat64(coerceNumberToWasmF64(WasmI32.toGrain(x): Number)) } ignore(number) @@ -2630,7 +2630,7 @@ provide let coerceBigIntToNumber = (num: BigInt) => { let x = WasmI32.fromGrain(num) // reducedBigInteger assumes that the bigint is dead, // but in our case, it is not - Memory.incRef(x) + let _ = Memory.incRef(x) let result = WasmI32.toGrain(reducedBigInteger(x)): Number ignore(num) result @@ -2654,7 +2654,7 @@ provide let coerceRationalToNumber = (rational: Rational) => { x } // incRef x to reuse it via WasmI32.toGrain - Memory.incRef(x) + let _ = Memory.incRef(x) let result = WasmI32.toGrain(x): Number ignore(rational) result @@ -2689,7 +2689,7 @@ provide let coerceFloat32ToNumber = (float: Float32) => { provide let coerceFloat64ToNumber = (float: Float64) => { let x = WasmI32.fromGrain(float) // incRef x to reuse it via WasmI32.toGrain - Memory.incRef(x) + let _ = Memory.incRef(x) let result = WasmI32.toGrain(x): Number ignore(float) result @@ -2713,7 +2713,7 @@ let convertInexactToExactHelp = x => { tag == Tags._GRAIN_BIGINT_BOXED_NUM_TAG || tag == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG ) { - Memory.incRef(x) + let _ = Memory.incRef(x) x } else { match (tag) { @@ -2959,11 +2959,11 @@ provide let (**) = (base, power) => { } else if (isRational(basePtr) && isInteger(powerPtr)) { // Apply expBySquaring to numerator and denominator let numerator = WasmI32.fromGrain(base) - Memory.incRef(numerator) + let _ = Memory.incRef(numerator) let numerator = WasmI32.toGrain(numerator): Rational let numerator = rationalNumerator(numerator) let denominator = WasmI32.fromGrain(base) - Memory.incRef(denominator) + let _ = Memory.incRef(denominator) let denominator = WasmI32.toGrain(denominator): Rational let denominator = rationalDenominator(denominator) let numerator = if (power < 0) diff --git a/stdlib/runtime/string.gr b/stdlib/runtime/string.gr index 630df2128..2e14e5beb 100644 --- a/stdlib/runtime/string.gr +++ b/stdlib/runtime/string.gr @@ -195,7 +195,7 @@ let getFieldArray = (fields, arity) => { for (let mut i = 0n; i < arity; i += 1n) { let fieldLength = WasmI32.load(fields + fieldOffset, 4n) let fieldName = allocateString(fieldLength) - Memory.incRef(fieldName) + let _ = Memory.incRef(fieldName) Memory.copy(fieldName + 8n, fields + fieldOffset + 8n, fieldLength) WasmI32.store(fieldArray + i * 4n, fieldName, 8n) @@ -451,7 +451,7 @@ let rec heapValueToString = (ptr, extraIndents, toplevel, cycles) => { match (tag) { t when t == Tags._GRAIN_STRING_HEAP_TAG => { // In both cases, we incRef ptr so we can use it again via WasmI32.toGrain - Memory.incRef(ptr) + let _ = Memory.incRef(ptr) if (toplevel) { WasmI32.toGrain(ptr): String } else { @@ -534,7 +534,7 @@ let rec heapValueToString = (ptr, extraIndents, toplevel, cycles) => { extraIndents, cycles ) - Memory.decRef(recordVariantFields) + let _ = Memory.decRef(recordVariantFields) let strings = [variantName, recordString] join(strings) @@ -562,7 +562,7 @@ let rec heapValueToString = (ptr, extraIndents, toplevel, cycles) => { extraIndents, cycles ) - Memory.decRef(fields) + let _ = Memory.decRef(fields) WasmI32.store(ptr, recordArity, 12n) join([cyclePrefix(ptr, cycles), result]) } @@ -656,7 +656,7 @@ let rec heapValueToString = (ptr, extraIndents, toplevel, cycles) => { } WasmI32.store(ptr, tupleLength, 4n) - Memory.incRef(WasmI32.fromGrain(strings)) + let _ = Memory.incRef(WasmI32.fromGrain(strings)) strings = [lparen, ...strings] if (tupleLength <= 1n) { // Special case: unary tuple, which is not valid Grain syntax; however, boxed values @@ -872,7 +872,7 @@ provide let print = (value, suffix="\n") => { let written = buf + 16n WasmI32.store(iov, ptr + 8n, 0n) WasmI32.store(iov, WasmI32.load(ptr, 4n), 4n) - fd_write(1n, iov, 1n, written) + let _ = fd_write(1n, iov, 1n, written) Memory.free(buf) ignore(value) ignore(suffix) diff --git a/stdlib/runtime/utils/printing.gr b/stdlib/runtime/utils/printing.gr index 96b267a9c..fba0d17bf 100644 --- a/stdlib/runtime/utils/printing.gr +++ b/stdlib/runtime/utils/printing.gr @@ -32,7 +32,7 @@ provide let printNumber = (n: WasmI64) => { WasmI32.store8(lf, 10n, 0n) WasmI32.store(iov, lf, 8n) WasmI32.store(iov, 1n, 12n) - fd_write(1n, iov, 2n, written) + let _ = fd_write(1n, iov, 2n, written) Memory.free(buf) void } @@ -54,7 +54,7 @@ provide let printString = (s: String) => { WasmI32.store8(lf, 10n, 0n) WasmI32.store(iov, lf, 8n) WasmI32.store(iov, 1n, 12n) - fd_write(1n, iov, 2n, written) + let _ = fd_write(1n, iov, 2n, written) Memory.free(buf) void }