Add extends = ... attributes to js-sys types

[fitzgen]

We should add all the inheritance relations for global JS types to js-sys.

We can use this snippet of JS to log the prototype chain for something, eg Uint8Array:

function logPrototypeChain(cls) {
  let obj = cls.prototype;
  do {
    console.log(obj.constructor.name);
    obj = obj.__proto__;
  } while (obj != null);
}

logPrototypeChain(Uint8Array);

Pasting that snippet in a browser's devtools console logs:

Uint8Array
TypedArray
Object

So we would add #[wasm_bindgen(extends = Object, extends = TypedArray) to Uint8Array's import definition and a corresponding test to the appropriate file in crates/js-sys/tests/.. like:

use wasm_bindgen::JsCast;

#[wasm_bindgen_test]
fn test_blah_inheritance() {
    let blah = js_sys::Blah::new(); // its constructor might require different args

    // Assert JS actually agrees with our set of base classes.
    assert!(blah.is_instance_of::<Blah>());
    assert!(blah.is_instance_of::<BlahBase>());
    // etc for each base class...
    assert!(blah.is_instance_of::<js_sys::Object>());

    // Ensure that we generated the appropriate `AsRef` upcasting implementations
    // for each base class.
    let _: &BlahBase = blah.as_ref();
    // etc for each base class...
    let _: &js_sys::Object = blah.as_ref();
}

Here is an example PR for the RegExp type: #671

See also js-sys contributing documentation: https://rustwasm.github.io/wasm-bindgen/js-sys.html

---

Here are all the JS global import types for which we need to add this information:

• Array
• ArrayBuffer
• Boolean
• DataView
• Date
• Error
• EvalError
• Float32Array
• Float64Array
• Function
• Generator
• Int16Array
• Int32Array
• Int8Array
• Intl.Collator
• Intl.DateTimeFormat
• Intl.NumberFormat
• Intl.PluralRules
• JSON
• Map
• Math
• Number
• Promise
• RangeError
• ReferenceError
• Reflect
• RegExp
• Set
• String
• Symbol
• SyntaxError
• TypeError
• TypedArray
• URIError
• Uint16Array
• Uint32Array
• Uint8Array
• Uint8ClampedArray
• WeakMap
• WeakSet
• WebAssembly.Module
• WebAssembly.Instance
• WebAssembly.Table
• WebAssembly.Memory

[fitzgen]

Here is an example of adding extends to the RegExp type: #671

[kraai]

It seems like the extends attribute isn't necessary for Promise. The following test passes without any changes to lib.rs:

use wasm_bindgen_test::*;                                                       
use wasm_bindgen::JsCast;                                                       
use js_sys::*;                                                                  
                                                                                
#[wasm_bindgen_test]                                                            
fn test_promise_inheritance() {                                                 
    let promise = Promise::new(&mut |_, _| ());                                 
    assert!(promise.is_instance_of::<Promise>());                               
    assert!(promise.is_instance_of::<Object>());                                 
}                                                                               

Should it be marked as complete, should the test be added, or should the extends attribute and test be added anyway?

[fitzgen]

Good catch! The example test I provided only tests the dynamic JS behavior with instanceof, which doesn't exercise the code emitted by extends = ... at all :-p Instead we should do something like this:

#[wasm_bindgen_test]
fn test_promise_inheritance() {
    let promise = Promise::new(&mut |_, _| ());

    // Assert that JS matches our inheritance hierarchy.
    assert!(promise.is_instance_of::<Promise>());
    assert!(promise.is_instance_of::<Object>());

    // Ensure that we emitted the appropriate `AsRef` implementations for each base class.
    let _: &Object = promise.as_ref();
}

That bottom bit is the new bits, and that should fail to compile without the extends = ... attributes!