Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2026-04-18 18:00:31 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibJS/SourceTextModule.h

80 lines
3.6 KiB
C
Raw Permalink Normal View History

LibJS: Add a barebones SourceTextModule class This corresponds to "Source Text Module Record" from the spec.
2021-09-14 20:51:16 +02:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2021-2023, Andreas Kling <andreas@ladybird.org>
LibJS: Implement Module linking and evaluating
2022-01-18 19:29:17 +01:00
* Copyright (c) 2022, David Tuin <davidot@serenityos.org>
LibJS: Add a barebones SourceTextModule class This corresponds to "Source Text Module Record" from the spec.
2021-09-14 20:51:16 +02:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
LibJS: Implement Module linking and evaluating
2022-01-18 19:29:17 +01:00
#include <LibJS/CyclicModule.h>
LibJS: Enable EXPLICIT_SYMBOL_EXPORT and annotate minimum symbol set
2025-07-19 13:49:30 -07:00
#include <LibJS/Export.h>
LibJS: Add a barebones SourceTextModule class This corresponds to "Source Text Module Record" from the spec.
2021-09-14 20:51:16 +02:00
#include <LibJS/Forward.h>
LibJS: Remove C++ AST Delete AST.cpp, AST.h, ASTDump.cpp, ScopeRecord.h, and the dead get_builtin(MemberExpression const&) from Builtins.cpp. Extract ImportEntry and ExportEntry into a new ModuleEntry.h, since they are data types used by the module system, not AST node types. Inline ModuleRequest's sorting constructor and SourceRange::filename(). Remove the dead annex_b_function_declarations field from EvalDeclarationData, which was only populated by the C++ parser.
2026-03-19 13:37:46 -05:00
#include <LibJS/ModuleEntry.h>
LibJS: Make CyclicModule.h not include PromiseCapability.h
2022-11-23 11:41:19 +01:00
#include <LibJS/Runtime/ExecutionContext.h>
LibJS: Add a barebones SourceTextModule class This corresponds to "Source Text Module Record" from the spec.
2021-09-14 20:51:16 +02:00
namespace JS {
LibJS: Generate FFI header using cbindgen instead of hand-rolling Replace the BytecodeFactory header with cbindgen. This will help ensure that types and enums and constants are kept in sync between the C++ and Rust code. It's also a step in exporting more Rust enums directly rather than relying on magic constants for switch statements. The FFI functions are now all placed in the JS::FFI namespace, which is the cause for all the churn in the scripting parts of LibJS and LibWeb.
2026-03-17 15:47:58 -06:00
namespace FFI {
struct ParsedProgram;
}
LibJS: Add a barebones SourceTextModule class This corresponds to "Source Text Module Record" from the spec.
2021-09-14 20:51:16 +02:00
// 16.2.1.6 Source Text Module Records, https://tc39.es/ecma262/#sec-source-text-module-records
LibJS: Enable EXPLICIT_SYMBOL_EXPORT and annotate minimum symbol set
2025-07-19 13:49:30 -07:00
class JS_API SourceTextModule final : public CyclicModule {
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_CELL(SourceTextModule, CyclicModule);
GC_DECLARE_ALLOCATOR(SourceTextModule);
LibJS: Make Script and Module GC-allocated This ensures that code currently in any active or saved execution stack always stays alive.
2022-09-05 14:31:25 +02:00
LibJS: Add a barebones SourceTextModule class This corresponds to "Source Text Module Record" from the spec.
2021-09-14 20:51:16 +02:00
public:
Everywhere: Write dtors for types with incomplete members out-of-line These are rejected by Clang (19) trunk as a result of https://github.com/llvm/llvm-project/pull/77753.
2024-06-16 10:38:35 +02:00
virtual ~SourceTextModule() override;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
static Result<GC::Ref<SourceTextModule>, Vector<ParserError>> parse(StringView source_text, Realm&, StringView filename = {}, Script::HostDefined* host_defined = nullptr);
LibJS: Generate FFI header using cbindgen instead of hand-rolling Replace the BytecodeFactory header with cbindgen. This will help ensure that types and enums and constants are kept in sync between the C++ and Rust code. It's also a step in exporting more Rust enums directly rather than relying on magic constants for switch statements. The FFI functions are now all placed in the JS::FFI namespace, which is the cause for all the churn in the scripting parts of LibJS and LibWeb.
2026-03-17 15:47:58 -06:00
static Result<GC::Ref<SourceTextModule>, Vector<ParserError>> parse_from_pre_parsed(FFI::ParsedProgram* parsed, NonnullRefPtr<SourceCode const> source_code, Realm&, Script::HostDefined* host_defined = nullptr);
LibJS: Add a barebones SourceTextModule class This corresponds to "Source Text Module Record" from the spec.
2021-09-14 20:51:16 +02:00
LibJS+LibWeb+WebContent: Port JS::PropertyKey to UTF-16 This has quite a lot of fall out. But the majority of it is just type or UDL substitution, where the changes just fall through to other function calls. By changing property key storage to UTF-16, the main affected areas are: * NativeFunction names must now be UTF-16 * Bytecode identifiers must now be UTF-16 * Module/binding names must now be UTF-16
2025-08-02 19:27:29 -04:00
virtual Vector<Utf16FlyString> get_exported_names(VM& vm, HashTable<Module const*>& export_star_set) override;
virtual ResolvedBinding resolve_export(VM& vm, Utf16FlyString const& export_name, Vector<ResolvedBinding> resolve_set = {}) override;
LibJS: Implement Module linking and evaluating
2022-01-18 19:29:17 +01:00
LibJS: Make Script and Module GC-allocated This ensures that code currently in any active or saved execution stack always stays alive.
2022-09-05 14:31:25 +02:00
Object* import_meta() { return m_import_meta; }
LibJS: Implement import.meta for bytecode
2023-07-11 23:07:12 -04:00
void set_import_meta(Badge<VM>, Object* import_meta) { m_import_meta = import_meta; }
LibJS: Implement Module linking and evaluating
2022-01-18 19:29:17 +01:00
LibJS: Add alternative source-to-bytecode pipeline in Rust Implement a complete Rust reimplementation of the LibJS frontend: lexer, parser, AST, scope collector, and bytecode code generator. The Rust pipeline is built via Corrosion (CMake-Cargo bridge) and linked into LibJS as a static library. It is gated behind a build flag (ENABLE_RUST, on by default except on Windows) and two runtime environment variables: - LIBJS_CPP: Use the C++ pipeline instead of Rust - LIBJS_COMPARE_PIPELINES=1: Run both pipelines in lockstep, aborting on any difference in AST or bytecode generated. The C++ side communicates with Rust through a C FFI layer (RustIntegration.cpp/h) that passes source text to Rust and receives a populated Executable back via a BytecodeFactory interface.
2026-02-23 11:50:46 +01:00
// Pre-computed module declaration instantiation data.
// These are extracted from the AST at construction time so that
// initialize_environment() can run without walking the AST.
struct FunctionToInitialize {
GC::Ref<SharedFunctionInstanceData> shared_data;
Utf16FlyString name;
};
struct LexicalBinding {
Utf16FlyString name;
bool is_constant { false };
i32 function_index { -1 }; // index into m_functions_to_initialize, -1 if not a function
};
LibJS: Implement Module linking and evaluating
2022-01-18 19:29:17 +01:00
protected:
LibJS: Remove implicit wrapping/unwrapping of completion records This is an editorial change in the ECMA-262 spec, with similar changes in some proposals. See: - https://github.com/tc39/ecma262/commit/7575f74 - https://github.com/tc39/proposal-array-grouping/commit/df899eb - https://github.com/tc39/proposal-shadowrealm/commit/9eb5a12 - https://github.com/tc39/proposal-shadowrealm/commit/c81f527
2022-05-02 20:54:39 +02:00
virtual ThrowCompletionOr<void> initialize_environment(VM& vm) override;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
virtual ThrowCompletionOr<void> execute_module(VM& vm, GC::Ptr<PromiseCapability> capability) override;
LibJS: Implement Module linking and evaluating
2022-01-18 19:29:17 +01:00
private:
LibJS: Add alternative source-to-bytecode pipeline in Rust Implement a complete Rust reimplementation of the LibJS frontend: lexer, parser, AST, scope collector, and bytecode code generator. The Rust pipeline is built via Corrosion (CMake-Cargo bridge) and linked into LibJS as a static library. It is gated behind a build flag (ENABLE_RUST, on by default except on Windows) and two runtime environment variables: - LIBJS_CPP: Use the C++ pipeline instead of Rust - LIBJS_COMPARE_PIPELINES=1: Run both pipelines in lockstep, aborting on any difference in AST or bytecode generated. The C++ side communicates with Rust through a C FFI layer (RustIntegration.cpp/h) that passes source text to Rust and receives a populated Executable back via a BytecodeFactory interface.
2026-02-23 11:50:46 +01:00
SourceTextModule(Realm&, StringView filename, Script::HostDefined* host_defined, bool has_top_level_await, Vector<ModuleRequest> requested_modules, Vector<ImportEntry> import_entries, Vector<ExportEntry> local_export_entries, Vector<ExportEntry> indirect_export_entries, Vector<ExportEntry> star_export_entries, Optional<Utf16FlyString> default_export_binding_name, Vector<Utf16FlyString> var_declared_names, Vector<LexicalBinding> lexical_bindings, Vector<FunctionToInitialize> functions_to_initialize, GC::Ptr<Bytecode::Executable> executable, GC::Ptr<SharedFunctionInstanceData> tla_shared_data);
LibJS: Make Script and Module GC-allocated This ensures that code currently in any active or saved execution stack always stays alive.
2022-09-05 14:31:25 +02:00
virtual void visit_edges(Cell::Visitor&) override;
LibJS: Always allocate ExecutionContext objects on the malloc heap Instead of allocating these in a mixture of ways, we now always put them on the malloc heap, and keep an intrusive linked list of them that we can iterate for GC marking purposes.
2023-11-27 16:45:45 +01:00
NonnullOwnPtr<ExecutionContext> m_execution_context; // [[Context]]
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Object> m_import_meta; // [[ImportMeta]]
LibJS: Always allocate ExecutionContext objects on the malloc heap Instead of allocating these in a mixture of ways, we now always put them on the malloc heap, and keep an intrusive linked list of them that we can iterate for GC marking purposes.
2023-11-27 16:45:45 +01:00
Vector<ImportEntry> m_import_entries; // [[ImportEntries]]
Vector<ExportEntry> m_local_export_entries; // [[LocalExportEntries]]
Vector<ExportEntry> m_indirect_export_entries; // [[IndirectExportEntries]]
Vector<ExportEntry> m_star_export_entries; // [[StarExportEntries]]
LibJS: Implement Module linking and evaluating
2022-01-18 19:29:17 +01:00
LibJS: Pre-compute module declaration metadata from AST Extract the data needed by initialize_environment() from the AST at construction time, following the pattern already used by Script for global declaration instantiation. This pre-computes var declared names, lexical bindings (with function indices), functions to initialize (with SharedFunctionInstanceData), and the default export binding name.
2026-02-11 09:48:00 +01:00
Vector<Utf16FlyString> m_var_declared_names;
Vector<LexicalBinding> m_lexical_bindings;
Vector<FunctionToInitialize> m_functions_to_initialize;
Optional<Utf16FlyString> m_default_export_binding_name;
LibJS: Cache compiled executable and pre-create TLA shared data For non-TLA modules, cache the compiled Bytecode::Executable on the SourceTextModule so we only compile once. For TLA modules, pre-create the SharedFunctionInstanceData for the async wrapper function at construction time. The wrapper function's first invocation will compile it to bytecode and then automatically drop the AST via clear_compile_inputs().
2026-02-11 09:49:52 +01:00
GC::Ptr<Bytecode::Executable> m_executable;
GC::Ptr<SharedFunctionInstanceData> m_tla_shared_data;
LibJS: Add a barebones SourceTextModule class This corresponds to "Source Text Module Record" from the spec.
2021-09-14 20:51:16 +02:00
};
}
Reference in a new issue Copy permalink