Merge pull request #114 from yousifBilal/constant-primary-in-cycle-delay-sequence

Fix sequence with parameter as cycle delay

Author: dalance

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

@@ -724,8 +724,10 @@ pub(crate) fn sequence_expr(s: Span) -> IResult<Span, SequenceExpr> {
 #[tracable_parser]
 #[packrat_parser]
 pub(crate) fn sequence_expr_cycle_delay_expr(s: Span) -> IResult<Span, SequenceExpr> {
-    let (s, a) = cycle_delay_range(s)?;
-    let (s, b) = sequence_expr(s)?;
+    let (s, (a, b)) = alt((
+        pair(cycle_delay_range, sequence_expr),
+        pair(cycle_delay_range_2, sequence_expr),
+    ))(s)?;
     let (s, c) = many0(pair(cycle_delay_range, sequence_expr))(s)?;
     Ok((
         s,
@@ -738,8 +740,10 @@ pub(crate) fn sequence_expr_cycle_delay_expr(s: Span) -> IResult<Span, SequenceE
 #[packrat_parser]
 pub(crate) fn sequence_expr_expr_cycle_delay_expr(s: Span) -> IResult<Span, SequenceExpr> {
     let (s, a) = sequence_expr(s)?;
-    let (s, b) = cycle_delay_range(s)?;
-    let (s, c) = sequence_expr(s)?;
+    let (s, (b, c)) = alt((
+        pair(cycle_delay_range, sequence_expr),
+        pair(cycle_delay_range_2, sequence_expr),
+    ))(s)?;
     let (s, d) = many0(pair(cycle_delay_range, sequence_expr))(s)?;
     Ok((
         s,
@@ -853,6 +857,17 @@ pub(crate) fn cycle_delay_range(s: Span) -> IResult<Span, CycleDelayRange> {
     ))(s)
 }
 
+#[tracable_parser]
+#[packrat_parser]
+pub(crate) fn cycle_delay_range_2(s: Span) -> IResult<Span, CycleDelayRange> {
+    alt((
+        cycle_delay_range_primary_no_function,
+        cycle_delay_range_expression,
+        cycle_delay_range_asterisk,
+        cycle_delay_range_plus,
+    ))(s)
+}
+
 #[tracable_parser]
 #[packrat_parser]
 pub(crate) fn cycle_delay_range_primary(s: Span) -> IResult<Span, CycleDelayRange> {
@@ -864,6 +879,17 @@ pub(crate) fn cycle_delay_range_primary(s: Span) -> IResult<Span, CycleDelayRang
     ))
 }
 
+#[tracable_parser]
+#[packrat_parser]
+pub(crate) fn cycle_delay_range_primary_no_function(s: Span) -> IResult<Span, CycleDelayRange> {
+    let (s, a) = symbol("##")(s)?;
+    let (s, b) = constant_primary_no_function(s)?;
+    Ok((
+        s,
+        CycleDelayRange::Primary(Box::new(CycleDelayRangePrimary { nodes: (a, b) })),
+    ))
+}
+
 #[tracable_parser]
 #[packrat_parser]
 pub(crate) fn cycle_delay_range_expression(s: Span) -> IResult<Span, CycleDelayRange> {

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

@@ -41,6 +41,41 @@ pub(crate) fn constant_primary(s: Span) -> IResult<Span, ConstantPrimary> {
     ))(s)
 }
 
+#[tracable_parser]
+#[packrat_parser]
+pub(crate) fn constant_primary_no_function(s: Span) -> IResult<Span, ConstantPrimary> {
+    alt((
+        // BNF-WA
+        map(keyword("$"), |x| ConstantPrimary::Dollar(Box::new(x))),
+        map(keyword("null"), |x| ConstantPrimary::Null(Box::new(x))),
+        map(constant_assignment_pattern_expression, |x| {
+            ConstantPrimary::ConstantAssignmentPatternExpression(Box::new(x))
+        }),
+        map(constant_cast, |x| {
+            ConstantPrimary::ConstantCast(Box::new(x))
+        }),
+        map(primary_literal, |x| {
+            ConstantPrimary::PrimaryLiteral(Box::new(x))
+        }),
+        constant_primary_mintypmax_expression,
+        constant_primary_ps_parameter,
+        constant_primary_specparam,
+        map(genvar_identifier, |x| {
+            ConstantPrimary::GenvarIdentifier(Box::new(x))
+        }),
+        constant_primary_formal_port,
+        constant_primary_enum,
+        constant_primary_concatenation,
+        constant_primary_multiple_concatenation,
+        map(constant_let_expression, |x| {
+            ConstantPrimary::ConstantLetExpression(Box::new(x))
+        }),
+        map(type_reference, |x| {
+            ConstantPrimary::TypeReference(Box::new(x))
+        }),
+    ))(s)
+}
+
 #[tracable_parser]
 #[packrat_parser]
 pub(crate) fn constant_primary_without_cast(s: Span) -> IResult<Span, ConstantPrimary> {

sv-parser-parser/src/tests.rs

@@ -15895,6 +15895,11 @@ mod spec {
         );
     }
 
+    #[test]
+    fn test_sequence_constant_primary_param() {
+        test!(sequence_expr, "##MY_PARAM (in2 == in3)", Ok((_, _)));
+    }
+
     #[test]
     fn clause36() {
         test!(