git.delta.rocks / jrsonnet / refs/commits / d14f5fd9b388

--- /dev/null
+++ b/crates/jrsonnet-formatter/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "jrsonnet-formatter"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+version.workspace = true
+
+[dependencies]
+dprint-core.workspace = true
+hi-doc.workspace = true
+jrsonnet-rowan-parser.workspace = true
+
+[lints]
+workspace = true

--- /dev/null
+++ b/crates/jrsonnet-formatter/src/children.rs
@@ -0,0 +1,251 @@
+// TODO: Return errors as trivia
+
+use std::{fmt::Debug, mem};
+
+use jrsonnet_rowan_parser::{
+	nodes::{CustomError, Trivia, TriviaKind},
+	AstNode, AstToken, SyntaxElement, SyntaxNode, TS,
+};
+
+pub type ChildTrivia = Vec<Result<Trivia, String>>;
+
+/// Node should have no non-trivia tokens before element
+pub fn trivia_before(node: SyntaxNode, end: Option<&SyntaxElement>) -> ChildTrivia {
+	let mut out = Vec::new();
+	for item in node.children_with_tokens() {
+		if Some(&item) == end {
+			break;
+		}
+
+		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
+			out.push(Ok(trivia));
+		} else if CustomError::can_cast(item.kind()) {
+			out.push(Err(item.to_string()));
+		} else if end.is_none() {
+			break;
+		} else {
+			assert!(
+				TS![, ;].contains(item.kind()),
+				"silently eaten token: {:?}",
+				item.kind()
+			);
+		}
+	}
+	out
+}
+/// Node should have no non-trivia tokens after element
+pub fn trivia_after(node: SyntaxNode, start: Option<&SyntaxElement>) -> ChildTrivia {
+	if start.is_none() {
+		return Vec::new();
+	}
+	let mut iter = node.children_with_tokens().peekable();
+	while iter.peek() != start {
+		iter.next();
+	}
+	iter.next();
+	let mut out = Vec::new();
+	for item in iter {
+		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
+			out.push(Ok(trivia));
+		} else if CustomError::can_cast(item.kind()) {
+			out.push(Err(item.to_string()));
+		} else {
+			assert!(
+				TS![, ;].contains(item.kind()),
+				"silently eaten token: {:?}",
+				item.kind()
+			);
+		}
+	}
+	out
+}
+
+pub fn children_between<T: AstNode + Debug>(
+	node: SyntaxNode,
+	start: Option<&SyntaxElement>,
+	end: Option<&SyntaxElement>,
+	trailing: Option<ChildTrivia>,
+) -> (Vec<Child<T>>, EndingComments) {
+	let mut iter = node.children_with_tokens().peekable();
+	if start.is_some() {
+		while iter.peek() != start {
+			iter.next();
+		}
+		iter.next();
+	}
+	children(
+		iter.take_while(|i| Some(i) != end),
+		start.is_none() && end.is_none(),
+		trailing,
+	)
+}
+
+pub fn should_start_with_newline(prev_inline: Option<&ChildTrivia>, tt: &ChildTrivia) -> bool {
+	count_newlines_before(tt)
+		+ prev_inline
+			.map(count_newlines_after)
+			.unwrap_or_default()
+
+		// First for previous item end, second for current item
+		>= 2
+}
+
+fn count_newlines_before(tt: &ChildTrivia) -> usize {
+	let mut nl_count = 0;
+	for t in tt {
+		match t {
+			Ok(t) => match t.kind() {
+				TriviaKind::Whitespace => {
+					nl_count += t.text().bytes().filter(|b| *b == b'\n').count();
+				}
+				_ => break,
+			},
+			Err(_) => {
+				nl_count += 1;
+			}
+		}
+	}
+	nl_count
+}
+fn count_newlines_after(tt: &ChildTrivia) -> usize {
+	let mut nl_count = 0;
+	for t in tt.iter().rev() {
+		match t {
+			Ok(t) => match t.kind() {
+				TriviaKind::Whitespace => {
+					nl_count += t.text().bytes().filter(|b| *b == b'\n').count();
+				}
+				TriviaKind::SingleLineHashComment | TriviaKind::SingleLineSlashComment => {
+					nl_count += 1;
+					break;
+				}
+				_ => {}
+			},
+			Err(_) => nl_count += 1,
+		}
+	}
+	nl_count
+}
+
+pub fn children<T: AstNode + Debug>(
+	items: impl Iterator<Item = SyntaxElement>,
+	loose: bool,
+	mut trailing: Option<ChildTrivia>,
+) -> (Vec<Child<T>>, EndingComments) {
+	let mut out = Vec::new();
+	let mut current_child = None::<Child<T>>;
+	let mut next = ChildTrivia::new();
+	// Previous element ended, do not add more inline comments
+	let mut started_next = false;
+	let mut had_some = false;
+
+	for item in items {
+		if let Some(value) = item.as_node().cloned().and_then(T::cast) {
+			let before_trivia = if let Some(trailing) = trailing.take() {
+				assert!(next.is_empty());
+				trailing
+			} else {
+				mem::take(&mut next)
+			};
+			let last_child = current_child.replace(Child {
+				// First item should not start with newline
+				should_start_with_newline: had_some
+					&& should_start_with_newline(
+						current_child.as_ref().map(|c| &c.inline_trivia),
+						&before_trivia,
+					),
+				before_trivia,
+				value,
+				inline_trivia: Vec::new(),
+			});
+			if let Some(last_child) = last_child {
+				out.push(last_child);
+			}
+			had_some = true;
+			started_next = false;
+		} else if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
+			let is_single_line_comment = trivia.kind() == TriviaKind::SingleLineHashComment
+				|| trivia.kind() == TriviaKind::SingleLineSlashComment;
+			if trailing.is_some() {
+				// Someone have already parsed trivia for us
+				continue;
+			} else if started_next
+				|| current_child.is_none()
+				|| trivia.text().contains('\n') && !is_single_line_comment
+			{
+				next.push(Ok(trivia.clone()));
+				started_next = true;
+			} else {
+				let cur = current_child.as_mut().expect("checked not none");
+				cur.inline_trivia.push(Ok(trivia));
+				if is_single_line_comment {
+					started_next = true;
+				}
+			}
+			had_some = true;
+		} else if CustomError::can_cast(item.kind()) {
+			next.push(Err(item.to_string()));
+		} else if loose {
+			if had_some {
+				break;
+			}
+			started_next = true;
+		} else {
+			assert!(
+				TS![, ;].contains(item.kind()),
+				"silently eaten token: {:?}",
+				item.kind()
+			);
+		}
+	}
+
+	let ending_comments = EndingComments {
+		should_start_with_newline: should_start_with_newline(
+			current_child.as_ref().map(|c| &c.inline_trivia),
+			&next,
+		),
+		trivia: next,
+	};
+
+	if let Some(current_child) = current_child {
+		out.push(current_child);
+	}
+
+	(out, ending_comments)
+}
+
+#[derive(Debug)]
+pub struct Child<T> {
+	/// If this child has two newlines above in source code, so it needs to have it in the output
+	pub should_start_with_newline: bool,
+	/// Comment before item, i.e
+	///
+	/// ```ignore
+	/// // Comment
+	/// item
+	/// ```
+	pub before_trivia: ChildTrivia,
+	pub value: T,
+	/// Comment after line, but located at same line
+	///
+	/// ```ignore
+	/// item1, // Inline comment
+	/// // Not inline comment
+	/// item2,
+	/// ```
+	pub inline_trivia: ChildTrivia,
+}
+
+pub struct EndingComments {
+	/// If this child has two newlines above in source code, so it needs to have it in the output
+	pub should_start_with_newline: bool,
+	pub trivia: ChildTrivia,
+}
+impl EndingComments {
+	pub fn is_empty(&self) -> bool {
+		!self.should_start_with_newline && self.trivia.is_empty()
+	}
+	pub fn extract_trailing(&mut self) -> ChildTrivia {
+		mem::take(&mut self.trivia)
+	}
+}

