grammar: Make UseTree less ultra-janky

compiler/cl-ast/src/ast.rs

@@ -228,15 +228,17 @@ pub enum ImplKind {
 /// An import of nonlocal [Item]s
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Use {
+    pub absolute: bool,
     pub tree: UseTree,
 }
 
 /// A tree of [Item] imports
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum UseTree {
-    Tree(Path, Vec<UseTree>),
-    Alias(Path, Identifier),
-    Path(Path),
+    Tree(Vec<UseTree>),
+    Path(PathPart, Box<UseTree>),
+    Alias(Identifier, Identifier),
+    Name(Identifier),
     Glob,
 }
 

compiler/cl-ast/src/ast_impl.rs

@@ -283,20 +283,22 @@ mod display {
 
     impl Display for Use {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            let Self { tree } = self;
-            write!(f, "use {tree}")
+            let Self { absolute, tree } = self;
+            if *absolute {
+                write!(f, "use ::{tree}")
+            } else {
+                write!(f, "use {tree}")
+            }
         }
     }
 
     impl Display for UseTree {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
-                UseTree::Tree(path, tree) => {
-                    write!(f, "{path}")?;
-                    separate(tree, ", ")(f.delimit(INLINE_BRACES))
-                }
+                UseTree::Tree(tree) => separate(tree, ", ")(f.delimit(INLINE_BRACES)),
+                UseTree::Path(path, rest) => write!(f, "{path}::{rest}"),
                 UseTree::Alias(path, name) => write!(f, "{path} as {name}"),
-                UseTree::Path(path) => write!(f, "{path}"),
+                UseTree::Name(name) => write!(f, "{name}"),
                 UseTree::Glob => write!(f, "*"),
             }
         }

compiler/cl-ast/src/ast_visitor/fold.rs

@@ -159,8 +159,8 @@ pub trait Fold {
         or_fold_impl_kind(self, kind)
     }
     fn fold_use(&mut self, u: Use) -> Use {
-        let Use { tree } = u;
-        Use { tree: self.fold_use_tree(tree) }
+        let Use { absolute, tree } = u;
+        Use { absolute, tree: self.fold_use_tree(tree) }
     }
     fn fold_use_tree(&mut self, tree: UseTree) -> UseTree {
         or_fold_use_tree(self, tree)
@@ -468,16 +468,19 @@ pub fn or_fold_impl_kind<F: Fold + ?Sized>(folder: &mut F, kind: ImplKind) -> Im
 #[inline]
 pub fn or_fold_use_tree<F: Fold + ?Sized>(folder: &mut F, tree: UseTree) -> UseTree {
     match tree {
-        UseTree::Tree(path, tree) => UseTree::Tree(
-            folder.fold_path(path),
+        UseTree::Tree(tree) => UseTree::Tree(
             tree.into_iter()
                 .map(|tree| folder.fold_use_tree(tree))
                 .collect(),
         ),
+        UseTree::Path(path, rest) => UseTree::Path(
+            folder.fold_path_part(path),
+            Box::new(folder.fold_use_tree(*rest)),
+        ),
         UseTree::Alias(path, name) => {
-            UseTree::Alias(folder.fold_path(path), folder.fold_identifier(name))
+            UseTree::Alias(folder.fold_identifier(path), folder.fold_identifier(name))
         }
-        UseTree::Path(path) => UseTree::Path(folder.fold_path(path)),
+        UseTree::Name(name) => UseTree::Name(folder.fold_identifier(name)),
         UseTree::Glob => UseTree::Glob,
     }
 }

compiler/cl-ast/src/ast_visitor/visit.rs

@@ -131,7 +131,7 @@ pub trait Visit<'a>: Sized {
         or_visit_impl_kind(self, target)
     }
     fn visit_use(&mut self, u: &'a Use) {
-        let Use { tree } = u;
+        let Use { absolute: _, tree } = u;
         self.visit_use_tree(tree);
     }
     fn visit_use_tree(&mut self, tree: &'a UseTree) {
@@ -386,15 +386,20 @@ pub fn or_visit_impl_kind<'a, V: Visit<'a>>(visitor: &mut V, target: &'a ImplKin
 
 pub fn or_visit_use_tree<'a, V: Visit<'a>>(visitor: &mut V, tree: &'a UseTree) {
     match tree {
-        UseTree::Tree(path, tree) => {
-            visitor.visit_path(path);
+        UseTree::Tree(tree) => {
             tree.iter().for_each(|tree| visitor.visit_use_tree(tree));
         }
+        UseTree::Path(path, rest) => {
+            visitor.visit_path_part(path);
+            visitor.visit_use_tree(rest)
+        }
         UseTree::Alias(path, name) => {
-            visitor.visit_path(path);
+            visitor.visit_identifier(path);
+            visitor.visit_identifier(name);
+        }
+        UseTree::Name(name) => {
             visitor.visit_identifier(name);
         }
-        UseTree::Path(path) => visitor.visit_path(path),
         UseTree::Glob => {}
     }
 }