Skip to content

Order of operations, when to throw or silently do nothing? #16

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
Tracked by #1
erights opened this issue Dec 1, 2024 · 2 comments
Open
Tracked by #1

Order of operations, when to throw or silently do nothing? #16

erights opened this issue Dec 1, 2024 · 2 comments

Comments

@erights
Copy link
Collaborator

erights commented Dec 1, 2024

  • Should sliceToImmutable with reversed start and end throw an exception even though slice with the same arguments would not?

  • Should trying to write data in an immutable ArrayBuffer via a TypedArray element set throw, even though trying to write out-of-bounds or to a detached ArrayBuffer does not?

  • Should TypedArray write methods (copyWithin, fill, reverse, set, etc.) throw when their backing ArrayBuffer is immutable but the targeted range is zero-length? If so, how early or late in the algorithm? The methods currently inspect arguments after ValidateTypedArray.

Similarly,

  • How early or late in SetViewValue against an immutable ArrayBuffer should an exception be thrown? It currently inspects arguments before IsViewOutOfBounds.

  • Likewise for abstract operations such as ArrayBufferCopyAndDetach (which currently checks IsSharedArrayBuffer, then newLength, then IsDetachedBuffer).

  • And also for Atomics functions.

@erights
Copy link
Collaborator Author

erights commented Dec 1, 2024

To be driven by implementor feedback.

But my general inclination is: when in doubt, throw.

Moddable XS implementation throws.

Looking for further implementation feedback, both regarding throwing, and any other observable order-of-operation questions.

@erights erights mentioned this issue Dec 5, 2024
45 tasks
@ljharb ljharb mentioned this issue Jan 10, 2025
8 tasks
erights added a commit to endojs/endo that referenced this issue Jan 13, 2025
Closes: tc39/proposal-immutable-arraybuffer#26
Refs: https://github.com/tc39/proposal-immutable-arraybuffer
tc39/proposal-immutable-arraybuffer#15
tc39/proposal-immutable-arraybuffer#9
tc39/proposal-immutable-arraybuffer#16

## Description

Since the last work on this immutable-arraybuffer shim, at the tc39
plenary we decided that
- `transferToImmutable` should take an optional `newLength` parameter,
to stay parallel to the other `transfer*` methods.
- The `sliceToImmutable` method should be added.

The spec at https://github.com/tc39/proposal-immutable-arraybuffer and
the Moddable XS implementation both already reflect these changes. This
PR brings this shim up to date with those changes, closing
tc39/proposal-immutable-arraybuffer#26

### Security Considerations

none

### Scaling Considerations

none

### Documentation Considerations

The proposal's draft spec has already been updated.

### Testing Considerations

New tests lightly test the new functionality. The code and tests may
differ from the current draft spec on order of operations and errors
thrown. But since these issues are purposely still open
tc39/proposal-immutable-arraybuffer#16 , this
divergence is not yet a big deal.

### Compatibility Considerations

No more than the baseline shim already on master.

### Upgrade Considerations

No production code yet depends on this shim. So, none.
@gibson042
Copy link
Collaborator

Tentative resolutions as reflected in spec text and testing plan as of 2025-05-29:

Should sliceToImmutable with reversed start and end throw an exception even though slice with the same arguments would not?

No

9. Let _newLen_ be max(_final_ - _first_, 0).

Should trying to write data in an immutable ArrayBuffer via a TypedArray element set throw, even though trying to write out-of-bounds or to a detached ArrayBuffer does not?

Yes.

1.b.ii. If IsImmutableBuffer(_O_.[[ViewedArrayBuffer]]) is *true*, return *false*.

Should TypedArray write methods (copyWithin, fill, reverse, set, etc.) throw when their backing ArrayBuffer is immutable but the targeted range is zero-length? If so, how early or late in the algorithm? The methods currently inspect arguments after ValidateTypedArray.

Yes, before touching arguments.

2. Let _taRecord_ be ? ValidateTypedArray(_O_, ~seq-cst~, ~write~).

How early or late in SetViewValue against an immutable ArrayBuffer should an exception be thrown? It currently inspects arguments before IsViewOutOfBounds.

Immediately after validating the receiver as a DataView.

3. If IsImmutableBuffer(_view_.[[ViewedArrayBuffer]]) is *true*, throw a *TypeError* exception.

Likewise for abstract operations such as ArrayBufferCopyAndDetach (which currently checks IsSharedArrayBuffer, then newLength, then IsDetachedBuffer).

ArrayBufferCopyAndDetach affects ArrayBuffer.prototype.{transfer,transferToFixedLength,transferToImmutable}, and this is indeed awkward. The mutability check immediately follows the non-detachment check.

6. If IsImmutableBuffer(_arrayBuffer_) is *true*, throw a *TypeError* exception.

And also for Atomics functions.

The first throwable step of AtomicReadModifyWrite and sibling algorithms in Atomics.compareExchange and Atomics.store is ValidateAtomicAccessOnIntegerTypedArray with accessMode=~write~, whose own first throwable step is RequireInternalSlot(O, [[TypedArrayName]]) in ValidateTypedArray. And the mutability check immediately follows.

4. If _accessMode_ is ~write~ and IsImmutableBuffer(_O_.[[ViewedArrayBuffer]]) is *true*, throw a *TypeError* exception.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests

2 participants