WIP: move Visitor into wdl-analysis

Author: a-frantz

wdl-analysis/src/lib.rs

@@ -20,7 +20,74 @@ mod rules;
 pub mod stdlib;
 pub mod types;
 mod validation;
+mod visitor;
 
 pub use analyzer::*;
 pub use rules::*;
 pub use validation::*;
+pub use visitor::*;
+
+use wdl_ast::SyntaxToken;
+use wdl_ast::SyntaxKind;
+use wdl_ast::SyntaxNode;
+use wdl_ast::Direction;
+use std::collections::HashSet;
+
+/// The prefix of `except` comments.
+pub const EXCEPT_COMMENT_PREFIX: &str = "#@ except:";
+
+/// An extension trait for syntax nodes.
+pub trait SyntaxNodeExt {
+    /// Gets an iterator over the `@except` comments for a syntax node.
+    fn except_comments(&self) -> impl Iterator<Item = SyntaxToken> + '_;
+
+    /// Gets the AST node's rule exceptions set.
+    ///
+    /// The set is the comma-delimited list of rule identifiers that follows a
+    /// `#@ except:` comment.
+    fn rule_exceptions(&self) -> HashSet<String>;
+
+    /// Determines if a given rule id is excepted for the syntax node.
+    fn is_rule_excepted(&self, id: &str) -> bool;
+}
+
+impl SyntaxNodeExt for SyntaxNode {
+    fn except_comments(&self) -> impl Iterator<Item = SyntaxToken> + '_ {
+        self.siblings_with_tokens(Direction::Prev)
+            .skip(1)
+            .map_while(|s| {
+                if s.kind() == SyntaxKind::Whitespace || s.kind() == SyntaxKind::Comment {
+                    s.into_token()
+                } else {
+                    None
+                }
+            })
+            .filter(|t| t.kind() == SyntaxKind::Comment)
+    }
+
+    fn rule_exceptions(&self) -> HashSet<String> {
+        let mut set = HashSet::default();
+        for comment in self.except_comments() {
+            if let Some(ids) = comment.text().strip_prefix(EXCEPT_COMMENT_PREFIX) {
+                for id in ids.split(',') {
+                    let id = id.trim();
+                    set.insert(id.to_string());
+                }
+            }
+        }
+
+        set
+    }
+
+    fn is_rule_excepted(&self, id: &str) -> bool {
+        for comment in self.except_comments() {
+            if let Some(ids) = comment.text().strip_prefix(EXCEPT_COMMENT_PREFIX) {
+                if ids.split(',').any(|i| i.trim() == id) {
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+}

wdl-ast/src/visitor.rs renamed to wdl-analysis/src/visitor.rs

@@ -24,45 +24,56 @@
 use std::sync::Arc;
 
 use rowan::WalkEvent;
-use wdl_grammar::SyntaxElement;
-
-use crate::AstToken;
-use crate::Comment;
-use crate::Diagnostic;
-use crate::Document;
-use crate::SupportedVersion;
-use crate::SyntaxKind;
-use crate::SyntaxNode;
+use wdl_ast::SyntaxElement;
+
+use wdl_ast::AstToken;
+use wdl_ast::Comment;
+use wdl_ast::Diagnostic;
+use wdl_ast::Document;
+use wdl_ast::SupportedVersion;
+use wdl_ast::SyntaxKind;
+use wdl_ast::SyntaxNode;
 use crate::SyntaxNodeExt;
-use crate::VersionStatement;
-use crate::VisitReason;
-use crate::Whitespace;
-use crate::v1::BoundDecl;
-use crate::v1::CallStatement;
-use crate::v1::CommandSection;
-use crate::v1::CommandText;
-use crate::v1::ConditionalStatement;
-use crate::v1::Expr;
-use crate::v1::ImportStatement;
-use crate::v1::InputSection;
-use crate::v1::MetadataArray;
-use crate::v1::MetadataObject;
-use crate::v1::MetadataObjectItem;
-use crate::v1::MetadataSection;
-use crate::v1::OutputSection;
-use crate::v1::ParameterMetadataSection;
-use crate::v1::Placeholder;
-use crate::v1::RequirementsSection;
-use crate::v1::RuntimeItem;
-use crate::v1::RuntimeSection;
-use crate::v1::ScatterStatement;
-use crate::v1::StringText;
-use crate::v1::StructDefinition;
-use crate::v1::TaskDefinition;
-use crate::v1::TaskHintsSection;
-use crate::v1::UnboundDecl;
-use crate::v1::WorkflowDefinition;
-use crate::v1::WorkflowHintsSection;
+use wdl_ast::VersionStatement;
+use wdl_ast::Whitespace;
+use wdl_ast::v1::BoundDecl;
+use wdl_ast::v1::CallStatement;
+use wdl_ast::v1::CommandSection;
+use wdl_ast::v1::CommandText;
+use wdl_ast::v1::ConditionalStatement;
+use wdl_ast::v1::Expr;
+use wdl_ast::v1::ImportStatement;
+use wdl_ast::v1::InputSection;
+use wdl_ast::v1::MetadataArray;
+use wdl_ast::v1::MetadataObject;
+use wdl_ast::v1::MetadataObjectItem;
+use wdl_ast::v1::MetadataSection;
+use wdl_ast::v1::OutputSection;
+use wdl_ast::v1::ParameterMetadataSection;
+use wdl_ast::v1::Placeholder;
+use wdl_ast::v1::RequirementsSection;
+use wdl_ast::v1::RuntimeItem;
+use wdl_ast::v1::RuntimeSection;
+use wdl_ast::v1::ScatterStatement;
+use wdl_ast::v1::StringText;
+use wdl_ast::v1::StructDefinition;
+use wdl_ast::v1::TaskDefinition;
+use wdl_ast::v1::TaskHintsSection;
+use wdl_ast::v1::UnboundDecl;
+use wdl_ast::v1::WorkflowDefinition;
+use wdl_ast::v1::WorkflowHintsSection;
+
+/// Represents the reason an AST node has been visited.
+///
+/// Each node is visited exactly once, but the visitor will receive
+/// a call for entering the node and a call for exiting the node.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum VisitReason {
+    /// The visit has entered the node.
+    Enter,
+    /// The visit has exited the node.
+    Exit,
+}
 
 /// Represents a collection of validation diagnostics.
 ///
@@ -652,3 +663,11 @@ pub(crate) fn visit<V: Visitor>(root: &SyntaxNode, diagnostics: &mut Diagnostics
         }
     }
 }
