aboutsummaryrefslogtreecommitdiff
path: root/crates
diff options
context:
space:
mode:
Diffstat (limited to 'crates')
-rw-r--r--crates/assert_eq_text/Cargo.toml7
-rw-r--r--crates/assert_eq_text/src/lib.rs25
-rw-r--r--crates/libeditor/Cargo.toml2
-rw-r--r--crates/libeditor/src/code_actions.rs33
-rw-r--r--crates/libeditor/src/edit.rs93
-rw-r--r--crates/libeditor/src/lib.rs7
-rw-r--r--crates/libeditor/tests/test.rs52
-rw-r--r--crates/libsyntax2/Cargo.toml2
-rw-r--r--crates/libsyntax2/src/algo/mod.rs48
-rw-r--r--crates/libsyntax2/src/syntax_kinds/mod.rs2
-rw-r--r--crates/libsyntax2/src/yellow/syntax.rs11
-rw-r--r--crates/libsyntax2/tests/test/main.rs48
12 files changed, 273 insertions, 57 deletions
diff --git a/crates/assert_eq_text/Cargo.toml b/crates/assert_eq_text/Cargo.toml
new file mode 100644
index 000000000..21858dfd3
--- /dev/null
+++ b/crates/assert_eq_text/Cargo.toml
@@ -0,0 +1,7 @@
1[package]
2name = "assert_eq_text"
3version = "0.1.0"
4authors = ["Aleksey Kladov <[email protected]>"]
5
6[dependencies]
7difference = "2.0.0"
diff --git a/crates/assert_eq_text/src/lib.rs b/crates/assert_eq_text/src/lib.rs
new file mode 100644
index 000000000..ed942d81a
--- /dev/null
+++ b/crates/assert_eq_text/src/lib.rs
@@ -0,0 +1,25 @@
1extern crate difference;
2pub use self::difference::Changeset as __Changeset;
3
4#[macro_export]
5macro_rules! assert_eq_text {
6 ($expected:expr, $actual:expr) => {{
7 let expected = $expected;
8 let actual = $actual;
9 if expected != actual {
10 let changeset = $crate::__Changeset::new(actual, expected, "\n");
11 println!("Expected:\n{}\n\nActual:\n{}\nDiff:{}\n", expected, actual, changeset);
12 panic!("text differs");
13 }
14 }};
15 ($expected:expr, $actual:expr, $($tt:tt)*) => {{
16 let expected = $expected;
17 let actual = $actual;
18 if expected != actual {
19 let changeset = $crate::__Changeset::new(actual, expected, "\n");
20 println!("Expected:\n{}\n\nActual:\n{}\n\nDiff:\n{}\n", expected, actual, changeset);
21 println!($($tt)*);
22 panic!("text differs");
23 }
24 }};
25}
diff --git a/crates/libeditor/Cargo.toml b/crates/libeditor/Cargo.toml
index d6423979b..fe688bc20 100644
--- a/crates/libeditor/Cargo.toml
+++ b/crates/libeditor/Cargo.toml
@@ -7,4 +7,6 @@ publish = false
7[dependencies] 7[dependencies]
8itertools = "0.7.8" 8itertools = "0.7.8"
9superslice = "0.1.0" 9superslice = "0.1.0"
10
10libsyntax2 = { path = "../libsyntax2" } 11libsyntax2 = { path = "../libsyntax2" }
12assert_eq_text = { path = "../assert_eq_text" }
diff --git a/crates/libeditor/src/code_actions.rs b/crates/libeditor/src/code_actions.rs
new file mode 100644
index 000000000..7c9874588
--- /dev/null
+++ b/crates/libeditor/src/code_actions.rs
@@ -0,0 +1,33 @@
1use {TextUnit, File, EditBuilder, Edit};
2use libsyntax2::{
3 ast::AstNode,
4 SyntaxKind::COMMA,
5 SyntaxNodeRef,
6 algo::{
7 Direction, siblings,
8 find_leaf_at_offset,
9 },
10};
11
12pub fn flip_comma<'a>(file: &'a File, offset: TextUnit) -> Option<impl FnOnce() -> Edit + 'a> {
13 let syntax = file.syntax();
14 let syntax = syntax.as_ref();
15
16 let comma = find_leaf_at_offset(syntax, offset).find(|leaf| leaf.kind() == COMMA)?;
17 let left = non_trivia_sibling(comma, Direction::Backward)?;
18 let right = non_trivia_sibling(comma, Direction::Forward)?;
19 Some(move || {
20 let mut edit = EditBuilder::new();
21 edit.replace(left.range(), right.text());
22 edit.replace(right.range(), left.text());
23 edit.finish()
24 })
25}
26
27fn non_trivia_sibling(node: SyntaxNodeRef, direction: Direction) -> Option<SyntaxNodeRef> {
28 siblings(node, direction)
29 .skip(1)
30 .find(|node| !node.kind().is_trivia())
31}
32
33
diff --git a/crates/libeditor/src/edit.rs b/crates/libeditor/src/edit.rs
new file mode 100644
index 000000000..163ecf6de
--- /dev/null
+++ b/crates/libeditor/src/edit.rs
@@ -0,0 +1,93 @@
1use {TextRange, TextUnit};
2
3#[derive(Debug)]
4pub struct Edit {
5 pub atoms: Vec<AtomEdit>,
6}
7
8#[derive(Debug)]
9pub struct AtomEdit {
10 pub delete: TextRange,
11 pub insert: String,
12}
13
14#[derive(Debug)]
15pub struct EditBuilder {
16 atoms: Vec<AtomEdit>
17}
18
19impl EditBuilder {
20 pub fn new() -> EditBuilder {
21 EditBuilder { atoms: Vec::new() }
22 }
23
24 pub fn replace(&mut self, range: TextRange, replacement: String) {
25 let range = self.translate(range);
26 self.atoms.push(AtomEdit { delete: range, insert: replacement })
27 }
28
29 pub fn delete(&mut self, range: TextRange) {
30 self.replace(range, String::new());
31 }
32
33 pub fn insert(&mut self, offset: TextUnit, text: String) {
34 self.replace(TextRange::offset_len(offset, 0.into()), text)
35 }
36
37 pub fn finish(self) -> Edit {
38 Edit { atoms: self.atoms }
39 }
40
41 fn translate(&self, range: TextRange) -> TextRange {
42 let mut range = range;
43 for atom in self.atoms.iter() {
44 range = atom.apply_to_range(range)
45 .expect("conflicting edits");
46 }
47 range
48 }
49}
50
51impl Edit {
52 pub fn apply(&self, text: &str) -> String {
53 let mut text = text.to_owned();
54 for atom in self.atoms.iter() {
55 text = atom.apply(&text);
56 }
57 text
58 }
59}
60
61impl AtomEdit {
62 fn apply(&self, text: &str) -> String {
63 let prefix = &text[
64 TextRange::from_to(0.into(), self.delete.start())
65 ];
66 let suffix = &text[
67 TextRange::from_to(self.delete.end(), TextUnit::of_str(text))
68 ];
69 let mut res = String::with_capacity(prefix.len() + self.insert.len() + suffix.len());
70 res.push_str(prefix);
71 res.push_str(&self.insert);
72 res.push_str(suffix);
73 res
74 }
75
76 fn apply_to_position(&self, pos: TextUnit) -> Option<TextUnit> {
77 if pos <= self.delete.start() {
78 return Some(pos);
79 }
80 if pos < self.delete.end() {
81 return None;
82 }
83 Some(pos - self.delete.len() + TextUnit::of_str(&self.insert))
84 }
85
86 fn apply_to_range(&self, range: TextRange) -> Option<TextRange> {
87 Some(TextRange::from_to(
88 self.apply_to_position(range.start())?,
89 self.apply_to_position(range.end())?,
90 ))
91 }
92}
93
diff --git a/crates/libeditor/src/lib.rs b/crates/libeditor/src/lib.rs
index 013d27450..103f32190 100644
--- a/crates/libeditor/src/lib.rs
+++ b/crates/libeditor/src/lib.rs
@@ -1,9 +1,12 @@
1extern crate libsyntax2; 1extern crate libsyntax2;
2extern crate superslice; 2extern crate superslice;
3extern crate itertools;
3 4
4mod extend_selection; 5mod extend_selection;
5mod symbols; 6mod symbols;
6mod line_index; 7mod line_index;
8mod edit;
9mod code_actions;
7 10
8use libsyntax2::{ 11use libsyntax2::{
9 ast::{self, NameOwner}, 12 ast::{self, NameOwner},
@@ -15,7 +18,9 @@ pub use libsyntax2::{File, TextRange, TextUnit};
15pub use self::{ 18pub use self::{
16 line_index::{LineIndex, LineCol}, 19 line_index::{LineIndex, LineCol},
17 extend_selection::extend_selection, 20 extend_selection::extend_selection,
18 symbols::{FileSymbol, file_symbols} 21 symbols::{FileSymbol, file_symbols},
22 edit::{EditBuilder, Edit},
23 code_actions::{flip_comma},
19}; 24};
20 25
21#[derive(Debug)] 26#[derive(Debug)]
diff --git a/crates/libeditor/tests/test.rs b/crates/libeditor/tests/test.rs
index dedca49a4..369854fed 100644
--- a/crates/libeditor/tests/test.rs
+++ b/crates/libeditor/tests/test.rs
@@ -1,9 +1,16 @@
1extern crate libeditor; 1extern crate libeditor;
2extern crate libsyntax2;
2extern crate itertools; 3extern crate itertools;
4#[macro_use]
5extern crate assert_eq_text;
3 6
4use std::fmt; 7use std::fmt;
5use itertools::Itertools; 8use itertools::Itertools;
6use libeditor::{File, highlight, runnables, extend_selection, TextRange, file_symbols}; 9use libsyntax2::AstNode;
10use libeditor::{
11 File, TextUnit, TextRange,
12 highlight, runnables, extend_selection, file_symbols, flip_comma,
13};
7 14
8#[test] 15#[test]
9fn test_extend_selection() { 16fn test_extend_selection() {
@@ -27,13 +34,13 @@ fn main() {}
27"#); 34"#);
28 let hls = highlight(&file); 35 let hls = highlight(&file);
29 dbg_eq( 36 dbg_eq(
30 &hls,
31 r#"[HighlightedRange { range: [1; 11), tag: "comment" }, 37 r#"[HighlightedRange { range: [1; 11), tag: "comment" },
32 HighlightedRange { range: [12; 14), tag: "keyword" }, 38 HighlightedRange { range: [12; 14), tag: "keyword" },
33 HighlightedRange { range: [15; 19), tag: "function" }, 39 HighlightedRange { range: [15; 19), tag: "function" },
34 HighlightedRange { range: [29; 36), tag: "text" }, 40 HighlightedRange { range: [29; 36), tag: "text" },
35 HighlightedRange { range: [38; 50), tag: "string" }, 41 HighlightedRange { range: [38; 50), tag: "string" },
36 HighlightedRange { range: [52; 54), tag: "literal" }]"# 42 HighlightedRange { range: [52; 54), tag: "literal" }]"#,
43 &hls,
37 ); 44 );
38} 45}
39 46
@@ -51,10 +58,10 @@ fn test_foo() {}
51"#); 58"#);
52 let runnables = runnables(&file); 59 let runnables = runnables(&file);
53 dbg_eq( 60 dbg_eq(
54 &runnables,
55 r#"[Runnable { range: [1; 13), kind: Bin }, 61 r#"[Runnable { range: [1; 13), kind: Bin },
56 Runnable { range: [15; 39), kind: Test { name: "test_foo" } }, 62 Runnable { range: [15; 39), kind: Test { name: "test_foo" } },
57 Runnable { range: [41; 75), kind: Test { name: "test_foo" } }]"#, 63 Runnable { range: [41; 75), kind: Test { name: "test_foo" } }]"#,
64 &runnables,
58 ) 65 )
59} 66}
60 67
@@ -76,7 +83,6 @@ const C: i32 = 92;
76"#); 83"#);
77 let symbols = file_symbols(&file); 84 let symbols = file_symbols(&file);
78 dbg_eq( 85 dbg_eq(
79 &symbols,
80 r#"[FileSymbol { parent: None, name: "Foo", name_range: [8; 11), node_range: [1; 26), kind: STRUCT }, 86 r#"[FileSymbol { parent: None, name: "Foo", name_range: [8; 11), node_range: [1; 26), kind: STRUCT },
81 FileSymbol { parent: None, name: "m", name_range: [32; 33), node_range: [28; 53), kind: MODULE }, 87 FileSymbol { parent: None, name: "m", name_range: [32; 33), node_range: [28; 53), kind: MODULE },
82 FileSymbol { parent: Some(1), name: "bar", name_range: [43; 46), node_range: [40; 51), kind: FUNCTION }, 88 FileSymbol { parent: Some(1), name: "bar", name_range: [43; 46), node_range: [40; 51), kind: FUNCTION },
@@ -84,6 +90,19 @@ const C: i32 = 92;
84 FileSymbol { parent: None, name: "T", name_range: [81; 82), node_range: [76; 88), kind: TYPE_ITEM }, 90 FileSymbol { parent: None, name: "T", name_range: [81; 82), node_range: [76; 88), kind: TYPE_ITEM },
85 FileSymbol { parent: None, name: "S", name_range: [96; 97), node_range: [89; 108), kind: STATIC_ITEM }, 91 FileSymbol { parent: None, name: "S", name_range: [96; 97), node_range: [89; 108), kind: STATIC_ITEM },
86 FileSymbol { parent: None, name: "C", name_range: [115; 116), node_range: [109; 127), kind: CONST_ITEM }]"#, 92 FileSymbol { parent: None, name: "C", name_range: [115; 116), node_range: [109; 127), kind: CONST_ITEM }]"#,
93 &symbols,
94 )
95}
96
97#[test]
98fn test_swap_comma() {
99 check_modification(
100 "fn foo(x: i32,<|> y: Result<(), ()>) {}",
101 "fn foo(y: Result<(), ()>, x: i32) {}",
102 &|file, offset| {
103 let edit = flip_comma(file, offset).unwrap()();
104 edit.apply(&file.syntax().text())
105 },
87 ) 106 )
88} 107}
89 108
@@ -91,8 +110,27 @@ fn file(text: &str) -> File {
91 File::parse(text) 110 File::parse(text)
92} 111}
93 112
94fn dbg_eq(actual: &impl fmt::Debug, expected: &str) { 113fn dbg_eq(expected: &str, actual: &impl fmt::Debug) {
95 let actual = format!("{:?}", actual); 114 let actual = format!("{:?}", actual);
96 let expected = expected.lines().map(|l| l.trim()).join(" "); 115 let expected = expected.lines().map(|l| l.trim()).join(" ");
97 assert_eq!(actual, expected); 116 assert_eq!(expected, actual);
117}
118
119fn check_modification(
120 before: &str,
121 after: &str,
122 f: &impl Fn(&File, TextUnit) -> String,
123) {
124 let cursor = "<|>";
125 let cursor_pos = match before.find(cursor) {
126 None => panic!("before text should contain cursor marker"),
127 Some(pos) => pos,
128 };
129 let mut text = String::with_capacity(before.len() - cursor.len());
130 text.push_str(&before[..cursor_pos]);
131 text.push_str(&before[cursor_pos + cursor.len()..]);
132 let cursor_pos = TextUnit::from(cursor_pos as u32);
133 let file = file(&text);
134 let actual = f(&file, cursor_pos);
135 assert_eq_text!(after, &actual);
98} 136}
diff --git a/crates/libsyntax2/Cargo.toml b/crates/libsyntax2/Cargo.toml
index 5a76ea82b..4c4040fe5 100644
--- a/crates/libsyntax2/Cargo.toml
+++ b/crates/libsyntax2/Cargo.toml
@@ -12,4 +12,4 @@ drop_bomb = "0.1.4"
12parking_lot = "0.6.0" 12parking_lot = "0.6.0"
13 13
14[dev-dependencies] 14[dev-dependencies]
15difference = "2.0.0" 15assert_eq_text = { path = "../assert_eq_text" }
diff --git a/crates/libsyntax2/src/algo/mod.rs b/crates/libsyntax2/src/algo/mod.rs
index 263b58d97..6efdff12f 100644
--- a/crates/libsyntax2/src/algo/mod.rs
+++ b/crates/libsyntax2/src/algo/mod.rs
@@ -74,7 +74,6 @@ impl<'f> Iterator for LeafAtOffset<'f> {
74 } 74 }
75} 75}
76 76
77
78pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRef { 77pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRef {
79 assert!(is_subrange(root.range(), range)); 78 assert!(is_subrange(root.range(), range));
80 let (left, right) = match ( 79 let (left, right) = match (
@@ -88,31 +87,33 @@ pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRe
88 common_ancestor(left, right) 87 common_ancestor(left, right)
89} 88}
90 89
91fn common_ancestor<'a>(n1: SyntaxNodeRef<'a>, n2: SyntaxNodeRef<'a>) -> SyntaxNodeRef<'a> {
92 for p in ancestors(n1) {
93 if ancestors(n2).any(|a| a == p) {
94 return p;
95 }
96 }
97 panic!("Can't find common ancestor of {:?} and {:?}", n1, n2)
98}
99
100pub fn ancestors<'a>(node: SyntaxNodeRef<'a>) -> impl Iterator<Item=SyntaxNodeRef<'a>> { 90pub fn ancestors<'a>(node: SyntaxNodeRef<'a>) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
101 Ancestors(Some(node)) 91 generate(Some(node), |&node| node.parent())
102} 92}
103 93
104#[derive(Debug)] 94#[derive(Debug)]
105struct Ancestors<'a>(Option<SyntaxNodeRef<'a>>); 95pub enum Direction {
96 Forward,
97 Backward,
98}
106 99
107impl<'a> Iterator for Ancestors<'a> { 100pub fn siblings<'a>(
108 type Item = SyntaxNodeRef<'a>; 101 node: SyntaxNodeRef<'a>,
102 direction: Direction
103) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
104 generate(Some(node), move |&node| match direction {
105 Direction::Forward => node.next_sibling(),
106 Direction::Backward => node.prev_sibling(),
107 })
108}
109 109
110 fn next(&mut self) -> Option<Self::Item> { 110fn common_ancestor<'a>(n1: SyntaxNodeRef<'a>, n2: SyntaxNodeRef<'a>) -> SyntaxNodeRef<'a> {
111 self.0.take().map(|n| { 111 for p in ancestors(n1) {
112 self.0 = n.parent(); 112 if ancestors(n2).any(|a| a == p) {
113 n 113 return p;
114 }) 114 }
115 } 115 }
116 panic!("Can't find common ancestor of {:?} and {:?}", n1, n2)
116} 117}
117 118
118fn contains_offset_nonstrict(range: TextRange, offset: TextUnit) -> bool { 119fn contains_offset_nonstrict(range: TextRange, offset: TextUnit) -> bool {
@@ -122,3 +123,12 @@ fn contains_offset_nonstrict(range: TextRange, offset: TextUnit) -> bool {
122fn is_subrange(range: TextRange, subrange: TextRange) -> bool { 123fn is_subrange(range: TextRange, subrange: TextRange) -> bool {
123 range.start() <= subrange.start() && subrange.end() <= range.end() 124 range.start() <= subrange.start() && subrange.end() <= range.end()
124} 125}
126
127fn generate<T>(seed: Option<T>, step: impl Fn(&T) -> Option<T>) -> impl Iterator<Item=T> {
128 ::itertools::unfold(seed, move |slot| {
129 slot.take().map(|curr| {
130 *slot = step(&curr);
131 curr
132 })
133 })
134}
diff --git a/crates/libsyntax2/src/syntax_kinds/mod.rs b/crates/libsyntax2/src/syntax_kinds/mod.rs
index ed4fa5d4d..332cd13ac 100644
--- a/crates/libsyntax2/src/syntax_kinds/mod.rs
+++ b/crates/libsyntax2/src/syntax_kinds/mod.rs
@@ -17,7 +17,7 @@ pub(crate) struct SyntaxInfo {
17} 17}
18 18
19impl SyntaxKind { 19impl SyntaxKind {
20 pub(crate) fn is_trivia(self) -> bool { 20 pub fn is_trivia(self) -> bool {
21 match self { 21 match self {
22 WHITESPACE | COMMENT | DOC_COMMENT => true, 22 WHITESPACE | COMMENT | DOC_COMMENT => true,
23 _ => false, 23 _ => false,
diff --git a/crates/libsyntax2/src/yellow/syntax.rs b/crates/libsyntax2/src/yellow/syntax.rs
index a22275ed9..00f76e51c 100644
--- a/crates/libsyntax2/src/yellow/syntax.rs
+++ b/crates/libsyntax2/src/yellow/syntax.rs
@@ -101,6 +101,17 @@ impl<R: TreeRoot> SyntaxNode<R> {
101 }) 101 })
102 } 102 }
103 103
104 pub fn prev_sibling(&self) -> Option<SyntaxNode<R>> {
105 let red = self.red();
106 let parent = self.parent()?;
107 let prev_sibling_idx = red.index_in_parent()?.checked_sub(1)?;
108 let sibling_red = parent.red().get_child(prev_sibling_idx)?;
109 Some(SyntaxNode {
110 root: self.root.clone(),
111 red: sibling_red,
112 })
113 }
114
104 pub fn is_leaf(&self) -> bool { 115 pub fn is_leaf(&self) -> bool {
105 self.first_child().is_none() 116 self.first_child().is_none()
106 } 117 }
diff --git a/crates/libsyntax2/tests/test/main.rs b/crates/libsyntax2/tests/test/main.rs
index 18e5bc4d4..64d080dfd 100644
--- a/crates/libsyntax2/tests/test/main.rs
+++ b/crates/libsyntax2/tests/test/main.rs
@@ -1,5 +1,6 @@
1extern crate libsyntax2; 1extern crate libsyntax2;
2extern crate difference; 2#[macro_use]
3extern crate assert_eq_text;
3 4
4use std::{ 5use std::{
5 fs, 6 fs,
@@ -7,8 +8,6 @@ use std::{
7 fmt::Write, 8 fmt::Write,
8}; 9};
9 10
10use difference::Changeset;
11
12#[test] 11#[test]
13fn lexer_tests() { 12fn lexer_tests() {
14 dir_tests(&["lexer"], |text| { 13 dir_tests(&["lexer"], |text| {
@@ -63,10 +62,26 @@ pub fn dir_tests<F>(paths: &[&str], f: F)
63 } 62 }
64} 63}
65 64
65const REWRITE: bool = false;
66
66fn assert_equal_text(expected: &str, actual: &str, path: &Path) { 67fn assert_equal_text(expected: &str, actual: &str, path: &Path) {
67 if expected != actual { 68 if expected == actual {
68 print_difference(expected, actual, path) 69 return;
70 }
71 let dir = project_dir();
72 let path = path.strip_prefix(&dir).unwrap_or_else(|_| path);
73 if expected.trim() == actual.trim() {
74 println!("whitespace difference, rewriting");
75 println!("file: {}\n", path.display());
76 fs::write(path, actual).unwrap();
77 return;
78 }
79 if REWRITE {
80 println!("rewriting {}", path.display());
81 fs::write(path, actual).unwrap();
82 return;
69 } 83 }
84 assert_eq_text!(expected, actual, "file: {}", path.display());
70} 85}
71 86
72fn collect_tests(paths: &[&str]) -> Vec<PathBuf> { 87fn collect_tests(paths: &[&str]) -> Vec<PathBuf> {
@@ -92,29 +107,6 @@ fn test_from_dir(dir: &Path) -> Vec<PathBuf> {
92 acc 107 acc
93} 108}
94 109
95const REWRITE: bool = false;
96
97fn print_difference(expected: &str, actual: &str, path: &Path) {
98 let dir = project_dir();
99 let path = path.strip_prefix(&dir).unwrap_or_else(|_| path);
100 if expected.trim() == actual.trim() {
101 println!("whitespace difference, rewriting");
102 println!("file: {}\n", path.display());
103 fs::write(path, actual).unwrap();
104 return;
105 }
106 if REWRITE {
107 println!("rewriting {}", path.display());
108 fs::write(path, actual).unwrap();
109 return;
110 }
111 let changeset = Changeset::new(actual, expected, "\n");
112 println!("Expected:\n{}\n\nActual:\n{}\n", expected, actual);
113 print!("{}", changeset);
114 println!("file: {}\n", path.display());
115 panic!("Comparison failed")
116}
117
118fn project_dir() -> PathBuf { 110fn project_dir() -> PathBuf {
119 let dir = env!("CARGO_MANIFEST_DIR"); 111 let dir = env!("CARGO_MANIFEST_DIR");
120 PathBuf::from(dir) 112 PathBuf::from(dir)