--- /dev/null
+++ b/crates/jrsonnet-formatter/src/comments.rs
@@ -0,0 +1,181 @@
+use std::string::String;
+
+use dprint_core::formatting::PrintItems;
+use jrsonnet_rowan_parser::{nodes::TriviaKind, AstToken};
+
+use crate::{children::ChildTrivia, p, pi};
+
+pub enum CommentLocation {
+	/// Above local, field, other things
+	AboveItem,
+	/// After item
+	ItemInline,
+	/// After all items in object
+	EndOfItems,
+}
+
+#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
+pub fn format_comments(comments: &ChildTrivia, loc: CommentLocation, out: &mut PrintItems) {
+	for c in comments {
+		let Ok(c) = c else {
+			let mut text = c.as_ref().unwrap_err() as &str;
+			while !text.is_empty() {
+				let pos = text.find(['\n', '\t']).unwrap_or(text.len());
+				let sliced = &text[..pos];
+				p!(out, string(sliced.to_string()));
+				text = &text[pos..];
+				if !text.is_empty() {
+					match text.as_bytes()[0] {
+						b'\n' => p!(out, nl),
+						b'\t' => p!(out, tab),
+						_ => unreachable!(),
+					}
+					text = &text[1..];
+				}
+			}
+			continue;
+		};
+		match c.kind() {
+			TriviaKind::Whitespace => {}
+			TriviaKind::MultiLineComment => {
+				let mut text = c
+					.text()
+					.strip_prefix("/*")
+					.expect("ml comment starts with /*")
+					.strip_suffix("*/")
+					.expect("ml comment ends with */");
+				// doc-style comment, /**
+				let doc = if text.starts_with('*') {
+					text = &text[1..];
+					true
+				} else {
+					false
+				};
+				// Is comment starts with text immediatly, i.e /*text
+				let mut immediate_start = true;
+				let mut lines = text
+					.split('\n')
+					.map(|l| l.trim_end().to_string())
+					.skip_while(|l| {
+						if l.is_empty() {
+							immediate_start = false;
+							true
+						} else {
+							false
+						}
+					})
+					.collect::<Vec<_>>();
+				while lines.last().is_some_and(String::is_empty) {
+					lines.pop();
+				}
+				if lines.len() == 1 && !doc {
+					if matches!(loc, CommentLocation::ItemInline) {
+						p!(out, str(" "));
+					}
+					p!(out, str("/* ") string(lines[0].trim().to_string()) str(" */") nl);
+				} else if !lines.is_empty() {
+					fn common_ws_prefix<'a>(a: &'a str, b: &str) -> &'a str {
+						let offset = a
+							.bytes()
+							.zip(b.bytes())
+							.take_while(|(a, b)| a == b && (a.is_ascii_whitespace() || *a == b'*'))
+							.count();
+						&a[..offset]
+					}
+					// First line is not empty, extract ws prefix of it
+					let mut common_ws_padding = (if immediate_start && lines.len() > 1 {
+						common_ws_prefix(&lines[1], &lines[1])
+					} else {
+						common_ws_prefix(&lines[0], &lines[0])
+					})
+					.to_string();
+					for line in lines
+						.iter()
+						.skip(if immediate_start { 2 } else { 1 })
+						.filter(|l| !l.is_empty())
+					{
+						common_ws_padding = common_ws_prefix(&common_ws_padding, line).to_string();
+					}
+					for line in lines
+						.iter_mut()
+						.skip(usize::from(immediate_start))
+						.filter(|l| !l.is_empty())
+					{
+						*line = line
+							.strip_prefix(&common_ws_padding)
+							.expect("all non-empty lines start with this padding")
+							.to_string();
+					}
+
+					p!(out, str("/*"));
+					if doc {
+						p!(out, str("*"));
+					}
+					p!(out, nl);
+					for mut line in lines {
+						if doc {
+							p!(out, str(" *"));
+						}
+						if line.is_empty() {
+							p!(out, nl);
+						} else {
+							if doc {
+								p!(out, str(" "));
+							}
+							while let Some(new_line) = line.strip_prefix('\t') {
+								if doc {
+									p!(out, str("    "));
+								} else {
+									p!(out, tab);
+								}
+								line = new_line.to_string();
+							}
+							p!(out, string(line.to_string()) nl);
+						}
+					}
+					if doc {
+						p!(out, str(" "));
+					}
+					p!(out, str("*/") nl);
+				}
+			}
+			// TODO: Keep common padding for multiple continous lines of single-line comments
+			// I.e
+			// ```
+			// #  Line1
+			// #    Line2
+			// ```
+			// Should be reformatted as
+			// ```
+			// # Line1
+			// #   Line2
+			// ```
+			// But currently comment formatter is not aware of continous comment lines, and reformats it as
+			// ```
+			// # Line1
+			// # Line2
+			// ```
+			TriviaKind::SingleLineHashComment => {
+				if matches!(loc, CommentLocation::ItemInline) {
+					p!(out, str(" "));
+				}
+				p!(out, str("# ") string(c.text().strip_prefix('#').expect("hash comment starts with #").trim().to_string()));
+				if !matches!(loc, CommentLocation::ItemInline) {
+					p!(out, nl);
+				}
+			}
+			TriviaKind::SingleLineSlashComment => {
+				if matches!(loc, CommentLocation::ItemInline) {
+					p!(out, str(" "));
+				}
+				p!(out, str("// ") string(c.text().strip_prefix("//").expect("comment starts with //").trim().to_string()));
+				if !matches!(loc, CommentLocation::ItemInline) {
+					p!(out, nl);
+				}
+			}
+			// Garbage in - garbage out
+			TriviaKind::ErrorCommentTooShort => p!(out, str("/*/")),
+			TriviaKind::ErrorCommentUnterminated => p!(out, string(c.text().to_string())),
+		}
+	}
+}

