1use std::{any::type_name, rc::Rc};23use children::{children_between, trivia_before};4use dprint_core::formatting::{5 condition_helpers::is_multiple_lines,6 condition_resolvers::true_resolver,7 ir_helpers::{new_line_group, with_indent},8 ConditionResolver, ConditionResolverContext, LineNumber, PrintItems, PrintOptions,9};10use hi_doc::{Formatting, SnippetBuilder};11use jrsonnet_rowan_parser::{12 collect_lexed_str_block,13 nodes::{14 Arg, ArgsDesc, Assertion, BinaryOperator, Bind, CompSpec, Destruct, DestructArrayPart,15 DestructRest, Expr, ExprArray, ExprBase, FieldName, ForSpec, IfSpec, ImportKind, Literal,16 Member, Name, Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc, SourceFile, Stmt, Suffix,17 Text, TextKind, UnaryOperator, Visibility,18 },19 AstNode, AstToken as _, SyntaxToken,20};2122use crate::{23 children::{trivia_after, Child, EndingComments},24 comments::{format_comments, CommentLocation},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 let (children, mut end_comments) = children_between::<Member>(454 l.syntax().clone(),455 l.l_brace_token().map(Into::into).as_ref(),456 Some(457 &(l.comp_specs()458 .next()459 .expect("at least one spec is defined")460 .syntax()461 .clone())462 .into(),463 ),464 None,465 );466 let trailing_for_comp = end_comments.extract_trailing();467 p!(out, str("{") >i nl);468 for mem in children {469 if mem.should_start_with_newline {470 p!(out, nl);471 }472 format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);473 p!(out, {mem.value} str(","));474 format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);475 p!(out, nl);476 }477478 if end_comments.should_start_with_newline {479 p!(out, nl);480 }481 format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);482483 let (compspecs, end_comments) = children_between::<CompSpec>(484 l.syntax().clone(),485 l.member_comps()486 .last()487 .map(|m| m.syntax().clone())488 .map(Into::into)489 .or_else(|| l.l_brace_token().map(Into::into))490 .as_ref(),491 l.r_brace_token().map(Into::into).as_ref(),492 Some(trailing_for_comp),493 );494 for mem in compspecs {495 if mem.should_start_with_newline {496 p!(out, nl);497 }498 format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);499 p!(out, { mem.value });500 format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);501 }502 if end_comments.should_start_with_newline {503 p!(out, nl);504 }505 format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);506507 p!(out, nl <i str("}"));508 }509 Self::ObjBodyMemberList(l) => {510 fn gen_members(511 children: Vec<Child<Member>>,512 multi_line: ConditionResolver,513 ) -> PrintItems {514 let mut out = PrintItems::new();515 let mut members = children.into_iter().peekable();516 while let Some(mem) = members.next() {517 if mem.should_start_with_newline {518 p!(out, nl);519 }520 format_comments(&mem.before_trivia, CommentLocation::AboveItem, &mut out);521 p!(&mut out, { mem.value });522 let has_more = members.peek().is_some();523 if has_more {524 p!(out, str(","));525 } else {526 p!(out, if("trailing comma", multi_line, str(",")));527 }528 format_comments(&mem.inline_trivia, CommentLocation::ItemInline, &mut out);529 p!(out, if_else("member separator", multi_line, nl)(sonl));530 }531 out532 }533534 let (children, end_comments) = children_between::<Member>(535 l.syntax().clone(),536 l.l_brace_token().map(Into::into).as_ref(),537 l.r_brace_token().map(Into::into).as_ref(),538 None,539 );540 if children.is_empty() && end_comments.is_empty() {541 p!(out, str("{ }"));542 return;543 }544545 let source_is_multiline = children.iter().any(|c| c.triggers_multiline)546 || end_comments.should_start_with_newline;547548 let start = LineNumber::new("obj start line");549 let end = LineNumber::new("obj end line");550 let multi_line: ConditionResolver = if source_is_multiline {551 true_resolver()552 } else {553 Rc::new(move |ctx: &mut ConditionResolverContext| {554 is_multiple_lines(ctx, start, end)555 })556 };557558 let members_items =559 new_line_group(gen_members(children, multi_line.clone())).into_rc_path();560561 let members = with_indent_eoi(multi_line, members_items.into(), end_comments);562563 p!(out, str("{") info(start));564 p!(out, items(members));565 p!(out, str("}") info(end));566 }567 }568 }569}570impl Printable for UnaryOperator {571 fn print(&self, out: &mut PrintItems) {572 p!(out, string(self.text().to_string()));573 }574}575impl Printable for BinaryOperator {576 fn print(&self, out: &mut PrintItems) {577 p!(out, string(self.text().to_string()));578 }579}580impl Printable for Bind {581 fn print(&self, out: &mut PrintItems) {582 match self {583 Self::BindDestruct(d) => {584 p!(out, {d.into()} str(" = ") {d.value()});585 }586 Self::BindFunction(f) => {587 p!(out, {f.name()} {f.params()} str(" = ") {f.value()});588 }589 }590 }591}592impl Printable for Literal {593 fn print(&self, out: &mut PrintItems) {594 p!(out, string(self.syntax().to_string()));595 }596}597impl Printable for ImportKind {598 fn print(&self, out: &mut PrintItems) {599 p!(out, string(self.syntax().to_string()));600 }601}602impl Printable for ForSpec {603 fn print(&self, out: &mut PrintItems) {604 p!(out, str("for ") {self.bind()} str(" in ") {self.expr()});605 }606}607impl Printable for IfSpec {608 fn print(&self, out: &mut PrintItems) {609 p!(out, str("if ") {self.expr()});610 }611}612impl Printable for CompSpec {613 fn print(&self, out: &mut PrintItems) {614 match self {615 Self::ForSpec(f) => f.print(out),616 Self::IfSpec(i) => i.print(out),617 }618 }619}620impl Printable for Expr {621 fn print(&self, out: &mut PrintItems) {622 let (stmts, _ending) = children_between::<Stmt>(623 self.syntax().clone(),624 None,625 self.expr_base()626 .as_ref()627 .map(ExprBase::syntax)628 .cloned()629 .map(Into::into)630 .as_ref(),631 None,632 );633 for stmt in stmts {634 p!(out, { stmt.value });635 }636 p!(out, { self.expr_base() });637 let (suffixes, _ending) = children_between::<Suffix>(638 self.syntax().clone(),639 self.expr_base()640 .as_ref()641 .map(ExprBase::syntax)642 .cloned()643 .map(Into::into)644 .as_ref(),645 None,646 None,647 );648 for suffix in suffixes {649 p!(out, { suffix.value });650 }651 }652}653impl Printable for Suffix {654 fn print(&self, out: &mut PrintItems) {655 match self {656 Self::SuffixIndex(i) => {657 if i.question_mark_token().is_some() {658 p!(out, str("?"));659 }660 p!(out, str(".") {i.index()});661 }662 Self::SuffixIndexExpr(e) => {663 if e.question_mark_token().is_some() {664 p!(out, str(".?"));665 }666 p!(out, str("[") {e.index()} str("]"));667 }668 Self::SuffixSlice(d) => {669 p!(out, { d.slice_desc() });670 }671 Self::SuffixApply(a) => {672 p!(out, { a.args_desc() });673 }674 }675 }676}677impl Printable for Stmt {678 fn print(&self, out: &mut PrintItems) {679 match self {680 Self::StmtLocal(l) => {681 let (binds, end_comments) = children_between::<Bind>(682 l.syntax().clone(),683 l.local_kw_token().map(Into::into).as_ref(),684 l.semi_token().map(Into::into).as_ref(),685 None,686 );687 if binds.len() == 1 {688 let bind = &binds[0];689 format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);690 p!(out, str("local ") {bind.value});691 692 } else {693 p!(out,str("local") >i nl);694 for bind in binds {695 if bind.should_start_with_newline {696 p!(out, nl);697 }698 format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);699 p!(out, {bind.value} str(","));700 format_comments(&bind.inline_trivia, CommentLocation::ItemInline, out);701 p!(out, nl);702 }703 if end_comments.should_start_with_newline {704 p!(out, nl);705 }706 format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);707 p!(out,<i);708 }709 p!(out,str(";") nl);710 }711 Self::StmtAssert(a) => {712 p!(out, {a.assertion()} str(";") nl);713 }714 }715 }716}717718impl Printable for ExprArray {719 fn print(&self, out: &mut PrintItems) {720 fn gen_elements(children: Vec<Child<Expr>>, multi_line: ConditionResolver) -> PrintItems {721 let mut out = PrintItems::new();722 let mut els = children.into_iter().peekable();723 while let Some(el) = els.next() {724 if el.should_start_with_newline {725 p!(out, nl);726 }727 format_comments(&el.before_trivia, CommentLocation::AboveItem, &mut out);728 p!(&mut out, { el.value });729 let has_more = els.peek().is_some();730 if has_more {731 p!(out, str(","));732 } else {733 p!(out, if("trailing comma", multi_line, str(",")));734 }735 format_comments(&el.inline_trivia, CommentLocation::ItemInline, &mut out);736 p!(out, if_else("element separator", multi_line, nl)(sonl));737 }738 out739 }740741 let (children, end_comments) = children_between::<Expr>(742 self.syntax().clone(),743 self.l_brack_token().map(Into::into).as_ref(),744 self.r_brack_token().map(Into::into).as_ref(),745 None,746 );747 if children.is_empty() && end_comments.is_empty() {748 p!(out, str("[ ]"));749 return;750 }751752 let source_is_multiline =753 children.iter().any(|c| c.triggers_multiline) || end_comments.should_start_with_newline;754755 let start = LineNumber::new("arr start line");756 let end = LineNumber::new("arr end line");757 let multi_line: ConditionResolver = if source_is_multiline {758 true_resolver()759 } else {760 Rc::new(move |ctx: &mut ConditionResolverContext| is_multiple_lines(ctx, start, end))761 };762763 let els_items = new_line_group(gen_elements(children, multi_line.clone())).into_rc_path();764765 let els = with_indent_eoi(multi_line, els_items.into(), end_comments);766767 p!(out, str("[") info(start) items(els) str("]") info(end));768 }769}770771impl Printable for ExprBase {772 fn print(&self, out: &mut PrintItems) {773 match self {774 Self::ExprBinary(b) => {775 p!(out, {b.lhs()} str(" ") {b.binary_operator()} str(" ") {b.rhs()});776 }777 Self::ExprUnary(u) => p!(out, {u.unary_operator()} {u.rhs()}),778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 Self::ExprObjExtend(ex) => {793 p!(out, {ex.lhs_work()} str(" ") {ex.rhs_work()});794 }795 Self::ExprParened(p) => {796 p!(out, str("(") {p.expr()} str(")"));797 }798 Self::ExprString(s) => p!(out, { s.text() }),799 Self::ExprNumber(n) => p!(out, { n.number() }),800 Self::ExprArray(a) => {801 p!(out, { a });802 }803 Self::ExprObject(obj) => {804 p!(out, { obj.obj_body() });805 }806 Self::ExprArrayComp(arr) => {807 p!(out, str("[") {arr.expr()});808 for spec in arr.comp_specs() {809 p!(out, str(" ") {spec});810 }811 p!(out, str("]"));812 }813 Self::ExprImport(v) => {814 p!(out, {v.import_kind()} str(" ") {v.text()});815 }816 Self::ExprVar(n) => p!(out, { n.name() }),817 818 819 Self::ExprIfThenElse(ite) => {820 p!(out, str("if ") {ite.cond()} str(" then ") {ite.then().map(|t| t.expr())});821 if ite.else_kw_token().is_some() || ite.else_().is_some() {822 p!(out, str(" else ") {ite.else_().map(|t| t.expr())});823 }824 }825 Self::ExprFunction(f) => p!(out, str("function") {f.params_desc()} nl {f.expr()}),826 827 Self::ExprError(e) => p!(out, str("error ") {e.expr()}),828 Self::ExprLiteral(l) => {829 p!(out, { l.literal() });830 }831 }832 }833}834835impl Printable for SourceFile {836 fn print(&self, out: &mut PrintItems) {837 let before = trivia_before(838 self.syntax().clone(),839 self.expr()840 .map(|e| e.syntax().clone())841 .map(Into::into)842 .as_ref(),843 );844 let after = trivia_after(845 self.syntax().clone(),846 self.expr()847 .map(|e| e.syntax().clone())848 .map(Into::into)849 .as_ref(),850 );851 format_comments(&before, CommentLocation::AboveItem, out);852 p!(out, {self.expr()} nl);853 format_comments(&after, CommentLocation::EndOfItems, out);854 }855}856857pub struct FormatOptions {858 859 pub indent: u8,860}861862#[allow(863 clippy::result_large_err,864 reason = "TODO: there should be an intermediate representation for such reports"865)]866pub fn format(input: &str, opts: &FormatOptions) -> Result<String, SnippetBuilder> {867 let (parsed, errors) = jrsonnet_rowan_parser::parse(input);868 if !errors.is_empty() {869 let mut builder = hi_doc::SnippetBuilder::new(input);870 for error in errors {871 builder872 .error(hi_doc::Text::fragment(873 format!("{:?}", error.error),874 Formatting::default(),875 ))876 .range(877 error.range.start().into()878 ..=(usize::from(error.range.end()) - 1).max(error.range.start().into()),879 )880 .build();881 }882 883 return Err(builder);884 885 886 887 }888 Ok(dprint_core::formatting::format(889 || {890 let mut out = PrintItems::new();891 parsed.print(&mut out);892 out893 },894 PrintOptions {895 indent_width: if opts.indent == 0 {896 897 3898 } else {899 opts.indent900 },901 max_width: 100,902 use_tabs: opts.indent == 0,903 new_line_text: "\n",904 },905 ))906}