Create readonly property from constructor argument in custom class?

[tomoverlund]

What I'm trying to do is start with something like the classes example:

struct Person {
    /// The name of the person.
    name: JsString,
    /// The age of the person.
    age: u32,
}

But have, for example, the name field be a readonly property set during construction:
let person = new Person('John', 19);

The Person example has code to set a readonly property:

fn init(class: &mut ClassBuilder<'_>) -> JsResult<()> {
        [..]
        // We add an `"inheritedProperty"` property to the prototype of `Person` with
        // a value of `10` and default attribute flags `READONLY`, `NON_ENUMERABLE` and `PERMANENT`.
        class.property(js_string!("inheritedProperty"), 10, Attribute::default());

But that's using a hardcoded value, whereas I want the value from the constructor (like 'John' above).

Based on a previous discussion and example code from the docs, I tried the following:

    fn object_constructor(
        instance: &JsObject,
        args: &[JsValue],
        context: &mut Context,
    ) -> JsResult<()> {
        let name = args.get_or_undefined(0).to_string(context)?;

        // Roughly equivalent to `this.name = String(name)`.                                                                                                                 
        instance.set(js_string!("name"), name, true, context)?;

        Ok(())
    }

This results in a JavaScript runtime error: "cannot set non-writable property: name"

If I comment out the class.property() line from init(), it works, but then the name property isn't readonly.

[HalidOdat]

Hi @tomoverlund 👋

Instead of using .set() which has implicit writable use the .define_own_property_or_throw(), with a PropertyDescriptor (here is an example usage of it

boa/core/engine/src/object/operations.rs

Lines 235 to 243 in 3700a94

	let new_desc = PropertyDescriptorBuilder::new()
	.value(value)
	.writable(true)
	.enumerable(false)
	.configurable(true)
	.build();
	// 3. Perform ! DefinePropertyOrThrow(O, P, newDesc).
	self.define_property_or_throw(key, new_desc, context)

, you just need to change the writable to be false and that should do it 😄 )

NOTE: You don't need class.property for that property, what class.property does is install the property in the class_name.prototype.property_name so every instance can access that property from the property chain.

Hope that helps :)

[tomoverlund]

Thanks for your answer. It seems to be working, except one surprise is that if I try to change the property in JavaScript, it silently ignores it, whereas before it was giving a runtime exception.

This is what I changed the code to:

    fn object_constructor(
        instance: &JsObject,
        args: &[JsValue],
        context: &mut Context,
    ) -> JsResult<()> {
        let name = args.get_or_undefined(0).to_string(context)?;

        let new_desc = PropertyDescriptorBuilder::new()
            .value(name)
            .writable(false)
            .enumerable(false)
            .configurable(true)
            .build();

        instance.define_property_or_throw(js_string!("name"), new_desc, context);

        Ok(())
    }

[HalidOdat]

[..] except one surprise is that if I try to change the property in JavaScript, it silently ignores it, whereas before it was giving a runtime exception.

Are you running in strict mode (should throw in strict-mode)? Non-strict JavaScript just ignores the property assign when it's non-writable.

[tomoverlund]

Oh, that explains it. I was not using strict mode in the JavaScript code. The earlier exception occurred from the Rust instance.set() call. If I change JavaScript to use strict, it gets the same exception. Thanks again!