ladybird/Userland/Libraries/LibJS/Runtime/BooleanConstructor.h

/*
 * Copyright (c) 2020, Jack Karamanian <karamanian.jack@gmail.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include <LibJS/Runtime/NativeFunction.h>

namespace JS {

class BooleanConstructor final : public NativeFunction {
    JS_OBJECT(BooleanConstructor, NativeFunction);

public:
    explicit BooleanConstructor(GlobalObject&);
    virtual void initialize(GlobalObject&) override;
    virtual ~BooleanConstructor() override;

    virtual ThrowCompletionOr<Value> call() override;
    virtual ThrowCompletionOr<Object*> construct(FunctionObject& new_target) override;

private:
    virtual bool has_constructor() const override { return true; }
};

}
LibJS: Add Boolean constructor object 2020-04-06 22:51:16 -05:00			`/*`
			`* Copyright (c) 2020, Jack Karamanian <karamanian.jack@gmail.com>`
			`*`
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt * 2021-04-22 01:24:48 -07:00			`* SPDX-License-Identifier: BSD-2-Clause`
LibJS: Add Boolean constructor object 2020-04-06 22:51:16 -05:00			`*/`

			`#pragma once`

			`#include <LibJS/Runtime/NativeFunction.h>`

			`namespace JS {`
LibJS: Reformat BooleanConstructor.{cpp,h} 2020-04-07 16:00:44 +01:00
LibJS: Add Boolean constructor object 2020-04-06 22:51:16 -05:00			`class BooleanConstructor final : public NativeFunction {`
LibJS+LibWeb: Add JS::Object::inherits(class_name) To allow implementing the DOM class hierarchy in JS bindings, this patch adds an inherits() function that can be used to ask an Object if it inherits from a specific C++ class (by name). The necessary overrides are baked into each Object subclass by the new JS_OBJECT macro, which works similarly to C_OBJECT in LibCore. Thanks to @Dexesttp for suggesting this approach. :^) 2020-06-21 15:14:02 +02:00			`JS_OBJECT(BooleanConstructor, NativeFunction);`

LibJS: Add Boolean constructor object 2020-04-06 22:51:16 -05:00			`public:`
LibJS: Move native objects towards two-pass construction To make sure that everything is set up correctly in objects before we start adding properties to them, we split cell allocation into 3 steps: 1. Allocate a cell of appropriate size from the Heap 2. Call the C++ constructor on the cell 3. Call initialize() on the constructed object The job of initialize() is to define all the initial properties. Doing it in a second pass guarantees that the Object has a valid Shape and can find its own GlobalObject. 2020-06-20 15:40:48 +02:00			`explicit BooleanConstructor(GlobalObject&);`
LibJS: Simplify Cell::initialize() Remove the Interpreter& argument and pass only GlobalObject&. We can find everything we need via the global object anyway. 2020-07-22 17:50:18 +02:00			`virtual void initialize(GlobalObject&) override;`
LibJS: Add Boolean constructor object 2020-04-06 22:51:16 -05:00			`virtual ~BooleanConstructor() override;`

LibJS: Convert NativeFunction::{call,construct}() to ThrowCompletionOr Both at the same time because many of them call construct() in call() and I'm not keen on adding a bunch of temporary plumbing to turn exceptions into throw completions. Also changes the return value of construct() to Object* instead of Value as it always needs to return an object; allowing an arbitrary Value is a massive foot gun. 2021-10-20 21:16:30 +01:00			`virtual ThrowCompletionOr<Value> call() override;`
			`virtual ThrowCompletionOr<Object*> construct(FunctionObject& new_target) override;`
LibJS: Add Boolean constructor object 2020-04-06 22:51:16 -05:00
			`private:`
			`virtual bool has_constructor() const override { return true; }`
			`};`
LibJS: Reformat BooleanConstructor.{cpp,h} 2020-04-07 16:00:44 +01:00
LibJS: Add Boolean constructor object 2020-04-06 22:51:16 -05:00			`}`