From 82c792d9f18548eaa3c2d5cb7880521099a152ef Mon Sep 17 00:00:00 2001 From: yousifB Date: Mon, 1 Jun 2026 19:13:19 +0200 Subject: [PATCH 1/6] Add vendor extension: nested begins in GenerateBlock --- sv-parser-parser/Cargo.toml | 2 + .../instantiations/generated_instantiation.rs | 3 + sv-parser-syntaxtree/Cargo.toml | 5 +- sv-parser-syntaxtree/build.rs | 103 - sv-parser-syntaxtree/src/any_node.rs | 5498 ++++++++++++++++- .../instantiations/generated_instantiation.rs | 13 + sv-parser/Cargo.toml | 2 + sv-parser/src/lib.rs | 50 +- 8 files changed, 5562 insertions(+), 114 deletions(-) delete mode 100644 sv-parser-syntaxtree/build.rs diff --git a/sv-parser-parser/Cargo.toml b/sv-parser-parser/Cargo.toml index 4c0528a4..20502a0f 100644 --- a/sv-parser-parser/Cargo.toml +++ b/sv-parser-parser/Cargo.toml @@ -19,6 +19,8 @@ tag = false [features] default = [] trace = ["nom-tracable/trace"] +nested-gen-block-begin = [] +vendor-extensions = ["nested-gen-block-begin"] [dependencies] nom = "7" diff --git a/sv-parser-parser/src/instantiations/generated_instantiation.rs b/sv-parser-parser/src/instantiations/generated_instantiation.rs index e3000387..8ab4dfab 100644 --- a/sv-parser-parser/src/instantiations/generated_instantiation.rs +++ b/sv-parser-parser/src/instantiations/generated_instantiation.rs @@ -175,6 +175,9 @@ pub(crate) fn generate_block_multiple(s: Span) -> IResult { let (s, a) = opt(pair(generate_block_identifier, symbol(":")))(s)?; let (s, b) = keyword("begin")(s)?; let (s, c) = opt(pair(symbol(":"), generate_block_identifier))(s)?; + #[cfg(feature = "nested-gen-block-begin")] + let (s, (d, e)) = many_till(generate_block, keyword("end"))(s)?; + #[cfg(not(feature = "nested-gen-block-begin"))] let (s, (d, e)) = many_till(generate_item, keyword("end"))(s)?; let (s, f) = opt(pair(symbol(":"), generate_block_identifier))(s)?; Ok(( diff --git a/sv-parser-syntaxtree/Cargo.toml b/sv-parser-syntaxtree/Cargo.toml index aeae9998..f68ccd4d 100644 --- a/sv-parser-syntaxtree/Cargo.toml +++ b/sv-parser-syntaxtree/Cargo.toml @@ -9,7 +9,6 @@ license = "MIT OR Apache-2.0" readme = "../README.md" description = "Helper crate of sv-parser" edition = "2018" -build = "build.rs" [lib] doctest = false @@ -23,3 +22,7 @@ sv-parser-macros = {version = "^0.13.5", path = "../sv-parser-macros"} [build-dependencies] regex = "1" walkdir = "2" + +[features] +nested-gen-block-begin = [] +vendor-extensions = ["nested-gen-block-begin"] diff --git a/sv-parser-syntaxtree/build.rs b/sv-parser-syntaxtree/build.rs deleted file mode 100644 index 1b5e043a..00000000 --- a/sv-parser-syntaxtree/build.rs +++ /dev/null @@ -1,103 +0,0 @@ -use regex::Regex; -use std::env; -use std::fs::File; -use std::io::{BufRead, BufReader, Write}; -use std::path::Path; -use walkdir::WalkDir; - -static REF_NODE_HEADER: &str = r##" -#[derive(Clone, Debug, PartialEq, RefNode)] -pub enum RefNode<'a> { - Locate(&'a Locate), -"##; - -static REF_NODE_FOOTER: &str = r##" -} -"##; - -static ANY_NODE_HEADER: &str = r##" -#[derive(Clone, Debug, PartialEq, AnyNode)] -pub enum AnyNode { - Locate(Locate), -"##; - -static ANY_NODE_FOOTER: &str = r##" -} -"##; - -static REF_NODE_DISPLAY_HEADER: &str = r##" -impl<'a> std::fmt::Display for RefNode<'a> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - RefNode::Locate(_) => write!(f, "Locate"), -"##; - -static REF_NODE_DISPLAY_FOOTER: &str = r##" - } - } -} -"##; - -static ANY_NODE_DISPLAY_HEADER: &str = r##" -impl std::fmt::Display for AnyNode { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - AnyNode::Locate(_) => write!(f, "Locate"), -"##; - -static ANY_NODE_DISPLAY_FOOTER: &str = r##" - } - } -} -"##; - -fn main() { - let out_dir = env::var("OUT_DIR").unwrap(); - let dest = Path::new(&out_dir).join("any_node.rs"); - let mut out = File::create(&dest).unwrap(); - - let mut ref_node = String::from(REF_NODE_HEADER); - let mut any_node = String::from(ANY_NODE_HEADER); - let mut ref_node_display = String::from(REF_NODE_DISPLAY_HEADER); - let mut any_node_display = String::from(ANY_NODE_DISPLAY_HEADER); - - let re_node = Regex::new(r"#\[derive.*Node.*\]").unwrap(); - - for entry in WalkDir::new("src") { - let entry = entry.unwrap(); - if entry.path().is_file() { - let f = File::open(entry.path()).unwrap(); - let f = BufReader::new(f); - let mut hit_node = false; - for line in f.lines() { - let line = line.unwrap(); - if hit_node { - let name = line.split_whitespace().nth(2).unwrap().replace("<'a>", ""); - ref_node = format!("{} {}(&'a {}),\n", ref_node, name, name); - any_node = format!("{} {}({}),\n", any_node, name, name); - ref_node_display = format!( - "{} RefNode::{}(_) => write!(f, \"{}\"),\n", - ref_node_display, name, name - ); - any_node_display = format!( - "{} AnyNode::{}(_) => write!(f, \"{}\"),\n", - any_node_display, name, name - ); - hit_node = false; - } - if re_node.is_match(&line) { - hit_node = true; - } - } - } - } - - ref_node = format!("{}{}\n", ref_node, REF_NODE_FOOTER); - any_node = format!("{}{}\n", any_node, ANY_NODE_FOOTER); - ref_node_display = format!("{}{}\n", ref_node_display, REF_NODE_DISPLAY_FOOTER); - any_node_display = format!("{}{}\n", any_node_display, ANY_NODE_DISPLAY_FOOTER); - let _ = write!(out, "{}", ref_node); - let _ = write!(out, "{}", any_node); - let _ = write!(out, "{}", ref_node_display); - let _ = write!(out, "{}", any_node_display); -} diff --git a/sv-parser-syntaxtree/src/any_node.rs b/sv-parser-syntaxtree/src/any_node.rs index 1adaf375..89f0176e 100644 --- a/sv-parser-syntaxtree/src/any_node.rs +++ b/sv-parser-syntaxtree/src/any_node.rs @@ -3,7 +3,5503 @@ use core::convert::TryFrom; // ----------------------------------------------------------------------------- -include!(concat!(env!("OUT_DIR"), "/any_node.rs")); +#[derive(Clone, Debug, PartialEq, RefNode)] +pub enum RefNode<'a> { + Locate(&'a Locate), + Comment(&'a Comment), + AttributeInstance(&'a AttributeInstance), + AttrSpec(&'a AttrSpec), + ArrayIdentifier(&'a ArrayIdentifier), + BlockIdentifier(&'a BlockIdentifier), + BinIdentifier(&'a BinIdentifier), + CIdentifier(&'a CIdentifier), + CellIdentifier(&'a CellIdentifier), + CheckerIdentifier(&'a CheckerIdentifier), + ClassIdentifier(&'a ClassIdentifier), + ClassVariableIdentifier(&'a ClassVariableIdentifier), + ClockingIdentifier(&'a ClockingIdentifier), + ConfigIdentifier(&'a ConfigIdentifier), + ConstIdentifier(&'a ConstIdentifier), + ConstraintIdentifier(&'a ConstraintIdentifier), + CovergroupIdentifier(&'a CovergroupIdentifier), + CovergroupVariableIdentifier(&'a CovergroupVariableIdentifier), + CoverPointIdentifier(&'a CoverPointIdentifier), + CrossIdentifier(&'a CrossIdentifier), + DynamicArrayVariableIdentifier(&'a DynamicArrayVariableIdentifier), + EnumIdentifier(&'a EnumIdentifier), + EscapedIdentifier(&'a EscapedIdentifier), + FormalIdentifier(&'a FormalIdentifier), + FormalPortIdentifier(&'a FormalPortIdentifier), + FunctionIdentifier(&'a FunctionIdentifier), + GenerateBlockIdentifier(&'a GenerateBlockIdentifier), + GenvarIdentifier(&'a GenvarIdentifier), + HierarchicalArrayIdentifier(&'a HierarchicalArrayIdentifier), + HierarchicalBlockIdentifier(&'a HierarchicalBlockIdentifier), + HierarchicalEventIdentifier(&'a HierarchicalEventIdentifier), + HierarchicalIdentifier(&'a HierarchicalIdentifier), + Root(&'a Root), + HierarchicalNetIdentifier(&'a HierarchicalNetIdentifier), + HierarchicalParameterIdentifier(&'a HierarchicalParameterIdentifier), + HierarchicalPropertyIdentifier(&'a HierarchicalPropertyIdentifier), + HierarchicalSequenceIdentifier(&'a HierarchicalSequenceIdentifier), + HierarchicalTaskIdentifier(&'a HierarchicalTaskIdentifier), + HierarchicalTfIdentifier(&'a HierarchicalTfIdentifier), + HierarchicalVariableIdentifier(&'a HierarchicalVariableIdentifier), + Identifier(&'a Identifier), + IndexVariableIdentifier(&'a IndexVariableIdentifier), + InterfaceIdentifier(&'a InterfaceIdentifier), + InterfaceInstanceIdentifier(&'a InterfaceInstanceIdentifier), + InoutPortIdentifier(&'a InoutPortIdentifier), + InputPortIdentifier(&'a InputPortIdentifier), + InstanceIdentifier(&'a InstanceIdentifier), + LibraryIdentifier(&'a LibraryIdentifier), + MemberIdentifier(&'a MemberIdentifier), + MethodIdentifier(&'a MethodIdentifier), + ModportIdentifier(&'a ModportIdentifier), + ModuleIdentifier(&'a ModuleIdentifier), + NetIdentifier(&'a NetIdentifier), + NetTypeIdentifier(&'a NetTypeIdentifier), + OutputPortIdentifier(&'a OutputPortIdentifier), + PackageIdentifier(&'a PackageIdentifier), + PackageScope(&'a PackageScope), + PackageScopePackage(&'a PackageScopePackage), + Unit(&'a Unit), + ParameterIdentifier(&'a ParameterIdentifier), + PortIdentifier(&'a PortIdentifier), + ProductionIdentifier(&'a ProductionIdentifier), + ProgramIdentifier(&'a ProgramIdentifier), + PropertyIdentifier(&'a PropertyIdentifier), + PsClassIdentifier(&'a PsClassIdentifier), + PsCovergroupIdentifier(&'a PsCovergroupIdentifier), + PsCheckerIdentifier(&'a PsCheckerIdentifier), + PsIdentifier(&'a PsIdentifier), + PsOrHierarchicalArrayIdentifier(&'a PsOrHierarchicalArrayIdentifier), + PsOrHierarchicalNetIdentifier(&'a PsOrHierarchicalNetIdentifier), + PsOrHierarchicalNetIdentifierPackageScope(&'a PsOrHierarchicalNetIdentifierPackageScope), + PsOrHierarchicalNetIdentifierHierarchical(&'a PsOrHierarchicalNetIdentifierHierarchical), + PsOrHierarchicalPropertyIdentifier(&'a PsOrHierarchicalPropertyIdentifier), + PsOrHierarchicalPropertyIdentifierPackageScope( + &'a PsOrHierarchicalPropertyIdentifierPackageScope, + ), + PsOrHierarchicalPropertyIdentifierHierarchical( + &'a PsOrHierarchicalPropertyIdentifierHierarchical, + ), + PsOrHierarchicalSequenceIdentifier(&'a PsOrHierarchicalSequenceIdentifier), + PsOrHierarchicalSequenceIdentifierPackageScope( + &'a PsOrHierarchicalSequenceIdentifierPackageScope, + ), + PsOrHierarchicalSequenceIdentifierHierarchical( + &'a PsOrHierarchicalSequenceIdentifierHierarchical, + ), + PsOrHierarchicalTfIdentifier(&'a PsOrHierarchicalTfIdentifier), + PsOrHierarchicalTfIdentifierPackageScope(&'a PsOrHierarchicalTfIdentifierPackageScope), + PsOrHierarchicalTfIdentifierHierarchical(&'a PsOrHierarchicalTfIdentifierHierarchical), + PsParameterIdentifier(&'a PsParameterIdentifier), + PsParameterIdentifierScope(&'a PsParameterIdentifierScope), + PsParameterIdentifierGenerate(&'a PsParameterIdentifierGenerate), + PsTypeIdentifier(&'a PsTypeIdentifier), + LocalOrPackageScopeOrClassScope(&'a LocalOrPackageScopeOrClassScope), + Local(&'a Local), + SequenceIdentifier(&'a SequenceIdentifier), + SignalIdentifier(&'a SignalIdentifier), + SimpleIdentifier(&'a SimpleIdentifier), + SpecparamIdentifier(&'a SpecparamIdentifier), + SystemTfIdentifier(&'a SystemTfIdentifier), + TaskIdentifier(&'a TaskIdentifier), + TfIdentifier(&'a TfIdentifier), + TerminalIdentifier(&'a TerminalIdentifier), + TopmoduleIdentifier(&'a TopmoduleIdentifier), + TypeIdentifier(&'a TypeIdentifier), + UdpIdentifier(&'a UdpIdentifier), + VariableIdentifier(&'a VariableIdentifier), + ImplicitClassHandleOrClassScopeOrPackageScope( + &'a ImplicitClassHandleOrClassScopeOrPackageScope, + ), + ImplicitClassHandleOrPackageScope(&'a ImplicitClassHandleOrPackageScope), + ImplicitClassHandleOrClassScope(&'a ImplicitClassHandleOrClassScope), + PackageScopeOrClassScope(&'a PackageScopeOrClassScope), + CompilerDirective(&'a CompilerDirective), + ResetallCompilerDirective(&'a ResetallCompilerDirective), + IncludeCompilerDirective(&'a IncludeCompilerDirective), + IncludeCompilerDirectiveDoubleQuote(&'a IncludeCompilerDirectiveDoubleQuote), + IncludeCompilerDirectiveAngleBracket(&'a IncludeCompilerDirectiveAngleBracket), + IncludeCompilerDirectiveTextMacroUsage(&'a IncludeCompilerDirectiveTextMacroUsage), + AngleBracketLiteral(&'a AngleBracketLiteral), + TextMacroDefinition(&'a TextMacroDefinition), + TextMacroName(&'a TextMacroName), + ListOfFormalArguments(&'a ListOfFormalArguments), + FormalArgument(&'a FormalArgument), + TextMacroIdentifier(&'a TextMacroIdentifier), + MacroText(&'a MacroText), + DefaultText(&'a DefaultText), + TextMacroUsage(&'a TextMacroUsage), + ListOfActualArguments(&'a ListOfActualArguments), + ActualArgument(&'a ActualArgument), + UndefineCompilerDirective(&'a UndefineCompilerDirective), + UndefineallCompilerDirective(&'a UndefineallCompilerDirective), + ConditionalCompilerDirective(&'a ConditionalCompilerDirective), + IfdefDirective(&'a IfdefDirective), + IfndefDirective(&'a IfndefDirective), + IfdefGroupOfLines(&'a IfdefGroupOfLines), + IfndefGroupOfLines(&'a IfndefGroupOfLines), + ElsifGroupOfLines(&'a ElsifGroupOfLines), + ElseGroupOfLines(&'a ElseGroupOfLines), + SourceDescription(&'a SourceDescription), + SourceDescriptionNotDirective(&'a SourceDescriptionNotDirective), + TimescaleCompilerDirective(&'a TimescaleCompilerDirective), + DefaultNettypeCompilerDirective(&'a DefaultNettypeCompilerDirective), + DefaultNettypeValue(&'a DefaultNettypeValue), + UnconnectedDriveCompilerDirective(&'a UnconnectedDriveCompilerDirective), + NounconnectedDriveCompilerDirective(&'a NounconnectedDriveCompilerDirective), + CelldefineDriveCompilerDirective(&'a CelldefineDriveCompilerDirective), + EndcelldefineDriveCompilerDirective(&'a EndcelldefineDriveCompilerDirective), + Pragma(&'a Pragma), + PragmaName(&'a PragmaName), + PragmaExpression(&'a PragmaExpression), + PragmaExpressionAssignment(&'a PragmaExpressionAssignment), + PragmaValue(&'a PragmaValue), + PragmaValueParen(&'a PragmaValueParen), + PragmaKeyword(&'a PragmaKeyword), + LineCompilerDirective(&'a LineCompilerDirective), + PositionCompilerDirective(&'a PositionCompilerDirective), + Level(&'a Level), + KeywordsDirective(&'a KeywordsDirective), + VersionSpecifier(&'a VersionSpecifier), + EndkeywordsDirective(&'a EndkeywordsDirective), + DriveStrength(&'a DriveStrength), + DriveStrength01(&'a DriveStrength01), + DriveStrength10(&'a DriveStrength10), + DriveStrength0z(&'a DriveStrength0z), + DriveStrength1z(&'a DriveStrength1z), + DriveStrengthz1(&'a DriveStrengthz1), + DriveStrengthz0(&'a DriveStrengthz0), + Strength0(&'a Strength0), + Strength1(&'a Strength1), + ChargeStrength(&'a ChargeStrength), + ChargeStrengthSmall(&'a ChargeStrengthSmall), + ChargeStrengthMedium(&'a ChargeStrengthMedium), + ChargeStrengthLarge(&'a ChargeStrengthLarge), + ModportDeclaration(&'a ModportDeclaration), + ModportItem(&'a ModportItem), + ModportPortsDeclaration(&'a ModportPortsDeclaration), + ModportPortsDeclarationSimple(&'a ModportPortsDeclarationSimple), + ModportPortsDeclarationTf(&'a ModportPortsDeclarationTf), + ModportPortsDeclarationClocking(&'a ModportPortsDeclarationClocking), + ModportClockingDeclaration(&'a ModportClockingDeclaration), + ModportSimplePortsDeclaration(&'a ModportSimplePortsDeclaration), + ModportSimplePort(&'a ModportSimplePort), + ModportSimplePortOrdered(&'a ModportSimplePortOrdered), + ModportSimplePortNamed(&'a ModportSimplePortNamed), + ModportTfPortsDeclaration(&'a ModportTfPortsDeclaration), + ModportTfPort(&'a ModportTfPort), + ImportExport(&'a ImportExport), + FunctionDataTypeOrImplicit(&'a FunctionDataTypeOrImplicit), + FunctionDeclaration(&'a FunctionDeclaration), + FunctionBodyDeclaration(&'a FunctionBodyDeclaration), + FunctionBodyDeclarationWithoutPort(&'a FunctionBodyDeclarationWithoutPort), + FunctionBodyDeclarationWithPort(&'a FunctionBodyDeclarationWithPort), + InterfaceIdentifierOrClassScope(&'a InterfaceIdentifierOrClassScope), + FunctionPrototype(&'a FunctionPrototype), + DpiImportExport(&'a DpiImportExport), + DpiImportExportImportFunction(&'a DpiImportExportImportFunction), + DpiImportExportImportTask(&'a DpiImportExportImportTask), + DpiImportExportExportFunction(&'a DpiImportExportExportFunction), + DpiImportExportExportTask(&'a DpiImportExportExportTask), + DpiSpecString(&'a DpiSpecString), + DpiFunctionImportProperty(&'a DpiFunctionImportProperty), + DpiTaskImportProperty(&'a DpiTaskImportProperty), + DpiFunctionProto(&'a DpiFunctionProto), + DpiTaskProto(&'a DpiTaskProto), + CovergroupDeclaration(&'a CovergroupDeclaration), + CoverageSpecOrOption(&'a CoverageSpecOrOption), + CoverageSpecOrOptionSpec(&'a CoverageSpecOrOptionSpec), + CoverageSpecOrOptionOption(&'a CoverageSpecOrOptionOption), + CoverageOption(&'a CoverageOption), + CoverageOptionOption(&'a CoverageOptionOption), + CoverageOptionTypeOption(&'a CoverageOptionTypeOption), + CoverageSpec(&'a CoverageSpec), + CoverageEvent(&'a CoverageEvent), + CoverageEventSample(&'a CoverageEventSample), + CoverageEventAt(&'a CoverageEventAt), + BlockEventExpression(&'a BlockEventExpression), + BlockEventExpressionOr(&'a BlockEventExpressionOr), + BlockEventExpressionBegin(&'a BlockEventExpressionBegin), + BlockEventExpressionEnd(&'a BlockEventExpressionEnd), + HierarchicalBtfIdentifier(&'a HierarchicalBtfIdentifier), + HierarchicalBtfIdentifierMethod(&'a HierarchicalBtfIdentifierMethod), + HierarchicalIdentifierOrClassScope(&'a HierarchicalIdentifierOrClassScope), + CoverPoint(&'a CoverPoint), + BinsOrEmpty(&'a BinsOrEmpty), + BinsOrEmptyNonEmpty(&'a BinsOrEmptyNonEmpty), + BinsOrOptions(&'a BinsOrOptions), + BinsOrOptionsCovergroup(&'a BinsOrOptionsCovergroup), + Wildcard(&'a Wildcard), + BinsOrOptionsCoverPoint(&'a BinsOrOptionsCoverPoint), + BinsOrOptionsSetCovergroup(&'a BinsOrOptionsSetCovergroup), + BinsOrOptionsTransList(&'a BinsOrOptionsTransList), + BinsOrOptionsDefault(&'a BinsOrOptionsDefault), + BinsOrOptionsDefaultSequence(&'a BinsOrOptionsDefaultSequence), + BinsKeyword(&'a BinsKeyword), + TransList(&'a TransList), + TransSet(&'a TransSet), + TransRangeList(&'a TransRangeList), + TransRangeListAsterisk(&'a TransRangeListAsterisk), + TransRangeListArrow(&'a TransRangeListArrow), + TransRangeListEqual(&'a TransRangeListEqual), + TransItem(&'a TransItem), + RepeatRange(&'a RepeatRange), + RepeatRangeBinary(&'a RepeatRangeBinary), + CoverCross(&'a CoverCross), + ListOfCrossItems(&'a ListOfCrossItems), + CrossItem(&'a CrossItem), + CrossBody(&'a CrossBody), + CrossBodyNonEmpty(&'a CrossBodyNonEmpty), + CrossBodyItem(&'a CrossBodyItem), + BinsSelectionOrOption(&'a BinsSelectionOrOption), + BinsSelectionOrOptionCoverage(&'a BinsSelectionOrOptionCoverage), + BinsSelectionOrOptionBins(&'a BinsSelectionOrOptionBins), + BinsSelection(&'a BinsSelection), + SelectExpression(&'a SelectExpression), + SelectExpressionNot(&'a SelectExpressionNot), + SelectExpressionAnd(&'a SelectExpressionAnd), + SelectExpressionOr(&'a SelectExpressionOr), + SelectExpressionParen(&'a SelectExpressionParen), + SelectExpressionWith(&'a SelectExpressionWith), + SelectExpressionCrossSet(&'a SelectExpressionCrossSet), + SelectCondition(&'a SelectCondition), + BinsExpression(&'a BinsExpression), + BinsExpressionCoverPoint(&'a BinsExpressionCoverPoint), + CovergroupRangeList(&'a CovergroupRangeList), + CovergroupValueRange(&'a CovergroupValueRange), + CovergroupValueRangeBinary(&'a CovergroupValueRangeBinary), + WithCovergroupExpression(&'a WithCovergroupExpression), + SetCovergroupExpression(&'a SetCovergroupExpression), + IntegerCovergroupExpression(&'a IntegerCovergroupExpression), + CrossSetExpression(&'a CrossSetExpression), + CovergroupExpression(&'a CovergroupExpression), + DataDeclaration(&'a DataDeclaration), + DataDeclarationVariable(&'a DataDeclarationVariable), + Const(&'a Const), + PackageImportDeclaration(&'a PackageImportDeclaration), + PackageImportItem(&'a PackageImportItem), + PackageImportItemIdentifier(&'a PackageImportItemIdentifier), + PackageImportItemAsterisk(&'a PackageImportItemAsterisk), + PackageExportDeclaration(&'a PackageExportDeclaration), + PackageExportDeclarationAsterisk(&'a PackageExportDeclarationAsterisk), + PackageExportDeclarationItem(&'a PackageExportDeclarationItem), + GenvarDeclaration(&'a GenvarDeclaration), + NetDeclaration(&'a NetDeclaration), + NetDeclarationNetType(&'a NetDeclarationNetType), + Strength(&'a Strength), + VectorScalar(&'a VectorScalar), + NetDeclarationNetTypeIdentifier(&'a NetDeclarationNetTypeIdentifier), + NetDeclarationInterconnect(&'a NetDeclarationInterconnect), + TypeDeclaration(&'a TypeDeclaration), + TypeDeclarationDataType(&'a TypeDeclarationDataType), + TypeDeclarationInterface(&'a TypeDeclarationInterface), + TypeDeclarationReserved(&'a TypeDeclarationReserved), + TypeDeclarationKeyword(&'a TypeDeclarationKeyword), + NetTypeDeclaration(&'a NetTypeDeclaration), + NetTypeDeclarationDataType(&'a NetTypeDeclarationDataType), + NetTypeDeclarationNetType(&'a NetTypeDeclarationNetType), + Lifetime(&'a Lifetime), + ConcurrentAssertionItem(&'a ConcurrentAssertionItem), + ConcurrentAssertionItemStatement(&'a ConcurrentAssertionItemStatement), + ConcurrentAssertionStatement(&'a ConcurrentAssertionStatement), + AssertPropertyStatement(&'a AssertPropertyStatement), + AssumePropertyStatement(&'a AssumePropertyStatement), + CoverPropertyStatement(&'a CoverPropertyStatement), + ExpectPropertyStatement(&'a ExpectPropertyStatement), + CoverSequenceStatement(&'a CoverSequenceStatement), + RestrictPropertyStatement(&'a RestrictPropertyStatement), + PropertyInstance(&'a PropertyInstance), + PropertyListOfArguments(&'a PropertyListOfArguments), + PropertyListOfArgumentsOrdered(&'a PropertyListOfArgumentsOrdered), + PropertyListOfArgumentsNamed(&'a PropertyListOfArgumentsNamed), + PropertyActualArg(&'a PropertyActualArg), + AssertionItemDeclaration(&'a AssertionItemDeclaration), + PropertyDeclaration(&'a PropertyDeclaration), + PropertyPortList(&'a PropertyPortList), + PropertyPortItem(&'a PropertyPortItem), + PropertyLvarPortDirection(&'a PropertyLvarPortDirection), + PropertyFormalType(&'a PropertyFormalType), + PropertySpec(&'a PropertySpec), + PropertyExpr(&'a PropertyExpr), + PropertyExprStrong(&'a PropertyExprStrong), + PropertyExprWeak(&'a PropertyExprWeak), + PropertyExprParen(&'a PropertyExprParen), + PropertyExprNot(&'a PropertyExprNot), + PropertyExprBinaryProperty(&'a PropertyExprBinaryProperty), + PropertyExprBinarySequence(&'a PropertyExprBinarySequence), + PropertyExprIf(&'a PropertyExprIf), + PropertyExprCase(&'a PropertyExprCase), + PropertyExprNexttime(&'a PropertyExprNexttime), + PropertyExprSNexttime(&'a PropertyExprSNexttime), + PropertyExprAlways(&'a PropertyExprAlways), + PropertyExprSAlways(&'a PropertyExprSAlways), + PropertyExprEventually(&'a PropertyExprEventually), + PropertyExprSEventually(&'a PropertyExprSEventually), + PropertyExprAcceptOn(&'a PropertyExprAcceptOn), + PropertyExprRejectOn(&'a PropertyExprRejectOn), + PropertyExprSyncAcceptOn(&'a PropertyExprSyncAcceptOn), + PropertyExprSyncRejectOn(&'a PropertyExprSyncRejectOn), + PropertyExprClockingEvent(&'a PropertyExprClockingEvent), + PropertyCaseItem(&'a PropertyCaseItem), + PropertyCaseItemNondefault(&'a PropertyCaseItemNondefault), + PropertyCaseItemDefault(&'a PropertyCaseItemDefault), + SequenceDeclaration(&'a SequenceDeclaration), + SequencePortList(&'a SequencePortList), + SequencePortItem(&'a SequencePortItem), + SequenceLvarPortDirection(&'a SequenceLvarPortDirection), + SequenceFormalType(&'a SequenceFormalType), + SequenceExpr(&'a SequenceExpr), + SequenceExprCycleDelayExpr(&'a SequenceExprCycleDelayExpr), + SequenceExprExprCycleDelayExpr(&'a SequenceExprExprCycleDelayExpr), + SequenceExprExpression(&'a SequenceExprExpression), + SequenceExprInstance(&'a SequenceExprInstance), + SequenceExprParen(&'a SequenceExprParen), + SequenceExprBinary(&'a SequenceExprBinary), + SequenceExprFirstMatch(&'a SequenceExprFirstMatch), + SequenceExprThroughout(&'a SequenceExprThroughout), + SequenceExprClockingEvent(&'a SequenceExprClockingEvent), + CycleDelayRange(&'a CycleDelayRange), + CycleDelayRangePrimary(&'a CycleDelayRangePrimary), + CycleDelayRangeExpression(&'a CycleDelayRangeExpression), + CycleDelayRangeAsterisk(&'a CycleDelayRangeAsterisk), + CycleDelayRangePlus(&'a CycleDelayRangePlus), + SequenceMethodCall(&'a SequenceMethodCall), + SequenceMatchItem(&'a SequenceMatchItem), + SequenceInstance(&'a SequenceInstance), + SequenceListOfArguments(&'a SequenceListOfArguments), + SequenceListOfArgumentsOrdered(&'a SequenceListOfArgumentsOrdered), + SequenceListOfArgumentsNamed(&'a SequenceListOfArgumentsNamed), + SequenceActualArg(&'a SequenceActualArg), + BooleanAbbrev(&'a BooleanAbbrev), + SequenceAbbrev(&'a SequenceAbbrev), + ConsecutiveRepetition(&'a ConsecutiveRepetition), + ConsecutiveRepetitionExpression(&'a ConsecutiveRepetitionExpression), + ConsecutiveRepetitionAsterisk(&'a ConsecutiveRepetitionAsterisk), + ConsecutiveRepetitionPlus(&'a ConsecutiveRepetitionPlus), + NonConsecutiveRepetition(&'a NonConsecutiveRepetition), + GotoRepetition(&'a GotoRepetition), + ConstOrRangeExpression(&'a ConstOrRangeExpression), + CycleDelayConstRangeExpression(&'a CycleDelayConstRangeExpression), + CycleDelayConstRangeExpressionBinary(&'a CycleDelayConstRangeExpressionBinary), + CycleDelayConstRangeExpressionDollar(&'a CycleDelayConstRangeExpressionDollar), + ExpressionOrDist(&'a ExpressionOrDist), + AssertionVariableDeclaration(&'a AssertionVariableDeclaration), + LetDeclaration(&'a LetDeclaration), + LetIdentifier(&'a LetIdentifier), + LetPortList(&'a LetPortList), + LetPortItem(&'a LetPortItem), + LetFormalType(&'a LetFormalType), + LetExpression(&'a LetExpression), + LetListOfArguments(&'a LetListOfArguments), + LetListOfArgumentsOrdered(&'a LetListOfArgumentsOrdered), + LetListOfArgumentsNamed(&'a LetListOfArgumentsNamed), + LetActualArg(&'a LetActualArg), + CastingType(&'a CastingType), + DataType(&'a DataType), + DataTypeVector(&'a DataTypeVector), + DataTypeAtom(&'a DataTypeAtom), + DataTypeStructUnion(&'a DataTypeStructUnion), + Packed(&'a Packed), + DataTypeEnum(&'a DataTypeEnum), + DataTypeVirtual(&'a DataTypeVirtual), + Interface(&'a Interface), + DataTypeType(&'a DataTypeType), + DataTypeOrImplicit(&'a DataTypeOrImplicit), + ImplicitDataType(&'a ImplicitDataType), + EnumBaseType(&'a EnumBaseType), + EnumBaseTypeAtom(&'a EnumBaseTypeAtom), + EnumBaseTypeVector(&'a EnumBaseTypeVector), + EnumBaseTypeType(&'a EnumBaseTypeType), + EnumNameDeclaration(&'a EnumNameDeclaration), + ClassScope(&'a ClassScope), + ClassType(&'a ClassType), + IntegerType(&'a IntegerType), + IntegerAtomType(&'a IntegerAtomType), + IntegerVectorType(&'a IntegerVectorType), + NonIntegerType(&'a NonIntegerType), + NetType(&'a NetType), + NetPortType(&'a NetPortType), + NetPortTypeDataType(&'a NetPortTypeDataType), + NetPortTypeInterconnect(&'a NetPortTypeInterconnect), + VariablePortType(&'a VariablePortType), + VarDataType(&'a VarDataType), + VarDataTypeVar(&'a VarDataTypeVar), + Signing(&'a Signing), + SimpleType(&'a SimpleType), + StructUnionMember(&'a StructUnionMember), + DataTypeOrVoid(&'a DataTypeOrVoid), + StructUnion(&'a StructUnion), + TypeReference(&'a TypeReference), + TypeReferenceExpression(&'a TypeReferenceExpression), + TypeReferenceDataType(&'a TypeReferenceDataType), + LocalParameterDeclaration(&'a LocalParameterDeclaration), + LocalParameterDeclarationParam(&'a LocalParameterDeclarationParam), + LocalParameterDeclarationType(&'a LocalParameterDeclarationType), + ParameterDeclaration(&'a ParameterDeclaration), + ParameterDeclarationParam(&'a ParameterDeclarationParam), + ParameterDeclarationType(&'a ParameterDeclarationType), + SpecparamDeclaration(&'a SpecparamDeclaration), + BlockItemDeclaration(&'a BlockItemDeclaration), + BlockItemDeclarationData(&'a BlockItemDeclarationData), + BlockItemDeclarationLocalParameter(&'a BlockItemDeclarationLocalParameter), + BlockItemDeclarationParameter(&'a BlockItemDeclarationParameter), + BlockItemDeclarationLet(&'a BlockItemDeclarationLet), + ListOfDefparamAssignments(&'a ListOfDefparamAssignments), + ListOfGenvarIdentifiers(&'a ListOfGenvarIdentifiers), + ListOfInterfaceIdentifiers(&'a ListOfInterfaceIdentifiers), + ListOfNetDeclAssignments(&'a ListOfNetDeclAssignments), + ListOfParamAssignments(&'a ListOfParamAssignments), + ListOfPortIdentifiers(&'a ListOfPortIdentifiers), + ListOfUdpPortIdentifiers(&'a ListOfUdpPortIdentifiers), + ListOfSpecparamAssignments(&'a ListOfSpecparamAssignments), + ListOfTfVariableIdentifiers(&'a ListOfTfVariableIdentifiers), + ListOfTypeAssignments(&'a ListOfTypeAssignments), + ListOfVariableDeclAssignments(&'a ListOfVariableDeclAssignments), + ListOfVariableIdentifiers(&'a ListOfVariableIdentifiers), + ListOfVariablePortIdentifiers(&'a ListOfVariablePortIdentifiers), + DefparamAssignment(&'a DefparamAssignment), + NetDeclAssignment(&'a NetDeclAssignment), + ParamAssignment(&'a ParamAssignment), + SpecparamAssignment(&'a SpecparamAssignment), + SpecparamAssignmentMintypmax(&'a SpecparamAssignmentMintypmax), + TypeAssignment(&'a TypeAssignment), + PulseControlSpecparam(&'a PulseControlSpecparam), + PulseControlSpecparamWithoutDescriptor(&'a PulseControlSpecparamWithoutDescriptor), + PulseControlSpecparamWithDescriptor(&'a PulseControlSpecparamWithDescriptor), + ErrorLimitValue(&'a ErrorLimitValue), + RejectLimitValue(&'a RejectLimitValue), + LimitValue(&'a LimitValue), + VariableDeclAssignment(&'a VariableDeclAssignment), + VariableDeclAssignmentVariable(&'a VariableDeclAssignmentVariable), + VariableDeclAssignmentDynamicArray(&'a VariableDeclAssignmentDynamicArray), + VariableDeclAssignmentClass(&'a VariableDeclAssignmentClass), + ClassNew(&'a ClassNew), + ClassNewArgument(&'a ClassNewArgument), + ClassNewExpression(&'a ClassNewExpression), + DynamicArrayNew(&'a DynamicArrayNew), + UnpackedDimension(&'a UnpackedDimension), + UnpackedDimensionRange(&'a UnpackedDimensionRange), + UnpackedDimensionExpression(&'a UnpackedDimensionExpression), + PackedDimension(&'a PackedDimension), + PackedDimensionRange(&'a PackedDimensionRange), + AssociativeDimension(&'a AssociativeDimension), + AssociativeDimensionDataType(&'a AssociativeDimensionDataType), + AssociativeDimensionAsterisk(&'a AssociativeDimensionAsterisk), + VariableDimension(&'a VariableDimension), + QueueDimension(&'a QueueDimension), + UnsizedDimension(&'a UnsizedDimension), + Delay3(&'a Delay3), + Delay3Single(&'a Delay3Single), + Delay3Mintypmax(&'a Delay3Mintypmax), + Delay2(&'a Delay2), + Delay2Single(&'a Delay2Single), + Delay2Mintypmax(&'a Delay2Mintypmax), + DelayValue(&'a DelayValue), + TaskDeclaration(&'a TaskDeclaration), + TaskBodyDeclaration(&'a TaskBodyDeclaration), + TaskBodyDeclarationWithoutPort(&'a TaskBodyDeclarationWithoutPort), + TaskBodyDeclarationWithPort(&'a TaskBodyDeclarationWithPort), + TfItemDeclaration(&'a TfItemDeclaration), + TfPortList(&'a TfPortList), + TfPortItem(&'a TfPortItem), + TfPortDirection(&'a TfPortDirection), + TfPortDeclaration(&'a TfPortDeclaration), + TaskPrototype(&'a TaskPrototype), + InoutDeclaration(&'a InoutDeclaration), + InputDeclaration(&'a InputDeclaration), + InputDeclarationNet(&'a InputDeclarationNet), + InputDeclarationVariable(&'a InputDeclarationVariable), + OutputDeclaration(&'a OutputDeclaration), + OutputDeclarationNet(&'a OutputDeclarationNet), + OutputDeclarationVariable(&'a OutputDeclarationVariable), + InterfacePortDeclaration(&'a InterfacePortDeclaration), + RefDeclaration(&'a RefDeclaration), + GenerateRegion(&'a GenerateRegion), + LoopGenerateConstruct(&'a LoopGenerateConstruct), + GenvarInitialization(&'a GenvarInitialization), + Genvar(&'a Genvar), + GenvarIteration(&'a GenvarIteration), + GenvarIterationAssignment(&'a GenvarIterationAssignment), + GenvarIterationPrefix(&'a GenvarIterationPrefix), + GenvarIterationSuffix(&'a GenvarIterationSuffix), + ConditionalGenerateConstruct(&'a ConditionalGenerateConstruct), + IfGenerateConstruct(&'a IfGenerateConstruct), + CaseGenerateConstruct(&'a CaseGenerateConstruct), + CaseGenerateItem(&'a CaseGenerateItem), + CaseGenerateItemNondefault(&'a CaseGenerateItemNondefault), + CaseGenerateItemDefault(&'a CaseGenerateItemDefault), + GenerateBlock(&'a GenerateBlock), + GenerateBlockMultiple(&'a GenerateBlockMultiple), + GenerateItem(&'a GenerateItem), + InterfaceInstantiation(&'a InterfaceInstantiation), + ProgramInstantiation(&'a ProgramInstantiation), + ModuleInstantiation(&'a ModuleInstantiation), + ParameterValueAssignment(&'a ParameterValueAssignment), + ListOfParameterAssignments(&'a ListOfParameterAssignments), + ListOfParameterAssignmentsOrdered(&'a ListOfParameterAssignmentsOrdered), + ListOfParameterAssignmentsNamed(&'a ListOfParameterAssignmentsNamed), + OrderedParameterAssignment(&'a OrderedParameterAssignment), + NamedParameterAssignment(&'a NamedParameterAssignment), + HierarchicalInstance(&'a HierarchicalInstance), + NameOfInstance(&'a NameOfInstance), + ListOfPortConnections(&'a ListOfPortConnections), + ListOfPortConnectionsOrdered(&'a ListOfPortConnectionsOrdered), + ListOfPortConnectionsNamed(&'a ListOfPortConnectionsNamed), + OrderedPortConnection(&'a OrderedPortConnection), + NamedPortConnection(&'a NamedPortConnection), + NamedPortConnectionIdentifier(&'a NamedPortConnectionIdentifier), + NamedPortConnectionAsterisk(&'a NamedPortConnectionAsterisk), + CheckerInstantiation(&'a CheckerInstantiation), + ListOfCheckerPortConnections(&'a ListOfCheckerPortConnections), + ListOfCheckerPortConnectionsOrdered(&'a ListOfCheckerPortConnectionsOrdered), + ListOfCheckerPortConnectionsNamed(&'a ListOfCheckerPortConnectionsNamed), + OrderedCheckerPortConnection(&'a OrderedCheckerPortConnection), + NamedCheckerPortConnection(&'a NamedCheckerPortConnection), + NamedCheckerPortConnectionIdentifier(&'a NamedCheckerPortConnectionIdentifier), + NamedCheckerPortConnectionAsterisk(&'a NamedCheckerPortConnectionAsterisk), + NetLvalue(&'a NetLvalue), + NetLvalueIdentifier(&'a NetLvalueIdentifier), + NetLvalueLvalue(&'a NetLvalueLvalue), + NetLvaluePattern(&'a NetLvaluePattern), + VariableLvalue(&'a VariableLvalue), + VariableLvalueIdentifier(&'a VariableLvalueIdentifier), + VariableLvalueLvalue(&'a VariableLvalueLvalue), + VariableLvaluePattern(&'a VariableLvaluePattern), + NonrangeVariableLvalue(&'a NonrangeVariableLvalue), + Concatenation(&'a Concatenation), + ConstantConcatenation(&'a ConstantConcatenation), + ConstantMultipleConcatenation(&'a ConstantMultipleConcatenation), + ModulePathConcatenation(&'a ModulePathConcatenation), + ModulePathMultipleConcatenation(&'a ModulePathMultipleConcatenation), + MultipleConcatenation(&'a MultipleConcatenation), + StreamingConcatenation(&'a StreamingConcatenation), + StreamOperator(&'a StreamOperator), + SliceSize(&'a SliceSize), + StreamConcatenation(&'a StreamConcatenation), + StreamExpression(&'a StreamExpression), + ArrayRangeExpression(&'a ArrayRangeExpression), + ArrayRangeExpressionColon(&'a ArrayRangeExpressionColon), + ArrayRangeExpressionPlusColon(&'a ArrayRangeExpressionPlusColon), + ArrayRangeExpressionMinusColon(&'a ArrayRangeExpressionMinusColon), + EmptyUnpackedArrayConcatenation(&'a EmptyUnpackedArrayConcatenation), + ConstantPrimary(&'a ConstantPrimary), + ConstantPrimaryPsParameter(&'a ConstantPrimaryPsParameter), + ConstantPrimarySpecparam(&'a ConstantPrimarySpecparam), + ConstantPrimaryFormalPort(&'a ConstantPrimaryFormalPort), + ConstantPrimaryEnum(&'a ConstantPrimaryEnum), + ConstantPrimaryConcatenation(&'a ConstantPrimaryConcatenation), + ConstantPrimaryMultipleConcatenation(&'a ConstantPrimaryMultipleConcatenation), + ConstantPrimaryMintypmaxExpression(&'a ConstantPrimaryMintypmaxExpression), + ModulePathPrimary(&'a ModulePathPrimary), + ModulePathPrimaryMintypmax(&'a ModulePathPrimaryMintypmax), + Primary(&'a Primary), + PrimaryHierarchical(&'a PrimaryHierarchical), + PrimaryConcatenation(&'a PrimaryConcatenation), + PrimaryMultipleConcatenation(&'a PrimaryMultipleConcatenation), + PrimaryMintypmaxExpression(&'a PrimaryMintypmaxExpression), + ClassQualifierOrPackageScope(&'a ClassQualifierOrPackageScope), + ClassQualifier(&'a ClassQualifier), + RangeExpression(&'a RangeExpression), + PrimaryLiteral(&'a PrimaryLiteral), + TimeLiteral(&'a TimeLiteral), + TimeLiteralUnsigned(&'a TimeLiteralUnsigned), + TimeLiteralFixedPoint(&'a TimeLiteralFixedPoint), + TimeUnit(&'a TimeUnit), + ImplicitClassHandle(&'a ImplicitClassHandle), + BitSelect(&'a BitSelect), + Select(&'a Select), + NonrangeSelect(&'a NonrangeSelect), + ConstantBitSelect(&'a ConstantBitSelect), + ConstantSelect(&'a ConstantSelect), + ConstantCast(&'a ConstantCast), + ConstantLetExpression(&'a ConstantLetExpression), + Cast(&'a Cast), + IncOrDecExpression(&'a IncOrDecExpression), + IncOrDecExpressionPrefix(&'a IncOrDecExpressionPrefix), + IncOrDecExpressionSuffix(&'a IncOrDecExpressionSuffix), + ConditionalExpression(&'a ConditionalExpression), + ConstantExpression(&'a ConstantExpression), + ConstantExpressionUnary(&'a ConstantExpressionUnary), + ConstantExpressionBinary(&'a ConstantExpressionBinary), + ConstantExpressionTernary(&'a ConstantExpressionTernary), + ConstantInsideExpression(&'a ConstantInsideExpression), + ConstantMintypmaxExpression(&'a ConstantMintypmaxExpression), + ConstantMintypmaxExpressionTernary(&'a ConstantMintypmaxExpressionTernary), + ConstantParamExpression(&'a ConstantParamExpression), + ParamExpression(&'a ParamExpression), + ConstantRangeExpression(&'a ConstantRangeExpression), + ConstantPartSelectRange(&'a ConstantPartSelectRange), + ConstantRange(&'a ConstantRange), + ConstantIndexedRange(&'a ConstantIndexedRange), + Expression(&'a Expression), + ExpressionUnary(&'a ExpressionUnary), + ExpressionOperatorAssignment(&'a ExpressionOperatorAssignment), + ExpressionBinary(&'a ExpressionBinary), + ExpressionBinaryOperand(&'a ExpressionBinaryOperand), + TaggedUnionExpression(&'a TaggedUnionExpression), + InsideExpression(&'a InsideExpression), + ValueRange(&'a ValueRange), + ValueRangeBinary(&'a ValueRangeBinary), + MintypmaxExpression(&'a MintypmaxExpression), + MintypmaxExpressionTernary(&'a MintypmaxExpressionTernary), + ModulePathConditionalExpression(&'a ModulePathConditionalExpression), + ModulePathExpression(&'a ModulePathExpression), + ModulePathExpressionUnary(&'a ModulePathExpressionUnary), + ModulePathExpressionBinary(&'a ModulePathExpressionBinary), + ModulePathMintypmaxExpression(&'a ModulePathMintypmaxExpression), + ModulePathMintypmaxExpressionTernary(&'a ModulePathMintypmaxExpressionTernary), + PartSelectRange(&'a PartSelectRange), + IndexedRange(&'a IndexedRange), + GenvarExpression(&'a GenvarExpression), + UnaryOperator(&'a UnaryOperator), + BinaryOperator(&'a BinaryOperator), + IncOrDecOperator(&'a IncOrDecOperator), + UnaryModulePathOperator(&'a UnaryModulePathOperator), + BinaryModulePathOperator(&'a BinaryModulePathOperator), + StringLiteral(&'a StringLiteral), + ConstantFunctionCall(&'a ConstantFunctionCall), + TfCall(&'a TfCall), + SystemTfCall(&'a SystemTfCall), + SystemTfCallArgOptional(&'a SystemTfCallArgOptional), + SystemTfCallArgDataType(&'a SystemTfCallArgDataType), + SystemTfCallArgExpression(&'a SystemTfCallArgExpression), + SubroutineCall(&'a SubroutineCall), + SubroutineCallRandomize(&'a SubroutineCallRandomize), + FunctionSubroutineCall(&'a FunctionSubroutineCall), + ListOfArguments(&'a ListOfArguments), + ListOfArgumentsOrdered(&'a ListOfArgumentsOrdered), + ListOfArgumentsNamed(&'a ListOfArgumentsNamed), + MethodCall(&'a MethodCall), + MethodCallBody(&'a MethodCallBody), + MethodCallBodyUser(&'a MethodCallBodyUser), + BuiltInMethodCall(&'a BuiltInMethodCall), + ArrayManipulationCall(&'a ArrayManipulationCall), + RandomizeCall(&'a RandomizeCall), + VariableIdentifierListOrNull(&'a VariableIdentifierListOrNull), + MethodCallRoot(&'a MethodCallRoot), + ArrayMethodName(&'a ArrayMethodName), + Number(&'a Number), + IntegralNumber(&'a IntegralNumber), + DecimalNumber(&'a DecimalNumber), + DecimalNumberBaseUnsigned(&'a DecimalNumberBaseUnsigned), + DecimalNumberBaseXNumber(&'a DecimalNumberBaseXNumber), + DecimalNumberBaseZNumber(&'a DecimalNumberBaseZNumber), + BinaryNumber(&'a BinaryNumber), + OctalNumber(&'a OctalNumber), + HexNumber(&'a HexNumber), + Sign(&'a Sign), + Size(&'a Size), + NonZeroUnsignedNumber(&'a NonZeroUnsignedNumber), + RealNumber(&'a RealNumber), + RealNumberFloating(&'a RealNumberFloating), + FixedPointNumber(&'a FixedPointNumber), + Exp(&'a Exp), + UnsignedNumber(&'a UnsignedNumber), + BinaryValue(&'a BinaryValue), + OctalValue(&'a OctalValue), + HexValue(&'a HexValue), + DecimalBase(&'a DecimalBase), + BinaryBase(&'a BinaryBase), + OctalBase(&'a OctalBase), + HexBase(&'a HexBase), + XNumber(&'a XNumber), + ZNumber(&'a ZNumber), + UnbasedUnsizedLiteral(&'a UnbasedUnsizedLiteral), + SourceText(&'a SourceText), + Description(&'a Description), + DescriptionPackageItem(&'a DescriptionPackageItem), + DescriptionBindDirective(&'a DescriptionBindDirective), + ModuleNonansiHeader(&'a ModuleNonansiHeader), + ModuleAnsiHeader(&'a ModuleAnsiHeader), + ModuleDeclaration(&'a ModuleDeclaration), + ModuleDeclarationNonansi(&'a ModuleDeclarationNonansi), + ModuleDeclarationAnsi(&'a ModuleDeclarationAnsi), + ModuleDeclarationWildcard(&'a ModuleDeclarationWildcard), + ModuleDeclarationExternNonansi(&'a ModuleDeclarationExternNonansi), + ModuleDeclarationExternAnsi(&'a ModuleDeclarationExternAnsi), + ModuleKeyword(&'a ModuleKeyword), + InterfaceDeclaration(&'a InterfaceDeclaration), + InterfaceDeclarationNonansi(&'a InterfaceDeclarationNonansi), + InterfaceDeclarationAnsi(&'a InterfaceDeclarationAnsi), + InterfaceDeclarationWildcard(&'a InterfaceDeclarationWildcard), + InterfaceDeclarationExternNonansi(&'a InterfaceDeclarationExternNonansi), + InterfaceDeclarationExternAnsi(&'a InterfaceDeclarationExternAnsi), + InterfaceNonansiHeader(&'a InterfaceNonansiHeader), + InterfaceAnsiHeader(&'a InterfaceAnsiHeader), + ProgramDeclaration(&'a ProgramDeclaration), + ProgramDeclarationNonansi(&'a ProgramDeclarationNonansi), + ProgramDeclarationAnsi(&'a ProgramDeclarationAnsi), + ProgramDeclarationWildcard(&'a ProgramDeclarationWildcard), + ProgramDeclarationExternNonansi(&'a ProgramDeclarationExternNonansi), + ProgramDeclarationExternAnsi(&'a ProgramDeclarationExternAnsi), + ProgramNonansiHeader(&'a ProgramNonansiHeader), + ProgramAnsiHeader(&'a ProgramAnsiHeader), + CheckerDeclaration(&'a CheckerDeclaration), + ClassDeclaration(&'a ClassDeclaration), + Virtual(&'a Virtual), + InterfaceClassType(&'a InterfaceClassType), + InterfaceClassDeclaration(&'a InterfaceClassDeclaration), + InterfaceClassItem(&'a InterfaceClassItem), + InterfaceClassItemMethod(&'a InterfaceClassItemMethod), + InterfaceClassMethod(&'a InterfaceClassMethod), + PackageDeclaration(&'a PackageDeclaration), + TimeunitsDeclaration(&'a TimeunitsDeclaration), + TimeunitsDeclarationTimeunit(&'a TimeunitsDeclarationTimeunit), + TimeunitsDeclarationTimeprecision(&'a TimeunitsDeclarationTimeprecision), + TimeunitsDeclarationTimeunitTimeprecision(&'a TimeunitsDeclarationTimeunitTimeprecision), + TimeunitsDeclarationTimeprecisionTimeunit(&'a TimeunitsDeclarationTimeprecisionTimeunit), + LibraryText(&'a LibraryText), + LibraryDescription(&'a LibraryDescription), + LibraryDeclaration(&'a LibraryDeclaration), + IncludeStatement(&'a IncludeStatement), + FilePathSpec(&'a FilePathSpec), + FilePathSpecNonLiteral(&'a FilePathSpecNonLiteral), + ParameterPortList(&'a ParameterPortList), + ParameterPortListAssignment(&'a ParameterPortListAssignment), + ParameterPortListDeclaration(&'a ParameterPortListDeclaration), + ParameterPortDeclaration(&'a ParameterPortDeclaration), + ParameterPortDeclarationParamList(&'a ParameterPortDeclarationParamList), + ParameterPortDeclarationTypeList(&'a ParameterPortDeclarationTypeList), + ListOfPorts(&'a ListOfPorts), + ListOfPortDeclarations(&'a ListOfPortDeclarations), + PortDeclaration(&'a PortDeclaration), + PortDeclarationInout(&'a PortDeclarationInout), + PortDeclarationInput(&'a PortDeclarationInput), + PortDeclarationOutput(&'a PortDeclarationOutput), + PortDeclarationRef(&'a PortDeclarationRef), + PortDeclarationInterface(&'a PortDeclarationInterface), + Port(&'a Port), + PortNonNamed(&'a PortNonNamed), + PortNamed(&'a PortNamed), + PortExpression(&'a PortExpression), + PortExpressionBrace(&'a PortExpressionBrace), + PortReference(&'a PortReference), + PortDirection(&'a PortDirection), + NetPortHeader(&'a NetPortHeader), + VariablePortHeader(&'a VariablePortHeader), + InterfacePortHeader(&'a InterfacePortHeader), + InterfacePortHeaderIdentifier(&'a InterfacePortHeaderIdentifier), + InterfacePortHeaderInterface(&'a InterfacePortHeaderInterface), + NetPortHeaderOrInterfacePortHeader(&'a NetPortHeaderOrInterfacePortHeader), + AnsiPortDeclaration(&'a AnsiPortDeclaration), + AnsiPortDeclarationNet(&'a AnsiPortDeclarationNet), + AnsiPortDeclarationVariable(&'a AnsiPortDeclarationVariable), + AnsiPortDeclarationParen(&'a AnsiPortDeclarationParen), + ProgramItem(&'a ProgramItem), + NonPortProgramItem(&'a NonPortProgramItem), + NonPortProgramItemAssign(&'a NonPortProgramItemAssign), + NonPortProgramItemModule(&'a NonPortProgramItemModule), + NonPortProgramItemInitial(&'a NonPortProgramItemInitial), + NonPortProgramItemFinal(&'a NonPortProgramItemFinal), + NonPortProgramItemAssertion(&'a NonPortProgramItemAssertion), + ProgramGenerateItem(&'a ProgramGenerateItem), + ElaborationSystemTask(&'a ElaborationSystemTask), + ElaborationSystemTaskFatal(&'a ElaborationSystemTaskFatal), + ElaborationSystemTaskError(&'a ElaborationSystemTaskError), + ElaborationSystemTaskWarning(&'a ElaborationSystemTaskWarning), + ElaborationSystemTaskInfo(&'a ElaborationSystemTaskInfo), + FinishNumber(&'a FinishNumber), + ModuleCommonItem(&'a ModuleCommonItem), + ModuleItem(&'a ModuleItem), + ModuleOrGenerateItem(&'a ModuleOrGenerateItem), + ModuleOrGenerateItemParameter(&'a ModuleOrGenerateItemParameter), + ModuleOrGenerateItemGate(&'a ModuleOrGenerateItemGate), + ModuleOrGenerateItemUdp(&'a ModuleOrGenerateItemUdp), + ModuleOrGenerateItemModule(&'a ModuleOrGenerateItemModule), + ModuleOrGenerateItemModuleItem(&'a ModuleOrGenerateItemModuleItem), + ModuleOrGenerateItemDeclaration(&'a ModuleOrGenerateItemDeclaration), + ModuleOrGenerateItemDeclarationClocking(&'a ModuleOrGenerateItemDeclarationClocking), + ModuleOrGenerateItemDeclarationDisable(&'a ModuleOrGenerateItemDeclarationDisable), + NonPortModuleItem(&'a NonPortModuleItem), + NonPortModuleItemSpecparam(&'a NonPortModuleItemSpecparam), + ParameterOverride(&'a ParameterOverride), + BindDirective(&'a BindDirective), + BindDirectiveScope(&'a BindDirectiveScope), + BindDirectiveInstance(&'a BindDirectiveInstance), + BindTargetScope(&'a BindTargetScope), + BindTargetInstance(&'a BindTargetInstance), + BindTargetInstanceList(&'a BindTargetInstanceList), + BindInstantiation(&'a BindInstantiation), + ConstraintDeclaration(&'a ConstraintDeclaration), + Static(&'a Static), + ConstraintBlock(&'a ConstraintBlock), + ConstraintBlockItem(&'a ConstraintBlockItem), + ConstraintBlockItemSolve(&'a ConstraintBlockItemSolve), + SolveBeforeList(&'a SolveBeforeList), + ConstraintPrimary(&'a ConstraintPrimary), + ConstraintExpression(&'a ConstraintExpression), + ConstraintExpressionExpression(&'a ConstraintExpressionExpression), + Soft(&'a Soft), + ConstraintExpressionArrow(&'a ConstraintExpressionArrow), + ConstraintExpressionIf(&'a ConstraintExpressionIf), + ConstraintExpressionForeach(&'a ConstraintExpressionForeach), + ConstraintExpressionDisable(&'a ConstraintExpressionDisable), + UniquenessConstraint(&'a UniquenessConstraint), + ConstraintSet(&'a ConstraintSet), + ConstraintSetBrace(&'a ConstraintSetBrace), + DistList(&'a DistList), + DistItem(&'a DistItem), + DistWeight(&'a DistWeight), + DistWeightEqual(&'a DistWeightEqual), + DistWeightDivide(&'a DistWeightDivide), + ConstraintPrototype(&'a ConstraintPrototype), + ConstraintPrototypeQualifier(&'a ConstraintPrototypeQualifier), + ExternConstraintDeclaration(&'a ExternConstraintDeclaration), + IdentifierList(&'a IdentifierList), + ConfigDeclaration(&'a ConfigDeclaration), + DesignStatement(&'a DesignStatement), + ConfigRuleStatement(&'a ConfigRuleStatement), + ConfigRuleStatementDefault(&'a ConfigRuleStatementDefault), + ConfigRuleStatementInstLib(&'a ConfigRuleStatementInstLib), + ConfigRuleStatementInstUse(&'a ConfigRuleStatementInstUse), + ConfigRuleStatementCellLib(&'a ConfigRuleStatementCellLib), + ConfigRuleStatementCellUse(&'a ConfigRuleStatementCellUse), + DefaultClause(&'a DefaultClause), + InstClause(&'a InstClause), + InstName(&'a InstName), + CellClause(&'a CellClause), + LiblistClause(&'a LiblistClause), + UseClause(&'a UseClause), + UseClauseCell(&'a UseClauseCell), + UseClauseNamed(&'a UseClauseNamed), + UseClauseCellNamed(&'a UseClauseCellNamed), + Config(&'a Config), + ClassItem(&'a ClassItem), + ClassItemProperty(&'a ClassItemProperty), + ClassItemMethod(&'a ClassItemMethod), + ClassItemConstraint(&'a ClassItemConstraint), + ClassItemDeclaration(&'a ClassItemDeclaration), + ClassItemCovergroup(&'a ClassItemCovergroup), + ClassProperty(&'a ClassProperty), + ClassPropertyNonConst(&'a ClassPropertyNonConst), + ClassPropertyConst(&'a ClassPropertyConst), + ClassPropertyConstExpression(&'a ClassPropertyConstExpression), + ClassMethod(&'a ClassMethod), + ClassMethodTask(&'a ClassMethodTask), + ClassMethodFunction(&'a ClassMethodFunction), + ClassMethodPureVirtual(&'a ClassMethodPureVirtual), + ClassMethodExternMethod(&'a ClassMethodExternMethod), + ClassMethodConstructor(&'a ClassMethodConstructor), + ClassMethodExternConstructor(&'a ClassMethodExternConstructor), + ClassConstructorPrototype(&'a ClassConstructorPrototype), + ClassConstraint(&'a ClassConstraint), + ClassItemQualifier(&'a ClassItemQualifier), + PropertyQualifier(&'a PropertyQualifier), + RandomQualifier(&'a RandomQualifier), + MethodQualifier(&'a MethodQualifier), + MethodPrototype(&'a MethodPrototype), + ClassConstructorDeclaration(&'a ClassConstructorDeclaration), + New(&'a New), + InterfaceOrGenerateItem(&'a InterfaceOrGenerateItem), + InterfaceOrGenerateItemModule(&'a InterfaceOrGenerateItemModule), + InterfaceOrGenerateItemExtern(&'a InterfaceOrGenerateItemExtern), + ExternTfDeclaration(&'a ExternTfDeclaration), + ExternTfDeclarationMethod(&'a ExternTfDeclarationMethod), + ExternTfDeclarationTask(&'a ExternTfDeclarationTask), + InterfaceItem(&'a InterfaceItem), + NonPortInterfaceItem(&'a NonPortInterfaceItem), + CheckerPortList(&'a CheckerPortList), + CheckerPortItem(&'a CheckerPortItem), + CheckerPortDirection(&'a CheckerPortDirection), + CheckerOrGenerateItem(&'a CheckerOrGenerateItem), + CheckerOrGenerateItemDeclaration(&'a CheckerOrGenerateItemDeclaration), + CheckerOrGenerateItemDeclarationData(&'a CheckerOrGenerateItemDeclarationData), + Rand(&'a Rand), + CheckerOrGenerateItemDeclarationClocking(&'a CheckerOrGenerateItemDeclarationClocking), + CheckerOrGenerateItemDeclarationDisable(&'a CheckerOrGenerateItemDeclarationDisable), + CheckerGenerateItem(&'a CheckerGenerateItem), + PackageItem(&'a PackageItem), + PackageOrGenerateItemDeclaration(&'a PackageOrGenerateItemDeclaration), + AnonymousProgram(&'a AnonymousProgram), + AnonymousProgramItem(&'a AnonymousProgramItem), + PreprocessorText(&'a PreprocessorText), + Symbol(&'a Symbol), + Keyword(&'a Keyword), + WhiteSpace(&'a WhiteSpace), + PulldownStrength(&'a PulldownStrength), + PulldownStrength01(&'a PulldownStrength01), + PulldownStrength10(&'a PulldownStrength10), + PulldownStrength0(&'a PulldownStrength0), + PullupStrength(&'a PullupStrength), + PullupStrength01(&'a PullupStrength01), + PullupStrength10(&'a PullupStrength10), + PullupStrength1(&'a PullupStrength1), + GateInstantiation(&'a GateInstantiation), + GateInstantiationCmos(&'a GateInstantiationCmos), + GateInstantiationEnable(&'a GateInstantiationEnable), + GateInstantiationMos(&'a GateInstantiationMos), + GateInstantiationNInput(&'a GateInstantiationNInput), + GateInstantiationNOutput(&'a GateInstantiationNOutput), + GateInstantiationPassEn(&'a GateInstantiationPassEn), + GateInstantiationPass(&'a GateInstantiationPass), + GateInstantiationPulldown(&'a GateInstantiationPulldown), + GateInstantiationPullup(&'a GateInstantiationPullup), + CmosSwitchInstance(&'a CmosSwitchInstance), + EnableGateInstance(&'a EnableGateInstance), + MosSwitchInstance(&'a MosSwitchInstance), + NInputGateInstance(&'a NInputGateInstance), + NOutputGateInstance(&'a NOutputGateInstance), + PassSwitchInstance(&'a PassSwitchInstance), + PassEnableSwitchInstance(&'a PassEnableSwitchInstance), + PullGateInstance(&'a PullGateInstance), + CmosSwitchtype(&'a CmosSwitchtype), + EnableGatetype(&'a EnableGatetype), + MosSwitchtype(&'a MosSwitchtype), + NInputGatetype(&'a NInputGatetype), + NOutputGatetype(&'a NOutputGatetype), + PassEnSwitchtype(&'a PassEnSwitchtype), + PassSwitchtype(&'a PassSwitchtype), + EnableTerminal(&'a EnableTerminal), + InoutTerminal(&'a InoutTerminal), + InputTerminal(&'a InputTerminal), + NcontrolTerminal(&'a NcontrolTerminal), + OutputTerminal(&'a OutputTerminal), + PcontrolTerminal(&'a PcontrolTerminal), + UdpPortList(&'a UdpPortList), + UdpDeclarationPortList(&'a UdpDeclarationPortList), + UdpPortDeclaration(&'a UdpPortDeclaration), + UdpOutputDeclaration(&'a UdpOutputDeclaration), + UdpOutputDeclarationNonreg(&'a UdpOutputDeclarationNonreg), + UdpOutputDeclarationReg(&'a UdpOutputDeclarationReg), + UdpInputDeclaration(&'a UdpInputDeclaration), + UdpRegDeclaration(&'a UdpRegDeclaration), + UdpInstantiation(&'a UdpInstantiation), + UdpInstance(&'a UdpInstance), + UdpNonansiDeclaration(&'a UdpNonansiDeclaration), + UdpAnsiDeclaration(&'a UdpAnsiDeclaration), + UdpDeclaration(&'a UdpDeclaration), + UdpDeclarationNonansi(&'a UdpDeclarationNonansi), + UdpDeclarationAnsi(&'a UdpDeclarationAnsi), + UdpDeclarationExternNonansi(&'a UdpDeclarationExternNonansi), + UdpDeclarationExternAnsi(&'a UdpDeclarationExternAnsi), + UdpDeclarationWildcard(&'a UdpDeclarationWildcard), + UdpBody(&'a UdpBody), + CombinationalBody(&'a CombinationalBody), + CombinationalEntry(&'a CombinationalEntry), + SequentialBody(&'a SequentialBody), + UdpInitialStatement(&'a UdpInitialStatement), + InitVal(&'a InitVal), + SequentialEntry(&'a SequentialEntry), + SeqInputList(&'a SeqInputList), + LevelInputList(&'a LevelInputList), + EdgeInputList(&'a EdgeInputList), + EdgeIndicator(&'a EdgeIndicator), + EdgeIndicatorParen(&'a EdgeIndicatorParen), + CurrentState(&'a CurrentState), + NextState(&'a NextState), + OutputSymbol(&'a OutputSymbol), + LevelSymbol(&'a LevelSymbol), + EdgeSymbol(&'a EdgeSymbol), + SpecifyInputTerminalDescriptor(&'a SpecifyInputTerminalDescriptor), + SpecifyOutputTerminalDescriptor(&'a SpecifyOutputTerminalDescriptor), + InputIdentifier(&'a InputIdentifier), + InputIdentifierInterface(&'a InputIdentifierInterface), + OutputIdentifier(&'a OutputIdentifier), + OutputIdentifierInterface(&'a OutputIdentifierInterface), + PathDeclaration(&'a PathDeclaration), + SimplePathDeclaration(&'a SimplePathDeclaration), + SimplePathDeclarationParallel(&'a SimplePathDeclarationParallel), + SimplePathDeclarationFull(&'a SimplePathDeclarationFull), + ParallelPathDescription(&'a ParallelPathDescription), + FullPathDescription(&'a FullPathDescription), + ListOfPathInputs(&'a ListOfPathInputs), + ListOfPathOutputs(&'a ListOfPathOutputs), + PathDelayValue(&'a PathDelayValue), + PathDelayValueParen(&'a PathDelayValueParen), + ListOfPathDelayExpressions(&'a ListOfPathDelayExpressions), + TPathDelayExpression(&'a TPathDelayExpression), + PathDelayExpression(&'a PathDelayExpression), + EdgeSensitivePathDeclaration(&'a EdgeSensitivePathDeclaration), + EdgeSensitivePathDeclarationParallel(&'a EdgeSensitivePathDeclarationParallel), + EdgeSensitivePathDeclarationFull(&'a EdgeSensitivePathDeclarationFull), + ParallelEdgeSensitivePathDescription(&'a ParallelEdgeSensitivePathDescription), + FullEdgeSensitivePathDescription(&'a FullEdgeSensitivePathDescription), + DataSourceExpression(&'a DataSourceExpression), + EdgeIdentifier(&'a EdgeIdentifier), + StateDependentPathDeclaration(&'a StateDependentPathDeclaration), + StateDependentPathDeclarationIfSimple(&'a StateDependentPathDeclarationIfSimple), + StateDependentPathDeclarationIfEdgeSensitive(&'a StateDependentPathDeclarationIfEdgeSensitive), + StateDependentPathDeclarationIfNone(&'a StateDependentPathDeclarationIfNone), + PolarityOperator(&'a PolarityOperator), + SpecifyBlock(&'a SpecifyBlock), + SpecifyItem(&'a SpecifyItem), + PulsestyleDeclaration(&'a PulsestyleDeclaration), + ShowcancelledDeclaration(&'a ShowcancelledDeclaration), + TimingCheckEvent(&'a TimingCheckEvent), + ControlledTimingCheckEvent(&'a ControlledTimingCheckEvent), + TimingCheckEventControl(&'a TimingCheckEventControl), + SpecifyTerminalDescriptor(&'a SpecifyTerminalDescriptor), + EdgeControlSpecifier(&'a EdgeControlSpecifier), + EdgeDescriptor(&'a EdgeDescriptor), + TimingCheckCondition(&'a TimingCheckCondition), + TimingCheckConditionParen(&'a TimingCheckConditionParen), + ScalarTimingCheckCondition(&'a ScalarTimingCheckCondition), + ScalarTimingCheckConditionUnary(&'a ScalarTimingCheckConditionUnary), + ScalarTimingCheckConditionBinary(&'a ScalarTimingCheckConditionBinary), + ScalarConstant(&'a ScalarConstant), + SystemTimingCheck(&'a SystemTimingCheck), + SetupTimingCheck(&'a SetupTimingCheck), + HoldTimingCheck(&'a HoldTimingCheck), + SetupholdTimingCheck(&'a SetupholdTimingCheck), + RecoveryTimingCheck(&'a RecoveryTimingCheck), + RemovalTimingCheck(&'a RemovalTimingCheck), + RecremTimingCheck(&'a RecremTimingCheck), + SkewTimingCheck(&'a SkewTimingCheck), + TimeskewTimingCheck(&'a TimeskewTimingCheck), + FullskewTimingCheck(&'a FullskewTimingCheck), + PeriodTimingCheck(&'a PeriodTimingCheck), + WidthTimingCheck(&'a WidthTimingCheck), + NochangeTimingCheck(&'a NochangeTimingCheck), + TimecheckCondition(&'a TimecheckCondition), + ControlledReferenceEvent(&'a ControlledReferenceEvent), + DataEvent(&'a DataEvent), + DelayedData(&'a DelayedData), + DelayedDataWithMintypmax(&'a DelayedDataWithMintypmax), + DelayedReference(&'a DelayedReference), + DelayedReferenceWithMintypmax(&'a DelayedReferenceWithMintypmax), + EndEdgeOffset(&'a EndEdgeOffset), + EventBasedFlag(&'a EventBasedFlag), + Notifier(&'a Notifier), + ReferenceEvent(&'a ReferenceEvent), + RemainActiveFlag(&'a RemainActiveFlag), + TimestampCondition(&'a TimestampCondition), + StartEdgeOffset(&'a StartEdgeOffset), + Threshold(&'a Threshold), + TimingCheckLimit(&'a TimingCheckLimit), + ProceduralTimingControlStatement(&'a ProceduralTimingControlStatement), + DelayOrEventControl(&'a DelayOrEventControl), + DelayOrEventControlRepeat(&'a DelayOrEventControlRepeat), + DelayControl(&'a DelayControl), + DelayControlDelay(&'a DelayControlDelay), + DelayControlMintypmax(&'a DelayControlMintypmax), + EventControl(&'a EventControl), + EventControlEventIdentifier(&'a EventControlEventIdentifier), + EventControlEventExpression(&'a EventControlEventExpression), + EventControlAsterisk(&'a EventControlAsterisk), + EventControlParenAsterisk(&'a EventControlParenAsterisk), + EventControlSequenceIdentifier(&'a EventControlSequenceIdentifier), + EventExpression(&'a EventExpression), + EventExpressionExpression(&'a EventExpressionExpression), + EventExpressionSequence(&'a EventExpressionSequence), + EventExpressionOr(&'a EventExpressionOr), + EventExpressionComma(&'a EventExpressionComma), + EventExpressionParen(&'a EventExpressionParen), + ProceduralTimingControl(&'a ProceduralTimingControl), + JumpStatement(&'a JumpStatement), + JumpStatementReturn(&'a JumpStatementReturn), + JumpStatementBreak(&'a JumpStatementBreak), + JumpStatementContinue(&'a JumpStatementContinue), + WaitStatement(&'a WaitStatement), + WaitStatementWait(&'a WaitStatementWait), + WaitStatementFork(&'a WaitStatementFork), + WaitStatementOrder(&'a WaitStatementOrder), + EventTrigger(&'a EventTrigger), + EventTriggerNamed(&'a EventTriggerNamed), + EventTriggerNonblocking(&'a EventTriggerNonblocking), + DisableStatement(&'a DisableStatement), + DisableStatementTask(&'a DisableStatementTask), + DisableStatementBlock(&'a DisableStatementBlock), + DisableStatementFork(&'a DisableStatementFork), + ConditionalStatement(&'a ConditionalStatement), + UniquePriority(&'a UniquePriority), + CondPredicate(&'a CondPredicate), + ExpressionOrCondPattern(&'a ExpressionOrCondPattern), + CondPattern(&'a CondPattern), + AssertionItem(&'a AssertionItem), + DeferredImmediateAssertionItem(&'a DeferredImmediateAssertionItem), + ProceduralAssertionStatement(&'a ProceduralAssertionStatement), + ImmediateAssertionStatement(&'a ImmediateAssertionStatement), + SimpleImmediateAssertionStatement(&'a SimpleImmediateAssertionStatement), + SimpleImmediateAssertStatement(&'a SimpleImmediateAssertStatement), + SimpleImmediateAssumeStatement(&'a SimpleImmediateAssumeStatement), + SimpleImmediateCoverStatement(&'a SimpleImmediateCoverStatement), + DeferredImmediateAssertionStatement(&'a DeferredImmediateAssertionStatement), + DeferredImmediateAssertStatement(&'a DeferredImmediateAssertStatement), + DeferredImmediateAssumeStatement(&'a DeferredImmediateAssumeStatement), + DeferredImmediateCoverStatement(&'a DeferredImmediateCoverStatement), + AssertTiming(&'a AssertTiming), + Pattern(&'a Pattern), + PatternVariable(&'a PatternVariable), + PatternTagged(&'a PatternTagged), + PatternList(&'a PatternList), + PatternIdentifierList(&'a PatternIdentifierList), + AssignmentPattern(&'a AssignmentPattern), + AssignmentPatternList(&'a AssignmentPatternList), + AssignmentPatternStructure(&'a AssignmentPatternStructure), + AssignmentPatternArray(&'a AssignmentPatternArray), + AssignmentPatternRepeat(&'a AssignmentPatternRepeat), + StructurePatternKey(&'a StructurePatternKey), + ArrayPatternKey(&'a ArrayPatternKey), + AssignmentPatternKey(&'a AssignmentPatternKey), + AssignmentPatternExpression(&'a AssignmentPatternExpression), + AssignmentPatternExpressionType(&'a AssignmentPatternExpressionType), + ConstantAssignmentPatternExpression(&'a ConstantAssignmentPatternExpression), + AssignmentPatternNetLvalue(&'a AssignmentPatternNetLvalue), + AssignmentPatternVariableLvalue(&'a AssignmentPatternVariableLvalue), + ContinuousAssign(&'a ContinuousAssign), + ContinuousAssignNet(&'a ContinuousAssignNet), + ContinuousAssignVariable(&'a ContinuousAssignVariable), + ListOfNetAssignments(&'a ListOfNetAssignments), + ListOfVariableAssignments(&'a ListOfVariableAssignments), + NetAlias(&'a NetAlias), + NetAssignment(&'a NetAssignment), + SubroutineCallStatement(&'a SubroutineCallStatement), + SubroutineCallStatementFunction(&'a SubroutineCallStatementFunction), + StatementOrNull(&'a StatementOrNull), + StatementOrNullAttribute(&'a StatementOrNullAttribute), + Statement(&'a Statement), + StatementItem(&'a StatementItem), + FunctionStatement(&'a FunctionStatement), + FunctionStatementOrNull(&'a FunctionStatementOrNull), + FunctionStatementOrNullAttribute(&'a FunctionStatementOrNullAttribute), + VariableIdentifierList(&'a VariableIdentifierList), + RandsequenceStatement(&'a RandsequenceStatement), + Production(&'a Production), + RsRule(&'a RsRule), + RsProductionList(&'a RsProductionList), + RsProductionListProd(&'a RsProductionListProd), + RsProductionListJoin(&'a RsProductionListJoin), + WeightSpecification(&'a WeightSpecification), + WeightSpecificationExpression(&'a WeightSpecificationExpression), + RsCodeBlock(&'a RsCodeBlock), + RsProd(&'a RsProd), + ProductionItem(&'a ProductionItem), + RsIfElse(&'a RsIfElse), + RsRepeat(&'a RsRepeat), + RsCase(&'a RsCase), + RsCaseItem(&'a RsCaseItem), + RsCaseItemNondefault(&'a RsCaseItemNondefault), + RsCaseItemDefault(&'a RsCaseItemDefault), + LoopStatement(&'a LoopStatement), + LoopStatementForever(&'a LoopStatementForever), + LoopStatementRepeat(&'a LoopStatementRepeat), + LoopStatementWhile(&'a LoopStatementWhile), + LoopStatementFor(&'a LoopStatementFor), + LoopStatementDoWhile(&'a LoopStatementDoWhile), + LoopStatementForeach(&'a LoopStatementForeach), + ForInitialization(&'a ForInitialization), + ForInitializationDeclaration(&'a ForInitializationDeclaration), + ForVariableDeclaration(&'a ForVariableDeclaration), + Var(&'a Var), + ForStep(&'a ForStep), + ForStepAssignment(&'a ForStepAssignment), + LoopVariables(&'a LoopVariables), + ActionBlock(&'a ActionBlock), + ActionBlockElse(&'a ActionBlockElse), + SeqBlock(&'a SeqBlock), + ParBlock(&'a ParBlock), + JoinKeyword(&'a JoinKeyword), + ClockingDeclaration(&'a ClockingDeclaration), + ClockingDeclarationLocal(&'a ClockingDeclarationLocal), + Default(&'a Default), + ClockingDeclarationGlobal(&'a ClockingDeclarationGlobal), + ClockingEvent(&'a ClockingEvent), + ClockingEventIdentifier(&'a ClockingEventIdentifier), + ClockingEventExpression(&'a ClockingEventExpression), + ClockingItem(&'a ClockingItem), + ClockingItemDefault(&'a ClockingItemDefault), + ClockingItemDirection(&'a ClockingItemDirection), + ClockingItemAssertion(&'a ClockingItemAssertion), + DefaultSkew(&'a DefaultSkew), + DefaultSkewInput(&'a DefaultSkewInput), + DefaultSkewOutput(&'a DefaultSkewOutput), + DefaultSkewInputOutput(&'a DefaultSkewInputOutput), + ClockingDirection(&'a ClockingDirection), + ClockingDirectionInput(&'a ClockingDirectionInput), + ClockingDirectionOutput(&'a ClockingDirectionOutput), + ClockingDirectionInputOutput(&'a ClockingDirectionInputOutput), + ListOfClockingDeclAssign(&'a ListOfClockingDeclAssign), + ClockingDeclAssign(&'a ClockingDeclAssign), + ClockingSkew(&'a ClockingSkew), + ClockingSkewEdge(&'a ClockingSkewEdge), + ClockingDrive(&'a ClockingDrive), + CycleDelay(&'a CycleDelay), + CycleDelayIntegral(&'a CycleDelayIntegral), + CycleDelayIdentifier(&'a CycleDelayIdentifier), + CycleDelayExpression(&'a CycleDelayExpression), + Clockvar(&'a Clockvar), + ClockvarExpression(&'a ClockvarExpression), + CaseStatement(&'a CaseStatement), + CaseStatementNormal(&'a CaseStatementNormal), + CaseStatementMatches(&'a CaseStatementMatches), + CaseStatementInside(&'a CaseStatementInside), + CaseKeyword(&'a CaseKeyword), + CaseExpression(&'a CaseExpression), + CaseExpressionExpression(&'a CaseExpressionExpression), + CaseItem(&'a CaseItem), + CaseItemNondefault(&'a CaseItemNondefault), + CaseItemDefault(&'a CaseItemDefault), + CasePatternItem(&'a CasePatternItem), + CasePatternItemNondefault(&'a CasePatternItemNondefault), + CaseInsideItem(&'a CaseInsideItem), + CaseInsideItemNondefault(&'a CaseInsideItemNondefault), + CaseItemExpression(&'a CaseItemExpression), + RandcaseStatement(&'a RandcaseStatement), + RandcaseItem(&'a RandcaseItem), + OpenRangeList(&'a OpenRangeList), + OpenValueRange(&'a OpenValueRange), + InitialConstruct(&'a InitialConstruct), + AlwaysConstruct(&'a AlwaysConstruct), + AlwaysKeyword(&'a AlwaysKeyword), + FinalConstruct(&'a FinalConstruct), + BlockingAssignment(&'a BlockingAssignment), + BlockingAssignmentVariable(&'a BlockingAssignmentVariable), + BlockingAssignmentNonrangeVariable(&'a BlockingAssignmentNonrangeVariable), + BlockingAssignmentHierarchicalVariable(&'a BlockingAssignmentHierarchicalVariable), + OperatorAssignment(&'a OperatorAssignment), + AssignmentOperator(&'a AssignmentOperator), + NonblockingAssignment(&'a NonblockingAssignment), + ProceduralContinuousAssignment(&'a ProceduralContinuousAssignment), + ProceduralContinuousAssignmentAssign(&'a ProceduralContinuousAssignmentAssign), + ProceduralContinuousAssignmentDeassign(&'a ProceduralContinuousAssignmentDeassign), + ProceduralContinuousAssignmentForceVariable(&'a ProceduralContinuousAssignmentForceVariable), + ProceduralContinuousAssignmentForceNet(&'a ProceduralContinuousAssignmentForceNet), + ProceduralContinuousAssignmentReleaseVariable( + &'a ProceduralContinuousAssignmentReleaseVariable, + ), + ProceduralContinuousAssignmentReleaseNet(&'a ProceduralContinuousAssignmentReleaseNet), + VariableAssignment(&'a VariableAssignment), +} + +#[derive(Clone, Debug, PartialEq, AnyNode)] +pub enum AnyNode { + Locate(Locate), + Comment(Comment), + AttributeInstance(AttributeInstance), + AttrSpec(AttrSpec), + ArrayIdentifier(ArrayIdentifier), + BlockIdentifier(BlockIdentifier), + BinIdentifier(BinIdentifier), + CIdentifier(CIdentifier), + CellIdentifier(CellIdentifier), + CheckerIdentifier(CheckerIdentifier), + ClassIdentifier(ClassIdentifier), + ClassVariableIdentifier(ClassVariableIdentifier), + ClockingIdentifier(ClockingIdentifier), + ConfigIdentifier(ConfigIdentifier), + ConstIdentifier(ConstIdentifier), + ConstraintIdentifier(ConstraintIdentifier), + CovergroupIdentifier(CovergroupIdentifier), + CovergroupVariableIdentifier(CovergroupVariableIdentifier), + CoverPointIdentifier(CoverPointIdentifier), + CrossIdentifier(CrossIdentifier), + DynamicArrayVariableIdentifier(DynamicArrayVariableIdentifier), + EnumIdentifier(EnumIdentifier), + EscapedIdentifier(EscapedIdentifier), + FormalIdentifier(FormalIdentifier), + FormalPortIdentifier(FormalPortIdentifier), + FunctionIdentifier(FunctionIdentifier), + GenerateBlockIdentifier(GenerateBlockIdentifier), + GenvarIdentifier(GenvarIdentifier), + HierarchicalArrayIdentifier(HierarchicalArrayIdentifier), + HierarchicalBlockIdentifier(HierarchicalBlockIdentifier), + HierarchicalEventIdentifier(HierarchicalEventIdentifier), + HierarchicalIdentifier(HierarchicalIdentifier), + Root(Root), + HierarchicalNetIdentifier(HierarchicalNetIdentifier), + HierarchicalParameterIdentifier(HierarchicalParameterIdentifier), + HierarchicalPropertyIdentifier(HierarchicalPropertyIdentifier), + HierarchicalSequenceIdentifier(HierarchicalSequenceIdentifier), + HierarchicalTaskIdentifier(HierarchicalTaskIdentifier), + HierarchicalTfIdentifier(HierarchicalTfIdentifier), + HierarchicalVariableIdentifier(HierarchicalVariableIdentifier), + Identifier(Identifier), + IndexVariableIdentifier(IndexVariableIdentifier), + InterfaceIdentifier(InterfaceIdentifier), + InterfaceInstanceIdentifier(InterfaceInstanceIdentifier), + InoutPortIdentifier(InoutPortIdentifier), + InputPortIdentifier(InputPortIdentifier), + InstanceIdentifier(InstanceIdentifier), + LibraryIdentifier(LibraryIdentifier), + MemberIdentifier(MemberIdentifier), + MethodIdentifier(MethodIdentifier), + ModportIdentifier(ModportIdentifier), + ModuleIdentifier(ModuleIdentifier), + NetIdentifier(NetIdentifier), + NetTypeIdentifier(NetTypeIdentifier), + OutputPortIdentifier(OutputPortIdentifier), + PackageIdentifier(PackageIdentifier), + PackageScope(PackageScope), + PackageScopePackage(PackageScopePackage), + Unit(Unit), + ParameterIdentifier(ParameterIdentifier), + PortIdentifier(PortIdentifier), + ProductionIdentifier(ProductionIdentifier), + ProgramIdentifier(ProgramIdentifier), + PropertyIdentifier(PropertyIdentifier), + PsClassIdentifier(PsClassIdentifier), + PsCovergroupIdentifier(PsCovergroupIdentifier), + PsCheckerIdentifier(PsCheckerIdentifier), + PsIdentifier(PsIdentifier), + PsOrHierarchicalArrayIdentifier(PsOrHierarchicalArrayIdentifier), + PsOrHierarchicalNetIdentifier(PsOrHierarchicalNetIdentifier), + PsOrHierarchicalNetIdentifierPackageScope(PsOrHierarchicalNetIdentifierPackageScope), + PsOrHierarchicalNetIdentifierHierarchical(PsOrHierarchicalNetIdentifierHierarchical), + PsOrHierarchicalPropertyIdentifier(PsOrHierarchicalPropertyIdentifier), + PsOrHierarchicalPropertyIdentifierPackageScope(PsOrHierarchicalPropertyIdentifierPackageScope), + PsOrHierarchicalPropertyIdentifierHierarchical(PsOrHierarchicalPropertyIdentifierHierarchical), + PsOrHierarchicalSequenceIdentifier(PsOrHierarchicalSequenceIdentifier), + PsOrHierarchicalSequenceIdentifierPackageScope(PsOrHierarchicalSequenceIdentifierPackageScope), + PsOrHierarchicalSequenceIdentifierHierarchical(PsOrHierarchicalSequenceIdentifierHierarchical), + PsOrHierarchicalTfIdentifier(PsOrHierarchicalTfIdentifier), + PsOrHierarchicalTfIdentifierPackageScope(PsOrHierarchicalTfIdentifierPackageScope), + PsOrHierarchicalTfIdentifierHierarchical(PsOrHierarchicalTfIdentifierHierarchical), + PsParameterIdentifier(PsParameterIdentifier), + PsParameterIdentifierScope(PsParameterIdentifierScope), + PsParameterIdentifierGenerate(PsParameterIdentifierGenerate), + PsTypeIdentifier(PsTypeIdentifier), + LocalOrPackageScopeOrClassScope(LocalOrPackageScopeOrClassScope), + Local(Local), + SequenceIdentifier(SequenceIdentifier), + SignalIdentifier(SignalIdentifier), + SimpleIdentifier(SimpleIdentifier), + SpecparamIdentifier(SpecparamIdentifier), + SystemTfIdentifier(SystemTfIdentifier), + TaskIdentifier(TaskIdentifier), + TfIdentifier(TfIdentifier), + TerminalIdentifier(TerminalIdentifier), + TopmoduleIdentifier(TopmoduleIdentifier), + TypeIdentifier(TypeIdentifier), + UdpIdentifier(UdpIdentifier), + VariableIdentifier(VariableIdentifier), + ImplicitClassHandleOrClassScopeOrPackageScope(ImplicitClassHandleOrClassScopeOrPackageScope), + ImplicitClassHandleOrPackageScope(ImplicitClassHandleOrPackageScope), + ImplicitClassHandleOrClassScope(ImplicitClassHandleOrClassScope), + PackageScopeOrClassScope(PackageScopeOrClassScope), + CompilerDirective(CompilerDirective), + ResetallCompilerDirective(ResetallCompilerDirective), + IncludeCompilerDirective(IncludeCompilerDirective), + IncludeCompilerDirectiveDoubleQuote(IncludeCompilerDirectiveDoubleQuote), + IncludeCompilerDirectiveAngleBracket(IncludeCompilerDirectiveAngleBracket), + IncludeCompilerDirectiveTextMacroUsage(IncludeCompilerDirectiveTextMacroUsage), + AngleBracketLiteral(AngleBracketLiteral), + TextMacroDefinition(TextMacroDefinition), + TextMacroName(TextMacroName), + ListOfFormalArguments(ListOfFormalArguments), + FormalArgument(FormalArgument), + TextMacroIdentifier(TextMacroIdentifier), + MacroText(MacroText), + DefaultText(DefaultText), + TextMacroUsage(TextMacroUsage), + ListOfActualArguments(ListOfActualArguments), + ActualArgument(ActualArgument), + UndefineCompilerDirective(UndefineCompilerDirective), + UndefineallCompilerDirective(UndefineallCompilerDirective), + ConditionalCompilerDirective(ConditionalCompilerDirective), + IfdefDirective(IfdefDirective), + IfndefDirective(IfndefDirective), + IfdefGroupOfLines(IfdefGroupOfLines), + IfndefGroupOfLines(IfndefGroupOfLines), + ElsifGroupOfLines(ElsifGroupOfLines), + ElseGroupOfLines(ElseGroupOfLines), + SourceDescription(SourceDescription), + SourceDescriptionNotDirective(SourceDescriptionNotDirective), + TimescaleCompilerDirective(TimescaleCompilerDirective), + DefaultNettypeCompilerDirective(DefaultNettypeCompilerDirective), + DefaultNettypeValue(DefaultNettypeValue), + UnconnectedDriveCompilerDirective(UnconnectedDriveCompilerDirective), + NounconnectedDriveCompilerDirective(NounconnectedDriveCompilerDirective), + CelldefineDriveCompilerDirective(CelldefineDriveCompilerDirective), + EndcelldefineDriveCompilerDirective(EndcelldefineDriveCompilerDirective), + Pragma(Pragma), + PragmaName(PragmaName), + PragmaExpression(PragmaExpression), + PragmaExpressionAssignment(PragmaExpressionAssignment), + PragmaValue(PragmaValue), + PragmaValueParen(PragmaValueParen), + PragmaKeyword(PragmaKeyword), + LineCompilerDirective(LineCompilerDirective), + PositionCompilerDirective(PositionCompilerDirective), + Level(Level), + KeywordsDirective(KeywordsDirective), + VersionSpecifier(VersionSpecifier), + EndkeywordsDirective(EndkeywordsDirective), + DriveStrength(DriveStrength), + DriveStrength01(DriveStrength01), + DriveStrength10(DriveStrength10), + DriveStrength0z(DriveStrength0z), + DriveStrength1z(DriveStrength1z), + DriveStrengthz1(DriveStrengthz1), + DriveStrengthz0(DriveStrengthz0), + Strength0(Strength0), + Strength1(Strength1), + ChargeStrength(ChargeStrength), + ChargeStrengthSmall(ChargeStrengthSmall), + ChargeStrengthMedium(ChargeStrengthMedium), + ChargeStrengthLarge(ChargeStrengthLarge), + ModportDeclaration(ModportDeclaration), + ModportItem(ModportItem), + ModportPortsDeclaration(ModportPortsDeclaration), + ModportPortsDeclarationSimple(ModportPortsDeclarationSimple), + ModportPortsDeclarationTf(ModportPortsDeclarationTf), + ModportPortsDeclarationClocking(ModportPortsDeclarationClocking), + ModportClockingDeclaration(ModportClockingDeclaration), + ModportSimplePortsDeclaration(ModportSimplePortsDeclaration), + ModportSimplePort(ModportSimplePort), + ModportSimplePortOrdered(ModportSimplePortOrdered), + ModportSimplePortNamed(ModportSimplePortNamed), + ModportTfPortsDeclaration(ModportTfPortsDeclaration), + ModportTfPort(ModportTfPort), + ImportExport(ImportExport), + FunctionDataTypeOrImplicit(FunctionDataTypeOrImplicit), + FunctionDeclaration(FunctionDeclaration), + FunctionBodyDeclaration(FunctionBodyDeclaration), + FunctionBodyDeclarationWithoutPort(FunctionBodyDeclarationWithoutPort), + FunctionBodyDeclarationWithPort(FunctionBodyDeclarationWithPort), + InterfaceIdentifierOrClassScope(InterfaceIdentifierOrClassScope), + FunctionPrototype(FunctionPrototype), + DpiImportExport(DpiImportExport), + DpiImportExportImportFunction(DpiImportExportImportFunction), + DpiImportExportImportTask(DpiImportExportImportTask), + DpiImportExportExportFunction(DpiImportExportExportFunction), + DpiImportExportExportTask(DpiImportExportExportTask), + DpiSpecString(DpiSpecString), + DpiFunctionImportProperty(DpiFunctionImportProperty), + DpiTaskImportProperty(DpiTaskImportProperty), + DpiFunctionProto(DpiFunctionProto), + DpiTaskProto(DpiTaskProto), + CovergroupDeclaration(CovergroupDeclaration), + CoverageSpecOrOption(CoverageSpecOrOption), + CoverageSpecOrOptionSpec(CoverageSpecOrOptionSpec), + CoverageSpecOrOptionOption(CoverageSpecOrOptionOption), + CoverageOption(CoverageOption), + CoverageOptionOption(CoverageOptionOption), + CoverageOptionTypeOption(CoverageOptionTypeOption), + CoverageSpec(CoverageSpec), + CoverageEvent(CoverageEvent), + CoverageEventSample(CoverageEventSample), + CoverageEventAt(CoverageEventAt), + BlockEventExpression(BlockEventExpression), + BlockEventExpressionOr(BlockEventExpressionOr), + BlockEventExpressionBegin(BlockEventExpressionBegin), + BlockEventExpressionEnd(BlockEventExpressionEnd), + HierarchicalBtfIdentifier(HierarchicalBtfIdentifier), + HierarchicalBtfIdentifierMethod(HierarchicalBtfIdentifierMethod), + HierarchicalIdentifierOrClassScope(HierarchicalIdentifierOrClassScope), + CoverPoint(CoverPoint), + BinsOrEmpty(BinsOrEmpty), + BinsOrEmptyNonEmpty(BinsOrEmptyNonEmpty), + BinsOrOptions(BinsOrOptions), + BinsOrOptionsCovergroup(BinsOrOptionsCovergroup), + Wildcard(Wildcard), + BinsOrOptionsCoverPoint(BinsOrOptionsCoverPoint), + BinsOrOptionsSetCovergroup(BinsOrOptionsSetCovergroup), + BinsOrOptionsTransList(BinsOrOptionsTransList), + BinsOrOptionsDefault(BinsOrOptionsDefault), + BinsOrOptionsDefaultSequence(BinsOrOptionsDefaultSequence), + BinsKeyword(BinsKeyword), + TransList(TransList), + TransSet(TransSet), + TransRangeList(TransRangeList), + TransRangeListAsterisk(TransRangeListAsterisk), + TransRangeListArrow(TransRangeListArrow), + TransRangeListEqual(TransRangeListEqual), + TransItem(TransItem), + RepeatRange(RepeatRange), + RepeatRangeBinary(RepeatRangeBinary), + CoverCross(CoverCross), + ListOfCrossItems(ListOfCrossItems), + CrossItem(CrossItem), + CrossBody(CrossBody), + CrossBodyNonEmpty(CrossBodyNonEmpty), + CrossBodyItem(CrossBodyItem), + BinsSelectionOrOption(BinsSelectionOrOption), + BinsSelectionOrOptionCoverage(BinsSelectionOrOptionCoverage), + BinsSelectionOrOptionBins(BinsSelectionOrOptionBins), + BinsSelection(BinsSelection), + SelectExpression(SelectExpression), + SelectExpressionNot(SelectExpressionNot), + SelectExpressionAnd(SelectExpressionAnd), + SelectExpressionOr(SelectExpressionOr), + SelectExpressionParen(SelectExpressionParen), + SelectExpressionWith(SelectExpressionWith), + SelectExpressionCrossSet(SelectExpressionCrossSet), + SelectCondition(SelectCondition), + BinsExpression(BinsExpression), + BinsExpressionCoverPoint(BinsExpressionCoverPoint), + CovergroupRangeList(CovergroupRangeList), + CovergroupValueRange(CovergroupValueRange), + CovergroupValueRangeBinary(CovergroupValueRangeBinary), + WithCovergroupExpression(WithCovergroupExpression), + SetCovergroupExpression(SetCovergroupExpression), + IntegerCovergroupExpression(IntegerCovergroupExpression), + CrossSetExpression(CrossSetExpression), + CovergroupExpression(CovergroupExpression), + DataDeclaration(DataDeclaration), + DataDeclarationVariable(DataDeclarationVariable), + Const(Const), + PackageImportDeclaration(PackageImportDeclaration), + PackageImportItem(PackageImportItem), + PackageImportItemIdentifier(PackageImportItemIdentifier), + PackageImportItemAsterisk(PackageImportItemAsterisk), + PackageExportDeclaration(PackageExportDeclaration), + PackageExportDeclarationAsterisk(PackageExportDeclarationAsterisk), + PackageExportDeclarationItem(PackageExportDeclarationItem), + GenvarDeclaration(GenvarDeclaration), + NetDeclaration(NetDeclaration), + NetDeclarationNetType(NetDeclarationNetType), + Strength(Strength), + VectorScalar(VectorScalar), + NetDeclarationNetTypeIdentifier(NetDeclarationNetTypeIdentifier), + NetDeclarationInterconnect(NetDeclarationInterconnect), + TypeDeclaration(TypeDeclaration), + TypeDeclarationDataType(TypeDeclarationDataType), + TypeDeclarationInterface(TypeDeclarationInterface), + TypeDeclarationReserved(TypeDeclarationReserved), + TypeDeclarationKeyword(TypeDeclarationKeyword), + NetTypeDeclaration(NetTypeDeclaration), + NetTypeDeclarationDataType(NetTypeDeclarationDataType), + NetTypeDeclarationNetType(NetTypeDeclarationNetType), + Lifetime(Lifetime), + ConcurrentAssertionItem(ConcurrentAssertionItem), + ConcurrentAssertionItemStatement(ConcurrentAssertionItemStatement), + ConcurrentAssertionStatement(ConcurrentAssertionStatement), + AssertPropertyStatement(AssertPropertyStatement), + AssumePropertyStatement(AssumePropertyStatement), + CoverPropertyStatement(CoverPropertyStatement), + ExpectPropertyStatement(ExpectPropertyStatement), + CoverSequenceStatement(CoverSequenceStatement), + RestrictPropertyStatement(RestrictPropertyStatement), + PropertyInstance(PropertyInstance), + PropertyListOfArguments(PropertyListOfArguments), + PropertyListOfArgumentsOrdered(PropertyListOfArgumentsOrdered), + PropertyListOfArgumentsNamed(PropertyListOfArgumentsNamed), + PropertyActualArg(PropertyActualArg), + AssertionItemDeclaration(AssertionItemDeclaration), + PropertyDeclaration(PropertyDeclaration), + PropertyPortList(PropertyPortList), + PropertyPortItem(PropertyPortItem), + PropertyLvarPortDirection(PropertyLvarPortDirection), + PropertyFormalType(PropertyFormalType), + PropertySpec(PropertySpec), + PropertyExpr(PropertyExpr), + PropertyExprStrong(PropertyExprStrong), + PropertyExprWeak(PropertyExprWeak), + PropertyExprParen(PropertyExprParen), + PropertyExprNot(PropertyExprNot), + PropertyExprBinaryProperty(PropertyExprBinaryProperty), + PropertyExprBinarySequence(PropertyExprBinarySequence), + PropertyExprIf(PropertyExprIf), + PropertyExprCase(PropertyExprCase), + PropertyExprNexttime(PropertyExprNexttime), + PropertyExprSNexttime(PropertyExprSNexttime), + PropertyExprAlways(PropertyExprAlways), + PropertyExprSAlways(PropertyExprSAlways), + PropertyExprEventually(PropertyExprEventually), + PropertyExprSEventually(PropertyExprSEventually), + PropertyExprAcceptOn(PropertyExprAcceptOn), + PropertyExprRejectOn(PropertyExprRejectOn), + PropertyExprSyncAcceptOn(PropertyExprSyncAcceptOn), + PropertyExprSyncRejectOn(PropertyExprSyncRejectOn), + PropertyExprClockingEvent(PropertyExprClockingEvent), + PropertyCaseItem(PropertyCaseItem), + PropertyCaseItemNondefault(PropertyCaseItemNondefault), + PropertyCaseItemDefault(PropertyCaseItemDefault), + SequenceDeclaration(SequenceDeclaration), + SequencePortList(SequencePortList), + SequencePortItem(SequencePortItem), + SequenceLvarPortDirection(SequenceLvarPortDirection), + SequenceFormalType(SequenceFormalType), + SequenceExpr(SequenceExpr), + SequenceExprCycleDelayExpr(SequenceExprCycleDelayExpr), + SequenceExprExprCycleDelayExpr(SequenceExprExprCycleDelayExpr), + SequenceExprExpression(SequenceExprExpression), + SequenceExprInstance(SequenceExprInstance), + SequenceExprParen(SequenceExprParen), + SequenceExprBinary(SequenceExprBinary), + SequenceExprFirstMatch(SequenceExprFirstMatch), + SequenceExprThroughout(SequenceExprThroughout), + SequenceExprClockingEvent(SequenceExprClockingEvent), + CycleDelayRange(CycleDelayRange), + CycleDelayRangePrimary(CycleDelayRangePrimary), + CycleDelayRangeExpression(CycleDelayRangeExpression), + CycleDelayRangeAsterisk(CycleDelayRangeAsterisk), + CycleDelayRangePlus(CycleDelayRangePlus), + SequenceMethodCall(SequenceMethodCall), + SequenceMatchItem(SequenceMatchItem), + SequenceInstance(SequenceInstance), + SequenceListOfArguments(SequenceListOfArguments), + SequenceListOfArgumentsOrdered(SequenceListOfArgumentsOrdered), + SequenceListOfArgumentsNamed(SequenceListOfArgumentsNamed), + SequenceActualArg(SequenceActualArg), + BooleanAbbrev(BooleanAbbrev), + SequenceAbbrev(SequenceAbbrev), + ConsecutiveRepetition(ConsecutiveRepetition), + ConsecutiveRepetitionExpression(ConsecutiveRepetitionExpression), + ConsecutiveRepetitionAsterisk(ConsecutiveRepetitionAsterisk), + ConsecutiveRepetitionPlus(ConsecutiveRepetitionPlus), + NonConsecutiveRepetition(NonConsecutiveRepetition), + GotoRepetition(GotoRepetition), + ConstOrRangeExpression(ConstOrRangeExpression), + CycleDelayConstRangeExpression(CycleDelayConstRangeExpression), + CycleDelayConstRangeExpressionBinary(CycleDelayConstRangeExpressionBinary), + CycleDelayConstRangeExpressionDollar(CycleDelayConstRangeExpressionDollar), + ExpressionOrDist(ExpressionOrDist), + AssertionVariableDeclaration(AssertionVariableDeclaration), + LetDeclaration(LetDeclaration), + LetIdentifier(LetIdentifier), + LetPortList(LetPortList), + LetPortItem(LetPortItem), + LetFormalType(LetFormalType), + LetExpression(LetExpression), + LetListOfArguments(LetListOfArguments), + LetListOfArgumentsOrdered(LetListOfArgumentsOrdered), + LetListOfArgumentsNamed(LetListOfArgumentsNamed), + LetActualArg(LetActualArg), + CastingType(CastingType), + DataType(DataType), + DataTypeVector(DataTypeVector), + DataTypeAtom(DataTypeAtom), + DataTypeStructUnion(DataTypeStructUnion), + Packed(Packed), + DataTypeEnum(DataTypeEnum), + DataTypeVirtual(DataTypeVirtual), + Interface(Interface), + DataTypeType(DataTypeType), + DataTypeOrImplicit(DataTypeOrImplicit), + ImplicitDataType(ImplicitDataType), + EnumBaseType(EnumBaseType), + EnumBaseTypeAtom(EnumBaseTypeAtom), + EnumBaseTypeVector(EnumBaseTypeVector), + EnumBaseTypeType(EnumBaseTypeType), + EnumNameDeclaration(EnumNameDeclaration), + ClassScope(ClassScope), + ClassType(ClassType), + IntegerType(IntegerType), + IntegerAtomType(IntegerAtomType), + IntegerVectorType(IntegerVectorType), + NonIntegerType(NonIntegerType), + NetType(NetType), + NetPortType(NetPortType), + NetPortTypeDataType(NetPortTypeDataType), + NetPortTypeInterconnect(NetPortTypeInterconnect), + VariablePortType(VariablePortType), + VarDataType(VarDataType), + VarDataTypeVar(VarDataTypeVar), + Signing(Signing), + SimpleType(SimpleType), + StructUnionMember(StructUnionMember), + DataTypeOrVoid(DataTypeOrVoid), + StructUnion(StructUnion), + TypeReference(TypeReference), + TypeReferenceExpression(TypeReferenceExpression), + TypeReferenceDataType(TypeReferenceDataType), + LocalParameterDeclaration(LocalParameterDeclaration), + LocalParameterDeclarationParam(LocalParameterDeclarationParam), + LocalParameterDeclarationType(LocalParameterDeclarationType), + ParameterDeclaration(ParameterDeclaration), + ParameterDeclarationParam(ParameterDeclarationParam), + ParameterDeclarationType(ParameterDeclarationType), + SpecparamDeclaration(SpecparamDeclaration), + BlockItemDeclaration(BlockItemDeclaration), + BlockItemDeclarationData(BlockItemDeclarationData), + BlockItemDeclarationLocalParameter(BlockItemDeclarationLocalParameter), + BlockItemDeclarationParameter(BlockItemDeclarationParameter), + BlockItemDeclarationLet(BlockItemDeclarationLet), + ListOfDefparamAssignments(ListOfDefparamAssignments), + ListOfGenvarIdentifiers(ListOfGenvarIdentifiers), + ListOfInterfaceIdentifiers(ListOfInterfaceIdentifiers), + ListOfNetDeclAssignments(ListOfNetDeclAssignments), + ListOfParamAssignments(ListOfParamAssignments), + ListOfPortIdentifiers(ListOfPortIdentifiers), + ListOfUdpPortIdentifiers(ListOfUdpPortIdentifiers), + ListOfSpecparamAssignments(ListOfSpecparamAssignments), + ListOfTfVariableIdentifiers(ListOfTfVariableIdentifiers), + ListOfTypeAssignments(ListOfTypeAssignments), + ListOfVariableDeclAssignments(ListOfVariableDeclAssignments), + ListOfVariableIdentifiers(ListOfVariableIdentifiers), + ListOfVariablePortIdentifiers(ListOfVariablePortIdentifiers), + DefparamAssignment(DefparamAssignment), + NetDeclAssignment(NetDeclAssignment), + ParamAssignment(ParamAssignment), + SpecparamAssignment(SpecparamAssignment), + SpecparamAssignmentMintypmax(SpecparamAssignmentMintypmax), + TypeAssignment(TypeAssignment), + PulseControlSpecparam(PulseControlSpecparam), + PulseControlSpecparamWithoutDescriptor(PulseControlSpecparamWithoutDescriptor), + PulseControlSpecparamWithDescriptor(PulseControlSpecparamWithDescriptor), + ErrorLimitValue(ErrorLimitValue), + RejectLimitValue(RejectLimitValue), + LimitValue(LimitValue), + VariableDeclAssignment(VariableDeclAssignment), + VariableDeclAssignmentVariable(VariableDeclAssignmentVariable), + VariableDeclAssignmentDynamicArray(VariableDeclAssignmentDynamicArray), + VariableDeclAssignmentClass(VariableDeclAssignmentClass), + ClassNew(ClassNew), + ClassNewArgument(ClassNewArgument), + ClassNewExpression(ClassNewExpression), + DynamicArrayNew(DynamicArrayNew), + UnpackedDimension(UnpackedDimension), + UnpackedDimensionRange(UnpackedDimensionRange), + UnpackedDimensionExpression(UnpackedDimensionExpression), + PackedDimension(PackedDimension), + PackedDimensionRange(PackedDimensionRange), + AssociativeDimension(AssociativeDimension), + AssociativeDimensionDataType(AssociativeDimensionDataType), + AssociativeDimensionAsterisk(AssociativeDimensionAsterisk), + VariableDimension(VariableDimension), + QueueDimension(QueueDimension), + UnsizedDimension(UnsizedDimension), + Delay3(Delay3), + Delay3Single(Delay3Single), + Delay3Mintypmax(Delay3Mintypmax), + Delay2(Delay2), + Delay2Single(Delay2Single), + Delay2Mintypmax(Delay2Mintypmax), + DelayValue(DelayValue), + TaskDeclaration(TaskDeclaration), + TaskBodyDeclaration(TaskBodyDeclaration), + TaskBodyDeclarationWithoutPort(TaskBodyDeclarationWithoutPort), + TaskBodyDeclarationWithPort(TaskBodyDeclarationWithPort), + TfItemDeclaration(TfItemDeclaration), + TfPortList(TfPortList), + TfPortItem(TfPortItem), + TfPortDirection(TfPortDirection), + TfPortDeclaration(TfPortDeclaration), + TaskPrototype(TaskPrototype), + InoutDeclaration(InoutDeclaration), + InputDeclaration(InputDeclaration), + InputDeclarationNet(InputDeclarationNet), + InputDeclarationVariable(InputDeclarationVariable), + OutputDeclaration(OutputDeclaration), + OutputDeclarationNet(OutputDeclarationNet), + OutputDeclarationVariable(OutputDeclarationVariable), + InterfacePortDeclaration(InterfacePortDeclaration), + RefDeclaration(RefDeclaration), + GenerateRegion(GenerateRegion), + LoopGenerateConstruct(LoopGenerateConstruct), + GenvarInitialization(GenvarInitialization), + Genvar(Genvar), + GenvarIteration(GenvarIteration), + GenvarIterationAssignment(GenvarIterationAssignment), + GenvarIterationPrefix(GenvarIterationPrefix), + GenvarIterationSuffix(GenvarIterationSuffix), + ConditionalGenerateConstruct(ConditionalGenerateConstruct), + IfGenerateConstruct(IfGenerateConstruct), + CaseGenerateConstruct(CaseGenerateConstruct), + CaseGenerateItem(CaseGenerateItem), + CaseGenerateItemNondefault(CaseGenerateItemNondefault), + CaseGenerateItemDefault(CaseGenerateItemDefault), + GenerateBlock(GenerateBlock), + GenerateBlockMultiple(GenerateBlockMultiple), + GenerateItem(GenerateItem), + InterfaceInstantiation(InterfaceInstantiation), + ProgramInstantiation(ProgramInstantiation), + ModuleInstantiation(ModuleInstantiation), + ParameterValueAssignment(ParameterValueAssignment), + ListOfParameterAssignments(ListOfParameterAssignments), + ListOfParameterAssignmentsOrdered(ListOfParameterAssignmentsOrdered), + ListOfParameterAssignmentsNamed(ListOfParameterAssignmentsNamed), + OrderedParameterAssignment(OrderedParameterAssignment), + NamedParameterAssignment(NamedParameterAssignment), + HierarchicalInstance(HierarchicalInstance), + NameOfInstance(NameOfInstance), + ListOfPortConnections(ListOfPortConnections), + ListOfPortConnectionsOrdered(ListOfPortConnectionsOrdered), + ListOfPortConnectionsNamed(ListOfPortConnectionsNamed), + OrderedPortConnection(OrderedPortConnection), + NamedPortConnection(NamedPortConnection), + NamedPortConnectionIdentifier(NamedPortConnectionIdentifier), + NamedPortConnectionAsterisk(NamedPortConnectionAsterisk), + CheckerInstantiation(CheckerInstantiation), + ListOfCheckerPortConnections(ListOfCheckerPortConnections), + ListOfCheckerPortConnectionsOrdered(ListOfCheckerPortConnectionsOrdered), + ListOfCheckerPortConnectionsNamed(ListOfCheckerPortConnectionsNamed), + OrderedCheckerPortConnection(OrderedCheckerPortConnection), + NamedCheckerPortConnection(NamedCheckerPortConnection), + NamedCheckerPortConnectionIdentifier(NamedCheckerPortConnectionIdentifier), + NamedCheckerPortConnectionAsterisk(NamedCheckerPortConnectionAsterisk), + NetLvalue(NetLvalue), + NetLvalueIdentifier(NetLvalueIdentifier), + NetLvalueLvalue(NetLvalueLvalue), + NetLvaluePattern(NetLvaluePattern), + VariableLvalue(VariableLvalue), + VariableLvalueIdentifier(VariableLvalueIdentifier), + VariableLvalueLvalue(VariableLvalueLvalue), + VariableLvaluePattern(VariableLvaluePattern), + NonrangeVariableLvalue(NonrangeVariableLvalue), + Concatenation(Concatenation), + ConstantConcatenation(ConstantConcatenation), + ConstantMultipleConcatenation(ConstantMultipleConcatenation), + ModulePathConcatenation(ModulePathConcatenation), + ModulePathMultipleConcatenation(ModulePathMultipleConcatenation), + MultipleConcatenation(MultipleConcatenation), + StreamingConcatenation(StreamingConcatenation), + StreamOperator(StreamOperator), + SliceSize(SliceSize), + StreamConcatenation(StreamConcatenation), + StreamExpression(StreamExpression), + ArrayRangeExpression(ArrayRangeExpression), + ArrayRangeExpressionColon(ArrayRangeExpressionColon), + ArrayRangeExpressionPlusColon(ArrayRangeExpressionPlusColon), + ArrayRangeExpressionMinusColon(ArrayRangeExpressionMinusColon), + EmptyUnpackedArrayConcatenation(EmptyUnpackedArrayConcatenation), + ConstantPrimary(ConstantPrimary), + ConstantPrimaryPsParameter(ConstantPrimaryPsParameter), + ConstantPrimarySpecparam(ConstantPrimarySpecparam), + ConstantPrimaryFormalPort(ConstantPrimaryFormalPort), + ConstantPrimaryEnum(ConstantPrimaryEnum), + ConstantPrimaryConcatenation(ConstantPrimaryConcatenation), + ConstantPrimaryMultipleConcatenation(ConstantPrimaryMultipleConcatenation), + ConstantPrimaryMintypmaxExpression(ConstantPrimaryMintypmaxExpression), + ModulePathPrimary(ModulePathPrimary), + ModulePathPrimaryMintypmax(ModulePathPrimaryMintypmax), + Primary(Primary), + PrimaryHierarchical(PrimaryHierarchical), + PrimaryConcatenation(PrimaryConcatenation), + PrimaryMultipleConcatenation(PrimaryMultipleConcatenation), + PrimaryMintypmaxExpression(PrimaryMintypmaxExpression), + ClassQualifierOrPackageScope(ClassQualifierOrPackageScope), + ClassQualifier(ClassQualifier), + RangeExpression(RangeExpression), + PrimaryLiteral(PrimaryLiteral), + TimeLiteral(TimeLiteral), + TimeLiteralUnsigned(TimeLiteralUnsigned), + TimeLiteralFixedPoint(TimeLiteralFixedPoint), + TimeUnit(TimeUnit), + ImplicitClassHandle(ImplicitClassHandle), + BitSelect(BitSelect), + Select(Select), + NonrangeSelect(NonrangeSelect), + ConstantBitSelect(ConstantBitSelect), + ConstantSelect(ConstantSelect), + ConstantCast(ConstantCast), + ConstantLetExpression(ConstantLetExpression), + Cast(Cast), + IncOrDecExpression(IncOrDecExpression), + IncOrDecExpressionPrefix(IncOrDecExpressionPrefix), + IncOrDecExpressionSuffix(IncOrDecExpressionSuffix), + ConditionalExpression(ConditionalExpression), + ConstantExpression(ConstantExpression), + ConstantExpressionUnary(ConstantExpressionUnary), + ConstantExpressionBinary(ConstantExpressionBinary), + ConstantExpressionTernary(ConstantExpressionTernary), + ConstantInsideExpression(ConstantInsideExpression), + ConstantMintypmaxExpression(ConstantMintypmaxExpression), + ConstantMintypmaxExpressionTernary(ConstantMintypmaxExpressionTernary), + ConstantParamExpression(ConstantParamExpression), + ParamExpression(ParamExpression), + ConstantRangeExpression(ConstantRangeExpression), + ConstantPartSelectRange(ConstantPartSelectRange), + ConstantRange(ConstantRange), + ConstantIndexedRange(ConstantIndexedRange), + Expression(Expression), + ExpressionUnary(ExpressionUnary), + ExpressionOperatorAssignment(ExpressionOperatorAssignment), + ExpressionBinary(ExpressionBinary), + ExpressionBinaryOperand(ExpressionBinaryOperand), + TaggedUnionExpression(TaggedUnionExpression), + InsideExpression(InsideExpression), + ValueRange(ValueRange), + ValueRangeBinary(ValueRangeBinary), + MintypmaxExpression(MintypmaxExpression), + MintypmaxExpressionTernary(MintypmaxExpressionTernary), + ModulePathConditionalExpression(ModulePathConditionalExpression), + ModulePathExpression(ModulePathExpression), + ModulePathExpressionUnary(ModulePathExpressionUnary), + ModulePathExpressionBinary(ModulePathExpressionBinary), + ModulePathMintypmaxExpression(ModulePathMintypmaxExpression), + ModulePathMintypmaxExpressionTernary(ModulePathMintypmaxExpressionTernary), + PartSelectRange(PartSelectRange), + IndexedRange(IndexedRange), + GenvarExpression(GenvarExpression), + UnaryOperator(UnaryOperator), + BinaryOperator(BinaryOperator), + IncOrDecOperator(IncOrDecOperator), + UnaryModulePathOperator(UnaryModulePathOperator), + BinaryModulePathOperator(BinaryModulePathOperator), + StringLiteral(StringLiteral), + ConstantFunctionCall(ConstantFunctionCall), + TfCall(TfCall), + SystemTfCall(SystemTfCall), + SystemTfCallArgOptional(SystemTfCallArgOptional), + SystemTfCallArgDataType(SystemTfCallArgDataType), + SystemTfCallArgExpression(SystemTfCallArgExpression), + SubroutineCall(SubroutineCall), + SubroutineCallRandomize(SubroutineCallRandomize), + FunctionSubroutineCall(FunctionSubroutineCall), + ListOfArguments(ListOfArguments), + ListOfArgumentsOrdered(ListOfArgumentsOrdered), + ListOfArgumentsNamed(ListOfArgumentsNamed), + MethodCall(MethodCall), + MethodCallBody(MethodCallBody), + MethodCallBodyUser(MethodCallBodyUser), + BuiltInMethodCall(BuiltInMethodCall), + ArrayManipulationCall(ArrayManipulationCall), + RandomizeCall(RandomizeCall), + VariableIdentifierListOrNull(VariableIdentifierListOrNull), + MethodCallRoot(MethodCallRoot), + ArrayMethodName(ArrayMethodName), + Number(Number), + IntegralNumber(IntegralNumber), + DecimalNumber(DecimalNumber), + DecimalNumberBaseUnsigned(DecimalNumberBaseUnsigned), + DecimalNumberBaseXNumber(DecimalNumberBaseXNumber), + DecimalNumberBaseZNumber(DecimalNumberBaseZNumber), + BinaryNumber(BinaryNumber), + OctalNumber(OctalNumber), + HexNumber(HexNumber), + Sign(Sign), + Size(Size), + NonZeroUnsignedNumber(NonZeroUnsignedNumber), + RealNumber(RealNumber), + RealNumberFloating(RealNumberFloating), + FixedPointNumber(FixedPointNumber), + Exp(Exp), + UnsignedNumber(UnsignedNumber), + BinaryValue(BinaryValue), + OctalValue(OctalValue), + HexValue(HexValue), + DecimalBase(DecimalBase), + BinaryBase(BinaryBase), + OctalBase(OctalBase), + HexBase(HexBase), + XNumber(XNumber), + ZNumber(ZNumber), + UnbasedUnsizedLiteral(UnbasedUnsizedLiteral), + SourceText(SourceText), + Description(Description), + DescriptionPackageItem(DescriptionPackageItem), + DescriptionBindDirective(DescriptionBindDirective), + ModuleNonansiHeader(ModuleNonansiHeader), + ModuleAnsiHeader(ModuleAnsiHeader), + ModuleDeclaration(ModuleDeclaration), + ModuleDeclarationNonansi(ModuleDeclarationNonansi), + ModuleDeclarationAnsi(ModuleDeclarationAnsi), + ModuleDeclarationWildcard(ModuleDeclarationWildcard), + ModuleDeclarationExternNonansi(ModuleDeclarationExternNonansi), + ModuleDeclarationExternAnsi(ModuleDeclarationExternAnsi), + ModuleKeyword(ModuleKeyword), + InterfaceDeclaration(InterfaceDeclaration), + InterfaceDeclarationNonansi(InterfaceDeclarationNonansi), + InterfaceDeclarationAnsi(InterfaceDeclarationAnsi), + InterfaceDeclarationWildcard(InterfaceDeclarationWildcard), + InterfaceDeclarationExternNonansi(InterfaceDeclarationExternNonansi), + InterfaceDeclarationExternAnsi(InterfaceDeclarationExternAnsi), + InterfaceNonansiHeader(InterfaceNonansiHeader), + InterfaceAnsiHeader(InterfaceAnsiHeader), + ProgramDeclaration(ProgramDeclaration), + ProgramDeclarationNonansi(ProgramDeclarationNonansi), + ProgramDeclarationAnsi(ProgramDeclarationAnsi), + ProgramDeclarationWildcard(ProgramDeclarationWildcard), + ProgramDeclarationExternNonansi(ProgramDeclarationExternNonansi), + ProgramDeclarationExternAnsi(ProgramDeclarationExternAnsi), + ProgramNonansiHeader(ProgramNonansiHeader), + ProgramAnsiHeader(ProgramAnsiHeader), + CheckerDeclaration(CheckerDeclaration), + ClassDeclaration(ClassDeclaration), + Virtual(Virtual), + InterfaceClassType(InterfaceClassType), + InterfaceClassDeclaration(InterfaceClassDeclaration), + InterfaceClassItem(InterfaceClassItem), + InterfaceClassItemMethod(InterfaceClassItemMethod), + InterfaceClassMethod(InterfaceClassMethod), + PackageDeclaration(PackageDeclaration), + TimeunitsDeclaration(TimeunitsDeclaration), + TimeunitsDeclarationTimeunit(TimeunitsDeclarationTimeunit), + TimeunitsDeclarationTimeprecision(TimeunitsDeclarationTimeprecision), + TimeunitsDeclarationTimeunitTimeprecision(TimeunitsDeclarationTimeunitTimeprecision), + TimeunitsDeclarationTimeprecisionTimeunit(TimeunitsDeclarationTimeprecisionTimeunit), + LibraryText(LibraryText), + LibraryDescription(LibraryDescription), + LibraryDeclaration(LibraryDeclaration), + IncludeStatement(IncludeStatement), + FilePathSpec(FilePathSpec), + FilePathSpecNonLiteral(FilePathSpecNonLiteral), + ParameterPortList(ParameterPortList), + ParameterPortListAssignment(ParameterPortListAssignment), + ParameterPortListDeclaration(ParameterPortListDeclaration), + ParameterPortDeclaration(ParameterPortDeclaration), + ParameterPortDeclarationParamList(ParameterPortDeclarationParamList), + ParameterPortDeclarationTypeList(ParameterPortDeclarationTypeList), + ListOfPorts(ListOfPorts), + ListOfPortDeclarations(ListOfPortDeclarations), + PortDeclaration(PortDeclaration), + PortDeclarationInout(PortDeclarationInout), + PortDeclarationInput(PortDeclarationInput), + PortDeclarationOutput(PortDeclarationOutput), + PortDeclarationRef(PortDeclarationRef), + PortDeclarationInterface(PortDeclarationInterface), + Port(Port), + PortNonNamed(PortNonNamed), + PortNamed(PortNamed), + PortExpression(PortExpression), + PortExpressionBrace(PortExpressionBrace), + PortReference(PortReference), + PortDirection(PortDirection), + NetPortHeader(NetPortHeader), + VariablePortHeader(VariablePortHeader), + InterfacePortHeader(InterfacePortHeader), + InterfacePortHeaderIdentifier(InterfacePortHeaderIdentifier), + InterfacePortHeaderInterface(InterfacePortHeaderInterface), + NetPortHeaderOrInterfacePortHeader(NetPortHeaderOrInterfacePortHeader), + AnsiPortDeclaration(AnsiPortDeclaration), + AnsiPortDeclarationNet(AnsiPortDeclarationNet), + AnsiPortDeclarationVariable(AnsiPortDeclarationVariable), + AnsiPortDeclarationParen(AnsiPortDeclarationParen), + ProgramItem(ProgramItem), + NonPortProgramItem(NonPortProgramItem), + NonPortProgramItemAssign(NonPortProgramItemAssign), + NonPortProgramItemModule(NonPortProgramItemModule), + NonPortProgramItemInitial(NonPortProgramItemInitial), + NonPortProgramItemFinal(NonPortProgramItemFinal), + NonPortProgramItemAssertion(NonPortProgramItemAssertion), + ProgramGenerateItem(ProgramGenerateItem), + ElaborationSystemTask(ElaborationSystemTask), + ElaborationSystemTaskFatal(ElaborationSystemTaskFatal), + ElaborationSystemTaskError(ElaborationSystemTaskError), + ElaborationSystemTaskWarning(ElaborationSystemTaskWarning), + ElaborationSystemTaskInfo(ElaborationSystemTaskInfo), + FinishNumber(FinishNumber), + ModuleCommonItem(ModuleCommonItem), + ModuleItem(ModuleItem), + ModuleOrGenerateItem(ModuleOrGenerateItem), + ModuleOrGenerateItemParameter(ModuleOrGenerateItemParameter), + ModuleOrGenerateItemGate(ModuleOrGenerateItemGate), + ModuleOrGenerateItemUdp(ModuleOrGenerateItemUdp), + ModuleOrGenerateItemModule(ModuleOrGenerateItemModule), + ModuleOrGenerateItemModuleItem(ModuleOrGenerateItemModuleItem), + ModuleOrGenerateItemDeclaration(ModuleOrGenerateItemDeclaration), + ModuleOrGenerateItemDeclarationClocking(ModuleOrGenerateItemDeclarationClocking), + ModuleOrGenerateItemDeclarationDisable(ModuleOrGenerateItemDeclarationDisable), + NonPortModuleItem(NonPortModuleItem), + NonPortModuleItemSpecparam(NonPortModuleItemSpecparam), + ParameterOverride(ParameterOverride), + BindDirective(BindDirective), + BindDirectiveScope(BindDirectiveScope), + BindDirectiveInstance(BindDirectiveInstance), + BindTargetScope(BindTargetScope), + BindTargetInstance(BindTargetInstance), + BindTargetInstanceList(BindTargetInstanceList), + BindInstantiation(BindInstantiation), + ConstraintDeclaration(ConstraintDeclaration), + Static(Static), + ConstraintBlock(ConstraintBlock), + ConstraintBlockItem(ConstraintBlockItem), + ConstraintBlockItemSolve(ConstraintBlockItemSolve), + SolveBeforeList(SolveBeforeList), + ConstraintPrimary(ConstraintPrimary), + ConstraintExpression(ConstraintExpression), + ConstraintExpressionExpression(ConstraintExpressionExpression), + Soft(Soft), + ConstraintExpressionArrow(ConstraintExpressionArrow), + ConstraintExpressionIf(ConstraintExpressionIf), + ConstraintExpressionForeach(ConstraintExpressionForeach), + ConstraintExpressionDisable(ConstraintExpressionDisable), + UniquenessConstraint(UniquenessConstraint), + ConstraintSet(ConstraintSet), + ConstraintSetBrace(ConstraintSetBrace), + DistList(DistList), + DistItem(DistItem), + DistWeight(DistWeight), + DistWeightEqual(DistWeightEqual), + DistWeightDivide(DistWeightDivide), + ConstraintPrototype(ConstraintPrototype), + ConstraintPrototypeQualifier(ConstraintPrototypeQualifier), + ExternConstraintDeclaration(ExternConstraintDeclaration), + IdentifierList(IdentifierList), + ConfigDeclaration(ConfigDeclaration), + DesignStatement(DesignStatement), + ConfigRuleStatement(ConfigRuleStatement), + ConfigRuleStatementDefault(ConfigRuleStatementDefault), + ConfigRuleStatementInstLib(ConfigRuleStatementInstLib), + ConfigRuleStatementInstUse(ConfigRuleStatementInstUse), + ConfigRuleStatementCellLib(ConfigRuleStatementCellLib), + ConfigRuleStatementCellUse(ConfigRuleStatementCellUse), + DefaultClause(DefaultClause), + InstClause(InstClause), + InstName(InstName), + CellClause(CellClause), + LiblistClause(LiblistClause), + UseClause(UseClause), + UseClauseCell(UseClauseCell), + UseClauseNamed(UseClauseNamed), + UseClauseCellNamed(UseClauseCellNamed), + Config(Config), + ClassItem(ClassItem), + ClassItemProperty(ClassItemProperty), + ClassItemMethod(ClassItemMethod), + ClassItemConstraint(ClassItemConstraint), + ClassItemDeclaration(ClassItemDeclaration), + ClassItemCovergroup(ClassItemCovergroup), + ClassProperty(ClassProperty), + ClassPropertyNonConst(ClassPropertyNonConst), + ClassPropertyConst(ClassPropertyConst), + ClassPropertyConstExpression(ClassPropertyConstExpression), + ClassMethod(ClassMethod), + ClassMethodTask(ClassMethodTask), + ClassMethodFunction(ClassMethodFunction), + ClassMethodPureVirtual(ClassMethodPureVirtual), + ClassMethodExternMethod(ClassMethodExternMethod), + ClassMethodConstructor(ClassMethodConstructor), + ClassMethodExternConstructor(ClassMethodExternConstructor), + ClassConstructorPrototype(ClassConstructorPrototype), + ClassConstraint(ClassConstraint), + ClassItemQualifier(ClassItemQualifier), + PropertyQualifier(PropertyQualifier), + RandomQualifier(RandomQualifier), + MethodQualifier(MethodQualifier), + MethodPrototype(MethodPrototype), + ClassConstructorDeclaration(ClassConstructorDeclaration), + New(New), + InterfaceOrGenerateItem(InterfaceOrGenerateItem), + InterfaceOrGenerateItemModule(InterfaceOrGenerateItemModule), + InterfaceOrGenerateItemExtern(InterfaceOrGenerateItemExtern), + ExternTfDeclaration(ExternTfDeclaration), + ExternTfDeclarationMethod(ExternTfDeclarationMethod), + ExternTfDeclarationTask(ExternTfDeclarationTask), + InterfaceItem(InterfaceItem), + NonPortInterfaceItem(NonPortInterfaceItem), + CheckerPortList(CheckerPortList), + CheckerPortItem(CheckerPortItem), + CheckerPortDirection(CheckerPortDirection), + CheckerOrGenerateItem(CheckerOrGenerateItem), + CheckerOrGenerateItemDeclaration(CheckerOrGenerateItemDeclaration), + CheckerOrGenerateItemDeclarationData(CheckerOrGenerateItemDeclarationData), + Rand(Rand), + CheckerOrGenerateItemDeclarationClocking(CheckerOrGenerateItemDeclarationClocking), + CheckerOrGenerateItemDeclarationDisable(CheckerOrGenerateItemDeclarationDisable), + CheckerGenerateItem(CheckerGenerateItem), + PackageItem(PackageItem), + PackageOrGenerateItemDeclaration(PackageOrGenerateItemDeclaration), + AnonymousProgram(AnonymousProgram), + AnonymousProgramItem(AnonymousProgramItem), + PreprocessorText(PreprocessorText), + Symbol(Symbol), + Keyword(Keyword), + WhiteSpace(WhiteSpace), + PulldownStrength(PulldownStrength), + PulldownStrength01(PulldownStrength01), + PulldownStrength10(PulldownStrength10), + PulldownStrength0(PulldownStrength0), + PullupStrength(PullupStrength), + PullupStrength01(PullupStrength01), + PullupStrength10(PullupStrength10), + PullupStrength1(PullupStrength1), + GateInstantiation(GateInstantiation), + GateInstantiationCmos(GateInstantiationCmos), + GateInstantiationEnable(GateInstantiationEnable), + GateInstantiationMos(GateInstantiationMos), + GateInstantiationNInput(GateInstantiationNInput), + GateInstantiationNOutput(GateInstantiationNOutput), + GateInstantiationPassEn(GateInstantiationPassEn), + GateInstantiationPass(GateInstantiationPass), + GateInstantiationPulldown(GateInstantiationPulldown), + GateInstantiationPullup(GateInstantiationPullup), + CmosSwitchInstance(CmosSwitchInstance), + EnableGateInstance(EnableGateInstance), + MosSwitchInstance(MosSwitchInstance), + NInputGateInstance(NInputGateInstance), + NOutputGateInstance(NOutputGateInstance), + PassSwitchInstance(PassSwitchInstance), + PassEnableSwitchInstance(PassEnableSwitchInstance), + PullGateInstance(PullGateInstance), + CmosSwitchtype(CmosSwitchtype), + EnableGatetype(EnableGatetype), + MosSwitchtype(MosSwitchtype), + NInputGatetype(NInputGatetype), + NOutputGatetype(NOutputGatetype), + PassEnSwitchtype(PassEnSwitchtype), + PassSwitchtype(PassSwitchtype), + EnableTerminal(EnableTerminal), + InoutTerminal(InoutTerminal), + InputTerminal(InputTerminal), + NcontrolTerminal(NcontrolTerminal), + OutputTerminal(OutputTerminal), + PcontrolTerminal(PcontrolTerminal), + UdpPortList(UdpPortList), + UdpDeclarationPortList(UdpDeclarationPortList), + UdpPortDeclaration(UdpPortDeclaration), + UdpOutputDeclaration(UdpOutputDeclaration), + UdpOutputDeclarationNonreg(UdpOutputDeclarationNonreg), + UdpOutputDeclarationReg(UdpOutputDeclarationReg), + UdpInputDeclaration(UdpInputDeclaration), + UdpRegDeclaration(UdpRegDeclaration), + UdpInstantiation(UdpInstantiation), + UdpInstance(UdpInstance), + UdpNonansiDeclaration(UdpNonansiDeclaration), + UdpAnsiDeclaration(UdpAnsiDeclaration), + UdpDeclaration(UdpDeclaration), + UdpDeclarationNonansi(UdpDeclarationNonansi), + UdpDeclarationAnsi(UdpDeclarationAnsi), + UdpDeclarationExternNonansi(UdpDeclarationExternNonansi), + UdpDeclarationExternAnsi(UdpDeclarationExternAnsi), + UdpDeclarationWildcard(UdpDeclarationWildcard), + UdpBody(UdpBody), + CombinationalBody(CombinationalBody), + CombinationalEntry(CombinationalEntry), + SequentialBody(SequentialBody), + UdpInitialStatement(UdpInitialStatement), + InitVal(InitVal), + SequentialEntry(SequentialEntry), + SeqInputList(SeqInputList), + LevelInputList(LevelInputList), + EdgeInputList(EdgeInputList), + EdgeIndicator(EdgeIndicator), + EdgeIndicatorParen(EdgeIndicatorParen), + CurrentState(CurrentState), + NextState(NextState), + OutputSymbol(OutputSymbol), + LevelSymbol(LevelSymbol), + EdgeSymbol(EdgeSymbol), + SpecifyInputTerminalDescriptor(SpecifyInputTerminalDescriptor), + SpecifyOutputTerminalDescriptor(SpecifyOutputTerminalDescriptor), + InputIdentifier(InputIdentifier), + InputIdentifierInterface(InputIdentifierInterface), + OutputIdentifier(OutputIdentifier), + OutputIdentifierInterface(OutputIdentifierInterface), + PathDeclaration(PathDeclaration), + SimplePathDeclaration(SimplePathDeclaration), + SimplePathDeclarationParallel(SimplePathDeclarationParallel), + SimplePathDeclarationFull(SimplePathDeclarationFull), + ParallelPathDescription(ParallelPathDescription), + FullPathDescription(FullPathDescription), + ListOfPathInputs(ListOfPathInputs), + ListOfPathOutputs(ListOfPathOutputs), + PathDelayValue(PathDelayValue), + PathDelayValueParen(PathDelayValueParen), + ListOfPathDelayExpressions(ListOfPathDelayExpressions), + TPathDelayExpression(TPathDelayExpression), + PathDelayExpression(PathDelayExpression), + EdgeSensitivePathDeclaration(EdgeSensitivePathDeclaration), + EdgeSensitivePathDeclarationParallel(EdgeSensitivePathDeclarationParallel), + EdgeSensitivePathDeclarationFull(EdgeSensitivePathDeclarationFull), + ParallelEdgeSensitivePathDescription(ParallelEdgeSensitivePathDescription), + FullEdgeSensitivePathDescription(FullEdgeSensitivePathDescription), + DataSourceExpression(DataSourceExpression), + EdgeIdentifier(EdgeIdentifier), + StateDependentPathDeclaration(StateDependentPathDeclaration), + StateDependentPathDeclarationIfSimple(StateDependentPathDeclarationIfSimple), + StateDependentPathDeclarationIfEdgeSensitive(StateDependentPathDeclarationIfEdgeSensitive), + StateDependentPathDeclarationIfNone(StateDependentPathDeclarationIfNone), + PolarityOperator(PolarityOperator), + SpecifyBlock(SpecifyBlock), + SpecifyItem(SpecifyItem), + PulsestyleDeclaration(PulsestyleDeclaration), + ShowcancelledDeclaration(ShowcancelledDeclaration), + TimingCheckEvent(TimingCheckEvent), + ControlledTimingCheckEvent(ControlledTimingCheckEvent), + TimingCheckEventControl(TimingCheckEventControl), + SpecifyTerminalDescriptor(SpecifyTerminalDescriptor), + EdgeControlSpecifier(EdgeControlSpecifier), + EdgeDescriptor(EdgeDescriptor), + TimingCheckCondition(TimingCheckCondition), + TimingCheckConditionParen(TimingCheckConditionParen), + ScalarTimingCheckCondition(ScalarTimingCheckCondition), + ScalarTimingCheckConditionUnary(ScalarTimingCheckConditionUnary), + ScalarTimingCheckConditionBinary(ScalarTimingCheckConditionBinary), + ScalarConstant(ScalarConstant), + SystemTimingCheck(SystemTimingCheck), + SetupTimingCheck(SetupTimingCheck), + HoldTimingCheck(HoldTimingCheck), + SetupholdTimingCheck(SetupholdTimingCheck), + RecoveryTimingCheck(RecoveryTimingCheck), + RemovalTimingCheck(RemovalTimingCheck), + RecremTimingCheck(RecremTimingCheck), + SkewTimingCheck(SkewTimingCheck), + TimeskewTimingCheck(TimeskewTimingCheck), + FullskewTimingCheck(FullskewTimingCheck), + PeriodTimingCheck(PeriodTimingCheck), + WidthTimingCheck(WidthTimingCheck), + NochangeTimingCheck(NochangeTimingCheck), + TimecheckCondition(TimecheckCondition), + ControlledReferenceEvent(ControlledReferenceEvent), + DataEvent(DataEvent), + DelayedData(DelayedData), + DelayedDataWithMintypmax(DelayedDataWithMintypmax), + DelayedReference(DelayedReference), + DelayedReferenceWithMintypmax(DelayedReferenceWithMintypmax), + EndEdgeOffset(EndEdgeOffset), + EventBasedFlag(EventBasedFlag), + Notifier(Notifier), + ReferenceEvent(ReferenceEvent), + RemainActiveFlag(RemainActiveFlag), + TimestampCondition(TimestampCondition), + StartEdgeOffset(StartEdgeOffset), + Threshold(Threshold), + TimingCheckLimit(TimingCheckLimit), + ProceduralTimingControlStatement(ProceduralTimingControlStatement), + DelayOrEventControl(DelayOrEventControl), + DelayOrEventControlRepeat(DelayOrEventControlRepeat), + DelayControl(DelayControl), + DelayControlDelay(DelayControlDelay), + DelayControlMintypmax(DelayControlMintypmax), + EventControl(EventControl), + EventControlEventIdentifier(EventControlEventIdentifier), + EventControlEventExpression(EventControlEventExpression), + EventControlAsterisk(EventControlAsterisk), + EventControlParenAsterisk(EventControlParenAsterisk), + EventControlSequenceIdentifier(EventControlSequenceIdentifier), + EventExpression(EventExpression), + EventExpressionExpression(EventExpressionExpression), + EventExpressionSequence(EventExpressionSequence), + EventExpressionOr(EventExpressionOr), + EventExpressionComma(EventExpressionComma), + EventExpressionParen(EventExpressionParen), + ProceduralTimingControl(ProceduralTimingControl), + JumpStatement(JumpStatement), + JumpStatementReturn(JumpStatementReturn), + JumpStatementBreak(JumpStatementBreak), + JumpStatementContinue(JumpStatementContinue), + WaitStatement(WaitStatement), + WaitStatementWait(WaitStatementWait), + WaitStatementFork(WaitStatementFork), + WaitStatementOrder(WaitStatementOrder), + EventTrigger(EventTrigger), + EventTriggerNamed(EventTriggerNamed), + EventTriggerNonblocking(EventTriggerNonblocking), + DisableStatement(DisableStatement), + DisableStatementTask(DisableStatementTask), + DisableStatementBlock(DisableStatementBlock), + DisableStatementFork(DisableStatementFork), + ConditionalStatement(ConditionalStatement), + UniquePriority(UniquePriority), + CondPredicate(CondPredicate), + ExpressionOrCondPattern(ExpressionOrCondPattern), + CondPattern(CondPattern), + AssertionItem(AssertionItem), + DeferredImmediateAssertionItem(DeferredImmediateAssertionItem), + ProceduralAssertionStatement(ProceduralAssertionStatement), + ImmediateAssertionStatement(ImmediateAssertionStatement), + SimpleImmediateAssertionStatement(SimpleImmediateAssertionStatement), + SimpleImmediateAssertStatement(SimpleImmediateAssertStatement), + SimpleImmediateAssumeStatement(SimpleImmediateAssumeStatement), + SimpleImmediateCoverStatement(SimpleImmediateCoverStatement), + DeferredImmediateAssertionStatement(DeferredImmediateAssertionStatement), + DeferredImmediateAssertStatement(DeferredImmediateAssertStatement), + DeferredImmediateAssumeStatement(DeferredImmediateAssumeStatement), + DeferredImmediateCoverStatement(DeferredImmediateCoverStatement), + AssertTiming(AssertTiming), + Pattern(Pattern), + PatternVariable(PatternVariable), + PatternTagged(PatternTagged), + PatternList(PatternList), + PatternIdentifierList(PatternIdentifierList), + AssignmentPattern(AssignmentPattern), + AssignmentPatternList(AssignmentPatternList), + AssignmentPatternStructure(AssignmentPatternStructure), + AssignmentPatternArray(AssignmentPatternArray), + AssignmentPatternRepeat(AssignmentPatternRepeat), + StructurePatternKey(StructurePatternKey), + ArrayPatternKey(ArrayPatternKey), + AssignmentPatternKey(AssignmentPatternKey), + AssignmentPatternExpression(AssignmentPatternExpression), + AssignmentPatternExpressionType(AssignmentPatternExpressionType), + ConstantAssignmentPatternExpression(ConstantAssignmentPatternExpression), + AssignmentPatternNetLvalue(AssignmentPatternNetLvalue), + AssignmentPatternVariableLvalue(AssignmentPatternVariableLvalue), + ContinuousAssign(ContinuousAssign), + ContinuousAssignNet(ContinuousAssignNet), + ContinuousAssignVariable(ContinuousAssignVariable), + ListOfNetAssignments(ListOfNetAssignments), + ListOfVariableAssignments(ListOfVariableAssignments), + NetAlias(NetAlias), + NetAssignment(NetAssignment), + SubroutineCallStatement(SubroutineCallStatement), + SubroutineCallStatementFunction(SubroutineCallStatementFunction), + StatementOrNull(StatementOrNull), + StatementOrNullAttribute(StatementOrNullAttribute), + Statement(Statement), + StatementItem(StatementItem), + FunctionStatement(FunctionStatement), + FunctionStatementOrNull(FunctionStatementOrNull), + FunctionStatementOrNullAttribute(FunctionStatementOrNullAttribute), + VariableIdentifierList(VariableIdentifierList), + RandsequenceStatement(RandsequenceStatement), + Production(Production), + RsRule(RsRule), + RsProductionList(RsProductionList), + RsProductionListProd(RsProductionListProd), + RsProductionListJoin(RsProductionListJoin), + WeightSpecification(WeightSpecification), + WeightSpecificationExpression(WeightSpecificationExpression), + RsCodeBlock(RsCodeBlock), + RsProd(RsProd), + ProductionItem(ProductionItem), + RsIfElse(RsIfElse), + RsRepeat(RsRepeat), + RsCase(RsCase), + RsCaseItem(RsCaseItem), + RsCaseItemNondefault(RsCaseItemNondefault), + RsCaseItemDefault(RsCaseItemDefault), + LoopStatement(LoopStatement), + LoopStatementForever(LoopStatementForever), + LoopStatementRepeat(LoopStatementRepeat), + LoopStatementWhile(LoopStatementWhile), + LoopStatementFor(LoopStatementFor), + LoopStatementDoWhile(LoopStatementDoWhile), + LoopStatementForeach(LoopStatementForeach), + ForInitialization(ForInitialization), + ForInitializationDeclaration(ForInitializationDeclaration), + ForVariableDeclaration(ForVariableDeclaration), + Var(Var), + ForStep(ForStep), + ForStepAssignment(ForStepAssignment), + LoopVariables(LoopVariables), + ActionBlock(ActionBlock), + ActionBlockElse(ActionBlockElse), + SeqBlock(SeqBlock), + ParBlock(ParBlock), + JoinKeyword(JoinKeyword), + ClockingDeclaration(ClockingDeclaration), + ClockingDeclarationLocal(ClockingDeclarationLocal), + Default(Default), + ClockingDeclarationGlobal(ClockingDeclarationGlobal), + ClockingEvent(ClockingEvent), + ClockingEventIdentifier(ClockingEventIdentifier), + ClockingEventExpression(ClockingEventExpression), + ClockingItem(ClockingItem), + ClockingItemDefault(ClockingItemDefault), + ClockingItemDirection(ClockingItemDirection), + ClockingItemAssertion(ClockingItemAssertion), + DefaultSkew(DefaultSkew), + DefaultSkewInput(DefaultSkewInput), + DefaultSkewOutput(DefaultSkewOutput), + DefaultSkewInputOutput(DefaultSkewInputOutput), + ClockingDirection(ClockingDirection), + ClockingDirectionInput(ClockingDirectionInput), + ClockingDirectionOutput(ClockingDirectionOutput), + ClockingDirectionInputOutput(ClockingDirectionInputOutput), + ListOfClockingDeclAssign(ListOfClockingDeclAssign), + ClockingDeclAssign(ClockingDeclAssign), + ClockingSkew(ClockingSkew), + ClockingSkewEdge(ClockingSkewEdge), + ClockingDrive(ClockingDrive), + CycleDelay(CycleDelay), + CycleDelayIntegral(CycleDelayIntegral), + CycleDelayIdentifier(CycleDelayIdentifier), + CycleDelayExpression(CycleDelayExpression), + Clockvar(Clockvar), + ClockvarExpression(ClockvarExpression), + CaseStatement(CaseStatement), + CaseStatementNormal(CaseStatementNormal), + CaseStatementMatches(CaseStatementMatches), + CaseStatementInside(CaseStatementInside), + CaseKeyword(CaseKeyword), + CaseExpression(CaseExpression), + CaseExpressionExpression(CaseExpressionExpression), + CaseItem(CaseItem), + CaseItemNondefault(CaseItemNondefault), + CaseItemDefault(CaseItemDefault), + CasePatternItem(CasePatternItem), + CasePatternItemNondefault(CasePatternItemNondefault), + CaseInsideItem(CaseInsideItem), + CaseInsideItemNondefault(CaseInsideItemNondefault), + CaseItemExpression(CaseItemExpression), + RandcaseStatement(RandcaseStatement), + RandcaseItem(RandcaseItem), + OpenRangeList(OpenRangeList), + OpenValueRange(OpenValueRange), + InitialConstruct(InitialConstruct), + AlwaysConstruct(AlwaysConstruct), + AlwaysKeyword(AlwaysKeyword), + FinalConstruct(FinalConstruct), + BlockingAssignment(BlockingAssignment), + BlockingAssignmentVariable(BlockingAssignmentVariable), + BlockingAssignmentNonrangeVariable(BlockingAssignmentNonrangeVariable), + BlockingAssignmentHierarchicalVariable(BlockingAssignmentHierarchicalVariable), + OperatorAssignment(OperatorAssignment), + AssignmentOperator(AssignmentOperator), + NonblockingAssignment(NonblockingAssignment), + ProceduralContinuousAssignment(ProceduralContinuousAssignment), + ProceduralContinuousAssignmentAssign(ProceduralContinuousAssignmentAssign), + ProceduralContinuousAssignmentDeassign(ProceduralContinuousAssignmentDeassign), + ProceduralContinuousAssignmentForceVariable(ProceduralContinuousAssignmentForceVariable), + ProceduralContinuousAssignmentForceNet(ProceduralContinuousAssignmentForceNet), + ProceduralContinuousAssignmentReleaseVariable(ProceduralContinuousAssignmentReleaseVariable), + ProceduralContinuousAssignmentReleaseNet(ProceduralContinuousAssignmentReleaseNet), + VariableAssignment(VariableAssignment), +} + +impl<'a> std::fmt::Display for RefNode<'a> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + RefNode::Locate(_) => write!(f, "Locate"), + RefNode::Comment(_) => write!(f, "Comment"), + RefNode::AttributeInstance(_) => write!(f, "AttributeInstance"), + RefNode::AttrSpec(_) => write!(f, "AttrSpec"), + RefNode::ArrayIdentifier(_) => write!(f, "ArrayIdentifier"), + RefNode::BlockIdentifier(_) => write!(f, "BlockIdentifier"), + RefNode::BinIdentifier(_) => write!(f, "BinIdentifier"), + RefNode::CIdentifier(_) => write!(f, "CIdentifier"), + RefNode::CellIdentifier(_) => write!(f, "CellIdentifier"), + RefNode::CheckerIdentifier(_) => write!(f, "CheckerIdentifier"), + RefNode::ClassIdentifier(_) => write!(f, "ClassIdentifier"), + RefNode::ClassVariableIdentifier(_) => write!(f, "ClassVariableIdentifier"), + RefNode::ClockingIdentifier(_) => write!(f, "ClockingIdentifier"), + RefNode::ConfigIdentifier(_) => write!(f, "ConfigIdentifier"), + RefNode::ConstIdentifier(_) => write!(f, "ConstIdentifier"), + RefNode::ConstraintIdentifier(_) => write!(f, "ConstraintIdentifier"), + RefNode::CovergroupIdentifier(_) => write!(f, "CovergroupIdentifier"), + RefNode::CovergroupVariableIdentifier(_) => write!(f, "CovergroupVariableIdentifier"), + RefNode::CoverPointIdentifier(_) => write!(f, "CoverPointIdentifier"), + RefNode::CrossIdentifier(_) => write!(f, "CrossIdentifier"), + RefNode::DynamicArrayVariableIdentifier(_) => { + write!(f, "DynamicArrayVariableIdentifier") + } + RefNode::EnumIdentifier(_) => write!(f, "EnumIdentifier"), + RefNode::EscapedIdentifier(_) => write!(f, "EscapedIdentifier"), + RefNode::FormalIdentifier(_) => write!(f, "FormalIdentifier"), + RefNode::FormalPortIdentifier(_) => write!(f, "FormalPortIdentifier"), + RefNode::FunctionIdentifier(_) => write!(f, "FunctionIdentifier"), + RefNode::GenerateBlockIdentifier(_) => write!(f, "GenerateBlockIdentifier"), + RefNode::GenvarIdentifier(_) => write!(f, "GenvarIdentifier"), + RefNode::HierarchicalArrayIdentifier(_) => write!(f, "HierarchicalArrayIdentifier"), + RefNode::HierarchicalBlockIdentifier(_) => write!(f, "HierarchicalBlockIdentifier"), + RefNode::HierarchicalEventIdentifier(_) => write!(f, "HierarchicalEventIdentifier"), + RefNode::HierarchicalIdentifier(_) => write!(f, "HierarchicalIdentifier"), + RefNode::Root(_) => write!(f, "Root"), + RefNode::HierarchicalNetIdentifier(_) => write!(f, "HierarchicalNetIdentifier"), + RefNode::HierarchicalParameterIdentifier(_) => { + write!(f, "HierarchicalParameterIdentifier") + } + RefNode::HierarchicalPropertyIdentifier(_) => { + write!(f, "HierarchicalPropertyIdentifier") + } + RefNode::HierarchicalSequenceIdentifier(_) => { + write!(f, "HierarchicalSequenceIdentifier") + } + RefNode::HierarchicalTaskIdentifier(_) => write!(f, "HierarchicalTaskIdentifier"), + RefNode::HierarchicalTfIdentifier(_) => write!(f, "HierarchicalTfIdentifier"), + RefNode::HierarchicalVariableIdentifier(_) => { + write!(f, "HierarchicalVariableIdentifier") + } + RefNode::Identifier(_) => write!(f, "Identifier"), + RefNode::IndexVariableIdentifier(_) => write!(f, "IndexVariableIdentifier"), + RefNode::InterfaceIdentifier(_) => write!(f, "InterfaceIdentifier"), + RefNode::InterfaceInstanceIdentifier(_) => write!(f, "InterfaceInstanceIdentifier"), + RefNode::InoutPortIdentifier(_) => write!(f, "InoutPortIdentifier"), + RefNode::InputPortIdentifier(_) => write!(f, "InputPortIdentifier"), + RefNode::InstanceIdentifier(_) => write!(f, "InstanceIdentifier"), + RefNode::LibraryIdentifier(_) => write!(f, "LibraryIdentifier"), + RefNode::MemberIdentifier(_) => write!(f, "MemberIdentifier"), + RefNode::MethodIdentifier(_) => write!(f, "MethodIdentifier"), + RefNode::ModportIdentifier(_) => write!(f, "ModportIdentifier"), + RefNode::ModuleIdentifier(_) => write!(f, "ModuleIdentifier"), + RefNode::NetIdentifier(_) => write!(f, "NetIdentifier"), + RefNode::NetTypeIdentifier(_) => write!(f, "NetTypeIdentifier"), + RefNode::OutputPortIdentifier(_) => write!(f, "OutputPortIdentifier"), + RefNode::PackageIdentifier(_) => write!(f, "PackageIdentifier"), + RefNode::PackageScope(_) => write!(f, "PackageScope"), + RefNode::PackageScopePackage(_) => write!(f, "PackageScopePackage"), + RefNode::Unit(_) => write!(f, "Unit"), + RefNode::ParameterIdentifier(_) => write!(f, "ParameterIdentifier"), + RefNode::PortIdentifier(_) => write!(f, "PortIdentifier"), + RefNode::ProductionIdentifier(_) => write!(f, "ProductionIdentifier"), + RefNode::ProgramIdentifier(_) => write!(f, "ProgramIdentifier"), + RefNode::PropertyIdentifier(_) => write!(f, "PropertyIdentifier"), + RefNode::PsClassIdentifier(_) => write!(f, "PsClassIdentifier"), + RefNode::PsCovergroupIdentifier(_) => write!(f, "PsCovergroupIdentifier"), + RefNode::PsCheckerIdentifier(_) => write!(f, "PsCheckerIdentifier"), + RefNode::PsIdentifier(_) => write!(f, "PsIdentifier"), + RefNode::PsOrHierarchicalArrayIdentifier(_) => { + write!(f, "PsOrHierarchicalArrayIdentifier") + } + RefNode::PsOrHierarchicalNetIdentifier(_) => write!(f, "PsOrHierarchicalNetIdentifier"), + RefNode::PsOrHierarchicalNetIdentifierPackageScope(_) => { + write!(f, "PsOrHierarchicalNetIdentifierPackageScope") + } + RefNode::PsOrHierarchicalNetIdentifierHierarchical(_) => { + write!(f, "PsOrHierarchicalNetIdentifierHierarchical") + } + RefNode::PsOrHierarchicalPropertyIdentifier(_) => { + write!(f, "PsOrHierarchicalPropertyIdentifier") + } + RefNode::PsOrHierarchicalPropertyIdentifierPackageScope(_) => { + write!(f, "PsOrHierarchicalPropertyIdentifierPackageScope") + } + RefNode::PsOrHierarchicalPropertyIdentifierHierarchical(_) => { + write!(f, "PsOrHierarchicalPropertyIdentifierHierarchical") + } + RefNode::PsOrHierarchicalSequenceIdentifier(_) => { + write!(f, "PsOrHierarchicalSequenceIdentifier") + } + RefNode::PsOrHierarchicalSequenceIdentifierPackageScope(_) => { + write!(f, "PsOrHierarchicalSequenceIdentifierPackageScope") + } + RefNode::PsOrHierarchicalSequenceIdentifierHierarchical(_) => { + write!(f, "PsOrHierarchicalSequenceIdentifierHierarchical") + } + RefNode::PsOrHierarchicalTfIdentifier(_) => write!(f, "PsOrHierarchicalTfIdentifier"), + RefNode::PsOrHierarchicalTfIdentifierPackageScope(_) => { + write!(f, "PsOrHierarchicalTfIdentifierPackageScope") + } + RefNode::PsOrHierarchicalTfIdentifierHierarchical(_) => { + write!(f, "PsOrHierarchicalTfIdentifierHierarchical") + } + RefNode::PsParameterIdentifier(_) => write!(f, "PsParameterIdentifier"), + RefNode::PsParameterIdentifierScope(_) => write!(f, "PsParameterIdentifierScope"), + RefNode::PsParameterIdentifierGenerate(_) => write!(f, "PsParameterIdentifierGenerate"), + RefNode::PsTypeIdentifier(_) => write!(f, "PsTypeIdentifier"), + RefNode::LocalOrPackageScopeOrClassScope(_) => { + write!(f, "LocalOrPackageScopeOrClassScope") + } + RefNode::Local(_) => write!(f, "Local"), + RefNode::SequenceIdentifier(_) => write!(f, "SequenceIdentifier"), + RefNode::SignalIdentifier(_) => write!(f, "SignalIdentifier"), + RefNode::SimpleIdentifier(_) => write!(f, "SimpleIdentifier"), + RefNode::SpecparamIdentifier(_) => write!(f, "SpecparamIdentifier"), + RefNode::SystemTfIdentifier(_) => write!(f, "SystemTfIdentifier"), + RefNode::TaskIdentifier(_) => write!(f, "TaskIdentifier"), + RefNode::TfIdentifier(_) => write!(f, "TfIdentifier"), + RefNode::TerminalIdentifier(_) => write!(f, "TerminalIdentifier"), + RefNode::TopmoduleIdentifier(_) => write!(f, "TopmoduleIdentifier"), + RefNode::TypeIdentifier(_) => write!(f, "TypeIdentifier"), + RefNode::UdpIdentifier(_) => write!(f, "UdpIdentifier"), + RefNode::VariableIdentifier(_) => write!(f, "VariableIdentifier"), + RefNode::ImplicitClassHandleOrClassScopeOrPackageScope(_) => { + write!(f, "ImplicitClassHandleOrClassScopeOrPackageScope") + } + RefNode::ImplicitClassHandleOrPackageScope(_) => { + write!(f, "ImplicitClassHandleOrPackageScope") + } + RefNode::ImplicitClassHandleOrClassScope(_) => { + write!(f, "ImplicitClassHandleOrClassScope") + } + RefNode::PackageScopeOrClassScope(_) => write!(f, "PackageScopeOrClassScope"), + RefNode::CompilerDirective(_) => write!(f, "CompilerDirective"), + RefNode::ResetallCompilerDirective(_) => write!(f, "ResetallCompilerDirective"), + RefNode::IncludeCompilerDirective(_) => write!(f, "IncludeCompilerDirective"), + RefNode::IncludeCompilerDirectiveDoubleQuote(_) => { + write!(f, "IncludeCompilerDirectiveDoubleQuote") + } + RefNode::IncludeCompilerDirectiveAngleBracket(_) => { + write!(f, "IncludeCompilerDirectiveAngleBracket") + } + RefNode::IncludeCompilerDirectiveTextMacroUsage(_) => { + write!(f, "IncludeCompilerDirectiveTextMacroUsage") + } + RefNode::AngleBracketLiteral(_) => write!(f, "AngleBracketLiteral"), + RefNode::TextMacroDefinition(_) => write!(f, "TextMacroDefinition"), + RefNode::TextMacroName(_) => write!(f, "TextMacroName"), + RefNode::ListOfFormalArguments(_) => write!(f, "ListOfFormalArguments"), + RefNode::FormalArgument(_) => write!(f, "FormalArgument"), + RefNode::TextMacroIdentifier(_) => write!(f, "TextMacroIdentifier"), + RefNode::MacroText(_) => write!(f, "MacroText"), + RefNode::DefaultText(_) => write!(f, "DefaultText"), + RefNode::TextMacroUsage(_) => write!(f, "TextMacroUsage"), + RefNode::ListOfActualArguments(_) => write!(f, "ListOfActualArguments"), + RefNode::ActualArgument(_) => write!(f, "ActualArgument"), + RefNode::UndefineCompilerDirective(_) => write!(f, "UndefineCompilerDirective"), + RefNode::UndefineallCompilerDirective(_) => write!(f, "UndefineallCompilerDirective"), + RefNode::ConditionalCompilerDirective(_) => write!(f, "ConditionalCompilerDirective"), + RefNode::IfdefDirective(_) => write!(f, "IfdefDirective"), + RefNode::IfndefDirective(_) => write!(f, "IfndefDirective"), + RefNode::IfdefGroupOfLines(_) => write!(f, "IfdefGroupOfLines"), + RefNode::IfndefGroupOfLines(_) => write!(f, "IfndefGroupOfLines"), + RefNode::ElsifGroupOfLines(_) => write!(f, "ElsifGroupOfLines"), + RefNode::ElseGroupOfLines(_) => write!(f, "ElseGroupOfLines"), + RefNode::SourceDescription(_) => write!(f, "SourceDescription"), + RefNode::SourceDescriptionNotDirective(_) => write!(f, "SourceDescriptionNotDirective"), + RefNode::TimescaleCompilerDirective(_) => write!(f, "TimescaleCompilerDirective"), + RefNode::DefaultNettypeCompilerDirective(_) => { + write!(f, "DefaultNettypeCompilerDirective") + } + RefNode::DefaultNettypeValue(_) => write!(f, "DefaultNettypeValue"), + RefNode::UnconnectedDriveCompilerDirective(_) => { + write!(f, "UnconnectedDriveCompilerDirective") + } + RefNode::NounconnectedDriveCompilerDirective(_) => { + write!(f, "NounconnectedDriveCompilerDirective") + } + RefNode::CelldefineDriveCompilerDirective(_) => { + write!(f, "CelldefineDriveCompilerDirective") + } + RefNode::EndcelldefineDriveCompilerDirective(_) => { + write!(f, "EndcelldefineDriveCompilerDirective") + } + RefNode::Pragma(_) => write!(f, "Pragma"), + RefNode::PragmaName(_) => write!(f, "PragmaName"), + RefNode::PragmaExpression(_) => write!(f, "PragmaExpression"), + RefNode::PragmaExpressionAssignment(_) => write!(f, "PragmaExpressionAssignment"), + RefNode::PragmaValue(_) => write!(f, "PragmaValue"), + RefNode::PragmaValueParen(_) => write!(f, "PragmaValueParen"), + RefNode::PragmaKeyword(_) => write!(f, "PragmaKeyword"), + RefNode::LineCompilerDirective(_) => write!(f, "LineCompilerDirective"), + RefNode::PositionCompilerDirective(_) => write!(f, "PositionCompilerDirective"), + RefNode::Level(_) => write!(f, "Level"), + RefNode::KeywordsDirective(_) => write!(f, "KeywordsDirective"), + RefNode::VersionSpecifier(_) => write!(f, "VersionSpecifier"), + RefNode::EndkeywordsDirective(_) => write!(f, "EndkeywordsDirective"), + RefNode::DriveStrength(_) => write!(f, "DriveStrength"), + RefNode::DriveStrength01(_) => write!(f, "DriveStrength01"), + RefNode::DriveStrength10(_) => write!(f, "DriveStrength10"), + RefNode::DriveStrength0z(_) => write!(f, "DriveStrength0z"), + RefNode::DriveStrength1z(_) => write!(f, "DriveStrength1z"), + RefNode::DriveStrengthz1(_) => write!(f, "DriveStrengthz1"), + RefNode::DriveStrengthz0(_) => write!(f, "DriveStrengthz0"), + RefNode::Strength0(_) => write!(f, "Strength0"), + RefNode::Strength1(_) => write!(f, "Strength1"), + RefNode::ChargeStrength(_) => write!(f, "ChargeStrength"), + RefNode::ChargeStrengthSmall(_) => write!(f, "ChargeStrengthSmall"), + RefNode::ChargeStrengthMedium(_) => write!(f, "ChargeStrengthMedium"), + RefNode::ChargeStrengthLarge(_) => write!(f, "ChargeStrengthLarge"), + RefNode::ModportDeclaration(_) => write!(f, "ModportDeclaration"), + RefNode::ModportItem(_) => write!(f, "ModportItem"), + RefNode::ModportPortsDeclaration(_) => write!(f, "ModportPortsDeclaration"), + RefNode::ModportPortsDeclarationSimple(_) => write!(f, "ModportPortsDeclarationSimple"), + RefNode::ModportPortsDeclarationTf(_) => write!(f, "ModportPortsDeclarationTf"), + RefNode::ModportPortsDeclarationClocking(_) => { + write!(f, "ModportPortsDeclarationClocking") + } + RefNode::ModportClockingDeclaration(_) => write!(f, "ModportClockingDeclaration"), + RefNode::ModportSimplePortsDeclaration(_) => write!(f, "ModportSimplePortsDeclaration"), + RefNode::ModportSimplePort(_) => write!(f, "ModportSimplePort"), + RefNode::ModportSimplePortOrdered(_) => write!(f, "ModportSimplePortOrdered"), + RefNode::ModportSimplePortNamed(_) => write!(f, "ModportSimplePortNamed"), + RefNode::ModportTfPortsDeclaration(_) => write!(f, "ModportTfPortsDeclaration"), + RefNode::ModportTfPort(_) => write!(f, "ModportTfPort"), + RefNode::ImportExport(_) => write!(f, "ImportExport"), + RefNode::FunctionDataTypeOrImplicit(_) => write!(f, "FunctionDataTypeOrImplicit"), + RefNode::FunctionDeclaration(_) => write!(f, "FunctionDeclaration"), + RefNode::FunctionBodyDeclaration(_) => write!(f, "FunctionBodyDeclaration"), + RefNode::FunctionBodyDeclarationWithoutPort(_) => { + write!(f, "FunctionBodyDeclarationWithoutPort") + } + RefNode::FunctionBodyDeclarationWithPort(_) => { + write!(f, "FunctionBodyDeclarationWithPort") + } + RefNode::InterfaceIdentifierOrClassScope(_) => { + write!(f, "InterfaceIdentifierOrClassScope") + } + RefNode::FunctionPrototype(_) => write!(f, "FunctionPrototype"), + RefNode::DpiImportExport(_) => write!(f, "DpiImportExport"), + RefNode::DpiImportExportImportFunction(_) => write!(f, "DpiImportExportImportFunction"), + RefNode::DpiImportExportImportTask(_) => write!(f, "DpiImportExportImportTask"), + RefNode::DpiImportExportExportFunction(_) => write!(f, "DpiImportExportExportFunction"), + RefNode::DpiImportExportExportTask(_) => write!(f, "DpiImportExportExportTask"), + RefNode::DpiSpecString(_) => write!(f, "DpiSpecString"), + RefNode::DpiFunctionImportProperty(_) => write!(f, "DpiFunctionImportProperty"), + RefNode::DpiTaskImportProperty(_) => write!(f, "DpiTaskImportProperty"), + RefNode::DpiFunctionProto(_) => write!(f, "DpiFunctionProto"), + RefNode::DpiTaskProto(_) => write!(f, "DpiTaskProto"), + RefNode::CovergroupDeclaration(_) => write!(f, "CovergroupDeclaration"), + RefNode::CoverageSpecOrOption(_) => write!(f, "CoverageSpecOrOption"), + RefNode::CoverageSpecOrOptionSpec(_) => write!(f, "CoverageSpecOrOptionSpec"), + RefNode::CoverageSpecOrOptionOption(_) => write!(f, "CoverageSpecOrOptionOption"), + RefNode::CoverageOption(_) => write!(f, "CoverageOption"), + RefNode::CoverageOptionOption(_) => write!(f, "CoverageOptionOption"), + RefNode::CoverageOptionTypeOption(_) => write!(f, "CoverageOptionTypeOption"), + RefNode::CoverageSpec(_) => write!(f, "CoverageSpec"), + RefNode::CoverageEvent(_) => write!(f, "CoverageEvent"), + RefNode::CoverageEventSample(_) => write!(f, "CoverageEventSample"), + RefNode::CoverageEventAt(_) => write!(f, "CoverageEventAt"), + RefNode::BlockEventExpression(_) => write!(f, "BlockEventExpression"), + RefNode::BlockEventExpressionOr(_) => write!(f, "BlockEventExpressionOr"), + RefNode::BlockEventExpressionBegin(_) => write!(f, "BlockEventExpressionBegin"), + RefNode::BlockEventExpressionEnd(_) => write!(f, "BlockEventExpressionEnd"), + RefNode::HierarchicalBtfIdentifier(_) => write!(f, "HierarchicalBtfIdentifier"), + RefNode::HierarchicalBtfIdentifierMethod(_) => { + write!(f, "HierarchicalBtfIdentifierMethod") + } + RefNode::HierarchicalIdentifierOrClassScope(_) => { + write!(f, "HierarchicalIdentifierOrClassScope") + } + RefNode::CoverPoint(_) => write!(f, "CoverPoint"), + RefNode::BinsOrEmpty(_) => write!(f, "BinsOrEmpty"), + RefNode::BinsOrEmptyNonEmpty(_) => write!(f, "BinsOrEmptyNonEmpty"), + RefNode::BinsOrOptions(_) => write!(f, "BinsOrOptions"), + RefNode::BinsOrOptionsCovergroup(_) => write!(f, "BinsOrOptionsCovergroup"), + RefNode::Wildcard(_) => write!(f, "Wildcard"), + RefNode::BinsOrOptionsCoverPoint(_) => write!(f, "BinsOrOptionsCoverPoint"), + RefNode::BinsOrOptionsSetCovergroup(_) => write!(f, "BinsOrOptionsSetCovergroup"), + RefNode::BinsOrOptionsTransList(_) => write!(f, "BinsOrOptionsTransList"), + RefNode::BinsOrOptionsDefault(_) => write!(f, "BinsOrOptionsDefault"), + RefNode::BinsOrOptionsDefaultSequence(_) => write!(f, "BinsOrOptionsDefaultSequence"), + RefNode::BinsKeyword(_) => write!(f, "BinsKeyword"), + RefNode::TransList(_) => write!(f, "TransList"), + RefNode::TransSet(_) => write!(f, "TransSet"), + RefNode::TransRangeList(_) => write!(f, "TransRangeList"), + RefNode::TransRangeListAsterisk(_) => write!(f, "TransRangeListAsterisk"), + RefNode::TransRangeListArrow(_) => write!(f, "TransRangeListArrow"), + RefNode::TransRangeListEqual(_) => write!(f, "TransRangeListEqual"), + RefNode::TransItem(_) => write!(f, "TransItem"), + RefNode::RepeatRange(_) => write!(f, "RepeatRange"), + RefNode::RepeatRangeBinary(_) => write!(f, "RepeatRangeBinary"), + RefNode::CoverCross(_) => write!(f, "CoverCross"), + RefNode::ListOfCrossItems(_) => write!(f, "ListOfCrossItems"), + RefNode::CrossItem(_) => write!(f, "CrossItem"), + RefNode::CrossBody(_) => write!(f, "CrossBody"), + RefNode::CrossBodyNonEmpty(_) => write!(f, "CrossBodyNonEmpty"), + RefNode::CrossBodyItem(_) => write!(f, "CrossBodyItem"), + RefNode::BinsSelectionOrOption(_) => write!(f, "BinsSelectionOrOption"), + RefNode::BinsSelectionOrOptionCoverage(_) => write!(f, "BinsSelectionOrOptionCoverage"), + RefNode::BinsSelectionOrOptionBins(_) => write!(f, "BinsSelectionOrOptionBins"), + RefNode::BinsSelection(_) => write!(f, "BinsSelection"), + RefNode::SelectExpression(_) => write!(f, "SelectExpression"), + RefNode::SelectExpressionNot(_) => write!(f, "SelectExpressionNot"), + RefNode::SelectExpressionAnd(_) => write!(f, "SelectExpressionAnd"), + RefNode::SelectExpressionOr(_) => write!(f, "SelectExpressionOr"), + RefNode::SelectExpressionParen(_) => write!(f, "SelectExpressionParen"), + RefNode::SelectExpressionWith(_) => write!(f, "SelectExpressionWith"), + RefNode::SelectExpressionCrossSet(_) => write!(f, "SelectExpressionCrossSet"), + RefNode::SelectCondition(_) => write!(f, "SelectCondition"), + RefNode::BinsExpression(_) => write!(f, "BinsExpression"), + RefNode::BinsExpressionCoverPoint(_) => write!(f, "BinsExpressionCoverPoint"), + RefNode::CovergroupRangeList(_) => write!(f, "CovergroupRangeList"), + RefNode::CovergroupValueRange(_) => write!(f, "CovergroupValueRange"), + RefNode::CovergroupValueRangeBinary(_) => write!(f, "CovergroupValueRangeBinary"), + RefNode::WithCovergroupExpression(_) => write!(f, "WithCovergroupExpression"), + RefNode::SetCovergroupExpression(_) => write!(f, "SetCovergroupExpression"), + RefNode::IntegerCovergroupExpression(_) => write!(f, "IntegerCovergroupExpression"), + RefNode::CrossSetExpression(_) => write!(f, "CrossSetExpression"), + RefNode::CovergroupExpression(_) => write!(f, "CovergroupExpression"), + RefNode::DataDeclaration(_) => write!(f, "DataDeclaration"), + RefNode::DataDeclarationVariable(_) => write!(f, "DataDeclarationVariable"), + RefNode::Const(_) => write!(f, "Const"), + RefNode::PackageImportDeclaration(_) => write!(f, "PackageImportDeclaration"), + RefNode::PackageImportItem(_) => write!(f, "PackageImportItem"), + RefNode::PackageImportItemIdentifier(_) => write!(f, "PackageImportItemIdentifier"), + RefNode::PackageImportItemAsterisk(_) => write!(f, "PackageImportItemAsterisk"), + RefNode::PackageExportDeclaration(_) => write!(f, "PackageExportDeclaration"), + RefNode::PackageExportDeclarationAsterisk(_) => { + write!(f, "PackageExportDeclarationAsterisk") + } + RefNode::PackageExportDeclarationItem(_) => write!(f, "PackageExportDeclarationItem"), + RefNode::GenvarDeclaration(_) => write!(f, "GenvarDeclaration"), + RefNode::NetDeclaration(_) => write!(f, "NetDeclaration"), + RefNode::NetDeclarationNetType(_) => write!(f, "NetDeclarationNetType"), + RefNode::Strength(_) => write!(f, "Strength"), + RefNode::VectorScalar(_) => write!(f, "VectorScalar"), + RefNode::NetDeclarationNetTypeIdentifier(_) => { + write!(f, "NetDeclarationNetTypeIdentifier") + } + RefNode::NetDeclarationInterconnect(_) => write!(f, "NetDeclarationInterconnect"), + RefNode::TypeDeclaration(_) => write!(f, "TypeDeclaration"), + RefNode::TypeDeclarationDataType(_) => write!(f, "TypeDeclarationDataType"), + RefNode::TypeDeclarationInterface(_) => write!(f, "TypeDeclarationInterface"), + RefNode::TypeDeclarationReserved(_) => write!(f, "TypeDeclarationReserved"), + RefNode::TypeDeclarationKeyword(_) => write!(f, "TypeDeclarationKeyword"), + RefNode::NetTypeDeclaration(_) => write!(f, "NetTypeDeclaration"), + RefNode::NetTypeDeclarationDataType(_) => write!(f, "NetTypeDeclarationDataType"), + RefNode::NetTypeDeclarationNetType(_) => write!(f, "NetTypeDeclarationNetType"), + RefNode::Lifetime(_) => write!(f, "Lifetime"), + RefNode::ConcurrentAssertionItem(_) => write!(f, "ConcurrentAssertionItem"), + RefNode::ConcurrentAssertionItemStatement(_) => { + write!(f, "ConcurrentAssertionItemStatement") + } + RefNode::ConcurrentAssertionStatement(_) => write!(f, "ConcurrentAssertionStatement"), + RefNode::AssertPropertyStatement(_) => write!(f, "AssertPropertyStatement"), + RefNode::AssumePropertyStatement(_) => write!(f, "AssumePropertyStatement"), + RefNode::CoverPropertyStatement(_) => write!(f, "CoverPropertyStatement"), + RefNode::ExpectPropertyStatement(_) => write!(f, "ExpectPropertyStatement"), + RefNode::CoverSequenceStatement(_) => write!(f, "CoverSequenceStatement"), + RefNode::RestrictPropertyStatement(_) => write!(f, "RestrictPropertyStatement"), + RefNode::PropertyInstance(_) => write!(f, "PropertyInstance"), + RefNode::PropertyListOfArguments(_) => write!(f, "PropertyListOfArguments"), + RefNode::PropertyListOfArgumentsOrdered(_) => { + write!(f, "PropertyListOfArgumentsOrdered") + } + RefNode::PropertyListOfArgumentsNamed(_) => write!(f, "PropertyListOfArgumentsNamed"), + RefNode::PropertyActualArg(_) => write!(f, "PropertyActualArg"), + RefNode::AssertionItemDeclaration(_) => write!(f, "AssertionItemDeclaration"), + RefNode::PropertyDeclaration(_) => write!(f, "PropertyDeclaration"), + RefNode::PropertyPortList(_) => write!(f, "PropertyPortList"), + RefNode::PropertyPortItem(_) => write!(f, "PropertyPortItem"), + RefNode::PropertyLvarPortDirection(_) => write!(f, "PropertyLvarPortDirection"), + RefNode::PropertyFormalType(_) => write!(f, "PropertyFormalType"), + RefNode::PropertySpec(_) => write!(f, "PropertySpec"), + RefNode::PropertyExpr(_) => write!(f, "PropertyExpr"), + RefNode::PropertyExprStrong(_) => write!(f, "PropertyExprStrong"), + RefNode::PropertyExprWeak(_) => write!(f, "PropertyExprWeak"), + RefNode::PropertyExprParen(_) => write!(f, "PropertyExprParen"), + RefNode::PropertyExprNot(_) => write!(f, "PropertyExprNot"), + RefNode::PropertyExprBinaryProperty(_) => write!(f, "PropertyExprBinaryProperty"), + RefNode::PropertyExprBinarySequence(_) => write!(f, "PropertyExprBinarySequence"), + RefNode::PropertyExprIf(_) => write!(f, "PropertyExprIf"), + RefNode::PropertyExprCase(_) => write!(f, "PropertyExprCase"), + RefNode::PropertyExprNexttime(_) => write!(f, "PropertyExprNexttime"), + RefNode::PropertyExprSNexttime(_) => write!(f, "PropertyExprSNexttime"), + RefNode::PropertyExprAlways(_) => write!(f, "PropertyExprAlways"), + RefNode::PropertyExprSAlways(_) => write!(f, "PropertyExprSAlways"), + RefNode::PropertyExprEventually(_) => write!(f, "PropertyExprEventually"), + RefNode::PropertyExprSEventually(_) => write!(f, "PropertyExprSEventually"), + RefNode::PropertyExprAcceptOn(_) => write!(f, "PropertyExprAcceptOn"), + RefNode::PropertyExprRejectOn(_) => write!(f, "PropertyExprRejectOn"), + RefNode::PropertyExprSyncAcceptOn(_) => write!(f, "PropertyExprSyncAcceptOn"), + RefNode::PropertyExprSyncRejectOn(_) => write!(f, "PropertyExprSyncRejectOn"), + RefNode::PropertyExprClockingEvent(_) => write!(f, "PropertyExprClockingEvent"), + RefNode::PropertyCaseItem(_) => write!(f, "PropertyCaseItem"), + RefNode::PropertyCaseItemNondefault(_) => write!(f, "PropertyCaseItemNondefault"), + RefNode::PropertyCaseItemDefault(_) => write!(f, "PropertyCaseItemDefault"), + RefNode::SequenceDeclaration(_) => write!(f, "SequenceDeclaration"), + RefNode::SequencePortList(_) => write!(f, "SequencePortList"), + RefNode::SequencePortItem(_) => write!(f, "SequencePortItem"), + RefNode::SequenceLvarPortDirection(_) => write!(f, "SequenceLvarPortDirection"), + RefNode::SequenceFormalType(_) => write!(f, "SequenceFormalType"), + RefNode::SequenceExpr(_) => write!(f, "SequenceExpr"), + RefNode::SequenceExprCycleDelayExpr(_) => write!(f, "SequenceExprCycleDelayExpr"), + RefNode::SequenceExprExprCycleDelayExpr(_) => { + write!(f, "SequenceExprExprCycleDelayExpr") + } + RefNode::SequenceExprExpression(_) => write!(f, "SequenceExprExpression"), + RefNode::SequenceExprInstance(_) => write!(f, "SequenceExprInstance"), + RefNode::SequenceExprParen(_) => write!(f, "SequenceExprParen"), + RefNode::SequenceExprBinary(_) => write!(f, "SequenceExprBinary"), + RefNode::SequenceExprFirstMatch(_) => write!(f, "SequenceExprFirstMatch"), + RefNode::SequenceExprThroughout(_) => write!(f, "SequenceExprThroughout"), + RefNode::SequenceExprClockingEvent(_) => write!(f, "SequenceExprClockingEvent"), + RefNode::CycleDelayRange(_) => write!(f, "CycleDelayRange"), + RefNode::CycleDelayRangePrimary(_) => write!(f, "CycleDelayRangePrimary"), + RefNode::CycleDelayRangeExpression(_) => write!(f, "CycleDelayRangeExpression"), + RefNode::CycleDelayRangeAsterisk(_) => write!(f, "CycleDelayRangeAsterisk"), + RefNode::CycleDelayRangePlus(_) => write!(f, "CycleDelayRangePlus"), + RefNode::SequenceMethodCall(_) => write!(f, "SequenceMethodCall"), + RefNode::SequenceMatchItem(_) => write!(f, "SequenceMatchItem"), + RefNode::SequenceInstance(_) => write!(f, "SequenceInstance"), + RefNode::SequenceListOfArguments(_) => write!(f, "SequenceListOfArguments"), + RefNode::SequenceListOfArgumentsOrdered(_) => { + write!(f, "SequenceListOfArgumentsOrdered") + } + RefNode::SequenceListOfArgumentsNamed(_) => write!(f, "SequenceListOfArgumentsNamed"), + RefNode::SequenceActualArg(_) => write!(f, "SequenceActualArg"), + RefNode::BooleanAbbrev(_) => write!(f, "BooleanAbbrev"), + RefNode::SequenceAbbrev(_) => write!(f, "SequenceAbbrev"), + RefNode::ConsecutiveRepetition(_) => write!(f, "ConsecutiveRepetition"), + RefNode::ConsecutiveRepetitionExpression(_) => { + write!(f, "ConsecutiveRepetitionExpression") + } + RefNode::ConsecutiveRepetitionAsterisk(_) => write!(f, "ConsecutiveRepetitionAsterisk"), + RefNode::ConsecutiveRepetitionPlus(_) => write!(f, "ConsecutiveRepetitionPlus"), + RefNode::NonConsecutiveRepetition(_) => write!(f, "NonConsecutiveRepetition"), + RefNode::GotoRepetition(_) => write!(f, "GotoRepetition"), + RefNode::ConstOrRangeExpression(_) => write!(f, "ConstOrRangeExpression"), + RefNode::CycleDelayConstRangeExpression(_) => { + write!(f, "CycleDelayConstRangeExpression") + } + RefNode::CycleDelayConstRangeExpressionBinary(_) => { + write!(f, "CycleDelayConstRangeExpressionBinary") + } + RefNode::CycleDelayConstRangeExpressionDollar(_) => { + write!(f, "CycleDelayConstRangeExpressionDollar") + } + RefNode::ExpressionOrDist(_) => write!(f, "ExpressionOrDist"), + RefNode::AssertionVariableDeclaration(_) => write!(f, "AssertionVariableDeclaration"), + RefNode::LetDeclaration(_) => write!(f, "LetDeclaration"), + RefNode::LetIdentifier(_) => write!(f, "LetIdentifier"), + RefNode::LetPortList(_) => write!(f, "LetPortList"), + RefNode::LetPortItem(_) => write!(f, "LetPortItem"), + RefNode::LetFormalType(_) => write!(f, "LetFormalType"), + RefNode::LetExpression(_) => write!(f, "LetExpression"), + RefNode::LetListOfArguments(_) => write!(f, "LetListOfArguments"), + RefNode::LetListOfArgumentsOrdered(_) => write!(f, "LetListOfArgumentsOrdered"), + RefNode::LetListOfArgumentsNamed(_) => write!(f, "LetListOfArgumentsNamed"), + RefNode::LetActualArg(_) => write!(f, "LetActualArg"), + RefNode::CastingType(_) => write!(f, "CastingType"), + RefNode::DataType(_) => write!(f, "DataType"), + RefNode::DataTypeVector(_) => write!(f, "DataTypeVector"), + RefNode::DataTypeAtom(_) => write!(f, "DataTypeAtom"), + RefNode::DataTypeStructUnion(_) => write!(f, "DataTypeStructUnion"), + RefNode::Packed(_) => write!(f, "Packed"), + RefNode::DataTypeEnum(_) => write!(f, "DataTypeEnum"), + RefNode::DataTypeVirtual(_) => write!(f, "DataTypeVirtual"), + RefNode::Interface(_) => write!(f, "Interface"), + RefNode::DataTypeType(_) => write!(f, "DataTypeType"), + RefNode::DataTypeOrImplicit(_) => write!(f, "DataTypeOrImplicit"), + RefNode::ImplicitDataType(_) => write!(f, "ImplicitDataType"), + RefNode::EnumBaseType(_) => write!(f, "EnumBaseType"), + RefNode::EnumBaseTypeAtom(_) => write!(f, "EnumBaseTypeAtom"), + RefNode::EnumBaseTypeVector(_) => write!(f, "EnumBaseTypeVector"), + RefNode::EnumBaseTypeType(_) => write!(f, "EnumBaseTypeType"), + RefNode::EnumNameDeclaration(_) => write!(f, "EnumNameDeclaration"), + RefNode::ClassScope(_) => write!(f, "ClassScope"), + RefNode::ClassType(_) => write!(f, "ClassType"), + RefNode::IntegerType(_) => write!(f, "IntegerType"), + RefNode::IntegerAtomType(_) => write!(f, "IntegerAtomType"), + RefNode::IntegerVectorType(_) => write!(f, "IntegerVectorType"), + RefNode::NonIntegerType(_) => write!(f, "NonIntegerType"), + RefNode::NetType(_) => write!(f, "NetType"), + RefNode::NetPortType(_) => write!(f, "NetPortType"), + RefNode::NetPortTypeDataType(_) => write!(f, "NetPortTypeDataType"), + RefNode::NetPortTypeInterconnect(_) => write!(f, "NetPortTypeInterconnect"), + RefNode::VariablePortType(_) => write!(f, "VariablePortType"), + RefNode::VarDataType(_) => write!(f, "VarDataType"), + RefNode::VarDataTypeVar(_) => write!(f, "VarDataTypeVar"), + RefNode::Signing(_) => write!(f, "Signing"), + RefNode::SimpleType(_) => write!(f, "SimpleType"), + RefNode::StructUnionMember(_) => write!(f, "StructUnionMember"), + RefNode::DataTypeOrVoid(_) => write!(f, "DataTypeOrVoid"), + RefNode::StructUnion(_) => write!(f, "StructUnion"), + RefNode::TypeReference(_) => write!(f, "TypeReference"), + RefNode::TypeReferenceExpression(_) => write!(f, "TypeReferenceExpression"), + RefNode::TypeReferenceDataType(_) => write!(f, "TypeReferenceDataType"), + RefNode::LocalParameterDeclaration(_) => write!(f, "LocalParameterDeclaration"), + RefNode::LocalParameterDeclarationParam(_) => { + write!(f, "LocalParameterDeclarationParam") + } + RefNode::LocalParameterDeclarationType(_) => write!(f, "LocalParameterDeclarationType"), + RefNode::ParameterDeclaration(_) => write!(f, "ParameterDeclaration"), + RefNode::ParameterDeclarationParam(_) => write!(f, "ParameterDeclarationParam"), + RefNode::ParameterDeclarationType(_) => write!(f, "ParameterDeclarationType"), + RefNode::SpecparamDeclaration(_) => write!(f, "SpecparamDeclaration"), + RefNode::BlockItemDeclaration(_) => write!(f, "BlockItemDeclaration"), + RefNode::BlockItemDeclarationData(_) => write!(f, "BlockItemDeclarationData"), + RefNode::BlockItemDeclarationLocalParameter(_) => { + write!(f, "BlockItemDeclarationLocalParameter") + } + RefNode::BlockItemDeclarationParameter(_) => write!(f, "BlockItemDeclarationParameter"), + RefNode::BlockItemDeclarationLet(_) => write!(f, "BlockItemDeclarationLet"), + RefNode::ListOfDefparamAssignments(_) => write!(f, "ListOfDefparamAssignments"), + RefNode::ListOfGenvarIdentifiers(_) => write!(f, "ListOfGenvarIdentifiers"), + RefNode::ListOfInterfaceIdentifiers(_) => write!(f, "ListOfInterfaceIdentifiers"), + RefNode::ListOfNetDeclAssignments(_) => write!(f, "ListOfNetDeclAssignments"), + RefNode::ListOfParamAssignments(_) => write!(f, "ListOfParamAssignments"), + RefNode::ListOfPortIdentifiers(_) => write!(f, "ListOfPortIdentifiers"), + RefNode::ListOfUdpPortIdentifiers(_) => write!(f, "ListOfUdpPortIdentifiers"), + RefNode::ListOfSpecparamAssignments(_) => write!(f, "ListOfSpecparamAssignments"), + RefNode::ListOfTfVariableIdentifiers(_) => write!(f, "ListOfTfVariableIdentifiers"), + RefNode::ListOfTypeAssignments(_) => write!(f, "ListOfTypeAssignments"), + RefNode::ListOfVariableDeclAssignments(_) => write!(f, "ListOfVariableDeclAssignments"), + RefNode::ListOfVariableIdentifiers(_) => write!(f, "ListOfVariableIdentifiers"), + RefNode::ListOfVariablePortIdentifiers(_) => write!(f, "ListOfVariablePortIdentifiers"), + RefNode::DefparamAssignment(_) => write!(f, "DefparamAssignment"), + RefNode::NetDeclAssignment(_) => write!(f, "NetDeclAssignment"), + RefNode::ParamAssignment(_) => write!(f, "ParamAssignment"), + RefNode::SpecparamAssignment(_) => write!(f, "SpecparamAssignment"), + RefNode::SpecparamAssignmentMintypmax(_) => write!(f, "SpecparamAssignmentMintypmax"), + RefNode::TypeAssignment(_) => write!(f, "TypeAssignment"), + RefNode::PulseControlSpecparam(_) => write!(f, "PulseControlSpecparam"), + RefNode::PulseControlSpecparamWithoutDescriptor(_) => { + write!(f, "PulseControlSpecparamWithoutDescriptor") + } + RefNode::PulseControlSpecparamWithDescriptor(_) => { + write!(f, "PulseControlSpecparamWithDescriptor") + } + RefNode::ErrorLimitValue(_) => write!(f, "ErrorLimitValue"), + RefNode::RejectLimitValue(_) => write!(f, "RejectLimitValue"), + RefNode::LimitValue(_) => write!(f, "LimitValue"), + RefNode::VariableDeclAssignment(_) => write!(f, "VariableDeclAssignment"), + RefNode::VariableDeclAssignmentVariable(_) => { + write!(f, "VariableDeclAssignmentVariable") + } + RefNode::VariableDeclAssignmentDynamicArray(_) => { + write!(f, "VariableDeclAssignmentDynamicArray") + } + RefNode::VariableDeclAssignmentClass(_) => write!(f, "VariableDeclAssignmentClass"), + RefNode::ClassNew(_) => write!(f, "ClassNew"), + RefNode::ClassNewArgument(_) => write!(f, "ClassNewArgument"), + RefNode::ClassNewExpression(_) => write!(f, "ClassNewExpression"), + RefNode::DynamicArrayNew(_) => write!(f, "DynamicArrayNew"), + RefNode::UnpackedDimension(_) => write!(f, "UnpackedDimension"), + RefNode::UnpackedDimensionRange(_) => write!(f, "UnpackedDimensionRange"), + RefNode::UnpackedDimensionExpression(_) => write!(f, "UnpackedDimensionExpression"), + RefNode::PackedDimension(_) => write!(f, "PackedDimension"), + RefNode::PackedDimensionRange(_) => write!(f, "PackedDimensionRange"), + RefNode::AssociativeDimension(_) => write!(f, "AssociativeDimension"), + RefNode::AssociativeDimensionDataType(_) => write!(f, "AssociativeDimensionDataType"), + RefNode::AssociativeDimensionAsterisk(_) => write!(f, "AssociativeDimensionAsterisk"), + RefNode::VariableDimension(_) => write!(f, "VariableDimension"), + RefNode::QueueDimension(_) => write!(f, "QueueDimension"), + RefNode::UnsizedDimension(_) => write!(f, "UnsizedDimension"), + RefNode::Delay3(_) => write!(f, "Delay3"), + RefNode::Delay3Single(_) => write!(f, "Delay3Single"), + RefNode::Delay3Mintypmax(_) => write!(f, "Delay3Mintypmax"), + RefNode::Delay2(_) => write!(f, "Delay2"), + RefNode::Delay2Single(_) => write!(f, "Delay2Single"), + RefNode::Delay2Mintypmax(_) => write!(f, "Delay2Mintypmax"), + RefNode::DelayValue(_) => write!(f, "DelayValue"), + RefNode::TaskDeclaration(_) => write!(f, "TaskDeclaration"), + RefNode::TaskBodyDeclaration(_) => write!(f, "TaskBodyDeclaration"), + RefNode::TaskBodyDeclarationWithoutPort(_) => { + write!(f, "TaskBodyDeclarationWithoutPort") + } + RefNode::TaskBodyDeclarationWithPort(_) => write!(f, "TaskBodyDeclarationWithPort"), + RefNode::TfItemDeclaration(_) => write!(f, "TfItemDeclaration"), + RefNode::TfPortList(_) => write!(f, "TfPortList"), + RefNode::TfPortItem(_) => write!(f, "TfPortItem"), + RefNode::TfPortDirection(_) => write!(f, "TfPortDirection"), + RefNode::TfPortDeclaration(_) => write!(f, "TfPortDeclaration"), + RefNode::TaskPrototype(_) => write!(f, "TaskPrototype"), + RefNode::InoutDeclaration(_) => write!(f, "InoutDeclaration"), + RefNode::InputDeclaration(_) => write!(f, "InputDeclaration"), + RefNode::InputDeclarationNet(_) => write!(f, "InputDeclarationNet"), + RefNode::InputDeclarationVariable(_) => write!(f, "InputDeclarationVariable"), + RefNode::OutputDeclaration(_) => write!(f, "OutputDeclaration"), + RefNode::OutputDeclarationNet(_) => write!(f, "OutputDeclarationNet"), + RefNode::OutputDeclarationVariable(_) => write!(f, "OutputDeclarationVariable"), + RefNode::InterfacePortDeclaration(_) => write!(f, "InterfacePortDeclaration"), + RefNode::RefDeclaration(_) => write!(f, "RefDeclaration"), + RefNode::GenerateRegion(_) => write!(f, "GenerateRegion"), + RefNode::LoopGenerateConstruct(_) => write!(f, "LoopGenerateConstruct"), + RefNode::GenvarInitialization(_) => write!(f, "GenvarInitialization"), + RefNode::Genvar(_) => write!(f, "Genvar"), + RefNode::GenvarIteration(_) => write!(f, "GenvarIteration"), + RefNode::GenvarIterationAssignment(_) => write!(f, "GenvarIterationAssignment"), + RefNode::GenvarIterationPrefix(_) => write!(f, "GenvarIterationPrefix"), + RefNode::GenvarIterationSuffix(_) => write!(f, "GenvarIterationSuffix"), + RefNode::ConditionalGenerateConstruct(_) => write!(f, "ConditionalGenerateConstruct"), + RefNode::IfGenerateConstruct(_) => write!(f, "IfGenerateConstruct"), + RefNode::CaseGenerateConstruct(_) => write!(f, "CaseGenerateConstruct"), + RefNode::CaseGenerateItem(_) => write!(f, "CaseGenerateItem"), + RefNode::CaseGenerateItemNondefault(_) => write!(f, "CaseGenerateItemNondefault"), + RefNode::CaseGenerateItemDefault(_) => write!(f, "CaseGenerateItemDefault"), + RefNode::GenerateBlock(_) => write!(f, "GenerateBlock"), + RefNode::GenerateBlockMultiple(_) => write!(f, "GenerateBlockMultiple"), + RefNode::GenerateItem(_) => write!(f, "GenerateItem"), + RefNode::InterfaceInstantiation(_) => write!(f, "InterfaceInstantiation"), + RefNode::ProgramInstantiation(_) => write!(f, "ProgramInstantiation"), + RefNode::ModuleInstantiation(_) => write!(f, "ModuleInstantiation"), + RefNode::ParameterValueAssignment(_) => write!(f, "ParameterValueAssignment"), + RefNode::ListOfParameterAssignments(_) => write!(f, "ListOfParameterAssignments"), + RefNode::ListOfParameterAssignmentsOrdered(_) => { + write!(f, "ListOfParameterAssignmentsOrdered") + } + RefNode::ListOfParameterAssignmentsNamed(_) => { + write!(f, "ListOfParameterAssignmentsNamed") + } + RefNode::OrderedParameterAssignment(_) => write!(f, "OrderedParameterAssignment"), + RefNode::NamedParameterAssignment(_) => write!(f, "NamedParameterAssignment"), + RefNode::HierarchicalInstance(_) => write!(f, "HierarchicalInstance"), + RefNode::NameOfInstance(_) => write!(f, "NameOfInstance"), + RefNode::ListOfPortConnections(_) => write!(f, "ListOfPortConnections"), + RefNode::ListOfPortConnectionsOrdered(_) => write!(f, "ListOfPortConnectionsOrdered"), + RefNode::ListOfPortConnectionsNamed(_) => write!(f, "ListOfPortConnectionsNamed"), + RefNode::OrderedPortConnection(_) => write!(f, "OrderedPortConnection"), + RefNode::NamedPortConnection(_) => write!(f, "NamedPortConnection"), + RefNode::NamedPortConnectionIdentifier(_) => write!(f, "NamedPortConnectionIdentifier"), + RefNode::NamedPortConnectionAsterisk(_) => write!(f, "NamedPortConnectionAsterisk"), + RefNode::CheckerInstantiation(_) => write!(f, "CheckerInstantiation"), + RefNode::ListOfCheckerPortConnections(_) => write!(f, "ListOfCheckerPortConnections"), + RefNode::ListOfCheckerPortConnectionsOrdered(_) => { + write!(f, "ListOfCheckerPortConnectionsOrdered") + } + RefNode::ListOfCheckerPortConnectionsNamed(_) => { + write!(f, "ListOfCheckerPortConnectionsNamed") + } + RefNode::OrderedCheckerPortConnection(_) => write!(f, "OrderedCheckerPortConnection"), + RefNode::NamedCheckerPortConnection(_) => write!(f, "NamedCheckerPortConnection"), + RefNode::NamedCheckerPortConnectionIdentifier(_) => { + write!(f, "NamedCheckerPortConnectionIdentifier") + } + RefNode::NamedCheckerPortConnectionAsterisk(_) => { + write!(f, "NamedCheckerPortConnectionAsterisk") + } + RefNode::NetLvalue(_) => write!(f, "NetLvalue"), + RefNode::NetLvalueIdentifier(_) => write!(f, "NetLvalueIdentifier"), + RefNode::NetLvalueLvalue(_) => write!(f, "NetLvalueLvalue"), + RefNode::NetLvaluePattern(_) => write!(f, "NetLvaluePattern"), + RefNode::VariableLvalue(_) => write!(f, "VariableLvalue"), + RefNode::VariableLvalueIdentifier(_) => write!(f, "VariableLvalueIdentifier"), + RefNode::VariableLvalueLvalue(_) => write!(f, "VariableLvalueLvalue"), + RefNode::VariableLvaluePattern(_) => write!(f, "VariableLvaluePattern"), + RefNode::NonrangeVariableLvalue(_) => write!(f, "NonrangeVariableLvalue"), + RefNode::Concatenation(_) => write!(f, "Concatenation"), + RefNode::ConstantConcatenation(_) => write!(f, "ConstantConcatenation"), + RefNode::ConstantMultipleConcatenation(_) => write!(f, "ConstantMultipleConcatenation"), + RefNode::ModulePathConcatenation(_) => write!(f, "ModulePathConcatenation"), + RefNode::ModulePathMultipleConcatenation(_) => { + write!(f, "ModulePathMultipleConcatenation") + } + RefNode::MultipleConcatenation(_) => write!(f, "MultipleConcatenation"), + RefNode::StreamingConcatenation(_) => write!(f, "StreamingConcatenation"), + RefNode::StreamOperator(_) => write!(f, "StreamOperator"), + RefNode::SliceSize(_) => write!(f, "SliceSize"), + RefNode::StreamConcatenation(_) => write!(f, "StreamConcatenation"), + RefNode::StreamExpression(_) => write!(f, "StreamExpression"), + RefNode::ArrayRangeExpression(_) => write!(f, "ArrayRangeExpression"), + RefNode::ArrayRangeExpressionColon(_) => write!(f, "ArrayRangeExpressionColon"), + RefNode::ArrayRangeExpressionPlusColon(_) => write!(f, "ArrayRangeExpressionPlusColon"), + RefNode::ArrayRangeExpressionMinusColon(_) => { + write!(f, "ArrayRangeExpressionMinusColon") + } + RefNode::EmptyUnpackedArrayConcatenation(_) => { + write!(f, "EmptyUnpackedArrayConcatenation") + } + RefNode::ConstantPrimary(_) => write!(f, "ConstantPrimary"), + RefNode::ConstantPrimaryPsParameter(_) => write!(f, "ConstantPrimaryPsParameter"), + RefNode::ConstantPrimarySpecparam(_) => write!(f, "ConstantPrimarySpecparam"), + RefNode::ConstantPrimaryFormalPort(_) => write!(f, "ConstantPrimaryFormalPort"), + RefNode::ConstantPrimaryEnum(_) => write!(f, "ConstantPrimaryEnum"), + RefNode::ConstantPrimaryConcatenation(_) => write!(f, "ConstantPrimaryConcatenation"), + RefNode::ConstantPrimaryMultipleConcatenation(_) => { + write!(f, "ConstantPrimaryMultipleConcatenation") + } + RefNode::ConstantPrimaryMintypmaxExpression(_) => { + write!(f, "ConstantPrimaryMintypmaxExpression") + } + RefNode::ModulePathPrimary(_) => write!(f, "ModulePathPrimary"), + RefNode::ModulePathPrimaryMintypmax(_) => write!(f, "ModulePathPrimaryMintypmax"), + RefNode::Primary(_) => write!(f, "Primary"), + RefNode::PrimaryHierarchical(_) => write!(f, "PrimaryHierarchical"), + RefNode::PrimaryConcatenation(_) => write!(f, "PrimaryConcatenation"), + RefNode::PrimaryMultipleConcatenation(_) => write!(f, "PrimaryMultipleConcatenation"), + RefNode::PrimaryMintypmaxExpression(_) => write!(f, "PrimaryMintypmaxExpression"), + RefNode::ClassQualifierOrPackageScope(_) => write!(f, "ClassQualifierOrPackageScope"), + RefNode::ClassQualifier(_) => write!(f, "ClassQualifier"), + RefNode::RangeExpression(_) => write!(f, "RangeExpression"), + RefNode::PrimaryLiteral(_) => write!(f, "PrimaryLiteral"), + RefNode::TimeLiteral(_) => write!(f, "TimeLiteral"), + RefNode::TimeLiteralUnsigned(_) => write!(f, "TimeLiteralUnsigned"), + RefNode::TimeLiteralFixedPoint(_) => write!(f, "TimeLiteralFixedPoint"), + RefNode::TimeUnit(_) => write!(f, "TimeUnit"), + RefNode::ImplicitClassHandle(_) => write!(f, "ImplicitClassHandle"), + RefNode::BitSelect(_) => write!(f, "BitSelect"), + RefNode::Select(_) => write!(f, "Select"), + RefNode::NonrangeSelect(_) => write!(f, "NonrangeSelect"), + RefNode::ConstantBitSelect(_) => write!(f, "ConstantBitSelect"), + RefNode::ConstantSelect(_) => write!(f, "ConstantSelect"), + RefNode::ConstantCast(_) => write!(f, "ConstantCast"), + RefNode::ConstantLetExpression(_) => write!(f, "ConstantLetExpression"), + RefNode::Cast(_) => write!(f, "Cast"), + RefNode::IncOrDecExpression(_) => write!(f, "IncOrDecExpression"), + RefNode::IncOrDecExpressionPrefix(_) => write!(f, "IncOrDecExpressionPrefix"), + RefNode::IncOrDecExpressionSuffix(_) => write!(f, "IncOrDecExpressionSuffix"), + RefNode::ConditionalExpression(_) => write!(f, "ConditionalExpression"), + RefNode::ConstantExpression(_) => write!(f, "ConstantExpression"), + RefNode::ConstantExpressionUnary(_) => write!(f, "ConstantExpressionUnary"), + RefNode::ConstantExpressionBinary(_) => write!(f, "ConstantExpressionBinary"), + RefNode::ConstantExpressionTernary(_) => write!(f, "ConstantExpressionTernary"), + RefNode::ConstantInsideExpression(_) => write!(f, "ConstantInsideExpression"), + RefNode::ConstantMintypmaxExpression(_) => write!(f, "ConstantMintypmaxExpression"), + RefNode::ConstantMintypmaxExpressionTernary(_) => { + write!(f, "ConstantMintypmaxExpressionTernary") + } + RefNode::ConstantParamExpression(_) => write!(f, "ConstantParamExpression"), + RefNode::ParamExpression(_) => write!(f, "ParamExpression"), + RefNode::ConstantRangeExpression(_) => write!(f, "ConstantRangeExpression"), + RefNode::ConstantPartSelectRange(_) => write!(f, "ConstantPartSelectRange"), + RefNode::ConstantRange(_) => write!(f, "ConstantRange"), + RefNode::ConstantIndexedRange(_) => write!(f, "ConstantIndexedRange"), + RefNode::Expression(_) => write!(f, "Expression"), + RefNode::ExpressionUnary(_) => write!(f, "ExpressionUnary"), + RefNode::ExpressionOperatorAssignment(_) => write!(f, "ExpressionOperatorAssignment"), + RefNode::ExpressionBinary(_) => write!(f, "ExpressionBinary"), + RefNode::ExpressionBinaryOperand(_) => write!(f, "ExpressionBinaryOperand"), + RefNode::TaggedUnionExpression(_) => write!(f, "TaggedUnionExpression"), + RefNode::InsideExpression(_) => write!(f, "InsideExpression"), + RefNode::ValueRange(_) => write!(f, "ValueRange"), + RefNode::ValueRangeBinary(_) => write!(f, "ValueRangeBinary"), + RefNode::MintypmaxExpression(_) => write!(f, "MintypmaxExpression"), + RefNode::MintypmaxExpressionTernary(_) => write!(f, "MintypmaxExpressionTernary"), + RefNode::ModulePathConditionalExpression(_) => { + write!(f, "ModulePathConditionalExpression") + } + RefNode::ModulePathExpression(_) => write!(f, "ModulePathExpression"), + RefNode::ModulePathExpressionUnary(_) => write!(f, "ModulePathExpressionUnary"), + RefNode::ModulePathExpressionBinary(_) => write!(f, "ModulePathExpressionBinary"), + RefNode::ModulePathMintypmaxExpression(_) => write!(f, "ModulePathMintypmaxExpression"), + RefNode::ModulePathMintypmaxExpressionTernary(_) => { + write!(f, "ModulePathMintypmaxExpressionTernary") + } + RefNode::PartSelectRange(_) => write!(f, "PartSelectRange"), + RefNode::IndexedRange(_) => write!(f, "IndexedRange"), + RefNode::GenvarExpression(_) => write!(f, "GenvarExpression"), + RefNode::UnaryOperator(_) => write!(f, "UnaryOperator"), + RefNode::BinaryOperator(_) => write!(f, "BinaryOperator"), + RefNode::IncOrDecOperator(_) => write!(f, "IncOrDecOperator"), + RefNode::UnaryModulePathOperator(_) => write!(f, "UnaryModulePathOperator"), + RefNode::BinaryModulePathOperator(_) => write!(f, "BinaryModulePathOperator"), + RefNode::StringLiteral(_) => write!(f, "StringLiteral"), + RefNode::ConstantFunctionCall(_) => write!(f, "ConstantFunctionCall"), + RefNode::TfCall(_) => write!(f, "TfCall"), + RefNode::SystemTfCall(_) => write!(f, "SystemTfCall"), + RefNode::SystemTfCallArgOptional(_) => write!(f, "SystemTfCallArgOptional"), + RefNode::SystemTfCallArgDataType(_) => write!(f, "SystemTfCallArgDataType"), + RefNode::SystemTfCallArgExpression(_) => write!(f, "SystemTfCallArgExpression"), + RefNode::SubroutineCall(_) => write!(f, "SubroutineCall"), + RefNode::SubroutineCallRandomize(_) => write!(f, "SubroutineCallRandomize"), + RefNode::FunctionSubroutineCall(_) => write!(f, "FunctionSubroutineCall"), + RefNode::ListOfArguments(_) => write!(f, "ListOfArguments"), + RefNode::ListOfArgumentsOrdered(_) => write!(f, "ListOfArgumentsOrdered"), + RefNode::ListOfArgumentsNamed(_) => write!(f, "ListOfArgumentsNamed"), + RefNode::MethodCall(_) => write!(f, "MethodCall"), + RefNode::MethodCallBody(_) => write!(f, "MethodCallBody"), + RefNode::MethodCallBodyUser(_) => write!(f, "MethodCallBodyUser"), + RefNode::BuiltInMethodCall(_) => write!(f, "BuiltInMethodCall"), + RefNode::ArrayManipulationCall(_) => write!(f, "ArrayManipulationCall"), + RefNode::RandomizeCall(_) => write!(f, "RandomizeCall"), + RefNode::VariableIdentifierListOrNull(_) => write!(f, "VariableIdentifierListOrNull"), + RefNode::MethodCallRoot(_) => write!(f, "MethodCallRoot"), + RefNode::ArrayMethodName(_) => write!(f, "ArrayMethodName"), + RefNode::Number(_) => write!(f, "Number"), + RefNode::IntegralNumber(_) => write!(f, "IntegralNumber"), + RefNode::DecimalNumber(_) => write!(f, "DecimalNumber"), + RefNode::DecimalNumberBaseUnsigned(_) => write!(f, "DecimalNumberBaseUnsigned"), + RefNode::DecimalNumberBaseXNumber(_) => write!(f, "DecimalNumberBaseXNumber"), + RefNode::DecimalNumberBaseZNumber(_) => write!(f, "DecimalNumberBaseZNumber"), + RefNode::BinaryNumber(_) => write!(f, "BinaryNumber"), + RefNode::OctalNumber(_) => write!(f, "OctalNumber"), + RefNode::HexNumber(_) => write!(f, "HexNumber"), + RefNode::Sign(_) => write!(f, "Sign"), + RefNode::Size(_) => write!(f, "Size"), + RefNode::NonZeroUnsignedNumber(_) => write!(f, "NonZeroUnsignedNumber"), + RefNode::RealNumber(_) => write!(f, "RealNumber"), + RefNode::RealNumberFloating(_) => write!(f, "RealNumberFloating"), + RefNode::FixedPointNumber(_) => write!(f, "FixedPointNumber"), + RefNode::Exp(_) => write!(f, "Exp"), + RefNode::UnsignedNumber(_) => write!(f, "UnsignedNumber"), + RefNode::BinaryValue(_) => write!(f, "BinaryValue"), + RefNode::OctalValue(_) => write!(f, "OctalValue"), + RefNode::HexValue(_) => write!(f, "HexValue"), + RefNode::DecimalBase(_) => write!(f, "DecimalBase"), + RefNode::BinaryBase(_) => write!(f, "BinaryBase"), + RefNode::OctalBase(_) => write!(f, "OctalBase"), + RefNode::HexBase(_) => write!(f, "HexBase"), + RefNode::XNumber(_) => write!(f, "XNumber"), + RefNode::ZNumber(_) => write!(f, "ZNumber"), + RefNode::UnbasedUnsizedLiteral(_) => write!(f, "UnbasedUnsizedLiteral"), + RefNode::SourceText(_) => write!(f, "SourceText"), + RefNode::Description(_) => write!(f, "Description"), + RefNode::DescriptionPackageItem(_) => write!(f, "DescriptionPackageItem"), + RefNode::DescriptionBindDirective(_) => write!(f, "DescriptionBindDirective"), + RefNode::ModuleNonansiHeader(_) => write!(f, "ModuleNonansiHeader"), + RefNode::ModuleAnsiHeader(_) => write!(f, "ModuleAnsiHeader"), + RefNode::ModuleDeclaration(_) => write!(f, "ModuleDeclaration"), + RefNode::ModuleDeclarationNonansi(_) => write!(f, "ModuleDeclarationNonansi"), + RefNode::ModuleDeclarationAnsi(_) => write!(f, "ModuleDeclarationAnsi"), + RefNode::ModuleDeclarationWildcard(_) => write!(f, "ModuleDeclarationWildcard"), + RefNode::ModuleDeclarationExternNonansi(_) => { + write!(f, "ModuleDeclarationExternNonansi") + } + RefNode::ModuleDeclarationExternAnsi(_) => write!(f, "ModuleDeclarationExternAnsi"), + RefNode::ModuleKeyword(_) => write!(f, "ModuleKeyword"), + RefNode::InterfaceDeclaration(_) => write!(f, "InterfaceDeclaration"), + RefNode::InterfaceDeclarationNonansi(_) => write!(f, "InterfaceDeclarationNonansi"), + RefNode::InterfaceDeclarationAnsi(_) => write!(f, "InterfaceDeclarationAnsi"), + RefNode::InterfaceDeclarationWildcard(_) => write!(f, "InterfaceDeclarationWildcard"), + RefNode::InterfaceDeclarationExternNonansi(_) => { + write!(f, "InterfaceDeclarationExternNonansi") + } + RefNode::InterfaceDeclarationExternAnsi(_) => { + write!(f, "InterfaceDeclarationExternAnsi") + } + RefNode::InterfaceNonansiHeader(_) => write!(f, "InterfaceNonansiHeader"), + RefNode::InterfaceAnsiHeader(_) => write!(f, "InterfaceAnsiHeader"), + RefNode::ProgramDeclaration(_) => write!(f, "ProgramDeclaration"), + RefNode::ProgramDeclarationNonansi(_) => write!(f, "ProgramDeclarationNonansi"), + RefNode::ProgramDeclarationAnsi(_) => write!(f, "ProgramDeclarationAnsi"), + RefNode::ProgramDeclarationWildcard(_) => write!(f, "ProgramDeclarationWildcard"), + RefNode::ProgramDeclarationExternNonansi(_) => { + write!(f, "ProgramDeclarationExternNonansi") + } + RefNode::ProgramDeclarationExternAnsi(_) => write!(f, "ProgramDeclarationExternAnsi"), + RefNode::ProgramNonansiHeader(_) => write!(f, "ProgramNonansiHeader"), + RefNode::ProgramAnsiHeader(_) => write!(f, "ProgramAnsiHeader"), + RefNode::CheckerDeclaration(_) => write!(f, "CheckerDeclaration"), + RefNode::ClassDeclaration(_) => write!(f, "ClassDeclaration"), + RefNode::Virtual(_) => write!(f, "Virtual"), + RefNode::InterfaceClassType(_) => write!(f, "InterfaceClassType"), + RefNode::InterfaceClassDeclaration(_) => write!(f, "InterfaceClassDeclaration"), + RefNode::InterfaceClassItem(_) => write!(f, "InterfaceClassItem"), + RefNode::InterfaceClassItemMethod(_) => write!(f, "InterfaceClassItemMethod"), + RefNode::InterfaceClassMethod(_) => write!(f, "InterfaceClassMethod"), + RefNode::PackageDeclaration(_) => write!(f, "PackageDeclaration"), + RefNode::TimeunitsDeclaration(_) => write!(f, "TimeunitsDeclaration"), + RefNode::TimeunitsDeclarationTimeunit(_) => write!(f, "TimeunitsDeclarationTimeunit"), + RefNode::TimeunitsDeclarationTimeprecision(_) => { + write!(f, "TimeunitsDeclarationTimeprecision") + } + RefNode::TimeunitsDeclarationTimeunitTimeprecision(_) => { + write!(f, "TimeunitsDeclarationTimeunitTimeprecision") + } + RefNode::TimeunitsDeclarationTimeprecisionTimeunit(_) => { + write!(f, "TimeunitsDeclarationTimeprecisionTimeunit") + } + RefNode::LibraryText(_) => write!(f, "LibraryText"), + RefNode::LibraryDescription(_) => write!(f, "LibraryDescription"), + RefNode::LibraryDeclaration(_) => write!(f, "LibraryDeclaration"), + RefNode::IncludeStatement(_) => write!(f, "IncludeStatement"), + RefNode::FilePathSpec(_) => write!(f, "FilePathSpec"), + RefNode::FilePathSpecNonLiteral(_) => write!(f, "FilePathSpecNonLiteral"), + RefNode::ParameterPortList(_) => write!(f, "ParameterPortList"), + RefNode::ParameterPortListAssignment(_) => write!(f, "ParameterPortListAssignment"), + RefNode::ParameterPortListDeclaration(_) => write!(f, "ParameterPortListDeclaration"), + RefNode::ParameterPortDeclaration(_) => write!(f, "ParameterPortDeclaration"), + RefNode::ParameterPortDeclarationParamList(_) => { + write!(f, "ParameterPortDeclarationParamList") + } + RefNode::ParameterPortDeclarationTypeList(_) => { + write!(f, "ParameterPortDeclarationTypeList") + } + RefNode::ListOfPorts(_) => write!(f, "ListOfPorts"), + RefNode::ListOfPortDeclarations(_) => write!(f, "ListOfPortDeclarations"), + RefNode::PortDeclaration(_) => write!(f, "PortDeclaration"), + RefNode::PortDeclarationInout(_) => write!(f, "PortDeclarationInout"), + RefNode::PortDeclarationInput(_) => write!(f, "PortDeclarationInput"), + RefNode::PortDeclarationOutput(_) => write!(f, "PortDeclarationOutput"), + RefNode::PortDeclarationRef(_) => write!(f, "PortDeclarationRef"), + RefNode::PortDeclarationInterface(_) => write!(f, "PortDeclarationInterface"), + RefNode::Port(_) => write!(f, "Port"), + RefNode::PortNonNamed(_) => write!(f, "PortNonNamed"), + RefNode::PortNamed(_) => write!(f, "PortNamed"), + RefNode::PortExpression(_) => write!(f, "PortExpression"), + RefNode::PortExpressionBrace(_) => write!(f, "PortExpressionBrace"), + RefNode::PortReference(_) => write!(f, "PortReference"), + RefNode::PortDirection(_) => write!(f, "PortDirection"), + RefNode::NetPortHeader(_) => write!(f, "NetPortHeader"), + RefNode::VariablePortHeader(_) => write!(f, "VariablePortHeader"), + RefNode::InterfacePortHeader(_) => write!(f, "InterfacePortHeader"), + RefNode::InterfacePortHeaderIdentifier(_) => write!(f, "InterfacePortHeaderIdentifier"), + RefNode::InterfacePortHeaderInterface(_) => write!(f, "InterfacePortHeaderInterface"), + RefNode::NetPortHeaderOrInterfacePortHeader(_) => { + write!(f, "NetPortHeaderOrInterfacePortHeader") + } + RefNode::AnsiPortDeclaration(_) => write!(f, "AnsiPortDeclaration"), + RefNode::AnsiPortDeclarationNet(_) => write!(f, "AnsiPortDeclarationNet"), + RefNode::AnsiPortDeclarationVariable(_) => write!(f, "AnsiPortDeclarationVariable"), + RefNode::AnsiPortDeclarationParen(_) => write!(f, "AnsiPortDeclarationParen"), + RefNode::ProgramItem(_) => write!(f, "ProgramItem"), + RefNode::NonPortProgramItem(_) => write!(f, "NonPortProgramItem"), + RefNode::NonPortProgramItemAssign(_) => write!(f, "NonPortProgramItemAssign"), + RefNode::NonPortProgramItemModule(_) => write!(f, "NonPortProgramItemModule"), + RefNode::NonPortProgramItemInitial(_) => write!(f, "NonPortProgramItemInitial"), + RefNode::NonPortProgramItemFinal(_) => write!(f, "NonPortProgramItemFinal"), + RefNode::NonPortProgramItemAssertion(_) => write!(f, "NonPortProgramItemAssertion"), + RefNode::ProgramGenerateItem(_) => write!(f, "ProgramGenerateItem"), + RefNode::ElaborationSystemTask(_) => write!(f, "ElaborationSystemTask"), + RefNode::ElaborationSystemTaskFatal(_) => write!(f, "ElaborationSystemTaskFatal"), + RefNode::ElaborationSystemTaskError(_) => write!(f, "ElaborationSystemTaskError"), + RefNode::ElaborationSystemTaskWarning(_) => write!(f, "ElaborationSystemTaskWarning"), + RefNode::ElaborationSystemTaskInfo(_) => write!(f, "ElaborationSystemTaskInfo"), + RefNode::FinishNumber(_) => write!(f, "FinishNumber"), + RefNode::ModuleCommonItem(_) => write!(f, "ModuleCommonItem"), + RefNode::ModuleItem(_) => write!(f, "ModuleItem"), + RefNode::ModuleOrGenerateItem(_) => write!(f, "ModuleOrGenerateItem"), + RefNode::ModuleOrGenerateItemParameter(_) => write!(f, "ModuleOrGenerateItemParameter"), + RefNode::ModuleOrGenerateItemGate(_) => write!(f, "ModuleOrGenerateItemGate"), + RefNode::ModuleOrGenerateItemUdp(_) => write!(f, "ModuleOrGenerateItemUdp"), + RefNode::ModuleOrGenerateItemModule(_) => write!(f, "ModuleOrGenerateItemModule"), + RefNode::ModuleOrGenerateItemModuleItem(_) => { + write!(f, "ModuleOrGenerateItemModuleItem") + } + RefNode::ModuleOrGenerateItemDeclaration(_) => { + write!(f, "ModuleOrGenerateItemDeclaration") + } + RefNode::ModuleOrGenerateItemDeclarationClocking(_) => { + write!(f, "ModuleOrGenerateItemDeclarationClocking") + } + RefNode::ModuleOrGenerateItemDeclarationDisable(_) => { + write!(f, "ModuleOrGenerateItemDeclarationDisable") + } + RefNode::NonPortModuleItem(_) => write!(f, "NonPortModuleItem"), + RefNode::NonPortModuleItemSpecparam(_) => write!(f, "NonPortModuleItemSpecparam"), + RefNode::ParameterOverride(_) => write!(f, "ParameterOverride"), + RefNode::BindDirective(_) => write!(f, "BindDirective"), + RefNode::BindDirectiveScope(_) => write!(f, "BindDirectiveScope"), + RefNode::BindDirectiveInstance(_) => write!(f, "BindDirectiveInstance"), + RefNode::BindTargetScope(_) => write!(f, "BindTargetScope"), + RefNode::BindTargetInstance(_) => write!(f, "BindTargetInstance"), + RefNode::BindTargetInstanceList(_) => write!(f, "BindTargetInstanceList"), + RefNode::BindInstantiation(_) => write!(f, "BindInstantiation"), + RefNode::ConstraintDeclaration(_) => write!(f, "ConstraintDeclaration"), + RefNode::Static(_) => write!(f, "Static"), + RefNode::ConstraintBlock(_) => write!(f, "ConstraintBlock"), + RefNode::ConstraintBlockItem(_) => write!(f, "ConstraintBlockItem"), + RefNode::ConstraintBlockItemSolve(_) => write!(f, "ConstraintBlockItemSolve"), + RefNode::SolveBeforeList(_) => write!(f, "SolveBeforeList"), + RefNode::ConstraintPrimary(_) => write!(f, "ConstraintPrimary"), + RefNode::ConstraintExpression(_) => write!(f, "ConstraintExpression"), + RefNode::ConstraintExpressionExpression(_) => { + write!(f, "ConstraintExpressionExpression") + } + RefNode::Soft(_) => write!(f, "Soft"), + RefNode::ConstraintExpressionArrow(_) => write!(f, "ConstraintExpressionArrow"), + RefNode::ConstraintExpressionIf(_) => write!(f, "ConstraintExpressionIf"), + RefNode::ConstraintExpressionForeach(_) => write!(f, "ConstraintExpressionForeach"), + RefNode::ConstraintExpressionDisable(_) => write!(f, "ConstraintExpressionDisable"), + RefNode::UniquenessConstraint(_) => write!(f, "UniquenessConstraint"), + RefNode::ConstraintSet(_) => write!(f, "ConstraintSet"), + RefNode::ConstraintSetBrace(_) => write!(f, "ConstraintSetBrace"), + RefNode::DistList(_) => write!(f, "DistList"), + RefNode::DistItem(_) => write!(f, "DistItem"), + RefNode::DistWeight(_) => write!(f, "DistWeight"), + RefNode::DistWeightEqual(_) => write!(f, "DistWeightEqual"), + RefNode::DistWeightDivide(_) => write!(f, "DistWeightDivide"), + RefNode::ConstraintPrototype(_) => write!(f, "ConstraintPrototype"), + RefNode::ConstraintPrototypeQualifier(_) => write!(f, "ConstraintPrototypeQualifier"), + RefNode::ExternConstraintDeclaration(_) => write!(f, "ExternConstraintDeclaration"), + RefNode::IdentifierList(_) => write!(f, "IdentifierList"), + RefNode::ConfigDeclaration(_) => write!(f, "ConfigDeclaration"), + RefNode::DesignStatement(_) => write!(f, "DesignStatement"), + RefNode::ConfigRuleStatement(_) => write!(f, "ConfigRuleStatement"), + RefNode::ConfigRuleStatementDefault(_) => write!(f, "ConfigRuleStatementDefault"), + RefNode::ConfigRuleStatementInstLib(_) => write!(f, "ConfigRuleStatementInstLib"), + RefNode::ConfigRuleStatementInstUse(_) => write!(f, "ConfigRuleStatementInstUse"), + RefNode::ConfigRuleStatementCellLib(_) => write!(f, "ConfigRuleStatementCellLib"), + RefNode::ConfigRuleStatementCellUse(_) => write!(f, "ConfigRuleStatementCellUse"), + RefNode::DefaultClause(_) => write!(f, "DefaultClause"), + RefNode::InstClause(_) => write!(f, "InstClause"), + RefNode::InstName(_) => write!(f, "InstName"), + RefNode::CellClause(_) => write!(f, "CellClause"), + RefNode::LiblistClause(_) => write!(f, "LiblistClause"), + RefNode::UseClause(_) => write!(f, "UseClause"), + RefNode::UseClauseCell(_) => write!(f, "UseClauseCell"), + RefNode::UseClauseNamed(_) => write!(f, "UseClauseNamed"), + RefNode::UseClauseCellNamed(_) => write!(f, "UseClauseCellNamed"), + RefNode::Config(_) => write!(f, "Config"), + RefNode::ClassItem(_) => write!(f, "ClassItem"), + RefNode::ClassItemProperty(_) => write!(f, "ClassItemProperty"), + RefNode::ClassItemMethod(_) => write!(f, "ClassItemMethod"), + RefNode::ClassItemConstraint(_) => write!(f, "ClassItemConstraint"), + RefNode::ClassItemDeclaration(_) => write!(f, "ClassItemDeclaration"), + RefNode::ClassItemCovergroup(_) => write!(f, "ClassItemCovergroup"), + RefNode::ClassProperty(_) => write!(f, "ClassProperty"), + RefNode::ClassPropertyNonConst(_) => write!(f, "ClassPropertyNonConst"), + RefNode::ClassPropertyConst(_) => write!(f, "ClassPropertyConst"), + RefNode::ClassPropertyConstExpression(_) => write!(f, "ClassPropertyConstExpression"), + RefNode::ClassMethod(_) => write!(f, "ClassMethod"), + RefNode::ClassMethodTask(_) => write!(f, "ClassMethodTask"), + RefNode::ClassMethodFunction(_) => write!(f, "ClassMethodFunction"), + RefNode::ClassMethodPureVirtual(_) => write!(f, "ClassMethodPureVirtual"), + RefNode::ClassMethodExternMethod(_) => write!(f, "ClassMethodExternMethod"), + RefNode::ClassMethodConstructor(_) => write!(f, "ClassMethodConstructor"), + RefNode::ClassMethodExternConstructor(_) => write!(f, "ClassMethodExternConstructor"), + RefNode::ClassConstructorPrototype(_) => write!(f, "ClassConstructorPrototype"), + RefNode::ClassConstraint(_) => write!(f, "ClassConstraint"), + RefNode::ClassItemQualifier(_) => write!(f, "ClassItemQualifier"), + RefNode::PropertyQualifier(_) => write!(f, "PropertyQualifier"), + RefNode::RandomQualifier(_) => write!(f, "RandomQualifier"), + RefNode::MethodQualifier(_) => write!(f, "MethodQualifier"), + RefNode::MethodPrototype(_) => write!(f, "MethodPrototype"), + RefNode::ClassConstructorDeclaration(_) => write!(f, "ClassConstructorDeclaration"), + RefNode::New(_) => write!(f, "New"), + RefNode::InterfaceOrGenerateItem(_) => write!(f, "InterfaceOrGenerateItem"), + RefNode::InterfaceOrGenerateItemModule(_) => write!(f, "InterfaceOrGenerateItemModule"), + RefNode::InterfaceOrGenerateItemExtern(_) => write!(f, "InterfaceOrGenerateItemExtern"), + RefNode::ExternTfDeclaration(_) => write!(f, "ExternTfDeclaration"), + RefNode::ExternTfDeclarationMethod(_) => write!(f, "ExternTfDeclarationMethod"), + RefNode::ExternTfDeclarationTask(_) => write!(f, "ExternTfDeclarationTask"), + RefNode::InterfaceItem(_) => write!(f, "InterfaceItem"), + RefNode::NonPortInterfaceItem(_) => write!(f, "NonPortInterfaceItem"), + RefNode::CheckerPortList(_) => write!(f, "CheckerPortList"), + RefNode::CheckerPortItem(_) => write!(f, "CheckerPortItem"), + RefNode::CheckerPortDirection(_) => write!(f, "CheckerPortDirection"), + RefNode::CheckerOrGenerateItem(_) => write!(f, "CheckerOrGenerateItem"), + RefNode::CheckerOrGenerateItemDeclaration(_) => { + write!(f, "CheckerOrGenerateItemDeclaration") + } + RefNode::CheckerOrGenerateItemDeclarationData(_) => { + write!(f, "CheckerOrGenerateItemDeclarationData") + } + RefNode::Rand(_) => write!(f, "Rand"), + RefNode::CheckerOrGenerateItemDeclarationClocking(_) => { + write!(f, "CheckerOrGenerateItemDeclarationClocking") + } + RefNode::CheckerOrGenerateItemDeclarationDisable(_) => { + write!(f, "CheckerOrGenerateItemDeclarationDisable") + } + RefNode::CheckerGenerateItem(_) => write!(f, "CheckerGenerateItem"), + RefNode::PackageItem(_) => write!(f, "PackageItem"), + RefNode::PackageOrGenerateItemDeclaration(_) => { + write!(f, "PackageOrGenerateItemDeclaration") + } + RefNode::AnonymousProgram(_) => write!(f, "AnonymousProgram"), + RefNode::AnonymousProgramItem(_) => write!(f, "AnonymousProgramItem"), + RefNode::PreprocessorText(_) => write!(f, "PreprocessorText"), + RefNode::Symbol(_) => write!(f, "Symbol"), + RefNode::Keyword(_) => write!(f, "Keyword"), + RefNode::WhiteSpace(_) => write!(f, "WhiteSpace"), + RefNode::PulldownStrength(_) => write!(f, "PulldownStrength"), + RefNode::PulldownStrength01(_) => write!(f, "PulldownStrength01"), + RefNode::PulldownStrength10(_) => write!(f, "PulldownStrength10"), + RefNode::PulldownStrength0(_) => write!(f, "PulldownStrength0"), + RefNode::PullupStrength(_) => write!(f, "PullupStrength"), + RefNode::PullupStrength01(_) => write!(f, "PullupStrength01"), + RefNode::PullupStrength10(_) => write!(f, "PullupStrength10"), + RefNode::PullupStrength1(_) => write!(f, "PullupStrength1"), + RefNode::GateInstantiation(_) => write!(f, "GateInstantiation"), + RefNode::GateInstantiationCmos(_) => write!(f, "GateInstantiationCmos"), + RefNode::GateInstantiationEnable(_) => write!(f, "GateInstantiationEnable"), + RefNode::GateInstantiationMos(_) => write!(f, "GateInstantiationMos"), + RefNode::GateInstantiationNInput(_) => write!(f, "GateInstantiationNInput"), + RefNode::GateInstantiationNOutput(_) => write!(f, "GateInstantiationNOutput"), + RefNode::GateInstantiationPassEn(_) => write!(f, "GateInstantiationPassEn"), + RefNode::GateInstantiationPass(_) => write!(f, "GateInstantiationPass"), + RefNode::GateInstantiationPulldown(_) => write!(f, "GateInstantiationPulldown"), + RefNode::GateInstantiationPullup(_) => write!(f, "GateInstantiationPullup"), + RefNode::CmosSwitchInstance(_) => write!(f, "CmosSwitchInstance"), + RefNode::EnableGateInstance(_) => write!(f, "EnableGateInstance"), + RefNode::MosSwitchInstance(_) => write!(f, "MosSwitchInstance"), + RefNode::NInputGateInstance(_) => write!(f, "NInputGateInstance"), + RefNode::NOutputGateInstance(_) => write!(f, "NOutputGateInstance"), + RefNode::PassSwitchInstance(_) => write!(f, "PassSwitchInstance"), + RefNode::PassEnableSwitchInstance(_) => write!(f, "PassEnableSwitchInstance"), + RefNode::PullGateInstance(_) => write!(f, "PullGateInstance"), + RefNode::CmosSwitchtype(_) => write!(f, "CmosSwitchtype"), + RefNode::EnableGatetype(_) => write!(f, "EnableGatetype"), + RefNode::MosSwitchtype(_) => write!(f, "MosSwitchtype"), + RefNode::NInputGatetype(_) => write!(f, "NInputGatetype"), + RefNode::NOutputGatetype(_) => write!(f, "NOutputGatetype"), + RefNode::PassEnSwitchtype(_) => write!(f, "PassEnSwitchtype"), + RefNode::PassSwitchtype(_) => write!(f, "PassSwitchtype"), + RefNode::EnableTerminal(_) => write!(f, "EnableTerminal"), + RefNode::InoutTerminal(_) => write!(f, "InoutTerminal"), + RefNode::InputTerminal(_) => write!(f, "InputTerminal"), + RefNode::NcontrolTerminal(_) => write!(f, "NcontrolTerminal"), + RefNode::OutputTerminal(_) => write!(f, "OutputTerminal"), + RefNode::PcontrolTerminal(_) => write!(f, "PcontrolTerminal"), + RefNode::UdpPortList(_) => write!(f, "UdpPortList"), + RefNode::UdpDeclarationPortList(_) => write!(f, "UdpDeclarationPortList"), + RefNode::UdpPortDeclaration(_) => write!(f, "UdpPortDeclaration"), + RefNode::UdpOutputDeclaration(_) => write!(f, "UdpOutputDeclaration"), + RefNode::UdpOutputDeclarationNonreg(_) => write!(f, "UdpOutputDeclarationNonreg"), + RefNode::UdpOutputDeclarationReg(_) => write!(f, "UdpOutputDeclarationReg"), + RefNode::UdpInputDeclaration(_) => write!(f, "UdpInputDeclaration"), + RefNode::UdpRegDeclaration(_) => write!(f, "UdpRegDeclaration"), + RefNode::UdpInstantiation(_) => write!(f, "UdpInstantiation"), + RefNode::UdpInstance(_) => write!(f, "UdpInstance"), + RefNode::UdpNonansiDeclaration(_) => write!(f, "UdpNonansiDeclaration"), + RefNode::UdpAnsiDeclaration(_) => write!(f, "UdpAnsiDeclaration"), + RefNode::UdpDeclaration(_) => write!(f, "UdpDeclaration"), + RefNode::UdpDeclarationNonansi(_) => write!(f, "UdpDeclarationNonansi"), + RefNode::UdpDeclarationAnsi(_) => write!(f, "UdpDeclarationAnsi"), + RefNode::UdpDeclarationExternNonansi(_) => write!(f, "UdpDeclarationExternNonansi"), + RefNode::UdpDeclarationExternAnsi(_) => write!(f, "UdpDeclarationExternAnsi"), + RefNode::UdpDeclarationWildcard(_) => write!(f, "UdpDeclarationWildcard"), + RefNode::UdpBody(_) => write!(f, "UdpBody"), + RefNode::CombinationalBody(_) => write!(f, "CombinationalBody"), + RefNode::CombinationalEntry(_) => write!(f, "CombinationalEntry"), + RefNode::SequentialBody(_) => write!(f, "SequentialBody"), + RefNode::UdpInitialStatement(_) => write!(f, "UdpInitialStatement"), + RefNode::InitVal(_) => write!(f, "InitVal"), + RefNode::SequentialEntry(_) => write!(f, "SequentialEntry"), + RefNode::SeqInputList(_) => write!(f, "SeqInputList"), + RefNode::LevelInputList(_) => write!(f, "LevelInputList"), + RefNode::EdgeInputList(_) => write!(f, "EdgeInputList"), + RefNode::EdgeIndicator(_) => write!(f, "EdgeIndicator"), + RefNode::EdgeIndicatorParen(_) => write!(f, "EdgeIndicatorParen"), + RefNode::CurrentState(_) => write!(f, "CurrentState"), + RefNode::NextState(_) => write!(f, "NextState"), + RefNode::OutputSymbol(_) => write!(f, "OutputSymbol"), + RefNode::LevelSymbol(_) => write!(f, "LevelSymbol"), + RefNode::EdgeSymbol(_) => write!(f, "EdgeSymbol"), + RefNode::SpecifyInputTerminalDescriptor(_) => { + write!(f, "SpecifyInputTerminalDescriptor") + } + RefNode::SpecifyOutputTerminalDescriptor(_) => { + write!(f, "SpecifyOutputTerminalDescriptor") + } + RefNode::InputIdentifier(_) => write!(f, "InputIdentifier"), + RefNode::InputIdentifierInterface(_) => write!(f, "InputIdentifierInterface"), + RefNode::OutputIdentifier(_) => write!(f, "OutputIdentifier"), + RefNode::OutputIdentifierInterface(_) => write!(f, "OutputIdentifierInterface"), + RefNode::PathDeclaration(_) => write!(f, "PathDeclaration"), + RefNode::SimplePathDeclaration(_) => write!(f, "SimplePathDeclaration"), + RefNode::SimplePathDeclarationParallel(_) => write!(f, "SimplePathDeclarationParallel"), + RefNode::SimplePathDeclarationFull(_) => write!(f, "SimplePathDeclarationFull"), + RefNode::ParallelPathDescription(_) => write!(f, "ParallelPathDescription"), + RefNode::FullPathDescription(_) => write!(f, "FullPathDescription"), + RefNode::ListOfPathInputs(_) => write!(f, "ListOfPathInputs"), + RefNode::ListOfPathOutputs(_) => write!(f, "ListOfPathOutputs"), + RefNode::PathDelayValue(_) => write!(f, "PathDelayValue"), + RefNode::PathDelayValueParen(_) => write!(f, "PathDelayValueParen"), + RefNode::ListOfPathDelayExpressions(_) => write!(f, "ListOfPathDelayExpressions"), + RefNode::TPathDelayExpression(_) => write!(f, "TPathDelayExpression"), + RefNode::PathDelayExpression(_) => write!(f, "PathDelayExpression"), + RefNode::EdgeSensitivePathDeclaration(_) => write!(f, "EdgeSensitivePathDeclaration"), + RefNode::EdgeSensitivePathDeclarationParallel(_) => { + write!(f, "EdgeSensitivePathDeclarationParallel") + } + RefNode::EdgeSensitivePathDeclarationFull(_) => { + write!(f, "EdgeSensitivePathDeclarationFull") + } + RefNode::ParallelEdgeSensitivePathDescription(_) => { + write!(f, "ParallelEdgeSensitivePathDescription") + } + RefNode::FullEdgeSensitivePathDescription(_) => { + write!(f, "FullEdgeSensitivePathDescription") + } + RefNode::DataSourceExpression(_) => write!(f, "DataSourceExpression"), + RefNode::EdgeIdentifier(_) => write!(f, "EdgeIdentifier"), + RefNode::StateDependentPathDeclaration(_) => write!(f, "StateDependentPathDeclaration"), + RefNode::StateDependentPathDeclarationIfSimple(_) => { + write!(f, "StateDependentPathDeclarationIfSimple") + } + RefNode::StateDependentPathDeclarationIfEdgeSensitive(_) => { + write!(f, "StateDependentPathDeclarationIfEdgeSensitive") + } + RefNode::StateDependentPathDeclarationIfNone(_) => { + write!(f, "StateDependentPathDeclarationIfNone") + } + RefNode::PolarityOperator(_) => write!(f, "PolarityOperator"), + RefNode::SpecifyBlock(_) => write!(f, "SpecifyBlock"), + RefNode::SpecifyItem(_) => write!(f, "SpecifyItem"), + RefNode::PulsestyleDeclaration(_) => write!(f, "PulsestyleDeclaration"), + RefNode::ShowcancelledDeclaration(_) => write!(f, "ShowcancelledDeclaration"), + RefNode::TimingCheckEvent(_) => write!(f, "TimingCheckEvent"), + RefNode::ControlledTimingCheckEvent(_) => write!(f, "ControlledTimingCheckEvent"), + RefNode::TimingCheckEventControl(_) => write!(f, "TimingCheckEventControl"), + RefNode::SpecifyTerminalDescriptor(_) => write!(f, "SpecifyTerminalDescriptor"), + RefNode::EdgeControlSpecifier(_) => write!(f, "EdgeControlSpecifier"), + RefNode::EdgeDescriptor(_) => write!(f, "EdgeDescriptor"), + RefNode::TimingCheckCondition(_) => write!(f, "TimingCheckCondition"), + RefNode::TimingCheckConditionParen(_) => write!(f, "TimingCheckConditionParen"), + RefNode::ScalarTimingCheckCondition(_) => write!(f, "ScalarTimingCheckCondition"), + RefNode::ScalarTimingCheckConditionUnary(_) => { + write!(f, "ScalarTimingCheckConditionUnary") + } + RefNode::ScalarTimingCheckConditionBinary(_) => { + write!(f, "ScalarTimingCheckConditionBinary") + } + RefNode::ScalarConstant(_) => write!(f, "ScalarConstant"), + RefNode::SystemTimingCheck(_) => write!(f, "SystemTimingCheck"), + RefNode::SetupTimingCheck(_) => write!(f, "SetupTimingCheck"), + RefNode::HoldTimingCheck(_) => write!(f, "HoldTimingCheck"), + RefNode::SetupholdTimingCheck(_) => write!(f, "SetupholdTimingCheck"), + RefNode::RecoveryTimingCheck(_) => write!(f, "RecoveryTimingCheck"), + RefNode::RemovalTimingCheck(_) => write!(f, "RemovalTimingCheck"), + RefNode::RecremTimingCheck(_) => write!(f, "RecremTimingCheck"), + RefNode::SkewTimingCheck(_) => write!(f, "SkewTimingCheck"), + RefNode::TimeskewTimingCheck(_) => write!(f, "TimeskewTimingCheck"), + RefNode::FullskewTimingCheck(_) => write!(f, "FullskewTimingCheck"), + RefNode::PeriodTimingCheck(_) => write!(f, "PeriodTimingCheck"), + RefNode::WidthTimingCheck(_) => write!(f, "WidthTimingCheck"), + RefNode::NochangeTimingCheck(_) => write!(f, "NochangeTimingCheck"), + RefNode::TimecheckCondition(_) => write!(f, "TimecheckCondition"), + RefNode::ControlledReferenceEvent(_) => write!(f, "ControlledReferenceEvent"), + RefNode::DataEvent(_) => write!(f, "DataEvent"), + RefNode::DelayedData(_) => write!(f, "DelayedData"), + RefNode::DelayedDataWithMintypmax(_) => write!(f, "DelayedDataWithMintypmax"), + RefNode::DelayedReference(_) => write!(f, "DelayedReference"), + RefNode::DelayedReferenceWithMintypmax(_) => write!(f, "DelayedReferenceWithMintypmax"), + RefNode::EndEdgeOffset(_) => write!(f, "EndEdgeOffset"), + RefNode::EventBasedFlag(_) => write!(f, "EventBasedFlag"), + RefNode::Notifier(_) => write!(f, "Notifier"), + RefNode::ReferenceEvent(_) => write!(f, "ReferenceEvent"), + RefNode::RemainActiveFlag(_) => write!(f, "RemainActiveFlag"), + RefNode::TimestampCondition(_) => write!(f, "TimestampCondition"), + RefNode::StartEdgeOffset(_) => write!(f, "StartEdgeOffset"), + RefNode::Threshold(_) => write!(f, "Threshold"), + RefNode::TimingCheckLimit(_) => write!(f, "TimingCheckLimit"), + RefNode::ProceduralTimingControlStatement(_) => { + write!(f, "ProceduralTimingControlStatement") + } + RefNode::DelayOrEventControl(_) => write!(f, "DelayOrEventControl"), + RefNode::DelayOrEventControlRepeat(_) => write!(f, "DelayOrEventControlRepeat"), + RefNode::DelayControl(_) => write!(f, "DelayControl"), + RefNode::DelayControlDelay(_) => write!(f, "DelayControlDelay"), + RefNode::DelayControlMintypmax(_) => write!(f, "DelayControlMintypmax"), + RefNode::EventControl(_) => write!(f, "EventControl"), + RefNode::EventControlEventIdentifier(_) => write!(f, "EventControlEventIdentifier"), + RefNode::EventControlEventExpression(_) => write!(f, "EventControlEventExpression"), + RefNode::EventControlAsterisk(_) => write!(f, "EventControlAsterisk"), + RefNode::EventControlParenAsterisk(_) => write!(f, "EventControlParenAsterisk"), + RefNode::EventControlSequenceIdentifier(_) => { + write!(f, "EventControlSequenceIdentifier") + } + RefNode::EventExpression(_) => write!(f, "EventExpression"), + RefNode::EventExpressionExpression(_) => write!(f, "EventExpressionExpression"), + RefNode::EventExpressionSequence(_) => write!(f, "EventExpressionSequence"), + RefNode::EventExpressionOr(_) => write!(f, "EventExpressionOr"), + RefNode::EventExpressionComma(_) => write!(f, "EventExpressionComma"), + RefNode::EventExpressionParen(_) => write!(f, "EventExpressionParen"), + RefNode::ProceduralTimingControl(_) => write!(f, "ProceduralTimingControl"), + RefNode::JumpStatement(_) => write!(f, "JumpStatement"), + RefNode::JumpStatementReturn(_) => write!(f, "JumpStatementReturn"), + RefNode::JumpStatementBreak(_) => write!(f, "JumpStatementBreak"), + RefNode::JumpStatementContinue(_) => write!(f, "JumpStatementContinue"), + RefNode::WaitStatement(_) => write!(f, "WaitStatement"), + RefNode::WaitStatementWait(_) => write!(f, "WaitStatementWait"), + RefNode::WaitStatementFork(_) => write!(f, "WaitStatementFork"), + RefNode::WaitStatementOrder(_) => write!(f, "WaitStatementOrder"), + RefNode::EventTrigger(_) => write!(f, "EventTrigger"), + RefNode::EventTriggerNamed(_) => write!(f, "EventTriggerNamed"), + RefNode::EventTriggerNonblocking(_) => write!(f, "EventTriggerNonblocking"), + RefNode::DisableStatement(_) => write!(f, "DisableStatement"), + RefNode::DisableStatementTask(_) => write!(f, "DisableStatementTask"), + RefNode::DisableStatementBlock(_) => write!(f, "DisableStatementBlock"), + RefNode::DisableStatementFork(_) => write!(f, "DisableStatementFork"), + RefNode::ConditionalStatement(_) => write!(f, "ConditionalStatement"), + RefNode::UniquePriority(_) => write!(f, "UniquePriority"), + RefNode::CondPredicate(_) => write!(f, "CondPredicate"), + RefNode::ExpressionOrCondPattern(_) => write!(f, "ExpressionOrCondPattern"), + RefNode::CondPattern(_) => write!(f, "CondPattern"), + RefNode::AssertionItem(_) => write!(f, "AssertionItem"), + RefNode::DeferredImmediateAssertionItem(_) => { + write!(f, "DeferredImmediateAssertionItem") + } + RefNode::ProceduralAssertionStatement(_) => write!(f, "ProceduralAssertionStatement"), + RefNode::ImmediateAssertionStatement(_) => write!(f, "ImmediateAssertionStatement"), + RefNode::SimpleImmediateAssertionStatement(_) => { + write!(f, "SimpleImmediateAssertionStatement") + } + RefNode::SimpleImmediateAssertStatement(_) => { + write!(f, "SimpleImmediateAssertStatement") + } + RefNode::SimpleImmediateAssumeStatement(_) => { + write!(f, "SimpleImmediateAssumeStatement") + } + RefNode::SimpleImmediateCoverStatement(_) => write!(f, "SimpleImmediateCoverStatement"), + RefNode::DeferredImmediateAssertionStatement(_) => { + write!(f, "DeferredImmediateAssertionStatement") + } + RefNode::DeferredImmediateAssertStatement(_) => { + write!(f, "DeferredImmediateAssertStatement") + } + RefNode::DeferredImmediateAssumeStatement(_) => { + write!(f, "DeferredImmediateAssumeStatement") + } + RefNode::DeferredImmediateCoverStatement(_) => { + write!(f, "DeferredImmediateCoverStatement") + } + RefNode::AssertTiming(_) => write!(f, "AssertTiming"), + RefNode::Pattern(_) => write!(f, "Pattern"), + RefNode::PatternVariable(_) => write!(f, "PatternVariable"), + RefNode::PatternTagged(_) => write!(f, "PatternTagged"), + RefNode::PatternList(_) => write!(f, "PatternList"), + RefNode::PatternIdentifierList(_) => write!(f, "PatternIdentifierList"), + RefNode::AssignmentPattern(_) => write!(f, "AssignmentPattern"), + RefNode::AssignmentPatternList(_) => write!(f, "AssignmentPatternList"), + RefNode::AssignmentPatternStructure(_) => write!(f, "AssignmentPatternStructure"), + RefNode::AssignmentPatternArray(_) => write!(f, "AssignmentPatternArray"), + RefNode::AssignmentPatternRepeat(_) => write!(f, "AssignmentPatternRepeat"), + RefNode::StructurePatternKey(_) => write!(f, "StructurePatternKey"), + RefNode::ArrayPatternKey(_) => write!(f, "ArrayPatternKey"), + RefNode::AssignmentPatternKey(_) => write!(f, "AssignmentPatternKey"), + RefNode::AssignmentPatternExpression(_) => write!(f, "AssignmentPatternExpression"), + RefNode::AssignmentPatternExpressionType(_) => { + write!(f, "AssignmentPatternExpressionType") + } + RefNode::ConstantAssignmentPatternExpression(_) => { + write!(f, "ConstantAssignmentPatternExpression") + } + RefNode::AssignmentPatternNetLvalue(_) => write!(f, "AssignmentPatternNetLvalue"), + RefNode::AssignmentPatternVariableLvalue(_) => { + write!(f, "AssignmentPatternVariableLvalue") + } + RefNode::ContinuousAssign(_) => write!(f, "ContinuousAssign"), + RefNode::ContinuousAssignNet(_) => write!(f, "ContinuousAssignNet"), + RefNode::ContinuousAssignVariable(_) => write!(f, "ContinuousAssignVariable"), + RefNode::ListOfNetAssignments(_) => write!(f, "ListOfNetAssignments"), + RefNode::ListOfVariableAssignments(_) => write!(f, "ListOfVariableAssignments"), + RefNode::NetAlias(_) => write!(f, "NetAlias"), + RefNode::NetAssignment(_) => write!(f, "NetAssignment"), + RefNode::SubroutineCallStatement(_) => write!(f, "SubroutineCallStatement"), + RefNode::SubroutineCallStatementFunction(_) => { + write!(f, "SubroutineCallStatementFunction") + } + RefNode::StatementOrNull(_) => write!(f, "StatementOrNull"), + RefNode::StatementOrNullAttribute(_) => write!(f, "StatementOrNullAttribute"), + RefNode::Statement(_) => write!(f, "Statement"), + RefNode::StatementItem(_) => write!(f, "StatementItem"), + RefNode::FunctionStatement(_) => write!(f, "FunctionStatement"), + RefNode::FunctionStatementOrNull(_) => write!(f, "FunctionStatementOrNull"), + RefNode::FunctionStatementOrNullAttribute(_) => { + write!(f, "FunctionStatementOrNullAttribute") + } + RefNode::VariableIdentifierList(_) => write!(f, "VariableIdentifierList"), + RefNode::RandsequenceStatement(_) => write!(f, "RandsequenceStatement"), + RefNode::Production(_) => write!(f, "Production"), + RefNode::RsRule(_) => write!(f, "RsRule"), + RefNode::RsProductionList(_) => write!(f, "RsProductionList"), + RefNode::RsProductionListProd(_) => write!(f, "RsProductionListProd"), + RefNode::RsProductionListJoin(_) => write!(f, "RsProductionListJoin"), + RefNode::WeightSpecification(_) => write!(f, "WeightSpecification"), + RefNode::WeightSpecificationExpression(_) => write!(f, "WeightSpecificationExpression"), + RefNode::RsCodeBlock(_) => write!(f, "RsCodeBlock"), + RefNode::RsProd(_) => write!(f, "RsProd"), + RefNode::ProductionItem(_) => write!(f, "ProductionItem"), + RefNode::RsIfElse(_) => write!(f, "RsIfElse"), + RefNode::RsRepeat(_) => write!(f, "RsRepeat"), + RefNode::RsCase(_) => write!(f, "RsCase"), + RefNode::RsCaseItem(_) => write!(f, "RsCaseItem"), + RefNode::RsCaseItemNondefault(_) => write!(f, "RsCaseItemNondefault"), + RefNode::RsCaseItemDefault(_) => write!(f, "RsCaseItemDefault"), + RefNode::LoopStatement(_) => write!(f, "LoopStatement"), + RefNode::LoopStatementForever(_) => write!(f, "LoopStatementForever"), + RefNode::LoopStatementRepeat(_) => write!(f, "LoopStatementRepeat"), + RefNode::LoopStatementWhile(_) => write!(f, "LoopStatementWhile"), + RefNode::LoopStatementFor(_) => write!(f, "LoopStatementFor"), + RefNode::LoopStatementDoWhile(_) => write!(f, "LoopStatementDoWhile"), + RefNode::LoopStatementForeach(_) => write!(f, "LoopStatementForeach"), + RefNode::ForInitialization(_) => write!(f, "ForInitialization"), + RefNode::ForInitializationDeclaration(_) => write!(f, "ForInitializationDeclaration"), + RefNode::ForVariableDeclaration(_) => write!(f, "ForVariableDeclaration"), + RefNode::Var(_) => write!(f, "Var"), + RefNode::ForStep(_) => write!(f, "ForStep"), + RefNode::ForStepAssignment(_) => write!(f, "ForStepAssignment"), + RefNode::LoopVariables(_) => write!(f, "LoopVariables"), + RefNode::ActionBlock(_) => write!(f, "ActionBlock"), + RefNode::ActionBlockElse(_) => write!(f, "ActionBlockElse"), + RefNode::SeqBlock(_) => write!(f, "SeqBlock"), + RefNode::ParBlock(_) => write!(f, "ParBlock"), + RefNode::JoinKeyword(_) => write!(f, "JoinKeyword"), + RefNode::ClockingDeclaration(_) => write!(f, "ClockingDeclaration"), + RefNode::ClockingDeclarationLocal(_) => write!(f, "ClockingDeclarationLocal"), + RefNode::Default(_) => write!(f, "Default"), + RefNode::ClockingDeclarationGlobal(_) => write!(f, "ClockingDeclarationGlobal"), + RefNode::ClockingEvent(_) => write!(f, "ClockingEvent"), + RefNode::ClockingEventIdentifier(_) => write!(f, "ClockingEventIdentifier"), + RefNode::ClockingEventExpression(_) => write!(f, "ClockingEventExpression"), + RefNode::ClockingItem(_) => write!(f, "ClockingItem"), + RefNode::ClockingItemDefault(_) => write!(f, "ClockingItemDefault"), + RefNode::ClockingItemDirection(_) => write!(f, "ClockingItemDirection"), + RefNode::ClockingItemAssertion(_) => write!(f, "ClockingItemAssertion"), + RefNode::DefaultSkew(_) => write!(f, "DefaultSkew"), + RefNode::DefaultSkewInput(_) => write!(f, "DefaultSkewInput"), + RefNode::DefaultSkewOutput(_) => write!(f, "DefaultSkewOutput"), + RefNode::DefaultSkewInputOutput(_) => write!(f, "DefaultSkewInputOutput"), + RefNode::ClockingDirection(_) => write!(f, "ClockingDirection"), + RefNode::ClockingDirectionInput(_) => write!(f, "ClockingDirectionInput"), + RefNode::ClockingDirectionOutput(_) => write!(f, "ClockingDirectionOutput"), + RefNode::ClockingDirectionInputOutput(_) => write!(f, "ClockingDirectionInputOutput"), + RefNode::ListOfClockingDeclAssign(_) => write!(f, "ListOfClockingDeclAssign"), + RefNode::ClockingDeclAssign(_) => write!(f, "ClockingDeclAssign"), + RefNode::ClockingSkew(_) => write!(f, "ClockingSkew"), + RefNode::ClockingSkewEdge(_) => write!(f, "ClockingSkewEdge"), + RefNode::ClockingDrive(_) => write!(f, "ClockingDrive"), + RefNode::CycleDelay(_) => write!(f, "CycleDelay"), + RefNode::CycleDelayIntegral(_) => write!(f, "CycleDelayIntegral"), + RefNode::CycleDelayIdentifier(_) => write!(f, "CycleDelayIdentifier"), + RefNode::CycleDelayExpression(_) => write!(f, "CycleDelayExpression"), + RefNode::Clockvar(_) => write!(f, "Clockvar"), + RefNode::ClockvarExpression(_) => write!(f, "ClockvarExpression"), + RefNode::CaseStatement(_) => write!(f, "CaseStatement"), + RefNode::CaseStatementNormal(_) => write!(f, "CaseStatementNormal"), + RefNode::CaseStatementMatches(_) => write!(f, "CaseStatementMatches"), + RefNode::CaseStatementInside(_) => write!(f, "CaseStatementInside"), + RefNode::CaseKeyword(_) => write!(f, "CaseKeyword"), + RefNode::CaseExpression(_) => write!(f, "CaseExpression"), + RefNode::CaseExpressionExpression(_) => write!(f, "CaseExpressionExpression"), + RefNode::CaseItem(_) => write!(f, "CaseItem"), + RefNode::CaseItemNondefault(_) => write!(f, "CaseItemNondefault"), + RefNode::CaseItemDefault(_) => write!(f, "CaseItemDefault"), + RefNode::CasePatternItem(_) => write!(f, "CasePatternItem"), + RefNode::CasePatternItemNondefault(_) => write!(f, "CasePatternItemNondefault"), + RefNode::CaseInsideItem(_) => write!(f, "CaseInsideItem"), + RefNode::CaseInsideItemNondefault(_) => write!(f, "CaseInsideItemNondefault"), + RefNode::CaseItemExpression(_) => write!(f, "CaseItemExpression"), + RefNode::RandcaseStatement(_) => write!(f, "RandcaseStatement"), + RefNode::RandcaseItem(_) => write!(f, "RandcaseItem"), + RefNode::OpenRangeList(_) => write!(f, "OpenRangeList"), + RefNode::OpenValueRange(_) => write!(f, "OpenValueRange"), + RefNode::InitialConstruct(_) => write!(f, "InitialConstruct"), + RefNode::AlwaysConstruct(_) => write!(f, "AlwaysConstruct"), + RefNode::AlwaysKeyword(_) => write!(f, "AlwaysKeyword"), + RefNode::FinalConstruct(_) => write!(f, "FinalConstruct"), + RefNode::BlockingAssignment(_) => write!(f, "BlockingAssignment"), + RefNode::BlockingAssignmentVariable(_) => write!(f, "BlockingAssignmentVariable"), + RefNode::BlockingAssignmentNonrangeVariable(_) => { + write!(f, "BlockingAssignmentNonrangeVariable") + } + RefNode::BlockingAssignmentHierarchicalVariable(_) => { + write!(f, "BlockingAssignmentHierarchicalVariable") + } + RefNode::OperatorAssignment(_) => write!(f, "OperatorAssignment"), + RefNode::AssignmentOperator(_) => write!(f, "AssignmentOperator"), + RefNode::NonblockingAssignment(_) => write!(f, "NonblockingAssignment"), + RefNode::ProceduralContinuousAssignment(_) => { + write!(f, "ProceduralContinuousAssignment") + } + RefNode::ProceduralContinuousAssignmentAssign(_) => { + write!(f, "ProceduralContinuousAssignmentAssign") + } + RefNode::ProceduralContinuousAssignmentDeassign(_) => { + write!(f, "ProceduralContinuousAssignmentDeassign") + } + RefNode::ProceduralContinuousAssignmentForceVariable(_) => { + write!(f, "ProceduralContinuousAssignmentForceVariable") + } + RefNode::ProceduralContinuousAssignmentForceNet(_) => { + write!(f, "ProceduralContinuousAssignmentForceNet") + } + RefNode::ProceduralContinuousAssignmentReleaseVariable(_) => { + write!(f, "ProceduralContinuousAssignmentReleaseVariable") + } + RefNode::ProceduralContinuousAssignmentReleaseNet(_) => { + write!(f, "ProceduralContinuousAssignmentReleaseNet") + } + RefNode::VariableAssignment(_) => write!(f, "VariableAssignment"), + } + } +} + +impl std::fmt::Display for AnyNode { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + AnyNode::Locate(_) => write!(f, "Locate"), + AnyNode::Comment(_) => write!(f, "Comment"), + AnyNode::AttributeInstance(_) => write!(f, "AttributeInstance"), + AnyNode::AttrSpec(_) => write!(f, "AttrSpec"), + AnyNode::ArrayIdentifier(_) => write!(f, "ArrayIdentifier"), + AnyNode::BlockIdentifier(_) => write!(f, "BlockIdentifier"), + AnyNode::BinIdentifier(_) => write!(f, "BinIdentifier"), + AnyNode::CIdentifier(_) => write!(f, "CIdentifier"), + AnyNode::CellIdentifier(_) => write!(f, "CellIdentifier"), + AnyNode::CheckerIdentifier(_) => write!(f, "CheckerIdentifier"), + AnyNode::ClassIdentifier(_) => write!(f, "ClassIdentifier"), + AnyNode::ClassVariableIdentifier(_) => write!(f, "ClassVariableIdentifier"), + AnyNode::ClockingIdentifier(_) => write!(f, "ClockingIdentifier"), + AnyNode::ConfigIdentifier(_) => write!(f, "ConfigIdentifier"), + AnyNode::ConstIdentifier(_) => write!(f, "ConstIdentifier"), + AnyNode::ConstraintIdentifier(_) => write!(f, "ConstraintIdentifier"), + AnyNode::CovergroupIdentifier(_) => write!(f, "CovergroupIdentifier"), + AnyNode::CovergroupVariableIdentifier(_) => write!(f, "CovergroupVariableIdentifier"), + AnyNode::CoverPointIdentifier(_) => write!(f, "CoverPointIdentifier"), + AnyNode::CrossIdentifier(_) => write!(f, "CrossIdentifier"), + AnyNode::DynamicArrayVariableIdentifier(_) => { + write!(f, "DynamicArrayVariableIdentifier") + } + AnyNode::EnumIdentifier(_) => write!(f, "EnumIdentifier"), + AnyNode::EscapedIdentifier(_) => write!(f, "EscapedIdentifier"), + AnyNode::FormalIdentifier(_) => write!(f, "FormalIdentifier"), + AnyNode::FormalPortIdentifier(_) => write!(f, "FormalPortIdentifier"), + AnyNode::FunctionIdentifier(_) => write!(f, "FunctionIdentifier"), + AnyNode::GenerateBlockIdentifier(_) => write!(f, "GenerateBlockIdentifier"), + AnyNode::GenvarIdentifier(_) => write!(f, "GenvarIdentifier"), + AnyNode::HierarchicalArrayIdentifier(_) => write!(f, "HierarchicalArrayIdentifier"), + AnyNode::HierarchicalBlockIdentifier(_) => write!(f, "HierarchicalBlockIdentifier"), + AnyNode::HierarchicalEventIdentifier(_) => write!(f, "HierarchicalEventIdentifier"), + AnyNode::HierarchicalIdentifier(_) => write!(f, "HierarchicalIdentifier"), + AnyNode::Root(_) => write!(f, "Root"), + AnyNode::HierarchicalNetIdentifier(_) => write!(f, "HierarchicalNetIdentifier"), + AnyNode::HierarchicalParameterIdentifier(_) => { + write!(f, "HierarchicalParameterIdentifier") + } + AnyNode::HierarchicalPropertyIdentifier(_) => { + write!(f, "HierarchicalPropertyIdentifier") + } + AnyNode::HierarchicalSequenceIdentifier(_) => { + write!(f, "HierarchicalSequenceIdentifier") + } + AnyNode::HierarchicalTaskIdentifier(_) => write!(f, "HierarchicalTaskIdentifier"), + AnyNode::HierarchicalTfIdentifier(_) => write!(f, "HierarchicalTfIdentifier"), + AnyNode::HierarchicalVariableIdentifier(_) => { + write!(f, "HierarchicalVariableIdentifier") + } + AnyNode::Identifier(_) => write!(f, "Identifier"), + AnyNode::IndexVariableIdentifier(_) => write!(f, "IndexVariableIdentifier"), + AnyNode::InterfaceIdentifier(_) => write!(f, "InterfaceIdentifier"), + AnyNode::InterfaceInstanceIdentifier(_) => write!(f, "InterfaceInstanceIdentifier"), + AnyNode::InoutPortIdentifier(_) => write!(f, "InoutPortIdentifier"), + AnyNode::InputPortIdentifier(_) => write!(f, "InputPortIdentifier"), + AnyNode::InstanceIdentifier(_) => write!(f, "InstanceIdentifier"), + AnyNode::LibraryIdentifier(_) => write!(f, "LibraryIdentifier"), + AnyNode::MemberIdentifier(_) => write!(f, "MemberIdentifier"), + AnyNode::MethodIdentifier(_) => write!(f, "MethodIdentifier"), + AnyNode::ModportIdentifier(_) => write!(f, "ModportIdentifier"), + AnyNode::ModuleIdentifier(_) => write!(f, "ModuleIdentifier"), + AnyNode::NetIdentifier(_) => write!(f, "NetIdentifier"), + AnyNode::NetTypeIdentifier(_) => write!(f, "NetTypeIdentifier"), + AnyNode::OutputPortIdentifier(_) => write!(f, "OutputPortIdentifier"), + AnyNode::PackageIdentifier(_) => write!(f, "PackageIdentifier"), + AnyNode::PackageScope(_) => write!(f, "PackageScope"), + AnyNode::PackageScopePackage(_) => write!(f, "PackageScopePackage"), + AnyNode::Unit(_) => write!(f, "Unit"), + AnyNode::ParameterIdentifier(_) => write!(f, "ParameterIdentifier"), + AnyNode::PortIdentifier(_) => write!(f, "PortIdentifier"), + AnyNode::ProductionIdentifier(_) => write!(f, "ProductionIdentifier"), + AnyNode::ProgramIdentifier(_) => write!(f, "ProgramIdentifier"), + AnyNode::PropertyIdentifier(_) => write!(f, "PropertyIdentifier"), + AnyNode::PsClassIdentifier(_) => write!(f, "PsClassIdentifier"), + AnyNode::PsCovergroupIdentifier(_) => write!(f, "PsCovergroupIdentifier"), + AnyNode::PsCheckerIdentifier(_) => write!(f, "PsCheckerIdentifier"), + AnyNode::PsIdentifier(_) => write!(f, "PsIdentifier"), + AnyNode::PsOrHierarchicalArrayIdentifier(_) => { + write!(f, "PsOrHierarchicalArrayIdentifier") + } + AnyNode::PsOrHierarchicalNetIdentifier(_) => write!(f, "PsOrHierarchicalNetIdentifier"), + AnyNode::PsOrHierarchicalNetIdentifierPackageScope(_) => { + write!(f, "PsOrHierarchicalNetIdentifierPackageScope") + } + AnyNode::PsOrHierarchicalNetIdentifierHierarchical(_) => { + write!(f, "PsOrHierarchicalNetIdentifierHierarchical") + } + AnyNode::PsOrHierarchicalPropertyIdentifier(_) => { + write!(f, "PsOrHierarchicalPropertyIdentifier") + } + AnyNode::PsOrHierarchicalPropertyIdentifierPackageScope(_) => { + write!(f, "PsOrHierarchicalPropertyIdentifierPackageScope") + } + AnyNode::PsOrHierarchicalPropertyIdentifierHierarchical(_) => { + write!(f, "PsOrHierarchicalPropertyIdentifierHierarchical") + } + AnyNode::PsOrHierarchicalSequenceIdentifier(_) => { + write!(f, "PsOrHierarchicalSequenceIdentifier") + } + AnyNode::PsOrHierarchicalSequenceIdentifierPackageScope(_) => { + write!(f, "PsOrHierarchicalSequenceIdentifierPackageScope") + } + AnyNode::PsOrHierarchicalSequenceIdentifierHierarchical(_) => { + write!(f, "PsOrHierarchicalSequenceIdentifierHierarchical") + } + AnyNode::PsOrHierarchicalTfIdentifier(_) => write!(f, "PsOrHierarchicalTfIdentifier"), + AnyNode::PsOrHierarchicalTfIdentifierPackageScope(_) => { + write!(f, "PsOrHierarchicalTfIdentifierPackageScope") + } + AnyNode::PsOrHierarchicalTfIdentifierHierarchical(_) => { + write!(f, "PsOrHierarchicalTfIdentifierHierarchical") + } + AnyNode::PsParameterIdentifier(_) => write!(f, "PsParameterIdentifier"), + AnyNode::PsParameterIdentifierScope(_) => write!(f, "PsParameterIdentifierScope"), + AnyNode::PsParameterIdentifierGenerate(_) => write!(f, "PsParameterIdentifierGenerate"), + AnyNode::PsTypeIdentifier(_) => write!(f, "PsTypeIdentifier"), + AnyNode::LocalOrPackageScopeOrClassScope(_) => { + write!(f, "LocalOrPackageScopeOrClassScope") + } + AnyNode::Local(_) => write!(f, "Local"), + AnyNode::SequenceIdentifier(_) => write!(f, "SequenceIdentifier"), + AnyNode::SignalIdentifier(_) => write!(f, "SignalIdentifier"), + AnyNode::SimpleIdentifier(_) => write!(f, "SimpleIdentifier"), + AnyNode::SpecparamIdentifier(_) => write!(f, "SpecparamIdentifier"), + AnyNode::SystemTfIdentifier(_) => write!(f, "SystemTfIdentifier"), + AnyNode::TaskIdentifier(_) => write!(f, "TaskIdentifier"), + AnyNode::TfIdentifier(_) => write!(f, "TfIdentifier"), + AnyNode::TerminalIdentifier(_) => write!(f, "TerminalIdentifier"), + AnyNode::TopmoduleIdentifier(_) => write!(f, "TopmoduleIdentifier"), + AnyNode::TypeIdentifier(_) => write!(f, "TypeIdentifier"), + AnyNode::UdpIdentifier(_) => write!(f, "UdpIdentifier"), + AnyNode::VariableIdentifier(_) => write!(f, "VariableIdentifier"), + AnyNode::ImplicitClassHandleOrClassScopeOrPackageScope(_) => { + write!(f, "ImplicitClassHandleOrClassScopeOrPackageScope") + } + AnyNode::ImplicitClassHandleOrPackageScope(_) => { + write!(f, "ImplicitClassHandleOrPackageScope") + } + AnyNode::ImplicitClassHandleOrClassScope(_) => { + write!(f, "ImplicitClassHandleOrClassScope") + } + AnyNode::PackageScopeOrClassScope(_) => write!(f, "PackageScopeOrClassScope"), + AnyNode::CompilerDirective(_) => write!(f, "CompilerDirective"), + AnyNode::ResetallCompilerDirective(_) => write!(f, "ResetallCompilerDirective"), + AnyNode::IncludeCompilerDirective(_) => write!(f, "IncludeCompilerDirective"), + AnyNode::IncludeCompilerDirectiveDoubleQuote(_) => { + write!(f, "IncludeCompilerDirectiveDoubleQuote") + } + AnyNode::IncludeCompilerDirectiveAngleBracket(_) => { + write!(f, "IncludeCompilerDirectiveAngleBracket") + } + AnyNode::IncludeCompilerDirectiveTextMacroUsage(_) => { + write!(f, "IncludeCompilerDirectiveTextMacroUsage") + } + AnyNode::AngleBracketLiteral(_) => write!(f, "AngleBracketLiteral"), + AnyNode::TextMacroDefinition(_) => write!(f, "TextMacroDefinition"), + AnyNode::TextMacroName(_) => write!(f, "TextMacroName"), + AnyNode::ListOfFormalArguments(_) => write!(f, "ListOfFormalArguments"), + AnyNode::FormalArgument(_) => write!(f, "FormalArgument"), + AnyNode::TextMacroIdentifier(_) => write!(f, "TextMacroIdentifier"), + AnyNode::MacroText(_) => write!(f, "MacroText"), + AnyNode::DefaultText(_) => write!(f, "DefaultText"), + AnyNode::TextMacroUsage(_) => write!(f, "TextMacroUsage"), + AnyNode::ListOfActualArguments(_) => write!(f, "ListOfActualArguments"), + AnyNode::ActualArgument(_) => write!(f, "ActualArgument"), + AnyNode::UndefineCompilerDirective(_) => write!(f, "UndefineCompilerDirective"), + AnyNode::UndefineallCompilerDirective(_) => write!(f, "UndefineallCompilerDirective"), + AnyNode::ConditionalCompilerDirective(_) => write!(f, "ConditionalCompilerDirective"), + AnyNode::IfdefDirective(_) => write!(f, "IfdefDirective"), + AnyNode::IfndefDirective(_) => write!(f, "IfndefDirective"), + AnyNode::IfdefGroupOfLines(_) => write!(f, "IfdefGroupOfLines"), + AnyNode::IfndefGroupOfLines(_) => write!(f, "IfndefGroupOfLines"), + AnyNode::ElsifGroupOfLines(_) => write!(f, "ElsifGroupOfLines"), + AnyNode::ElseGroupOfLines(_) => write!(f, "ElseGroupOfLines"), + AnyNode::SourceDescription(_) => write!(f, "SourceDescription"), + AnyNode::SourceDescriptionNotDirective(_) => write!(f, "SourceDescriptionNotDirective"), + AnyNode::TimescaleCompilerDirective(_) => write!(f, "TimescaleCompilerDirective"), + AnyNode::DefaultNettypeCompilerDirective(_) => { + write!(f, "DefaultNettypeCompilerDirective") + } + AnyNode::DefaultNettypeValue(_) => write!(f, "DefaultNettypeValue"), + AnyNode::UnconnectedDriveCompilerDirective(_) => { + write!(f, "UnconnectedDriveCompilerDirective") + } + AnyNode::NounconnectedDriveCompilerDirective(_) => { + write!(f, "NounconnectedDriveCompilerDirective") + } + AnyNode::CelldefineDriveCompilerDirective(_) => { + write!(f, "CelldefineDriveCompilerDirective") + } + AnyNode::EndcelldefineDriveCompilerDirective(_) => { + write!(f, "EndcelldefineDriveCompilerDirective") + } + AnyNode::Pragma(_) => write!(f, "Pragma"), + AnyNode::PragmaName(_) => write!(f, "PragmaName"), + AnyNode::PragmaExpression(_) => write!(f, "PragmaExpression"), + AnyNode::PragmaExpressionAssignment(_) => write!(f, "PragmaExpressionAssignment"), + AnyNode::PragmaValue(_) => write!(f, "PragmaValue"), + AnyNode::PragmaValueParen(_) => write!(f, "PragmaValueParen"), + AnyNode::PragmaKeyword(_) => write!(f, "PragmaKeyword"), + AnyNode::LineCompilerDirective(_) => write!(f, "LineCompilerDirective"), + AnyNode::PositionCompilerDirective(_) => write!(f, "PositionCompilerDirective"), + AnyNode::Level(_) => write!(f, "Level"), + AnyNode::KeywordsDirective(_) => write!(f, "KeywordsDirective"), + AnyNode::VersionSpecifier(_) => write!(f, "VersionSpecifier"), + AnyNode::EndkeywordsDirective(_) => write!(f, "EndkeywordsDirective"), + AnyNode::DriveStrength(_) => write!(f, "DriveStrength"), + AnyNode::DriveStrength01(_) => write!(f, "DriveStrength01"), + AnyNode::DriveStrength10(_) => write!(f, "DriveStrength10"), + AnyNode::DriveStrength0z(_) => write!(f, "DriveStrength0z"), + AnyNode::DriveStrength1z(_) => write!(f, "DriveStrength1z"), + AnyNode::DriveStrengthz1(_) => write!(f, "DriveStrengthz1"), + AnyNode::DriveStrengthz0(_) => write!(f, "DriveStrengthz0"), + AnyNode::Strength0(_) => write!(f, "Strength0"), + AnyNode::Strength1(_) => write!(f, "Strength1"), + AnyNode::ChargeStrength(_) => write!(f, "ChargeStrength"), + AnyNode::ChargeStrengthSmall(_) => write!(f, "ChargeStrengthSmall"), + AnyNode::ChargeStrengthMedium(_) => write!(f, "ChargeStrengthMedium"), + AnyNode::ChargeStrengthLarge(_) => write!(f, "ChargeStrengthLarge"), + AnyNode::ModportDeclaration(_) => write!(f, "ModportDeclaration"), + AnyNode::ModportItem(_) => write!(f, "ModportItem"), + AnyNode::ModportPortsDeclaration(_) => write!(f, "ModportPortsDeclaration"), + AnyNode::ModportPortsDeclarationSimple(_) => write!(f, "ModportPortsDeclarationSimple"), + AnyNode::ModportPortsDeclarationTf(_) => write!(f, "ModportPortsDeclarationTf"), + AnyNode::ModportPortsDeclarationClocking(_) => { + write!(f, "ModportPortsDeclarationClocking") + } + AnyNode::ModportClockingDeclaration(_) => write!(f, "ModportClockingDeclaration"), + AnyNode::ModportSimplePortsDeclaration(_) => write!(f, "ModportSimplePortsDeclaration"), + AnyNode::ModportSimplePort(_) => write!(f, "ModportSimplePort"), + AnyNode::ModportSimplePortOrdered(_) => write!(f, "ModportSimplePortOrdered"), + AnyNode::ModportSimplePortNamed(_) => write!(f, "ModportSimplePortNamed"), + AnyNode::ModportTfPortsDeclaration(_) => write!(f, "ModportTfPortsDeclaration"), + AnyNode::ModportTfPort(_) => write!(f, "ModportTfPort"), + AnyNode::ImportExport(_) => write!(f, "ImportExport"), + AnyNode::FunctionDataTypeOrImplicit(_) => write!(f, "FunctionDataTypeOrImplicit"), + AnyNode::FunctionDeclaration(_) => write!(f, "FunctionDeclaration"), + AnyNode::FunctionBodyDeclaration(_) => write!(f, "FunctionBodyDeclaration"), + AnyNode::FunctionBodyDeclarationWithoutPort(_) => { + write!(f, "FunctionBodyDeclarationWithoutPort") + } + AnyNode::FunctionBodyDeclarationWithPort(_) => { + write!(f, "FunctionBodyDeclarationWithPort") + } + AnyNode::InterfaceIdentifierOrClassScope(_) => { + write!(f, "InterfaceIdentifierOrClassScope") + } + AnyNode::FunctionPrototype(_) => write!(f, "FunctionPrototype"), + AnyNode::DpiImportExport(_) => write!(f, "DpiImportExport"), + AnyNode::DpiImportExportImportFunction(_) => write!(f, "DpiImportExportImportFunction"), + AnyNode::DpiImportExportImportTask(_) => write!(f, "DpiImportExportImportTask"), + AnyNode::DpiImportExportExportFunction(_) => write!(f, "DpiImportExportExportFunction"), + AnyNode::DpiImportExportExportTask(_) => write!(f, "DpiImportExportExportTask"), + AnyNode::DpiSpecString(_) => write!(f, "DpiSpecString"), + AnyNode::DpiFunctionImportProperty(_) => write!(f, "DpiFunctionImportProperty"), + AnyNode::DpiTaskImportProperty(_) => write!(f, "DpiTaskImportProperty"), + AnyNode::DpiFunctionProto(_) => write!(f, "DpiFunctionProto"), + AnyNode::DpiTaskProto(_) => write!(f, "DpiTaskProto"), + AnyNode::CovergroupDeclaration(_) => write!(f, "CovergroupDeclaration"), + AnyNode::CoverageSpecOrOption(_) => write!(f, "CoverageSpecOrOption"), + AnyNode::CoverageSpecOrOptionSpec(_) => write!(f, "CoverageSpecOrOptionSpec"), + AnyNode::CoverageSpecOrOptionOption(_) => write!(f, "CoverageSpecOrOptionOption"), + AnyNode::CoverageOption(_) => write!(f, "CoverageOption"), + AnyNode::CoverageOptionOption(_) => write!(f, "CoverageOptionOption"), + AnyNode::CoverageOptionTypeOption(_) => write!(f, "CoverageOptionTypeOption"), + AnyNode::CoverageSpec(_) => write!(f, "CoverageSpec"), + AnyNode::CoverageEvent(_) => write!(f, "CoverageEvent"), + AnyNode::CoverageEventSample(_) => write!(f, "CoverageEventSample"), + AnyNode::CoverageEventAt(_) => write!(f, "CoverageEventAt"), + AnyNode::BlockEventExpression(_) => write!(f, "BlockEventExpression"), + AnyNode::BlockEventExpressionOr(_) => write!(f, "BlockEventExpressionOr"), + AnyNode::BlockEventExpressionBegin(_) => write!(f, "BlockEventExpressionBegin"), + AnyNode::BlockEventExpressionEnd(_) => write!(f, "BlockEventExpressionEnd"), + AnyNode::HierarchicalBtfIdentifier(_) => write!(f, "HierarchicalBtfIdentifier"), + AnyNode::HierarchicalBtfIdentifierMethod(_) => { + write!(f, "HierarchicalBtfIdentifierMethod") + } + AnyNode::HierarchicalIdentifierOrClassScope(_) => { + write!(f, "HierarchicalIdentifierOrClassScope") + } + AnyNode::CoverPoint(_) => write!(f, "CoverPoint"), + AnyNode::BinsOrEmpty(_) => write!(f, "BinsOrEmpty"), + AnyNode::BinsOrEmptyNonEmpty(_) => write!(f, "BinsOrEmptyNonEmpty"), + AnyNode::BinsOrOptions(_) => write!(f, "BinsOrOptions"), + AnyNode::BinsOrOptionsCovergroup(_) => write!(f, "BinsOrOptionsCovergroup"), + AnyNode::Wildcard(_) => write!(f, "Wildcard"), + AnyNode::BinsOrOptionsCoverPoint(_) => write!(f, "BinsOrOptionsCoverPoint"), + AnyNode::BinsOrOptionsSetCovergroup(_) => write!(f, "BinsOrOptionsSetCovergroup"), + AnyNode::BinsOrOptionsTransList(_) => write!(f, "BinsOrOptionsTransList"), + AnyNode::BinsOrOptionsDefault(_) => write!(f, "BinsOrOptionsDefault"), + AnyNode::BinsOrOptionsDefaultSequence(_) => write!(f, "BinsOrOptionsDefaultSequence"), + AnyNode::BinsKeyword(_) => write!(f, "BinsKeyword"), + AnyNode::TransList(_) => write!(f, "TransList"), + AnyNode::TransSet(_) => write!(f, "TransSet"), + AnyNode::TransRangeList(_) => write!(f, "TransRangeList"), + AnyNode::TransRangeListAsterisk(_) => write!(f, "TransRangeListAsterisk"), + AnyNode::TransRangeListArrow(_) => write!(f, "TransRangeListArrow"), + AnyNode::TransRangeListEqual(_) => write!(f, "TransRangeListEqual"), + AnyNode::TransItem(_) => write!(f, "TransItem"), + AnyNode::RepeatRange(_) => write!(f, "RepeatRange"), + AnyNode::RepeatRangeBinary(_) => write!(f, "RepeatRangeBinary"), + AnyNode::CoverCross(_) => write!(f, "CoverCross"), + AnyNode::ListOfCrossItems(_) => write!(f, "ListOfCrossItems"), + AnyNode::CrossItem(_) => write!(f, "CrossItem"), + AnyNode::CrossBody(_) => write!(f, "CrossBody"), + AnyNode::CrossBodyNonEmpty(_) => write!(f, "CrossBodyNonEmpty"), + AnyNode::CrossBodyItem(_) => write!(f, "CrossBodyItem"), + AnyNode::BinsSelectionOrOption(_) => write!(f, "BinsSelectionOrOption"), + AnyNode::BinsSelectionOrOptionCoverage(_) => write!(f, "BinsSelectionOrOptionCoverage"), + AnyNode::BinsSelectionOrOptionBins(_) => write!(f, "BinsSelectionOrOptionBins"), + AnyNode::BinsSelection(_) => write!(f, "BinsSelection"), + AnyNode::SelectExpression(_) => write!(f, "SelectExpression"), + AnyNode::SelectExpressionNot(_) => write!(f, "SelectExpressionNot"), + AnyNode::SelectExpressionAnd(_) => write!(f, "SelectExpressionAnd"), + AnyNode::SelectExpressionOr(_) => write!(f, "SelectExpressionOr"), + AnyNode::SelectExpressionParen(_) => write!(f, "SelectExpressionParen"), + AnyNode::SelectExpressionWith(_) => write!(f, "SelectExpressionWith"), + AnyNode::SelectExpressionCrossSet(_) => write!(f, "SelectExpressionCrossSet"), + AnyNode::SelectCondition(_) => write!(f, "SelectCondition"), + AnyNode::BinsExpression(_) => write!(f, "BinsExpression"), + AnyNode::BinsExpressionCoverPoint(_) => write!(f, "BinsExpressionCoverPoint"), + AnyNode::CovergroupRangeList(_) => write!(f, "CovergroupRangeList"), + AnyNode::CovergroupValueRange(_) => write!(f, "CovergroupValueRange"), + AnyNode::CovergroupValueRangeBinary(_) => write!(f, "CovergroupValueRangeBinary"), + AnyNode::WithCovergroupExpression(_) => write!(f, "WithCovergroupExpression"), + AnyNode::SetCovergroupExpression(_) => write!(f, "SetCovergroupExpression"), + AnyNode::IntegerCovergroupExpression(_) => write!(f, "IntegerCovergroupExpression"), + AnyNode::CrossSetExpression(_) => write!(f, "CrossSetExpression"), + AnyNode::CovergroupExpression(_) => write!(f, "CovergroupExpression"), + AnyNode::DataDeclaration(_) => write!(f, "DataDeclaration"), + AnyNode::DataDeclarationVariable(_) => write!(f, "DataDeclarationVariable"), + AnyNode::Const(_) => write!(f, "Const"), + AnyNode::PackageImportDeclaration(_) => write!(f, "PackageImportDeclaration"), + AnyNode::PackageImportItem(_) => write!(f, "PackageImportItem"), + AnyNode::PackageImportItemIdentifier(_) => write!(f, "PackageImportItemIdentifier"), + AnyNode::PackageImportItemAsterisk(_) => write!(f, "PackageImportItemAsterisk"), + AnyNode::PackageExportDeclaration(_) => write!(f, "PackageExportDeclaration"), + AnyNode::PackageExportDeclarationAsterisk(_) => { + write!(f, "PackageExportDeclarationAsterisk") + } + AnyNode::PackageExportDeclarationItem(_) => write!(f, "PackageExportDeclarationItem"), + AnyNode::GenvarDeclaration(_) => write!(f, "GenvarDeclaration"), + AnyNode::NetDeclaration(_) => write!(f, "NetDeclaration"), + AnyNode::NetDeclarationNetType(_) => write!(f, "NetDeclarationNetType"), + AnyNode::Strength(_) => write!(f, "Strength"), + AnyNode::VectorScalar(_) => write!(f, "VectorScalar"), + AnyNode::NetDeclarationNetTypeIdentifier(_) => { + write!(f, "NetDeclarationNetTypeIdentifier") + } + AnyNode::NetDeclarationInterconnect(_) => write!(f, "NetDeclarationInterconnect"), + AnyNode::TypeDeclaration(_) => write!(f, "TypeDeclaration"), + AnyNode::TypeDeclarationDataType(_) => write!(f, "TypeDeclarationDataType"), + AnyNode::TypeDeclarationInterface(_) => write!(f, "TypeDeclarationInterface"), + AnyNode::TypeDeclarationReserved(_) => write!(f, "TypeDeclarationReserved"), + AnyNode::TypeDeclarationKeyword(_) => write!(f, "TypeDeclarationKeyword"), + AnyNode::NetTypeDeclaration(_) => write!(f, "NetTypeDeclaration"), + AnyNode::NetTypeDeclarationDataType(_) => write!(f, "NetTypeDeclarationDataType"), + AnyNode::NetTypeDeclarationNetType(_) => write!(f, "NetTypeDeclarationNetType"), + AnyNode::Lifetime(_) => write!(f, "Lifetime"), + AnyNode::ConcurrentAssertionItem(_) => write!(f, "ConcurrentAssertionItem"), + AnyNode::ConcurrentAssertionItemStatement(_) => { + write!(f, "ConcurrentAssertionItemStatement") + } + AnyNode::ConcurrentAssertionStatement(_) => write!(f, "ConcurrentAssertionStatement"), + AnyNode::AssertPropertyStatement(_) => write!(f, "AssertPropertyStatement"), + AnyNode::AssumePropertyStatement(_) => write!(f, "AssumePropertyStatement"), + AnyNode::CoverPropertyStatement(_) => write!(f, "CoverPropertyStatement"), + AnyNode::ExpectPropertyStatement(_) => write!(f, "ExpectPropertyStatement"), + AnyNode::CoverSequenceStatement(_) => write!(f, "CoverSequenceStatement"), + AnyNode::RestrictPropertyStatement(_) => write!(f, "RestrictPropertyStatement"), + AnyNode::PropertyInstance(_) => write!(f, "PropertyInstance"), + AnyNode::PropertyListOfArguments(_) => write!(f, "PropertyListOfArguments"), + AnyNode::PropertyListOfArgumentsOrdered(_) => { + write!(f, "PropertyListOfArgumentsOrdered") + } + AnyNode::PropertyListOfArgumentsNamed(_) => write!(f, "PropertyListOfArgumentsNamed"), + AnyNode::PropertyActualArg(_) => write!(f, "PropertyActualArg"), + AnyNode::AssertionItemDeclaration(_) => write!(f, "AssertionItemDeclaration"), + AnyNode::PropertyDeclaration(_) => write!(f, "PropertyDeclaration"), + AnyNode::PropertyPortList(_) => write!(f, "PropertyPortList"), + AnyNode::PropertyPortItem(_) => write!(f, "PropertyPortItem"), + AnyNode::PropertyLvarPortDirection(_) => write!(f, "PropertyLvarPortDirection"), + AnyNode::PropertyFormalType(_) => write!(f, "PropertyFormalType"), + AnyNode::PropertySpec(_) => write!(f, "PropertySpec"), + AnyNode::PropertyExpr(_) => write!(f, "PropertyExpr"), + AnyNode::PropertyExprStrong(_) => write!(f, "PropertyExprStrong"), + AnyNode::PropertyExprWeak(_) => write!(f, "PropertyExprWeak"), + AnyNode::PropertyExprParen(_) => write!(f, "PropertyExprParen"), + AnyNode::PropertyExprNot(_) => write!(f, "PropertyExprNot"), + AnyNode::PropertyExprBinaryProperty(_) => write!(f, "PropertyExprBinaryProperty"), + AnyNode::PropertyExprBinarySequence(_) => write!(f, "PropertyExprBinarySequence"), + AnyNode::PropertyExprIf(_) => write!(f, "PropertyExprIf"), + AnyNode::PropertyExprCase(_) => write!(f, "PropertyExprCase"), + AnyNode::PropertyExprNexttime(_) => write!(f, "PropertyExprNexttime"), + AnyNode::PropertyExprSNexttime(_) => write!(f, "PropertyExprSNexttime"), + AnyNode::PropertyExprAlways(_) => write!(f, "PropertyExprAlways"), + AnyNode::PropertyExprSAlways(_) => write!(f, "PropertyExprSAlways"), + AnyNode::PropertyExprEventually(_) => write!(f, "PropertyExprEventually"), + AnyNode::PropertyExprSEventually(_) => write!(f, "PropertyExprSEventually"), + AnyNode::PropertyExprAcceptOn(_) => write!(f, "PropertyExprAcceptOn"), + AnyNode::PropertyExprRejectOn(_) => write!(f, "PropertyExprRejectOn"), + AnyNode::PropertyExprSyncAcceptOn(_) => write!(f, "PropertyExprSyncAcceptOn"), + AnyNode::PropertyExprSyncRejectOn(_) => write!(f, "PropertyExprSyncRejectOn"), + AnyNode::PropertyExprClockingEvent(_) => write!(f, "PropertyExprClockingEvent"), + AnyNode::PropertyCaseItem(_) => write!(f, "PropertyCaseItem"), + AnyNode::PropertyCaseItemNondefault(_) => write!(f, "PropertyCaseItemNondefault"), + AnyNode::PropertyCaseItemDefault(_) => write!(f, "PropertyCaseItemDefault"), + AnyNode::SequenceDeclaration(_) => write!(f, "SequenceDeclaration"), + AnyNode::SequencePortList(_) => write!(f, "SequencePortList"), + AnyNode::SequencePortItem(_) => write!(f, "SequencePortItem"), + AnyNode::SequenceLvarPortDirection(_) => write!(f, "SequenceLvarPortDirection"), + AnyNode::SequenceFormalType(_) => write!(f, "SequenceFormalType"), + AnyNode::SequenceExpr(_) => write!(f, "SequenceExpr"), + AnyNode::SequenceExprCycleDelayExpr(_) => write!(f, "SequenceExprCycleDelayExpr"), + AnyNode::SequenceExprExprCycleDelayExpr(_) => { + write!(f, "SequenceExprExprCycleDelayExpr") + } + AnyNode::SequenceExprExpression(_) => write!(f, "SequenceExprExpression"), + AnyNode::SequenceExprInstance(_) => write!(f, "SequenceExprInstance"), + AnyNode::SequenceExprParen(_) => write!(f, "SequenceExprParen"), + AnyNode::SequenceExprBinary(_) => write!(f, "SequenceExprBinary"), + AnyNode::SequenceExprFirstMatch(_) => write!(f, "SequenceExprFirstMatch"), + AnyNode::SequenceExprThroughout(_) => write!(f, "SequenceExprThroughout"), + AnyNode::SequenceExprClockingEvent(_) => write!(f, "SequenceExprClockingEvent"), + AnyNode::CycleDelayRange(_) => write!(f, "CycleDelayRange"), + AnyNode::CycleDelayRangePrimary(_) => write!(f, "CycleDelayRangePrimary"), + AnyNode::CycleDelayRangeExpression(_) => write!(f, "CycleDelayRangeExpression"), + AnyNode::CycleDelayRangeAsterisk(_) => write!(f, "CycleDelayRangeAsterisk"), + AnyNode::CycleDelayRangePlus(_) => write!(f, "CycleDelayRangePlus"), + AnyNode::SequenceMethodCall(_) => write!(f, "SequenceMethodCall"), + AnyNode::SequenceMatchItem(_) => write!(f, "SequenceMatchItem"), + AnyNode::SequenceInstance(_) => write!(f, "SequenceInstance"), + AnyNode::SequenceListOfArguments(_) => write!(f, "SequenceListOfArguments"), + AnyNode::SequenceListOfArgumentsOrdered(_) => { + write!(f, "SequenceListOfArgumentsOrdered") + } + AnyNode::SequenceListOfArgumentsNamed(_) => write!(f, "SequenceListOfArgumentsNamed"), + AnyNode::SequenceActualArg(_) => write!(f, "SequenceActualArg"), + AnyNode::BooleanAbbrev(_) => write!(f, "BooleanAbbrev"), + AnyNode::SequenceAbbrev(_) => write!(f, "SequenceAbbrev"), + AnyNode::ConsecutiveRepetition(_) => write!(f, "ConsecutiveRepetition"), + AnyNode::ConsecutiveRepetitionExpression(_) => { + write!(f, "ConsecutiveRepetitionExpression") + } + AnyNode::ConsecutiveRepetitionAsterisk(_) => write!(f, "ConsecutiveRepetitionAsterisk"), + AnyNode::ConsecutiveRepetitionPlus(_) => write!(f, "ConsecutiveRepetitionPlus"), + AnyNode::NonConsecutiveRepetition(_) => write!(f, "NonConsecutiveRepetition"), + AnyNode::GotoRepetition(_) => write!(f, "GotoRepetition"), + AnyNode::ConstOrRangeExpression(_) => write!(f, "ConstOrRangeExpression"), + AnyNode::CycleDelayConstRangeExpression(_) => { + write!(f, "CycleDelayConstRangeExpression") + } + AnyNode::CycleDelayConstRangeExpressionBinary(_) => { + write!(f, "CycleDelayConstRangeExpressionBinary") + } + AnyNode::CycleDelayConstRangeExpressionDollar(_) => { + write!(f, "CycleDelayConstRangeExpressionDollar") + } + AnyNode::ExpressionOrDist(_) => write!(f, "ExpressionOrDist"), + AnyNode::AssertionVariableDeclaration(_) => write!(f, "AssertionVariableDeclaration"), + AnyNode::LetDeclaration(_) => write!(f, "LetDeclaration"), + AnyNode::LetIdentifier(_) => write!(f, "LetIdentifier"), + AnyNode::LetPortList(_) => write!(f, "LetPortList"), + AnyNode::LetPortItem(_) => write!(f, "LetPortItem"), + AnyNode::LetFormalType(_) => write!(f, "LetFormalType"), + AnyNode::LetExpression(_) => write!(f, "LetExpression"), + AnyNode::LetListOfArguments(_) => write!(f, "LetListOfArguments"), + AnyNode::LetListOfArgumentsOrdered(_) => write!(f, "LetListOfArgumentsOrdered"), + AnyNode::LetListOfArgumentsNamed(_) => write!(f, "LetListOfArgumentsNamed"), + AnyNode::LetActualArg(_) => write!(f, "LetActualArg"), + AnyNode::CastingType(_) => write!(f, "CastingType"), + AnyNode::DataType(_) => write!(f, "DataType"), + AnyNode::DataTypeVector(_) => write!(f, "DataTypeVector"), + AnyNode::DataTypeAtom(_) => write!(f, "DataTypeAtom"), + AnyNode::DataTypeStructUnion(_) => write!(f, "DataTypeStructUnion"), + AnyNode::Packed(_) => write!(f, "Packed"), + AnyNode::DataTypeEnum(_) => write!(f, "DataTypeEnum"), + AnyNode::DataTypeVirtual(_) => write!(f, "DataTypeVirtual"), + AnyNode::Interface(_) => write!(f, "Interface"), + AnyNode::DataTypeType(_) => write!(f, "DataTypeType"), + AnyNode::DataTypeOrImplicit(_) => write!(f, "DataTypeOrImplicit"), + AnyNode::ImplicitDataType(_) => write!(f, "ImplicitDataType"), + AnyNode::EnumBaseType(_) => write!(f, "EnumBaseType"), + AnyNode::EnumBaseTypeAtom(_) => write!(f, "EnumBaseTypeAtom"), + AnyNode::EnumBaseTypeVector(_) => write!(f, "EnumBaseTypeVector"), + AnyNode::EnumBaseTypeType(_) => write!(f, "EnumBaseTypeType"), + AnyNode::EnumNameDeclaration(_) => write!(f, "EnumNameDeclaration"), + AnyNode::ClassScope(_) => write!(f, "ClassScope"), + AnyNode::ClassType(_) => write!(f, "ClassType"), + AnyNode::IntegerType(_) => write!(f, "IntegerType"), + AnyNode::IntegerAtomType(_) => write!(f, "IntegerAtomType"), + AnyNode::IntegerVectorType(_) => write!(f, "IntegerVectorType"), + AnyNode::NonIntegerType(_) => write!(f, "NonIntegerType"), + AnyNode::NetType(_) => write!(f, "NetType"), + AnyNode::NetPortType(_) => write!(f, "NetPortType"), + AnyNode::NetPortTypeDataType(_) => write!(f, "NetPortTypeDataType"), + AnyNode::NetPortTypeInterconnect(_) => write!(f, "NetPortTypeInterconnect"), + AnyNode::VariablePortType(_) => write!(f, "VariablePortType"), + AnyNode::VarDataType(_) => write!(f, "VarDataType"), + AnyNode::VarDataTypeVar(_) => write!(f, "VarDataTypeVar"), + AnyNode::Signing(_) => write!(f, "Signing"), + AnyNode::SimpleType(_) => write!(f, "SimpleType"), + AnyNode::StructUnionMember(_) => write!(f, "StructUnionMember"), + AnyNode::DataTypeOrVoid(_) => write!(f, "DataTypeOrVoid"), + AnyNode::StructUnion(_) => write!(f, "StructUnion"), + AnyNode::TypeReference(_) => write!(f, "TypeReference"), + AnyNode::TypeReferenceExpression(_) => write!(f, "TypeReferenceExpression"), + AnyNode::TypeReferenceDataType(_) => write!(f, "TypeReferenceDataType"), + AnyNode::LocalParameterDeclaration(_) => write!(f, "LocalParameterDeclaration"), + AnyNode::LocalParameterDeclarationParam(_) => { + write!(f, "LocalParameterDeclarationParam") + } + AnyNode::LocalParameterDeclarationType(_) => write!(f, "LocalParameterDeclarationType"), + AnyNode::ParameterDeclaration(_) => write!(f, "ParameterDeclaration"), + AnyNode::ParameterDeclarationParam(_) => write!(f, "ParameterDeclarationParam"), + AnyNode::ParameterDeclarationType(_) => write!(f, "ParameterDeclarationType"), + AnyNode::SpecparamDeclaration(_) => write!(f, "SpecparamDeclaration"), + AnyNode::BlockItemDeclaration(_) => write!(f, "BlockItemDeclaration"), + AnyNode::BlockItemDeclarationData(_) => write!(f, "BlockItemDeclarationData"), + AnyNode::BlockItemDeclarationLocalParameter(_) => { + write!(f, "BlockItemDeclarationLocalParameter") + } + AnyNode::BlockItemDeclarationParameter(_) => write!(f, "BlockItemDeclarationParameter"), + AnyNode::BlockItemDeclarationLet(_) => write!(f, "BlockItemDeclarationLet"), + AnyNode::ListOfDefparamAssignments(_) => write!(f, "ListOfDefparamAssignments"), + AnyNode::ListOfGenvarIdentifiers(_) => write!(f, "ListOfGenvarIdentifiers"), + AnyNode::ListOfInterfaceIdentifiers(_) => write!(f, "ListOfInterfaceIdentifiers"), + AnyNode::ListOfNetDeclAssignments(_) => write!(f, "ListOfNetDeclAssignments"), + AnyNode::ListOfParamAssignments(_) => write!(f, "ListOfParamAssignments"), + AnyNode::ListOfPortIdentifiers(_) => write!(f, "ListOfPortIdentifiers"), + AnyNode::ListOfUdpPortIdentifiers(_) => write!(f, "ListOfUdpPortIdentifiers"), + AnyNode::ListOfSpecparamAssignments(_) => write!(f, "ListOfSpecparamAssignments"), + AnyNode::ListOfTfVariableIdentifiers(_) => write!(f, "ListOfTfVariableIdentifiers"), + AnyNode::ListOfTypeAssignments(_) => write!(f, "ListOfTypeAssignments"), + AnyNode::ListOfVariableDeclAssignments(_) => write!(f, "ListOfVariableDeclAssignments"), + AnyNode::ListOfVariableIdentifiers(_) => write!(f, "ListOfVariableIdentifiers"), + AnyNode::ListOfVariablePortIdentifiers(_) => write!(f, "ListOfVariablePortIdentifiers"), + AnyNode::DefparamAssignment(_) => write!(f, "DefparamAssignment"), + AnyNode::NetDeclAssignment(_) => write!(f, "NetDeclAssignment"), + AnyNode::ParamAssignment(_) => write!(f, "ParamAssignment"), + AnyNode::SpecparamAssignment(_) => write!(f, "SpecparamAssignment"), + AnyNode::SpecparamAssignmentMintypmax(_) => write!(f, "SpecparamAssignmentMintypmax"), + AnyNode::TypeAssignment(_) => write!(f, "TypeAssignment"), + AnyNode::PulseControlSpecparam(_) => write!(f, "PulseControlSpecparam"), + AnyNode::PulseControlSpecparamWithoutDescriptor(_) => { + write!(f, "PulseControlSpecparamWithoutDescriptor") + } + AnyNode::PulseControlSpecparamWithDescriptor(_) => { + write!(f, "PulseControlSpecparamWithDescriptor") + } + AnyNode::ErrorLimitValue(_) => write!(f, "ErrorLimitValue"), + AnyNode::RejectLimitValue(_) => write!(f, "RejectLimitValue"), + AnyNode::LimitValue(_) => write!(f, "LimitValue"), + AnyNode::VariableDeclAssignment(_) => write!(f, "VariableDeclAssignment"), + AnyNode::VariableDeclAssignmentVariable(_) => { + write!(f, "VariableDeclAssignmentVariable") + } + AnyNode::VariableDeclAssignmentDynamicArray(_) => { + write!(f, "VariableDeclAssignmentDynamicArray") + } + AnyNode::VariableDeclAssignmentClass(_) => write!(f, "VariableDeclAssignmentClass"), + AnyNode::ClassNew(_) => write!(f, "ClassNew"), + AnyNode::ClassNewArgument(_) => write!(f, "ClassNewArgument"), + AnyNode::ClassNewExpression(_) => write!(f, "ClassNewExpression"), + AnyNode::DynamicArrayNew(_) => write!(f, "DynamicArrayNew"), + AnyNode::UnpackedDimension(_) => write!(f, "UnpackedDimension"), + AnyNode::UnpackedDimensionRange(_) => write!(f, "UnpackedDimensionRange"), + AnyNode::UnpackedDimensionExpression(_) => write!(f, "UnpackedDimensionExpression"), + AnyNode::PackedDimension(_) => write!(f, "PackedDimension"), + AnyNode::PackedDimensionRange(_) => write!(f, "PackedDimensionRange"), + AnyNode::AssociativeDimension(_) => write!(f, "AssociativeDimension"), + AnyNode::AssociativeDimensionDataType(_) => write!(f, "AssociativeDimensionDataType"), + AnyNode::AssociativeDimensionAsterisk(_) => write!(f, "AssociativeDimensionAsterisk"), + AnyNode::VariableDimension(_) => write!(f, "VariableDimension"), + AnyNode::QueueDimension(_) => write!(f, "QueueDimension"), + AnyNode::UnsizedDimension(_) => write!(f, "UnsizedDimension"), + AnyNode::Delay3(_) => write!(f, "Delay3"), + AnyNode::Delay3Single(_) => write!(f, "Delay3Single"), + AnyNode::Delay3Mintypmax(_) => write!(f, "Delay3Mintypmax"), + AnyNode::Delay2(_) => write!(f, "Delay2"), + AnyNode::Delay2Single(_) => write!(f, "Delay2Single"), + AnyNode::Delay2Mintypmax(_) => write!(f, "Delay2Mintypmax"), + AnyNode::DelayValue(_) => write!(f, "DelayValue"), + AnyNode::TaskDeclaration(_) => write!(f, "TaskDeclaration"), + AnyNode::TaskBodyDeclaration(_) => write!(f, "TaskBodyDeclaration"), + AnyNode::TaskBodyDeclarationWithoutPort(_) => { + write!(f, "TaskBodyDeclarationWithoutPort") + } + AnyNode::TaskBodyDeclarationWithPort(_) => write!(f, "TaskBodyDeclarationWithPort"), + AnyNode::TfItemDeclaration(_) => write!(f, "TfItemDeclaration"), + AnyNode::TfPortList(_) => write!(f, "TfPortList"), + AnyNode::TfPortItem(_) => write!(f, "TfPortItem"), + AnyNode::TfPortDirection(_) => write!(f, "TfPortDirection"), + AnyNode::TfPortDeclaration(_) => write!(f, "TfPortDeclaration"), + AnyNode::TaskPrototype(_) => write!(f, "TaskPrototype"), + AnyNode::InoutDeclaration(_) => write!(f, "InoutDeclaration"), + AnyNode::InputDeclaration(_) => write!(f, "InputDeclaration"), + AnyNode::InputDeclarationNet(_) => write!(f, "InputDeclarationNet"), + AnyNode::InputDeclarationVariable(_) => write!(f, "InputDeclarationVariable"), + AnyNode::OutputDeclaration(_) => write!(f, "OutputDeclaration"), + AnyNode::OutputDeclarationNet(_) => write!(f, "OutputDeclarationNet"), + AnyNode::OutputDeclarationVariable(_) => write!(f, "OutputDeclarationVariable"), + AnyNode::InterfacePortDeclaration(_) => write!(f, "InterfacePortDeclaration"), + AnyNode::RefDeclaration(_) => write!(f, "RefDeclaration"), + AnyNode::GenerateRegion(_) => write!(f, "GenerateRegion"), + AnyNode::LoopGenerateConstruct(_) => write!(f, "LoopGenerateConstruct"), + AnyNode::GenvarInitialization(_) => write!(f, "GenvarInitialization"), + AnyNode::Genvar(_) => write!(f, "Genvar"), + AnyNode::GenvarIteration(_) => write!(f, "GenvarIteration"), + AnyNode::GenvarIterationAssignment(_) => write!(f, "GenvarIterationAssignment"), + AnyNode::GenvarIterationPrefix(_) => write!(f, "GenvarIterationPrefix"), + AnyNode::GenvarIterationSuffix(_) => write!(f, "GenvarIterationSuffix"), + AnyNode::ConditionalGenerateConstruct(_) => write!(f, "ConditionalGenerateConstruct"), + AnyNode::IfGenerateConstruct(_) => write!(f, "IfGenerateConstruct"), + AnyNode::CaseGenerateConstruct(_) => write!(f, "CaseGenerateConstruct"), + AnyNode::CaseGenerateItem(_) => write!(f, "CaseGenerateItem"), + AnyNode::CaseGenerateItemNondefault(_) => write!(f, "CaseGenerateItemNondefault"), + AnyNode::CaseGenerateItemDefault(_) => write!(f, "CaseGenerateItemDefault"), + AnyNode::GenerateBlock(_) => write!(f, "GenerateBlock"), + AnyNode::GenerateBlockMultiple(_) => write!(f, "GenerateBlockMultiple"), + AnyNode::GenerateItem(_) => write!(f, "GenerateItem"), + AnyNode::InterfaceInstantiation(_) => write!(f, "InterfaceInstantiation"), + AnyNode::ProgramInstantiation(_) => write!(f, "ProgramInstantiation"), + AnyNode::ModuleInstantiation(_) => write!(f, "ModuleInstantiation"), + AnyNode::ParameterValueAssignment(_) => write!(f, "ParameterValueAssignment"), + AnyNode::ListOfParameterAssignments(_) => write!(f, "ListOfParameterAssignments"), + AnyNode::ListOfParameterAssignmentsOrdered(_) => { + write!(f, "ListOfParameterAssignmentsOrdered") + } + AnyNode::ListOfParameterAssignmentsNamed(_) => { + write!(f, "ListOfParameterAssignmentsNamed") + } + AnyNode::OrderedParameterAssignment(_) => write!(f, "OrderedParameterAssignment"), + AnyNode::NamedParameterAssignment(_) => write!(f, "NamedParameterAssignment"), + AnyNode::HierarchicalInstance(_) => write!(f, "HierarchicalInstance"), + AnyNode::NameOfInstance(_) => write!(f, "NameOfInstance"), + AnyNode::ListOfPortConnections(_) => write!(f, "ListOfPortConnections"), + AnyNode::ListOfPortConnectionsOrdered(_) => write!(f, "ListOfPortConnectionsOrdered"), + AnyNode::ListOfPortConnectionsNamed(_) => write!(f, "ListOfPortConnectionsNamed"), + AnyNode::OrderedPortConnection(_) => write!(f, "OrderedPortConnection"), + AnyNode::NamedPortConnection(_) => write!(f, "NamedPortConnection"), + AnyNode::NamedPortConnectionIdentifier(_) => write!(f, "NamedPortConnectionIdentifier"), + AnyNode::NamedPortConnectionAsterisk(_) => write!(f, "NamedPortConnectionAsterisk"), + AnyNode::CheckerInstantiation(_) => write!(f, "CheckerInstantiation"), + AnyNode::ListOfCheckerPortConnections(_) => write!(f, "ListOfCheckerPortConnections"), + AnyNode::ListOfCheckerPortConnectionsOrdered(_) => { + write!(f, "ListOfCheckerPortConnectionsOrdered") + } + AnyNode::ListOfCheckerPortConnectionsNamed(_) => { + write!(f, "ListOfCheckerPortConnectionsNamed") + } + AnyNode::OrderedCheckerPortConnection(_) => write!(f, "OrderedCheckerPortConnection"), + AnyNode::NamedCheckerPortConnection(_) => write!(f, "NamedCheckerPortConnection"), + AnyNode::NamedCheckerPortConnectionIdentifier(_) => { + write!(f, "NamedCheckerPortConnectionIdentifier") + } + AnyNode::NamedCheckerPortConnectionAsterisk(_) => { + write!(f, "NamedCheckerPortConnectionAsterisk") + } + AnyNode::NetLvalue(_) => write!(f, "NetLvalue"), + AnyNode::NetLvalueIdentifier(_) => write!(f, "NetLvalueIdentifier"), + AnyNode::NetLvalueLvalue(_) => write!(f, "NetLvalueLvalue"), + AnyNode::NetLvaluePattern(_) => write!(f, "NetLvaluePattern"), + AnyNode::VariableLvalue(_) => write!(f, "VariableLvalue"), + AnyNode::VariableLvalueIdentifier(_) => write!(f, "VariableLvalueIdentifier"), + AnyNode::VariableLvalueLvalue(_) => write!(f, "VariableLvalueLvalue"), + AnyNode::VariableLvaluePattern(_) => write!(f, "VariableLvaluePattern"), + AnyNode::NonrangeVariableLvalue(_) => write!(f, "NonrangeVariableLvalue"), + AnyNode::Concatenation(_) => write!(f, "Concatenation"), + AnyNode::ConstantConcatenation(_) => write!(f, "ConstantConcatenation"), + AnyNode::ConstantMultipleConcatenation(_) => write!(f, "ConstantMultipleConcatenation"), + AnyNode::ModulePathConcatenation(_) => write!(f, "ModulePathConcatenation"), + AnyNode::ModulePathMultipleConcatenation(_) => { + write!(f, "ModulePathMultipleConcatenation") + } + AnyNode::MultipleConcatenation(_) => write!(f, "MultipleConcatenation"), + AnyNode::StreamingConcatenation(_) => write!(f, "StreamingConcatenation"), + AnyNode::StreamOperator(_) => write!(f, "StreamOperator"), + AnyNode::SliceSize(_) => write!(f, "SliceSize"), + AnyNode::StreamConcatenation(_) => write!(f, "StreamConcatenation"), + AnyNode::StreamExpression(_) => write!(f, "StreamExpression"), + AnyNode::ArrayRangeExpression(_) => write!(f, "ArrayRangeExpression"), + AnyNode::ArrayRangeExpressionColon(_) => write!(f, "ArrayRangeExpressionColon"), + AnyNode::ArrayRangeExpressionPlusColon(_) => write!(f, "ArrayRangeExpressionPlusColon"), + AnyNode::ArrayRangeExpressionMinusColon(_) => { + write!(f, "ArrayRangeExpressionMinusColon") + } + AnyNode::EmptyUnpackedArrayConcatenation(_) => { + write!(f, "EmptyUnpackedArrayConcatenation") + } + AnyNode::ConstantPrimary(_) => write!(f, "ConstantPrimary"), + AnyNode::ConstantPrimaryPsParameter(_) => write!(f, "ConstantPrimaryPsParameter"), + AnyNode::ConstantPrimarySpecparam(_) => write!(f, "ConstantPrimarySpecparam"), + AnyNode::ConstantPrimaryFormalPort(_) => write!(f, "ConstantPrimaryFormalPort"), + AnyNode::ConstantPrimaryEnum(_) => write!(f, "ConstantPrimaryEnum"), + AnyNode::ConstantPrimaryConcatenation(_) => write!(f, "ConstantPrimaryConcatenation"), + AnyNode::ConstantPrimaryMultipleConcatenation(_) => { + write!(f, "ConstantPrimaryMultipleConcatenation") + } + AnyNode::ConstantPrimaryMintypmaxExpression(_) => { + write!(f, "ConstantPrimaryMintypmaxExpression") + } + AnyNode::ModulePathPrimary(_) => write!(f, "ModulePathPrimary"), + AnyNode::ModulePathPrimaryMintypmax(_) => write!(f, "ModulePathPrimaryMintypmax"), + AnyNode::Primary(_) => write!(f, "Primary"), + AnyNode::PrimaryHierarchical(_) => write!(f, "PrimaryHierarchical"), + AnyNode::PrimaryConcatenation(_) => write!(f, "PrimaryConcatenation"), + AnyNode::PrimaryMultipleConcatenation(_) => write!(f, "PrimaryMultipleConcatenation"), + AnyNode::PrimaryMintypmaxExpression(_) => write!(f, "PrimaryMintypmaxExpression"), + AnyNode::ClassQualifierOrPackageScope(_) => write!(f, "ClassQualifierOrPackageScope"), + AnyNode::ClassQualifier(_) => write!(f, "ClassQualifier"), + AnyNode::RangeExpression(_) => write!(f, "RangeExpression"), + AnyNode::PrimaryLiteral(_) => write!(f, "PrimaryLiteral"), + AnyNode::TimeLiteral(_) => write!(f, "TimeLiteral"), + AnyNode::TimeLiteralUnsigned(_) => write!(f, "TimeLiteralUnsigned"), + AnyNode::TimeLiteralFixedPoint(_) => write!(f, "TimeLiteralFixedPoint"), + AnyNode::TimeUnit(_) => write!(f, "TimeUnit"), + AnyNode::ImplicitClassHandle(_) => write!(f, "ImplicitClassHandle"), + AnyNode::BitSelect(_) => write!(f, "BitSelect"), + AnyNode::Select(_) => write!(f, "Select"), + AnyNode::NonrangeSelect(_) => write!(f, "NonrangeSelect"), + AnyNode::ConstantBitSelect(_) => write!(f, "ConstantBitSelect"), + AnyNode::ConstantSelect(_) => write!(f, "ConstantSelect"), + AnyNode::ConstantCast(_) => write!(f, "ConstantCast"), + AnyNode::ConstantLetExpression(_) => write!(f, "ConstantLetExpression"), + AnyNode::Cast(_) => write!(f, "Cast"), + AnyNode::IncOrDecExpression(_) => write!(f, "IncOrDecExpression"), + AnyNode::IncOrDecExpressionPrefix(_) => write!(f, "IncOrDecExpressionPrefix"), + AnyNode::IncOrDecExpressionSuffix(_) => write!(f, "IncOrDecExpressionSuffix"), + AnyNode::ConditionalExpression(_) => write!(f, "ConditionalExpression"), + AnyNode::ConstantExpression(_) => write!(f, "ConstantExpression"), + AnyNode::ConstantExpressionUnary(_) => write!(f, "ConstantExpressionUnary"), + AnyNode::ConstantExpressionBinary(_) => write!(f, "ConstantExpressionBinary"), + AnyNode::ConstantExpressionTernary(_) => write!(f, "ConstantExpressionTernary"), + AnyNode::ConstantInsideExpression(_) => write!(f, "AnyNode::ConstantInsideExpression"), + AnyNode::ConstantMintypmaxExpression(_) => write!(f, "ConstantMintypmaxExpression"), + AnyNode::ConstantMintypmaxExpressionTernary(_) => { + write!(f, "ConstantMintypmaxExpressionTernary") + } + AnyNode::ConstantParamExpression(_) => write!(f, "ConstantParamExpression"), + AnyNode::ParamExpression(_) => write!(f, "ParamExpression"), + AnyNode::ConstantRangeExpression(_) => write!(f, "ConstantRangeExpression"), + AnyNode::ConstantPartSelectRange(_) => write!(f, "ConstantPartSelectRange"), + AnyNode::ConstantRange(_) => write!(f, "ConstantRange"), + AnyNode::ConstantIndexedRange(_) => write!(f, "ConstantIndexedRange"), + AnyNode::Expression(_) => write!(f, "Expression"), + AnyNode::ExpressionUnary(_) => write!(f, "ExpressionUnary"), + AnyNode::ExpressionOperatorAssignment(_) => write!(f, "ExpressionOperatorAssignment"), + AnyNode::ExpressionBinary(_) => write!(f, "ExpressionBinary"), + AnyNode::ExpressionBinaryOperand(_) => write!(f, "ExpressionBinaryOperand"), + AnyNode::TaggedUnionExpression(_) => write!(f, "TaggedUnionExpression"), + AnyNode::InsideExpression(_) => write!(f, "InsideExpression"), + AnyNode::ValueRange(_) => write!(f, "ValueRange"), + AnyNode::ValueRangeBinary(_) => write!(f, "ValueRangeBinary"), + AnyNode::MintypmaxExpression(_) => write!(f, "MintypmaxExpression"), + AnyNode::MintypmaxExpressionTernary(_) => write!(f, "MintypmaxExpressionTernary"), + AnyNode::ModulePathConditionalExpression(_) => { + write!(f, "ModulePathConditionalExpression") + } + AnyNode::ModulePathExpression(_) => write!(f, "ModulePathExpression"), + AnyNode::ModulePathExpressionUnary(_) => write!(f, "ModulePathExpressionUnary"), + AnyNode::ModulePathExpressionBinary(_) => write!(f, "ModulePathExpressionBinary"), + AnyNode::ModulePathMintypmaxExpression(_) => write!(f, "ModulePathMintypmaxExpression"), + AnyNode::ModulePathMintypmaxExpressionTernary(_) => { + write!(f, "ModulePathMintypmaxExpressionTernary") + } + AnyNode::PartSelectRange(_) => write!(f, "PartSelectRange"), + AnyNode::IndexedRange(_) => write!(f, "IndexedRange"), + AnyNode::GenvarExpression(_) => write!(f, "GenvarExpression"), + AnyNode::UnaryOperator(_) => write!(f, "UnaryOperator"), + AnyNode::BinaryOperator(_) => write!(f, "BinaryOperator"), + AnyNode::IncOrDecOperator(_) => write!(f, "IncOrDecOperator"), + AnyNode::UnaryModulePathOperator(_) => write!(f, "UnaryModulePathOperator"), + AnyNode::BinaryModulePathOperator(_) => write!(f, "BinaryModulePathOperator"), + AnyNode::StringLiteral(_) => write!(f, "StringLiteral"), + AnyNode::ConstantFunctionCall(_) => write!(f, "ConstantFunctionCall"), + AnyNode::TfCall(_) => write!(f, "TfCall"), + AnyNode::SystemTfCall(_) => write!(f, "SystemTfCall"), + AnyNode::SystemTfCallArgOptional(_) => write!(f, "SystemTfCallArgOptional"), + AnyNode::SystemTfCallArgDataType(_) => write!(f, "SystemTfCallArgDataType"), + AnyNode::SystemTfCallArgExpression(_) => write!(f, "SystemTfCallArgExpression"), + AnyNode::SubroutineCall(_) => write!(f, "SubroutineCall"), + AnyNode::SubroutineCallRandomize(_) => write!(f, "SubroutineCallRandomize"), + AnyNode::FunctionSubroutineCall(_) => write!(f, "FunctionSubroutineCall"), + AnyNode::ListOfArguments(_) => write!(f, "ListOfArguments"), + AnyNode::ListOfArgumentsOrdered(_) => write!(f, "ListOfArgumentsOrdered"), + AnyNode::ListOfArgumentsNamed(_) => write!(f, "ListOfArgumentsNamed"), + AnyNode::MethodCall(_) => write!(f, "MethodCall"), + AnyNode::MethodCallBody(_) => write!(f, "MethodCallBody"), + AnyNode::MethodCallBodyUser(_) => write!(f, "MethodCallBodyUser"), + AnyNode::BuiltInMethodCall(_) => write!(f, "BuiltInMethodCall"), + AnyNode::ArrayManipulationCall(_) => write!(f, "ArrayManipulationCall"), + AnyNode::RandomizeCall(_) => write!(f, "RandomizeCall"), + AnyNode::VariableIdentifierListOrNull(_) => write!(f, "VariableIdentifierListOrNull"), + AnyNode::MethodCallRoot(_) => write!(f, "MethodCallRoot"), + AnyNode::ArrayMethodName(_) => write!(f, "ArrayMethodName"), + AnyNode::Number(_) => write!(f, "Number"), + AnyNode::IntegralNumber(_) => write!(f, "IntegralNumber"), + AnyNode::DecimalNumber(_) => write!(f, "DecimalNumber"), + AnyNode::DecimalNumberBaseUnsigned(_) => write!(f, "DecimalNumberBaseUnsigned"), + AnyNode::DecimalNumberBaseXNumber(_) => write!(f, "DecimalNumberBaseXNumber"), + AnyNode::DecimalNumberBaseZNumber(_) => write!(f, "DecimalNumberBaseZNumber"), + AnyNode::BinaryNumber(_) => write!(f, "BinaryNumber"), + AnyNode::OctalNumber(_) => write!(f, "OctalNumber"), + AnyNode::HexNumber(_) => write!(f, "HexNumber"), + AnyNode::Sign(_) => write!(f, "Sign"), + AnyNode::Size(_) => write!(f, "Size"), + AnyNode::NonZeroUnsignedNumber(_) => write!(f, "NonZeroUnsignedNumber"), + AnyNode::RealNumber(_) => write!(f, "RealNumber"), + AnyNode::RealNumberFloating(_) => write!(f, "RealNumberFloating"), + AnyNode::FixedPointNumber(_) => write!(f, "FixedPointNumber"), + AnyNode::Exp(_) => write!(f, "Exp"), + AnyNode::UnsignedNumber(_) => write!(f, "UnsignedNumber"), + AnyNode::BinaryValue(_) => write!(f, "BinaryValue"), + AnyNode::OctalValue(_) => write!(f, "OctalValue"), + AnyNode::HexValue(_) => write!(f, "HexValue"), + AnyNode::DecimalBase(_) => write!(f, "DecimalBase"), + AnyNode::BinaryBase(_) => write!(f, "BinaryBase"), + AnyNode::OctalBase(_) => write!(f, "OctalBase"), + AnyNode::HexBase(_) => write!(f, "HexBase"), + AnyNode::XNumber(_) => write!(f, "XNumber"), + AnyNode::ZNumber(_) => write!(f, "ZNumber"), + AnyNode::UnbasedUnsizedLiteral(_) => write!(f, "UnbasedUnsizedLiteral"), + AnyNode::SourceText(_) => write!(f, "SourceText"), + AnyNode::Description(_) => write!(f, "Description"), + AnyNode::DescriptionPackageItem(_) => write!(f, "DescriptionPackageItem"), + AnyNode::DescriptionBindDirective(_) => write!(f, "DescriptionBindDirective"), + AnyNode::ModuleNonansiHeader(_) => write!(f, "ModuleNonansiHeader"), + AnyNode::ModuleAnsiHeader(_) => write!(f, "ModuleAnsiHeader"), + AnyNode::ModuleDeclaration(_) => write!(f, "ModuleDeclaration"), + AnyNode::ModuleDeclarationNonansi(_) => write!(f, "ModuleDeclarationNonansi"), + AnyNode::ModuleDeclarationAnsi(_) => write!(f, "ModuleDeclarationAnsi"), + AnyNode::ModuleDeclarationWildcard(_) => write!(f, "ModuleDeclarationWildcard"), + AnyNode::ModuleDeclarationExternNonansi(_) => { + write!(f, "ModuleDeclarationExternNonansi") + } + AnyNode::ModuleDeclarationExternAnsi(_) => write!(f, "ModuleDeclarationExternAnsi"), + AnyNode::ModuleKeyword(_) => write!(f, "ModuleKeyword"), + AnyNode::InterfaceDeclaration(_) => write!(f, "InterfaceDeclaration"), + AnyNode::InterfaceDeclarationNonansi(_) => write!(f, "InterfaceDeclarationNonansi"), + AnyNode::InterfaceDeclarationAnsi(_) => write!(f, "InterfaceDeclarationAnsi"), + AnyNode::InterfaceDeclarationWildcard(_) => write!(f, "InterfaceDeclarationWildcard"), + AnyNode::InterfaceDeclarationExternNonansi(_) => { + write!(f, "InterfaceDeclarationExternNonansi") + } + AnyNode::InterfaceDeclarationExternAnsi(_) => { + write!(f, "InterfaceDeclarationExternAnsi") + } + AnyNode::InterfaceNonansiHeader(_) => write!(f, "InterfaceNonansiHeader"), + AnyNode::InterfaceAnsiHeader(_) => write!(f, "InterfaceAnsiHeader"), + AnyNode::ProgramDeclaration(_) => write!(f, "ProgramDeclaration"), + AnyNode::ProgramDeclarationNonansi(_) => write!(f, "ProgramDeclarationNonansi"), + AnyNode::ProgramDeclarationAnsi(_) => write!(f, "ProgramDeclarationAnsi"), + AnyNode::ProgramDeclarationWildcard(_) => write!(f, "ProgramDeclarationWildcard"), + AnyNode::ProgramDeclarationExternNonansi(_) => { + write!(f, "ProgramDeclarationExternNonansi") + } + AnyNode::ProgramDeclarationExternAnsi(_) => write!(f, "ProgramDeclarationExternAnsi"), + AnyNode::ProgramNonansiHeader(_) => write!(f, "ProgramNonansiHeader"), + AnyNode::ProgramAnsiHeader(_) => write!(f, "ProgramAnsiHeader"), + AnyNode::CheckerDeclaration(_) => write!(f, "CheckerDeclaration"), + AnyNode::ClassDeclaration(_) => write!(f, "ClassDeclaration"), + AnyNode::Virtual(_) => write!(f, "Virtual"), + AnyNode::InterfaceClassType(_) => write!(f, "InterfaceClassType"), + AnyNode::InterfaceClassDeclaration(_) => write!(f, "InterfaceClassDeclaration"), + AnyNode::InterfaceClassItem(_) => write!(f, "InterfaceClassItem"), + AnyNode::InterfaceClassItemMethod(_) => write!(f, "InterfaceClassItemMethod"), + AnyNode::InterfaceClassMethod(_) => write!(f, "InterfaceClassMethod"), + AnyNode::PackageDeclaration(_) => write!(f, "PackageDeclaration"), + AnyNode::TimeunitsDeclaration(_) => write!(f, "TimeunitsDeclaration"), + AnyNode::TimeunitsDeclarationTimeunit(_) => write!(f, "TimeunitsDeclarationTimeunit"), + AnyNode::TimeunitsDeclarationTimeprecision(_) => { + write!(f, "TimeunitsDeclarationTimeprecision") + } + AnyNode::TimeunitsDeclarationTimeunitTimeprecision(_) => { + write!(f, "TimeunitsDeclarationTimeunitTimeprecision") + } + AnyNode::TimeunitsDeclarationTimeprecisionTimeunit(_) => { + write!(f, "TimeunitsDeclarationTimeprecisionTimeunit") + } + AnyNode::LibraryText(_) => write!(f, "LibraryText"), + AnyNode::LibraryDescription(_) => write!(f, "LibraryDescription"), + AnyNode::LibraryDeclaration(_) => write!(f, "LibraryDeclaration"), + AnyNode::IncludeStatement(_) => write!(f, "IncludeStatement"), + AnyNode::FilePathSpec(_) => write!(f, "FilePathSpec"), + AnyNode::FilePathSpecNonLiteral(_) => write!(f, "FilePathSpecNonLiteral"), + AnyNode::ParameterPortList(_) => write!(f, "ParameterPortList"), + AnyNode::ParameterPortListAssignment(_) => write!(f, "ParameterPortListAssignment"), + AnyNode::ParameterPortListDeclaration(_) => write!(f, "ParameterPortListDeclaration"), + AnyNode::ParameterPortDeclaration(_) => write!(f, "ParameterPortDeclaration"), + AnyNode::ParameterPortDeclarationParamList(_) => { + write!(f, "ParameterPortDeclarationParamList") + } + AnyNode::ParameterPortDeclarationTypeList(_) => { + write!(f, "ParameterPortDeclarationTypeList") + } + AnyNode::ListOfPorts(_) => write!(f, "ListOfPorts"), + AnyNode::ListOfPortDeclarations(_) => write!(f, "ListOfPortDeclarations"), + AnyNode::PortDeclaration(_) => write!(f, "PortDeclaration"), + AnyNode::PortDeclarationInout(_) => write!(f, "PortDeclarationInout"), + AnyNode::PortDeclarationInput(_) => write!(f, "PortDeclarationInput"), + AnyNode::PortDeclarationOutput(_) => write!(f, "PortDeclarationOutput"), + AnyNode::PortDeclarationRef(_) => write!(f, "PortDeclarationRef"), + AnyNode::PortDeclarationInterface(_) => write!(f, "PortDeclarationInterface"), + AnyNode::Port(_) => write!(f, "Port"), + AnyNode::PortNonNamed(_) => write!(f, "PortNonNamed"), + AnyNode::PortNamed(_) => write!(f, "PortNamed"), + AnyNode::PortExpression(_) => write!(f, "PortExpression"), + AnyNode::PortExpressionBrace(_) => write!(f, "PortExpressionBrace"), + AnyNode::PortReference(_) => write!(f, "PortReference"), + AnyNode::PortDirection(_) => write!(f, "PortDirection"), + AnyNode::NetPortHeader(_) => write!(f, "NetPortHeader"), + AnyNode::VariablePortHeader(_) => write!(f, "VariablePortHeader"), + AnyNode::InterfacePortHeader(_) => write!(f, "InterfacePortHeader"), + AnyNode::InterfacePortHeaderIdentifier(_) => write!(f, "InterfacePortHeaderIdentifier"), + AnyNode::InterfacePortHeaderInterface(_) => write!(f, "InterfacePortHeaderInterface"), + AnyNode::NetPortHeaderOrInterfacePortHeader(_) => { + write!(f, "NetPortHeaderOrInterfacePortHeader") + } + AnyNode::AnsiPortDeclaration(_) => write!(f, "AnsiPortDeclaration"), + AnyNode::AnsiPortDeclarationNet(_) => write!(f, "AnsiPortDeclarationNet"), + AnyNode::AnsiPortDeclarationVariable(_) => write!(f, "AnsiPortDeclarationVariable"), + AnyNode::AnsiPortDeclarationParen(_) => write!(f, "AnsiPortDeclarationParen"), + AnyNode::ProgramItem(_) => write!(f, "ProgramItem"), + AnyNode::NonPortProgramItem(_) => write!(f, "NonPortProgramItem"), + AnyNode::NonPortProgramItemAssign(_) => write!(f, "NonPortProgramItemAssign"), + AnyNode::NonPortProgramItemModule(_) => write!(f, "NonPortProgramItemModule"), + AnyNode::NonPortProgramItemInitial(_) => write!(f, "NonPortProgramItemInitial"), + AnyNode::NonPortProgramItemFinal(_) => write!(f, "NonPortProgramItemFinal"), + AnyNode::NonPortProgramItemAssertion(_) => write!(f, "NonPortProgramItemAssertion"), + AnyNode::ProgramGenerateItem(_) => write!(f, "ProgramGenerateItem"), + AnyNode::ElaborationSystemTask(_) => write!(f, "ElaborationSystemTask"), + AnyNode::ElaborationSystemTaskFatal(_) => write!(f, "ElaborationSystemTaskFatal"), + AnyNode::ElaborationSystemTaskError(_) => write!(f, "ElaborationSystemTaskError"), + AnyNode::ElaborationSystemTaskWarning(_) => write!(f, "ElaborationSystemTaskWarning"), + AnyNode::ElaborationSystemTaskInfo(_) => write!(f, "ElaborationSystemTaskInfo"), + AnyNode::FinishNumber(_) => write!(f, "FinishNumber"), + AnyNode::ModuleCommonItem(_) => write!(f, "ModuleCommonItem"), + AnyNode::ModuleItem(_) => write!(f, "ModuleItem"), + AnyNode::ModuleOrGenerateItem(_) => write!(f, "ModuleOrGenerateItem"), + AnyNode::ModuleOrGenerateItemParameter(_) => write!(f, "ModuleOrGenerateItemParameter"), + AnyNode::ModuleOrGenerateItemGate(_) => write!(f, "ModuleOrGenerateItemGate"), + AnyNode::ModuleOrGenerateItemUdp(_) => write!(f, "ModuleOrGenerateItemUdp"), + AnyNode::ModuleOrGenerateItemModule(_) => write!(f, "ModuleOrGenerateItemModule"), + AnyNode::ModuleOrGenerateItemModuleItem(_) => { + write!(f, "ModuleOrGenerateItemModuleItem") + } + AnyNode::ModuleOrGenerateItemDeclaration(_) => { + write!(f, "ModuleOrGenerateItemDeclaration") + } + AnyNode::ModuleOrGenerateItemDeclarationClocking(_) => { + write!(f, "ModuleOrGenerateItemDeclarationClocking") + } + AnyNode::ModuleOrGenerateItemDeclarationDisable(_) => { + write!(f, "ModuleOrGenerateItemDeclarationDisable") + } + AnyNode::NonPortModuleItem(_) => write!(f, "NonPortModuleItem"), + AnyNode::NonPortModuleItemSpecparam(_) => write!(f, "NonPortModuleItemSpecparam"), + AnyNode::ParameterOverride(_) => write!(f, "ParameterOverride"), + AnyNode::BindDirective(_) => write!(f, "BindDirective"), + AnyNode::BindDirectiveScope(_) => write!(f, "BindDirectiveScope"), + AnyNode::BindDirectiveInstance(_) => write!(f, "BindDirectiveInstance"), + AnyNode::BindTargetScope(_) => write!(f, "BindTargetScope"), + AnyNode::BindTargetInstance(_) => write!(f, "BindTargetInstance"), + AnyNode::BindTargetInstanceList(_) => write!(f, "BindTargetInstanceList"), + AnyNode::BindInstantiation(_) => write!(f, "BindInstantiation"), + AnyNode::ConstraintDeclaration(_) => write!(f, "ConstraintDeclaration"), + AnyNode::Static(_) => write!(f, "Static"), + AnyNode::ConstraintBlock(_) => write!(f, "ConstraintBlock"), + AnyNode::ConstraintBlockItem(_) => write!(f, "ConstraintBlockItem"), + AnyNode::ConstraintBlockItemSolve(_) => write!(f, "ConstraintBlockItemSolve"), + AnyNode::SolveBeforeList(_) => write!(f, "SolveBeforeList"), + AnyNode::ConstraintPrimary(_) => write!(f, "ConstraintPrimary"), + AnyNode::ConstraintExpression(_) => write!(f, "ConstraintExpression"), + AnyNode::ConstraintExpressionExpression(_) => { + write!(f, "ConstraintExpressionExpression") + } + AnyNode::Soft(_) => write!(f, "Soft"), + AnyNode::ConstraintExpressionArrow(_) => write!(f, "ConstraintExpressionArrow"), + AnyNode::ConstraintExpressionIf(_) => write!(f, "ConstraintExpressionIf"), + AnyNode::ConstraintExpressionForeach(_) => write!(f, "ConstraintExpressionForeach"), + AnyNode::ConstraintExpressionDisable(_) => write!(f, "ConstraintExpressionDisable"), + AnyNode::UniquenessConstraint(_) => write!(f, "UniquenessConstraint"), + AnyNode::ConstraintSet(_) => write!(f, "ConstraintSet"), + AnyNode::ConstraintSetBrace(_) => write!(f, "ConstraintSetBrace"), + AnyNode::DistList(_) => write!(f, "DistList"), + AnyNode::DistItem(_) => write!(f, "DistItem"), + AnyNode::DistWeight(_) => write!(f, "DistWeight"), + AnyNode::DistWeightEqual(_) => write!(f, "DistWeightEqual"), + AnyNode::DistWeightDivide(_) => write!(f, "DistWeightDivide"), + AnyNode::ConstraintPrototype(_) => write!(f, "ConstraintPrototype"), + AnyNode::ConstraintPrototypeQualifier(_) => write!(f, "ConstraintPrototypeQualifier"), + AnyNode::ExternConstraintDeclaration(_) => write!(f, "ExternConstraintDeclaration"), + AnyNode::IdentifierList(_) => write!(f, "IdentifierList"), + AnyNode::ConfigDeclaration(_) => write!(f, "ConfigDeclaration"), + AnyNode::DesignStatement(_) => write!(f, "DesignStatement"), + AnyNode::ConfigRuleStatement(_) => write!(f, "ConfigRuleStatement"), + AnyNode::ConfigRuleStatementDefault(_) => write!(f, "ConfigRuleStatementDefault"), + AnyNode::ConfigRuleStatementInstLib(_) => write!(f, "ConfigRuleStatementInstLib"), + AnyNode::ConfigRuleStatementInstUse(_) => write!(f, "ConfigRuleStatementInstUse"), + AnyNode::ConfigRuleStatementCellLib(_) => write!(f, "ConfigRuleStatementCellLib"), + AnyNode::ConfigRuleStatementCellUse(_) => write!(f, "ConfigRuleStatementCellUse"), + AnyNode::DefaultClause(_) => write!(f, "DefaultClause"), + AnyNode::InstClause(_) => write!(f, "InstClause"), + AnyNode::InstName(_) => write!(f, "InstName"), + AnyNode::CellClause(_) => write!(f, "CellClause"), + AnyNode::LiblistClause(_) => write!(f, "LiblistClause"), + AnyNode::UseClause(_) => write!(f, "UseClause"), + AnyNode::UseClauseCell(_) => write!(f, "UseClauseCell"), + AnyNode::UseClauseNamed(_) => write!(f, "UseClauseNamed"), + AnyNode::UseClauseCellNamed(_) => write!(f, "UseClauseCellNamed"), + AnyNode::Config(_) => write!(f, "Config"), + AnyNode::ClassItem(_) => write!(f, "ClassItem"), + AnyNode::ClassItemProperty(_) => write!(f, "ClassItemProperty"), + AnyNode::ClassItemMethod(_) => write!(f, "ClassItemMethod"), + AnyNode::ClassItemConstraint(_) => write!(f, "ClassItemConstraint"), + AnyNode::ClassItemDeclaration(_) => write!(f, "ClassItemDeclaration"), + AnyNode::ClassItemCovergroup(_) => write!(f, "ClassItemCovergroup"), + AnyNode::ClassProperty(_) => write!(f, "ClassProperty"), + AnyNode::ClassPropertyNonConst(_) => write!(f, "ClassPropertyNonConst"), + AnyNode::ClassPropertyConst(_) => write!(f, "ClassPropertyConst"), + AnyNode::ClassPropertyConstExpression(_) => write!(f, "ClassPropertyConstExpression"), + AnyNode::ClassMethod(_) => write!(f, "ClassMethod"), + AnyNode::ClassMethodTask(_) => write!(f, "ClassMethodTask"), + AnyNode::ClassMethodFunction(_) => write!(f, "ClassMethodFunction"), + AnyNode::ClassMethodPureVirtual(_) => write!(f, "ClassMethodPureVirtual"), + AnyNode::ClassMethodExternMethod(_) => write!(f, "ClassMethodExternMethod"), + AnyNode::ClassMethodConstructor(_) => write!(f, "ClassMethodConstructor"), + AnyNode::ClassMethodExternConstructor(_) => write!(f, "ClassMethodExternConstructor"), + AnyNode::ClassConstructorPrototype(_) => write!(f, "ClassConstructorPrototype"), + AnyNode::ClassConstraint(_) => write!(f, "ClassConstraint"), + AnyNode::ClassItemQualifier(_) => write!(f, "ClassItemQualifier"), + AnyNode::PropertyQualifier(_) => write!(f, "PropertyQualifier"), + AnyNode::RandomQualifier(_) => write!(f, "RandomQualifier"), + AnyNode::MethodQualifier(_) => write!(f, "MethodQualifier"), + AnyNode::MethodPrototype(_) => write!(f, "MethodPrototype"), + AnyNode::ClassConstructorDeclaration(_) => write!(f, "ClassConstructorDeclaration"), + AnyNode::New(_) => write!(f, "New"), + AnyNode::InterfaceOrGenerateItem(_) => write!(f, "InterfaceOrGenerateItem"), + AnyNode::InterfaceOrGenerateItemModule(_) => write!(f, "InterfaceOrGenerateItemModule"), + AnyNode::InterfaceOrGenerateItemExtern(_) => write!(f, "InterfaceOrGenerateItemExtern"), + AnyNode::ExternTfDeclaration(_) => write!(f, "ExternTfDeclaration"), + AnyNode::ExternTfDeclarationMethod(_) => write!(f, "ExternTfDeclarationMethod"), + AnyNode::ExternTfDeclarationTask(_) => write!(f, "ExternTfDeclarationTask"), + AnyNode::InterfaceItem(_) => write!(f, "InterfaceItem"), + AnyNode::NonPortInterfaceItem(_) => write!(f, "NonPortInterfaceItem"), + AnyNode::CheckerPortList(_) => write!(f, "CheckerPortList"), + AnyNode::CheckerPortItem(_) => write!(f, "CheckerPortItem"), + AnyNode::CheckerPortDirection(_) => write!(f, "CheckerPortDirection"), + AnyNode::CheckerOrGenerateItem(_) => write!(f, "CheckerOrGenerateItem"), + AnyNode::CheckerOrGenerateItemDeclaration(_) => { + write!(f, "CheckerOrGenerateItemDeclaration") + } + AnyNode::CheckerOrGenerateItemDeclarationData(_) => { + write!(f, "CheckerOrGenerateItemDeclarationData") + } + AnyNode::Rand(_) => write!(f, "Rand"), + AnyNode::CheckerOrGenerateItemDeclarationClocking(_) => { + write!(f, "CheckerOrGenerateItemDeclarationClocking") + } + AnyNode::CheckerOrGenerateItemDeclarationDisable(_) => { + write!(f, "CheckerOrGenerateItemDeclarationDisable") + } + AnyNode::CheckerGenerateItem(_) => write!(f, "CheckerGenerateItem"), + AnyNode::PackageItem(_) => write!(f, "PackageItem"), + AnyNode::PackageOrGenerateItemDeclaration(_) => { + write!(f, "PackageOrGenerateItemDeclaration") + } + AnyNode::AnonymousProgram(_) => write!(f, "AnonymousProgram"), + AnyNode::AnonymousProgramItem(_) => write!(f, "AnonymousProgramItem"), + AnyNode::PreprocessorText(_) => write!(f, "PreprocessorText"), + AnyNode::Symbol(_) => write!(f, "Symbol"), + AnyNode::Keyword(_) => write!(f, "Keyword"), + AnyNode::WhiteSpace(_) => write!(f, "WhiteSpace"), + AnyNode::PulldownStrength(_) => write!(f, "PulldownStrength"), + AnyNode::PulldownStrength01(_) => write!(f, "PulldownStrength01"), + AnyNode::PulldownStrength10(_) => write!(f, "PulldownStrength10"), + AnyNode::PulldownStrength0(_) => write!(f, "PulldownStrength0"), + AnyNode::PullupStrength(_) => write!(f, "PullupStrength"), + AnyNode::PullupStrength01(_) => write!(f, "PullupStrength01"), + AnyNode::PullupStrength10(_) => write!(f, "PullupStrength10"), + AnyNode::PullupStrength1(_) => write!(f, "PullupStrength1"), + AnyNode::GateInstantiation(_) => write!(f, "GateInstantiation"), + AnyNode::GateInstantiationCmos(_) => write!(f, "GateInstantiationCmos"), + AnyNode::GateInstantiationEnable(_) => write!(f, "GateInstantiationEnable"), + AnyNode::GateInstantiationMos(_) => write!(f, "GateInstantiationMos"), + AnyNode::GateInstantiationNInput(_) => write!(f, "GateInstantiationNInput"), + AnyNode::GateInstantiationNOutput(_) => write!(f, "GateInstantiationNOutput"), + AnyNode::GateInstantiationPassEn(_) => write!(f, "GateInstantiationPassEn"), + AnyNode::GateInstantiationPass(_) => write!(f, "GateInstantiationPass"), + AnyNode::GateInstantiationPulldown(_) => write!(f, "GateInstantiationPulldown"), + AnyNode::GateInstantiationPullup(_) => write!(f, "GateInstantiationPullup"), + AnyNode::CmosSwitchInstance(_) => write!(f, "CmosSwitchInstance"), + AnyNode::EnableGateInstance(_) => write!(f, "EnableGateInstance"), + AnyNode::MosSwitchInstance(_) => write!(f, "MosSwitchInstance"), + AnyNode::NInputGateInstance(_) => write!(f, "NInputGateInstance"), + AnyNode::NOutputGateInstance(_) => write!(f, "NOutputGateInstance"), + AnyNode::PassSwitchInstance(_) => write!(f, "PassSwitchInstance"), + AnyNode::PassEnableSwitchInstance(_) => write!(f, "PassEnableSwitchInstance"), + AnyNode::PullGateInstance(_) => write!(f, "PullGateInstance"), + AnyNode::CmosSwitchtype(_) => write!(f, "CmosSwitchtype"), + AnyNode::EnableGatetype(_) => write!(f, "EnableGatetype"), + AnyNode::MosSwitchtype(_) => write!(f, "MosSwitchtype"), + AnyNode::NInputGatetype(_) => write!(f, "NInputGatetype"), + AnyNode::NOutputGatetype(_) => write!(f, "NOutputGatetype"), + AnyNode::PassEnSwitchtype(_) => write!(f, "PassEnSwitchtype"), + AnyNode::PassSwitchtype(_) => write!(f, "PassSwitchtype"), + AnyNode::EnableTerminal(_) => write!(f, "EnableTerminal"), + AnyNode::InoutTerminal(_) => write!(f, "InoutTerminal"), + AnyNode::InputTerminal(_) => write!(f, "InputTerminal"), + AnyNode::NcontrolTerminal(_) => write!(f, "NcontrolTerminal"), + AnyNode::OutputTerminal(_) => write!(f, "OutputTerminal"), + AnyNode::PcontrolTerminal(_) => write!(f, "PcontrolTerminal"), + AnyNode::UdpPortList(_) => write!(f, "UdpPortList"), + AnyNode::UdpDeclarationPortList(_) => write!(f, "UdpDeclarationPortList"), + AnyNode::UdpPortDeclaration(_) => write!(f, "UdpPortDeclaration"), + AnyNode::UdpOutputDeclaration(_) => write!(f, "UdpOutputDeclaration"), + AnyNode::UdpOutputDeclarationNonreg(_) => write!(f, "UdpOutputDeclarationNonreg"), + AnyNode::UdpOutputDeclarationReg(_) => write!(f, "UdpOutputDeclarationReg"), + AnyNode::UdpInputDeclaration(_) => write!(f, "UdpInputDeclaration"), + AnyNode::UdpRegDeclaration(_) => write!(f, "UdpRegDeclaration"), + AnyNode::UdpInstantiation(_) => write!(f, "UdpInstantiation"), + AnyNode::UdpInstance(_) => write!(f, "UdpInstance"), + AnyNode::UdpNonansiDeclaration(_) => write!(f, "UdpNonansiDeclaration"), + AnyNode::UdpAnsiDeclaration(_) => write!(f, "UdpAnsiDeclaration"), + AnyNode::UdpDeclaration(_) => write!(f, "UdpDeclaration"), + AnyNode::UdpDeclarationNonansi(_) => write!(f, "UdpDeclarationNonansi"), + AnyNode::UdpDeclarationAnsi(_) => write!(f, "UdpDeclarationAnsi"), + AnyNode::UdpDeclarationExternNonansi(_) => write!(f, "UdpDeclarationExternNonansi"), + AnyNode::UdpDeclarationExternAnsi(_) => write!(f, "UdpDeclarationExternAnsi"), + AnyNode::UdpDeclarationWildcard(_) => write!(f, "UdpDeclarationWildcard"), + AnyNode::UdpBody(_) => write!(f, "UdpBody"), + AnyNode::CombinationalBody(_) => write!(f, "CombinationalBody"), + AnyNode::CombinationalEntry(_) => write!(f, "CombinationalEntry"), + AnyNode::SequentialBody(_) => write!(f, "SequentialBody"), + AnyNode::UdpInitialStatement(_) => write!(f, "UdpInitialStatement"), + AnyNode::InitVal(_) => write!(f, "InitVal"), + AnyNode::SequentialEntry(_) => write!(f, "SequentialEntry"), + AnyNode::SeqInputList(_) => write!(f, "SeqInputList"), + AnyNode::LevelInputList(_) => write!(f, "LevelInputList"), + AnyNode::EdgeInputList(_) => write!(f, "EdgeInputList"), + AnyNode::EdgeIndicator(_) => write!(f, "EdgeIndicator"), + AnyNode::EdgeIndicatorParen(_) => write!(f, "EdgeIndicatorParen"), + AnyNode::CurrentState(_) => write!(f, "CurrentState"), + AnyNode::NextState(_) => write!(f, "NextState"), + AnyNode::OutputSymbol(_) => write!(f, "OutputSymbol"), + AnyNode::LevelSymbol(_) => write!(f, "LevelSymbol"), + AnyNode::EdgeSymbol(_) => write!(f, "EdgeSymbol"), + AnyNode::SpecifyInputTerminalDescriptor(_) => { + write!(f, "SpecifyInputTerminalDescriptor") + } + AnyNode::SpecifyOutputTerminalDescriptor(_) => { + write!(f, "SpecifyOutputTerminalDescriptor") + } + AnyNode::InputIdentifier(_) => write!(f, "InputIdentifier"), + AnyNode::InputIdentifierInterface(_) => write!(f, "InputIdentifierInterface"), + AnyNode::OutputIdentifier(_) => write!(f, "OutputIdentifier"), + AnyNode::OutputIdentifierInterface(_) => write!(f, "OutputIdentifierInterface"), + AnyNode::PathDeclaration(_) => write!(f, "PathDeclaration"), + AnyNode::SimplePathDeclaration(_) => write!(f, "SimplePathDeclaration"), + AnyNode::SimplePathDeclarationParallel(_) => write!(f, "SimplePathDeclarationParallel"), + AnyNode::SimplePathDeclarationFull(_) => write!(f, "SimplePathDeclarationFull"), + AnyNode::ParallelPathDescription(_) => write!(f, "ParallelPathDescription"), + AnyNode::FullPathDescription(_) => write!(f, "FullPathDescription"), + AnyNode::ListOfPathInputs(_) => write!(f, "ListOfPathInputs"), + AnyNode::ListOfPathOutputs(_) => write!(f, "ListOfPathOutputs"), + AnyNode::PathDelayValue(_) => write!(f, "PathDelayValue"), + AnyNode::PathDelayValueParen(_) => write!(f, "PathDelayValueParen"), + AnyNode::ListOfPathDelayExpressions(_) => write!(f, "ListOfPathDelayExpressions"), + AnyNode::TPathDelayExpression(_) => write!(f, "TPathDelayExpression"), + AnyNode::PathDelayExpression(_) => write!(f, "PathDelayExpression"), + AnyNode::EdgeSensitivePathDeclaration(_) => write!(f, "EdgeSensitivePathDeclaration"), + AnyNode::EdgeSensitivePathDeclarationParallel(_) => { + write!(f, "EdgeSensitivePathDeclarationParallel") + } + AnyNode::EdgeSensitivePathDeclarationFull(_) => { + write!(f, "EdgeSensitivePathDeclarationFull") + } + AnyNode::ParallelEdgeSensitivePathDescription(_) => { + write!(f, "ParallelEdgeSensitivePathDescription") + } + AnyNode::FullEdgeSensitivePathDescription(_) => { + write!(f, "FullEdgeSensitivePathDescription") + } + AnyNode::DataSourceExpression(_) => write!(f, "DataSourceExpression"), + AnyNode::EdgeIdentifier(_) => write!(f, "EdgeIdentifier"), + AnyNode::StateDependentPathDeclaration(_) => write!(f, "StateDependentPathDeclaration"), + AnyNode::StateDependentPathDeclarationIfSimple(_) => { + write!(f, "StateDependentPathDeclarationIfSimple") + } + AnyNode::StateDependentPathDeclarationIfEdgeSensitive(_) => { + write!(f, "StateDependentPathDeclarationIfEdgeSensitive") + } + AnyNode::StateDependentPathDeclarationIfNone(_) => { + write!(f, "StateDependentPathDeclarationIfNone") + } + AnyNode::PolarityOperator(_) => write!(f, "PolarityOperator"), + AnyNode::SpecifyBlock(_) => write!(f, "SpecifyBlock"), + AnyNode::SpecifyItem(_) => write!(f, "SpecifyItem"), + AnyNode::PulsestyleDeclaration(_) => write!(f, "PulsestyleDeclaration"), + AnyNode::ShowcancelledDeclaration(_) => write!(f, "ShowcancelledDeclaration"), + AnyNode::TimingCheckEvent(_) => write!(f, "TimingCheckEvent"), + AnyNode::ControlledTimingCheckEvent(_) => write!(f, "ControlledTimingCheckEvent"), + AnyNode::TimingCheckEventControl(_) => write!(f, "TimingCheckEventControl"), + AnyNode::SpecifyTerminalDescriptor(_) => write!(f, "SpecifyTerminalDescriptor"), + AnyNode::EdgeControlSpecifier(_) => write!(f, "EdgeControlSpecifier"), + AnyNode::EdgeDescriptor(_) => write!(f, "EdgeDescriptor"), + AnyNode::TimingCheckCondition(_) => write!(f, "TimingCheckCondition"), + AnyNode::TimingCheckConditionParen(_) => write!(f, "TimingCheckConditionParen"), + AnyNode::ScalarTimingCheckCondition(_) => write!(f, "ScalarTimingCheckCondition"), + AnyNode::ScalarTimingCheckConditionUnary(_) => { + write!(f, "ScalarTimingCheckConditionUnary") + } + AnyNode::ScalarTimingCheckConditionBinary(_) => { + write!(f, "ScalarTimingCheckConditionBinary") + } + AnyNode::ScalarConstant(_) => write!(f, "ScalarConstant"), + AnyNode::SystemTimingCheck(_) => write!(f, "SystemTimingCheck"), + AnyNode::SetupTimingCheck(_) => write!(f, "SetupTimingCheck"), + AnyNode::HoldTimingCheck(_) => write!(f, "HoldTimingCheck"), + AnyNode::SetupholdTimingCheck(_) => write!(f, "SetupholdTimingCheck"), + AnyNode::RecoveryTimingCheck(_) => write!(f, "RecoveryTimingCheck"), + AnyNode::RemovalTimingCheck(_) => write!(f, "RemovalTimingCheck"), + AnyNode::RecremTimingCheck(_) => write!(f, "RecremTimingCheck"), + AnyNode::SkewTimingCheck(_) => write!(f, "SkewTimingCheck"), + AnyNode::TimeskewTimingCheck(_) => write!(f, "TimeskewTimingCheck"), + AnyNode::FullskewTimingCheck(_) => write!(f, "FullskewTimingCheck"), + AnyNode::PeriodTimingCheck(_) => write!(f, "PeriodTimingCheck"), + AnyNode::WidthTimingCheck(_) => write!(f, "WidthTimingCheck"), + AnyNode::NochangeTimingCheck(_) => write!(f, "NochangeTimingCheck"), + AnyNode::TimecheckCondition(_) => write!(f, "TimecheckCondition"), + AnyNode::ControlledReferenceEvent(_) => write!(f, "ControlledReferenceEvent"), + AnyNode::DataEvent(_) => write!(f, "DataEvent"), + AnyNode::DelayedData(_) => write!(f, "DelayedData"), + AnyNode::DelayedDataWithMintypmax(_) => write!(f, "DelayedDataWithMintypmax"), + AnyNode::DelayedReference(_) => write!(f, "DelayedReference"), + AnyNode::DelayedReferenceWithMintypmax(_) => write!(f, "DelayedReferenceWithMintypmax"), + AnyNode::EndEdgeOffset(_) => write!(f, "EndEdgeOffset"), + AnyNode::EventBasedFlag(_) => write!(f, "EventBasedFlag"), + AnyNode::Notifier(_) => write!(f, "Notifier"), + AnyNode::ReferenceEvent(_) => write!(f, "ReferenceEvent"), + AnyNode::RemainActiveFlag(_) => write!(f, "RemainActiveFlag"), + AnyNode::TimestampCondition(_) => write!(f, "TimestampCondition"), + AnyNode::StartEdgeOffset(_) => write!(f, "StartEdgeOffset"), + AnyNode::Threshold(_) => write!(f, "Threshold"), + AnyNode::TimingCheckLimit(_) => write!(f, "TimingCheckLimit"), + AnyNode::ProceduralTimingControlStatement(_) => { + write!(f, "ProceduralTimingControlStatement") + } + AnyNode::DelayOrEventControl(_) => write!(f, "DelayOrEventControl"), + AnyNode::DelayOrEventControlRepeat(_) => write!(f, "DelayOrEventControlRepeat"), + AnyNode::DelayControl(_) => write!(f, "DelayControl"), + AnyNode::DelayControlDelay(_) => write!(f, "DelayControlDelay"), + AnyNode::DelayControlMintypmax(_) => write!(f, "DelayControlMintypmax"), + AnyNode::EventControl(_) => write!(f, "EventControl"), + AnyNode::EventControlEventIdentifier(_) => write!(f, "EventControlEventIdentifier"), + AnyNode::EventControlEventExpression(_) => write!(f, "EventControlEventExpression"), + AnyNode::EventControlAsterisk(_) => write!(f, "EventControlAsterisk"), + AnyNode::EventControlParenAsterisk(_) => write!(f, "EventControlParenAsterisk"), + AnyNode::EventControlSequenceIdentifier(_) => { + write!(f, "EventControlSequenceIdentifier") + } + AnyNode::EventExpression(_) => write!(f, "EventExpression"), + AnyNode::EventExpressionExpression(_) => write!(f, "EventExpressionExpression"), + AnyNode::EventExpressionSequence(_) => write!(f, "EventExpressionSequence"), + AnyNode::EventExpressionOr(_) => write!(f, "EventExpressionOr"), + AnyNode::EventExpressionComma(_) => write!(f, "EventExpressionComma"), + AnyNode::EventExpressionParen(_) => write!(f, "EventExpressionParen"), + AnyNode::ProceduralTimingControl(_) => write!(f, "ProceduralTimingControl"), + AnyNode::JumpStatement(_) => write!(f, "JumpStatement"), + AnyNode::JumpStatementReturn(_) => write!(f, "JumpStatementReturn"), + AnyNode::JumpStatementBreak(_) => write!(f, "JumpStatementBreak"), + AnyNode::JumpStatementContinue(_) => write!(f, "JumpStatementContinue"), + AnyNode::WaitStatement(_) => write!(f, "WaitStatement"), + AnyNode::WaitStatementWait(_) => write!(f, "WaitStatementWait"), + AnyNode::WaitStatementFork(_) => write!(f, "WaitStatementFork"), + AnyNode::WaitStatementOrder(_) => write!(f, "WaitStatementOrder"), + AnyNode::EventTrigger(_) => write!(f, "EventTrigger"), + AnyNode::EventTriggerNamed(_) => write!(f, "EventTriggerNamed"), + AnyNode::EventTriggerNonblocking(_) => write!(f, "EventTriggerNonblocking"), + AnyNode::DisableStatement(_) => write!(f, "DisableStatement"), + AnyNode::DisableStatementTask(_) => write!(f, "DisableStatementTask"), + AnyNode::DisableStatementBlock(_) => write!(f, "DisableStatementBlock"), + AnyNode::DisableStatementFork(_) => write!(f, "DisableStatementFork"), + AnyNode::ConditionalStatement(_) => write!(f, "ConditionalStatement"), + AnyNode::UniquePriority(_) => write!(f, "UniquePriority"), + AnyNode::CondPredicate(_) => write!(f, "CondPredicate"), + AnyNode::ExpressionOrCondPattern(_) => write!(f, "ExpressionOrCondPattern"), + AnyNode::CondPattern(_) => write!(f, "CondPattern"), + AnyNode::AssertionItem(_) => write!(f, "AssertionItem"), + AnyNode::DeferredImmediateAssertionItem(_) => { + write!(f, "DeferredImmediateAssertionItem") + } + AnyNode::ProceduralAssertionStatement(_) => write!(f, "ProceduralAssertionStatement"), + AnyNode::ImmediateAssertionStatement(_) => write!(f, "ImmediateAssertionStatement"), + AnyNode::SimpleImmediateAssertionStatement(_) => { + write!(f, "SimpleImmediateAssertionStatement") + } + AnyNode::SimpleImmediateAssertStatement(_) => { + write!(f, "SimpleImmediateAssertStatement") + } + AnyNode::SimpleImmediateAssumeStatement(_) => { + write!(f, "SimpleImmediateAssumeStatement") + } + AnyNode::SimpleImmediateCoverStatement(_) => write!(f, "SimpleImmediateCoverStatement"), + AnyNode::DeferredImmediateAssertionStatement(_) => { + write!(f, "DeferredImmediateAssertionStatement") + } + AnyNode::DeferredImmediateAssertStatement(_) => { + write!(f, "DeferredImmediateAssertStatement") + } + AnyNode::DeferredImmediateAssumeStatement(_) => { + write!(f, "DeferredImmediateAssumeStatement") + } + AnyNode::DeferredImmediateCoverStatement(_) => { + write!(f, "DeferredImmediateCoverStatement") + } + AnyNode::AssertTiming(_) => write!(f, "AssertTiming"), + AnyNode::Pattern(_) => write!(f, "Pattern"), + AnyNode::PatternVariable(_) => write!(f, "PatternVariable"), + AnyNode::PatternTagged(_) => write!(f, "PatternTagged"), + AnyNode::PatternList(_) => write!(f, "PatternList"), + AnyNode::PatternIdentifierList(_) => write!(f, "PatternIdentifierList"), + AnyNode::AssignmentPattern(_) => write!(f, "AssignmentPattern"), + AnyNode::AssignmentPatternList(_) => write!(f, "AssignmentPatternList"), + AnyNode::AssignmentPatternStructure(_) => write!(f, "AssignmentPatternStructure"), + AnyNode::AssignmentPatternArray(_) => write!(f, "AssignmentPatternArray"), + AnyNode::AssignmentPatternRepeat(_) => write!(f, "AssignmentPatternRepeat"), + AnyNode::StructurePatternKey(_) => write!(f, "StructurePatternKey"), + AnyNode::ArrayPatternKey(_) => write!(f, "ArrayPatternKey"), + AnyNode::AssignmentPatternKey(_) => write!(f, "AssignmentPatternKey"), + AnyNode::AssignmentPatternExpression(_) => write!(f, "AssignmentPatternExpression"), + AnyNode::AssignmentPatternExpressionType(_) => { + write!(f, "AssignmentPatternExpressionType") + } + AnyNode::ConstantAssignmentPatternExpression(_) => { + write!(f, "ConstantAssignmentPatternExpression") + } + AnyNode::AssignmentPatternNetLvalue(_) => write!(f, "AssignmentPatternNetLvalue"), + AnyNode::AssignmentPatternVariableLvalue(_) => { + write!(f, "AssignmentPatternVariableLvalue") + } + AnyNode::ContinuousAssign(_) => write!(f, "ContinuousAssign"), + AnyNode::ContinuousAssignNet(_) => write!(f, "ContinuousAssignNet"), + AnyNode::ContinuousAssignVariable(_) => write!(f, "ContinuousAssignVariable"), + AnyNode::ListOfNetAssignments(_) => write!(f, "ListOfNetAssignments"), + AnyNode::ListOfVariableAssignments(_) => write!(f, "ListOfVariableAssignments"), + AnyNode::NetAlias(_) => write!(f, "NetAlias"), + AnyNode::NetAssignment(_) => write!(f, "NetAssignment"), + AnyNode::SubroutineCallStatement(_) => write!(f, "SubroutineCallStatement"), + AnyNode::SubroutineCallStatementFunction(_) => { + write!(f, "SubroutineCallStatementFunction") + } + AnyNode::StatementOrNull(_) => write!(f, "StatementOrNull"), + AnyNode::StatementOrNullAttribute(_) => write!(f, "StatementOrNullAttribute"), + AnyNode::Statement(_) => write!(f, "Statement"), + AnyNode::StatementItem(_) => write!(f, "StatementItem"), + AnyNode::FunctionStatement(_) => write!(f, "FunctionStatement"), + AnyNode::FunctionStatementOrNull(_) => write!(f, "FunctionStatementOrNull"), + AnyNode::FunctionStatementOrNullAttribute(_) => { + write!(f, "FunctionStatementOrNullAttribute") + } + AnyNode::VariableIdentifierList(_) => write!(f, "VariableIdentifierList"), + AnyNode::RandsequenceStatement(_) => write!(f, "RandsequenceStatement"), + AnyNode::Production(_) => write!(f, "Production"), + AnyNode::RsRule(_) => write!(f, "RsRule"), + AnyNode::RsProductionList(_) => write!(f, "RsProductionList"), + AnyNode::RsProductionListProd(_) => write!(f, "RsProductionListProd"), + AnyNode::RsProductionListJoin(_) => write!(f, "RsProductionListJoin"), + AnyNode::WeightSpecification(_) => write!(f, "WeightSpecification"), + AnyNode::WeightSpecificationExpression(_) => write!(f, "WeightSpecificationExpression"), + AnyNode::RsCodeBlock(_) => write!(f, "RsCodeBlock"), + AnyNode::RsProd(_) => write!(f, "RsProd"), + AnyNode::ProductionItem(_) => write!(f, "ProductionItem"), + AnyNode::RsIfElse(_) => write!(f, "RsIfElse"), + AnyNode::RsRepeat(_) => write!(f, "RsRepeat"), + AnyNode::RsCase(_) => write!(f, "RsCase"), + AnyNode::RsCaseItem(_) => write!(f, "RsCaseItem"), + AnyNode::RsCaseItemNondefault(_) => write!(f, "RsCaseItemNondefault"), + AnyNode::RsCaseItemDefault(_) => write!(f, "RsCaseItemDefault"), + AnyNode::LoopStatement(_) => write!(f, "LoopStatement"), + AnyNode::LoopStatementForever(_) => write!(f, "LoopStatementForever"), + AnyNode::LoopStatementRepeat(_) => write!(f, "LoopStatementRepeat"), + AnyNode::LoopStatementWhile(_) => write!(f, "LoopStatementWhile"), + AnyNode::LoopStatementFor(_) => write!(f, "LoopStatementFor"), + AnyNode::LoopStatementDoWhile(_) => write!(f, "LoopStatementDoWhile"), + AnyNode::LoopStatementForeach(_) => write!(f, "LoopStatementForeach"), + AnyNode::ForInitialization(_) => write!(f, "ForInitialization"), + AnyNode::ForInitializationDeclaration(_) => write!(f, "ForInitializationDeclaration"), + AnyNode::ForVariableDeclaration(_) => write!(f, "ForVariableDeclaration"), + AnyNode::Var(_) => write!(f, "Var"), + AnyNode::ForStep(_) => write!(f, "ForStep"), + AnyNode::ForStepAssignment(_) => write!(f, "ForStepAssignment"), + AnyNode::LoopVariables(_) => write!(f, "LoopVariables"), + AnyNode::ActionBlock(_) => write!(f, "ActionBlock"), + AnyNode::ActionBlockElse(_) => write!(f, "ActionBlockElse"), + AnyNode::SeqBlock(_) => write!(f, "SeqBlock"), + AnyNode::ParBlock(_) => write!(f, "ParBlock"), + AnyNode::JoinKeyword(_) => write!(f, "JoinKeyword"), + AnyNode::ClockingDeclaration(_) => write!(f, "ClockingDeclaration"), + AnyNode::ClockingDeclarationLocal(_) => write!(f, "ClockingDeclarationLocal"), + AnyNode::Default(_) => write!(f, "Default"), + AnyNode::ClockingDeclarationGlobal(_) => write!(f, "ClockingDeclarationGlobal"), + AnyNode::ClockingEvent(_) => write!(f, "ClockingEvent"), + AnyNode::ClockingEventIdentifier(_) => write!(f, "ClockingEventIdentifier"), + AnyNode::ClockingEventExpression(_) => write!(f, "ClockingEventExpression"), + AnyNode::ClockingItem(_) => write!(f, "ClockingItem"), + AnyNode::ClockingItemDefault(_) => write!(f, "ClockingItemDefault"), + AnyNode::ClockingItemDirection(_) => write!(f, "ClockingItemDirection"), + AnyNode::ClockingItemAssertion(_) => write!(f, "ClockingItemAssertion"), + AnyNode::DefaultSkew(_) => write!(f, "DefaultSkew"), + AnyNode::DefaultSkewInput(_) => write!(f, "DefaultSkewInput"), + AnyNode::DefaultSkewOutput(_) => write!(f, "DefaultSkewOutput"), + AnyNode::DefaultSkewInputOutput(_) => write!(f, "DefaultSkewInputOutput"), + AnyNode::ClockingDirection(_) => write!(f, "ClockingDirection"), + AnyNode::ClockingDirectionInput(_) => write!(f, "ClockingDirectionInput"), + AnyNode::ClockingDirectionOutput(_) => write!(f, "ClockingDirectionOutput"), + AnyNode::ClockingDirectionInputOutput(_) => write!(f, "ClockingDirectionInputOutput"), + AnyNode::ListOfClockingDeclAssign(_) => write!(f, "ListOfClockingDeclAssign"), + AnyNode::ClockingDeclAssign(_) => write!(f, "ClockingDeclAssign"), + AnyNode::ClockingSkew(_) => write!(f, "ClockingSkew"), + AnyNode::ClockingSkewEdge(_) => write!(f, "ClockingSkewEdge"), + AnyNode::ClockingDrive(_) => write!(f, "ClockingDrive"), + AnyNode::CycleDelay(_) => write!(f, "CycleDelay"), + AnyNode::CycleDelayIntegral(_) => write!(f, "CycleDelayIntegral"), + AnyNode::CycleDelayIdentifier(_) => write!(f, "CycleDelayIdentifier"), + AnyNode::CycleDelayExpression(_) => write!(f, "CycleDelayExpression"), + AnyNode::Clockvar(_) => write!(f, "Clockvar"), + AnyNode::ClockvarExpression(_) => write!(f, "ClockvarExpression"), + AnyNode::CaseStatement(_) => write!(f, "CaseStatement"), + AnyNode::CaseStatementNormal(_) => write!(f, "CaseStatementNormal"), + AnyNode::CaseStatementMatches(_) => write!(f, "CaseStatementMatches"), + AnyNode::CaseStatementInside(_) => write!(f, "CaseStatementInside"), + AnyNode::CaseKeyword(_) => write!(f, "CaseKeyword"), + AnyNode::CaseExpression(_) => write!(f, "CaseExpression"), + AnyNode::CaseExpressionExpression(_) => write!(f, "CaseExpressionExpression"), + AnyNode::CaseItem(_) => write!(f, "CaseItem"), + AnyNode::CaseItemNondefault(_) => write!(f, "CaseItemNondefault"), + AnyNode::CaseItemDefault(_) => write!(f, "CaseItemDefault"), + AnyNode::CasePatternItem(_) => write!(f, "CasePatternItem"), + AnyNode::CasePatternItemNondefault(_) => write!(f, "CasePatternItemNondefault"), + AnyNode::CaseInsideItem(_) => write!(f, "CaseInsideItem"), + AnyNode::CaseInsideItemNondefault(_) => write!(f, "CaseInsideItemNondefault"), + AnyNode::CaseItemExpression(_) => write!(f, "CaseItemExpression"), + AnyNode::RandcaseStatement(_) => write!(f, "RandcaseStatement"), + AnyNode::RandcaseItem(_) => write!(f, "RandcaseItem"), + AnyNode::OpenRangeList(_) => write!(f, "OpenRangeList"), + AnyNode::OpenValueRange(_) => write!(f, "OpenValueRange"), + AnyNode::InitialConstruct(_) => write!(f, "InitialConstruct"), + AnyNode::AlwaysConstruct(_) => write!(f, "AlwaysConstruct"), + AnyNode::AlwaysKeyword(_) => write!(f, "AlwaysKeyword"), + AnyNode::FinalConstruct(_) => write!(f, "FinalConstruct"), + AnyNode::BlockingAssignment(_) => write!(f, "BlockingAssignment"), + AnyNode::BlockingAssignmentVariable(_) => write!(f, "BlockingAssignmentVariable"), + AnyNode::BlockingAssignmentNonrangeVariable(_) => { + write!(f, "BlockingAssignmentNonrangeVariable") + } + AnyNode::BlockingAssignmentHierarchicalVariable(_) => { + write!(f, "BlockingAssignmentHierarchicalVariable") + } + AnyNode::OperatorAssignment(_) => write!(f, "OperatorAssignment"), + AnyNode::AssignmentOperator(_) => write!(f, "AssignmentOperator"), + AnyNode::NonblockingAssignment(_) => write!(f, "NonblockingAssignment"), + AnyNode::ProceduralContinuousAssignment(_) => { + write!(f, "ProceduralContinuousAssignment") + } + AnyNode::ProceduralContinuousAssignmentAssign(_) => { + write!(f, "ProceduralContinuousAssignmentAssign") + } + AnyNode::ProceduralContinuousAssignmentDeassign(_) => { + write!(f, "ProceduralContinuousAssignmentDeassign") + } + AnyNode::ProceduralContinuousAssignmentForceVariable(_) => { + write!(f, "ProceduralContinuousAssignmentForceVariable") + } + AnyNode::ProceduralContinuousAssignmentForceNet(_) => { + write!(f, "ProceduralContinuousAssignmentForceNet") + } + AnyNode::ProceduralContinuousAssignmentReleaseVariable(_) => { + write!(f, "ProceduralContinuousAssignmentReleaseVariable") + } + AnyNode::ProceduralContinuousAssignmentReleaseNet(_) => { + write!(f, "ProceduralContinuousAssignmentReleaseNet") + } + AnyNode::VariableAssignment(_) => write!(f, "VariableAssignment"), + } + } +} // ----------------------------------------------------------------------------- diff --git a/sv-parser-syntaxtree/src/instantiations/generated_instantiation.rs b/sv-parser-syntaxtree/src/instantiations/generated_instantiation.rs index 18882c0e..dd7afa0d 100644 --- a/sv-parser-syntaxtree/src/instantiations/generated_instantiation.rs +++ b/sv-parser-syntaxtree/src/instantiations/generated_instantiation.rs @@ -102,6 +102,7 @@ pub enum GenerateBlock { Multiple(Box), } +#[cfg(not(feature = "nested-gen-block-begin"))] #[derive(Clone, Debug, PartialEq, Node)] pub struct GenerateBlockMultiple { pub nodes: ( @@ -113,6 +114,18 @@ pub struct GenerateBlockMultiple { Option<(Symbol, GenerateBlockIdentifier)>, ), } +#[cfg(feature = "nested-gen-block-begin")] +#[derive(Clone, Debug, PartialEq, Node)] +pub struct GenerateBlockMultiple { + pub nodes: ( + Option<(GenerateBlockIdentifier, Symbol)>, + Keyword, + Option<(Symbol, GenerateBlockIdentifier)>, + Vec, + Keyword, + Option<(Symbol, GenerateBlockIdentifier)>, + ), +} #[derive(Clone, Debug, PartialEq, Node)] pub enum GenerateItem { diff --git a/sv-parser/Cargo.toml b/sv-parser/Cargo.toml index ff6bdc66..167d856b 100644 --- a/sv-parser/Cargo.toml +++ b/sv-parser/Cargo.toml @@ -24,6 +24,8 @@ pre-release-replacements = [ [features] default = [] trace = ["sv-parser-parser/trace"] +nested-gen-block-begin = ["sv-parser-parser/nested-gen-block-begin", "sv-parser-syntaxtree/nested-gen-block-begin"] +vendor-extensions = ["sv-parser-parser/vendor-extensions", "sv-parser-syntaxtree/vendor-extensions"] [dependencies] nom = "7" diff --git a/sv-parser/src/lib.rs b/sv-parser/src/lib.rs index e84700a7..51d58a77 100644 --- a/sv-parser/src/lib.rs +++ b/sv-parser/src/lib.rs @@ -149,10 +149,18 @@ impl fmt::Debug for SyntaxTree { } NodeEvent::Enter(x) => { match x { - RefNode::WhiteSpace(WhiteSpace::Newline(_)) => { ws = WS::Newline; } - RefNode::WhiteSpace(WhiteSpace::Space(_)) => { ws = WS::Space; } - RefNode::WhiteSpace(WhiteSpace::Comment(_)) => { ws = WS::Comment; } - RefNode::WhiteSpace(WhiteSpace::CompilerDirective(_)) => { ws = WS::CompilerDirective; } + RefNode::WhiteSpace(WhiteSpace::Newline(_)) => { + ws = WS::Newline; + } + RefNode::WhiteSpace(WhiteSpace::Space(_)) => { + ws = WS::Space; + } + RefNode::WhiteSpace(WhiteSpace::Comment(_)) => { + ws = WS::Comment; + } + RefNode::WhiteSpace(WhiteSpace::CompilerDirective(_)) => { + ws = WS::CompilerDirective; + } _ => {} } ret.push_str(&format!("{}{}\n", " ".repeat(depth), x)); @@ -161,7 +169,9 @@ impl fmt::Debug for SyntaxTree { NodeEvent::Leave(x) => { match x { RefNode::WhiteSpace(_) => {} - _ => { ws = WS::NotWhitespace; } + _ => { + ws = WS::NotWhitespace; + } } depth -= 1; } @@ -252,8 +262,8 @@ pub fn parse_sv_str, U: AsRef, V: BuildHasher>( include_paths, ignore_include, false, // strip_comments - 0, // resolve_depth - 0, // include_depth + 0, // resolve_depth + 0, // include_depth )?; parse_sv_pp(text, defines, allow_incomplete) } @@ -290,8 +300,8 @@ pub fn parse_lib_str, U: AsRef, V: BuildHasher>( include_paths, ignore_include, false, // strip_comments - 0, // resolve_depth - 0, // include_depth + 0, // resolve_depth + 0, // include_depth )?; parse_lib_pp(text, defines, allow_incomplete) } @@ -474,4 +484,26 @@ endmodule"##; let ret = parse_sv_str(src, &path, &defines, &[""], false, false); assert!(ret.is_ok()); } + + #[test] + fn test_nested_begins() { + let src = r##"module my_top; + for (genvar i = 0; i < 7; i++) begin begin: something + begin: another + begin + logic c; + end + end + end + end + endmodule +"##; + let path = PathBuf::from(""); + let defines = HashMap::new(); + let ret = parse_sv_str(src, &path, &defines, &[""], false, false); + #[cfg(not(feature = "nested-gen-block-begin"))] + assert!(ret.is_err()); + #[cfg(feature = "nested-gen-block-begin")] + assert!(ret.is_ok()); + } } From 3c577c32b65d88b081de0cb27295801c022e9d84 Mon Sep 17 00:00:00 2001 From: yousifB Date: Thu, 4 Jun 2026 12:38:22 +0200 Subject: [PATCH 2/6] Fix relax empty queue syntax --- sv-parser-parser/Cargo.toml | 3 ++- sv-parser-parser/src/expressions/concatenations.rs | 2 ++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/sv-parser-parser/Cargo.toml b/sv-parser-parser/Cargo.toml index 20502a0f..f6fc67aa 100644 --- a/sv-parser-parser/Cargo.toml +++ b/sv-parser-parser/Cargo.toml @@ -20,7 +20,8 @@ tag = false default = [] trace = ["nom-tracable/trace"] nested-gen-block-begin = [] -vendor-extensions = ["nested-gen-block-begin"] +empty-queue-syntax = [] +vendor-extensions = ["nested-gen-block-begin", "empty-queue-syntax"] [dependencies] nom = "7" diff --git a/sv-parser-parser/src/expressions/concatenations.rs b/sv-parser-parser/src/expressions/concatenations.rs index 05adb82a..879edaa8 100644 --- a/sv-parser-parser/src/expressions/concatenations.rs +++ b/sv-parser-parser/src/expressions/concatenations.rs @@ -156,6 +156,8 @@ pub(crate) fn array_range_expression_minus_colon(s: Span) -> IResult IResult { + #[cfg(feature = "empty-queue-syntax")] + let (s, _) = opt(symbol("'"))(s)?; let (s, a) = symbol("{")(s)?; let (s, b) = symbol("}")(s)?; Ok((s, EmptyUnpackedArrayConcatenation { nodes: (a, b) })) From 1e7f5dccbc1e5de00117cb0a9b08278fd67b502a Mon Sep 17 00:00:00 2001 From: yousifB Date: Mon, 8 Jun 2026 12:12:18 +0200 Subject: [PATCH 3/6] Allow consecutive unary operators with feature --- sv-parser-parser/Cargo.toml | 3 ++- .../src/expressions/expressions.rs | 18 ++++++++++++++---- sv-parser-syntaxtree/Cargo.toml | 3 ++- .../src/expressions/expressions.rs | 12 ++++++++++++ 4 files changed, 30 insertions(+), 6 deletions(-) diff --git a/sv-parser-parser/Cargo.toml b/sv-parser-parser/Cargo.toml index f6fc67aa..7870d742 100644 --- a/sv-parser-parser/Cargo.toml +++ b/sv-parser-parser/Cargo.toml @@ -21,7 +21,8 @@ default = [] trace = ["nom-tracable/trace"] nested-gen-block-begin = [] empty-queue-syntax = [] -vendor-extensions = ["nested-gen-block-begin", "empty-queue-syntax"] +consecutive-unary-operators = [] +vendor-extensions = ["nested-gen-block-begin", "empty-queue-syntax", "consecutive-unary-operators"] [dependencies] nom = "7" diff --git a/sv-parser-parser/src/expressions/expressions.rs b/sv-parser-parser/src/expressions/expressions.rs index 11089029..98e8309c 100644 --- a/sv-parser-parser/src/expressions/expressions.rs +++ b/sv-parser-parser/src/expressions/expressions.rs @@ -282,13 +282,23 @@ pub(crate) fn expression(s: Span) -> IResult { #[tracable_parser] #[packrat_parser] pub(crate) fn expression_unary(s: Span) -> IResult { - let (s, x) = unary_operator(s)?; + let (s, w) = unary_operator(s)?; + #[cfg(feature = "consecutive-unary-operators")] + let (s, x) = many0(unary_operator)(s)?; let (s, y) = many0(attribute_instance)(s)?; let (s, z) = primary(s)?; - Ok(( + #[cfg(not(feature = "consecutive-unary-operators"))] + return Ok(( s, - Expression::Unary(Box::new(ExpressionUnary { nodes: (x, y, z) })), - )) + Expression::Unary(Box::new(ExpressionUnary { nodes: (w, y, z) })), + )); + #[cfg(feature = "consecutive-unary-operators")] + return Ok(( + s, + Expression::Unary(Box::new(ExpressionUnary { + nodes: (w, x, y, z), + })), + )); } #[tracable_parser] diff --git a/sv-parser-syntaxtree/Cargo.toml b/sv-parser-syntaxtree/Cargo.toml index f68ccd4d..1ec24171 100644 --- a/sv-parser-syntaxtree/Cargo.toml +++ b/sv-parser-syntaxtree/Cargo.toml @@ -25,4 +25,5 @@ walkdir = "2" [features] nested-gen-block-begin = [] -vendor-extensions = ["nested-gen-block-begin"] +consecutive-unary-operators = [] +vendor-extensions = ["nested-gen-block-begin", "consecutive-unary-operators"] diff --git a/sv-parser-syntaxtree/src/expressions/expressions.rs b/sv-parser-syntaxtree/src/expressions/expressions.rs index d88a5678..08a9a140 100644 --- a/sv-parser-syntaxtree/src/expressions/expressions.rs +++ b/sv-parser-syntaxtree/src/expressions/expressions.rs @@ -136,11 +136,23 @@ pub enum Expression { TaggedUnionExpression(Box), } +#[cfg(not(feature = "consecutive-unary-operators"))] #[derive(Clone, Debug, PartialEq, Node)] pub struct ExpressionUnary { pub nodes: (UnaryOperator, Vec, Primary), } +#[cfg(feature = "consecutive-unary-operators")] +#[derive(Clone, Debug, PartialEq, Node)] +pub struct ExpressionUnary { + pub nodes: ( + UnaryOperator, + Vec, + Vec, + Primary, + ), +} + #[derive(Clone, Debug, PartialEq, Node)] pub struct ExpressionOperatorAssignment { pub nodes: (Paren,), From 591f3f968936296e9628b7b3f4c9b792d24883ba Mon Sep 17 00:00:00 2001 From: yousifB Date: Tue, 9 Jun 2026 19:33:45 +0200 Subject: [PATCH 4/6] Allow brace without apostrophes for arrays --- sv-parser-parser/Cargo.toml | 28 +++++++++++-------- .../src/behavioral_statements/patterns.rs | 19 +++++++++++++ sv-parser-syntaxtree/Cargo.toml | 11 ++++++-- sv-parser-syntaxtree/src/any_node.rs | 8 ++++++ .../src/behavioral_statements/patterns.rs | 14 ++++++++++ 5 files changed, 66 insertions(+), 14 deletions(-) diff --git a/sv-parser-parser/Cargo.toml b/sv-parser-parser/Cargo.toml index 7870d742..7e1fb3a2 100644 --- a/sv-parser-parser/Cargo.toml +++ b/sv-parser-parser/Cargo.toml @@ -18,19 +18,25 @@ tag = false [features] default = [] -trace = ["nom-tracable/trace"] +trace = ["nom-tracable/trace"] nested-gen-block-begin = [] empty-queue-syntax = [] consecutive-unary-operators = [] -vendor-extensions = ["nested-gen-block-begin", "empty-queue-syntax", "consecutive-unary-operators"] +allow-no-apostrophe = [] +vendor-extensions = [ + "nested-gen-block-begin", + "empty-queue-syntax", + "consecutive-unary-operators", + "allow-no-apostrophe", +] [dependencies] -nom = "7" -nom_locate = "4" -nom-greedyerror = "0.5" -nom-packrat = "0.7" -nom-recursive = {version = "0.5", features = ["tracer128"]} -nom-tracable = "0.9" -str-concat = "0.2" -sv-parser-macros = {version = "^0.13.5", path = "../sv-parser-macros"} -sv-parser-syntaxtree = {version = "^0.13.5", path = "../sv-parser-syntaxtree"} +nom = "7" +nom_locate = "4" +nom-greedyerror = "0.5" +nom-packrat = "0.7" +nom-recursive = { version = "0.5", features = ["tracer128"] } +nom-tracable = "0.9" +str-concat = "0.2" +sv-parser-macros = { version = "^0.13.5", path = "../sv-parser-macros" } +sv-parser-syntaxtree = { version = "^0.13.5", path = "../sv-parser-syntaxtree" } diff --git a/sv-parser-parser/src/behavioral_statements/patterns.rs b/sv-parser-parser/src/behavioral_statements/patterns.rs index 147a66b3..664f8ffd 100644 --- a/sv-parser-parser/src/behavioral_statements/patterns.rs +++ b/sv-parser-parser/src/behavioral_statements/patterns.rs @@ -100,10 +100,29 @@ pub(crate) fn assignment_pattern_structure(s: Span) -> IResult IResult { + #[cfg(not(feature = "allow-no-apostrophe"))] let (s, a) = apostrophe_brace(list( symbol(","), triple(array_pattern_key, symbol(":"), expression), ))(s)?; + #[cfg(feature = "allow-no-apostrophe")] + let (s, a) = alt(( + map( + apostrophe_brace(list( + symbol(","), + triple(array_pattern_key, symbol(":"), expression), + )), + |ab| BraceOrApostropheBraceArray::ApostropheBrace(ab), + ), + map( + brace(list( + symbol(","), + triple(array_pattern_key, symbol(":"), expression), + )), + |b| BraceOrApostropheBraceArray::Brace(b), + ), + ))(s)?; + Ok(( s, AssignmentPattern::Array(Box::new(AssignmentPatternArray { nodes: (a,) })), diff --git a/sv-parser-syntaxtree/Cargo.toml b/sv-parser-syntaxtree/Cargo.toml index 1ec24171..7a9084bd 100644 --- a/sv-parser-syntaxtree/Cargo.toml +++ b/sv-parser-syntaxtree/Cargo.toml @@ -17,13 +17,18 @@ doctest = false tag = false [dependencies] -sv-parser-macros = {version = "^0.13.5", path = "../sv-parser-macros"} +sv-parser-macros = { version = "^0.13.5", path = "../sv-parser-macros" } [build-dependencies] -regex = "1" +regex = "1" walkdir = "2" [features] nested-gen-block-begin = [] consecutive-unary-operators = [] -vendor-extensions = ["nested-gen-block-begin", "consecutive-unary-operators"] +allow-no-apostrophe = [] +vendor-extensions = [ + "nested-gen-block-begin", + "consecutive-unary-operators", + "allow-no-apostrophe", +] diff --git a/sv-parser-syntaxtree/src/any_node.rs b/sv-parser-syntaxtree/src/any_node.rs index 89f0176e..4732d97a 100644 --- a/sv-parser-syntaxtree/src/any_node.rs +++ b/sv-parser-syntaxtree/src/any_node.rs @@ -1131,6 +1131,8 @@ pub enum RefNode<'a> { AssignmentPatternList(&'a AssignmentPatternList), AssignmentPatternStructure(&'a AssignmentPatternStructure), AssignmentPatternArray(&'a AssignmentPatternArray), + #[cfg(feature = "allow-no-apostrophe")] + BraceOrApostropheBraceArray(&'a BraceOrApostropheBraceArray), AssignmentPatternRepeat(&'a AssignmentPatternRepeat), StructurePatternKey(&'a StructurePatternKey), ArrayPatternKey(&'a ArrayPatternKey), @@ -2383,6 +2385,8 @@ pub enum AnyNode { AssignmentPatternList(AssignmentPatternList), AssignmentPatternStructure(AssignmentPatternStructure), AssignmentPatternArray(AssignmentPatternArray), + #[cfg(feature = "allow-no-apostrophe")] + BraceOrApostropheBraceArray(BraceOrApostropheBraceArray), AssignmentPatternRepeat(AssignmentPatternRepeat), StructurePatternKey(StructurePatternKey), ArrayPatternKey(ArrayPatternKey), @@ -3846,6 +3850,8 @@ impl<'a> std::fmt::Display for RefNode<'a> { RefNode::AssignmentPatternList(_) => write!(f, "AssignmentPatternList"), RefNode::AssignmentPatternStructure(_) => write!(f, "AssignmentPatternStructure"), RefNode::AssignmentPatternArray(_) => write!(f, "AssignmentPatternArray"), + #[cfg(feature = "allow-no-apostrophe")] + RefNode::BraceOrApostropheBraceArray(_) => write!(f, "BraceOrApostropheBraceArray"), RefNode::AssignmentPatternRepeat(_) => write!(f, "AssignmentPatternRepeat"), RefNode::StructurePatternKey(_) => write!(f, "StructurePatternKey"), RefNode::ArrayPatternKey(_) => write!(f, "ArrayPatternKey"), @@ -5339,6 +5345,8 @@ impl std::fmt::Display for AnyNode { AnyNode::AssignmentPatternList(_) => write!(f, "AssignmentPatternList"), AnyNode::AssignmentPatternStructure(_) => write!(f, "AssignmentPatternStructure"), AnyNode::AssignmentPatternArray(_) => write!(f, "AssignmentPatternArray"), + #[cfg(feature = "allow-no-apostrophe")] + AnyNode::BraceOrApostropheBraceArray(_) => write!(f, "BraceOrApostropheBraceArray"), AnyNode::AssignmentPatternRepeat(_) => write!(f, "AssignmentPatternRepeat"), AnyNode::StructurePatternKey(_) => write!(f, "StructurePatternKey"), AnyNode::ArrayPatternKey(_) => write!(f, "ArrayPatternKey"), diff --git a/sv-parser-syntaxtree/src/behavioral_statements/patterns.rs b/sv-parser-syntaxtree/src/behavioral_statements/patterns.rs index 1572e3ef..09f6c113 100644 --- a/sv-parser-syntaxtree/src/behavioral_statements/patterns.rs +++ b/sv-parser-syntaxtree/src/behavioral_statements/patterns.rs @@ -50,11 +50,25 @@ pub struct AssignmentPatternStructure { pub nodes: (ApostropheBrace>,), } +#[cfg(not(feature = "allow-no-apostrophe"))] #[derive(Clone, Debug, PartialEq, Node)] pub struct AssignmentPatternArray { pub nodes: (ApostropheBrace>,), } +#[cfg(feature = "allow-no-apostrophe")] +#[derive(Clone, Debug, PartialEq, Node)] +pub struct AssignmentPatternArray { + pub nodes: (BraceOrApostropheBraceArray,), +} + +#[cfg(feature = "allow-no-apostrophe")] +#[derive(Clone, Debug, PartialEq, Node)] +pub enum BraceOrApostropheBraceArray { + Brace(Brace>), + ApostropheBrace(ApostropheBrace>), +} + #[derive(Clone, Debug, PartialEq, Node)] pub struct AssignmentPatternRepeat { pub nodes: (ApostropheBrace<(ConstantExpression, Brace>)>,), From a8f151205eacbf9d415337a2925fee071bfb1e3f Mon Sep 17 00:00:00 2001 From: yousifB Date: Fri, 12 Jun 2026 22:11:38 +0200 Subject: [PATCH 5/6] Fix feature --- sv-parser/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sv-parser/Cargo.toml b/sv-parser/Cargo.toml index 167d856b..5fa929ca 100644 --- a/sv-parser/Cargo.toml +++ b/sv-parser/Cargo.toml @@ -25,7 +25,7 @@ pre-release-replacements = [ default = [] trace = ["sv-parser-parser/trace"] nested-gen-block-begin = ["sv-parser-parser/nested-gen-block-begin", "sv-parser-syntaxtree/nested-gen-block-begin"] -vendor-extensions = ["sv-parser-parser/vendor-extensions", "sv-parser-syntaxtree/vendor-extensions"] +vendor-extensions = ["nested-gen-block-begin"] [dependencies] nom = "7" From 9422af73c0af7a5ccfbe021befe4c38d9ed6a490 Mon Sep 17 00:00:00 2001 From: yousifB Date: Fri, 12 Jun 2026 23:52:56 +0200 Subject: [PATCH 6/6] Update readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8cfeb272..899eb99f 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ # sv-parser -SystemVerilog parser library fully compliant with [IEEE 1800-2017](https://standards.ieee.org/standard/1800-2017.html). +SystemVerilog parser library fully compliant with [IEEE 1800-2017](https://standards.ieee.org/standard/1800-2017.html). Relaxed parsing rues are possible via feature flags. [![Actions Status](https://github.com/dalance/sv-parser/workflows/Regression/badge.svg)](https://github.com/dalance/sv-parser/actions) [![Crates.io](https://img.shields.io/crates/v/sv-parser.svg)](https://crates.io/crates/sv-parser)