--- /dev/null
+++ b/crates/jrsonnet-formatter/src/lib.rs
@@ -0,0 +1,740 @@
+use std::{any::type_name, rc::Rc};
+
+use children::{children_between, trivia_before};
+use dprint_core::formatting::{
+	condition_helpers::is_multiple_lines, condition_resolvers::true_resolver,
+	ConditionResolverContext, LineNumber, PrintItems, PrintOptions,
+};
+use hi_doc::{Formatting, SnippetBuilder};
+use jrsonnet_rowan_parser::{
+	nodes::{
+		Arg, ArgsDesc, Assertion, BinaryOperator, Bind, CompSpec, Destruct, DestructArrayPart,
+		DestructRest, Expr, ExprBase, FieldName, ForSpec, IfSpec, ImportKind, Literal, Member,
+		Name, Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc, SourceFile, Stmt, Suffix, Text,
+		UnaryOperator, Visibility,
+	},
+	AstNode, AstToken as _, SyntaxToken,
+};
+
+use crate::{
+	children::trivia_after,
+	comments::{format_comments, CommentLocation},
+};
+
+mod children;
+mod comments;
+#[cfg(test)]
+mod tests;
+
+pub trait Printable {
+	fn print(&self, out: &mut PrintItems);
+}
+
+macro_rules! pi {
+	(@i; $($t:tt)*) => {{
+		#[allow(unused_mut)]
+		let mut o = dprint_core::formatting::PrintItems::new();
+		pi!(@s; o: $($t)*);
+		o
+	}};
+	(@s; $o:ident: str($e:expr $(,)?) $($t:tt)*) => {{
+		$o.push_string($e.to_owned());
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: string($e:expr $(,)?) $($t:tt)*) => {{
+		$o.push_string($e);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: nl $($t:tt)*) => {{
+		$o.push_signal(dprint_core::formatting::Signal::NewLine);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: tab $($t:tt)*) => {{
+		$o.push_signal(dprint_core::formatting::Signal::Tab);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: >i $($t:tt)*) => {{
+		$o.push_signal(dprint_core::formatting::Signal::StartIndent);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: <i $($t:tt)*) => {{
+		$o.push_signal(dprint_core::formatting::Signal::FinishIndent);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: info($v:expr) $($t:tt)*) => {{
+		$o.push_info($v);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: if($s:literal, $cond:expr, $($i:tt)*) $($t:tt)*) => {{
+		$o.push_condition(dprint_core::formatting::conditions::if_true(
+			$s,
+			$cond.clone(),
+			{
+				let mut o = PrintItems::new();
+				p!(o, $($i)*);
+				o
+			},
+		));
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: if_else($s:literal, $cond:expr, $($i:tt)*)($($e:tt)+) $($t:tt)*) => {{
+		$o.push_condition(dprint_core::formatting::conditions::if_true_or(
+			$s,
+			$cond.clone(),
+			{
+				let mut o = PrintItems::new();
+				p!(o, $($i)*);
+				o
+			},
+			{
+				let mut o = PrintItems::new();
+				p!(o, $($e)*);
+				o
+			},
+		));
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: if_not($s:literal, $cond:expr, $($e:tt)*) $($t:tt)*) => {{
+		$o.push_condition(dprint_core::formatting::conditions::if_true_or(
+			$s,
+			$cond.clone(),
+			{
+				let o = PrintItems::new();
+				o
+			},
+			{
+				let mut o = PrintItems::new();
+				p!(o, $($e)*);
+				o
+			},
+		));
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: {$expr:expr} $($t:tt)*) => {{
+		$expr.print($o);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: items($expr:expr) $($t:tt)*) => {{
+		$o.extend($expr);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: if ($e:expr)($($then:tt)*) $($t:tt)*) => {{
+		if $e {
+			pi!(@s; $o: $($then)*);
+		}
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: ifelse ($e:expr)($($then:tt)*)($($else:tt)*) $($t:tt)*) => {{
+		if $e {
+			pi!(@s; $o: $($then)*);
+		} else {
+			pi!(@s; $o: $($else)*);
+		}
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $i:ident:) => {}
+}
+macro_rules! p {
+	($o:ident, $($t:tt)*) => {
+		pi!(@s; $o: $($t)*)
+	};
+}
+pub(crate) use p;
+pub(crate) use pi;
+
+impl<P> Printable for Option<P>
+where
+	P: Printable,
+{
+	fn print(&self, out: &mut PrintItems) {
+		if let Some(v) = self {
+			v.print(out);
+		} else {
+			p!(
+				out,
+				string(format!(
+					"/*missing {}*/",
+					type_name::<P>().replace("jrsonnet_rowan_parser::generated::nodes::", "")
+				),)
+			);
+		}
+	}
+}
+
+impl Printable for SyntaxToken {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, string(self.to_string()));
+	}
+}
+
+impl Printable for Text {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, string(format!("{}", self)));
+	}
+}
+impl Printable for Number {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, string(format!("{}", self)));
+	}
+}
+
+impl Printable for Name {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, { self.ident_lit() });
+	}
+}
+
+impl Printable for DestructRest {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, str("..."));
+		if let Some(name) = self.into() {
+			p!(out, { name });
+		}
+	}
+}
+
+impl Printable for Destruct {
+	fn print(&self, out: &mut PrintItems) {
+		match self {
+			Self::DestructFull(f) => {
+				p!(out, { f.name() });
+			}
+			Self::DestructSkip(_) => p!(out, str("?")),
+			Self::DestructArray(a) => {
+				p!(out, str("[") >i nl);
+				for el in a.destruct_array_parts() {
+					match el {
+						DestructArrayPart::DestructArrayElement(e) => {
+							p!(out, {e.destruct()} str(",") nl);
+						}
+						DestructArrayPart::DestructRest(d) => {
+							p!(out, {d} str(",") nl);
+						}
+					}
+				}
+				p!(out, <i str("]"));
+			}
+			Self::DestructObject(o) => {
+				p!(out, str("{") >i nl);
+				for item in o.destruct_object_fields() {
+					p!(out, { item.field() });
+					if let Some(des) = item.destruct() {
+						p!(out, str(": ") {des});
+					}
+					if let Some(def) = item.expr() {
+						p!(out, str(" = ") {def});
+					}
+					p!(out, str(",") nl);
+				}
+				if let Some(rest) = o.destruct_rest() {
+					p!(out, {rest} nl);
+				}
+				p!(out, <i str("}"));
+			}
+		}
+	}
+}
+
+impl Printable for FieldName {
+	fn print(&self, out: &mut PrintItems) {
+		match self {
+			Self::FieldNameFixed(f) => {
+				if let Some(id) = f.id() {
+					p!(out, { id });
+				} else if let Some(str) = f.text() {
+					p!(out, { str });
+				} else {
+					p!(out, str("/*missing FieldName*/"));
+				}
+			}
+			Self::FieldNameDynamic(d) => {
+				p!(out, str("[") {d.expr()} str("]"));
+			}
+		}
+	}
+}
+
+impl Printable for Visibility {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, string(self.to_string()));
+	}
+}
+
+impl Printable for ObjLocal {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, str("local ") {self.bind()});
+	}
+}
+
+impl Printable for Assertion {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, str("assert ") {self.condition()});
+		if self.colon_token().is_some() || self.message().is_some() {
+			p!(out, str(": ") {self.message()});
+		}
+	}
+}
+
+impl Printable for ParamsDesc {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, str("(") >i nl);
+		for param in self.params() {
+			p!(out, { param.destruct() });
+			if param.assign_token().is_some() || param.expr().is_some() {
+				p!(out, str(" = ") {param.expr()});
+			}
+			p!(out, str(",") nl);
+		}
+		p!(out, <i str(")"));
+	}
+}
+impl Printable for ArgsDesc {
+	fn print(&self, out: &mut PrintItems) {
+		let start = LineNumber::new("start");
+		let end = LineNumber::new("end");
+		let multi_line = Rc::new(move |condition_context: &mut ConditionResolverContext| {
+			is_multiple_lines(condition_context, start, end).map(|v| !v)
+		});
+		p!(out, str("(") info(start) if("start args", multi_line, >i nl));
+		let (children, end_comments) = children_between::<Arg>(
+			self.syntax().clone(),
+			self.l_paren_token().map(Into::into).as_ref(),
+			self.r_paren_token().map(Into::into).as_ref(),
+			None,
+		);
+		let mut args = children.into_iter().peekable();
+		while let Some(ele) = args.next() {
+			if ele.should_start_with_newline {
+				p!(out, nl);
+			}
+			format_comments(&ele.before_trivia, CommentLocation::AboveItem, out);
+			let arg = ele.value;
+			if arg.name().is_some() || arg.assign_token().is_some() {
+				p!(out, {arg.name()} str(" = "));
+			}
+			let comma_between = if args.peek().is_some() {
+				true_resolver()
+			} else {
+				multi_line.clone()
+			};
+			p!(out, {arg.expr()} if("arg comma", comma_between, str(",") if_not("between args", multi_line, str(" "))));
+			format_comments(&ele.inline_trivia, CommentLocation::ItemInline, out);
+			p!(out, if("between args", multi_line, nl));
+		}
+		if end_comments.should_start_with_newline {
+			p!(out, nl);
+		}
+		format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);
+		p!(out, if("end args", multi_line, <i info(end)) str(")"));
+	}
+}
+impl Printable for SliceDesc {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, str("["));
+		if self.from().is_some() {
+			p!(out, { self.from() });
+		}
+		p!(out, str(":"));
+		if self.end().is_some() {
+			p!(out, { self.end().map(|e| e.expr()) });
+		}
+		// Keep only one : in case if we don't need step
+		if self.step().is_some() {
+			p!(out, str(":") {self.step().map(|e|e.expr())});
+		}
+		p!(out, str("]"));
+	}
+}
+
+impl Printable for Member {
+	fn print(&self, out: &mut PrintItems) {
+		match self {
+			Self::MemberBindStmt(b) => {
+				p!(out, { b.obj_local() });
+			}
+			Self::MemberAssertStmt(ass) => {
+				p!(out, { ass.assertion() });
+			}
+			Self::MemberFieldNormal(n) => {
+				p!(out, {n.field_name()} if(n.plus_token().is_some())({n.plus_token()}) {n.visibility()} str(" ") {n.expr()});
+			}
+			Self::MemberFieldMethod(m) => {
+				p!(out, {m.field_name()} {m.params_desc()} {m.visibility()} str(" ") {m.expr()});
+			}
+		}
+	}
+}
+
+impl Printable for ObjBody {
+	fn print(&self, out: &mut PrintItems) {
+		match self {
+			Self::ObjBodyComp(l) => {
+				let (children, mut end_comments) = children_between::<Member>(
+					l.syntax().clone(),
+					l.l_brace_token().map(Into::into).as_ref(),
+					Some(
+						&(l.comp_specs()
+							.next()
+							.expect("at least one spec is defined")
+							.syntax()
+							.clone())
+						.into(),
+					),
+					None,
+				);
+				let trailing_for_comp = end_comments.extract_trailing();
+				p!(out, str("{") >i nl);
+				for mem in children {
+					if mem.should_start_with_newline {
+						p!(out, nl);
+					}
+					format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);
+					p!(out, {mem.value} str(","));
+					format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);
+					p!(out, nl);
+				}
+
+				if end_comments.should_start_with_newline {
+					p!(out, nl);
+				}
+				format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);
+
+				let (compspecs, end_comments) = children_between::<CompSpec>(
+					l.syntax().clone(),
+					l.member_comps()
+						.last()
+						.map(|m| m.syntax().clone())
+						.map(Into::into)
+						.or_else(|| l.l_brace_token().map(Into::into))
+						.as_ref(),
+					l.r_brace_token().map(Into::into).as_ref(),
+					Some(trailing_for_comp),
+				);
+				for mem in compspecs {
+					if mem.should_start_with_newline {
+						p!(out, nl);
+					}
+					format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);
+					p!(out, { mem.value });
+					format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);
+				}
+				if end_comments.should_start_with_newline {
+					p!(out, nl);
+				}
+				format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);
+
+				p!(out, nl <i str("}"));
+			}
+			Self::ObjBodyMemberList(l) => {
+				let (children, end_comments) = children_between::<Member>(
+					l.syntax().clone(),
+					l.l_brace_token().map(Into::into).as_ref(),
+					l.r_brace_token().map(Into::into).as_ref(),
+					None,
+				);
+				if children.is_empty() && end_comments.is_empty() {
+					p!(out, str("{ }"));
+					return;
+				}
+				p!(out, str("{") >i nl);
+				for (i, mem) in children.into_iter().enumerate() {
+					if mem.should_start_with_newline && i != 0 {
+						p!(out, nl);
+					}
+					format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);
+					p!(out, {mem.value} str(","));
+					format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);
+					p!(out, nl);
+				}
+
+				if end_comments.should_start_with_newline {
+					p!(out, nl);
+				}
+				format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);
+				p!(out, <i str("}"));
+			}
+		}
+	}
+}
+impl Printable for UnaryOperator {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, string(self.text().to_string()));
+	}
+}
+impl Printable for BinaryOperator {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, string(self.text().to_string()));
+	}
+}
+impl Printable for Bind {
+	fn print(&self, out: &mut PrintItems) {
+		match self {
+			Self::BindDestruct(d) => {
+				p!(out, {d.into()} str(" = ") {d.value()});
+			}
+			Self::BindFunction(f) => {
+				p!(out, {f.name()} {f.params()} str(" = ") {f.value()});
+			}
+		}
+	}
+}
+impl Printable for Literal {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, string(self.syntax().to_string()));
+	}
+}
+impl Printable for ImportKind {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, string(self.syntax().to_string()));
+	}
+}
+impl Printable for ForSpec {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, str("for ") {self.bind()} str(" in ") {self.expr()});
+	}
+}
+impl Printable for IfSpec {
+	fn print(&self, out: &mut PrintItems) {
+		p!(out, str("if ") {self.expr()});
+	}
+}
+impl Printable for CompSpec {
+	fn print(&self, out: &mut PrintItems) {
+		match self {
+			Self::ForSpec(f) => f.print(out),
+			Self::IfSpec(i) => i.print(out),
+		}
+	}
+}
+impl Printable for Expr {
+	fn print(&self, out: &mut PrintItems) {
+		let (stmts, _ending) = children_between::<Stmt>(
+			self.syntax().clone(),
+			None,
+			self.expr_base()
+				.as_ref()
+				.map(ExprBase::syntax)
+				.cloned()
+				.map(Into::into)
+				.as_ref(),
+			None,
+		);
+		for stmt in stmts {
+			p!(out, { stmt.value });
+		}
+		p!(out, { self.expr_base() });
+		let (suffixes, _ending) = children_between::<Suffix>(
+			self.syntax().clone(),
+			self.expr_base()
+				.as_ref()
+				.map(ExprBase::syntax)
+				.cloned()
+				.map(Into::into)
+				.as_ref(),
+			None,
+			None,
+		);
+		for suffix in suffixes {
+			p!(out, { suffix.value });
+		}
+	}
+}
+impl Printable for Suffix {
+	fn print(&self, out: &mut PrintItems) {
+		match self {
+			Self::SuffixIndex(i) => {
+				if i.question_mark_token().is_some() {
+					p!(out, str("?"));
+				}
+				p!(out, str(".") {i.index()});
+			}
+			Self::SuffixIndexExpr(e) => {
+				if e.question_mark_token().is_some() {
+					p!(out, str(".?"));
+				}
+				p!(out, str("[") {e.index()} str("]"));
+			}
+			Self::SuffixSlice(d) => {
+				p!(out, { d.slice_desc() });
+			}
+			Self::SuffixApply(a) => {
+				p!(out, { a.args_desc() });
+			}
+		}
+	}
+}
+impl Printable for Stmt {
+	fn print(&self, out: &mut PrintItems) {
+		match self {
+			Self::StmtLocal(l) => {
+				let (binds, end_comments) = children_between::<Bind>(
+					l.syntax().clone(),
+					l.local_kw_token().map(Into::into).as_ref(),
+					l.semi_token().map(Into::into).as_ref(),
+					None,
+				);
+				if binds.len() == 1 {
+					let bind = &binds[0];
+					format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);
+					p!(out, str("local ") {bind.value});
+				// TODO: keep end_comments, child.inline_trivia somehow, force multiple locals formatting in case of presence?
+				} else {
+					p!(out,str("local") >i nl);
+					for bind in binds {
+						if bind.should_start_with_newline {
+							p!(out, nl);
+						}
+						format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);
+						p!(out, {bind.value} str(","));
+						format_comments(&bind.inline_trivia, CommentLocation::ItemInline, out);
+						p!(out, nl);
+					}
+					if end_comments.should_start_with_newline {
+						p!(out, nl);
+					}
+					format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);
+					p!(out,<i);
+				}
+				p!(out,str(";") nl);
+			}
+			Self::StmtAssert(a) => {
+				p!(out, {a.assertion()} str(";") nl);
+			}
+		}
+	}
+}
+impl Printable for ExprBase {
+	fn print(&self, out: &mut PrintItems) {
+		match self {
+			Self::ExprBinary(b) => {
+				p!(out, {b.lhs_work()} str(" ") {b.binary_operator()} str(" ") {b.rhs_work()});
+			}
+			Self::ExprUnary(u) => p!(out, {u.unary_operator()} {u.rhs()}),
+			// Self::ExprSlice(s) => {
+			// 	p!(new: {s.expr()} {s.slice_desc()})
+			// }
+			// Self::ExprIndex(i) => {
+			// 	p!(new: {i.expr()} str(".") {i.index()})
+			// }
+			// Self::ExprIndexExpr(i) => p!(new: {i.base()} str("[") {i.index()} str("]")),
+			// Self::ExprApply(a) => {
+			// 	let mut pi = p!(new: {a.expr()} {a.args_desc()});
+			// 	if a.tailstrict_kw_token().is_some() {
+			// 		p!(out,str(" tailstrict"));
+			// 	}
+			// 	pi
+			// }
+			Self::ExprObjExtend(ex) => {
+				p!(out, {ex.lhs_work()} str(" ") {ex.rhs_work()});
+			}
+			Self::ExprParened(p) => {
+				p!(out, str("(") {p.expr()} str(")"));
+			}
+			Self::ExprString(s) => p!(out, { s.text() }),
+			Self::ExprNumber(n) => p!(out, { n.number() }),
+			Self::ExprArray(a) => {
+				p!(out, str("[") >i nl);
+				for el in a.exprs() {
+					p!(out, {el} str(",") nl);
+				}
+				p!(out, <i str("]"));
+			}
+			Self::ExprObject(obj) => {
+				p!(out, { obj.obj_body() });
+			}
+			Self::ExprArrayComp(arr) => {
+				p!(out, str("[") {arr.expr()});
+				for spec in arr.comp_specs() {
+					p!(out, str(" ") {spec});
+				}
+				p!(out, str("]"));
+			}
+			Self::ExprImport(v) => {
+				p!(out, {v.import_kind()} str(" ") {v.text()});
+			}
+			Self::ExprVar(n) => p!(out, { n.name() }),
+			// Self::ExprLocal(l) => {
+			// }
+			Self::ExprIfThenElse(ite) => {
+				p!(out, str("if ") {ite.cond()} str(" then ") {ite.then().map(|t| t.expr())});
+				if ite.else_kw_token().is_some() || ite.else_().is_some() {
+					p!(out, str(" else ") {ite.else_().map(|t| t.expr())});
+				}
+			}
+			Self::ExprFunction(f) => p!(out, str("function") {f.params_desc()} nl {f.expr()}),
+			// Self::ExprAssert(a) => p!(new: {a.assertion()} str("; ") {a.expr()}),
+			Self::ExprError(e) => p!(out, str("error ") {e.expr()}),
+			Self::ExprLiteral(l) => {
+				p!(out, { l.literal() });
+			}
+		}
+	}
+}
+
+impl Printable for SourceFile {
+	fn print(&self, out: &mut PrintItems) {
+		let before = trivia_before(
+			self.syntax().clone(),
+			self.expr()
+				.map(|e| e.syntax().clone())
+				.map(Into::into)
+				.as_ref(),
+		);
+		let after = trivia_after(
+			self.syntax().clone(),
+			self.expr()
+				.map(|e| e.syntax().clone())
+				.map(Into::into)
+				.as_ref(),
+		);
+		format_comments(&before, CommentLocation::AboveItem, out);
+		p!(out, {self.expr()} nl);
+		format_comments(&after, CommentLocation::EndOfItems, out);
+	}
+}
+
+pub struct FormatOptions {
+	// 0 for hard tabs
+	pub indent: u8,
+}
+pub fn format(input: &str, opts: &FormatOptions) -> Result<String, SnippetBuilder> {
+	let (parsed, errors) = jrsonnet_rowan_parser::parse(input);
+	if !errors.is_empty() {
+		let mut builder = hi_doc::SnippetBuilder::new(input);
+		for error in errors {
+			builder
+				.error(hi_doc::Text::fragment(
+					format!("{:?}", error.error),
+					Formatting::default(),
+				))
+				.range(
+					error.range.start().into()
+						..=(usize::from(error.range.end()) - 1).max(error.range.start().into()),
+				)
+				.build();
+		}
+		// let snippet = builder.build();
+		return Err(builder);
+		// It is possible to recover from this failure, but the output may be broken, as formatter is free to skip
+		// ERROR rowan nodes.
+		// Recovery needs to be enabled for LSP, though.
+	}
+	Ok(dprint_core::formatting::format(
+		|| {
+			let mut out = PrintItems::new();
+			parsed.print(&mut out);
+			out
+		},
+		PrintOptions {
+			indent_width: if opts.indent == 0 {
+				// Reasonable max length for both 2 and 4 space sized tabs.
+				3
+			} else {
+				opts.indent
+			},
+			max_width: 100,
+			use_tabs: opts.indent == 0,
+			new_line_text: "\n",
+		},
+	))
+}

