git.delta.rocks / jrsonnet / refs/commits / 6fbe7c61b4ca

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		// 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 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				// TODO: keep end_comments, child.inline_trivia somehow, force multiple locals formatting in case of presence?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			// Self::ExprSlice(s) => {820			// 	p!(new: {s.expr()} {s.slice_desc()})821			// }822			// Self::ExprIndex(i) => {823			// 	p!(new: {i.expr()} str(".") {i.index()})824			// }825			// Self::ExprIndexExpr(i) => p!(new: {i.base()} str("[") {i.index()} str("]")),826			// Self::ExprApply(a) => {827			// 	let mut pi = p!(new: {a.expr()} {a.args_desc()});828			// 	if a.tailstrict_kw_token().is_some() {829			// 		p!(out,str(" tailstrict"));830			// 	}831			// 	pi832			// }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			// Self::ExprLocal(l) => {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			// Self::ExprAssert(a) => p!(new: {a.assertion()} str("; ") {a.expr()}),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}897898#[derive(Default)]899pub struct FormatOptions {900	// 0 for hard tabs, otherwise number of spaces901	pub indent: u8,902}903impl FormatOptions {904	pub fn new() -> Self {905		Self::default()906	}907}908909#[allow(910	clippy::result_large_err,911	reason = "TODO: there should be an intermediate representation for such reports"912)]913pub fn format(input: &str, opts: &FormatOptions) -> Result<String, SnippetBuilder> {914	let (parsed, errors) = jrsonnet_rowan_parser::parse(input);915	if !errors.is_empty() {916		// Reserve one char for EOF display917		let input = format!("{input} ");918		let mut builder = hi_doc::SnippetBuilder::new(input);919		for error in errors {920			builder921				.error(hi_doc::Text::fragment(922					format!("{:?}", error.error),923					Formatting::default(),924				))925				.range(926					error.range.start().into()927						..=(usize::from(error.range.end()) - 1).max(error.range.start().into()),928				)929				.build();930		}931		// let snippet = builder.build();932		return Err(builder);933		// It is possible to recover from this failure, but the output may be broken, as formatter is free to skip934		// ERROR rowan nodes.935		// Recovery needs to be enabled for LSP, though.936	}937	Ok(dprint_core::formatting::format(938		|| {939			let mut out = PrintItems::new();940			parsed.print(&mut out);941			out942		},943		PrintOptions {944			indent_width: if opts.indent == 0 {945				// Reasonable max length for both 2 and 4 space sized tabs.946				3947			} else {948				opts.indent949			},950			max_width: 100,951			use_tabs: opts.indent == 0,952			new_line_text: "\n",953		},954	))955}