585 lines
28 KiB
Rust
585 lines
28 KiB
Rust
//! 模块编译：import/export 解析、依赖加载（递归）、快照式链接与命名空间。
|
||
//!
|
||
//! 快照式链接：依赖模块先整体求值（`__moduleEval`）并返回命名空间对象，
|
||
//! 导入绑定在 prelude 一次性初始化；`export` 语句就地注册导出值。
|
||
//! live binding / defer / source-phase 语义留待后续轮次（循环导入在编译期跳过）。
|
||
|
||
use std::collections::HashSet;
|
||
use std::path::Path;
|
||
|
||
use crate::expr::call::pack_arg_regs;
|
||
use crate::{CompileCtx, Emitter};
|
||
use oxc_allocator::Box;
|
||
use oxide_bytecode::module::Constant;
|
||
use oxide_bytecode::opcode::OpCode;
|
||
use oxide_ir::inst::Inst;
|
||
use oxide_ir::operand::Operand;
|
||
use oxide_ir::{IRFunction, ParamLayout};
|
||
use oxide_parser::{
|
||
BindingPattern, Declaration, ExportDefaultDeclarationKind, ImportAttributeKey, ImportDeclarationSpecifier,
|
||
ModuleExportName, Statement, VariableDeclarationKind, WithClause,
|
||
};
|
||
|
||
/// 数据模块种类（非 JS 源码模块）。
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum ModuleKind {
|
||
Js,
|
||
Json,
|
||
Text,
|
||
Bytes,
|
||
}
|
||
|
||
/// 已解析的依赖模块。
|
||
pub struct ResolvedModule {
|
||
/// 模块源码（JS / 数据内容）。
|
||
pub source: String,
|
||
/// 模块规范路径（用于自身导入识别与循环检测）。
|
||
pub path: String,
|
||
/// 模块种类。
|
||
pub kind: ModuleKind,
|
||
}
|
||
|
||
/// 模块加载器：由调用方（test262 runner / CLI）提供文件解析。
|
||
pub trait ModuleSourceLoader {
|
||
fn resolve(
|
||
&mut self, base_dir: &str, specifier: &str, attributes: &[(&str, &str)],
|
||
) -> Result<ResolvedModule, String>;
|
||
}
|
||
|
||
fn module_export_name_str(m: &ModuleExportName) -> String {
|
||
match m {
|
||
ModuleExportName::IdentifierName(i) => i.name.to_string(),
|
||
ModuleExportName::IdentifierReference(i) => i.name.to_string(),
|
||
ModuleExportName::StringLiteral(s) => s.value.to_string(),
|
||
}
|
||
}
|
||
|
||
fn module_attributes(with_clause: &Option<Box<'_, WithClause<'_>>>) -> Vec<(String, String)> {
|
||
let mut out = Vec::new();
|
||
if let Some(wc) = with_clause {
|
||
for attr in &wc.with_entries {
|
||
let key = match &attr.key {
|
||
ImportAttributeKey::Identifier(id) => id.name.to_string(),
|
||
ImportAttributeKey::StringLiteral(s) => s.value.to_string(),
|
||
};
|
||
out.push((key, attr.value.value.to_string()));
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// 收集模块自身直接导出的名称集合（含字符串导出名与 default）：
|
||
/// 供 self-import 链接期校验（自引用导入不存在的导出 → 编译期错误）。
|
||
fn module_own_export_names(body: &[Statement]) -> HashSet<String> {
|
||
let mut names = HashSet::new();
|
||
for stmt in body {
|
||
match stmt {
|
||
Statement::ExportNamedDeclaration(exp) => {
|
||
if let Some(decl) = &exp.declaration {
|
||
match decl {
|
||
Declaration::VariableDeclaration(vd) => {
|
||
for d in &vd.declarations {
|
||
if let BindingPattern::BindingIdentifier(bi) = &d.id {
|
||
names.insert(bi.name.to_string());
|
||
}
|
||
}
|
||
}
|
||
Declaration::FunctionDeclaration(fd) => {
|
||
if let Some(id) = &fd.id {
|
||
names.insert(id.name.to_string());
|
||
}
|
||
}
|
||
Declaration::ClassDeclaration(cl) => {
|
||
if let Some(id) = &cl.id {
|
||
names.insert(id.name.to_string());
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
} else {
|
||
for spec in &exp.specifiers {
|
||
names.insert(module_export_name_str(&spec.exported));
|
||
}
|
||
}
|
||
}
|
||
Statement::ExportDefaultDeclaration(_) => {
|
||
names.insert("default".to_string());
|
||
}
|
||
Statement::ExportAllDeclaration(exp) => {
|
||
if let Some(exported) = &exp.exported {
|
||
names.insert(module_export_name_str(exported));
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
names
|
||
}
|
||
|
||
fn is_hoisted_function_decl(stmt: &Statement) -> bool {
|
||
match stmt {
|
||
Statement::FunctionDeclaration(_) => true,
|
||
Statement::ExportNamedDeclaration(exp) => {
|
||
matches!(&exp.declaration, Some(Declaration::FunctionDeclaration(_)))
|
||
}
|
||
_ => false,
|
||
}
|
||
}
|
||
|
||
impl Emitter {
|
||
/// 编译 ES module：顶层 body + 递归依赖。
|
||
/// `module_path` 为模块文件的规范路径（依赖解析基准 = 其父目录）。
|
||
pub fn emit_program_module(
|
||
&self, program: &oxide_parser::Program, module_path: &str, loader: &mut dyn ModuleSourceLoader,
|
||
) -> Result<IRFunction, String> {
|
||
crate::emit_debug!("emit_program_module: {} stmts", program.body.len());
|
||
let mut ctx = CompileCtx::new();
|
||
// 模块顶层 var/function 不写全局对象（模块作用域绑定）。
|
||
ctx.is_global_scope = false;
|
||
// ES module 顶层恒严格模式（模块代码是严格模式代码，嵌套函数经父 ctx 继承）。
|
||
ctx.is_strict = true;
|
||
let mut path_stack = vec![module_path.to_string()];
|
||
self.emit_module_into_ctx(program, module_path, loader, &mut path_stack, &mut ctx)?;
|
||
Ok(ctx.assemble_ir(ParamLayout { base: 0, count: 0 }, None))
|
||
}
|
||
|
||
/// 模块体 emit（顶层与依赖模块共用入口）。
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn emit_module_into_ctx(
|
||
&self, program: &oxide_parser::Program, module_path: &str, loader: &mut dyn ModuleSourceLoader,
|
||
path_stack: &mut Vec<String>, ctx: &mut CompileCtx,
|
||
) -> Result<(), String> {
|
||
let body = &program.body;
|
||
|
||
// —— 预声明（镜像 emit_program；import/export 包装的声明也计入 hoisting）——
|
||
self.predeclare_function_declarations(body, ctx);
|
||
self.pre_register_builtin_references(body, ctx);
|
||
self.predeclare_var_declarations(body, ctx);
|
||
self.predeclare_lexical_declarations(body, ctx);
|
||
|
||
// 闭包捕获分析（import 绑定名纳入 own_bindings，供嵌套函数 cell 捕获）。
|
||
ctx.own_bindings = self.collect_own_binding_names(&[], body);
|
||
ctx.captured_bindings = self.collect_captured_bindings(body, &[], &ctx.own_bindings);
|
||
|
||
// —— 模块命名空间对象 ——
|
||
let ns_reg = self.emit_module_call(ctx, "__moduleObject", &[])?;
|
||
ctx.module_ns_reg = Some(ns_reg);
|
||
|
||
// —— 依赖收集（import + re-export/star 的 source，按首次出现去重）——
|
||
let base_dir = Path::new(module_path)
|
||
.parent()
|
||
.map(|p| p.to_string_lossy().to_string())
|
||
.unwrap_or_default();
|
||
let mut deps: Vec<(String, Vec<(String, String)>)> = Vec::new();
|
||
for stmt in body {
|
||
let (spec, attrs) = match stmt {
|
||
Statement::ImportDeclaration(imp) => {
|
||
(imp.source.value.to_string(), module_attributes(&imp.with_clause))
|
||
}
|
||
Statement::ExportNamedDeclaration(exp) => {
|
||
if let Some(src) = &exp.source {
|
||
(src.value.to_string(), module_attributes(&exp.with_clause))
|
||
} else {
|
||
continue;
|
||
}
|
||
}
|
||
Statement::ExportAllDeclaration(exp) => {
|
||
(exp.source.value.to_string(), module_attributes(&exp.with_clause))
|
||
}
|
||
_ => continue,
|
||
};
|
||
if !deps.iter().any(|(s, _)| *s == spec) {
|
||
deps.push((spec, attrs));
|
||
}
|
||
}
|
||
|
||
// —— 编译并求值依赖 ——
|
||
for (spec, attrs) in deps {
|
||
let attr_refs: Vec<(&str, &str)> = attrs.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect();
|
||
let resolved = loader.resolve(&base_dir, &spec, &attr_refs)?;
|
||
let dep_ns_reg = if resolved.path == module_path {
|
||
// 自导入：读自身命名空间（依赖即本模块，勿递归）。
|
||
ns_reg
|
||
} else {
|
||
if path_stack.contains(&resolved.path) {
|
||
return Err(format!("circular module import not supported: {}", resolved.path));
|
||
}
|
||
path_stack.push(resolved.path.clone());
|
||
let dep_ir = match resolved.kind {
|
||
ModuleKind::Js => self.compile_js_dep(&resolved, loader, path_stack)?,
|
||
ModuleKind::Json => self.compile_data_dep("json", &resolved.source)?,
|
||
ModuleKind::Text => self.compile_data_dep("text", &resolved.source)?,
|
||
ModuleKind::Bytes => return Err("bytes module not supported".into()),
|
||
};
|
||
path_stack.pop();
|
||
ctx.nested.push(dep_ir);
|
||
let fn_reg = ctx.alloc_reg();
|
||
ctx.inst(Inst::create_closure(Operand::Reg(fn_reg), ctx.nested.len() as u16));
|
||
self.emit_module_call(ctx, "__moduleEval", &[fn_reg])?
|
||
};
|
||
ctx.module_dep_ns_regs.insert(spec.clone(), dep_ns_reg);
|
||
if resolved.path == module_path {
|
||
// 自导入：绑定走别名语义（源导出在 body 执行中才就绪），
|
||
// 不能像普通依赖那样链接期快照。
|
||
ctx.module_self_import_specs.insert(spec.clone());
|
||
}
|
||
}
|
||
|
||
// —— 导入绑定初始化（const 语义；命名空间绑定直接引用 ns 对象）——
|
||
let own_export_names = module_own_export_names(body);
|
||
// export * from 'x'（无命名再导出）会把依赖的全部导出转发给自身：
|
||
// self-import 的名称可能来自 star，编译期无法静态判定，校验放宽。
|
||
let has_unnamed_star = body
|
||
.iter()
|
||
.any(|s| matches!(s, Statement::ExportAllDeclaration(e) if e.exported.is_none()));
|
||
// 自导入（import from 自身）的绑定在 body 执行中由 export 语句回写：
|
||
// prelude 先初始化为 undefined（规范：实例化后未求值前 var 源绑定为
|
||
// undefined），并登记 导出名 → 本地绑定槽 供回写。
|
||
for stmt in body {
|
||
if let Statement::ImportDeclaration(imp) = stmt {
|
||
let dep_spec = imp.source.value.to_string();
|
||
let dep_ns_reg = *ctx
|
||
.module_dep_ns_regs
|
||
.get(&dep_spec)
|
||
.ok_or_else(|| format!("module dependency missing: {dep_spec}"))?;
|
||
let is_self = ctx.module_self_import_specs.contains(&dep_spec);
|
||
if let Some(specifiers) = &imp.specifiers {
|
||
for sp in specifiers {
|
||
match sp {
|
||
ImportDeclarationSpecifier::ImportSpecifier(s) => {
|
||
let imported = module_export_name_str(&s.imported);
|
||
if is_self {
|
||
if !own_export_names.contains(&imported) && !has_unnamed_star {
|
||
return Err(format!("requested module export is not exported: {imported}"));
|
||
}
|
||
let undef_idx = ctx.add_constant(Constant::Undefined);
|
||
let undef_reg = ctx.alloc_reg();
|
||
ctx.inst(Inst::load_const(Operand::Reg(undef_reg), undef_idx));
|
||
self.emit_bind_target(
|
||
s.local.name.as_str(),
|
||
undef_reg,
|
||
VariableDeclarationKind::Const,
|
||
true,
|
||
false,
|
||
ctx,
|
||
)?;
|
||
if let Ok(reg) = ctx.lookup(s.local.name.as_str()) {
|
||
ctx.module_self_aliases.insert(imported, reg);
|
||
}
|
||
} else {
|
||
let name_reg = self.load_string_const(&imported, ctx);
|
||
let val_reg =
|
||
self.emit_module_call(ctx, "__moduleLinkGet", &[dep_ns_reg, name_reg])?;
|
||
self.emit_bind_target(
|
||
s.local.name.as_str(),
|
||
val_reg,
|
||
VariableDeclarationKind::Const,
|
||
true,
|
||
false,
|
||
ctx,
|
||
)?;
|
||
}
|
||
}
|
||
ImportDeclarationSpecifier::ImportDefaultSpecifier(s) => {
|
||
if is_self {
|
||
if !own_export_names.contains("default") {
|
||
return Err("requested module export is not exported: default".into());
|
||
}
|
||
let undef_idx = ctx.add_constant(Constant::Undefined);
|
||
let undef_reg = ctx.alloc_reg();
|
||
ctx.inst(Inst::load_const(Operand::Reg(undef_reg), undef_idx));
|
||
self.emit_bind_target(
|
||
s.local.name.as_str(),
|
||
undef_reg,
|
||
VariableDeclarationKind::Const,
|
||
true,
|
||
false,
|
||
ctx,
|
||
)?;
|
||
if let Ok(reg) = ctx.lookup(s.local.name.as_str()) {
|
||
ctx.module_self_aliases.insert("default".to_string(), reg);
|
||
}
|
||
} else {
|
||
let name_reg = self.load_string_const("default", ctx);
|
||
let val_reg =
|
||
self.emit_module_call(ctx, "__moduleLinkGet", &[dep_ns_reg, name_reg])?;
|
||
self.emit_bind_target(
|
||
s.local.name.as_str(),
|
||
val_reg,
|
||
VariableDeclarationKind::Const,
|
||
true,
|
||
false,
|
||
ctx,
|
||
)?;
|
||
}
|
||
}
|
||
ImportDeclarationSpecifier::ImportNamespaceSpecifier(s) => {
|
||
// 命名空间绑定引用 ns 对象本身：自导入时同一对象，
|
||
// body 执行后导出自然可见。
|
||
self.emit_bind_target(
|
||
s.local.name.as_str(),
|
||
dep_ns_reg,
|
||
VariableDeclarationKind::Const,
|
||
true,
|
||
false,
|
||
ctx,
|
||
)?;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// —— re-export（export { x } from 'mod'）链接检查：实例化期解析，须先于
|
||
// body 求值（$DONOTEVALUATE 等断言依赖链接错误先抛）——
|
||
for stmt in body {
|
||
if let Statement::ExportNamedDeclaration(exp) = stmt {
|
||
if exp.declaration.is_some() {
|
||
continue;
|
||
}
|
||
if let Some(src) = &exp.source {
|
||
let dep_spec = src.value.to_string();
|
||
if ctx.module_self_import_specs.contains(&dep_spec) {
|
||
continue; // 自身导出未就绪，body 执行中再解析
|
||
}
|
||
if let Some(&dep_ns_reg) = ctx.module_dep_ns_regs.get(&dep_spec) {
|
||
for spec in &exp.specifiers {
|
||
let local_name = module_export_name_str(&spec.local);
|
||
let name_reg = self.load_string_const(&local_name, ctx);
|
||
self.emit_module_call(ctx, "__moduleLinkGet", &[dep_ns_reg, name_reg])?;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// —— body（函数声明 hoisting 先发，随后其余；import 已由 prelude 处理）——
|
||
for stmt in body {
|
||
if is_hoisted_function_decl(stmt) {
|
||
self.emit_statement(stmt, ctx)?;
|
||
}
|
||
}
|
||
for stmt in body {
|
||
if is_hoisted_function_decl(stmt) {
|
||
continue;
|
||
}
|
||
if matches!(stmt, Statement::ImportDeclaration(_)) {
|
||
continue;
|
||
}
|
||
self.emit_statement(stmt, ctx)?;
|
||
}
|
||
|
||
// —— 收尾：封冻命名空间并返回（顶层 RETURN 亦终止 run）——
|
||
self.emit_module_call(ctx, "__moduleSeal", &[ns_reg])?;
|
||
ctx.inst(Inst::ret(Operand::Reg(ns_reg), 0, 0));
|
||
Ok(())
|
||
}
|
||
|
||
/// 编译 JS 依赖模块（递归）。
|
||
fn compile_js_dep(
|
||
&self, resolved: &ResolvedModule, loader: &mut dyn ModuleSourceLoader, path_stack: &mut Vec<String>,
|
||
) -> Result<IRFunction, String> {
|
||
let alloc = oxide_parser::Allocator::default();
|
||
let program = oxide_parser::parse_module(&alloc, &resolved.source).map_err(|errs| {
|
||
format!(
|
||
"module parse error: {}",
|
||
errs.first().map(|e| e.message.as_str()).unwrap_or("parse failed")
|
||
)
|
||
})?;
|
||
let mut ctx = CompileCtx::new();
|
||
ctx.is_global_scope = false;
|
||
// 依赖模块经 parse_module 解析，顶层恒严格模式。
|
||
ctx.is_strict = true;
|
||
self.emit_module_into_ctx(&program, &resolved.path, loader, path_stack, &mut ctx)?;
|
||
Ok(ctx.assemble_ir(ParamLayout { base: 0, count: 0 }, None))
|
||
}
|
||
|
||
/// 编译数据模块（json/text）：body 仅为 __moduleData 调用 + RETURN。
|
||
fn compile_data_dep(&self, kind: &str, content: &str) -> Result<IRFunction, String> {
|
||
let mut ctx = CompileCtx::new();
|
||
let kind_reg = self.load_string_const(kind, &mut ctx);
|
||
let content_reg = self.load_string_const(content, &mut ctx);
|
||
let val_reg = self.emit_module_call(&mut ctx, "__moduleData", &[kind_reg, content_reg])?;
|
||
ctx.inst(Inst::ret(Operand::Reg(val_reg), 0, 0));
|
||
Ok(ctx.assemble_ir(ParamLayout { base: 0, count: 0 }, None))
|
||
}
|
||
|
||
/// 内部辅助调用：CALL_NATIVE 到全局 native（__module*），返回结果寄存器。
|
||
pub(crate) fn emit_module_call(&self, ctx: &mut CompileCtx, name: &str, arg_regs: &[u32]) -> Result<u32, String> {
|
||
let callee_reg = ctx.lookup_or_builtin(name)?;
|
||
let this_reg = ctx.alloc_reg();
|
||
let undef_idx = ctx.add_constant(Constant::Undefined);
|
||
ctx.inst(Inst::load_const(Operand::Reg(this_reg), undef_idx));
|
||
// CALL_NATIVE 按 regs[first_arg + i] 连续读参数：把非连续 vreg 打包为连续块。
|
||
let mut packed = arg_regs.to_vec();
|
||
let first_arg_reg = if packed.is_empty() { this_reg } else { pack_arg_regs(&mut packed, ctx) };
|
||
ctx.inst(Inst::call_native(
|
||
Operand::Reg(callee_reg),
|
||
Operand::Reg(this_reg),
|
||
Operand::Reg(first_arg_reg),
|
||
packed.len() as u8,
|
||
));
|
||
let result_reg = ctx.alloc_reg();
|
||
ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg), Operand::None, Operand::None));
|
||
Ok(result_reg)
|
||
}
|
||
|
||
fn load_string_const(&self, s: &str, ctx: &mut CompileCtx) -> u32 {
|
||
let idx = ctx.add_constant(Constant::String(s.to_string()));
|
||
let reg = ctx.alloc_reg();
|
||
ctx.inst(Inst::load_const(Operand::Reg(reg), idx));
|
||
reg
|
||
}
|
||
|
||
/// 自导入别名回写：导出名若被本模块 self-import 绑定别名引用，
|
||
/// export 语句执行时同步把值写回本地绑定槽。
|
||
fn emit_self_alias_write(&self, ctx: &mut CompileCtx, export_name: &str, value_reg: u32) {
|
||
if let Some(&alias_reg) = ctx.module_self_aliases.get(export_name) {
|
||
ctx.inst(Inst::new(
|
||
OpCode::STORE_VAR,
|
||
Operand::Reg(alias_reg),
|
||
Operand::Reg(value_reg),
|
||
Operand::None,
|
||
));
|
||
}
|
||
}
|
||
|
||
fn emit_module_set(&self, ctx: &mut CompileCtx, ns_reg: u32, name: &str, value_reg: u32) -> Result<(), String> {
|
||
let name_reg = self.load_string_const(name, ctx);
|
||
self.emit_module_call(ctx, "__moduleSet", &[ns_reg, name_reg, value_reg])?;
|
||
Ok(())
|
||
}
|
||
|
||
fn load_var_reg(&self, name: &str, ctx: &mut CompileCtx) -> Result<u32, String> {
|
||
let var_reg = ctx.lookup(name)?;
|
||
let val_reg = ctx.alloc_reg();
|
||
ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(val_reg), Operand::Reg(var_reg), Operand::None));
|
||
Ok(val_reg)
|
||
}
|
||
|
||
/// export 语句 emit：声明照常 + 导出值就地注册到命名空间。
|
||
pub(crate) fn emit_module_export_domain(
|
||
&self, stmt: &Statement, ctx: &mut CompileCtx,
|
||
) -> Result<Option<u32>, String> {
|
||
let ns_reg = ctx.module_ns_reg.ok_or_else(|| "export outside module context".to_string())?;
|
||
match stmt {
|
||
Statement::ExportNamedDeclaration(exp) => {
|
||
if let Some(decl) = &exp.declaration {
|
||
match decl {
|
||
Declaration::VariableDeclaration(vd) => {
|
||
self.emit_variable_declaration(vd, ctx)?;
|
||
for d in &vd.declarations {
|
||
if let BindingPattern::BindingIdentifier(bi) = &d.id {
|
||
let name = bi.name.as_str();
|
||
let val_reg = self.load_var_reg(name, ctx)?;
|
||
self.emit_module_set(ctx, ns_reg, name, val_reg)?;
|
||
self.emit_self_alias_write(ctx, name, val_reg);
|
||
}
|
||
}
|
||
}
|
||
Declaration::FunctionDeclaration(fd) => {
|
||
self.emit_function_declaration(fd, ctx)?;
|
||
if let Some(id) = &fd.id {
|
||
let name = id.name.as_str();
|
||
let val_reg = self.load_var_reg(name, ctx)?;
|
||
self.emit_module_set(ctx, ns_reg, name, val_reg)?;
|
||
self.emit_self_alias_write(ctx, name, val_reg);
|
||
}
|
||
}
|
||
Declaration::ClassDeclaration(cl) => {
|
||
self.emit_class_declaration(cl, ctx)?;
|
||
if let Some(id) = &cl.id {
|
||
let name = id.name.as_str();
|
||
let val_reg = self.load_var_reg(name, ctx)?;
|
||
self.emit_module_set(ctx, ns_reg, name, val_reg)?;
|
||
self.emit_self_alias_write(ctx, name, val_reg);
|
||
}
|
||
}
|
||
_ => return Err("unsupported export declaration".into()),
|
||
}
|
||
} else {
|
||
let dep_ns_opt = exp
|
||
.source
|
||
.as_ref()
|
||
.map(|src| ctx.module_dep_ns_regs.get(src.value.as_str()).copied());
|
||
for spec in &exp.specifiers {
|
||
let local_name = module_export_name_str(&spec.local);
|
||
let exported_name = module_export_name_str(&spec.exported);
|
||
let val_reg = match dep_ns_opt {
|
||
Some(Some(dep_ns_reg)) => {
|
||
let name_reg = self.load_string_const(&local_name, ctx);
|
||
self.emit_module_call(ctx, "__moduleLinkGet", &[dep_ns_reg, name_reg])?
|
||
}
|
||
Some(None) => {
|
||
return Err(format!(
|
||
"export from unknown module: {}",
|
||
exp.source.as_ref().unwrap().value
|
||
))
|
||
}
|
||
None => self.load_var_reg(&local_name, ctx)?,
|
||
};
|
||
self.emit_module_set(ctx, ns_reg, &exported_name, val_reg)?;
|
||
}
|
||
}
|
||
}
|
||
Statement::ExportDefaultDeclaration(exp) => {
|
||
let val_reg = match &exp.declaration {
|
||
ExportDefaultDeclarationKind::FunctionDeclaration(fd) => {
|
||
let reg = self.emit_function_expression(fd, ctx)?;
|
||
if let Some(id) = &fd.id {
|
||
self.emit_bind_target(
|
||
id.name.as_str(),
|
||
reg,
|
||
VariableDeclarationKind::Const,
|
||
true,
|
||
false,
|
||
ctx,
|
||
)?;
|
||
}
|
||
reg
|
||
}
|
||
ExportDefaultDeclarationKind::ClassDeclaration(cl) => {
|
||
let reg = self.emit_class_expression(cl, ctx)?;
|
||
if let Some(id) = &cl.id {
|
||
self.emit_bind_target(
|
||
id.name.as_str(),
|
||
reg,
|
||
VariableDeclarationKind::Const,
|
||
true,
|
||
false,
|
||
ctx,
|
||
)?;
|
||
}
|
||
reg
|
||
}
|
||
other => {
|
||
let expr = other
|
||
.as_expression()
|
||
.ok_or_else(|| "unsupported export default declaration".to_string())?;
|
||
self.emit_expression(expr, ctx)?
|
||
}
|
||
};
|
||
self.emit_module_set(ctx, ns_reg, "default", val_reg)?;
|
||
self.emit_self_alias_write(ctx, "default", val_reg);
|
||
}
|
||
Statement::ExportAllDeclaration(exp) => {
|
||
let source = exp.source.value.as_str();
|
||
let dep_ns_reg = *ctx
|
||
.module_dep_ns_regs
|
||
.get(source)
|
||
.ok_or_else(|| format!("export * from unknown module: {source}"))?;
|
||
if let Some(exported) = &exp.exported {
|
||
// export * as ns from '...'：命名空间再导出。
|
||
let exported_name = module_export_name_str(exported);
|
||
self.emit_module_set(ctx, ns_reg, &exported_name, dep_ns_reg)?;
|
||
} else {
|
||
self.emit_module_call(ctx, "__moduleStar", &[ns_reg, dep_ns_reg])?;
|
||
}
|
||
}
|
||
_ => return Err("unsupported module export statement".into()),
|
||
}
|
||
Ok(None)
|
||
}
|
||
}
|