Struct swc_ecma_codegen::Emitter

pub struct Emitter<'a> {
    pub cfg: Config,
    pub cm: Arc<SourceMap>,
    pub comments: Option<&'a Comments>,
    pub wr: Box<dyn WriteJs + 'a>,
    pub handlers: Box<dyn Handlers + 'a>,
}

Fields

cfg: Config

cm: Arc<SourceMap>

comments: Option<&'a Comments>

wr: Box<dyn WriteJs + 'a>

handlers: Box<dyn Handlers + 'a>

Methods

impl<'a> Emitter<'a>

pub fn emit_decl(&mut self, node: &Decl) -> Result

pub fn emit_class_decl(&mut self, node: &ClassDecl) -> Result

pub fn emit_fn_decl(&mut self, node: &FnDecl) -> Result

pub fn emit_var_decl(&mut self, node: &VarDecl) -> Result

pub fn emit_var_declator(&mut self, node: &VarDeclarator) -> Result

impl<'a> Emitter<'a>

pub fn emit_jsx_element(&mut self, node: &JSXElement) -> Result

pub fn emit_jsx_opening_element(&mut self, node: &JSXOpeningElement) -> Result

pub fn emit_jsx_element_name(&mut self, node: &JSXElementName) -> Result

pub fn emit_jsx_attr(&mut self, node: &JSXAttr) -> Result

pub fn emit_jsx_attr_value(&mut self, node: &JSXAttrValue) -> Result

pub fn emit_jsx_attr_name(&mut self, node: &JSXAttrName) -> Result

pub fn emit_jsx_attr_or_spread(&mut self, node: &JSXAttrOrSpread) -> Result

pub fn emit_jsx_element_child(&mut self, node: &JSXElementChild) -> Result

pub fn emit_jsx_spread_child(&mut self, node: &JSXSpreadChild) -> Result

pub fn emit_jsx_expr_container(&mut self, node: &JSXExprContainer) -> Result

pub fn emit_jsx_expr(&mut self, node: &JSXExpr) -> Result

pub fn emit_jsx_closing_element(&mut self, node: &JSXClosingElement) -> Result

pub fn emit_jsx_fragment(&mut self, node: &JSXFragment) -> Result

pub fn emit_jsx_opening_fragment(&mut self, node: &JSXOpeningFragment) -> Result

pub fn emit_jsx_closing_fragment(&mut self, node: &JSXClosingFragment) -> Result

pub fn emit_jsx_namespaced_name(&mut self, node: &JSXNamespacedName) -> Result

pub fn emit_jsx_empty_expr(&mut self, node: &JSXEmptyExpr) -> Result

pub fn emit_jsx_text(&mut self, node: &JSXText) -> Result

pub fn emit_jsx_member_expr(&mut self, node: &JSXMemberExpr) -> Result

pub fn emit_jsx_object(&mut self, node: &JSXObject) -> Result

impl<'a> Emitter<'a>

pub fn emit_pat_or_ts_param_prop(&mut self, n: &PatOrTsParamProp) -> Result

pub fn emit_ts_array_type(&mut self, n: &TsArrayType) -> Result

pub fn emit_ts_as_expr(&mut self, n: &TsAsExpr) -> Result

pub fn emit_ts_call_signature_decl(&mut self, n: &TsCallSignatureDecl) -> Result

pub fn emit_ts_cond_type(&mut self, n: &TsConditionalType) -> Result

pub fn emit_ts_constructor_signature_decl(
    &mut self,
    n: &TsConstructSignatureDecl
) -> Result

pub fn emit_ts_constructor_type(&mut self, n: &TsConstructorType) -> Result

pub fn emit_ts_entity_name(&mut self, n: &TsEntityName) -> Result

pub fn emit_ts_enum_decl(&mut self, n: &TsEnumDecl) -> Result

pub fn emit_ts_enum_member(&mut self, n: &TsEnumMember) -> Result

pub fn emit_ts_enum_member_id(&mut self, n: &TsEnumMemberId) -> Result

pub fn emit_ts_export_assignment(&mut self, n: &TsExportAssignment) -> Result

pub fn emit_ts_expr_with_type_args(&mut self, n: &TsExprWithTypeArgs) -> Result

pub fn emit_ts_external_module_ref(&mut self, n: &TsExternalModuleRef) -> Result

pub fn emit_ts_fn_or_constructor_type(
    &mut self,
    n: &TsFnOrConstructorType
) -> Result

pub fn emit_ts_fn_param(&mut self, n: &TsFnParam) -> Result

