Deglobify

Author: matklad

src/api.rs

@@ -104,7 +104,7 @@ impl<L: Language> fmt::Display for SyntaxToken<L> {
     }
 }
 
-pub(crate) type SyntaxElement<L> = NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>;
+pub type SyntaxElement<L> = NodeOrToken<SyntaxNode<L>, SyntaxToken<L>>;
 
 impl<L: Language> From<cursor::SyntaxElement> for SyntaxElement<L> {
     fn from(raw: cursor::SyntaxElement) -> SyntaxElement<L> {

src/cursor.rs

@@ -7,8 +7,8 @@ use std::{
 };
 
 use crate::{
-    Children, Direction, GreenElementRef, GreenNode, GreenToken, NodeOrToken, SmolStr, SyntaxText,
-    TextRange, TextUnit, TokenAtOffset, WalkEvent,
+    green::GreenElementRef, Children, Direction, GreenNode, GreenToken, NodeOrToken, SmolStr,
+    SyntaxText, TextRange, TextUnit, TokenAtOffset, WalkEvent,
 };
 
 /// SyntaxKind is a type tag for each token or node.

src/green.rs

@@ -3,6 +3,35 @@ mod token;
 mod element;
 mod builder;
 
-pub(crate) use self::element::*;
+pub(crate) use self::element::GreenElementRef;
+use self::element::{GreenElement, PackedGreenElement};
 
-pub use self::{builder::*, node::*, token::*};
+pub use self::{
+    builder::{Checkpoint, GreenNodeBuilder, NodeCache},
+    node::{Children, GreenNode},
+    token::GreenToken,
+};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn assert_send_sync() {
+        fn f<T: Send + Sync>() {}
+        f::<GreenNode>();
+        f::<GreenToken>();
+        f::<GreenElement>();
+        f::<PackedGreenElement>();
+    }
+
+    #[test]
+    fn test_size_of() {
+        use std::mem::size_of;
+
+        eprintln!("GreenNode          {}", size_of::<GreenNode>());
+        eprintln!("GreenToken         {}", size_of::<GreenToken>());
+        eprintln!("GreenElement       {}", size_of::<GreenElement>());
+        eprintln!("PackedGreenElement {}", size_of::<PackedGreenElement>());
+    }
+}

src/green/builder.rs

@@ -1,11 +1,15 @@
-use crate::{cursor::SyntaxKind, NodeOrToken, SmolStr};
+use rustc_hash::FxHashSet;
 
-use super::*;
+use crate::{
+    cursor::SyntaxKind,
+    green::{GreenElement, GreenNode, GreenToken},
+    NodeOrToken, SmolStr,
+};
 
 #[derive(Default, Debug)]
 pub struct NodeCache {
-    nodes: rustc_hash::FxHashSet<GreenNode>,
-    tokens: rustc_hash::FxHashSet<GreenToken>,
+    nodes: FxHashSet<GreenNode>,
+    tokens: FxHashSet<GreenToken>,
 }
 
 impl NodeCache {

src/green/element.rs

@@ -2,14 +2,17 @@ use std::{fmt, hash, mem};
 
 use thin_dst::ErasedPtr;
 
-use crate::{cursor::SyntaxKind, NodeOrToken, TextUnit};
+use crate::{
+    cursor::SyntaxKind,
+    green::{GreenNode, GreenToken},
+    NodeOrToken, TextUnit,
+};
 
-use super::*;
-
-pub(crate) type GreenElement = NodeOrToken<GreenNode, GreenToken>;
+pub(super) type GreenElement = NodeOrToken<GreenNode, GreenToken>;
 pub(crate) type GreenElementRef<'a> = NodeOrToken<&'a GreenNode, &'a GreenToken>;
+
 #[repr(transparent)]
-pub(crate) struct PackedGreenElement {
+pub(super) struct PackedGreenElement {
     ptr: ErasedPtr,
 }
 

src/green/node.rs

@@ -2,9 +2,11 @@ use std::{iter::FusedIterator, slice, sync::Arc};
 
 use thin_dst::{ThinArc, ThinData};
 
-use crate::{cursor::SyntaxKind, TextUnit};
-
-use super::*;
+use crate::{
+    cursor::SyntaxKind,
+    green::{GreenElement, GreenElementRef, PackedGreenElement},
+    TextUnit,
+};
 
 #[repr(align(2))] // NB: this is an at-least annotation
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]

src/green/token.rs

@@ -4,14 +4,14 @@ use crate::{cursor::SyntaxKind, SmolStr, TextUnit};
 
 #[repr(align(2))] // NB: this is an at-least annotation
 #[derive(Debug, PartialEq, Eq, Hash)]
-pub(crate) struct GreenTokenData {
+struct GreenTokenData {
     kind: SyntaxKind,
     text: SmolStr,
 }
 
 /// Leaf node in the immutable tree.
 pub struct GreenToken {
-    pub(super) ptr: ptr::NonNull<GreenTokenData>,
+    ptr: ptr::NonNull<GreenTokenData>,
 }
 
 unsafe impl Send for GreenToken {} // where GreenTokenData: Send + Sync

src/lib.rs

@@ -12,53 +12,24 @@
 mod green;
 #[allow(unsafe_code)]
 pub mod cursor;
+
 pub mod api;
 mod syntax_text;
 mod utility_types;
 #[cfg(feature = "serde1")]
 mod serde_impls;
 
-#[allow(unused)]
-use green::{GreenElement, GreenElementRef, PackedGreenElement};
-
 // Reexport types for working with strings. We might be too opinionated about
 // these, as a custom interner might work better, but `SmolStr` is a pretty good
 // default.
 pub use smol_str::SmolStr;
 pub use text_unit::{TextRange, TextUnit};
 
 pub use crate::{
-    api::*,
+    api::{
+        Language, SyntaxElement, SyntaxElementChildren, SyntaxNode, SyntaxNodeChildren, SyntaxToken,
+    },
     green::{Checkpoint, Children, GreenNode, GreenNodeBuilder, GreenToken},
     syntax_text::SyntaxText,
     utility_types::{Direction, NodeOrToken, TokenAtOffset, WalkEvent},
 };
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn assert_send_sync() {
-        fn f<T: Send + Sync>() {}
-        f::<GreenNode>();
-        f::<GreenToken>();
-        f::<GreenElement>();
-        f::<PackedGreenElement>();
-        f::<green::GreenTokenData>();
-    }
-
-    #[test]
-    fn test_size_of() {
-        use std::mem::size_of;
-
-        eprintln!("GreenNode          {}", size_of::<GreenNode>());
-        eprintln!("GreenToken         {}", size_of::<GreenToken>());
-        eprintln!("GreenElement       {}", size_of::<GreenElement>());
-        eprintln!("PackedGreenElement {}", size_of::<PackedGreenElement>());
-        eprintln!();
-        eprintln!("SyntaxNode    {}", size_of::<cursor::SyntaxNode>());
-        eprintln!("SyntaxToken   {}", size_of::<cursor::SyntaxToken>());
-        eprintln!("SyntaxElement {}", size_of::<cursor::SyntaxElement>());
-    }
-}