mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-04-26 22:38:51 +00:00
830ea0414c
Before this we used an ad-hoc combination of references and 'variables'
stored in a hashmap. This worked in most cases but is not spec like.
Additionally hoisting, dynamically naming functions and scope analysis
was not done properly.
This patch fixes all of that by:
- Implement BindingInitialization for destructuring assignment.
- Implementing a new ScopePusher which tracks the lexical and var
scoped declarations. This hoists functions to the top level if no
lexical declaration name overlaps. Furthermore we do checking of
redeclarations in the ScopePusher now requiring less checks all over
the place.
- Add methods for parsing the directives and statement lists instead
of having that code duplicated in multiple places. This allows
declarations to pushed to the appropriate scope more easily.
- Remove the non spec way of storing 'variables' in
DeclarativeEnvironment and make Reference follow the spec instead of
checking both the bindings and 'variables'.
- Remove all scoping related things from the Interpreter. And instead
use environments as specified by the spec. This also includes fixing
that NativeFunctions did not produce a valid FunctionEnvironment
which could cause issues with callbacks and eval. All
FunctionObjects now have a valid NewFunctionEnvironment
implementation.
- Remove execute_statements from Interpreter and instead use
ASTNode::execute everywhere this simplifies AST.cpp as you no longer
need to worry about which method to call.
- Make ScopeNodes setup their own environment. This uses four
different methods specified by the spec
{Block, Function, Eval, Global}DeclarationInstantiation with the
annexB extensions.
- Implement and use NamedEvaluation where specified.
Additionally there are fixes to things exposed by these changes to eval,
{for, for-in, for-of} loops and assignment.
Finally it also fixes some tests in test-js which where passing before
but not now that we have correct behavior :^).
107 lines
4.4 KiB
C++
107 lines
4.4 KiB
C++
/*
|
|
* Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <LibJS/AST.h>
|
|
#include <LibJS/Bytecode/Generator.h>
|
|
#include <LibJS/Runtime/FunctionObject.h>
|
|
|
|
namespace JS {
|
|
|
|
// 10.2 ECMAScript Function Objects, https://tc39.es/ecma262/#sec-ecmascript-function-objects
|
|
class ECMAScriptFunctionObject final : public FunctionObject {
|
|
JS_OBJECT(ECMAScriptFunctionObject, FunctionObject);
|
|
|
|
public:
|
|
enum class ConstructorKind : u8 {
|
|
Base,
|
|
Derived,
|
|
};
|
|
|
|
enum class ThisMode : u8 {
|
|
Lexical,
|
|
Strict,
|
|
Global,
|
|
};
|
|
|
|
static ECMAScriptFunctionObject* create(GlobalObject&, FlyString name, Statement const& ecmascript_code, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, Environment* parent_scope, FunctionKind, bool is_strict, bool is_arrow_function = false);
|
|
|
|
ECMAScriptFunctionObject(FlyString name, Statement const& ecmascript_code, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, Environment* parent_scope, Object& prototype, FunctionKind, bool is_strict, bool is_arrow_function = false);
|
|
virtual void initialize(GlobalObject&) override;
|
|
virtual ~ECMAScriptFunctionObject();
|
|
|
|
Statement const& ecmascript_code() const { return m_ecmascript_code; }
|
|
Vector<FunctionNode::Parameter> const& formal_parameters() const { return m_formal_parameters; };
|
|
|
|
virtual Value call() override;
|
|
virtual Value construct(FunctionObject& new_target) override;
|
|
|
|
virtual const FlyString& name() const override { return m_name; };
|
|
void set_name(const FlyString& name);
|
|
|
|
void set_is_class_constructor() { m_is_class_constructor = true; };
|
|
|
|
auto& bytecode_executable() const { return m_bytecode_executable; }
|
|
|
|
Environment* environment() { return m_environment; }
|
|
virtual Realm* realm() const override { return m_realm; }
|
|
|
|
ConstructorKind constructor_kind() const { return m_constructor_kind; };
|
|
void set_constructor_kind(ConstructorKind constructor_kind) { m_constructor_kind = constructor_kind; }
|
|
|
|
ThisMode this_mode() const { return m_this_mode; }
|
|
|
|
Object* home_object() const { return m_home_object; }
|
|
void set_home_object(Object* home_object) { m_home_object = home_object; }
|
|
|
|
struct InstanceField {
|
|
StringOrSymbol name;
|
|
ECMAScriptFunctionObject* initializer { nullptr };
|
|
|
|
void define_field(VM& vm, Object& receiver) const;
|
|
};
|
|
|
|
Vector<InstanceField> const& fields() const { return m_fields; }
|
|
void add_field(StringOrSymbol property_key, ECMAScriptFunctionObject* initializer) { m_fields.empend(property_key, initializer); }
|
|
|
|
// This is for IsSimpleParameterList (static semantics)
|
|
bool has_simple_parameter_list() const { return m_has_simple_parameter_list; }
|
|
|
|
virtual bool has_constructor() const override { return true; }
|
|
|
|
protected:
|
|
virtual bool is_strict_mode() const final { return m_strict; }
|
|
|
|
private:
|
|
virtual bool is_ecmascript_function_object() const override { return true; }
|
|
virtual FunctionEnvironment* new_function_environment(Object* new_target) override;
|
|
virtual void visit_edges(Visitor&) override;
|
|
|
|
ThrowCompletionOr<void> function_declaration_instantiation(Interpreter*);
|
|
Value execute_function_body();
|
|
|
|
// Internal Slots of ECMAScript Function Objects, https://tc39.es/ecma262/#table-internal-slots-of-ecmascript-function-objects
|
|
Environment* m_environment { nullptr }; // [[Environment]]
|
|
Vector<FunctionNode::Parameter> const m_formal_parameters; // [[FormalParameters]]
|
|
NonnullRefPtr<Statement> m_ecmascript_code; // [[ECMAScriptCode]]
|
|
ConstructorKind m_constructor_kind { ConstructorKind::Base }; // [[ConstructorKind]]
|
|
Realm* m_realm { nullptr }; // [[Realm]]
|
|
ThisMode m_this_mode { ThisMode::Global }; // [[ThisMode]]
|
|
bool m_strict { false }; // [[Strict]]
|
|
Object* m_home_object { nullptr }; // [[HomeObject]]
|
|
Vector<InstanceField> m_fields; // [[Fields]]
|
|
bool m_is_class_constructor { false }; // [[IsClassConstructor]]
|
|
|
|
FlyString m_name;
|
|
Optional<Bytecode::Executable> m_bytecode_executable;
|
|
i32 m_function_length { 0 };
|
|
FunctionKind m_kind { FunctionKind::Regular };
|
|
bool m_is_arrow_function { false };
|
|
bool m_has_simple_parameter_list { false };
|
|
};
|
|
|
|
}
|