git.delta.rocks / jrsonnet / refs/commits / 752087cb9057

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, ForObjSpec, ForSpec, IfSpec,17		ImportKind, Literal, Member, Name, Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc,18		SourceFile, Stmt, Suffix, 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		// Keep only one : in case if we don't need step422		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 ForObjSpec {649	fn print(&self, out: &mut PrintItems) {650		p!(out, str("for [") {self.key()} str("]") {self.visibility()} str(" ") {self.value()} str(" in ") {self.expr()});651	}652}653impl Printable for IfSpec {654	fn print(&self, out: &mut PrintItems) {655		p!(out, str("if ") {self.expr()});656	}657}658impl Printable for CompSpec {659	fn print(&self, out: &mut PrintItems) {660		match self {661			Self::ForSpec(f) => f.print(out),662			Self::ForObjSpec(f) => f.print(out),663			Self::IfSpec(i) => i.print(out),664		}665	}666}667impl Printable for Expr {668	fn print(&self, out: &mut PrintItems) {669		let (stmts, _ending) = children_between::<Stmt>(670			self.syntax().clone(),671			None,672			self.expr_base()673				.as_ref()674				.map(ExprBase::syntax)675				.cloned()676				.map(Into::into)677				.as_ref(),678			None,679		);680		for stmt in stmts {681			p!(out, { stmt.value });682		}683		p!(out, { self.expr_base() });684		let (suffixes, _ending) = children_between::<Suffix>(685			self.syntax().clone(),686			self.expr_base()687				.as_ref()688				.map(ExprBase::syntax)689				.cloned()690				.map(Into::into)691				.as_ref(),692			None,693			None,694		);695		for suffix in suffixes {696			p!(out, { suffix.value });697		}698	}699}700impl Printable for Suffix {701	fn print(&self, out: &mut PrintItems) {702		match self {703			Self::SuffixIndex(i) => {704				if i.question_mark_token().is_some() {705					p!(out, str("?"));706				}707				p!(out, str(".") {i.index()});708			}709			Self::SuffixIndexExpr(e) => {710				if e.question_mark_token().is_some() {711					p!(out, str(".?"));712				}713				p!(out, str("[") {e.index()} str("]"));714			}715			Self::SuffixSlice(d) => {716				p!(out, { d.slice_desc() });717			}718			Self::SuffixApply(a) => {719				p!(out, { a.args_desc() });720			}721		}722	}723}724impl Printable for Stmt {725	fn print(&self, out: &mut PrintItems) {726		match self {727			Self::StmtLocal(l) => {728				let (binds, end_comments) = children_between::<Bind>(729					l.syntax().clone(),730					l.local_kw_token().map(Into::into).as_ref(),731					l.semi_token().map(Into::into).as_ref(),732					None,733				);734				if binds.len() == 1 {735					let bind = &binds[0];736					format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);737					p!(out, str("local ") {bind.value});738				// TODO: keep end_comments, child.inline_trivia somehow, force multiple locals formatting in case of presence?739				} else {740					p!(out,str("local") >i nl);741					for bind in binds {742						if bind.should_start_with_newline {743							p!(out, nl);744						}745						format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);746						p!(out, {bind.value} str(","));747						format_comments(&bind.inline_trivia, CommentLocation::ItemInline, out);748						p!(out, nl);749					}750					if end_comments.should_start_with_newline {751						p!(out, nl);752					}753					format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);754					p!(out,<i);755				}756				p!(out,str(";") nl);757			}758			Self::StmtAssert(a) => {759				p!(out, {a.assertion()} str(";") nl);760			}761		}762	}763}764765impl Printable for ExprArray {766	fn print(&self, out: &mut PrintItems) {767		fn gen_elements(children: Vec<Child<Expr>>, multi_line: ConditionResolver) -> PrintItems {768			let mut out = PrintItems::new();769			let mut els = children.into_iter().peekable();770			while let Some(el) = els.next() {771				if el.should_start_with_newline {772					p!(out, nl);773				}774				format_comments(&el.before_trivia, CommentLocation::AboveItem, &mut out);775				p!(&mut out, { el.value });776				let has_more = els.peek().is_some();777				if has_more {778					p!(out, str(","));779				} else {780					p!(out, if("trailing comma", multi_line, str(",")));781				}782				format_comments(&el.inline_trivia, CommentLocation::ItemInline, &mut out);783				p!(out, if_else("element separator", multi_line, nl)(sonl));784			}785			out786		}787788		let (children, end_comments) = children_between::<Expr>(789			self.syntax().clone(),790			self.l_brack_token().map(Into::into).as_ref(),791			self.r_brack_token().map(Into::into).as_ref(),792			None,793		);794		if children.is_empty() && end_comments.is_empty() {795			p!(out, str("[ ]"));796			return;797		}798799		let source_is_multiline =800			children.iter().any(|c| c.triggers_multiline) || end_comments.should_start_with_newline;801802		let start = LineNumber::new("arr start line");803		let end = LineNumber::new("arr end line");804		let multi_line: ConditionResolver = if source_is_multiline {805			true_resolver()806		} else {807			Rc::new(move |ctx: &mut ConditionResolverContext| is_multiple_lines(ctx, start, end))808		};809810		let els_items = new_line_group(gen_elements(children, multi_line.clone())).into_rc_path();811812		let els = with_indent_eoi(multi_line, els_items.into(), end_comments);813814		p!(out, str("[") info(start) items(els) str("]") info(end));815	}816}817818impl Printable for ExprBase {819	fn print(&self, out: &mut PrintItems) {820		match self {821			Self::ExprBinary(b) => {822				p!(out, {b.lhs()} str(" ") {b.binary_operator()} str(" ") {b.rhs()});823			}824			Self::ExprUnary(u) => p!(out, {u.unary_operator()} {u.rhs()}),825			// Self::ExprSlice(s) => {826			// 	p!(new: {s.expr()} {s.slice_desc()})827			// }828			// Self::ExprIndex(i) => {829			// 	p!(new: {i.expr()} str(".") {i.index()})830			// }831			// Self::ExprIndexExpr(i) => p!(new: {i.base()} str("[") {i.index()} str("]")),832			// Self::ExprApply(a) => {833			// 	let mut pi = p!(new: {a.expr()} {a.args_desc()});834			// 	if a.tailstrict_kw_token().is_some() {835			// 		p!(out,str(" tailstrict"));836			// 	}837			// 	pi838			// }839			Self::ExprObjExtend(ex) => {840				p!(out, {ex.lhs()} str(" ") {ex.rhs()});841			}842			Self::ExprParened(p) => {843				p!(out, str("(") {p.expr()} str(")"));844			}845			Self::ExprString(s) => p!(out, { s.text() }),846			Self::ExprNumber(n) => p!(out, { n.number() }),847			Self::ExprArray(a) => {848				p!(out, { a });849			}850			Self::ExprObject(obj) => {851				p!(out, { obj.obj_body() });852			}853			Self::ExprArrayComp(arr) => {854				p!(out, str("[") {arr.expr()});855				for spec in arr.comp_specs() {856					p!(out, str(" ") {spec});857				}858				p!(out, str("]"));859			}860			Self::ExprImport(v) => {861				p!(out, {v.import_kind()} str(" ") {v.text()});862			}863			Self::ExprVar(n) => p!(out, { n.name() }),864			// Self::ExprLocal(l) => {865			// }866			Self::ExprIfThenElse(ite) => {867				p!(out, str("if ") {ite.cond()} str(" then ") {ite.then().map(|t| t.expr())});868				if ite.else_kw_token().is_some() || ite.else_().is_some() {869					p!(out, str(" else ") {ite.else_().map(|t| t.expr())});870				}871			}872			Self::ExprFunction(f) => p!(out, str("function") {f.params_desc()} nl {f.expr()}),873			// Self::ExprAssert(a) => p!(new: {a.assertion()} str("; ") {a.expr()}),874			Self::ExprError(e) => p!(out, str("error ") {e.expr()}),875			Self::ExprLiteral(l) => {876				p!(out, { l.literal() });877			}878		}879	}880}881882impl Printable for SourceFile {883	fn print(&self, out: &mut PrintItems) {884		let before = trivia_before(885			self.syntax().clone(),886			self.expr()887				.map(|e| e.syntax().clone())888				.map(Into::into)889				.as_ref(),890		);891		let after = trivia_after(892			self.syntax().clone(),893			self.expr()894				.map(|e| e.syntax().clone())895				.map(Into::into)896				.as_ref(),897		);898		format_comments(&before, CommentLocation::AboveItem, out);899		p!(out, {self.expr()} nl);900		format_comments(&after, CommentLocation::EndOfItems, out);901	}902}903904#[derive(Default)]905pub struct FormatOptions {906	// 0 for hard tabs, otherwise number of spaces907	pub indent: u8,908}909impl FormatOptions {910	pub fn new() -> Self {911		Self::default()912	}913}914915#[allow(916	clippy::result_large_err,917	reason = "TODO: there should be an intermediate representation for such reports"918)]919pub fn format(input: &str, opts: &FormatOptions) -> Result<String, SnippetBuilder> {920	let (parsed, errors) = jrsonnet_rowan_parser::parse(input);921	if !errors.is_empty() {922		// Reserve one char for EOF display923		let input = format!("{input} ");924		let mut builder = hi_doc::SnippetBuilder::new(input);925		for error in errors {926			builder927				.error(hi_doc::Text::fragment(928					format!("{:?}", error.error),929					Formatting::default(),930				))931				.range(932					error.range.start().into()933						..=(usize::from(error.range.end()) - 1).max(error.range.start().into()),934				)935				.build();936		}937		// let snippet = builder.build();938		return Err(builder);939		// It is possible to recover from this failure, but the output may be broken, as formatter is free to skip940		// ERROR rowan nodes.941		// Recovery needs to be enabled for LSP, though.942	}943	Ok(dprint_core::formatting::format(944		|| {945			let mut out = PrintItems::new();946			parsed.print(&mut out);947			out948		},949		PrintOptions {950			indent_width: if opts.indent == 0 {951				// Reasonable max length for both 2 and 4 space sized tabs.952				3953			} else {954				opts.indent955			},956			max_width: 100,957			use_tabs: opts.indent == 0,958			new_line_text: "\n",959		},960	))961}