diff --git a/crates/oxc_codegen/src/gen.rs b/crates/oxc_codegen/src/gen.rs index dab9cd8944e15..d97f3dea6b294 100644 --- a/crates/oxc_codegen/src/gen.rs +++ b/crates/oxc_codegen/src/gen.rs @@ -53,8 +53,8 @@ impl<'a, const MINIFY: bool> Gen for Program<'a> { impl<'a, const MINIFY: bool> Gen for Hashbang<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { - p.print_str(b"#!"); - p.print_str(self.value.as_bytes()); + p.print_str("#!"); + p.print_str(self.value.as_str()); } } @@ -66,7 +66,7 @@ impl<'a, const MINIFY: bool> Gen for Directive<'a> { // So here should print original `directive` value, the `expression` value is escaped str. // See https://github.com/babel/babel/blob/main/packages/babel-generator/src/generators/base.ts#L64 p.wrap_quote(self.directive.as_str(), |p, _| { - p.print_str(self.directive.as_bytes()); + p.print_str(self.directive.as_str()); }); p.print_semicolon_after_statement(); } @@ -177,11 +177,11 @@ fn print_if( p: &mut Codegen<{ MINIFY }>, ctx: Context, ) { - p.print_str(b"if"); + p.print_str("if"); p.print_soft_space(); - p.print(b'('); + p.print_char(b'('); p.print_expression(&if_stmt.test); - p.print(b')'); + p.print_char(b')'); match &if_stmt.consequent { Statement::BlockStatement(block) => { @@ -210,7 +210,7 @@ fn print_if( if let Some(alternate) = if_stmt.alternate.as_ref() { p.print_semicolon_if_needed(); p.print_space_before_identifier(); - p.print_str(b"else"); + p.print_str("else"); match alternate { Statement::BlockStatement(block) => { p.print_soft_space(); @@ -261,9 +261,9 @@ impl<'a, const MINIFY: bool> Gen for ForStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"for"); + p.print_str("for"); p.print_soft_space(); - p.print(b'('); + p.print_char(b'('); if let Some(init) = self.init.as_ref() { let ctx = Context::empty(); @@ -290,7 +290,7 @@ impl<'a, const MINIFY: bool> Gen for ForStatement<'a> { p.print_expression(update); } - p.print(b')'); + p.print_char(b')'); p.print_body(&self.body, false, ctx); } } @@ -299,16 +299,16 @@ impl<'a, const MINIFY: bool> Gen for ForInStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"for"); + p.print_str("for"); p.print_soft_space(); - p.print(b'('); + p.print_char(b'('); self.left.gen(p, ctx); p.print_soft_space(); p.print_space_before_identifier(); - p.print_str(b"in"); + p.print_str("in"); p.print_hard_space(); p.print_expression(&self.right); - p.print(b')'); + p.print_char(b')'); p.print_body(&self.body, false, ctx); } } @@ -317,18 +317,18 @@ impl<'a, const MINIFY: bool> Gen for ForOfStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"for"); + p.print_str("for"); p.print_soft_space(); if self.r#await { - p.print_str(b" await"); + p.print_str(" await"); } - p.print(b'('); + p.print_char(b'('); self.left.gen(p, ctx); p.print_soft_space(); p.print_space_before_identifier(); - p.print_str(b"of "); + p.print_str("of "); self.right.gen_expr(p, Precedence::Assign, Context::default()); - p.print(b')'); + p.print_char(b')'); p.print_body(&self.body, false, ctx); } } @@ -353,11 +353,11 @@ impl<'a, const MINIFY: bool> Gen for WhileStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"while"); + p.print_str("while"); p.print_soft_space(); - p.print(b'('); + p.print_char(b'('); p.print_expression(&self.test); - p.print(b')'); + p.print_char(b')'); p.print_body(&self.body, false, ctx); } } @@ -366,7 +366,7 @@ impl<'a, const MINIFY: bool> Gen for DoWhileStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"do "); + p.print_str("do "); if let Statement::BlockStatement(block) = &self.body { p.print_block_statement(block, ctx); p.print_soft_space(); @@ -378,11 +378,11 @@ impl<'a, const MINIFY: bool> Gen for DoWhileStatement<'a> { p.dedent(); p.print_indent(); } - p.print_str(b"while"); + p.print_str("while"); p.print_soft_space(); - p.print(b'('); + p.print_char(b'('); p.print_expression(&self.test); - p.print(b')'); + p.print_char(b')'); p.print_semicolon_after_statement(); } } @@ -400,7 +400,7 @@ impl<'a, const MINIFY: bool> Gen for ContinueStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"continue"); + p.print_str("continue"); if let Some(label) = &self.label { p.print_hard_space(); label.gen(p, ctx); @@ -413,7 +413,7 @@ impl<'a, const MINIFY: bool> Gen for BreakStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"break"); + p.print_str("break"); if let Some(label) = &self.label { p.print_hard_space(); label.gen(p, ctx); @@ -426,11 +426,11 @@ impl<'a, const MINIFY: bool> Gen for SwitchStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"switch"); + p.print_str("switch"); p.print_soft_space(); - p.print(b'('); + p.print_char(b'('); p.print_expression(&self.discriminant); - p.print(b')'); + p.print_char(b')'); p.print_soft_space(); p.print_curly_braces(self.span, self.cases.is_empty(), |p| { for case in &self.cases { @@ -449,10 +449,10 @@ impl<'a, const MINIFY: bool> Gen for SwitchCase<'a> { p.print_indent(); match &self.test { Some(test) => { - p.print_str(b"case "); + p.print_str("case "); p.print_expression(test); } - None => p.print_str(b"default"), + None => p.print_str("default"), } p.print_colon(); @@ -475,7 +475,7 @@ impl<'a, const MINIFY: bool> Gen for ReturnStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"return"); + p.print_str("return"); if let Some(arg) = &self.argument { p.print_hard_space(); p.print_expression(arg); @@ -502,17 +502,17 @@ impl<'a, const MINIFY: bool> Gen for TryStatement<'a> { p.add_source_mapping(self.span.start); p.print_indent(); p.print_space_before_identifier(); - p.print_str(b"try"); + p.print_str("try"); p.print_soft_space(); p.print_block_statement(&self.block, ctx); if let Some(handler) = &self.handler { p.print_soft_space(); - p.print_str(b"catch"); + p.print_str("catch"); if let Some(param) = &handler.param { p.print_soft_space(); - p.print_str(b"("); + p.print_str("("); param.pattern.gen(p, ctx); - p.print_str(b")"); + p.print_str(")"); } p.print_soft_space(); p.print_block_statement(&handler.body, ctx); @@ -522,7 +522,7 @@ impl<'a, const MINIFY: bool> Gen for TryStatement<'a> { } if let Some(finalizer) = &self.finalizer { p.print_soft_space(); - p.print_str(b"finally"); + p.print_str("finally"); p.print_soft_space(); p.print_block_statement(finalizer, ctx); } @@ -534,7 +534,7 @@ impl<'a, const MINIFY: bool> Gen for ThrowStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"throw "); + p.print_str("throw "); p.print_expression(&self.argument); p.print_semicolon_after_statement(); } @@ -544,10 +544,10 @@ impl<'a, const MINIFY: bool> Gen for WithStatement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"with"); - p.print(b'('); + p.print_str("with"); + p.print_char(b'('); p.print_expression(&self.object); - p.print(b')'); + p.print_char(b')'); p.print_body(&self.body, false, ctx); } } @@ -556,7 +556,7 @@ impl Gen for DebuggerStatement { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"debugger"); + p.print_str("debugger"); p.print_semicolon_after_statement(); } } @@ -564,10 +564,10 @@ impl Gen for DebuggerStatement { impl<'a, const MINIFY: bool> Gen for UsingDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.is_await { - p.print_str(b"await"); + p.print_str("await"); p.print_soft_space(); } - p.print_str(b"using"); + p.print_str("using"); p.print_soft_space(); p.print_list(&self.declarations, ctx); } @@ -577,7 +577,7 @@ impl<'a, const MINIFY: bool> Gen for VariableDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); if self.declare { - p.print_str(b"declare "); + p.print_str("declare "); } if p.comment_options.preserve_annotate_comments @@ -625,14 +625,14 @@ impl<'a, const MINIFY: bool> Gen for Function<'a> { let wrap = self.is_expression() && (p.start_of_stmt == n || p.start_of_default_export == n); p.wrap(wrap, |p| { if self.declare { - p.print_str(b"declare "); + p.print_str("declare "); } if self.r#async { - p.print_str(b"async "); + p.print_str("async "); } - p.print_str(b"function"); + p.print_str("function"); if self.generator { - p.print(b'*'); + p.print_char(b'*'); p.print_soft_space(); } if let Some(id) = &self.id { @@ -642,18 +642,18 @@ impl<'a, const MINIFY: bool> Gen for Function<'a> { if let Some(type_parameters) = &self.type_parameters { type_parameters.gen(p, ctx); } - p.print(b'('); + p.print_char(b'('); if let Some(this_param) = &self.this_param { this_param.gen(p, ctx); if !self.params.is_empty() || self.params.rest.is_some() { - p.print_str(b","); + p.print_str(","); } p.print_soft_space(); } self.params.gen(p, ctx); - p.print(b')'); + p.print_char(b')'); if let Some(return_type) = &self.return_type { - p.print_str(b": "); + p.print_str(": "); return_type.gen(p, ctx); } if let Some(body) = &self.body { @@ -682,7 +682,7 @@ impl<'a, const MINIFY: bool> Gen for FormalParameter<'a> { accessibility.gen(p, ctx); } if self.readonly { - p.print_str(b"readonly "); + p.print_str("readonly "); } self.pattern.gen(p, ctx); } @@ -705,19 +705,19 @@ impl<'a, const MINIFY: bool> Gen for ImportDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"import "); + p.print_str("import "); if self.import_kind.is_type() { - p.print_str(b"type "); + p.print_str("type "); } if let Some(specifiers) = &self.specifiers { if specifiers.is_empty() { - p.print_str(b"{}"); + p.print_str("{}"); p.print_soft_space(); - p.print_str(b"from"); + p.print_str("from"); p.print_soft_space(); - p.print(b'\''); - p.print_str(self.source.value.as_bytes()); - p.print(b'\''); + p.print_char(b'\''); + p.print_str(self.source.value.as_str()); + p.print_char(b'\''); if self.with_clause.is_some() { p.print_hard_space(); } @@ -732,7 +732,7 @@ impl<'a, const MINIFY: bool> Gen for ImportDeclaration<'a> { ImportDeclarationSpecifier::ImportDefaultSpecifier(spec) => { if in_block { p.print_soft_space(); - p.print_str(b"},"); + p.print_str("},"); in_block = false; } else if index != 0 { p.print_comma(); @@ -743,13 +743,13 @@ impl<'a, const MINIFY: bool> Gen for ImportDeclaration<'a> { ImportDeclarationSpecifier::ImportNamespaceSpecifier(spec) => { if in_block { p.print_soft_space(); - p.print_str(b"},"); + p.print_str("},"); in_block = false; } else if index != 0 { p.print_comma(); p.print_soft_space(); } - p.print_str(b"* as "); + p.print_str("* as "); spec.local.gen(p, ctx); } ImportDeclarationSpecifier::ImportSpecifier(spec) => { @@ -762,33 +762,33 @@ impl<'a, const MINIFY: bool> Gen for ImportDeclaration<'a> { p.print_soft_space(); } in_block = true; - p.print(b'{'); + p.print_char(b'{'); p.print_soft_space(); } if spec.import_kind.is_type() { - p.print_str(b"type "); + p.print_str("type "); } let imported_name = match &spec.imported { ModuleExportName::IdentifierName(identifier) => { identifier.gen(p, ctx); - identifier.name.as_bytes() + identifier.name.as_str() } ModuleExportName::IdentifierReference(identifier) => { identifier.gen(p, ctx); - identifier.name.as_bytes() + identifier.name.as_str() } ModuleExportName::StringLiteral(literal) => { literal.gen(p, ctx); - literal.value.as_bytes() + literal.value.as_str() } }; - let local_name = spec.local.name.as_bytes(); + let local_name = spec.local.name.as_str(); if imported_name != local_name { - p.print_str(b" as "); + p.print_str(" as "); spec.local.gen(p, ctx); } } @@ -796,9 +796,9 @@ impl<'a, const MINIFY: bool> Gen for ImportDeclaration<'a> { } if in_block { p.print_soft_space(); - p.print(b'}'); + p.print_char(b'}'); } - p.print_str(b" from "); + p.print_str(" from "); } self.source.gen(p, ctx); if self.with_clause.is_some() { @@ -833,7 +833,7 @@ impl<'a, const MINIFY: bool> Gen for ImportAttribute<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { match &self.key { ImportAttributeKey::Identifier(identifier) => { - p.print_str(identifier.name.as_bytes()); + p.print_str(identifier.name.as_str()); } ImportAttributeKey::StringLiteral(literal) => literal.gen(p, ctx), }; @@ -868,9 +868,9 @@ impl<'a, const MINIFY: bool> Gen for ExportNamedDeclaration<'a> { _ => {} }; } - p.print_str(b"export "); + p.print_str("export "); if self.export_kind.is_type() { - p.print_str(b"type "); + p.print_str("type "); } match &self.declaration { Some(decl) => { @@ -899,16 +899,16 @@ impl<'a, const MINIFY: bool> Gen for ExportNamedDeclaration<'a> { } } None => { - p.print(b'{'); + p.print_char(b'{'); if !self.specifiers.is_empty() { p.print_soft_space(); p.print_list(&self.specifiers, ctx); p.print_soft_space(); } - p.print(b'}'); + p.print_char(b'}'); if let Some(source) = &self.source { p.print_soft_space(); - p.print_str(b"from"); + p.print_str("from"); p.print_soft_space(); source.gen(p, ctx); } @@ -921,7 +921,7 @@ impl<'a, const MINIFY: bool> Gen for ExportNamedDeclaration<'a> { impl<'a, const MINIFY: bool> Gen for TSExportAssignment<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.print_indent(); - p.print_str(b"export = "); + p.print_str("export = "); self.expression.gen_expr(p, Precedence::lowest(), ctx); p.print_semicolon_after_statement(); } @@ -930,7 +930,7 @@ impl<'a, const MINIFY: bool> Gen for TSExportAssignment<'a> { impl<'a, const MINIFY: bool> Gen for TSNamespaceExportDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.print_indent(); - p.print_str(b"export as namespace "); + p.print_str("export as namespace "); self.id.gen(p, ctx); p.print_semicolon_after_statement(); } @@ -939,11 +939,11 @@ impl<'a, const MINIFY: bool> Gen for TSNamespaceExportDeclaration<'a> { impl<'a, const MINIFY: bool> Gen for ExportSpecifier<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.export_kind.is_type() { - p.print_str(b"type "); + p.print_str("type "); } self.local.gen(p, ctx); if self.local.name() != self.exported.name() { - p.print_str(b" as "); + p.print_str(" as "); self.exported.gen(p, ctx); } } @@ -952,8 +952,8 @@ impl<'a, const MINIFY: bool> Gen for ExportSpecifier<'a> { impl<'a, const MINIFY: bool> Gen for ModuleExportName<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { match self { - Self::IdentifierName(identifier) => p.print_str(identifier.name.as_bytes()), - Self::IdentifierReference(identifier) => p.print_str(identifier.name.as_bytes()), + Self::IdentifierName(identifier) => p.print_str(identifier.name.as_str()), + Self::IdentifierReference(identifier) => p.print_str(identifier.name.as_str()), Self::StringLiteral(literal) => literal.gen(p, ctx), }; } @@ -963,18 +963,18 @@ impl<'a, const MINIFY: bool> Gen for ExportAllDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"export "); + p.print_str("export "); if self.export_kind.is_type() { - p.print_str(b"type "); + p.print_str("type "); } - p.print(b'*'); + p.print_char(b'*'); if let Some(exported) = &self.exported { - p.print_str(b" as "); + p.print_str(" as "); exported.gen(p, ctx); } - p.print_str(b" from "); + p.print_str(" from "); self.source.gen(p, ctx); if self.with_clause.is_some() { p.print_hard_space(); @@ -988,7 +988,7 @@ impl<'a, const MINIFY: bool> Gen for ExportDefaultDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); p.print_indent(); - p.print_str(b"export default "); + p.print_str("export default "); self.declaration.gen(p, ctx); } } @@ -1053,7 +1053,7 @@ impl<'a, const MINIFY: bool> GenExpr for Expression<'a> { Self::TSAsExpression(e) => e.gen_expr(p, precedence, ctx), Self::TSSatisfiesExpression(e) => { e.expression.gen_expr(p, precedence, ctx); - p.print_str(b" satisfies "); + p.print_str(" satisfies "); e.type_annotation.gen(p, ctx); } Self::TSTypeAssertion(e) => e.gen_expr(p, precedence, ctx), @@ -1066,16 +1066,16 @@ impl<'a, const MINIFY: bool> GenExpr for Expression<'a> { impl<'a, const MINIFY: bool> GenExpr for TSAsExpression<'a> { fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, precedence: Precedence, ctx: Context) { self.expression.gen_expr(p, precedence, ctx); - p.print_str(b" as "); + p.print_str(" as "); self.type_annotation.gen(p, ctx); } } impl<'a, const MINIFY: bool> GenExpr for ParenthesizedExpression<'a> { fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, precedence: Precedence, ctx: Context) { - p.print_str(b"("); + p.print_str("("); self.expression.gen_expr(p, precedence, ctx); - p.print_str(b")"); + p.print_str(")"); } } @@ -1084,20 +1084,20 @@ impl<'a, const MINIFY: bool> Gen for IdentifierReference<'a> { // if let Some(mangler) = &p.mangler { // if let Some(reference_id) = self.reference_id.get() { // if let Some(name) = mangler.get_reference_name(reference_id) { - // p.print_str(name.clone().as_bytes()); + // p.print_str(name.clone().as_str()); // return; // } // } // } p.add_source_mapping_for_name(self.span, &self.name); - p.print_str(self.name.as_bytes()); + p.print_str(self.name.as_str()); } } impl<'a, const MINIFY: bool> Gen for IdentifierName<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); - p.print_str(self.name.as_bytes()); + p.print_str(self.name.as_str()); } } @@ -1110,14 +1110,14 @@ impl<'a, const MINIFY: bool> Gen for BindingIdentifier<'a> { impl<'a, const MINIFY: bool> Gen for LabelIdentifier<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping_for_name(self.span, &self.name); - p.print_str(self.name.as_bytes()); + p.print_str(self.name.as_str()); } } impl Gen for BooleanLiteral { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); - p.print_str(self.as_str().as_bytes()); + p.print_str(self.as_str()); } } @@ -1125,13 +1125,13 @@ impl Gen for NullLiteral { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.print_space_before_identifier(); p.add_source_mapping(self.span.start); - p.print_str(b"null"); + p.print_str("null"); } } // Need a space before "." if it could be parsed as a decimal point. -fn need_space_before_dot(bytes: &[u8], p: &mut Codegen<{ MINIFY }>) { - if !bytes.iter().any(|&b| matches!(b, b'.' | b'e' | b'x')) { +fn need_space_before_dot(s: &str, p: &mut Codegen<{ MINIFY }>) { + if !s.bytes().any(|b| matches!(b, b'.' | b'e' | b'x')) { p.need_space_before_dot = p.code_len(); } } @@ -1146,7 +1146,7 @@ impl<'a, const MINIFY: bool> Gen for NumericLiteral<'a> { if self.value.is_sign_negative() { p.print_space_before_operator(Operator::Unary(UnaryOperator::UnaryNegation)); - p.print_str(b"-"); + p.print_str("-"); } let result = if self.base == NumberBase::Float { @@ -1169,13 +1169,12 @@ impl<'a, const MINIFY: bool> Gen for NumericLiteral<'a> { print_non_negative_float(abs_value, p) } }; - let bytes = result.as_bytes(); + let bytes = result.as_str(); p.print_str(bytes); need_space_before_dot(bytes, p); } else { - let bytes = self.raw.as_bytes(); - p.print_str(bytes); - need_space_before_dot(bytes, p); + p.print_str(self.raw); + need_space_before_dot(self.raw, p); }; } } @@ -1244,7 +1243,7 @@ fn print_non_negative_float(value: f64, _p: &Codegen<{ MINIF impl<'a, const MINIFY: bool> Gen for BigIntLiteral<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); - p.print_str(self.raw.as_bytes()); + p.print_str(self.raw.as_str()); } } @@ -1259,10 +1258,10 @@ impl<'a, const MINIFY: bool> Gen for RegExpLiteral<'a> { { p.print_hard_space(); } - p.print(b'/'); - p.print_str(self.regex.pattern.as_bytes()); - p.print(b'/'); - p.print_str(self.regex.flags.to_string().as_bytes()); + p.print_char(b'/'); + p.print_str(self.regex.pattern.as_str()); + p.print_char(b'/'); + p.print_str(self.regex.flags.to_string().as_str()); p.prev_reg_exp_end = p.code().len(); } } @@ -1274,76 +1273,76 @@ fn print_unquoted_str(s: &str, quote: char, p: &mut Codegen< match c { '\x00' => { if chars.peek().is_some_and(|&next| next.is_ascii_digit()) { - p.print_str(b"\\x00"); + p.print_str("\\x00"); } else { - p.print_str(b"\\0"); + p.print_str("\\0"); } } '\x07' => { - p.print_str(b"\\x07"); + p.print_str("\\x07"); } // \b '\u{8}' => { - p.print_str(b"\\b"); + p.print_str("\\b"); } // \v '\u{b}' => { - p.print_str(b"\\v"); + p.print_str("\\v"); } // \f '\u{c}' => { - p.print_str(b"\\f"); + p.print_str("\\f"); } '\n' => { - p.print_str(b"\\n"); + p.print_str("\\n"); } '\r' => { - p.print_str(b"\\r"); + p.print_str("\\r"); } '\x1B' => { - p.print_str(b"\\x1B"); + p.print_str("\\x1B"); } '\\' => { - p.print_str(b"\\\\"); + p.print_str("\\\\"); } '\'' => { if quote == '\'' { - p.print_str(b"\\'"); + p.print_str("\\'"); } else { - p.print_str(b"'"); + p.print_str("'"); } } '\"' => { if quote == '"' { - p.print_str(b"\\\""); + p.print_str("\\\""); } else { - p.print_str(b"\""); + p.print_str("\""); } } '`' => { if quote == '`' { - p.print_str(b"\\`"); + p.print_str("\\`"); } else { - p.print_str(b"`"); + p.print_str("`"); } } '$' => { if chars.peek().is_some_and(|&next| next == '{') { - p.print_str(b"\\$"); + p.print_str("\\$"); } else { - p.print_str(b"$"); + p.print_str("$"); } } // Allow `U+2028` and `U+2029` in string literals // // - LS => p.print_str(b"\\u2028"), - PS => p.print_str(b"\\u2029"), + LS => p.print_str("\\u2028"), + PS => p.print_str("\\u2029"), '\u{a0}' => { - p.print_str(b"\\xA0"); + p.print_str("\\xA0"); } _ => { - p.print_str(c.encode_utf8([0; 4].as_mut()).as_bytes()); + p.print_str(c.encode_utf8([0; 4].as_mut())); } } } @@ -1363,7 +1362,7 @@ impl Gen for ThisExpression { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); p.print_space_before_identifier(); - p.print_str(b"this"); + p.print_str("this"); } } @@ -1383,11 +1382,11 @@ impl<'a, const MINIFY: bool> GenExpr for ComputedMemberExpression<'a> { fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, _precedence: Precedence, ctx: Context) { self.object.gen_expr(p, Precedence::Postfix, ctx); if self.optional { - p.print_str(b"?."); + p.print_str("?."); } - p.print(b'['); + p.print_char(b'['); self.expression.gen_expr(p, Precedence::lowest(), ctx); - p.print(b']'); + p.print_char(b']'); } } @@ -1395,12 +1394,12 @@ impl<'a, const MINIFY: bool> GenExpr for StaticMemberExpression<'a> { fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, _precedence: Precedence, ctx: Context) { self.object.gen_expr(p, Precedence::Postfix, ctx); if self.optional { - p.print(b'?'); + p.print_char(b'?'); } else if p.need_space_before_dot == p.code_len() { // `0.toExponential()` is invalid, add a space before the dot, `0 .toExponential()` is valid p.print_hard_space(); } - p.print(b'.'); + p.print_char(b'.'); self.property.gen(p, ctx); } } @@ -1409,9 +1408,9 @@ impl<'a, const MINIFY: bool> GenExpr for PrivateFieldExpression<'a> { fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, _precedence: Precedence, ctx: Context) { self.object.gen_expr(p, Precedence::Postfix, ctx); if self.optional { - p.print_str(b"?"); + p.print_str("?"); } - p.print(b'.'); + p.print_char(b'.'); self.field.gen(p, ctx); } } @@ -1425,14 +1424,14 @@ impl<'a, const MINIFY: bool> GenExpr for CallExpression<'a> { p.add_source_mapping(self.span.start); self.callee.gen_expr(p, self.precedence(), ctx); if self.optional { - p.print_str(b"?."); + p.print_str("?."); } if let Some(type_parameters) = &self.type_parameters { type_parameters.gen(p, ctx); } - p.print(b'('); + p.print_char(b'('); p.print_list(&self.arguments, ctx); - p.print(b')'); + p.print_char(b')'); p.add_source_mapping(self.span.end); }); } @@ -1472,12 +1471,12 @@ impl<'a, const MINIFY: bool> Gen for SpreadElement<'a> { impl<'a, const MINIFY: bool> Gen for ArrayExpression<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); - p.print(b'['); + p.print_char(b'['); p.print_list(&self.elements, ctx); if self.trailing_comma.is_some() { p.print_comma(); } - p.print(b']'); + p.print_char(b']'); p.add_source_mapping(self.span.end); } } @@ -1523,35 +1522,35 @@ impl<'a, const MINIFY: bool> Gen for ObjectProperty<'a> { PropertyKind::Init => false, PropertyKind::Get => { p.add_source_mapping(self.span.start); - p.print_str(b"get "); + p.print_str("get "); true } PropertyKind::Set => { p.add_source_mapping(self.span.start); - p.print_str(b"set "); + p.print_str("set "); true } }; if self.method || is_accessor { if func.r#async { - p.print_str(b"async "); + p.print_str("async "); } if func.generator { - p.print_str(b"*"); + p.print_str("*"); } if self.computed { - p.print(b'['); + p.print_char(b'['); } self.key.gen(p, ctx); if self.computed { - p.print(b']'); + p.print_char(b']'); } if let Some(type_parameters) = &func.type_parameters { type_parameters.gen(p, ctx); } - p.print(b'('); + p.print_char(b'('); func.params.gen(p, ctx); - p.print(b')'); + p.print_char(b')'); if let Some(body) = &func.body { p.print_soft_space(); body.gen(p, ctx); @@ -1560,13 +1559,13 @@ impl<'a, const MINIFY: bool> Gen for ObjectProperty<'a> { } } if self.computed { - p.print(b'['); + p.print_char(b'['); } if !self.shorthand { self.key.gen(p, ctx); } if self.computed { - p.print(b']'); + p.print_char(b']'); } if !self.shorthand { p.print_colon(); @@ -1594,7 +1593,7 @@ impl<'a, const MINIFY: bool> GenExpr for ArrowFunctionExpression<'a> { self.gen_comment(p, ctx); if self.r#async { p.add_source_mapping(self.span.start); - p.print_str(b"async"); + p.print_str("async"); } if self.r#async { @@ -1605,16 +1604,16 @@ impl<'a, const MINIFY: bool> GenExpr for ArrowFunctionExpression<'a> { type_parameters.gen(p, ctx); } p.add_source_mapping(self.span.start); - p.print(b'('); + p.print_char(b'('); self.params.gen(p, ctx); - p.print(b')'); + p.print_char(b')'); if let Some(return_type) = &self.return_type { - p.print_str(b":"); + p.print_str(":"); p.print_soft_space(); return_type.gen(p, ctx); } p.print_soft_space(); - p.print_str(b"=>"); + p.print_str("=>"); p.print_soft_space(); if self.expression { if let Statement::ExpressionStatement(stmt) = &self.body.statements[0] { @@ -1633,9 +1632,9 @@ impl<'a, const MINIFY: bool> GenExpr for YieldExpression<'a> { p.wrap(precedence >= self.precedence(), |p| { p.add_source_mapping(self.span.start); p.print_space_before_identifier(); - p.print_str(b"yield"); + p.print_str("yield"); if self.delegate { - p.print(b'*'); + p.print_char(b'*'); p.print_soft_space(); } if let Some(argument) = self.argument.as_ref() { @@ -1650,7 +1649,7 @@ impl<'a, const MINIFY: bool> GenExpr for YieldExpression<'a> { impl<'a, const MINIFY: bool> GenExpr for UpdateExpression<'a> { fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, precedence: Precedence, ctx: Context) { - let operator = self.operator.as_str().as_bytes(); + let operator = self.operator.as_str(); p.wrap(precedence > self.precedence(), |p| { if self.prefix { p.add_source_mapping(self.span.start); @@ -1673,7 +1672,7 @@ impl<'a, const MINIFY: bool> GenExpr for UpdateExpression<'a> { impl<'a, const MINIFY: bool> GenExpr for UnaryExpression<'a> { fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, precedence: Precedence, ctx: Context) { p.wrap(precedence > self.precedence() || precedence == Precedence::Exponential, |p| { - let operator = self.operator.as_str().as_bytes(); + let operator = self.operator.as_str(); if self.operator.is_keyword() { p.print_space_before_identifier(); p.print_str(operator); @@ -1718,7 +1717,7 @@ impl<'a, const MINIFY: bool> GenExpr for BinaryExpression<'a> { impl Gen for BinaryOperator { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { - let operator = self.as_str().as_bytes(); + let operator = self.as_str(); if self.is_keyword() { p.print_str(operator); p.print_hard_space(); @@ -1736,7 +1735,7 @@ impl Gen for BinaryOperator { impl<'a, const MINIFY: bool> Gen for PrivateInExpression<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { self.left.gen(p, ctx); - p.print_str(b" in "); + p.print_str(" in "); self.right.gen_expr(p, Precedence::Shift, Context::default()); } } @@ -1751,7 +1750,7 @@ impl<'a, const MINIFY: bool> GenExpr for LogicalExpression<'a> { p.wrap(mixed || (precedence > self.precedence()), |p| { self.left.gen_expr(p, self.precedence(), ctx); p.print_soft_space(); - p.print_str(self.operator.as_str().as_bytes()); + p.print_str(self.operator.as_str()); p.print_soft_space(); self.right.gen_expr(p, self.precedence(), ctx); }); @@ -1764,7 +1763,7 @@ impl<'a, const MINIFY: bool> GenExpr for ConditionalExpression<'a> { p.wrap(wrap, |p| { self.test.gen_expr(p, self.precedence(), ctx); p.print_soft_space(); - p.print(b'?'); + p.print_char(b'?'); p.print_soft_space(); self.consequent.gen_expr(p, Precedence::Assign, ctx.and_in(true)); p.print_soft_space(); @@ -1805,7 +1804,7 @@ impl<'a, const MINIFY: bool> GenExpr for AssignmentExpression<'a> { p.wrap(wrap || precedence > self.precedence(), |p| { self.left.gen(p, ctx); p.print_soft_space(); - p.print_str(self.operator.as_str().as_bytes()); + p.print_str(self.operator.as_str()); p.print_soft_space(); self.right.gen_expr(p, Precedence::Assign, ctx); }); @@ -1857,7 +1856,7 @@ impl<'a, const MINIFY: bool> Gen for AssignmentTargetPattern<'a> { impl<'a, const MINIFY: bool> Gen for ArrayAssignmentTarget<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); - p.print(b'['); + p.print_char(b'['); p.print_list(&self.elements, ctx); if let Some(target) = &self.rest { if !self.elements.is_empty() { @@ -1869,7 +1868,7 @@ impl<'a, const MINIFY: bool> Gen for ArrayAssignmentTarget<'a> { if self.trailing_comma.is_some() { p.print_comma(); } - p.print(b']'); + p.print_char(b']'); p.add_source_mapping(self.span.end); } } @@ -1885,7 +1884,7 @@ impl<'a, const MINIFY: bool> Gen for Option Gen for ObjectAssignmentTarget<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); - p.print(b'{'); + p.print_char(b'{'); p.print_list(&self.properties, ctx); if let Some(target) = &self.rest { if !self.properties.is_empty() { @@ -1894,7 +1893,7 @@ impl<'a, const MINIFY: bool> Gen for ObjectAssignmentTarget<'a> { p.add_source_mapping(self.span.start); target.gen(p, ctx); } - p.print(b'}'); + p.print_char(b'}'); p.add_source_mapping(self.span.end); } } @@ -1949,9 +1948,9 @@ impl<'a, const MINIFY: bool> Gen for AssignmentTargetPropertyProperty<'a ident.gen(p, ctx); } key @ match_expression!(PropertyKey) => { - p.print(b'['); + p.print_char(b'['); key.to_expression().gen_expr(p, Precedence::Assign, Context::default()); - p.print(b']'); + p.print_char(b']'); } } p.print_colon(); @@ -1981,34 +1980,34 @@ impl<'a, const MINIFY: bool> GenExpr for ImportExpression<'a> { let ctx = ctx.and_forbid_call(false); p.wrap(wrap, |p| { p.add_source_mapping(self.span.start); - p.print_str(b"import("); + p.print_str("import("); self.source.gen_expr(p, Precedence::Assign, ctx); if !self.arguments.is_empty() { p.print_comma(); p.print_expressions(&self.arguments, Precedence::Assign, ctx); } - p.print(b')'); + p.print_char(b')'); }); } } impl<'a, const MINIFY: bool> Gen for TemplateLiteral<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { - p.print(b'`'); + p.print_char(b'`'); let mut expressions = self.expressions.iter(); for quasi in &self.quasis { p.add_source_mapping(quasi.span.start); - p.print_str(quasi.value.raw.as_bytes()); + p.print_str(quasi.value.raw.as_str()); if let Some(expr) = expressions.next() { - p.print_str(b"${"); + p.print_str("${"); p.print_expression(expr); - p.print(b'}'); + p.print_char(b'}'); } } - p.print(b'`'); + p.print_char(b'`'); } } @@ -2023,7 +2022,7 @@ impl<'a, const MINIFY: bool> Gen for TaggedTemplateExpression<'a> { impl Gen for Super { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); - p.print_str(b"super"); + p.print_str("super"); } } @@ -2031,7 +2030,7 @@ impl<'a, const MINIFY: bool> GenExpr for AwaitExpression<'a> { fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, precedence: Precedence, ctx: Context) { p.wrap(precedence > self.precedence(), |p| { p.add_source_mapping(self.span.start); - p.print_str(b"await "); + p.print_str("await "); self.argument.gen_expr(p, self.precedence(), ctx); }); } @@ -2053,11 +2052,11 @@ impl<'a, const MINIFY: bool> GenExpr for NewExpression<'a> { self.gen_comment(p, ctx); p.wrap(precedence > self.precedence(), |p| { p.add_source_mapping(self.span.start); - p.print_str(b"new "); + p.print_str("new "); self.callee.gen_expr(p, Precedence::NewWithoutArgs, ctx.and_forbid_call(true)); - p.print(b'('); + p.print_char(b'('); p.print_list(&self.arguments, ctx); - p.print(b')'); + p.print_char(b')'); }); } } @@ -2066,7 +2065,7 @@ impl<'a, const MINIFY: bool> Gen for MetaProperty<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); self.meta.gen(p, ctx); - p.print(b'.'); + p.print_char(b'.'); self.property.gen(p, ctx); } } @@ -2075,16 +2074,16 @@ impl<'a, const MINIFY: bool> Gen for Class<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); if self.declare { - p.print_str(b"declare "); + p.print_str("declare "); } if self.r#abstract { - p.print_str(b"abstract "); + p.print_str("abstract "); } let n = p.code_len(); let wrap = self.is_expression() && (p.start_of_stmt == n || p.start_of_default_export == n); p.wrap(wrap, |p| { self.decorators.gen(p, ctx); - p.print_str(b"class"); + p.print_str("class"); if let Some(id) = &self.id { p.print_hard_space(); id.gen(p, ctx); @@ -2093,14 +2092,14 @@ impl<'a, const MINIFY: bool> Gen for Class<'a> { } } if let Some(super_class) = self.super_class.as_ref() { - p.print_str(b" extends "); + p.print_str(" extends "); super_class.gen_expr(p, Precedence::Call, Context::default()); if let Some(super_type_parameters) = &self.super_type_parameters { super_type_parameters.gen(p, ctx); } } if let Some(implements) = self.implements.as_ref() { - p.print_str(b" implements "); + p.print_str(" implements "); p.print_list(implements, ctx); } p.print_soft_space(); @@ -2152,7 +2151,7 @@ impl<'a, const MINIFY: bool> Gen for ClassElement<'a> { impl<'a, const MINIFY: bool> Gen for JSXIdentifier<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping_for_name(self.span, &self.name); - p.print_str(self.name.as_bytes()); + p.print_str(self.name.as_str()); } } @@ -2168,7 +2167,7 @@ impl<'a, const MINIFY: bool> Gen for JSXMemberExpressionObject<'a> { impl<'a, const MINIFY: bool> Gen for JSXMemberExpression<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { self.object.gen(p, ctx); - p.print(b'.'); + p.print_char(b'.'); self.property.gen(p, ctx); } } @@ -2225,9 +2224,9 @@ impl<'a, const MINIFY: bool> Gen for JSXExpression<'a> { impl<'a, const MINIFY: bool> Gen for JSXExpressionContainer<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print(b'{'); + p.print_char(b'{'); self.expression.gen(p, ctx); - p.print(b'}'); + p.print_char(b'}'); } } @@ -2237,9 +2236,9 @@ impl<'a, const MINIFY: bool> Gen for JSXAttributeValue<'a> { Self::Fragment(fragment) => fragment.gen(p, ctx), Self::Element(el) => el.gen(p, ctx), Self::StringLiteral(lit) => { - p.print(b'"'); + p.print_char(b'"'); print_unquoted_str(&lit.value, '"', p); - p.print(b'"'); + p.print_char(b'"'); } Self::ExpressionContainer(expr_container) => expr_container.gen(p, ctx), } @@ -2248,9 +2247,9 @@ impl<'a, const MINIFY: bool> Gen for JSXAttributeValue<'a> { impl<'a, const MINIFY: bool> Gen for JSXSpreadAttribute<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { - p.print_str(b"{..."); + p.print_str("{..."); self.argument.gen_expr(p, Precedence::Assign, Context::default()); - p.print(b'}'); + p.print_char(b'}'); } } @@ -2266,16 +2265,16 @@ impl<'a, const MINIFY: bool> Gen for JSXAttributeItem<'a> { impl<'a, const MINIFY: bool> Gen for JSXOpeningElement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); - p.print_str(b"<"); + p.print_str("<"); self.name.gen(p, ctx); for attr in &self.attributes { p.print_hard_space(); attr.gen(p, ctx); } if self.self_closing { - p.print_str(b"/>"); + p.print_str("/>"); } else { - p.print(b'>'); + p.print_char(b'>'); } } } @@ -2283,9 +2282,9 @@ impl<'a, const MINIFY: bool> Gen for JSXOpeningElement<'a> { impl<'a, const MINIFY: bool> Gen for JSXClosingElement<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); - p.print_str(b"'); + p.print_char(b'>'); } } @@ -2304,27 +2303,27 @@ impl<'a, const MINIFY: bool> Gen for JSXElement<'a> { impl Gen for JSXOpeningFragment { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); - p.print_str(b"<>"); + p.print_str("<>"); } } impl Gen for JSXClosingFragment { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); - p.print_str(b""); + p.print_str(""); } } impl<'a, const MINIFY: bool> Gen for JSXText<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping(self.span.start); - p.print_str(self.value.as_bytes()); + p.print_str(self.value.as_str()); } } impl<'a, const MINIFY: bool> Gen for JSXSpreadChild<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { - p.print_str(b"..."); + p.print_str("..."); p.print_expression(&self.expression); } } @@ -2354,7 +2353,7 @@ impl<'a, const MINIFY: bool> Gen for JSXFragment<'a> { impl<'a, const MINIFY: bool> Gen for StaticBlock<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); - p.print_str(b"static"); + p.print_str("static"); p.print_soft_space(); p.print_curly_braces(self.span, self.body.is_empty(), |p| { for stmt in &self.body { @@ -2375,46 +2374,46 @@ impl<'a, const MINIFY: bool> Gen for MethodDefinition<'a> { accessibility.gen(p, ctx); } if self.r#type == MethodDefinitionType::TSAbstractMethodDefinition { - p.print_str(b"abstract "); + p.print_str("abstract "); } if self.r#static { - p.print_str(b"static "); + p.print_str("static "); } match &self.kind { MethodDefinitionKind::Constructor | MethodDefinitionKind::Method => {} MethodDefinitionKind::Get => { - p.print_str(b"get "); + p.print_str("get "); } MethodDefinitionKind::Set => { - p.print_str(b"set "); + p.print_str("set "); } } if self.value.r#async { - p.print_str(b"async "); + p.print_str("async "); } if self.value.generator { - p.print_str(b"*"); + p.print_str("*"); } if self.computed { - p.print(b'['); + p.print_char(b'['); } self.key.gen(p, ctx); if self.computed { - p.print(b']'); + p.print_char(b']'); } if self.optional { - p.print(b'?'); + p.print_char(b'?'); } if let Some(type_parameters) = self.value.type_parameters.as_ref() { type_parameters.gen(p, ctx); } - p.print(b'('); + p.print_char(b'('); self.value.params.gen(p, ctx); - p.print(b')'); + p.print_char(b')'); if let Some(return_type) = &self.value.return_type { p.print_colon(); p.print_soft_space(); @@ -2437,23 +2436,23 @@ impl<'a, const MINIFY: bool> Gen for PropertyDefinition<'a> { accessibility.gen(p, ctx); } if self.r#type == PropertyDefinitionType::TSAbstractPropertyDefinition { - p.print_str(b"abstract "); + p.print_str("abstract "); } if self.r#static { - p.print_str(b"static "); + p.print_str("static "); } if self.readonly { - p.print_str(b"readonly "); + p.print_str("readonly "); } if self.computed { - p.print(b'['); + p.print_char(b'['); } self.key.gen(p, ctx); if self.computed { - p.print(b']'); + p.print_char(b']'); } if self.optional { - p.print_str(b"?"); + p.print_str("?"); } if let Some(type_annotation) = &self.type_annotation { p.print_colon(); @@ -2473,18 +2472,18 @@ impl<'a, const MINIFY: bool> Gen for AccessorProperty<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); if self.r#type.is_abstract() { - p.print_str(b"abstract "); + p.print_str("abstract "); } if self.r#static { - p.print_str(b"static "); + p.print_str("static "); } - p.print_str(b"accessor "); + p.print_str("accessor "); if self.computed { - p.print(b'['); + p.print_char(b'['); } self.key.gen(p, ctx); if self.computed { - p.print(b']'); + p.print_char(b']'); } if let Some(value) = &self.value { p.print_equal(); @@ -2497,8 +2496,8 @@ impl<'a, const MINIFY: bool> Gen for AccessorProperty<'a> { impl<'a, const MINIFY: bool> Gen for PrivateIdentifier<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { p.add_source_mapping_for_name(self.span, &self.name); - p.print(b'#'); - p.print_str(self.name.as_bytes()); + p.print_char(b'#'); + p.print_str(self.name.as_str()); } } @@ -2511,7 +2510,7 @@ impl<'a, const MINIFY: bool> Gen for BindingPattern<'a> { BindingPatternKind::AssignmentPattern(pattern) => pattern.gen(p, ctx), } if self.optional { - p.print_str(b"?"); + p.print_str("?"); } if let Some(type_annotation) = &self.type_annotation { p.print_colon(); @@ -2524,7 +2523,7 @@ impl<'a, const MINIFY: bool> Gen for BindingPattern<'a> { impl<'a, const MINIFY: bool> Gen for ObjectPattern<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.add_source_mapping(self.span.start); - p.print(b'{'); + p.print_char(b'{'); p.print_soft_space(); p.print_list(&self.properties, ctx); if let Some(rest) = &self.rest { @@ -2534,7 +2533,7 @@ impl<'a, const MINIFY: bool> Gen for ObjectPattern<'a> { rest.gen(p, ctx); } p.print_soft_space(); - p.print(b'}'); + p.print_char(b'}'); p.add_source_mapping(self.span.end); } } @@ -2543,13 +2542,13 @@ impl<'a, const MINIFY: bool> Gen for BindingProperty<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); if self.computed { - p.print(b'['); + p.print_char(b'['); } if !self.shorthand { self.key.gen(p, ctx); } if self.computed { - p.print(b']'); + p.print_char(b']'); } if !self.shorthand { p.print_colon(); @@ -2570,7 +2569,7 @@ impl<'a, const MINIFY: bool> Gen for BindingRestElement<'a> { impl<'a, const MINIFY: bool> Gen for ArrayPattern<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.add_source_mapping(self.span.start); - p.print(b'['); + p.print_char(b'['); for (index, item) in self.elements.iter().enumerate() { if index != 0 { p.print_comma(); @@ -2589,7 +2588,7 @@ impl<'a, const MINIFY: bool> Gen for ArrayPattern<'a> { p.print_soft_space(); rest.gen(p, ctx); } - p.print(b']'); + p.print_char(b']'); p.add_source_mapping(self.span.end); } } @@ -2632,7 +2631,7 @@ impl<'a, const MINIFY: bool> Gen for Decorator<'a> { } p.add_source_mapping(self.span.start); - p.print(b'@'); + p.print_char(b'@'); let wrap = need_wrap(&self.expression); p.wrap(wrap, |p| { self.expression.gen_expr(p, Precedence::Assign, Context::default()); @@ -2651,9 +2650,9 @@ impl<'a, const MINIFY: bool> Gen for TSClassImplements<'a> { impl<'a, const MINIFY: bool> Gen for TSTypeParameterDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print_str(b"<"); + p.print_str("<"); p.print_list(&self.params, ctx); - p.print_str(b">"); + p.print_str(">"); } } @@ -2681,20 +2680,20 @@ impl<'a, const MINIFY: bool> Gen for TSType<'a> { Self::TSLiteralType(ty) => ty.literal.gen(p, ctx), Self::TSImportType(ty) => ty.gen(p, ctx), Self::TSQualifiedName(ty) => ty.gen(p, ctx), - Self::TSAnyKeyword(_) => p.print_str(b"any"), - Self::TSBigIntKeyword(_) => p.print_str(b"bigint"), - Self::TSBooleanKeyword(_) => p.print_str(b"boolean"), - Self::TSIntrinsicKeyword(_) => p.print_str(b"intrinsic"), - Self::TSNeverKeyword(_) => p.print_str(b"never"), - Self::TSNullKeyword(_) => p.print_str(b"null"), - Self::TSNumberKeyword(_) => p.print_str(b"number"), - Self::TSObjectKeyword(_) => p.print_str(b"object"), - Self::TSStringKeyword(_) => p.print_str(b"string"), - Self::TSSymbolKeyword(_) => p.print_str(b"symbol"), - Self::TSThisType(_) => p.print_str(b"this"), - Self::TSUndefinedKeyword(_) => p.print_str(b"undefined"), - Self::TSUnknownKeyword(_) => p.print_str(b"unknown"), - Self::TSVoidKeyword(_) => p.print_str(b"void"), + Self::TSAnyKeyword(_) => p.print_str("any"), + Self::TSBigIntKeyword(_) => p.print_str("bigint"), + Self::TSBooleanKeyword(_) => p.print_str("boolean"), + Self::TSIntrinsicKeyword(_) => p.print_str("intrinsic"), + Self::TSNeverKeyword(_) => p.print_str("never"), + Self::TSNullKeyword(_) => p.print_str("null"), + Self::TSNumberKeyword(_) => p.print_str("number"), + Self::TSObjectKeyword(_) => p.print_str("object"), + Self::TSStringKeyword(_) => p.print_str("string"), + Self::TSSymbolKeyword(_) => p.print_str("symbol"), + Self::TSThisType(_) => p.print_str("this"), + Self::TSUndefinedKeyword(_) => p.print_str("undefined"), + Self::TSUnknownKeyword(_) => p.print_str("unknown"), + Self::TSVoidKeyword(_) => p.print_str("void"), Self::TSTemplateLiteralType(ty) => ty.gen(p, ctx), Self::TSTypeLiteral(ty) => ty.gen(p, ctx), Self::TSTypeOperatorType(ty) => ty.gen(p, ctx), @@ -2703,7 +2702,7 @@ impl<'a, const MINIFY: bool> Gen for TSType<'a> { Self::TSTypeReference(ty) => ty.gen(p, ctx), Self::JSDocNullableType(ty) => ty.gen(p, ctx), Self::JSDocNonNullableType(ty) => ty.gen(p, ctx), - Self::JSDocUnknownType(_ty) => p.print_str(b"unknown"), + Self::JSDocUnknownType(_ty) => p.print_str("unknown"), } } } @@ -2711,15 +2710,15 @@ impl<'a, const MINIFY: bool> Gen for TSType<'a> { impl<'a, const MINIFY: bool> Gen for TSArrayType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { self.element_type.gen(p, ctx); - p.print_str(b"[]"); + p.print_str("[]"); } } impl<'a, const MINIFY: bool> Gen for TSTupleType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print_str(b"["); + p.print_str("["); p.print_list(&self.element_types, ctx); - p.print_str(b"]"); + p.print_str("]"); } } @@ -2732,7 +2731,7 @@ impl<'a, const MINIFY: bool> Gen for TSUnionType<'a> { for (index, item) in self.types.iter().enumerate() { if index != 0 { p.print_soft_space(); - p.print_str(b"|"); + p.print_str("|"); p.print_soft_space(); } item.gen(p, ctx); @@ -2742,9 +2741,9 @@ impl<'a, const MINIFY: bool> Gen for TSUnionType<'a> { impl<'a, const MINIFY: bool> Gen for TSParenthesizedType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print(b'('); + p.print_char(b'('); self.type_annotation.gen(p, ctx); - p.print(b')'); + p.print_char(b')'); } } @@ -2757,7 +2756,7 @@ impl<'a, const MINIFY: bool> Gen for TSIntersectionType<'a> { for (index, item) in self.types.iter().enumerate() { if index != 0 { p.print_soft_space(); - p.print_str(b"&"); + p.print_str("&"); p.print_soft_space(); } item.gen(p, ctx); @@ -2768,18 +2767,18 @@ impl<'a, const MINIFY: bool> Gen for TSIntersectionType<'a> { impl<'a, const MINIFY: bool> Gen for TSConditionalType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { self.check_type.gen(p, ctx); - p.print_str(b" extends "); + p.print_str(" extends "); self.extends_type.gen(p, ctx); - p.print_str(b" ? "); + p.print_str(" ? "); self.true_type.gen(p, ctx); - p.print_str(b" : "); + p.print_str(" : "); self.false_type.gen(p, ctx); } } impl<'a, const MINIFY: bool> Gen for TSInferType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print_str(b"infer "); + p.print_str("infer "); self.type_parameter.gen(p, ctx); } } @@ -2787,69 +2786,69 @@ impl<'a, const MINIFY: bool> Gen for TSInferType<'a> { impl<'a, const MINIFY: bool> Gen for TSIndexedAccessType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { self.object_type.gen(p, ctx); - p.print_str(b"["); + p.print_str("["); self.index_type.gen(p, ctx); - p.print_str(b"]"); + p.print_str("]"); } } impl<'a, const MINIFY: bool> Gen for TSMappedType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print_str(b"{"); + p.print_str("{"); match self.readonly { TSMappedTypeModifierOperator::True => { - p.print_str(b"readonly"); + p.print_str("readonly"); } TSMappedTypeModifierOperator::Plus => { - p.print_str(b"+readonly"); + p.print_str("+readonly"); } TSMappedTypeModifierOperator::Minus => { - p.print_str(b"-readonly"); + p.print_str("-readonly"); } TSMappedTypeModifierOperator::None => {} } p.print_hard_space(); - p.print_str(b"["); + p.print_str("["); self.type_parameter.name.gen(p, ctx); if let Some(constraint) = &self.type_parameter.constraint { - p.print_str(b" in "); + p.print_str(" in "); constraint.gen(p, ctx); } if let Some(default) = &self.type_parameter.default { - p.print_str(b" = "); + p.print_str(" = "); default.gen(p, ctx); } if let Some(name_type) = &self.name_type { - p.print_str(b" as "); + p.print_str(" as "); name_type.gen(p, ctx); } - p.print_str(b"]"); + p.print_str("]"); match self.optional { TSMappedTypeModifierOperator::True => { - p.print_str(b"?"); + p.print_str("?"); } TSMappedTypeModifierOperator::Plus => { - p.print_str(b"+?"); + p.print_str("+?"); } TSMappedTypeModifierOperator::Minus => { - p.print_str(b"-?"); + p.print_str("-?"); } TSMappedTypeModifierOperator::None => {} } p.print_soft_space(); if let Some(type_annotation) = &self.type_annotation { - p.print_str(b":"); + p.print_str(":"); p.print_soft_space(); type_annotation.gen(p, ctx); } - p.print_str(b"}"); + p.print_str("}"); } } impl<'a, const MINIFY: bool> Gen for TSQualifiedName<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { self.left.gen(p, ctx); - p.print_str(b"."); + p.print_str("."); self.right.gen(p, ctx); } } @@ -2858,13 +2857,13 @@ impl<'a, const MINIFY: bool> Gen for TSTypeOperator<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { match self.operator { TSTypeOperatorOperator::Keyof => { - p.print_str(b"keyof "); + p.print_str("keyof "); } TSTypeOperatorOperator::Unique => { - p.print_str(b"unique "); + p.print_str("unique "); } TSTypeOperatorOperator::Readonly => { - p.print_str(b"readonly "); + p.print_str("readonly "); } } self.type_annotation.gen(p, ctx); @@ -2874,18 +2873,18 @@ impl<'a, const MINIFY: bool> Gen for TSTypeOperator<'a> { impl<'a, const MINIFY: bool> Gen for TSTypePredicate<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.asserts { - p.print_str(b"asserts "); + p.print_str("asserts "); } match &self.parameter_name { TSTypePredicateName::Identifier(ident) => { ident.gen(p, ctx); } TSTypePredicateName::This(_ident) => { - p.print_str(b"this"); + p.print_str("this"); } } if let Some(type_annotation) = &self.type_annotation { - p.print_str(b" is "); + p.print_str(" is "); type_annotation.gen(p, ctx); } } @@ -2904,9 +2903,9 @@ impl<'a, const MINIFY: bool> Gen for JSDocNullableType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.postfix { self.type_annotation.gen(p, ctx); - p.print_str(b"?"); + p.print_str("?"); } else { - p.print_str(b"?"); + p.print_str("?"); self.type_annotation.gen(p, ctx); } } @@ -2916,9 +2915,9 @@ impl<'a, const MINIFY: bool> Gen for JSDocNonNullableType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.postfix { self.type_annotation.gen(p, ctx); - p.print_str(b"!"); + p.print_str("!"); } else { - p.print_str(b"!"); + p.print_str("!"); self.type_annotation.gen(p, ctx); } } @@ -2926,18 +2925,18 @@ impl<'a, const MINIFY: bool> Gen for JSDocNonNullableType<'a> { impl<'a, const MINIFY: bool> Gen for TSTemplateLiteralType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print_str(b"`"); + p.print_str("`"); for (index, item) in self.quasis.iter().enumerate() { if index != 0 { if let Some(types) = self.types.get(index - 1) { - p.print_str(b"${"); + p.print_str("${"); types.gen(p, ctx); - p.print_str(b"}"); + p.print_str("}"); } } - p.print_str(item.value.raw.as_bytes()); + p.print_str(item.value.raw.as_str()); } - p.print_str(b"`"); + p.print_str("`"); } } @@ -2961,11 +2960,11 @@ impl<'a, const MINIFY: bool> Gen for TSTypeName<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { match self { Self::IdentifierReference(decl) => { - p.print_str(decl.name.as_bytes()); + p.print_str(decl.name.as_str()); } Self::QualifiedName(decl) => { decl.left.gen(p, ctx); - p.print_str(b"."); + p.print_str("."); decl.right.gen(p, ctx); } } @@ -2990,15 +2989,15 @@ impl<'a, const MINIFY: bool> Gen for TSLiteral<'a> { impl<'a, const MINIFY: bool> Gen for TSTypeParameter<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.r#const { - p.print_str(b"const "); + p.print_str("const "); } self.name.gen(p, ctx); if let Some(constraint) = &self.constraint { - p.print_str(b" extends "); + p.print_str(" extends "); constraint.gen(p, ctx); } if let Some(default) = &self.default { - p.print_str(b" = "); + p.print_str(" = "); default.gen(p, ctx); } } @@ -3009,18 +3008,18 @@ impl<'a, const MINIFY: bool> Gen for TSFunctionType<'a> { if let Some(type_parameters) = &self.type_parameters { type_parameters.gen(p, ctx); } - p.print_str(b"("); + p.print_str("("); if let Some(this_param) = &self.this_param { this_param.gen(p, ctx); if !self.params.is_empty() || self.params.rest.is_some() { - p.print_str(b","); + p.print_str(","); } p.print_soft_space(); } self.params.gen(p, ctx); - p.print_str(b")"); + p.print_str(")"); p.print_soft_space(); - p.print_str(b"=>"); + p.print_str("=>"); p.print_soft_space(); self.return_type.gen(p, ctx); } @@ -3030,7 +3029,7 @@ impl<'a, const MINIFY: bool> Gen for TSThisParameter<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { self.this.gen(p, ctx); if let Some(type_annotation) = &self.type_annotation { - p.print_str(b": "); + p.print_str(": "); type_annotation.gen(p, ctx); } } @@ -3042,19 +3041,19 @@ impl<'a, const MINIFY: bool> Gen for TSSignature<'a> { Self::TSIndexSignature(signature) => signature.gen(p, ctx), Self::TSPropertySignature(signature) => { if signature.readonly { - p.print_str(b"readonly "); + p.print_str("readonly "); } if signature.computed { - p.print(b'['); + p.print_char(b'['); signature.key.gen(p, ctx); - p.print(b']'); + p.print_char(b']'); } else { match &signature.key { PropertyKey::StaticIdentifier(key) => { key.gen(p, ctx); } PropertyKey::PrivateIdentifier(key) => { - p.print_str(key.name.as_bytes()); + p.print_str(key.name.as_str()); } key @ match_expression!(PropertyKey) => { key.to_expression().gen_expr(p, Precedence::Assign, ctx); @@ -3062,7 +3061,7 @@ impl<'a, const MINIFY: bool> Gen for TSSignature<'a> { } } if signature.optional { - p.print_str(b"?"); + p.print_str("?"); } if let Some(type_annotation) = &signature.type_annotation { p.print_colon(); @@ -3074,16 +3073,16 @@ impl<'a, const MINIFY: bool> Gen for TSSignature<'a> { if let Some(type_parameters) = signature.type_parameters.as_ref() { type_parameters.gen(p, ctx); } - p.print_str(b"("); + p.print_str("("); if let Some(this_param) = &signature.this_param { this_param.gen(p, ctx); if !signature.params.is_empty() || signature.params.rest.is_some() { - p.print_str(b","); + p.print_str(","); } p.print_soft_space(); } signature.params.gen(p, ctx); - p.print_str(b")"); + p.print_str(")"); if let Some(return_type) = &signature.return_type { p.print_colon(); p.print_soft_space(); @@ -3091,13 +3090,13 @@ impl<'a, const MINIFY: bool> Gen for TSSignature<'a> { } } Self::TSConstructSignatureDeclaration(signature) => { - p.print_str(b"new "); + p.print_str("new "); if let Some(type_parameters) = signature.type_parameters.as_ref() { type_parameters.gen(p, ctx); } - p.print_str(b"("); + p.print_str("("); signature.params.gen(p, ctx); - p.print_str(b")"); + p.print_str(")"); if let Some(return_type) = &signature.return_type { p.print_colon(); p.print_soft_space(); @@ -3107,20 +3106,20 @@ impl<'a, const MINIFY: bool> Gen for TSSignature<'a> { Self::TSMethodSignature(signature) => { match signature.kind { TSMethodSignatureKind::Method => {} - TSMethodSignatureKind::Get => p.print_str(b"get "), - TSMethodSignatureKind::Set => p.print_str(b"set "), + TSMethodSignatureKind::Get => p.print_str("get "), + TSMethodSignatureKind::Set => p.print_str("set "), } if signature.computed { - p.print(b'['); + p.print_char(b'['); signature.key.gen(p, ctx); - p.print(b']'); + p.print_char(b']'); } else { match &signature.key { PropertyKey::StaticIdentifier(key) => { key.gen(p, ctx); } PropertyKey::PrivateIdentifier(key) => { - p.print_str(key.name.as_bytes()); + p.print_str(key.name.as_str()); } key @ match_expression!(PropertyKey) => { key.to_expression().gen_expr(p, Precedence::Assign, ctx); @@ -3128,21 +3127,21 @@ impl<'a, const MINIFY: bool> Gen for TSSignature<'a> { } } if signature.optional { - p.print_str(b"?"); + p.print_str("?"); } if let Some(type_parameters) = &signature.type_parameters { type_parameters.gen(p, ctx); } - p.print_str(b"("); + p.print_str("("); if let Some(this_param) = &signature.this_param { this_param.gen(p, ctx); if !signature.params.is_empty() || signature.params.rest.is_some() { - p.print_str(b","); + p.print_str(","); } p.print_soft_space(); } signature.params.gen(p, ctx); - p.print_str(b")"); + p.print_str(")"); if let Some(return_type) = &signature.return_type { p.print_colon(); p.print_soft_space(); @@ -3155,7 +3154,7 @@ impl<'a, const MINIFY: bool> Gen for TSSignature<'a> { impl<'a, const MINIFY: bool> Gen for TSTypeQuery<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print_str(b"typeof "); + p.print_str("typeof "); self.expr_name.gen(p, ctx); if let Some(type_params) = &self.type_parameters { type_params.gen(p, ctx); @@ -3175,17 +3174,17 @@ impl<'a, const MINIFY: bool> Gen for TSTypeQueryExprName<'a> { impl<'a, const MINIFY: bool> Gen for TSImportType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.is_type_of { - p.print_str(b"typeof "); + p.print_str("typeof "); } - p.print_str(b"import("); + p.print_str("import("); self.parameter.gen(p, ctx); if let Some(attributes) = &self.attributes { p.print_str(", "); attributes.gen(p, ctx); } - p.print_str(b")"); + p.print_str(")"); if let Some(qualifier) = &self.qualifier { - p.print(b'.'); + p.print_char(b'.'); qualifier.gen(p, ctx); } if let Some(type_parameters) = &self.type_parameters { @@ -3197,9 +3196,9 @@ impl<'a, const MINIFY: bool> Gen for TSImportType<'a> { impl<'a, const MINIFY: bool> Gen for TSImportAttributes<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { // { with: { ... } } - p.print_str(b"{ with: { "); + p.print_str("{ with: { "); p.print_list(&self.elements, ctx); - p.print_str(b" }}"); + p.print_str(" }}"); } } @@ -3222,28 +3221,28 @@ impl<'a, const MINIFY: bool> Gen for TSImportAttributeName<'a> { impl<'a, const MINIFY: bool> Gen for TSTypeParameterInstantiation<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print_str(b"<"); + p.print_str("<"); p.print_list(&self.params, ctx); - p.print_str(b">"); + p.print_str(">"); } } impl<'a, const MINIFY: bool> Gen for TSIndexSignature<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.readonly { - p.print_str(b"readonly "); + p.print_str("readonly "); } - p.print_str(b"["); + p.print_str("["); for (index, parameter) in self.parameters.iter().enumerate() { if index != 0 { - p.print_str(b" | "); + p.print_str(" | "); } - p.print_str(parameter.name.as_bytes()); + p.print_str(parameter.name.as_str()); p.print_colon(); p.print_soft_space(); parameter.type_annotation.gen(p, ctx); } - p.print_str(b"]"); + p.print_str("]"); p.print_colon(); p.print_soft_space(); self.type_annotation.gen(p, ctx); @@ -3256,10 +3255,10 @@ impl<'a, const MINIFY: bool> Gen for TSTupleElement<'a> { match_ts_type!(TSTupleElement) => self.to_ts_type().gen(p, ctx), TSTupleElement::TSOptionalType(ts_type) => { ts_type.type_annotation.gen(p, ctx); - p.print_str(b"?"); + p.print_str("?"); } TSTupleElement::TSRestType(ts_type) => { - p.print_str(b"..."); + p.print_str("..."); ts_type.type_annotation.gen(p, ctx); } } @@ -3270,9 +3269,9 @@ impl<'a, const MINIFY: bool> Gen for TSNamedTupleMember<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { self.label.gen(p, ctx); if self.optional { - p.print_str(b"?"); + p.print_str("?"); } - p.print_str(b":"); + p.print_str(":"); p.print_soft_space(); self.element_type.gen(p, ctx); } @@ -3281,7 +3280,7 @@ impl<'a, const MINIFY: bool> Gen for TSNamedTupleMember<'a> { impl<'a, const MINIFY: bool> Gen for TSModuleDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.declare { - p.print_str(b"declare "); + p.print_str("declare "); } self.kind.gen(p, ctx); // If the kind is global, then the id is also `global`, so we don't need to print it @@ -3295,7 +3294,7 @@ impl<'a, const MINIFY: bool> Gen for TSModuleDeclaration<'a> { loop { match body { TSModuleDeclarationBody::TSModuleDeclaration(b) => { - p.print(b'.'); + p.print_char(b'.'); b.id.gen(p, ctx); if let Some(b) = &b.body { body = b; @@ -3319,13 +3318,13 @@ impl Gen for TSModuleDeclarationKind { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _: Context) { match self { TSModuleDeclarationKind::Global => { - p.print_str(b"global"); + p.print_str("global"); } TSModuleDeclarationKind::Module => { - p.print_str(b"module"); + p.print_str("module"); } TSModuleDeclarationKind::Namespace => { - p.print_str(b"namespace"); + p.print_str("namespace"); } } } @@ -3352,16 +3351,16 @@ impl<'a, const MINIFY: bool> Gen for TSModuleBlock<'a> { impl<'a, const MINIFY: bool> Gen for TSTypeAliasDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.declare { - p.print_str(b"declare "); + p.print_str("declare "); } - p.print_str(b"type"); + p.print_str("type"); p.print_space_before_identifier(); self.id.gen(p, ctx); if let Some(type_parameters) = &self.type_parameters { type_parameters.gen(p, ctx); } p.print_soft_space(); - p.print_str(b"="); + p.print_str("="); p.print_soft_space(); self.type_annotation.gen(p, ctx); } @@ -3369,7 +3368,7 @@ impl<'a, const MINIFY: bool> Gen for TSTypeAliasDeclaration<'a> { impl<'a, const MINIFY: bool> Gen for TSInterfaceDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print_str(b"interface"); + p.print_str("interface"); p.print_hard_space(); self.id.gen(p, ctx); if let Some(type_parameters) = &self.type_parameters { @@ -3377,7 +3376,7 @@ impl<'a, const MINIFY: bool> Gen for TSInterfaceDeclaration<'a> { } if let Some(extends) = &self.extends { if !extends.is_empty() { - p.print_str(b" extends "); + p.print_str(" extends "); p.print_list(extends, ctx); } } @@ -3406,13 +3405,13 @@ impl<'a, const MINIFY: bool> Gen for TSEnumDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { p.print_indent(); if self.declare { - p.print_str(b"declare "); + p.print_str("declare "); } if self.r#const { - p.print_str(b"const "); + p.print_str("const "); } p.print_space_before_identifier(); - p.print_str(b"enum "); + p.print_str("enum "); self.id.gen(p, ctx); p.print_space_before_identifier(); p.print_curly_braces(self.span, self.members.is_empty(), |p| { @@ -3433,9 +3432,9 @@ impl<'a, const MINIFY: bool> Gen for TSEnumMember<'a> { TSEnumMemberName::StaticStringLiteral(decl) => decl.gen(p, ctx), TSEnumMemberName::StaticNumericLiteral(decl) => decl.gen(p, ctx), decl @ match_expression!(TSEnumMemberName) => { - p.print_str(b"["); + p.print_str("["); decl.to_expression().gen_expr(p, Precedence::lowest(), ctx); - p.print_str(b"]"); + p.print_str("]"); } } if let Some(init) = &self.initializer { @@ -3450,17 +3449,17 @@ impl<'a, const MINIFY: bool> Gen for TSEnumMember<'a> { impl<'a, const MINIFY: bool> Gen for TSConstructorType<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { if self.r#abstract { - p.print_str(b"abstract "); + p.print_str("abstract "); } - p.print_str(b"new "); + p.print_str("new "); if let Some(type_parameters) = &self.type_parameters { type_parameters.gen(p, ctx); } - p.print_str(b"("); + p.print_str("("); self.params.gen(p, ctx); - p.print_str(b")"); + p.print_str(")"); p.print_soft_space(); - p.print_str(b"=>"); + p.print_str("=>"); p.print_soft_space(); self.return_type.gen(p, ctx); } @@ -3468,9 +3467,9 @@ impl<'a, const MINIFY: bool> Gen for TSConstructorType<'a> { impl<'a, const MINIFY: bool> Gen for TSImportEqualsDeclaration<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { - p.print_str(b"import "); + p.print_str("import "); self.id.gen(p, ctx); - p.print_str(b" = "); + p.print_str(" = "); self.module_reference.gen(p, ctx); } } @@ -3479,9 +3478,9 @@ impl<'a, const MINIFY: bool> Gen for TSModuleReference<'a> { fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) { match self { Self::ExternalModuleReference(decl) => { - p.print_str(b"require("); + p.print_str("require("); decl.expression.gen(p, ctx); - p.print_str(b")"); + p.print_str(")"); } match_ts_type_name!(Self) => self.to_ts_type_name().gen(p, ctx), } @@ -3491,14 +3490,14 @@ impl<'a, const MINIFY: bool> Gen for TSModuleReference<'a> { impl<'a, const MINIFY: bool> GenExpr for TSTypeAssertion<'a> { fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, precedence: Precedence, ctx: Context) { p.wrap(precedence > self.precedence(), |p| { - p.print_str(b"<"); + p.print_str("<"); // var r = < (x: T) => T > ((x) => { return null; }); // ^ make sure space is printed here. if matches!(self.type_annotation, TSType::TSFunctionType(_)) { p.print_hard_space(); } self.type_annotation.gen(p, ctx); - p.print_str(b">"); + p.print_str(">"); self.expression.gen_expr(p, Precedence::Grouping, ctx); }); } @@ -3507,9 +3506,9 @@ impl<'a, const MINIFY: bool> GenExpr for TSTypeAssertion<'a> { impl Gen for TSAccessibility { fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) { match self { - Self::Public => p.print_str(b"public "), - Self::Private => p.print_str(b"private "), - Self::Protected => p.print_str(b"protected "), + Self::Public => p.print_str("public "), + Self::Private => p.print_str("private "), + Self::Protected => p.print_str("protected "), } } } diff --git a/crates/oxc_codegen/src/lib.rs b/crates/oxc_codegen/src/lib.rs index 1b62391198617..822a1c5919dc5 100644 --- a/crates/oxc_codegen/src/lib.rs +++ b/crates/oxc_codegen/src/lib.rs @@ -175,13 +175,15 @@ impl<'a, const MINIFY: bool> Codegen<'a, MINIFY> { } /// Push a single character into the buffer - pub fn print(&mut self, ch: u8) { + #[inline] + pub fn print_char(&mut self, ch: u8) { self.code.push(ch); } /// Push a single character into the buffer - pub fn print_str>(&mut self, s: T) { - self.code.extend_from_slice(s.as_ref()); + #[inline] + pub fn print_str(&mut self, s: &str) { + self.code.extend(s.as_bytes()); } } @@ -198,30 +200,30 @@ impl<'a, const MINIFY: bool> Codegen<'a, MINIFY> { #[inline] fn print_soft_space(&mut self) { if !MINIFY { - self.print(b' '); + self.print_char(b' '); } } #[inline] pub fn print_hard_space(&mut self) { - self.print(b' '); + self.print_char(b' '); } #[inline] fn print_soft_newline(&mut self) { if !MINIFY { - self.print(b'\n'); + self.print_char(b'\n'); } } #[inline] fn print_semicolon(&mut self) { - self.print(b';'); + self.print_char(b';'); } #[inline] fn print_comma(&mut self) { - self.print(b','); + self.print_char(b','); } #[inline] @@ -273,7 +275,7 @@ impl<'a, const MINIFY: bool> Codegen<'a, MINIFY> { if MINIFY { self.needs_semicolon = true; } else { - self.print_str(b";\n"); + self.print_str(";\n"); } } @@ -287,17 +289,17 @@ impl<'a, const MINIFY: bool> Codegen<'a, MINIFY> { #[inline] fn print_ellipsis(&mut self) { - self.print_str(b"..."); + self.print_str("..."); } #[inline] pub fn print_colon(&mut self) { - self.print(b':'); + self.print_char(b':'); } #[inline] fn print_equal(&mut self) { - self.print(b'='); + self.print_char(b'='); } fn print_sequence>(&mut self, items: &[T], ctx: Context) { @@ -309,7 +311,7 @@ impl<'a, const MINIFY: bool> Codegen<'a, MINIFY> { fn print_curly_braces(&mut self, span: Span, single_line: bool, op: F) { self.add_source_mapping(span.start); - self.print(b'{'); + self.print_char(b'{'); if !single_line { self.print_soft_newline(); self.indent(); @@ -320,12 +322,12 @@ impl<'a, const MINIFY: bool> Codegen<'a, MINIFY> { self.print_indent(); } self.add_source_mapping(span.end); - self.print(b'}'); + self.print_char(b'}'); } fn print_block_start(&mut self, position: u32) { self.add_source_mapping(position); - self.print(b'{'); + self.print_char(b'{'); self.print_soft_newline(); self.indent(); } @@ -334,7 +336,7 @@ impl<'a, const MINIFY: bool> Codegen<'a, MINIFY> { self.dedent(); self.print_indent(); self.add_source_mapping(position); - self.print(b'}'); + self.print_char(b'}'); } fn print_body(&mut self, stmt: &Statement<'_>, need_space: bool, ctx: Context) { @@ -400,12 +402,12 @@ impl<'a, const MINIFY: bool> Codegen<'a, MINIFY> { // if let Some(mangler) = &self.mangler { // if let Some(symbol_id) = symbol_id { // let name = mangler.get_symbol_name(symbol_id); - // self.print_str(name.clone().as_bytes()); + // self.print_str(name.clone()); // return; // } // } self.add_source_mapping_for_name(span, fallback); - self.print_str(fallback.as_bytes()); + self.print_str(fallback); } fn print_space_before_operator(&mut self, next: Operator) { @@ -454,9 +456,9 @@ impl<'a, const MINIFY: bool> Codegen<'a, MINIFY> { #[inline] fn wrap_quote(&mut self, s: &str, mut f: F) { let quote = Self::choose_quote(s); - self.print(quote as u8); + self.print_char(quote as u8); f(self, quote); - self.print(quote as u8); + self.print_char(quote as u8); } fn print_directives_and_statements( diff --git a/crates/oxc_linter/src/rules/eslint/no_unsafe_negation.rs b/crates/oxc_linter/src/rules/eslint/no_unsafe_negation.rs index 2b5de78d0cbe0..7b49b4657b4c9 100644 --- a/crates/oxc_linter/src/rules/eslint/no_unsafe_negation.rs +++ b/crates/oxc_linter/src/rules/eslint/no_unsafe_negation.rs @@ -83,13 +83,13 @@ impl NoUnsafeNegation { // modify `!a instance of B` to `!(a instanceof B)` let modified_code = { let mut codegen = fixer.codegen(); - codegen.print(b'!'); + codegen.print_char(b'!'); let Expression::UnaryExpression(left) = &expr.left else { unreachable!() }; - codegen.print(b'('); + codegen.print_char(b'('); codegen.print_expression(&left.argument); expr.operator.gen(&mut codegen, Context::default()); codegen.print_expression(&expr.right); - codegen.print(b')'); + codegen.print_char(b')'); codegen.into_source_text() }; fixer.replace(expr.span, modified_code) diff --git a/crates/oxc_linter/src/rules/jest/no_untyped_mock_factory.rs b/crates/oxc_linter/src/rules/jest/no_untyped_mock_factory.rs index e8b5031157f0a..c8ac2398e754c 100644 --- a/crates/oxc_linter/src/rules/jest/no_untyped_mock_factory.rs +++ b/crates/oxc_linter/src/rules/jest/no_untyped_mock_factory.rs @@ -141,9 +141,9 @@ impl NoUntypedMockFactory { ), |fixer| { let mut content = fixer.codegen(); - content.print_str(b"("); + content.print_str("("); let span = Span::sized(string_literal.span.start - 1, 1); fixer.replace(span, content) diff --git a/crates/oxc_linter/src/rules/jest/prefer_comparison_matcher.rs b/crates/oxc_linter/src/rules/jest/prefer_comparison_matcher.rs index 39483dd14c762..78178f857ea82 100644 --- a/crates/oxc_linter/src/rules/jest/prefer_comparison_matcher.rs +++ b/crates/oxc_linter/src/rules/jest/prefer_comparison_matcher.rs @@ -127,7 +127,7 @@ impl PreferComparisonMatcher { binary_expr, call_span_end, arg_span_end, - parse_expect_jest_fn.local.as_bytes(), + &parse_expect_jest_fn.local, &parse_expect_jest_fn.modifiers(), prefer_matcher_name, fixer, @@ -175,31 +175,31 @@ impl PreferComparisonMatcher { binary_expr: &BinaryExpression<'a>, call_span_end: &str, arg_span_end: &str, - local_name: &[u8], + local_name: &str, modifiers: &[&KnownMemberExpressionProperty<'a>], prefer_matcher_name: &str, fixer: RuleFixer<'_, 'a>, ) -> String { let mut content = fixer.codegen(); content.print_str(local_name); - content.print(b'('); + content.print_char(b'('); content.print_expression(&binary_expr.left); - content.print_str(call_span_end.as_bytes()); - content.print(b'.'); + content.print_str(call_span_end); + content.print_char(b'.'); for modifier in modifiers { let Some(modifier_name) = modifier.name() else { continue; }; if !modifier_name.eq("not") { - content.print_str(modifier_name.as_bytes()); - content.print(b'.'); + content.print_str(&modifier_name); + content.print_char(b'.'); } } - content.print_str(prefer_matcher_name.as_bytes()); - content.print(b'('); + content.print_str(prefer_matcher_name); + content.print_char(b'('); content.print_expression(&binary_expr.right); - content.print_str(arg_span_end.as_bytes()); + content.print_str(arg_span_end); content.into_source_text() } } diff --git a/crates/oxc_linter/src/rules/jest/prefer_expect_resolves.rs b/crates/oxc_linter/src/rules/jest/prefer_expect_resolves.rs index 65e89905a53fd..1289c3ce2b5c9 100644 --- a/crates/oxc_linter/src/rules/jest/prefer_expect_resolves.rs +++ b/crates/oxc_linter/src/rules/jest/prefer_expect_resolves.rs @@ -135,12 +135,12 @@ impl PreferExpectResolves { call_expr.span.end, ); - formatter.print_str(b"await"); + formatter.print_str("await"); formatter.print_hard_space(); - formatter.print_str(jest_expect_fn_call.local.as_bytes()); - formatter.print(b'('); + formatter.print_str(&jest_expect_fn_call.local); + formatter.print_char(b'('); formatter.print_str(fixer.source_range(arg_span)); - formatter.print_str(b".resolves"); + formatter.print_str(".resolves"); fixer.replace(call_expr.span, formatter) } } diff --git a/crates/oxc_linter/src/rules/jest/prefer_mock_promise_shorthand.rs b/crates/oxc_linter/src/rules/jest/prefer_mock_promise_shorthand.rs index 0dd918a60663c..296b040431035 100644 --- a/crates/oxc_linter/src/rules/jest/prefer_mock_promise_shorthand.rs +++ b/crates/oxc_linter/src/rules/jest/prefer_mock_promise_shorthand.rs @@ -167,9 +167,9 @@ impl PreferMockPromiseShorthand { ) -> String { let mut content = fixer.codegen(); content.print_str(prefer_name); - content.print(b'('); + content.print_char(b'('); if call_expr.arguments.is_empty() { - content.print_str(b"undefined"); + content.print_str("undefined"); } else { for argument in &call_expr.arguments { if let Some(expr) = argument.as_expression() { diff --git a/crates/oxc_linter/src/rules/jest/prefer_spy_on.rs b/crates/oxc_linter/src/rules/jest/prefer_spy_on.rs index a85437d63be59..f0e126d38c6ad 100644 --- a/crates/oxc_linter/src/rules/jest/prefer_spy_on.rs +++ b/crates/oxc_linter/src/rules/jest/prefer_spy_on.rs @@ -139,38 +139,38 @@ impl PreferSpyOn { fixer: RuleFixer<'_, 'a>, ) -> String { let mut formatter = fixer.codegen(); - formatter.print_str(b"jest.spyOn("); + formatter.print_str("jest.spyOn("); match left_assign { MemberExpression::ComputedMemberExpression(cmp_mem_expr) => { formatter.print_expression(&cmp_mem_expr.object); - formatter.print(b','); + formatter.print_char(b','); formatter.print_hard_space(); formatter.print_expression(&cmp_mem_expr.expression); } MemberExpression::StaticMemberExpression(static_mem_expr) => { let name = &static_mem_expr.property.name; formatter.print_expression(&static_mem_expr.object); - formatter.print(b','); + formatter.print_char(b','); formatter.print_hard_space(); - formatter.print_str(format!("\'{name}\'").as_bytes()); + formatter.print_str(format!("\'{name}\'").as_str()); } MemberExpression::PrivateFieldExpression(_) => (), } - formatter.print(b')'); + formatter.print_char(b')'); if has_mock_implementation { return formatter.into_source_text(); } - formatter.print_str(b".mockImplementation("); + formatter.print_str(".mockImplementation("); if let Some(expr) = Self::get_jest_fn_call(call_expr) { formatter.print_expression(expr); } - formatter.print(b')'); + formatter.print_char(b')'); formatter.into_source_text() } diff --git a/crates/oxc_linter/src/rules/jest/prefer_to_have_length.rs b/crates/oxc_linter/src/rules/jest/prefer_to_have_length.rs index 3efdc90edff84..91698f620eb7a 100644 --- a/crates/oxc_linter/src/rules/jest/prefer_to_have_length.rs +++ b/crates/oxc_linter/src/rules/jest/prefer_to_have_length.rs @@ -167,24 +167,24 @@ impl PreferToHaveLength { return formatter.into_source_text(); }; - formatter.print_str(b"expect("); - formatter.print_str(prop_ident.name.as_bytes()); - formatter.print_str(b")"); + formatter.print_str("expect("); + formatter.print_str(prop_ident.name.as_str()); + formatter.print_str(")"); if let Some(kind_val) = kind { if kind_val == "ComputedMember" { let property = property_name.unwrap(); - formatter.print_str(b"[\""); - formatter.print_str(property.as_bytes()); - formatter.print_str(b"\"]"); + formatter.print_str("[\""); + formatter.print_str(property); + formatter.print_str("\"]"); } else if kind_val == "StaticMember" { - formatter.print_str(b"."); + formatter.print_str("."); let property = property_name.unwrap(); - formatter.print_str(property.as_bytes()); + formatter.print_str(property); } } - formatter.print_str(b".toHaveLength"); + formatter.print_str(".toHaveLength"); formatter.into_source_text() } } diff --git a/crates/oxc_linter/src/rules/jest/prefer_todo.rs b/crates/oxc_linter/src/rules/jest/prefer_todo.rs index cc109f0563988..f08b8f3b152a0 100644 --- a/crates/oxc_linter/src/rules/jest/prefer_todo.rs +++ b/crates/oxc_linter/src/rules/jest/prefer_todo.rs @@ -142,21 +142,21 @@ fn build_code<'a>(fixer: RuleFixer<'_, 'a>, expr: &CallExpression<'a>) -> Fix<'a match &expr.callee { Expression::Identifier(ident) => { - formatter.print_str(ident.name.as_bytes()); - formatter.print_str(b".todo("); + formatter.print_str(ident.name.as_str()); + formatter.print_str(".todo("); } Expression::ComputedMemberExpression(expr) => { if let Expression::Identifier(ident) = &expr.object { - formatter.print_str(ident.name.as_bytes()); - formatter.print_str(b"["); - formatter.print_str(b"'todo'"); - formatter.print_str(b"]("); + formatter.print_str(ident.name.as_str()); + formatter.print_str("["); + formatter.print_str("'todo'"); + formatter.print_str("]("); } } Expression::StaticMemberExpression(expr) => { if let Expression::Identifier(ident) = &expr.object { - formatter.print_str(ident.name.as_bytes()); - formatter.print_str(b".todo("); + formatter.print_str(ident.name.as_str()); + formatter.print_str(".todo("); } } _ => {} @@ -164,17 +164,17 @@ fn build_code<'a>(fixer: RuleFixer<'_, 'a>, expr: &CallExpression<'a>) -> Fix<'a if let Argument::StringLiteral(ident) = &expr.arguments[0] { // Todo: this punctuation should read from the config - formatter.print(b'\''); - formatter.print_str(ident.value.as_bytes()); - formatter.print(b'\''); - formatter.print(b')'); + formatter.print_char(b'\''); + formatter.print_str(ident.value.as_str()); + formatter.print_char(b'\''); + formatter.print_char(b')'); } else if let Argument::TemplateLiteral(temp) = &expr.arguments[0] { - formatter.print(b'`'); + formatter.print_char(b'`'); for q in &temp.quasis { - formatter.print_str(q.value.raw.as_bytes()); + formatter.print_str(q.value.raw.as_str()); } - formatter.print(b'`'); - formatter.print(b')'); + formatter.print_char(b'`'); + formatter.print_char(b')'); } fixer.replace(expr.span, formatter) diff --git a/crates/oxc_linter/src/rules/unicorn/explicit_length_check.rs b/crates/oxc_linter/src/rules/unicorn/explicit_length_check.rs index a29876a307834..a8f6cf4343707 100644 --- a/crates/oxc_linter/src/rules/unicorn/explicit_length_check.rs +++ b/crates/oxc_linter/src/rules/unicorn/explicit_length_check.rs @@ -198,7 +198,7 @@ impl ExplicitLengthCheck { let start = ctx.source_text().as_bytes()[span.start as usize - 1]; need_pad_start = start.is_ascii_alphabetic() || !start.is_ascii(); } - if (span.end as usize) < ctx.source_text().as_bytes().len() { + if (span.end as usize) < ctx.source_text().len() { let end = ctx.source_text().as_bytes()[span.end as usize]; need_pad_end = end.is_ascii_alphabetic() || !end.is_ascii(); } diff --git a/crates/oxc_linter/src/rules/unicorn/no_useless_spread.rs b/crates/oxc_linter/src/rules/unicorn/no_useless_spread.rs index b7a3f1552b697..e19f9cc2b426c 100644 --- a/crates/oxc_linter/src/rules/unicorn/no_useless_spread.rs +++ b/crates/oxc_linter/src/rules/unicorn/no_useless_spread.rs @@ -224,18 +224,18 @@ fn diagnose_array_in_array_spread<'a>( // [ ...[a, b, c], ...[d, e, f] ] -> [a, b, c, d, e, f] ctx.diagnostic_with_fix(diagnostic, |fixer| { let mut codegen = fixer.codegen(); - codegen.print(b'['); + codegen.print_char(b'['); let elements = spreads.iter().flat_map(|arr| arr.elements.iter()).collect::>(); let n = elements.len(); for (i, el) in elements.into_iter().enumerate() { codegen.print_expression(el.to_expression()); if i < n - 1 { - codegen.print(b','); + codegen.print_char(b','); codegen.print_hard_space(); } } - codegen.print(b']'); + codegen.print_char(b']'); fixer.replace(outer_array.span, codegen) }); } diff --git a/crates/oxc_linter/src/rules/unicorn/require_number_to_fixed_digits_argument.rs b/crates/oxc_linter/src/rules/unicorn/require_number_to_fixed_digits_argument.rs index b1f019944691c..be7e5baea70a7 100644 --- a/crates/oxc_linter/src/rules/unicorn/require_number_to_fixed_digits_argument.rs +++ b/crates/oxc_linter/src/rules/unicorn/require_number_to_fixed_digits_argument.rs @@ -70,8 +70,8 @@ impl Rule for RequireNumberToFixedDigitsArgument { let span_source_code = fixer.source_range(parenthesis_span_without_right_one); - formatter.print_str(span_source_code.as_bytes()); - formatter.print_str(b"0)"); + formatter.print_str(span_source_code); + formatter.print_str("0)"); formatter.into_source_text() }; diff --git a/crates/oxc_linter/src/rules/unicorn/switch_case_braces.rs b/crates/oxc_linter/src/rules/unicorn/switch_case_braces.rs index 77b82c7ecf0f1..f93da95d2672a 100644 --- a/crates/oxc_linter/src/rules/unicorn/switch_case_braces.rs +++ b/crates/oxc_linter/src/rules/unicorn/switch_case_braces.rs @@ -77,19 +77,19 @@ impl Rule for SwitchCaseBraces { let mut formatter = fixer.codegen(); if let Some(case_test) = &case.test { - formatter.print_str(b"case "); + formatter.print_str("case "); formatter.print_expression(case_test); } else { - formatter.print_str(b"default"); + formatter.print_str("default"); } formatter.print_colon(); formatter.print_hard_space(); - formatter.print(b'{'); + formatter.print_char(b'{'); case.consequent .iter() .for_each(|x| x.gen(&mut formatter, Context::default())); - formatter.print(b'}'); + formatter.print_char(b'}'); formatter.into_source_text() };