feat: improved reformat edits

Cargo.toml

@@ -23,7 +23,9 @@ regex = "1.5.6"
 rnix = "0.10.2"
 serde = "1.0.138"
 serde_json = "1.0.82"
-nixpkgs-fmt-rnix = "1.2.0"
+nixpkgs-fmt = { git = "https://github.com/nix-community/nixpkgs-fmt" }
+smol_str = "0.1.17"
+textedit-merge = "0.2.1"
 
 [dev-dependencies]
 stoppable_thread = "0.2.1"

src/main.rs

@@ -59,7 +59,10 @@ use std::{
  str::FromStr,
 };
 
-use crate::error::AppError;
+use crate::{
+ error::AppError,
+ utils::{atom_edit_to_tuple, tuple_to_text_edit},
+};
 
 type Error = Box<dyn std::error::Error>;
 
@@ -210,11 +213,21 @@ impl App {
  self.reply(Response::new_ok(id, document_links));
  } else if let Some((id, params)) = cast::<Formatting>(&mut req) {
  let changes = if let Some((ast, code, _)) = self.files.get(&params.text_document.uri) {
- let fmt = nixpkgs_fmt::reformat_node(&ast.node());
- vec![TextEdit {
- range: utils::range(&code, TextRange::up_to(ast.node().text().len())),
- new_text: fmt.text().to_string(),
- }]
+ let (spacing_edits, indent_edits) = nixpkgs_fmt::reformat_edits(&ast.node());
+ let merged_edits = textedit_merge::merge(
+ &spacing_edits
+ .into_iter()
+ .map(atom_edit_to_tuple)
+ .collect::<Vec<(std::ops::Range<usize>, _)>>(),
+ &indent_edits
+ .into_iter()
+ .map(atom_edit_to_tuple)
+ .collect::<Vec<(std::ops::Range<usize>, _)>>(),
+ );
+ merged_edits
+ .into_iter()
+ .map(|t| tuple_to_text_edit(t, &code))
+ .collect::<Vec<_>>()
  } else {
  Vec::new()
  };

src/tests.rs

@@ -263,6 +263,138 @@ fn test_rename() {
  handle.stop().join().expect("Failed to gracefully terminate LSP worker thread!");
 }
 
+#[test]
+fn test_reformat_integration() {
+ let urlpath = "file:///code/default.nix";
+ let input = r#"{
+ f = { x
+ , y
+ }: body;
+
+ testAllTrue = expr: {inherit expr;expected=map (x: true) expr; };
+}
+"#;
+ let (client, handle) = prepare_integration_test(input, urlpath);
+
+ let r = Request {
+ id: RequestId::from(23),
+ method: String::from("textDocument/formatting"),
+ params: json!({
+ "textDocument": {
+ "uri": "file:///code/default.nix",
+ },
+ "options": {
+ // Tab size isn't respected yet
+ "tabSize": 37,
+ "insertSpaces": true
+ }
+ })
+ };
+ client.sender.send(r.into()).expect("Cannot send reformat request!");
+
+ expect_diagnostics(&client);
+
+ let msg = recv_msg(&client);
+ let hover_json = coerce_response(msg).result.expect("Expected reformat response!");
+ let edits = hover_json;
+ let expected = json!([
+ {
+ "newText": "\n ",
+ "range": {
+ "start": {
+ "character": 5,
+ "line": 1
+ },
+ "end": {
+ "character": 6,
+ "line": 1
+ }
+ }
+ },
+ {
+ "newText": "\n ",
+ "range": {
+ "start": {
+ "character": 9,
+ "line": 1
+ },
+ "end": {
+ "character": 2,
+ "line": 2
+ }
+ }
+ },
+ {
+ "newText": "\n ",
+ "range": {
+ "start": {
+ "character": 5,
+ "line": 2
+ },
+ "end": {
+ "character": 6,
+ "line": 3
+ }
+ }
+ },
+ {
+ "newText": " ",
+ "range": {
+ "start": {
+ "character": 23,
+ "line": 5
+ },
+ "end": {
+ "character": 23,
+ "line": 5
+ }
+ }
+ },
+ {
+ "newText": " ",
+ "range": {
+ "start": {
+ "character": 36,
+ "line": 5
+ },
+ "end": {
+ "character": 36,
+ "line": 5
+ }
+ }
+ },
+ {
+ "newText": " ",
+ "range": {
+ "start": {
+ "character": 44,
+ "line": 5
+ },
+ "end": {
+ "character": 44,
+ "line": 5
+ }
+ }
+ },
+ {
+ "newText": " ",
+ "range": {
+ "start": {
+ "character": 45,
+ "line": 5
+ },
+ "end": {
+ "character": 45,
+ "line": 5
+ }
+ }
+ }
+ ]);
+ assert_eq!(edits, expected);
+
+ handle.stop().join().expect("Failed to gracefully terminate LSP worker thread!");
+}
+
 #[test]
 fn attrs_simple() {
  let code = "{ x = 1; y = 2; }.x";

src/utils.rs

@@ -1,9 +1,11 @@
 use lsp_types::*;
+use nixpkgs_fmt::AtomEdit;
 use rnix::{types::*, SyntaxNode, TextRange, TextSize, TokenAtOffset};
 use std::{
  collections::HashMap,
  convert::TryFrom,
  fmt::{Debug, Display, Formatter, Result},
+ ops,
  path::PathBuf,
  rc::Rc,
 };
@@ -323,9 +325,30 @@ pub fn selection_ranges(root: &SyntaxNode, content: &str, pos: Position) -> Opti
  root.map(|b| *b)
 }
 
