dan/oxc
1
0
Fork 0
mirror of https://github.com/danbulant/oxc synced 2026-05-24 12:21:58 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor(prettier): use plain print_xxx functions (#1361)

Browse source
This commit is contained in:
Boshen 2023-11-17 12:36:05 +08:00 committed by GitHub
parent 3267437128
commit c6957ae8f1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 278 additions and 276 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
crates/oxc_prettier/src/format/array.rs
View file

@ -21,26 +21,24 @@ impl<'a, 'b> Array<'a, 'b> {
}
}
impl<'a> Prettier<'a> {
pub(super) fn print_array(&mut self, array: &Array<'a, '_>) -> Doc<'a> {
if array.len() == 0 {
return ss!("[]");
}
let mut parts = self.vec();
parts.push(ss!("["));
let mut parts_inner = self.vec();
parts_inner.push(Doc::Softline);
parts_inner.extend(print_elements(self, array));
parts_inner.push(if_break!(self, ","));
parts.push(group!(self, Doc::Indent(parts_inner)));
parts.push(Doc::Softline);
parts.push(ss!("]"));
Doc::Group(parts)
pub(super) fn print_array<'a>(p: &mut Prettier<'a>, array: &Array<'a, '_>) -> Doc<'a> {
if array.len() == 0 {
return ss!("[]");
}
let mut parts = p.vec();
parts.push(ss!("["));
let mut parts_inner = p.vec();
parts_inner.push(Doc::Softline);
parts_inner.extend(print_elements(p, array));
parts_inner.push(if_break!(p, ","));
parts.push(group!(p, Doc::Indent(parts_inner)));
parts.push(Doc::Softline);
parts.push(ss!("]"));
Doc::Group(parts)
}
fn print_elements<'a>(p: &mut Prettier<'a>, array: &Array<'a, '_>) -> Vec<'a, Doc<'a>> {

15
crates/oxc_prettier/src/format/arrow_function.rs
View file

@ -3,13 +3,14 @@ use oxc_ast::ast::*;
use crate::{doc::Doc, ss, Format, Prettier};
impl<'a> Prettier<'a> {
pub(super) fn print_arrow_function(&mut self, expr: &ArrowExpression<'a>) -> Doc<'a> {
let mut parts = self.vec();
pub(super) fn print_arrow_function<'a>(
p: &mut Prettier<'a>,
expr: &ArrowExpression<'a>,
) -> Doc<'a> {
let mut parts = p.vec();
parts.push(ss!("() => "));
parts.push(expr.body.format(self));
parts.push(ss!("() => "));
parts.push(expr.body.format(p));
Doc::Array(parts)
}
Doc::Array(parts)
}

28
crates/oxc_prettier/src/format/binaryish.rs
View file

@ -33,19 +33,17 @@ impl BinaryishOperator {
}
}
impl<'a> Prettier<'a> {
pub(super) fn print_binaryish_expression<'b>(
&mut self,
left: &BinaryishLeft<'a, 'b>,
operator: BinaryishOperator,
right: &Expression<'a>,
) -> Doc<'a> {
let mut parts = self.vec();
parts.push(left.format(self));
parts.push(ss!(" "));
parts.push(ss!(operator.as_str()));
parts.push(Doc::Line);
parts.push(right.format(self));
Doc::Array(parts)
}
pub(super) fn print_binaryish_expression<'a>(
p: &mut Prettier<'a>,
left: &BinaryishLeft<'a, '_>,
operator: BinaryishOperator,
right: &Expression<'a>,
) -> Doc<'a> {
let mut parts = p.vec();
parts.push(left.format(p));
parts.push(ss!(" "));
parts.push(ss!(operator.as_str()));
parts.push(Doc::Line);
parts.push(right.format(p));
Doc::Array(parts)
}

88
crates/oxc_prettier/src/format/block.rs
View file