--- /dev/null
+++ b/crates/jrsonnet-formatter/src/snapshots/jrsonnet_fmt__tests__complex_comments_snapshot.snap
@@ -0,0 +1,53 @@
+---
+source: cmds/jrsonnet-fmt/src/tests.rs
+expression: "reformat(indoc!(\"{\n\t\t  comments: {\n\t\t\t_: '',\n\t\t\t//     Plain comment\n\t\t\ta: '',\n\n\t\t\t#    Plain comment with empty line before\n\t\t\tb: '',\n\t\t\t/*Single-line multiline comment\n\n\t\t\t*/\n\t\t\tc: '',\n\n\t\t\t/**Single-line multiline doc comment\n\n\t\t\t*/\n\t\t\tc: '',\n\n\t\t\t/**Multiline doc\n\t\t\tComment\n\t\t\t*/\n\t\t\tc: '',\n\n\t\t\t/*\n\n\tMulti-line\n\n\tcomment\n\t\t\t*/\n\t\t\td: '',\n\n\t\t\te: '', // Inline comment\n\n\t\t\tk: '',\n\n\t\t\t// Text after everything\n\t\t  },\n\t\t  comments2: {\n\t\t\tk: '',\n\t\t\t// Text after everything, but no newline above\n\t\t  },\n          spacing: {\n            a: '',\n\n            b: '',\n          },\n          noSpacing: {\n            a: '',\n            b: '',\n          },\n        }\"))"
+---
+{
+	comments: {
+		_: '',
+		// Plain comment
+		a: '',
+
+		# Plain comment with empty line before
+		b: '',
+		/* Single-line multiline comment */
+		c: '',
+
+		/**
+		 * Single-line multiline doc comment
+		 */
+		c: '',
+
+		/**
+		 * Multiline doc
+		 * Comment
+		 */
+		c: '',
+
+		/*
+		Multi-line
+
+		comment
+		*/
+		d: '',
+
+		e: '', // Inline comment
+
+		k: '',
+
+		// Text after everything
+	},
+	comments2: {
+		k: '',
+		// Text after everything, but no newline above
+	},
+	spacing: {
+		a: '',
+
+		b: '',
+	},
+	noSpacing: {
+		a: '',
+		b: '',
+	},
+}

