It appears to me that we're respecting ShouldThrowOnError from V8, which says:

   * \note Always `false` when intercepting `Reflect.set()`
   * independent of the language mode.

which is why we're not throwing. +some V8 folk to comment on whether this is the right thing

 - navigator.mimeTypes manifests the same issue. Any other object that throws a `TypeError` with message `Failed to set an indexed property on '....': Index property setter is not supported.` may be affected by this issue.

 - Such objects seem to not be complying to spec with respect to `Reflect.defineProperty` as well.
   `Object.defineProperty(window, '0', { value: {}, configurable: true})` throws, but
   `Reflect.defineProperty(window, '0', { value: {}, configurable: true})` returns `true. 

From reading the spec, I agree with the OP. We should return false for the `Reflect.set` case. Similar to how module namespace objects work:
https://cs.chromium.org/chromium/src/v8/src/accessors.cc?l=258-265&rcl=20425a75e22b7a9b632bb1073393a2bee3cba7b8

I suspect this requires a fix in the bindings code and not V8.

The issue seems to be related to ECMA262 Specification which is out of TE-scope. Hence, adding label TE-NeedsTriageHelp for further investigation from dev team.

Thanks...!!

#6: Which should return false; Reflect.set or ShouldThrowOnError?

The bindings is respecting V8's ShouldThrowOnError, just as ModuleNamespaceEntrySetter is.

#9: The PropertyCallbackInfo::GetReturnValue of the accessor should be set to false. Is this already the case?

Re #10: Is it the V8 API specification?

v8/include/v8.h says:

/**
 * See `v8::GenericNamedPropertySetterCallback`.
 */
typedef void (*IndexedPropertySetterCallback)(
    uint32_t index,
    Local<Value> value,
    const PropertyCallbackInfo<Value>& info);

and GenericNamedPropertySetterCallback says:

/**
 * Interceptor for set requests on an object.
 *
 * Use `info.GetReturnValue()` to indicate whether the request was intercepted
 * or not. If the setter successfully intercepts the request, i.e., if the
 * request should not be further executed, call
 * `info.GetReturnValue().Set(value)`. If the setter
 * did not intercept the request, i.e., if the request should be handled as
 * if no interceptor is present, do not not call `Set()`.
 *
 * \param property The name of the property for which the request was
 * intercepted.
 * \param value The value which the property will have if the request
 * is not intercepted.
 * \param info Information about the intercepted request, such as
 * isolate, receiver, return value, or whether running in `'use strict'` mode.
 * See `PropertyCallbackInfo`.
 *
 * See also
 * `ObjectTemplate::SetHandler.`
 */
typedef void (*GenericNamedPropertySetterCallback)(
    Local<Name> property, Local<Value> value,
    const PropertyCallbackInfo<Value>& info);

By the way, NamedPropertySetterCallback says:

/**
 * Returns the value if the setter intercepts the request.
 * Otherwise, returns an empty handle.
 */
typedef void (*NamedPropertySetterCallback)(
    Local<String> property,
    Local<Value> value,
    const PropertyCallbackInfo<Value>& info);

As far as I can tell from v8.h, there is no such contract for the embedder to return v8::True or v8::False.  My understanding has been "whether non-empty handle or empty handle matters, and nothing else matters (or it's recommended to return the value being set)".  If it's necessary to return v8::True or v8::False, then I'm happy to change Blink implementation.

I'd like V8 team to clarify the API specification first.  Then, we'll follow it.

Yang, WDYT?

If a return value is set, V8 ignores it and returns true.
if no return value is set, V8 returns false.

See https://cs.chromium.org/chromium/src/v8/src/objects.cc?sq=package:chromium&q=objects.cc+file:%5Esrc/v8/+package:%5Echromium$&g=0&l=1835

We could change V8 to respect the return value (and enforce it to be boolean), see the TODO in the code. I've made a similar change before at
https://codereview.chromium.org/2397603003. Not sure how much work it would be.

The quick fix is to change the setters in question such that they don't set a return value in the error case.