pub fn emit_ts_fn_type(&mut self, n: &TsFnType) -> Result

pub fn emit_ts_import_equals_decl(&mut self, n: &TsImportEqualsDecl) -> Result

pub fn emit_ts_index_signature(&mut self, n: &TsIndexSignature) -> Result

pub fn emit_ts_index_accessed_type(&mut self, n: &TsIndexedAccessType) -> Result

pub fn emit_ts_infer_type(&mut self, n: &TsInferType) -> Result

pub fn emit_ts_interface_body(&mut self, n: &TsInterfaceBody) -> Result

pub fn emit_ts_interface_decl(&mut self, n: &TsInterfaceDecl) -> Result

pub fn emit_ts_intersection_type(&mut self, n: &TsIntersectionType) -> Result

pub fn emit_ts_keyword_type(&mut self, n: &TsKeywordType) -> Result

pub fn emit_ts_lit(&mut self, n: &TsLit) -> Result

pub fn emit_ts_lit_type(&mut self, n: &TsLitType) -> Result

pub fn emit_ts_mapped_type(&mut self, n: &TsMappedType) -> Result

pub fn emit_ts_method_signature(&mut self, n: &TsMethodSignature) -> Result

pub fn emit_ts_module_block(&mut self, n: &TsModuleBlock) -> Result

pub fn emit_ts_module_decl(&mut self, n: &TsModuleDecl) -> Result

pub fn emit_ts_module_name(&mut self, n: &TsModuleName) -> Result

pub fn emit_ts_module_ref(&mut self, n: &TsModuleRef) -> Result

pub fn emit_ts_ns_body(&mut self, n: &TsNamespaceBody) -> Result

pub fn emit_ts_ns_decl(&mut self, n: &TsNamespaceDecl) -> Result

pub fn emit_ts_ns_export_decl(&mut self, n: &TsNamespaceExportDecl) -> Result

pub fn emit_ts_non_null_expr(&mut self, n: &TsNonNullExpr) -> Result

pub fn emit_ts_optional_type(&mut self, n: &TsOptionalType) -> Result

pub fn emit_ts_param_prop(&mut self, n: &TsParamProp) -> Result

pub fn emit_ts_param_prop_param(&mut self, n: &TsParamPropParam) -> Result

pub fn emit_ts_paren_type(&mut self, n: &TsParenthesizedType) -> Result

pub fn emit_ts_property_signature(&mut self, n: &TsPropertySignature) -> Result

pub fn emit_ts_qualified_name(&mut self, n: &TsQualifiedName) -> Result

pub fn emit_ts_rest_type(&mut self, n: &TsRestType) -> Result

pub fn emit_ts_signature_decl(&mut self, n: &TsSignatureDecl) -> Result

pub fn emit_ts_this_type(&mut self, n: &TsThisType) -> Result

pub fn emit_ts_this_type_or_ident(&mut self, n: &TsThisTypeOrIdent) -> Result

pub fn emit_ts_tuple_type(&mut self, n: &TsTupleType) -> Result

pub fn emit_ts_type(&mut self, n: &TsType) -> Result

pub fn emit_ts_type_alias_decl(&mut self, n: &TsTypeAliasDecl) -> Result

pub fn emit_ts_type_ann(&mut self, n: &TsTypeAnn) -> Result

pub fn emit_ts_type_assertion(&mut self, n: &TsTypeAssertion) -> Result

pub fn emit_ts_const_assertion(&mut self, n: &TsConstAssertion) -> Result

pub fn emit_ts_type_cast_expr(&mut self, n: &TsTypeCastExpr) -> Result

pub fn emit_ts_type_element(&mut self, n: &TsTypeElement) -> Result

pub fn emit_ts_type_lit(&mut self, n: &TsTypeLit) -> Result

pub fn emit_ts_type_operator(&mut self, n: &TsTypeOperator) -> Result

pub fn emit_ts_type_param(&mut self, n: &TsTypeParam) -> Result

pub fn emit_ts_type_param_decl(&mut self, n: &TsTypeParamDecl) -> Result

pub fn emit_ts_type_param_instantiation(
    &mut self,
    n: &TsTypeParamInstantiation
) -> Result

pub fn emit_ts_type_predicate(&mut self, n: &TsTypePredicate) -> Result

pub fn emit_ts_type_query(&mut self, n: &TsTypeQuery) -> Result

pub fn emit_ts_type_ref(&mut self, n: &TsTypeRef) -> Result

pub fn emit_ts_union_or_intersection_type(
    &mut self,
    n: &TsUnionOrIntersectionType
) -> Result