+
+impl Document<SyntaxNode> {
+    /// Visits the document with a pre-order traversal using the provided
+    /// visitor to visit each element in the document.
+    pub fn visit<V: Visitor>(&self, diagnostics: &mut Diagnostics, visitor: &mut V) {
+        visit(&self.0, diagnostics, visitor)
+    }
+}

wdl-ast/src/lib.rs

@@ -16,7 +16,6 @@
 //! ```rust
 //! # let source = "version 1.1\nworkflow test {}";
 //! use wdl_ast::Document;
-//! use wdl_ast::Validator;
 //!
 //! let (document, diagnostics) = Document::parse(source);
 //! if !diagnostics.is_empty() {
@@ -31,7 +30,6 @@
 #![warn(clippy::missing_docs_in_private_items)]
 #![warn(rustdoc::broken_intra_doc_links)]
 
-use std::collections::HashSet;
 use std::fmt;
 
 pub use rowan::Direction;
@@ -59,13 +57,8 @@ pub use wdl_grammar::version;
 pub mod v1;
 
 mod element;
-mod visitor;
 
 pub use element::*;
-pub use visitor::*;
-
-/// The prefix of `except` comments.
-pub const EXCEPT_COMMENT_PREFIX: &str = "#@ except:";
 
 /// A trait that abstracts the underlying representation of a syntax tree node.
 ///
@@ -104,9 +97,6 @@ pub trait TreeNode: Clone + fmt::Debug + PartialEq + Eq + std::hash::Hash {
 
     /// Gets the ancestors of the node.
     fn ancestors(&self) -> impl Iterator<Item = Self>;
-
-    /// Determines if a given rule id is excepted for the node.
-    fn is_rule_excepted(&self, id: &str) -> bool;
 }
 
 /// A trait that abstracts the underlying representation of a syntax token.
@@ -361,10 +351,6 @@ impl TreeNode for SyntaxNode {
     fn ancestors(&self) -> impl Iterator<Item = Self> {
         self.ancestors()
     }
-
-    fn is_rule_excepted(&self, id: &str) -> bool {
-        <Self as SyntaxNodeExt>::is_rule_excepted(self, id)
-    }
 }
 
 impl TreeToken for SyntaxToken {
@@ -389,74 +375,6 @@ impl TreeToken for SyntaxToken {
     }
 }
 
