derive impl Display for NodeOrToken

src/utility_types.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 /// Convenience type to represent tree elements which may either be a node or a token.
 ///
 /// Used for both red and green tree, references to elements, ...
@@ -53,6 +55,15 @@ impl<N: Clone, T: Clone> NodeOrToken<&N, &T> {
     }
 }
 
+impl<N: fmt::Display, T: fmt::Display> fmt::Display for NodeOrToken<N, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            NodeOrToken::Node(node) => node.fmt(f),
+            NodeOrToken::Token(token) => token.fmt(f),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Direction {
     Next,

tests/basic.rs

@@ -1,6 +1,8 @@
 mod common;
 
-use common::{build_recursive, build_tree_with_cache, Element, SyntaxNode};
+use common::{
+    build_recursive, build_tree_with_cache, Element, SyntaxElement, SyntaxElementRef, SyntaxNode, SyntaxToken,
+};
 use cstree::{GreenNodeBuilder, NodeCache, SyntaxKind, TextRange};
 use lasso::{Resolver, Rodeo};
 
@@ -129,3 +131,15 @@ fn inline_resolver() {
         );
     }
 }
+
+#[test]
+fn assert_debug_display() {
+    use std::fmt;
+    fn f<T: fmt::Debug + fmt::Display>() {}
+
+    f::<SyntaxNode<(), lasso::Rodeo>>();
+    f::<SyntaxToken<(), lasso::Rodeo>>();
+    f::<SyntaxElement<(), lasso::Rodeo>>();
+    f::<SyntaxElementRef<'static, (), lasso::Rodeo>>();
+    f::<cstree::NodeOrToken<String, u128>>();
+}

tests/common.rs

@@ -2,6 +2,9 @@ use cstree::{GreenNode, GreenNodeBuilder, Language, NodeCache, SyntaxKind};
 use lasso::Interner;
 
 pub type SyntaxNode<D = (), R = ()> = cstree::SyntaxNode<TestLang, D, R>;
+pub type SyntaxToken<D = (), R = ()> = cstree::SyntaxToken<TestLang, D, R>;
+pub type SyntaxElement<D = (), R = ()> = cstree::SyntaxElement<TestLang, D, R>;
+pub type SyntaxElementRef<'a, D = (), R = ()> = cstree::SyntaxElementRef<'a, TestLang, D, R>;
 
 #[derive(Debug)]
 pub enum Element<'s> {