@ -4,50 +4,50 @@ use oxc_ast::ast::*;
use crate::{doc::Doc, hardline, indent, ss, Prettier};
impl<'a> Prettier<'a> {
pub(super) fn print_block(
&mut self,
stmts: &Vec<'a, Statement<'a>>,
directives: Option<&Vec<'a, Directive>>,
is_static_block: bool,
) -> Doc<'a> {
let mut parts = self.vec();
if is_static_block {
parts.push(ss!("static "));
}
parts.push(ss!("{"));
if let Some(doc) = self.print_block_body(stmts, directives) {
parts.push(indent![self, hardline!(), doc]);
parts.push(hardline!());
}
parts.push(ss!("}"));
Doc::Array(parts)
use super::statement;
pub(super) fn print_block<'a>(
p: &mut Prettier<'a>,
stmts: &Vec<'a, Statement<'a>>,
directives: Option<&Vec<'a, Directive>>,
is_static_block: bool,
) -> Doc<'a> {
let mut parts = p.vec();
if is_static_block {
parts.push(ss!("static "));
}
pub(super) fn print_block_body(
&mut self,
stmts: &Vec<'a, Statement<'a>>,
directives: Option<&Vec<'a, Directive>>,
) -> Option<Doc<'a>> {
let has_directives = directives.is_some_and(|directives| !directives.is_empty());
let has_body = stmts.iter().any(|stmt| !matches!(stmt, Statement::EmptyStatement(_)));
if !has_body && !has_directives {
return None;
}
let mut parts = self.vec();
if has_directives {
if let Some(directives) = directives {
parts.extend(self.print_statement_sequence(directives));
}
}
if !stmts.is_empty() {
parts.extend(self.print_statement_sequence(stmts));
}
Some(Doc::Array(parts))
parts.push(ss!("{"));
if let Some(doc) = print_block_body(p, stmts, directives) {
parts.push(indent![p, hardline!(), doc]);
parts.push(hardline!());
}
parts.push(ss!("}"));
Doc::Array(parts)
}
pub(super) fn print_block_body<'a>(
p: &mut Prettier<'a>,
stmts: &Vec<'a, Statement<'a>>,
directives: Option<&Vec<'a, Directive>>,
) -> Option<Doc<'a>> {
let has_directives = directives.is_some_and(|directives| !directives.is_empty());
let has_body = stmts.iter().any(|stmt| !matches!(stmt, Statement::EmptyStatement(_)));
if !has_body && !has_directives {
return None;
}
let mut parts = p.vec();
if has_directives {
if let Some(directives) = directives {
parts.extend(statement::print_statement_sequence(p, directives));
}
}
if !stmts.is_empty() {
parts.extend(statement::print_statement_sequence(p, stmts));
}
Some(Doc::Array(parts))
}

28
crates/oxc_prettier/src/format/call_expression.rs
View file

@ -4,19 +4,17 @@ use oxc_ast::ast::*;
use crate::{doc::Doc, ss, Format, Prettier};
impl<'a> Prettier<'a> {
pub(super) fn print_call_expression(
&mut self,
callee: &Expression<'a>,
arguments: &Vec<'a, Argument<'a>>,
optional: bool, // for optional chaining
type_parameters: &Option<Box<'a, TSTypeParameterInstantiation<'a>>>,
) -> Doc<'a> {
let mut parts = self.vec();
parts.push(callee.format(self));
parts.push(ss!("("));
parts.extend(arguments.iter().map(|arg| arg.format(self)));
parts.push(ss!(")"));
Doc::Array(parts)
}
pub(super) fn print_call_expression<'a>(
p: &mut Prettier<'a>,
callee: &Expression<'a>,
arguments: &Vec<'a, Argument<'a>>,
optional: bool, // for optional chaining
type_parameters: &Option<Box<'a, TSTypeParameterInstantiation<'a>>>,
) -> Doc<'a> {
let mut parts = p.vec();
parts.push(callee.format(p));
parts.push(ss!("("));
parts.extend(arguments.iter().map(|arg| arg.format(p)));
parts.push(ss!(")"));
Doc::Array(parts)
}

18
crates/oxc_prettier/src/format/class.rs
View file