+/// Convert an AtomEdit to a tuple whose first element is `atom_edit`'s delete range, and whose
+/// second element is a String with the same contents as `atom_edit`'s insert value.
+pub fn atom_edit_to_tuple(atom_edit: AtomEdit) -> (ops::Range<usize>, String) {
+ let r: std::ops::Range<usize> = atom_edit.delete.start().into()..atom_edit.delete.end().into();
+ (r, atom_edit.insert.to_string())
+}
+
+pub fn tuple_to_text_edit(tup: (ops::Range<usize>, String), code: &str) -> TextEdit {
+ TextEdit {
+ range: range(
+ code,
+ TextRange::new(
+ TextSize::from(tup.0.start as u32),
+ TextSize::from(tup.0.end as u32),
+ ),
+ ),
+ new_text: tup.1,
+ }
+}
+
 #[cfg(test)]
 mod tests {
  use super::*;
+ use smol_str::SmolStr;
 
  #[test]
  fn test_get_offset_from_nix_expr() {
@@ -467,4 +490,34 @@ mod tests {
  let ident_ = ident.unwrap();
  assert_eq!(vec!["a"], ident_.path);
  }
+
+ #[test]
+ fn test_atom_edit_to_tuple() {
+ let atom_edits = vec![
+ AtomEdit {
+ delete: TextRange::new(TextSize::from(5), TextSize::from(9)),
+ insert: SmolStr::from("hello world"),
+ },
+ AtomEdit {
+ delete: TextRange::new(TextSize::from(11), TextSize::from(11)),
+ insert: SmolStr::from("the quick brown fox"),
+ },
+ AtomEdit {
+ delete: TextRange::new(TextSize::from(115698), TextSize::from(126498)),
+ insert: SmolStr::from("a string"),
+ },
+ ];
+ let expected = vec![
+ (5..9, String::from("hello world")),
+ (11..11, String::from("the quick brown fox")),
+ (115698..126498, String::from("a string")),
+ ];
+ assert_eq!(
+ atom_edits
+ .into_iter()
+ .map(atom_edit_to_tuple)
+ .collect::<Vec<(ops::Range<usize>, String)>>(),
+ expected
+ );
+ }
 }