diff options
Diffstat (limited to 'src/yellow')
-rw-r--r-- | src/yellow/builder.rs | 15 | ||||
-rw-r--r-- | src/yellow/green.rs | 37 | ||||
-rw-r--r-- | src/yellow/mod.rs | 6 | ||||
-rw-r--r-- | src/yellow/red.rs | 34 | ||||
-rw-r--r-- | src/yellow/syntax.rs | 23 |
5 files changed, 54 insertions, 61 deletions
diff --git a/src/yellow/builder.rs b/src/yellow/builder.rs index 65cc97ff9..0f7ca45d7 100644 --- a/src/yellow/builder.rs +++ b/src/yellow/builder.rs | |||
@@ -1,7 +1,7 @@ | |||
1 | use { | 1 | use { |
2 | parser::Sink, | ||
3 | yellow::{GreenNode, GreenNodeBuilder, SyntaxError, SyntaxNode, SyntaxRoot}, | ||
2 | SyntaxKind, TextRange, TextUnit, | 4 | SyntaxKind, TextRange, TextUnit, |
3 | yellow::{SyntaxNode, SyntaxRoot, GreenNode, GreenNodeBuilder, SyntaxError}, | ||
4 | parser::Sink | ||
5 | }; | 5 | }; |
6 | 6 | ||
7 | pub(crate) struct GreenBuilder { | 7 | pub(crate) struct GreenBuilder { |
@@ -12,9 +12,7 @@ pub(crate) struct GreenBuilder { | |||
12 | errors: Vec<SyntaxError>, | 12 | errors: Vec<SyntaxError>, |
13 | } | 13 | } |
14 | 14 | ||
15 | impl GreenBuilder { | 15 | impl GreenBuilder {} |
16 | |||
17 | } | ||
18 | 16 | ||
19 | impl Sink for GreenBuilder { | 17 | impl Sink for GreenBuilder { |
20 | type Tree = SyntaxNode; | 18 | type Tree = SyntaxNode; |
@@ -53,7 +51,10 @@ impl Sink for GreenBuilder { | |||
53 | } | 51 | } |
54 | 52 | ||
55 | fn error(&mut self, message: String) { | 53 | fn error(&mut self, message: String) { |
56 | self.errors.push(SyntaxError { message, offset: self.pos }) | 54 | self.errors.push(SyntaxError { |
55 | message, | ||
56 | offset: self.pos, | ||
57 | }) | ||
57 | } | 58 | } |
58 | 59 | ||
59 | fn finish(self) -> SyntaxNode { | 60 | fn finish(self) -> SyntaxNode { |
@@ -61,5 +62,3 @@ impl Sink for GreenBuilder { | |||
61 | SyntaxNode::new_owned(root) | 62 | SyntaxNode::new_owned(root) |
62 | } | 63 | } |
63 | } | 64 | } |
64 | |||
65 | |||
diff --git a/src/yellow/green.rs b/src/yellow/green.rs index cb9dff128..507e4d57e 100644 --- a/src/yellow/green.rs +++ b/src/yellow/green.rs | |||
@@ -1,5 +1,8 @@ | |||
1 | use std::sync::Arc; | 1 | use std::sync::Arc; |
2 | use {SyntaxKind::{self, *}, TextUnit}; | 2 | use { |
3 | SyntaxKind::{self, *}, | ||
4 | TextUnit, | ||
5 | }; | ||
3 | 6 | ||
4 | #[derive(Clone, Debug)] | 7 | #[derive(Clone, Debug)] |
5 | pub(crate) enum GreenNode { | 8 | pub(crate) enum GreenNode { |
@@ -36,9 +39,7 @@ impl GreenNode { | |||
36 | fn go(node: &GreenNode, buff: &mut String) { | 39 | fn go(node: &GreenNode, buff: &mut String) { |
37 | match node { | 40 | match node { |
38 | GreenNode::Leaf(l) => buff.push_str(&l.text()), | 41 | GreenNode::Leaf(l) => buff.push_str(&l.text()), |
39 | GreenNode::Branch(b) => { | 42 | GreenNode::Branch(b) => b.children().iter().for_each(|child| go(child, buff)), |
40 | b.children().iter().for_each(|child| go(child, buff)) | ||
41 | } | ||
42 | } | 43 | } |
43 | } | 44 | } |
44 | } | 45 | } |
@@ -71,7 +72,6 @@ impl GreenNodeBuilder { | |||
71 | } | 72 | } |
72 | } | 73 | } |
73 | 74 | ||
74 | |||
75 | #[test] | 75 | #[test] |
76 | fn assert_send_sync() { | 76 | fn assert_send_sync() { |
77 | fn f<T: Send + Sync>() {} | 77 | fn f<T: Send + Sync>() {} |
@@ -80,14 +80,8 @@ fn assert_send_sync() { | |||
80 | 80 | ||
81 | #[derive(Clone, Debug)] | 81 | #[derive(Clone, Debug)] |
82 | pub(crate) enum GreenLeaf { | 82 | pub(crate) enum GreenLeaf { |
83 | Whitespace { | 83 | Whitespace { newlines: u8, spaces: u8 }, |
84 | newlines: u8, | 84 | Token { kind: SyntaxKind, text: Arc<str> }, |
85 | spaces: u8, | ||
86 | }, | ||
87 | Token { | ||
88 | kind: SyntaxKind, | ||
89 | text: Arc<str>, | ||
90 | }, | ||
91 | } | 85 | } |
92 | 86 | ||
93 | impl GreenLeaf { | 87 | impl GreenLeaf { |
@@ -96,10 +90,16 @@ impl GreenLeaf { | |||
96 | let newlines = text.bytes().take_while(|&b| b == b'\n').count(); | 90 | let newlines = text.bytes().take_while(|&b| b == b'\n').count(); |
97 | let spaces = text[newlines..].bytes().take_while(|&b| b == b' ').count(); | 91 | let spaces = text[newlines..].bytes().take_while(|&b| b == b' ').count(); |
98 | if newlines + spaces == text.len() && newlines <= N_NEWLINES && spaces <= N_SPACES { | 92 | if newlines + spaces == text.len() && newlines <= N_NEWLINES && spaces <= N_SPACES { |
99 | return GreenLeaf::Whitespace { newlines: newlines as u8, spaces: spaces as u8 }; | 93 | return GreenLeaf::Whitespace { |
94 | newlines: newlines as u8, | ||
95 | spaces: spaces as u8, | ||
96 | }; | ||
100 | } | 97 | } |
101 | } | 98 | } |
102 | GreenLeaf::Token { kind, text: text.to_owned().into_boxed_str().into() } | 99 | GreenLeaf::Token { |
100 | kind, | ||
101 | text: text.to_owned().into_boxed_str().into(), | ||
102 | } | ||
103 | } | 103 | } |
104 | 104 | ||
105 | pub(crate) fn kind(&self) -> SyntaxKind { | 105 | pub(crate) fn kind(&self) -> SyntaxKind { |
@@ -141,7 +141,11 @@ pub(crate) struct GreenBranch { | |||
141 | impl GreenBranch { | 141 | impl GreenBranch { |
142 | fn new(kind: SyntaxKind, children: Vec<GreenNode>) -> GreenBranch { | 142 | fn new(kind: SyntaxKind, children: Vec<GreenNode>) -> GreenBranch { |
143 | let text_len = children.iter().map(|x| x.text_len()).sum::<TextUnit>(); | 143 | let text_len = children.iter().map(|x| x.text_len()).sum::<TextUnit>(); |
144 | GreenBranch { text_len, kind, children } | 144 | GreenBranch { |
145 | text_len, | ||
146 | kind, | ||
147 | children, | ||
148 | } | ||
145 | } | 149 | } |
146 | 150 | ||
147 | pub fn kind(&self) -> SyntaxKind { | 151 | pub fn kind(&self) -> SyntaxKind { |
@@ -156,4 +160,3 @@ impl GreenBranch { | |||
156 | self.children.as_slice() | 160 | self.children.as_slice() |
157 | } | 161 | } |
158 | } | 162 | } |
159 | |||
diff --git a/src/yellow/mod.rs b/src/yellow/mod.rs index 89eefc98b..cada65d2f 100644 --- a/src/yellow/mod.rs +++ b/src/yellow/mod.rs | |||
@@ -1,12 +1,12 @@ | |||
1 | mod builder; | ||
1 | mod green; | 2 | mod green; |
2 | mod red; | 3 | mod red; |
3 | mod syntax; | 4 | mod syntax; |
4 | mod builder; | ||
5 | 5 | ||
6 | pub use self::syntax::{SyntaxNode, SyntaxNodeRef}; | ||
6 | pub(crate) use self::{ | 7 | pub(crate) use self::{ |
8 | builder::GreenBuilder, | ||
7 | green::{GreenNode, GreenNodeBuilder}, | 9 | green::{GreenNode, GreenNodeBuilder}, |
8 | red::RedNode, | 10 | red::RedNode, |
9 | syntax::{SyntaxError, SyntaxRoot}, | 11 | syntax::{SyntaxError, SyntaxRoot}, |
10 | builder::GreenBuilder, | ||
11 | }; | 12 | }; |
12 | pub use self::syntax::{SyntaxNode, SyntaxNodeRef}; | ||
diff --git a/src/yellow/red.rs b/src/yellow/red.rs index 3f0ddd04c..8907100e4 100644 --- a/src/yellow/red.rs +++ b/src/yellow/red.rs | |||
@@ -1,11 +1,5 @@ | |||
1 | use std::{ | 1 | use std::{ptr, sync::RwLock}; |
2 | ptr, | 2 | use {yellow::GreenNode, TextUnit}; |
3 | sync::RwLock, | ||
4 | }; | ||
5 | use { | ||
6 | TextUnit, | ||
7 | yellow::GreenNode, | ||
8 | }; | ||
9 | 3 | ||
10 | #[derive(Debug)] | 4 | #[derive(Debug)] |
11 | pub(crate) struct RedNode { | 5 | pub(crate) struct RedNode { |
@@ -22,9 +16,7 @@ struct ParentData { | |||
22 | } | 16 | } |
23 | 17 | ||
24 | impl RedNode { | 18 | impl RedNode { |
25 | pub fn new_root( | 19 | pub fn new_root(green: GreenNode) -> RedNode { |
26 | green: GreenNode, | ||
27 | ) -> RedNode { | ||
28 | RedNode::new(green, None) | 20 | RedNode::new(green, None) |
29 | } | 21 | } |
30 | 22 | ||
@@ -42,13 +34,14 @@ impl RedNode { | |||
42 | RedNode::new(green, Some(parent_data)) | 34 | RedNode::new(green, Some(parent_data)) |
43 | } | 35 | } |
44 | 36 | ||
45 | fn new( | 37 | fn new(green: GreenNode, parent: Option<ParentData>) -> RedNode { |
46 | green: GreenNode, | ||
47 | parent: Option<ParentData>, | ||
48 | ) -> RedNode { | ||
49 | let n_children = green.children().len(); | 38 | let n_children = green.children().len(); |
50 | let children = (0..n_children).map(|_| None).collect(); | 39 | let children = (0..n_children).map(|_| None).collect(); |
51 | RedNode { green, parent, children: RwLock::new(children) } | 40 | RedNode { |
41 | green, | ||
42 | parent, | ||
43 | children: RwLock::new(children), | ||
44 | } | ||
52 | } | 45 | } |
53 | 46 | ||
54 | pub(crate) fn green(&self) -> &GreenNode { | 47 | pub(crate) fn green(&self) -> &GreenNode { |
@@ -75,12 +68,15 @@ impl RedNode { | |||
75 | if children[idx].is_none() { | 68 | if children[idx].is_none() { |
76 | let green_children = self.green.children(); | 69 | let green_children = self.green.children(); |
77 | let start_offset = self.start_offset() | 70 | let start_offset = self.start_offset() |
78 | + green_children[..idx].iter().map(|x| x.text_len()).sum::<TextUnit>(); | 71 | + green_children[..idx] |
79 | let child = RedNode::new_child(green_children[idx].clone(), self.into(), start_offset, idx); | 72 | .iter() |
73 | .map(|x| x.text_len()) | ||
74 | .sum::<TextUnit>(); | ||
75 | let child = | ||
76 | RedNode::new_child(green_children[idx].clone(), self.into(), start_offset, idx); | ||
80 | children[idx] = Some(child) | 77 | children[idx] = Some(child) |
81 | } | 78 | } |
82 | children[idx].as_ref().unwrap().into() | 79 | children[idx].as_ref().unwrap().into() |
83 | |||
84 | } | 80 | } |
85 | 81 | ||
86 | pub(crate) fn parent(&self) -> Option<ptr::NonNull<RedNode>> { | 82 | pub(crate) fn parent(&self) -> Option<ptr::NonNull<RedNode>> { |
diff --git a/src/yellow/syntax.rs b/src/yellow/syntax.rs index 64af08236..19a9b8ac2 100644 --- a/src/yellow/syntax.rs +++ b/src/yellow/syntax.rs | |||
@@ -1,17 +1,12 @@ | |||
1 | use std::{ | 1 | use std::{fmt, ops::Deref, ptr, sync::Arc}; |
2 | fmt, | ||
3 | sync::Arc, | ||
4 | ptr, | ||
5 | ops::Deref, | ||
6 | }; | ||
7 | 2 | ||
8 | use { | 3 | use { |
9 | TextRange, TextUnit, | 4 | yellow::{GreenNode, RedNode}, |
10 | SyntaxKind::{self, *}, | 5 | SyntaxKind::{self, *}, |
11 | yellow::{RedNode, GreenNode}, | 6 | TextRange, TextUnit, |
12 | }; | 7 | }; |
13 | 8 | ||
14 | pub trait TreeRoot: Deref<Target=SyntaxRoot> + Clone {} | 9 | pub trait TreeRoot: Deref<Target = SyntaxRoot> + Clone {} |
15 | impl TreeRoot for Arc<SyntaxRoot> {} | 10 | impl TreeRoot for Arc<SyntaxRoot> {} |
16 | impl<'a> TreeRoot for &'a SyntaxRoot {} | 11 | impl<'a> TreeRoot for &'a SyntaxRoot {} |
17 | 12 | ||
@@ -50,7 +45,10 @@ impl SyntaxNode<Arc<SyntaxRoot>> { | |||
50 | pub(crate) fn new_owned(root: SyntaxRoot) -> Self { | 45 | pub(crate) fn new_owned(root: SyntaxRoot) -> Self { |
51 | let root = Arc::new(root); | 46 | let root = Arc::new(root); |
52 | let red_weak = ptr::NonNull::from(&root.red); | 47 | let red_weak = ptr::NonNull::from(&root.red); |
53 | SyntaxNode { root, red: red_weak } | 48 | SyntaxNode { |
49 | root, | ||
50 | red: red_weak, | ||
51 | } | ||
54 | } | 52 | } |
55 | } | 53 | } |
56 | 54 | ||
@@ -68,10 +66,7 @@ impl<ROOT: TreeRoot> SyntaxNode<ROOT> { | |||
68 | 66 | ||
69 | pub fn range(&self) -> TextRange { | 67 | pub fn range(&self) -> TextRange { |
70 | let red = self.red(); | 68 | let red = self.red(); |
71 | TextRange::offset_len( | 69 | TextRange::offset_len(red.start_offset(), red.green().text_len()) |
72 | red.start_offset(), | ||
73 | red.green().text_len(), | ||
74 | ) | ||
75 | } | 70 | } |
76 | 71 | ||
77 | pub fn text(&self) -> String { | 72 | pub fn text(&self) -> String { |