mirror of
https://github.com/pjh456/OxideJS.git
synced 2026-10-23 18:21:13 +08:00
470 lines
24 KiB
Rust
470 lines
24 KiB
Rust
//! class 声明整体 emit：驱动头、原型、方法、字段各阶段，组装最终类对象。
|
||
//!
|
||
//! 函数：`emit_class`。
|
||
|
||
use crate::{symbol_table::ScopeKind, ClassElementHooks, CompileCtx, Emitter, FunctionBodyContext, FunctionFlags};
|
||
use oxide_bytecode::module::Constant;
|
||
use oxide_bytecode::opcode::OpCode;
|
||
use oxide_ir::inst::Inst;
|
||
use oxide_ir::operand::Operand;
|
||
use oxide_parser::{Class, ClassElement, Expression, MethodDefinitionKind, PropertyKey, VariableDeclarationKind};
|
||
|
||
impl Emitter {
|
||
pub(crate) fn emit_class(&self, class: &Class, ctx: &mut CompileCtx) -> Result<u32, String> {
|
||
// 类表达式：类名在类体内为 const 绑定；不向调用方复用寄存器时，
|
||
// 由 emit_class_with_binding 新建块作用域声明（TDZ），类构建完成后
|
||
// STORE_VAR 初始化再弹出作用域，类名不泄漏到外层。
|
||
self.emit_class_with_binding(class, ctx, None, None)
|
||
}
|
||
|
||
/// 类名绑定可复用调用方寄存器的类整体 emit。
|
||
///
|
||
/// 类声明由调用方先在外层声明绑定（未初始化），`binding_reg` 复用该槽；
|
||
/// 类表达式无外部槽时，在独立块作用域声明 const 绑定（未初始化）。
|
||
/// 无论哪种形态，绑定都在 `extends` 求值前建立：extends 引用类名按规范
|
||
/// 抛 TDZ ReferenceError；类构建完成后 `init_var` + `STORE_VAR` 初始化。
|
||
///
|
||
/// `implicit_name` 供 `export default` 的匿名类做 SetFunctionName：类名缺省时
|
||
/// 以它为构造器 `name`；具名类由 `ctor_name` 优先，不受影响。
|
||
pub(crate) fn emit_class_with_binding(
|
||
&self, class: &Class, ctx: &mut CompileCtx, binding_reg: Option<u32>, implicit_name: Option<&str>,
|
||
) -> Result<u32, String> {
|
||
// 类定义体是严格模式代码：字段初始化/静态块/extends 表达式内嵌套函数以
|
||
// 本 ctx 为父 ctx，类编译期间强制 strict（函数末尾恢复外层标志）。
|
||
let saved_strict = ctx.is_strict;
|
||
ctx.is_strict = true;
|
||
let ctor_name = class.id.as_ref().map(|id| id.name.to_string());
|
||
// 类声明由调用方提供外层绑定槽（binding_reg=Some），类表达式无外部槽
|
||
// （None，类名是类体内独立 const 绑定）。真实名 cell 仅声明路径指向
|
||
// 本作用域绑定；表达式路径按名查 captured_bindings 会命中外层同名绑定。
|
||
let is_class_decl = binding_reg.is_some();
|
||
let mut pushed_scope = false;
|
||
let binding_reg = if let Some(name) = ctor_name.as_deref() {
|
||
match binding_reg {
|
||
Some(reg) => {
|
||
pushed_scope = false;
|
||
reg
|
||
}
|
||
None => {
|
||
let reg = ctx.alloc_reg();
|
||
ctx.push_scope_with_kind(ScopeKind::BlockScope);
|
||
ctx.declare(name, reg, VariableDeclarationKind::Const)?;
|
||
pushed_scope = true;
|
||
reg
|
||
}
|
||
}
|
||
} else {
|
||
0
|
||
};
|
||
let elements = &class.body.body;
|
||
let mut constructor_method = None;
|
||
let mut instance_field_indices = Vec::new();
|
||
let mut private_names = Vec::<(String, u32, Option<MethodDefinitionKind>, bool)>::new();
|
||
let is_derived = class.super_class.is_some();
|
||
|
||
for (idx, element) in elements.iter().enumerate() {
|
||
match element {
|
||
ClassElement::MethodDefinition(method) => {
|
||
let method = method.as_ref();
|
||
if let PropertyKey::PrivateIdentifier(private) = &method.key {
|
||
let name = private.name.as_str().to_string();
|
||
let kind = method.kind;
|
||
match private_names.iter().find(|(n, _, _, _)| n == &name) {
|
||
// 同名 getter/setter 构成访问器对，复用同一私有名。
|
||
Some((_, _, Some(MethodDefinitionKind::Get), _)) if kind == MethodDefinitionKind::Set => {}
|
||
Some((_, _, Some(MethodDefinitionKind::Set), _)) if kind == MethodDefinitionKind::Get => {}
|
||
Some(_) => return Err(format!("duplicate private name #{name}")),
|
||
None => {
|
||
let id = ctx.scopes.next_private_name_id;
|
||
ctx.scopes.next_private_name_id = ctx.scopes.next_private_name_id.saturating_add(1);
|
||
private_names.push((name, id, Some(kind), method.r#static));
|
||
}
|
||
}
|
||
}
|
||
if method.kind == MethodDefinitionKind::Constructor {
|
||
if constructor_method.is_some() {
|
||
return Err("duplicate class constructor".into());
|
||
}
|
||
constructor_method = Some(method);
|
||
}
|
||
}
|
||
ClassElement::PropertyDefinition(prop) => {
|
||
let prop = prop.as_ref();
|
||
if let PropertyKey::PrivateIdentifier(private) = &prop.key {
|
||
let name = private.name.as_str().to_string();
|
||
if private_names.iter().any(|(existing, _, _, _)| existing == &name) {
|
||
return Err(format!("duplicate private name #{name}"));
|
||
}
|
||
let id = ctx.scopes.next_private_name_id;
|
||
ctx.scopes.next_private_name_id = ctx.scopes.next_private_name_id.saturating_add(1);
|
||
private_names.push((name, id, None, prop.r#static));
|
||
}
|
||
if !prop.r#static {
|
||
instance_field_indices.push(idx);
|
||
}
|
||
}
|
||
ClassElement::AccessorProperty(_) => return Err("class accessor properties not yet supported".into()),
|
||
ClassElement::StaticBlock(_) | ClassElement::TSIndexSignature(_) => {}
|
||
}
|
||
}
|
||
|
||
// 计算键 slot 分配：全部元素源码序（方法 + 公有字段），私有元素非 computed。
|
||
let mut computed_slot = 0u8;
|
||
let key_slots: Vec<Option<u8>> = elements
|
||
.iter()
|
||
.map(|e| {
|
||
let computed = match e {
|
||
ClassElement::MethodDefinition(m) => m.computed,
|
||
ClassElement::PropertyDefinition(p) => {
|
||
p.computed && !matches!(p.key, PropertyKey::PrivateIdentifier(_))
|
||
}
|
||
_ => false,
|
||
};
|
||
if computed {
|
||
let s = computed_slot;
|
||
computed_slot += 1;
|
||
Some(s)
|
||
} else {
|
||
None
|
||
}
|
||
})
|
||
.collect();
|
||
let any_computed = computed_slot > 0;
|
||
|
||
let (ctor_reg, proto_reg, super_reg) = self.emit_class_header(class, ctx)?;
|
||
let self_binding = ctor_name.as_deref().map(|name| vec![(name, binding_reg)]).unwrap_or_default();
|
||
// 类名绑定 cell：引用类名的类元素（构造器/方法/字段）经此专用 cell 捕获。
|
||
// 类体内的读取经 LOAD_UPVALUE 命中同一 cell，使类名与其它引用在 epoch 晋升
|
||
// （会改写 cell 值）与内联 accessor 调用（会清空寄存器文件）之后仍保持 identity
|
||
// 一致；合成键 @@class_self_N 不影响外层作用域的同名用户绑定。
|
||
let class_self_cell: Option<u8> = ctor_name.as_deref().map(|_| {
|
||
let cell_idx = ctx.alloc_cell_idx();
|
||
ctx.captured_bindings.insert(format!("@@class_self_{cell_idx}"), cell_idx);
|
||
cell_idx
|
||
});
|
||
|
||
let saved_derived = ctx.in_derived_constructor;
|
||
let saved_private_names = ctx.scopes.private_name_map.clone();
|
||
let saved_private_kinds = ctx.scopes.private_element_kinds.clone();
|
||
let saved_brand_id = ctx.scopes.private_brand_id;
|
||
let saved_brand_chain = ctx.brand_chain.clone();
|
||
ctx.in_derived_constructor = is_derived;
|
||
|
||
// 类 brand：有私有元素时分配 brand 私有名 id，并创建 brand 对象（= 类原型）。
|
||
// 构造器把 brand 槽写入实例 own；私有方法/访问器/静态字段访问（GET/SET）据
|
||
// brand 对象同一性做检查；instance 字段走 PrivateFieldFind 原型链查找，不检查。
|
||
let private_brand_id = if !private_names.is_empty() {
|
||
let id = ctx.scopes.next_private_name_id;
|
||
ctx.scopes.next_private_name_id = ctx.scopes.next_private_name_id.saturating_add(1);
|
||
Some(id)
|
||
} else {
|
||
None
|
||
};
|
||
ctx.scopes.private_brand_id = private_brand_id;
|
||
|
||
// 私有名环境是词法环境链：内类条目遮蔽外类同名条目，外类其余名字保持
|
||
// 可解析（内类方法体可访问外类声明的私有名）。
|
||
let mut stacked_names = saved_private_names.clone();
|
||
let mut stacked_kinds = saved_private_kinds.clone();
|
||
for (n, id, kind, is_static) in &private_names {
|
||
stacked_names.insert(n.clone(), *id);
|
||
stacked_kinds.insert(n.clone(), (*kind, *is_static, private_brand_id.unwrap_or(0)));
|
||
}
|
||
ctx.scopes.private_name_map = stacked_names;
|
||
ctx.scopes.private_element_kinds = stacked_kinds;
|
||
|
||
// 实例公有字段 computed key 求值于构造器帧外，须类定义期存入数组。构造器以
|
||
// upvalue 捕获该数组：父作用域登记 `@@field_keys`（索引经共享计数器追加，
|
||
// 与块级遮蔽绑定的追加索引不碰撞）。
|
||
let has_computed_instance = instance_field_indices.iter().any(|&i| {
|
||
let ClassElement::PropertyDefinition(p) = &elements[i] else { return false };
|
||
p.computed && !matches!(p.key, PropertyKey::PrivateIdentifier(_))
|
||
});
|
||
let field_key_cell: Option<u8> = if has_computed_instance {
|
||
let cell_idx = ctx.alloc_cell_idx();
|
||
ctx.captured_bindings.insert("@@field_keys".to_string(), cell_idx);
|
||
Some(cell_idx)
|
||
} else {
|
||
None
|
||
};
|
||
// 类 brand 对象（= proto）由类定义期 MAKE_CELL 写入，构造器经 upvalue 捕获。
|
||
// 捕获名按本类 brand id 编号：嵌套类各自登记 brand，内类方法体沿 brand 链
|
||
// 保持外类 brand 条目可见，跨类 brand 检查据此定位声明类的 brand 对象。
|
||
let brand_cell: Option<u8> = private_brand_id.map(|bid| {
|
||
let cell_idx = ctx.alloc_cell_idx();
|
||
ctx.captured_bindings.insert(format!("@@class_brand_{bid}"), cell_idx);
|
||
ctx.brand_chain.push((bid, cell_idx, None));
|
||
cell_idx
|
||
});
|
||
// 字段值表达式运行于构造器帧：其自由变量须纳入构造器 upvalue 捕获。
|
||
let field_value_exprs: Vec<&Expression> = instance_field_indices
|
||
.iter()
|
||
.filter_map(|&i| match &elements[i] {
|
||
ClassElement::PropertyDefinition(p) => p.value.as_ref(),
|
||
_ => None,
|
||
})
|
||
.collect();
|
||
let mut extra_upvalue_names: Vec<(String, u8)> = Vec::new();
|
||
if let Some(c) = field_key_cell {
|
||
extra_upvalue_names.push(("@@field_keys".to_string(), c));
|
||
}
|
||
if let (Some(c), Some(bid)) = (brand_cell, private_brand_id) {
|
||
extra_upvalue_names.push((format!("@@class_brand_{bid}"), c));
|
||
}
|
||
if let (Some(name), Some(c)) = (ctor_name.as_deref(), class_self_cell) {
|
||
extra_upvalue_names.push((name.to_string(), c));
|
||
}
|
||
|
||
let emit_instance_fields = |compiler: &Emitter, field_ctx: &mut CompileCtx| -> Result<(), String> {
|
||
// 先写 brand 槽（私有方法/访问器的 brand 检查依据），再初始化字段。
|
||
if let Some(bid) = private_brand_id {
|
||
if brand_cell.is_none() {
|
||
return Err("class brand cell missing".into());
|
||
}
|
||
let brand_reg = field_ctx.alloc_reg();
|
||
let brand_name = format!("@@class_brand_{bid}");
|
||
let uv_idx = field_ctx
|
||
.current_upvalue_captures
|
||
.iter()
|
||
.position(|u| u.name == brand_name)
|
||
.ok_or("class brand upvalue missing")? as u16;
|
||
field_ctx.inst(Inst::new(
|
||
OpCode::LOAD_UPVALUE,
|
||
Operand::Reg(brand_reg),
|
||
Operand::Imm(uv_idx),
|
||
Operand::None,
|
||
));
|
||
let key_idx = field_ctx.add_constant(Constant::Int(bid as i32));
|
||
let brand_key_reg = field_ctx.alloc_reg();
|
||
field_ctx.inst(Inst::load_const(Operand::Reg(brand_key_reg), key_idx));
|
||
field_ctx.inst(Inst::init_private(
|
||
Operand::This,
|
||
Operand::Reg(brand_reg),
|
||
Operand::Reg(brand_key_reg),
|
||
false,
|
||
));
|
||
}
|
||
for &idx in &instance_field_indices {
|
||
let ClassElement::PropertyDefinition(field) = &elements[idx] else {
|
||
unreachable!()
|
||
};
|
||
let field = field.as_ref();
|
||
if let PropertyKey::PrivateIdentifier(private) = &field.key {
|
||
compiler.emit_private_field_init(
|
||
Operand::This,
|
||
private.name.as_str(),
|
||
field.value.as_ref(),
|
||
field_ctx,
|
||
)?;
|
||
} else {
|
||
compiler.emit_public_field_init(
|
||
Operand::This,
|
||
&field.key,
|
||
field.computed,
|
||
field.value.as_ref(),
|
||
key_slots[idx],
|
||
field_ctx,
|
||
)?;
|
||
}
|
||
}
|
||
Ok(())
|
||
};
|
||
|
||
// 构造器（显式与隐式派生）共用同一组标志与钩子：恒 strict、无表达式体、
|
||
// 字段发射钩子按派生与否在 super() 前后执行。
|
||
let ctor_flags = FunctionFlags {
|
||
is_expression_body: false,
|
||
is_generator: false,
|
||
is_async: false,
|
||
own_strict: true,
|
||
name: None,
|
||
};
|
||
let ctor_hooks = ClassElementHooks {
|
||
extra_bindings: &self_binding,
|
||
emit_fields: Some(emit_instance_fields),
|
||
fields_after_super: is_derived,
|
||
extra_capture_exprs: &field_value_exprs,
|
||
extra_upvalue_names: &extra_upvalue_names,
|
||
};
|
||
let mut ctor_module = if let Some(method) = constructor_method {
|
||
let (param_names, body_stmts) = self.extract_function_parts(method.value.as_ref())?;
|
||
self.compile_function_body(
|
||
¶m_names,
|
||
body_stmts,
|
||
ctx,
|
||
FunctionBodyContext::ClassElement,
|
||
ctor_flags,
|
||
ctor_hooks,
|
||
)?
|
||
} else {
|
||
let mut module =
|
||
self.compile_function_body(&[], &[], ctx, FunctionBodyContext::ClassElement, ctor_flags, ctor_hooks)?;
|
||
if is_derived {
|
||
module.insts.clear();
|
||
module.constants.clear();
|
||
module.n_registers = 2;
|
||
// 隐式派生构造器等价于 `constructor(...args) { super(...args); }`：
|
||
// 收集全部实参为数组，再展开传给 super。
|
||
module.insts.push(Inst::create_rest_array(Operand::Reg(1), 0));
|
||
module.insts.push(Inst::super_call_spread(Operand::Reg(0), &[0x8000_0000 | 1]));
|
||
// 字段初始化直接重发：构造器 upvalue/内置槽引用须与首轮编译产物对齐。
|
||
let mut field_ctx = CompileCtx::new();
|
||
// 字段表达式运行于构造器帧，构造器恒 strict，字段 ctx 同步置位。
|
||
// 私有名环境按堆叠口径整表继承（字段初始化器内的嵌套类需要外类
|
||
// 私有名与 brand 链保持可解析）。
|
||
field_ctx.is_strict = true;
|
||
field_ctx.scopes.private_name_map = ctx.scopes.private_name_map.clone();
|
||
field_ctx.scopes.private_element_kinds = ctx.scopes.private_element_kinds.clone();
|
||
field_ctx.scopes.private_brand_id = ctx.scopes.private_brand_id;
|
||
field_ctx.brand_chain = ctx.brand_chain.clone();
|
||
field_ctx.scopes.builtin_reg_map = module.builtin_reg_map.clone();
|
||
field_ctx.current_upvalue_captures = module.upvalue_captures.clone();
|
||
field_ctx.field_keys_uv = module
|
||
.upvalue_captures
|
||
.iter()
|
||
.position(|u| u.name == "@@field_keys")
|
||
.map(|i| i as u8);
|
||
emit_instance_fields(self, &mut field_ctx)?;
|
||
// 构造器尾裸 return 须物化 undefined：RETURN 读 rd 槽值，字段初始化器
|
||
// 尾表达式为返回对象的调用时，该对象会漏出为构造结果。
|
||
let undef_idx = field_ctx.add_constant(Constant::Undefined);
|
||
let undef_reg = field_ctx.alloc_reg();
|
||
field_ctx.inst(Inst::load_const(Operand::Reg(undef_reg), undef_idx));
|
||
module.insts.extend(field_ctx.insts);
|
||
module.constants = field_ctx.constants;
|
||
module.n_registers = field_ctx.max_regs.max(1);
|
||
module.insts.push(Inst::ret(Operand::Reg(undef_reg), 0, 0, 0));
|
||
}
|
||
module
|
||
};
|
||
ctx.in_derived_constructor = saved_derived;
|
||
ctor_module.is_class_constructor = true;
|
||
ctor_module.is_derived_constructor = is_derived;
|
||
ctor_module.function_name = ctor_name.clone().or_else(|| implicit_name.map(str::to_string));
|
||
ctx.nested.push(ctor_module);
|
||
// 键数组构建会在 keys 表达式中压入嵌套模块（箭头/函数/类键），
|
||
// 必须在压入后用固定下标引用构造器模块，避免嵌套长度偏移。
|
||
let ctor_sub_idx = ctx.nested.len() as u16;
|
||
|
||
// 类定义期按源码序求值全部 computed key（extends 之后、构造器闭包创建之前），
|
||
// 存数组供方法/静态字段/实例字段初始化阶段按 slot 取用。
|
||
if any_computed {
|
||
let keys_reg = ctx.alloc_reg();
|
||
ctx.inst(Inst::new(
|
||
OpCode::NEW_ARRAY,
|
||
Operand::Reg(keys_reg),
|
||
Operand::Imm(computed_slot as u16),
|
||
Operand::None,
|
||
));
|
||
for (idx, element) in elements.iter().enumerate() {
|
||
let Some(slot) = key_slots[idx] else { continue };
|
||
let key_expr = match element {
|
||
ClassElement::MethodDefinition(m) => m.key.as_expression(),
|
||
ClassElement::PropertyDefinition(p) => p.key.as_expression(),
|
||
_ => None,
|
||
};
|
||
let Some(expr) = key_expr else { continue };
|
||
let key_reg = self.emit_expression(expr, ctx)?;
|
||
let idx_reg = ctx.alloc_reg();
|
||
let idx_const = ctx.add_constant(Constant::Int(slot as i32));
|
||
ctx.inst(Inst::load_const(Operand::Reg(idx_reg), idx_const));
|
||
ctx.inst(Inst::new(
|
||
OpCode::SET_ELEM,
|
||
Operand::Reg(keys_reg),
|
||
Operand::Reg(idx_reg),
|
||
Operand::Reg(key_reg),
|
||
));
|
||
}
|
||
if let Some(cell_idx) = field_key_cell {
|
||
ctx.inst(Inst::new(
|
||
OpCode::MAKE_CELL,
|
||
Operand::Reg(keys_reg),
|
||
Operand::Imm(cell_idx as u16),
|
||
Operand::None,
|
||
));
|
||
}
|
||
ctx.class_keys_reg = Some(keys_reg);
|
||
}
|
||
|
||
self.emit_class_prototype(ctor_reg, proto_reg, super_reg, ctor_sub_idx, ctx)?;
|
||
// brand 对象即类原型：构造器对象（静态私有访问）与实例（实例私有访问）各写
|
||
// brand 槽；构造器经 @@class_brand upvalue 捕获原型对象。
|
||
if let (Some(bid), Some(cell_idx)) = (private_brand_id, brand_cell) {
|
||
let key_idx = ctx.add_constant(Constant::Int(bid as i32));
|
||
let brand_key_reg = ctx.alloc_reg();
|
||
ctx.inst(Inst::load_const(Operand::Reg(brand_key_reg), key_idx));
|
||
ctx.inst(Inst::init_private(
|
||
Operand::Reg(ctor_reg),
|
||
Operand::Reg(proto_reg),
|
||
Operand::Reg(brand_key_reg),
|
||
false,
|
||
));
|
||
ctx.inst(Inst::new(
|
||
OpCode::MAKE_CELL,
|
||
Operand::Reg(proto_reg),
|
||
Operand::Imm(cell_idx as u16),
|
||
Operand::None,
|
||
));
|
||
}
|
||
self.emit_class_methods(
|
||
&class.body.body,
|
||
ctor_reg,
|
||
proto_reg,
|
||
&self_binding,
|
||
class_self_cell,
|
||
&key_slots,
|
||
ctx,
|
||
)?;
|
||
self.emit_class_static_elements(&class.body.body, ctor_reg, &key_slots, ctx)?;
|
||
|
||
// 类构建完成：初始化类名绑定并写入类构造器（类内方法引用该寄存器/捕获）。
|
||
if let Some(name) = ctor_name.as_deref() {
|
||
ctx.init_var(name);
|
||
ctx.inst(Inst::new(
|
||
OpCode::STORE_VAR,
|
||
Operand::Reg(binding_reg),
|
||
Operand::Reg(ctor_reg),
|
||
Operand::None,
|
||
));
|
||
// 顶层词法双写镜像：类声明值同步写镜像，使跨脚本（间接 eval）读经
|
||
// 镜像见当前值。
|
||
self.emit_global_lex_mirror_write(name, ctor_reg, ctx);
|
||
if let Some(cell_idx) = class_self_cell {
|
||
// 以构造器初始化类名 cell 并解除 TDZ（占位 cell 已由类元素闭包在 hoist 期创建）。
|
||
ctx.inst(Inst::new(
|
||
OpCode::MAKE_CELL,
|
||
Operand::Reg(binding_reg),
|
||
Operand::Imm(cell_idx as u16),
|
||
Operand::None,
|
||
));
|
||
}
|
||
// 类名被外层嵌套函数捕获时，真实名 cell 同样须初始化（类元素自引用走
|
||
// @@class_self_* 合成 cell，二者 cell_idx 不同则各发一次）。
|
||
// 仅类声明：类名是本作用域绑定，可见绑定解析到的是它的 cell；类表达式
|
||
// 名是类体内独立 const 绑定，按名解析只会命中外层同名绑定 cell，
|
||
// MAKE_CELL 会把类值误写进外层绑定。
|
||
if is_class_decl {
|
||
if let Some((cell_idx, _)) = ctx.visible_cell(name) {
|
||
ctx.inst(Inst::new(
|
||
OpCode::MAKE_CELL,
|
||
Operand::Reg(binding_reg),
|
||
Operand::Imm(cell_idx as u16),
|
||
Operand::None,
|
||
));
|
||
}
|
||
}
|
||
}
|
||
|
||
if pushed_scope {
|
||
ctx.pop_scope();
|
||
}
|
||
ctx.scopes.private_name_map = saved_private_names;
|
||
ctx.scopes.private_element_kinds = saved_private_kinds;
|
||
ctx.scopes.private_brand_id = saved_brand_id;
|
||
ctx.brand_chain = saved_brand_chain;
|
||
// 类编译结束恢复外层 strict 标志：类在 sloppy 上下文时不得泄漏 strict 到类后代码。
|
||
ctx.is_strict = saved_strict;
|
||
Ok(ctor_reg)
|
||
}
|
||
}
|