-/// Represents the reason an AST node has been visited.
-///
-/// Each node is visited exactly once, but the visitor will receive
-/// a call for entering the node and a call for exiting the node.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum VisitReason {
-    /// The visit has entered the node.
-    Enter,
-    /// The visit has exited the node.
-    Exit,
-}
-
-/// An extension trait for syntax nodes.
-pub trait SyntaxNodeExt {
-    /// Gets an iterator over the `@except` comments for a syntax node.
-    fn except_comments(&self) -> impl Iterator<Item = SyntaxToken> + '_;
-
-    /// Gets the AST node's rule exceptions set.
-    ///
-    /// The set is the comma-delimited list of rule identifiers that follows a
-    /// `#@ except:` comment.
-    fn rule_exceptions(&self) -> HashSet<String>;
-
-    /// Determines if a given rule id is excepted for the syntax node.
-    fn is_rule_excepted(&self, id: &str) -> bool;
-}
-
-impl SyntaxNodeExt for SyntaxNode {
-    fn except_comments(&self) -> impl Iterator<Item = SyntaxToken> + '_ {
-        self.siblings_with_tokens(Direction::Prev)
-            .skip(1)
-            .map_while(|s| {
-                if s.kind() == SyntaxKind::Whitespace || s.kind() == SyntaxKind::Comment {
-                    s.into_token()
-                } else {
-                    None
-                }
-            })
-            .filter(|t| t.kind() == SyntaxKind::Comment)
-    }
-
-    fn rule_exceptions(&self) -> HashSet<String> {
-        let mut set = HashSet::default();
-        for comment in self.except_comments() {
-            if let Some(ids) = comment.text().strip_prefix(EXCEPT_COMMENT_PREFIX) {
-                for id in ids.split(',') {
-                    let id = id.trim();
-                    set.insert(id.to_string());
-                }
-            }
-        }
-
-        set
-    }
-
-    fn is_rule_excepted(&self, id: &str) -> bool {
-        for comment in self.except_comments() {
-            if let Some(ids) = comment.text().strip_prefix(EXCEPT_COMMENT_PREFIX) {
-                if ids.split(',').any(|i| i.trim() == id) {
-                    return true;
-                }
-            }
-        }
-
-        false
-    }
-}
-
 /// Represents the AST of a [Document].
 ///
 /// See [Document::ast].
@@ -550,11 +468,11 @@ impl Document {
     ///     Ast::Unsupported => panic!("should be a V1 AST"),
     /// }
     /// ```
-    pub fn parse(source: &str) -> (Self, Diagnostics) {
+    pub fn parse(source: &str) -> (Self, Vec<Diagnostic>) {
         let (tree, diagnostics) = SyntaxTree::parse(source);
         (
             Document::cast(tree.into_syntax()).expect("document should cast"),
-            visitor::Diagnostics(diagnostics),
+            diagnostics,
         )
     }
 }
@@ -589,14 +507,6 @@ impl<N: TreeNode> Document<N> {
     }
 }
 
-impl Document<SyntaxNode> {
-    /// Visits the document with a pre-order traversal using the provided
-    /// visitor to visit each element in the document.
-    pub fn visit<V: Visitor>(&self, diagnostics: &mut Diagnostics, visitor: &mut V) {
-        visit(&self.0, diagnostics, visitor)
-    }
-}
-
 impl fmt::Debug for Document {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)

wdl-ast/src/v1/decls.rs

@@ -964,11 +964,7 @@ impl<N: TreeNode> Decl<N> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::Diagnostics;
     use crate::Document;
-    use crate::SupportedVersion;
-    use crate::VisitReason;
-    use crate::Visitor;
 
     #[test]
     fn decls() {
@@ -1099,41 +1095,5 @@ task test {
                 .text(),
             "foo"
         );
-
-        // Use a visitor to count the number of declarations
-        #[derive(Default)]
-        struct MyVisitor {
-            bound: usize,
-            unbound: usize,
-        }
-
-        impl Visitor for MyVisitor {
-            fn document(
-                &mut self,
-                _: &mut Diagnostics,
-                _: VisitReason,
-                _: &Document,
-                _: SupportedVersion,
-            ) {
-            }
-
-            fn bound_decl(&mut self, _: &mut Diagnostics, reason: VisitReason, _: &BoundDecl) {
-                if reason == VisitReason::Enter {
-                    self.bound += 1;
-                }
-            }
-
-            fn unbound_decl(&mut self, _: &mut Diagnostics, reason: VisitReason, _: &UnboundDecl) {
-                if reason == VisitReason::Enter {
-                    self.unbound += 1;
-                }
-            }
-        }
-
-        let mut visitor = MyVisitor::default();
-        let mut diagnostics = Diagnostics::default();
-        document.visit(&mut diagnostics, &mut visitor);
-        assert_eq!(visitor.bound, 6);
-        assert_eq!(visitor.unbound, 5);
     }
 }