@ -3,15 +3,13 @@ use oxc_ast::ast::*;
use crate::{doc::Doc, ss, Format, Prettier};
impl<'a> Prettier<'a> {
pub(super) fn print_class(&mut self, class: &Class<'a>) -> Doc<'a> {
let mut parts = self.vec();
parts.push(ss!("class "));
if let Some(id) = &class.id {
parts.push(id.format(self));
}
parts.push(ss!(" "));
parts.push(class.body.format(self));
Doc::Array(parts)
pub(super) fn print_class<'a>(p: &mut Prettier<'a>, class: &Class<'a>) -> Doc<'a> {
let mut parts = p.vec();
parts.push(ss!("class "));
if let Some(id) = &class.id {
parts.push(id.format(p));
}
parts.push(ss!(" "));
parts.push(class.body.format(p));
Doc::Array(parts)
}

106
crates/oxc_prettier/src/format/function.rs
View file

@ -3,66 +3,64 @@ use oxc_ast::ast::*;
use crate::{doc::Doc, group, hardline, if_break, indent, softline, ss, Format, Prettier};
impl<'a> Prettier<'a> {
pub(super) fn print_function(&mut self, func: &Function<'a>) -> Doc<'a> {
let mut parts = self.vec();
if let Some(comments) = self.print_leading_comments(func.span) {
parts.push(comments);
}
if func.r#async {
parts.push(ss!("async "));
}
if func.generator {
parts.push(ss!("function* "));
} else {
parts.push(ss!("function "));
}
if let Some(type_params) = &func.type_parameters {
parts.push(type_params.format(self));
}
if let Some(id) = &func.id {
parts.push(self.str(id.name.as_str()));
}
if should_group_function_parameters(func) {
parts.push(group!(self, func.params.format(self)));
} else {
parts.push(func.params.format(self));
}
if let Some(body) = &func.body {
parts.push(ss!(" "));
parts.push(body.format(self));
}
if self.options.semi && (func.is_ts_declare_function() || func.body.is_none()) {
parts.push(self.str(";"));
}
Doc::Array(parts)
pub(super) fn print_function<'a>(p: &mut Prettier<'a>, func: &Function<'a>) -> Doc<'a> {
let mut parts = p.vec();
if let Some(comments) = p.print_leading_comments(func.span) {
parts.push(comments);
}
if func.r#async {
parts.push(ss!("async "));
}
if func.generator {
parts.push(ss!("function* "));
} else {
parts.push(ss!("function "));
}
if let Some(type_params) = &func.type_parameters {
parts.push(type_params.format(p));
}
if let Some(id) = &func.id {
parts.push(p.str(id.name.as_str()));
}
if should_group_function_parameters(func) {
parts.push(group!(p, func.params.format(p)));
} else {
parts.push(func.params.format(p));
}
if let Some(body) = &func.body {
parts.push(ss!(" "));
parts.push(body.format(p));
}
if p.options.semi && (func.is_ts_declare_function() || func.body.is_none()) {
parts.push(p.str(";"));
}
pub(super) fn print_return_or_throw_argument(
&mut self,
argument: Option<&Expression<'a>>,
is_return: bool,
) -> Doc<'a> {
let mut parts = self.vec();
Doc::Array(parts)
}
parts.push(ss!(if is_return { "return" } else { "throw" }));
pub(super) fn print_return_or_throw_argument<'a>(
p: &mut Prettier<'a>,
argument: Option<&Expression<'a>>,
is_return: bool,
) -> Doc<'a> {
let mut parts = p.vec();
if let Some(argument) = argument {
parts.push(ss!(" "));
parts.push(group![
self,
if_break!(self, "("),
indent!(self, softline!(), argument.format(self)),
softline!(),
if_break!(self, ")")
]);
}
parts.push(ss!(if is_return { "return" } else { "throw" }));
parts.push(self.str(";"));
parts.push(hardline!());
Doc::Array(parts)
if let Some(argument) = argument {
parts.push(ss!(" "));
parts.push(group![
p,
if_break!(p, "("),
indent!(p, softline!(), argument.format(p)),
softline!(),
if_break!(p, ")")
]);
}
parts.push(p.str(";"));
parts.push(hardline!());
Doc::Array(parts)
}
fn should_group_function_parameters(func: &Function) -> bool {

33
crates/oxc_prettier/src/format/function_parameters.rs
View file

@ -3,24 +3,25 @@ use oxc_ast::ast::*;
use crate::{doc::Doc, ss, Format, Prettier};
impl<'a> Prettier<'a> {
pub(super) fn print_function_parameters(&mut self, params: &FormalParameters<'a>) -> Doc<'a> {
let mut parts = self.vec();
parts.push(ss!("("));
pub(super) fn print_function_parameters<'a>(
p: &mut Prettier<'a>,
params: &FormalParameters<'a>,
) -> Doc<'a> {
let mut parts = p.vec();
parts.push(ss!("("));
for (i, param) in params.items.iter().enumerate() {
parts.push(param.format(self));
if i < params.items.len() - 1 {
parts.push(ss!(", "));
}
}
if let Some(rest) = &params.rest {
for (i, param) in params.items.iter().enumerate() {
parts.push(param.format(p));
if i < params.items.len() - 1 {
parts.push(ss!(", "));
parts.push(rest.format(self));
}
parts.push(ss!(")"));
Doc::Array(parts)
}
if let Some(rest) = &params.rest {
parts.push(ss!(", "));
parts.push(rest.format(p));
}
parts.push(ss!(")"));
Doc::Array(parts)
}

55
crates/oxc_prettier/src/format/mod.rs
View file

@ -52,7 +52,7 @@ where
impl<'a> Format<'a> for Program<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_block_body(&self.body, Some(&self.directives)).unwrap_or(ss!(""))
block::print_block_body(p, &self.body, Some(&self.directives)).unwrap_or(ss!(""))
}
}
@ -131,7 +131,7 @@ impl<'a> Format<'a> for IfStatement<'a> {
impl<'a> Format<'a> for BlockStatement<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_block(&self.body, None, false)
block::print_block(p, &self.body, None, false)
}
}
@ -262,7 +262,7 @@ impl<'a> Format<'a> for SwitchCase<'a> {
impl<'a> Format<'a> for ReturnStatement<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_return_or_throw_argument(self.argument.as_ref(), true)
function::print_return_or_throw_argument(p, self.argument.as_ref(), true)
}
}
@ -311,7 +311,7 @@ impl<'a> Format<'a> for CatchClause<'a> {
impl<'a> Format<'a> for ThrowStatement<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_return_or_throw_argument(Some(&self.argument), false)
function::print_return_or_throw_argument(p, Some(&self.argument), false)
}
}
@ -352,7 +352,7 @@ impl<'a> Format<'a> for ModuleDeclaration<'a> {
if let ModuleDeclaration::ImportDeclaration(decl) = self {
decl.format(p)
} else {
p.print_export_declaration(self)
module::print_export_declaration(p, self)
}
}
}
@ -460,19 +460,19 @@ impl<'a> Format<'a> for VariableDeclarator<'a> {
impl<'a> Format<'a> for Function<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_function(self)
function::print_function(p, self)
}
}
impl<'a> Format<'a> for FunctionBody<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_block(&self.statements, Some(&self.directives), false)
block::print_block(p, &self.statements, Some(&self.directives), false)
}
}
impl<'a> Format<'a> for FormalParameters<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_function_parameters(self)
function_parameters::print_function_parameters(p, self)
}
}
@ -790,7 +790,13 @@ impl<'a> Format<'a> for PrivateFieldExpression<'a> {
impl<'a> Format<'a> for CallExpression<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_call_expression(&self.callee, &self.arguments, self.optional, &self.type_parameters)
call_expression::print_call_expression(
p,
&self.callee,
&self.arguments,
self.optional,
&self.type_parameters,
)
}
}
@ -821,13 +827,13 @@ impl<'a> Format<'a> for SpreadElement<'a> {
impl<'a> Format<'a> for ArrayExpression<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_array(&Array::ArrayExpression(self))
array::print_array(p, &Array::ArrayExpression(self))
}
}
impl<'a> Format<'a> for ObjectExpression<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_object_properties(&self.properties)
object::print_object_properties(p, &self.properties)
}
}
@ -863,7 +869,7 @@ impl<'a> Format<'a> for PropertyKey<'a> {
impl<'a> Format<'a> for ArrowExpression<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_arrow_function(self)
arrow_function::print_arrow_function(p, self)
}
}
@ -912,7 +918,8 @@ impl<'a> Format<'a> for UnaryExpression<'a> {
impl<'a> Format<'a> for BinaryExpression<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_binaryish_expression(
binaryish::print_binaryish_expression(
p,
&BinaryishLeft::Expression(&self.left),
BinaryishOperator::BinaryOperator(self.operator),
&self.right,
@ -922,7 +929,8 @@ impl<'a> Format<'a> for BinaryExpression<'a> {
impl<'a> Format<'a> for PrivateInExpression<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_binaryish_expression(
binaryish::print_binaryish_expression(
p,
&BinaryishLeft::PrivateIdentifier(&self.left),
BinaryishOperator::BinaryOperator(self.operator),
&self.right,
@ -932,7 +940,8 @@ impl<'a> Format<'a> for PrivateInExpression<'a> {
impl<'a> Format<'a> for LogicalExpression<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_binaryish_expression(
binaryish::print_binaryish_expression(
p,
&BinaryishLeft::Expression(&self.left),
BinaryishOperator::LogicalOperator(self.operator),
&self.right,
@ -942,7 +951,7 @@ impl<'a> Format<'a> for LogicalExpression<'a> {
impl<'a> Format<'a> for ConditionalExpression<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_ternary(self)
ternary::print_ternary(p, self)
}
}
@ -1102,7 +1111,13 @@ impl<'a> Format<'a> for ChainElement<'a> {
impl<'a> Format<'a> for NewExpression<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_call_expression(&self.callee, &self.arguments, false, &self.type_parameters)
call_expression::print_call_expression(
p,
&self.callee,
&self.arguments,
false,
&self.type_parameters,
)
}
}
@ -1114,7 +1129,7 @@ impl<'a> Format<'a> for MetaProperty {
impl<'a> Format<'a> for Class<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_class(self)
class::print_class(p, self)
}
}
@ -1274,7 +1289,7 @@ impl<'a> Format<'a> for JSXFragment<'a> {
impl<'a> Format<'a> for StaticBlock<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_block(&self.body, None, false)
block::print_block(p, &self.body, None, false)
}
}
@ -1320,7 +1335,7 @@ impl<'a> Format<'a> for BindingPattern<'a> {
impl<'a> Format<'a> for ObjectPattern<'a> {
fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
p.print_object_properties(&self.properties)
object::print_object_properties(p, &self.properties)
}
}