--- /dev/null
+++ b/crates/jrsonnet-formatter/src/tests.rs
@@ -0,0 +1,79 @@
+use dprint_core::formatting::{PrintItems, PrintOptions};
+use indoc::indoc;
+
+use crate::Printable;
+
+fn reformat(input: &str) -> String {
+	let (source, _) = jrsonnet_rowan_parser::parse(input);
+
+	dprint_core::formatting::format(
+		|| {
+			let mut out = PrintItems::new();
+			source.print(&mut out);
+			out
+		},
+		PrintOptions {
+			indent_width: 2,
+			max_width: 100,
+			use_tabs: true,
+			new_line_text: "\n",
+		},
+	)
+}
+
+#[test]
+fn complex_comments_snapshot() {
+	insta::assert_snapshot!(reformat(indoc!(
+		"{
+		  comments: {
+			_: '',
+			//     Plain comment
+			a: '',
+
+			#    Plain comment with empty line before
+			b: '',
+			/*Single-line multiline comment
+
+			*/
+			c: '',
+
+			/**Single-line multiline doc comment
+
+			*/
+			c: '',
+
+			/**Multiline doc
+			Comment
+			*/
+			c: '',
+
+			/*
+
+	Multi-line
+
+	comment
+			*/
+			d: '',
+
+			e: '', // Inline comment
+
+			k: '',
+
+			// Text after everything
+		  },
+		  comments2: {
+			k: '',
+			// Text after everything, but no newline above
+		  },
+          spacing: {
+            a: '',
+
+            b: '',
+          },
+          noSpacing: {
+            a: '',
+            b: '',
+          },
+        }"
+	)));
+}