fmt

Author: mhasel

src/codegen/generators/data_type_generator.rs

@@ -366,8 +366,8 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
                             Some(v) => Ok((it.get_qualified_name(), v)),
                             None => self
                                 .types_index
-                                        .get_associated_type(it.get_type_name())
-                                        .map(get_default_for)
+                                .get_associated_type(it.get_type_name())
+                                .map(get_default_for)
                                 .map(|v| (it.get_qualified_name(), v)),
                         })
                     })

src/parser.rs

@@ -1105,7 +1105,9 @@ fn parse_string_size_expression(lexer: &mut ParseSession) -> Option<AstNode> {
                         .with_location(error_range)
                         .with_error_code("E009"),
                 );
-            } else if !is_enum_like && (opening_token == KeywordParensOpen || lexer.token == KeywordParensClose) {
+            } else if !is_enum_like
+                && (opening_token == KeywordParensOpen || lexer.token == KeywordParensClose)
+            {
                 lexer.accept_diagnostic(Diagnostic::new(
                     "Unusual type of parentheses around string size expression, consider using square parentheses '[]'").
                     with_location(error_range)
@@ -1135,21 +1137,14 @@ fn parse_string_type_definition(
 
     // Check if this is actually an enum type (e.g., STRING (a := 1, b := 2))
     // If size is an ExpressionList with assignments, it's likely an invalid enum definition
-    let is_enum_like = matches!(
-        &size,
-        Some(AstNode { stmt: AstStatement::ExpressionList(_), .. })
-    );
+    let is_enum_like = matches!(&size, Some(AstNode { stmt: AstStatement::ExpressionList(_), .. }));
 
     match (size, &name, is_enum_like) {
         (Some(size), _, true) => {
             // This looks like an enum definition with STRING/WSTRING as the type
             // Create an EnumType so validation can catch it as invalid
             Some(DataTypeDeclaration::Definition {
-                data_type: Box::new(DataType::EnumType {
-                    name,
-                    numeric_type: text,
-                    elements: size,
-                }),
+                data_type: Box::new(DataType::EnumType { name, numeric_type: text, elements: size }),
                 location,
                 scope: lexer.scope.clone(),
             })
@@ -1189,11 +1184,8 @@ fn parse_enum_type_definition(
 
     // Check for Codesys-style type specification after the enum list
     // TYPE COLOR : (...) DWORD;
-    let numeric_type = if lexer.token == Identifier {
-        lexer.slice_and_advance()
-    } else {
-        DINT_TYPE.to_string()
-    };
+    let numeric_type =
+        if lexer.token == Identifier { lexer.slice_and_advance() } else { DINT_TYPE.to_string() };
 
     let initializer = lexer.try_consume(KeywordAssignment).then(|| parse_expression(lexer));
     Some((

src/resolver.rs

@@ -389,9 +389,14 @@ impl TypeAnnotator<'_> {
                                     }
                                     // Enum types need to be promoted based on their underlying integer type
                                     DataTypeInformation::Enum { referenced_type, .. } => {
-                                        let enum_base_type = self.index.get_effective_type_or_void_by_name(referenced_type);
-                                        if let DataTypeInformation::Integer { .. } = enum_base_type.get_type_information() {
-                                            if !enum_base_type.information.is_bool() && !enum_base_type.information.is_character() {
+                                        let enum_base_type =
+                                            self.index.get_effective_type_or_void_by_name(referenced_type);
+                                        if let DataTypeInformation::Integer { .. } =
+                                            enum_base_type.get_type_information()
+                                        {
+                                            if !enum_base_type.information.is_bool()
+                                                && !enum_base_type.information.is_character()
+                                            {
                                                 get_bigger_type(
                                                     enum_base_type,
                                                     self.index.get_type_or_panic(DINT_TYPE),

src/validation/tests/enum_validation_test.rs

@@ -416,7 +416,7 @@ fn type_name_used_as_value() {
         END_PROGRAM
         ",
     );
-    
+
     assert!(diagnostics.len() > 0);
     assert_snapshot!(diagnostics, @r#""#);
 }

src/validation/types.rs

@@ -54,8 +54,7 @@ pub fn visit_data_type<T: AnnotationMap>(
                     .with_location(location),
                 );
             }
-        }
-         else {
+        } else {
             validator.push_diagnostic(Diagnostic::unknown_type(numeric_type, location));
         }
     }