mirror of https://github.com/boa-dev/boa.git
José Julián Espina
7 months ago
committed by
GitHub
7 changed files with 864 additions and 261 deletions
@ -0,0 +1,223 @@
|
||||
use std::path::{Path, PathBuf}; |
||||
|
||||
use rustc_hash::FxHashMap; |
||||
|
||||
use boa_gc::GcRefCell; |
||||
use boa_parser::Source; |
||||
|
||||
use crate::script::Script; |
||||
use crate::{ |
||||
js_string, object::JsObject, realm::Realm, vm::ActiveRunnable, Context, JsError, JsNativeError, |
||||
JsResult, JsString, |
||||
}; |
||||
|
||||
use super::Module; |
||||
|
||||
/// The referrer from which a load request of a module originates.
|
||||
#[derive(Debug, Clone)] |
||||
pub enum Referrer { |
||||
/// A [**Source Text Module Record**](https://tc39.es/ecma262/#sec-source-text-module-records).
|
||||
Module(Module), |
||||
/// A [**Realm**](https://tc39.es/ecma262/#sec-code-realms).
|
||||
Realm(Realm), |
||||
/// A [**Script Record**](https://tc39.es/ecma262/#sec-script-records)
|
||||
Script(Script), |
||||
} |
||||
|
||||
impl From<ActiveRunnable> for Referrer { |
||||
fn from(value: ActiveRunnable) -> Self { |
||||
match value { |
||||
ActiveRunnable::Script(script) => Self::Script(script), |
||||
ActiveRunnable::Module(module) => Self::Module(module), |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Module loading related host hooks.
|
||||
///
|
||||
/// This trait allows to customize the behaviour of the engine on module load requests and
|
||||
/// `import.meta` requests.
|
||||
pub trait ModuleLoader { |
||||
/// Host hook [`HostLoadImportedModule ( referrer, specifier, hostDefined, payload )`][spec].
|
||||
///
|
||||
/// This hook allows to customize the module loading functionality of the engine. Technically,
|
||||
/// this should call the [`FinishLoadingImportedModule`][finish] operation, but this simpler API just provides
|
||||
/// a closure that replaces `FinishLoadingImportedModule`.
|
||||
///
|
||||
/// # Requirements
|
||||
///
|
||||
/// - The host environment must perform `FinishLoadingImportedModule(referrer, specifier, payload, result)`,
|
||||
/// where result is either a normal completion containing the loaded Module Record or a throw
|
||||
/// completion, either synchronously or asynchronously. This is equivalent to calling the `finish_load`
|
||||
/// callback.
|
||||
/// - If this operation is called multiple times with the same `(referrer, specifier)` pair and
|
||||
/// it performs FinishLoadingImportedModule(referrer, specifier, payload, result) where result
|
||||
/// is a normal completion, then it must perform
|
||||
/// `FinishLoadingImportedModule(referrer, specifier, payload, result)` with the same result each
|
||||
/// time.
|
||||
/// - The operation must treat payload as an opaque value to be passed through to
|
||||
/// `FinishLoadingImportedModule`. (can be ignored)
|
||||
///
|
||||
/// [spec]: https://tc39.es/ecma262/#sec-HostLoadImportedModule
|
||||
/// [finish]: https://tc39.es/ecma262/#sec-FinishLoadingImportedModule
|
||||
#[allow(clippy::type_complexity)] |
||||
fn load_imported_module( |
||||
&self, |
||||
referrer: Referrer, |
||||
specifier: JsString, |
||||
finish_load: Box<dyn FnOnce(JsResult<Module>, &mut Context<'_>)>, |
||||
context: &mut Context<'_>, |
||||
); |
||||
|
||||
/// Registers a new module into the module loader.
|
||||
///
|
||||
/// This is a convenience method for module loaders caching already parsed modules, since it
|
||||
/// allows registering a new module through the `&dyn ModuleLoader` provided by
|
||||
/// [`Context::module_loader`].
|
||||
///
|
||||
/// Does nothing by default.
|
||||
fn register_module(&self, _specifier: JsString, _module: Module) {} |
||||
|
||||
/// Gets the module associated with the provided specifier.
|
||||
///
|
||||
/// This is a convenience method for module loaders caching already parsed modules, since it
|
||||
/// allows getting a cached module through the `&dyn ModuleLoader` provided by
|
||||
/// [`Context::module_loader`].
|
||||
///
|
||||
/// Returns `None` by default.
|
||||
fn get_module(&self, _specifier: JsString) -> Option<Module> { |
||||
None |
||||
} |
||||
|
||||
/// Host hooks [`HostGetImportMetaProperties ( moduleRecord )`][meta] and
|
||||
/// [`HostFinalizeImportMeta ( importMeta, moduleRecord )`][final].
|
||||
///
|
||||
/// This unifies both APIs into a single hook that can be overriden on both cases.
|
||||
/// The most common usage is to add properties to `import_meta` and return, but this also
|
||||
/// allows modifying the import meta object in more exotic ways before exposing it to ECMAScript
|
||||
/// code.
|
||||
///
|
||||
/// The default implementation of `HostGetImportMetaProperties` is to return a new empty List.
|
||||
///
|
||||
/// [meta]: https://tc39.es/ecma262/#sec-hostgetimportmetaproperties
|
||||
/// [final]: https://tc39.es/ecma262/#sec-hostfinalizeimportmeta
|
||||
fn init_import_meta( |
||||
&self, |
||||
_import_meta: &JsObject, |
||||
_module: &Module, |
||||
_context: &mut Context<'_>, |
||||
) { |
||||
} |
||||
} |
||||
|
||||
/// A module loader that throws when trying to load any modules.
|
||||
///
|
||||
/// Useful to disable the module system on platforms that don't have a filesystem, for example.
|
||||
#[derive(Debug, Clone, Copy)] |
||||
pub struct IdleModuleLoader; |
||||
|
||||
impl ModuleLoader for IdleModuleLoader { |
||||
fn load_imported_module( |
||||
&self, |
||||
_referrer: Referrer, |
||||
_specifier: JsString, |
||||
finish_load: Box<dyn FnOnce(JsResult<Module>, &mut Context<'_>)>, |
||||
context: &mut Context<'_>, |
||||
) { |
||||
finish_load( |
||||
Err(JsNativeError::typ() |
||||
.with_message("module resolution is disabled for this context") |
||||
.into()), |
||||
context, |
||||
); |
||||
} |
||||
} |
||||
|
||||
/// A simple module loader that loads modules relative to a root path.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// This loader only works by using the type methods [`SimpleModuleLoader::insert`] and
|
||||
/// [`SimpleModuleLoader::get`]. The utility methods on [`ModuleLoader`] don't work at the moment,
|
||||
/// but we'll unify both APIs in the future.
|
||||
#[derive(Debug)] |
||||
pub struct SimpleModuleLoader { |
||||
root: PathBuf, |
||||
module_map: GcRefCell<FxHashMap<PathBuf, Module>>, |
||||
} |
||||
|
||||
impl SimpleModuleLoader { |
||||
/// Creates a new `SimpleModuleLoader` from a root module path.
|
||||
pub fn new<P: AsRef<Path>>(root: P) -> JsResult<Self> { |
||||
if cfg!(target_family = "wasm") { |
||||
return Err(JsNativeError::typ() |
||||
.with_message("cannot resolve a relative path in WASM targets") |
||||
.into()); |
||||
} |
||||
let root = root.as_ref(); |
||||
let absolute = root.canonicalize().map_err(|e| { |
||||
JsNativeError::typ() |
||||
.with_message(format!("could not set module root `{}`", root.display())) |
||||
.with_cause(JsError::from_opaque(js_string!(e.to_string()).into())) |
||||
})?; |
||||
Ok(Self { |
||||
root: absolute, |
||||
module_map: GcRefCell::default(), |
||||
}) |
||||
} |
||||
|
||||
/// Inserts a new module onto the module map.
|
||||
#[inline] |
||||
pub fn insert(&self, path: PathBuf, module: Module) { |
||||
self.module_map.borrow_mut().insert(path, module); |
||||
} |
||||
|
||||
/// Gets a module from its original path.
|
||||
#[inline] |
||||
pub fn get(&self, path: &Path) -> Option<Module> { |
||||
self.module_map.borrow().get(path).cloned() |
||||
} |
||||
} |
||||
|
||||
impl ModuleLoader for SimpleModuleLoader { |
||||
fn load_imported_module( |
||||
&self, |
||||
_referrer: Referrer, |
||||
specifier: JsString, |
||||
finish_load: Box<dyn FnOnce(JsResult<Module>, &mut Context<'_>)>, |
||||
context: &mut Context<'_>, |
||||
) { |
||||
let result = (|| { |
||||
let path = specifier |
||||
.to_std_string() |
||||
.map_err(|err| JsNativeError::typ().with_message(err.to_string()))?; |
||||
let short_path = Path::new(&path); |
||||
let path = self.root.join(short_path); |
||||
let path = path.canonicalize().map_err(|err| { |
||||
JsNativeError::typ() |
||||
.with_message(format!( |
||||
"could not canonicalize path `{}`", |
||||
short_path.display() |
||||
)) |
||||
.with_cause(JsError::from_opaque(js_string!(err.to_string()).into())) |
||||
})?; |
||||
if let Some(module) = self.get(&path) { |
||||
return Ok(module); |
||||
} |
||||
let source = Source::from_filepath(&path).map_err(|err| { |
||||
JsNativeError::typ() |
||||
.with_message(format!("could not open file `{}`", short_path.display())) |
||||
.with_cause(JsError::from_opaque(js_string!(err.to_string()).into())) |
||||
})?; |
||||
let module = Module::parse(source, None, context).map_err(|err| { |
||||
JsNativeError::syntax() |
||||
.with_message(format!("could not parse module `{}`", short_path.display())) |
||||
.with_cause(err) |
||||
})?; |
||||
self.insert(path, module.clone()); |
||||
Ok(module) |
||||
})(); |
||||
|
||||
finish_load(result, context); |
||||
} |
||||
} |
||||
@ -0,0 +1,383 @@
|
||||
use std::rc::Rc; |
||||
|
||||
use boa_ast::expression::Identifier; |
||||
use boa_gc::{Finalize, Gc, GcRefCell, Trace, WeakGc}; |
||||
use boa_interner::Sym; |
||||
use rustc_hash::FxHashSet; |
||||
|
||||
use crate::{ |
||||
builtins::promise::ResolvingFunctions, |
||||
bytecompiler::ByteCompiler, |
||||
environments::{CompileTimeEnvironment, EnvironmentStack}, |
||||
object::JsPromise, |
||||
vm::{ActiveRunnable, CallFrame, CodeBlock}, |
||||
Context, JsNativeError, JsResult, JsString, JsValue, Module, |
||||
}; |
||||
|
||||
use super::{BindingName, ModuleRepr, ResolveExportError, ResolvedBinding}; |
||||
|
||||
trait TraceableCallback: Trace { |
||||
fn call(&self, module: &SyntheticModule, context: &mut Context<'_>) -> JsResult<()>; |
||||
} |
||||
|
||||
#[derive(Trace, Finalize)] |
||||
struct Callback<F, T> |
||||
where |
||||
F: Fn(&SyntheticModule, &T, &mut Context<'_>) -> JsResult<()>, |
||||
T: Trace, |
||||
{ |
||||
// SAFETY: `SyntheticModuleInitializer`'s safe API ensures only `Copy` closures are stored; its unsafe API,
|
||||
// on the other hand, explains the invariants to hold in order for this to be safe, shifting
|
||||
// the responsibility to the caller.
|
||||
#[unsafe_ignore_trace] |
||||
f: F, |
||||
captures: T, |
||||
} |
||||
|
||||
impl<F, T> TraceableCallback for Callback<F, T> |
||||
where |
||||
F: Fn(&SyntheticModule, &T, &mut Context<'_>) -> JsResult<()>, |
||||
T: Trace, |
||||
{ |
||||
fn call(&self, module: &SyntheticModule, context: &mut Context<'_>) -> JsResult<()> { |
||||
(self.f)(module, &self.captures, context) |
||||
} |
||||
} |
||||
|
||||
/// The initializing steps of a [`SyntheticModule`].
|
||||
///
|
||||
/// # Caveats
|
||||
///
|
||||
/// By limitations of the Rust language, the garbage collector currently cannot inspect closures
|
||||
/// in order to trace their captured variables. This means that only [`Copy`] closures are 100% safe
|
||||
/// to use. All other closures can also be stored in a `NativeFunction`, albeit by using an `unsafe`
|
||||
/// API, but note that passing closures implicitly capturing traceable types could cause
|
||||
/// **Undefined Behaviour**.
|
||||
#[derive(Clone, Trace, Finalize)] |
||||
pub struct SyntheticModuleInitializer { |
||||
inner: Gc<dyn TraceableCallback>, |
||||
} |
||||
|
||||
impl std::fmt::Debug for SyntheticModuleInitializer { |
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
||||
f.debug_struct("ModuleInitializer").finish_non_exhaustive() |
||||
} |
||||
} |
||||
|
||||
impl SyntheticModuleInitializer { |
||||
/// Creates a `SyntheticModuleInitializer` from a [`Copy`] closure.
|
||||
pub fn from_copy_closure<F>(closure: F) -> Self |
||||
where |
||||
F: Fn(&SyntheticModule, &mut Context<'_>) -> JsResult<()> + Copy + 'static, |
||||
{ |
||||
// SAFETY: The `Copy` bound ensures there are no traceable types inside the closure.
|
||||
unsafe { Self::from_closure(closure) } |
||||
} |
||||
|
||||
/// Creates a `SyntheticModuleInitializer` from a [`Copy`] closure and a list of traceable captures.
|
||||
pub fn from_copy_closure_with_captures<F, T>(closure: F, captures: T) -> Self |
||||
where |
||||
F: Fn(&SyntheticModule, &T, &mut Context<'_>) -> JsResult<()> + Copy + 'static, |
||||
T: Trace + 'static, |
||||
{ |
||||
// SAFETY: The `Copy` bound ensures there are no traceable types inside the closure.
|
||||
unsafe { Self::from_closure_with_captures(closure, captures) } |
||||
} |
||||
|
||||
/// Creates a new `SyntheticModuleInitializer` from a closure.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// Passing a closure that contains a captured variable that needs to be traced by the garbage
|
||||
/// collector could cause an use after free, memory corruption or other kinds of **Undefined
|
||||
/// Behaviour**. See <https://github.com/Manishearth/rust-gc/issues/50> for a technical explanation
|
||||
/// on why that is the case.
|
||||
pub unsafe fn from_closure<F>(closure: F) -> Self |
||||
where |
||||
F: Fn(&SyntheticModule, &mut Context<'_>) -> JsResult<()> + 'static, |
||||
{ |
||||
// SAFETY: The caller must ensure the invariants of the closure hold.
|
||||
unsafe { |
||||
Self::from_closure_with_captures(move |module, _, context| closure(module, context), ()) |
||||
} |
||||
} |
||||
|
||||
/// Create a new `SyntheticModuleInitializer` from a closure and a list of traceable captures.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// Passing a closure that contains a captured variable that needs to be traced by the garbage
|
||||
/// collector could cause an use after free, memory corruption or other kinds of **Undefined
|
||||
/// Behaviour**. See <https://github.com/Manishearth/rust-gc/issues/50> for a technical explanation
|
||||
/// on why that is the case.
|
||||
pub unsafe fn from_closure_with_captures<F, T>(closure: F, captures: T) -> Self |
||||
where |
||||
F: Fn(&SyntheticModule, &T, &mut Context<'_>) -> JsResult<()> + 'static, |
||||
T: Trace + 'static, |
||||
{ |
||||
// Hopefully, this unsafe operation will be replaced by the `CoerceUnsized` API in the
|
||||
// future: https://github.com/rust-lang/rust/issues/18598
|
||||
let ptr = Gc::into_raw(Gc::new(Callback { |
||||
f: closure, |
||||
captures, |
||||
})); |
||||
|
||||
// SAFETY: The pointer returned by `into_raw` is only used to coerce to a trait object,
|
||||
// meaning this is safe.
|
||||
unsafe { |
||||
Self { |
||||
inner: Gc::from_raw(ptr), |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Calls this `SyntheticModuleInitializer`, forwarding the arguments to the corresponding function.
|
||||
#[inline] |
||||
pub fn call(&self, module: &SyntheticModule, context: &mut Context<'_>) -> JsResult<()> { |
||||
self.inner.call(module, context) |
||||
} |
||||
} |
||||
|
||||
/// ECMAScript's [**Synthetic Module Records**][spec].
|
||||
///
|
||||
/// [spec]: https://tc39.es/proposal-json-modules/#sec-synthetic-module-records
|
||||
#[derive(Clone, Trace, Finalize)] |
||||
pub struct SyntheticModule { |
||||
inner: Gc<Inner>, |
||||
} |
||||
|
||||
impl std::fmt::Debug for SyntheticModule { |
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
||||
f.debug_struct("SyntheticModule") |
||||
.field("export_names", &self.inner.export_names) |
||||
.field("eval_steps", &self.inner.eval_steps) |
||||
.finish_non_exhaustive() |
||||
} |
||||
} |
||||
|
||||
#[derive(Trace, Finalize)] |
||||
struct Inner { |
||||
parent: WeakGc<ModuleRepr>, |
||||
#[unsafe_ignore_trace] |
||||
export_names: FxHashSet<Sym>, |
||||
eval_context: GcRefCell<Option<(EnvironmentStack, Gc<CodeBlock>)>>, |
||||
eval_steps: SyntheticModuleInitializer, |
||||
} |
||||
|
||||
impl SyntheticModule { |
||||
/// Gets the parent module of this source module.
|
||||
fn parent(&self) -> Module { |
||||
Module { |
||||
inner: self |
||||
.inner |
||||
.parent |
||||
.upgrade() |
||||
.expect("parent module must be live"), |
||||
} |
||||
} |
||||
|
||||
/// Creates a new synthetic module.
|
||||
pub(super) fn new( |
||||
names: FxHashSet<Sym>, |
||||
eval_steps: SyntheticModuleInitializer, |
||||
parent: WeakGc<ModuleRepr>, |
||||
) -> Self { |
||||
Self { |
||||
inner: Gc::new(Inner { |
||||
parent, |
||||
export_names: names, |
||||
eval_steps, |
||||
eval_context: GcRefCell::default(), |
||||
}), |
||||
} |
||||
} |
||||
|
||||
/// Concrete method [`LoadRequestedModules ( )`][spec].
|
||||
///
|
||||
/// [spec]: https://tc39.es/proposal-json-modules/#sec-smr-LoadRequestedModules
|
||||
pub(super) fn load(context: &mut Context<'_>) -> JsPromise { |
||||
// 1. Return ! PromiseResolve(%Promise%, undefined).
|
||||
JsPromise::resolve(JsValue::undefined(), context) |
||||
.expect("creating a promise from the %Promise% constructor must not fail") |
||||
} |
||||
|
||||
/// Concrete method [`GetExportedNames ( [ exportStarSet ] )`][spec].
|
||||
///
|
||||
/// [spec]: https://tc39.es/proposal-json-modules/#sec-smr-getexportednames
|
||||
pub(super) fn get_exported_names(&self) -> FxHashSet<Sym> { |
||||
// 1. Return module.[[ExportNames]].
|
||||
self.inner.export_names.clone() |
||||
} |
||||
|
||||
/// Concrete method [`ResolveExport ( exportName )`][spec]
|
||||
///
|
||||
/// [spec]: https://tc39.es/proposal-json-modules/#sec-smr-resolveexport
|
||||
#[allow(clippy::mutable_key_type)] |
||||
pub(super) fn resolve_export( |
||||
&self, |
||||
export_name: Sym, |
||||
) -> Result<ResolvedBinding, ResolveExportError> { |
||||
if self.inner.export_names.contains(&export_name) { |
||||
// 2. Return ResolvedBinding Record { [[Module]]: module, [[BindingName]]: exportName }.
|
||||
Ok(ResolvedBinding { |
||||
module: self.parent(), |
||||
binding_name: BindingName::Name(Identifier::new(export_name)), |
||||
}) |
||||
} else { |
||||
// 1. If module.[[ExportNames]] does not contain exportName, return null.
|
||||
Err(ResolveExportError::NotFound) |
||||
} |
||||
} |
||||
|
||||
/// Concrete method [`Link ( )`][spec].
|
||||
///
|
||||
/// [spec]: https://tc39.es/ecma262/#sec-moduledeclarationlinking
|
||||
pub(super) fn link(&self, context: &mut Context<'_>) { |
||||
let parent = self.parent(); |
||||
// 1. Let realm be module.[[Realm]].
|
||||
// 2. Let env be NewModuleEnvironment(realm.[[GlobalEnv]]).
|
||||
// 3. Set module.[[Environment]] to env.
|
||||
let global_env = parent.realm().environment().clone(); |
||||
let global_compile_env = global_env.compile_env(); |
||||
let module_compile_env = Rc::new(CompileTimeEnvironment::new(global_compile_env, true)); |
||||
|
||||
// TODO: A bit of a hack to be able to pass the currently active runnable without an
|
||||
// available codeblock to execute.
|
||||
let compiler = ByteCompiler::new( |
||||
Sym::MAIN, |
||||
true, |
||||
false, |
||||
module_compile_env.clone(), |
||||
module_compile_env.clone(), |
||||
context, |
||||
); |
||||
|
||||
// 4. For each String exportName in module.[[ExportNames]], do
|
||||
let exports = self |
||||
.inner |
||||
.export_names |
||||
.iter() |
||||
.map(|name| { |
||||
let ident = Identifier::new(*name); |
||||
// a. Perform ! env.CreateMutableBinding(exportName, false).
|
||||
module_compile_env.create_mutable_binding(ident, false) |
||||
}) |
||||
.collect::<Vec<_>>(); |
||||
|
||||
let cb = Gc::new(compiler.finish()); |
||||
|
||||
let mut envs = EnvironmentStack::new(global_env); |
||||
envs.push_module(module_compile_env); |
||||
|
||||
for locator in exports { |
||||
// b. Perform ! env.InitializeBinding(exportName, undefined).
|
||||
envs.put_lexical_value( |
||||
locator.environment_index(), |
||||
locator.binding_index(), |
||||
JsValue::undefined(), |
||||
); |
||||
} |
||||
|
||||
*parent.inner.environment.borrow_mut() = envs.current().as_declarative().cloned(); |
||||
|
||||
*self.inner.eval_context.borrow_mut() = Some((envs, cb)); |
||||
|
||||
// 5. Return unused.
|
||||
} |
||||
|
||||
/// Concrete method [`Evaluate ( )`][spec].
|
||||
///
|
||||
/// [spec]: https://tc39.es/proposal-json-modules/#sec-smr-Evaluate
|
||||
pub(super) fn evaluate(&self, context: &mut Context<'_>) -> JsPromise { |
||||
// 1. Let moduleContext be a new ECMAScript code execution context.
|
||||
|
||||
let parent = self.parent(); |
||||
let mut realm = parent.realm().clone(); |
||||
let (mut environments, codeblock) = self |
||||
.inner |
||||
.eval_context |
||||
.borrow() |
||||
.clone() |
||||
.expect("should have been initialized on `link`"); |
||||
|
||||
let env_fp = environments.len() as u32; |
||||
let callframe = CallFrame::new( |
||||
codeblock, |
||||
// 4. Set the ScriptOrModule of moduleContext to module.
|
||||
Some(ActiveRunnable::Module(parent)), |
||||
// 2. Set the Function of moduleContext to null.
|
||||
None, |
||||
) |
||||
.with_env_fp(env_fp); |
||||
|
||||
// 5. Set the VariableEnvironment of moduleContext to module.[[Environment]].
|
||||
// 6. Set the LexicalEnvironment of moduleContext to module.[[Environment]].
|
||||
std::mem::swap(&mut context.vm.environments, &mut environments); |
||||
// 3. Set the Realm of moduleContext to module.[[Realm]].
|
||||
context.swap_realm(&mut realm); |
||||
// 7. Suspend the currently running execution context.
|
||||
// 8. Push moduleContext on to the execution context stack; moduleContext is now the running execution context.
|
||||
context.vm.push_frame(callframe); |
||||
|
||||
// 9. Let steps be module.[[EvaluationSteps]].
|
||||
// 10. Let result be Completion(steps(module)).
|
||||
let result = self.inner.eval_steps.call(self, context); |
||||
|
||||
// 11. Suspend moduleContext and remove it from the execution context stack.
|
||||
// 12. Resume the context that is now on the top of the execution context stack as the running execution context.
|
||||
std::mem::swap(&mut context.vm.environments, &mut environments); |
||||
context.swap_realm(&mut realm); |
||||
context.vm.pop_frame(); |
||||
|
||||
// 13. Let pc be ! NewPromiseCapability(%Promise%).
|
||||
let (promise, ResolvingFunctions { resolve, reject }) = JsPromise::new_pending(context); |
||||
|
||||
match result { |
||||
// 15. Perform ! pc.[[Resolve]](result).
|
||||
Ok(()) => resolve.call(&JsValue::undefined(), &[], context), |
||||
// 14. IfAbruptRejectPromise(result, pc).
|
||||
Err(err) => reject.call(&JsValue::undefined(), &[err.to_opaque(context)], context), |
||||
} |
||||
.expect("default resolving functions cannot throw"); |
||||
|
||||
// 16. Return pc.[[Promise]].
|
||||
promise |
||||
} |
||||
|
||||
/// Abstract operation [`SetSyntheticModuleExport ( module, exportName, exportValue )`][spec].
|
||||
///
|
||||
/// Sets or changes the exported value for `exportName` in the synthetic module.
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// The default export corresponds to the name `"default"`, but note that it needs to
|
||||
/// be passed to the list of exported names in [`Module::synthetic`] beforehand.
|
||||
///
|
||||
/// [spec]: https://tc39.es/proposal-json-modules/#sec-createsyntheticmodule
|
||||
pub fn set_export( |
||||
&self, |
||||
export_name: &JsString, |
||||
export_value: JsValue, |
||||
context: &mut Context<'_>, |
||||
) -> JsResult<()> { |
||||
let identifier = context.interner_mut().get_or_intern(&**export_name); |
||||
let identifier = Identifier::new(identifier); |
||||
|
||||
let environment = self |
||||
.parent() |
||||
.environment() |
||||
.expect("this must be initialized before evaluating"); |
||||
let locator = environment |
||||
.compile_env() |
||||
.get_binding(identifier) |
||||
.ok_or_else(|| { |
||||
JsNativeError::reference().with_message(format!( |
||||
"cannot set name `{}` which was not included in the list of exports", |
||||
export_name.to_std_string_escaped() |
||||
)) |
||||
})?; |
||||
environment.set(locator.binding_index(), export_value); |
||||
|
||||
Ok(()) |
||||
} |
||||
} |
||||
@ -0,0 +1,180 @@
|
||||
// This example implements a synthetic Rust module that is exposed to JS code.
|
||||
// This mirrors the `modules.rs` example but uses synthetic modules instead.
|
||||
|
||||
use std::path::PathBuf; |
||||
use std::{error::Error, path::Path}; |
||||
|
||||
use boa_engine::builtins::promise::PromiseState; |
||||
use boa_engine::module::{ModuleLoader, SimpleModuleLoader, SyntheticModuleInitializer}; |
||||
use boa_engine::object::FunctionObjectBuilder; |
||||
use boa_engine::{ |
||||
js_string, Context, JsArgs, JsError, JsNativeError, JsValue, Module, NativeFunction, Source, |
||||
}; |
||||
|
||||
fn main() -> Result<(), Box<dyn Error>> { |
||||
// A simple module that we want to compile from Rust code.
|
||||
const MODULE_SRC: &str = r#" |
||||
import { pyth } from "./trig.mjs"; |
||||
import * as ops from "./operations.mjs"; |
||||
|
||||
export let result = pyth(3, 4); |
||||
export function mix(a, b) { |
||||
return ops.sum(ops.mult(a, ops.sub(b, a)), 10); |
||||
} |
||||
"#; |
||||
|
||||
// This can be overriden with any custom implementation of `ModuleLoader`.
|
||||
let loader = &SimpleModuleLoader::new("./scripts/modules")?; |
||||
let dyn_loader: &dyn ModuleLoader = loader; |
||||
|
||||
// Just need to cast to a `ModuleLoader` before passing it to the builder.
|
||||
let context = &mut Context::builder().module_loader(dyn_loader).build()?; |
||||
|
||||
// Now, create the synthetic module and insert it into the loader.
|
||||
let operations = create_operations_module(context); |
||||
loader.insert( |
||||
PathBuf::from("./scripts/modules") |
||||
.canonicalize()? |
||||
.join("operations.mjs"), |
||||
operations, |
||||
); |
||||
|
||||
let source = Source::from_reader(MODULE_SRC.as_bytes(), Some(Path::new("./main.mjs"))); |
||||
|
||||
// Can also pass a `Some(realm)` if you need to execute the module in another realm.
|
||||
let module = Module::parse(source, None, context)?; |
||||
|
||||
// Don't forget to insert the parsed module into the loader itself, since the root module
|
||||
// is not automatically inserted by the `ModuleLoader::load_imported_module` impl.
|
||||
//
|
||||
// Simulate as if the "fake" module is located in the modules root, just to ensure that
|
||||
// the loader won't double load in case someone tries to import "./main.mjs".
|
||||
loader.insert( |
||||
Path::new("./scripts/modules") |
||||
.canonicalize()? |
||||
.join("main.mjs"), |
||||
module.clone(), |
||||
); |
||||
|
||||
// This uses the utility function to load, link and evaluate a module without having to deal
|
||||
// with callbacks. For an example demonstrating the whole lifecycle of a module, see
|
||||
// `modules.rs`
|
||||
let promise_result = module.load_link_evaluate(context)?; |
||||
|
||||
// Very important to push forward the job queue after queueing promises.
|
||||
context.run_jobs(); |
||||
|
||||
// Checking if the final promise didn't return an error.
|
||||
match promise_result.state()? { |
||||
PromiseState::Pending => return Err("module didn't execute!".into()), |
||||
PromiseState::Fulfilled(v) => { |
||||
assert_eq!(v, JsValue::undefined()) |
||||
} |
||||
PromiseState::Rejected(err) => { |
||||
return Err(JsError::from_opaque(err).try_native(context)?.into()) |
||||
} |
||||
} |
||||
|
||||
// We can access the full namespace of the module with all its exports.
|
||||
let namespace = module.namespace(context); |
||||
let result = namespace.get(js_string!("result"), context)?; |
||||
|
||||
println!("result = {}", result.display()); |
||||
|
||||
assert_eq!( |
||||
namespace.get(js_string!("result"), context)?, |
||||
JsValue::from(5) |
||||
); |
||||
|
||||
let mix = namespace |
||||
.get(js_string!("mix"), context)? |
||||
.as_callable() |
||||
.cloned() |
||||
.ok_or_else(|| JsNativeError::typ().with_message("mix export wasn't a function!"))?; |
||||
let result = mix.call(&JsValue::undefined(), &[5.into(), 10.into()], context)?; |
||||
|
||||
println!("mix(5, 10) = {}", result.display()); |
||||
|
||||
assert_eq!(result, 35.into()); |
||||
|
||||
Ok(()) |
||||
} |
||||
|
||||
// Creates the synthetic equivalent to the `./modules/operations.mjs` file.
|
||||
fn create_operations_module(context: &mut Context<'_>) -> Module { |
||||
// We first create the function objects that will be exported by the module. More
|
||||
// on that below.
|
||||
let sum = FunctionObjectBuilder::new( |
||||
context.realm(), |
||||
NativeFunction::from_fn_ptr(|_, args, ctx| { |
||||
args.get_or_undefined(0).add(args.get_or_undefined(1), ctx) |
||||
}), |
||||
) |
||||
.length(2) |
||||
.name(js_string!("sum")) |
||||
.build(); |
||||
let sub = FunctionObjectBuilder::new( |
||||
context.realm(), |
||||
NativeFunction::from_fn_ptr(|_, args, ctx| { |
||||
args.get_or_undefined(0).sub(args.get_or_undefined(1), ctx) |
||||
}), |
||||
) |
||||
.length(2) |
||||
.name(js_string!("sub")) |
||||
.build(); |
||||
let mult = FunctionObjectBuilder::new( |
||||
context.realm(), |
||||
NativeFunction::from_fn_ptr(|_, args, ctx| { |
||||
args.get_or_undefined(0).mul(args.get_or_undefined(1), ctx) |
||||
}), |
||||
) |
||||
.length(2) |
||||
.name(js_string!("mult")) |
||||
.build(); |
||||
let div = FunctionObjectBuilder::new( |
||||
context.realm(), |
||||
NativeFunction::from_fn_ptr(|_, args, ctx| { |
||||
args.get_or_undefined(0).div(args.get_or_undefined(1), ctx) |
||||
}), |
||||
) |
||||
.length(2) |
||||
.name(js_string!("div")) |
||||
.build(); |
||||
let sqrt = FunctionObjectBuilder::new( |
||||
context.realm(), |
||||
NativeFunction::from_fn_ptr(|_, args, ctx| { |
||||
let a = args.get_or_undefined(0).to_number(ctx)?; |
||||
Ok(JsValue::from(a.sqrt())) |
||||
}), |
||||
) |
||||
.length(1) |
||||
.name(js_string!("sqrt")) |
||||
.build(); |
||||
|
||||
Module::synthetic( |
||||
// Make sure to list all exports beforehand.
|
||||
&[ |
||||
js_string!("sum"), |
||||
js_string!("sub"), |
||||
js_string!("mult"), |
||||
js_string!("div"), |
||||
js_string!("sqrt"), |
||||
], |
||||
// The initializer is evaluated every time a module imports this synthetic module,
|
||||
// so we avoid creating duplicate objects by capturing and cloning them instead.
|
||||
SyntheticModuleInitializer::from_copy_closure_with_captures( |
||||
|module, fns, context| { |
||||
println!("Running initializer!"); |
||||
module.set_export(&js_string!("sum"), fns.0.clone().into(), context)?; |
||||
module.set_export(&js_string!("sub"), fns.1.clone().into(), context)?; |
||||
module.set_export(&js_string!("mult"), fns.2.clone().into(), context)?; |
||||
module.set_export(&js_string!("div"), fns.3.clone().into(), context)?; |
||||
module.set_export(&js_string!("sqrt"), fns.4.clone().into(), context)?; |
||||
Ok(()) |
||||
}, |
||||
(sum, sub, mult, div, sqrt), |
||||
), |
||||
None, |
||||
context, |
||||
) |
||||
} |
||||
Loading…
Reference in new issue