1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
/*
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2022, David Tuin <davidot@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/FlyString.h>
#include <LibJS/Heap/Handle.h>
#include <LibJS/Runtime/Environment.h>
#include <LibJS/Runtime/Realm.h>
namespace JS {
struct ResolvedBinding {
enum Type {
BindingName,
Namespace,
Ambiguous,
Null,
};
static ResolvedBinding null()
{
return {};
}
static ResolvedBinding ambiguous()
{
ResolvedBinding binding;
binding.type = Ambiguous;
return binding;
}
Type type { Null };
Module* module { nullptr };
FlyString export_name;
bool is_valid() const
{
return type == BindingName || type == Namespace;
}
bool is_namespace() const
{
return type == Namespace;
}
bool is_ambiguous() const
{
return type == Ambiguous;
}
};
// 16.2.1.4 Abstract Module Records, https://tc39.es/ecma262/#sec-abstract-module-records
class Module
: public RefCounted<Module>
, public Weakable<Module> {
public:
virtual ~Module() = default;
Realm& realm() { return *m_realm.cell(); }
Realm const& realm() const { return *m_realm.cell(); }
StringView filename() const { return m_filename; }
Environment* environment() { return m_environment.cell(); }
ThrowCompletionOr<Object*> get_module_namespace(VM& vm);
virtual ThrowCompletionOr<void> link(VM& vm) = 0;
virtual ThrowCompletionOr<Promise*> evaluate(VM& vm) = 0;
virtual ThrowCompletionOr<Vector<FlyString>> get_exported_names(VM& vm, Vector<Module*> export_star_set = {}) = 0;
virtual ThrowCompletionOr<ResolvedBinding> resolve_export(VM& vm, FlyString const& export_name, Vector<ResolvedBinding> resolve_set = {}) = 0;
virtual ThrowCompletionOr<u32> inner_module_linking(VM& vm, Vector<Module*>& stack, u32 index);
virtual ThrowCompletionOr<u32> inner_module_evaluation(VM& vm, Vector<Module*>& stack, u32 index);
protected:
Module(Realm&, String filename);
void set_environment(Environment* environment)
{
m_environment = make_handle(environment);
}
private:
Object* module_namespace_create(VM& vm, Vector<FlyString> unambiguous_names);
// These handles are only safe as long as the VM they live in is valid.
// But evaluated modules SHOULD be stored in the VM so unless you intentionally
// destroy the VM but keep the modules this should not happen. Because VM
// stores modules with a RefPtr we cannot just store the VM as that leads to
// cycles.
Handle<Realm> m_realm; // [[Realm]]
Handle<Environment> m_environment; // [[Environment]]
Handle<Object> m_namespace; // [[Namespace]]
// Needed for potential lookups of modules.
String m_filename;
};
}
|