39
crates/oxc_prettier/src/format/module.rs
View file

@ -3,26 +3,27 @@ use oxc_ast::ast::*;
use crate::{doc::Doc, ss, Format, Prettier};
impl<'a> Prettier<'a> {
pub(super) fn print_export_declaration(&mut self, decl: &ModuleDeclaration<'a>) -> Doc<'a> {
debug_assert!(decl.is_export());
pub(super) fn print_export_declaration<'a>(
p: &mut Prettier<'a>,
decl: &ModuleDeclaration<'a>,
) -> Doc<'a> {
debug_assert!(decl.is_export());
let mut parts = self.vec();
parts.push(ss!("export"));
let mut parts = p.vec();
parts.push(ss!("export"));
if decl.is_default_export() {
parts.push(ss!(" default "));
}
parts.push(match decl {
ModuleDeclaration::ImportDeclaration(decl) => unreachable!(),
ModuleDeclaration::ExportAllDeclaration(decl) => decl.format(self),
ModuleDeclaration::ExportDefaultDeclaration(decl) => decl.format(self),
ModuleDeclaration::ExportNamedDeclaration(decl) => decl.format(self),
ModuleDeclaration::TSExportAssignment(decl) => decl.format(self),
ModuleDeclaration::TSNamespaceExportDeclaration(decl) => decl.format(self),
});
Doc::Array(parts)
if decl.is_default_export() {
parts.push(ss!(" default "));
}
parts.push(match decl {
ModuleDeclaration::ImportDeclaration(decl) => unreachable!(),
ModuleDeclaration::ExportAllDeclaration(decl) => decl.format(p),
ModuleDeclaration::ExportDefaultDeclaration(decl) => decl.format(p),
ModuleDeclaration::ExportNamedDeclaration(decl) => decl.format(p),
ModuleDeclaration::TSExportAssignment(decl) => decl.format(p),
ModuleDeclaration::TSNamespaceExportDeclaration(decl) => decl.format(p),
});
Doc::Array(parts)
}

60
crates/oxc_prettier/src/format/object.rs
View file

@ -4,42 +4,40 @@ use crate::{doc::Doc, group, if_break, ss, Prettier};
use super::Format;
impl<'a> Prettier<'a> {
pub(super) fn print_object_properties<F: Format<'a>>(
&mut self,
properties: &Vec<'a, F>,
) -> Doc<'a> {
let mut parts = self.vec();
parts.push(ss!("{"));
pub(super) fn print_object_properties<'a, F: Format<'a>>(
p: &mut Prettier<'a>,
properties: &Vec<'a, F>,
) -> Doc<'a> {
let mut parts = p.vec();
parts.push(ss!("{"));
let mut indent_parts = self.vec();
let mut indent_parts = p.vec();
if self.options.bracket_spacing {
if p.options.bracket_spacing {
indent_parts.push(Doc::Line);
} else {
indent_parts.push(Doc::Softline);
};
let len = properties.len();
properties.iter().map(|prop| prop.format(p)).enumerate().for_each(|(i, prop)| {
indent_parts.push(prop);
if i < len - 1 {
indent_parts.push(Doc::Str(","));
indent_parts.push(Doc::Line);
} else {
indent_parts.push(Doc::Softline);
};
let len = properties.len();
properties.iter().map(|prop| prop.format(self)).enumerate().for_each(|(i, prop)| {
indent_parts.push(prop);
if i < len - 1 {
indent_parts.push(Doc::Str(","));
indent_parts.push(Doc::Line);
}
});
parts.push(group!(self, Doc::Indent(indent_parts)));
parts.push(if_break!(self, ","));
if self.options.bracket_spacing {
parts.push(Doc::Line);
} else {
parts.push(Doc::Softline);
}
});
parts.push(ss!("}"));
parts.push(group!(p, Doc::Indent(indent_parts)));
parts.push(if_break!(p, ","));
Doc::Group(parts)
if p.options.bracket_spacing {
parts.push(Doc::Line);
} else {
parts.push(Doc::Softline);
}
parts.push(ss!("}"));
Doc::Group(parts)
}

18
crates/oxc_prettier/src/format/statement.rs
View file

@ -4,15 +4,13 @@ use crate::{doc::Doc, Prettier};
use super::Format;
impl<'a> Prettier<'a> {
pub(super) fn print_statement_sequence<F: Format<'a>>(
&mut self,
stmts: &Vec<'a, F>,
) -> Vec<'a, Doc<'a>> {
let mut parts = self.vec();
for stmt in stmts {
parts.push(stmt.format(self));
}
parts
pub(super) fn print_statement_sequence<'a, F: Format<'a>>(
p: &mut Prettier<'a>,
stmts: &Vec<'a, F>,
) -> Vec<'a, Doc<'a>> {
let mut parts = p.vec();
for stmt in stmts {
parts.push(stmt.format(p));
}
parts
}

30
crates/oxc_prettier/src/format/ternary.rs
View file

@ -3,20 +3,18 @@ use oxc_ast::ast::*;
use crate::{doc::Doc, group, indent, ss, Format, Prettier};
impl<'a> Prettier<'a> {
pub(super) fn print_ternary(&mut self, expr: &ConditionalExpression<'a>) -> Doc<'a> {
group![
self,
expr.test.format(self),
indent!(
self,
Doc::Line,
ss!("? "),
expr.consequent.format(self),
Doc::Line,
ss!(": "),
expr.alternate.format(self)
)
]
}
pub(super) fn print_ternary<'a>(p: &mut Prettier<'a>, expr: &ConditionalExpression<'a>) -> Doc<'a> {
group![
p,
expr.test.format(p),
indent!(
p,
Doc::Line,
ss!("? "),
expr.consequent.format(p),
Doc::Line,
ss!(": "),
expr.alternate.format(p)
)
]
}