fix clippy warnings on assert_eq with boolean

crates/analyzer/src/handlers/check_identifier.rs

@@ -456,49 +456,49 @@ mod tests {
 
     #[test]
     fn lower_camel_case() {
-        assert_eq!(is_lower_camel_case("abc"), true);
-        assert_eq!(is_lower_camel_case("aBc"), true);
-        assert_eq!(is_lower_camel_case("AbC"), false);
-        assert_eq!(is_lower_camel_case("ABc"), false);
-        assert_eq!(is_lower_camel_case("ABC"), false);
-        assert_eq!(is_lower_camel_case("a_b_c"), false);
-        assert_eq!(is_lower_camel_case("a_B_c"), false);
-        assert_eq!(is_lower_camel_case("A_B_C"), false);
+        assert!(is_lower_camel_case("abc"));
+        assert!(is_lower_camel_case("aBc"));
+        assert!(!is_lower_camel_case("AbC"));
+        assert!(!is_lower_camel_case("ABc"));
+        assert!(!is_lower_camel_case("ABC"));
+        assert!(!is_lower_camel_case("a_b_c"));
+        assert!(!is_lower_camel_case("a_B_c"));
+        assert!(!is_lower_camel_case("A_B_C"));
     }
 
     #[test]
     fn upper_camel_case() {
-        assert_eq!(is_upper_camel_case("abc"), false);
-        assert_eq!(is_upper_camel_case("aBc"), false);
-        assert_eq!(is_upper_camel_case("AbC"), true);
-        assert_eq!(is_upper_camel_case("ABc"), true);
-        assert_eq!(is_upper_camel_case("ABC"), true);
-        assert_eq!(is_upper_camel_case("a_b_c"), false);
-        assert_eq!(is_upper_camel_case("a_B_c"), false);
-        assert_eq!(is_upper_camel_case("A_B_C"), false);
+        assert!(!is_upper_camel_case("abc"));
+        assert!(!is_upper_camel_case("aBc"));
+        assert!(is_upper_camel_case("AbC"));
+        assert!(is_upper_camel_case("ABc"));
+        assert!(is_upper_camel_case("ABC"));
+        assert!(!is_upper_camel_case("a_b_c"));
+        assert!(!is_upper_camel_case("a_B_c"));
+        assert!(!is_upper_camel_case("A_B_C"));
     }
 
     #[test]
     fn snake_case() {
-        assert_eq!(is_snake_case("abc"), true);
-        assert_eq!(is_snake_case("aBc"), false);
-        assert_eq!(is_snake_case("AbC"), false);
-        assert_eq!(is_snake_case("ABc"), false);
-        assert_eq!(is_snake_case("ABC"), false);
-        assert_eq!(is_snake_case("a_b_c"), true);
-        assert_eq!(is_snake_case("a_B_c"), false);
-        assert_eq!(is_snake_case("A_B_C"), false);
+        assert!(is_snake_case("abc"));
+        assert!(!is_snake_case("aBc"));
+        assert!(!is_snake_case("AbC"));
+        assert!(!is_snake_case("ABc"));
+        assert!(!is_snake_case("ABC"));
+        assert!(is_snake_case("a_b_c"));
+        assert!(!is_snake_case("a_B_c"));
+        assert!(!is_snake_case("A_B_C"));
     }
 
     #[test]
     fn screaming_snake_case() {
-        assert_eq!(is_screaming_snake_case("abc"), false);
-        assert_eq!(is_screaming_snake_case("aBc"), false);
-        assert_eq!(is_screaming_snake_case("AbC"), false);
-        assert_eq!(is_screaming_snake_case("ABc"), false);
-        assert_eq!(is_screaming_snake_case("ABC"), true);
-        assert_eq!(is_screaming_snake_case("a_b_c"), false);
-        assert_eq!(is_screaming_snake_case("a_B_c"), false);
-        assert_eq!(is_screaming_snake_case("A_B_C"), true);
+        assert!(!is_screaming_snake_case("abc"));
+        assert!(!is_screaming_snake_case("aBc"));
+        assert!(!is_screaming_snake_case("AbC"));
+        assert!(!is_screaming_snake_case("ABc"));
+        assert!(is_screaming_snake_case("ABC"));
+        assert!(!is_screaming_snake_case("a_b_c"));
+        assert!(!is_screaming_snake_case("a_B_c"));
+        assert!(is_screaming_snake_case("A_B_C"));
     }
 }

crates/analyzer/src/handlers/check_port.rs

@@ -26,11 +26,16 @@ impl Handler for CheckPort {
 
 impl VerylGrammarTrait for CheckPort {
     fn port_declaration_item(&mut self, arg: &PortDeclarationItem) -> Result<(), ParolError> {
+        println!("PER: x {:?}", arg.identifier.identifier_token.token.to_string());
         if let HandlerPoint::Before = self.point {
             if let PortDeclarationItemGroup::PortTypeConcrete(x) =
                 arg.port_declaration_item_group.as_ref()
             {
                 let x = x.port_type_concrete.as_ref();
+
+                // println!("PER: x {:?}", x.port_type_concrete_opt);
+                // println!("PER: x {:?}", x.port_type_concrete_opt0);
+
                 let direction = x.direction.as_ref();
                 if let Direction::Inout(_) = direction {
                     let r#type = &x.array_type;

crates/analyzer/src/handlers/check_type.rs

@@ -215,6 +215,7 @@ impl VerylGrammarTrait for CheckType {
     fn scoped_identifier(&mut self, arg: &ScopedIdentifier) -> Result<(), ParolError> {
         if let HandlerPoint::Before = self.point {
             if let Ok(symbol) = symbol_table::resolve(arg) {
+                println!("Malte: token: {:?} kind: {:?}", symbol.found.token.to_string(), symbol.found.kind);
                 // Mangled enum member can't be used directly
                 if matches!(symbol.found.kind, SymbolKind::EnumMemberMangled) {
                     self.errors.push(AnalyzerError::undefined_identifier(

crates/analyzer/src/tests.rs

@@ -4393,6 +4393,30 @@ fn clock_domain() {
     ));
 }
 
+#[test]
+fn bit_width() {
+    let code = r#"
+    module t1 (
+    i: input logic<314>,
+    o: output logic,
+    ) {
+        assign o = 1;
+    }
+
+    module t2 (
+        i4: input logic<4>,
+        o4: output logic<-1>,
+    ) {
+        //    inst my_t1: t1 (i: i4, o: o4[0]); // correct type o4[0] is 1 bit wide
+        inst my_t1: t1 (i: i4, o: o4); // incorrect type o4 is 4 bit wide (should be rejected)
+    }
+    "#;
+
+    let errors = analyze(code);
+    println!("errors {:?}", errors);
+    // assert!(matches!(errors[0], AnalyzerError::UnknownUnsafe { .. }));
+}
+
 #[test]
 fn r#unsafe() {
     let code = r#"