pub fn emit_ts_union_type(&mut self, n: &TsUnionType) -> Result

impl<'a> Emitter<'a>

pub fn emit_stmts(&mut self, stmts: &[Stmt]) -> Result

pub fn emit_program(&mut self, node: &Program) -> Result

pub fn emit_module(&mut self, node: &Module) -> Result

pub fn emit_script(&mut self, node: &Script) -> Result

pub fn emit_module_item(&mut self, node: &ModuleItem) -> Result

pub fn emit_module_decl(&mut self, node: &ModuleDecl) -> Result

pub fn emit_export_decl(&mut self, node: &ExportDecl) -> Result

pub fn emit_export_default_expr(&mut self, node: &ExportDefaultExpr) -> Result

pub fn emit_export_default_decl(&mut self, node: &ExportDefaultDecl) -> Result

pub fn emit_import(&mut self, node: &ImportDecl) -> Result

pub fn emit_import_specific(&mut self, node: &ImportSpecific) -> Result

pub fn emit_export_specifier(&mut self, node: &ExportSpecifier) -> Result

pub fn emit_named_export_specifier(
    &mut self,
    node: &NamedExportSpecifier
) -> Result

pub fn emit_named_export(&mut self, node: &NamedExport) -> Result

pub fn emit_export_all(&mut self, node: &ExportAll) -> Result

pub fn emit_lit(&mut self, node: &Lit) -> Result

pub fn emit_str_lit(&mut self, node: &Str) -> Result

pub fn emit_num_lit(&mut self, num: &Number) -> Result

pub fn emit_big_lit(&mut self, v: &BigInt) -> Result

pub fn emit_expr_or_super(&mut self, node: &ExprOrSuper) -> Result

pub fn emit_super(&mut self, node: &Super) -> Result

pub fn emit_expr(&mut self, node: &Expr) -> Result

pub fn emit_opt_chain(&mut self, n: &OptChainExpr) -> Result

pub fn emit_invalid(&mut self, n: &Invalid) -> Result

pub fn emit_call_expr(&mut self, node: &CallExpr) -> Result

pub fn emit_new_expr(&mut self, node: &NewExpr) -> Result

pub fn emit_member_expr(&mut self, node: &MemberExpr) -> Result

pub fn needs_2dots_for_property_access(&self, expr: &ExprOrSuper) -> bool

1..toString is a valid property access, emit a dot after the literal

pub fn emit_arrow_expr(&mut self, node: &ArrowExpr) -> Result

pub fn emit_meta_prop_expr(&mut self, node: &MetaPropExpr) -> Result

pub fn emit_seq_expr(&mut self, node: &SeqExpr) -> Result

pub fn emit_assign_expr(&mut self, node: &AssignExpr) -> Result

pub fn emit_bin_expr(&mut self, node: &BinExpr) -> Result

pub fn emit_decorator(&mut self, node: &Decorator) -> Result

pub fn emit_class_expr(&mut self, node: &ClassExpr) -> Result

pub fn emit_class_trailing(&mut self, node: &Class) -> Result

pub fn emit_class_memeber(&mut self, node: &ClassMember) -> Result

pub fn emit_private_method(&mut self, n: &PrivateMethod) -> Result

pub fn emit_class_method(&mut self, n: &ClassMethod) -> Result

pub fn emit_private_prop(&mut self, n: &PrivateProp) -> Result

pub fn emit_class_prop(&mut self, node: &ClassProp) -> Result

pub fn emit_class_constructor(&mut self, n: &Constructor) -> Result

pub fn emit_prop_name(&mut self, node: &PropName) -> Result

pub fn emit_computed_prop_name(&mut self, node: &ComputedPropName) -> Result

pub fn emit_cond_expr(&mut self, node: &CondExpr) -> Result

pub fn emit_fn_expr(&mut self, node: &FnExpr) -> Result

pub fn emit_fn_trailing(&mut self, node: &Function) -> Result

prints (b){} from function a(b){}

pub fn emit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr) -> Result

pub fn emit_this_expr(&mut self, node: &ThisExpr) -> Result

pub fn emit_tpl_lit(&mut self, node: &Tpl) -> Result

pub fn emit_tagged_tpl_lit(&mut self, node: &TaggedTpl) -> Result

pub fn emit_quasi(&mut self, node: &TplElement) -> Result

pub fn emit_unary_expr(&mut self, node: &UnaryExpr) -> Result

pub fn emit_update_expr(&mut self, node: &UpdateExpr) -> Result

