1use std::{any::type_name, rc::Rc};23use children::{children_between, trivia_before};4use dprint_core::formatting::{5 ConditionResolver, ConditionResolverContext, LineNumber, PrintItems, PrintOptions,6 condition_helpers::is_multiple_lines,7 condition_resolvers::true_resolver,8 ir_helpers::{new_line_group, with_indent},9};10use hi_doc::{Formatting, SnippetBuilder};11use jrsonnet_lexer::collect_lexed_str_block;12use jrsonnet_rowan_parser::{13 AstNode, AstToken as _, SyntaxToken,14 nodes::{15 Arg, ArgsDesc, Assertion, BinaryOperator, Bind, CompSpec, Destruct, DestructArrayPart,16 DestructRest, Expr, ExprArray, ExprBase, FieldName, ForSpec, IfSpec, ImportKind, Literal,17 Member, Name, Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc, SourceFile, Stmt, Suffix,18 Text, TextKind, UnaryOperator, Visibility,19 },20};2122use crate::{23 children::{Child, EndingComments, trivia_after},24 comments::{CommentLocation, format_comments},25};2627mod children;28mod comments;29mod tests;3031fn with_indent_eoi(cond: ConditionResolver, o: PrintItems, e: EndingComments) -> PrintItems {32 let end_comments_items = {33 let mut items = PrintItems::new();34 if e.should_start_with_newline {35 p!(&mut items, nl);36 }37 format_comments(&e.trivia, CommentLocation::EndOfItems, &mut items);38 items.into_rc_path()39 };40 let items = new_line_group(pi!(@i; items(o) items(end_comments_items.into()))).into_rc_path();4142 let indented = with_indent(pi!(@i; nl items(items.into())));4344 pi!(@i; if_else("indented body", cond, items(indented))(str(" ") items(items.into())))45}4647pub trait Printable {48 fn print(&self, out: &mut PrintItems);49}5051macro_rules! pi {52 (@i; $($t:tt)*) => {{53 #[allow(unused_mut)]54 let mut o = dprint_core::formatting::PrintItems::new();55 pi!(@s; o: $($t)*);56 o57 }};58 (@s; $o:ident: str($e:expr $(,)?) $($t:tt)*) => {{59 $o.push_string($e.to_owned());60 pi!(@s; $o: $($t)*);61 }};62 (@s; $o:ident: string($e:expr $(,)?) $($t:tt)*) => {{63 $o.push_string($e);64 pi!(@s; $o: $($t)*);65 }};66 (@s; $o:ident: nl $($t:tt)*) => {{67 $o.push_signal(dprint_core::formatting::Signal::NewLine);68 pi!(@s; $o: $($t)*);69 }};70 (@s; $o:ident: sonl $($t:tt)*) => {{71 $o.push_signal(dprint_core::formatting::Signal::SpaceOrNewLine);72 pi!(@s; $o: $($t)*);73 }};74 (@s; $o:ident: tab $($t:tt)*) => {{75 $o.push_signal(dprint_core::formatting::Signal::Tab);76 pi!(@s; $o: $($t)*);77 }};78 (@s; $o:ident: >i $($t:tt)*) => {{79 $o.push_signal(dprint_core::formatting::Signal::StartIndent);80 pi!(@s; $o: $($t)*);81 }};82 (@s; $o:ident: <i $($t:tt)*) => {{83 $o.push_signal(dprint_core::formatting::Signal::FinishIndent);84 pi!(@s; $o: $($t)*);85 }};86 (@s; $o:ident: >ii $($t:tt)*) => {{87 $o.push_signal(dprint_core::formatting::Signal::StartIgnoringIndent);88 pi!(@s; $o: $($t)*);89 }};90 (@s; $o:ident: <ii $($t:tt)*) => {{91 $o.push_signal(dprint_core::formatting::Signal::FinishIgnoringIndent);92 pi!(@s; $o: $($t)*);93 }};94 (@s; $o:ident: info($v:expr) $($t:tt)*) => {{95 $o.push_info($v);96 pi!(@s; $o: $($t)*);97 }};98 (@s; $o:ident: ln_anchor($v:expr) $($t:tt)*) => {{99 $o.push_anchor(LineNumberAnchor::new($v));100 pi!(@s; $o: $($t)*);101 }};102 (@s; $o:ident: if($s:literal, $cond:expr, $($i:tt)*) $($t:tt)*) => {{103 $o.push_condition(dprint_core::formatting::conditions::if_true(104 $s,105 $cond.clone(),106 {107 let mut o = PrintItems::new();108 p!(o, $($i)*);109 o110 },111 ));112 pi!(@s; $o: $($t)*);113 }};114 (@s; $o:ident: if_else($s:literal, $cond:expr, $($i:tt)*)($($e:tt)+) $($t:tt)*) => {{115 $o.push_condition(dprint_core::formatting::conditions::if_true_or(116 $s,117 $cond.clone(),118 {119 let mut o = PrintItems::new();120 p!(o, $($i)*);121 o122 },123 {124 let mut o = PrintItems::new();125 p!(o, $($e)*);126 o127 },128 ));129 pi!(@s; $o: $($t)*);130 }};131 (@s; $o:ident: if_not($s:literal, $cond:expr, $($e:tt)*) $($t:tt)*) => {{132 $o.push_condition(dprint_core::formatting::conditions::if_true_or(133 $s,134 $cond.clone(),135 {136 let o = PrintItems::new();137 o138 },139 {140 let mut o = PrintItems::new();141 p!(o, $($e)*);142 o143 },144 ));145 pi!(@s; $o: $($t)*);146 }};147 (@s; $o:ident: {$expr:expr} $($t:tt)*) => {{148 $expr.print($o);149 pi!(@s; $o: $($t)*);150 }};151 (@s; $o:ident: items($expr:expr) $($t:tt)*) => {{152 $o.extend($expr);153 pi!(@s; $o: $($t)*);154 }};155 (@s; $o:ident: if ($e:expr)($($then:tt)*) $($t:tt)*) => {{156 if $e {157 pi!(@s; $o: $($then)*);158 }159 pi!(@s; $o: $($t)*);160 }};161 (@s; $o:ident: ifelse ($e:expr)($($then:tt)*)($($else:tt)*) $($t:tt)*) => {{162 if $e {163 pi!(@s; $o: $($then)*);164 } else {165 pi!(@s; $o: $($else)*);166 }167 pi!(@s; $o: $($t)*);168 }};169 (@s; $i:ident:) => {}170}171macro_rules! p {172 ($o:ident, $($t:tt)*) => {173 pi!(@s; $o: $($t)*)174 };175 (&mut $o:ident, $($t:tt)*) => {176 let om = &mut $o;177 pi!(@s; om: $($t)*)178 };179}180pub(crate) use p;181pub(crate) use pi;182183impl<P> Printable for Option<P>184where185 P: Printable,186{187 fn print(&self, out: &mut PrintItems) {188 if let Some(v) = self {189 v.print(out);190 } else {191 p!(192 out,193 string(format!(194 "/*missing {}*/",195 type_name::<P>().replace("jrsonnet_rowan_parser::generated::nodes::", "")196 ),)197 );198 }199 }200}201202impl Printable for SyntaxToken {203 fn print(&self, out: &mut PrintItems) {204 p!(out, string(self.to_string()));205 }206}207208impl Printable for Text {209 fn print(&self, out: &mut PrintItems) {210 if matches!(self.kind(), TextKind::StringBlock) {211 let text = self.text();212 let mut text = collect_lexed_str_block(&text[3..])213 .expect("formatting is not performed on code with parsing errors");214215 if text.truncate && text.lines.ends_with(&[""]) {216 text.truncate = false;217 text.lines.pop();218 }219220 p!(out, str("|||"));221 if text.truncate {222 p!(out, str("-"));223 }224 p!(out, nl > i);225 for ele in text.lines {226 if ele.is_empty() {227 p!(out, >ii nl <ii);228 } else {229 p!(out, string(ele.to_string()) nl);230 }231 }232 p!(out, <i str("|||"));233234 return;235 }236 p!(out, string(format!("{}", self)));237 }238}239impl Printable for Number {240 fn print(&self, out: &mut PrintItems) {241 p!(out, string(format!("{}", self)));242 }243}244245impl Printable for Name {246 fn print(&self, out: &mut PrintItems) {247 p!(out, { self.ident_lit() });248 }249}250251impl Printable for DestructRest {252 fn print(&self, out: &mut PrintItems) {253 p!(out, str("..."));254 if let Some(name) = self.into() {255 p!(out, { name });256 }257 }258}259260impl Printable for Destruct {261 fn print(&self, out: &mut PrintItems) {262 match self {263 Self::DestructFull(f) => {264 p!(out, { f.name() });265 }266 Self::DestructSkip(_) => p!(out, str("?")),267 Self::DestructArray(a) => {268 p!(out, str("[") >i nl);269 for el in a.destruct_array_parts() {270 match el {271 DestructArrayPart::DestructArrayElement(e) => {272 p!(out, {e.destruct()} str(",") nl);273 }274 DestructArrayPart::DestructRest(d) => {275 p!(out, {d} str(",") nl);276 }277 }278 }279 p!(out, <i str("]"));280 }281 Self::DestructObject(o) => {282 p!(out, str("{") >i nl);283 for item in o.destruct_object_fields() {284 p!(out, { item.field() });285 if let Some(des) = item.destruct() {286 p!(out, str(": ") {des});287 }288 if let Some(def) = item.expr() {289 p!(out, str(" = ") {def});290 }291 p!(out, str(",") nl);292 }293 if let Some(rest) = o.destruct_rest() {294 p!(out, {rest} nl);295 }296 p!(out, <i str("}"));297 }298 }299 }300}301302impl Printable for FieldName {303 fn print(&self, out: &mut PrintItems) {304 match self {305 Self::FieldNameFixed(f) => {306 if let Some(id) = f.id() {307 p!(out, { id });308 } else if let Some(str) = f.text() {309 p!(out, { str });310 } else {311 p!(out, str("/*missing FieldName*/"));312 }313 }314 Self::FieldNameDynamic(d) => {315 p!(out, str("[") {d.expr()} str("]"));316 }317 }318 }319}320321impl Printable for Visibility {322 fn print(&self, out: &mut PrintItems) {323 p!(out, string(self.to_string()));324 }325}326327impl Printable for ObjLocal {328 fn print(&self, out: &mut PrintItems) {329 p!(out, str("local ") {self.bind()});330 }331}332333impl Printable for Assertion {334 fn print(&self, out: &mut PrintItems) {335 p!(out, str("assert ") {self.condition()});336 if self.colon_token().is_some() || self.message().is_some() {337 p!(out, str(": ") {self.message()});338 }339 }340}341342impl Printable for ParamsDesc {343 fn print(&self, out: &mut PrintItems) {344 p!(out, str("(") >i nl);345 for param in self.params() {346 p!(out, { param.destruct() });347 if param.assign_token().is_some() || param.expr().is_some() {348 p!(out, str(" = ") {param.expr()});349 }350 p!(out, str(",") nl);351 }352 p!(out, <i str(")"));353 }354}355impl Printable for ArgsDesc {356 fn print(&self, out: &mut PrintItems) {357 fn gen_args(children: Vec<Child<Arg>>, multi_line: ConditionResolver) -> PrintItems {358 let mut out = PrintItems::new();359360 let mut args = children.into_iter().peekable();361 while let Some(ele) = args.next() {362 if ele.should_start_with_newline {363 p!(out, nl);364 }365 format_comments(&ele.before_trivia, CommentLocation::AboveItem, &mut out);366 let arg = ele.value;367 if arg.name().is_some() || arg.assign_token().is_some() {368 p!(&mut out, {arg.name()} str(" = "));369 }370 p!(&mut out, { arg.expr() });371 let has_more = args.peek().is_some();372 if has_more {373 p!(out, str(","));374 } else {375 p!(out, if("trailing comma", multi_line, str(",")));376 }377 format_comments(&ele.inline_trivia, CommentLocation::ItemInline, &mut out);378 if has_more {379 p!(out, if_else("arg separator", multi_line, nl)(sonl));380 }381 }382383 out384 }385386 let start = LineNumber::new("args start line");387 let end = LineNumber::new("args end line");388 let multi_line = Rc::new(move |condition_context: &mut ConditionResolverContext| {389 is_multiple_lines(condition_context, start, end)390 });391392 let (children, end_comments) = children_between::<Arg>(393 self.syntax().clone(),394 self.l_paren_token().map(Into::into).as_ref(),395 self.r_paren_token().map(Into::into).as_ref(),396 None,397 );398399 let args_items = new_line_group(gen_args(children, multi_line.clone())).into_rc_path();400 let args_indented = with_indent(pi!(@i; nl items(args_items.into())));401402 p!(out, str("(") info(start));403 p!(out, if_else("args body", multi_line, items(args_indented) nl)(items(args_items.into())));404 if end_comments.should_start_with_newline {405 p!(out, nl);406 }407 format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);408 p!(out, str(")") info(end));409 }410}411impl Printable for SliceDesc {412 fn print(&self, out: &mut PrintItems) {413 p!(out, str("["));414 if self.from().is_some() {415 p!(out, { self.from() });416 }417 p!(out, str(":"));418 if self.end().is_some() {419 p!(out, { self.end().map(|e| e.expr()) });420 }421 422 if self.step().is_some() {423 p!(out, str(":") {self.step().map(|e|e.expr())});424 }425 p!(out, str("]"));426 }427}428429impl Printable for Member {430 fn print(&self, out: &mut PrintItems) {431 match self {432 Self::MemberBindStmt(b) => {433 p!(out, { b.obj_local() });434 }435 Self::MemberAssertStmt(ass) => {436 p!(out, { ass.assertion() });437 }438 Self::MemberFieldNormal(n) => {439 p!(out, {n.field_name()} if(n.plus_token().is_some())({n.plus_token()}) {n.visibility()} str(" ") {n.expr()});440 }441 Self::MemberFieldMethod(m) => {442 p!(out, {m.field_name()} {m.params_desc()} {m.visibility()} str(" ") {m.expr()});443 }444 }445 }446}447448impl Printable for ObjBody {449 #[allow(clippy::too_many_lines)]450 fn print(&self, out: &mut PrintItems) {451 match self {452 Self::ObjBodyComp(l) => {453 fn gen_obj_comp(454 members: Vec<Child<Member>>,455 member_end_comments: EndingComments,456 compspecs: Vec<Child<CompSpec>>,457 multi_line: ConditionResolver,458 ) -> PrintItems {459 let mut out = PrintItems::new();460 for mem in members {461 if mem.should_start_with_newline {462 p!(out, nl);463 }464 format_comments(&mem.before_trivia, CommentLocation::AboveItem, &mut out);465 p!(&mut out, { mem.value });466 p!(out, if("trailing comma", multi_line, str(",")));467 format_comments(&mem.inline_trivia, CommentLocation::ItemInline, &mut out);468 p!(out, if_else("member-comp sep", multi_line, nl)(sonl));469 }470471 if member_end_comments.should_start_with_newline {472 p!(out, nl);473 }474 format_comments(475 &member_end_comments.trivia,476 CommentLocation::EndOfItems,477 &mut out,478 );479480 let mut compspecs = compspecs.into_iter().peekable();481 while let Some(mem) = compspecs.next() {482 if mem.should_start_with_newline {483 p!(out, nl);484 }485 format_comments(&mem.before_trivia, CommentLocation::AboveItem, &mut out);486 p!(&mut out, { mem.value });487 format_comments(&mem.inline_trivia, CommentLocation::ItemInline, &mut out);488 p!(out, if_else("comp spec sep", multi_line, nl)(sonl));489 }490491 out492 }493494 let (children, mut end_comments) = children_between::<Member>(495 l.syntax().clone(),496 l.l_brace_token().map(Into::into).as_ref(),497 Some(498 &(l.comp_specs()499 .next()500 .expect("at least one spec is defined")501 .syntax()502 .clone())503 .into(),504 ),505 None,506 );507 let trailing_for_comp = end_comments.extract_trailing();508509 let (compspecs, comp_end_comments) = children_between::<CompSpec>(510 l.syntax().clone(),511 l.member_comps()512 .last()513 .map(|m| m.syntax().clone())514 .map(Into::into)515 .or_else(|| l.l_brace_token().map(Into::into))516 .as_ref(),517 l.r_brace_token().map(Into::into).as_ref(),518 Some(trailing_for_comp),519 );520521 let source_is_multiline = children.iter().any(|c| c.triggers_multiline)522 || compspecs.iter().any(|c| c.triggers_multiline)523 || end_comments.should_start_with_newline524 || comp_end_comments.should_start_with_newline;525526 let start = LineNumber::new("obj comp start line");527 let end = LineNumber::new("obj comp end line");528 let multi_line: ConditionResolver = if source_is_multiline {529 true_resolver()530 } else {531 Rc::new(move |ctx: &mut ConditionResolverContext| {532 is_multiple_lines(ctx, start, end)533 })534 };535536 let body = new_line_group(gen_obj_comp(537 children,538 end_comments,539 compspecs,540 multi_line.clone(),541 ))542 .into_rc_path();543544 let body = with_indent_eoi(multi_line, body.into(), comp_end_comments);545546 p!(out, str("{") info(start));547 p!(out, items(body));548 p!(out, str("}") info(end));549 }550 Self::ObjBodyMemberList(l) => {551 fn gen_members(552 children: Vec<Child<Member>>,553 multi_line: ConditionResolver,554 ) -> PrintItems {555 let mut out = PrintItems::new();556 let mut members = children.into_iter().peekable();557 while let Some(mem) = members.next() {558 if mem.should_start_with_newline {559 p!(out, nl);560 }561 format_comments(&mem.before_trivia, CommentLocation::AboveItem, &mut out);562 p!(&mut out, { mem.value });563 let has_more = members.peek().is_some();564 if has_more {565 p!(out, str(","));566 } else {567 p!(out, if("trailing comma", multi_line, str(",")));568 }569 format_comments(&mem.inline_trivia, CommentLocation::ItemInline, &mut out);570 p!(out, if_else("member separator", multi_line, nl)(sonl));571 }572 out573 }574575 let (children, end_comments) = children_between::<Member>(576 l.syntax().clone(),577 l.l_brace_token().map(Into::into).as_ref(),578 l.r_brace_token().map(Into::into).as_ref(),579 None,580 );581 if children.is_empty() && end_comments.is_empty() {582 p!(out, str("{ }"));583 return;584 }585586 let source_is_multiline = children.iter().any(|c| c.triggers_multiline)587 || end_comments.should_start_with_newline;588589 let start = LineNumber::new("obj start line");590 let end = LineNumber::new("obj end line");591 let multi_line: ConditionResolver = if source_is_multiline {592 true_resolver()593 } else {594 Rc::new(move |ctx: &mut ConditionResolverContext| {595 is_multiple_lines(ctx, start, end)596 })597 };598599 let members_items =600 new_line_group(gen_members(children, multi_line.clone())).into_rc_path();601602 let members = with_indent_eoi(multi_line, members_items.into(), end_comments);603604 p!(out, str("{") info(start));605 p!(out, items(members));606 p!(out, str("}") info(end));607 }608 }609 }610}611impl Printable for UnaryOperator {612 fn print(&self, out: &mut PrintItems) {613 p!(out, string(self.text().to_string()));614 }615}616impl Printable for BinaryOperator {617 fn print(&self, out: &mut PrintItems) {618 p!(out, string(self.text().to_string()));619 }620}621impl Printable for Bind {622 fn print(&self, out: &mut PrintItems) {623 match self {624 Self::BindDestruct(d) => {625 p!(out, {d.into()} str(" = ") {d.value()});626 }627 Self::BindFunction(f) => {628 p!(out, {f.name()} {f.params()} str(" = ") {f.value()});629 }630 }631 }632}633impl Printable for Literal {634 fn print(&self, out: &mut PrintItems) {635 p!(out, string(self.syntax().to_string()));636 }637}638impl Printable for ImportKind {639 fn print(&self, out: &mut PrintItems) {640 p!(out, string(self.syntax().to_string()));641 }642}643impl Printable for ForSpec {644 fn print(&self, out: &mut PrintItems) {645 p!(out, str("for ") {self.bind()} str(" in ") {self.expr()});646 }647}648impl Printable for IfSpec {649 fn print(&self, out: &mut PrintItems) {650 p!(out, str("if ") {self.expr()});651 }652}653impl Printable for CompSpec {654 fn print(&self, out: &mut PrintItems) {655 match self {656 Self::ForSpec(f) => f.print(out),657 Self::IfSpec(i) => i.print(out),658 }659 }660}661impl Printable for Expr {662 fn print(&self, out: &mut PrintItems) {663 let (stmts, _ending) = children_between::<Stmt>(664 self.syntax().clone(),665 None,666 self.expr_base()667 .as_ref()668 .map(ExprBase::syntax)669 .cloned()670 .map(Into::into)671 .as_ref(),672 None,673 );674 for stmt in stmts {675 p!(out, { stmt.value });676 }677 p!(out, { self.expr_base() });678 let (suffixes, _ending) = children_between::<Suffix>(679 self.syntax().clone(),680 self.expr_base()681 .as_ref()682 .map(ExprBase::syntax)683 .cloned()684 .map(Into::into)685 .as_ref(),686 None,687 None,688 );689 for suffix in suffixes {690 p!(out, { suffix.value });691 }692 }693}694impl Printable for Suffix {695 fn print(&self, out: &mut PrintItems) {696 match self {697 Self::SuffixIndex(i) => {698 if i.question_mark_token().is_some() {699 p!(out, str("?"));700 }701 p!(out, str(".") {i.index()});702 }703 Self::SuffixIndexExpr(e) => {704 if e.question_mark_token().is_some() {705 p!(out, str(".?"));706 }707 p!(out, str("[") {e.index()} str("]"));708 }709 Self::SuffixSlice(d) => {710 p!(out, { d.slice_desc() });711 }712 Self::SuffixApply(a) => {713 p!(out, { a.args_desc() });714 }715 }716 }717}718impl Printable for Stmt {719 fn print(&self, out: &mut PrintItems) {720 match self {721 Self::StmtLocal(l) => {722 let (binds, end_comments) = children_between::<Bind>(723 l.syntax().clone(),724 l.local_kw_token().map(Into::into).as_ref(),725 l.semi_token().map(Into::into).as_ref(),726 None,727 );728 if binds.len() == 1 {729 let bind = &binds[0];730 format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);731 p!(out, str("local ") {bind.value});732 733 } else {734 p!(out,str("local") >i nl);735 for bind in binds {736 if bind.should_start_with_newline {737 p!(out, nl);738 }739 format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);740 p!(out, {bind.value} str(","));741 format_comments(&bind.inline_trivia, CommentLocation::ItemInline, out);742 p!(out, nl);743 }744 if end_comments.should_start_with_newline {745 p!(out, nl);746 }747 format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);748 p!(out,<i);749 }750 p!(out,str(";") nl);751 }752 Self::StmtAssert(a) => {753 p!(out, {a.assertion()} str(";") nl);754 }755 }756 }757}758759impl Printable for ExprArray {760 fn print(&self, out: &mut PrintItems) {761 fn gen_elements(children: Vec<Child<Expr>>, multi_line: ConditionResolver) -> PrintItems {762 let mut out = PrintItems::new();763 let mut els = children.into_iter().peekable();764 while let Some(el) = els.next() {765 if el.should_start_with_newline {766 p!(out, nl);767 }768 format_comments(&el.before_trivia, CommentLocation::AboveItem, &mut out);769 p!(&mut out, { el.value });770 let has_more = els.peek().is_some();771 if has_more {772 p!(out, str(","));773 } else {774 p!(out, if("trailing comma", multi_line, str(",")));775 }776 format_comments(&el.inline_trivia, CommentLocation::ItemInline, &mut out);777 p!(out, if_else("element separator", multi_line, nl)(sonl));778 }779 out780 }781782 let (children, end_comments) = children_between::<Expr>(783 self.syntax().clone(),784 self.l_brack_token().map(Into::into).as_ref(),785 self.r_brack_token().map(Into::into).as_ref(),786 None,787 );788 if children.is_empty() && end_comments.is_empty() {789 p!(out, str("[ ]"));790 return;791 }792793 let source_is_multiline =794 children.iter().any(|c| c.triggers_multiline) || end_comments.should_start_with_newline;795796 let start = LineNumber::new("arr start line");797 let end = LineNumber::new("arr end line");798 let multi_line: ConditionResolver = if source_is_multiline {799 true_resolver()800 } else {801 Rc::new(move |ctx: &mut ConditionResolverContext| is_multiple_lines(ctx, start, end))802 };803804 let els_items = new_line_group(gen_elements(children, multi_line.clone())).into_rc_path();805806 let els = with_indent_eoi(multi_line, els_items.into(), end_comments);807808 p!(out, str("[") info(start) items(els) str("]") info(end));809 }810}811812impl Printable for ExprBase {813 fn print(&self, out: &mut PrintItems) {814 match self {815 Self::ExprBinary(b) => {816 p!(out, {b.lhs()} str(" ") {b.binary_operator()} str(" ") {b.rhs()});817 }818 Self::ExprUnary(u) => p!(out, {u.unary_operator()} {u.rhs()}),819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 Self::ExprObjExtend(ex) => {834 p!(out, {ex.lhs()} str(" ") {ex.rhs()});835 }836 Self::ExprParened(p) => {837 p!(out, str("(") {p.expr()} str(")"));838 }839 Self::ExprString(s) => p!(out, { s.text() }),840 Self::ExprNumber(n) => p!(out, { n.number() }),841 Self::ExprArray(a) => {842 p!(out, { a });843 }844 Self::ExprObject(obj) => {845 p!(out, { obj.obj_body() });846 }847 Self::ExprArrayComp(arr) => {848 p!(out, str("[") {arr.expr()});849 for spec in arr.comp_specs() {850 p!(out, str(" ") {spec});851 }852 p!(out, str("]"));853 }854 Self::ExprImport(v) => {855 p!(out, {v.import_kind()} str(" ") {v.text()});856 }857 Self::ExprVar(n) => p!(out, { n.name() }),858 859 860 Self::ExprIfThenElse(ite) => {861 p!(out, str("if ") {ite.cond()} str(" then ") {ite.then().map(|t| t.expr())});862 if ite.else_kw_token().is_some() || ite.else_().is_some() {863 p!(out, str(" else ") {ite.else_().map(|t| t.expr())});864 }865 }866 Self::ExprFunction(f) => p!(out, str("function") {f.params_desc()} nl {f.expr()}),867 868 Self::ExprError(e) => p!(out, str("error ") {e.expr()}),869 Self::ExprLiteral(l) => {870 p!(out, { l.literal() });871 }872 }873 }874}875876impl Printable for SourceFile {877 fn print(&self, out: &mut PrintItems) {878 let before = trivia_before(879 self.syntax().clone(),880 self.expr()881 .map(|e| e.syntax().clone())882 .map(Into::into)883 .as_ref(),884 );885 let after = trivia_after(886 self.syntax().clone(),887 self.expr()888 .map(|e| e.syntax().clone())889 .map(Into::into)890 .as_ref(),891 );892 format_comments(&before, CommentLocation::AboveItem, out);893 p!(out, {self.expr()} nl);894 format_comments(&after, CommentLocation::EndOfItems, out);895 }896}897898pub struct FormatOptions {899 900 pub indent: u8,901}902903#[allow(904 clippy::result_large_err,905 reason = "TODO: there should be an intermediate representation for such reports"906)]907pub fn format(input: &str, opts: &FormatOptions) -> Result<String, SnippetBuilder> {908 let (parsed, errors) = jrsonnet_rowan_parser::parse(input);909 if !errors.is_empty() {910 let mut builder = hi_doc::SnippetBuilder::new(input);911 for error in errors {912 builder913 .error(hi_doc::Text::fragment(914 format!("{:?}", error.error),915 Formatting::default(),916 ))917 .range(918 error.range.start().into()919 ..=(usize::from(error.range.end()) - 1).max(error.range.start().into()),920 )921 .build();922 }923 924 return Err(builder);925 926 927 928 }929 Ok(dprint_core::formatting::format(930 || {931 let mut out = PrintItems::new();932 parsed.print(&mut out);933 out934 },935 PrintOptions {936 indent_width: if opts.indent == 0 {937 938 3939 } else {940 opts.indent941 },942 max_width: 100,943 use_tabs: opts.indent == 0,944 new_line_text: "\n",945 },946 ))947}