Add preprocessor

sv-parser-macros/src/lib.rs

@@ -67,6 +67,38 @@ fn impl_node(ast: &DeriveInput) -> TokenStream {
             }
         }
 
+        impl<'a> From<&'a #name> for RefNode<'a> {
+            fn from(x: &'a #name) -> Self {
+                RefNode::#name(x)
+            }
+        }
+
+        impl core::convert::TryFrom<#name> for Locate {
+            type Error = ();
+            fn try_from(x: #name) -> Result<Self, Self::Error> {
+                Self::try_from(&x)
+            }
+        }
+
+        impl<'a> core::convert::TryFrom<&'a #name> for Locate {
+            type Error = ();
+            fn try_from(x: &'a #name) -> Result<Self, Self::Error> {
+                let mut locate: Option<Locate> = None;
+                for x in x {
+                    match x {
+                        RefNode::Locate(x) => if let Some(loc) = locate {
+                            assert_eq!(x.offset, loc.offset + loc.len);
+                            locate = Some(Locate { offset: loc.offset, line: loc.line, len: loc.len + x.len });
+                        } else {
+                            locate = Some(*x);
+                        },
+                        _ => (),
+                    }
+                }
+                locate.ok_or(())
+            }
+        }
+
         impl<'a> IntoIterator for &'a #name {
             type Item = RefNode<'a>;
             type IntoIter = Iter<'a>;

sv-parser-parser/src/general/compiler_directives.rs

