Enum sv_parser::any_node::RefNode

pub enum RefNode<'a> {
    Locate(&'a Locate),
    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),
    Comment(&'a Comment),
    AttributeInstance(&'a AttributeInstance),
    AttrSpec(&'a AttrSpec),
    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),
    PackageItem(&'a PackageItem),
    PackageOrGenerateItemDeclaration(&'a PackageOrGenerateItemDeclaration),
    AnonymousProgram(&'a AnonymousProgram),
    AnonymousProgramItem(&'a AnonymousProgramItem),
    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),
    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),
    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),
    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),
    InterfaceOrGenerateItem(&'a InterfaceOrGenerateItem),
    InterfaceOrGenerateItemModule(&'a InterfaceOrGenerateItemModule),
    InterfaceOrGenerateItemExtern(&'a InterfaceOrGenerateItemExtern),
    ExternTfDeclaration(&'a ExternTfDeclaration),
    ExternTfDeclarationMethod(&'a ExternTfDeclarationMethod),
    ExternTfDeclarationTask(&'a ExternTfDeclarationTask),
    InterfaceItem(&'a InterfaceItem),
    NonPortInterfaceItem(&'a NonPortInterfaceItem),
    ProgramItem(&'a ProgramItem),
    NonPortProgramItem(&'a NonPortProgramItem),
    NonPortProgramItemAssign(&'a NonPortProgramItemAssign),
    NonPortProgramItemModule(&'a NonPortProgramItemModule),
    NonPortProgramItemInitial(&'a NonPortProgramItemInitial),
    NonPortProgramItemFinal(&'a NonPortProgramItemFinal),
    NonPortProgramItemAssertion(&'a NonPortProgramItemAssertion),
    ProgramGenerateItem(&'a ProgramGenerateItem),
    LibraryText(&'a LibraryText),
    LibraryDescription(&'a LibraryDescription),
    LibraryDeclaration(&'a LibraryDeclaration),
    IncludeStatement(&'a IncludeStatement),
    FilePathSpec(&'a FilePathSpec),
    FilePathSpecNonLiteral(&'a FilePathSpecNonLiteral),
    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),
    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),
    UnaryOperator(&'a UnaryOperator),
    BinaryOperator(&'a BinaryOperator),
    IncOrDecOperator(&'a IncOrDecOperator),
    UnaryModulePathOperator(&'a UnaryModulePathOperator),
    BinaryModulePathOperator(&'a BinaryModulePathOperator),
    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),
    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),
    IncOrDecExpression(&'a IncOrDecExpression),
    IncOrDecExpressionPrefix(&'a IncOrDecExpressionPrefix),
    IncOrDecExpressionSuffix(&'a IncOrDecExpressionSuffix),
    ConditionalExpression(&'a ConditionalExpression),
    ConstantExpression(&'a ConstantExpression),
    ConstantExpressionUnary(&'a ConstantExpressionUnary),
    ConstantExpressionBinary(&'a ConstantExpressionBinary),
    ConstantExpressionTernary(&'a ConstantExpressionTernary),
    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),
    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),
    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),
    StringLiteral(&'a StringLiteral),
    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),
    PreprocessorText(&'a PreprocessorText),
    CmosSwitchtype(&'a CmosSwitchtype),
    EnableGatetype(&'a EnableGatetype),
    MosSwitchtype(&'a MosSwitchtype),
    NInputGatetype(&'a NInputGatetype),
    NOutputGatetype(&'a NOutputGatetype),
    PassEnSwitchtype(&'a PassEnSwitchtype),
    PassSwitchtype(&'a PassSwitchtype),
    PulldownStrength(&'a PulldownStrength),
    PulldownStrength01(&'a PulldownStrength01),
    PulldownStrength10(&'a PulldownStrength10),
    PulldownStrength0(&'a PulldownStrength0),
    PullupStrength(&'a PullupStrength),
    PullupStrength01(&'a PullupStrength01),
    PullupStrength10(&'a PullupStrength10),
    PullupStrength1(&'a PullupStrength1),
    EnableTerminal(&'a EnableTerminal),
    InoutTerminal(&'a InoutTerminal),
    InputTerminal(&'a InputTerminal),
    NcontrolTerminal(&'a NcontrolTerminal),
    OutputTerminal(&'a OutputTerminal),
    PcontrolTerminal(&'a PcontrolTerminal),
    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),
    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),
    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),
    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),
    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),
    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),
    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),
    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),
    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),
    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),
    LocalParameterDeclaration(&'a LocalParameterDeclaration),
    LocalParameterDeclarationParam(&'a LocalParameterDeclarationParam),
    LocalParameterDeclarationType(&'a LocalParameterDeclarationType),
    ParameterDeclaration(&'a ParameterDeclaration),
    ParameterDeclarationParam(&'a ParameterDeclarationParam),
    ParameterDeclarationType(&'a ParameterDeclarationType),
    SpecparamDeclaration(&'a SpecparamDeclaration),
    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),
    BlockItemDeclaration(&'a BlockItemDeclaration),
    BlockItemDeclarationData(&'a BlockItemDeclarationData),
    BlockItemDeclarationLocalParameter(&'a BlockItemDeclarationLocalParameter),
    BlockItemDeclarationParameter(&'a BlockItemDeclarationParameter),
    BlockItemDeclarationLet(&'a BlockItemDeclarationLet),
    Delay3(&'a Delay3),
    Delay3Single(&'a Delay3Single),
    Delay3Mintypmax(&'a Delay3Mintypmax),
    Delay2(&'a Delay2),
    Delay2Single(&'a Delay2Single),
    Delay2Mintypmax(&'a Delay2Mintypmax),
    DelayValue(&'a DelayValue),
    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),
    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),
    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),
    Symbol(&'a Symbol),
    Keyword(&'a Keyword),
    WhiteSpace(&'a WhiteSpace),
    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),
    SpecifyBlock(&'a SpecifyBlock),
    SpecifyItem(&'a SpecifyItem),
    PulsestyleDeclaration(&'a PulsestyleDeclaration),
    ShowcancelledDeclaration(&'a ShowcancelledDeclaration),
    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),
    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),
    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),
    PathDeclaration(&'a PathDeclaration),
    SimplePathDeclaration(&'a SimplePathDeclaration),
    SimplePathDeclarationParallel(&'a SimplePathDeclarationParallel),
    SimplePathDeclarationFull(&'a SimplePathDeclarationFull),
    ParallelPathDescription(&'a ParallelPathDescription),
    FullPathDescription(&'a FullPathDescription),
    ListOfPathInputs(&'a ListOfPathInputs),
    ListOfPathOutputs(&'a ListOfPathOutputs),
    SpecifyInputTerminalDescriptor(&'a SpecifyInputTerminalDescriptor),
    SpecifyOutputTerminalDescriptor(&'a SpecifyOutputTerminalDescriptor),
    InputIdentifier(&'a InputIdentifier),
    InputIdentifierInterface(&'a InputIdentifierInterface),
    OutputIdentifier(&'a OutputIdentifier),
    OutputIdentifierInterface(&'a OutputIdentifierInterface),
    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),
    CaseStatement(&'a CaseStatement),
    CaseStatementNormal(&'a CaseStatementNormal),
    CaseStatementMatches(&'a CaseStatementMatches),
    CaseStatementInside(&'a CaseStatementInside),
    CaseKeyword(&'a CaseKeyword),
    CaseExpression(&'a CaseExpression),
    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),
    ContinuousAssign(&'a ContinuousAssign),
    ContinuousAssignNet(&'a ContinuousAssignNet),
    ContinuousAssignVariable(&'a ContinuousAssignVariable),
    ListOfNetAssignments(&'a ListOfNetAssignments),
    ListOfVariableAssignments(&'a ListOfVariableAssignments),
    NetAlias(&'a NetAlias),
    NetAssignment(&'a NetAssignment),
    ConditionalStatement(&'a ConditionalStatement),
    UniquePriority(&'a UniquePriority),
    CondPredicate(&'a CondPredicate),
    ExpressionOrCondPattern(&'a ExpressionOrCondPattern),
    CondPattern(&'a CondPattern),
    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),
    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),
    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),
    AssertionItem(&'a AssertionItem),
    DeferredImmediateAssetionItem(&'a DeferredImmediateAssetionItem),
    ProceduralAssertionStatement(&'a ProceduralAssertionStatement),
    ImmediateAssetionStatement(&'a ImmediateAssetionStatement),
    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),
    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),
    SubroutineCallStatement(&'a SubroutineCallStatement),
    SubroutineCallStatementFunction(&'a SubroutineCallStatementFunction),
    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),
    ActionBlock(&'a ActionBlock),
    ActionBlockElse(&'a ActionBlockElse),
    SeqBlock(&'a SeqBlock),
    ParBlock(&'a ParBlock),
    JoinKeyword(&'a JoinKeyword),
    StatementOrNull(&'a StatementOrNull),
    StatementOrNullAttribute(&'a StatementOrNullAttribute),
    Statement(&'a Statement),
    StatementItem(&'a StatementItem),
    FunctionStatement(&'a FunctionStatement),
    FunctionStatementOrNull(&'a FunctionStatementOrNull),
    FunctionStatementOrNullAttribute(&'a FunctionStatementOrNullAttribute),
    VariableIdentifierList(&'a VariableIdentifierList),
    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),
    UdpPortList(&'a UdpPortList),
    UdpDeclarationPortList(&'a UdpDeclarationPortList),
    UdpPortDeclaration(&'a UdpPortDeclaration),
    UdpOutputDeclaration(&'a UdpOutputDeclaration),
    UdpOutputDeclarationNonreg(&'a UdpOutputDeclarationNonreg),
    UdpOutputDeclarationReg(&'a UdpOutputDeclarationReg),
    UdpInputDeclaration(&'a UdpInputDeclaration),
    UdpRegDeclaration(&'a UdpRegDeclaration),
    InterfaceInstantiation(&'a InterfaceInstantiation),
    CheckerInstantiation(&'a CheckerInstantiation),
    ListOfCheckerPortConnections(&'a ListOfCheckerPortConnections),
    ListOfCheckerPortConnectionsOrdered(&'a ListOfCheckerPortConnectionsOrdered),
    ListOfCheckerPortConnectionsNamed(&'a ListOfCheckerPortConnectionsNamed),
    OrderedCheckerPortConnection(&'a OrderedCheckerPortConnection),
    NamedCheckerPortConnection(&'a NamedCheckerPortConnection),
    NamedCheckerPortConnectionIdentifier(&'a NamedCheckerPortConnectionIdentifier),
    NamedCheckerPortConnectionAsterisk(&'a NamedCheckerPortConnectionAsterisk),
    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),
    ProgramInstantiation(&'a ProgramInstantiation),
    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),
}

Variants

Locate(&'a Locate)

Tuple Fields of Locate

0: &'a Locate

ArrayIdentifier(&'a ArrayIdentifier)

Tuple Fields of ArrayIdentifier

0: &'a ArrayIdentifier

BlockIdentifier(&'a BlockIdentifier)

Tuple Fields of BlockIdentifier

0: &'a BlockIdentifier

BinIdentifier(&'a BinIdentifier)

Tuple Fields of BinIdentifier

0: &'a BinIdentifier

CIdentifier(&'a CIdentifier)

Tuple Fields of CIdentifier

0: &'a CIdentifier

CellIdentifier(&'a CellIdentifier)

Tuple Fields of CellIdentifier

0: &'a CellIdentifier

CheckerIdentifier(&'a CheckerIdentifier)

Tuple Fields of CheckerIdentifier

0: &'a CheckerIdentifier

ClassIdentifier(&'a ClassIdentifier)

Tuple Fields of ClassIdentifier

0: &'a ClassIdentifier

ClassVariableIdentifier(&'a ClassVariableIdentifier)

Tuple Fields of ClassVariableIdentifier

0: &'a ClassVariableIdentifier

ClockingIdentifier(&'a ClockingIdentifier)

Tuple Fields of ClockingIdentifier

0: &'a ClockingIdentifier

ConfigIdentifier(&'a ConfigIdentifier)

Tuple Fields of ConfigIdentifier

0: &'a ConfigIdentifier

ConstIdentifier(&'a ConstIdentifier)

Tuple Fields of ConstIdentifier

0: &'a ConstIdentifier

ConstraintIdentifier(&'a ConstraintIdentifier)

Tuple Fields of ConstraintIdentifier

0: &'a ConstraintIdentifier

CovergroupIdentifier(&'a CovergroupIdentifier)

Tuple Fields of CovergroupIdentifier

0: &'a CovergroupIdentifier

CovergroupVariableIdentifier(&'a CovergroupVariableIdentifier)

Tuple Fields of CovergroupVariableIdentifier

0: &'a CovergroupVariableIdentifier

CoverPointIdentifier(&'a CoverPointIdentifier)

Tuple Fields of CoverPointIdentifier

0: &'a CoverPointIdentifier

CrossIdentifier(&'a CrossIdentifier)

Tuple Fields of CrossIdentifier

0: &'a CrossIdentifier

DynamicArrayVariableIdentifier(&'a DynamicArrayVariableIdentifier)

Tuple Fields of DynamicArrayVariableIdentifier

0: &'a DynamicArrayVariableIdentifier

EnumIdentifier(&'a EnumIdentifier)

Tuple Fields of EnumIdentifier

0: &'a EnumIdentifier

EscapedIdentifier(&'a EscapedIdentifier)

Tuple Fields of EscapedIdentifier

0: &'a EscapedIdentifier

FormalIdentifier(&'a FormalIdentifier)

Tuple Fields of FormalIdentifier

0: &'a FormalIdentifier

FormalPortIdentifier(&'a FormalPortIdentifier)

Tuple Fields of FormalPortIdentifier

0: &'a FormalPortIdentifier

FunctionIdentifier(&'a FunctionIdentifier)

Tuple Fields of FunctionIdentifier

0: &'a FunctionIdentifier

GenerateBlockIdentifier(&'a GenerateBlockIdentifier)

Tuple Fields of GenerateBlockIdentifier

0: &'a GenerateBlockIdentifier

GenvarIdentifier(&'a GenvarIdentifier)

Tuple Fields of GenvarIdentifier

0: &'a GenvarIdentifier

HierarchicalArrayIdentifier(&'a HierarchicalArrayIdentifier)

Tuple Fields of HierarchicalArrayIdentifier

0: &'a HierarchicalArrayIdentifier

HierarchicalBlockIdentifier(&'a HierarchicalBlockIdentifier)

Tuple Fields of HierarchicalBlockIdentifier

0: &'a HierarchicalBlockIdentifier

HierarchicalEventIdentifier(&'a HierarchicalEventIdentifier)

Tuple Fields of HierarchicalEventIdentifier

0: &'a HierarchicalEventIdentifier

HierarchicalIdentifier(&'a HierarchicalIdentifier)

Tuple Fields of HierarchicalIdentifier

0: &'a HierarchicalIdentifier

Root(&'a Root)

Tuple Fields of Root

0: &'a Root

HierarchicalNetIdentifier(&'a HierarchicalNetIdentifier)

Tuple Fields of HierarchicalNetIdentifier

0: &'a HierarchicalNetIdentifier

HierarchicalParameterIdentifier(&'a HierarchicalParameterIdentifier)

Tuple Fields of HierarchicalParameterIdentifier

0: &'a HierarchicalParameterIdentifier

HierarchicalPropertyIdentifier(&'a HierarchicalPropertyIdentifier)

Tuple Fields of HierarchicalPropertyIdentifier

0: &'a HierarchicalPropertyIdentifier

HierarchicalSequenceIdentifier(&'a HierarchicalSequenceIdentifier)

Tuple Fields of HierarchicalSequenceIdentifier

0: &'a HierarchicalSequenceIdentifier

HierarchicalTaskIdentifier(&'a HierarchicalTaskIdentifier)

Tuple Fields of HierarchicalTaskIdentifier

0: &'a HierarchicalTaskIdentifier

HierarchicalTfIdentifier(&'a HierarchicalTfIdentifier)

Tuple Fields of HierarchicalTfIdentifier

0: &'a HierarchicalTfIdentifier

HierarchicalVariableIdentifier(&'a HierarchicalVariableIdentifier)

Tuple Fields of HierarchicalVariableIdentifier

0: &'a HierarchicalVariableIdentifier

Identifier(&'a Identifier)

Tuple Fields of Identifier

0: &'a Identifier

IndexVariableIdentifier(&'a IndexVariableIdentifier)

Tuple Fields of IndexVariableIdentifier

0: &'a IndexVariableIdentifier

InterfaceIdentifier(&'a InterfaceIdentifier)

Tuple Fields of InterfaceIdentifier

0: &'a InterfaceIdentifier

InterfaceInstanceIdentifier(&'a InterfaceInstanceIdentifier)

Tuple Fields of InterfaceInstanceIdentifier

0: &'a InterfaceInstanceIdentifier

InoutPortIdentifier(&'a InoutPortIdentifier)

Tuple Fields of InoutPortIdentifier

0: &'a InoutPortIdentifier

InputPortIdentifier(&'a InputPortIdentifier)

Tuple Fields of InputPortIdentifier

0: &'a InputPortIdentifier

InstanceIdentifier(&'a InstanceIdentifier)

Tuple Fields of InstanceIdentifier

0: &'a InstanceIdentifier

LibraryIdentifier(&'a LibraryIdentifier)

Tuple Fields of LibraryIdentifier

0: &'a LibraryIdentifier

MemberIdentifier(&'a MemberIdentifier)

Tuple Fields of MemberIdentifier

0: &'a MemberIdentifier

MethodIdentifier(&'a MethodIdentifier)

Tuple Fields of MethodIdentifier

0: &'a MethodIdentifier

ModportIdentifier(&'a ModportIdentifier)

Tuple Fields of ModportIdentifier

0: &'a ModportIdentifier

ModuleIdentifier(&'a ModuleIdentifier)

Tuple Fields of ModuleIdentifier

0: &'a ModuleIdentifier

NetIdentifier(&'a NetIdentifier)

Tuple Fields of NetIdentifier

0: &'a NetIdentifier

NetTypeIdentifier(&'a NetTypeIdentifier)

Tuple Fields of NetTypeIdentifier

0: &'a NetTypeIdentifier

OutputPortIdentifier(&'a OutputPortIdentifier)

Tuple Fields of OutputPortIdentifier

0: &'a OutputPortIdentifier

PackageIdentifier(&'a PackageIdentifier)

Tuple Fields of PackageIdentifier

0: &'a PackageIdentifier

PackageScope(&'a PackageScope)

Tuple Fields of PackageScope

0: &'a PackageScope

PackageScopePackage(&'a PackageScopePackage)

Tuple Fields of PackageScopePackage

0: &'a PackageScopePackage

Unit(&'a Unit)

Tuple Fields of Unit

0: &'a Unit

ParameterIdentifier(&'a ParameterIdentifier)

Tuple Fields of ParameterIdentifier

0: &'a ParameterIdentifier

PortIdentifier(&'a PortIdentifier)

Tuple Fields of PortIdentifier

0: &'a PortIdentifier

ProductionIdentifier(&'a ProductionIdentifier)

Tuple Fields of ProductionIdentifier

0: &'a ProductionIdentifier

ProgramIdentifier(&'a ProgramIdentifier)

Tuple Fields of ProgramIdentifier

0: &'a ProgramIdentifier

PropertyIdentifier(&'a PropertyIdentifier)

Tuple Fields of PropertyIdentifier

0: &'a PropertyIdentifier

PsClassIdentifier(&'a PsClassIdentifier)

Tuple Fields of PsClassIdentifier

0: &'a PsClassIdentifier

PsCovergroupIdentifier(&'a PsCovergroupIdentifier)

Tuple Fields of PsCovergroupIdentifier

0: &'a PsCovergroupIdentifier

PsCheckerIdentifier(&'a PsCheckerIdentifier)

Tuple Fields of PsCheckerIdentifier

0: &'a PsCheckerIdentifier

PsIdentifier(&'a PsIdentifier)

Tuple Fields of PsIdentifier

0: &'a PsIdentifier

PsOrHierarchicalArrayIdentifier(&'a PsOrHierarchicalArrayIdentifier)

Tuple Fields of PsOrHierarchicalArrayIdentifier

0: &'a PsOrHierarchicalArrayIdentifier

PsOrHierarchicalNetIdentifier(&'a PsOrHierarchicalNetIdentifier)

Tuple Fields of PsOrHierarchicalNetIdentifier

0: &'a PsOrHierarchicalNetIdentifier

PsOrHierarchicalNetIdentifierPackageScope(&'a PsOrHierarchicalNetIdentifierPackageScope)

Tuple Fields of PsOrHierarchicalNetIdentifierPackageScope

0: &'a PsOrHierarchicalNetIdentifierPackageScope

PsOrHierarchicalNetIdentifierHierarchical(&'a PsOrHierarchicalNetIdentifierHierarchical)

Tuple Fields of PsOrHierarchicalNetIdentifierHierarchical

0: &'a PsOrHierarchicalNetIdentifierHierarchical

PsOrHierarchicalPropertyIdentifier(&'a PsOrHierarchicalPropertyIdentifier)

Tuple Fields of PsOrHierarchicalPropertyIdentifier

0: &'a PsOrHierarchicalPropertyIdentifier

PsOrHierarchicalPropertyIdentifierPackageScope(&'a PsOrHierarchicalPropertyIdentifierPackageScope)

Tuple Fields of PsOrHierarchicalPropertyIdentifierPackageScope

0: &'a PsOrHierarchicalPropertyIdentifierPackageScope

PsOrHierarchicalPropertyIdentifierHierarchical(&'a PsOrHierarchicalPropertyIdentifierHierarchical)

Tuple Fields of PsOrHierarchicalPropertyIdentifierHierarchical

0: &'a PsOrHierarchicalPropertyIdentifierHierarchical

PsOrHierarchicalSequenceIdentifier(&'a PsOrHierarchicalSequenceIdentifier)

Tuple Fields of PsOrHierarchicalSequenceIdentifier

0: &'a PsOrHierarchicalSequenceIdentifier

PsOrHierarchicalSequenceIdentifierPackageScope(&'a PsOrHierarchicalSequenceIdentifierPackageScope)

Tuple Fields of PsOrHierarchicalSequenceIdentifierPackageScope

0: &'a PsOrHierarchicalSequenceIdentifierPackageScope

PsOrHierarchicalSequenceIdentifierHierarchical(&'a PsOrHierarchicalSequenceIdentifierHierarchical)

Tuple Fields of PsOrHierarchicalSequenceIdentifierHierarchical

0: &'a PsOrHierarchicalSequenceIdentifierHierarchical

PsOrHierarchicalTfIdentifier(&'a PsOrHierarchicalTfIdentifier)

Tuple Fields of PsOrHierarchicalTfIdentifier

0: &'a PsOrHierarchicalTfIdentifier

PsOrHierarchicalTfIdentifierPackageScope(&'a PsOrHierarchicalTfIdentifierPackageScope)

Tuple Fields of PsOrHierarchicalTfIdentifierPackageScope

0: &'a PsOrHierarchicalTfIdentifierPackageScope

PsOrHierarchicalTfIdentifierHierarchical(&'a PsOrHierarchicalTfIdentifierHierarchical)

Tuple Fields of PsOrHierarchicalTfIdentifierHierarchical

0: &'a PsOrHierarchicalTfIdentifierHierarchical

PsParameterIdentifier(&'a PsParameterIdentifier)

Tuple Fields of PsParameterIdentifier

0: &'a PsParameterIdentifier

PsParameterIdentifierScope(&'a PsParameterIdentifierScope)

Tuple Fields of PsParameterIdentifierScope

0: &'a PsParameterIdentifierScope

PsParameterIdentifierGenerate(&'a PsParameterIdentifierGenerate)

Tuple Fields of PsParameterIdentifierGenerate

0: &'a PsParameterIdentifierGenerate

PsTypeIdentifier(&'a PsTypeIdentifier)

Tuple Fields of PsTypeIdentifier

0: &'a PsTypeIdentifier

LocalOrPackageScopeOrClassScope(&'a LocalOrPackageScopeOrClassScope)

Tuple Fields of LocalOrPackageScopeOrClassScope

0: &'a LocalOrPackageScopeOrClassScope

Local(&'a Local)

Tuple Fields of Local

0: &'a Local

SequenceIdentifier(&'a SequenceIdentifier)

Tuple Fields of SequenceIdentifier

0: &'a SequenceIdentifier

SignalIdentifier(&'a SignalIdentifier)

Tuple Fields of SignalIdentifier

0: &'a SignalIdentifier

SimpleIdentifier(&'a SimpleIdentifier)

Tuple Fields of SimpleIdentifier

0: &'a SimpleIdentifier

SpecparamIdentifier(&'a SpecparamIdentifier)

Tuple Fields of SpecparamIdentifier

0: &'a SpecparamIdentifier

SystemTfIdentifier(&'a SystemTfIdentifier)

Tuple Fields of SystemTfIdentifier

0: &'a SystemTfIdentifier

TaskIdentifier(&'a TaskIdentifier)

Tuple Fields of TaskIdentifier

0: &'a TaskIdentifier

TfIdentifier(&'a TfIdentifier)

Tuple Fields of TfIdentifier

0: &'a TfIdentifier

TerminalIdentifier(&'a TerminalIdentifier)

Tuple Fields of TerminalIdentifier

0: &'a TerminalIdentifier

TopmoduleIdentifier(&'a TopmoduleIdentifier)

Tuple Fields of TopmoduleIdentifier

0: &'a TopmoduleIdentifier

TypeIdentifier(&'a TypeIdentifier)

Tuple Fields of TypeIdentifier

0: &'a TypeIdentifier

UdpIdentifier(&'a UdpIdentifier)

Tuple Fields of UdpIdentifier

0: &'a UdpIdentifier

VariableIdentifier(&'a VariableIdentifier)

Tuple Fields of VariableIdentifier

0: &'a VariableIdentifier

ImplicitClassHandleOrClassScopeOrPackageScope(&'a ImplicitClassHandleOrClassScopeOrPackageScope)

Tuple Fields of ImplicitClassHandleOrClassScopeOrPackageScope

0: &'a ImplicitClassHandleOrClassScopeOrPackageScope

ImplicitClassHandleOrPackageScope(&'a ImplicitClassHandleOrPackageScope)

Tuple Fields of ImplicitClassHandleOrPackageScope

0: &'a ImplicitClassHandleOrPackageScope

ImplicitClassHandleOrClassScope(&'a ImplicitClassHandleOrClassScope)

Tuple Fields of ImplicitClassHandleOrClassScope

0: &'a ImplicitClassHandleOrClassScope

PackageScopeOrClassScope(&'a PackageScopeOrClassScope)

Tuple Fields of PackageScopeOrClassScope

0: &'a PackageScopeOrClassScope

CompilerDirective(&'a CompilerDirective)

Tuple Fields of CompilerDirective

0: &'a CompilerDirective

ResetallCompilerDirective(&'a ResetallCompilerDirective)

Tuple Fields of ResetallCompilerDirective

0: &'a ResetallCompilerDirective

IncludeCompilerDirective(&'a IncludeCompilerDirective)

Tuple Fields of IncludeCompilerDirective

0: &'a IncludeCompilerDirective

IncludeCompilerDirectiveDoubleQuote(&'a IncludeCompilerDirectiveDoubleQuote)

Tuple Fields of IncludeCompilerDirectiveDoubleQuote

0: &'a IncludeCompilerDirectiveDoubleQuote

IncludeCompilerDirectiveAngleBracket(&'a IncludeCompilerDirectiveAngleBracket)

Tuple Fields of IncludeCompilerDirectiveAngleBracket

0: &'a IncludeCompilerDirectiveAngleBracket

IncludeCompilerDirectiveTextMacroUsage(&'a IncludeCompilerDirectiveTextMacroUsage)

Tuple Fields of IncludeCompilerDirectiveTextMacroUsage

0: &'a IncludeCompilerDirectiveTextMacroUsage

AngleBracketLiteral(&'a AngleBracketLiteral)

Tuple Fields of AngleBracketLiteral

0: &'a AngleBracketLiteral

TextMacroDefinition(&'a TextMacroDefinition)

Tuple Fields of TextMacroDefinition

0: &'a TextMacroDefinition

TextMacroName(&'a TextMacroName)

Tuple Fields of TextMacroName

0: &'a TextMacroName

ListOfFormalArguments(&'a ListOfFormalArguments)

Tuple Fields of ListOfFormalArguments

0: &'a ListOfFormalArguments

FormalArgument(&'a FormalArgument)

Tuple Fields of FormalArgument

0: &'a FormalArgument

TextMacroIdentifier(&'a TextMacroIdentifier)

Tuple Fields of TextMacroIdentifier

0: &'a TextMacroIdentifier

MacroText(&'a MacroText)

Tuple Fields of MacroText

0: &'a MacroText

DefaultText(&'a DefaultText)

Tuple Fields of DefaultText

0: &'a DefaultText

TextMacroUsage(&'a TextMacroUsage)

Tuple Fields of TextMacroUsage

0: &'a TextMacroUsage

ListOfActualArguments(&'a ListOfActualArguments)

Tuple Fields of ListOfActualArguments

0: &'a ListOfActualArguments

ActualArgument(&'a ActualArgument)

Tuple Fields of ActualArgument

0: &'a ActualArgument

UndefineCompilerDirective(&'a UndefineCompilerDirective)

Tuple Fields of UndefineCompilerDirective

0: &'a UndefineCompilerDirective

UndefineallCompilerDirective(&'a UndefineallCompilerDirective)

Tuple Fields of UndefineallCompilerDirective

0: &'a UndefineallCompilerDirective

ConditionalCompilerDirective(&'a ConditionalCompilerDirective)

Tuple Fields of ConditionalCompilerDirective

0: &'a ConditionalCompilerDirective

IfdefDirective(&'a IfdefDirective)

Tuple Fields of IfdefDirective

0: &'a IfdefDirective

IfndefDirective(&'a IfndefDirective)

Tuple Fields of IfndefDirective

0: &'a IfndefDirective

IfdefGroupOfLines(&'a IfdefGroupOfLines)

Tuple Fields of IfdefGroupOfLines

0: &'a IfdefGroupOfLines

IfndefGroupOfLines(&'a IfndefGroupOfLines)

Tuple Fields of IfndefGroupOfLines

0: &'a IfndefGroupOfLines

ElsifGroupOfLines(&'a ElsifGroupOfLines)

Tuple Fields of ElsifGroupOfLines

0: &'a ElsifGroupOfLines

ElseGroupOfLines(&'a ElseGroupOfLines)

Tuple Fields of ElseGroupOfLines

0: &'a ElseGroupOfLines

SourceDescription(&'a SourceDescription)

Tuple Fields of SourceDescription

0: &'a SourceDescription

SourceDescriptionNotDirective(&'a SourceDescriptionNotDirective)

Tuple Fields of SourceDescriptionNotDirective

0: &'a SourceDescriptionNotDirective

TimescaleCompilerDirective(&'a TimescaleCompilerDirective)

Tuple Fields of TimescaleCompilerDirective

0: &'a TimescaleCompilerDirective

DefaultNettypeCompilerDirective(&'a DefaultNettypeCompilerDirective)

Tuple Fields of DefaultNettypeCompilerDirective

0: &'a DefaultNettypeCompilerDirective

DefaultNettypeValue(&'a DefaultNettypeValue)

Tuple Fields of DefaultNettypeValue

0: &'a DefaultNettypeValue

UnconnectedDriveCompilerDirective(&'a UnconnectedDriveCompilerDirective)

Tuple Fields of UnconnectedDriveCompilerDirective

0: &'a UnconnectedDriveCompilerDirective

NounconnectedDriveCompilerDirective(&'a NounconnectedDriveCompilerDirective)

Tuple Fields of NounconnectedDriveCompilerDirective

0: &'a NounconnectedDriveCompilerDirective

CelldefineDriveCompilerDirective(&'a CelldefineDriveCompilerDirective)

Tuple Fields of CelldefineDriveCompilerDirective

0: &'a CelldefineDriveCompilerDirective

EndcelldefineDriveCompilerDirective(&'a EndcelldefineDriveCompilerDirective)

Tuple Fields of EndcelldefineDriveCompilerDirective

0: &'a EndcelldefineDriveCompilerDirective

Pragma(&'a Pragma)

Tuple Fields of Pragma

0: &'a Pragma

PragmaName(&'a PragmaName)

Tuple Fields of PragmaName

0: &'a PragmaName

PragmaExpression(&'a PragmaExpression)

Tuple Fields of PragmaExpression

0: &'a PragmaExpression

PragmaExpressionAssignment(&'a PragmaExpressionAssignment)

Tuple Fields of PragmaExpressionAssignment

0: &'a PragmaExpressionAssignment

PragmaValue(&'a PragmaValue)

Tuple Fields of PragmaValue

0: &'a PragmaValue

PragmaValueParen(&'a PragmaValueParen)

Tuple Fields of PragmaValueParen

0: &'a PragmaValueParen

PragmaKeyword(&'a PragmaKeyword)

Tuple Fields of PragmaKeyword

0: &'a PragmaKeyword

LineCompilerDirective(&'a LineCompilerDirective)

Tuple Fields of LineCompilerDirective

0: &'a LineCompilerDirective

PositionCompilerDirective(&'a PositionCompilerDirective)

Tuple Fields of PositionCompilerDirective

0: &'a PositionCompilerDirective

Level(&'a Level)

Tuple Fields of Level

0: &'a Level

KeywordsDirective(&'a KeywordsDirective)

Tuple Fields of KeywordsDirective

0: &'a KeywordsDirective

VersionSpecifier(&'a VersionSpecifier)

Tuple Fields of VersionSpecifier

0: &'a VersionSpecifier

EndkeywordsDirective(&'a EndkeywordsDirective)

Tuple Fields of EndkeywordsDirective

0: &'a EndkeywordsDirective

Comment(&'a Comment)

Tuple Fields of Comment

0: &'a Comment

AttributeInstance(&'a AttributeInstance)

Tuple Fields of AttributeInstance

0: &'a AttributeInstance

AttrSpec(&'a AttrSpec)

Tuple Fields of AttrSpec

0: &'a AttrSpec

SourceText(&'a SourceText)

Tuple Fields of SourceText

0: &'a SourceText

Description(&'a Description)

Tuple Fields of Description

0: &'a Description

DescriptionPackageItem(&'a DescriptionPackageItem)

Tuple Fields of DescriptionPackageItem

0: &'a DescriptionPackageItem

DescriptionBindDirective(&'a DescriptionBindDirective)

Tuple Fields of DescriptionBindDirective

0: &'a DescriptionBindDirective

ModuleNonansiHeader(&'a ModuleNonansiHeader)

Tuple Fields of ModuleNonansiHeader

0: &'a ModuleNonansiHeader

ModuleAnsiHeader(&'a ModuleAnsiHeader)

Tuple Fields of ModuleAnsiHeader

0: &'a ModuleAnsiHeader

ModuleDeclaration(&'a ModuleDeclaration)

Tuple Fields of ModuleDeclaration

0: &'a ModuleDeclaration

ModuleDeclarationNonansi(&'a ModuleDeclarationNonansi)

Tuple Fields of ModuleDeclarationNonansi

0: &'a ModuleDeclarationNonansi

ModuleDeclarationAnsi(&'a ModuleDeclarationAnsi)

Tuple Fields of ModuleDeclarationAnsi

0: &'a ModuleDeclarationAnsi

ModuleDeclarationWildcard(&'a ModuleDeclarationWildcard)

Tuple Fields of ModuleDeclarationWildcard

0: &'a ModuleDeclarationWildcard

ModuleDeclarationExternNonansi(&'a ModuleDeclarationExternNonansi)

Tuple Fields of ModuleDeclarationExternNonansi

0: &'a ModuleDeclarationExternNonansi

ModuleDeclarationExternAnsi(&'a ModuleDeclarationExternAnsi)

Tuple Fields of ModuleDeclarationExternAnsi

0: &'a ModuleDeclarationExternAnsi

ModuleKeyword(&'a ModuleKeyword)

Tuple Fields of ModuleKeyword

0: &'a ModuleKeyword

InterfaceDeclaration(&'a InterfaceDeclaration)

Tuple Fields of InterfaceDeclaration

0: &'a InterfaceDeclaration

InterfaceDeclarationNonansi(&'a InterfaceDeclarationNonansi)

Tuple Fields of InterfaceDeclarationNonansi

0: &'a InterfaceDeclarationNonansi

InterfaceDeclarationAnsi(&'a InterfaceDeclarationAnsi)

Tuple Fields of InterfaceDeclarationAnsi

0: &'a InterfaceDeclarationAnsi

InterfaceDeclarationWildcard(&'a InterfaceDeclarationWildcard)

Tuple Fields of InterfaceDeclarationWildcard

0: &'a InterfaceDeclarationWildcard

InterfaceDeclarationExternNonansi(&'a InterfaceDeclarationExternNonansi)

Tuple Fields of InterfaceDeclarationExternNonansi

0: &'a InterfaceDeclarationExternNonansi

InterfaceDeclarationExternAnsi(&'a InterfaceDeclarationExternAnsi)

Tuple Fields of InterfaceDeclarationExternAnsi

0: &'a InterfaceDeclarationExternAnsi

InterfaceNonansiHeader(&'a InterfaceNonansiHeader)

Tuple Fields of InterfaceNonansiHeader

0: &'a InterfaceNonansiHeader

InterfaceAnsiHeader(&'a InterfaceAnsiHeader)

Tuple Fields of InterfaceAnsiHeader

0: &'a InterfaceAnsiHeader

ProgramDeclaration(&'a ProgramDeclaration)

Tuple Fields of ProgramDeclaration

0: &'a ProgramDeclaration

ProgramDeclarationNonansi(&'a ProgramDeclarationNonansi)

Tuple Fields of ProgramDeclarationNonansi

0: &'a ProgramDeclarationNonansi

ProgramDeclarationAnsi(&'a ProgramDeclarationAnsi)

Tuple Fields of ProgramDeclarationAnsi

0: &'a ProgramDeclarationAnsi

ProgramDeclarationWildcard(&'a ProgramDeclarationWildcard)

Tuple Fields of ProgramDeclarationWildcard

0: &'a ProgramDeclarationWildcard

ProgramDeclarationExternNonansi(&'a ProgramDeclarationExternNonansi)

Tuple Fields of ProgramDeclarationExternNonansi

0: &'a ProgramDeclarationExternNonansi

ProgramDeclarationExternAnsi(&'a ProgramDeclarationExternAnsi)

Tuple Fields of ProgramDeclarationExternAnsi

0: &'a ProgramDeclarationExternAnsi

ProgramNonansiHeader(&'a ProgramNonansiHeader)

Tuple Fields of ProgramNonansiHeader

0: &'a ProgramNonansiHeader

ProgramAnsiHeader(&'a ProgramAnsiHeader)

Tuple Fields of ProgramAnsiHeader

0: &'a ProgramAnsiHeader

CheckerDeclaration(&'a CheckerDeclaration)

Tuple Fields of CheckerDeclaration

0: &'a CheckerDeclaration

ClassDeclaration(&'a ClassDeclaration)

Tuple Fields of ClassDeclaration

0: &'a ClassDeclaration

Virtual(&'a Virtual)

Tuple Fields of Virtual

0: &'a Virtual

InterfaceClassType(&'a InterfaceClassType)

Tuple Fields of InterfaceClassType

0: &'a InterfaceClassType

InterfaceClassDeclaration(&'a InterfaceClassDeclaration)

Tuple Fields of InterfaceClassDeclaration

0: &'a InterfaceClassDeclaration

InterfaceClassItem(&'a InterfaceClassItem)

Tuple Fields of InterfaceClassItem

0: &'a InterfaceClassItem

InterfaceClassItemMethod(&'a InterfaceClassItemMethod)

Tuple Fields of InterfaceClassItemMethod

0: &'a InterfaceClassItemMethod

InterfaceClassMethod(&'a InterfaceClassMethod)

Tuple Fields of InterfaceClassMethod

0: &'a InterfaceClassMethod

PackageDeclaration(&'a PackageDeclaration)

Tuple Fields of PackageDeclaration

0: &'a PackageDeclaration

TimeunitsDeclaration(&'a TimeunitsDeclaration)

Tuple Fields of TimeunitsDeclaration

0: &'a TimeunitsDeclaration

TimeunitsDeclarationTimeunit(&'a TimeunitsDeclarationTimeunit)

Tuple Fields of TimeunitsDeclarationTimeunit

0: &'a TimeunitsDeclarationTimeunit

TimeunitsDeclarationTimeprecision(&'a TimeunitsDeclarationTimeprecision)

Tuple Fields of TimeunitsDeclarationTimeprecision

0: &'a TimeunitsDeclarationTimeprecision

TimeunitsDeclarationTimeunitTimeprecision(&'a TimeunitsDeclarationTimeunitTimeprecision)

Tuple Fields of TimeunitsDeclarationTimeunitTimeprecision

0: &'a TimeunitsDeclarationTimeunitTimeprecision

TimeunitsDeclarationTimeprecisionTimeunit(&'a TimeunitsDeclarationTimeprecisionTimeunit)

Tuple Fields of TimeunitsDeclarationTimeprecisionTimeunit

0: &'a TimeunitsDeclarationTimeprecisionTimeunit

PackageItem(&'a PackageItem)

Tuple Fields of PackageItem

0: &'a PackageItem

PackageOrGenerateItemDeclaration(&'a PackageOrGenerateItemDeclaration)

Tuple Fields of PackageOrGenerateItemDeclaration

0: &'a PackageOrGenerateItemDeclaration

AnonymousProgram(&'a AnonymousProgram)

Tuple Fields of AnonymousProgram

0: &'a AnonymousProgram

AnonymousProgramItem(&'a AnonymousProgramItem)

Tuple Fields of AnonymousProgramItem

0: &'a AnonymousProgramItem

ElaborationSystemTask(&'a ElaborationSystemTask)

Tuple Fields of ElaborationSystemTask

0: &'a ElaborationSystemTask

ElaborationSystemTaskFatal(&'a ElaborationSystemTaskFatal)

Tuple Fields of ElaborationSystemTaskFatal

0: &'a ElaborationSystemTaskFatal

ElaborationSystemTaskError(&'a ElaborationSystemTaskError)

Tuple Fields of ElaborationSystemTaskError

0: &'a ElaborationSystemTaskError

ElaborationSystemTaskWarning(&'a ElaborationSystemTaskWarning)

Tuple Fields of ElaborationSystemTaskWarning

0: &'a ElaborationSystemTaskWarning

ElaborationSystemTaskInfo(&'a ElaborationSystemTaskInfo)

Tuple Fields of ElaborationSystemTaskInfo

0: &'a ElaborationSystemTaskInfo

FinishNumber(&'a FinishNumber)

Tuple Fields of FinishNumber

0: &'a FinishNumber

ModuleCommonItem(&'a ModuleCommonItem)

Tuple Fields of ModuleCommonItem

0: &'a ModuleCommonItem

ModuleItem(&'a ModuleItem)

Tuple Fields of ModuleItem

0: &'a ModuleItem

ModuleOrGenerateItem(&'a ModuleOrGenerateItem)

Tuple Fields of ModuleOrGenerateItem

0: &'a ModuleOrGenerateItem

ModuleOrGenerateItemParameter(&'a ModuleOrGenerateItemParameter)

Tuple Fields of ModuleOrGenerateItemParameter

0: &'a ModuleOrGenerateItemParameter

ModuleOrGenerateItemGate(&'a ModuleOrGenerateItemGate)

Tuple Fields of ModuleOrGenerateItemGate

0: &'a ModuleOrGenerateItemGate

ModuleOrGenerateItemUdp(&'a ModuleOrGenerateItemUdp)

Tuple Fields of ModuleOrGenerateItemUdp

0: &'a ModuleOrGenerateItemUdp

ModuleOrGenerateItemModule(&'a ModuleOrGenerateItemModule)

Tuple Fields of ModuleOrGenerateItemModule

0: &'a ModuleOrGenerateItemModule

ModuleOrGenerateItemModuleItem(&'a ModuleOrGenerateItemModuleItem)

Tuple Fields of ModuleOrGenerateItemModuleItem

0: &'a ModuleOrGenerateItemModuleItem

ModuleOrGenerateItemDeclaration(&'a ModuleOrGenerateItemDeclaration)

Tuple Fields of ModuleOrGenerateItemDeclaration

0: &'a ModuleOrGenerateItemDeclaration

ModuleOrGenerateItemDeclarationClocking(&'a ModuleOrGenerateItemDeclarationClocking)

Tuple Fields of ModuleOrGenerateItemDeclarationClocking

0: &'a ModuleOrGenerateItemDeclarationClocking

ModuleOrGenerateItemDeclarationDisable(&'a ModuleOrGenerateItemDeclarationDisable)

Tuple Fields of ModuleOrGenerateItemDeclarationDisable

0: &'a ModuleOrGenerateItemDeclarationDisable

NonPortModuleItem(&'a NonPortModuleItem)

Tuple Fields of NonPortModuleItem

0: &'a NonPortModuleItem

NonPortModuleItemSpecparam(&'a NonPortModuleItemSpecparam)

Tuple Fields of NonPortModuleItemSpecparam

0: &'a NonPortModuleItemSpecparam

ParameterOverride(&'a ParameterOverride)

Tuple Fields of ParameterOverride

0: &'a ParameterOverride

BindDirective(&'a BindDirective)

Tuple Fields of BindDirective

0: &'a BindDirective

BindDirectiveScope(&'a BindDirectiveScope)

Tuple Fields of BindDirectiveScope

0: &'a BindDirectiveScope

BindDirectiveInstance(&'a BindDirectiveInstance)

Tuple Fields of BindDirectiveInstance

0: &'a BindDirectiveInstance

BindTargetScope(&'a BindTargetScope)

Tuple Fields of BindTargetScope

0: &'a BindTargetScope

BindTargetInstance(&'a BindTargetInstance)

Tuple Fields of BindTargetInstance

0: &'a BindTargetInstance

BindTargetInstanceList(&'a BindTargetInstanceList)

Tuple Fields of BindTargetInstanceList

0: &'a BindTargetInstanceList

BindInstantiation(&'a BindInstantiation)

Tuple Fields of BindInstantiation

0: &'a BindInstantiation

ParameterPortList(&'a ParameterPortList)

Tuple Fields of ParameterPortList

0: &'a ParameterPortList

ParameterPortListAssignment(&'a ParameterPortListAssignment)

Tuple Fields of ParameterPortListAssignment

0: &'a ParameterPortListAssignment

ParameterPortListDeclaration(&'a ParameterPortListDeclaration)

Tuple Fields of ParameterPortListDeclaration

0: &'a ParameterPortListDeclaration

ParameterPortDeclaration(&'a ParameterPortDeclaration)

Tuple Fields of ParameterPortDeclaration

0: &'a ParameterPortDeclaration

ParameterPortDeclarationParamList(&'a ParameterPortDeclarationParamList)

Tuple Fields of ParameterPortDeclarationParamList

0: &'a ParameterPortDeclarationParamList

ParameterPortDeclarationTypeList(&'a ParameterPortDeclarationTypeList)

Tuple Fields of ParameterPortDeclarationTypeList

0: &'a ParameterPortDeclarationTypeList

ListOfPorts(&'a ListOfPorts)

Tuple Fields of ListOfPorts

0: &'a ListOfPorts

ListOfPortDeclarations(&'a ListOfPortDeclarations)

Tuple Fields of ListOfPortDeclarations

0: &'a ListOfPortDeclarations

PortDeclaration(&'a PortDeclaration)

Tuple Fields of PortDeclaration

0: &'a PortDeclaration

PortDeclarationInout(&'a PortDeclarationInout)

Tuple Fields of PortDeclarationInout

0: &'a PortDeclarationInout

PortDeclarationInput(&'a PortDeclarationInput)

Tuple Fields of PortDeclarationInput

0: &'a PortDeclarationInput

PortDeclarationOutput(&'a PortDeclarationOutput)

Tuple Fields of PortDeclarationOutput

0: &'a PortDeclarationOutput

PortDeclarationRef(&'a PortDeclarationRef)

Tuple Fields of PortDeclarationRef

0: &'a PortDeclarationRef

PortDeclarationInterface(&'a PortDeclarationInterface)

Tuple Fields of PortDeclarationInterface

0: &'a PortDeclarationInterface

Port(&'a Port)

Tuple Fields of Port

0: &'a Port

PortNonNamed(&'a PortNonNamed)

Tuple Fields of PortNonNamed

0: &'a PortNonNamed

PortNamed(&'a PortNamed)

Tuple Fields of PortNamed

0: &'a PortNamed

PortExpression(&'a PortExpression)

Tuple Fields of PortExpression

0: &'a PortExpression

PortExpressionBrace(&'a PortExpressionBrace)

Tuple Fields of PortExpressionBrace

0: &'a PortExpressionBrace

PortReference(&'a PortReference)

Tuple Fields of PortReference

0: &'a PortReference

PortDirection(&'a PortDirection)

Tuple Fields of PortDirection

0: &'a PortDirection

NetPortHeader(&'a NetPortHeader)

Tuple Fields of NetPortHeader

0: &'a NetPortHeader

VariablePortHeader(&'a VariablePortHeader)

Tuple Fields of VariablePortHeader

0: &'a VariablePortHeader

InterfacePortHeader(&'a InterfacePortHeader)

Tuple Fields of InterfacePortHeader

0: &'a InterfacePortHeader

InterfacePortHeaderIdentifier(&'a InterfacePortHeaderIdentifier)

Tuple Fields of InterfacePortHeaderIdentifier

0: &'a InterfacePortHeaderIdentifier

InterfacePortHeaderInterface(&'a InterfacePortHeaderInterface)

Tuple Fields of InterfacePortHeaderInterface

0: &'a InterfacePortHeaderInterface

NetPortHeaderOrInterfacePortHeader(&'a NetPortHeaderOrInterfacePortHeader)

Tuple Fields of NetPortHeaderOrInterfacePortHeader

0: &'a NetPortHeaderOrInterfacePortHeader

AnsiPortDeclaration(&'a AnsiPortDeclaration)

Tuple Fields of AnsiPortDeclaration

0: &'a AnsiPortDeclaration

AnsiPortDeclarationNet(&'a AnsiPortDeclarationNet)

Tuple Fields of AnsiPortDeclarationNet

0: &'a AnsiPortDeclarationNet

AnsiPortDeclarationVariable(&'a AnsiPortDeclarationVariable)

Tuple Fields of AnsiPortDeclarationVariable

0: &'a AnsiPortDeclarationVariable

AnsiPortDeclarationParen(&'a AnsiPortDeclarationParen)

Tuple Fields of AnsiPortDeclarationParen

0: &'a AnsiPortDeclarationParen

CheckerPortList(&'a CheckerPortList)

Tuple Fields of CheckerPortList

0: &'a CheckerPortList

CheckerPortItem(&'a CheckerPortItem)

Tuple Fields of CheckerPortItem

0: &'a CheckerPortItem

CheckerPortDirection(&'a CheckerPortDirection)

Tuple Fields of CheckerPortDirection

0: &'a CheckerPortDirection

CheckerOrGenerateItem(&'a CheckerOrGenerateItem)

Tuple Fields of CheckerOrGenerateItem

0: &'a CheckerOrGenerateItem

CheckerOrGenerateItemDeclaration(&'a CheckerOrGenerateItemDeclaration)

Tuple Fields of CheckerOrGenerateItemDeclaration

0: &'a CheckerOrGenerateItemDeclaration

CheckerOrGenerateItemDeclarationData(&'a CheckerOrGenerateItemDeclarationData)

Tuple Fields of CheckerOrGenerateItemDeclarationData

0: &'a CheckerOrGenerateItemDeclarationData

Rand(&'a Rand)

Tuple Fields of Rand

0: &'a Rand

CheckerOrGenerateItemDeclarationClocking(&'a CheckerOrGenerateItemDeclarationClocking)

Tuple Fields of CheckerOrGenerateItemDeclarationClocking

0: &'a CheckerOrGenerateItemDeclarationClocking

CheckerOrGenerateItemDeclarationDisable(&'a CheckerOrGenerateItemDeclarationDisable)

Tuple Fields of CheckerOrGenerateItemDeclarationDisable

0: &'a CheckerOrGenerateItemDeclarationDisable

CheckerGenerateItem(&'a CheckerGenerateItem)

Tuple Fields of CheckerGenerateItem

0: &'a CheckerGenerateItem

ConstraintDeclaration(&'a ConstraintDeclaration)

Tuple Fields of ConstraintDeclaration

0: &'a ConstraintDeclaration

Static(&'a Static)

Tuple Fields of Static

0: &'a Static

ConstraintBlock(&'a ConstraintBlock)

Tuple Fields of ConstraintBlock

0: &'a ConstraintBlock

ConstraintBlockItem(&'a ConstraintBlockItem)

Tuple Fields of ConstraintBlockItem

0: &'a ConstraintBlockItem

ConstraintBlockItemSolve(&'a ConstraintBlockItemSolve)

Tuple Fields of ConstraintBlockItemSolve

0: &'a ConstraintBlockItemSolve

SolveBeforeList(&'a SolveBeforeList)

Tuple Fields of SolveBeforeList

0: &'a SolveBeforeList

ConstraintPrimary(&'a ConstraintPrimary)

Tuple Fields of ConstraintPrimary

0: &'a ConstraintPrimary

ConstraintExpression(&'a ConstraintExpression)

Tuple Fields of ConstraintExpression

0: &'a ConstraintExpression

ConstraintExpressionExpression(&'a ConstraintExpressionExpression)

Tuple Fields of ConstraintExpressionExpression

0: &'a ConstraintExpressionExpression

Soft(&'a Soft)

Tuple Fields of Soft

0: &'a Soft

ConstraintExpressionArrow(&'a ConstraintExpressionArrow)

Tuple Fields of ConstraintExpressionArrow

0: &'a ConstraintExpressionArrow

ConstraintExpressionIf(&'a ConstraintExpressionIf)

Tuple Fields of ConstraintExpressionIf

0: &'a ConstraintExpressionIf

ConstraintExpressionForeach(&'a ConstraintExpressionForeach)

Tuple Fields of ConstraintExpressionForeach

0: &'a ConstraintExpressionForeach

ConstraintExpressionDisable(&'a ConstraintExpressionDisable)

Tuple Fields of ConstraintExpressionDisable

0: &'a ConstraintExpressionDisable

UniquenessConstraint(&'a UniquenessConstraint)

Tuple Fields of UniquenessConstraint

0: &'a UniquenessConstraint

ConstraintSet(&'a ConstraintSet)

Tuple Fields of ConstraintSet

0: &'a ConstraintSet

ConstraintSetBrace(&'a ConstraintSetBrace)

Tuple Fields of ConstraintSetBrace

0: &'a ConstraintSetBrace

DistList(&'a DistList)

Tuple Fields of DistList

0: &'a DistList

DistItem(&'a DistItem)

Tuple Fields of DistItem

0: &'a DistItem

DistWeight(&'a DistWeight)

Tuple Fields of DistWeight

0: &'a DistWeight

DistWeightEqual(&'a DistWeightEqual)

Tuple Fields of DistWeightEqual

0: &'a DistWeightEqual

DistWeightDivide(&'a DistWeightDivide)

Tuple Fields of DistWeightDivide

0: &'a DistWeightDivide

ConstraintPrototype(&'a ConstraintPrototype)

Tuple Fields of ConstraintPrototype

0: &'a ConstraintPrototype

ConstraintPrototypeQualifier(&'a ConstraintPrototypeQualifier)

Tuple Fields of ConstraintPrototypeQualifier

0: &'a ConstraintPrototypeQualifier

ExternConstraintDeclaration(&'a ExternConstraintDeclaration)

Tuple Fields of ExternConstraintDeclaration

0: &'a ExternConstraintDeclaration

IdentifierList(&'a IdentifierList)

Tuple Fields of IdentifierList

0: &'a IdentifierList

InterfaceOrGenerateItem(&'a InterfaceOrGenerateItem)

Tuple Fields of InterfaceOrGenerateItem

0: &'a InterfaceOrGenerateItem

InterfaceOrGenerateItemModule(&'a InterfaceOrGenerateItemModule)

Tuple Fields of InterfaceOrGenerateItemModule

0: &'a InterfaceOrGenerateItemModule

InterfaceOrGenerateItemExtern(&'a InterfaceOrGenerateItemExtern)

Tuple Fields of InterfaceOrGenerateItemExtern

0: &'a InterfaceOrGenerateItemExtern

ExternTfDeclaration(&'a ExternTfDeclaration)

Tuple Fields of ExternTfDeclaration

0: &'a ExternTfDeclaration

ExternTfDeclarationMethod(&'a ExternTfDeclarationMethod)

Tuple Fields of ExternTfDeclarationMethod

0: &'a ExternTfDeclarationMethod

ExternTfDeclarationTask(&'a ExternTfDeclarationTask)

Tuple Fields of ExternTfDeclarationTask

0: &'a ExternTfDeclarationTask

InterfaceItem(&'a InterfaceItem)

Tuple Fields of InterfaceItem

0: &'a InterfaceItem

NonPortInterfaceItem(&'a NonPortInterfaceItem)

Tuple Fields of NonPortInterfaceItem

0: &'a NonPortInterfaceItem

ProgramItem(&'a ProgramItem)

Tuple Fields of ProgramItem

0: &'a ProgramItem

NonPortProgramItem(&'a NonPortProgramItem)

Tuple Fields of NonPortProgramItem

0: &'a NonPortProgramItem

NonPortProgramItemAssign(&'a NonPortProgramItemAssign)

Tuple Fields of NonPortProgramItemAssign

0: &'a NonPortProgramItemAssign

NonPortProgramItemModule(&'a NonPortProgramItemModule)

Tuple Fields of NonPortProgramItemModule

0: &'a NonPortProgramItemModule

NonPortProgramItemInitial(&'a NonPortProgramItemInitial)

Tuple Fields of NonPortProgramItemInitial

0: &'a NonPortProgramItemInitial

NonPortProgramItemFinal(&'a NonPortProgramItemFinal)

Tuple Fields of NonPortProgramItemFinal

0: &'a NonPortProgramItemFinal

NonPortProgramItemAssertion(&'a NonPortProgramItemAssertion)

Tuple Fields of NonPortProgramItemAssertion

0: &'a NonPortProgramItemAssertion

ProgramGenerateItem(&'a ProgramGenerateItem)

Tuple Fields of ProgramGenerateItem

0: &'a ProgramGenerateItem

LibraryText(&'a LibraryText)

Tuple Fields of LibraryText

0: &'a LibraryText

LibraryDescription(&'a LibraryDescription)

Tuple Fields of LibraryDescription

0: &'a LibraryDescription

LibraryDeclaration(&'a LibraryDeclaration)

Tuple Fields of LibraryDeclaration

0: &'a LibraryDeclaration

IncludeStatement(&'a IncludeStatement)

Tuple Fields of IncludeStatement

0: &'a IncludeStatement

FilePathSpec(&'a FilePathSpec)

Tuple Fields of FilePathSpec

0: &'a FilePathSpec

FilePathSpecNonLiteral(&'a FilePathSpecNonLiteral)

Tuple Fields of FilePathSpecNonLiteral

0: &'a FilePathSpecNonLiteral

ConfigDeclaration(&'a ConfigDeclaration)

Tuple Fields of ConfigDeclaration

0: &'a ConfigDeclaration

DesignStatement(&'a DesignStatement)

Tuple Fields of DesignStatement

0: &'a DesignStatement

ConfigRuleStatement(&'a ConfigRuleStatement)

Tuple Fields of ConfigRuleStatement

0: &'a ConfigRuleStatement

ConfigRuleStatementDefault(&'a ConfigRuleStatementDefault)

Tuple Fields of ConfigRuleStatementDefault

0: &'a ConfigRuleStatementDefault

ConfigRuleStatementInstLib(&'a ConfigRuleStatementInstLib)

Tuple Fields of ConfigRuleStatementInstLib

0: &'a ConfigRuleStatementInstLib

ConfigRuleStatementInstUse(&'a ConfigRuleStatementInstUse)

Tuple Fields of ConfigRuleStatementInstUse

0: &'a ConfigRuleStatementInstUse

ConfigRuleStatementCellLib(&'a ConfigRuleStatementCellLib)

Tuple Fields of ConfigRuleStatementCellLib

0: &'a ConfigRuleStatementCellLib

ConfigRuleStatementCellUse(&'a ConfigRuleStatementCellUse)

Tuple Fields of ConfigRuleStatementCellUse

0: &'a ConfigRuleStatementCellUse

DefaultClause(&'a DefaultClause)

Tuple Fields of DefaultClause

0: &'a DefaultClause

InstClause(&'a InstClause)

Tuple Fields of InstClause

0: &'a InstClause

InstName(&'a InstName)

Tuple Fields of InstName

0: &'a InstName

CellClause(&'a CellClause)

Tuple Fields of CellClause

0: &'a CellClause

LiblistClause(&'a LiblistClause)

Tuple Fields of LiblistClause

0: &'a LiblistClause

UseClause(&'a UseClause)

Tuple Fields of UseClause

0: &'a UseClause

UseClauseCell(&'a UseClauseCell)

Tuple Fields of UseClauseCell

0: &'a UseClauseCell

UseClauseNamed(&'a UseClauseNamed)

Tuple Fields of UseClauseNamed

0: &'a UseClauseNamed

UseClauseCellNamed(&'a UseClauseCellNamed)

Tuple Fields of UseClauseCellNamed

0: &'a UseClauseCellNamed

Config(&'a Config)

Tuple Fields of Config

0: &'a Config

ClassItem(&'a ClassItem)

Tuple Fields of ClassItem

0: &'a ClassItem

ClassItemProperty(&'a ClassItemProperty)

Tuple Fields of ClassItemProperty

0: &'a ClassItemProperty

ClassItemMethod(&'a ClassItemMethod)

Tuple Fields of ClassItemMethod

0: &'a ClassItemMethod

ClassItemConstraint(&'a ClassItemConstraint)

Tuple Fields of ClassItemConstraint

0: &'a ClassItemConstraint

ClassItemDeclaration(&'a ClassItemDeclaration)

Tuple Fields of ClassItemDeclaration

0: &'a ClassItemDeclaration

ClassItemCovergroup(&'a ClassItemCovergroup)

Tuple Fields of ClassItemCovergroup

0: &'a ClassItemCovergroup

ClassProperty(&'a ClassProperty)

Tuple Fields of ClassProperty

0: &'a ClassProperty

ClassPropertyNonConst(&'a ClassPropertyNonConst)

Tuple Fields of ClassPropertyNonConst

0: &'a ClassPropertyNonConst

ClassPropertyConst(&'a ClassPropertyConst)

Tuple Fields of ClassPropertyConst

0: &'a ClassPropertyConst

ClassPropertyConstExpression(&'a ClassPropertyConstExpression)

Tuple Fields of ClassPropertyConstExpression

0: &'a ClassPropertyConstExpression

ClassMethod(&'a ClassMethod)

Tuple Fields of ClassMethod

0: &'a ClassMethod

ClassMethodTask(&'a ClassMethodTask)

Tuple Fields of ClassMethodTask

0: &'a ClassMethodTask

ClassMethodFunction(&'a ClassMethodFunction)

Tuple Fields of ClassMethodFunction

0: &'a ClassMethodFunction

ClassMethodPureVirtual(&'a ClassMethodPureVirtual)

Tuple Fields of ClassMethodPureVirtual

0: &'a ClassMethodPureVirtual

ClassMethodExternMethod(&'a ClassMethodExternMethod)

Tuple Fields of ClassMethodExternMethod

0: &'a ClassMethodExternMethod

ClassMethodConstructor(&'a ClassMethodConstructor)

Tuple Fields of ClassMethodConstructor

0: &'a ClassMethodConstructor

ClassMethodExternConstructor(&'a ClassMethodExternConstructor)

Tuple Fields of ClassMethodExternConstructor

0: &'a ClassMethodExternConstructor

ClassConstructorPrototype(&'a ClassConstructorPrototype)

Tuple Fields of ClassConstructorPrototype

0: &'a ClassConstructorPrototype

ClassConstraint(&'a ClassConstraint)

Tuple Fields of ClassConstraint

0: &'a ClassConstraint

ClassItemQualifier(&'a ClassItemQualifier)

Tuple Fields of ClassItemQualifier

0: &'a ClassItemQualifier

PropertyQualifier(&'a PropertyQualifier)

Tuple Fields of PropertyQualifier

0: &'a PropertyQualifier

RandomQualifier(&'a RandomQualifier)

Tuple Fields of RandomQualifier

0: &'a RandomQualifier

MethodQualifier(&'a MethodQualifier)

Tuple Fields of MethodQualifier

0: &'a MethodQualifier

MethodPrototype(&'a MethodPrototype)

Tuple Fields of MethodPrototype

0: &'a MethodPrototype

ClassConstructorDeclaration(&'a ClassConstructorDeclaration)

Tuple Fields of ClassConstructorDeclaration

0: &'a ClassConstructorDeclaration

New(&'a New)

Tuple Fields of New

0: &'a New

Number(&'a Number)

Tuple Fields of Number

0: &'a Number

IntegralNumber(&'a IntegralNumber)

Tuple Fields of IntegralNumber

0: &'a IntegralNumber

DecimalNumber(&'a DecimalNumber)

Tuple Fields of DecimalNumber

0: &'a DecimalNumber

DecimalNumberBaseUnsigned(&'a DecimalNumberBaseUnsigned)

Tuple Fields of DecimalNumberBaseUnsigned

0: &'a DecimalNumberBaseUnsigned

DecimalNumberBaseXNumber(&'a DecimalNumberBaseXNumber)

Tuple Fields of DecimalNumberBaseXNumber

0: &'a DecimalNumberBaseXNumber

DecimalNumberBaseZNumber(&'a DecimalNumberBaseZNumber)

Tuple Fields of DecimalNumberBaseZNumber

0: &'a DecimalNumberBaseZNumber

BinaryNumber(&'a BinaryNumber)

Tuple Fields of BinaryNumber

0: &'a BinaryNumber

OctalNumber(&'a OctalNumber)

Tuple Fields of OctalNumber

0: &'a OctalNumber

HexNumber(&'a HexNumber)

Tuple Fields of HexNumber

0: &'a HexNumber

Sign(&'a Sign)

Tuple Fields of Sign

0: &'a Sign

Size(&'a Size)

Tuple Fields of Size

0: &'a Size

NonZeroUnsignedNumber(&'a NonZeroUnsignedNumber)

Tuple Fields of NonZeroUnsignedNumber

0: &'a NonZeroUnsignedNumber

RealNumber(&'a RealNumber)

Tuple Fields of RealNumber

0: &'a RealNumber

RealNumberFloating(&'a RealNumberFloating)

Tuple Fields of RealNumberFloating

0: &'a RealNumberFloating

FixedPointNumber(&'a FixedPointNumber)

Tuple Fields of FixedPointNumber

0: &'a FixedPointNumber

Exp(&'a Exp)

Tuple Fields of Exp

0: &'a Exp

UnsignedNumber(&'a UnsignedNumber)

Tuple Fields of UnsignedNumber

0: &'a UnsignedNumber

BinaryValue(&'a BinaryValue)

Tuple Fields of BinaryValue

0: &'a BinaryValue

OctalValue(&'a OctalValue)

Tuple Fields of OctalValue

0: &'a OctalValue

HexValue(&'a HexValue)

Tuple Fields of HexValue

0: &'a HexValue

DecimalBase(&'a DecimalBase)

Tuple Fields of DecimalBase

0: &'a DecimalBase

BinaryBase(&'a BinaryBase)

Tuple Fields of BinaryBase

0: &'a BinaryBase

OctalBase(&'a OctalBase)

Tuple Fields of OctalBase

0: &'a OctalBase

HexBase(&'a HexBase)

Tuple Fields of HexBase

0: &'a HexBase

XNumber(&'a XNumber)

Tuple Fields of XNumber

0: &'a XNumber

ZNumber(&'a ZNumber)

Tuple Fields of ZNumber

0: &'a ZNumber

UnbasedUnsizedLiteral(&'a UnbasedUnsizedLiteral)

Tuple Fields of UnbasedUnsizedLiteral

0: &'a UnbasedUnsizedLiteral

UnaryOperator(&'a UnaryOperator)

Tuple Fields of UnaryOperator

0: &'a UnaryOperator

BinaryOperator(&'a BinaryOperator)

Tuple Fields of BinaryOperator

0: &'a BinaryOperator

IncOrDecOperator(&'a IncOrDecOperator)

Tuple Fields of IncOrDecOperator

0: &'a IncOrDecOperator

UnaryModulePathOperator(&'a UnaryModulePathOperator)

Tuple Fields of UnaryModulePathOperator

0: &'a UnaryModulePathOperator

BinaryModulePathOperator(&'a BinaryModulePathOperator)

Tuple Fields of BinaryModulePathOperator

0: &'a BinaryModulePathOperator

ConstantPrimary(&'a ConstantPrimary)

Tuple Fields of ConstantPrimary

0: &'a ConstantPrimary

ConstantPrimaryPsParameter(&'a ConstantPrimaryPsParameter)

Tuple Fields of ConstantPrimaryPsParameter

0: &'a ConstantPrimaryPsParameter

ConstantPrimarySpecparam(&'a ConstantPrimarySpecparam)

Tuple Fields of ConstantPrimarySpecparam

0: &'a ConstantPrimarySpecparam

ConstantPrimaryFormalPort(&'a ConstantPrimaryFormalPort)

Tuple Fields of ConstantPrimaryFormalPort

0: &'a ConstantPrimaryFormalPort

ConstantPrimaryEnum(&'a ConstantPrimaryEnum)

Tuple Fields of ConstantPrimaryEnum

0: &'a ConstantPrimaryEnum

ConstantPrimaryConcatenation(&'a ConstantPrimaryConcatenation)

Tuple Fields of ConstantPrimaryConcatenation

0: &'a ConstantPrimaryConcatenation

ConstantPrimaryMultipleConcatenation(&'a ConstantPrimaryMultipleConcatenation)

Tuple Fields of ConstantPrimaryMultipleConcatenation

0: &'a ConstantPrimaryMultipleConcatenation

ConstantPrimaryMintypmaxExpression(&'a ConstantPrimaryMintypmaxExpression)

Tuple Fields of ConstantPrimaryMintypmaxExpression

0: &'a ConstantPrimaryMintypmaxExpression

ModulePathPrimary(&'a ModulePathPrimary)

Tuple Fields of ModulePathPrimary

0: &'a ModulePathPrimary

ModulePathPrimaryMintypmax(&'a ModulePathPrimaryMintypmax)

Tuple Fields of ModulePathPrimaryMintypmax

0: &'a ModulePathPrimaryMintypmax

Primary(&'a Primary)

Tuple Fields of Primary

0: &'a Primary

PrimaryHierarchical(&'a PrimaryHierarchical)

Tuple Fields of PrimaryHierarchical

0: &'a PrimaryHierarchical

PrimaryConcatenation(&'a PrimaryConcatenation)

Tuple Fields of PrimaryConcatenation

0: &'a PrimaryConcatenation

PrimaryMultipleConcatenation(&'a PrimaryMultipleConcatenation)

Tuple Fields of PrimaryMultipleConcatenation

0: &'a PrimaryMultipleConcatenation

PrimaryMintypmaxExpression(&'a PrimaryMintypmaxExpression)

Tuple Fields of PrimaryMintypmaxExpression

0: &'a PrimaryMintypmaxExpression

ClassQualifierOrPackageScope(&'a ClassQualifierOrPackageScope)

Tuple Fields of ClassQualifierOrPackageScope

0: &'a ClassQualifierOrPackageScope

ClassQualifier(&'a ClassQualifier)

Tuple Fields of ClassQualifier

0: &'a ClassQualifier

RangeExpression(&'a RangeExpression)

Tuple Fields of RangeExpression

0: &'a RangeExpression

PrimaryLiteral(&'a PrimaryLiteral)

Tuple Fields of PrimaryLiteral

0: &'a PrimaryLiteral

TimeLiteral(&'a TimeLiteral)

Tuple Fields of TimeLiteral

0: &'a TimeLiteral

TimeLiteralUnsigned(&'a TimeLiteralUnsigned)

Tuple Fields of TimeLiteralUnsigned

0: &'a TimeLiteralUnsigned

TimeLiteralFixedPoint(&'a TimeLiteralFixedPoint)

Tuple Fields of TimeLiteralFixedPoint

0: &'a TimeLiteralFixedPoint

TimeUnit(&'a TimeUnit)

Tuple Fields of TimeUnit

0: &'a TimeUnit

ImplicitClassHandle(&'a ImplicitClassHandle)

Tuple Fields of ImplicitClassHandle

0: &'a ImplicitClassHandle

BitSelect(&'a BitSelect)

Tuple Fields of BitSelect

0: &'a BitSelect

Select(&'a Select)

Tuple Fields of Select

0: &'a Select

NonrangeSelect(&'a NonrangeSelect)

Tuple Fields of NonrangeSelect

0: &'a NonrangeSelect

ConstantBitSelect(&'a ConstantBitSelect)

Tuple Fields of ConstantBitSelect

0: &'a ConstantBitSelect

ConstantSelect(&'a ConstantSelect)

Tuple Fields of ConstantSelect

0: &'a ConstantSelect

ConstantCast(&'a ConstantCast)

Tuple Fields of ConstantCast

0: &'a ConstantCast

ConstantLetExpression(&'a ConstantLetExpression)

Tuple Fields of ConstantLetExpression

0: &'a ConstantLetExpression

Cast(&'a Cast)

Tuple Fields of Cast

0: &'a Cast

Concatenation(&'a Concatenation)

Tuple Fields of Concatenation

0: &'a Concatenation

ConstantConcatenation(&'a ConstantConcatenation)

Tuple Fields of ConstantConcatenation

0: &'a ConstantConcatenation

ConstantMultipleConcatenation(&'a ConstantMultipleConcatenation)

Tuple Fields of ConstantMultipleConcatenation

0: &'a ConstantMultipleConcatenation

ModulePathConcatenation(&'a ModulePathConcatenation)

Tuple Fields of ModulePathConcatenation

0: &'a ModulePathConcatenation

ModulePathMultipleConcatenation(&'a ModulePathMultipleConcatenation)

Tuple Fields of ModulePathMultipleConcatenation

0: &'a ModulePathMultipleConcatenation

MultipleConcatenation(&'a MultipleConcatenation)

Tuple Fields of MultipleConcatenation

0: &'a MultipleConcatenation

StreamingConcatenation(&'a StreamingConcatenation)

Tuple Fields of StreamingConcatenation

0: &'a StreamingConcatenation

StreamOperator(&'a StreamOperator)

Tuple Fields of StreamOperator

0: &'a StreamOperator

SliceSize(&'a SliceSize)

Tuple Fields of SliceSize

0: &'a SliceSize

StreamConcatenation(&'a StreamConcatenation)

Tuple Fields of StreamConcatenation

0: &'a StreamConcatenation

StreamExpression(&'a StreamExpression)

Tuple Fields of StreamExpression

0: &'a StreamExpression

ArrayRangeExpression(&'a ArrayRangeExpression)

Tuple Fields of ArrayRangeExpression

0: &'a ArrayRangeExpression

ArrayRangeExpressionColon(&'a ArrayRangeExpressionColon)

Tuple Fields of ArrayRangeExpressionColon

0: &'a ArrayRangeExpressionColon

ArrayRangeExpressionPlusColon(&'a ArrayRangeExpressionPlusColon)

Tuple Fields of ArrayRangeExpressionPlusColon

0: &'a ArrayRangeExpressionPlusColon

ArrayRangeExpressionMinusColon(&'a ArrayRangeExpressionMinusColon)

Tuple Fields of ArrayRangeExpressionMinusColon

0: &'a ArrayRangeExpressionMinusColon

EmptyUnpackedArrayConcatenation(&'a EmptyUnpackedArrayConcatenation)

Tuple Fields of EmptyUnpackedArrayConcatenation

0: &'a EmptyUnpackedArrayConcatenation

IncOrDecExpression(&'a IncOrDecExpression)

Tuple Fields of IncOrDecExpression

0: &'a IncOrDecExpression

IncOrDecExpressionPrefix(&'a IncOrDecExpressionPrefix)

Tuple Fields of IncOrDecExpressionPrefix

0: &'a IncOrDecExpressionPrefix

IncOrDecExpressionSuffix(&'a IncOrDecExpressionSuffix)

Tuple Fields of IncOrDecExpressionSuffix

0: &'a IncOrDecExpressionSuffix

ConditionalExpression(&'a ConditionalExpression)

Tuple Fields of ConditionalExpression

0: &'a ConditionalExpression

ConstantExpression(&'a ConstantExpression)

Tuple Fields of ConstantExpression

0: &'a ConstantExpression

ConstantExpressionUnary(&'a ConstantExpressionUnary)

Tuple Fields of ConstantExpressionUnary

0: &'a ConstantExpressionUnary

ConstantExpressionBinary(&'a ConstantExpressionBinary)

Tuple Fields of ConstantExpressionBinary

0: &'a ConstantExpressionBinary

ConstantExpressionTernary(&'a ConstantExpressionTernary)

Tuple Fields of ConstantExpressionTernary

0: &'a ConstantExpressionTernary

ConstantMintypmaxExpression(&'a ConstantMintypmaxExpression)

Tuple Fields of ConstantMintypmaxExpression

0: &'a ConstantMintypmaxExpression

ConstantMintypmaxExpressionTernary(&'a ConstantMintypmaxExpressionTernary)

Tuple Fields of ConstantMintypmaxExpressionTernary

0: &'a ConstantMintypmaxExpressionTernary

ConstantParamExpression(&'a ConstantParamExpression)

Tuple Fields of ConstantParamExpression

0: &'a ConstantParamExpression

ParamExpression(&'a ParamExpression)

Tuple Fields of ParamExpression

0: &'a ParamExpression

ConstantRangeExpression(&'a ConstantRangeExpression)

Tuple Fields of ConstantRangeExpression

0: &'a ConstantRangeExpression

ConstantPartSelectRange(&'a ConstantPartSelectRange)

Tuple Fields of ConstantPartSelectRange

0: &'a ConstantPartSelectRange

ConstantRange(&'a ConstantRange)

Tuple Fields of ConstantRange

0: &'a ConstantRange

ConstantIndexedRange(&'a ConstantIndexedRange)

Tuple Fields of ConstantIndexedRange

0: &'a ConstantIndexedRange

Expression(&'a Expression)

Tuple Fields of Expression

0: &'a Expression

ExpressionUnary(&'a ExpressionUnary)

Tuple Fields of ExpressionUnary

0: &'a ExpressionUnary

ExpressionOperatorAssignment(&'a ExpressionOperatorAssignment)

Tuple Fields of ExpressionOperatorAssignment

0: &'a ExpressionOperatorAssignment

ExpressionBinary(&'a ExpressionBinary)

Tuple Fields of ExpressionBinary

0: &'a ExpressionBinary

TaggedUnionExpression(&'a TaggedUnionExpression)

Tuple Fields of TaggedUnionExpression

0: &'a TaggedUnionExpression

InsideExpression(&'a InsideExpression)

Tuple Fields of InsideExpression

0: &'a InsideExpression

ValueRange(&'a ValueRange)

Tuple Fields of ValueRange

0: &'a ValueRange

ValueRangeBinary(&'a ValueRangeBinary)

Tuple Fields of ValueRangeBinary

0: &'a ValueRangeBinary

MintypmaxExpression(&'a MintypmaxExpression)

Tuple Fields of MintypmaxExpression

0: &'a MintypmaxExpression

MintypmaxExpressionTernary(&'a MintypmaxExpressionTernary)

Tuple Fields of MintypmaxExpressionTernary

0: &'a MintypmaxExpressionTernary

ModulePathConditionalExpression(&'a ModulePathConditionalExpression)

Tuple Fields of ModulePathConditionalExpression

0: &'a ModulePathConditionalExpression

ModulePathExpression(&'a ModulePathExpression)

Tuple Fields of ModulePathExpression

0: &'a ModulePathExpression

ModulePathExpressionUnary(&'a ModulePathExpressionUnary)

Tuple Fields of ModulePathExpressionUnary

0: &'a ModulePathExpressionUnary

ModulePathExpressionBinary(&'a ModulePathExpressionBinary)

Tuple Fields of ModulePathExpressionBinary

0: &'a ModulePathExpressionBinary

ModulePathMintypmaxExpression(&'a ModulePathMintypmaxExpression)

Tuple Fields of ModulePathMintypmaxExpression

0: &'a ModulePathMintypmaxExpression

ModulePathMintypmaxExpressionTernary(&'a ModulePathMintypmaxExpressionTernary)

Tuple Fields of ModulePathMintypmaxExpressionTernary

0: &'a ModulePathMintypmaxExpressionTernary

PartSelectRange(&'a PartSelectRange)

Tuple Fields of PartSelectRange

0: &'a PartSelectRange

IndexedRange(&'a IndexedRange)

Tuple Fields of IndexedRange

0: &'a IndexedRange

GenvarExpression(&'a GenvarExpression)

Tuple Fields of GenvarExpression

0: &'a GenvarExpression

ConstantFunctionCall(&'a ConstantFunctionCall)

Tuple Fields of ConstantFunctionCall

0: &'a ConstantFunctionCall

TfCall(&'a TfCall)

Tuple Fields of TfCall

0: &'a TfCall

SystemTfCall(&'a SystemTfCall)

Tuple Fields of SystemTfCall

0: &'a SystemTfCall

SystemTfCallArgOptional(&'a SystemTfCallArgOptional)

Tuple Fields of SystemTfCallArgOptional

0: &'a SystemTfCallArgOptional

SystemTfCallArgDataType(&'a SystemTfCallArgDataType)

Tuple Fields of SystemTfCallArgDataType

0: &'a SystemTfCallArgDataType

SystemTfCallArgExpression(&'a SystemTfCallArgExpression)

Tuple Fields of SystemTfCallArgExpression

0: &'a SystemTfCallArgExpression

SubroutineCall(&'a SubroutineCall)

Tuple Fields of SubroutineCall

0: &'a SubroutineCall

SubroutineCallRandomize(&'a SubroutineCallRandomize)

Tuple Fields of SubroutineCallRandomize

0: &'a SubroutineCallRandomize

FunctionSubroutineCall(&'a FunctionSubroutineCall)

Tuple Fields of FunctionSubroutineCall

0: &'a FunctionSubroutineCall

ListOfArguments(&'a ListOfArguments)

Tuple Fields of ListOfArguments

0: &'a ListOfArguments

ListOfArgumentsOrdered(&'a ListOfArgumentsOrdered)

Tuple Fields of ListOfArgumentsOrdered

0: &'a ListOfArgumentsOrdered

ListOfArgumentsNamed(&'a ListOfArgumentsNamed)

Tuple Fields of ListOfArgumentsNamed

0: &'a ListOfArgumentsNamed

MethodCall(&'a MethodCall)

Tuple Fields of MethodCall

0: &'a MethodCall

MethodCallBody(&'a MethodCallBody)

Tuple Fields of MethodCallBody

0: &'a MethodCallBody

MethodCallBodyUser(&'a MethodCallBodyUser)

Tuple Fields of MethodCallBodyUser

0: &'a MethodCallBodyUser

BuiltInMethodCall(&'a BuiltInMethodCall)

Tuple Fields of BuiltInMethodCall

0: &'a BuiltInMethodCall

ArrayManipulationCall(&'a ArrayManipulationCall)

Tuple Fields of ArrayManipulationCall

0: &'a ArrayManipulationCall

RandomizeCall(&'a RandomizeCall)

Tuple Fields of RandomizeCall

0: &'a RandomizeCall

VariableIdentifierListOrNull(&'a VariableIdentifierListOrNull)

Tuple Fields of VariableIdentifierListOrNull

0: &'a VariableIdentifierListOrNull

MethodCallRoot(&'a MethodCallRoot)

Tuple Fields of MethodCallRoot

0: &'a MethodCallRoot

ArrayMethodName(&'a ArrayMethodName)

Tuple Fields of ArrayMethodName

0: &'a ArrayMethodName

StringLiteral(&'a StringLiteral)

Tuple Fields of StringLiteral

0: &'a StringLiteral

NetLvalue(&'a NetLvalue)

Tuple Fields of NetLvalue

0: &'a NetLvalue

NetLvalueIdentifier(&'a NetLvalueIdentifier)

Tuple Fields of NetLvalueIdentifier

0: &'a NetLvalueIdentifier

NetLvalueLvalue(&'a NetLvalueLvalue)

Tuple Fields of NetLvalueLvalue

0: &'a NetLvalueLvalue

NetLvaluePattern(&'a NetLvaluePattern)

Tuple Fields of NetLvaluePattern

0: &'a NetLvaluePattern

VariableLvalue(&'a VariableLvalue)

Tuple Fields of VariableLvalue

0: &'a VariableLvalue

VariableLvalueIdentifier(&'a VariableLvalueIdentifier)

Tuple Fields of VariableLvalueIdentifier

0: &'a VariableLvalueIdentifier

VariableLvalueLvalue(&'a VariableLvalueLvalue)

Tuple Fields of VariableLvalueLvalue

0: &'a VariableLvalueLvalue

VariableLvaluePattern(&'a VariableLvaluePattern)

Tuple Fields of VariableLvaluePattern

0: &'a VariableLvaluePattern

NonrangeVariableLvalue(&'a NonrangeVariableLvalue)

Tuple Fields of NonrangeVariableLvalue

0: &'a NonrangeVariableLvalue

PreprocessorText(&'a PreprocessorText)

Tuple Fields of PreprocessorText

0: &'a PreprocessorText

CmosSwitchtype(&'a CmosSwitchtype)

Tuple Fields of CmosSwitchtype

0: &'a CmosSwitchtype

EnableGatetype(&'a EnableGatetype)

Tuple Fields of EnableGatetype

0: &'a EnableGatetype

MosSwitchtype(&'a MosSwitchtype)

Tuple Fields of MosSwitchtype

0: &'a MosSwitchtype

NInputGatetype(&'a NInputGatetype)

Tuple Fields of NInputGatetype

0: &'a NInputGatetype

NOutputGatetype(&'a NOutputGatetype)

Tuple Fields of NOutputGatetype

0: &'a NOutputGatetype

PassEnSwitchtype(&'a PassEnSwitchtype)

Tuple Fields of PassEnSwitchtype

0: &'a PassEnSwitchtype

PassSwitchtype(&'a PassSwitchtype)

Tuple Fields of PassSwitchtype

0: &'a PassSwitchtype

PulldownStrength(&'a PulldownStrength)

Tuple Fields of PulldownStrength

0: &'a PulldownStrength

PulldownStrength01(&'a PulldownStrength01)

Tuple Fields of PulldownStrength01

0: &'a PulldownStrength01

PulldownStrength10(&'a PulldownStrength10)

Tuple Fields of PulldownStrength10

0: &'a PulldownStrength10

PulldownStrength0(&'a PulldownStrength0)

Tuple Fields of PulldownStrength0

0: &'a PulldownStrength0

PullupStrength(&'a PullupStrength)

Tuple Fields of PullupStrength

0: &'a PullupStrength

PullupStrength01(&'a PullupStrength01)

Tuple Fields of PullupStrength01

0: &'a PullupStrength01

PullupStrength10(&'a PullupStrength10)

Tuple Fields of PullupStrength10

0: &'a PullupStrength10

PullupStrength1(&'a PullupStrength1)

Tuple Fields of PullupStrength1

0: &'a PullupStrength1

EnableTerminal(&'a EnableTerminal)

Tuple Fields of EnableTerminal

0: &'a EnableTerminal

InoutTerminal(&'a InoutTerminal)

Tuple Fields of InoutTerminal

0: &'a InoutTerminal

InputTerminal(&'a InputTerminal)

Tuple Fields of InputTerminal

0: &'a InputTerminal

NcontrolTerminal(&'a NcontrolTerminal)

Tuple Fields of NcontrolTerminal

0: &'a NcontrolTerminal

OutputTerminal(&'a OutputTerminal)

Tuple Fields of OutputTerminal

0: &'a OutputTerminal

PcontrolTerminal(&'a PcontrolTerminal)

Tuple Fields of PcontrolTerminal

0: &'a PcontrolTerminal

GateInstantiation(&'a GateInstantiation)

Tuple Fields of GateInstantiation

0: &'a GateInstantiation

GateInstantiationCmos(&'a GateInstantiationCmos)

Tuple Fields of GateInstantiationCmos

0: &'a GateInstantiationCmos

GateInstantiationEnable(&'a GateInstantiationEnable)

Tuple Fields of GateInstantiationEnable

0: &'a GateInstantiationEnable

GateInstantiationMos(&'a GateInstantiationMos)

Tuple Fields of GateInstantiationMos

0: &'a GateInstantiationMos

GateInstantiationNInput(&'a GateInstantiationNInput)

Tuple Fields of GateInstantiationNInput

0: &'a GateInstantiationNInput

GateInstantiationNOutput(&'a GateInstantiationNOutput)

Tuple Fields of GateInstantiationNOutput

0: &'a GateInstantiationNOutput

GateInstantiationPassEn(&'a GateInstantiationPassEn)

Tuple Fields of GateInstantiationPassEn

0: &'a GateInstantiationPassEn

GateInstantiationPass(&'a GateInstantiationPass)

Tuple Fields of GateInstantiationPass

0: &'a GateInstantiationPass

GateInstantiationPulldown(&'a GateInstantiationPulldown)

Tuple Fields of GateInstantiationPulldown

0: &'a GateInstantiationPulldown

GateInstantiationPullup(&'a GateInstantiationPullup)

Tuple Fields of GateInstantiationPullup

0: &'a GateInstantiationPullup

CmosSwitchInstance(&'a CmosSwitchInstance)

Tuple Fields of CmosSwitchInstance

0: &'a CmosSwitchInstance

EnableGateInstance(&'a EnableGateInstance)

Tuple Fields of EnableGateInstance

0: &'a EnableGateInstance

MosSwitchInstance(&'a MosSwitchInstance)

Tuple Fields of MosSwitchInstance

0: &'a MosSwitchInstance

NInputGateInstance(&'a NInputGateInstance)

Tuple Fields of NInputGateInstance

0: &'a NInputGateInstance

NOutputGateInstance(&'a NOutputGateInstance)

Tuple Fields of NOutputGateInstance

0: &'a NOutputGateInstance

PassSwitchInstance(&'a PassSwitchInstance)

Tuple Fields of PassSwitchInstance

0: &'a PassSwitchInstance

PassEnableSwitchInstance(&'a PassEnableSwitchInstance)

Tuple Fields of PassEnableSwitchInstance

0: &'a PassEnableSwitchInstance

PullGateInstance(&'a PullGateInstance)

Tuple Fields of PullGateInstance

0: &'a PullGateInstance

ConcurrentAssertionItem(&'a ConcurrentAssertionItem)

Tuple Fields of ConcurrentAssertionItem

0: &'a ConcurrentAssertionItem

ConcurrentAssertionItemStatement(&'a ConcurrentAssertionItemStatement)

Tuple Fields of ConcurrentAssertionItemStatement

0: &'a ConcurrentAssertionItemStatement

ConcurrentAssertionStatement(&'a ConcurrentAssertionStatement)

Tuple Fields of ConcurrentAssertionStatement

0: &'a ConcurrentAssertionStatement

AssertPropertyStatement(&'a AssertPropertyStatement)

Tuple Fields of AssertPropertyStatement

0: &'a AssertPropertyStatement

AssumePropertyStatement(&'a AssumePropertyStatement)

Tuple Fields of AssumePropertyStatement

0: &'a AssumePropertyStatement

CoverPropertyStatement(&'a CoverPropertyStatement)

Tuple Fields of CoverPropertyStatement

0: &'a CoverPropertyStatement

ExpectPropertyStatement(&'a ExpectPropertyStatement)

Tuple Fields of ExpectPropertyStatement

0: &'a ExpectPropertyStatement

CoverSequenceStatement(&'a CoverSequenceStatement)

Tuple Fields of CoverSequenceStatement

0: &'a CoverSequenceStatement

RestrictPropertyStatement(&'a RestrictPropertyStatement)

Tuple Fields of RestrictPropertyStatement

0: &'a RestrictPropertyStatement

PropertyInstance(&'a PropertyInstance)

Tuple Fields of PropertyInstance

0: &'a PropertyInstance

PropertyListOfArguments(&'a PropertyListOfArguments)

Tuple Fields of PropertyListOfArguments

0: &'a PropertyListOfArguments

PropertyListOfArgumentsOrdered(&'a PropertyListOfArgumentsOrdered)

Tuple Fields of PropertyListOfArgumentsOrdered

0: &'a PropertyListOfArgumentsOrdered

PropertyListOfArgumentsNamed(&'a PropertyListOfArgumentsNamed)

Tuple Fields of PropertyListOfArgumentsNamed

0: &'a PropertyListOfArgumentsNamed

PropertyActualArg(&'a PropertyActualArg)

Tuple Fields of PropertyActualArg

0: &'a PropertyActualArg

AssertionItemDeclaration(&'a AssertionItemDeclaration)

Tuple Fields of AssertionItemDeclaration

0: &'a AssertionItemDeclaration

PropertyDeclaration(&'a PropertyDeclaration)

Tuple Fields of PropertyDeclaration

0: &'a PropertyDeclaration

PropertyPortList(&'a PropertyPortList)

Tuple Fields of PropertyPortList

0: &'a PropertyPortList

PropertyPortItem(&'a PropertyPortItem)

Tuple Fields of PropertyPortItem

0: &'a PropertyPortItem

PropertyLvarPortDirection(&'a PropertyLvarPortDirection)

Tuple Fields of PropertyLvarPortDirection

0: &'a PropertyLvarPortDirection

PropertyFormalType(&'a PropertyFormalType)

Tuple Fields of PropertyFormalType

0: &'a PropertyFormalType

PropertySpec(&'a PropertySpec)

Tuple Fields of PropertySpec

0: &'a PropertySpec

PropertyExpr(&'a PropertyExpr)

Tuple Fields of PropertyExpr

0: &'a PropertyExpr

PropertyExprStrong(&'a PropertyExprStrong)

Tuple Fields of PropertyExprStrong

0: &'a PropertyExprStrong

PropertyExprWeak(&'a PropertyExprWeak)

Tuple Fields of PropertyExprWeak

0: &'a PropertyExprWeak

PropertyExprParen(&'a PropertyExprParen)

Tuple Fields of PropertyExprParen

0: &'a PropertyExprParen

PropertyExprNot(&'a PropertyExprNot)

Tuple Fields of PropertyExprNot

0: &'a PropertyExprNot

PropertyExprBinaryProperty(&'a PropertyExprBinaryProperty)

Tuple Fields of PropertyExprBinaryProperty

0: &'a PropertyExprBinaryProperty

PropertyExprBinarySequence(&'a PropertyExprBinarySequence)

Tuple Fields of PropertyExprBinarySequence

0: &'a PropertyExprBinarySequence

PropertyExprIf(&'a PropertyExprIf)

Tuple Fields of PropertyExprIf

0: &'a PropertyExprIf

PropertyExprCase(&'a PropertyExprCase)

Tuple Fields of PropertyExprCase

0: &'a PropertyExprCase

PropertyExprNexttime(&'a PropertyExprNexttime)

Tuple Fields of PropertyExprNexttime

0: &'a PropertyExprNexttime

PropertyExprSNexttime(&'a PropertyExprSNexttime)

Tuple Fields of PropertyExprSNexttime

0: &'a PropertyExprSNexttime

PropertyExprAlways(&'a PropertyExprAlways)

Tuple Fields of PropertyExprAlways

0: &'a PropertyExprAlways

PropertyExprSAlways(&'a PropertyExprSAlways)

Tuple Fields of PropertyExprSAlways

0: &'a PropertyExprSAlways

PropertyExprEventually(&'a PropertyExprEventually)

Tuple Fields of PropertyExprEventually

0: &'a PropertyExprEventually

PropertyExprSEventually(&'a PropertyExprSEventually)

Tuple Fields of PropertyExprSEventually

0: &'a PropertyExprSEventually

PropertyExprAcceptOn(&'a PropertyExprAcceptOn)

Tuple Fields of PropertyExprAcceptOn

0: &'a PropertyExprAcceptOn

PropertyExprRejectOn(&'a PropertyExprRejectOn)

Tuple Fields of PropertyExprRejectOn

0: &'a PropertyExprRejectOn

PropertyExprSyncAcceptOn(&'a PropertyExprSyncAcceptOn)

Tuple Fields of PropertyExprSyncAcceptOn

0: &'a PropertyExprSyncAcceptOn

PropertyExprSyncRejectOn(&'a PropertyExprSyncRejectOn)

Tuple Fields of PropertyExprSyncRejectOn

0: &'a PropertyExprSyncRejectOn

PropertyExprClockingEvent(&'a PropertyExprClockingEvent)

Tuple Fields of PropertyExprClockingEvent

0: &'a PropertyExprClockingEvent

PropertyCaseItem(&'a PropertyCaseItem)

Tuple Fields of PropertyCaseItem

0: &'a PropertyCaseItem

PropertyCaseItemNondefault(&'a PropertyCaseItemNondefault)

Tuple Fields of PropertyCaseItemNondefault

0: &'a PropertyCaseItemNondefault

PropertyCaseItemDefault(&'a PropertyCaseItemDefault)

Tuple Fields of PropertyCaseItemDefault

0: &'a PropertyCaseItemDefault

SequenceDeclaration(&'a SequenceDeclaration)

Tuple Fields of SequenceDeclaration

0: &'a SequenceDeclaration

SequencePortList(&'a SequencePortList)

Tuple Fields of SequencePortList

0: &'a SequencePortList

SequencePortItem(&'a SequencePortItem)

Tuple Fields of SequencePortItem

0: &'a SequencePortItem

SequenceLvarPortDirection(&'a SequenceLvarPortDirection)

Tuple Fields of SequenceLvarPortDirection

0: &'a SequenceLvarPortDirection

SequenceFormalType(&'a SequenceFormalType)

Tuple Fields of SequenceFormalType

0: &'a SequenceFormalType

SequenceExpr(&'a SequenceExpr)

Tuple Fields of SequenceExpr

0: &'a SequenceExpr

SequenceExprCycleDelayExpr(&'a SequenceExprCycleDelayExpr)

Tuple Fields of SequenceExprCycleDelayExpr

0: &'a SequenceExprCycleDelayExpr

SequenceExprExprCycleDelayExpr(&'a SequenceExprExprCycleDelayExpr)

Tuple Fields of SequenceExprExprCycleDelayExpr

0: &'a SequenceExprExprCycleDelayExpr

SequenceExprExpression(&'a SequenceExprExpression)

Tuple Fields of SequenceExprExpression

0: &'a SequenceExprExpression

SequenceExprInstance(&'a SequenceExprInstance)

Tuple Fields of SequenceExprInstance

0: &'a SequenceExprInstance

SequenceExprParen(&'a SequenceExprParen)

Tuple Fields of SequenceExprParen

0: &'a SequenceExprParen

SequenceExprBinary(&'a SequenceExprBinary)

Tuple Fields of SequenceExprBinary

0: &'a SequenceExprBinary

SequenceExprFirstMatch(&'a SequenceExprFirstMatch)

Tuple Fields of SequenceExprFirstMatch

0: &'a SequenceExprFirstMatch

SequenceExprThroughout(&'a SequenceExprThroughout)

Tuple Fields of SequenceExprThroughout

0: &'a SequenceExprThroughout

SequenceExprClockingEvent(&'a SequenceExprClockingEvent)

Tuple Fields of SequenceExprClockingEvent

0: &'a SequenceExprClockingEvent

CycleDelayRange(&'a CycleDelayRange)

Tuple Fields of CycleDelayRange

0: &'a CycleDelayRange

CycleDelayRangePrimary(&'a CycleDelayRangePrimary)

Tuple Fields of CycleDelayRangePrimary

0: &'a CycleDelayRangePrimary

CycleDelayRangeExpression(&'a CycleDelayRangeExpression)

Tuple Fields of CycleDelayRangeExpression

0: &'a CycleDelayRangeExpression

CycleDelayRangeAsterisk(&'a CycleDelayRangeAsterisk)

Tuple Fields of CycleDelayRangeAsterisk

0: &'a CycleDelayRangeAsterisk

CycleDelayRangePlus(&'a CycleDelayRangePlus)

Tuple Fields of CycleDelayRangePlus

0: &'a CycleDelayRangePlus

SequenceMethodCall(&'a SequenceMethodCall)

Tuple Fields of SequenceMethodCall

0: &'a SequenceMethodCall

SequenceMatchItem(&'a SequenceMatchItem)

Tuple Fields of SequenceMatchItem

0: &'a SequenceMatchItem

SequenceInstance(&'a SequenceInstance)

Tuple Fields of SequenceInstance

0: &'a SequenceInstance

SequenceListOfArguments(&'a SequenceListOfArguments)

Tuple Fields of SequenceListOfArguments

0: &'a SequenceListOfArguments

SequenceListOfArgumentsOrdered(&'a SequenceListOfArgumentsOrdered)

Tuple Fields of SequenceListOfArgumentsOrdered

0: &'a SequenceListOfArgumentsOrdered

SequenceListOfArgumentsNamed(&'a SequenceListOfArgumentsNamed)

Tuple Fields of SequenceListOfArgumentsNamed

0: &'a SequenceListOfArgumentsNamed

SequenceActualArg(&'a SequenceActualArg)

Tuple Fields of SequenceActualArg

0: &'a SequenceActualArg

BooleanAbbrev(&'a BooleanAbbrev)

Tuple Fields of BooleanAbbrev

0: &'a BooleanAbbrev

SequenceAbbrev(&'a SequenceAbbrev)

Tuple Fields of SequenceAbbrev

0: &'a SequenceAbbrev

ConsecutiveRepetition(&'a ConsecutiveRepetition)

Tuple Fields of ConsecutiveRepetition

0: &'a ConsecutiveRepetition

ConsecutiveRepetitionExpression(&'a ConsecutiveRepetitionExpression)

Tuple Fields of ConsecutiveRepetitionExpression

0: &'a ConsecutiveRepetitionExpression

ConsecutiveRepetitionAsterisk(&'a ConsecutiveRepetitionAsterisk)

Tuple Fields of ConsecutiveRepetitionAsterisk

0: &'a ConsecutiveRepetitionAsterisk

ConsecutiveRepetitionPlus(&'a ConsecutiveRepetitionPlus)

Tuple Fields of ConsecutiveRepetitionPlus

0: &'a ConsecutiveRepetitionPlus

NonConsecutiveRepetition(&'a NonConsecutiveRepetition)

Tuple Fields of NonConsecutiveRepetition

0: &'a NonConsecutiveRepetition

GotoRepetition(&'a GotoRepetition)

Tuple Fields of GotoRepetition

0: &'a GotoRepetition

ConstOrRangeExpression(&'a ConstOrRangeExpression)

Tuple Fields of ConstOrRangeExpression

0: &'a ConstOrRangeExpression

CycleDelayConstRangeExpression(&'a CycleDelayConstRangeExpression)

Tuple Fields of CycleDelayConstRangeExpression

0: &'a CycleDelayConstRangeExpression

CycleDelayConstRangeExpressionBinary(&'a CycleDelayConstRangeExpressionBinary)

Tuple Fields of CycleDelayConstRangeExpressionBinary

0: &'a CycleDelayConstRangeExpressionBinary

CycleDelayConstRangeExpressionDollar(&'a CycleDelayConstRangeExpressionDollar)

Tuple Fields of CycleDelayConstRangeExpressionDollar

0: &'a CycleDelayConstRangeExpressionDollar

ExpressionOrDist(&'a ExpressionOrDist)

Tuple Fields of ExpressionOrDist

0: &'a ExpressionOrDist

AssertionVariableDeclaration(&'a AssertionVariableDeclaration)

Tuple Fields of AssertionVariableDeclaration

0: &'a AssertionVariableDeclaration

TaskDeclaration(&'a TaskDeclaration)

Tuple Fields of TaskDeclaration

0: &'a TaskDeclaration

TaskBodyDeclaration(&'a TaskBodyDeclaration)

Tuple Fields of TaskBodyDeclaration

0: &'a TaskBodyDeclaration

TaskBodyDeclarationWithoutPort(&'a TaskBodyDeclarationWithoutPort)

Tuple Fields of TaskBodyDeclarationWithoutPort

0: &'a TaskBodyDeclarationWithoutPort

TaskBodyDeclarationWithPort(&'a TaskBodyDeclarationWithPort)

Tuple Fields of TaskBodyDeclarationWithPort

0: &'a TaskBodyDeclarationWithPort

TfItemDeclaration(&'a TfItemDeclaration)

Tuple Fields of TfItemDeclaration

0: &'a TfItemDeclaration

TfPortList(&'a TfPortList)

Tuple Fields of TfPortList

0: &'a TfPortList

TfPortItem(&'a TfPortItem)

Tuple Fields of TfPortItem

0: &'a TfPortItem

TfPortDirection(&'a TfPortDirection)

Tuple Fields of TfPortDirection

0: &'a TfPortDirection

TfPortDeclaration(&'a TfPortDeclaration)

Tuple Fields of TfPortDeclaration

0: &'a TfPortDeclaration

TaskPrototype(&'a TaskPrototype)

Tuple Fields of TaskPrototype

0: &'a TaskPrototype

DefparamAssignment(&'a DefparamAssignment)

Tuple Fields of DefparamAssignment

0: &'a DefparamAssignment

NetDeclAssignment(&'a NetDeclAssignment)

Tuple Fields of NetDeclAssignment

0: &'a NetDeclAssignment

ParamAssignment(&'a ParamAssignment)

Tuple Fields of ParamAssignment

0: &'a ParamAssignment

SpecparamAssignment(&'a SpecparamAssignment)

Tuple Fields of SpecparamAssignment

0: &'a SpecparamAssignment

SpecparamAssignmentMintypmax(&'a SpecparamAssignmentMintypmax)

Tuple Fields of SpecparamAssignmentMintypmax

0: &'a SpecparamAssignmentMintypmax

TypeAssignment(&'a TypeAssignment)

Tuple Fields of TypeAssignment

0: &'a TypeAssignment

PulseControlSpecparam(&'a PulseControlSpecparam)

Tuple Fields of PulseControlSpecparam

0: &'a PulseControlSpecparam

PulseControlSpecparamWithoutDescriptor(&'a PulseControlSpecparamWithoutDescriptor)

Tuple Fields of PulseControlSpecparamWithoutDescriptor

0: &'a PulseControlSpecparamWithoutDescriptor

PulseControlSpecparamWithDescriptor(&'a PulseControlSpecparamWithDescriptor)

Tuple Fields of PulseControlSpecparamWithDescriptor

0: &'a PulseControlSpecparamWithDescriptor

ErrorLimitValue(&'a ErrorLimitValue)

Tuple Fields of ErrorLimitValue

0: &'a ErrorLimitValue

RejectLimitValue(&'a RejectLimitValue)

Tuple Fields of RejectLimitValue

0: &'a RejectLimitValue

LimitValue(&'a LimitValue)

Tuple Fields of LimitValue

0: &'a LimitValue

VariableDeclAssignment(&'a VariableDeclAssignment)

Tuple Fields of VariableDeclAssignment

0: &'a VariableDeclAssignment

VariableDeclAssignmentVariable(&'a VariableDeclAssignmentVariable)

Tuple Fields of VariableDeclAssignmentVariable

0: &'a VariableDeclAssignmentVariable

VariableDeclAssignmentDynamicArray(&'a VariableDeclAssignmentDynamicArray)

Tuple Fields of VariableDeclAssignmentDynamicArray

0: &'a VariableDeclAssignmentDynamicArray

VariableDeclAssignmentClass(&'a VariableDeclAssignmentClass)

Tuple Fields of VariableDeclAssignmentClass

0: &'a VariableDeclAssignmentClass

ClassNew(&'a ClassNew)

Tuple Fields of ClassNew

0: &'a ClassNew

ClassNewArgument(&'a ClassNewArgument)

Tuple Fields of ClassNewArgument

0: &'a ClassNewArgument

ClassNewExpression(&'a ClassNewExpression)

Tuple Fields of ClassNewExpression

0: &'a ClassNewExpression

DynamicArrayNew(&'a DynamicArrayNew)

Tuple Fields of DynamicArrayNew

0: &'a DynamicArrayNew

ListOfDefparamAssignments(&'a ListOfDefparamAssignments)

Tuple Fields of ListOfDefparamAssignments

0: &'a ListOfDefparamAssignments

ListOfGenvarIdentifiers(&'a ListOfGenvarIdentifiers)

Tuple Fields of ListOfGenvarIdentifiers

0: &'a ListOfGenvarIdentifiers

ListOfInterfaceIdentifiers(&'a ListOfInterfaceIdentifiers)

Tuple Fields of ListOfInterfaceIdentifiers

0: &'a ListOfInterfaceIdentifiers

ListOfNetDeclAssignments(&'a ListOfNetDeclAssignments)

Tuple Fields of ListOfNetDeclAssignments

0: &'a ListOfNetDeclAssignments

ListOfParamAssignments(&'a ListOfParamAssignments)

Tuple Fields of ListOfParamAssignments

0: &'a ListOfParamAssignments

ListOfPortIdentifiers(&'a ListOfPortIdentifiers)

Tuple Fields of ListOfPortIdentifiers

0: &'a ListOfPortIdentifiers

ListOfUdpPortIdentifiers(&'a ListOfUdpPortIdentifiers)

Tuple Fields of ListOfUdpPortIdentifiers

0: &'a ListOfUdpPortIdentifiers

ListOfSpecparamAssignments(&'a ListOfSpecparamAssignments)

Tuple Fields of ListOfSpecparamAssignments

0: &'a ListOfSpecparamAssignments

ListOfTfVariableIdentifiers(&'a ListOfTfVariableIdentifiers)

Tuple Fields of ListOfTfVariableIdentifiers

0: &'a ListOfTfVariableIdentifiers

ListOfTypeAssignments(&'a ListOfTypeAssignments)

Tuple Fields of ListOfTypeAssignments

0: &'a ListOfTypeAssignments

ListOfVariableDeclAssignments(&'a ListOfVariableDeclAssignments)

Tuple Fields of ListOfVariableDeclAssignments

0: &'a ListOfVariableDeclAssignments

ListOfVariableIdentifiers(&'a ListOfVariableIdentifiers)

Tuple Fields of ListOfVariableIdentifiers

0: &'a ListOfVariableIdentifiers

ListOfVariablePortIdentifiers(&'a ListOfVariablePortIdentifiers)

Tuple Fields of ListOfVariablePortIdentifiers

0: &'a ListOfVariablePortIdentifiers

DataDeclaration(&'a DataDeclaration)

Tuple Fields of DataDeclaration

0: &'a DataDeclaration

DataDeclarationVariable(&'a DataDeclarationVariable)

Tuple Fields of DataDeclarationVariable

0: &'a DataDeclarationVariable

Const(&'a Const)

Tuple Fields of Const

0: &'a Const

PackageImportDeclaration(&'a PackageImportDeclaration)

Tuple Fields of PackageImportDeclaration

0: &'a PackageImportDeclaration

PackageImportItem(&'a PackageImportItem)

Tuple Fields of PackageImportItem

0: &'a PackageImportItem

PackageImportItemIdentifier(&'a PackageImportItemIdentifier)

Tuple Fields of PackageImportItemIdentifier

0: &'a PackageImportItemIdentifier

PackageImportItemAsterisk(&'a PackageImportItemAsterisk)

Tuple Fields of PackageImportItemAsterisk

0: &'a PackageImportItemAsterisk

PackageExportDeclaration(&'a PackageExportDeclaration)

Tuple Fields of PackageExportDeclaration

0: &'a PackageExportDeclaration

PackageExportDeclarationAsterisk(&'a PackageExportDeclarationAsterisk)

Tuple Fields of PackageExportDeclarationAsterisk

0: &'a PackageExportDeclarationAsterisk

PackageExportDeclarationItem(&'a PackageExportDeclarationItem)

Tuple Fields of PackageExportDeclarationItem

0: &'a PackageExportDeclarationItem

GenvarDeclaration(&'a GenvarDeclaration)

Tuple Fields of GenvarDeclaration

0: &'a GenvarDeclaration

NetDeclaration(&'a NetDeclaration)

Tuple Fields of NetDeclaration

0: &'a NetDeclaration

NetDeclarationNetType(&'a NetDeclarationNetType)

Tuple Fields of NetDeclarationNetType

0: &'a NetDeclarationNetType

Strength(&'a Strength)

Tuple Fields of Strength

0: &'a Strength

VectorScalar(&'a VectorScalar)

Tuple Fields of VectorScalar

0: &'a VectorScalar

NetDeclarationNetTypeIdentifier(&'a NetDeclarationNetTypeIdentifier)

Tuple Fields of NetDeclarationNetTypeIdentifier

0: &'a NetDeclarationNetTypeIdentifier

NetDeclarationInterconnect(&'a NetDeclarationInterconnect)

Tuple Fields of NetDeclarationInterconnect

0: &'a NetDeclarationInterconnect

TypeDeclaration(&'a TypeDeclaration)

Tuple Fields of TypeDeclaration

0: &'a TypeDeclaration

TypeDeclarationDataType(&'a TypeDeclarationDataType)

Tuple Fields of TypeDeclarationDataType

0: &'a TypeDeclarationDataType

TypeDeclarationInterface(&'a TypeDeclarationInterface)

Tuple Fields of TypeDeclarationInterface

0: &'a TypeDeclarationInterface

TypeDeclarationReserved(&'a TypeDeclarationReserved)

Tuple Fields of TypeDeclarationReserved

0: &'a TypeDeclarationReserved

TypeDeclarationKeyword(&'a TypeDeclarationKeyword)

Tuple Fields of TypeDeclarationKeyword

0: &'a TypeDeclarationKeyword

NetTypeDeclaration(&'a NetTypeDeclaration)

Tuple Fields of NetTypeDeclaration

0: &'a NetTypeDeclaration

NetTypeDeclarationDataType(&'a NetTypeDeclarationDataType)

Tuple Fields of NetTypeDeclarationDataType

0: &'a NetTypeDeclarationDataType

NetTypeDeclarationNetType(&'a NetTypeDeclarationNetType)

Tuple Fields of NetTypeDeclarationNetType

0: &'a NetTypeDeclarationNetType

Lifetime(&'a Lifetime)

Tuple Fields of Lifetime

0: &'a Lifetime

DriveStrength(&'a DriveStrength)

Tuple Fields of DriveStrength

0: &'a DriveStrength

DriveStrength01(&'a DriveStrength01)

Tuple Fields of DriveStrength01

0: &'a DriveStrength01

DriveStrength10(&'a DriveStrength10)

Tuple Fields of DriveStrength10

0: &'a DriveStrength10

DriveStrength0z(&'a DriveStrength0z)

Tuple Fields of DriveStrength0z

0: &'a DriveStrength0z

DriveStrength1z(&'a DriveStrength1z)

Tuple Fields of DriveStrength1z

0: &'a DriveStrength1z

DriveStrengthz1(&'a DriveStrengthz1)

Tuple Fields of DriveStrengthz1

0: &'a DriveStrengthz1

DriveStrengthz0(&'a DriveStrengthz0)

Tuple Fields of DriveStrengthz0

0: &'a DriveStrengthz0

Strength0(&'a Strength0)

Tuple Fields of Strength0

0: &'a Strength0

Strength1(&'a Strength1)

Tuple Fields of Strength1

0: &'a Strength1

ChargeStrength(&'a ChargeStrength)

Tuple Fields of ChargeStrength

0: &'a ChargeStrength

ChargeStrengthSmall(&'a ChargeStrengthSmall)

Tuple Fields of ChargeStrengthSmall

0: &'a ChargeStrengthSmall

ChargeStrengthMedium(&'a ChargeStrengthMedium)

Tuple Fields of ChargeStrengthMedium

0: &'a ChargeStrengthMedium

ChargeStrengthLarge(&'a ChargeStrengthLarge)

Tuple Fields of ChargeStrengthLarge

0: &'a ChargeStrengthLarge

LetDeclaration(&'a LetDeclaration)

Tuple Fields of LetDeclaration

0: &'a LetDeclaration

LetIdentifier(&'a LetIdentifier)

Tuple Fields of LetIdentifier

0: &'a LetIdentifier

LetPortList(&'a LetPortList)

Tuple Fields of LetPortList

0: &'a LetPortList

LetPortItem(&'a LetPortItem)

Tuple Fields of LetPortItem

0: &'a LetPortItem

LetFormalType(&'a LetFormalType)

Tuple Fields of LetFormalType

0: &'a LetFormalType

LetExpression(&'a LetExpression)

Tuple Fields of LetExpression

0: &'a LetExpression

LetListOfArguments(&'a LetListOfArguments)

Tuple Fields of LetListOfArguments

0: &'a LetListOfArguments

LetListOfArgumentsOrdered(&'a LetListOfArgumentsOrdered)

Tuple Fields of LetListOfArgumentsOrdered

0: &'a LetListOfArgumentsOrdered

LetListOfArgumentsNamed(&'a LetListOfArgumentsNamed)

Tuple Fields of LetListOfArgumentsNamed

0: &'a LetListOfArgumentsNamed

LetActualArg(&'a LetActualArg)

Tuple Fields of LetActualArg

0: &'a LetActualArg

InoutDeclaration(&'a InoutDeclaration)

Tuple Fields of InoutDeclaration

0: &'a InoutDeclaration

InputDeclaration(&'a InputDeclaration)

Tuple Fields of InputDeclaration

0: &'a InputDeclaration

InputDeclarationNet(&'a InputDeclarationNet)

Tuple Fields of InputDeclarationNet

0: &'a InputDeclarationNet

InputDeclarationVariable(&'a InputDeclarationVariable)

Tuple Fields of InputDeclarationVariable

0: &'a InputDeclarationVariable

OutputDeclaration(&'a OutputDeclaration)

Tuple Fields of OutputDeclaration

0: &'a OutputDeclaration

OutputDeclarationNet(&'a OutputDeclarationNet)

Tuple Fields of OutputDeclarationNet

0: &'a OutputDeclarationNet

OutputDeclarationVariable(&'a OutputDeclarationVariable)

Tuple Fields of OutputDeclarationVariable

0: &'a OutputDeclarationVariable

InterfacePortDeclaration(&'a InterfacePortDeclaration)

Tuple Fields of InterfacePortDeclaration

0: &'a InterfacePortDeclaration

RefDeclaration(&'a RefDeclaration)

Tuple Fields of RefDeclaration

0: &'a RefDeclaration

UnpackedDimension(&'a UnpackedDimension)

Tuple Fields of UnpackedDimension

0: &'a UnpackedDimension

UnpackedDimensionRange(&'a UnpackedDimensionRange)

Tuple Fields of UnpackedDimensionRange

0: &'a UnpackedDimensionRange

UnpackedDimensionExpression(&'a UnpackedDimensionExpression)

Tuple Fields of UnpackedDimensionExpression

0: &'a UnpackedDimensionExpression

PackedDimension(&'a PackedDimension)

Tuple Fields of PackedDimension

0: &'a PackedDimension

PackedDimensionRange(&'a PackedDimensionRange)

Tuple Fields of PackedDimensionRange

0: &'a PackedDimensionRange

AssociativeDimension(&'a AssociativeDimension)

Tuple Fields of AssociativeDimension

0: &'a AssociativeDimension

AssociativeDimensionDataType(&'a AssociativeDimensionDataType)

Tuple Fields of AssociativeDimensionDataType

0: &'a AssociativeDimensionDataType

AssociativeDimensionAsterisk(&'a AssociativeDimensionAsterisk)

Tuple Fields of AssociativeDimensionAsterisk

0: &'a AssociativeDimensionAsterisk

VariableDimension(&'a VariableDimension)

Tuple Fields of VariableDimension

0: &'a VariableDimension

QueueDimension(&'a QueueDimension)

Tuple Fields of QueueDimension

0: &'a QueueDimension

UnsizedDimension(&'a UnsizedDimension)

Tuple Fields of UnsizedDimension

0: &'a UnsizedDimension

LocalParameterDeclaration(&'a LocalParameterDeclaration)

Tuple Fields of LocalParameterDeclaration

0: &'a LocalParameterDeclaration

LocalParameterDeclarationParam(&'a LocalParameterDeclarationParam)

Tuple Fields of LocalParameterDeclarationParam

0: &'a LocalParameterDeclarationParam

LocalParameterDeclarationType(&'a LocalParameterDeclarationType)

Tuple Fields of LocalParameterDeclarationType

0: &'a LocalParameterDeclarationType

ParameterDeclaration(&'a ParameterDeclaration)

Tuple Fields of ParameterDeclaration

0: &'a ParameterDeclaration

ParameterDeclarationParam(&'a ParameterDeclarationParam)

Tuple Fields of ParameterDeclarationParam

0: &'a ParameterDeclarationParam

ParameterDeclarationType(&'a ParameterDeclarationType)

Tuple Fields of ParameterDeclarationType

0: &'a ParameterDeclarationType

SpecparamDeclaration(&'a SpecparamDeclaration)

Tuple Fields of SpecparamDeclaration

0: &'a SpecparamDeclaration

CovergroupDeclaration(&'a CovergroupDeclaration)

Tuple Fields of CovergroupDeclaration

0: &'a CovergroupDeclaration

CoverageSpecOrOption(&'a CoverageSpecOrOption)

Tuple Fields of CoverageSpecOrOption

0: &'a CoverageSpecOrOption

CoverageSpecOrOptionSpec(&'a CoverageSpecOrOptionSpec)

Tuple Fields of CoverageSpecOrOptionSpec

0: &'a CoverageSpecOrOptionSpec

CoverageSpecOrOptionOption(&'a CoverageSpecOrOptionOption)

Tuple Fields of CoverageSpecOrOptionOption

0: &'a CoverageSpecOrOptionOption

CoverageOption(&'a CoverageOption)

Tuple Fields of CoverageOption

0: &'a CoverageOption

CoverageOptionOption(&'a CoverageOptionOption)

Tuple Fields of CoverageOptionOption

0: &'a CoverageOptionOption

CoverageOptionTypeOption(&'a CoverageOptionTypeOption)

Tuple Fields of CoverageOptionTypeOption

0: &'a CoverageOptionTypeOption

CoverageSpec(&'a CoverageSpec)

Tuple Fields of CoverageSpec

0: &'a CoverageSpec

CoverageEvent(&'a CoverageEvent)

Tuple Fields of CoverageEvent

0: &'a CoverageEvent

CoverageEventSample(&'a CoverageEventSample)

Tuple Fields of CoverageEventSample

0: &'a CoverageEventSample

CoverageEventAt(&'a CoverageEventAt)

Tuple Fields of CoverageEventAt

0: &'a CoverageEventAt

BlockEventExpression(&'a BlockEventExpression)

Tuple Fields of BlockEventExpression

0: &'a BlockEventExpression

BlockEventExpressionOr(&'a BlockEventExpressionOr)

Tuple Fields of BlockEventExpressionOr

0: &'a BlockEventExpressionOr

BlockEventExpressionBegin(&'a BlockEventExpressionBegin)

Tuple Fields of BlockEventExpressionBegin

0: &'a BlockEventExpressionBegin

BlockEventExpressionEnd(&'a BlockEventExpressionEnd)

Tuple Fields of BlockEventExpressionEnd

0: &'a BlockEventExpressionEnd

HierarchicalBtfIdentifier(&'a HierarchicalBtfIdentifier)

Tuple Fields of HierarchicalBtfIdentifier

0: &'a HierarchicalBtfIdentifier

HierarchicalBtfIdentifierMethod(&'a HierarchicalBtfIdentifierMethod)

Tuple Fields of HierarchicalBtfIdentifierMethod

0: &'a HierarchicalBtfIdentifierMethod

HierarchicalIdentifierOrClassScope(&'a HierarchicalIdentifierOrClassScope)

Tuple Fields of HierarchicalIdentifierOrClassScope

0: &'a HierarchicalIdentifierOrClassScope

CoverPoint(&'a CoverPoint)

Tuple Fields of CoverPoint

0: &'a CoverPoint

BinsOrEmpty(&'a BinsOrEmpty)

Tuple Fields of BinsOrEmpty

0: &'a BinsOrEmpty

BinsOrEmptyNonEmpty(&'a BinsOrEmptyNonEmpty)

Tuple Fields of BinsOrEmptyNonEmpty

0: &'a BinsOrEmptyNonEmpty

BinsOrOptions(&'a BinsOrOptions)

Tuple Fields of BinsOrOptions

0: &'a BinsOrOptions

BinsOrOptionsCovergroup(&'a BinsOrOptionsCovergroup)

Tuple Fields of BinsOrOptionsCovergroup

0: &'a BinsOrOptionsCovergroup

Wildcard(&'a Wildcard)

Tuple Fields of Wildcard

0: &'a Wildcard

BinsOrOptionsCoverPoint(&'a BinsOrOptionsCoverPoint)

Tuple Fields of BinsOrOptionsCoverPoint

0: &'a BinsOrOptionsCoverPoint

BinsOrOptionsSetCovergroup(&'a BinsOrOptionsSetCovergroup)

Tuple Fields of BinsOrOptionsSetCovergroup

0: &'a BinsOrOptionsSetCovergroup

BinsOrOptionsTransList(&'a BinsOrOptionsTransList)

Tuple Fields of BinsOrOptionsTransList

0: &'a BinsOrOptionsTransList

BinsOrOptionsDefault(&'a BinsOrOptionsDefault)

Tuple Fields of BinsOrOptionsDefault

0: &'a BinsOrOptionsDefault

BinsOrOptionsDefaultSequence(&'a BinsOrOptionsDefaultSequence)

Tuple Fields of BinsOrOptionsDefaultSequence

0: &'a BinsOrOptionsDefaultSequence

BinsKeyword(&'a BinsKeyword)

Tuple Fields of BinsKeyword

0: &'a BinsKeyword

TransList(&'a TransList)

Tuple Fields of TransList

0: &'a TransList

TransSet(&'a TransSet)

Tuple Fields of TransSet

0: &'a TransSet

TransRangeList(&'a TransRangeList)

Tuple Fields of TransRangeList

0: &'a TransRangeList

TransRangeListAsterisk(&'a TransRangeListAsterisk)

Tuple Fields of TransRangeListAsterisk

0: &'a TransRangeListAsterisk

TransRangeListArrow(&'a TransRangeListArrow)

Tuple Fields of TransRangeListArrow

0: &'a TransRangeListArrow

TransRangeListEqual(&'a TransRangeListEqual)

Tuple Fields of TransRangeListEqual

0: &'a TransRangeListEqual

TransItem(&'a TransItem)

Tuple Fields of TransItem

0: &'a TransItem

RepeatRange(&'a RepeatRange)

Tuple Fields of RepeatRange

0: &'a RepeatRange

RepeatRangeBinary(&'a RepeatRangeBinary)

Tuple Fields of RepeatRangeBinary

0: &'a RepeatRangeBinary

CoverCross(&'a CoverCross)

Tuple Fields of CoverCross

0: &'a CoverCross

ListOfCrossItems(&'a ListOfCrossItems)

Tuple Fields of ListOfCrossItems

0: &'a ListOfCrossItems

CrossItem(&'a CrossItem)

Tuple Fields of CrossItem

0: &'a CrossItem

CrossBody(&'a CrossBody)

Tuple Fields of CrossBody

0: &'a CrossBody

CrossBodyNonEmpty(&'a CrossBodyNonEmpty)

Tuple Fields of CrossBodyNonEmpty

0: &'a CrossBodyNonEmpty

CrossBodyItem(&'a CrossBodyItem)

Tuple Fields of CrossBodyItem

0: &'a CrossBodyItem

BinsSelectionOrOption(&'a BinsSelectionOrOption)

Tuple Fields of BinsSelectionOrOption

0: &'a BinsSelectionOrOption

BinsSelectionOrOptionCoverage(&'a BinsSelectionOrOptionCoverage)

Tuple Fields of BinsSelectionOrOptionCoverage

0: &'a BinsSelectionOrOptionCoverage

BinsSelectionOrOptionBins(&'a BinsSelectionOrOptionBins)

Tuple Fields of BinsSelectionOrOptionBins

0: &'a BinsSelectionOrOptionBins

BinsSelection(&'a BinsSelection)

Tuple Fields of BinsSelection

0: &'a BinsSelection

SelectExpression(&'a SelectExpression)

Tuple Fields of SelectExpression

0: &'a SelectExpression

SelectExpressionNot(&'a SelectExpressionNot)

Tuple Fields of SelectExpressionNot

0: &'a SelectExpressionNot

SelectExpressionAnd(&'a SelectExpressionAnd)

Tuple Fields of SelectExpressionAnd

0: &'a SelectExpressionAnd

SelectExpressionOr(&'a SelectExpressionOr)

Tuple Fields of SelectExpressionOr

0: &'a SelectExpressionOr

SelectExpressionParen(&'a SelectExpressionParen)

Tuple Fields of SelectExpressionParen

0: &'a SelectExpressionParen

SelectExpressionWith(&'a SelectExpressionWith)

Tuple Fields of SelectExpressionWith

0: &'a SelectExpressionWith

SelectExpressionCrossSet(&'a SelectExpressionCrossSet)

Tuple Fields of SelectExpressionCrossSet

0: &'a SelectExpressionCrossSet

SelectCondition(&'a SelectCondition)

Tuple Fields of SelectCondition

0: &'a SelectCondition

BinsExpression(&'a BinsExpression)

Tuple Fields of BinsExpression

0: &'a BinsExpression

BinsExpressionCoverPoint(&'a BinsExpressionCoverPoint)

Tuple Fields of BinsExpressionCoverPoint

0: &'a BinsExpressionCoverPoint

CovergroupRangeList(&'a CovergroupRangeList)

Tuple Fields of CovergroupRangeList

0: &'a CovergroupRangeList

CovergroupValueRange(&'a CovergroupValueRange)

Tuple Fields of CovergroupValueRange

0: &'a CovergroupValueRange

CovergroupValueRangeBinary(&'a CovergroupValueRangeBinary)

Tuple Fields of CovergroupValueRangeBinary

0: &'a CovergroupValueRangeBinary

WithCovergroupExpression(&'a WithCovergroupExpression)

Tuple Fields of WithCovergroupExpression

0: &'a WithCovergroupExpression

SetCovergroupExpression(&'a SetCovergroupExpression)

Tuple Fields of SetCovergroupExpression

0: &'a SetCovergroupExpression

IntegerCovergroupExpression(&'a IntegerCovergroupExpression)

Tuple Fields of IntegerCovergroupExpression

0: &'a IntegerCovergroupExpression

CrossSetExpression(&'a CrossSetExpression)

Tuple Fields of CrossSetExpression

0: &'a CrossSetExpression

CovergroupExpression(&'a CovergroupExpression)

Tuple Fields of CovergroupExpression

0: &'a CovergroupExpression

BlockItemDeclaration(&'a BlockItemDeclaration)

Tuple Fields of BlockItemDeclaration

0: &'a BlockItemDeclaration

BlockItemDeclarationData(&'a BlockItemDeclarationData)

Tuple Fields of BlockItemDeclarationData

0: &'a BlockItemDeclarationData

BlockItemDeclarationLocalParameter(&'a BlockItemDeclarationLocalParameter)

Tuple Fields of BlockItemDeclarationLocalParameter

0: &'a BlockItemDeclarationLocalParameter

BlockItemDeclarationParameter(&'a BlockItemDeclarationParameter)

Tuple Fields of BlockItemDeclarationParameter

0: &'a BlockItemDeclarationParameter

BlockItemDeclarationLet(&'a BlockItemDeclarationLet)

Tuple Fields of BlockItemDeclarationLet

0: &'a BlockItemDeclarationLet

Delay3(&'a Delay3)

Tuple Fields of Delay3

0: &'a Delay3

Delay3Single(&'a Delay3Single)

Tuple Fields of Delay3Single

0: &'a Delay3Single

Delay3Mintypmax(&'a Delay3Mintypmax)

Tuple Fields of Delay3Mintypmax

0: &'a Delay3Mintypmax

Delay2(&'a Delay2)

Tuple Fields of Delay2

0: &'a Delay2

Delay2Single(&'a Delay2Single)

Tuple Fields of Delay2Single

0: &'a Delay2Single

Delay2Mintypmax(&'a Delay2Mintypmax)

Tuple Fields of Delay2Mintypmax

0: &'a Delay2Mintypmax

DelayValue(&'a DelayValue)

Tuple Fields of DelayValue

0: &'a DelayValue

ModportDeclaration(&'a ModportDeclaration)

Tuple Fields of ModportDeclaration

0: &'a ModportDeclaration

ModportItem(&'a ModportItem)

Tuple Fields of ModportItem

0: &'a ModportItem

ModportPortsDeclaration(&'a ModportPortsDeclaration)

Tuple Fields of ModportPortsDeclaration

0: &'a ModportPortsDeclaration

ModportPortsDeclarationSimple(&'a ModportPortsDeclarationSimple)

Tuple Fields of ModportPortsDeclarationSimple

0: &'a ModportPortsDeclarationSimple

ModportPortsDeclarationTf(&'a ModportPortsDeclarationTf)

Tuple Fields of ModportPortsDeclarationTf

0: &'a ModportPortsDeclarationTf

ModportPortsDeclarationClocking(&'a ModportPortsDeclarationClocking)

Tuple Fields of ModportPortsDeclarationClocking

0: &'a ModportPortsDeclarationClocking

ModportClockingDeclaration(&'a ModportClockingDeclaration)

Tuple Fields of ModportClockingDeclaration

0: &'a ModportClockingDeclaration

ModportSimplePortsDeclaration(&'a ModportSimplePortsDeclaration)

Tuple Fields of ModportSimplePortsDeclaration

0: &'a ModportSimplePortsDeclaration

ModportSimplePort(&'a ModportSimplePort)

Tuple Fields of ModportSimplePort

0: &'a ModportSimplePort

ModportSimplePortOrdered(&'a ModportSimplePortOrdered)

Tuple Fields of ModportSimplePortOrdered

0: &'a ModportSimplePortOrdered

ModportSimplePortNamed(&'a ModportSimplePortNamed)

Tuple Fields of ModportSimplePortNamed

0: &'a ModportSimplePortNamed

ModportTfPortsDeclaration(&'a ModportTfPortsDeclaration)

Tuple Fields of ModportTfPortsDeclaration

0: &'a ModportTfPortsDeclaration

ModportTfPort(&'a ModportTfPort)

Tuple Fields of ModportTfPort

0: &'a ModportTfPort

ImportExport(&'a ImportExport)

Tuple Fields of ImportExport

0: &'a ImportExport

CastingType(&'a CastingType)

Tuple Fields of CastingType

0: &'a CastingType

DataType(&'a DataType)

Tuple Fields of DataType

0: &'a DataType

DataTypeVector(&'a DataTypeVector)

Tuple Fields of DataTypeVector

0: &'a DataTypeVector

DataTypeAtom(&'a DataTypeAtom)

Tuple Fields of DataTypeAtom

0: &'a DataTypeAtom

DataTypeStructUnion(&'a DataTypeStructUnion)

Tuple Fields of DataTypeStructUnion

0: &'a DataTypeStructUnion

Packed(&'a Packed)

Tuple Fields of Packed

0: &'a Packed

DataTypeEnum(&'a DataTypeEnum)

Tuple Fields of DataTypeEnum

0: &'a DataTypeEnum

DataTypeVirtual(&'a DataTypeVirtual)

Tuple Fields of DataTypeVirtual

0: &'a DataTypeVirtual

Interface(&'a Interface)

Tuple Fields of Interface

0: &'a Interface

DataTypeType(&'a DataTypeType)

Tuple Fields of DataTypeType

0: &'a DataTypeType

DataTypeOrImplicit(&'a DataTypeOrImplicit)

Tuple Fields of DataTypeOrImplicit

0: &'a DataTypeOrImplicit

ImplicitDataType(&'a ImplicitDataType)

Tuple Fields of ImplicitDataType

0: &'a ImplicitDataType

EnumBaseType(&'a EnumBaseType)

Tuple Fields of EnumBaseType

0: &'a EnumBaseType

EnumBaseTypeAtom(&'a EnumBaseTypeAtom)

Tuple Fields of EnumBaseTypeAtom

0: &'a EnumBaseTypeAtom

EnumBaseTypeVector(&'a EnumBaseTypeVector)

Tuple Fields of EnumBaseTypeVector

0: &'a EnumBaseTypeVector

EnumBaseTypeType(&'a EnumBaseTypeType)

Tuple Fields of EnumBaseTypeType

0: &'a EnumBaseTypeType

EnumNameDeclaration(&'a EnumNameDeclaration)

Tuple Fields of EnumNameDeclaration

0: &'a EnumNameDeclaration

ClassScope(&'a ClassScope)

Tuple Fields of ClassScope

0: &'a ClassScope

ClassType(&'a ClassType)

Tuple Fields of ClassType

0: &'a ClassType

IntegerType(&'a IntegerType)

Tuple Fields of IntegerType

0: &'a IntegerType

IntegerAtomType(&'a IntegerAtomType)

Tuple Fields of IntegerAtomType

0: &'a IntegerAtomType

IntegerVectorType(&'a IntegerVectorType)

Tuple Fields of IntegerVectorType

0: &'a IntegerVectorType

NonIntegerType(&'a NonIntegerType)

Tuple Fields of NonIntegerType

0: &'a NonIntegerType

NetType(&'a NetType)

Tuple Fields of NetType

0: &'a NetType

NetPortType(&'a NetPortType)

Tuple Fields of NetPortType

0: &'a NetPortType

NetPortTypeDataType(&'a NetPortTypeDataType)

Tuple Fields of NetPortTypeDataType

0: &'a NetPortTypeDataType

NetPortTypeInterconnect(&'a NetPortTypeInterconnect)

Tuple Fields of NetPortTypeInterconnect

0: &'a NetPortTypeInterconnect

VariablePortType(&'a VariablePortType)

Tuple Fields of VariablePortType

0: &'a VariablePortType

VarDataType(&'a VarDataType)

Tuple Fields of VarDataType

0: &'a VarDataType

VarDataTypeVar(&'a VarDataTypeVar)

Tuple Fields of VarDataTypeVar

0: &'a VarDataTypeVar

Signing(&'a Signing)

Tuple Fields of Signing

0: &'a Signing

SimpleType(&'a SimpleType)

Tuple Fields of SimpleType

0: &'a SimpleType

StructUnionMember(&'a StructUnionMember)

Tuple Fields of StructUnionMember

0: &'a StructUnionMember

DataTypeOrVoid(&'a DataTypeOrVoid)

Tuple Fields of DataTypeOrVoid

0: &'a DataTypeOrVoid

StructUnion(&'a StructUnion)

Tuple Fields of StructUnion

0: &'a StructUnion

TypeReference(&'a TypeReference)

Tuple Fields of TypeReference

0: &'a TypeReference

TypeReferenceExpression(&'a TypeReferenceExpression)

Tuple Fields of TypeReferenceExpression

0: &'a TypeReferenceExpression

TypeReferenceDataType(&'a TypeReferenceDataType)

Tuple Fields of TypeReferenceDataType

0: &'a TypeReferenceDataType

FunctionDataTypeOrImplicit(&'a FunctionDataTypeOrImplicit)

Tuple Fields of FunctionDataTypeOrImplicit

0: &'a FunctionDataTypeOrImplicit

FunctionDeclaration(&'a FunctionDeclaration)

Tuple Fields of FunctionDeclaration

0: &'a FunctionDeclaration

FunctionBodyDeclaration(&'a FunctionBodyDeclaration)

Tuple Fields of FunctionBodyDeclaration

0: &'a FunctionBodyDeclaration

FunctionBodyDeclarationWithoutPort(&'a FunctionBodyDeclarationWithoutPort)

Tuple Fields of FunctionBodyDeclarationWithoutPort

0: &'a FunctionBodyDeclarationWithoutPort

FunctionBodyDeclarationWithPort(&'a FunctionBodyDeclarationWithPort)

Tuple Fields of FunctionBodyDeclarationWithPort

0: &'a FunctionBodyDeclarationWithPort

InterfaceIdentifierOrClassScope(&'a InterfaceIdentifierOrClassScope)

Tuple Fields of InterfaceIdentifierOrClassScope

0: &'a InterfaceIdentifierOrClassScope

FunctionPrototype(&'a FunctionPrototype)

Tuple Fields of FunctionPrototype

0: &'a FunctionPrototype

DpiImportExport(&'a DpiImportExport)

Tuple Fields of DpiImportExport

0: &'a DpiImportExport

DpiImportExportImportFunction(&'a DpiImportExportImportFunction)

Tuple Fields of DpiImportExportImportFunction

0: &'a DpiImportExportImportFunction

DpiImportExportImportTask(&'a DpiImportExportImportTask)

Tuple Fields of DpiImportExportImportTask

0: &'a DpiImportExportImportTask

DpiImportExportExportFunction(&'a DpiImportExportExportFunction)

Tuple Fields of DpiImportExportExportFunction

0: &'a DpiImportExportExportFunction

DpiImportExportExportTask(&'a DpiImportExportExportTask)

Tuple Fields of DpiImportExportExportTask

0: &'a DpiImportExportExportTask

DpiSpecString(&'a DpiSpecString)

Tuple Fields of DpiSpecString

0: &'a DpiSpecString

DpiFunctionImportProperty(&'a DpiFunctionImportProperty)

Tuple Fields of DpiFunctionImportProperty

0: &'a DpiFunctionImportProperty

DpiTaskImportProperty(&'a DpiTaskImportProperty)

Tuple Fields of DpiTaskImportProperty

0: &'a DpiTaskImportProperty

DpiFunctionProto(&'a DpiFunctionProto)

Tuple Fields of DpiFunctionProto

0: &'a DpiFunctionProto

DpiTaskProto(&'a DpiTaskProto)

Tuple Fields of DpiTaskProto

0: &'a DpiTaskProto

Symbol(&'a Symbol)

Tuple Fields of Symbol

0: &'a Symbol

Keyword(&'a Keyword)

Tuple Fields of Keyword

0: &'a Keyword

WhiteSpace(&'a WhiteSpace)

Tuple Fields of WhiteSpace

0: &'a WhiteSpace

TimingCheckEvent(&'a TimingCheckEvent)

Tuple Fields of TimingCheckEvent

0: &'a TimingCheckEvent

ControlledTimingCheckEvent(&'a ControlledTimingCheckEvent)

Tuple Fields of ControlledTimingCheckEvent

0: &'a ControlledTimingCheckEvent

TimingCheckEventControl(&'a TimingCheckEventControl)

Tuple Fields of TimingCheckEventControl

0: &'a TimingCheckEventControl

SpecifyTerminalDescriptor(&'a SpecifyTerminalDescriptor)

Tuple Fields of SpecifyTerminalDescriptor

0: &'a SpecifyTerminalDescriptor

EdgeControlSpecifier(&'a EdgeControlSpecifier)

Tuple Fields of EdgeControlSpecifier

0: &'a EdgeControlSpecifier

EdgeDescriptor(&'a EdgeDescriptor)

Tuple Fields of EdgeDescriptor

0: &'a EdgeDescriptor

TimingCheckCondition(&'a TimingCheckCondition)

Tuple Fields of TimingCheckCondition

0: &'a TimingCheckCondition

TimingCheckConditionParen(&'a TimingCheckConditionParen)

Tuple Fields of TimingCheckConditionParen

0: &'a TimingCheckConditionParen

ScalarTimingCheckCondition(&'a ScalarTimingCheckCondition)

Tuple Fields of ScalarTimingCheckCondition

0: &'a ScalarTimingCheckCondition

ScalarTimingCheckConditionUnary(&'a ScalarTimingCheckConditionUnary)

Tuple Fields of ScalarTimingCheckConditionUnary

0: &'a ScalarTimingCheckConditionUnary

ScalarTimingCheckConditionBinary(&'a ScalarTimingCheckConditionBinary)

Tuple Fields of ScalarTimingCheckConditionBinary

0: &'a ScalarTimingCheckConditionBinary

ScalarConstant(&'a ScalarConstant)

Tuple Fields of ScalarConstant

0: &'a ScalarConstant

SpecifyBlock(&'a SpecifyBlock)

Tuple Fields of SpecifyBlock

0: &'a SpecifyBlock

SpecifyItem(&'a SpecifyItem)

Tuple Fields of SpecifyItem

0: &'a SpecifyItem

PulsestyleDeclaration(&'a PulsestyleDeclaration)

Tuple Fields of PulsestyleDeclaration

0: &'a PulsestyleDeclaration

ShowcancelledDeclaration(&'a ShowcancelledDeclaration)

Tuple Fields of ShowcancelledDeclaration

0: &'a ShowcancelledDeclaration

SystemTimingCheck(&'a SystemTimingCheck)

Tuple Fields of SystemTimingCheck

0: &'a SystemTimingCheck

SetupTimingCheck(&'a SetupTimingCheck)

Tuple Fields of SetupTimingCheck

0: &'a SetupTimingCheck

HoldTimingCheck(&'a HoldTimingCheck)

Tuple Fields of HoldTimingCheck

0: &'a HoldTimingCheck

SetupholdTimingCheck(&'a SetupholdTimingCheck)

Tuple Fields of SetupholdTimingCheck

0: &'a SetupholdTimingCheck

RecoveryTimingCheck(&'a RecoveryTimingCheck)

Tuple Fields of RecoveryTimingCheck

0: &'a RecoveryTimingCheck

RemovalTimingCheck(&'a RemovalTimingCheck)

Tuple Fields of RemovalTimingCheck

0: &'a RemovalTimingCheck

RecremTimingCheck(&'a RecremTimingCheck)

Tuple Fields of RecremTimingCheck

0: &'a RecremTimingCheck

SkewTimingCheck(&'a SkewTimingCheck)

Tuple Fields of SkewTimingCheck

0: &'a SkewTimingCheck

TimeskewTimingCheck(&'a TimeskewTimingCheck)

Tuple Fields of TimeskewTimingCheck

0: &'a TimeskewTimingCheck

FullskewTimingCheck(&'a FullskewTimingCheck)

Tuple Fields of FullskewTimingCheck

0: &'a FullskewTimingCheck

PeriodTimingCheck(&'a PeriodTimingCheck)

Tuple Fields of PeriodTimingCheck

0: &'a PeriodTimingCheck

WidthTimingCheck(&'a WidthTimingCheck)

Tuple Fields of WidthTimingCheck

0: &'a WidthTimingCheck

NochangeTimingCheck(&'a NochangeTimingCheck)

Tuple Fields of NochangeTimingCheck

0: &'a NochangeTimingCheck

PathDelayValue(&'a PathDelayValue)

Tuple Fields of PathDelayValue

0: &'a PathDelayValue

PathDelayValueParen(&'a PathDelayValueParen)

Tuple Fields of PathDelayValueParen

0: &'a PathDelayValueParen

ListOfPathDelayExpressions(&'a ListOfPathDelayExpressions)

Tuple Fields of ListOfPathDelayExpressions

0: &'a ListOfPathDelayExpressions

TPathDelayExpression(&'a TPathDelayExpression)

Tuple Fields of TPathDelayExpression

0: &'a TPathDelayExpression

PathDelayExpression(&'a PathDelayExpression)

Tuple Fields of PathDelayExpression

0: &'a PathDelayExpression

EdgeSensitivePathDeclaration(&'a EdgeSensitivePathDeclaration)

Tuple Fields of EdgeSensitivePathDeclaration

0: &'a EdgeSensitivePathDeclaration

EdgeSensitivePathDeclarationParallel(&'a EdgeSensitivePathDeclarationParallel)

Tuple Fields of EdgeSensitivePathDeclarationParallel

0: &'a EdgeSensitivePathDeclarationParallel

EdgeSensitivePathDeclarationFull(&'a EdgeSensitivePathDeclarationFull)

Tuple Fields of EdgeSensitivePathDeclarationFull

0: &'a EdgeSensitivePathDeclarationFull

ParallelEdgeSensitivePathDescription(&'a ParallelEdgeSensitivePathDescription)

Tuple Fields of ParallelEdgeSensitivePathDescription

0: &'a ParallelEdgeSensitivePathDescription

FullEdgeSensitivePathDescription(&'a FullEdgeSensitivePathDescription)

Tuple Fields of FullEdgeSensitivePathDescription

0: &'a FullEdgeSensitivePathDescription

DataSourceExpression(&'a DataSourceExpression)

Tuple Fields of DataSourceExpression

0: &'a DataSourceExpression

EdgeIdentifier(&'a EdgeIdentifier)

Tuple Fields of EdgeIdentifier

0: &'a EdgeIdentifier

StateDependentPathDeclaration(&'a StateDependentPathDeclaration)

Tuple Fields of StateDependentPathDeclaration

0: &'a StateDependentPathDeclaration

StateDependentPathDeclarationIfSimple(&'a StateDependentPathDeclarationIfSimple)

Tuple Fields of StateDependentPathDeclarationIfSimple

0: &'a StateDependentPathDeclarationIfSimple

StateDependentPathDeclarationIfEdgeSensitive(&'a StateDependentPathDeclarationIfEdgeSensitive)

Tuple Fields of StateDependentPathDeclarationIfEdgeSensitive

0: &'a StateDependentPathDeclarationIfEdgeSensitive

StateDependentPathDeclarationIfNone(&'a StateDependentPathDeclarationIfNone)

Tuple Fields of StateDependentPathDeclarationIfNone

0: &'a StateDependentPathDeclarationIfNone

PolarityOperator(&'a PolarityOperator)

Tuple Fields of PolarityOperator

0: &'a PolarityOperator

TimecheckCondition(&'a TimecheckCondition)

Tuple Fields of TimecheckCondition

0: &'a TimecheckCondition

ControlledReferenceEvent(&'a ControlledReferenceEvent)

Tuple Fields of ControlledReferenceEvent

0: &'a ControlledReferenceEvent

DataEvent(&'a DataEvent)

Tuple Fields of DataEvent

0: &'a DataEvent

DelayedData(&'a DelayedData)

Tuple Fields of DelayedData

0: &'a DelayedData

DelayedDataWithMintypmax(&'a DelayedDataWithMintypmax)

Tuple Fields of DelayedDataWithMintypmax

0: &'a DelayedDataWithMintypmax

DelayedReference(&'a DelayedReference)

Tuple Fields of DelayedReference

0: &'a DelayedReference

DelayedReferenceWithMintypmax(&'a DelayedReferenceWithMintypmax)

Tuple Fields of DelayedReferenceWithMintypmax

0: &'a DelayedReferenceWithMintypmax

EndEdgeOffset(&'a EndEdgeOffset)

Tuple Fields of EndEdgeOffset

0: &'a EndEdgeOffset

EventBasedFlag(&'a EventBasedFlag)

Tuple Fields of EventBasedFlag

0: &'a EventBasedFlag

Notifier(&'a Notifier)

Tuple Fields of Notifier

0: &'a Notifier

ReferenceEvent(&'a ReferenceEvent)

Tuple Fields of ReferenceEvent

0: &'a ReferenceEvent

RemainActiveFlag(&'a RemainActiveFlag)

Tuple Fields of RemainActiveFlag

0: &'a RemainActiveFlag

TimestampCondition(&'a TimestampCondition)

Tuple Fields of TimestampCondition

0: &'a TimestampCondition

StartEdgeOffset(&'a StartEdgeOffset)

Tuple Fields of StartEdgeOffset

0: &'a StartEdgeOffset

Threshold(&'a Threshold)

Tuple Fields of Threshold

0: &'a Threshold

TimingCheckLimit(&'a TimingCheckLimit)

Tuple Fields of TimingCheckLimit

0: &'a TimingCheckLimit

PathDeclaration(&'a PathDeclaration)

Tuple Fields of PathDeclaration

0: &'a PathDeclaration

SimplePathDeclaration(&'a SimplePathDeclaration)

Tuple Fields of SimplePathDeclaration

0: &'a SimplePathDeclaration

SimplePathDeclarationParallel(&'a SimplePathDeclarationParallel)

Tuple Fields of SimplePathDeclarationParallel

0: &'a SimplePathDeclarationParallel

SimplePathDeclarationFull(&'a SimplePathDeclarationFull)

Tuple Fields of SimplePathDeclarationFull

0: &'a SimplePathDeclarationFull

ParallelPathDescription(&'a ParallelPathDescription)

Tuple Fields of ParallelPathDescription

0: &'a ParallelPathDescription

FullPathDescription(&'a FullPathDescription)

Tuple Fields of FullPathDescription

0: &'a FullPathDescription

ListOfPathInputs(&'a ListOfPathInputs)

Tuple Fields of ListOfPathInputs

0: &'a ListOfPathInputs

ListOfPathOutputs(&'a ListOfPathOutputs)

Tuple Fields of ListOfPathOutputs

0: &'a ListOfPathOutputs

SpecifyInputTerminalDescriptor(&'a SpecifyInputTerminalDescriptor)

Tuple Fields of SpecifyInputTerminalDescriptor

0: &'a SpecifyInputTerminalDescriptor

SpecifyOutputTerminalDescriptor(&'a SpecifyOutputTerminalDescriptor)

Tuple Fields of SpecifyOutputTerminalDescriptor

0: &'a SpecifyOutputTerminalDescriptor

InputIdentifier(&'a InputIdentifier)

Tuple Fields of InputIdentifier

0: &'a InputIdentifier

InputIdentifierInterface(&'a InputIdentifierInterface)

Tuple Fields of InputIdentifierInterface

0: &'a InputIdentifierInterface

OutputIdentifier(&'a OutputIdentifier)

Tuple Fields of OutputIdentifier

0: &'a OutputIdentifier

OutputIdentifierInterface(&'a OutputIdentifierInterface)

Tuple Fields of OutputIdentifierInterface

0: &'a OutputIdentifierInterface

LoopStatement(&'a LoopStatement)

Tuple Fields of LoopStatement

0: &'a LoopStatement

LoopStatementForever(&'a LoopStatementForever)

Tuple Fields of LoopStatementForever

0: &'a LoopStatementForever

LoopStatementRepeat(&'a LoopStatementRepeat)

Tuple Fields of LoopStatementRepeat

0: &'a LoopStatementRepeat

LoopStatementWhile(&'a LoopStatementWhile)

Tuple Fields of LoopStatementWhile

0: &'a LoopStatementWhile

LoopStatementFor(&'a LoopStatementFor)

Tuple Fields of LoopStatementFor

0: &'a LoopStatementFor

LoopStatementDoWhile(&'a LoopStatementDoWhile)

Tuple Fields of LoopStatementDoWhile

0: &'a LoopStatementDoWhile

LoopStatementForeach(&'a LoopStatementForeach)

Tuple Fields of LoopStatementForeach

0: &'a LoopStatementForeach

ForInitialization(&'a ForInitialization)

Tuple Fields of ForInitialization

0: &'a ForInitialization

ForInitializationDeclaration(&'a ForInitializationDeclaration)

Tuple Fields of ForInitializationDeclaration

0: &'a ForInitializationDeclaration

ForVariableDeclaration(&'a ForVariableDeclaration)

Tuple Fields of ForVariableDeclaration

0: &'a ForVariableDeclaration

Var(&'a Var)

Tuple Fields of Var

0: &'a Var

ForStep(&'a ForStep)

Tuple Fields of ForStep

0: &'a ForStep

ForStepAssignment(&'a ForStepAssignment)

Tuple Fields of ForStepAssignment

0: &'a ForStepAssignment

LoopVariables(&'a LoopVariables)

Tuple Fields of LoopVariables

0: &'a LoopVariables

CaseStatement(&'a CaseStatement)

Tuple Fields of CaseStatement

0: &'a CaseStatement

CaseStatementNormal(&'a CaseStatementNormal)

Tuple Fields of CaseStatementNormal

0: &'a CaseStatementNormal

CaseStatementMatches(&'a CaseStatementMatches)

Tuple Fields of CaseStatementMatches

0: &'a CaseStatementMatches

CaseStatementInside(&'a CaseStatementInside)

Tuple Fields of CaseStatementInside

0: &'a CaseStatementInside

CaseKeyword(&'a CaseKeyword)

Tuple Fields of CaseKeyword

0: &'a CaseKeyword

CaseExpression(&'a CaseExpression)

Tuple Fields of CaseExpression

0: &'a CaseExpression

CaseItem(&'a CaseItem)

Tuple Fields of CaseItem

0: &'a CaseItem

CaseItemNondefault(&'a CaseItemNondefault)

Tuple Fields of CaseItemNondefault

0: &'a CaseItemNondefault

CaseItemDefault(&'a CaseItemDefault)

Tuple Fields of CaseItemDefault

0: &'a CaseItemDefault

CasePatternItem(&'a CasePatternItem)

Tuple Fields of CasePatternItem

0: &'a CasePatternItem

CasePatternItemNondefault(&'a CasePatternItemNondefault)

Tuple Fields of CasePatternItemNondefault

0: &'a CasePatternItemNondefault

CaseInsideItem(&'a CaseInsideItem)

Tuple Fields of CaseInsideItem

0: &'a CaseInsideItem

CaseInsideItemNondefault(&'a CaseInsideItemNondefault)

Tuple Fields of CaseInsideItemNondefault

0: &'a CaseInsideItemNondefault

CaseItemExpression(&'a CaseItemExpression)

Tuple Fields of CaseItemExpression

0: &'a CaseItemExpression

RandcaseStatement(&'a RandcaseStatement)

Tuple Fields of RandcaseStatement

0: &'a RandcaseStatement

RandcaseItem(&'a RandcaseItem)

Tuple Fields of RandcaseItem

0: &'a RandcaseItem

OpenRangeList(&'a OpenRangeList)

Tuple Fields of OpenRangeList

0: &'a OpenRangeList

OpenValueRange(&'a OpenValueRange)

Tuple Fields of OpenValueRange

0: &'a OpenValueRange

ContinuousAssign(&'a ContinuousAssign)

Tuple Fields of ContinuousAssign

0: &'a ContinuousAssign

ContinuousAssignNet(&'a ContinuousAssignNet)

Tuple Fields of ContinuousAssignNet

0: &'a ContinuousAssignNet

ContinuousAssignVariable(&'a ContinuousAssignVariable)

Tuple Fields of ContinuousAssignVariable

0: &'a ContinuousAssignVariable

ListOfNetAssignments(&'a ListOfNetAssignments)

Tuple Fields of ListOfNetAssignments

0: &'a ListOfNetAssignments

ListOfVariableAssignments(&'a ListOfVariableAssignments)

Tuple Fields of ListOfVariableAssignments

0: &'a ListOfVariableAssignments

NetAlias(&'a NetAlias)

Tuple Fields of NetAlias

0: &'a NetAlias

NetAssignment(&'a NetAssignment)

Tuple Fields of NetAssignment

0: &'a NetAssignment

ConditionalStatement(&'a ConditionalStatement)

Tuple Fields of ConditionalStatement

0: &'a ConditionalStatement

UniquePriority(&'a UniquePriority)

Tuple Fields of UniquePriority

0: &'a UniquePriority

CondPredicate(&'a CondPredicate)

Tuple Fields of CondPredicate

0: &'a CondPredicate

ExpressionOrCondPattern(&'a ExpressionOrCondPattern)

Tuple Fields of ExpressionOrCondPattern

0: &'a ExpressionOrCondPattern

CondPattern(&'a CondPattern)

Tuple Fields of CondPattern

0: &'a CondPattern

ProceduralTimingControlStatement(&'a ProceduralTimingControlStatement)

Tuple Fields of ProceduralTimingControlStatement

0: &'a ProceduralTimingControlStatement

DelayOrEventControl(&'a DelayOrEventControl)

Tuple Fields of DelayOrEventControl

0: &'a DelayOrEventControl

DelayOrEventControlRepeat(&'a DelayOrEventControlRepeat)

Tuple Fields of DelayOrEventControlRepeat

0: &'a DelayOrEventControlRepeat

DelayControl(&'a DelayControl)

Tuple Fields of DelayControl

0: &'a DelayControl

DelayControlDelay(&'a DelayControlDelay)

Tuple Fields of DelayControlDelay

0: &'a DelayControlDelay

DelayControlMintypmax(&'a DelayControlMintypmax)

Tuple Fields of DelayControlMintypmax

0: &'a DelayControlMintypmax

EventControl(&'a EventControl)

Tuple Fields of EventControl

0: &'a EventControl

EventControlEventIdentifier(&'a EventControlEventIdentifier)

Tuple Fields of EventControlEventIdentifier

0: &'a EventControlEventIdentifier

EventControlEventExpression(&'a EventControlEventExpression)

Tuple Fields of EventControlEventExpression

0: &'a EventControlEventExpression

EventControlAsterisk(&'a EventControlAsterisk)

Tuple Fields of EventControlAsterisk

0: &'a EventControlAsterisk

EventControlParenAsterisk(&'a EventControlParenAsterisk)

Tuple Fields of EventControlParenAsterisk

0: &'a EventControlParenAsterisk

EventControlSequenceIdentifier(&'a EventControlSequenceIdentifier)

Tuple Fields of EventControlSequenceIdentifier

0: &'a EventControlSequenceIdentifier

EventExpression(&'a EventExpression)

Tuple Fields of EventExpression

0: &'a EventExpression

EventExpressionExpression(&'a EventExpressionExpression)

Tuple Fields of EventExpressionExpression

0: &'a EventExpressionExpression

EventExpressionSequence(&'a EventExpressionSequence)

Tuple Fields of EventExpressionSequence

0: &'a EventExpressionSequence

EventExpressionOr(&'a EventExpressionOr)

Tuple Fields of EventExpressionOr

0: &'a EventExpressionOr

EventExpressionComma(&'a EventExpressionComma)

Tuple Fields of EventExpressionComma

0: &'a EventExpressionComma

EventExpressionParen(&'a EventExpressionParen)

Tuple Fields of EventExpressionParen

0: &'a EventExpressionParen

ProceduralTimingControl(&'a ProceduralTimingControl)

Tuple Fields of ProceduralTimingControl

0: &'a ProceduralTimingControl

JumpStatement(&'a JumpStatement)

Tuple Fields of JumpStatement

0: &'a JumpStatement

JumpStatementReturn(&'a JumpStatementReturn)

Tuple Fields of JumpStatementReturn

0: &'a JumpStatementReturn

JumpStatementBreak(&'a JumpStatementBreak)

Tuple Fields of JumpStatementBreak

0: &'a JumpStatementBreak

JumpStatementContinue(&'a JumpStatementContinue)

Tuple Fields of JumpStatementContinue

0: &'a JumpStatementContinue

WaitStatement(&'a WaitStatement)

Tuple Fields of WaitStatement

0: &'a WaitStatement

WaitStatementWait(&'a WaitStatementWait)

Tuple Fields of WaitStatementWait

0: &'a WaitStatementWait

WaitStatementFork(&'a WaitStatementFork)

Tuple Fields of WaitStatementFork

0: &'a WaitStatementFork

WaitStatementOrder(&'a WaitStatementOrder)

Tuple Fields of WaitStatementOrder

0: &'a WaitStatementOrder

EventTrigger(&'a EventTrigger)

Tuple Fields of EventTrigger

0: &'a EventTrigger

EventTriggerNamed(&'a EventTriggerNamed)

Tuple Fields of EventTriggerNamed

0: &'a EventTriggerNamed

EventTriggerNonblocking(&'a EventTriggerNonblocking)

Tuple Fields of EventTriggerNonblocking

0: &'a EventTriggerNonblocking

DisableStatement(&'a DisableStatement)

Tuple Fields of DisableStatement

0: &'a DisableStatement

DisableStatementTask(&'a DisableStatementTask)

Tuple Fields of DisableStatementTask

0: &'a DisableStatementTask

DisableStatementBlock(&'a DisableStatementBlock)

Tuple Fields of DisableStatementBlock

0: &'a DisableStatementBlock

DisableStatementFork(&'a DisableStatementFork)

Tuple Fields of DisableStatementFork

0: &'a DisableStatementFork

RandsequenceStatement(&'a RandsequenceStatement)

Tuple Fields of RandsequenceStatement

0: &'a RandsequenceStatement

Production(&'a Production)

Tuple Fields of Production

0: &'a Production

RsRule(&'a RsRule)

Tuple Fields of RsRule

0: &'a RsRule

RsProductionList(&'a RsProductionList)

Tuple Fields of RsProductionList

0: &'a RsProductionList

RsProductionListProd(&'a RsProductionListProd)

Tuple Fields of RsProductionListProd

0: &'a RsProductionListProd

RsProductionListJoin(&'a RsProductionListJoin)

Tuple Fields of RsProductionListJoin

0: &'a RsProductionListJoin

WeightSpecification(&'a WeightSpecification)

Tuple Fields of WeightSpecification

0: &'a WeightSpecification

WeightSpecificationExpression(&'a WeightSpecificationExpression)

Tuple Fields of WeightSpecificationExpression

0: &'a WeightSpecificationExpression

RsCodeBlock(&'a RsCodeBlock)

Tuple Fields of RsCodeBlock

0: &'a RsCodeBlock

RsProd(&'a RsProd)

Tuple Fields of RsProd

0: &'a RsProd

ProductionItem(&'a ProductionItem)

Tuple Fields of ProductionItem

0: &'a ProductionItem

RsIfElse(&'a RsIfElse)

Tuple Fields of RsIfElse

0: &'a RsIfElse

RsRepeat(&'a RsRepeat)

Tuple Fields of RsRepeat

0: &'a RsRepeat

RsCase(&'a RsCase)

Tuple Fields of RsCase

0: &'a RsCase

RsCaseItem(&'a RsCaseItem)

Tuple Fields of RsCaseItem

0: &'a RsCaseItem

RsCaseItemNondefault(&'a RsCaseItemNondefault)

Tuple Fields of RsCaseItemNondefault

0: &'a RsCaseItemNondefault

RsCaseItemDefault(&'a RsCaseItemDefault)

Tuple Fields of RsCaseItemDefault

0: &'a RsCaseItemDefault

Pattern(&'a Pattern)

Tuple Fields of Pattern

0: &'a Pattern

PatternVariable(&'a PatternVariable)

Tuple Fields of PatternVariable

0: &'a PatternVariable

PatternTagged(&'a PatternTagged)

Tuple Fields of PatternTagged

0: &'a PatternTagged

PatternList(&'a PatternList)

Tuple Fields of PatternList

0: &'a PatternList

PatternIdentifierList(&'a PatternIdentifierList)

Tuple Fields of PatternIdentifierList

0: &'a PatternIdentifierList

AssignmentPattern(&'a AssignmentPattern)

Tuple Fields of AssignmentPattern

0: &'a AssignmentPattern

AssignmentPatternList(&'a AssignmentPatternList)

Tuple Fields of AssignmentPatternList

0: &'a AssignmentPatternList

AssignmentPatternStructure(&'a AssignmentPatternStructure)

Tuple Fields of AssignmentPatternStructure

0: &'a AssignmentPatternStructure

AssignmentPatternArray(&'a AssignmentPatternArray)

Tuple Fields of AssignmentPatternArray

0: &'a AssignmentPatternArray

AssignmentPatternRepeat(&'a AssignmentPatternRepeat)

Tuple Fields of AssignmentPatternRepeat

0: &'a AssignmentPatternRepeat

StructurePatternKey(&'a StructurePatternKey)

Tuple Fields of StructurePatternKey

0: &'a StructurePatternKey

ArrayPatternKey(&'a ArrayPatternKey)

Tuple Fields of ArrayPatternKey

0: &'a ArrayPatternKey

AssignmentPatternKey(&'a AssignmentPatternKey)

Tuple Fields of AssignmentPatternKey

0: &'a AssignmentPatternKey

AssignmentPatternExpression(&'a AssignmentPatternExpression)

Tuple Fields of AssignmentPatternExpression

0: &'a AssignmentPatternExpression

AssignmentPatternExpressionType(&'a AssignmentPatternExpressionType)

Tuple Fields of AssignmentPatternExpressionType

0: &'a AssignmentPatternExpressionType

ConstantAssignmentPatternExpression(&'a ConstantAssignmentPatternExpression)

Tuple Fields of ConstantAssignmentPatternExpression

0: &'a ConstantAssignmentPatternExpression

AssignmentPatternNetLvalue(&'a AssignmentPatternNetLvalue)

Tuple Fields of AssignmentPatternNetLvalue

0: &'a AssignmentPatternNetLvalue

AssignmentPatternVariableLvalue(&'a AssignmentPatternVariableLvalue)

Tuple Fields of AssignmentPatternVariableLvalue

0: &'a AssignmentPatternVariableLvalue

AssertionItem(&'a AssertionItem)

Tuple Fields of AssertionItem

0: &'a AssertionItem

DeferredImmediateAssetionItem(&'a DeferredImmediateAssetionItem)

Tuple Fields of DeferredImmediateAssetionItem

0: &'a DeferredImmediateAssetionItem

ProceduralAssertionStatement(&'a ProceduralAssertionStatement)

Tuple Fields of ProceduralAssertionStatement

0: &'a ProceduralAssertionStatement

ImmediateAssetionStatement(&'a ImmediateAssetionStatement)

Tuple Fields of ImmediateAssetionStatement

0: &'a ImmediateAssetionStatement

SimpleImmediateAssertionStatement(&'a SimpleImmediateAssertionStatement)

Tuple Fields of SimpleImmediateAssertionStatement

0: &'a SimpleImmediateAssertionStatement

SimpleImmediateAssertStatement(&'a SimpleImmediateAssertStatement)

Tuple Fields of SimpleImmediateAssertStatement

0: &'a SimpleImmediateAssertStatement

SimpleImmediateAssumeStatement(&'a SimpleImmediateAssumeStatement)

Tuple Fields of SimpleImmediateAssumeStatement

0: &'a SimpleImmediateAssumeStatement

SimpleImmediateCoverStatement(&'a SimpleImmediateCoverStatement)

Tuple Fields of SimpleImmediateCoverStatement

0: &'a SimpleImmediateCoverStatement

DeferredImmediateAssertionStatement(&'a DeferredImmediateAssertionStatement)

Tuple Fields of DeferredImmediateAssertionStatement

0: &'a DeferredImmediateAssertionStatement

DeferredImmediateAssertStatement(&'a DeferredImmediateAssertStatement)

Tuple Fields of DeferredImmediateAssertStatement

0: &'a DeferredImmediateAssertStatement

DeferredImmediateAssumeStatement(&'a DeferredImmediateAssumeStatement)

Tuple Fields of DeferredImmediateAssumeStatement

0: &'a DeferredImmediateAssumeStatement

DeferredImmediateCoverStatement(&'a DeferredImmediateCoverStatement)

Tuple Fields of DeferredImmediateCoverStatement

0: &'a DeferredImmediateCoverStatement

AssertTiming(&'a AssertTiming)

Tuple Fields of AssertTiming

0: &'a AssertTiming

InitialConstruct(&'a InitialConstruct)

Tuple Fields of InitialConstruct

0: &'a InitialConstruct

AlwaysConstruct(&'a AlwaysConstruct)

Tuple Fields of AlwaysConstruct

0: &'a AlwaysConstruct

AlwaysKeyword(&'a AlwaysKeyword)

Tuple Fields of AlwaysKeyword

0: &'a AlwaysKeyword

FinalConstruct(&'a FinalConstruct)

Tuple Fields of FinalConstruct

0: &'a FinalConstruct

BlockingAssignment(&'a BlockingAssignment)

Tuple Fields of BlockingAssignment

0: &'a BlockingAssignment

BlockingAssignmentVariable(&'a BlockingAssignmentVariable)

Tuple Fields of BlockingAssignmentVariable

0: &'a BlockingAssignmentVariable

BlockingAssignmentNonrangeVariable(&'a BlockingAssignmentNonrangeVariable)

Tuple Fields of BlockingAssignmentNonrangeVariable

0: &'a BlockingAssignmentNonrangeVariable

BlockingAssignmentHierarchicalVariable(&'a BlockingAssignmentHierarchicalVariable)

Tuple Fields of BlockingAssignmentHierarchicalVariable

0: &'a BlockingAssignmentHierarchicalVariable

OperatorAssignment(&'a OperatorAssignment)

Tuple Fields of OperatorAssignment

0: &'a OperatorAssignment

AssignmentOperator(&'a AssignmentOperator)

Tuple Fields of AssignmentOperator

0: &'a AssignmentOperator

NonblockingAssignment(&'a NonblockingAssignment)

Tuple Fields of NonblockingAssignment

0: &'a NonblockingAssignment

ProceduralContinuousAssignment(&'a ProceduralContinuousAssignment)

Tuple Fields of ProceduralContinuousAssignment

0: &'a ProceduralContinuousAssignment

ProceduralContinuousAssignmentAssign(&'a ProceduralContinuousAssignmentAssign)

Tuple Fields of ProceduralContinuousAssignmentAssign

0: &'a ProceduralContinuousAssignmentAssign

ProceduralContinuousAssignmentDeassign(&'a ProceduralContinuousAssignmentDeassign)

Tuple Fields of ProceduralContinuousAssignmentDeassign

0: &'a ProceduralContinuousAssignmentDeassign

ProceduralContinuousAssignmentForceVariable(&'a ProceduralContinuousAssignmentForceVariable)

Tuple Fields of ProceduralContinuousAssignmentForceVariable

0: &'a ProceduralContinuousAssignmentForceVariable

ProceduralContinuousAssignmentForceNet(&'a ProceduralContinuousAssignmentForceNet)

Tuple Fields of ProceduralContinuousAssignmentForceNet

0: &'a ProceduralContinuousAssignmentForceNet

ProceduralContinuousAssignmentReleaseVariable(&'a ProceduralContinuousAssignmentReleaseVariable)

Tuple Fields of ProceduralContinuousAssignmentReleaseVariable

0: &'a ProceduralContinuousAssignmentReleaseVariable

ProceduralContinuousAssignmentReleaseNet(&'a ProceduralContinuousAssignmentReleaseNet)

Tuple Fields of ProceduralContinuousAssignmentReleaseNet

0: &'a ProceduralContinuousAssignmentReleaseNet

VariableAssignment(&'a VariableAssignment)

Tuple Fields of VariableAssignment

0: &'a VariableAssignment

SubroutineCallStatement(&'a SubroutineCallStatement)

Tuple Fields of SubroutineCallStatement

0: &'a SubroutineCallStatement

SubroutineCallStatementFunction(&'a SubroutineCallStatementFunction)

Tuple Fields of SubroutineCallStatementFunction

0: &'a SubroutineCallStatementFunction

ClockingDeclaration(&'a ClockingDeclaration)

Tuple Fields of ClockingDeclaration

0: &'a ClockingDeclaration

ClockingDeclarationLocal(&'a ClockingDeclarationLocal)

Tuple Fields of ClockingDeclarationLocal

0: &'a ClockingDeclarationLocal

Default(&'a Default)

Tuple Fields of Default

0: &'a Default

ClockingDeclarationGlobal(&'a ClockingDeclarationGlobal)

Tuple Fields of ClockingDeclarationGlobal

0: &'a ClockingDeclarationGlobal

ClockingEvent(&'a ClockingEvent)

Tuple Fields of ClockingEvent

0: &'a ClockingEvent

ClockingEventIdentifier(&'a ClockingEventIdentifier)

Tuple Fields of ClockingEventIdentifier

0: &'a ClockingEventIdentifier

ClockingEventExpression(&'a ClockingEventExpression)

Tuple Fields of ClockingEventExpression

0: &'a ClockingEventExpression

ClockingItem(&'a ClockingItem)

Tuple Fields of ClockingItem

0: &'a ClockingItem

ClockingItemDefault(&'a ClockingItemDefault)

Tuple Fields of ClockingItemDefault

0: &'a ClockingItemDefault

ClockingItemDirection(&'a ClockingItemDirection)

Tuple Fields of ClockingItemDirection

0: &'a ClockingItemDirection

ClockingItemAssertion(&'a ClockingItemAssertion)

Tuple Fields of ClockingItemAssertion

0: &'a ClockingItemAssertion

DefaultSkew(&'a DefaultSkew)

Tuple Fields of DefaultSkew

0: &'a DefaultSkew

DefaultSkewInput(&'a DefaultSkewInput)

Tuple Fields of DefaultSkewInput

0: &'a DefaultSkewInput

DefaultSkewOutput(&'a DefaultSkewOutput)

Tuple Fields of DefaultSkewOutput

0: &'a DefaultSkewOutput

DefaultSkewInputOutput(&'a DefaultSkewInputOutput)

Tuple Fields of DefaultSkewInputOutput

0: &'a DefaultSkewInputOutput

ClockingDirection(&'a ClockingDirection)

Tuple Fields of ClockingDirection

0: &'a ClockingDirection

ClockingDirectionInput(&'a ClockingDirectionInput)

Tuple Fields of ClockingDirectionInput

0: &'a ClockingDirectionInput

ClockingDirectionOutput(&'a ClockingDirectionOutput)

Tuple Fields of ClockingDirectionOutput

0: &'a ClockingDirectionOutput

ClockingDirectionInputOutput(&'a ClockingDirectionInputOutput)

Tuple Fields of ClockingDirectionInputOutput

0: &'a ClockingDirectionInputOutput

ListOfClockingDeclAssign(&'a ListOfClockingDeclAssign)

Tuple Fields of ListOfClockingDeclAssign

0: &'a ListOfClockingDeclAssign

ClockingDeclAssign(&'a ClockingDeclAssign)

Tuple Fields of ClockingDeclAssign

0: &'a ClockingDeclAssign

ClockingSkew(&'a ClockingSkew)

Tuple Fields of ClockingSkew

0: &'a ClockingSkew

ClockingSkewEdge(&'a ClockingSkewEdge)

Tuple Fields of ClockingSkewEdge

0: &'a ClockingSkewEdge

ClockingDrive(&'a ClockingDrive)

Tuple Fields of ClockingDrive

0: &'a ClockingDrive

CycleDelay(&'a CycleDelay)

Tuple Fields of CycleDelay

0: &'a CycleDelay

CycleDelayIntegral(&'a CycleDelayIntegral)

Tuple Fields of CycleDelayIntegral

0: &'a CycleDelayIntegral

CycleDelayIdentifier(&'a CycleDelayIdentifier)

Tuple Fields of CycleDelayIdentifier

0: &'a CycleDelayIdentifier

CycleDelayExpression(&'a CycleDelayExpression)

Tuple Fields of CycleDelayExpression

0: &'a CycleDelayExpression

Clockvar(&'a Clockvar)

Tuple Fields of Clockvar

0: &'a Clockvar

ClockvarExpression(&'a ClockvarExpression)

Tuple Fields of ClockvarExpression

0: &'a ClockvarExpression

ActionBlock(&'a ActionBlock)

Tuple Fields of ActionBlock

0: &'a ActionBlock

ActionBlockElse(&'a ActionBlockElse)

Tuple Fields of ActionBlockElse

0: &'a ActionBlockElse

SeqBlock(&'a SeqBlock)

Tuple Fields of SeqBlock

0: &'a SeqBlock

ParBlock(&'a ParBlock)

Tuple Fields of ParBlock

0: &'a ParBlock

JoinKeyword(&'a JoinKeyword)

Tuple Fields of JoinKeyword

0: &'a JoinKeyword

StatementOrNull(&'a StatementOrNull)

Tuple Fields of StatementOrNull

0: &'a StatementOrNull

StatementOrNullAttribute(&'a StatementOrNullAttribute)

Tuple Fields of StatementOrNullAttribute

0: &'a StatementOrNullAttribute

Statement(&'a Statement)

Tuple Fields of Statement

0: &'a Statement

StatementItem(&'a StatementItem)

Tuple Fields of StatementItem

0: &'a StatementItem

FunctionStatement(&'a FunctionStatement)

Tuple Fields of FunctionStatement

0: &'a FunctionStatement

FunctionStatementOrNull(&'a FunctionStatementOrNull)

Tuple Fields of FunctionStatementOrNull

0: &'a FunctionStatementOrNull

FunctionStatementOrNullAttribute(&'a FunctionStatementOrNullAttribute)

Tuple Fields of FunctionStatementOrNullAttribute

0: &'a FunctionStatementOrNullAttribute

VariableIdentifierList(&'a VariableIdentifierList)

Tuple Fields of VariableIdentifierList

0: &'a VariableIdentifierList

UdpInstantiation(&'a UdpInstantiation)

Tuple Fields of UdpInstantiation

0: &'a UdpInstantiation

UdpInstance(&'a UdpInstance)

Tuple Fields of UdpInstance

0: &'a UdpInstance

UdpNonansiDeclaration(&'a UdpNonansiDeclaration)

Tuple Fields of UdpNonansiDeclaration

0: &'a UdpNonansiDeclaration

UdpAnsiDeclaration(&'a UdpAnsiDeclaration)

Tuple Fields of UdpAnsiDeclaration

0: &'a UdpAnsiDeclaration

UdpDeclaration(&'a UdpDeclaration)

Tuple Fields of UdpDeclaration

0: &'a UdpDeclaration

UdpDeclarationNonansi(&'a UdpDeclarationNonansi)

Tuple Fields of UdpDeclarationNonansi

0: &'a UdpDeclarationNonansi

UdpDeclarationAnsi(&'a UdpDeclarationAnsi)

Tuple Fields of UdpDeclarationAnsi

0: &'a UdpDeclarationAnsi

UdpDeclarationExternNonansi(&'a UdpDeclarationExternNonansi)

Tuple Fields of UdpDeclarationExternNonansi

0: &'a UdpDeclarationExternNonansi

UdpDeclarationExternAnsi(&'a UdpDeclarationExternAnsi)

Tuple Fields of UdpDeclarationExternAnsi

0: &'a UdpDeclarationExternAnsi

UdpDeclarationWildcard(&'a UdpDeclarationWildcard)

Tuple Fields of UdpDeclarationWildcard

0: &'a UdpDeclarationWildcard

UdpBody(&'a UdpBody)

Tuple Fields of UdpBody

0: &'a UdpBody

CombinationalBody(&'a CombinationalBody)

Tuple Fields of CombinationalBody

0: &'a CombinationalBody

CombinationalEntry(&'a CombinationalEntry)

Tuple Fields of CombinationalEntry

0: &'a CombinationalEntry

SequentialBody(&'a SequentialBody)

Tuple Fields of SequentialBody

0: &'a SequentialBody

UdpInitialStatement(&'a UdpInitialStatement)

Tuple Fields of UdpInitialStatement

0: &'a UdpInitialStatement

InitVal(&'a InitVal)

Tuple Fields of InitVal

0: &'a InitVal

SequentialEntry(&'a SequentialEntry)

Tuple Fields of SequentialEntry

0: &'a SequentialEntry

SeqInputList(&'a SeqInputList)

Tuple Fields of SeqInputList

0: &'a SeqInputList

LevelInputList(&'a LevelInputList)

Tuple Fields of LevelInputList

0: &'a LevelInputList

EdgeInputList(&'a EdgeInputList)

Tuple Fields of EdgeInputList

0: &'a EdgeInputList

EdgeIndicator(&'a EdgeIndicator)

Tuple Fields of EdgeIndicator

0: &'a EdgeIndicator

EdgeIndicatorParen(&'a EdgeIndicatorParen)

Tuple Fields of EdgeIndicatorParen

0: &'a EdgeIndicatorParen

CurrentState(&'a CurrentState)

Tuple Fields of CurrentState

0: &'a CurrentState

NextState(&'a NextState)

Tuple Fields of NextState

0: &'a NextState

OutputSymbol(&'a OutputSymbol)

Tuple Fields of OutputSymbol

0: &'a OutputSymbol

LevelSymbol(&'a LevelSymbol)

Tuple Fields of LevelSymbol

0: &'a LevelSymbol

EdgeSymbol(&'a EdgeSymbol)

Tuple Fields of EdgeSymbol

0: &'a EdgeSymbol

UdpPortList(&'a UdpPortList)

Tuple Fields of UdpPortList

0: &'a UdpPortList

UdpDeclarationPortList(&'a UdpDeclarationPortList)

Tuple Fields of UdpDeclarationPortList

0: &'a UdpDeclarationPortList

UdpPortDeclaration(&'a UdpPortDeclaration)

Tuple Fields of UdpPortDeclaration

0: &'a UdpPortDeclaration

UdpOutputDeclaration(&'a UdpOutputDeclaration)

Tuple Fields of UdpOutputDeclaration

0: &'a UdpOutputDeclaration

UdpOutputDeclarationNonreg(&'a UdpOutputDeclarationNonreg)

Tuple Fields of UdpOutputDeclarationNonreg

0: &'a UdpOutputDeclarationNonreg

UdpOutputDeclarationReg(&'a UdpOutputDeclarationReg)

Tuple Fields of UdpOutputDeclarationReg

0: &'a UdpOutputDeclarationReg

UdpInputDeclaration(&'a UdpInputDeclaration)

Tuple Fields of UdpInputDeclaration

0: &'a UdpInputDeclaration

UdpRegDeclaration(&'a UdpRegDeclaration)

Tuple Fields of UdpRegDeclaration

0: &'a UdpRegDeclaration

InterfaceInstantiation(&'a InterfaceInstantiation)

Tuple Fields of InterfaceInstantiation

0: &'a InterfaceInstantiation

CheckerInstantiation(&'a CheckerInstantiation)

Tuple Fields of CheckerInstantiation

0: &'a CheckerInstantiation

ListOfCheckerPortConnections(&'a ListOfCheckerPortConnections)

Tuple Fields of ListOfCheckerPortConnections

0: &'a ListOfCheckerPortConnections

ListOfCheckerPortConnectionsOrdered(&'a ListOfCheckerPortConnectionsOrdered)

Tuple Fields of ListOfCheckerPortConnectionsOrdered

0: &'a ListOfCheckerPortConnectionsOrdered

ListOfCheckerPortConnectionsNamed(&'a ListOfCheckerPortConnectionsNamed)

Tuple Fields of ListOfCheckerPortConnectionsNamed

0: &'a ListOfCheckerPortConnectionsNamed

OrderedCheckerPortConnection(&'a OrderedCheckerPortConnection)

Tuple Fields of OrderedCheckerPortConnection

0: &'a OrderedCheckerPortConnection

NamedCheckerPortConnection(&'a NamedCheckerPortConnection)

Tuple Fields of NamedCheckerPortConnection

0: &'a NamedCheckerPortConnection

NamedCheckerPortConnectionIdentifier(&'a NamedCheckerPortConnectionIdentifier)

Tuple Fields of NamedCheckerPortConnectionIdentifier

0: &'a NamedCheckerPortConnectionIdentifier

NamedCheckerPortConnectionAsterisk(&'a NamedCheckerPortConnectionAsterisk)

Tuple Fields of NamedCheckerPortConnectionAsterisk

0: &'a NamedCheckerPortConnectionAsterisk

ModuleInstantiation(&'a ModuleInstantiation)

Tuple Fields of ModuleInstantiation

0: &'a ModuleInstantiation

ParameterValueAssignment(&'a ParameterValueAssignment)

Tuple Fields of ParameterValueAssignment

0: &'a ParameterValueAssignment

ListOfParameterAssignments(&'a ListOfParameterAssignments)

Tuple Fields of ListOfParameterAssignments

0: &'a ListOfParameterAssignments

ListOfParameterAssignmentsOrdered(&'a ListOfParameterAssignmentsOrdered)

Tuple Fields of ListOfParameterAssignmentsOrdered

0: &'a ListOfParameterAssignmentsOrdered

ListOfParameterAssignmentsNamed(&'a ListOfParameterAssignmentsNamed)

Tuple Fields of ListOfParameterAssignmentsNamed

0: &'a ListOfParameterAssignmentsNamed

OrderedParameterAssignment(&'a OrderedParameterAssignment)

Tuple Fields of OrderedParameterAssignment

0: &'a OrderedParameterAssignment

NamedParameterAssignment(&'a NamedParameterAssignment)

Tuple Fields of NamedParameterAssignment

0: &'a NamedParameterAssignment

HierarchicalInstance(&'a HierarchicalInstance)

Tuple Fields of HierarchicalInstance

0: &'a HierarchicalInstance

NameOfInstance(&'a NameOfInstance)

Tuple Fields of NameOfInstance

0: &'a NameOfInstance

ListOfPortConnections(&'a ListOfPortConnections)

Tuple Fields of ListOfPortConnections

0: &'a ListOfPortConnections

ListOfPortConnectionsOrdered(&'a ListOfPortConnectionsOrdered)

Tuple Fields of ListOfPortConnectionsOrdered

0: &'a ListOfPortConnectionsOrdered

ListOfPortConnectionsNamed(&'a ListOfPortConnectionsNamed)

Tuple Fields of ListOfPortConnectionsNamed

0: &'a ListOfPortConnectionsNamed

OrderedPortConnection(&'a OrderedPortConnection)

Tuple Fields of OrderedPortConnection

0: &'a OrderedPortConnection

NamedPortConnection(&'a NamedPortConnection)

Tuple Fields of NamedPortConnection

0: &'a NamedPortConnection

NamedPortConnectionIdentifier(&'a NamedPortConnectionIdentifier)

Tuple Fields of NamedPortConnectionIdentifier

0: &'a NamedPortConnectionIdentifier

NamedPortConnectionAsterisk(&'a NamedPortConnectionAsterisk)

Tuple Fields of NamedPortConnectionAsterisk

0: &'a NamedPortConnectionAsterisk

ProgramInstantiation(&'a ProgramInstantiation)

Tuple Fields of ProgramInstantiation

0: &'a ProgramInstantiation

GenerateRegion(&'a GenerateRegion)

Tuple Fields of GenerateRegion

0: &'a GenerateRegion

LoopGenerateConstruct(&'a LoopGenerateConstruct)

Tuple Fields of LoopGenerateConstruct

0: &'a LoopGenerateConstruct

GenvarInitialization(&'a GenvarInitialization)

Tuple Fields of GenvarInitialization

0: &'a GenvarInitialization

Genvar(&'a Genvar)

Tuple Fields of Genvar

0: &'a Genvar

GenvarIteration(&'a GenvarIteration)

Tuple Fields of GenvarIteration

0: &'a GenvarIteration

GenvarIterationAssignment(&'a GenvarIterationAssignment)

Tuple Fields of GenvarIterationAssignment

0: &'a GenvarIterationAssignment

GenvarIterationPrefix(&'a GenvarIterationPrefix)

Tuple Fields of GenvarIterationPrefix

0: &'a GenvarIterationPrefix

GenvarIterationSuffix(&'a GenvarIterationSuffix)

Tuple Fields of GenvarIterationSuffix

0: &'a GenvarIterationSuffix

ConditionalGenerateConstruct(&'a ConditionalGenerateConstruct)

Tuple Fields of ConditionalGenerateConstruct

0: &'a ConditionalGenerateConstruct

IfGenerateConstruct(&'a IfGenerateConstruct)

Tuple Fields of IfGenerateConstruct

0: &'a IfGenerateConstruct

CaseGenerateConstruct(&'a CaseGenerateConstruct)

Tuple Fields of CaseGenerateConstruct

0: &'a CaseGenerateConstruct

CaseGenerateItem(&'a CaseGenerateItem)

Tuple Fields of CaseGenerateItem

0: &'a CaseGenerateItem

CaseGenerateItemNondefault(&'a CaseGenerateItemNondefault)

Tuple Fields of CaseGenerateItemNondefault

0: &'a CaseGenerateItemNondefault

CaseGenerateItemDefault(&'a CaseGenerateItemDefault)

Tuple Fields of CaseGenerateItemDefault

0: &'a CaseGenerateItemDefault

GenerateBlock(&'a GenerateBlock)

Tuple Fields of GenerateBlock

0: &'a GenerateBlock

GenerateBlockMultiple(&'a GenerateBlockMultiple)

Tuple Fields of GenerateBlockMultiple

0: &'a GenerateBlockMultiple

GenerateItem(&'a GenerateItem)

Tuple Fields of GenerateItem

0: &'a GenerateItem

Trait Implementations

impl<'a> Clone for RefNode<'a>

pub fn clone(&self) -> RefNode<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for RefNode<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Display for RefNode<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> From<&'a ActionBlock> for RefNode<'a>

pub fn from(x: &'a ActionBlock) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ActionBlockElse> for RefNode<'a>

pub fn from(x: &'a ActionBlockElse) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ActualArgument> for RefNode<'a>

pub fn from(x: &'a ActualArgument) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AlwaysConstruct> for RefNode<'a>

pub fn from(x: &'a AlwaysConstruct) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AlwaysKeyword> for RefNode<'a>

pub fn from(x: &'a AlwaysKeyword) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AngleBracketLiteral> for RefNode<'a>

pub fn from(x: &'a AngleBracketLiteral) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AnonymousProgram> for RefNode<'a>

pub fn from(x: &'a AnonymousProgram) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AnonymousProgramItem> for RefNode<'a>

pub fn from(x: &'a AnonymousProgramItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AnsiPortDeclaration> for RefNode<'a>

pub fn from(x: &'a AnsiPortDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AnsiPortDeclarationNet> for RefNode<'a>

pub fn from(x: &'a AnsiPortDeclarationNet) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AnsiPortDeclarationParen> for RefNode<'a>

pub fn from(x: &'a AnsiPortDeclarationParen) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AnsiPortDeclarationVariable> for RefNode<'a>

pub fn from(x: &'a AnsiPortDeclarationVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AnyNode> for RefNode<'a>

pub fn from(x: &'a AnyNode) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ArrayIdentifier> for RefNode<'a>

pub fn from(x: &'a ArrayIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ArrayManipulationCall> for RefNode<'a>

pub fn from(x: &'a ArrayManipulationCall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ArrayMethodName> for RefNode<'a>

pub fn from(x: &'a ArrayMethodName) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ArrayPatternKey> for RefNode<'a>

pub fn from(x: &'a ArrayPatternKey) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ArrayRangeExpression> for RefNode<'a>

pub fn from(x: &'a ArrayRangeExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ArrayRangeExpressionColon> for RefNode<'a>

pub fn from(x: &'a ArrayRangeExpressionColon) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ArrayRangeExpressionMinusColon> for RefNode<'a>

pub fn from(x: &'a ArrayRangeExpressionMinusColon) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ArrayRangeExpressionPlusColon> for RefNode<'a>

pub fn from(x: &'a ArrayRangeExpressionPlusColon) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssertPropertyStatement> for RefNode<'a>

pub fn from(x: &'a AssertPropertyStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssertTiming> for RefNode<'a>

pub fn from(x: &'a AssertTiming) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssertionItem> for RefNode<'a>

pub fn from(x: &'a AssertionItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssertionItemDeclaration> for RefNode<'a>

pub fn from(x: &'a AssertionItemDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssertionVariableDeclaration> for RefNode<'a>

pub fn from(x: &'a AssertionVariableDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentOperator> for RefNode<'a>

pub fn from(x: &'a AssignmentOperator) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentPattern> for RefNode<'a>

pub fn from(x: &'a AssignmentPattern) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentPatternArray> for RefNode<'a>

pub fn from(x: &'a AssignmentPatternArray) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentPatternExpression> for RefNode<'a>

pub fn from(x: &'a AssignmentPatternExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentPatternExpressionType> for RefNode<'a>

pub fn from(x: &'a AssignmentPatternExpressionType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentPatternKey> for RefNode<'a>

pub fn from(x: &'a AssignmentPatternKey) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentPatternList> for RefNode<'a>

pub fn from(x: &'a AssignmentPatternList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentPatternNetLvalue> for RefNode<'a>

pub fn from(x: &'a AssignmentPatternNetLvalue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentPatternRepeat> for RefNode<'a>

pub fn from(x: &'a AssignmentPatternRepeat) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentPatternStructure> for RefNode<'a>

pub fn from(x: &'a AssignmentPatternStructure) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssignmentPatternVariableLvalue> for RefNode<'a>

pub fn from(x: &'a AssignmentPatternVariableLvalue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssociativeDimension> for RefNode<'a>

pub fn from(x: &'a AssociativeDimension) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssociativeDimensionAsterisk> for RefNode<'a>

pub fn from(x: &'a AssociativeDimensionAsterisk) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssociativeDimensionDataType> for RefNode<'a>

pub fn from(x: &'a AssociativeDimensionDataType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AssumePropertyStatement> for RefNode<'a>

pub fn from(x: &'a AssumePropertyStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AttrSpec> for RefNode<'a>

pub fn from(x: &'a AttrSpec) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a AttributeInstance> for RefNode<'a>

pub fn from(x: &'a AttributeInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinIdentifier> for RefNode<'a>

pub fn from(x: &'a BinIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinaryBase> for RefNode<'a>

pub fn from(x: &'a BinaryBase) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinaryModulePathOperator> for RefNode<'a>

pub fn from(x: &'a BinaryModulePathOperator) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinaryNumber> for RefNode<'a>

pub fn from(x: &'a BinaryNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinaryOperator> for RefNode<'a>

pub fn from(x: &'a BinaryOperator) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinaryValue> for RefNode<'a>

pub fn from(x: &'a BinaryValue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BindDirective> for RefNode<'a>

pub fn from(x: &'a BindDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BindDirectiveInstance> for RefNode<'a>

pub fn from(x: &'a BindDirectiveInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BindDirectiveScope> for RefNode<'a>

pub fn from(x: &'a BindDirectiveScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BindInstantiation> for RefNode<'a>

pub fn from(x: &'a BindInstantiation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BindTargetInstance> for RefNode<'a>

pub fn from(x: &'a BindTargetInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BindTargetInstanceList> for RefNode<'a>

pub fn from(x: &'a BindTargetInstanceList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BindTargetScope> for RefNode<'a>

pub fn from(x: &'a BindTargetScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsExpression> for RefNode<'a>

pub fn from(x: &'a BinsExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsExpressionCoverPoint> for RefNode<'a>

pub fn from(x: &'a BinsExpressionCoverPoint) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsKeyword> for RefNode<'a>

pub fn from(x: &'a BinsKeyword) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsOrEmpty> for RefNode<'a>

pub fn from(x: &'a BinsOrEmpty) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsOrEmptyNonEmpty> for RefNode<'a>

pub fn from(x: &'a BinsOrEmptyNonEmpty) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsOrOptions> for RefNode<'a>

pub fn from(x: &'a BinsOrOptions) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsOrOptionsCoverPoint> for RefNode<'a>

pub fn from(x: &'a BinsOrOptionsCoverPoint) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsOrOptionsCovergroup> for RefNode<'a>

pub fn from(x: &'a BinsOrOptionsCovergroup) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsOrOptionsDefault> for RefNode<'a>

pub fn from(x: &'a BinsOrOptionsDefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsOrOptionsDefaultSequence> for RefNode<'a>

pub fn from(x: &'a BinsOrOptionsDefaultSequence) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsOrOptionsSetCovergroup> for RefNode<'a>

pub fn from(x: &'a BinsOrOptionsSetCovergroup) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsOrOptionsTransList> for RefNode<'a>

pub fn from(x: &'a BinsOrOptionsTransList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsSelection> for RefNode<'a>

pub fn from(x: &'a BinsSelection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsSelectionOrOption> for RefNode<'a>

pub fn from(x: &'a BinsSelectionOrOption) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsSelectionOrOptionBins> for RefNode<'a>

pub fn from(x: &'a BinsSelectionOrOptionBins) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BinsSelectionOrOptionCoverage> for RefNode<'a>

pub fn from(x: &'a BinsSelectionOrOptionCoverage) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BitSelect> for RefNode<'a>

pub fn from(x: &'a BitSelect) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockEventExpression> for RefNode<'a>

pub fn from(x: &'a BlockEventExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockEventExpressionBegin> for RefNode<'a>

pub fn from(x: &'a BlockEventExpressionBegin) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockEventExpressionEnd> for RefNode<'a>

pub fn from(x: &'a BlockEventExpressionEnd) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockEventExpressionOr> for RefNode<'a>

pub fn from(x: &'a BlockEventExpressionOr) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockIdentifier> for RefNode<'a>

pub fn from(x: &'a BlockIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockItemDeclaration> for RefNode<'a>

pub fn from(x: &'a BlockItemDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockItemDeclarationData> for RefNode<'a>

pub fn from(x: &'a BlockItemDeclarationData) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockItemDeclarationLet> for RefNode<'a>

pub fn from(x: &'a BlockItemDeclarationLet) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockItemDeclarationLocalParameter> for RefNode<'a>

pub fn from(x: &'a BlockItemDeclarationLocalParameter) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockItemDeclarationParameter> for RefNode<'a>

pub fn from(x: &'a BlockItemDeclarationParameter) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockingAssignment> for RefNode<'a>

pub fn from(x: &'a BlockingAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockingAssignmentHierarchicalVariable> for RefNode<'a>

pub fn from(x: &'a BlockingAssignmentHierarchicalVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockingAssignmentNonrangeVariable> for RefNode<'a>

pub fn from(x: &'a BlockingAssignmentNonrangeVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BlockingAssignmentVariable> for RefNode<'a>

pub fn from(x: &'a BlockingAssignmentVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BooleanAbbrev> for RefNode<'a>

pub fn from(x: &'a BooleanAbbrev) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a BuiltInMethodCall> for RefNode<'a>

pub fn from(x: &'a BuiltInMethodCall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CIdentifier> for RefNode<'a>

pub fn from(x: &'a CIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseExpression> for RefNode<'a>

pub fn from(x: &'a CaseExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseGenerateConstruct> for RefNode<'a>

pub fn from(x: &'a CaseGenerateConstruct) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseGenerateItem> for RefNode<'a>

pub fn from(x: &'a CaseGenerateItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseGenerateItemDefault> for RefNode<'a>

pub fn from(x: &'a CaseGenerateItemDefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseGenerateItemNondefault> for RefNode<'a>

pub fn from(x: &'a CaseGenerateItemNondefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseInsideItem> for RefNode<'a>

pub fn from(x: &'a CaseInsideItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseInsideItemNondefault> for RefNode<'a>

pub fn from(x: &'a CaseInsideItemNondefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseItem> for RefNode<'a>

pub fn from(x: &'a CaseItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseItemDefault> for RefNode<'a>

pub fn from(x: &'a CaseItemDefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseItemExpression> for RefNode<'a>

pub fn from(x: &'a CaseItemExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseItemNondefault> for RefNode<'a>

pub fn from(x: &'a CaseItemNondefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseKeyword> for RefNode<'a>

pub fn from(x: &'a CaseKeyword) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CasePatternItem> for RefNode<'a>

pub fn from(x: &'a CasePatternItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CasePatternItemNondefault> for RefNode<'a>

pub fn from(x: &'a CasePatternItemNondefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseStatement> for RefNode<'a>

pub fn from(x: &'a CaseStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseStatementInside> for RefNode<'a>

pub fn from(x: &'a CaseStatementInside) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseStatementMatches> for RefNode<'a>

pub fn from(x: &'a CaseStatementMatches) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CaseStatementNormal> for RefNode<'a>

pub fn from(x: &'a CaseStatementNormal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Cast> for RefNode<'a>

pub fn from(x: &'a Cast) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CastingType> for RefNode<'a>

pub fn from(x: &'a CastingType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CellClause> for RefNode<'a>

pub fn from(x: &'a CellClause) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CellIdentifier> for RefNode<'a>

pub fn from(x: &'a CellIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CelldefineDriveCompilerDirective> for RefNode<'a>

pub fn from(x: &'a CelldefineDriveCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ChargeStrength> for RefNode<'a>

pub fn from(x: &'a ChargeStrength) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ChargeStrengthLarge> for RefNode<'a>

pub fn from(x: &'a ChargeStrengthLarge) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ChargeStrengthMedium> for RefNode<'a>

pub fn from(x: &'a ChargeStrengthMedium) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ChargeStrengthSmall> for RefNode<'a>

pub fn from(x: &'a ChargeStrengthSmall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerDeclaration> for RefNode<'a>

pub fn from(x: &'a CheckerDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerGenerateItem> for RefNode<'a>

pub fn from(x: &'a CheckerGenerateItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerIdentifier> for RefNode<'a>

pub fn from(x: &'a CheckerIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerInstantiation> for RefNode<'a>

pub fn from(x: &'a CheckerInstantiation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerOrGenerateItem> for RefNode<'a>

pub fn from(x: &'a CheckerOrGenerateItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerOrGenerateItemDeclaration> for RefNode<'a>

pub fn from(x: &'a CheckerOrGenerateItemDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerOrGenerateItemDeclarationClocking> for RefNode<'a>

pub fn from(x: &'a CheckerOrGenerateItemDeclarationClocking) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerOrGenerateItemDeclarationData> for RefNode<'a>

pub fn from(x: &'a CheckerOrGenerateItemDeclarationData) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerOrGenerateItemDeclarationDisable> for RefNode<'a>

pub fn from(x: &'a CheckerOrGenerateItemDeclarationDisable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerPortDirection> for RefNode<'a>

pub fn from(x: &'a CheckerPortDirection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerPortItem> for RefNode<'a>

pub fn from(x: &'a CheckerPortItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CheckerPortList> for RefNode<'a>

pub fn from(x: &'a CheckerPortList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassConstraint> for RefNode<'a>

pub fn from(x: &'a ClassConstraint) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassConstructorDeclaration> for RefNode<'a>

pub fn from(x: &'a ClassConstructorDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassConstructorPrototype> for RefNode<'a>

pub fn from(x: &'a ClassConstructorPrototype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassDeclaration> for RefNode<'a>

pub fn from(x: &'a ClassDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassIdentifier> for RefNode<'a>

pub fn from(x: &'a ClassIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassItem> for RefNode<'a>

pub fn from(x: &'a ClassItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassItemConstraint> for RefNode<'a>

pub fn from(x: &'a ClassItemConstraint) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassItemCovergroup> for RefNode<'a>

pub fn from(x: &'a ClassItemCovergroup) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassItemDeclaration> for RefNode<'a>

pub fn from(x: &'a ClassItemDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassItemMethod> for RefNode<'a>

pub fn from(x: &'a ClassItemMethod) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassItemProperty> for RefNode<'a>

pub fn from(x: &'a ClassItemProperty) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassItemQualifier> for RefNode<'a>

pub fn from(x: &'a ClassItemQualifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassMethod> for RefNode<'a>

pub fn from(x: &'a ClassMethod) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassMethodConstructor> for RefNode<'a>

pub fn from(x: &'a ClassMethodConstructor) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassMethodExternConstructor> for RefNode<'a>

pub fn from(x: &'a ClassMethodExternConstructor) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassMethodExternMethod> for RefNode<'a>

pub fn from(x: &'a ClassMethodExternMethod) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassMethodFunction> for RefNode<'a>

pub fn from(x: &'a ClassMethodFunction) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassMethodPureVirtual> for RefNode<'a>

pub fn from(x: &'a ClassMethodPureVirtual) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassMethodTask> for RefNode<'a>

pub fn from(x: &'a ClassMethodTask) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassNew> for RefNode<'a>

pub fn from(x: &'a ClassNew) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassNewArgument> for RefNode<'a>

pub fn from(x: &'a ClassNewArgument) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassNewExpression> for RefNode<'a>

pub fn from(x: &'a ClassNewExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassProperty> for RefNode<'a>

pub fn from(x: &'a ClassProperty) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassPropertyConst> for RefNode<'a>

pub fn from(x: &'a ClassPropertyConst) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassPropertyConstExpression> for RefNode<'a>

pub fn from(x: &'a ClassPropertyConstExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassPropertyNonConst> for RefNode<'a>

pub fn from(x: &'a ClassPropertyNonConst) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassQualifier> for RefNode<'a>

pub fn from(x: &'a ClassQualifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassQualifierOrPackageScope> for RefNode<'a>

pub fn from(x: &'a ClassQualifierOrPackageScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassScope> for RefNode<'a>

pub fn from(x: &'a ClassScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassType> for RefNode<'a>

pub fn from(x: &'a ClassType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClassVariableIdentifier> for RefNode<'a>

pub fn from(x: &'a ClassVariableIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingDeclAssign> for RefNode<'a>

pub fn from(x: &'a ClockingDeclAssign) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingDeclaration> for RefNode<'a>

pub fn from(x: &'a ClockingDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingDeclarationGlobal> for RefNode<'a>

pub fn from(x: &'a ClockingDeclarationGlobal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingDeclarationLocal> for RefNode<'a>

pub fn from(x: &'a ClockingDeclarationLocal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingDirection> for RefNode<'a>

pub fn from(x: &'a ClockingDirection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingDirectionInput> for RefNode<'a>

pub fn from(x: &'a ClockingDirectionInput) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingDirectionInputOutput> for RefNode<'a>

pub fn from(x: &'a ClockingDirectionInputOutput) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingDirectionOutput> for RefNode<'a>

pub fn from(x: &'a ClockingDirectionOutput) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingDrive> for RefNode<'a>

pub fn from(x: &'a ClockingDrive) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingEvent> for RefNode<'a>

pub fn from(x: &'a ClockingEvent) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingEventExpression> for RefNode<'a>

pub fn from(x: &'a ClockingEventExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingEventIdentifier> for RefNode<'a>

pub fn from(x: &'a ClockingEventIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingIdentifier> for RefNode<'a>

pub fn from(x: &'a ClockingIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingItem> for RefNode<'a>

pub fn from(x: &'a ClockingItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingItemAssertion> for RefNode<'a>

pub fn from(x: &'a ClockingItemAssertion) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingItemDefault> for RefNode<'a>

pub fn from(x: &'a ClockingItemDefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingItemDirection> for RefNode<'a>

pub fn from(x: &'a ClockingItemDirection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingSkew> for RefNode<'a>

pub fn from(x: &'a ClockingSkew) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockingSkewEdge> for RefNode<'a>

pub fn from(x: &'a ClockingSkewEdge) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Clockvar> for RefNode<'a>

pub fn from(x: &'a Clockvar) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ClockvarExpression> for RefNode<'a>

pub fn from(x: &'a ClockvarExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CmosSwitchInstance> for RefNode<'a>

pub fn from(x: &'a CmosSwitchInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CmosSwitchtype> for RefNode<'a>

pub fn from(x: &'a CmosSwitchtype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CombinationalBody> for RefNode<'a>

pub fn from(x: &'a CombinationalBody) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CombinationalEntry> for RefNode<'a>

pub fn from(x: &'a CombinationalEntry) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Comment> for RefNode<'a>

pub fn from(x: &'a Comment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CompilerDirective> for RefNode<'a>

pub fn from(x: &'a CompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Concatenation> for RefNode<'a>

pub fn from(x: &'a Concatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConcurrentAssertionItem> for RefNode<'a>

pub fn from(x: &'a ConcurrentAssertionItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConcurrentAssertionItemStatement> for RefNode<'a>

pub fn from(x: &'a ConcurrentAssertionItemStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConcurrentAssertionStatement> for RefNode<'a>

pub fn from(x: &'a ConcurrentAssertionStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CondPattern> for RefNode<'a>

pub fn from(x: &'a CondPattern) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CondPredicate> for RefNode<'a>

pub fn from(x: &'a CondPredicate) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConditionalCompilerDirective> for RefNode<'a>

pub fn from(x: &'a ConditionalCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConditionalExpression> for RefNode<'a>

pub fn from(x: &'a ConditionalExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConditionalGenerateConstruct> for RefNode<'a>

pub fn from(x: &'a ConditionalGenerateConstruct) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConditionalStatement> for RefNode<'a>

pub fn from(x: &'a ConditionalStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Config> for RefNode<'a>

pub fn from(x: &'a Config) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConfigDeclaration> for RefNode<'a>

pub fn from(x: &'a ConfigDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConfigIdentifier> for RefNode<'a>

pub fn from(x: &'a ConfigIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConfigRuleStatement> for RefNode<'a>

pub fn from(x: &'a ConfigRuleStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConfigRuleStatementCellLib> for RefNode<'a>

pub fn from(x: &'a ConfigRuleStatementCellLib) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConfigRuleStatementCellUse> for RefNode<'a>

pub fn from(x: &'a ConfigRuleStatementCellUse) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConfigRuleStatementDefault> for RefNode<'a>

pub fn from(x: &'a ConfigRuleStatementDefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConfigRuleStatementInstLib> for RefNode<'a>

pub fn from(x: &'a ConfigRuleStatementInstLib) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConfigRuleStatementInstUse> for RefNode<'a>

pub fn from(x: &'a ConfigRuleStatementInstUse) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConsecutiveRepetition> for RefNode<'a>

pub fn from(x: &'a ConsecutiveRepetition) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConsecutiveRepetitionAsterisk> for RefNode<'a>

pub fn from(x: &'a ConsecutiveRepetitionAsterisk) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConsecutiveRepetitionExpression> for RefNode<'a>

pub fn from(x: &'a ConsecutiveRepetitionExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConsecutiveRepetitionPlus> for RefNode<'a>

pub fn from(x: &'a ConsecutiveRepetitionPlus) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Const> for RefNode<'a>

pub fn from(x: &'a Const) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstIdentifier> for RefNode<'a>

pub fn from(x: &'a ConstIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstOrRangeExpression> for RefNode<'a>

pub fn from(x: &'a ConstOrRangeExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantAssignmentPatternExpression> for RefNode<'a>

pub fn from(x: &'a ConstantAssignmentPatternExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantBitSelect> for RefNode<'a>

pub fn from(x: &'a ConstantBitSelect) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantCast> for RefNode<'a>

pub fn from(x: &'a ConstantCast) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantConcatenation> for RefNode<'a>

pub fn from(x: &'a ConstantConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantExpression> for RefNode<'a>

pub fn from(x: &'a ConstantExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantExpressionBinary> for RefNode<'a>

pub fn from(x: &'a ConstantExpressionBinary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantExpressionTernary> for RefNode<'a>

pub fn from(x: &'a ConstantExpressionTernary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantExpressionUnary> for RefNode<'a>

pub fn from(x: &'a ConstantExpressionUnary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantFunctionCall> for RefNode<'a>

pub fn from(x: &'a ConstantFunctionCall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantIndexedRange> for RefNode<'a>

pub fn from(x: &'a ConstantIndexedRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantLetExpression> for RefNode<'a>

pub fn from(x: &'a ConstantLetExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantMintypmaxExpression> for RefNode<'a>

pub fn from(x: &'a ConstantMintypmaxExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantMintypmaxExpressionTernary> for RefNode<'a>

pub fn from(x: &'a ConstantMintypmaxExpressionTernary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantMultipleConcatenation> for RefNode<'a>

pub fn from(x: &'a ConstantMultipleConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantParamExpression> for RefNode<'a>

pub fn from(x: &'a ConstantParamExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantPartSelectRange> for RefNode<'a>

pub fn from(x: &'a ConstantPartSelectRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantPrimary> for RefNode<'a>

pub fn from(x: &'a ConstantPrimary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantPrimaryConcatenation> for RefNode<'a>

pub fn from(x: &'a ConstantPrimaryConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantPrimaryEnum> for RefNode<'a>

pub fn from(x: &'a ConstantPrimaryEnum) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantPrimaryFormalPort> for RefNode<'a>

pub fn from(x: &'a ConstantPrimaryFormalPort) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantPrimaryMintypmaxExpression> for RefNode<'a>

pub fn from(x: &'a ConstantPrimaryMintypmaxExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantPrimaryMultipleConcatenation> for RefNode<'a>

pub fn from(x: &'a ConstantPrimaryMultipleConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantPrimaryPsParameter> for RefNode<'a>

pub fn from(x: &'a ConstantPrimaryPsParameter) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantPrimarySpecparam> for RefNode<'a>

pub fn from(x: &'a ConstantPrimarySpecparam) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantRange> for RefNode<'a>

pub fn from(x: &'a ConstantRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantRangeExpression> for RefNode<'a>

pub fn from(x: &'a ConstantRangeExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstantSelect> for RefNode<'a>

pub fn from(x: &'a ConstantSelect) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintBlock> for RefNode<'a>

pub fn from(x: &'a ConstraintBlock) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintBlockItem> for RefNode<'a>

pub fn from(x: &'a ConstraintBlockItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintBlockItemSolve> for RefNode<'a>

pub fn from(x: &'a ConstraintBlockItemSolve) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintDeclaration> for RefNode<'a>

pub fn from(x: &'a ConstraintDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintExpression> for RefNode<'a>

pub fn from(x: &'a ConstraintExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintExpressionArrow> for RefNode<'a>

pub fn from(x: &'a ConstraintExpressionArrow) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintExpressionDisable> for RefNode<'a>

pub fn from(x: &'a ConstraintExpressionDisable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintExpressionExpression> for RefNode<'a>

pub fn from(x: &'a ConstraintExpressionExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintExpressionForeach> for RefNode<'a>

pub fn from(x: &'a ConstraintExpressionForeach) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintExpressionIf> for RefNode<'a>

pub fn from(x: &'a ConstraintExpressionIf) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintIdentifier> for RefNode<'a>

pub fn from(x: &'a ConstraintIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintPrimary> for RefNode<'a>

pub fn from(x: &'a ConstraintPrimary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintPrototype> for RefNode<'a>

pub fn from(x: &'a ConstraintPrototype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintPrototypeQualifier> for RefNode<'a>

pub fn from(x: &'a ConstraintPrototypeQualifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintSet> for RefNode<'a>

pub fn from(x: &'a ConstraintSet) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ConstraintSetBrace> for RefNode<'a>

pub fn from(x: &'a ConstraintSetBrace) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ContinuousAssign> for RefNode<'a>

pub fn from(x: &'a ContinuousAssign) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ContinuousAssignNet> for RefNode<'a>

pub fn from(x: &'a ContinuousAssignNet) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ContinuousAssignVariable> for RefNode<'a>

pub fn from(x: &'a ContinuousAssignVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ControlledReferenceEvent> for RefNode<'a>

pub fn from(x: &'a ControlledReferenceEvent) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ControlledTimingCheckEvent> for RefNode<'a>

pub fn from(x: &'a ControlledTimingCheckEvent) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverCross> for RefNode<'a>

pub fn from(x: &'a CoverCross) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverPoint> for RefNode<'a>

pub fn from(x: &'a CoverPoint) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverPointIdentifier> for RefNode<'a>

pub fn from(x: &'a CoverPointIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverPropertyStatement> for RefNode<'a>

pub fn from(x: &'a CoverPropertyStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverSequenceStatement> for RefNode<'a>

pub fn from(x: &'a CoverSequenceStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverageEvent> for RefNode<'a>

pub fn from(x: &'a CoverageEvent) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverageEventAt> for RefNode<'a>

pub fn from(x: &'a CoverageEventAt) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverageEventSample> for RefNode<'a>

pub fn from(x: &'a CoverageEventSample) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverageOption> for RefNode<'a>

pub fn from(x: &'a CoverageOption) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverageOptionOption> for RefNode<'a>

pub fn from(x: &'a CoverageOptionOption) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverageOptionTypeOption> for RefNode<'a>

pub fn from(x: &'a CoverageOptionTypeOption) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverageSpec> for RefNode<'a>

pub fn from(x: &'a CoverageSpec) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverageSpecOrOption> for RefNode<'a>

pub fn from(x: &'a CoverageSpecOrOption) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverageSpecOrOptionOption> for RefNode<'a>

pub fn from(x: &'a CoverageSpecOrOptionOption) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CoverageSpecOrOptionSpec> for RefNode<'a>

pub fn from(x: &'a CoverageSpecOrOptionSpec) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CovergroupDeclaration> for RefNode<'a>

pub fn from(x: &'a CovergroupDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CovergroupExpression> for RefNode<'a>

pub fn from(x: &'a CovergroupExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CovergroupIdentifier> for RefNode<'a>

pub fn from(x: &'a CovergroupIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CovergroupRangeList> for RefNode<'a>

pub fn from(x: &'a CovergroupRangeList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CovergroupValueRange> for RefNode<'a>

pub fn from(x: &'a CovergroupValueRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CovergroupValueRangeBinary> for RefNode<'a>

pub fn from(x: &'a CovergroupValueRangeBinary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CovergroupVariableIdentifier> for RefNode<'a>

pub fn from(x: &'a CovergroupVariableIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CrossBody> for RefNode<'a>

pub fn from(x: &'a CrossBody) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CrossBodyItem> for RefNode<'a>

pub fn from(x: &'a CrossBodyItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CrossBodyNonEmpty> for RefNode<'a>

pub fn from(x: &'a CrossBodyNonEmpty) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CrossIdentifier> for RefNode<'a>

pub fn from(x: &'a CrossIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CrossItem> for RefNode<'a>

pub fn from(x: &'a CrossItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CrossSetExpression> for RefNode<'a>

pub fn from(x: &'a CrossSetExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CurrentState> for RefNode<'a>

pub fn from(x: &'a CurrentState) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelay> for RefNode<'a>

pub fn from(x: &'a CycleDelay) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayConstRangeExpression> for RefNode<'a>

pub fn from(x: &'a CycleDelayConstRangeExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayConstRangeExpressionBinary> for RefNode<'a>

pub fn from(x: &'a CycleDelayConstRangeExpressionBinary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayConstRangeExpressionDollar> for RefNode<'a>

pub fn from(x: &'a CycleDelayConstRangeExpressionDollar) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayExpression> for RefNode<'a>

pub fn from(x: &'a CycleDelayExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayIdentifier> for RefNode<'a>

pub fn from(x: &'a CycleDelayIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayIntegral> for RefNode<'a>

pub fn from(x: &'a CycleDelayIntegral) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayRange> for RefNode<'a>

pub fn from(x: &'a CycleDelayRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayRangeAsterisk> for RefNode<'a>

pub fn from(x: &'a CycleDelayRangeAsterisk) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayRangeExpression> for RefNode<'a>

pub fn from(x: &'a CycleDelayRangeExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayRangePlus> for RefNode<'a>

pub fn from(x: &'a CycleDelayRangePlus) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a CycleDelayRangePrimary> for RefNode<'a>

pub fn from(x: &'a CycleDelayRangePrimary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataDeclaration> for RefNode<'a>

pub fn from(x: &'a DataDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataDeclarationVariable> for RefNode<'a>

pub fn from(x: &'a DataDeclarationVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataEvent> for RefNode<'a>

pub fn from(x: &'a DataEvent) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataSourceExpression> for RefNode<'a>

pub fn from(x: &'a DataSourceExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataType> for RefNode<'a>

pub fn from(x: &'a DataType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataTypeAtom> for RefNode<'a>

pub fn from(x: &'a DataTypeAtom) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataTypeEnum> for RefNode<'a>

pub fn from(x: &'a DataTypeEnum) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataTypeOrImplicit> for RefNode<'a>

pub fn from(x: &'a DataTypeOrImplicit) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataTypeOrVoid> for RefNode<'a>

pub fn from(x: &'a DataTypeOrVoid) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataTypeStructUnion> for RefNode<'a>

pub fn from(x: &'a DataTypeStructUnion) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataTypeType> for RefNode<'a>

pub fn from(x: &'a DataTypeType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataTypeVector> for RefNode<'a>

pub fn from(x: &'a DataTypeVector) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DataTypeVirtual> for RefNode<'a>

pub fn from(x: &'a DataTypeVirtual) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DecimalBase> for RefNode<'a>

pub fn from(x: &'a DecimalBase) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DecimalNumber> for RefNode<'a>

pub fn from(x: &'a DecimalNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DecimalNumberBaseUnsigned> for RefNode<'a>

pub fn from(x: &'a DecimalNumberBaseUnsigned) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DecimalNumberBaseXNumber> for RefNode<'a>

pub fn from(x: &'a DecimalNumberBaseXNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DecimalNumberBaseZNumber> for RefNode<'a>

pub fn from(x: &'a DecimalNumberBaseZNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Default> for RefNode<'a>

pub fn from(x: &'a Default) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DefaultClause> for RefNode<'a>

pub fn from(x: &'a DefaultClause) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DefaultNettypeCompilerDirective> for RefNode<'a>

pub fn from(x: &'a DefaultNettypeCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DefaultNettypeValue> for RefNode<'a>

pub fn from(x: &'a DefaultNettypeValue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DefaultSkew> for RefNode<'a>

pub fn from(x: &'a DefaultSkew) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DefaultSkewInput> for RefNode<'a>

pub fn from(x: &'a DefaultSkewInput) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DefaultSkewInputOutput> for RefNode<'a>

pub fn from(x: &'a DefaultSkewInputOutput) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DefaultSkewOutput> for RefNode<'a>

pub fn from(x: &'a DefaultSkewOutput) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DefaultText> for RefNode<'a>

pub fn from(x: &'a DefaultText) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DeferredImmediateAssertStatement> for RefNode<'a>

pub fn from(x: &'a DeferredImmediateAssertStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DeferredImmediateAssertionStatement> for RefNode<'a>

pub fn from(x: &'a DeferredImmediateAssertionStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DeferredImmediateAssetionItem> for RefNode<'a>

pub fn from(x: &'a DeferredImmediateAssetionItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DeferredImmediateAssumeStatement> for RefNode<'a>

pub fn from(x: &'a DeferredImmediateAssumeStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DeferredImmediateCoverStatement> for RefNode<'a>

pub fn from(x: &'a DeferredImmediateCoverStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DefparamAssignment> for RefNode<'a>

pub fn from(x: &'a DefparamAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Delay2> for RefNode<'a>

pub fn from(x: &'a Delay2) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Delay2Mintypmax> for RefNode<'a>

pub fn from(x: &'a Delay2Mintypmax) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Delay2Single> for RefNode<'a>

pub fn from(x: &'a Delay2Single) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Delay3> for RefNode<'a>

pub fn from(x: &'a Delay3) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Delay3Mintypmax> for RefNode<'a>

pub fn from(x: &'a Delay3Mintypmax) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Delay3Single> for RefNode<'a>

pub fn from(x: &'a Delay3Single) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DelayControl> for RefNode<'a>

pub fn from(x: &'a DelayControl) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DelayControlDelay> for RefNode<'a>

pub fn from(x: &'a DelayControlDelay) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DelayControlMintypmax> for RefNode<'a>

pub fn from(x: &'a DelayControlMintypmax) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DelayOrEventControl> for RefNode<'a>

pub fn from(x: &'a DelayOrEventControl) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DelayOrEventControlRepeat> for RefNode<'a>

pub fn from(x: &'a DelayOrEventControlRepeat) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DelayValue> for RefNode<'a>

pub fn from(x: &'a DelayValue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DelayedData> for RefNode<'a>

pub fn from(x: &'a DelayedData) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DelayedDataWithMintypmax> for RefNode<'a>

pub fn from(x: &'a DelayedDataWithMintypmax) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DelayedReference> for RefNode<'a>

pub fn from(x: &'a DelayedReference) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DelayedReferenceWithMintypmax> for RefNode<'a>

pub fn from(x: &'a DelayedReferenceWithMintypmax) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Description> for RefNode<'a>

pub fn from(x: &'a Description) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DescriptionBindDirective> for RefNode<'a>

pub fn from(x: &'a DescriptionBindDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DescriptionPackageItem> for RefNode<'a>

pub fn from(x: &'a DescriptionPackageItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DesignStatement> for RefNode<'a>

pub fn from(x: &'a DesignStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DisableStatement> for RefNode<'a>

pub fn from(x: &'a DisableStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DisableStatementBlock> for RefNode<'a>

pub fn from(x: &'a DisableStatementBlock) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DisableStatementFork> for RefNode<'a>

pub fn from(x: &'a DisableStatementFork) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DisableStatementTask> for RefNode<'a>

pub fn from(x: &'a DisableStatementTask) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DistItem> for RefNode<'a>

pub fn from(x: &'a DistItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DistList> for RefNode<'a>

pub fn from(x: &'a DistList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DistWeight> for RefNode<'a>

pub fn from(x: &'a DistWeight) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DistWeightDivide> for RefNode<'a>

pub fn from(x: &'a DistWeightDivide) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DistWeightEqual> for RefNode<'a>

pub fn from(x: &'a DistWeightEqual) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DpiFunctionImportProperty> for RefNode<'a>

pub fn from(x: &'a DpiFunctionImportProperty) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DpiFunctionProto> for RefNode<'a>

pub fn from(x: &'a DpiFunctionProto) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DpiImportExport> for RefNode<'a>

pub fn from(x: &'a DpiImportExport) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DpiImportExportExportFunction> for RefNode<'a>

pub fn from(x: &'a DpiImportExportExportFunction) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DpiImportExportExportTask> for RefNode<'a>

pub fn from(x: &'a DpiImportExportExportTask) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DpiImportExportImportFunction> for RefNode<'a>

pub fn from(x: &'a DpiImportExportImportFunction) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DpiImportExportImportTask> for RefNode<'a>

pub fn from(x: &'a DpiImportExportImportTask) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DpiSpecString> for RefNode<'a>

pub fn from(x: &'a DpiSpecString) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DpiTaskImportProperty> for RefNode<'a>

pub fn from(x: &'a DpiTaskImportProperty) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DpiTaskProto> for RefNode<'a>

pub fn from(x: &'a DpiTaskProto) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DriveStrength> for RefNode<'a>

pub fn from(x: &'a DriveStrength) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DriveStrength01> for RefNode<'a>

pub fn from(x: &'a DriveStrength01) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DriveStrength0z> for RefNode<'a>

pub fn from(x: &'a DriveStrength0z) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DriveStrength10> for RefNode<'a>

pub fn from(x: &'a DriveStrength10) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DriveStrength1z> for RefNode<'a>

pub fn from(x: &'a DriveStrength1z) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DriveStrengthz0> for RefNode<'a>

pub fn from(x: &'a DriveStrengthz0) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DriveStrengthz1> for RefNode<'a>

pub fn from(x: &'a DriveStrengthz1) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DynamicArrayNew> for RefNode<'a>

pub fn from(x: &'a DynamicArrayNew) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a DynamicArrayVariableIdentifier> for RefNode<'a>

pub fn from(x: &'a DynamicArrayVariableIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EdgeControlSpecifier> for RefNode<'a>

pub fn from(x: &'a EdgeControlSpecifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EdgeDescriptor> for RefNode<'a>

pub fn from(x: &'a EdgeDescriptor) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EdgeIdentifier> for RefNode<'a>

pub fn from(x: &'a EdgeIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EdgeIndicator> for RefNode<'a>

pub fn from(x: &'a EdgeIndicator) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EdgeIndicatorParen> for RefNode<'a>

pub fn from(x: &'a EdgeIndicatorParen) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EdgeInputList> for RefNode<'a>

pub fn from(x: &'a EdgeInputList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EdgeSensitivePathDeclaration> for RefNode<'a>

pub fn from(x: &'a EdgeSensitivePathDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EdgeSensitivePathDeclarationFull> for RefNode<'a>

pub fn from(x: &'a EdgeSensitivePathDeclarationFull) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EdgeSensitivePathDeclarationParallel> for RefNode<'a>

pub fn from(x: &'a EdgeSensitivePathDeclarationParallel) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EdgeSymbol> for RefNode<'a>

pub fn from(x: &'a EdgeSymbol) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ElaborationSystemTask> for RefNode<'a>

pub fn from(x: &'a ElaborationSystemTask) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ElaborationSystemTaskError> for RefNode<'a>

pub fn from(x: &'a ElaborationSystemTaskError) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ElaborationSystemTaskFatal> for RefNode<'a>

pub fn from(x: &'a ElaborationSystemTaskFatal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ElaborationSystemTaskInfo> for RefNode<'a>

pub fn from(x: &'a ElaborationSystemTaskInfo) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ElaborationSystemTaskWarning> for RefNode<'a>

pub fn from(x: &'a ElaborationSystemTaskWarning) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ElseGroupOfLines> for RefNode<'a>

pub fn from(x: &'a ElseGroupOfLines) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ElsifGroupOfLines> for RefNode<'a>

pub fn from(x: &'a ElsifGroupOfLines) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EmptyUnpackedArrayConcatenation> for RefNode<'a>

pub fn from(x: &'a EmptyUnpackedArrayConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EnableGateInstance> for RefNode<'a>

pub fn from(x: &'a EnableGateInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EnableGatetype> for RefNode<'a>

pub fn from(x: &'a EnableGatetype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EnableTerminal> for RefNode<'a>

pub fn from(x: &'a EnableTerminal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EndEdgeOffset> for RefNode<'a>

pub fn from(x: &'a EndEdgeOffset) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EndcelldefineDriveCompilerDirective> for RefNode<'a>

pub fn from(x: &'a EndcelldefineDriveCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EndkeywordsDirective> for RefNode<'a>

pub fn from(x: &'a EndkeywordsDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EnumBaseType> for RefNode<'a>

pub fn from(x: &'a EnumBaseType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EnumBaseTypeAtom> for RefNode<'a>

pub fn from(x: &'a EnumBaseTypeAtom) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EnumBaseTypeType> for RefNode<'a>

pub fn from(x: &'a EnumBaseTypeType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EnumBaseTypeVector> for RefNode<'a>

pub fn from(x: &'a EnumBaseTypeVector) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EnumIdentifier> for RefNode<'a>

pub fn from(x: &'a EnumIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EnumNameDeclaration> for RefNode<'a>

pub fn from(x: &'a EnumNameDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ErrorLimitValue> for RefNode<'a>

pub fn from(x: &'a ErrorLimitValue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EscapedIdentifier> for RefNode<'a>

pub fn from(x: &'a EscapedIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventBasedFlag> for RefNode<'a>

pub fn from(x: &'a EventBasedFlag) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventControl> for RefNode<'a>

pub fn from(x: &'a EventControl) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventControlAsterisk> for RefNode<'a>

pub fn from(x: &'a EventControlAsterisk) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventControlEventExpression> for RefNode<'a>

pub fn from(x: &'a EventControlEventExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventControlEventIdentifier> for RefNode<'a>

pub fn from(x: &'a EventControlEventIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventControlParenAsterisk> for RefNode<'a>

pub fn from(x: &'a EventControlParenAsterisk) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventControlSequenceIdentifier> for RefNode<'a>

pub fn from(x: &'a EventControlSequenceIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventExpression> for RefNode<'a>

pub fn from(x: &'a EventExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventExpressionComma> for RefNode<'a>

pub fn from(x: &'a EventExpressionComma) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventExpressionExpression> for RefNode<'a>

pub fn from(x: &'a EventExpressionExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventExpressionOr> for RefNode<'a>

pub fn from(x: &'a EventExpressionOr) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventExpressionParen> for RefNode<'a>

pub fn from(x: &'a EventExpressionParen) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventExpressionSequence> for RefNode<'a>

pub fn from(x: &'a EventExpressionSequence) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventTrigger> for RefNode<'a>

pub fn from(x: &'a EventTrigger) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventTriggerNamed> for RefNode<'a>

pub fn from(x: &'a EventTriggerNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a EventTriggerNonblocking> for RefNode<'a>

pub fn from(x: &'a EventTriggerNonblocking) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Exp> for RefNode<'a>

pub fn from(x: &'a Exp) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ExpectPropertyStatement> for RefNode<'a>

pub fn from(x: &'a ExpectPropertyStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Expression> for RefNode<'a>

pub fn from(x: &'a Expression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ExpressionBinary> for RefNode<'a>

pub fn from(x: &'a ExpressionBinary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ExpressionOperatorAssignment> for RefNode<'a>

pub fn from(x: &'a ExpressionOperatorAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ExpressionOrCondPattern> for RefNode<'a>

pub fn from(x: &'a ExpressionOrCondPattern) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ExpressionOrDist> for RefNode<'a>

pub fn from(x: &'a ExpressionOrDist) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ExpressionUnary> for RefNode<'a>

pub fn from(x: &'a ExpressionUnary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ExternConstraintDeclaration> for RefNode<'a>

pub fn from(x: &'a ExternConstraintDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ExternTfDeclaration> for RefNode<'a>

pub fn from(x: &'a ExternTfDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ExternTfDeclarationMethod> for RefNode<'a>

pub fn from(x: &'a ExternTfDeclarationMethod) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ExternTfDeclarationTask> for RefNode<'a>

pub fn from(x: &'a ExternTfDeclarationTask) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FilePathSpec> for RefNode<'a>

pub fn from(x: &'a FilePathSpec) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FilePathSpecNonLiteral> for RefNode<'a>

pub fn from(x: &'a FilePathSpecNonLiteral) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FinalConstruct> for RefNode<'a>

pub fn from(x: &'a FinalConstruct) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FinishNumber> for RefNode<'a>

pub fn from(x: &'a FinishNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FixedPointNumber> for RefNode<'a>

pub fn from(x: &'a FixedPointNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ForInitialization> for RefNode<'a>

pub fn from(x: &'a ForInitialization) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ForInitializationDeclaration> for RefNode<'a>

pub fn from(x: &'a ForInitializationDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ForStep> for RefNode<'a>

pub fn from(x: &'a ForStep) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ForStepAssignment> for RefNode<'a>

pub fn from(x: &'a ForStepAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ForVariableDeclaration> for RefNode<'a>

pub fn from(x: &'a ForVariableDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FormalArgument> for RefNode<'a>

pub fn from(x: &'a FormalArgument) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FormalIdentifier> for RefNode<'a>

pub fn from(x: &'a FormalIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FormalPortIdentifier> for RefNode<'a>

pub fn from(x: &'a FormalPortIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FullEdgeSensitivePathDescription> for RefNode<'a>

pub fn from(x: &'a FullEdgeSensitivePathDescription) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FullPathDescription> for RefNode<'a>

pub fn from(x: &'a FullPathDescription) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FullskewTimingCheck> for RefNode<'a>

pub fn from(x: &'a FullskewTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionBodyDeclaration> for RefNode<'a>

pub fn from(x: &'a FunctionBodyDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionBodyDeclarationWithPort> for RefNode<'a>

pub fn from(x: &'a FunctionBodyDeclarationWithPort) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionBodyDeclarationWithoutPort> for RefNode<'a>

pub fn from(x: &'a FunctionBodyDeclarationWithoutPort) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionDataTypeOrImplicit> for RefNode<'a>

pub fn from(x: &'a FunctionDataTypeOrImplicit) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionDeclaration> for RefNode<'a>

pub fn from(x: &'a FunctionDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionIdentifier> for RefNode<'a>

pub fn from(x: &'a FunctionIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionPrototype> for RefNode<'a>

pub fn from(x: &'a FunctionPrototype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionStatement> for RefNode<'a>

pub fn from(x: &'a FunctionStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionStatementOrNull> for RefNode<'a>

pub fn from(x: &'a FunctionStatementOrNull) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionStatementOrNullAttribute> for RefNode<'a>

pub fn from(x: &'a FunctionStatementOrNullAttribute) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a FunctionSubroutineCall> for RefNode<'a>

pub fn from(x: &'a FunctionSubroutineCall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GateInstantiation> for RefNode<'a>

pub fn from(x: &'a GateInstantiation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GateInstantiationCmos> for RefNode<'a>

pub fn from(x: &'a GateInstantiationCmos) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GateInstantiationEnable> for RefNode<'a>

pub fn from(x: &'a GateInstantiationEnable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GateInstantiationMos> for RefNode<'a>

pub fn from(x: &'a GateInstantiationMos) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GateInstantiationNInput> for RefNode<'a>

pub fn from(x: &'a GateInstantiationNInput) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GateInstantiationNOutput> for RefNode<'a>

pub fn from(x: &'a GateInstantiationNOutput) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GateInstantiationPass> for RefNode<'a>

pub fn from(x: &'a GateInstantiationPass) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GateInstantiationPassEn> for RefNode<'a>

pub fn from(x: &'a GateInstantiationPassEn) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GateInstantiationPulldown> for RefNode<'a>

pub fn from(x: &'a GateInstantiationPulldown) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GateInstantiationPullup> for RefNode<'a>

pub fn from(x: &'a GateInstantiationPullup) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenerateBlock> for RefNode<'a>

pub fn from(x: &'a GenerateBlock) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenerateBlockIdentifier> for RefNode<'a>

pub fn from(x: &'a GenerateBlockIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenerateBlockMultiple> for RefNode<'a>

pub fn from(x: &'a GenerateBlockMultiple) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenerateItem> for RefNode<'a>

pub fn from(x: &'a GenerateItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenerateRegion> for RefNode<'a>

pub fn from(x: &'a GenerateRegion) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Genvar> for RefNode<'a>

pub fn from(x: &'a Genvar) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenvarDeclaration> for RefNode<'a>

pub fn from(x: &'a GenvarDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenvarExpression> for RefNode<'a>

pub fn from(x: &'a GenvarExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenvarIdentifier> for RefNode<'a>

pub fn from(x: &'a GenvarIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenvarInitialization> for RefNode<'a>

pub fn from(x: &'a GenvarInitialization) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenvarIteration> for RefNode<'a>

pub fn from(x: &'a GenvarIteration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenvarIterationAssignment> for RefNode<'a>

pub fn from(x: &'a GenvarIterationAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenvarIterationPrefix> for RefNode<'a>

pub fn from(x: &'a GenvarIterationPrefix) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GenvarIterationSuffix> for RefNode<'a>

pub fn from(x: &'a GenvarIterationSuffix) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a GotoRepetition> for RefNode<'a>

pub fn from(x: &'a GotoRepetition) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HexBase> for RefNode<'a>

pub fn from(x: &'a HexBase) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HexNumber> for RefNode<'a>

pub fn from(x: &'a HexNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HexValue> for RefNode<'a>

pub fn from(x: &'a HexValue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalArrayIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalArrayIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalBlockIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalBlockIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalBtfIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalBtfIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalBtfIdentifierMethod> for RefNode<'a>

pub fn from(x: &'a HierarchicalBtfIdentifierMethod) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalEventIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalEventIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalIdentifierOrClassScope> for RefNode<'a>

pub fn from(x: &'a HierarchicalIdentifierOrClassScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalInstance> for RefNode<'a>

pub fn from(x: &'a HierarchicalInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalNetIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalNetIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalParameterIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalParameterIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalPropertyIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalPropertyIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalSequenceIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalSequenceIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalTaskIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalTaskIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalTfIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalTfIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HierarchicalVariableIdentifier> for RefNode<'a>

pub fn from(x: &'a HierarchicalVariableIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a HoldTimingCheck> for RefNode<'a>

pub fn from(x: &'a HoldTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Identifier> for RefNode<'a>

pub fn from(x: &'a Identifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IdentifierList> for RefNode<'a>

pub fn from(x: &'a IdentifierList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IfGenerateConstruct> for RefNode<'a>

pub fn from(x: &'a IfGenerateConstruct) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IfdefDirective> for RefNode<'a>

pub fn from(x: &'a IfdefDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IfdefGroupOfLines> for RefNode<'a>

pub fn from(x: &'a IfdefGroupOfLines) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IfndefDirective> for RefNode<'a>

pub fn from(x: &'a IfndefDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IfndefGroupOfLines> for RefNode<'a>

pub fn from(x: &'a IfndefGroupOfLines) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ImmediateAssetionStatement> for RefNode<'a>

pub fn from(x: &'a ImmediateAssetionStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ImplicitClassHandle> for RefNode<'a>

pub fn from(x: &'a ImplicitClassHandle) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ImplicitClassHandleOrClassScope> for RefNode<'a>

pub fn from(x: &'a ImplicitClassHandleOrClassScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ImplicitClassHandleOrClassScopeOrPackageScope> for RefNode<'a>

pub fn from(x: &'a ImplicitClassHandleOrClassScopeOrPackageScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ImplicitClassHandleOrPackageScope> for RefNode<'a>

pub fn from(x: &'a ImplicitClassHandleOrPackageScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ImplicitDataType> for RefNode<'a>

pub fn from(x: &'a ImplicitDataType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ImportExport> for RefNode<'a>

pub fn from(x: &'a ImportExport) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IncOrDecExpression> for RefNode<'a>

pub fn from(x: &'a IncOrDecExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IncOrDecExpressionPrefix> for RefNode<'a>

pub fn from(x: &'a IncOrDecExpressionPrefix) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IncOrDecExpressionSuffix> for RefNode<'a>

pub fn from(x: &'a IncOrDecExpressionSuffix) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IncOrDecOperator> for RefNode<'a>

pub fn from(x: &'a IncOrDecOperator) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IncludeCompilerDirective> for RefNode<'a>

pub fn from(x: &'a IncludeCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IncludeCompilerDirectiveAngleBracket> for RefNode<'a>

pub fn from(x: &'a IncludeCompilerDirectiveAngleBracket) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IncludeCompilerDirectiveDoubleQuote> for RefNode<'a>

pub fn from(x: &'a IncludeCompilerDirectiveDoubleQuote) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IncludeCompilerDirectiveTextMacroUsage> for RefNode<'a>

pub fn from(x: &'a IncludeCompilerDirectiveTextMacroUsage) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IncludeStatement> for RefNode<'a>

pub fn from(x: &'a IncludeStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IndexVariableIdentifier> for RefNode<'a>

pub fn from(x: &'a IndexVariableIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IndexedRange> for RefNode<'a>

pub fn from(x: &'a IndexedRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InitVal> for RefNode<'a>

pub fn from(x: &'a InitVal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InitialConstruct> for RefNode<'a>

pub fn from(x: &'a InitialConstruct) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InoutDeclaration> for RefNode<'a>

pub fn from(x: &'a InoutDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InoutPortIdentifier> for RefNode<'a>

pub fn from(x: &'a InoutPortIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InoutTerminal> for RefNode<'a>

pub fn from(x: &'a InoutTerminal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InputDeclaration> for RefNode<'a>

pub fn from(x: &'a InputDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InputDeclarationNet> for RefNode<'a>

pub fn from(x: &'a InputDeclarationNet) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InputDeclarationVariable> for RefNode<'a>

pub fn from(x: &'a InputDeclarationVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InputIdentifier> for RefNode<'a>

pub fn from(x: &'a InputIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InputIdentifierInterface> for RefNode<'a>

pub fn from(x: &'a InputIdentifierInterface) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InputPortIdentifier> for RefNode<'a>

pub fn from(x: &'a InputPortIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InputTerminal> for RefNode<'a>

pub fn from(x: &'a InputTerminal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InsideExpression> for RefNode<'a>

pub fn from(x: &'a InsideExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InstClause> for RefNode<'a>

pub fn from(x: &'a InstClause) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InstName> for RefNode<'a>

pub fn from(x: &'a InstName) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InstanceIdentifier> for RefNode<'a>

pub fn from(x: &'a InstanceIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IntegerAtomType> for RefNode<'a>

pub fn from(x: &'a IntegerAtomType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IntegerCovergroupExpression> for RefNode<'a>

pub fn from(x: &'a IntegerCovergroupExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IntegerType> for RefNode<'a>

pub fn from(x: &'a IntegerType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IntegerVectorType> for RefNode<'a>

pub fn from(x: &'a IntegerVectorType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a IntegralNumber> for RefNode<'a>

pub fn from(x: &'a IntegralNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Interface> for RefNode<'a>

pub fn from(x: &'a Interface) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceAnsiHeader> for RefNode<'a>

pub fn from(x: &'a InterfaceAnsiHeader) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceClassDeclaration> for RefNode<'a>

pub fn from(x: &'a InterfaceClassDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceClassItem> for RefNode<'a>

pub fn from(x: &'a InterfaceClassItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceClassItemMethod> for RefNode<'a>

pub fn from(x: &'a InterfaceClassItemMethod) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceClassMethod> for RefNode<'a>

pub fn from(x: &'a InterfaceClassMethod) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceClassType> for RefNode<'a>

pub fn from(x: &'a InterfaceClassType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceDeclaration> for RefNode<'a>

pub fn from(x: &'a InterfaceDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceDeclarationAnsi> for RefNode<'a>

pub fn from(x: &'a InterfaceDeclarationAnsi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceDeclarationExternAnsi> for RefNode<'a>

pub fn from(x: &'a InterfaceDeclarationExternAnsi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceDeclarationExternNonansi> for RefNode<'a>

pub fn from(x: &'a InterfaceDeclarationExternNonansi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceDeclarationNonansi> for RefNode<'a>

pub fn from(x: &'a InterfaceDeclarationNonansi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceDeclarationWildcard> for RefNode<'a>

pub fn from(x: &'a InterfaceDeclarationWildcard) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceIdentifier> for RefNode<'a>

pub fn from(x: &'a InterfaceIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceIdentifierOrClassScope> for RefNode<'a>

pub fn from(x: &'a InterfaceIdentifierOrClassScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceInstanceIdentifier> for RefNode<'a>

pub fn from(x: &'a InterfaceInstanceIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceInstantiation> for RefNode<'a>

pub fn from(x: &'a InterfaceInstantiation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceItem> for RefNode<'a>

pub fn from(x: &'a InterfaceItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceNonansiHeader> for RefNode<'a>

pub fn from(x: &'a InterfaceNonansiHeader) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceOrGenerateItem> for RefNode<'a>

pub fn from(x: &'a InterfaceOrGenerateItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceOrGenerateItemExtern> for RefNode<'a>

pub fn from(x: &'a InterfaceOrGenerateItemExtern) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfaceOrGenerateItemModule> for RefNode<'a>

pub fn from(x: &'a InterfaceOrGenerateItemModule) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfacePortDeclaration> for RefNode<'a>

pub fn from(x: &'a InterfacePortDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfacePortHeader> for RefNode<'a>

pub fn from(x: &'a InterfacePortHeader) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfacePortHeaderIdentifier> for RefNode<'a>

pub fn from(x: &'a InterfacePortHeaderIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a InterfacePortHeaderInterface> for RefNode<'a>

pub fn from(x: &'a InterfacePortHeaderInterface) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a JoinKeyword> for RefNode<'a>

pub fn from(x: &'a JoinKeyword) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a JumpStatement> for RefNode<'a>

pub fn from(x: &'a JumpStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a JumpStatementBreak> for RefNode<'a>

pub fn from(x: &'a JumpStatementBreak) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a JumpStatementContinue> for RefNode<'a>

pub fn from(x: &'a JumpStatementContinue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a JumpStatementReturn> for RefNode<'a>

pub fn from(x: &'a JumpStatementReturn) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Keyword> for RefNode<'a>

pub fn from(x: &'a Keyword) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a KeywordsDirective> for RefNode<'a>

pub fn from(x: &'a KeywordsDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LetActualArg> for RefNode<'a>

pub fn from(x: &'a LetActualArg) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LetDeclaration> for RefNode<'a>

pub fn from(x: &'a LetDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LetExpression> for RefNode<'a>

pub fn from(x: &'a LetExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LetFormalType> for RefNode<'a>

pub fn from(x: &'a LetFormalType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LetIdentifier> for RefNode<'a>

pub fn from(x: &'a LetIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LetListOfArguments> for RefNode<'a>

pub fn from(x: &'a LetListOfArguments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LetListOfArgumentsNamed> for RefNode<'a>

pub fn from(x: &'a LetListOfArgumentsNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LetListOfArgumentsOrdered> for RefNode<'a>

pub fn from(x: &'a LetListOfArgumentsOrdered) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LetPortItem> for RefNode<'a>

pub fn from(x: &'a LetPortItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LetPortList> for RefNode<'a>

pub fn from(x: &'a LetPortList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Level> for RefNode<'a>

pub fn from(x: &'a Level) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LevelInputList> for RefNode<'a>

pub fn from(x: &'a LevelInputList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LevelSymbol> for RefNode<'a>

pub fn from(x: &'a LevelSymbol) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LiblistClause> for RefNode<'a>

pub fn from(x: &'a LiblistClause) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LibraryDeclaration> for RefNode<'a>

pub fn from(x: &'a LibraryDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LibraryDescription> for RefNode<'a>

pub fn from(x: &'a LibraryDescription) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LibraryIdentifier> for RefNode<'a>

pub fn from(x: &'a LibraryIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LibraryText> for RefNode<'a>

pub fn from(x: &'a LibraryText) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Lifetime> for RefNode<'a>

pub fn from(x: &'a Lifetime) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LimitValue> for RefNode<'a>

pub fn from(x: &'a LimitValue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LineCompilerDirective> for RefNode<'a>

pub fn from(x: &'a LineCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfActualArguments> for RefNode<'a>

pub fn from(x: &'a ListOfActualArguments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfArguments> for RefNode<'a>

pub fn from(x: &'a ListOfArguments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfArgumentsNamed> for RefNode<'a>

pub fn from(x: &'a ListOfArgumentsNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfArgumentsOrdered> for RefNode<'a>

pub fn from(x: &'a ListOfArgumentsOrdered) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfCheckerPortConnections> for RefNode<'a>

pub fn from(x: &'a ListOfCheckerPortConnections) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfCheckerPortConnectionsNamed> for RefNode<'a>

pub fn from(x: &'a ListOfCheckerPortConnectionsNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfCheckerPortConnectionsOrdered> for RefNode<'a>

pub fn from(x: &'a ListOfCheckerPortConnectionsOrdered) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfClockingDeclAssign> for RefNode<'a>

pub fn from(x: &'a ListOfClockingDeclAssign) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfCrossItems> for RefNode<'a>

pub fn from(x: &'a ListOfCrossItems) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfDefparamAssignments> for RefNode<'a>

pub fn from(x: &'a ListOfDefparamAssignments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfFormalArguments> for RefNode<'a>

pub fn from(x: &'a ListOfFormalArguments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfGenvarIdentifiers> for RefNode<'a>

pub fn from(x: &'a ListOfGenvarIdentifiers) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfInterfaceIdentifiers> for RefNode<'a>

pub fn from(x: &'a ListOfInterfaceIdentifiers) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfNetAssignments> for RefNode<'a>

pub fn from(x: &'a ListOfNetAssignments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfNetDeclAssignments> for RefNode<'a>

pub fn from(x: &'a ListOfNetDeclAssignments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfParamAssignments> for RefNode<'a>

pub fn from(x: &'a ListOfParamAssignments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfParameterAssignments> for RefNode<'a>

pub fn from(x: &'a ListOfParameterAssignments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfParameterAssignmentsNamed> for RefNode<'a>

pub fn from(x: &'a ListOfParameterAssignmentsNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfParameterAssignmentsOrdered> for RefNode<'a>

pub fn from(x: &'a ListOfParameterAssignmentsOrdered) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfPathDelayExpressions> for RefNode<'a>

pub fn from(x: &'a ListOfPathDelayExpressions) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfPathInputs> for RefNode<'a>

pub fn from(x: &'a ListOfPathInputs) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfPathOutputs> for RefNode<'a>

pub fn from(x: &'a ListOfPathOutputs) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfPortConnections> for RefNode<'a>

pub fn from(x: &'a ListOfPortConnections) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfPortConnectionsNamed> for RefNode<'a>

pub fn from(x: &'a ListOfPortConnectionsNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfPortConnectionsOrdered> for RefNode<'a>

pub fn from(x: &'a ListOfPortConnectionsOrdered) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfPortDeclarations> for RefNode<'a>

pub fn from(x: &'a ListOfPortDeclarations) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfPortIdentifiers> for RefNode<'a>

pub fn from(x: &'a ListOfPortIdentifiers) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfPorts> for RefNode<'a>

pub fn from(x: &'a ListOfPorts) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfSpecparamAssignments> for RefNode<'a>

pub fn from(x: &'a ListOfSpecparamAssignments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfTfVariableIdentifiers> for RefNode<'a>

pub fn from(x: &'a ListOfTfVariableIdentifiers) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfTypeAssignments> for RefNode<'a>

pub fn from(x: &'a ListOfTypeAssignments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfUdpPortIdentifiers> for RefNode<'a>

pub fn from(x: &'a ListOfUdpPortIdentifiers) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfVariableAssignments> for RefNode<'a>

pub fn from(x: &'a ListOfVariableAssignments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfVariableDeclAssignments> for RefNode<'a>

pub fn from(x: &'a ListOfVariableDeclAssignments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfVariableIdentifiers> for RefNode<'a>

pub fn from(x: &'a ListOfVariableIdentifiers) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ListOfVariablePortIdentifiers> for RefNode<'a>

pub fn from(x: &'a ListOfVariablePortIdentifiers) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Local> for RefNode<'a>

pub fn from(x: &'a Local) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LocalOrPackageScopeOrClassScope> for RefNode<'a>

pub fn from(x: &'a LocalOrPackageScopeOrClassScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LocalParameterDeclaration> for RefNode<'a>

pub fn from(x: &'a LocalParameterDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LocalParameterDeclarationParam> for RefNode<'a>

pub fn from(x: &'a LocalParameterDeclarationParam) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LocalParameterDeclarationType> for RefNode<'a>

pub fn from(x: &'a LocalParameterDeclarationType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LoopGenerateConstruct> for RefNode<'a>

pub fn from(x: &'a LoopGenerateConstruct) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LoopStatement> for RefNode<'a>

pub fn from(x: &'a LoopStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LoopStatementDoWhile> for RefNode<'a>

pub fn from(x: &'a LoopStatementDoWhile) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LoopStatementFor> for RefNode<'a>

pub fn from(x: &'a LoopStatementFor) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LoopStatementForeach> for RefNode<'a>

pub fn from(x: &'a LoopStatementForeach) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LoopStatementForever> for RefNode<'a>

pub fn from(x: &'a LoopStatementForever) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LoopStatementRepeat> for RefNode<'a>

pub fn from(x: &'a LoopStatementRepeat) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LoopStatementWhile> for RefNode<'a>

pub fn from(x: &'a LoopStatementWhile) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a LoopVariables> for RefNode<'a>

pub fn from(x: &'a LoopVariables) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MacroText> for RefNode<'a>

pub fn from(x: &'a MacroText) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MemberIdentifier> for RefNode<'a>

pub fn from(x: &'a MemberIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MethodCall> for RefNode<'a>

pub fn from(x: &'a MethodCall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MethodCallBody> for RefNode<'a>

pub fn from(x: &'a MethodCallBody) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MethodCallBodyUser> for RefNode<'a>

pub fn from(x: &'a MethodCallBodyUser) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MethodCallRoot> for RefNode<'a>

pub fn from(x: &'a MethodCallRoot) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MethodIdentifier> for RefNode<'a>

pub fn from(x: &'a MethodIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MethodPrototype> for RefNode<'a>

pub fn from(x: &'a MethodPrototype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MethodQualifier> for RefNode<'a>

pub fn from(x: &'a MethodQualifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MintypmaxExpression> for RefNode<'a>

pub fn from(x: &'a MintypmaxExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MintypmaxExpressionTernary> for RefNode<'a>

pub fn from(x: &'a MintypmaxExpressionTernary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportClockingDeclaration> for RefNode<'a>

pub fn from(x: &'a ModportClockingDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportDeclaration> for RefNode<'a>

pub fn from(x: &'a ModportDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportIdentifier> for RefNode<'a>

pub fn from(x: &'a ModportIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportItem> for RefNode<'a>

pub fn from(x: &'a ModportItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportPortsDeclaration> for RefNode<'a>

pub fn from(x: &'a ModportPortsDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportPortsDeclarationClocking> for RefNode<'a>

pub fn from(x: &'a ModportPortsDeclarationClocking) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportPortsDeclarationSimple> for RefNode<'a>

pub fn from(x: &'a ModportPortsDeclarationSimple) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportPortsDeclarationTf> for RefNode<'a>

pub fn from(x: &'a ModportPortsDeclarationTf) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportSimplePort> for RefNode<'a>

pub fn from(x: &'a ModportSimplePort) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportSimplePortNamed> for RefNode<'a>

pub fn from(x: &'a ModportSimplePortNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportSimplePortOrdered> for RefNode<'a>

pub fn from(x: &'a ModportSimplePortOrdered) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportSimplePortsDeclaration> for RefNode<'a>

pub fn from(x: &'a ModportSimplePortsDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportTfPort> for RefNode<'a>

pub fn from(x: &'a ModportTfPort) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModportTfPortsDeclaration> for RefNode<'a>

pub fn from(x: &'a ModportTfPortsDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleAnsiHeader> for RefNode<'a>

pub fn from(x: &'a ModuleAnsiHeader) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleCommonItem> for RefNode<'a>

pub fn from(x: &'a ModuleCommonItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleDeclaration> for RefNode<'a>

pub fn from(x: &'a ModuleDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleDeclarationAnsi> for RefNode<'a>

pub fn from(x: &'a ModuleDeclarationAnsi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleDeclarationExternAnsi> for RefNode<'a>

pub fn from(x: &'a ModuleDeclarationExternAnsi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleDeclarationExternNonansi> for RefNode<'a>

pub fn from(x: &'a ModuleDeclarationExternNonansi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleDeclarationNonansi> for RefNode<'a>

pub fn from(x: &'a ModuleDeclarationNonansi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleDeclarationWildcard> for RefNode<'a>

pub fn from(x: &'a ModuleDeclarationWildcard) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleIdentifier> for RefNode<'a>

pub fn from(x: &'a ModuleIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleInstantiation> for RefNode<'a>

pub fn from(x: &'a ModuleInstantiation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleItem> for RefNode<'a>

pub fn from(x: &'a ModuleItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleKeyword> for RefNode<'a>

pub fn from(x: &'a ModuleKeyword) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleNonansiHeader> for RefNode<'a>

pub fn from(x: &'a ModuleNonansiHeader) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleOrGenerateItem> for RefNode<'a>

pub fn from(x: &'a ModuleOrGenerateItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleOrGenerateItemDeclaration> for RefNode<'a>

pub fn from(x: &'a ModuleOrGenerateItemDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleOrGenerateItemDeclarationClocking> for RefNode<'a>

pub fn from(x: &'a ModuleOrGenerateItemDeclarationClocking) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleOrGenerateItemDeclarationDisable> for RefNode<'a>

pub fn from(x: &'a ModuleOrGenerateItemDeclarationDisable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleOrGenerateItemGate> for RefNode<'a>

pub fn from(x: &'a ModuleOrGenerateItemGate) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleOrGenerateItemModule> for RefNode<'a>

pub fn from(x: &'a ModuleOrGenerateItemModule) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleOrGenerateItemModuleItem> for RefNode<'a>

pub fn from(x: &'a ModuleOrGenerateItemModuleItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleOrGenerateItemParameter> for RefNode<'a>

pub fn from(x: &'a ModuleOrGenerateItemParameter) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModuleOrGenerateItemUdp> for RefNode<'a>

pub fn from(x: &'a ModuleOrGenerateItemUdp) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModulePathConcatenation> for RefNode<'a>

pub fn from(x: &'a ModulePathConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModulePathConditionalExpression> for RefNode<'a>

pub fn from(x: &'a ModulePathConditionalExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModulePathExpression> for RefNode<'a>

pub fn from(x: &'a ModulePathExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModulePathExpressionBinary> for RefNode<'a>

pub fn from(x: &'a ModulePathExpressionBinary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModulePathExpressionUnary> for RefNode<'a>

pub fn from(x: &'a ModulePathExpressionUnary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModulePathMintypmaxExpression> for RefNode<'a>

pub fn from(x: &'a ModulePathMintypmaxExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModulePathMintypmaxExpressionTernary> for RefNode<'a>

pub fn from(x: &'a ModulePathMintypmaxExpressionTernary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModulePathMultipleConcatenation> for RefNode<'a>

pub fn from(x: &'a ModulePathMultipleConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModulePathPrimary> for RefNode<'a>

pub fn from(x: &'a ModulePathPrimary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ModulePathPrimaryMintypmax> for RefNode<'a>

pub fn from(x: &'a ModulePathPrimaryMintypmax) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MosSwitchInstance> for RefNode<'a>

pub fn from(x: &'a MosSwitchInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MosSwitchtype> for RefNode<'a>

pub fn from(x: &'a MosSwitchtype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a MultipleConcatenation> for RefNode<'a>

pub fn from(x: &'a MultipleConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NInputGateInstance> for RefNode<'a>

pub fn from(x: &'a NInputGateInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NInputGatetype> for RefNode<'a>

pub fn from(x: &'a NInputGatetype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NOutputGateInstance> for RefNode<'a>

pub fn from(x: &'a NOutputGateInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NOutputGatetype> for RefNode<'a>

pub fn from(x: &'a NOutputGatetype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NameOfInstance> for RefNode<'a>

pub fn from(x: &'a NameOfInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NamedCheckerPortConnection> for RefNode<'a>

pub fn from(x: &'a NamedCheckerPortConnection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NamedCheckerPortConnectionAsterisk> for RefNode<'a>

pub fn from(x: &'a NamedCheckerPortConnectionAsterisk) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NamedCheckerPortConnectionIdentifier> for RefNode<'a>

pub fn from(x: &'a NamedCheckerPortConnectionIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NamedParameterAssignment> for RefNode<'a>

pub fn from(x: &'a NamedParameterAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NamedPortConnection> for RefNode<'a>

pub fn from(x: &'a NamedPortConnection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NamedPortConnectionAsterisk> for RefNode<'a>

pub fn from(x: &'a NamedPortConnectionAsterisk) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NamedPortConnectionIdentifier> for RefNode<'a>

pub fn from(x: &'a NamedPortConnectionIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NcontrolTerminal> for RefNode<'a>

pub fn from(x: &'a NcontrolTerminal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetAlias> for RefNode<'a>

pub fn from(x: &'a NetAlias) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetAssignment> for RefNode<'a>

pub fn from(x: &'a NetAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetDeclAssignment> for RefNode<'a>

pub fn from(x: &'a NetDeclAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetDeclaration> for RefNode<'a>

pub fn from(x: &'a NetDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetDeclarationInterconnect> for RefNode<'a>

pub fn from(x: &'a NetDeclarationInterconnect) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetDeclarationNetType> for RefNode<'a>

pub fn from(x: &'a NetDeclarationNetType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetDeclarationNetTypeIdentifier> for RefNode<'a>

pub fn from(x: &'a NetDeclarationNetTypeIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetIdentifier> for RefNode<'a>

pub fn from(x: &'a NetIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetLvalue> for RefNode<'a>

pub fn from(x: &'a NetLvalue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetLvalueIdentifier> for RefNode<'a>

pub fn from(x: &'a NetLvalueIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetLvalueLvalue> for RefNode<'a>

pub fn from(x: &'a NetLvalueLvalue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetLvaluePattern> for RefNode<'a>

pub fn from(x: &'a NetLvaluePattern) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetPortHeader> for RefNode<'a>

pub fn from(x: &'a NetPortHeader) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetPortHeaderOrInterfacePortHeader> for RefNode<'a>

pub fn from(x: &'a NetPortHeaderOrInterfacePortHeader) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetPortType> for RefNode<'a>

pub fn from(x: &'a NetPortType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetPortTypeDataType> for RefNode<'a>

pub fn from(x: &'a NetPortTypeDataType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetPortTypeInterconnect> for RefNode<'a>

pub fn from(x: &'a NetPortTypeInterconnect) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetType> for RefNode<'a>

pub fn from(x: &'a NetType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetTypeDeclaration> for RefNode<'a>

pub fn from(x: &'a NetTypeDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetTypeDeclarationDataType> for RefNode<'a>

pub fn from(x: &'a NetTypeDeclarationDataType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetTypeDeclarationNetType> for RefNode<'a>

pub fn from(x: &'a NetTypeDeclarationNetType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NetTypeIdentifier> for RefNode<'a>

pub fn from(x: &'a NetTypeIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a New> for RefNode<'a>

pub fn from(x: &'a New) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NextState> for RefNode<'a>

pub fn from(x: &'a NextState) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NochangeTimingCheck> for RefNode<'a>

pub fn from(x: &'a NochangeTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonConsecutiveRepetition> for RefNode<'a>

pub fn from(x: &'a NonConsecutiveRepetition) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonIntegerType> for RefNode<'a>

pub fn from(x: &'a NonIntegerType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonPortInterfaceItem> for RefNode<'a>

pub fn from(x: &'a NonPortInterfaceItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonPortModuleItem> for RefNode<'a>

pub fn from(x: &'a NonPortModuleItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonPortModuleItemSpecparam> for RefNode<'a>

pub fn from(x: &'a NonPortModuleItemSpecparam) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonPortProgramItem> for RefNode<'a>

pub fn from(x: &'a NonPortProgramItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonPortProgramItemAssertion> for RefNode<'a>

pub fn from(x: &'a NonPortProgramItemAssertion) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonPortProgramItemAssign> for RefNode<'a>

pub fn from(x: &'a NonPortProgramItemAssign) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonPortProgramItemFinal> for RefNode<'a>

pub fn from(x: &'a NonPortProgramItemFinal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonPortProgramItemInitial> for RefNode<'a>

pub fn from(x: &'a NonPortProgramItemInitial) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonPortProgramItemModule> for RefNode<'a>

pub fn from(x: &'a NonPortProgramItemModule) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonZeroUnsignedNumber> for RefNode<'a>

pub fn from(x: &'a NonZeroUnsignedNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonblockingAssignment> for RefNode<'a>

pub fn from(x: &'a NonblockingAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonrangeSelect> for RefNode<'a>

pub fn from(x: &'a NonrangeSelect) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NonrangeVariableLvalue> for RefNode<'a>

pub fn from(x: &'a NonrangeVariableLvalue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Notifier> for RefNode<'a>

pub fn from(x: &'a Notifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a NounconnectedDriveCompilerDirective> for RefNode<'a>

pub fn from(x: &'a NounconnectedDriveCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Number> for RefNode<'a>

pub fn from(x: &'a Number) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OctalBase> for RefNode<'a>

pub fn from(x: &'a OctalBase) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OctalNumber> for RefNode<'a>

pub fn from(x: &'a OctalNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OctalValue> for RefNode<'a>

pub fn from(x: &'a OctalValue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OpenRangeList> for RefNode<'a>

pub fn from(x: &'a OpenRangeList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OpenValueRange> for RefNode<'a>

pub fn from(x: &'a OpenValueRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OperatorAssignment> for RefNode<'a>

pub fn from(x: &'a OperatorAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OrderedCheckerPortConnection> for RefNode<'a>

pub fn from(x: &'a OrderedCheckerPortConnection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OrderedParameterAssignment> for RefNode<'a>

pub fn from(x: &'a OrderedParameterAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OrderedPortConnection> for RefNode<'a>

pub fn from(x: &'a OrderedPortConnection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OutputDeclaration> for RefNode<'a>

pub fn from(x: &'a OutputDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OutputDeclarationNet> for RefNode<'a>

pub fn from(x: &'a OutputDeclarationNet) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OutputDeclarationVariable> for RefNode<'a>

pub fn from(x: &'a OutputDeclarationVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OutputIdentifier> for RefNode<'a>

pub fn from(x: &'a OutputIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OutputIdentifierInterface> for RefNode<'a>

pub fn from(x: &'a OutputIdentifierInterface) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OutputPortIdentifier> for RefNode<'a>

pub fn from(x: &'a OutputPortIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OutputSymbol> for RefNode<'a>

pub fn from(x: &'a OutputSymbol) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a OutputTerminal> for RefNode<'a>

pub fn from(x: &'a OutputTerminal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageDeclaration> for RefNode<'a>

pub fn from(x: &'a PackageDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageExportDeclaration> for RefNode<'a>

pub fn from(x: &'a PackageExportDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageExportDeclarationAsterisk> for RefNode<'a>

pub fn from(x: &'a PackageExportDeclarationAsterisk) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageExportDeclarationItem> for RefNode<'a>

pub fn from(x: &'a PackageExportDeclarationItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageIdentifier> for RefNode<'a>

pub fn from(x: &'a PackageIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageImportDeclaration> for RefNode<'a>

pub fn from(x: &'a PackageImportDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageImportItem> for RefNode<'a>

pub fn from(x: &'a PackageImportItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageImportItemAsterisk> for RefNode<'a>

pub fn from(x: &'a PackageImportItemAsterisk) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageImportItemIdentifier> for RefNode<'a>

pub fn from(x: &'a PackageImportItemIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageItem> for RefNode<'a>

pub fn from(x: &'a PackageItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageOrGenerateItemDeclaration> for RefNode<'a>

pub fn from(x: &'a PackageOrGenerateItemDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageScope> for RefNode<'a>

pub fn from(x: &'a PackageScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageScopeOrClassScope> for RefNode<'a>

pub fn from(x: &'a PackageScopeOrClassScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackageScopePackage> for RefNode<'a>

pub fn from(x: &'a PackageScopePackage) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Packed> for RefNode<'a>

pub fn from(x: &'a Packed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackedDimension> for RefNode<'a>

pub fn from(x: &'a PackedDimension) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PackedDimensionRange> for RefNode<'a>

pub fn from(x: &'a PackedDimensionRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParBlock> for RefNode<'a>

pub fn from(x: &'a ParBlock) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParallelEdgeSensitivePathDescription> for RefNode<'a>

pub fn from(x: &'a ParallelEdgeSensitivePathDescription) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParallelPathDescription> for RefNode<'a>

pub fn from(x: &'a ParallelPathDescription) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParamAssignment> for RefNode<'a>

pub fn from(x: &'a ParamAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParamExpression> for RefNode<'a>

pub fn from(x: &'a ParamExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterDeclaration> for RefNode<'a>

pub fn from(x: &'a ParameterDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterDeclarationParam> for RefNode<'a>

pub fn from(x: &'a ParameterDeclarationParam) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterDeclarationType> for RefNode<'a>

pub fn from(x: &'a ParameterDeclarationType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterIdentifier> for RefNode<'a>

pub fn from(x: &'a ParameterIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterOverride> for RefNode<'a>

pub fn from(x: &'a ParameterOverride) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterPortDeclaration> for RefNode<'a>

pub fn from(x: &'a ParameterPortDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterPortDeclarationParamList> for RefNode<'a>

pub fn from(x: &'a ParameterPortDeclarationParamList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterPortDeclarationTypeList> for RefNode<'a>

pub fn from(x: &'a ParameterPortDeclarationTypeList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterPortList> for RefNode<'a>

pub fn from(x: &'a ParameterPortList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterPortListAssignment> for RefNode<'a>

pub fn from(x: &'a ParameterPortListAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterPortListDeclaration> for RefNode<'a>

pub fn from(x: &'a ParameterPortListDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ParameterValueAssignment> for RefNode<'a>

pub fn from(x: &'a ParameterValueAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PartSelectRange> for RefNode<'a>

pub fn from(x: &'a PartSelectRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PassEnSwitchtype> for RefNode<'a>

pub fn from(x: &'a PassEnSwitchtype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PassEnableSwitchInstance> for RefNode<'a>

pub fn from(x: &'a PassEnableSwitchInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PassSwitchInstance> for RefNode<'a>

pub fn from(x: &'a PassSwitchInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PassSwitchtype> for RefNode<'a>

pub fn from(x: &'a PassSwitchtype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PathDeclaration> for RefNode<'a>

pub fn from(x: &'a PathDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PathDelayExpression> for RefNode<'a>

pub fn from(x: &'a PathDelayExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PathDelayValue> for RefNode<'a>

pub fn from(x: &'a PathDelayValue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PathDelayValueParen> for RefNode<'a>

pub fn from(x: &'a PathDelayValueParen) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Pattern> for RefNode<'a>

pub fn from(x: &'a Pattern) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PatternIdentifierList> for RefNode<'a>

pub fn from(x: &'a PatternIdentifierList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PatternList> for RefNode<'a>

pub fn from(x: &'a PatternList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PatternTagged> for RefNode<'a>

pub fn from(x: &'a PatternTagged) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PatternVariable> for RefNode<'a>

pub fn from(x: &'a PatternVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PcontrolTerminal> for RefNode<'a>

pub fn from(x: &'a PcontrolTerminal) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PeriodTimingCheck> for RefNode<'a>

pub fn from(x: &'a PeriodTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PolarityOperator> for RefNode<'a>

pub fn from(x: &'a PolarityOperator) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Port> for RefNode<'a>

pub fn from(x: &'a Port) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortDeclaration> for RefNode<'a>

pub fn from(x: &'a PortDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortDeclarationInout> for RefNode<'a>

pub fn from(x: &'a PortDeclarationInout) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortDeclarationInput> for RefNode<'a>

pub fn from(x: &'a PortDeclarationInput) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortDeclarationInterface> for RefNode<'a>

pub fn from(x: &'a PortDeclarationInterface) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortDeclarationOutput> for RefNode<'a>

pub fn from(x: &'a PortDeclarationOutput) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortDeclarationRef> for RefNode<'a>

pub fn from(x: &'a PortDeclarationRef) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortDirection> for RefNode<'a>

pub fn from(x: &'a PortDirection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortExpression> for RefNode<'a>

pub fn from(x: &'a PortExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortExpressionBrace> for RefNode<'a>

pub fn from(x: &'a PortExpressionBrace) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortIdentifier> for RefNode<'a>

pub fn from(x: &'a PortIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortNamed> for RefNode<'a>

pub fn from(x: &'a PortNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortNonNamed> for RefNode<'a>

pub fn from(x: &'a PortNonNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PortReference> for RefNode<'a>

pub fn from(x: &'a PortReference) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PositionCompilerDirective> for RefNode<'a>

pub fn from(x: &'a PositionCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Pragma> for RefNode<'a>

pub fn from(x: &'a Pragma) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PragmaExpression> for RefNode<'a>

pub fn from(x: &'a PragmaExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PragmaExpressionAssignment> for RefNode<'a>

pub fn from(x: &'a PragmaExpressionAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PragmaKeyword> for RefNode<'a>

pub fn from(x: &'a PragmaKeyword) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PragmaName> for RefNode<'a>

pub fn from(x: &'a PragmaName) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PragmaValue> for RefNode<'a>

pub fn from(x: &'a PragmaValue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PragmaValueParen> for RefNode<'a>

pub fn from(x: &'a PragmaValueParen) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PreprocessorText> for RefNode<'a>

pub fn from(x: &'a PreprocessorText) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Primary> for RefNode<'a>

pub fn from(x: &'a Primary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PrimaryConcatenation> for RefNode<'a>

pub fn from(x: &'a PrimaryConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PrimaryHierarchical> for RefNode<'a>

pub fn from(x: &'a PrimaryHierarchical) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PrimaryLiteral> for RefNode<'a>

pub fn from(x: &'a PrimaryLiteral) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PrimaryMintypmaxExpression> for RefNode<'a>

pub fn from(x: &'a PrimaryMintypmaxExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PrimaryMultipleConcatenation> for RefNode<'a>

pub fn from(x: &'a PrimaryMultipleConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProceduralAssertionStatement> for RefNode<'a>

pub fn from(x: &'a ProceduralAssertionStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProceduralContinuousAssignment> for RefNode<'a>

pub fn from(x: &'a ProceduralContinuousAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProceduralContinuousAssignmentAssign> for RefNode<'a>

pub fn from(x: &'a ProceduralContinuousAssignmentAssign) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProceduralContinuousAssignmentDeassign> for RefNode<'a>

pub fn from(x: &'a ProceduralContinuousAssignmentDeassign) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProceduralContinuousAssignmentForceNet> for RefNode<'a>

pub fn from(x: &'a ProceduralContinuousAssignmentForceNet) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProceduralContinuousAssignmentForceVariable> for RefNode<'a>

pub fn from(x: &'a ProceduralContinuousAssignmentForceVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProceduralContinuousAssignmentReleaseNet> for RefNode<'a>

pub fn from(x: &'a ProceduralContinuousAssignmentReleaseNet) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProceduralContinuousAssignmentReleaseVariable> for RefNode<'a>

pub fn from(x: &'a ProceduralContinuousAssignmentReleaseVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProceduralTimingControl> for RefNode<'a>

pub fn from(x: &'a ProceduralTimingControl) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProceduralTimingControlStatement> for RefNode<'a>

pub fn from(x: &'a ProceduralTimingControlStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Production> for RefNode<'a>

pub fn from(x: &'a Production) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProductionIdentifier> for RefNode<'a>

pub fn from(x: &'a ProductionIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProductionItem> for RefNode<'a>

pub fn from(x: &'a ProductionItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramAnsiHeader> for RefNode<'a>

pub fn from(x: &'a ProgramAnsiHeader) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramDeclaration> for RefNode<'a>

pub fn from(x: &'a ProgramDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramDeclarationAnsi> for RefNode<'a>

pub fn from(x: &'a ProgramDeclarationAnsi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramDeclarationExternAnsi> for RefNode<'a>

pub fn from(x: &'a ProgramDeclarationExternAnsi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramDeclarationExternNonansi> for RefNode<'a>

pub fn from(x: &'a ProgramDeclarationExternNonansi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramDeclarationNonansi> for RefNode<'a>

pub fn from(x: &'a ProgramDeclarationNonansi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramDeclarationWildcard> for RefNode<'a>

pub fn from(x: &'a ProgramDeclarationWildcard) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramGenerateItem> for RefNode<'a>

pub fn from(x: &'a ProgramGenerateItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramIdentifier> for RefNode<'a>

pub fn from(x: &'a ProgramIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramInstantiation> for RefNode<'a>

pub fn from(x: &'a ProgramInstantiation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramItem> for RefNode<'a>

pub fn from(x: &'a ProgramItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ProgramNonansiHeader> for RefNode<'a>

pub fn from(x: &'a ProgramNonansiHeader) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyActualArg> for RefNode<'a>

pub fn from(x: &'a PropertyActualArg) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyCaseItem> for RefNode<'a>

pub fn from(x: &'a PropertyCaseItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyCaseItemDefault> for RefNode<'a>

pub fn from(x: &'a PropertyCaseItemDefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyCaseItemNondefault> for RefNode<'a>

pub fn from(x: &'a PropertyCaseItemNondefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyDeclaration> for RefNode<'a>

pub fn from(x: &'a PropertyDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExpr> for RefNode<'a>

pub fn from(x: &'a PropertyExpr) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprAcceptOn> for RefNode<'a>

pub fn from(x: &'a PropertyExprAcceptOn) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprAlways> for RefNode<'a>

pub fn from(x: &'a PropertyExprAlways) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprBinaryProperty> for RefNode<'a>

pub fn from(x: &'a PropertyExprBinaryProperty) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprBinarySequence> for RefNode<'a>

pub fn from(x: &'a PropertyExprBinarySequence) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprCase> for RefNode<'a>

pub fn from(x: &'a PropertyExprCase) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprClockingEvent> for RefNode<'a>

pub fn from(x: &'a PropertyExprClockingEvent) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprEventually> for RefNode<'a>

pub fn from(x: &'a PropertyExprEventually) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprIf> for RefNode<'a>

pub fn from(x: &'a PropertyExprIf) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprNexttime> for RefNode<'a>

pub fn from(x: &'a PropertyExprNexttime) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprNot> for RefNode<'a>

pub fn from(x: &'a PropertyExprNot) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprParen> for RefNode<'a>

pub fn from(x: &'a PropertyExprParen) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprRejectOn> for RefNode<'a>

pub fn from(x: &'a PropertyExprRejectOn) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprSAlways> for RefNode<'a>

pub fn from(x: &'a PropertyExprSAlways) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprSEventually> for RefNode<'a>

pub fn from(x: &'a PropertyExprSEventually) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprSNexttime> for RefNode<'a>

pub fn from(x: &'a PropertyExprSNexttime) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprStrong> for RefNode<'a>

pub fn from(x: &'a PropertyExprStrong) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprSyncAcceptOn> for RefNode<'a>

pub fn from(x: &'a PropertyExprSyncAcceptOn) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprSyncRejectOn> for RefNode<'a>

pub fn from(x: &'a PropertyExprSyncRejectOn) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyExprWeak> for RefNode<'a>

pub fn from(x: &'a PropertyExprWeak) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyFormalType> for RefNode<'a>

pub fn from(x: &'a PropertyFormalType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyIdentifier> for RefNode<'a>

pub fn from(x: &'a PropertyIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyInstance> for RefNode<'a>

pub fn from(x: &'a PropertyInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyListOfArguments> for RefNode<'a>

pub fn from(x: &'a PropertyListOfArguments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyListOfArgumentsNamed> for RefNode<'a>

pub fn from(x: &'a PropertyListOfArgumentsNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyListOfArgumentsOrdered> for RefNode<'a>

pub fn from(x: &'a PropertyListOfArgumentsOrdered) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyLvarPortDirection> for RefNode<'a>

pub fn from(x: &'a PropertyLvarPortDirection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyPortItem> for RefNode<'a>

pub fn from(x: &'a PropertyPortItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyPortList> for RefNode<'a>

pub fn from(x: &'a PropertyPortList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertyQualifier> for RefNode<'a>

pub fn from(x: &'a PropertyQualifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PropertySpec> for RefNode<'a>

pub fn from(x: &'a PropertySpec) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsCheckerIdentifier> for RefNode<'a>

pub fn from(x: &'a PsCheckerIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsClassIdentifier> for RefNode<'a>

pub fn from(x: &'a PsClassIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsCovergroupIdentifier> for RefNode<'a>

pub fn from(x: &'a PsCovergroupIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsIdentifier> for RefNode<'a>

pub fn from(x: &'a PsIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalArrayIdentifier> for RefNode<'a>

pub fn from(x: &'a PsOrHierarchicalArrayIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalNetIdentifier> for RefNode<'a>

pub fn from(x: &'a PsOrHierarchicalNetIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalNetIdentifierHierarchical> for RefNode<'a>

pub fn from(x: &'a PsOrHierarchicalNetIdentifierHierarchical) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalNetIdentifierPackageScope> for RefNode<'a>

pub fn from(x: &'a PsOrHierarchicalNetIdentifierPackageScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalPropertyIdentifier> for RefNode<'a>

pub fn from(x: &'a PsOrHierarchicalPropertyIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalPropertyIdentifierHierarchical> for RefNode<'a>

pub fn from(
    x: &'a PsOrHierarchicalPropertyIdentifierHierarchical
) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalPropertyIdentifierPackageScope> for RefNode<'a>

pub fn from(
    x: &'a PsOrHierarchicalPropertyIdentifierPackageScope
) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalSequenceIdentifier> for RefNode<'a>

pub fn from(x: &'a PsOrHierarchicalSequenceIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalSequenceIdentifierHierarchical> for RefNode<'a>

pub fn from(
    x: &'a PsOrHierarchicalSequenceIdentifierHierarchical
) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalSequenceIdentifierPackageScope> for RefNode<'a>

pub fn from(
    x: &'a PsOrHierarchicalSequenceIdentifierPackageScope
) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalTfIdentifier> for RefNode<'a>

pub fn from(x: &'a PsOrHierarchicalTfIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalTfIdentifierHierarchical> for RefNode<'a>

pub fn from(x: &'a PsOrHierarchicalTfIdentifierHierarchical) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsOrHierarchicalTfIdentifierPackageScope> for RefNode<'a>

pub fn from(x: &'a PsOrHierarchicalTfIdentifierPackageScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsParameterIdentifier> for RefNode<'a>

pub fn from(x: &'a PsParameterIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsParameterIdentifierGenerate> for RefNode<'a>

pub fn from(x: &'a PsParameterIdentifierGenerate) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsParameterIdentifierScope> for RefNode<'a>

pub fn from(x: &'a PsParameterIdentifierScope) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PsTypeIdentifier> for RefNode<'a>

pub fn from(x: &'a PsTypeIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PullGateInstance> for RefNode<'a>

pub fn from(x: &'a PullGateInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PulldownStrength> for RefNode<'a>

pub fn from(x: &'a PulldownStrength) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PulldownStrength0> for RefNode<'a>

pub fn from(x: &'a PulldownStrength0) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PulldownStrength01> for RefNode<'a>

pub fn from(x: &'a PulldownStrength01) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PulldownStrength10> for RefNode<'a>

pub fn from(x: &'a PulldownStrength10) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PullupStrength> for RefNode<'a>

pub fn from(x: &'a PullupStrength) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PullupStrength01> for RefNode<'a>

pub fn from(x: &'a PullupStrength01) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PullupStrength1> for RefNode<'a>

pub fn from(x: &'a PullupStrength1) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PullupStrength10> for RefNode<'a>

pub fn from(x: &'a PullupStrength10) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PulseControlSpecparam> for RefNode<'a>

pub fn from(x: &'a PulseControlSpecparam) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PulseControlSpecparamWithDescriptor> for RefNode<'a>

pub fn from(x: &'a PulseControlSpecparamWithDescriptor) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PulseControlSpecparamWithoutDescriptor> for RefNode<'a>

pub fn from(x: &'a PulseControlSpecparamWithoutDescriptor) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a PulsestyleDeclaration> for RefNode<'a>

pub fn from(x: &'a PulsestyleDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a QueueDimension> for RefNode<'a>

pub fn from(x: &'a QueueDimension) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Rand> for RefNode<'a>

pub fn from(x: &'a Rand) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RandcaseItem> for RefNode<'a>

pub fn from(x: &'a RandcaseItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RandcaseStatement> for RefNode<'a>

pub fn from(x: &'a RandcaseStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RandomQualifier> for RefNode<'a>

pub fn from(x: &'a RandomQualifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RandomizeCall> for RefNode<'a>

pub fn from(x: &'a RandomizeCall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RandsequenceStatement> for RefNode<'a>

pub fn from(x: &'a RandsequenceStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RangeExpression> for RefNode<'a>

pub fn from(x: &'a RangeExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RealNumber> for RefNode<'a>

pub fn from(x: &'a RealNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RealNumberFloating> for RefNode<'a>

pub fn from(x: &'a RealNumberFloating) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RecoveryTimingCheck> for RefNode<'a>

pub fn from(x: &'a RecoveryTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RecremTimingCheck> for RefNode<'a>

pub fn from(x: &'a RecremTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RefDeclaration> for RefNode<'a>

pub fn from(x: &'a RefDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ReferenceEvent> for RefNode<'a>

pub fn from(x: &'a ReferenceEvent) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RejectLimitValue> for RefNode<'a>

pub fn from(x: &'a RejectLimitValue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RemainActiveFlag> for RefNode<'a>

pub fn from(x: &'a RemainActiveFlag) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RemovalTimingCheck> for RefNode<'a>

pub fn from(x: &'a RemovalTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RepeatRange> for RefNode<'a>

pub fn from(x: &'a RepeatRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RepeatRangeBinary> for RefNode<'a>

pub fn from(x: &'a RepeatRangeBinary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ResetallCompilerDirective> for RefNode<'a>

pub fn from(x: &'a ResetallCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RestrictPropertyStatement> for RefNode<'a>

pub fn from(x: &'a RestrictPropertyStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Root> for RefNode<'a>

pub fn from(x: &'a Root) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsCase> for RefNode<'a>

pub fn from(x: &'a RsCase) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsCaseItem> for RefNode<'a>

pub fn from(x: &'a RsCaseItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsCaseItemDefault> for RefNode<'a>

pub fn from(x: &'a RsCaseItemDefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsCaseItemNondefault> for RefNode<'a>

pub fn from(x: &'a RsCaseItemNondefault) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsCodeBlock> for RefNode<'a>

pub fn from(x: &'a RsCodeBlock) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsIfElse> for RefNode<'a>

pub fn from(x: &'a RsIfElse) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsProd> for RefNode<'a>

pub fn from(x: &'a RsProd) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsProductionList> for RefNode<'a>

pub fn from(x: &'a RsProductionList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsProductionListJoin> for RefNode<'a>

pub fn from(x: &'a RsProductionListJoin) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsProductionListProd> for RefNode<'a>

pub fn from(x: &'a RsProductionListProd) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsRepeat> for RefNode<'a>

pub fn from(x: &'a RsRepeat) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a RsRule> for RefNode<'a>

pub fn from(x: &'a RsRule) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ScalarConstant> for RefNode<'a>

pub fn from(x: &'a ScalarConstant) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ScalarTimingCheckCondition> for RefNode<'a>

pub fn from(x: &'a ScalarTimingCheckCondition) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ScalarTimingCheckConditionBinary> for RefNode<'a>

pub fn from(x: &'a ScalarTimingCheckConditionBinary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ScalarTimingCheckConditionUnary> for RefNode<'a>

pub fn from(x: &'a ScalarTimingCheckConditionUnary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Select> for RefNode<'a>

pub fn from(x: &'a Select) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SelectCondition> for RefNode<'a>

pub fn from(x: &'a SelectCondition) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SelectExpression> for RefNode<'a>

pub fn from(x: &'a SelectExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SelectExpressionAnd> for RefNode<'a>

pub fn from(x: &'a SelectExpressionAnd) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SelectExpressionCrossSet> for RefNode<'a>

pub fn from(x: &'a SelectExpressionCrossSet) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SelectExpressionNot> for RefNode<'a>

pub fn from(x: &'a SelectExpressionNot) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SelectExpressionOr> for RefNode<'a>

pub fn from(x: &'a SelectExpressionOr) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SelectExpressionParen> for RefNode<'a>

pub fn from(x: &'a SelectExpressionParen) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SelectExpressionWith> for RefNode<'a>

pub fn from(x: &'a SelectExpressionWith) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SeqBlock> for RefNode<'a>

pub fn from(x: &'a SeqBlock) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SeqInputList> for RefNode<'a>

pub fn from(x: &'a SeqInputList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceAbbrev> for RefNode<'a>

pub fn from(x: &'a SequenceAbbrev) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceActualArg> for RefNode<'a>

pub fn from(x: &'a SequenceActualArg) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceDeclaration> for RefNode<'a>

pub fn from(x: &'a SequenceDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceExpr> for RefNode<'a>

pub fn from(x: &'a SequenceExpr) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceExprBinary> for RefNode<'a>

pub fn from(x: &'a SequenceExprBinary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceExprClockingEvent> for RefNode<'a>

pub fn from(x: &'a SequenceExprClockingEvent) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceExprCycleDelayExpr> for RefNode<'a>

pub fn from(x: &'a SequenceExprCycleDelayExpr) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceExprExprCycleDelayExpr> for RefNode<'a>

pub fn from(x: &'a SequenceExprExprCycleDelayExpr) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceExprExpression> for RefNode<'a>

pub fn from(x: &'a SequenceExprExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceExprFirstMatch> for RefNode<'a>

pub fn from(x: &'a SequenceExprFirstMatch) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceExprInstance> for RefNode<'a>

pub fn from(x: &'a SequenceExprInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceExprParen> for RefNode<'a>

pub fn from(x: &'a SequenceExprParen) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceExprThroughout> for RefNode<'a>

pub fn from(x: &'a SequenceExprThroughout) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceFormalType> for RefNode<'a>

pub fn from(x: &'a SequenceFormalType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceIdentifier> for RefNode<'a>

pub fn from(x: &'a SequenceIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceInstance> for RefNode<'a>

pub fn from(x: &'a SequenceInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceListOfArguments> for RefNode<'a>

pub fn from(x: &'a SequenceListOfArguments) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceListOfArgumentsNamed> for RefNode<'a>

pub fn from(x: &'a SequenceListOfArgumentsNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceListOfArgumentsOrdered> for RefNode<'a>

pub fn from(x: &'a SequenceListOfArgumentsOrdered) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceLvarPortDirection> for RefNode<'a>

pub fn from(x: &'a SequenceLvarPortDirection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceMatchItem> for RefNode<'a>

pub fn from(x: &'a SequenceMatchItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequenceMethodCall> for RefNode<'a>

pub fn from(x: &'a SequenceMethodCall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequencePortItem> for RefNode<'a>

pub fn from(x: &'a SequencePortItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequencePortList> for RefNode<'a>

pub fn from(x: &'a SequencePortList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequentialBody> for RefNode<'a>

pub fn from(x: &'a SequentialBody) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SequentialEntry> for RefNode<'a>

pub fn from(x: &'a SequentialEntry) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SetCovergroupExpression> for RefNode<'a>

pub fn from(x: &'a SetCovergroupExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SetupTimingCheck> for RefNode<'a>

pub fn from(x: &'a SetupTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SetupholdTimingCheck> for RefNode<'a>

pub fn from(x: &'a SetupholdTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ShowcancelledDeclaration> for RefNode<'a>

pub fn from(x: &'a ShowcancelledDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Sign> for RefNode<'a>

pub fn from(x: &'a Sign) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SignalIdentifier> for RefNode<'a>

pub fn from(x: &'a SignalIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Signing> for RefNode<'a>

pub fn from(x: &'a Signing) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SimpleIdentifier> for RefNode<'a>

pub fn from(x: &'a SimpleIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SimpleImmediateAssertStatement> for RefNode<'a>

pub fn from(x: &'a SimpleImmediateAssertStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SimpleImmediateAssertionStatement> for RefNode<'a>

pub fn from(x: &'a SimpleImmediateAssertionStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SimpleImmediateAssumeStatement> for RefNode<'a>

pub fn from(x: &'a SimpleImmediateAssumeStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SimpleImmediateCoverStatement> for RefNode<'a>

pub fn from(x: &'a SimpleImmediateCoverStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SimplePathDeclaration> for RefNode<'a>

pub fn from(x: &'a SimplePathDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SimplePathDeclarationFull> for RefNode<'a>

pub fn from(x: &'a SimplePathDeclarationFull) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SimplePathDeclarationParallel> for RefNode<'a>

pub fn from(x: &'a SimplePathDeclarationParallel) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SimpleType> for RefNode<'a>

pub fn from(x: &'a SimpleType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Size> for RefNode<'a>

pub fn from(x: &'a Size) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SkewTimingCheck> for RefNode<'a>

pub fn from(x: &'a SkewTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SliceSize> for RefNode<'a>

pub fn from(x: &'a SliceSize) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Soft> for RefNode<'a>

pub fn from(x: &'a Soft) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SolveBeforeList> for RefNode<'a>

pub fn from(x: &'a SolveBeforeList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SourceDescription> for RefNode<'a>

pub fn from(x: &'a SourceDescription) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SourceDescriptionNotDirective> for RefNode<'a>

pub fn from(x: &'a SourceDescriptionNotDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SourceText> for RefNode<'a>

pub fn from(x: &'a SourceText) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SpecifyBlock> for RefNode<'a>

pub fn from(x: &'a SpecifyBlock) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SpecifyInputTerminalDescriptor> for RefNode<'a>

pub fn from(x: &'a SpecifyInputTerminalDescriptor) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SpecifyItem> for RefNode<'a>

pub fn from(x: &'a SpecifyItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SpecifyOutputTerminalDescriptor> for RefNode<'a>

pub fn from(x: &'a SpecifyOutputTerminalDescriptor) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SpecifyTerminalDescriptor> for RefNode<'a>

pub fn from(x: &'a SpecifyTerminalDescriptor) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SpecparamAssignment> for RefNode<'a>

pub fn from(x: &'a SpecparamAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SpecparamAssignmentMintypmax> for RefNode<'a>

pub fn from(x: &'a SpecparamAssignmentMintypmax) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SpecparamDeclaration> for RefNode<'a>

pub fn from(x: &'a SpecparamDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SpecparamIdentifier> for RefNode<'a>

pub fn from(x: &'a SpecparamIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StartEdgeOffset> for RefNode<'a>

pub fn from(x: &'a StartEdgeOffset) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StateDependentPathDeclaration> for RefNode<'a>

pub fn from(x: &'a StateDependentPathDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StateDependentPathDeclarationIfEdgeSensitive> for RefNode<'a>

pub fn from(x: &'a StateDependentPathDeclarationIfEdgeSensitive) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StateDependentPathDeclarationIfNone> for RefNode<'a>

pub fn from(x: &'a StateDependentPathDeclarationIfNone) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StateDependentPathDeclarationIfSimple> for RefNode<'a>

pub fn from(x: &'a StateDependentPathDeclarationIfSimple) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Statement> for RefNode<'a>

pub fn from(x: &'a Statement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StatementItem> for RefNode<'a>

pub fn from(x: &'a StatementItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StatementOrNull> for RefNode<'a>

pub fn from(x: &'a StatementOrNull) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StatementOrNullAttribute> for RefNode<'a>

pub fn from(x: &'a StatementOrNullAttribute) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Static> for RefNode<'a>

pub fn from(x: &'a Static) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StreamConcatenation> for RefNode<'a>

pub fn from(x: &'a StreamConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StreamExpression> for RefNode<'a>

pub fn from(x: &'a StreamExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StreamOperator> for RefNode<'a>

pub fn from(x: &'a StreamOperator) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StreamingConcatenation> for RefNode<'a>

pub fn from(x: &'a StreamingConcatenation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Strength> for RefNode<'a>

pub fn from(x: &'a Strength) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Strength0> for RefNode<'a>

pub fn from(x: &'a Strength0) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Strength1> for RefNode<'a>

pub fn from(x: &'a Strength1) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StringLiteral> for RefNode<'a>

pub fn from(x: &'a StringLiteral) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StructUnion> for RefNode<'a>

pub fn from(x: &'a StructUnion) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StructUnionMember> for RefNode<'a>

pub fn from(x: &'a StructUnionMember) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a StructurePatternKey> for RefNode<'a>

pub fn from(x: &'a StructurePatternKey) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SubroutineCall> for RefNode<'a>

pub fn from(x: &'a SubroutineCall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SubroutineCallRandomize> for RefNode<'a>

pub fn from(x: &'a SubroutineCallRandomize) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SubroutineCallStatement> for RefNode<'a>

pub fn from(x: &'a SubroutineCallStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SubroutineCallStatementFunction> for RefNode<'a>

pub fn from(x: &'a SubroutineCallStatementFunction) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Symbol> for RefNode<'a>

pub fn from(x: &'a Symbol) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SystemTfCall> for RefNode<'a>

pub fn from(x: &'a SystemTfCall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SystemTfCallArgDataType> for RefNode<'a>

pub fn from(x: &'a SystemTfCallArgDataType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SystemTfCallArgExpression> for RefNode<'a>

pub fn from(x: &'a SystemTfCallArgExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SystemTfCallArgOptional> for RefNode<'a>

pub fn from(x: &'a SystemTfCallArgOptional) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SystemTfIdentifier> for RefNode<'a>

pub fn from(x: &'a SystemTfIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a SystemTimingCheck> for RefNode<'a>

pub fn from(x: &'a SystemTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TPathDelayExpression> for RefNode<'a>

pub fn from(x: &'a TPathDelayExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TaggedUnionExpression> for RefNode<'a>

pub fn from(x: &'a TaggedUnionExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TaskBodyDeclaration> for RefNode<'a>

pub fn from(x: &'a TaskBodyDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TaskBodyDeclarationWithPort> for RefNode<'a>

pub fn from(x: &'a TaskBodyDeclarationWithPort) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TaskBodyDeclarationWithoutPort> for RefNode<'a>

pub fn from(x: &'a TaskBodyDeclarationWithoutPort) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TaskDeclaration> for RefNode<'a>

pub fn from(x: &'a TaskDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TaskIdentifier> for RefNode<'a>

pub fn from(x: &'a TaskIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TaskPrototype> for RefNode<'a>

pub fn from(x: &'a TaskPrototype) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TerminalIdentifier> for RefNode<'a>

pub fn from(x: &'a TerminalIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TextMacroDefinition> for RefNode<'a>

pub fn from(x: &'a TextMacroDefinition) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TextMacroIdentifier> for RefNode<'a>

pub fn from(x: &'a TextMacroIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TextMacroName> for RefNode<'a>

pub fn from(x: &'a TextMacroName) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TextMacroUsage> for RefNode<'a>

pub fn from(x: &'a TextMacroUsage) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TfCall> for RefNode<'a>

pub fn from(x: &'a TfCall) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TfIdentifier> for RefNode<'a>

pub fn from(x: &'a TfIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TfItemDeclaration> for RefNode<'a>

pub fn from(x: &'a TfItemDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TfPortDeclaration> for RefNode<'a>

pub fn from(x: &'a TfPortDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TfPortDirection> for RefNode<'a>

pub fn from(x: &'a TfPortDirection) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TfPortItem> for RefNode<'a>

pub fn from(x: &'a TfPortItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TfPortList> for RefNode<'a>

pub fn from(x: &'a TfPortList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Threshold> for RefNode<'a>

pub fn from(x: &'a Threshold) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimeLiteral> for RefNode<'a>

pub fn from(x: &'a TimeLiteral) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimeLiteralFixedPoint> for RefNode<'a>

pub fn from(x: &'a TimeLiteralFixedPoint) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimeLiteralUnsigned> for RefNode<'a>

pub fn from(x: &'a TimeLiteralUnsigned) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimeUnit> for RefNode<'a>

pub fn from(x: &'a TimeUnit) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimecheckCondition> for RefNode<'a>

pub fn from(x: &'a TimecheckCondition) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimescaleCompilerDirective> for RefNode<'a>

pub fn from(x: &'a TimescaleCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimeskewTimingCheck> for RefNode<'a>

pub fn from(x: &'a TimeskewTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimestampCondition> for RefNode<'a>

pub fn from(x: &'a TimestampCondition) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimeunitsDeclaration> for RefNode<'a>

pub fn from(x: &'a TimeunitsDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimeunitsDeclarationTimeprecision> for RefNode<'a>

pub fn from(x: &'a TimeunitsDeclarationTimeprecision) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimeunitsDeclarationTimeprecisionTimeunit> for RefNode<'a>

pub fn from(x: &'a TimeunitsDeclarationTimeprecisionTimeunit) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimeunitsDeclarationTimeunit> for RefNode<'a>

pub fn from(x: &'a TimeunitsDeclarationTimeunit) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimeunitsDeclarationTimeunitTimeprecision> for RefNode<'a>

pub fn from(x: &'a TimeunitsDeclarationTimeunitTimeprecision) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimingCheckCondition> for RefNode<'a>

pub fn from(x: &'a TimingCheckCondition) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimingCheckConditionParen> for RefNode<'a>

pub fn from(x: &'a TimingCheckConditionParen) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimingCheckEvent> for RefNode<'a>

pub fn from(x: &'a TimingCheckEvent) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimingCheckEventControl> for RefNode<'a>

pub fn from(x: &'a TimingCheckEventControl) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TimingCheckLimit> for RefNode<'a>

pub fn from(x: &'a TimingCheckLimit) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TopmoduleIdentifier> for RefNode<'a>

pub fn from(x: &'a TopmoduleIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TransItem> for RefNode<'a>

pub fn from(x: &'a TransItem) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TransList> for RefNode<'a>

pub fn from(x: &'a TransList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TransRangeList> for RefNode<'a>

pub fn from(x: &'a TransRangeList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TransRangeListArrow> for RefNode<'a>

pub fn from(x: &'a TransRangeListArrow) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TransRangeListAsterisk> for RefNode<'a>

pub fn from(x: &'a TransRangeListAsterisk) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TransRangeListEqual> for RefNode<'a>

pub fn from(x: &'a TransRangeListEqual) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TransSet> for RefNode<'a>

pub fn from(x: &'a TransSet) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TypeAssignment> for RefNode<'a>

pub fn from(x: &'a TypeAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TypeDeclaration> for RefNode<'a>

pub fn from(x: &'a TypeDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TypeDeclarationDataType> for RefNode<'a>

pub fn from(x: &'a TypeDeclarationDataType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TypeDeclarationInterface> for RefNode<'a>

pub fn from(x: &'a TypeDeclarationInterface) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TypeDeclarationKeyword> for RefNode<'a>

pub fn from(x: &'a TypeDeclarationKeyword) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TypeDeclarationReserved> for RefNode<'a>

pub fn from(x: &'a TypeDeclarationReserved) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TypeIdentifier> for RefNode<'a>

pub fn from(x: &'a TypeIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TypeReference> for RefNode<'a>

pub fn from(x: &'a TypeReference) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TypeReferenceDataType> for RefNode<'a>

pub fn from(x: &'a TypeReferenceDataType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a TypeReferenceExpression> for RefNode<'a>

pub fn from(x: &'a TypeReferenceExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpAnsiDeclaration> for RefNode<'a>

pub fn from(x: &'a UdpAnsiDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpBody> for RefNode<'a>

pub fn from(x: &'a UdpBody) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpDeclaration> for RefNode<'a>

pub fn from(x: &'a UdpDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpDeclarationAnsi> for RefNode<'a>

pub fn from(x: &'a UdpDeclarationAnsi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpDeclarationExternAnsi> for RefNode<'a>

pub fn from(x: &'a UdpDeclarationExternAnsi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpDeclarationExternNonansi> for RefNode<'a>

pub fn from(x: &'a UdpDeclarationExternNonansi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpDeclarationNonansi> for RefNode<'a>

pub fn from(x: &'a UdpDeclarationNonansi) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpDeclarationPortList> for RefNode<'a>

pub fn from(x: &'a UdpDeclarationPortList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpDeclarationWildcard> for RefNode<'a>

pub fn from(x: &'a UdpDeclarationWildcard) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpIdentifier> for RefNode<'a>

pub fn from(x: &'a UdpIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpInitialStatement> for RefNode<'a>

pub fn from(x: &'a UdpInitialStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpInputDeclaration> for RefNode<'a>

pub fn from(x: &'a UdpInputDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpInstance> for RefNode<'a>

pub fn from(x: &'a UdpInstance) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpInstantiation> for RefNode<'a>

pub fn from(x: &'a UdpInstantiation) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpNonansiDeclaration> for RefNode<'a>

pub fn from(x: &'a UdpNonansiDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpOutputDeclaration> for RefNode<'a>

pub fn from(x: &'a UdpOutputDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpOutputDeclarationNonreg> for RefNode<'a>

pub fn from(x: &'a UdpOutputDeclarationNonreg) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpOutputDeclarationReg> for RefNode<'a>

pub fn from(x: &'a UdpOutputDeclarationReg) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpPortDeclaration> for RefNode<'a>

pub fn from(x: &'a UdpPortDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpPortList> for RefNode<'a>

pub fn from(x: &'a UdpPortList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UdpRegDeclaration> for RefNode<'a>

pub fn from(x: &'a UdpRegDeclaration) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UnaryModulePathOperator> for RefNode<'a>

pub fn from(x: &'a UnaryModulePathOperator) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UnaryOperator> for RefNode<'a>

pub fn from(x: &'a UnaryOperator) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UnbasedUnsizedLiteral> for RefNode<'a>

pub fn from(x: &'a UnbasedUnsizedLiteral) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UnconnectedDriveCompilerDirective> for RefNode<'a>

pub fn from(x: &'a UnconnectedDriveCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UndefineCompilerDirective> for RefNode<'a>

pub fn from(x: &'a UndefineCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UndefineallCompilerDirective> for RefNode<'a>

pub fn from(x: &'a UndefineallCompilerDirective) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UniquePriority> for RefNode<'a>

pub fn from(x: &'a UniquePriority) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UniquenessConstraint> for RefNode<'a>

pub fn from(x: &'a UniquenessConstraint) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Unit> for RefNode<'a>

pub fn from(x: &'a Unit) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UnpackedDimension> for RefNode<'a>

pub fn from(x: &'a UnpackedDimension) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UnpackedDimensionExpression> for RefNode<'a>

pub fn from(x: &'a UnpackedDimensionExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UnpackedDimensionRange> for RefNode<'a>

pub fn from(x: &'a UnpackedDimensionRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UnsignedNumber> for RefNode<'a>

pub fn from(x: &'a UnsignedNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UnsizedDimension> for RefNode<'a>

pub fn from(x: &'a UnsizedDimension) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UseClause> for RefNode<'a>

pub fn from(x: &'a UseClause) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UseClauseCell> for RefNode<'a>

pub fn from(x: &'a UseClauseCell) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UseClauseCellNamed> for RefNode<'a>

pub fn from(x: &'a UseClauseCellNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a UseClauseNamed> for RefNode<'a>

pub fn from(x: &'a UseClauseNamed) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ValueRange> for RefNode<'a>

pub fn from(x: &'a ValueRange) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ValueRangeBinary> for RefNode<'a>

pub fn from(x: &'a ValueRangeBinary) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Var> for RefNode<'a>

pub fn from(x: &'a Var) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VarDataType> for RefNode<'a>

pub fn from(x: &'a VarDataType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VarDataTypeVar> for RefNode<'a>

pub fn from(x: &'a VarDataTypeVar) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableAssignment> for RefNode<'a>

pub fn from(x: &'a VariableAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableDeclAssignment> for RefNode<'a>

pub fn from(x: &'a VariableDeclAssignment) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableDeclAssignmentClass> for RefNode<'a>

pub fn from(x: &'a VariableDeclAssignmentClass) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableDeclAssignmentDynamicArray> for RefNode<'a>

pub fn from(x: &'a VariableDeclAssignmentDynamicArray) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableDeclAssignmentVariable> for RefNode<'a>

pub fn from(x: &'a VariableDeclAssignmentVariable) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableDimension> for RefNode<'a>

pub fn from(x: &'a VariableDimension) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableIdentifier> for RefNode<'a>

pub fn from(x: &'a VariableIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableIdentifierList> for RefNode<'a>

pub fn from(x: &'a VariableIdentifierList) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableIdentifierListOrNull> for RefNode<'a>

pub fn from(x: &'a VariableIdentifierListOrNull) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableLvalue> for RefNode<'a>

pub fn from(x: &'a VariableLvalue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableLvalueIdentifier> for RefNode<'a>

pub fn from(x: &'a VariableLvalueIdentifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableLvalueLvalue> for RefNode<'a>

pub fn from(x: &'a VariableLvalueLvalue) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariableLvaluePattern> for RefNode<'a>

pub fn from(x: &'a VariableLvaluePattern) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariablePortHeader> for RefNode<'a>

pub fn from(x: &'a VariablePortHeader) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VariablePortType> for RefNode<'a>

pub fn from(x: &'a VariablePortType) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VectorScalar> for RefNode<'a>

pub fn from(x: &'a VectorScalar) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a VersionSpecifier> for RefNode<'a>

pub fn from(x: &'a VersionSpecifier) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Virtual> for RefNode<'a>

pub fn from(x: &'a Virtual) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a WaitStatement> for RefNode<'a>

pub fn from(x: &'a WaitStatement) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a WaitStatementFork> for RefNode<'a>

pub fn from(x: &'a WaitStatementFork) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a WaitStatementOrder> for RefNode<'a>

pub fn from(x: &'a WaitStatementOrder) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a WaitStatementWait> for RefNode<'a>

pub fn from(x: &'a WaitStatementWait) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a WeightSpecification> for RefNode<'a>

pub fn from(x: &'a WeightSpecification) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a WeightSpecificationExpression> for RefNode<'a>

pub fn from(x: &'a WeightSpecificationExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a WhiteSpace> for RefNode<'a>

pub fn from(x: &'a WhiteSpace) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a WidthTimingCheck> for RefNode<'a>

pub fn from(x: &'a WidthTimingCheck) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a Wildcard> for RefNode<'a>

pub fn from(x: &'a Wildcard) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a WithCovergroupExpression> for RefNode<'a>

pub fn from(x: &'a WithCovergroupExpression) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a XNumber> for RefNode<'a>

pub fn from(x: &'a XNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> From<&'a ZNumber> for RefNode<'a>

pub fn from(x: &'a ZNumber) -> RefNode<'a>

Performs the conversion.

impl<'a> IntoIterator for RefNode<'a>

type Item = RefNode<'a>

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <RefNode<'a> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> PartialEq<RefNode<'a>> for RefNode<'a>

pub fn eq(&self, other: &RefNode<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &RefNode<'a>) -> bool

This method tests for !=.

impl<'a> StructuralPartialEq for RefNode<'a>