Add MaybeRecursive attr

src/parser/behavioral_statements/case_statements.rs

@@ -226,7 +226,7 @@ pub fn case_item(s: Span) -> IResult<Span, CaseItem> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn case_item_nondefault(s: Span) -> IResult<Span, CaseItem> {
     let (s, a) = list(symbol(","), case_item_expression)(s)?;
     let (s, b) = symbol(":")(s)?;
@@ -253,7 +253,7 @@ pub fn case_pattern_item(s: Span) -> IResult<Span, CasePatternItem> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn case_pattern_item_nondefault(s: Span) -> IResult<Span, CasePatternItem> {
     let (s, a) = pattern(s)?;
     let (s, b) = opt(pair(symbol("&&&"), expression))(s)?;
@@ -275,7 +275,7 @@ pub fn case_inside_item(s: Span) -> IResult<Span, CaseInsideItem> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn case_inside_item_nondefault(s: Span) -> IResult<Span, CaseInsideItem> {
     let (s, a) = open_range_list(s)?;
     let (s, b) = symbol(":")(s)?;
@@ -306,7 +306,7 @@ pub fn randcase_statement(s: Span) -> IResult<Span, RandcaseStatement> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn randcase_item(s: Span) -> IResult<Span, RandcaseItem> {
     let (s, a) = expression(s)?;
     let (s, b) = symbol(":")(s)?;
@@ -314,7 +314,7 @@ pub fn randcase_item(s: Span) -> IResult<Span, RandcaseItem> {
     Ok((s, RandcaseItem { nodes: (a, b, c) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn open_range_list(s: Span) -> IResult<Span, OpenRangeList> {
     let (s, a) = list(symbol(","), open_value_range)(s)?;
     Ok((s, OpenRangeList { nodes: (a,) }))

src/parser/behavioral_statements/conditional_statements.rs

@@ -81,7 +81,7 @@ pub fn unique_priority(s: Span) -> IResult<Span, UniquePriority> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn cond_predicate(s: Span) -> IResult<Span, CondPredicate> {
     let (s, a) = list(symbol("&&&"), expression_or_cond_pattern)(s)?;
     Ok((s, CondPredicate { nodes: (a,) }))
@@ -95,7 +95,7 @@ pub fn expression_or_cond_pattern(s: Span) -> IResult<Span, ExpressionOrCondPatt
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn cond_pattern(s: Span) -> IResult<Span, CondPattern> {
     let (s, a) = expression(s)?;
     let (s, b) = symbol("matches")(s)?;

src/parser/behavioral_statements/continuous_assignment_and_net_alias_statements.rs

@@ -97,13 +97,13 @@ pub fn continuous_assign_variable(s: Span) -> IResult<Span, ContinuousAssign> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn list_of_net_assignments(s: Span) -> IResult<Span, ListOfNetAssignments> {
     let (s, a) = list(symbol(","), net_assignment)(s)?;
     Ok((s, ListOfNetAssignments { nodes: (a,) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn list_of_variable_assignments(s: Span) -> IResult<Span, ListOfVariableAssignments> {
     let (s, a) = list(symbol(","), variable_assignment)(s)?;
     Ok((s, ListOfVariableAssignments { nodes: (a,) }))
@@ -125,7 +125,7 @@ pub fn net_alias(s: Span) -> IResult<Span, NetAlias> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn net_assignment(s: Span) -> IResult<Span, NetAssignment> {
     let (s, a) = net_lvalue(s)?;
     let (s, b) = symbol("=")(s)?;

src/parser/behavioral_statements/looping_statements.rs

@@ -217,7 +217,7 @@ pub fn for_initialization(s: Span) -> IResult<Span, ForInitialization> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn for_initialization_declaration(s: Span) -> IResult<Span, ForInitialization> {
     let (s, a) = list(symbol(","), for_variable_declaration)(s)?;
     Ok((
@@ -243,7 +243,7 @@ pub fn var(s: Span) -> IResult<Span, Var> {
     Ok((s, Var { nodes: (a,) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn for_step(s: Span) -> IResult<Span, ForStep> {
     let (s, a) = list(symbol(","), for_step_assignment)(s)?;
     Ok((s, ForStep { nodes: (a,) }))

src/parser/behavioral_statements/procedural_blocks_and_assignments.rs

@@ -173,7 +173,7 @@ pub fn blocking_assignment(s: Span) -> IResult<Span, BlockingAssignment> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn blocking_assignment_variable(s: Span) -> IResult<Span, BlockingAssignment> {
     let (s, a) = variable_lvalue(s)?;
     let (s, b) = symbol("=")(s)?;
@@ -187,7 +187,7 @@ pub fn blocking_assignment_variable(s: Span) -> IResult<Span, BlockingAssignment
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn blocking_assignment_nonrange_variable(s: Span) -> IResult<Span, BlockingAssignment> {
     let (s, a) = nonrange_variable_lvalue(s)?;
     let (s, b) = symbol("=")(s)?;
@@ -215,7 +215,7 @@ pub fn blocking_assignment_hierarchical_variable(s: Span) -> IResult<Span, Block
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn operator_assignment(s: Span) -> IResult<Span, OperatorAssignment> {
     let (s, a) = variable_lvalue(s)?;
     let (s, b) = assignment_operator(s)?;
@@ -242,7 +242,7 @@ pub fn assignment_operator(s: Span) -> IResult<Span, AssignmentOperator> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn nonblocking_assignment(s: Span) -> IResult<Span, NonblockingAssignment> {
     let (s, a) = variable_lvalue(s)?;
     let (s, b) = symbol("<=")(s)?;
@@ -352,7 +352,7 @@ pub fn procedural_continuous_assignment_release_net(
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn variable_assignment(s: Span) -> IResult<Span, VariableAssignment> {
     let (s, a) = variable_lvalue(s)?;
     let (s, b) = symbol("=")(s)?;

src/parser/behavioral_statements/randsequence.rs

@@ -307,7 +307,7 @@ pub fn rs_case_item(s: Span) -> IResult<Span, RsCaseItem> {
     alt((rs_case_item_nondefault, rs_case_item_default))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn rs_case_item_nondefault(s: Span) -> IResult<Span, RsCaseItem> {
     let (s, a) = list(symbol(","), case_item_expression)(s)?;
     let (s, b) = symbol(":")(s)?;

src/parser/behavioral_statements/statements.rs

@@ -93,7 +93,7 @@ pub fn statement_or_null_attribute(s: Span) -> IResult<Span, StatementOrNull> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn statement(s: Span) -> IResult<Span, Statement> {
     let (s, a) = opt(pair(block_identifier, symbol(":")))(s)?;
     let (s, b) = many0(attribute_instance)(s)?;

src/parser/behavioral_statements/timing_control_statements.rs

@@ -334,7 +334,7 @@ pub fn event_expression(s: Span) -> IResult<Span, EventExpression> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn event_expression_expression(s: Span) -> IResult<Span, EventExpression> {
     let (s, a) = opt(edge_identifier)(s)?;
     let (s, b) = expression(s)?;
@@ -355,7 +355,7 @@ pub fn event_expression_sequence(s: Span) -> IResult<Span, EventExpression> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn event_expression_or(s: Span) -> IResult<Span, EventExpression> {
     let (s, a) = event_expression(s)?;
     let (s, b) = symbol("or")(s)?;
@@ -366,7 +366,7 @@ pub fn event_expression_or(s: Span) -> IResult<Span, EventExpression> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn event_expression_comma(s: Span) -> IResult<Span, EventExpression> {
     let (s, a) = event_expression(s)?;
     let (s, b) = symbol(",")(s)?;

src/parser/declarations/assertion_declarations.rs

@@ -898,7 +898,7 @@ pub fn property_list_of_arguments(s: Span) -> IResult<Span, PropertyListOfArgume
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_list_of_arguments_ordered(s: Span) -> IResult<Span, PropertyListOfArguments> {
     let (s, a) = list(symbol(","), opt(property_actual_arg))(s)?;
     let (s, b) = many0(tuple((
@@ -1007,7 +1007,7 @@ pub fn property_formal_type(s: Span) -> IResult<Span, PropertyFormalType> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_spec(s: Span) -> IResult<Span, PropertySpec> {
     let (s, a) = opt(clocking_event)(s)?;
     let (s, b) = opt(triple(
@@ -1101,7 +1101,7 @@ pub fn property_expr_not(s: Span) -> IResult<Span, PropertyExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_or(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = property_expr(s)?;
     let (s, b) = symbol("or")(s)?;
@@ -1112,7 +1112,7 @@ pub fn property_expr_or(s: Span) -> IResult<Span, PropertyExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_and(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = property_expr(s)?;
     let (s, b) = symbol("and")(s)?;
@@ -1123,7 +1123,7 @@ pub fn property_expr_and(s: Span) -> IResult<Span, PropertyExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_implication_overlapped(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = sequence_expr(s)?;
     let (s, b) = symbol("|->")(s)?;
@@ -1136,7 +1136,7 @@ pub fn property_expr_implication_overlapped(s: Span) -> IResult<Span, PropertyEx
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_implication_nonoverlapped(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = sequence_expr(s)?;
     let (s, b) = symbol("|=>")(s)?;
@@ -1178,7 +1178,7 @@ pub fn property_expr_case(s: Span) -> IResult<Span, PropertyExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_followed_by_overlapped(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = sequence_expr(s)?;
     let (s, b) = symbol("#-#")(s)?;
@@ -1191,7 +1191,7 @@ pub fn property_expr_followed_by_overlapped(s: Span) -> IResult<Span, PropertyEx
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_followed_by_nonoverlapped(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = sequence_expr(s)?;
     let (s, b) = symbol("#=#")(s)?;
@@ -1270,7 +1270,7 @@ pub fn property_expr_s_eventually(s: Span) -> IResult<Span, PropertyExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_until(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = property_expr(s)?;
     let (s, b) = symbol("until")(s)?;
@@ -1281,7 +1281,7 @@ pub fn property_expr_until(s: Span) -> IResult<Span, PropertyExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_s_until(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = property_expr(s)?;
     let (s, b) = symbol("s_until")(s)?;
@@ -1292,7 +1292,7 @@ pub fn property_expr_s_until(s: Span) -> IResult<Span, PropertyExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_until_with(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = property_expr(s)?;
     let (s, b) = symbol("until_with")(s)?;
@@ -1303,7 +1303,7 @@ pub fn property_expr_until_with(s: Span) -> IResult<Span, PropertyExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_s_until_with(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = property_expr(s)?;
     let (s, b) = symbol("s_until_with")(s)?;
@@ -1314,7 +1314,7 @@ pub fn property_expr_s_until_with(s: Span) -> IResult<Span, PropertyExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_implies(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = property_expr(s)?;
     let (s, b) = symbol("implies")(s)?;
@@ -1325,7 +1325,7 @@ pub fn property_expr_implies(s: Span) -> IResult<Span, PropertyExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_expr_iff(s: Span) -> IResult<Span, PropertyExpr> {
     let (s, a) = property_expr(s)?;
     let (s, b) = symbol("iff")(s)?;
@@ -1395,7 +1395,7 @@ pub fn property_case_item(s: Span) -> IResult<Span, PropertyCaseItem> {
     alt((property_case_item_nondefault, property_case_item_default))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn property_case_item_nondefault(s: Span) -> IResult<Span, PropertyCaseItem> {
     let (s, a) = list(symbol(","), expression_or_dist)(s)?;
     let (s, b) = symbol(":")(s)?;
@@ -1513,7 +1513,7 @@ pub fn sequence_expr_cycle_delay_expr(s: Span) -> IResult<Span, SequenceExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub 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)?;
@@ -1527,7 +1527,7 @@ pub fn sequence_expr_expr_cycle_delay_expr(s: Span) -> IResult<Span, SequenceExp
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn sequence_expr_expression(s: Span) -> IResult<Span, SequenceExpr> {
     let (s, a) = expression_or_dist(s)?;
     let (s, b) = opt(boolean_abbrev)(s)?;
@@ -1560,7 +1560,7 @@ pub fn sequence_expr_paren(s: Span) -> IResult<Span, SequenceExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn sequence_expr_and(s: Span) -> IResult<Span, SequenceExpr> {
     let (s, a) = sequence_expr(s)?;
     let (s, b) = symbol("and")(s)?;
@@ -1571,7 +1571,7 @@ pub fn sequence_expr_and(s: Span) -> IResult<Span, SequenceExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn sequence_expr_intersect(s: Span) -> IResult<Span, SequenceExpr> {
     let (s, a) = sequence_expr(s)?;
     let (s, b) = symbol("intersect")(s)?;
@@ -1582,7 +1582,7 @@ pub fn sequence_expr_intersect(s: Span) -> IResult<Span, SequenceExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn sequence_expr_or(s: Span) -> IResult<Span, SequenceExpr> {
     let (s, a) = sequence_expr(s)?;
     let (s, b) = symbol("or")(s)?;
@@ -1606,7 +1606,7 @@ pub fn sequence_expr_first_match(s: Span) -> IResult<Span, SequenceExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn sequence_expr_throughout(s: Span) -> IResult<Span, SequenceExpr> {
     let (s, a) = expression_or_dist(s)?;
     let (s, b) = symbol("throughout")(s)?;
@@ -1617,7 +1617,7 @@ pub fn sequence_expr_throughout(s: Span) -> IResult<Span, SequenceExpr> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn sequence_expr_within(s: Span) -> IResult<Span, SequenceExpr> {
     let (s, a) = sequence_expr(s)?;
     let (s, b) = symbol("within")(s)?;
@@ -1724,7 +1724,7 @@ pub fn sequence_list_of_arguments(s: Span) -> IResult<Span, SequenceListOfArgume
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn sequence_list_of_arguments_ordered(s: Span) -> IResult<Span, SequenceListOfArguments> {
     let (s, a) = list(symbol(","), opt(sequence_actual_arg))(s)?;
     let (s, b) = many0(tuple((
@@ -1848,7 +1848,7 @@ pub fn cycle_delay_const_range_expression(
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn cycle_delay_const_range_expression_binary(
     s: Span,
 ) -> IResult<Span, CycleDelayConstRangeExpression> {
@@ -1863,7 +1863,7 @@ pub fn cycle_delay_const_range_expression_binary(
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn cycle_delay_const_range_expression_dollar(
     s: Span,
 ) -> IResult<Span, CycleDelayConstRangeExpression> {
@@ -1878,7 +1878,7 @@ pub fn cycle_delay_const_range_expression_dollar(
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn expression_or_dist(s: Span) -> IResult<Span, ExpressionOrDist> {
     let (s, a) = expression(s)?;
     let (s, b) = opt(pair(symbol("dist"), brace(dist_list)))(s)?;

src/parser/declarations/block_item_declarations.rs

@@ -54,7 +54,7 @@ pub fn block_item_declaration(s: Span) -> IResult<Span, BlockItemDeclaration> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn block_item_declaration_data(s: Span) -> IResult<Span, BlockItemDeclaration> {
     let (s, a) = many0(attribute_instance)(s)?;
     let (s, b) = data_declaration(s)?;

src/parser/declarations/covergroup_declarations.rs

@@ -647,7 +647,7 @@ pub fn block_event_expression(s: Span) -> IResult<Span, BlockEventExpression> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn block_event_expression_or(s: Span) -> IResult<Span, BlockEventExpression> {
     let (s, a) = block_event_expression(s)?;
     let (s, b) = symbol("or")(s)?;
@@ -891,7 +891,7 @@ pub fn trans_list(s: Span) -> IResult<Span, TransList> {
     Ok((s, TransList { nodes: (a,) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn trans_set(s: Span) -> IResult<Span, TransSet> {
     let (s, a) = list(symbol("=>"), trans_range_list)(s)?;
     Ok((s, TransSet { nodes: (a,) }))
@@ -907,7 +907,7 @@ pub fn trans_range_list(s: Span) -> IResult<Span, TransRangeList> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn trans_range_list_asterisk(s: Span) -> IResult<Span, TransRangeList> {
     let (s, a) = trans_item(s)?;
     let (s, b) = bracket(pair(symbol("*"), repeat_range))(s)?;
@@ -917,7 +917,7 @@ pub fn trans_range_list_asterisk(s: Span) -> IResult<Span, TransRangeList> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn trans_range_list_arrow(s: Span) -> IResult<Span, TransRangeList> {
     let (s, a) = trans_item(s)?;
     let (s, b) = bracket(pair(symbol("->"), repeat_range))(s)?;
@@ -927,7 +927,7 @@ pub fn trans_range_list_arrow(s: Span) -> IResult<Span, TransRangeList> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn trans_range_list_equal(s: Span) -> IResult<Span, TransRangeList> {
     let (s, a) = trans_item(s)?;
     let (s, b) = bracket(pair(symbol("="), repeat_range))(s)?;
@@ -953,7 +953,7 @@ pub fn repeat_range(s: Span) -> IResult<Span, RepeatRange> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn repeat_range_binary(s: Span) -> IResult<Span, RepeatRange> {
     let (s, a) = covergroup_expression(s)?;
     let (s, b) = symbol(":")(s)?;
@@ -1089,7 +1089,7 @@ pub fn select_expression_not(s: Span) -> IResult<Span, SelectExpression> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn select_expression_and(s: Span) -> IResult<Span, SelectExpression> {
     let (s, a) = select_expression(s)?;
     let (s, b) = symbol("&&")(s)?;
@@ -1100,7 +1100,7 @@ pub fn select_expression_and(s: Span) -> IResult<Span, SelectExpression> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn select_expression_or(s: Span) -> IResult<Span, SelectExpression> {
     let (s, a) = select_expression(s)?;
     let (s, b) = symbol("||")(s)?;
@@ -1120,7 +1120,7 @@ pub fn select_expression_paren(s: Span) -> IResult<Span, SelectExpression> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn select_expression_with(s: Span) -> IResult<Span, SelectExpression> {
     let (s, a) = select_expression(s)?;
     let (s, b) = symbol("with")(s)?;
@@ -1134,7 +1134,7 @@ pub fn select_expression_with(s: Span) -> IResult<Span, SelectExpression> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn select_expression_cross_set(s: Span) -> IResult<Span, SelectExpression> {
     let (s, a) = cross_set_expression(s)?;
     let (s, b) = opt(pair(symbol("matches"), integer_covergroup_expression))(s)?;
@@ -1172,7 +1172,7 @@ pub fn bins_expression_cover_point(s: Span) -> IResult<Span, BinsExpression> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn covergroup_range_list(s: Span) -> IResult<Span, CovergroupRangeList> {
     let (s, a) = list(symbol(","), covergroup_value_range)(s)?;
     Ok((s, CovergroupRangeList { nodes: (a,) }))

src/parser/declarations/let_declarations.rs

@@ -162,7 +162,7 @@ pub fn let_list_of_arguments(s: Span) -> IResult<Span, LetListOfArguments> {
     alt((let_list_of_arguments_ordered, let_list_of_arguments_named))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn let_list_of_arguments_ordered(s: Span) -> IResult<Span, LetListOfArguments> {
     let (s, a) = list(symbol(","), opt(let_actual_arg))(s)?;
     let (s, b) = many0(tuple((

src/parser/expressions/concatenations.rs

@@ -175,7 +175,7 @@ pub fn stream_concatenation(s: Span) -> IResult<Span, StreamConcatenation> {
     Ok((s, StreamConcatenation { nodes: (a,) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn stream_expression(s: Span) -> IResult<Span, StreamExpression> {
     let (s, a) = expression(s)?;
     let (s, b) = opt(pair(symbol("with"), bracket(array_range_expression)))(s)?;
@@ -192,7 +192,7 @@ pub fn array_range_expression(s: Span) -> IResult<Span, ArrayRangeExpression> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn array_range_expression_colon(s: Span) -> IResult<Span, ArrayRangeExpression> {
     let (s, a) = expression(s)?;
     let (s, b) = symbol(":")(s)?;
@@ -203,7 +203,7 @@ pub fn array_range_expression_colon(s: Span) -> IResult<Span, ArrayRangeExpressi
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn array_range_expression_plus_colon(s: Span) -> IResult<Span, ArrayRangeExpression> {
     let (s, a) = expression(s)?;
     let (s, b) = symbol("+:")(s)?;
@@ -214,7 +214,7 @@ pub fn array_range_expression_plus_colon(s: Span) -> IResult<Span, ArrayRangeExp
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn array_range_expression_minus_colon(s: Span) -> IResult<Span, ArrayRangeExpression> {
     let (s, a) = expression(s)?;
     let (s, b) = symbol("-:")(s)?;

src/parser/expressions/expression_leftside_values.rs

@@ -156,6 +156,41 @@ pub fn nonrange_variable_lvalue(s: Span) -> IResult<Span, NonrangeVariableLvalue
     Ok((s, NonrangeVariableLvalue { nodes: (a, b, c) }))
 }
 
+#[derive(Debug, Node)]
+pub enum Expr<'a> {
+    Expr(Box<ExprExpr<'a>>),
+    Term(ExprTerm<'a>),
+}
+
+#[derive(Debug, Node)]
+pub struct ExprExpr<'a> {
+    pub nodes: (Expr<'a>, Symbol<'a>, Expr<'a>),
+}
+
+#[derive(Debug, Node)]
+pub struct ExprTerm<'a> {
+    pub nodes: (Identifier<'a>,),
+}
+
+#[parser]
+pub fn expr(s: Span) -> IResult<Span, Expr> {
+    alt((expr_expr, expr_term))(s)
+}
+
+#[parser(MaybeRecursive)]
+pub fn expr_expr(s: Span) -> IResult<Span, Expr> {
+    let (s, a) = expr(s)?;
+    let (s, b) = symbol("+")(s)?;
+    let (s, c) = expr(s)?;
+    Ok((s, Expr::Expr(Box::new(ExprExpr { nodes: (a, b, c) }))))
+}
+
+#[parser]
+pub fn expr_term(s: Span) -> IResult<Span, Expr> {
+    let (s, a) = identifier(s)?;
+    Ok((s, Expr::Term(ExprTerm { nodes: (a,) })))
+}
+
 // -----------------------------------------------------------------------------
 
 #[cfg(test)]
@@ -184,4 +219,10 @@ mod tests {
         //parser_test!(nonrange_variable_lvalue, "A[][2][3]", Ok((_, _)));
         //parser_test!(nonrange_variable_lvalue, "A[][]", Ok((_, _)));
     }
+
+    #[test]
+    fn test_expr() {
+        parser_test!(expr, "A", Ok((_, _)));
+        parser_test!(expr, "A+B", Ok((_, _)));
+    }
 }

src/parser/expressions/expressions.rs

@@ -295,7 +295,7 @@ pub fn inc_or_dec_expression_prefix(s: Span) -> IResult<Span, IncOrDecExpression
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn inc_or_dec_expression_suffix(s: Span) -> IResult<Span, IncOrDecExpression> {
     let (s, a) = variable_lvalue(s)?;
     let (s, b) = many0(attribute_instance)(s)?;
@@ -306,7 +306,7 @@ pub fn inc_or_dec_expression_suffix(s: Span) -> IResult<Span, IncOrDecExpression
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn conditional_expression(s: Span) -> IResult<Span, ConditionalExpression> {
     let (s, a) = cond_predicate(s)?;
     let (s, b) = symbol("?")(s)?;
@@ -345,7 +345,7 @@ pub fn constant_expression_unary(s: Span) -> IResult<Span, ConstantExpression> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn constant_expression_binary(s: Span) -> IResult<Span, ConstantExpression> {
     let (s, a) = constant_expression(s)?;
     let (s, b) = binary_operator(s)?;
@@ -359,7 +359,7 @@ pub fn constant_expression_binary(s: Span) -> IResult<Span, ConstantExpression>
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn constant_expression_ternary(s: Span) -> IResult<Span, ConstantExpression> {
     let (s, a) = constant_expression(s)?;
     let (s, b) = symbol("?")(s)?;
@@ -385,7 +385,7 @@ pub fn constant_mintypmax_expression(s: Span) -> IResult<Span, ConstantMintypmax
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn constant_mintypmax_expression_ternary(
     s: Span,
 ) -> IResult<Span, ConstantMintypmaxExpression> {
@@ -448,7 +448,7 @@ pub fn constant_part_select_range(s: Span) -> IResult<Span, ConstantPartSelectRa
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn constant_range(s: Span) -> IResult<Span, ConstantRange> {
     let (s, a) = constant_expression(s)?;
     let (s, b) = symbol(":")(s)?;
@@ -456,7 +456,7 @@ pub fn constant_range(s: Span) -> IResult<Span, ConstantRange> {
     Ok((s, ConstantRange { nodes: (a, b, c) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn constant_indexed_range(s: Span) -> IResult<Span, ConstantIndexedRange> {
     let (s, a) = constant_expression(s)?;
     let (s, b) = alt((symbol("+:"), symbol("-:")))(s)?;
@@ -506,7 +506,7 @@ pub fn expression_operator_assignment(s: Span) -> IResult<Span, Expression> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn expression_binary(s: Span) -> IResult<Span, Expression> {
     let (s, a) = expression(s)?;
     let (s, b) = binary_operator(s)?;
@@ -528,7 +528,7 @@ pub fn tagged_union_expression(s: Span) -> IResult<Span, TaggedUnionExpression>
     Ok((s, TaggedUnionExpression { nodes: (a, b, c) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn inside_expression(s: Span) -> IResult<Span, InsideExpression> {
     let (s, a) = expression(s)?;
     let (s, b) = symbol("inside")(s)?;
@@ -558,7 +558,7 @@ pub fn mintypmax_expression(s: Span) -> IResult<Span, MintypmaxExpression> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn mintypmax_expression_ternary(s: Span) -> IResult<Span, MintypmaxExpression> {
     let (s, a) = expression(s)?;
     let (s, b) = symbol(":")(s)?;
@@ -573,7 +573,7 @@ pub fn mintypmax_expression_ternary(s: Span) -> IResult<Span, MintypmaxExpressio
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn module_path_conditional_expression(
     s: Span,
 ) -> IResult<Span, ModulePathConditionalExpression> {
@@ -616,7 +616,7 @@ pub fn module_path_expression_unary(s: Span) -> IResult<Span, ModulePathExpressi
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn module_path_expression_binary(s: Span) -> IResult<Span, ModulePathExpression> {
     let (s, a) = module_path_expression(s)?;
     let (s, b) = binary_module_path_operator(s)?;
@@ -640,7 +640,7 @@ pub fn module_path_mintypmax_expression(s: Span) -> IResult<Span, ModulePathMint
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn module_path_mintypmax_expression_ternary(
     s: Span,
 ) -> IResult<Span, ModulePathMintypmaxExpression> {
@@ -665,7 +665,7 @@ pub fn part_select_range(s: Span) -> IResult<Span, PartSelectRange> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn indexed_range(s: Span) -> IResult<Span, IndexedRange> {
     let (s, a) = expression(s)?;
     let (s, b) = alt((symbol("+:"), symbol("-:")))(s)?;

src/parser/expressions/primaries.rs

@@ -466,7 +466,7 @@ pub fn class_qualifier_or_package_scope(s: Span) -> IResult<Span, ClassQualifier
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn class_qualifier(s: Span) -> IResult<Span, ClassQualifier> {
     let (s, a) = opt(local)(s)?;
     let (s, b) = opt(implicit_class_handle_or_class_scope)(s)?;
@@ -589,7 +589,7 @@ pub fn constant_select(s: Span) -> IResult<Span, ConstantSelect> {
     Ok((s, ConstantSelect { nodes: (a, b, c) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn constant_cast(s: Span) -> IResult<Span, ConstantCast> {
     let (s, a) = casting_type(s)?;
     let (s, b) = symbol("'")(s)?;
@@ -603,7 +603,7 @@ pub fn constant_let_expression(s: Span) -> IResult<Span, ConstantLetExpression>
     Ok((s, ConstantLetExpression { nodes: (a,) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn cast(s: Span) -> IResult<Span, Cast> {
     let (s, a) = casting_type(s)?;
     let (s, b) = symbol("'")(s)?;

src/parser/expressions/subroutine_calls.rs

@@ -272,7 +272,7 @@ pub fn list_of_arguments(s: Span) -> IResult<Span, ListOfArguments> {
     alt((list_of_arguments_ordered, list_of_arguments_named))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn list_of_arguments_ordered(s: Span) -> IResult<Span, ListOfArguments> {
     let (s, a) = list(symbol(","), opt(expression))(s)?;
     let (s, b) = many0(tuple((
@@ -306,7 +306,7 @@ pub fn list_of_arguments_named(s: Span) -> IResult<Span, ListOfArguments> {
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn method_call(s: Span) -> IResult<Span, MethodCall> {
     let (s, a) = method_call_root(s)?;
     let (s, b) = symbol(".")(s)?;

src/parser/instantiations/checker_instantiation.rs

@@ -83,7 +83,7 @@ pub fn list_of_checker_port_connections(s: Span) -> IResult<Span, ListOfCheckerP
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn list_of_checker_port_connections_ordered(
     s: Span,
 ) -> IResult<Span, ListOfCheckerPortConnections> {
@@ -105,7 +105,7 @@ pub fn list_of_checker_port_connections_named(
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn ordered_checker_port_connection(s: Span) -> IResult<Span, OrderedCheckerPortConnection> {
     let (s, x) = many0(attribute_instance)(s)?;
     let (s, y) = opt(property_actual_arg)(s)?;

src/parser/instantiations/generated_instantiation.rs

@@ -266,7 +266,7 @@ pub fn case_generate_item(s: Span) -> IResult<Span, CaseGenerateItem> {
     alt((case_generate_item_nondefault, case_generate_item_default))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn case_generate_item_nondefault(s: Span) -> IResult<Span, CaseGenerateItem> {
     let (s, a) = list(symbol(","), constant_expression)(s)?;
     let (s, b) = symbol(":")(s)?;

src/parser/instantiations/module_instantiation.rs

@@ -141,7 +141,7 @@ pub fn list_of_parameter_assignments(s: Span) -> IResult<Span, ListOfParameterAs
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn list_of_parameter_assignments_ordered(s: Span) -> IResult<Span, ListOfParameterAssignments> {
     let (s, a) = list(symbol(","), ordered_parameter_assignment)(s)?;
     Ok((
@@ -195,7 +195,7 @@ pub fn list_of_port_connections(s: Span) -> IResult<Span, ListOfPortConnections>
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn list_of_port_connections_ordered(s: Span) -> IResult<Span, ListOfPortConnections> {
     let (s, a) = list(symbol(","), ordered_port_connection)(s)?;
     Ok((
@@ -213,7 +213,7 @@ pub fn list_of_port_connections_named(s: Span) -> IResult<Span, ListOfPortConnec
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn ordered_port_connection(s: Span) -> IResult<Span, OrderedPortConnection> {
     let (s, x) = many0(attribute_instance)(s)?;
     let (s, y) = opt(expression)(s)?;

src/parser/source_text/constraints.rs

@@ -270,7 +270,7 @@ pub fn constraint_expression(s: Span) -> IResult<Span, ConstraintExpression> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn constraint_expression_expression(s: Span) -> IResult<Span, ConstraintExpression> {
     let (s, a) = opt(soft)(s)?;
     let (s, b) = expression_or_dist(s)?;
@@ -287,7 +287,7 @@ pub fn soft(s: Span) -> IResult<Span, Soft> {
     Ok((s, Soft { nodes: (a,) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn constraint_expression_arrow(s: Span) -> IResult<Span, ConstraintExpression> {
     let (s, a) = expression(s)?;
     let (s, b) = symbol("->")(s)?;
@@ -363,13 +363,13 @@ pub fn constraint_set_brace(s: Span) -> IResult<Span, ConstraintSet> {
     Ok((s, ConstraintSet::Brace(ConstraintSetBrace { nodes: (a,) })))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn dist_list(s: Span) -> IResult<Span, DistList> {
     let (s, a) = list(symbol(","), dist_item)(s)?;
     Ok((s, DistList { nodes: (a,) }))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn dist_item(s: Span) -> IResult<Span, DistItem> {
     let (s, a) = value_range(s)?;
     let (s, b) = opt(dist_weight)(s)?;

src/parser/source_text/interface_items.rs

@@ -66,7 +66,7 @@ pub fn interface_or_generate_item(s: Span) -> IResult<Span, InterfaceOrGenerateI
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn interface_or_generate_item_module(s: Span) -> IResult<Span, InterfaceOrGenerateItem> {
     let (s, a) = many0(attribute_instance)(s)?;
     let (s, b) = module_common_item(s)?;

src/parser/source_text/module_items.rs

@@ -374,7 +374,7 @@ pub fn module_or_generate_item_module(s: Span) -> IResult<Span, ModuleOrGenerate
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn module_or_generate_item_module_item(s: Span) -> IResult<Span, ModuleOrGenerateItem> {
     let (s, a) = many0(attribute_instance)(s)?;
     let (s, b) = module_common_item(s)?;

src/parser/source_text/module_parameters_and_ports.rs

@@ -373,7 +373,7 @@ pub fn port(s: Span) -> IResult<Span, Port> {
     alt((port_non_named, port_named))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn port_non_named(s: Span) -> IResult<Span, Port> {
     let (s, a) = opt(port_expression)(s)?;
     Ok((s, Port::NonNamed(PortNonNamed { nodes: (a,) })))

src/parser/source_text/program_items.rs

@@ -102,7 +102,7 @@ pub fn non_port_program_item_assign(s: Span) -> IResult<Span, NonPortProgramItem
     ))
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn non_port_program_item_module(s: Span) -> IResult<Span, NonPortProgramItem> {
     let (s, a) = many0(attribute_instance)(s)?;
     let (s, b) = module_or_generate_item_declaration(s)?;

src/parser/source_text/system_verilog_source_text.rs

@@ -460,7 +460,7 @@ pub fn description(s: Span) -> IResult<Span, Description> {
     ))(s)
 }
 
-#[parser]
+#[parser(MaybeRecursive)]
 pub fn description_package_item(s: Span) -> IResult<Span, Description> {
     let (s, a) = many0(attribute_instance)(s)?;
     let (s, b) = package_item(s)?;

sv-parser-derive/src/lib.rs

@@ -4,7 +4,10 @@ extern crate proc_macro;
 
 use crate::proc_macro::TokenStream;
 use quote::quote;
-use syn::{self, parse_macro_input, ItemFn};
+use syn::Data::{Enum, Struct};
+use syn::{
+    self, parse_macro_input, AttributeArgs, DeriveInput, Expr, ItemFn, Meta, NestedMeta, Stmt,
+};
 
 #[proc_macro_derive(Node)]
 pub fn node_derive(input: TokenStream) -> TokenStream {
@@ -12,11 +15,11 @@ pub fn node_derive(input: TokenStream) -> TokenStream {
     impl_node(&ast)
 }
 
-fn impl_node(ast: &syn::DeriveInput) -> TokenStream {
+fn impl_node(ast: &DeriveInput) -> TokenStream {
     let name = &ast.ident;
 
     let next = match ast.data {
-        syn::Data::Enum(ref data) => {
+        Enum(ref data) => {
             let mut items = quote! {};
             for v in &data.variants {
                 let ident = &v.ident;
@@ -35,7 +38,7 @@ fn impl_node(ast: &syn::DeriveInput) -> TokenStream {
                 }
             }
         }
-        syn::Data::Struct(_) => {
+        Struct(_) => {
             quote! {
                 (&(self.nodes)).into()
             }
@@ -79,9 +82,9 @@ pub fn any_node_derive(input: TokenStream) -> TokenStream {
     impl_any_node(&ast)
 }
 
-fn impl_any_node(ast: &syn::DeriveInput) -> TokenStream {
+fn impl_any_node(ast: &DeriveInput) -> TokenStream {
     let ref data = match ast.data {
-        syn::Data::Enum(ref data) => data,
+        Enum(ref data) => data,
         _ => unreachable!(),
     };
 
@@ -111,12 +114,15 @@ fn impl_any_node(ast: &syn::DeriveInput) -> TokenStream {
 }
 
 #[proc_macro_attribute]
-pub fn parser(_attr: TokenStream, item: TokenStream) -> TokenStream {
+pub fn parser(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr = parse_macro_input!(attr as AttributeArgs);
     let item = parse_macro_input!(item as ItemFn);
-    impl_parser(&item)
+    impl_parser(&attr, &item)
 }
 
-fn impl_parser(item: &syn::ItemFn) -> TokenStream {
+fn impl_parser(attr: &AttributeArgs, item: &ItemFn) -> TokenStream {
+    let (maybe_recursive,) = impl_parser_attribute(attr);
+
     let ident = &item.ident;
     let mut item = item.clone();
 
@@ -126,7 +132,7 @@ fn impl_parser(item: &syn::ItemFn) -> TokenStream {
         }
     };
     let tracer: TokenStream = tracer.into();
-    let tracer = parse_macro_input!(tracer as syn::Stmt);
+    let tracer = parse_macro_input!(tracer as Stmt);
 
     let checker = quote! {
         if thread_context::PARSER_INDEX.with(|p| {
@@ -143,7 +149,7 @@ fn impl_parser(item: &syn::ItemFn) -> TokenStream {
         }
     };
     let checker: TokenStream = checker.into();
-    let checker = parse_macro_input!(checker as syn::Stmt);
+    let checker = parse_macro_input!(checker as Stmt);
 
     let before = quote! {
         let s = thread_context::PARSER_INDEX.with(|p| {
@@ -158,7 +164,7 @@ fn impl_parser(item: &syn::ItemFn) -> TokenStream {
         });
     };
     let before: TokenStream = before.into();
-    let before = parse_macro_input!(before as syn::Stmt);
+    let before = parse_macro_input!(before as Stmt);
 
     let mut body = quote! {};
     for s in &item.block.stmts {
@@ -171,19 +177,21 @@ fn impl_parser(item: &syn::ItemFn) -> TokenStream {
         let (s, ret) = { #body }?;
     };
     let body: TokenStream = body.into();
-    let body = parse_macro_input!(body as syn::Stmt);
+    let body = parse_macro_input!(body as Stmt);
 
     let after = quote! {
         Ok((clear_bit(s), ret))
     };
     let after: TokenStream = after.into();
-    let after = parse_macro_input!(after as syn::Expr);
-    let after = syn::Stmt::Expr(after);
+    let after = parse_macro_input!(after as Expr);
+    let after = Stmt::Expr(after);
 
     item.block.stmts.clear();
     item.block.stmts.push(tracer);
-    item.block.stmts.push(checker);
-    item.block.stmts.push(before);
+    if maybe_recursive {
+        item.block.stmts.push(checker);
+        item.block.stmts.push(before);
+    }
     item.block.stmts.push(body);
     item.block.stmts.push(after);
 
@@ -192,3 +200,16 @@ fn impl_parser(item: &syn::ItemFn) -> TokenStream {
     };
     gen.into()
 }
+
+fn impl_parser_attribute(attr: &AttributeArgs) -> (bool,) {
+    let mut maybe_recursive = false;
+
+    for a in attr {
+        match a {
+            NestedMeta::Meta(Meta::Word(x)) if x == "MaybeRecursive" => maybe_recursive = true,
+            _ => panic!(),
+        }
+    }
+
+    (maybe_recursive,)
+}