@@ -137,7 +137,9 @@ pub(crate) fn angle_bracket_literal_impl(s: Span) -> IResult<Span, Locate> {
 pub(crate) fn text_macro_definition(s: Span) -> IResult<Span, TextMacroDefinition> {
     let (s, a) = symbol("`")(s)?;
     let (s, b) = keyword("define")(s)?;
+    begin_lb_not_space();
     let (s, c) = text_macro_name(s)?;
+    end_lb_not_space();
     let (s, d) = opt(macro_text)(s)?;
     Ok((
         s,

sv-parser-parser/src/tests.rs

@@ -302,6 +302,18 @@ mod unit {
             Ok((_, _))
         );
         test!(text_macro_definition, r##"`define a"##, Ok((_, _)));
+        test!(
+            source_text,
+            r##"module test(out);
+                  `define nest_two
+                  `ifdef wow
+                    initial $display("wow is defined");
+                  `else
+                    initial $display("wow is not defined");
+                  `endif
+                endmodule"##,
+            Ok((_, _))
+        );
     }
 }
 

sv-parser-parser/src/utils.rs

@@ -258,18 +258,14 @@ where
 pub(crate) fn white_space(s: Span) -> IResult<Span, WhiteSpace> {
     if in_directive() {
         alt((
-            map(multispace1, |x: Span| {
+            map(space, |x: Span| WhiteSpace::Space(Box::new(into_locate(x)))),
-                WhiteSpace::Space(Box::new(into_locate(x)))
-            }),
             map(preceded(peek(char('/')), comment), |x| {
                 WhiteSpace::Comment(Box::new(x))
             }),
         ))(s)
     } else {
         alt((
-            map(multispace1, |x: Span| {
+            map(space, |x: Span| WhiteSpace::Space(Box::new(into_locate(x)))),
-                WhiteSpace::Space(Box::new(into_locate(x)))
-            }),
             map(preceded(peek(char('/')), comment), |x| {
                 WhiteSpace::Comment(Box::new(x))
             }),
@@ -280,6 +276,14 @@ pub(crate) fn white_space(s: Span) -> IResult<Span, WhiteSpace> {
     }
 }
 
+pub(crate) fn space(s: Span) -> IResult<Span, Span> {
+    if lb_not_space() {
+        space1(s)
+    } else {
+        multispace1(s)
+    }
+}
+
 thread_local!(
     static IN_DIRECTIVE: core::cell::RefCell<Vec<()>> = {
         core::cell::RefCell::new(Vec::new())
@@ -301,6 +305,27 @@ pub(crate) fn end_directive() {
     IN_DIRECTIVE.with(|x| x.borrow_mut().pop());
 }
 
+thread_local!(
+    static LB_NOT_SPACE: core::cell::RefCell<Vec<()>> = {
+        core::cell::RefCell::new(Vec::new())
+    }
+);
+
+pub(crate) fn lb_not_space() -> bool {
+    LB_NOT_SPACE.with(|x| match x.borrow().last() {
+        Some(_) => true,
+        None => false,
+    })
+}
+
+pub(crate) fn begin_lb_not_space() {
+    LB_NOT_SPACE.with(|x| x.borrow_mut().push(()));
+}
+
+pub(crate) fn end_lb_not_space() {
+    LB_NOT_SPACE.with(|x| x.borrow_mut().pop());
+}
+
 // -----------------------------------------------------------------------------
 
 #[derive(Clone, Copy)]

sv-parser-pp/Cargo.toml

@@ -4,10 +4,11 @@ version = "0.1.0"
 authors = ["dalance <dalance@gmail.com>"]
 edition = "2018"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+default = []
+trace   = ["sv-parser-parser/trace"]
 
 [dependencies]
 nom                  = "5.0.0"
-nom_locate   = "1.0.0"
+sv-parser-parser     = { path = "../sv-parser-parser" }
-nom-tracable = "0.3.1"
+sv-parser-syntaxtree = { path = "../sv-parser-syntaxtree" }
-str-concat   = "0.1.4"

sv-parser-pp/src/lib.rs

@@ -1,7 +1,154 @@
+use std::collections::HashMap;
+use std::convert::TryInto;
+use sv_parser_parser::{pp_parser, Span, SpanInfo};
+use sv_parser_syntaxtree::{Locate, NodeEvent, RefNode};
+
+pub fn preprocessor(s: &str) -> String {
+    let mut ret = String::new();
+    let pp_text = pp_parser(Span::new_extra(s, SpanInfo::default()));
+
+    let mut skip = false;
+    let mut skip_nodes = vec![];
+    let mut defines = HashMap::new();
+
+    if let Ok((_, pp_text)) = pp_text {
+        for n in pp_text.into_iter().event() {
+            match n {
+                NodeEvent::Enter(RefNode::ResetallCompilerDirective(_)) if !skip => {
+                    defines.clear();
+                }
+                NodeEvent::Enter(RefNode::UndefineCompilerDirective(x)) if !skip => {
+                    let (_, _, ref name) = x.nodes;
+                    let id = identifier((&name.nodes.0).into());
+                    let id = String::from(id.unwrap().str(s));
+                    defines.remove(&id);
+                }
+                NodeEvent::Enter(RefNode::UndefineallCompilerDirective(_)) if !skip => {
+                    defines.clear();
+                }
+                NodeEvent::Enter(RefNode::SourceDescriptionNotDirective(x)) if !skip => {
+                    let locate: Locate = x.try_into().unwrap();
+                    ret.push_str(locate.str(s));
+                }
+                NodeEvent::Enter(RefNode::IfdefDirective(x)) if !skip => {
+                    let (_, _, ref ifid, ref ifbody, ref elsif, ref elsebody, _, _) = x.nodes;
+                    let ifid = identifier(ifid.into());
+                    let ifid = String::from(ifid.unwrap().str(s));
+                    let mut hit = false;
+                    if defines.contains_key(&ifid) {
+                        hit = true;
+                    } else {
+                        skip_nodes.push(ifbody.into());
+                    }
+
+                    for x in elsif {
+                        let (_, _, ref elsifid, ref elsifbody) = x;
+                        let elsifid = identifier(elsifid.into());
+                        let elsifid = String::from(elsifid.unwrap().str(s));
+                        if hit {
+                            skip_nodes.push(elsifbody.into());
+                        } else if defines.contains_key(&elsifid) {
+                            hit = true;
+                        } else {
+                            skip_nodes.push(elsifbody.into());
+                        }
+                    }
+
+                    if let Some(elsebody) = elsebody {
+                        let (_, _, ref elsebody) = elsebody;
+                        if hit {
+                            skip_nodes.push(elsebody.into());
+                        }
+                    }
+                }
+                NodeEvent::Enter(RefNode::IfndefDirective(x)) if !skip => {
+                    let (_, _, ref ifid, ref ifbody, ref elsif, ref elsebody, _, _) = x.nodes;
+                    let ifid = identifier(ifid.into());
+                    let mut hit = false;
+                    if !defines.contains_key(&String::from(ifid.unwrap().str(s))) {
+                        hit = true;
+                    } else {
+                        skip_nodes.push(ifbody.into());
+                    }
+
+                    for x in elsif {
+                        let (_, _, ref elsifid, ref elsifbody) = x;
+                        let elsifid = identifier(elsifid.into());
+                        if hit {
+                            skip_nodes.push(elsifbody.into());
+                        } else if defines.contains_key(&String::from(elsifid.unwrap().str(s))) {
+                            hit = true;
+                        } else {
+                            skip_nodes.push(elsifbody.into());
+                        }
+                    }
+
+                    if let Some(elsebody) = elsebody {
+                        let (_, _, ref elsebody) = elsebody;
+                        if hit {
+                            skip_nodes.push(elsebody.into());
+                        }
+                    }
+                }
+                NodeEvent::Enter(RefNode::TextMacroDefinition(x)) if !skip => {
+                    let (_, _, ref name, _) = x.nodes;
+                    let id = identifier((&name.nodes.0).into());
+                    let id = String::from(id.unwrap().str(s));
+                    defines.insert(id, x.clone());
+                }
+                NodeEvent::Enter(x) => {
+                    if skip_nodes.contains(&x) {
+                        skip = true;
+                    }
+                }
+                NodeEvent::Leave(x) => {
+                    if skip_nodes.contains(&x) {
+                        skip = false;
+                    }
+                }
+            }
+        }
+    }
+    //let ret = dbg!(ret);
+    println!("{}", ret);
+
+    ret
+}
+
+fn identifier(node: RefNode) -> Option<Locate> {
+    for x in node {
+        match x {
+            RefNode::SimpleIdentifier(x) => {
+                let x: Locate = x.nodes.0.try_into().unwrap();
+                return Some(x);
+            }
+            RefNode::EscapedIdentifier(x) => {
+                let x: Locate = x.nodes.0.try_into().unwrap();
+                return Some(x);
+            }
+            _ => (),
+        }
+    }
+    None
+}
+
 #[cfg(test)]
 mod tests {
+    use super::*;
+
     #[test]
     fn it_works() {
-        assert_eq!(2 + 2, 4);
+        let s = r##"module and_op (a, b, c);
+                  output a;
+                  input b, c;
+
+                  `define behavioral
+                  `ifdef behavioral
+                    wire a = b & c;
+                  `else
+                    and a1 (a,b,c);
+                  `endif
+                endmodule"##;
+        preprocessor(s);
     }
 }

sv-parser-syntaxtree/build.rs

@@ -11,12 +11,12 @@ fn main() {
     let mut out = File::create(&dest).unwrap();
 
     let mut ref_node = String::new();
-    ref_node = format!("{}#[derive(Debug, Clone, RefNode)]\n", ref_node);
+    ref_node = format!("{}#[derive(Clone, Debug, PartialEq, RefNode)]\n", ref_node);
     ref_node = format!("{}pub enum RefNode<'a> {{\n", ref_node);
     ref_node = format!("{}    Locate(&'a Locate),\n", ref_node);
 
     let mut any_node = String::new();
-    any_node = format!("{}#[derive(Debug, Clone, AnyNode)]\n", any_node);
+    any_node = format!("{}#[derive(Clone, Debug, PartialEq, AnyNode)]\n", any_node);
     any_node = format!("{}pub enum AnyNode {{\n", any_node);
     any_node = format!("{}    Locate(Locate),\n", any_node);
 

sv-parser-syntaxtree/src/any_node.rs

@@ -5,14 +5,21 @@ use core::convert::TryFrom;
 
 include!(concat!(env!("OUT_DIR"), "/any_node.rs"));
 
-pub struct RefNodes<'a>(pub Vec<RefNode<'a>>);
-
 // -----------------------------------------------------------------------------
 
+pub struct RefNodes<'a>(pub Vec<RefNode<'a>>);
+
 pub struct Iter<'a> {
     pub(crate) next: RefNodes<'a>,
 }
 
+impl<'a> Iter<'a> {
+    pub fn event(self) -> EventIter<'a> {
+        let next: NodeEvents = self.next.into();
+        EventIter { next }
+    }
+}
+
 impl<'a> Iterator for Iter<'a> {
     type Item = RefNode<'a>;
 
@@ -29,6 +36,59 @@ impl<'a> Iterator for Iter<'a> {
 
 // -----------------------------------------------------------------------------
 
+#[derive(Debug, Clone)]
+pub enum NodeEvent<'a> {
+    Enter(RefNode<'a>),
+    Leave(RefNode<'a>),
+}
+
+pub struct NodeEvents<'a>(pub Vec<NodeEvent<'a>>);
+
+pub struct EventIter<'a> {
+    pub(crate) next: NodeEvents<'a>,
+}
+
+impl<'a> Iterator for EventIter<'a> {
+    type Item = NodeEvent<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let ret = self.next.0.pop();
+        if let Some(x) = ret.clone() {
+            if let NodeEvent::Enter(x) = x {
+                self.next.0.push(NodeEvent::Leave(x.clone()));
+                let mut x: NodeEvents = x.next().into();
+                x.0.reverse();
+                self.next.0.append(&mut x.0);
+            }
+        }
+        ret
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+impl<'a> From<Iter<'a>> for EventIter<'a> {
+    fn from(x: Iter<'a>) -> Self {
+        let mut ret = Vec::new();
+        for x in x.next.0 {
+            ret.push(NodeEvent::Enter(x));
+        }
+        EventIter {
+            next: NodeEvents(ret),
+        }
+    }
+}
+
+impl<'a> From<RefNodes<'a>> for NodeEvents<'a> {
+    fn from(x: RefNodes<'a>) -> Self {
+        let mut ret = Vec::new();
+        for x in x.0 {
+            ret.push(NodeEvent::Enter(x));
+        }
+        NodeEvents(ret)
+    }
+}
+
 impl<'a> From<Vec<RefNode<'a>>> for RefNodes<'a> {
     fn from(x: Vec<RefNode<'a>>) -> Self {
         RefNodes(x)

sv-parser-syntaxtree/src/behavioral_statements/assertion_statements.rs

@@ -2,13 +2,13 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum AssertionItem {
     Concurrent(Box<ConcurrentAssertionItem>),
     Immediate(Box<DeferredImmediateAssetionItem>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DeferredImmediateAssetionItem {
     pub nodes: (
         Option<(BlockIdentifier, Symbol)>,
@@ -16,64 +16,64 @@ pub struct DeferredImmediateAssetionItem {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ProceduralAssertionStatement {
     Concurrent(Box<ConcurrentAssertionStatement>),
     Immediate(Box<ImmediateAssetionStatement>),
     Checker(Box<CheckerInstantiation>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ImmediateAssetionStatement {
     Simple(Box<SimpleImmediateAssertionStatement>),
     Deferred(Box<DeferredImmediateAssertionStatement>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SimpleImmediateAssertionStatement {
     Assert(Box<SimpleImmediateAssertStatement>),
     Assume(Box<SimpleImmediateAssumeStatement>),
     Cover(Box<SimpleImmediateCoverStatement>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SimpleImmediateAssertStatement {
     pub nodes: (Keyword, Paren<Expression>, ActionBlock),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SimpleImmediateAssumeStatement {
     pub nodes: (Keyword, Paren<Expression>, ActionBlock),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SimpleImmediateCoverStatement {
     pub nodes: (Keyword, Paren<Expression>, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DeferredImmediateAssertionStatement {
     Assert(Box<DeferredImmediateAssertStatement>),
     Assume(Box<DeferredImmediateAssumeStatement>),
     Cover(Box<DeferredImmediateCoverStatement>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DeferredImmediateAssertStatement {
     pub nodes: (Keyword, AssertTiming, Paren<Expression>, ActionBlock),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DeferredImmediateAssumeStatement {
     pub nodes: (Keyword, AssertTiming, Paren<Expression>, ActionBlock),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DeferredImmediateCoverStatement {
     pub nodes: (Keyword, AssertTiming, Paren<Expression>, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum AssertTiming {
     Zero(Box<Symbol>),
     Final(Box<Keyword>),

sv-parser-syntaxtree/src/behavioral_statements/case_statements.rs

@@ -2,14 +2,14 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CaseStatement {
     Normal(Box<CaseStatementNormal>),
     Matches(Box<CaseStatementMatches>),
     Inside(Box<CaseStatementInside>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseStatementNormal {
     pub nodes: (
         Option<UniquePriority>,
@@ -21,7 +21,7 @@ pub struct CaseStatementNormal {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseStatementMatches {
     pub nodes: (
         Option<UniquePriority>,
@@ -34,7 +34,7 @@ pub struct CaseStatementMatches {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseStatementInside {
     pub nodes: (
         Option<UniquePriority>,
@@ -47,41 +47,41 @@ pub struct CaseStatementInside {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CaseKeyword {
     Case(Box<Keyword>),
     Casez(Box<Keyword>),
     Casex(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseExpression {
     pub nodes: (Expression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CaseItem {
     NonDefault(Box<CaseItemNondefault>),
     Default(Box<CaseItemDefault>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseItemNondefault {
     pub nodes: (List<Symbol, CaseItemExpression>, Symbol, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseItemDefault {
     pub nodes: (Keyword, Option<Symbol>, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CasePatternItem {
     NonDefault(Box<CasePatternItemNondefault>),
     Default(Box<CaseItemDefault>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CasePatternItemNondefault {
     pub nodes: (
         Pattern,
@@ -91,38 +91,38 @@ pub struct CasePatternItemNondefault {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CaseInsideItem {
     NonDefault(Box<CaseInsideItemNondefault>),
     Default(Box<CaseItemDefault>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseInsideItemNondefault {
     pub nodes: (OpenRangeList, Symbol, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseItemExpression {
     pub nodes: (Expression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RandcaseStatement {
     pub nodes: (Keyword, RandcaseItem, Vec<RandcaseItem>, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RandcaseItem {
     pub nodes: (Expression, Symbol, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OpenRangeList {
     pub nodes: (List<Symbol, OpenValueRange>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OpenValueRange {
     pub nodes: (ValueRange,),
 }

sv-parser-syntaxtree/src/behavioral_statements/clocking_block.rs

@@ -2,13 +2,13 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClockingDeclaration {
     Local(Box<ClockingDeclarationLocal>),
     Global(Box<ClockingDeclarationGlobal>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingDeclarationLocal {
     pub nodes: (
         Option<Default>,
@@ -22,12 +22,12 @@ pub struct ClockingDeclarationLocal {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Default {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingDeclarationGlobal {
     pub nodes: (
         Keyword,
@@ -40,67 +40,67 @@ pub struct ClockingDeclarationGlobal {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClockingEvent {
     Identifier(Box<ClockingEventIdentifier>),
     Expression(Box<ClockingEventExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingEventIdentifier {
     pub nodes: (Symbol, Identifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingEventExpression {
     pub nodes: (Symbol, Paren<EventExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClockingItem {
     Default(Box<ClockingItemDefault>),
     Direction(Box<ClockingItemDirection>),
     Assertion(Box<ClockingItemAssertion>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingItemDefault {
     pub nodes: (Keyword, DefaultSkew, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingItemDirection {
     pub nodes: (ClockingDirection, ListOfClockingDeclAssign, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingItemAssertion {
     pub nodes: (Vec<AttributeInstance>, AssertionItemDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DefaultSkew {
     Input(Box<DefaultSkewInput>),
     Output(Box<DefaultSkewOutput>),
     InputOutput(Box<DefaultSkewInputOutput>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DefaultSkewInput {
     pub nodes: (Keyword, ClockingSkew),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DefaultSkewOutput {
     pub nodes: (Keyword, ClockingSkew),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DefaultSkewInputOutput {
     pub nodes: (Keyword, ClockingSkew, Keyword, ClockingSkew),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClockingDirection {
     Input(Box<ClockingDirectionInput>),
     Output(Box<ClockingDirectionOutput>),
@@ -108,75 +108,75 @@ pub enum ClockingDirection {
     Inout(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingDirectionInput {
     pub nodes: (Keyword, Option<ClockingSkew>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingDirectionOutput {
     pub nodes: (Keyword, Option<ClockingSkew>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingDirectionInputOutput {
     pub nodes: (Keyword, Option<ClockingSkew>, Keyword, Option<ClockingSkew>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfClockingDeclAssign {
     pub nodes: (List<Symbol, ClockingDeclAssign>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingDeclAssign {
     pub nodes: (SignalIdentifier, Option<(Symbol, Expression)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClockingSkew {
     Edge(Box<ClockingSkewEdge>),
     DelayControl(Box<DelayControl>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingSkewEdge {
     pub nodes: (EdgeIdentifier, Option<DelayControl>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingDrive {
     pub nodes: (ClockvarExpression, Symbol, Option<CycleDelay>, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CycleDelay {
     Integral(Box<CycleDelayIntegral>),
     Identifier(Box<CycleDelayIdentifier>),
     Expression(Box<CycleDelayExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CycleDelayIntegral {
     pub nodes: (Symbol, IntegralNumber),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CycleDelayIdentifier {
     pub nodes: (Symbol, Identifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CycleDelayExpression {
     pub nodes: (Symbol, Paren<Expression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Clockvar {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockvarExpression {
     pub nodes: (Clockvar, Select),
 }

sv-parser-syntaxtree/src/behavioral_statements/conditional_statements.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConditionalStatement {
     pub nodes: (
         Option<UniquePriority>,
@@ -14,25 +14,25 @@ pub struct ConditionalStatement {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum UniquePriority {
     Unique(Box<Keyword>),
     Unique0(Box<Keyword>),
     Priority(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CondPredicate {
     pub nodes: (List<Symbol, ExpressionOrCondPattern>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ExpressionOrCondPattern {
     Expression(Box<Expression>),
     CondPattern(Box<CondPattern>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CondPattern {
     pub nodes: (Expression, Keyword, Pattern),
 }

sv-parser-syntaxtree/src/behavioral_statements/continuous_assignment_and_net_alias_statements.rs

@@ -2,13 +2,13 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ContinuousAssign {
     Net(Box<ContinuousAssignNet>),
     Variable(Box<ContinuousAssignVariable>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ContinuousAssignNet {
     pub nodes: (
         Keyword,
@@ -19,7 +19,7 @@ pub struct ContinuousAssignNet {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ContinuousAssignVariable {
     pub nodes: (
         Keyword,
@@ -29,22 +29,22 @@ pub struct ContinuousAssignVariable {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfNetAssignments {
     pub nodes: (List<Symbol, NetAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfVariableAssignments {
     pub nodes: (List<Symbol, VariableAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetAlias {
     pub nodes: (Keyword, NetLvalue, Symbol, List<Symbol, NetLvalue>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetAssignment {
     pub nodes: (NetLvalue, Symbol, Expression),
 }

sv-parser-syntaxtree/src/behavioral_statements/looping_statements.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum LoopStatement {
     Forever(Box<LoopStatementForever>),
     Repeat(Box<LoopStatementRepeat>),
@@ -12,22 +12,22 @@ pub enum LoopStatement {
     Foreach(Box<LoopStatementForeach>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LoopStatementForever {
     pub nodes: (Keyword, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LoopStatementRepeat {
     pub nodes: (Keyword, Paren<Expression>, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LoopStatementWhile {
     pub nodes: (Keyword, Paren<Expression>, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LoopStatementFor {
     pub nodes: (
         Keyword,
@@ -42,12 +42,12 @@ pub struct LoopStatementFor {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LoopStatementDoWhile {
     pub nodes: (Keyword, StatementOrNull, Keyword, Paren<Expression>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LoopStatementForeach {
     pub nodes: (
         Keyword,
@@ -56,18 +56,18 @@ pub struct LoopStatementForeach {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ForInitialization {
     ListOfVariableAssignments(Box<ListOfVariableAssignments>),
     Declaration(Box<ForInitializationDeclaration>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ForInitializationDeclaration {
     pub nodes: (List<Symbol, ForVariableDeclaration>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ForVariableDeclaration {
     pub nodes: (
         Option<Var>,
@@ -76,24 +76,24 @@ pub struct ForVariableDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Var {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ForStep {
     pub nodes: (List<Symbol, ForStepAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ForStepAssignment {
     OperatorAssignment(Box<OperatorAssignment>),
     IncOrDecExpression(Box<IncOrDecExpression>),
     FunctionSubroutineCall(Box<FunctionSubroutineCall>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LoopVariables {
     pub nodes: (List<Symbol, Option<IndexVariableIdentifier>>,),
 }

sv-parser-syntaxtree/src/behavioral_statements/parallel_and_sequential_blocks.rs

@@ -2,18 +2,18 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ActionBlock {
     StatementOrNull(Box<StatementOrNull>),
     Else(Box<ActionBlockElse>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ActionBlockElse {
     pub nodes: (Option<Statement>, Keyword, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SeqBlock {
     pub nodes: (
         Keyword,
@@ -25,7 +25,7 @@ pub struct SeqBlock {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParBlock {
     pub nodes: (
         Keyword,
@@ -37,7 +37,7 @@ pub struct ParBlock {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum JoinKeyword {
     Join(Box<Keyword>),
     JoinAny(Box<Keyword>),

sv-parser-syntaxtree/src/behavioral_statements/patterns.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Pattern {
     Variable(Box<PatternVariable>),
     Asterisk(Box<Symbol>),
@@ -12,27 +12,27 @@ pub enum Pattern {
     IdentifierList(Box<PatternIdentifierList>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PatternVariable {
     pub nodes: (Symbol, VariableIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PatternTagged {
     pub nodes: (Keyword, MemberIdentifier, Option<Pattern>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PatternList {
     pub nodes: (ApostropheBrace<List<Symbol, Pattern>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PatternIdentifierList {
     pub nodes: (ApostropheBrace<List<Symbol, (MemberIdentifier, Symbol, Pattern)>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum AssignmentPattern {
     List(Box<AssignmentPatternList>),
     Structure(Box<AssignmentPatternStructure>),
@@ -40,50 +40,50 @@ pub enum AssignmentPattern {
     Repeat(Box<AssignmentPatternRepeat>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssignmentPatternList {
     pub nodes: (ApostropheBrace<List<Symbol, Expression>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssignmentPatternStructure {
     pub nodes: (ApostropheBrace<List<Symbol, (StructurePatternKey, Symbol, Expression)>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssignmentPatternArray {
     pub nodes: (ApostropheBrace<List<Symbol, (ArrayPatternKey, Symbol, Expression)>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssignmentPatternRepeat {
     pub nodes: (ApostropheBrace<(ConstantExpression, Brace<List<Symbol, Expression>>)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum StructurePatternKey {
     MemberIdentifier(Box<MemberIdentifier>),
     AssignmentPatternKey(Box<AssignmentPatternKey>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ArrayPatternKey {
     ConstantExpression(Box<ConstantExpression>),
     AssignmentPatternKey(Box<AssignmentPatternKey>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum AssignmentPatternKey {
     SimpleType(Box<SimpleType>),
     Default(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssignmentPatternExpression {
     pub nodes: (Option<AssignmentPatternExpressionType>, AssignmentPattern),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum AssignmentPatternExpressionType {
     PsTypeIdentifier(Box<PsTypeIdentifier>),
     PsParameterIdentifier(Box<PsParameterIdentifier>),
@@ -91,17 +91,17 @@ pub enum AssignmentPatternExpressionType {
     TypeReference(Box<TypeReference>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantAssignmentPatternExpression {
     pub nodes: (AssignmentPatternExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssignmentPatternNetLvalue {
     pub nodes: (ApostropheBrace<List<Symbol, NetLvalue>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssignmentPatternVariableLvalue {
     pub nodes: (ApostropheBrace<List<Symbol, VariableLvalue>>,),
 }

sv-parser-syntaxtree/src/behavioral_statements/procedural_blocks_and_assignments.rs

@@ -2,17 +2,17 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InitialConstruct {
     pub nodes: (Keyword, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AlwaysConstruct {
     pub nodes: (AlwaysKeyword, Statement),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum AlwaysKeyword {
     Always(Box<Keyword>),
     AlwaysComb(Box<Keyword>),
@@ -20,12 +20,12 @@ pub enum AlwaysKeyword {
     AlwaysFf(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FinalConstruct {
     pub nodes: (Keyword, FunctionStatement),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BlockingAssignment {
     Variable(Box<BlockingAssignmentVariable>),
     NonrangeVariable(Box<BlockingAssignmentNonrangeVariable>),
@@ -33,17 +33,17 @@ pub enum BlockingAssignment {
     OperatorAssignment(Box<OperatorAssignment>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockingAssignmentVariable {
     pub nodes: (VariableLvalue, Symbol, DelayOrEventControl, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockingAssignmentNonrangeVariable {
     pub nodes: (NonrangeVariableLvalue, Symbol, DynamicArrayNew),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockingAssignmentHierarchicalVariable {
     pub nodes: (
         Option<ImplicitClassHandleOrClassScopeOrPackageScope>,
@@ -54,17 +54,17 @@ pub struct BlockingAssignmentHierarchicalVariable {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OperatorAssignment {
     pub nodes: (VariableLvalue, AssignmentOperator, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssignmentOperator {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonblockingAssignment {
     pub nodes: (
         VariableLvalue,
@@ -74,7 +74,7 @@ pub struct NonblockingAssignment {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ProceduralContinuousAssignment {
     Assign(Box<ProceduralContinuousAssignmentAssign>),
     Deassign(Box<ProceduralContinuousAssignmentDeassign>),
@@ -84,37 +84,37 @@ pub enum ProceduralContinuousAssignment {
     ReleaseNet(Box<ProceduralContinuousAssignmentReleaseNet>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProceduralContinuousAssignmentAssign {
     pub nodes: (Keyword, VariableAssignment),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProceduralContinuousAssignmentDeassign {
     pub nodes: (Keyword, VariableLvalue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProceduralContinuousAssignmentForceVariable {
     pub nodes: (Keyword, VariableAssignment),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProceduralContinuousAssignmentForceNet {
     pub nodes: (Keyword, NetAssignment),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProceduralContinuousAssignmentReleaseVariable {
     pub nodes: (Keyword, VariableLvalue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProceduralContinuousAssignmentReleaseNet {
     pub nodes: (Keyword, NetLvalue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariableAssignment {
     pub nodes: (VariableLvalue, Symbol, Expression),
 }

sv-parser-syntaxtree/src/behavioral_statements/randsequence.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RandsequenceStatement {
     pub nodes: (
         Keyword,
@@ -13,7 +13,7 @@ pub struct RandsequenceStatement {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Production {
     pub nodes: (
         Option<DataTypeOrVoid>,
@@ -25,7 +25,7 @@ pub struct Production {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RsRule {
     pub nodes: (
         RsProductionList,
@@ -33,18 +33,18 @@ pub struct RsRule {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum RsProductionList {
     Prod(Box<RsProductionListProd>),
     Join(Box<RsProductionListJoin>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RsProductionListProd {
     pub nodes: (RsProd, Vec<RsProd>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RsProductionListJoin {
     pub nodes: (
         Keyword,
@@ -56,24 +56,24 @@ pub struct RsProductionListJoin {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum WeightSpecification {
     IntegralNumber(Box<IntegralNumber>),
     PsIdentifier(Box<PsIdentifier>),
     Expression(Box<WeightSpecificationExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct WeightSpecificationExpression {
     pub nodes: (Paren<Expression>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RsCodeBlock {
     pub nodes: (Brace<(Vec<DataDeclaration>, Vec<StatementOrNull>)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum RsProd {
     ProductionItem(Box<ProductionItem>),
     RsCodeBlock(Box<RsCodeBlock>),
@@ -82,12 +82,12 @@ pub enum RsProd {
     RsCase(Box<RsCase>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProductionItem {
     pub nodes: (ProductionIdentifier, Option<Paren<ListOfArguments>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RsIfElse {
     pub nodes: (
         Keyword,
@@ -97,12 +97,12 @@ pub struct RsIfElse {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RsRepeat {
     pub nodes: (Keyword, Paren<Expression>, ProductionItem),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RsCase {
     pub nodes: (
         Keyword,
@@ -113,13 +113,13 @@ pub struct RsCase {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum RsCaseItem {
     NonDefault(Box<RsCaseItemNondefault>),
     Default(Box<RsCaseItemDefault>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RsCaseItemNondefault {
     pub nodes: (
         List<Symbol, CaseItemExpression>,
@@ -129,7 +129,7 @@ pub struct RsCaseItemNondefault {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RsCaseItemDefault {
     pub nodes: (Keyword, Option<Symbol>, ProductionItem, Symbol),
 }

sv-parser-syntaxtree/src/behavioral_statements/statements.rs

@@ -2,18 +2,18 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum StatementOrNull {
     Statement(Box<Statement>),
     Attribute(Box<StatementOrNullAttribute>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StatementOrNullAttribute {
     pub nodes: (Vec<AttributeInstance>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Statement {
     pub nodes: (
         Option<(BlockIdentifier, Symbol)>,
@@ -22,7 +22,7 @@ pub struct Statement {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum StatementItem {
     BlockingAssignment(Box<(BlockingAssignment, Symbol)>),
     NonblockingAssignment(Box<(NonblockingAssignment, Symbol)>),
@@ -46,23 +46,23 @@ pub enum StatementItem {
     ExpectPropertyStatement(Box<ExpectPropertyStatement>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FunctionStatement {
     pub nodes: (Statement,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum FunctionStatementOrNull {
     Statement(Box<FunctionStatement>),
     Attribute(Box<FunctionStatementOrNullAttribute>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FunctionStatementOrNullAttribute {
     pub nodes: (Vec<AttributeInstance>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariableIdentifierList {
     pub nodes: (List<Symbol, VariableIdentifier>,),
 }

sv-parser-syntaxtree/src/behavioral_statements/subroutine_call_statements.rs

@@ -2,13 +2,13 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SubroutineCallStatement {
     SubroutineCall(Box<(SubroutineCall, Symbol)>),
     Function(Box<SubroutineCallStatementFunction>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SubroutineCallStatementFunction {
     pub nodes: (Keyword, Symbol, Paren<FunctionSubroutineCall>, Symbol),
 }

sv-parser-syntaxtree/src/behavioral_statements/timing_control_statements.rs

@@ -2,40 +2,40 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProceduralTimingControlStatement {
     pub nodes: (ProceduralTimingControl, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DelayOrEventControl {
     Delay(Box<DelayControl>),
     Event(Box<EventControl>),
     Repeat(Box<DelayOrEventControlRepeat>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DelayOrEventControlRepeat {
     pub nodes: (Keyword, Paren<Expression>, EventControl),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DelayControl {
     Delay(Box<DelayControlDelay>),
     Mintypmax(Box<DelayControlMintypmax>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DelayControlDelay {
     pub nodes: (Symbol, DelayValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DelayControlMintypmax {
     pub nodes: (Symbol, Paren<MintypmaxExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum EventControl {
     EventIdentifier(Box<EventControlEventIdentifier>),
     EventExpression(Box<EventControlEventExpression>),
@@ -44,32 +44,32 @@ pub enum EventControl {
     SequenceIdentifier(Box<EventControlSequenceIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventControlEventIdentifier {
     pub nodes: (Symbol, HierarchicalEventIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventControlEventExpression {
     pub nodes: (Symbol, Paren<EventExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventControlAsterisk {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventControlParenAsterisk {
     pub nodes: (Symbol, Paren<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventControlSequenceIdentifier {
     pub nodes: (Symbol, PsOrHierarchicalSequenceIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum EventExpression {
     Expression(Box<EventExpressionExpression>),
     Sequence(Box<EventExpressionSequence>),
@@ -78,7 +78,7 @@ pub enum EventExpression {
     Paren(Box<EventExpressionParen>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventExpressionExpression {
     pub nodes: (
         Option<EdgeIdentifier>,
@@ -87,73 +87,73 @@ pub struct EventExpressionExpression {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventExpressionSequence {
     pub nodes: (SequenceInstance, Option<(Keyword, Expression)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventExpressionOr {
     pub nodes: (EventExpression, Keyword, EventExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventExpressionComma {
     pub nodes: (EventExpression, Symbol, EventExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventExpressionParen {
     pub nodes: (Paren<EventExpression>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ProceduralTimingControl {
     DelayControl(Box<DelayControl>),
     EventControl(Box<EventControl>),
     CycleDelay(Box<CycleDelay>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum JumpStatement {
     Return(Box<JumpStatementReturn>),
     Break(Box<JumpStatementBreak>),
     Continue(Box<JumpStatementContinue>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct JumpStatementReturn {
     pub nodes: (Keyword, Option<Expression>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct JumpStatementBreak {
     pub nodes: (Keyword, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct JumpStatementContinue {
     pub nodes: (Keyword, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum WaitStatement {
     Wait(Box<WaitStatementWait>),
     Fork(Box<WaitStatementFork>),
     Order(Box<WaitStatementOrder>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct WaitStatementWait {
     pub nodes: (Keyword, Paren<Expression>, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct WaitStatementFork {
     pub nodes: (Keyword, Keyword, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct WaitStatementOrder {
     pub nodes: (
         Keyword,
@@ -162,18 +162,18 @@ pub struct WaitStatementOrder {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum EventTrigger {
     Named(Box<EventTriggerNamed>),
     Nonblocking(Box<EventTriggerNonblocking>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventTriggerNamed {
     pub nodes: (Symbol, HierarchicalEventIdentifier, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventTriggerNonblocking {
     pub nodes: (
         Symbol,
@@ -183,24 +183,24 @@ pub struct EventTriggerNonblocking {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DisableStatement {
     Task(Box<DisableStatementTask>),
     Block(Box<DisableStatementBlock>),
     Fork(Box<DisableStatementFork>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DisableStatementTask {
     pub nodes: (Keyword, HierarchicalTaskIdentifier, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DisableStatementBlock {
     pub nodes: (Keyword, HierarchicalBlockIdentifier, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DisableStatementFork {
     pub nodes: (Keyword, Keyword, Symbol),
 }

sv-parser-syntaxtree/src/declarations/assertion_declarations.rs

@@ -2,13 +2,13 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConcurrentAssertionItem {
     Statement(Box<ConcurrentAssertionItemStatement>),
     CheckerInstantiation(Box<CheckerInstantiation>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConcurrentAssertionItemStatement {
     pub nodes: (
         Option<(BlockIdentifier, Symbol)>,
@@ -16,7 +16,7 @@ pub struct ConcurrentAssertionItemStatement {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConcurrentAssertionStatement {
     AssertPropertyStatement(Box<AssertPropertyStatement>),
     AssumePropertyStatement(Box<AssumePropertyStatement>),
@@ -25,27 +25,27 @@ pub enum ConcurrentAssertionStatement {
     RestrictPropertyStatement(Box<RestrictPropertyStatement>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssertPropertyStatement {
     pub nodes: (Keyword, Keyword, Paren<PropertySpec>, ActionBlock),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssumePropertyStatement {
     pub nodes: (Keyword, Keyword, Paren<PropertySpec>, ActionBlock),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverPropertyStatement {
     pub nodes: (Keyword, Keyword, Paren<PropertySpec>, StatementOrNull),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ExpectPropertyStatement {
     pub nodes: (Keyword, Paren<PropertySpec>, ActionBlock),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverSequenceStatement {
     pub nodes: (
         Keyword,
@@ -59,12 +59,12 @@ pub struct CoverSequenceStatement {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RestrictPropertyStatement {
     pub nodes: (Keyword, Keyword, Paren<PropertySpec>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyInstance {
     pub nodes: (
         PsOrHierarchicalPropertyIdentifier,
@@ -72,13 +72,13 @@ pub struct PropertyInstance {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PropertyListOfArguments {
     Ordered(Box<PropertyListOfArgumentsOrdered>),
     Named(Box<PropertyListOfArgumentsNamed>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyListOfArgumentsOrdered {
     pub nodes: (
         List<Symbol, Option<PropertyActualArg>>,
@@ -86,25 +86,25 @@ pub struct PropertyListOfArgumentsOrdered {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyListOfArgumentsNamed {
     pub nodes: (List<Symbol, (Symbol, Identifier, Paren<Option<PropertyActualArg>>)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PropertyActualArg {
     PropertyExpr(Box<PropertyExpr>),
     SequenceActualArg(Box<SequenceActualArg>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum AssertionItemDeclaration {
     PropertyDeclaration(Box<PropertyDeclaration>),
     SequenceDeclaration(Box<SequenceDeclaration>),
     LetDeclaration(Box<LetDeclaration>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyDeclaration {
     pub nodes: (
         Keyword,
@@ -119,12 +119,12 @@ pub struct PropertyDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyPortList {
     pub nodes: (List<Symbol, PropertyPortItem>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyPortItem {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -136,18 +136,18 @@ pub struct PropertyPortItem {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PropertyLvarPortDirection {
     Input(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PropertyFormalType {
     SequenceFormalType(Box<SequenceFormalType>),
     Property(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertySpec {
     pub nodes: (
         Option<ClockingEvent>,
@@ -156,7 +156,7 @@ pub struct PropertySpec {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PropertyExpr {
     SequenceExpr(Box<SequenceExpr>),
     Strong(Box<PropertyExprStrong>),
@@ -181,37 +181,37 @@ pub enum PropertyExpr {
     ClockingEvent(Box<PropertyExprClockingEvent>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprStrong {
     pub nodes: (Keyword, Paren<SequenceExpr>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprWeak {
     pub nodes: (Keyword, Paren<SequenceExpr>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprParen {
     pub nodes: (Paren<PropertyExpr>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprNot {
     pub nodes: (Keyword, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprBinaryProperty {
     pub nodes: (PropertyExpr, Keyword, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprBinarySequence {
     pub nodes: (SequenceExpr, Symbol, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprIf {
     pub nodes: (
         Keyword,
@@ -221,7 +221,7 @@ pub struct PropertyExprIf {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprCase {
     pub nodes: (
         Keyword,
@@ -232,17 +232,17 @@ pub struct PropertyExprCase {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprNexttime {
     pub nodes: (Keyword, Option<Bracket<ConstantExpression>>, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprSNexttime {
     pub nodes: (Keyword, Option<Bracket<ConstantExpression>>, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprAlways {
     pub nodes: (
         Keyword,
@@ -251,7 +251,7 @@ pub struct PropertyExprAlways {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprSAlways {
     pub nodes: (
         Keyword,
@@ -260,12 +260,12 @@ pub struct PropertyExprSAlways {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprEventually {
     pub nodes: (Keyword, Bracket<ConstantRange>, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprSEventually {
     pub nodes: (
         Keyword,
@@ -274,48 +274,48 @@ pub struct PropertyExprSEventually {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprAcceptOn {
     pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprRejectOn {
     pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprSyncAcceptOn {
     pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprSyncRejectOn {
     pub nodes: (Keyword, Paren<ExpressionOrDist>, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyExprClockingEvent {
     pub nodes: (ClockingEvent, PropertyExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PropertyCaseItem {
     Nondefault(Box<PropertyCaseItemNondefault>),
     Default(Box<PropertyCaseItemDefault>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyCaseItemNondefault {
     pub nodes: (List<Symbol, ExpressionOrDist>, Symbol, PropertyExpr, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyCaseItemDefault {
     pub nodes: (Keyword, Option<Symbol>, PropertyExpr, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceDeclaration {
     pub nodes: (
         Keyword,
@@ -330,12 +330,12 @@ pub struct SequenceDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequencePortList {
     pub nodes: (List<Symbol, SequencePortItem>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequencePortItem {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -347,21 +347,21 @@ pub struct SequencePortItem {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SequenceLvarPortDirection {
     Input(Box<Keyword>),
     Inout(Box<Keyword>),
     Output(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SequenceFormalType {
     DataTypeOrImplicit(Box<DataTypeOrImplicit>),
     Sequence(Box<Keyword>),
     Untyped(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SequenceExpr {
     CycleDelayExpr(Box<SequenceExprCycleDelayExpr>),
     ExprCycleDelayExpr(Box<SequenceExprExprCycleDelayExpr>),
@@ -374,7 +374,7 @@ pub enum SequenceExpr {
     ClockingEvent(Box<SequenceExprClockingEvent>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceExprCycleDelayExpr {
     pub nodes: (
         CycleDelayRange,
@@ -383,7 +383,7 @@ pub struct SequenceExprCycleDelayExpr {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceExprExprCycleDelayExpr {
     pub nodes: (
         SequenceExpr,
@@ -393,17 +393,17 @@ pub struct SequenceExprExprCycleDelayExpr {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceExprExpression {
     pub nodes: (ExpressionOrDist, Option<BooleanAbbrev>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceExprInstance {
     pub nodes: (SequenceInstance, Option<SequenceAbbrev>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceExprParen {
     pub nodes: (
         Paren<(SequenceExpr, Vec<(Symbol, SequenceMatchItem)>)>,
@@ -411,12 +411,12 @@ pub struct SequenceExprParen {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceExprBinary {
     pub nodes: (SequenceExpr, Keyword, SequenceExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceExprFirstMatch {
     pub nodes: (
         Keyword,
@@ -424,17 +424,17 @@ pub struct SequenceExprFirstMatch {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceExprThroughout {
     pub nodes: (ExpressionOrDist, Keyword, SequenceExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceExprClockingEvent {
     pub nodes: (ClockingEvent, SequenceExpr),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CycleDelayRange {
     Primary(Box<CycleDelayRangePrimary>),
     Expression(Box<CycleDelayRangeExpression>),
@@ -442,39 +442,39 @@ pub enum CycleDelayRange {
     Plus(Box<CycleDelayRangePlus>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CycleDelayRangePrimary {
     pub nodes: (Symbol, ConstantPrimary),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CycleDelayRangeExpression {
     pub nodes: (Symbol, Bracket<CycleDelayConstRangeExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CycleDelayRangeAsterisk {
     pub nodes: (Symbol, Bracket<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CycleDelayRangePlus {
     pub nodes: (Symbol, Bracket<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceMethodCall {
     pub nodes: (SequenceInstance, Symbol, MethodIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SequenceMatchItem {
     OperatorAssignment(Box<OperatorAssignment>),
     IncOrDecExpression(Box<IncOrDecExpression>),
     SubroutineCall(Box<SubroutineCall>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceInstance {
     pub nodes: (
         PsOrHierarchicalSequenceIdentifier,
@@ -482,13 +482,13 @@ pub struct SequenceInstance {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SequenceListOfArguments {
     Ordered(Box<SequenceListOfArgumentsOrdered>),
     Named(Box<SequenceListOfArgumentsNamed>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceListOfArgumentsOrdered {
     pub nodes: (
         List<Symbol, Option<SequenceActualArg>>,
@@ -496,89 +496,89 @@ pub struct SequenceListOfArgumentsOrdered {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceListOfArgumentsNamed {
     pub nodes: (List<Symbol, (Symbol, Identifier, Paren<Option<SequenceActualArg>>)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SequenceActualArg {
     EventExpression(Box<EventExpression>),
     SequenceExpr(Box<SequenceExpr>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BooleanAbbrev {
     ConsecutiveRepetition(Box<ConsecutiveRepetition>),
     NonConsecutiveRepetition(Box<NonConsecutiveRepetition>),
     GotoRepetition(Box<GotoRepetition>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceAbbrev {
     pub nodes: (ConsecutiveRepetition,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConsecutiveRepetition {
     Expression(Box<ConsecutiveRepetitionExpression>),
     Asterisk(Box<ConsecutiveRepetitionAsterisk>),
     Plus(Box<ConsecutiveRepetitionPlus>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConsecutiveRepetitionExpression {
     pub nodes: (Bracket<(Symbol, ConstOrRangeExpression)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConsecutiveRepetitionAsterisk {
     pub nodes: (Bracket<Symbol>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConsecutiveRepetitionPlus {
     pub nodes: (Bracket<Symbol>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonConsecutiveRepetition {
     pub nodes: (Bracket<(Symbol, ConstOrRangeExpression)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GotoRepetition {
     pub nodes: (Bracket<(Symbol, ConstOrRangeExpression)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstOrRangeExpression {
     ConstantExpression(Box<ConstantExpression>),
     CycleDelayConstRangeExpression(Box<CycleDelayConstRangeExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CycleDelayConstRangeExpression {
     Binary(Box<CycleDelayConstRangeExpressionBinary>),
     Dollar(Box<CycleDelayConstRangeExpressionDollar>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CycleDelayConstRangeExpressionBinary {
     pub nodes: (ConstantExpression, Symbol, ConstantExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CycleDelayConstRangeExpressionDollar {
     pub nodes: (ConstantExpression, Symbol, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ExpressionOrDist {
     pub nodes: (Expression, Option<(Keyword, Brace<DistList>)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssertionVariableDeclaration {
     pub nodes: (VarDataType, ListOfVariableDeclAssignments, Symbol),
 }

sv-parser-syntaxtree/src/declarations/block_item_declarations.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BlockItemDeclaration {
     Data(Box<BlockItemDeclarationData>),
     LocalParameter(Box<BlockItemDeclarationLocalParameter>),
@@ -10,22 +10,22 @@ pub enum BlockItemDeclaration {
     Let(Box<BlockItemDeclarationLet>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockItemDeclarationData {
     pub nodes: (Vec<AttributeInstance>, DataDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockItemDeclarationLocalParameter {
     pub nodes: (Vec<AttributeInstance>, LocalParameterDeclaration, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockItemDeclarationParameter {
     pub nodes: (Vec<AttributeInstance>, ParameterDeclaration, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockItemDeclarationLet {
     pub nodes: (Vec<AttributeInstance>, LetDeclaration),
 }

sv-parser-syntaxtree/src/declarations/covergroup_declarations.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CovergroupDeclaration {
     pub nodes: (
         Keyword,
@@ -16,34 +16,34 @@ pub struct CovergroupDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CoverageSpecOrOption {
     Spec(Box<CoverageSpecOrOptionSpec>),
     Option(Box<CoverageSpecOrOptionOption>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverageSpecOrOptionSpec {
     pub nodes: (Vec<AttributeInstance>, CoverageSpec),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverageSpecOrOptionOption {
     pub nodes: (Vec<AttributeInstance>, CoverageOption, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CoverageOption {
     Option(Box<CoverageOptionOption>),
     TypeOption(Box<CoverageOptionTypeOption>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverageOptionOption {
     pub nodes: (Keyword, Symbol, MemberIdentifier, Symbol, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverageOptionTypeOption {
     pub nodes: (
         Keyword,
@@ -54,70 +54,70 @@ pub struct CoverageOptionTypeOption {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CoverageSpec {
     CoverPoint(Box<CoverPoint>),
     CoverCross(Box<CoverCross>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CoverageEvent {
     ClockingEvent(Box<ClockingEvent>),
     Sample(Box<CoverageEventSample>),
     At(Box<CoverageEventAt>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverageEventSample {
     pub nodes: (Keyword, Keyword, Keyword, Paren<Option<TfPortList>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverageEventAt {
     pub nodes: (Symbol, Paren<BlockEventExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BlockEventExpression {
     Or(Box<BlockEventExpressionOr>),
     Begin(Box<BlockEventExpressionBegin>),
     End(Box<BlockEventExpressionEnd>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockEventExpressionOr {
     pub nodes: (BlockEventExpression, Keyword, BlockEventExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockEventExpressionBegin {
     pub nodes: (Keyword, HierarchicalBtfIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockEventExpressionEnd {
     pub nodes: (Keyword, HierarchicalBtfIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum HierarchicalBtfIdentifier {
     HierarchicalTfIdentifier(Box<HierarchicalTfIdentifier>),
     HierarchicalBlockIdentifier(Box<HierarchicalBlockIdentifier>),
     Method(Box<HierarchicalBtfIdentifierMethod>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalBtfIdentifierMethod {
     pub nodes: (Option<HierarchicalIdentifierOrClassScope>, MethodIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum HierarchicalIdentifierOrClassScope {
     HierarchicalIdentifier(Box<(HierarchicalIdentifier, Symbol)>),
     ClassScope(Box<ClassScope>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverPoint {
     pub nodes: (
         Option<(Option<DataTypeOrImplicit>, CoverPointIdentifier, Symbol)>,
@@ -128,18 +128,18 @@ pub struct CoverPoint {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BinsOrEmpty {
     NonEmpty(Box<BinsOrEmptyNonEmpty>),
     Empty(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsOrEmptyNonEmpty {
     pub nodes: (Brace<(Vec<AttributeInstance>, Vec<(BinsOrOptions, Symbol)>)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BinsOrOptions {
     CoverageOption(Box<CoverageOption>),
     Covergroup(Box<BinsOrOptionsCovergroup>),
@@ -150,7 +150,7 @@ pub enum BinsOrOptions {
     DefaultSequence(Box<BinsOrOptionsDefaultSequence>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsOrOptionsCovergroup {
     pub nodes: (
         Option<Wildcard>,
@@ -164,12 +164,12 @@ pub struct BinsOrOptionsCovergroup {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Wildcard {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsOrOptionsCoverPoint {
     pub nodes: (
         Option<Wildcard>,
@@ -184,7 +184,7 @@ pub struct BinsOrOptionsCoverPoint {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsOrOptionsSetCovergroup {
     pub nodes: (
         Option<Wildcard>,
@@ -197,7 +197,7 @@ pub struct BinsOrOptionsSetCovergroup {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsOrOptionsTransList {
     pub nodes: (
         Option<Wildcard>,
@@ -210,7 +210,7 @@ pub struct BinsOrOptionsTransList {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsOrOptionsDefault {
     pub nodes: (
         BinsKeyword,
@@ -222,7 +222,7 @@ pub struct BinsOrOptionsDefault {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsOrOptionsDefaultSequence {
     pub nodes: (
         BinsKeyword,
@@ -234,24 +234,24 @@ pub struct BinsOrOptionsDefaultSequence {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BinsKeyword {
     Bins(Box<Keyword>),
     IllegalBins(Box<Keyword>),
     IgnoreBins(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TransList {
     pub nodes: (List<Symbol, Paren<TransSet>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TransSet {
     pub nodes: (List<Symbol, TransRangeList>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TransRangeList {
     TransItem(Box<TransItem>),
     Asterisk(Box<TransRangeListAsterisk>),
@@ -259,38 +259,38 @@ pub enum TransRangeList {
     Equal(Box<TransRangeListEqual>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TransRangeListAsterisk {
     pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TransRangeListArrow {
     pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TransRangeListEqual {
     pub nodes: (TransItem, Bracket<(Symbol, RepeatRange)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TransItem {
     pub nodes: (CovergroupRangeList,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum RepeatRange {
     CovergroupExpression(Box<CovergroupExpression>),
     Binary(Box<RepeatRangeBinary>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RepeatRangeBinary {
     pub nodes: (CovergroupExpression, Symbol, CovergroupExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverCross {
     pub nodes: (
         Option<(CrossIdentifier, Symbol)>,
@@ -301,51 +301,51 @@ pub struct CoverCross {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfCrossItems {
     pub nodes: (CrossItem, Symbol, List<Symbol, CrossItem>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CrossItem {
     CoverPointIdentifier(Box<CoverPointIdentifier>),
     VariableIdentifier(Box<VariableIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CrossBody {
     NonEmpty(Box<CrossBodyNonEmpty>),
     Empty(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CrossBodyNonEmpty {
     pub nodes: (Brace<Vec<CrossBodyItem>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CrossBodyItem {
     FunctionDeclaration(Box<FunctionDeclaration>),
     BinsSelectionOrOption(Box<(BinsSelectionOrOption, Symbol)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BinsSelectionOrOption {
     Coverage(Box<BinsSelectionOrOptionCoverage>),
     Bins(Box<BinsSelectionOrOptionBins>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsSelectionOrOptionCoverage {
     pub nodes: (Vec<AttributeInstance>, CoverageOption),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsSelectionOrOptionBins {
     pub nodes: (Vec<AttributeInstance>, BinsSelection),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsSelection {
     pub nodes: (
         BinsKeyword,
@@ -356,7 +356,7 @@ pub struct BinsSelection {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SelectExpression {
     SelectCondition(Box<SelectCondition>),
     Not(Box<SelectExpressionNot>),
@@ -368,27 +368,27 @@ pub enum SelectExpression {
     CrossSet(Box<SelectExpressionCrossSet>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SelectExpressionNot {
     pub nodes: (Symbol, SelectCondition),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SelectExpressionAnd {
     pub nodes: (SelectExpression, Symbol, SelectExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SelectExpressionOr {
     pub nodes: (SelectExpression, Symbol, SelectExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SelectExpressionParen {
     pub nodes: (Paren<SelectExpression>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SelectExpressionWith {
     pub nodes: (
         SelectExpression,
@@ -398,7 +398,7 @@ pub struct SelectExpressionWith {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SelectExpressionCrossSet {
     pub nodes: (
         CrossSetExpression,
@@ -406,7 +406,7 @@ pub struct SelectExpressionCrossSet {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SelectCondition {
     pub nodes: (
         Keyword,
@@ -415,54 +415,54 @@ pub struct SelectCondition {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BinsExpression {
     VariableIdentifier(Box<VariableIdentifier>),
     CoverPoint(Box<BinsExpressionCoverPoint>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinsExpressionCoverPoint {
     pub nodes: (CoverPointIdentifier, Option<(Symbol, BinIdentifier)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CovergroupRangeList {
     pub nodes: (List<Symbol, CovergroupValueRange>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CovergroupValueRange {
     CovergroupExpression(Box<CovergroupExpression>),
     Binary(Box<CovergroupValueRangeBinary>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CovergroupValueRangeBinary {
     pub nodes: (Bracket<(CovergroupExpression, Symbol, CovergroupExpression)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct WithCovergroupExpression {
     pub nodes: (CovergroupExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SetCovergroupExpression {
     pub nodes: (CovergroupExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IntegerCovergroupExpression {
     pub nodes: (CovergroupExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CrossSetExpression {
     pub nodes: (CovergroupExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CovergroupExpression {
     pub nodes: (Expression,),
 }

sv-parser-syntaxtree/src/declarations/declaration_assignments.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DefparamAssignment {
     pub nodes: (
         HierarchicalParameterIdentifier,
@@ -11,7 +11,7 @@ pub struct DefparamAssignment {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetDeclAssignment {
     pub nodes: (
         NetIdentifier,
@@ -20,7 +20,7 @@ pub struct NetDeclAssignment {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParamAssignment {
     pub nodes: (
         ParameterIdentifier,
@@ -29,29 +29,29 @@ pub struct ParamAssignment {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SpecparamAssignment {
     Mintypmax(Box<SpecparamAssignmentMintypmax>),
     PulseControlSpecparam(Box<PulseControlSpecparam>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SpecparamAssignmentMintypmax {
     pub nodes: (SpecparamIdentifier, Symbol, ConstantMintypmaxExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TypeAssignment {
     pub nodes: (TypeIdentifier, Option<(Symbol, DataType)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PulseControlSpecparam {
     WithoutDescriptor(Box<PulseControlSpecparamWithoutDescriptor>),
     WithDescriptor(Box<PulseControlSpecparamWithDescriptor>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PulseControlSpecparamWithoutDescriptor {
     pub nodes: (
         Symbol,
@@ -60,7 +60,7 @@ pub struct PulseControlSpecparamWithoutDescriptor {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PulseControlSpecparamWithDescriptor {
     pub nodes: (
         Symbol,
@@ -72,29 +72,29 @@ pub struct PulseControlSpecparamWithDescriptor {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ErrorLimitValue {
     pub nodes: (LimitValue,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RejectLimitValue {
     pub nodes: (LimitValue,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LimitValue {
     pub nodes: (ConstantMintypmaxExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum VariableDeclAssignment {
     Variable(Box<VariableDeclAssignmentVariable>),
     DynamicArray(Box<VariableDeclAssignmentDynamicArray>),
     Class(Box<VariableDeclAssignmentClass>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariableDeclAssignmentVariable {
     pub nodes: (
         VariableIdentifier,
@@ -103,7 +103,7 @@ pub struct VariableDeclAssignmentVariable {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariableDeclAssignmentDynamicArray {
     pub nodes: (
         DynamicArrayVariableIdentifier,
@@ -113,28 +113,28 @@ pub struct VariableDeclAssignmentDynamicArray {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariableDeclAssignmentClass {
     pub nodes: (ClassVariableIdentifier, (Symbol, ClassNew)),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClassNew {
     Argument(Box<ClassNewArgument>),
     Expression(Box<ClassNewExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassNewArgument {
     pub nodes: (Option<ClassScope>, Keyword, Option<Paren<ListOfArguments>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassNewExpression {
     pub nodes: (Keyword, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DynamicArrayNew {
     pub nodes: (Keyword, Bracket<Expression>, Option<Paren<Expression>>),
 }

sv-parser-syntaxtree/src/declarations/declaration_lists.rs

@@ -2,47 +2,47 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfDefparamAssignments {
     pub nodes: (List<Symbol, DefparamAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfGenvarIdentifiers {
     pub nodes: (List<Symbol, GenvarIdentifier>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfInterfaceIdentifiers {
     pub nodes: (List<Symbol, (InterfaceIdentifier, Vec<UnpackedDimension>)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfNetDeclAssignments {
     pub nodes: (List<Symbol, NetDeclAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfParamAssignments {
     pub nodes: (List<Symbol, ParamAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfPortIdentifiers {
     pub nodes: (List<Symbol, (PortIdentifier, Vec<UnpackedDimension>)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfUdpPortIdentifiers {
     pub nodes: (List<Symbol, PortIdentifier>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfSpecparamAssignments {
     pub nodes: (List<Symbol, SpecparamAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfTfVariableIdentifiers {
     pub nodes: (
         List<
@@ -56,22 +56,22 @@ pub struct ListOfTfVariableIdentifiers {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfTypeAssignments {
     pub nodes: (List<Symbol, TypeAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfVariableDeclAssignments {
     pub nodes: (List<Symbol, VariableDeclAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfVariableIdentifiers {
     pub nodes: (List<Symbol, (VariableIdentifier, Vec<VariableDimension>)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfVariablePortIdentifiers {
     pub nodes: (
         List<

sv-parser-syntaxtree/src/declarations/declaration_ranges.rs

@@ -2,50 +2,50 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum UnpackedDimension {
     Range(Box<UnpackedDimensionRange>),
     Expression(Box<UnpackedDimensionExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UnpackedDimensionRange {
     pub nodes: (Bracket<ConstantRange>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UnpackedDimensionExpression {
     pub nodes: (Bracket<ConstantExpression>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PackedDimension {
     Range(Box<PackedDimensionRange>),
     UnsizedDimension(Box<UnsizedDimension>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PackedDimensionRange {
     pub nodes: (Bracket<ConstantRange>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum AssociativeDimension {
     DataType(Box<AssociativeDimensionDataType>),
     Asterisk(Box<AssociativeDimensionAsterisk>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssociativeDimensionDataType {
     pub nodes: (Bracket<DataType>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AssociativeDimensionAsterisk {
     pub nodes: (Bracket<Symbol>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum VariableDimension {
     UnsizedDimension(Box<UnsizedDimension>),
     UnpackedDimension(Box<UnpackedDimension>),
@@ -53,12 +53,12 @@ pub enum VariableDimension {
     QueueDimension(Box<QueueDimension>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct QueueDimension {
     pub nodes: (Bracket<(Symbol, Option<(Symbol, ConstantExpression)>)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UnsizedDimension {
     pub nodes: (Symbol, Symbol),
 }

sv-parser-syntaxtree/src/declarations/delays.rs

@@ -2,18 +2,18 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Delay3 {
     Single(Box<Delay3Single>),
     Mintypmax(Box<Delay3Mintypmax>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Delay3Single {
     pub nodes: (Symbol, DelayValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Delay3Mintypmax {
     pub nodes: (
         Symbol,
@@ -28,18 +28,18 @@ pub struct Delay3Mintypmax {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Delay2 {
     Single(Box<Delay2Single>),
     Mintypmax(Box<Delay2Mintypmax>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Delay2Single {
     pub nodes: (Symbol, DelayValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Delay2Mintypmax {
     pub nodes: (
         Symbol,
@@ -47,7 +47,7 @@ pub struct Delay2Mintypmax {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DelayValue {
     UnsignedNumber(Box<UnsignedNumber>),
     RealNumber(Box<RealNumber>),

sv-parser-syntaxtree/src/declarations/function_declarations.rs

@@ -2,24 +2,24 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum FunctionDataTypeOrImplicit {
     DataTypeOrVoid(Box<DataTypeOrVoid>),
     ImplicitDataType(Box<ImplicitDataType>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FunctionDeclaration {
     pub nodes: (Keyword, Option<Lifetime>, FunctionBodyDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum FunctionBodyDeclaration {
     WithoutPort(Box<FunctionBodyDeclarationWithoutPort>),
     WithPort(Box<FunctionBodyDeclarationWithPort>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FunctionBodyDeclarationWithoutPort {
     pub nodes: (
         FunctionDataTypeOrImplicit,
@@ -33,7 +33,7 @@ pub struct FunctionBodyDeclarationWithoutPort {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FunctionBodyDeclarationWithPort {
     pub nodes: (
         FunctionDataTypeOrImplicit,
@@ -48,13 +48,13 @@ pub struct FunctionBodyDeclarationWithPort {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum InterfaceIdentifierOrClassScope {
     InterfaceIdentifier(Box<(InterfaceIdentifier, Symbol)>),
     ClassScope(Box<ClassScope>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FunctionPrototype {
     pub nodes: (
         Keyword,
@@ -64,7 +64,7 @@ pub struct FunctionPrototype {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DpiImportExport {
     ImportFunction(Box<DpiImportExportImportFunction>),
     ImportTask(Box<DpiImportExportImportTask>),
@@ -72,7 +72,7 @@ pub enum DpiImportExport {
     ExportTask(Box<DpiImportExportExportTask>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DpiImportExportImportFunction {
     pub nodes: (
         Keyword,
@@ -84,7 +84,7 @@ pub struct DpiImportExportImportFunction {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DpiImportExportImportTask {
     pub nodes: (
         Keyword,
@@ -96,7 +96,7 @@ pub struct DpiImportExportImportTask {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DpiImportExportExportFunction {
     pub nodes: (
         Keyword,
@@ -108,7 +108,7 @@ pub struct DpiImportExportExportFunction {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DpiImportExportExportTask {
     pub nodes: (
         Keyword,
@@ -120,29 +120,29 @@ pub struct DpiImportExportExportTask {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DpiSpecString {
     DpiC(Box<Keyword>),
     Dpi(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DpiFunctionImportProperty {
     Context(Box<Keyword>),
     Pure(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DpiTaskImportProperty {
     Context(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DpiFunctionProto {
     pub nodes: (FunctionPrototype,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DpiTaskProto {
     pub nodes: (TaskPrototype,),
 }

sv-parser-syntaxtree/src/declarations/interface_declarations.rs

@@ -2,12 +2,12 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportDeclaration {
     pub nodes: (Keyword, List<Symbol, ModportItem>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportItem {
     pub nodes: (
         ModportIdentifier,
@@ -15,66 +15,66 @@ pub struct ModportItem {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModportPortsDeclaraton {
     Simple(Box<ModportPortsDeclaratonSimple>),
     Tf(Box<ModportPortsDeclaratonTf>),
     Clocking(Box<ModportPortsDeclaratonClocking>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportPortsDeclaratonSimple {
     pub nodes: (Vec<AttributeInstance>, ModportSimplePortsDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportPortsDeclaratonTf {
     pub nodes: (Vec<AttributeInstance>, ModportTfPortsDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportPortsDeclaratonClocking {
     pub nodes: (Vec<AttributeInstance>, ModportClockingDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportClockingDeclaration {
     pub nodes: (Keyword, ClockingIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportSimplePortsDeclaration {
     pub nodes: (PortDirection, List<Symbol, ModportSimplePort>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModportSimplePort {
     Ordered(Box<ModportSimplePortOrdered>),
     Named(Box<ModportSimplePortNamed>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportSimplePortOrdered {
     pub nodes: (PortIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportSimplePortNamed {
     pub nodes: (Symbol, PortIdentifier, Paren<Option<Expression>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportTfPortsDeclaration {
     pub nodes: (ImportExport, List<Symbol, ModportTfPort>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModportTfPort {
     MethodPrototype(Box<MethodPrototype>),
     TfIdentifier(Box<TfIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ImportExport {
     Import(Box<Keyword>),
     Export(Box<Keyword>),

sv-parser-syntaxtree/src/declarations/let_declarations.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LetDeclaration {
     pub nodes: (
         Keyword,
@@ -14,17 +14,17 @@ pub struct LetDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LetIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LetPortList {
     pub nodes: (List<Symbol, LetPortItem>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LetPortItem {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -35,13 +35,13 @@ pub struct LetPortItem {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum LetFormalType {
     DataTypeOrImplicit(Box<DataTypeOrImplicit>),
     Untyped(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LetExpression {
     pub nodes: (
         Option<PackageScope>,
@@ -50,13 +50,13 @@ pub struct LetExpression {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum LetListOfArguments {
     Ordered(Box<LetListOfArgumentsOrdered>),
     Named(Box<LetListOfArgumentsNamed>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LetListOfArgumentsOrdered {
     pub nodes: (
         List<Symbol, Option<LetActualArg>>,
@@ -64,12 +64,12 @@ pub struct LetListOfArgumentsOrdered {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LetListOfArgumentsNamed {
     pub nodes: (List<Symbol, (Symbol, Identifier, Paren<Option<LetActualArg>>)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LetActualArg {
     pub nodes: (Expression,),
 }

sv-parser-syntaxtree/src/declarations/module_parameter_declarations.rs

@@ -2,39 +2,39 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum LocalParameterDeclaration {
     Param(Box<LocalParameterDeclarationParam>),
     Type(Box<LocalParameterDeclarationType>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LocalParameterDeclarationParam {
     pub nodes: (Keyword, DataTypeOrImplicit, ListOfParamAssignments),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LocalParameterDeclarationType {
     pub nodes: (Keyword, Keyword, ListOfTypeAssignments),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ParameterDeclaration {
     Param(Box<ParameterDeclarationParam>),
     Type(Box<ParameterDeclarationType>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParameterDeclarationParam {
     pub nodes: (Keyword, DataTypeOrImplicit, ListOfParamAssignments),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParameterDeclarationType {
     pub nodes: (Keyword, Keyword, ListOfTypeAssignments),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SpecparamDeclaration {
     pub nodes: (
         Keyword,

sv-parser-syntaxtree/src/declarations/net_and_variable_types.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CastingType {
     SimpleType(Box<SimpleType>),
     ConstantPrimary(Box<ConstantPrimary>),
@@ -11,7 +11,7 @@ pub enum CastingType {
     Const(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DataType {
     Vector(Box<DataTypeVector>),
     Atom(Box<DataTypeAtom>),
@@ -28,17 +28,17 @@ pub enum DataType {
     TypeReference(Box<TypeReference>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DataTypeVector {
     pub nodes: (IntegerVectorType, Option<Signing>, Vec<PackedDimension>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DataTypeAtom {
     pub nodes: (IntegerAtomType, Option<Signing>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DataTypeStructUnion {
     pub nodes: (
         StructUnion,
@@ -48,12 +48,12 @@ pub struct DataTypeStructUnion {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Packed {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DataTypeEnum {
     pub nodes: (
         Keyword,
@@ -63,7 +63,7 @@ pub struct DataTypeEnum {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DataTypeVirtual {
     pub nodes: (
         Keyword,
@@ -74,12 +74,12 @@ pub struct DataTypeVirtual {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Interface {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DataTypeType {
     pub nodes: (
         Option<PackageScopeOrClassScope>,
@@ -88,40 +88,40 @@ pub struct DataTypeType {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DataTypeOrImplicit {
     DataType(Box<DataType>),
     ImplicitDataType(Box<ImplicitDataType>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ImplicitDataType {
     pub nodes: (Option<Signing>, Vec<PackedDimension>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum EnumBaseType {
     Atom(Box<EnumBaseTypeAtom>),
     Vector(Box<EnumBaseTypeVector>),
     Type(Box<EnumBaseTypeType>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EnumBaseTypeAtom {
     pub nodes: (IntegerAtomType, Option<Signing>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EnumBaseTypeVector {
     pub nodes: (IntegerVectorType, Option<Signing>, Option<PackedDimension>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EnumBaseTypeType {
     pub nodes: (TypeIdentifier, Option<PackedDimension>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EnumNameDeclaration {
     pub nodes: (
         EnumIdentifier,
@@ -130,12 +130,12 @@ pub struct EnumNameDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassScope {
     pub nodes: (ClassType, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassType {
     pub nodes: (
         PsClassIdentifier,
@@ -144,13 +144,13 @@ pub struct ClassType {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum IntegerType {
     IntegerVectorType(Box<IntegerVectorType>),
     IntegerAtomType(Box<IntegerAtomType>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum IntegerAtomType {
     Byte(Box<Keyword>),
     Shortint(Box<Keyword>),
@@ -160,21 +160,21 @@ pub enum IntegerAtomType {
     Time(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum IntegerVectorType {
     Bit(Box<Keyword>),
     Logic(Box<Keyword>),
     Reg(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NonIntegerType {
     Shortreal(Box<Keyword>),
     Real(Box<Keyword>),
     Realtime(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NetType {
     Supply0(Box<Keyword>),
     Supply1(Box<Keyword>),
@@ -190,46 +190,46 @@ pub enum NetType {
     Wor(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NetPortType {
     DataType(Box<NetPortTypeDataType>),
     NetTypeIdentifier(Box<NetTypeIdentifier>),
     Interconnect(Box<NetPortTypeInterconnect>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetPortTypeDataType {
     pub nodes: (Option<NetType>, DataTypeOrImplicit),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetPortTypeInterconnect {
     pub nodes: (Keyword, ImplicitDataType),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariablePortType {
     pub nodes: (VarDataType,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum VarDataType {
     DataType(Box<DataType>),
     Var(Box<VarDataTypeVar>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VarDataTypeVar {
     pub nodes: (Keyword, DataTypeOrImplicit),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Signing {
     Signed(Box<Keyword>),
     Unsigned(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SimpleType {
     IntegerType(Box<IntegerType>),
     NonIntegerType(Box<NonIntegerType>),
@@ -237,7 +237,7 @@ pub enum SimpleType {
     PsParameterIdentifier(Box<PsParameterIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StructUnionMember {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -248,31 +248,31 @@ pub struct StructUnionMember {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DataTypeOrVoid {
     DataType(Box<DataType>),
     Void(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum StructUnion {
     Struct(Box<Keyword>),
     Union(Box<Keyword>),
     UnionTagged(Box<(Keyword, Keyword)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TypeReference {
     Expression(Box<TypeReferenceExpression>),
     DataType(Box<TypeReferenceDataType>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TypeReferenceExpression {
     pub nodes: (Keyword, Paren<Expression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TypeReferenceDataType {
     pub nodes: (Keyword, Paren<DataType>),
 }

sv-parser-syntaxtree/src/declarations/port_declarations.rs

@@ -2,44 +2,44 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InoutDeclaration {
     pub nodes: (Keyword, NetPortType, ListOfPortIdentifiers),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum InputDeclaration {
     Net(Box<InputDeclarationNet>),
     Variable(Box<InputDeclarationVariable>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InputDeclarationNet {
     pub nodes: (Keyword, NetPortType, ListOfPortIdentifiers),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InputDeclarationVariable {
     pub nodes: (Keyword, VariablePortType, ListOfVariableIdentifiers),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum OutputDeclaration {
     Net(Box<OutputDeclarationNet>),
     Variable(Box<OutputDeclarationVariable>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OutputDeclarationNet {
     pub nodes: (Keyword, NetPortType, ListOfPortIdentifiers),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OutputDeclarationVariable {
     pub nodes: (Keyword, VariablePortType, ListOfVariablePortIdentifiers),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfacePortDeclaration {
     pub nodes: (
         InterfaceIdentifier,
@@ -48,7 +48,7 @@ pub struct InterfacePortDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RefDeclaration {
     pub nodes: (Keyword, VariablePortType, ListOfVariableIdentifiers),
 }

sv-parser-syntaxtree/src/declarations/strengths.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DriveStrength {
     Strength01(Box<DriveStrength01>),
     Strength10(Box<DriveStrength10>),
@@ -12,37 +12,37 @@ pub enum DriveStrength {
     Strengthz1(Box<DriveStrengthz1>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DriveStrength01 {
     pub nodes: (Paren<(Strength0, Symbol, Strength1)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DriveStrength10 {
     pub nodes: (Paren<(Strength1, Symbol, Strength0)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DriveStrength0z {
     pub nodes: (Paren<(Strength0, Symbol, Keyword)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DriveStrength1z {
     pub nodes: (Paren<(Strength1, Symbol, Keyword)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DriveStrengthz1 {
     pub nodes: (Paren<(Keyword, Symbol, Strength1)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DriveStrengthz0 {
     pub nodes: (Paren<(Keyword, Symbol, Strength0)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Strength0 {
     Supply0(Box<Keyword>),
     Strong0(Box<Keyword>),
@@ -50,7 +50,7 @@ pub enum Strength0 {
     Weak0(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Strength1 {
     Supply1(Box<Keyword>),
     Strong1(Box<Keyword>),
@@ -58,24 +58,24 @@ pub enum Strength1 {
     Weak1(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ChargeStrength {
     Small(Box<ChargeStrengthSmall>),
     Medium(Box<ChargeStrengthMedium>),
     Large(Box<ChargeStrengthLarge>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ChargeStrengthSmall {
     pub nodes: (Paren<Keyword>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ChargeStrengthMedium {
     pub nodes: (Paren<Keyword>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ChargeStrengthLarge {
     pub nodes: (Paren<Keyword>,),
 }

sv-parser-syntaxtree/src/declarations/task_declarations.rs

@@ -2,18 +2,18 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TaskDeclaration {
     pub nodes: (Keyword, Option<Lifetime>, TaskBodyDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TaskBodyDeclaration {
     WithoutPort(Box<TaskBodyDeclarationWithoutPort>),
     WithPort(Box<TaskBodyDeclarationWithPort>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TaskBodyDeclarationWithoutPort {
     pub nodes: (
         Option<InterfaceIdentifierOrClassScope>,
@@ -26,7 +26,7 @@ pub struct TaskBodyDeclarationWithoutPort {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TaskBodyDeclarationWithPort {
     pub nodes: (
         Option<InterfaceIdentifierOrClassScope>,
@@ -40,18 +40,18 @@ pub struct TaskBodyDeclarationWithPort {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TfItemDeclaration {
     BlockItemDeclaration(Box<BlockItemDeclaration>),
     TfPortDeclaration(Box<TfPortDeclaration>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TfPortList {
     pub nodes: (List<Symbol, TfPortItem>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TfPortItem {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -66,13 +66,13 @@ pub struct TfPortItem {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TfPortDirection {
     PortDirection(Box<PortDirection>),
     ConstRef(Box<(Keyword, Keyword)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TfPortDeclaration {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -84,7 +84,7 @@ pub struct TfPortDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TaskPrototype {
     pub nodes: (Keyword, TaskIdentifier, Option<Paren<Option<TfPortList>>>),
 }

sv-parser-syntaxtree/src/declarations/type_declarations.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DataDeclaration {
     Variable(Box<DataDeclarationVariable>),
     TypeDeclaration(Box<TypeDeclaration>),
@@ -10,7 +10,7 @@ pub enum DataDeclaration {
     NetTypeDeclaration(Box<NetTypeDeclaration>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DataDeclarationVariable {
     pub nodes: (
         Option<Const>,
@@ -22,61 +22,61 @@ pub struct DataDeclarationVariable {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Const {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PackageImportDeclaration {
     pub nodes: (Keyword, List<Symbol, PackageImportItem>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PackageImportItem {
     Identifier(Box<PackageImportItemIdentifier>),
     Asterisk(Box<PackageImportItemAsterisk>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PackageImportItemIdentifier {
     pub nodes: (PackageIdentifier, Symbol, Identifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PackageImportItemAsterisk {
     pub nodes: (PackageIdentifier, Symbol, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PackageExportDeclaration {
     Asterisk(Box<PackageExportDeclarationAsterisk>),
     Item(Box<PackageExportDeclarationItem>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PackageExportDeclarationAsterisk {
     pub nodes: (Keyword, Symbol, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PackageExportDeclarationItem {
     pub nodes: (Keyword, List<Symbol, PackageImportItem>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GenvarDeclaration {
     pub nodes: (Keyword, ListOfGenvarIdentifiers, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NetDeclaration {
     NetType(Box<NetDeclarationNetType>),
     NetTypeIdentifier(Box<NetDeclarationNetTypeIdentifier>),
     Interconnect(Box<NetDeclarationInterconnect>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetDeclarationNetType {
     pub nodes: (
         NetType,
@@ -89,19 +89,19 @@ pub struct NetDeclarationNetType {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Strength {
     Drive(Box<DriveStrength>),
     Charge(Box<ChargeStrength>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum VectorScalar {
     Vectored(Box<Keyword>),
     Scalared(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetDeclarationNetTypeIdentifier {
     pub nodes: (
         NetTypeIdentifier,
@@ -111,7 +111,7 @@ pub struct NetDeclarationNetTypeIdentifier {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetDeclarationInterconnect {
     pub nodes: (
         Keyword,
@@ -124,14 +124,14 @@ pub struct NetDeclarationInterconnect {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TypeDeclaration {
     DataType(Box<TypeDeclarationDataType>),
     Interface(Box<TypeDeclarationInterface>),
     Reserved(Box<TypeDeclarationReserved>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TypeDeclarationDataType {
     pub nodes: (
         Keyword,
@@ -142,7 +142,7 @@ pub struct TypeDeclarationDataType {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TypeDeclarationInterface {
     pub nodes: (
         Keyword,
@@ -155,7 +155,7 @@ pub struct TypeDeclarationInterface {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TypeDeclarationReserved {
     pub nodes: (
         Keyword,
@@ -165,7 +165,7 @@ pub struct TypeDeclarationReserved {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TypeDeclarationKeyword {
     Enum(Box<Keyword>),
     Struct(Box<Keyword>),
@@ -174,13 +174,13 @@ pub enum TypeDeclarationKeyword {
     InterfaceClass(Box<(Keyword, Keyword)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NetTypeDeclaration {
     DataType(Box<NetTypeDeclarationDataType>),
     NetType(Box<NetTypeDeclarationNetType>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetTypeDeclarationDataType {
     pub nodes: (
         Keyword,
@@ -191,7 +191,7 @@ pub struct NetTypeDeclarationDataType {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetTypeDeclarationNetType {
     pub nodes: (
         Keyword,
@@ -202,7 +202,7 @@ pub struct NetTypeDeclarationNetType {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Lifetime {
     Static(Box<Keyword>),
     Automatic(Box<Keyword>),

sv-parser-syntaxtree/src/expressions/concatenations.rs

@@ -2,63 +2,63 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Concatenation {
     pub nodes: (Brace<List<Symbol, Expression>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantConcatenation {
     pub nodes: (Brace<List<Symbol, ConstantExpression>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantMultipleConcatenation {
     pub nodes: (Brace<(ConstantExpression, ConstantConcatenation)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModulePathConcatenation {
     pub nodes: (Brace<List<Symbol, ModulePathExpression>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModulePathMultipleConcatenation {
     pub nodes: (Brace<(ConstantExpression, ModulePathConcatenation)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct MultipleConcatenation {
     pub nodes: (Brace<(Expression, Concatenation)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StreamingConcatenation {
     pub nodes: (Brace<(StreamOperator, Option<SliceSize>, StreamConcatenation)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StreamOperator {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SliceSize {
     SimpleType(Box<SimpleType>),
     ConstantExpression(Box<ConstantExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StreamConcatenation {
     pub nodes: (Brace<List<Symbol, StreamExpression>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StreamExpression {
     pub nodes: (Expression, Option<(Keyword, Bracket<ArrayRangeExpression>)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ArrayRangeExpression {
     Expression(Box<Expression>),
     Colon(Box<ArrayRangeExpressionColon>),
@@ -66,22 +66,22 @@ pub enum ArrayRangeExpression {
     MinusColon(Box<ArrayRangeExpressionMinusColon>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ArrayRangeExpressionColon {
     pub nodes: (Expression, Symbol, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ArrayRangeExpressionPlusColon {
     pub nodes: (Expression, Symbol, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ArrayRangeExpressionMinusColon {
     pub nodes: (Expression, Symbol, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EmptyUnpackedArrayConcatenation {
     pub nodes: (Symbol, Symbol),
 }

sv-parser-syntaxtree/src/expressions/expression_leftside_values.rs

@@ -2,24 +2,24 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NetLvalue {
     Identifier(Box<NetLvalueIdentifier>),
     Lvalue(Box<NetLvalueLvalue>),
     Pattern(Box<NetLvaluePattern>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetLvalueIdentifier {
     pub nodes: (PsOrHierarchicalNetIdentifier, ConstantSelect),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetLvalueLvalue {
     pub nodes: (Brace<List<Symbol, NetLvalue>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetLvaluePattern {
     pub nodes: (
         Option<AssignmentPatternExpressionType>,
@@ -27,7 +27,7 @@ pub struct NetLvaluePattern {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum VariableLvalue {
     Identifier(Box<VariableLvalueIdentifier>),
     Lvalue(Box<VariableLvalueLvalue>),
@@ -35,7 +35,7 @@ pub enum VariableLvalue {
     StreamingConcatenation(Box<StreamingConcatenation>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariableLvalueIdentifier {
     pub nodes: (
         Option<ImplicitClassHandleOrPackageScope>,
@@ -44,12 +44,12 @@ pub struct VariableLvalueIdentifier {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariableLvalueLvalue {
     pub nodes: (Brace<List<Symbol, VariableLvalue>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariableLvaluePattern {
     pub nodes: (
         Option<AssignmentPatternExpressionType>,
@@ -57,7 +57,7 @@ pub struct VariableLvaluePattern {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonrangeVariableLvalue {
     pub nodes: (
         Option<ImplicitClassHandleOrPackageScope>,

sv-parser-syntaxtree/src/expressions/expressions.rs

@@ -2,23 +2,23 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum IncOrDecExpression {
     Prefix(Box<IncOrDecExpressionPrefix>),
     Suffix(Box<IncOrDecExpressionSuffix>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IncOrDecExpressionPrefix {
     pub nodes: (IncOrDecOperator, Vec<AttributeInstance>, VariableLvalue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IncOrDecExpressionSuffix {
     pub nodes: (VariableLvalue, Vec<AttributeInstance>, IncOrDecOperator),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConditionalExpression {
     pub nodes: (
         CondPredicate,
@@ -30,7 +30,7 @@ pub struct ConditionalExpression {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstantExpression {
     ConstantPrimary(Box<ConstantPrimary>),
     Unary(Box<ConstantExpressionUnary>),
@@ -38,12 +38,12 @@ pub enum ConstantExpression {
     Ternary(Box<ConstantExpressionTernary>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantExpressionUnary {
     pub nodes: (UnaryOperator, Vec<AttributeInstance>, ConstantPrimary),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantExpressionBinary {
     pub nodes: (
         ConstantExpression,
@@ -53,7 +53,7 @@ pub struct ConstantExpressionBinary {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantExpressionTernary {
     pub nodes: (
         ConstantExpression,
@@ -65,13 +65,13 @@ pub struct ConstantExpressionTernary {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstantMintypmaxExpression {
     Unary(Box<ConstantExpression>),
     Ternary(Box<ConstantMintypmaxExpressionTernary>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantMintypmaxExpressionTernary {
     pub nodes: (
         ConstantExpression,
@@ -82,43 +82,43 @@ pub struct ConstantMintypmaxExpressionTernary {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstantParamExpression {
     ConstantMintypmaxExpression(Box<ConstantMintypmaxExpression>),
     DataType(Box<DataType>),
     Dollar(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ParamExpression {
     MintypmaxExpression(Box<MintypmaxExpression>),
     DataType(Box<DataType>),
     Dollar(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstantRangeExpression {
     ConstantExpression(Box<ConstantExpression>),
     ConstantPartSelectRange(Box<ConstantPartSelectRange>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstantPartSelectRange {
     ConstantRange(Box<ConstantRange>),
     ConstantIndexedRange(Box<ConstantIndexedRange>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantRange {
     pub nodes: (ConstantExpression, Symbol, ConstantExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantIndexedRange {
     pub nodes: (ConstantExpression, Symbol, ConstantExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Expression {
     Primary(Box<Primary>),
     Unary(Box<ExpressionUnary>),
@@ -130,17 +130,17 @@ pub enum Expression {
     TaggedUnionExpression(Box<TaggedUnionExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ExpressionUnary {
     pub nodes: (UnaryOperator, Vec<AttributeInstance>, Primary),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ExpressionOperatorAssignment {
     pub nodes: (Paren<OperatorAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ExpressionBinary {
     pub nodes: (
         Expression,
@@ -150,39 +150,39 @@ pub struct ExpressionBinary {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TaggedUnionExpression {
     pub nodes: (Keyword, MemberIdentifier, Option<Expression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InsideExpression {
     pub nodes: (Expression, Keyword, Brace<OpenRangeList>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ValueRange {
     Expression(Box<Expression>),
     Binary(Box<ValueRangeBinary>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ValueRangeBinary {
     pub nodes: (Bracket<(Expression, Symbol, Expression)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum MintypmaxExpression {
     Expression(Box<Expression>),
     Ternary(Box<MintypmaxExpressionTernary>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct MintypmaxExpressionTernary {
     pub nodes: (Expression, Symbol, Expression, Symbol, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModulePathConditionalExpression {
     pub nodes: (
         ModulePathExpression,
@@ -194,7 +194,7 @@ pub struct ModulePathConditionalExpression {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModulePathExpression {
     ModulePathPrimary(Box<ModulePathPrimary>),
     Unary(Box<ModulePathExpressionUnary>),
@@ -202,7 +202,7 @@ pub enum ModulePathExpression {
     ModulePathConditionalExpression(Box<ModulePathConditionalExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModulePathExpressionUnary {
     pub nodes: (
         UnaryModulePathOperator,
@@ -211,7 +211,7 @@ pub struct ModulePathExpressionUnary {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModulePathExpressionBinary {
     pub nodes: (
         ModulePathExpression,
@@ -221,13 +221,13 @@ pub struct ModulePathExpressionBinary {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModulePathMintypmaxExpression {
     ModulePathExpression(Box<ModulePathExpression>),
     Ternary(Box<ModulePathMintypmaxExpressionTernary>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModulePathMintypmaxExpressionTernary {
     pub nodes: (
         ModulePathExpression,
@@ -238,18 +238,18 @@ pub struct ModulePathMintypmaxExpressionTernary {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PartSelectRange {
     ConstantRange(Box<ConstantRange>),
     IndexedRange(Box<IndexedRange>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IndexedRange {
     pub nodes: (Expression, Symbol, ConstantExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GenvarExpression {
     pub nodes: (ConstantExpression,),
 }

sv-parser-syntaxtree/src/expressions/numbers.rs

@@ -2,13 +2,13 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Number {
     IntegralNumber(Box<IntegralNumber>),
     RealNumber(Box<RealNumber>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum IntegralNumber {
     DecimalNumber(Box<DecimalNumber>),
     OctalNumber(Box<OctalNumber>),
@@ -16,7 +16,7 @@ pub enum IntegralNumber {
     HexNumber(Box<HexNumber>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DecimalNumber {
     UnsignedNumber(Box<UnsignedNumber>),
     BaseUnsigned(Box<DecimalNumberBaseUnsigned>),
@@ -24,59 +24,59 @@ pub enum DecimalNumber {
     BaseZNumber(Box<DecimalNumberBaseZNumber>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DecimalNumberBaseUnsigned {
     pub nodes: (Option<Size>, DecimalBase, UnsignedNumber),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DecimalNumberBaseXNumber {
     pub nodes: (Option<Size>, DecimalBase, XNumber),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DecimalNumberBaseZNumber {
     pub nodes: (Option<Size>, DecimalBase, ZNumber),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinaryNumber {
     pub nodes: (Option<Size>, BinaryBase, BinaryValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OctalNumber {
     pub nodes: (Option<Size>, OctalBase, OctalValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HexNumber {
     pub nodes: (Option<Size>, HexBase, HexValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Sign {
     Plus(Box<Symbol>),
     Minus(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Size {
     pub nodes: (NonZeroUnsignedNumber,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonZeroUnsignedNumber {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum RealNumber {
     FixedPointNumber(Box<FixedPointNumber>),
     Floating(Box<RealNumberFloating>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RealNumberFloating {
     pub nodes: (
         UnsignedNumber,
@@ -87,67 +87,67 @@ pub struct RealNumberFloating {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FixedPointNumber {
     pub nodes: (UnsignedNumber, Symbol, UnsignedNumber),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Exp {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UnsignedNumber {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinaryValue {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OctalValue {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HexValue {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DecimalBase {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinaryBase {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OctalBase {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HexBase {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct XNumber {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ZNumber {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UnbasedUnsizedLiteral {
     pub nodes: (Symbol,),
 }

sv-parser-syntaxtree/src/expressions/operators.rs

@@ -2,27 +2,27 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UnaryOperator {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinaryOperator {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IncOrDecOperator {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UnaryModulePathOperator {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinaryModulePathOperator {
     pub nodes: (Symbol,),
 }

sv-parser-syntaxtree/src/expressions/primaries.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstantPrimary {
     PrimaryLiteral(Box<PrimaryLiteral>),
     PsParameter(Box<ConstantPrimaryPsParameter>),
@@ -21,12 +21,12 @@ pub enum ConstantPrimary {
     Null(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantPrimaryPsParameter {
     pub nodes: (PsParameterIdentifier, ConstantSelect),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantPrimarySpecparam {
     pub nodes: (
         SpecparamIdentifier,
@@ -34,17 +34,17 @@ pub struct ConstantPrimarySpecparam {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantPrimaryFormalPort {
     pub nodes: (FormalPortIdentifier, ConstantSelect),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantPrimaryEnum {
     pub nodes: (PackageScopeOrClassScope, EnumIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantPrimaryConcatenation {
     pub nodes: (
         ConstantConcatenation,
@@ -52,7 +52,7 @@ pub struct ConstantPrimaryConcatenation {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantPrimaryMultipleConcatenation {
     pub nodes: (
         ConstantMultipleConcatenation,
@@ -60,12 +60,12 @@ pub struct ConstantPrimaryMultipleConcatenation {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantPrimaryMintypmaxExpression {
     pub nodes: (Paren<ConstantMintypmaxExpression>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModulePathPrimary {
     Number(Box<Number>),
     Identifier(Box<Identifier>),
@@ -75,12 +75,12 @@ pub enum ModulePathPrimary {
     Mintypmax(Box<ModulePathPrimaryMintypmax>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModulePathPrimaryMintypmax {
     pub nodes: (Paren<ModulePathMintypmaxExpression>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Primary {
     PrimaryLiteral(Box<PrimaryLiteral>),
     Hierarchical(Box<PrimaryHierarchical>),
@@ -99,7 +99,7 @@ pub enum Primary {
     Null(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PrimaryHierarchical {
     pub nodes: (
         Option<ClassQualifierOrPackageScope>,
@@ -108,39 +108,39 @@ pub struct PrimaryHierarchical {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PrimaryConcatenation {
     pub nodes: (Concatenation, Option<Bracket<RangeExpression>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PrimaryMultipleConcatenation {
     pub nodes: (MultipleConcatenation, Option<Bracket<RangeExpression>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PrimaryMintypmaxExpression {
     pub nodes: (Paren<MintypmaxExpression>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClassQualifierOrPackageScope {
     ClassQualifier(Box<ClassQualifier>),
     PackageScope(Box<PackageScope>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassQualifier {
     pub nodes: (Option<Local>, Option<ImplicitClassHandleOrClassScope>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum RangeExpression {
     Expression(Box<Expression>),
     PartSelectRange(Box<PartSelectRange>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PrimaryLiteral {
     Number(Box<Number>),
     TimeLiteral(Box<TimeLiteral>),
@@ -148,23 +148,23 @@ pub enum PrimaryLiteral {
     StringLiteral(Box<StringLiteral>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TimeLiteral {
     Unsigned(Box<TimeLiteralUnsigned>),
     FixedPoint(Box<TimeLiteralFixedPoint>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimeLiteralUnsigned {
     pub nodes: (UnsignedNumber, TimeUnit),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimeLiteralFixedPoint {
     pub nodes: (FixedPointNumber, TimeUnit),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TimeUnit {
     S(Box<Keyword>),
     MS(Box<Keyword>),
@@ -174,19 +174,19 @@ pub enum TimeUnit {
     FS(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ImplicitClassHandle {
     This(Box<Keyword>),
     Super(Box<Keyword>),
     ThisSuper(Box<(Keyword, Symbol, Keyword)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BitSelect {
     pub nodes: (Vec<Bracket<Expression>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Select {
     pub nodes: (
         Option<(
@@ -199,7 +199,7 @@ pub struct Select {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonrangeSelect {
     pub nodes: (
         Option<(
@@ -211,12 +211,12 @@ pub struct NonrangeSelect {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantBitSelect {
     pub nodes: (Vec<Bracket<ConstantExpression>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantSelect {
     pub nodes: (
         Option<(
@@ -229,17 +229,17 @@ pub struct ConstantSelect {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantCast {
     pub nodes: (CastingType, Symbol, Paren<ConstantExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantLetExpression {
     pub nodes: (LetExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Cast {
     pub nodes: (CastingType, Symbol, Paren<Expression>),
 }

sv-parser-syntaxtree/src/expressions/strings.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StringLiteral {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }

sv-parser-syntaxtree/src/expressions/subroutine_calls.rs

@@ -2,12 +2,12 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstantFunctionCall {
     pub nodes: (FunctionSubroutineCall,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TfCall {
     pub nodes: (
         PsOrHierarchicalTfIdentifier,
@@ -16,19 +16,19 @@ pub struct TfCall {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SystemTfCall {
     ArgOptionl(Box<SystemTfCallArgOptional>),
     ArgDataType(Box<SystemTfCallArgDataType>),
     ArgExpression(Box<SystemTfCallArgExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SystemTfCallArgOptional {
     pub nodes: (SystemTfIdentifier, Option<Paren<ListOfArguments>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SystemTfCallArgDataType {
     pub nodes: (
         SystemTfIdentifier,
@@ -36,7 +36,7 @@ pub struct SystemTfCallArgDataType {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SystemTfCallArgExpression {
     pub nodes: (
         SystemTfIdentifier,
@@ -47,7 +47,7 @@ pub struct SystemTfCallArgExpression {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SubroutineCall {
     TfCall(Box<TfCall>),
     SystemTfCall(Box<SystemTfCall>),
@@ -55,23 +55,23 @@ pub enum SubroutineCall {
     Randomize(Box<SubroutineCallRandomize>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SubroutineCallRandomize {
     pub nodes: (Option<(Keyword, Symbol)>, RandomizeCall),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FunctionSubroutineCall {
     pub nodes: (SubroutineCall,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ListOfArguments {
     Ordered(Box<ListOfArgumentsOrdered>),
     Named(Box<ListOfArgumentsNamed>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfArgumentsOrdered {
     pub nodes: (
         List<Symbol, Option<Expression>>,
@@ -79,7 +79,7 @@ pub struct ListOfArgumentsOrdered {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfArgumentsNamed {
     pub nodes: (
         Symbol,
@@ -89,18 +89,18 @@ pub struct ListOfArgumentsNamed {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct MethodCall {
     pub nodes: (MethodCallRoot, Symbol, MethodCallBody),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum MethodCallBody {
     User(Box<MethodCallBodyUser>),
     BuiltInMethodCall(Box<BuiltInMethodCall>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct MethodCallBodyUser {
     pub nodes: (
         MethodIdentifier,
@@ -109,13 +109,13 @@ pub struct MethodCallBodyUser {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BuiltInMethodCall {
     ArrayManipulationCall(Box<ArrayManipulationCall>),
     RandomizeCall(Box<RandomizeCall>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ArrayManipulationCall {
     pub nodes: (
         ArrayMethodName,
@@ -125,7 +125,7 @@ pub struct ArrayManipulationCall {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RandomizeCall {
     pub nodes: (
         Keyword,
@@ -139,19 +139,19 @@ pub struct RandomizeCall {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum VariableIdentifierListOrNull {
     VariableIdentifierList(Box<VariableIdentifierList>),
     Null(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum MethodCallRoot {
     Primary(Box<Primary>),
     ImplicitClassHandle(Box<ImplicitClassHandle>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ArrayMethodName {
     MethodIdentifier(Box<MethodIdentifier>),
     Unique(Box<Keyword>),

sv-parser-syntaxtree/src/general/attributes.rs

@@ -2,12 +2,12 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AttributeInstance {
     pub nodes: (Symbol, List<Symbol, AttrSpec>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AttrSpec {
     pub nodes: (Identifier, Option<(Symbol, ConstantExpression)>),
 }

sv-parser-syntaxtree/src/general/comments.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Comment {
     pub nodes: (Locate,),
 }

sv-parser-syntaxtree/src/general/compiler_directives.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CompilerDirective {
     ResetallCompilerDirective(Box<ResetallCompilerDirective>),
     IncludeCompilerDirective(Box<IncludeCompilerDirective>),
@@ -24,68 +24,68 @@ pub enum CompilerDirective {
     EndkeywordsDirective(Box<EndkeywordsDirective>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ResetallCompilerDirective {
     pub nodes: (Symbol, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum IncludeCompilerDirective {
     DoubleQuote(Box<IncludeCompilerDirectiveDoubleQuote>),
     AngleBracket(Box<IncludeCompilerDirectiveAngleBracket>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IncludeCompilerDirectiveDoubleQuote {
     pub nodes: (Symbol, Keyword, StringLiteral),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IncludeCompilerDirectiveAngleBracket {
     pub nodes: (Symbol, Keyword, AngleBracketLiteral),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AngleBracketLiteral {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TextMacroDefinition {
     pub nodes: (Symbol, Keyword, TextMacroName, Option<MacroText>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TextMacroName {
     pub nodes: (TextMacroIdentifier, Option<Paren<ListOfFormalArguments>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfFormalArguments {
     pub nodes: (List<Symbol, FormalArgument>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FormalArgument {
     pub nodes: (SimpleIdentifier, Option<(Symbol, DefaultText)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TextMacroIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct MacroText {
     pub nodes: (Locate,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DefaultText {
     pub nodes: (Locate,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TextMacroUsage {
     pub nodes: (
         Symbol,
@@ -94,33 +94,33 @@ pub struct TextMacroUsage {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfActualArguments {
     pub nodes: (List<Symbol, ActualArgument>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ActualArgument {
     pub nodes: (Expression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UndefineCompilerDirective {
     pub nodes: (Symbol, Keyword, TextMacroIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UndefineallCompilerDirective {
     pub nodes: (Symbol, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConditionalCompilerDirective {
     IfdefDirective(Box<IfdefDirective>),
     IfndefDirective(Box<IfndefDirective>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IfdefDirective {
     pub nodes: (
         Symbol,
@@ -134,7 +134,7 @@ pub struct IfdefDirective {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IfndefDirective {
     pub nodes: (
         Symbol,
@@ -148,74 +148,74 @@ pub struct IfndefDirective {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IfdefGroupOfLines {
     pub nodes: (Vec<SourceDescription>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IfndefGroupOfLines {
     pub nodes: (Vec<SourceDescription>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ElsifGroupOfLines {
     pub nodes: (Vec<SourceDescription>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ElseGroupOfLines {
     pub nodes: (Vec<SourceDescription>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SourceDescription {
     Comment(Box<Comment>),
     NotDirective(Box<SourceDescriptionNotDirective>),
     CompilerDirective(Box<CompilerDirective>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SourceDescriptionNotDirective {
     pub nodes: (Locate,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimescaleCompilerDirective {
     pub nodes: (Symbol, Keyword, TimeLiteral, Symbol, TimeLiteral),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DefaultNettypeCompilerDirective {
     pub nodes: (Symbol, Keyword, DefaultNettypeValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DefaultNettypeValue {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UnconnectedDriveCompilerDirective {
     pub nodes: (Symbol, Keyword, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NounconnectedDriveCompilerDirective {
     pub nodes: (Symbol, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CelldefineDriveCompilerDirective {
     pub nodes: (Symbol, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EndcelldefineDriveCompilerDirective {
     pub nodes: (Symbol, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Pragma {
     pub nodes: (
         Symbol,
@@ -225,24 +225,24 @@ pub struct Pragma {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PragmaName {
     pub nodes: (SimpleIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PragmaExpression {
     PragmaKeyword(Box<PragmaKeyword>),
     Assignment(Box<PragmaExpressionAssignment>),
     PragmaValue(Box<PragmaValue>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PragmaExpressionAssignment {
     pub nodes: (PragmaKeyword, Symbol, PragmaValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PragmaValue {
     Paren(Box<PragmaValueParen>),
     Number(Box<Number>),
@@ -250,42 +250,42 @@ pub enum PragmaValue {
     Identifier(Box<Identifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PragmaValueParen {
     pub nodes: (Paren<List<Symbol, PragmaExpression>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PragmaKeyword {
     pub nodes: (SimpleIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LineCompilerDirective {
     pub nodes: (Symbol, Keyword, Number, StringLiteral, Level),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PositionCompilerDirective {
     pub nodes: (Symbol, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Level {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct KeywordsDirective {
     pub nodes: (Symbol, Keyword, Symbol, VersionSpecifier, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VersionSpecifier {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EndkeywordsDirective {
     pub nodes: (Symbol, Keyword),
 }

sv-parser-syntaxtree/src/general/identifiers.rs

@@ -2,142 +2,142 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ArrayIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BlockIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BinIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CIdentifier {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CellIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CheckerIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassVariableIdentifier {
     pub nodes: (VariableIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClockingIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConfigIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CovergroupIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CovergroupVariableIdentifier {
     pub nodes: (VariableIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CoverPointIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CrossIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DynamicArrayVariableIdentifier {
     pub nodes: (VariableIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EnumIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EscapedIdentifier {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FormalIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FormalPortIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FunctionIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GenerateBlockIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GenvarIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalArrayIdentifier {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalBlockIdentifier {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalEventIdentifier {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalIdentifier {
     pub nodes: (
         Option<Root>,
@@ -146,189 +146,189 @@ pub struct HierarchicalIdentifier {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Root {
     pub nodes: (Keyword, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalNetIdentifier {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalParameterIdentifier {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalPropertyIdentifier {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalSequenceIdentifier {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalTaskIdentifier {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalTfIdentifier {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalVariableIdentifier {
     pub nodes: (HierarchicalIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Identifier {
     SimpleIdentifier(Box<SimpleIdentifier>),
     EscapedIdentifier(Box<EscapedIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IndexVariableIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceInstanceIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InoutPortIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InputPortIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InstanceIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LibraryIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct MemberIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct MethodIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModportIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetTypeIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OutputPortIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PackageIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PackageScope {
     Package(Box<PackageScopePackage>),
     Unit(Box<Unit>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PackageScopePackage {
     pub nodes: (PackageIdentifier, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Unit {
     pub nodes: (Keyword, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParameterIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PortIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProductionIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProgramIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PropertyIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsClassIdentifier {
     pub nodes: (Option<PackageScope>, ClassIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsCovergroupIdentifier {
     pub nodes: (Option<PackageScope>, CovergroupIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsCheckerIdentifier {
     pub nodes: (Option<PackageScope>, CheckerIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsIdentifier {
     pub nodes: (Option<PackageScope>, Identifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsOrHierarchicalArrayIdentifier {
     pub nodes: (
         Option<ImplicitClassHandleOrClassScopeOrPackageScope>,
@@ -336,82 +336,82 @@ pub struct PsOrHierarchicalArrayIdentifier {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PsOrHierarchicalNetIdentifier {
     PackageScope(Box<PsOrHierarchicalNetIdentifierPackageScope>),
     HierarchicalNetIdentifier(Box<HierarchicalNetIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsOrHierarchicalNetIdentifierPackageScope {
     pub nodes: (Option<PackageScope>, NetIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsOrHierarchicalNetIdentifierHierarchical {
     pub nodes: (HierarchicalNetIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PsOrHierarchicalPropertyIdentifier {
     PackageScope(Box<PsOrHierarchicalPropertyIdentifierPackageScope>),
     HierarchicalPropertyIdentifier(Box<HierarchicalPropertyIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsOrHierarchicalPropertyIdentifierPackageScope {
     pub nodes: (Option<PackageScope>, PropertyIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsOrHierarchicalPropertyIdentifierHierarchical {
     pub nodes: (HierarchicalPropertyIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PsOrHierarchicalSequenceIdentifier {
     PackageScope(Box<PsOrHierarchicalSequenceIdentifierPackageScope>),
     HierarchicalSequenceIdentifier(Box<HierarchicalSequenceIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsOrHierarchicalSequenceIdentifierPackageScope {
     pub nodes: (Option<PackageScope>, SequenceIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsOrHierarchicalSequenceIdentifierHierarchical {
     pub nodes: (HierarchicalSequenceIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PsOrHierarchicalTfIdentifier {
     PackageScope(Box<PsOrHierarchicalTfIdentifierPackageScope>),
     HierarchicalTfIdentifier(Box<HierarchicalTfIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsOrHierarchicalTfIdentifierPackageScope {
     pub nodes: (Option<PackageScope>, TfIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsOrHierarchicalTfIdentifierHierarchical {
     pub nodes: (HierarchicalTfIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PsParameterIdentifier {
     Scope(Box<PsParameterIdentifierScope>),
     Generate(Box<PsParameterIdentifierGenerate>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsParameterIdentifierScope {
     pub nodes: (Option<PackageScopeOrClassScope>, ParameterIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsParameterIdentifierGenerate {
     pub nodes: (
         Vec<(
@@ -423,103 +423,103 @@ pub struct PsParameterIdentifierGenerate {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PsTypeIdentifier {
     pub nodes: (Option<LocalOrPackageScopeOrClassScope>, TypeIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum LocalOrPackageScopeOrClassScope {
     Local(Box<Local>),
     PackageScope(Box<PackageScope>),
     ClassScope(Box<ClassScope>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Local {
     pub nodes: (Keyword, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequenceIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SignalIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SimpleIdentifier {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SpecparamIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SystemTfIdentifier {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TaskIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TfIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TerminalIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TopmoduleIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TypeIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariableIdentifier {
     pub nodes: (Identifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ImplicitClassHandleOrClassScopeOrPackageScope {
     ImplicitClassHandle(Box<(ImplicitClassHandle, Symbol)>),
     ClassScope(Box<ClassScope>),
     PackageScope(Box<PackageScope>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ImplicitClassHandleOrPackageScope {
     ImplicitClassHandle(Box<(ImplicitClassHandle, Symbol)>),
     PackageScope(Box<PackageScope>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ImplicitClassHandleOrClassScope {
     ImplicitClassHandle(Box<(ImplicitClassHandle, Symbol)>),
     ClassScope(Box<ClassScope>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PackageScopeOrClassScope {
     PackageScope(Box<PackageScope>),
     ClassScope(Box<ClassScope>),

sv-parser-syntaxtree/src/instantiations/checker_instantiation.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CheckerInstantiation {
     pub nodes: (
         PsCheckerIdentifier,
@@ -12,34 +12,34 @@ pub struct CheckerInstantiation {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ListOfCheckerPortConnections {
     Ordered(Box<ListOfCheckerPortConnectionsOrdered>),
     Named(Box<ListOfCheckerPortConnectionsNamed>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfCheckerPortConnectionsOrdered {
     pub nodes: (List<Symbol, OrderedCheckerPortConnection>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfCheckerPortConnectionsNamed {
     pub nodes: (List<Symbol, NamedCheckerPortConnection>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OrderedCheckerPortConnection {
     pub nodes: (Vec<AttributeInstance>, Option<PropertyActualArg>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NamedCheckerPortConnection {
     Identifier(Box<NamedCheckerPortConnectionIdentifier>),
     Asterisk(Box<NamedCheckerPortConnectionAsterisk>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NamedCheckerPortConnectionIdentifier {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -49,7 +49,7 @@ pub struct NamedCheckerPortConnectionIdentifier {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NamedCheckerPortConnectionAsterisk {
     pub nodes: (Vec<AttributeInstance>, Symbol),
 }

sv-parser-syntaxtree/src/instantiations/generated_instantiation.rs

@@ -2,12 +2,12 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GenerateRegion {
     pub nodes: (Keyword, Vec<GenerateItem>, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LoopGenerateConstruct {
     pub nodes: (
         Keyword,
@@ -22,45 +22,45 @@ pub struct LoopGenerateConstruct {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GenvarInitialization {
     pub nodes: (Option<Genvar>, GenvarIdentifier, Symbol, ConstantExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Genvar {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum GenvarIteration {
     Assignment(Box<GenvarIterationAssignment>),
     Prefix(Box<GenvarIterationPrefix>),
     Suffix(Box<GenvarIterationSuffix>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GenvarIterationAssignment {
     pub nodes: (GenvarIdentifier, AssignmentOperator, GenvarExpression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GenvarIterationPrefix {
     pub nodes: (IncOrDecOperator, GenvarIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GenvarIterationSuffix {
     pub nodes: (GenvarIdentifier, IncOrDecOperator),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConditionalGenerateConstruct {
     If(Box<IfGenerateConstruct>),
     Case(Box<CaseGenerateConstruct>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IfGenerateConstruct {
     pub nodes: (
         Keyword,
@@ -70,7 +70,7 @@ pub struct IfGenerateConstruct {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseGenerateConstruct {
     pub nodes: (
         Keyword,
@@ -80,29 +80,29 @@ pub struct CaseGenerateConstruct {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CaseGenerateItem {
     Nondefault(Box<CaseGenerateItemNondefault>),
     Default(Box<CaseGenerateItemDefault>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseGenerateItemNondefault {
     pub nodes: (List<Symbol, ConstantExpression>, Symbol, GenerateBlock),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CaseGenerateItemDefault {
     pub nodes: (Keyword, Option<Symbol>, GenerateBlock),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum GenerateBlock {
     GenerateItem(Box<GenerateItem>),
     Multiple(Box<GenerateBlockMultiple>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GenerateBlockMultiple {
     pub nodes: (
         Option<(GenerateBlockIdentifier, Symbol)>,
@@ -114,7 +114,7 @@ pub struct GenerateBlockMultiple {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum GenerateItem {
     ModuleOrGenerateItem(Box<ModuleOrGenerateItem>),
     InterfaceOrGenerateItem(Box<InterfaceOrGenerateItem>),

sv-parser-syntaxtree/src/instantiations/interface_instantiation.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceInstantiation {
     pub nodes: (
         InterfaceIdentifier,

sv-parser-syntaxtree/src/instantiations/module_instantiation.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleInstantiation {
     pub nodes: (
         ModuleIdentifier,
@@ -12,75 +12,75 @@ pub struct ModuleInstantiation {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParameterValueAssignment {
     pub nodes: (Symbol, Paren<Option<ListOfParameterAssignments>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ListOfParameterAssignments {
     Ordered(Box<ListOfParameterAssignmentsOrdered>),
     Named(Box<ListOfParameterAssignmentsNamed>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfParameterAssignmentsOrdered {
     pub nodes: (List<Symbol, OrderedParameterAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfParameterAssignmentsNamed {
     pub nodes: (List<Symbol, NamedParameterAssignment>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OrderedParameterAssignment {
     pub nodes: (ParamExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NamedParameterAssignment {
     pub nodes: (Symbol, ParameterIdentifier, Paren<Option<ParamExpression>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HierarchicalInstance {
     pub nodes: (NameOfInstance, Paren<Option<ListOfPortConnections>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NameOfInstance {
     pub nodes: (InstanceIdentifier, Vec<UnpackedDimension>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ListOfPortConnections {
     Ordered(Box<ListOfPortConnectionsOrdered>),
     Named(Box<ListOfPortConnectionsNamed>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfPortConnectionsOrdered {
     pub nodes: (List<Symbol, OrderedPortConnection>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfPortConnectionsNamed {
     pub nodes: (List<Symbol, NamedPortConnection>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OrderedPortConnection {
     pub nodes: (Vec<AttributeInstance>, Option<Expression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NamedPortConnection {
     Identifier(Box<NamedPortConnectionIdentifier>),
     Asterisk(Box<NamedPortConnectionAsterisk>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NamedPortConnectionIdentifier {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -90,7 +90,7 @@ pub struct NamedPortConnectionIdentifier {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NamedPortConnectionAsterisk {
     pub nodes: (Vec<AttributeInstance>, Symbol),
 }

sv-parser-syntaxtree/src/instantiations/program_instantiation.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProgramInstantiation {
     pub nodes: (
         ProgramIdentifier,

sv-parser-syntaxtree/src/lib.rs

@@ -36,6 +36,12 @@ pub struct Locate {
     pub len: usize,
 }
 
+impl Locate {
+    pub fn str<'a, 'b>(&'a self, s: &'b str) -> &'b str {
+        &s[self.offset..self.offset + self.len]
+    }
+}
+
 // -----------------------------------------------------------------------------
 
 pub trait Node<'a> {

sv-parser-syntaxtree/src/preprocessor/preprocessor.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PreprocessorText {
     pub nodes: (Vec<SourceDescription>,),
 }

sv-parser-syntaxtree/src/primitive_instances/primitive_gate_and_switch_types.rs

@@ -2,37 +2,37 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CmosSwitchtype {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EnableGatetype {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct MosSwitchtype {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NInputGatetype {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NOutputGatetype {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PassEnSwitchtype {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PassSwitchtype {
     pub nodes: (Keyword,),
 }

sv-parser-syntaxtree/src/primitive_instances/primitive_instantiation_and_instances.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum GateInstantiation {
     Cmos(Box<GateInstantiationCmos>),
     Enable(Box<GateInstantiationEnable>),
@@ -15,7 +15,7 @@ pub enum GateInstantiation {
     Pullup(Box<GateInstantiationPullup>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GateInstantiationCmos {
     pub nodes: (
         CmosSwitchtype,
@@ -25,7 +25,7 @@ pub struct GateInstantiationCmos {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GateInstantiationEnable {
     pub nodes: (
         EnableGatetype,
@@ -36,7 +36,7 @@ pub struct GateInstantiationEnable {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GateInstantiationMos {
     pub nodes: (
         MosSwitchtype,
@@ -46,7 +46,7 @@ pub struct GateInstantiationMos {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GateInstantiationNInput {
     pub nodes: (
         NInputGatetype,
@@ -57,7 +57,7 @@ pub struct GateInstantiationNInput {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GateInstantiationNOutput {
     pub nodes: (
         NOutputGatetype,
@@ -68,7 +68,7 @@ pub struct GateInstantiationNOutput {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GateInstantiationPassEn {
     pub nodes: (
         PassEnSwitchtype,
@@ -78,12 +78,12 @@ pub struct GateInstantiationPassEn {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GateInstantiationPass {
     pub nodes: (PassSwitchtype, List<Symbol, PassSwitchInstance>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GateInstantiationPulldown {
     pub nodes: (
         Keyword,
@@ -93,7 +93,7 @@ pub struct GateInstantiationPulldown {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct GateInstantiationPullup {
     pub nodes: (
         Keyword,
@@ -103,7 +103,7 @@ pub struct GateInstantiationPullup {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CmosSwitchInstance {
     pub nodes: (
         Option<NameOfInstance>,
@@ -119,7 +119,7 @@ pub struct CmosSwitchInstance {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EnableGateInstance {
     pub nodes: (
         Option<NameOfInstance>,
@@ -133,7 +133,7 @@ pub struct EnableGateInstance {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct MosSwitchInstance {
     pub nodes: (
         Option<NameOfInstance>,
@@ -147,7 +147,7 @@ pub struct MosSwitchInstance {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NInputGateInstance {
     pub nodes: (
         Option<NameOfInstance>,
@@ -155,7 +155,7 @@ pub struct NInputGateInstance {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NOutputGateInstance {
     pub nodes: (
         Option<NameOfInstance>,
@@ -163,7 +163,7 @@ pub struct NOutputGateInstance {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PassSwitchInstance {
     pub nodes: (
         Option<NameOfInstance>,
@@ -171,7 +171,7 @@ pub struct PassSwitchInstance {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PassEnableSwitchInstance {
     pub nodes: (
         Option<NameOfInstance>,
@@ -179,7 +179,7 @@ pub struct PassEnableSwitchInstance {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PullGateInstance {
     pub nodes: (Option<NameOfInstance>, Paren<OutputTerminal>),
 }

sv-parser-syntaxtree/src/primitive_instances/primitive_strengths.rs

@@ -2,46 +2,46 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PulldownStrength {
     Strength01(Box<PulldownStrength01>),
     Strength10(Box<PulldownStrength10>),
     Strength0(Box<PulldownStrength0>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PulldownStrength01 {
     pub nodes: (Paren<(Strength0, Symbol, Strength1)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PulldownStrength10 {
     pub nodes: (Paren<(Strength1, Symbol, Strength0)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PulldownStrength0 {
     pub nodes: (Paren<Strength0>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PullupStrength {
     Strength01(Box<PullupStrength01>),
     Strength10(Box<PullupStrength10>),
     Strength1(Box<PullupStrength1>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PullupStrength01 {
     pub nodes: (Paren<(Strength0, Symbol, Strength1)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PullupStrength10 {
     pub nodes: (Paren<(Strength1, Symbol, Strength0)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PullupStrength1 {
     pub nodes: (Paren<Strength1>,),
 }

sv-parser-syntaxtree/src/primitive_instances/primitive_terminals.rs

@@ -2,32 +2,32 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EnableTerminal {
     pub nodes: (Expression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InoutTerminal {
     pub nodes: (NetLvalue,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InputTerminal {
     pub nodes: (Expression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NcontrolTerminal {
     pub nodes: (Expression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OutputTerminal {
     pub nodes: (NetLvalue,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PcontrolTerminal {
     pub nodes: (Expression,),
 }

sv-parser-syntaxtree/src/source_text/checker_items.rs

@@ -2,12 +2,12 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CheckerPortList {
     pub nodes: (List<Symbol, CheckerPortItem>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CheckerPortItem {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -19,13 +19,13 @@ pub struct CheckerPortItem {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CheckerPortDirection {
     Input(Box<Keyword>),
     Output(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CheckerOrGenerateItem {
     CheckerOrGenerateItemDeclaration(Box<CheckerOrGenerateItemDeclaration>),
     InitialConstruct(Box<InitialConstruct>),
@@ -36,7 +36,7 @@ pub enum CheckerOrGenerateItem {
     CheckerGenerateItem(Box<CheckerGenerateItem>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CheckerOrGenerateItemDeclaration {
     Data(Box<CheckerOrGenerateItemDeclarationData>),
     FunctionDeclaration(Box<FunctionDeclaration>),
@@ -50,27 +50,27 @@ pub enum CheckerOrGenerateItemDeclaration {
     Empty(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CheckerOrGenerateItemDeclarationData {
     pub nodes: (Option<Rand>, DataDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Rand {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CheckerOrGenerateItemDeclarationClocking {
     pub nodes: (Keyword, Keyword, ClockingIdentifier, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CheckerOrGenerateItemDeclarationDisable {
     pub nodes: (Keyword, Keyword, Keyword, ExpressionOrDist, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum CheckerGenerateItem {
     LoopGenerateConstruct(Box<LoopGenerateConstruct>),
     ConditionalGenerateConstruct(Box<ConditionalGenerateConstruct>),

sv-parser-syntaxtree/src/source_text/class_items.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClassItem {
     Property(Box<ClassItemProperty>),
     Method(Box<ClassItemMethod>),
@@ -14,43 +14,43 @@ pub enum ClassItem {
     Empty(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassItemProperty {
     pub nodes: (Vec<AttributeInstance>, ClassProperty),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassItemMethod {
     pub nodes: (Vec<AttributeInstance>, ClassMethod),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassItemConstraint {
     pub nodes: (Vec<AttributeInstance>, ClassConstraint),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassItemDeclaration {
     pub nodes: (Vec<AttributeInstance>, ClassDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassItemCovergroup {
     pub nodes: (Vec<AttributeInstance>, CovergroupDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClassProperty {
     NonConst(Box<ClassPropertyNonConst>),
     Const(Box<ClassPropertyConst>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassPropertyNonConst {
     pub nodes: (Vec<PropertyQualifier>, DataDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassPropertyConst {
     pub nodes: (
         Keyword,
@@ -62,7 +62,7 @@ pub struct ClassPropertyConst {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClassMethod {
     Task(Box<ClassMethodTask>),
     Function(Box<ClassMethodFunction>),
@@ -72,17 +72,17 @@ pub enum ClassMethod {
     ExternConstructor(Box<ClassMethodExternConstructor>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassMethodTask {
     pub nodes: (Vec<MethodQualifier>, TaskDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassMethodFunction {
     pub nodes: (Vec<MethodQualifier>, FunctionDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassMethodPureVirtual {
     pub nodes: (
         Keyword,
@@ -93,65 +93,65 @@ pub struct ClassMethodPureVirtual {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassMethodExternMethod {
     pub nodes: (Keyword, Vec<MethodQualifier>, MethodPrototype, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassMethodConstructor {
     pub nodes: (Vec<MethodQualifier>, ClassConstructorDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassMethodExternConstructor {
     pub nodes: (Keyword, Vec<MethodQualifier>, ClassConstructorPrototype),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassConstructorPrototype {
     pub nodes: (Keyword, Keyword, Option<Paren<Option<TfPortList>>>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClassConstraint {
     ConstraintPrototype(Box<ConstraintPrototype>),
     ConstraintDeclaration(Box<ConstraintDeclaration>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ClassItemQualifier {
     Static(Box<Keyword>),
     Protected(Box<Keyword>),
     Local(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PropertyQualifier {
     RandomQualifier(Box<RandomQualifier>),
     ClassItemQualifier(Box<ClassItemQualifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum RandomQualifier {
     Rand(Box<Keyword>),
     Randc(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum MethodQualifier {
     Virtual(Box<Keyword>),
     PureVirtual(Box<(Keyword, Keyword)>),
     ClassItemQualifier(Box<ClassItemQualifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum MethodPrototype {
     TaskPrototype(Box<TaskPrototype>),
     FunctionPrototype(Box<FunctionPrototype>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassConstructorDeclaration {
     pub nodes: (
         Keyword,
@@ -173,7 +173,7 @@ pub struct ClassConstructorDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct New {
     pub nodes: (Keyword,),
 }

sv-parser-syntaxtree/src/source_text/configuration_source_text.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConfigDeclaration {
     pub nodes: (
         Keyword,
@@ -16,7 +16,7 @@ pub struct ConfigDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DesignStatement {
     pub nodes: (
         Keyword,
@@ -25,7 +25,7 @@ pub struct DesignStatement {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConfigRuleStatement {
     Default(Box<ConfigRuleStatementDefault>),
     InstLib(Box<ConfigRuleStatementInstLib>),
@@ -34,64 +34,64 @@ pub enum ConfigRuleStatement {
     CellUse(Box<ConfigRuleStatementCellUse>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConfigRuleStatementDefault {
     pub nodes: (DefaultClause, LiblistClause, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConfigRuleStatementInstLib {
     pub nodes: (InstClause, LiblistClause, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConfigRuleStatementInstUse {
     pub nodes: (InstClause, UseClause, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConfigRuleStatementCellLib {
     pub nodes: (CellClause, LiblistClause, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConfigRuleStatementCellUse {
     pub nodes: (CellClause, UseClause, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DefaultClause {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InstClause {
     pub nodes: (Keyword, InstName),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InstName {
     pub nodes: (TopmoduleIdentifier, Vec<(Symbol, InstanceIdentifier)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CellClause {
     pub nodes: (Keyword, Option<(LibraryIdentifier, Symbol)>, CellIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LiblistClause {
     pub nodes: (Keyword, Vec<LibraryIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum UseClause {
     Cell(Box<UseClauseCell>),
     Named(Box<UseClauseNamed>),
     CellNamed(Box<UseClauseCellNamed>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UseClauseCell {
     pub nodes: (
         Keyword,
@@ -101,7 +101,7 @@ pub struct UseClauseCell {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UseClauseNamed {
     pub nodes: (
         Keyword,
@@ -110,7 +110,7 @@ pub struct UseClauseNamed {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UseClauseCellNamed {
     pub nodes: (
         Keyword,
@@ -121,7 +121,7 @@ pub struct UseClauseCellNamed {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Config {
     pub nodes: (Keyword,),
 }

sv-parser-syntaxtree/src/source_text/constraints.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintDeclaration {
     pub nodes: (
         Option<Static>,
@@ -12,33 +12,33 @@ pub struct ConstraintDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Static {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintBlock {
     pub nodes: (Brace<Vec<ConstraintBlockItem>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstraintBlockItem {
     Solve(Box<ConstraintBlockItemSolve>),
     ConstraintExpression(Box<ConstraintExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintBlockItemSolve {
     pub nodes: (Keyword, SolveBeforeList, Keyword, SolveBeforeList, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SolveBeforeList {
     pub nodes: (List<Symbol, ConstraintPrimary>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintPrimary {
     pub nodes: (
         Option<ImplicitClassHandleOrClassScope>,
@@ -47,7 +47,7 @@ pub struct ConstraintPrimary {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstraintExpression {
     Expression(Box<ConstraintExpressionExpression>),
     UniquenessConstraint(Box<(UniquenessConstraint, Symbol)>),
@@ -57,22 +57,22 @@ pub enum ConstraintExpression {
     Disable(Box<ConstraintExpressionDisable>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintExpressionExpression {
     pub nodes: (Option<Soft>, ExpressionOrDist, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Soft {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintExpressionArrow {
     pub nodes: (Expression, Symbol, ConstraintSet),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintExpressionIf {
     pub nodes: (
         Keyword,
@@ -82,7 +82,7 @@ pub struct ConstraintExpressionIf {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintExpressionForeach {
     pub nodes: (
         Keyword,
@@ -91,54 +91,54 @@ pub struct ConstraintExpressionForeach {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintExpressionDisable {
     pub nodes: (Keyword, Keyword, ConstraintPrimary, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UniquenessConstraint {
     pub nodes: (Keyword, Brace<OpenRangeList>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstraintSet {
     ConstraintExpression(Box<ConstraintExpression>),
     Brace(Box<ConstraintSetBrace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintSetBrace {
     pub nodes: (Brace<Vec<ConstraintExpression>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DistList {
     pub nodes: (List<Symbol, DistItem>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DistItem {
     pub nodes: (ValueRange, Option<DistWeight>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DistWeight {
     Equal(Box<DistWeightEqual>),
     Divide(Box<DistWeightDivide>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DistWeightEqual {
     pub nodes: (Symbol, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DistWeightDivide {
     pub nodes: (Symbol, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ConstraintPrototype {
     pub nodes: (
         Option<ConstraintPrototypeQualifier>,
@@ -149,13 +149,13 @@ pub struct ConstraintPrototype {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ConstraintPrototypeQualifier {
     Extern(Box<Keyword>),
     Pure(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ExternConstraintDeclaration {
     pub nodes: (
         Option<Static>,
@@ -166,7 +166,7 @@ pub struct ExternConstraintDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IdentifierList {
     pub nodes: (List<Symbol, Identifier>,),
 }

sv-parser-syntaxtree/src/source_text/interface_items.rs

@@ -2,45 +2,45 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum InterfaceOrGenerateItem {
     Module(Box<InterfaceOrGenerateItemModule>),
     Extern(Box<InterfaceOrGenerateItemExtern>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceOrGenerateItemModule {
     pub nodes: (Vec<AttributeInstance>, ModuleCommonItem),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceOrGenerateItemExtern {
     pub nodes: (Vec<AttributeInstance>, ExternTfDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ExternTfDeclaration {
     Method(Box<ExternTfDeclarationMethod>),
     Task(Box<ExternTfDeclarationTask>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ExternTfDeclarationMethod {
     pub nodes: (Keyword, MethodPrototype, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ExternTfDeclarationTask {
     pub nodes: (Keyword, Keyword, TaskPrototype, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum InterfaceItem {
     PortDeclaration(Box<(PortDeclaration, Symbol)>),
     NonPortInterfaceItem(Box<NonPortInterfaceItem>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NonPortInterfaceItem {
     GenerateRegion(Box<GenerateRegion>),
     InterfaceOrGenerateItem(Box<InterfaceOrGenerateItem>),

sv-parser-syntaxtree/src/source_text/library_source_text.rs

@@ -2,12 +2,12 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LibraryText {
     pub nodes: (Vec<WhiteSpace>, Vec<LibraryDescription>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum LibraryDescription {
     LibraryDeclaration(Box<LibraryDeclaration>),
     IncludeStatement(Box<IncludeStatement>),
@@ -15,7 +15,7 @@ pub enum LibraryDescription {
     Null(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LibraryDeclaration {
     pub nodes: (
         Keyword,
@@ -26,18 +26,18 @@ pub struct LibraryDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct IncludeStatement {
     pub nodes: (Keyword, FilePathSpec, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum FilePathSpec {
     Literal(StringLiteral),
     NonLiteral(FilePathSpecNonLiteral),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FilePathSpecNonLiteral {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }

sv-parser-syntaxtree/src/source_text/module_items.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ElaborationSystemTask {
     TaskFatal(Box<ElaborationSystemTaskFatal>),
     TaskError(Box<ElaborationSystemTaskError>),
@@ -10,7 +10,7 @@ pub enum ElaborationSystemTask {
     TaskInfo(Box<ElaborationSystemTaskInfo>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ElaborationSystemTaskFatal {
     pub nodes: (
         Keyword,
@@ -19,29 +19,29 @@ pub struct ElaborationSystemTaskFatal {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ElaborationSystemTaskError {
     pub nodes: (Keyword, Option<Paren<Option<ListOfArguments>>>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ElaborationSystemTaskWarning {
     pub nodes: (Keyword, Option<Paren<Option<ListOfArguments>>>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ElaborationSystemTaskInfo {
     pub nodes: (Keyword, Option<Paren<Option<ListOfArguments>>>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum FinishNumber {
     Zero(Box<Symbol>),
     One(Box<Symbol>),
     Two(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModuleCommonItem {
     ModuleOrGenerateItemDeclaration(Box<ModuleOrGenerateItemDeclaration>),
     InterfaceInstantiation(Box<InterfaceInstantiation>),
@@ -58,13 +58,13 @@ pub enum ModuleCommonItem {
     ElaborationSystemTask(Box<ElaborationSystemTask>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModuleItem {
     PortDeclaration(Box<(PortDeclaration, Symbol)>),
     NonPortModuleItem(Box<NonPortModuleItem>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModuleOrGenerateItem {
     Parameter(Box<ModuleOrGenerateItemParameter>),
     Gate(Box<ModuleOrGenerateItemGate>),
@@ -73,32 +73,32 @@ pub enum ModuleOrGenerateItem {
     ModuleItem(Box<ModuleOrGenerateItemModuleItem>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleOrGenerateItemParameter {
     pub nodes: (Vec<AttributeInstance>, ParameterOverride),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleOrGenerateItemGate {
     pub nodes: (Vec<AttributeInstance>, GateInstantiation),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleOrGenerateItemUdp {
     pub nodes: (Vec<AttributeInstance>, UdpInstantiation),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleOrGenerateItemModule {
     pub nodes: (Vec<AttributeInstance>, ModuleInstantiation),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleOrGenerateItemModuleItem {
     pub nodes: (Vec<AttributeInstance>, ModuleCommonItem),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModuleOrGenerateItemDeclaration {
     PackageOrGenerateItemDeclaration(Box<PackageOrGenerateItemDeclaration>),
     GenvarDeclaration(Box<GenvarDeclaration>),
@@ -107,17 +107,17 @@ pub enum ModuleOrGenerateItemDeclaration {
     Disable(Box<ModuleOrGenerateItemDeclarationDisable>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleOrGenerateItemDeclarationClocking {
     pub nodes: (Keyword, Keyword, ClockingIdentifier, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleOrGenerateItemDeclarationDisable {
     pub nodes: (Keyword, Keyword, Keyword, ExpressionOrDist, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NonPortModuleItem {
     GenerateRegion(Box<GenerateRegion>),
     ModuleOrGenerateItem(Box<ModuleOrGenerateItem>),
@@ -129,23 +129,23 @@ pub enum NonPortModuleItem {
     TimeunitsDeclaration(Box<TimeunitsDeclaration>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonPortModuleItemSpecparam {
     pub nodes: (Vec<AttributeInstance>, SpecparamDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParameterOverride {
     pub nodes: (Keyword, ListOfDefparamAssignments, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BindDirective {
     Scope(Box<BindDirectiveScope>),
     Instance(Box<BindDirectiveInstance>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BindDirectiveScope {
     pub nodes: (
         Keyword,
@@ -155,28 +155,28 @@ pub struct BindDirectiveScope {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BindDirectiveInstance {
     pub nodes: (Keyword, BindTargetInstance, BindInstantiation),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BindTargetScope {
     ModuleIdentifier(Box<ModuleIdentifier>),
     InterfaceIdentifier(Box<InterfaceIdentifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BindTargetInstance {
     pub nodes: (HierarchicalIdentifier, ConstantBitSelect),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct BindTargetInstanceList {
     pub nodes: (List<Symbol, BindTargetInstance>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum BindInstantiation {
     ProgramInstantiation(Box<ProgramInstantiation>),
     ModuleInstantiation(Box<ModuleInstantiation>),

sv-parser-syntaxtree/src/source_text/module_parameters_and_ports.rs

@@ -2,14 +2,14 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ParameterPortList {
     Assignment(Box<ParameterPortListAssignment>),
     Declaration(Box<ParameterPortListDeclaration>),
     Empty(Box<(Symbol, Symbol, Symbol)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParameterPortListAssignment {
     pub nodes: (
         Symbol,
@@ -20,12 +20,12 @@ pub struct ParameterPortListAssignment {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParameterPortListDeclaration {
     pub nodes: (Symbol, Paren<List<Symbol, ParameterPortDeclaration>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ParameterPortDeclaration {
     ParameterDeclaration(Box<ParameterDeclaration>),
     LocalParameterDeclaration(Box<LocalParameterDeclaration>),
@@ -33,27 +33,27 @@ pub enum ParameterPortDeclaration {
     TypeList(Box<ParameterPortDeclarationTypeList>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParameterPortDeclarationParamList {
     pub nodes: (DataType, ListOfParamAssignments),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParameterPortDeclarationTypeList {
     pub nodes: (Keyword, ListOfTypeAssignments),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfPorts {
     pub nodes: (Paren<List<Symbol, Port>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfPortDeclarations {
     pub nodes: (Paren<Option<List<Symbol, (Vec<AttributeInstance>, AnsiPortDeclaration)>>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PortDeclaration {
     Inout(Box<PortDeclarationInout>),
     Input(Box<PortDeclarationInput>),
@@ -62,64 +62,64 @@ pub enum PortDeclaration {
     Interface(Box<PortDeclarationInterface>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PortDeclarationInout {
     pub nodes: (Vec<AttributeInstance>, InoutDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PortDeclarationInput {
     pub nodes: (Vec<AttributeInstance>, InputDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PortDeclarationOutput {
     pub nodes: (Vec<AttributeInstance>, OutputDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PortDeclarationRef {
     pub nodes: (Vec<AttributeInstance>, RefDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PortDeclarationInterface {
     pub nodes: (Vec<AttributeInstance>, InterfacePortDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Port {
     NonNamed(Box<PortNonNamed>),
     Named(Box<PortNamed>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PortNonNamed {
     pub nodes: (Option<PortExpression>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PortNamed {
     pub nodes: (Symbol, PortIdentifier, Paren<Option<PortExpression>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PortExpression {
     PortReference(Box<PortReference>),
     Brace(Box<PortExpressionBrace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PortExpressionBrace {
     pub nodes: (Brace<List<Symbol, PortReference>>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PortReference {
     pub nodes: (PortIdentifier, ConstantSelect),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PortDirection {
     Input(Box<Keyword>),
     Output(Box<Keyword>),
@@ -127,45 +127,45 @@ pub enum PortDirection {
     Ref(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NetPortHeader {
     pub nodes: (Option<PortDirection>, NetPortType),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct VariablePortHeader {
     pub nodes: (Option<PortDirection>, VariablePortType),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum InterfacePortHeader {
     Identifier(Box<InterfacePortHeaderIdentifier>),
     Interface(Box<InterfacePortHeaderInterface>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfacePortHeaderIdentifier {
     pub nodes: (InterfaceIdentifier, Option<(Symbol, ModportIdentifier)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfacePortHeaderInterface {
     pub nodes: (Keyword, Option<(Symbol, ModportIdentifier)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NetPortHeaderOrInterfacePortHeader {
     NetPortHeader(Box<NetPortHeader>),
     InterfacePortHeader(Box<InterfacePortHeader>),
 }
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum AnsiPortDeclaration {
     Net(Box<AnsiPortDeclarationNet>),
     Variable(Box<AnsiPortDeclarationVariable>),
     Paren(Box<AnsiPortDeclarationParen>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AnsiPortDeclarationNet {
     pub nodes: (
         Option<NetPortHeaderOrInterfacePortHeader>,
@@ -175,7 +175,7 @@ pub struct AnsiPortDeclarationNet {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AnsiPortDeclarationVariable {
     pub nodes: (
         Option<VariablePortHeader>,
@@ -185,7 +185,7 @@ pub struct AnsiPortDeclarationVariable {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AnsiPortDeclarationParen {
     pub nodes: (
         Option<PortDirection>,

sv-parser-syntaxtree/src/source_text/package_items.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PackageItem {
     PackageOrGenerateItemDeclaration(Box<PackageOrGenerateItemDeclaration>),
     AnonymousProgram(Box<AnonymousProgram>),
@@ -10,7 +10,7 @@ pub enum PackageItem {
     TimeunitsDeclaration(Box<TimeunitsDeclaration>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PackageOrGenerateItemDeclaration {
     NetDeclaration(Box<NetDeclaration>),
     DataDeclaration(Box<DataDeclaration>),
@@ -29,12 +29,12 @@ pub enum PackageOrGenerateItemDeclaration {
     Empty(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct AnonymousProgram {
     pub nodes: (Keyword, Symbol, Vec<AnonymousProgramItem>, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum AnonymousProgramItem {
     TaskDeclaration(Box<TaskDeclaration>),
     FunctionDeclaration(Box<FunctionDeclaration>),

sv-parser-syntaxtree/src/source_text/program_items.rs

@@ -2,13 +2,13 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ProgramItem {
     PortDeclaration(Box<(PortDeclaration, Symbol)>),
     NonPortProgramItem(Box<NonPortProgramItem>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NonPortProgramItem {
     Assign(Box<NonPortProgramItemAssign>),
     Module(Box<NonPortProgramItemModule>),
@@ -19,32 +19,32 @@ pub enum NonPortProgramItem {
     ProgramGenerateItem(Box<ProgramGenerateItem>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonPortProgramItemAssign {
     pub nodes: (Vec<AttributeInstance>, ContinuousAssign),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonPortProgramItemModule {
     pub nodes: (Vec<AttributeInstance>, ModuleOrGenerateItemDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonPortProgramItemInitial {
     pub nodes: (Vec<AttributeInstance>, InitialConstruct),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonPortProgramItemFinal {
     pub nodes: (Vec<AttributeInstance>, FinalConstruct),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NonPortProgramItemAssertion {
     pub nodes: (Vec<AttributeInstance>, ConcurrentAssertionItem),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ProgramGenerateItem {
     LoopGenerateConstruct(Box<LoopGenerateConstruct>),
     ConditionalGenerateConstruct(Box<ConditionalGenerateConstruct>),

sv-parser-syntaxtree/src/source_text/system_verilog_source_text.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SourceText {
     pub nodes: (
         Vec<WhiteSpace>,
@@ -11,7 +11,7 @@ pub struct SourceText {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum Description {
     ModuleDeclaration(Box<ModuleDeclaration>),
     UdpDeclaration(Box<UdpDeclaration>),
@@ -24,17 +24,17 @@ pub enum Description {
     ConfigDeclaration(Box<ConfigDeclaration>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DescriptionPackageItem {
     pub nodes: (Vec<AttributeInstance>, PackageItem),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DescriptionBindDirective {
     pub nodes: (Vec<AttributeInstance>, BindDirective),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleNonansiHeader {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -48,7 +48,7 @@ pub struct ModuleNonansiHeader {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleAnsiHeader {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -62,7 +62,7 @@ pub struct ModuleAnsiHeader {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModuleDeclaration {
     Nonansi(Box<ModuleDeclarationNonansi>),
     Ansi(Box<ModuleDeclarationAnsi>),
@@ -71,7 +71,7 @@ pub enum ModuleDeclaration {
     ExternAnsi(Box<ModuleDeclarationExternAnsi>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleDeclarationNonansi {
     pub nodes: (
         ModuleNonansiHeader,
@@ -82,7 +82,7 @@ pub struct ModuleDeclarationNonansi {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleDeclarationAnsi {
     pub nodes: (
         ModuleAnsiHeader,
@@ -93,7 +93,7 @@ pub struct ModuleDeclarationAnsi {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleDeclarationWildcard {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -109,23 +109,23 @@ pub struct ModuleDeclarationWildcard {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleDeclarationExternNonansi {
     pub nodes: (Keyword, ModuleNonansiHeader),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ModuleDeclarationExternAnsi {
     pub nodes: (Keyword, ModuleAnsiHeader),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ModuleKeyword {
     Module(Box<Keyword>),
     Macromodule(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum InterfaceDeclaration {
     Nonansi(Box<InterfaceDeclarationNonansi>),
     Ansi(Box<InterfaceDeclarationAnsi>),
@@ -134,7 +134,7 @@ pub enum InterfaceDeclaration {
     ExternAnsi(Box<InterfaceDeclarationExternAnsi>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceDeclarationNonansi {
     pub nodes: (
         InterfaceNonansiHeader,
@@ -145,7 +145,7 @@ pub struct InterfaceDeclarationNonansi {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceDeclarationAnsi {
     pub nodes: (
         InterfaceAnsiHeader,
@@ -156,7 +156,7 @@ pub struct InterfaceDeclarationAnsi {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceDeclarationWildcard {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -172,17 +172,17 @@ pub struct InterfaceDeclarationWildcard {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceDeclarationExternNonansi {
     pub nodes: (Keyword, InterfaceNonansiHeader),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceDeclarationExternAnsi {
     pub nodes: (Keyword, InterfaceAnsiHeader),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceNonansiHeader {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -196,7 +196,7 @@ pub struct InterfaceNonansiHeader {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceAnsiHeader {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -210,7 +210,7 @@ pub struct InterfaceAnsiHeader {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ProgramDeclaration {
     Nonansi(Box<ProgramDeclarationNonansi>),
     Ansi(Box<ProgramDeclarationAnsi>),
@@ -219,7 +219,7 @@ pub enum ProgramDeclaration {
     ExternAnsi(Box<ProgramDeclarationExternAnsi>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProgramDeclarationNonansi {
     pub nodes: (
         ProgramNonansiHeader,
@@ -230,7 +230,7 @@ pub struct ProgramDeclarationNonansi {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProgramDeclarationAnsi {
     pub nodes: (
         ProgramAnsiHeader,
@@ -241,7 +241,7 @@ pub struct ProgramDeclarationAnsi {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProgramDeclarationWildcard {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -256,17 +256,17 @@ pub struct ProgramDeclarationWildcard {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProgramDeclarationExternNonansi {
     pub nodes: (Keyword, ProgramNonansiHeader),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProgramDeclarationExternAnsi {
     pub nodes: (Keyword, ProgramAnsiHeader),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProgramNonansiHeader {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -280,7 +280,7 @@ pub struct ProgramNonansiHeader {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ProgramAnsiHeader {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -294,7 +294,7 @@ pub struct ProgramAnsiHeader {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CheckerDeclaration {
     pub nodes: (
         Keyword,
@@ -307,7 +307,7 @@ pub struct CheckerDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ClassDeclaration {
     pub nodes: (
         Option<Virtual>,
@@ -324,17 +324,17 @@ pub struct ClassDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Virtual {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceClassType {
     pub nodes: (PsClassIdentifier, Option<ParameterValueAssignment>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceClassDeclaration {
     pub nodes: (
         Keyword,
@@ -349,7 +349,7 @@ pub struct InterfaceClassDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum InterfaceClassItem {
     TypeDeclaration(Box<TypeDeclaration>),
     Method(Box<InterfaceClassItemMethod>),
@@ -358,17 +358,17 @@ pub enum InterfaceClassItem {
     Null(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceClassItemMethod {
     pub nodes: (Vec<AttributeInstance>, InterfaceClassMethod),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InterfaceClassMethod {
     pub nodes: (Keyword, Keyword, MethodPrototype, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PackageDeclaration {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -383,7 +383,7 @@ pub struct PackageDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TimeunitsDeclaration {
     Timeunit(Box<TimeunitsDeclarationTimeunit>),
     Timeprecision(Box<TimeunitsDeclarationTimeprecision>),
@@ -391,22 +391,22 @@ pub enum TimeunitsDeclaration {
     TimeprecisionTimeunit(Box<TimeunitsDeclarationTimeprecisionTimeunit>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimeunitsDeclarationTimeunit {
     pub nodes: (Keyword, TimeLiteral, Option<(Symbol, TimeLiteral)>, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimeunitsDeclarationTimeprecision {
     pub nodes: (Keyword, TimeLiteral, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimeunitsDeclarationTimeunitTimeprecision {
     pub nodes: (Keyword, TimeLiteral, Symbol, Keyword, TimeLiteral, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimeunitsDeclarationTimeprecisionTimeunit {
     pub nodes: (Keyword, TimeLiteral, Symbol, Keyword, TimeLiteral, Symbol),
 }

sv-parser-syntaxtree/src/special_node.rs

@@ -2,44 +2,44 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Symbol {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Keyword {
     pub nodes: (Locate, Vec<WhiteSpace>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum WhiteSpace {
     Space(Box<Locate>),
     Comment(Box<Comment>),
     CompilerDirective(Box<CompilerDirective>),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct Paren<T> {
     pub nodes: (Symbol, T, Symbol),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct Brace<T> {
     pub nodes: (Symbol, T, Symbol),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct Bracket<T> {
     pub nodes: (Symbol, T, Symbol),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct ApostropheBrace<T> {
     pub nodes: (Symbol, T, Symbol),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct List<T, U> {
     pub nodes: (U, Vec<(T, U)>),
 }

sv-parser-syntaxtree/src/specify_section/specify_block_declaration.rs

@@ -2,12 +2,12 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SpecifyBlock {
     pub nodes: (Keyword, Vec<SpecifyItem>, Keyword),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SpecifyItem {
     SpecparamDeclaration(Box<SpecparamDeclaration>),
     PulsestyleDeclaration(Box<PulsestyleDeclaration>),
@@ -16,12 +16,12 @@ pub enum SpecifyItem {
     SystemTimingCheck(Box<SystemTimingCheck>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PulsestyleDeclaration {
     pub nodes: (Keyword, ListOfPathOutputs, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ShowcancelledDeclaration {
     pub nodes: (Keyword, ListOfPathOutputs, Symbol),
 }

sv-parser-syntaxtree/src/specify_section/specify_block_terminals.rs

@@ -2,36 +2,36 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SpecifyInputTerminalDescriptor {
     pub nodes: (InputIdentifier, Option<Bracket<ConstantRangeExpression>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SpecifyOutputTerminalDescriptor {
     pub nodes: (OutputIdentifier, Option<Bracket<ConstantRangeExpression>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum InputIdentifier {
     InputPortIdentifier(Box<InputPortIdentifier>),
     InoutPortIdentifier(Box<InoutPortIdentifier>),
     Interface(Box<InputIdentifierInterface>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InputIdentifierInterface {
     pub nodes: (InterfaceIdentifier, Symbol, PortIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum OutputIdentifier {
     OutputPortIdentifier(Box<OutputPortIdentifier>),
     InoutPortIdentifier(Box<InoutPortIdentifier>),
     Interface(Box<OutputIdentifierInterface>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OutputIdentifierInterface {
     pub nodes: (InterfaceIdentifier, Symbol, PortIdentifier),
 }

sv-parser-syntaxtree/src/specify_section/specify_path_declarations.rs

@@ -2,30 +2,30 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PathDeclaration {
     SimplePathDeclaration(Box<(SimplePathDeclaration, Symbol)>),
     EdgeSensitivePathDeclaration(Box<(EdgeSensitivePathDeclaration, Symbol)>),
     StateDependentPathDeclaration(Box<(StateDependentPathDeclaration, Symbol)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SimplePathDeclaration {
     Parallel(Box<SimplePathDeclarationParallel>),
     Full(Box<SimplePathDeclarationFull>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SimplePathDeclarationParallel {
     pub nodes: (ParallelPathDescription, Symbol, PathDelayValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SimplePathDeclarationFull {
     pub nodes: (FullPathDescription, Symbol, PathDelayValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParallelPathDescription {
     pub nodes: (
         Paren<(
@@ -37,7 +37,7 @@ pub struct ParallelPathDescription {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FullPathDescription {
     pub nodes: (
         Paren<(
@@ -49,12 +49,12 @@ pub struct FullPathDescription {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfPathInputs {
     pub nodes: (List<Symbol, SpecifyInputTerminalDescriptor>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfPathOutputs {
     pub nodes: (List<Symbol, SpecifyOutputTerminalDescriptor>,),
 }

sv-parser-syntaxtree/src/specify_section/specify_path_delays.rs

@@ -2,48 +2,48 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum PathDelayValue {
     ListOfPathDelayExpressions(Box<ListOfPathDelayExpressions>),
     Paren(Box<PathDelayValueParen>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PathDelayValueParen {
     pub nodes: (Paren<ListOfPathDelayExpressions>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ListOfPathDelayExpressions {
     pub nodes: (List<Symbol, TPathDelayExpression>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TPathDelayExpression {
     pub nodes: (PathDelayExpression,),
 }
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PathDelayExpression {
     pub nodes: (ConstantMintypmaxExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum EdgeSensitivePathDeclaration {
     Parallel(Box<EdgeSensitivePathDeclarationParallel>),
     Full(Box<EdgeSensitivePathDeclarationFull>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EdgeSensitivePathDeclarationParallel {
     pub nodes: (ParallelEdgeSensitivePathDescription, Symbol, PathDelayValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EdgeSensitivePathDeclarationFull {
     pub nodes: (FullEdgeSensitivePathDescription, Symbol, PathDelayValue),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ParallelEdgeSensitivePathDescription {
     pub nodes: (
         Paren<(
@@ -61,7 +61,7 @@ pub struct ParallelEdgeSensitivePathDescription {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FullEdgeSensitivePathDescription {
     pub nodes: (
         Paren<(
@@ -79,31 +79,31 @@ pub struct FullEdgeSensitivePathDescription {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DataSourceExpression {
     pub nodes: (Expression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum EdgeIdentifier {
     Posedge(Box<Keyword>),
     Negedge(Box<Keyword>),
     Edge(Box<Keyword>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum StateDependentPathDeclaration {
     IfSimple(Box<StateDependentPathDeclarationIfSimple>),
     IfEdgeSensitive(Box<StateDependentPathDeclarationIfEdgeSensitive>),
     IfNone(Box<StateDependentPathDeclarationIfNone>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StateDependentPathDeclarationIfSimple {
     pub nodes: (Keyword, Paren<ModulePathExpression>, SimplePathDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StateDependentPathDeclarationIfEdgeSensitive {
     pub nodes: (
         Keyword,
@@ -112,12 +112,12 @@ pub struct StateDependentPathDeclarationIfEdgeSensitive {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StateDependentPathDeclarationIfNone {
     pub nodes: (Keyword, SimplePathDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PolarityOperator {
     pub nodes: (Symbol,),
 }

sv-parser-syntaxtree/src/specify_section/system_timing_check_command_arguments.rs

@@ -2,84 +2,84 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimecheckCondition {
     pub nodes: (MintypmaxExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ControlledReferenceEvent {
     pub nodes: (ControlledTimingCheckEvent,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DataEvent {
     pub nodes: (TimingCheckEvent,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DelayedData {
     TerminalIdentifier(Box<TerminalIdentifier>),
     WithMintypmax(Box<DelayedDataWithMintypmax>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DelayedDataWithMintypmax {
     pub nodes: (TerminalIdentifier, Bracket<ConstantMintypmaxExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum DelayedReference {
     TerminalIdentifier(Box<TerminalIdentifier>),
     WithMintypmax(Box<DelayedReferenceWithMintypmax>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct DelayedReferenceWithMintypmax {
     pub nodes: (TerminalIdentifier, Bracket<ConstantMintypmaxExpression>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EndEdgeOffset {
     pub nodes: (MintypmaxExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EventBasedFlag {
     pub nodes: (ConstantExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Notifier {
     pub nodes: (VariableIdentifier,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ReferenceEvent {
     pub nodes: (TimingCheckEvent,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RemainActiveFlag {
     pub nodes: (ConstantMintypmaxExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimestampCondition {
     pub nodes: (MintypmaxExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct StartEdgeOffset {
     pub nodes: (MintypmaxExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct Threshold {
     pub nodes: (ConstantExpression,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimingCheckLimit {
     pub nodes: (Expression,),
 }

sv-parser-syntaxtree/src/specify_section/system_timing_check_commands.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SystemTimingCheck {
     SetupTimingCheck(Box<SetupTimingCheck>),
     HoldTimingCheck(Box<HoldTimingCheck>),
@@ -18,7 +18,7 @@ pub enum SystemTimingCheck {
     NochangeTimingCheck(Box<NochangeTimingCheck>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SetupTimingCheck {
     pub nodes: (
         Keyword,
@@ -34,7 +34,7 @@ pub struct SetupTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct HoldTimingCheck {
     pub nodes: (
         Keyword,
@@ -50,7 +50,7 @@ pub struct HoldTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SetupholdTimingCheck {
     pub nodes: (
         Keyword,
@@ -84,7 +84,7 @@ pub struct SetupholdTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RecoveryTimingCheck {
     pub nodes: (
         Keyword,
@@ -100,7 +100,7 @@ pub struct RecoveryTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RemovalTimingCheck {
     pub nodes: (
         Keyword,
@@ -116,7 +116,7 @@ pub struct RemovalTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct RecremTimingCheck {
     pub nodes: (
         Keyword,
@@ -150,7 +150,7 @@ pub struct RecremTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SkewTimingCheck {
     pub nodes: (
         Keyword,
@@ -166,7 +166,7 @@ pub struct SkewTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimeskewTimingCheck {
     pub nodes: (
         Keyword,
@@ -190,7 +190,7 @@ pub struct TimeskewTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct FullskewTimingCheck {
     pub nodes: (
         Keyword,
@@ -216,7 +216,7 @@ pub struct FullskewTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct PeriodTimingCheck {
     pub nodes: (
         Keyword,
@@ -230,7 +230,7 @@ pub struct PeriodTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct WidthTimingCheck {
     pub nodes: (
         Keyword,
@@ -246,7 +246,7 @@ pub struct WidthTimingCheck {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct NochangeTimingCheck {
     pub nodes: (
         Keyword,

sv-parser-syntaxtree/src/specify_section/system_timing_check_event_definitions.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimingCheckEvent {
     pub nodes: (
         Option<TimingCheckEventControl>,
@@ -11,7 +11,7 @@ pub struct TimingCheckEvent {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ControlledTimingCheckEvent {
     pub nodes: (
         TimingCheckEventControl,
@@ -20,7 +20,7 @@ pub struct ControlledTimingCheckEvent {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TimingCheckEventControl {
     Posedge(Box<Keyword>),
     Negedge(Box<Keyword>),
@@ -28,51 +28,51 @@ pub enum TimingCheckEventControl {
     EdgeControlSpecifier(Box<EdgeControlSpecifier>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SpecifyTerminalDescriptor {
     SpecifyInputTerminalDescriptor(Box<SpecifyInputTerminalDescriptor>),
     SpecifyOutputTerminalDescriptor(Box<SpecifyOutputTerminalDescriptor>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EdgeControlSpecifier {
     pub nodes: (Keyword, Bracket<List<Symbol, EdgeDescriptor>>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EdgeDescriptor {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum TimingCheckCondition {
     ScalarTimingCheckCondition(Box<ScalarTimingCheckCondition>),
     Paren(Box<TimingCheckConditionParen>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct TimingCheckConditionParen {
     pub nodes: (Paren<ScalarTimingCheckCondition>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum ScalarTimingCheckCondition {
     Expression(Box<Expression>),
     Unary(Box<ScalarTimingCheckConditionUnary>),
     Binary(Box<ScalarTimingCheckConditionBinary>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ScalarTimingCheckConditionUnary {
     pub nodes: (Symbol, Expression),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ScalarTimingCheckConditionBinary {
     pub nodes: (Expression, Symbol, ScalarConstant),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct ScalarConstant {
     pub nodes: (Keyword,),
 }

sv-parser-syntaxtree/src/udp_declaration_and_instantiation/udp_body.rs

@@ -2,13 +2,13 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum UdpBody {
     CombinationalBody(Box<CombinationalBody>),
     SequentialBody(Box<SequentialBody>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CombinationalBody {
     pub nodes: (
         Keyword,
@@ -18,12 +18,12 @@ pub struct CombinationalBody {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CombinationalEntry {
     pub nodes: (LevelInputList, Symbol, OutputSymbol, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequentialBody {
     pub nodes: (
         Option<UdpInitialStatement>,
@@ -34,17 +34,17 @@ pub struct SequentialBody {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpInitialStatement {
     pub nodes: (Keyword, OutputPortIdentifier, Symbol, InitVal, Symbol),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct InitVal {
     pub nodes: (Keyword,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct SequentialEntry {
     pub nodes: (
         SeqInputList,
@@ -56,55 +56,55 @@ pub struct SequentialEntry {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum SeqInputList {
     LevelInputList(Box<LevelInputList>),
     EdgeInputList(Box<EdgeInputList>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LevelInputList {
     pub nodes: (LevelSymbol, Vec<LevelSymbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EdgeInputList {
     pub nodes: (Vec<LevelSymbol>, EdgeIndicator, Vec<LevelSymbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum EdgeIndicator {
     Paren(Box<EdgeIndicatorParen>),
     EdgeSymbol(Box<EdgeSymbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EdgeIndicatorParen {
     pub nodes: (Paren<(LevelSymbol, LevelSymbol)>,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct CurrentState {
     pub nodes: (LevelSymbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum NextState {
     OutputSymbol(Box<OutputSymbol>),
     Minus(Box<Symbol>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct OutputSymbol {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct LevelSymbol {
     pub nodes: (Symbol,),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct EdgeSymbol {
     pub nodes: (Symbol,),
 }

sv-parser-syntaxtree/src/udp_declaration_and_instantiation/udp_declaration.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpNonansiDeclaration {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -13,7 +13,7 @@ pub struct UdpNonansiDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpAnsiDeclaration {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -24,7 +24,7 @@ pub struct UdpAnsiDeclaration {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum UdpDeclaration {
     Nonansi(Box<UdpDeclarationNonansi>),
     Ansi(Box<UdpDeclarationAnsi>),
@@ -33,7 +33,7 @@ pub enum UdpDeclaration {
     Wildcard(Box<UdpDeclarationWildcard>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpDeclarationNonansi {
     pub nodes: (
         UdpNonansiDeclaration,
@@ -45,7 +45,7 @@ pub struct UdpDeclarationNonansi {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpDeclarationAnsi {
     pub nodes: (
         UdpAnsiDeclaration,
@@ -55,17 +55,17 @@ pub struct UdpDeclarationAnsi {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpDeclarationExternNonansi {
     pub nodes: (Keyword, UdpNonansiDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpDeclarationExternAnsi {
     pub nodes: (Keyword, UdpAnsiDeclaration),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpDeclarationWildcard {
     pub nodes: (
         Vec<AttributeInstance>,

sv-parser-syntaxtree/src/udp_declaration_and_instantiation/udp_instantiation.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpInstantiation {
     pub nodes: (
         UdpIdentifier,
@@ -13,7 +13,7 @@ pub struct UdpInstantiation {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpInstance {
     pub nodes: (
         Option<NameOfInstance>,

sv-parser-syntaxtree/src/udp_declaration_and_instantiation/udp_ports.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 // -----------------------------------------------------------------------------
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpPortList {
     pub nodes: (
         OutputPortIdentifier,
@@ -11,7 +11,7 @@ pub struct UdpPortList {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpDeclarationPortList {
     pub nodes: (
         UdpOutputDeclaration,
@@ -20,25 +20,25 @@ pub struct UdpDeclarationPortList {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum UdpPortDeclaration {
     UdpOutputDeclaration(Box<(UdpOutputDeclaration, Symbol)>),
     UdpInputDeclaration(Box<(UdpInputDeclaration, Symbol)>),
     UdpRegDeclaration(Box<(UdpRegDeclaration, Symbol)>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub enum UdpOutputDeclaration {
     Nonreg(Box<UdpOutputDeclarationNonreg>),
     Reg(Box<UdpOutputDeclarationReg>),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpOutputDeclarationNonreg {
     pub nodes: (Vec<AttributeInstance>, Keyword, PortIdentifier),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpOutputDeclarationReg {
     pub nodes: (
         Vec<AttributeInstance>,
@@ -49,12 +49,12 @@ pub struct UdpOutputDeclarationReg {
     ),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpInputDeclaration {
     pub nodes: (Vec<AttributeInstance>, Keyword, ListOfUdpPortIdentifiers),
 }
 
-#[derive(Clone, Debug, Node)]
+#[derive(Clone, Debug, PartialEq, Node)]
 pub struct UdpRegDeclaration {
     pub nodes: (Vec<AttributeInstance>, Keyword, VariableIdentifier),
 }