Remove all user-space asUint/toUint in the libraries. #5194
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
7d70ace to
509e955
Compare
|
|
gzm0
requested changes
Jun 15, 2025
| } | ||
|
|
||
| newTree match { | ||
| // Unless both arguments are (convertible to) bigint's, | always returns an Int |
There was a problem hiding this comment.
The "(convertible to)" feels confusing here. At least node seems to disallow any implicitness here:
> 1n | 1
Uncaught TypeError: Cannot mix BigInt and other types, use explicit conversions
> 1n | "1"
Uncaught TypeError: Cannot mix BigInt and other types, use explicit conversions
I assume this is specified?
Maybe also add "| always returns an Int or throws".
There was a problem hiding this comment.
I elaborated the comment. Primitive numbers cannot be mixed in this way, but objects with a valueOf() method returning a bigint can be converted to bigints.
gzm0
approved these changes
Jun 21, 2025
| /* Unless it throws, `x | y` returns either a signed 32-bit integer | ||
| * (an `Int`) or a bigint. | ||
| * | ||
| * The only case in which it returns it bigint is when both arguments |
There was a problem hiding this comment.
Suggested change
| * The only case in which it returns it bigint is when both arguments | |
| * The only case in which it returns a bigint is when both arguments |
We use these in some low-level routines, notably in `RuntimeLong`. Introducing casts avoids unnecessary `AsInstanceOf`s around them.
Its implementation is shorter than many of the methods we already inline, like additions and multiplications. We do pay a little code size cost for this change. This will be particularly useful for the following commit, which will rely on folding to happen within `toDouble`, once inlined at call site.
Instead, we use `Integer.toUnsignedLong(x).toDouble`, which is semantically equivalent. The only remaining use of `x >>> 0` is in the JS-only runtime libraries, notably `RuntimeLong`. We add some optimizations to generate the best possible code on all targets. For JS with `RuntimeLong`, we need a tailored rewrite in the optimizer to get rid of a `Double` addition of `0.0 + y` when `y` is provably non-negative. This shape comes from inlining `RuntimeLong.toDouble`. For JS with `bigint`s, we directly fold `(double) <toLongUnsigned>(x)` into `x >>> 0`. Otherwise, we unnecessarily go through a `bigint` with `Number(BigInt(x >>> 0))`. For Wasm, we fold the same shape into a single operation `f64.convert_i32_u`, which we add in `WasmTransients`. Overall, this has no real impact on the JS target. However, it removes two round-trips from Wasm to JS. Previously, we needed to call a helper function to do the `x >>> 0`, then call the `$uD` helper to retrieve the result. Now, the same operations stays entirely within Wasm.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Instead, we use
Integer.toUnsignedLong(x).toDouble, which is semantically equivalent. The only remaining use ofx >>> 0is in the JS-only runtime libraries, notablyRuntimeLong.We add some optimizations to generate the best possible code on all targets.
For JS with
RuntimeLong, we need to markRuntimeLong.toDoubleas fully inline. That is fine, as its body is actually very short (shorter than most methods ofRuntimeLong). Moreover, we need a tailored rewrite in the optimizer to get rid of aDoubleaddition of0.0 + ywhenyis provably non-negative.For JS with
bigints, we directly fold(double) <toLongUnsigned>(x)intox >>> 0. Otherwise, we unnecessarily go through abigintwithNumber(BigInt(x >>> 0)).For Wasm, we fold the same shape into a single operation
f64.convert_i32_u, which we add inWasmTransients.Overall, this has no real impact on the JS target. However, it removes two round-trips from Wasm to JS. Previously, we needed to call a helper function to do the
x >>> 0, then call the$uDhelper to retrieve the result. Now, the same operations stays entirely within Wasm.