RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 18:07:34 +00:00
Code Issues Activity Actions

LibJS: Make FunctionNode::Parameter be a standalone FunctionParameter

Browse source 
This will allow us to forward declare it and avoid including AST.h in a
number of places.
This commit is contained in:
Andreas Kling 2022-11-23 13:12:36 +01:00 • committed by Linus Groh
parent 2a531efc5d
commit 835d7aac96
8 changed files with 35 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

22
Userland/Libraries/LibJS/AST.h
View file

@ -607,18 +607,18 @@ struct BindingPattern : RefCounted<BindingPattern> {
Kind kind { Kind::Object }; Kind kind { Kind::Object };
}; };
struct FunctionParameter {
Variant<FlyString, NonnullRefPtr<BindingPattern>> binding;
RefPtr<Expression> default_value;
bool is_rest { false };
};
class FunctionNode { class FunctionNode {
public: public:
struct Parameter {
Variant<FlyString, NonnullRefPtr<BindingPattern>> binding;
RefPtr<Expression> default_value;
bool is_rest { false };
};
FlyString const& name() const { return m_name; } FlyString const& name() const { return m_name; }
String const& source_text() const { return m_source_text; } String const& source_text() const { return m_source_text; }
Statement const& body() const { return *m_body; } Statement const& body() const { return *m_body; }
Vector<Parameter> const& parameters() const { return m_parameters; }; Vector<FunctionParameter> const& parameters() const { return m_parameters; };
i32 function_length() const { return m_function_length; } i32 function_length() const { return m_function_length; }
bool is_strict_mode() const { return m_is_strict_mode; } bool is_strict_mode() const { return m_is_strict_mode; }
bool might_need_arguments_object() const { return m_might_need_arguments_object; } bool might_need_arguments_object() const { return m_might_need_arguments_object; }
@ -627,7 +627,7 @@ public:
FunctionKind kind() const { return m_kind; } FunctionKind kind() const { return m_kind; }
protected: protected:
FunctionNode(FlyString name, String source_text, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, FunctionKind kind, bool is_strict_mode, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function) FunctionNode(FlyString name, String source_text, NonnullRefPtr<Statement> body, Vector<FunctionParameter> parameters, i32 function_length, FunctionKind kind, bool is_strict_mode, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function)
: m_name(move(name)) : m_name(move(name))
, m_source_text(move(source_text)) , m_source_text(move(source_text))
, m_body(move(body)) , m_body(move(body))
@ -649,7 +649,7 @@ private:
FlyString m_name; FlyString m_name;
String m_source_text; String m_source_text;
NonnullRefPtr<Statement> m_body; NonnullRefPtr<Statement> m_body;
Vector<Parameter> const m_parameters; Vector<FunctionParameter> const m_parameters;
const i32 m_function_length; const i32 m_function_length;
FunctionKind m_kind; FunctionKind m_kind;
bool m_is_strict_mode { false }; bool m_is_strict_mode { false };
@ -664,7 +664,7 @@ class FunctionDeclaration final
public: public:
static bool must_have_name() { return true; } static bool must_have_name() { return true; }
FunctionDeclaration(SourceRange source_range, FlyString const& name, String source_text, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, FunctionKind kind, bool is_strict_mode, bool might_need_arguments_object, bool contains_direct_call_to_eval) FunctionDeclaration(SourceRange source_range, FlyString const& name, String source_text, NonnullRefPtr<Statement> body, Vector<FunctionParameter> parameters, i32 function_length, FunctionKind kind, bool is_strict_mode, bool might_need_arguments_object, bool contains_direct_call_to_eval)
: Declaration(source_range) : Declaration(source_range)
, FunctionNode(name, move(source_text), move(body), move(parameters), function_length, kind, is_strict_mode, might_need_arguments_object, contains_direct_call_to_eval, false) , FunctionNode(name, move(source_text), move(body), move(parameters), function_length, kind, is_strict_mode, might_need_arguments_object, contains_direct_call_to_eval, false)
{ {
@ -690,7 +690,7 @@ class FunctionExpression final
public: public:
static bool must_have_name() { return false; } static bool must_have_name() { return false; }
FunctionExpression(SourceRange source_range, FlyString const& name, String source_text, NonnullRefPtr<Statement> body, Vector<Parameter> parameters, i32 function_length, FunctionKind kind, bool is_strict_mode, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function = false) FunctionExpression(SourceRange source_range, FlyString const& name, String source_text, NonnullRefPtr<Statement> body, Vector<FunctionParameter> parameters, i32 function_length, FunctionKind kind, bool is_strict_mode, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function = false)
: Expression(source_range) : Expression(source_range)
, FunctionNode(name, move(source_text), move(body), move(parameters), function_length, kind, is_strict_mode, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function) , FunctionNode(name, move(source_text), move(body), move(parameters), function_length, kind, is_strict_mode, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function)
{ {

1
Userland/Libraries/LibJS/Forward.h
View file

@ -169,6 +169,7 @@ class Expression;
class ForStatement; class ForStatement;
class FunctionEnvironment; class FunctionEnvironment;
class FunctionNode; class FunctionNode;
struct FunctionParameter;
class GlobalEnvironment; class GlobalEnvironment;
class GlobalObject; class GlobalObject;
class HandleImpl; class HandleImpl;

22
Userland/Libraries/LibJS/Parser.cpp
View file

@ -59,7 +59,7 @@ private:
} }
public: public:
static ScopePusher function_scope(Parser& parser, FunctionBody& function_body, Vector<FunctionDeclaration::Parameter> const& parameters) static ScopePusher function_scope(Parser& parser, FunctionBody& function_body, Vector<FunctionParameter> const& parameters)
{ {
ScopePusher scope_pusher(parser, &function_body, ScopeLevel::FunctionTopLevel); ScopePusher scope_pusher(parser, &function_body, ScopeLevel::FunctionTopLevel);
scope_pusher.m_function_parameters = parameters; scope_pusher.m_function_parameters = parameters;
@ -200,7 +200,7 @@ public:
return nullptr; return nullptr;
} }
Vector<FunctionDeclaration::Parameter> const& function_parameters() const Vector<FunctionParameter> const& function_parameters() const
{ {
return *m_function_parameters; return *m_function_parameters;
} }
@ -274,7 +274,7 @@ private:
HashTable<FlyString> m_forbidden_var_names; HashTable<FlyString> m_forbidden_var_names;
NonnullRefPtrVector<FunctionDeclaration> m_functions_to_hoist; NonnullRefPtrVector<FunctionDeclaration> m_functions_to_hoist;
Optional<Vector<FunctionDeclaration::Parameter>> m_function_parameters; Optional<Vector<FunctionParameter>> m_function_parameters;
bool m_contains_access_to_arguments_object { false }; bool m_contains_access_to_arguments_object { false };
bool m_contains_direct_call_to_eval { false }; bool m_contains_direct_call_to_eval { false };
@ -704,9 +704,9 @@ static bool is_strict_reserved_word(StringView str)
}); });
} }
static bool is_simple_parameter_list(Vector<FunctionNode::Parameter> const& parameters) static bool is_simple_parameter_list(Vector<FunctionParameter> const& parameters)
{ {
return all_of(parameters, [](FunctionNode::Parameter const& parameter) { return all_of(parameters, [](FunctionParameter const& parameter) {
return !parameter.is_rest && parameter.default_value.is_null() && parameter.binding.has<FlyString>(); return !parameter.is_rest && parameter.default_value.is_null() && parameter.binding.has<FlyString>();
}); });
} }
@ -756,7 +756,7 @@ RefPtr<FunctionExpression> Parser::try_parse_arrow_function_expression(bool expe
} }
} }
Vector<FunctionNode::Parameter> parameters; Vector<FunctionParameter> parameters;
i32 function_length = -1; i32 function_length = -1;
if (expect_parens) { if (expect_parens) {
// We have parens around the function parameters and can re-use the same parsing // We have parens around the function parameters and can re-use the same parsing
@ -1343,12 +1343,12 @@ NonnullRefPtr<ClassExpression> Parser::parse_class_expression(bool expect_class_
constructor = create_ast_node<FunctionExpression>( constructor = create_ast_node<FunctionExpression>(
{ m_source_code, rule_start.position(), position() }, class_name, "", { m_source_code, rule_start.position(), position() }, class_name, "",
move(constructor_body), Vector { FunctionNode::Parameter { move(argument_name), nullptr, true } }, 0, FunctionKind::Normal, move(constructor_body), Vector { FunctionParameter { move(argument_name), nullptr, true } }, 0, FunctionKind::Normal,
/* is_strict_mode */ true, /* might_need_arguments_object */ false, /* contains_direct_call_to_eval */ false); /* is_strict_mode */ true, /* might_need_arguments_object */ false, /* contains_direct_call_to_eval */ false);
} else { } else {
constructor = create_ast_node<FunctionExpression>( constructor = create_ast_node<FunctionExpression>(
{ m_source_code, rule_start.position(), position() }, class_name, "", { m_source_code, rule_start.position(), position() }, class_name, "",
move(constructor_body), Vector<FunctionNode::Parameter> {}, 0, FunctionKind::Normal, move(constructor_body), Vector<FunctionParameter> {}, 0, FunctionKind::Normal,
/* is_strict_mode */ true, /* might_need_arguments_object */ false, /* contains_direct_call_to_eval */ false); /* is_strict_mode */ true, /* might_need_arguments_object */ false, /* contains_direct_call_to_eval */ false);
} }
} }
@ -2458,7 +2458,7 @@ void Parser::parse_statement_list(ScopeNode& output_node, AllowLabelledFunction
} }
// FunctionBody, https://tc39.es/ecma262/#prod-FunctionBody // FunctionBody, https://tc39.es/ecma262/#prod-FunctionBody
NonnullRefPtr<FunctionBody> Parser::parse_function_body(Vector<FunctionDeclaration::Parameter> const& parameters, FunctionKind function_kind, bool& contains_direct_call_to_eval) NonnullRefPtr<FunctionBody> Parser::parse_function_body(Vector<FunctionParameter> const& parameters, FunctionKind function_kind, bool& contains_direct_call_to_eval)
{ {
auto rule_start = push_start(); auto rule_start = push_start();
auto function_body = create_ast_node<FunctionBody>({ m_source_code, rule_start.position(), position() }); auto function_body = create_ast_node<FunctionBody>({ m_source_code, rule_start.position(), position() });
@ -2632,14 +2632,14 @@ NonnullRefPtr<FunctionNodeType> Parser::parse_function_node(u16 parse_options, O
contains_direct_call_to_eval); contains_direct_call_to_eval);
} }
Vector<FunctionNode::Parameter> Parser::parse_formal_parameters(int& function_length, u16 parse_options) Vector<FunctionParameter> Parser::parse_formal_parameters(int& function_length, u16 parse_options)
{ {
auto rule_start = push_start(); auto rule_start = push_start();
bool has_default_parameter = false; bool has_default_parameter = false;
bool has_rest_parameter = false; bool has_rest_parameter = false;
TemporaryChange formal_parameter_context_change { m_state.in_formal_parameter_context, true }; TemporaryChange formal_parameter_context_change { m_state.in_formal_parameter_context, true };
Vector<FunctionNode::Parameter> parameters; Vector<FunctionParameter> parameters;
auto consume_identifier_or_binding_pattern = [&]() -> Variant<FlyString, NonnullRefPtr<BindingPattern>> { auto consume_identifier_or_binding_pattern = [&]() -> Variant<FlyString, NonnullRefPtr<BindingPattern>> {
if (auto pattern = parse_binding_pattern(AllowDuplicates::No, AllowMemberExpressions::No)) if (auto pattern = parse_binding_pattern(AllowDuplicates::No, AllowMemberExpressions::No))

4
Userland/Libraries/LibJS/Parser.h
View file

@ -58,7 +58,7 @@ public:
template<typename FunctionNodeType> template<typename FunctionNodeType>
NonnullRefPtr<FunctionNodeType> parse_function_node(u16 parse_options = FunctionNodeParseOptions::CheckForFunctionAndName, Optional<Position> const& function_start = {}); NonnullRefPtr<FunctionNodeType> parse_function_node(u16 parse_options = FunctionNodeParseOptions::CheckForFunctionAndName, Optional<Position> const& function_start = {});
Vector<FunctionNode::Parameter> parse_formal_parameters(int& function_length, u16 parse_options = 0); Vector<FunctionParameter> parse_formal_parameters(int& function_length, u16 parse_options = 0);
enum class AllowDuplicates { enum class AllowDuplicates {
Yes, Yes,
@ -86,7 +86,7 @@ public:
NonnullRefPtr<Statement> parse_statement(AllowLabelledFunction allow_labelled_function = AllowLabelledFunction::No); NonnullRefPtr<Statement> parse_statement(AllowLabelledFunction allow_labelled_function = AllowLabelledFunction::No);
NonnullRefPtr<BlockStatement> parse_block_statement(); NonnullRefPtr<BlockStatement> parse_block_statement();
NonnullRefPtr<FunctionBody> parse_function_body(Vector<FunctionDeclaration::Parameter> const& parameters, FunctionKind function_kind, bool& contains_direct_call_to_eval); NonnullRefPtr<FunctionBody> parse_function_body(Vector<FunctionParameter> const& parameters, FunctionKind function_kind, bool& contains_direct_call_to_eval);
NonnullRefPtr<ReturnStatement> parse_return_statement(); NonnullRefPtr<ReturnStatement> parse_return_statement();
NonnullRefPtr<VariableDeclaration> parse_variable_declaration(bool for_loop_variable_declaration = false); NonnullRefPtr<VariableDeclaration> parse_variable_declaration(bool for_loop_variable_declaration = false);
NonnullRefPtr<Statement> parse_for_statement(); NonnullRefPtr<Statement> parse_for_statement();

2
Userland/Libraries/LibJS/Runtime/AbstractOperations.cpp
View file

@ -1065,7 +1065,7 @@ Object* create_unmapped_arguments_object(VM& vm, Span<Value> arguments)
} }
// 10.4.4.7 CreateMappedArgumentsObject ( func, formals, argumentsList, env ), https://tc39.es/ecma262/#sec-createmappedargumentsobject // 10.4.4.7 CreateMappedArgumentsObject ( func, formals, argumentsList, env ), https://tc39.es/ecma262/#sec-createmappedargumentsobject
Object* create_mapped_arguments_object(VM& vm, FunctionObject& function, Vector<FunctionNode::Parameter> const& formals, Span<Value> arguments, Environment& environment) Object* create_mapped_arguments_object(VM& vm, FunctionObject& function, Vector<FunctionParameter> const& formals, Span<Value> arguments, Environment& environment)
{ {
auto& realm = *vm.current_realm(); auto& realm = *vm.current_realm();

2
Userland/Libraries/LibJS/Runtime/AbstractOperations.h
View file

@ -40,7 +40,7 @@ bool is_compatible_property_descriptor(bool extensible, PropertyDescriptor const
bool validate_and_apply_property_descriptor(Object*, PropertyKey const&, bool extensible, PropertyDescriptor const&, Optional<PropertyDescriptor> const& current); bool validate_and_apply_property_descriptor(Object*, PropertyKey const&, bool extensible, PropertyDescriptor const&, Optional<PropertyDescriptor> const& current);
ThrowCompletionOr<Object*> get_prototype_from_constructor(VM&, FunctionObject const& constructor, Object* (Intrinsics::*intrinsic_default_prototype)()); ThrowCompletionOr<Object*> get_prototype_from_constructor(VM&, FunctionObject const& constructor, Object* (Intrinsics::*intrinsic_default_prototype)());
Object* create_unmapped_arguments_object(VM&, Span<Value> arguments); Object* create_unmapped_arguments_object(VM&, Span<Value> arguments);
Object* create_mapped_arguments_object(VM&, FunctionObject&, Vector<FunctionNode::Parameter> const&, Span<Value> arguments, Environment&); Object* create_mapped_arguments_object(VM&, FunctionObject&, Vector<FunctionParameter> const&, Span<Value> arguments, Environment&);
enum class CanonicalIndexMode { enum class CanonicalIndexMode {
DetectNumericRoundtrip, DetectNumericRoundtrip,

6
Userland/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.cpp
View file

@ -28,7 +28,7 @@
namespace JS { namespace JS {
ECMAScriptFunctionObject* ECMAScriptFunctionObject::create(Realm& realm, FlyString name, String source_text, Statement const& ecmascript_code, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name) ECMAScriptFunctionObject* ECMAScriptFunctionObject::create(Realm& realm, FlyString name, String source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
{ {
Object* prototype = nullptr; Object* prototype = nullptr;
switch (kind) { switch (kind) {
@ -48,12 +48,12 @@ ECMAScriptFunctionObject* ECMAScriptFunctionObject::create(Realm& realm, FlyStri
return realm.heap().allocate<ECMAScriptFunctionObject>(realm, move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, parent_environment, private_environment, *prototype, kind, is_strict, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function, move(class_field_initializer_name)); return realm.heap().allocate<ECMAScriptFunctionObject>(realm, move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, parent_environment, private_environment, *prototype, kind, is_strict, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function, move(class_field_initializer_name));
} }
ECMAScriptFunctionObject* ECMAScriptFunctionObject::create(Realm& realm, FlyString name, Object& prototype, String source_text, Statement const& ecmascript_code, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name) ECMAScriptFunctionObject* ECMAScriptFunctionObject::create(Realm& realm, FlyString name, Object& prototype, String source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
{ {
return realm.heap().allocate<ECMAScriptFunctionObject>(realm, move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, parent_environment, private_environment, prototype, kind, is_strict, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function, move(class_field_initializer_name)); return realm.heap().allocate<ECMAScriptFunctionObject>(realm, move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, parent_environment, private_environment, prototype, kind, is_strict, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function, move(class_field_initializer_name));
} }
ECMAScriptFunctionObject::ECMAScriptFunctionObject(FlyString name, String source_text, Statement const& ecmascript_code, Vector<FunctionNode::Parameter> formal_parameters, i32 function_length, Environment* parent_environment, PrivateEnvironment* private_environment, Object& prototype, FunctionKind kind, bool strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name) ECMAScriptFunctionObject::ECMAScriptFunctionObject(FlyString name, String source_text, Statement const& ecmascript_code, Vector<FunctionParameter> formal_parameters, i32 function_length, Environment* parent_environment, PrivateEnvironment* private_environment, Object& prototype, FunctionKind kind, bool strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
: FunctionObject(prototype) : FunctionObject(prototype)
, m_name(move(name)) , m_name(move(name))
, m_function_length(function_length) , m_function_length(function_length)

10
Userland/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.h
View file

@ -32,8 +32,8 @@ public:
Global, Global,
}; };
static ECMAScriptFunctionObject* create(Realm&, FlyString name, String source_text, Statement const& ecmascript_code, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind, bool is_strict, bool might_need_arguments_object = true, bool contains_direct_call_to_eval = true, bool is_arrow_function = false, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name = {}); static ECMAScriptFunctionObject* create(Realm&, FlyString name, String source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind, bool is_strict, bool might_need_arguments_object = true, bool contains_direct_call_to_eval = true, bool is_arrow_function = false, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name = {});
static ECMAScriptFunctionObject* create(Realm&, FlyString name, Object& prototype, String source_text, Statement const& ecmascript_code, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind, bool is_strict, bool might_need_arguments_object = true, bool contains_direct_call_to_eval = true, bool is_arrow_function = false, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name = {}); static ECMAScriptFunctionObject* create(Realm&, FlyString name, Object& prototype, String source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind, bool is_strict, bool might_need_arguments_object = true, bool contains_direct_call_to_eval = true, bool is_arrow_function = false, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name = {});
virtual void initialize(Realm&) override; virtual void initialize(Realm&) override;
virtual ~ECMAScriptFunctionObject() override = default; virtual ~ECMAScriptFunctionObject() override = default;
@ -44,7 +44,7 @@ public:
void make_method(Object& home_object); void make_method(Object& home_object);
Statement const& ecmascript_code() const { return m_ecmascript_code; } Statement const& ecmascript_code() const { return m_ecmascript_code; }
Vector<FunctionNode::Parameter> const& formal_parameters() const { return m_formal_parameters; }; Vector<FunctionParameter> const& formal_parameters() const { return m_formal_parameters; };
virtual FlyString const& name() const override { return m_name; }; virtual FlyString const& name() const override { return m_name; };
void set_name(FlyString const& name); void set_name(FlyString const& name);
@ -93,7 +93,7 @@ protected:
virtual Completion ordinary_call_evaluate_body(); virtual Completion ordinary_call_evaluate_body();
private: private:
ECMAScriptFunctionObject(FlyString name, String source_text, Statement const& ecmascript_code, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, Object& prototype, FunctionKind, bool is_strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name); ECMAScriptFunctionObject(FlyString name, String source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, Object& prototype, FunctionKind, bool is_strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name);
virtual bool is_ecmascript_function_object() const override { return true; } virtual bool is_ecmascript_function_object() const override { return true; }
virtual void visit_edges(Visitor&) override; virtual void visit_edges(Visitor&) override;
@ -113,7 +113,7 @@ private:
// Internal Slots of ECMAScript Function Objects, https://tc39.es/ecma262/#table-internal-slots-of-ecmascript-function-objects // Internal Slots of ECMAScript Function Objects, https://tc39.es/ecma262/#table-internal-slots-of-ecmascript-function-objects
Environment* m_environment { nullptr }; // [[Environment]] Environment* m_environment { nullptr }; // [[Environment]]
PrivateEnvironment* m_private_environment { nullptr }; // [[PrivateEnvironment]] PrivateEnvironment* m_private_environment { nullptr }; // [[PrivateEnvironment]]
Vector<FunctionNode::Parameter> const m_formal_parameters; // [[FormalParameters]] Vector<FunctionParameter> const m_formal_parameters; // [[FormalParameters]]
NonnullRefPtr<Statement> m_ecmascript_code; // [[ECMAScriptCode]] NonnullRefPtr<Statement> m_ecmascript_code; // [[ECMAScriptCode]]
Realm* m_realm { nullptr }; // [[Realm]] Realm* m_realm { nullptr }; // [[Realm]]
ScriptOrModule m_script_or_module; // [[ScriptOrModule]] ScriptOrModule m_script_or_module; // [[ScriptOrModule]]