scarf_syntax/declarations/
assertion_declarations.rs

1// =======================================================================
2// assertion_declarations.rs
3// =======================================================================
4// CST Nodes from 1800-2023 A.2.10
5use crate::*;
6
7#[derive(Clone, Debug, PartialEq)]
8pub enum ConcurrentAssertionItem<'a> {
9    Assertion(
10        Box<(
11            Option<(
12                BlockIdentifier<'a>,
13                Metadata<'a>, // :
14            )>,
15            ConcurrentAssertionStatement<'a>,
16        )>,
17    ),
18    Checker(Box<CheckerInstantiation<'a>>),
19}
20
21#[derive(Clone, Debug, PartialEq)]
22pub enum ConcurrentAssertionStatement<'a> {
23    AssertProp(Box<AssertPropertyStatement<'a>>),
24    AssumeProp(Box<AssumePropertyStatement<'a>>),
25    CoverProp(Box<CoverPropertyStatement<'a>>),
26    CoverSeq(Box<CoverSequenceStatement<'a>>),
27    RestrictProp(Box<RestrictPropertyStatement<'a>>),
28}
29
30#[derive(Clone, Debug, PartialEq)]
31pub struct AssertPropertyStatement<'a>(
32    pub Metadata<'a>, // assert
33    pub Metadata<'a>, // property
34    pub Metadata<'a>, // (
35    pub PropertySpec<'a>,
36    pub Metadata<'a>, // )
37    pub ActionBlock<'a>,
38);
39
40#[derive(Clone, Debug, PartialEq)]
41pub struct AssumePropertyStatement<'a>(
42    pub Metadata<'a>, // assume
43    pub Metadata<'a>, // property
44    pub Metadata<'a>, // (
45    pub PropertySpec<'a>,
46    pub Metadata<'a>, // )
47    pub ActionBlock<'a>,
48);
49
50#[derive(Clone, Debug, PartialEq)]
51pub struct CoverPropertyStatement<'a>(
52    pub Metadata<'a>, // cover
53    pub Metadata<'a>, // property
54    pub Metadata<'a>, // (
55    pub PropertySpec<'a>,
56    pub Metadata<'a>, // )
57    pub StatementOrNull<'a>,
58);
59
60#[derive(Clone, Debug, PartialEq)]
61pub struct ExpectPropertyStatement<'a>(
62    pub Metadata<'a>, // expect
63    pub Metadata<'a>, // (
64    pub PropertySpec<'a>,
65    pub Metadata<'a>, // )
66    pub ActionBlock<'a>,
67);
68
69#[derive(Clone, Debug, PartialEq)]
70pub struct CoverSequenceStatement<'a>(
71    pub Metadata<'a>, // cover
72    pub Metadata<'a>, // sequence
73    pub Metadata<'a>, // (
74    pub Option<ClockingEvent<'a>>,
75    pub  Option<(
76        Metadata<'a>, // disable
77        Metadata<'a>, // iff
78        Metadata<'a>, // (
79        ExpressionOrDist<'a>,
80        Metadata<'a>, // )
81    )>,
82    pub SequenceExpr<'a>,
83    pub Metadata<'a>, // )
84    pub StatementOrNull<'a>,
85);
86
87#[derive(Clone, Debug, PartialEq)]
88pub struct RestrictPropertyStatement<'a>(
89    pub Metadata<'a>, // restrict
90    pub Metadata<'a>, // property
91    pub Metadata<'a>, // (
92    pub PropertySpec<'a>,
93    pub Metadata<'a>, // )
94    pub Metadata<'a>, // ;
95);
96
97#[derive(Clone, Debug, PartialEq)]
98pub struct PropertyInstance<'a>(
99    pub PsOrHierarchicalPropertyIdentifier<'a>,
100    pub  Option<(
101        Metadata<'a>, // (
102        Option<PropertyListOfArguments<'a>>,
103        Metadata<'a>, // )
104    )>,
105);
106
107#[derive(Clone, Debug, PartialEq)]
108pub enum PropertyListOfArguments<'a> {
109    PartialIdentifier(
110        Box<(
111            Option<PropertyActualArg<'a>>,
112            Vec<(
113                Metadata<'a>, // ,
114                Option<PropertyActualArg<'a>>,
115            )>,
116            Vec<(
117                Metadata<'a>, // ,
118                Metadata<'a>, // .
119                Identifier<'a>,
120                Metadata<'a>, // (
121                Option<PropertyActualArg<'a>>,
122                Metadata<'a>, // )
123            )>,
124        )>,
125    ),
126    Identifier(
127        Box<(
128            Metadata<'a>, // .
129            Identifier<'a>,
130            Metadata<'a>, // (
131            Option<PropertyActualArg<'a>>,
132            Metadata<'a>, // )
133            Vec<(
134                Metadata<'a>, // ,
135                Metadata<'a>, // .
136                Identifier<'a>,
137                Metadata<'a>, // (
138                Option<PropertyActualArg<'a>>,
139                Metadata<'a>, // )
140            )>,
141        )>,
142    ),
143}
144
145#[derive(Clone, Debug, PartialEq)]
146pub enum PropertyActualArg<'a> {
147    Property(Box<PropertyExpr<'a>>),
148    Sequence(Box<SequenceActualArg<'a>>),
149}
150
151#[derive(Clone, Debug, PartialEq)]
152pub enum AssertionItemDeclaration<'a> {
153    Property(Box<PropertyDeclaration<'a>>),
154    Sequence(Box<SequenceDeclaration<'a>>),
155    Let(Box<LetDeclaration<'a>>),
156}
157
158#[derive(Clone, Debug, PartialEq)]
159pub struct PropertyDeclaration<'a>(
160    pub Metadata<'a>, // property
161    pub PropertyIdentifier<'a>,
162    pub  Option<(
163        Metadata<'a>, // (
164        Option<PropertyPortList<'a>>,
165        Metadata<'a>, // )
166    )>,
167    pub Metadata<'a>, // ;
168    pub Vec<AssertionVariableDeclaration<'a>>,
169    pub PropertySpec<'a>,
170    pub Option<Metadata<'a>>, // ;
171    pub Metadata<'a>,         // endproperty
172    pub  Option<(
173        Metadata<'a>, // :
174        PropertyIdentifier<'a>,
175    )>,
176);
177
178#[derive(Clone, Debug, PartialEq)]
179pub struct PropertyPortList<'a>(
180    pub PropertyPortItem<'a>,
181    pub  Vec<(
182        Metadata<'a>, // ,
183        PropertyPortItem<'a>,
184    )>,
185);
186
187#[derive(Clone, Debug, PartialEq)]
188pub struct PropertyPortItem<'a>(
189    pub Vec<AttributeInstance<'a>>,
190    pub  Option<(
191        Metadata<'a>, // local
192        Option<PropertyLvarPortDirection<'a>>,
193    )>,
194    pub PropertyFormalType<'a>,
195    pub FormalPortIdentifier<'a>,
196    pub Vec<VariableDimension<'a>>,
197    pub  Option<(
198        Metadata<'a>, // =
199        PropertyActualArg<'a>,
200    )>,
201);
202
203#[derive(Clone, Debug, PartialEq)]
204pub struct PropertyLvarPortDirection<'a>(
205    pub Metadata<'a>, // input
206);
207
208#[derive(Clone, Debug, PartialEq)]
209pub enum PropertyFormalType<'a> {
210    Sequence(Box<SequenceFormalType<'a>>),
211    Property(Box<Metadata<'a>>),
212}
213
214#[derive(Clone, Debug, PartialEq)]
215pub struct PropertySpec<'a>(
216    pub Option<ClockingEvent<'a>>,
217    pub  Option<(
218        Metadata<'a>, // disable
219        Metadata<'a>, // iff
220        Metadata<'a>, // (
221        ExpressionOrDist<'a>,
222        Metadata<'a>, // )
223    )>,
224    pub PropertyExpr<'a>,
225);
226
227#[derive(Clone, Debug, PartialEq)]
228pub enum PropertyExpr<'a> {
229    SeqExpr(Box<SequenceExpr<'a>>),
230    Strong(
231        Box<(
232            Metadata<'a>, // strong
233            Metadata<'a>, // (
234            SequenceExpr<'a>,
235            Metadata<'a>, // )
236        )>,
237    ),
238    Weak(
239        Box<(
240            Metadata<'a>, // weak
241            Metadata<'a>, // (
242            SequenceExpr<'a>,
243            Metadata<'a>, // )
244        )>,
245    ),
246    Paren(
247        Box<(
248            Metadata<'a>, // (
249            PropertyExpr<'a>,
250            Metadata<'a>, // )
251        )>,
252    ),
253    Not(
254        Box<(
255            Metadata<'a>, // not
256            PropertyExpr<'a>,
257        )>,
258    ),
259    Or(
260        Box<(
261            PropertyExpr<'a>,
262            Metadata<'a>, // or
263            PropertyExpr<'a>,
264        )>,
265    ),
266    And(
267        Box<(
268            PropertyExpr<'a>,
269            Metadata<'a>, // and
270            PropertyExpr<'a>,
271        )>,
272    ),
273    OverlapImpl(
274        Box<(
275            SequenceExpr<'a>,
276            Metadata<'a>, // |->
277            PropertyExpr<'a>,
278        )>,
279    ),
280    NonoverlapImpl(
281        Box<(
282            SequenceExpr<'a>,
283            Metadata<'a>, // |=>
284            PropertyExpr<'a>,
285        )>,
286    ),
287    Conditional(
288        Box<(
289            Metadata<'a>, // if
290            Metadata<'a>, // (
291            ExpressionOrDist<'a>,
292            Metadata<'a>, // )
293            PropertyExpr<'a>,
294            Option<(
295                Metadata<'a>, // else
296                PropertyExpr<'a>,
297            )>,
298        )>,
299    ),
300    Case(
301        Box<(
302            Metadata<'a>, // case
303            Metadata<'a>, // (
304            ExpressionOrDist<'a>,
305            Metadata<'a>, // )
306            PropertyCaseItem<'a>,
307            Vec<PropertyCaseItem<'a>>,
308            Metadata<'a>, // endcase
309        )>,
310    ),
311    OverlapFollowedBy(
312        Box<(
313            SequenceExpr<'a>,
314            Metadata<'a>, // #-#
315            PropertyExpr<'a>,
316        )>,
317    ),
318    NonoverlapFollowedBy(
319        Box<(
320            SequenceExpr<'a>,
321            Metadata<'a>, // #=#
322            PropertyExpr<'a>,
323        )>,
324    ),
325    Nexttime(
326        Box<(
327            Metadata<'a>, // nexttime
328            PropertyExpr<'a>,
329        )>,
330    ),
331    NexttimeExpr(
332        Box<(
333            Metadata<'a>, // nexttime
334            Metadata<'a>, // [
335            ConstantExpression<'a>,
336            Metadata<'a>, // ]
337            PropertyExpr<'a>,
338        )>,
339    ),
340    SNexttime(
341        Box<(
342            Metadata<'a>, // s_nexttime
343            PropertyExpr<'a>,
344        )>,
345    ),
346    SNexttimeExpr(
347        Box<(
348            Metadata<'a>, // s_nexttime
349            Metadata<'a>, // [
350            ConstantExpression<'a>,
351            Metadata<'a>, // ]
352            PropertyExpr<'a>,
353        )>,
354    ),
355    Always(
356        Box<(
357            Metadata<'a>, // always
358            PropertyExpr<'a>,
359        )>,
360    ),
361    AlwaysRange(
362        Box<(
363            Metadata<'a>, // always
364            Metadata<'a>, // [
365            CycleDelayConstRangeExpression<'a>,
366            Metadata<'a>, // ]
367            PropertyExpr<'a>,
368        )>,
369    ),
370    SAlways(
371        Box<(
372            Metadata<'a>, // s_always
373            Metadata<'a>, // [
374            ConstantRange<'a>,
375            Metadata<'a>, // ]
376            PropertyExpr<'a>,
377        )>,
378    ),
379    SEventually(
380        Box<(
381            Metadata<'a>, // s_eventually
382            PropertyExpr<'a>,
383        )>,
384    ),
385    Eventually(
386        Box<(
387            Metadata<'a>, // eventually
388            Metadata<'a>, // [
389            ConstantRange<'a>,
390            Metadata<'a>, // ]
391            PropertyExpr<'a>,
392        )>,
393    ),
394    SEventuallyRange(
395        Box<(
396            Metadata<'a>, // s_eventually
397            Metadata<'a>, // [
398            CycleDelayConstRangeExpression<'a>,
399            Metadata<'a>, // ]
400            PropertyExpr<'a>,
401        )>,
402    ),
403    Until(
404        Box<(
405            PropertyExpr<'a>,
406            Metadata<'a>, // until
407            PropertyExpr<'a>,
408        )>,
409    ),
410    SUntil(
411        Box<(
412            PropertyExpr<'a>,
413            Metadata<'a>, // s_until
414            PropertyExpr<'a>,
415        )>,
416    ),
417    UntilWith(
418        Box<(
419            PropertyExpr<'a>,
420            Metadata<'a>, // until_with
421            PropertyExpr<'a>,
422        )>,
423    ),
424    SUntilWith(
425        Box<(
426            PropertyExpr<'a>,
427            Metadata<'a>, // s_until_with
428            PropertyExpr<'a>,
429        )>,
430    ),
431    Implies(
432        Box<(
433            PropertyExpr<'a>,
434            Metadata<'a>, // implies
435            PropertyExpr<'a>,
436        )>,
437    ),
438    Iff(
439        Box<(
440            PropertyExpr<'a>,
441            Metadata<'a>, // iff
442            PropertyExpr<'a>,
443        )>,
444    ),
445    AcceptOn(
446        Box<(
447            Metadata<'a>, // accept_on
448            Metadata<'a>, // (
449            ExpressionOrDist<'a>,
450            Metadata<'a>, // )
451            PropertyExpr<'a>,
452        )>,
453    ),
454    RejectOn(
455        Box<(
456            Metadata<'a>, // reject_on
457            Metadata<'a>, // (
458            ExpressionOrDist<'a>,
459            Metadata<'a>, // )
460            PropertyExpr<'a>,
461        )>,
462    ),
463    SyncAcceptOn(
464        Box<(
465            Metadata<'a>, // sync_accept_on
466            Metadata<'a>, // (
467            ExpressionOrDist<'a>,
468            Metadata<'a>, // )
469            PropertyExpr<'a>,
470        )>,
471    ),
472    SyncRejectOn(
473        Box<(
474            Metadata<'a>, // sync_reject_on
475            Metadata<'a>, // (
476            ExpressionOrDist<'a>,
477            Metadata<'a>, // )
478            PropertyExpr<'a>,
479        )>,
480    ),
481    Instance(Box<PropertyInstance<'a>>),
482    Clocking(Box<(ClockingEvent<'a>, PropertyExpr<'a>)>),
483}
484
485#[derive(Clone, Debug, PartialEq)]
486pub enum PropertyCaseItem<'a> {
487    Expr(
488        Box<(
489            ExpressionOrDist<'a>,
490            Vec<(
491                Metadata<'a>, // ,
492                ExpressionOrDist<'a>,
493            )>,
494            Metadata<'a>, // :
495            PropertyExpr<'a>,
496            Metadata<'a>, // ;
497        )>,
498    ),
499    Default(
500        Box<(
501            Metadata<'a>,         // default
502            Option<Metadata<'a>>, // :
503            PropertyExpr<'a>,
504            Metadata<'a>, // ;
505        )>,
506    ),
507}
508
509#[derive(Clone, Debug, PartialEq)]
510pub struct SequenceDeclaration<'a>(
511    pub Metadata<'a>, // sequence
512    pub SequenceIdentifier<'a>,
513    pub  Option<(
514        Metadata<'a>, // (
515        Option<SequencePortList<'a>>,
516        Metadata<'a>, // )
517    )>,
518    pub Metadata<'a>, // ;
519    pub Vec<AssertionVariableDeclaration<'a>>,
520    pub SequenceExpr<'a>,
521    pub Option<Metadata<'a>>, // ;
522    pub Metadata<'a>,         // endsequence
523    pub  Option<(
524        Metadata<'a>, // :
525        SequenceIdentifier<'a>,
526    )>,
527);
528
529#[derive(Clone, Debug, PartialEq)]
530pub struct SequencePortList<'a>(
531    pub SequencePortItem<'a>,
532    pub  Vec<(
533        Metadata<'a>, // ,
534        SequencePortItem<'a>,
535    )>,
536);
537
538#[derive(Clone, Debug, PartialEq)]
539pub struct SequencePortItem<'a>(
540    pub Vec<AttributeInstance<'a>>,
541    pub  Option<(
542        Metadata<'a>, // local
543        Option<SequenceLvarPortDirection<'a>>,
544    )>,
545    pub SequenceFormalType<'a>,
546    pub FormalPortIdentifier<'a>,
547    pub Vec<VariableDimension<'a>>,
548    pub  Option<(
549        Metadata<'a>, // =
550        SequenceActualArg<'a>,
551    )>,
552);
553
554#[derive(Clone, Debug, PartialEq)]
555pub enum SequenceLvarPortDirection<'a> {
556    Input(Metadata<'a>),
557    Inout(Metadata<'a>),
558    Output(Metadata<'a>),
559}
560
561#[derive(Clone, Debug, PartialEq)]
562pub enum SequenceFormalType<'a> {
563    DataTypeOrImplicit(Box<DataTypeOrImplicit<'a>>),
564    Sequence(Box<Metadata<'a>>),
565    Untyped(Box<Metadata<'a>>),
566}
567
568#[derive(Clone, Debug, PartialEq)]
569pub enum SequenceExpr<'a> {
570    StartDelay(
571        Box<(
572            CycleDelayRange<'a>,
573            SequenceExpr<'a>,
574            Vec<(CycleDelayRange<'a>, SequenceExpr<'a>)>,
575        )>,
576    ),
577    Delay(
578        Box<(
579            SequenceExpr<'a>,
580            CycleDelayRange<'a>,
581            SequenceExpr<'a>,
582            Vec<(CycleDelayRange<'a>, SequenceExpr<'a>)>,
583        )>,
584    ),
585    Expr(Box<(ExpressionOrDist<'a>, Option<BooleanAbbrev<'a>>)>),
586    Inst(Box<(SequenceInstance<'a>, Option<SequenceAbbrev<'a>>)>),
587    Paren(
588        Box<(
589            Metadata<'a>, // (
590            SequenceExpr<'a>,
591            Vec<(
592                Metadata<'a>, // ,
593                SequenceMatchItem<'a>,
594            )>,
595            Metadata<'a>, // )
596            Option<SequenceAbbrev<'a>>,
597        )>,
598    ),
599    And(
600        Box<(
601            SequenceExpr<'a>,
602            Metadata<'a>, // and
603            SequenceExpr<'a>,
604        )>,
605    ),
606    Intersect(
607        Box<(
608            SequenceExpr<'a>,
609            Metadata<'a>, // intersect
610            SequenceExpr<'a>,
611        )>,
612    ),
613    Or(
614        Box<(
615            SequenceExpr<'a>,
616            Metadata<'a>, // or
617            SequenceExpr<'a>,
618        )>,
619    ),
620    FirstMatch(
621        Box<(
622            Metadata<'a>, // first_match
623            Metadata<'a>, // (
624            SequenceExpr<'a>,
625            Vec<(
626                Metadata<'a>, // ,
627                SequenceMatchItem<'a>,
628            )>,
629            Metadata<'a>, // )
630        )>,
631    ),
632    Throughout(
633        Box<(
634            ExpressionOrDist<'a>,
635            Metadata<'a>, // throughout
636            SequenceExpr<'a>,
637        )>,
638    ),
639    Within(
640        Box<(
641            SequenceExpr<'a>,
642            Metadata<'a>, // within
643            SequenceExpr<'a>,
644        )>,
645    ),
646    Clocking(Box<(ClockingEvent<'a>, SequenceExpr<'a>)>),
647}
648
649#[derive(Clone, Debug, PartialEq)]
650pub enum CycleDelayRange<'a> {
651    Primary(
652        Box<(
653            Metadata<'a>, // ##
654            ConstantPrimary<'a>,
655        )>,
656    ),
657    Range(
658        Box<(
659            Metadata<'a>, // ##
660            Metadata<'a>, // [
661            CycleDelayConstRangeExpression<'a>,
662            Metadata<'a>, // ]
663        )>,
664    ),
665    Star(
666        Box<(
667            Metadata<'a>, // ##
668            Metadata<'a>, // [
669            Metadata<'a>, // *
670            Metadata<'a>, // ]
671        )>,
672    ),
673    Plus(
674        Box<(
675            Metadata<'a>, // ##
676            Metadata<'a>, // [
677            Metadata<'a>, // +
678            Metadata<'a>, // ]
679        )>,
680    ),
681}
682
683#[derive(Clone, Debug, PartialEq)]
684pub struct SequenceMethodCall<'a>(
685    pub SequenceInstance<'a>,
686    pub Metadata<'a>, // .
687    pub MethodIdentifier<'a>,
688);
689
690#[derive(Clone, Debug, PartialEq)]
691pub enum SequenceMatchItem<'a> {
692    Operator(Box<OperatorAssignment<'a>>),
693    IncOrDec(Box<IncOrDecExpression<'a>>),
694    Subroutine(Box<SubroutineCall<'a>>),
695}
696
697#[derive(Clone, Debug, PartialEq)]
698pub struct SequenceInstance<'a>(
699    pub PsOrHierarchicalSequenceIdentifier<'a>,
700    pub  Option<(
701        Metadata<'a>, // (
702        Option<SequenceListOfArguments<'a>>,
703        Metadata<'a>, // )
704    )>,
705);
706
707#[derive(Clone, Debug, PartialEq)]
708pub enum SequenceListOfArguments<'a> {
709    PartialIdentifier(
710        Box<(
711            Option<SequenceActualArg<'a>>,
712            Vec<(
713                Metadata<'a>, // ,
714                Option<SequenceActualArg<'a>>,
715            )>,
716            Vec<(
717                Metadata<'a>, // ,
718                Metadata<'a>, // .
719                Identifier<'a>,
720                Metadata<'a>, // (
721                Option<SequenceActualArg<'a>>,
722                Metadata<'a>, // )
723            )>,
724        )>,
725    ),
726    Identifier(
727        Box<(
728            Metadata<'a>, // .
729            Identifier<'a>,
730            Metadata<'a>, // (
731            Option<SequenceActualArg<'a>>,
732            Metadata<'a>, // )
733            Vec<(
734                Metadata<'a>, // ,
735                Metadata<'a>, // .
736                Identifier<'a>,
737                Metadata<'a>, // (
738                Option<SequenceActualArg<'a>>,
739                Metadata<'a>, // )
740            )>,
741        )>,
742    ),
743}
744
745#[derive(Clone, Debug, PartialEq)]
746pub enum SequenceActualArg<'a> {
747    Event(Box<EventExpression<'a>>),
748    Sequence(Box<SequenceExpr<'a>>),
749    Dollar(Box<Metadata<'a>>),
750}
751
752#[derive(Clone, Debug, PartialEq)]
753pub enum BooleanAbbrev<'a> {
754    Consecutive(Box<ConsecutiveRepetition<'a>>),
755    Nonconsecutive(Box<NonconsecutiveRepetition<'a>>),
756    Goto(Box<GotoRepetition<'a>>),
757}
758
759#[derive(Clone, Debug, PartialEq)]
760pub struct SequenceAbbrev<'a>(pub ConsecutiveRepetition<'a>);
761
762#[derive(Clone, Debug, PartialEq)]
763pub enum ConsecutiveRepetition<'a> {
764    Expr(
765        Box<(
766            Metadata<'a>, // [
767            Metadata<'a>, // *
768            ConstOrRangeExpression<'a>,
769            Metadata<'a>, // ]
770        )>,
771    ),
772    Star(
773        Box<(
774            Metadata<'a>, // [
775            Metadata<'a>, // *
776            Metadata<'a>, // ]
777        )>,
778    ),
779    Plus(
780        Box<(
781            Metadata<'a>, // [
782            Metadata<'a>, // +
783            Metadata<'a>, // ]
784        )>,
785    ),
786}
787
788#[derive(Clone, Debug, PartialEq)]
789pub struct NonconsecutiveRepetition<'a>(
790    pub Metadata<'a>, // [
791    pub Metadata<'a>, // =
792    pub ConstOrRangeExpression<'a>,
793    pub Metadata<'a>, // ]
794);
795
796#[derive(Clone, Debug, PartialEq)]
797pub struct GotoRepetition<'a>(
798    pub Metadata<'a>, // [
799    pub Metadata<'a>, //  ->
800    pub ConstOrRangeExpression<'a>,
801    pub Metadata<'a>, // ]
802);
803
804#[derive(Clone, Debug, PartialEq)]
805pub enum ConstOrRangeExpression<'a> {
806    Expr(Box<ConstantExpression<'a>>),
807    Range(Box<CycleDelayConstRangeExpression<'a>>),
808}
809
810#[derive(Clone, Debug, PartialEq)]
811pub enum CycleDelayConstRangeExpression<'a> {
812    Bounded(
813        Box<(
814            ConstantExpression<'a>,
815            Metadata<'a>, // :
816            ConstantExpression<'a>,
817        )>,
818    ),
819    Unbounded(
820        Box<(
821            ConstantExpression<'a>,
822            Metadata<'a>, // :
823            Metadata<'a>, // $
824        )>,
825    ),
826}
827
828#[derive(Clone, Debug, PartialEq)]
829pub struct AssertionVariableDeclaration<'a>(
830    pub VarDataType<'a>,
831    pub ListOfVariableDeclAssignments<'a>,
832    pub Metadata<'a>, // ;
833);
scarf_syntax/declarations/assertion_declarations.rs

scarf_syntax/declarations/
assertion_declarations.rs