pub fn emit_yield_expr(&mut self, node: &YieldExpr) -> Result

pub fn emit_expr_or_spreads(
    &mut self,
    parent_node: Span,
    nodes: &[ExprOrSpread],
    format: ListFormat
) -> Result

pub fn emit_expr_or_spread(&mut self, node: &ExprOrSpread) -> Result

pub fn emit_await_expr(&mut self, node: &AwaitExpr) -> Result

pub fn emit_array_lit(&mut self, node: &ArrayLit) -> Result

pub fn emit_object_lit(&mut self, node: &ObjectLit) -> Result

pub fn emit_prop(&mut self, node: &Prop) -> Result

pub fn emit_kv_prop(&mut self, node: &KeyValueProp) -> Result

pub fn emit_assign_prop(&mut self, node: &AssignProp) -> Result

pub fn emit_getter_prop(&mut self, node: &GetterProp) -> Result

pub fn emit_setter_prop(&mut self, node: &SetterProp) -> Result

pub fn emit_method_prop(&mut self, node: &MethodProp) -> Result

pub fn emit_paren_expr(&mut self, node: &ParenExpr) -> Result

pub fn emit_ident(&mut self, ident: &Ident) -> Result

pub fn emit_list<N: Node>(
    &mut self,
    parent_node: Span,
    children: Option<&[N]>,
    format: ListFormat
) -> Result

pub fn emit_list5<N: Node>(
    &mut self,
    parent_node: Span,
    children: Option<&[N]>,
    format: ListFormat,
    start: usize,
    count: usize
) -> Result

impl<'a> Emitter<'a>

Patterns

pub fn emit_pat(&mut self, node: &Pat) -> Result

pub fn emit_rest_pat(&mut self, node: &RestPat) -> Result

pub fn emit_prop_or_spread(&mut self, node: &PropOrSpread) -> Result

pub fn emit_spread_element(&mut self, node: &SpreadElement) -> Result

pub fn emit_pat_or_expr(&mut self, node: &PatOrExpr) -> Result

pub fn emit_array_pat(&mut self, node: &ArrayPat) -> Result

pub fn emit_assign_pat(&mut self, node: &AssignPat) -> Result

pub fn emit_object_pat(&mut self, node: &ObjectPat) -> Result

pub fn emit_object_pat_prop(&mut self, node: &ObjectPatProp) -> Result

pub fn emit_object_kv_pat(&mut self, node: &KeyValuePatProp) -> Result

pub fn emit_object_assign_pat(&mut self, node: &AssignPatProp) -> Result

pub fn emit_var_decl_or_pat(&mut self, node: &VarDeclOrPat) -> Result

impl<'a> Emitter<'a>

Statements

pub fn emit_stmt(&mut self, node: &Stmt) -> Result

pub fn emit_expr_stmt(&mut self, e: &ExprStmt) -> Result

pub fn emit_block_stmt(&mut self, node: &BlockStmt) -> Result

pub fn emit_empty_stmt(&mut self, node: &EmptyStmt) -> Result

pub fn emit_debugger_stmt(&mut self, node: &DebuggerStmt) -> Result

pub fn emit_with_stmt(&mut self, node: &WithStmt) -> Result

pub fn emit_return_stmt(&mut self, node: &ReturnStmt) -> Result

pub fn emit_labeled_stmt(&mut self, node: &LabeledStmt) -> Result

pub fn emit_break_stmt(&mut self, node: &BreakStmt) -> Result

pub fn emit_continue_stmt(&mut self, node: &ContinueStmt) -> Result

pub fn emit_if_stmt(&mut self, node: &IfStmt) -> Result

pub fn emit_switch_stmt(&mut self, node: &SwitchStmt) -> Result

pub fn emit_catch_clause(&mut self, node: &CatchClause) -> Result

pub fn emit_switch_case(&mut self, node: &SwitchCase) -> Result

pub fn emit_throw_stmt(&mut self, node: &ThrowStmt) -> Result

pub fn emit_try_stmt(&mut self, node: &TryStmt) -> Result

pub fn emit_while_stmt(&mut self, node: &WhileStmt) -> Result

pub fn emit_do_while_stmt(&mut self, node: &DoWhileStmt) -> Result

pub fn emit_for_stmt(&mut self, node: &ForStmt) -> Result

pub fn emit_for_in_stmt(&mut self, node: &ForInStmt) -> Result

pub fn emit_for_of_stmt(&mut self, node: &ForOfStmt) -> Result

impl<'a> Emitter<'a>

pub fn emit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr) -> Result