Fix ifdef attribute state leaking across scopes accepting orphan else/elsif

Author: dalance

crates/analyzer/src/handlers/check_attribute.rs

@@ -165,6 +165,15 @@ impl CheckAttribute {
         self.check_ifdef(&mut attrs, last);
         self.set_attrs(attrs, range);
     }
+
+    /// An elsif/else can only chain to an ifdef/ifndef in the same group
+    /// list; clear the state left by a previous list or an enclosing scope,
+    /// which would otherwise let an orphan #[else] emit an unmatched `else.
+    fn reset_ifdef(&mut self) {
+        self.ifdef_state = IfdefState::None;
+        self.ifdef_pos.clear();
+        self.ifdef_neg.clear();
+    }
 }
 
 impl Handler for CheckAttribute {
@@ -176,6 +185,7 @@ impl Handler for CheckAttribute {
 impl VerylGrammarTrait for CheckAttribute {
     fn statement_block(&mut self, arg: &StatementBlock) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             for x in &arg.statement_block_list {
                 let x = x.statement_block_group.as_ref();
                 let attrs: Vec<_> = x
@@ -191,6 +201,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn modport_list(&mut self, arg: &ModportList) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             let mut groups = vec![arg.modport_group.as_ref()];
             groups.extend(
                 arg.modport_list_list
@@ -213,6 +224,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn enum_list(&mut self, arg: &EnumList) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             let mut groups = vec![arg.enum_group.as_ref()];
             groups.extend(arg.enum_list_list.iter().map(|x| x.enum_group.as_ref()));
             let len = groups.len();
@@ -231,6 +243,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn struct_union_list(&mut self, arg: &StructUnionList) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             let mut groups = vec![arg.struct_union_group.as_ref()];
             groups.extend(
                 arg.struct_union_list_list
@@ -253,6 +266,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn inst_parameter_list(&mut self, arg: &InstParameterList) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             let mut groups = vec![arg.inst_parameter_group.as_ref()];
             groups.extend(
                 arg.inst_parameter_list_list
@@ -275,6 +289,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn inst_port_list(&mut self, arg: &InstPortList) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             let mut groups = vec![arg.inst_port_group.as_ref()];
             groups.extend(
                 arg.inst_port_list_list
@@ -297,6 +312,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn with_parameter_list(&mut self, arg: &WithParameterList) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             let mut groups = vec![arg.with_parameter_group.as_ref()];
             groups.extend(
                 arg.with_parameter_list_list
@@ -319,6 +335,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn port_declaration_list(&mut self, arg: &PortDeclarationList) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             let mut groups = vec![arg.port_declaration_group.as_ref()];
             groups.extend(
                 arg.port_declaration_list_list
@@ -341,6 +358,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn module_declaration(&mut self, arg: &ModuleDeclaration) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             for x in &arg.module_declaration_list {
                 let x = x.module_group.as_ref();
                 let attrs: Vec<_> = x
@@ -356,6 +374,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn interface_declaration(&mut self, arg: &InterfaceDeclaration) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             for x in &arg.interface_declaration_list {
                 let x = x.interface_group.as_ref();
                 let attrs: Vec<_> = x
@@ -371,6 +390,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn generate_named_block(&mut self, arg: &GenerateNamedBlock) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             for x in &arg.generate_named_block_list {
                 let x = x.generate_group.as_ref();
                 let attrs: Vec<_> = x
@@ -389,6 +409,7 @@ impl VerylGrammarTrait for CheckAttribute {
         arg: &GenerateOptionalNamedBlock,
     ) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             for x in &arg.generate_optional_named_block_list {
                 let x = x.generate_group.as_ref();
                 let attrs: Vec<_> = x
@@ -404,6 +425,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn package_declaration(&mut self, arg: &PackageDeclaration) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             for x in &arg.package_declaration_list {
                 let x = x.package_group.as_ref();
                 let attrs: Vec<_> = x
@@ -419,6 +441,7 @@ impl VerylGrammarTrait for CheckAttribute {
 
     fn veryl(&mut self, arg: &Veryl) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
+            self.reset_ifdef();
             for x in &arg.veryl_list {
                 let x = x.description_group.as_ref();
                 let attrs: Vec<_> = x

crates/analyzer/src/tests.rs

@@ -18618,3 +18618,68 @@ module M {
     let errors = analyze();
     assert!(errors.is_empty(), "{errors:?}");
 }
+
+#[test]
+fn orphan_else_across_scopes() {
+    // The ifdef/elsif/else attribute state persisted across attribute-group
+    // lists and nesting levels, so an orphan #[else] chained to an #[ifdef]
+    // in a previous module or an enclosing scope and emitted an unmatched
+    // `else into the SV output.
+    let code = r#"
+    module ModuleA {
+        #[ifdef(A)]
+        let _x: logic = 1'b0;
+        let _z: logic = 1'b0;
+    }
+    module ModuleB {
+        #[else]
+        let _y: logic = 1'b0;
+        let _w: logic = 1'b0;
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(
+        errors
+            .iter()
+            .any(|e| matches!(e, AnalyzerError::AmbiguousElsif { .. })),
+        "{errors:?}"
+    );
+
+    // Nested scope: an outer #[ifdef] must not legitimize an inner #[else].
+    let code = r#"
+    #[ifdef(DEF_X)]
+    module ModuleA {
+        #[else]
+        let _a: logic = 1;
+        let _b: logic = 1;
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(
+        errors
+            .iter()
+            .any(|e| matches!(e, AnalyzerError::AmbiguousElsif { .. })),
+        "{errors:?}"
+    );
+
+    // A well-formed chain in one list stays accepted.
+    let code = r#"
+    module ModuleA {
+        #[ifdef(A)]
+        let _x: logic = 1'b0;
+        #[else]
+        let _y: logic = 1'b0;
+        let _z: logic = 1'b0;
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(
+        !errors
+            .iter()
+            .any(|e| matches!(e, AnalyzerError::AmbiguousElsif { .. })),
+        "{errors:?}"
+    );
+}