git.delta.rocks / jrsonnet / refs/commits / 00fbb919e422

1use std::{2	any::type_name,3	fs,4	io::{self, Write},5	path::PathBuf,6	process,7	rc::Rc,8};910use children::{children_between, trivia_before};11use clap::Parser;12use dprint_core::formatting::{13	condition_helpers::is_multiple_lines, condition_resolvers::true_resolver,14	ConditionResolverContext, LineNumber, PrintItems, PrintOptions,15};16use jrsonnet_rowan_parser::{17	nodes::{18		Arg, ArgsDesc, Assertion, BinaryOperator, Bind, CompSpec, Destruct, DestructArrayPart,19		DestructRest, Expr, ExprBase, FieldName, ForSpec, IfSpec, ImportKind, Literal, Member,20		Name, Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc, SourceFile, Stmt, Suffix, Text,21		UnaryOperator, Visibility,22	},23	AstNode, AstToken as _, SyntaxToken,24};2526use crate::{27	children::trivia_after,28	comments::{format_comments, CommentLocation},29};3031mod children;32mod comments;33#[cfg(test)]34mod tests;3536pub trait Printable {37	fn print(&self, out: &mut PrintItems);38}3940macro_rules! pi {41	(@i; $($t:tt)*) => {{42		#[allow(unused_mut)]43		let mut o = dprint_core::formatting::PrintItems::new();44		pi!(@s; o: $($t)*);45		o46	}};47	(@s; $o:ident: str($e:expr $(,)?) $($t:tt)*) => {{48		$o.push_str($e);49		pi!(@s; $o: $($t)*);50	}};51	(@s; $o:ident: string($e:expr $(,)?) $($t:tt)*) => {{52		$o.push_string($e);53		pi!(@s; $o: $($t)*);54	}};55	(@s; $o:ident: nl $($t:tt)*) => {{56		$o.push_signal(dprint_core::formatting::Signal::NewLine);57		pi!(@s; $o: $($t)*);58	}};59	(@s; $o:ident: tab $($t:tt)*) => {{60		$o.push_signal(dprint_core::formatting::Signal::Tab);61		pi!(@s; $o: $($t)*);62	}};63	(@s; $o:ident: >i $($t:tt)*) => {{64		$o.push_signal(dprint_core::formatting::Signal::StartIndent);65		pi!(@s; $o: $($t)*);66	}};67	(@s; $o:ident: <i $($t:tt)*) => {{68		$o.push_signal(dprint_core::formatting::Signal::FinishIndent);69		pi!(@s; $o: $($t)*);70	}};71	(@s; $o:ident: info($v:expr) $($t:tt)*) => {{72		$o.push_info($v);73		pi!(@s; $o: $($t)*);74	}};75	(@s; $o:ident: if($s:literal, $cond:expr, $($i:tt)*) $($t:tt)*) => {{76		$o.push_condition(dprint_core::formatting::conditions::if_true(77			$s,78			$cond.clone(),79			{80				let mut o = PrintItems::new();81				p!(o, $($i)*);82				o83			},84		));85		pi!(@s; $o: $($t)*);86	}};87	(@s; $o:ident: if_else($s:literal, $cond:expr, $($i:tt)*)($($e:tt)+) $($t:tt)*) => {{88		$o.push_condition(dprint_core::formatting::conditions::if_true_or(89			$s,90			$cond.clone(),91			{92				let mut o = PrintItems::new();93				p!(o, $($i)*);94				o95			},96			{97				let mut o = PrintItems::new();98				p!(o, $($e)*);99				o100			},101		));102		pi!(@s; $o: $($t)*);103	}};104	(@s; $o:ident: if_not($s:literal, $cond:expr, $($e:tt)*) $($t:tt)*) => {{105		$o.push_condition(dprint_core::formatting::conditions::if_true_or(106			$s,107			$cond.clone(),108			{109				let o = PrintItems::new();110				o111			},112			{113				let mut o = PrintItems::new();114				p!(o, $($e)*);115				o116			},117		));118		pi!(@s; $o: $($t)*);119	}};120	(@s; $o:ident: {$expr:expr} $($t:tt)*) => {{121		$expr.print($o);122		pi!(@s; $o: $($t)*);123	}};124	(@s; $o:ident: items($expr:expr) $($t:tt)*) => {{125		$o.extend($expr);126		pi!(@s; $o: $($t)*);127	}};128	(@s; $o:ident: if ($e:expr)($($then:tt)*) $($t:tt)*) => {{129		if $e {130			pi!(@s; $o: $($then)*);131		}132		pi!(@s; $o: $($t)*);133	}};134	(@s; $o:ident: ifelse ($e:expr)($($then:tt)*)($($else:tt)*) $($t:tt)*) => {{135		if $e {136			pi!(@s; $o: $($then)*);137		} else {138			pi!(@s; $o: $($else)*);139		}140		pi!(@s; $o: $($t)*);141	}};142	(@s; $i:ident:) => {}143}144macro_rules! p {145	($o:ident, $($t:tt)*) => {146		pi!(@s; $o: $($t)*)147	};148}149pub(crate) use p;150pub(crate) use pi;151152impl<P> Printable for Option<P>153where154	P: Printable,155{156	fn print(&self, out: &mut PrintItems) {157		if let Some(v) = self {158			v.print(out)159		} else {160			p!(161				out,162				string(format!(163					"/*missing {}*/",164					type_name::<P>().replace("jrsonnet_rowan_parser::generated::nodes::", "")165				),)166			)167		}168	}169}170171impl Printable for SyntaxToken {172	fn print(&self, out: &mut PrintItems) {173		p!(out, string(self.to_string()))174	}175}176177impl Printable for Text {178	fn print(&self, out: &mut PrintItems) {179		p!(out, string(format!("{}", self)))180	}181}182impl Printable for Number {183	fn print(&self, out: &mut PrintItems) {184		p!(out, string(format!("{}", self)))185	}186}187188impl Printable for Name {189	fn print(&self, out: &mut PrintItems) {190		p!(out, { self.ident_lit() })191	}192}193194impl Printable for DestructRest {195	fn print(&self, out: &mut PrintItems) {196		p!(out, str("..."));197		if let Some(name) = self.into() {198			p!(out, { name });199		}200	}201}202203impl Printable for Destruct {204	fn print(&self, out: &mut PrintItems) {205		match self {206			Destruct::DestructFull(f) => {207				p!(out, { f.name() })208			}209			Destruct::DestructSkip(_) => p!(out, str("?")),210			Destruct::DestructArray(a) => {211				p!(out, str("[") >i nl);212				for el in a.destruct_array_parts() {213					match el {214						DestructArrayPart::DestructArrayElement(e) => {215							p!(out, {e.destruct()} str(",") nl)216						}217						DestructArrayPart::DestructRest(d) => {218							p!(out, {d} str(",") nl)219						}220					}221				}222				p!(out, <i str("]"));223			}224			Destruct::DestructObject(o) => {225				p!(out, str("{") >i nl);226				for item in o.destruct_object_fields() {227					p!(out, { item.field() });228					if let Some(des) = item.destruct() {229						p!(out, str(": ") {des})230					}231					if let Some(def) = item.expr() {232						p!(out, str(" = ") {def});233					}234					p!(out, str(",") nl);235				}236				if let Some(rest) = o.destruct_rest() {237					p!(out, {rest} nl)238				}239				p!(out, <i str("}"));240			}241		}242	}243}244245impl Printable for FieldName {246	fn print(&self, out: &mut PrintItems) {247		match self {248			FieldName::FieldNameFixed(f) => {249				if let Some(id) = f.id() {250					p!(out, { id })251				} else if let Some(str) = f.text() {252					p!(out, { str })253				} else {254					p!(out, str("/*missing FieldName*/"))255				}256			}257			FieldName::FieldNameDynamic(d) => {258				p!(out, str("[") {d.expr()} str("]"))259			}260		}261	}262}263264impl Printable for Visibility {265	fn print(&self, out: &mut PrintItems) {266		p!(out, string(self.to_string()))267	}268}269270impl Printable for ObjLocal {271	fn print(&self, out: &mut PrintItems) {272		p!(out, str("local ") {self.bind()})273	}274}275276impl Printable for Assertion {277	fn print(&self, out: &mut PrintItems) {278		p!(out, str("assert ") {self.condition()});279		if self.colon_token().is_some() || self.message().is_some() {280			p!(out, str(": ") {self.message()})281		}282	}283}284285impl Printable for ParamsDesc {286	fn print(&self, out: &mut PrintItems) {287		p!(out, str("(") >i nl);288		for param in self.params() {289			p!(out, { param.destruct() });290			if param.assign_token().is_some() || param.expr().is_some() {291				p!(out, str(" = ") {param.expr()})292			}293			p!(out, str(",") nl)294		}295		p!(out, <i str(")"));296	}297}298impl Printable for ArgsDesc {299	fn print(&self, out: &mut PrintItems) {300		let start = LineNumber::new("start");301		let end = LineNumber::new("end");302		let multi_line = Rc::new(move |condition_context: &mut ConditionResolverContext| {303			is_multiple_lines(condition_context, start, end).map(|v| !v)304		});305		p!(out, str("(") info(start) if("start args", multi_line, >i nl));306		let (children, end_comments) = children_between::<Arg>(307			self.syntax().clone(),308			self.l_paren_token().map(Into::into).as_ref(),309			self.r_paren_token().map(Into::into).as_ref(),310			None,311		);312		let mut args = children.into_iter().peekable();313		while let Some(ele) = args.next() {314			if ele.should_start_with_newline {315				p!(out, nl);316			}317			format_comments(&ele.before_trivia, CommentLocation::AboveItem, out);318			let arg = ele.value;319			if arg.name().is_some() || arg.assign_token().is_some() {320				p!(out, {arg.name()} str(" = "));321			}322			let comma_between = if args.peek().is_some() {323				true_resolver()324			} else {325				multi_line.clone()326			};327			p!(out, {arg.expr()} if("arg comma", comma_between, str(",") if_not("between args", multi_line, str(" "))));328			format_comments(&ele.inline_trivia, CommentLocation::ItemInline, out);329			p!(out, if("between args", multi_line, nl));330		}331		p!(out, if("end args", multi_line, <i info(end)) str(")"));332	}333}334impl Printable for SliceDesc {335	fn print(&self, out: &mut PrintItems) {336		p!(out, str("["));337		if self.from().is_some() {338			p!(out, { self.from() });339		}340		p!(out, str(":"));341		if self.end().is_some() {342			p!(out, { self.end().map(|e| e.expr()) })343		}344		// Keep only one : in case if we don't need step345		if self.step().is_some() {346			p!(out, str(":") {self.step().map(|e|e.expr())});347		}348		p!(out, str("]"));349	}350}351352impl Printable for Member {353	fn print(&self, out: &mut PrintItems) {354		match self {355			Member::MemberBindStmt(b) => {356				p!(out, { b.obj_local() })357			}358			Member::MemberAssertStmt(ass) => {359				p!(out, { ass.assertion() })360			}361			Member::MemberFieldNormal(n) => {362				p!(out, {n.field_name()} if(n.plus_token().is_some())({n.plus_token()}) {n.visibility()} str(" ") {n.expr()})363			}364			Member::MemberFieldMethod(m) => {365				p!(out, {m.field_name()} {m.params_desc()} {m.visibility()} str(" ") {m.expr()})366			}367		}368	}369}370371impl Printable for ObjBody {372	fn print(&self, out: &mut PrintItems) {373		match self {374			ObjBody::ObjBodyComp(l) => {375				let (children, mut end_comments) = children_between::<Member>(376					l.syntax().clone(),377					l.l_brace_token().map(Into::into).as_ref(),378					Some(379						&(l.comp_specs()380							.next()381							.expect("at least one spec is defined")382							.syntax()383							.clone())384						.into(),385					),386					None,387				);388				let trailing_for_comp = end_comments.extract_trailing();389				p!(out, str("{") >i nl);390				for mem in children.into_iter() {391					if mem.should_start_with_newline {392						p!(out, nl);393					}394					format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);395					p!(out, {mem.value} str(","));396					format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);397					p!(out, nl)398				}399400				if end_comments.should_start_with_newline {401					p!(out, nl);402				}403				format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);404405				let (compspecs, end_comments) = children_between::<CompSpec>(406					l.syntax().clone(),407					l.member_comps()408						.last()409						.map(|m| m.syntax().clone())410						.map(Into::into)411						.or_else(|| l.l_brace_token().map(Into::into))412						.as_ref(),413					l.r_brace_token().map(Into::into).as_ref(),414					Some(trailing_for_comp),415				);416				for mem in compspecs.into_iter() {417					if mem.should_start_with_newline {418						p!(out, nl);419					}420					format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);421					p!(out, { mem.value });422					format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);423				}424				if end_comments.should_start_with_newline {425					p!(out, nl);426				}427				format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);428429				p!(out, nl <i str("}"));430			}431			ObjBody::ObjBodyMemberList(l) => {432				let (children, end_comments) = children_between::<Member>(433					l.syntax().clone(),434					l.l_brace_token().map(Into::into).as_ref(),435					l.r_brace_token().map(Into::into).as_ref(),436					None,437				);438				if children.is_empty() && end_comments.is_empty() {439					p!(out, str("{ }"));440					return;441				}442				p!(out, str("{") >i nl);443				for (i, mem) in children.into_iter().enumerate() {444					if mem.should_start_with_newline && i != 0 {445						p!(out, nl);446					}447					format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);448					p!(out, {mem.value} str(","));449					format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);450					p!(out, nl)451				}452453				if end_comments.should_start_with_newline {454					p!(out, nl);455				}456				format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);457				p!(out, <i str("}"));458			}459		}460	}461}462impl Printable for UnaryOperator {463	fn print(&self, out: &mut PrintItems) {464		p!(out, string(self.text().to_string()))465	}466}467impl Printable for BinaryOperator {468	fn print(&self, out: &mut PrintItems) {469		p!(out, string(self.text().to_string()))470	}471}472impl Printable for Bind {473	fn print(&self, out: &mut PrintItems) {474		match self {475			Bind::BindDestruct(d) => {476				p!(out, {d.into()} str(" = ") {d.value()})477			}478			Bind::BindFunction(f) => {479				p!(out, {f.name()} {f.params()} str(" = ") {f.value()})480			}481		}482	}483}484impl Printable for Literal {485	fn print(&self, out: &mut PrintItems) {486		p!(out, string(self.syntax().to_string()))487	}488}489impl Printable for ImportKind {490	fn print(&self, out: &mut PrintItems) {491		p!(out, string(self.syntax().to_string()))492	}493}494impl Printable for ForSpec {495	fn print(&self, out: &mut PrintItems) {496		p!(out, str("for ") {self.bind()} str(" in ") {self.expr()})497	}498}499impl Printable for IfSpec {500	fn print(&self, out: &mut PrintItems) {501		p!(out, str("if ") {self.expr()})502	}503}504impl Printable for CompSpec {505	fn print(&self, out: &mut PrintItems) {506		match self {507			CompSpec::ForSpec(f) => f.print(out),508			CompSpec::IfSpec(i) => i.print(out),509		}510	}511}512impl Printable for Expr {513	fn print(&self, out: &mut PrintItems) {514		let (stmts, _ending) = children_between::<Stmt>(515			self.syntax().clone(),516			None,517			self.expr_base()518				.as_ref()519				.map(ExprBase::syntax)520				.cloned()521				.map(Into::into)522				.as_ref(),523			None,524		);525		for stmt in stmts {526			p!(out, { stmt.value });527		}528		p!(out, { self.expr_base() });529		let (suffixes, _ending) = children_between::<Suffix>(530			self.syntax().clone(),531			self.expr_base()532				.as_ref()533				.map(ExprBase::syntax)534				.cloned()535				.map(Into::into)536				.as_ref(),537			None,538			None,539		);540		for suffix in suffixes {541			p!(out, { suffix.value });542		}543	}544}545impl Printable for Suffix {546	fn print(&self, out: &mut PrintItems) {547		match self {548			Suffix::SuffixIndex(i) => {549				if i.question_mark_token().is_some() {550					p!(out, str("?"));551				}552				p!(out, str(".") {i.index()});553			}554			Suffix::SuffixIndexExpr(e) => {555				if e.question_mark_token().is_some() {556					p!(out, str(".?"));557				}558				p!(out, str("[") {e.index()} str("]"))559			}560			Suffix::SuffixSlice(d) => {561				p!(out, { d.slice_desc() })562			}563			Suffix::SuffixApply(a) => {564				p!(out, { a.args_desc() })565			}566		}567	}568}569impl Printable for Stmt {570	fn print(&self, out: &mut PrintItems) {571		match self {572			Stmt::StmtLocal(l) => {573				let (binds, end_comments) = children_between::<Bind>(574					l.syntax().clone(),575					l.local_kw_token().map(Into::into).as_ref(),576					l.semi_token().map(Into::into).as_ref(),577					None,578				);579				if binds.len() == 1 {580					let bind = &binds[0];581					format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);582					p!(out, str("local ") {bind.value});583				// TODO: keep end_comments, child.inline_trivia somehow, force multiple locals formatting in case of presence?584				} else {585					p!(out,str("local") >i nl);586					for bind in binds {587						if bind.should_start_with_newline {588							p!(out, nl);589						}590						format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);591						p!(out, {bind.value} str(","));592						format_comments(&bind.inline_trivia, CommentLocation::ItemInline, out);593						p!(out, nl)594					}595					if end_comments.should_start_with_newline {596						p!(out, nl)597					}598					format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);599					p!(out,<i);600				}601				p!(out,str(";") nl);602			}603			Stmt::StmtAssert(a) => {604				p!(out, {a.assertion()} str(";") nl)605			}606		}607	}608}609impl Printable for ExprBase {610	fn print(&self, out: &mut PrintItems) {611		match self {612			Self::ExprBinary(b) => {613				p!(out, {b.lhs_work()} str(" ") {b.binary_operator()} str(" ") {b.rhs_work()})614			}615			Self::ExprUnary(u) => p!(out, {u.unary_operator()} {u.rhs()}),616			// Self::ExprSlice(s) => {617			// 	p!(new: {s.expr()} {s.slice_desc()})618			// }619			// Self::ExprIndex(i) => {620			// 	p!(new: {i.expr()} str(".") {i.index()})621			// }622			// Self::ExprIndexExpr(i) => p!(new: {i.base()} str("[") {i.index()} str("]")),623			// Self::ExprApply(a) => {624			// 	let mut pi = p!(new: {a.expr()} {a.args_desc()});625			// 	if a.tailstrict_kw_token().is_some() {626			// 		p!(out,str(" tailstrict"));627			// 	}628			// 	pi629			// }630			Self::ExprObjExtend(ex) => {631				p!(out, {ex.lhs_work()} str(" ") {ex.rhs_work()})632			}633			Self::ExprParened(p) => {634				p!(out, str("(") {p.expr()} str(")"))635			}636			Self::ExprString(s) => p!(out, { s.text() }),637			Self::ExprNumber(n) => p!(out, { n.number() }),638			Self::ExprArray(a) => {639				p!(out, str("[") >i nl);640				for el in a.exprs() {641					p!(out, {el} str(",") nl);642				}643				p!(out, <i str("]"));644			}645			Self::ExprObject(obj) => {646				p!(out, { obj.obj_body() })647			}648			Self::ExprArrayComp(arr) => {649				p!(out, str("[") {arr.expr()});650				for spec in arr.comp_specs() {651					p!(out, str(" ") {spec});652				}653				p!(out, str("]"));654			}655			Self::ExprImport(v) => {656				p!(out, {v.import_kind()} str(" ") {v.text()})657			}658			Self::ExprVar(n) => p!(out, { n.name() }),659			// Self::ExprLocal(l) => {660			// }661			Self::ExprIfThenElse(ite) => {662				p!(out, str("if ") {ite.cond()} str(" then ") {ite.then().map(|t| t.expr())});663				if ite.else_kw_token().is_some() || ite.else_().is_some() {664					p!(out, str(" else ") {ite.else_().map(|t| t.expr())})665				}666			}667			Self::ExprFunction(f) => p!(out, str("function") {f.params_desc()} nl {f.expr()}),668			// Self::ExprAssert(a) => p!(new: {a.assertion()} str("; ") {a.expr()}),669			Self::ExprError(e) => p!(out, str("error ") {e.expr()}),670			Self::ExprLiteral(l) => {671				p!(out, { l.literal() })672			}673		}674	}675}676677impl Printable for SourceFile {678	fn print(&self, out: &mut PrintItems) {679		let before = trivia_before(680			self.syntax().clone(),681			self.expr()682				.map(|e| e.syntax().clone())683				.map(Into::into)684				.as_ref(),685		);686		let after = trivia_after(687			self.syntax().clone(),688			self.expr()689				.map(|e| e.syntax().clone())690				.map(Into::into)691				.as_ref(),692		);693		format_comments(&before, CommentLocation::AboveItem, out);694		p!(out, {self.expr()} nl);695		format_comments(&after, CommentLocation::EndOfItems, out)696	}697}698699struct FormatOptions {700	// 0 for hard tabs701	indent: u8,702}703fn format(input: &str, opts: &FormatOptions) -> Option<String> {704	let (parsed, errors) = jrsonnet_rowan_parser::parse(input);705	if !errors.is_empty() {706		let mut builder = hi_doc::SnippetBuilder::new(input);707		for error in errors {708			builder709				.error(hi_doc::Text::single(710					format!("{:?}", error.error).chars(),711					Default::default(),712				))713				.range(714					error.range.start().into()715						..=(usize::from(error.range.end()) - 1).max(error.range.start().into()),716				)717				.build();718		}719		let snippet = builder.build();720		let ansi = hi_doc::source_to_ansi(&snippet);721		eprintln!("{ansi}");722		// It is possible to recover from this failure, but the output may be broken, as formatter is free to skip723		// ERROR rowan nodes.724		// Recovery needs to be enabled for LSP, though.725		//726		// TODO: Verify how formatter interacts in cases of missing positional values, i.e `if cond then /*missing Expr*/ else residual`.727		return None;728	}729	Some(dprint_core::formatting::format(730		|| {731			let mut out = PrintItems::new();732			parsed.print(&mut out);733			out734		},735		PrintOptions {736			indent_width: if opts.indent == 0 {737				// Reasonable max length for both 2 and 4 space sized tabs.738				3739			} else {740				opts.indent741			},742			max_width: 100,743			use_tabs: opts.indent == 0,744			new_line_text: "\n",745		},746	))747}748749#[derive(Parser)]750struct Opts {751	/// Treat input as code, reformat it instead of reading file.752	#[clap(long, short = 'e')]753	exec: bool,754	/// Path to be reformatted if `--exec` if unset, otherwise code itself.755	input: String,756	/// Replace code with formatted in-place, instead of printing it to stdout.757	/// Only applicable if `--exec` is unset.758	#[clap(long, short = 'i')]759	in_place: bool,760761	/// Exit with error if formatted does not match input762	#[arg(long)]763	test: bool,764	/// Number of spaces to indent with765	///766	/// 0 for guess from input (default), and use hard tabs if unable to guess.767	#[arg(long, default_value = "0")]768	indent: u8,769	/// Force hard tab for indentation770	#[arg(long)]771	hard_tabs: bool,772773	/// Debug option: how many times to call reformatting in case of unstable dprint output resolution.774	///775	/// 0 for not retrying to reformat.776	#[arg(long, default_value = "0")]777	conv_limit: usize,778}779780#[derive(thiserror::Error, Debug)]781enum Error {782	#[error("--in-place is incompatible with --exec")]783	InPlaceExec,784	#[error("io: {0}")]785	Io(#[from] io::Error),786	#[error("persist: {0}")]787	Persist(#[from] tempfile::PersistError),788	#[error("parsing failed, refusing to reformat corrupted input")]789	Parse,790}791792fn main_result() -> Result<(), Error> {793	eprintln!("jrsonnet-fmt is a prototype of a jsonnet code formatter, do not expect it to produce meaningful results right now.");794	eprintln!("It is not expected for its output to match other implementations, it will be completly separate implementation with maybe different name.");795	let mut opts = Opts::parse();796	let input = if opts.exec {797		if opts.in_place {798			return Err(Error::InPlaceExec);799		}800		opts.input.clone()801	} else {802		fs::read_to_string(&opts.input)?803	};804805	if opts.indent == 0 {806		// Sane default.807		// TODO: Implement actual guessing.808		opts.hard_tabs = true;809	}810811	let mut iteration = 0;812	let mut formatted = input.clone();813	let mut tmp;814	// https://github.com/dprint/dprint/pull/423815	loop {816		let Some(reformatted) = format(817			&formatted,818			&FormatOptions {819				indent: if opts.indent == 0 || opts.hard_tabs {820					0821				} else {822					opts.indent823				},824			},825		) else {826			return Err(Error::Parse);827		};828		tmp = reformatted.trim().to_owned();829		if formatted == tmp {830			break;831		}832		formatted = tmp;833		if opts.conv_limit == 0 {834			break;835		}836		iteration += 1;837		if iteration > opts.conv_limit {838			panic!("formatting not converged");839		}840	}841	formatted.push('\n');842	if opts.test && formatted != input {843		process::exit(1);844	}845	if opts.in_place {846		let path = PathBuf::from(opts.input);847		let mut temp = tempfile::NamedTempFile::new_in(path.parent().expect(848			"not failed during read, this path is not a directory, and there is a parent",849		))?;850		temp.write_all(formatted.as_bytes())?;851		temp.flush()?;852		temp.persist(&path)?;853	} else {854		print!("{formatted}")855	}856	Ok(())857}858859fn main() {860	if let Err(e) = main_result() {861		eprintln!("{e}");862		process::exit(1);863	}864}