Merge pull request #19 from jonathanalgar/quality-improvements

Small code quality improvements

Author: jonathanalgar

src/CustomCode-Analyzer/Analyzer.cs

@@ -421,9 +421,7 @@ private void InitializeCompilationAnalysis(CompilationStartAnalysisContext compi
         private void AnalyzeStruct(SymbolAnalysisContext context, INamedTypeSymbol typeSymbol)
         {
             // Check if the struct has the OSStructure attribute
-            bool hasOSStructureAttribute = typeSymbol.GetAttributes()
-                .Any(a => a.AttributeClass?.Name is "OSStructureAttribute" or "OSStructure");
-
+            bool hasOSStructureAttribute = HasAttribute(typeSymbol, OSStructureAttributeNames);
             if (!hasOSStructureAttribute) return;
 
             // Retrieve the actual syntax node for reporting precise locations
@@ -472,8 +470,7 @@ Location GetMemberLocation()
                 }
 
                 // Check if the member has the OSStructureField attribute
-                var hasOSStructureField = member.GetAttributes()
-                    .Any(a => a.AttributeClass?.Name is "OSStructureFieldAttribute" or "OSStructureField");
+                bool hasOSStructureField = HasAttribute(member, OSStructureFieldAttributeNames);
 
                 // If the member is decorated with OSStructureField but not public, report a diagnostic
                 if (hasOSStructureField && !member.DeclaredAccessibility.HasFlag(Accessibility.Public))
@@ -520,8 +517,7 @@ Location GetMemberLocation()
                 }
 
                 // Check if the member has the OSIgnore attribute
-                var hasOSIgnore = member.GetAttributes()
-                    .Any(a => a.AttributeClass?.Name is "OSIgnoreAttribute" or "OSIgnore");
+                bool hasOSIgnore = HasAttribute(member, OSIgnoreAttributeNames);
 
                 // If the member is decorated with OSIgnore but not public, report a diagnostic
                 if (hasOSIgnore && !member.DeclaredAccessibility.HasFlag(Accessibility.Public))
@@ -576,8 +572,7 @@ private static void AnalyzeInterface(
             ConcurrentDictionary<string, (InterfaceDeclarationSyntax Syntax, INamedTypeSymbol Symbol)> osInterfaces)
         {
             // Check if the interface has the OSInterface attribute
-            var osInterfaceAttr = typeSymbol.GetAttributes()
-                .FirstOrDefault(a => a.AttributeClass?.Name is "OSInterfaceAttribute" or "OSInterface");
+            var osInterfaceAttr = GetAttribute(typeSymbol, OSInterfaceAttributeNames);
             if (osInterfaceAttr == null) return;
 
             var syntaxRef = typeSymbol.DeclaringSyntaxReferences.FirstOrDefault();
@@ -675,15 +670,12 @@ private static void AnalyzeMethod(SymbolAnalysisContext context, IMethodSymbol m
             var containingType = methodSymbol.ContainingType;
 
             // Determine if the method is in an OSInterface or in a class that implements one
-            var hasOSInterfaceAttribute = containingType.GetAttributes()
-                .Any(a => a.AttributeClass?.Name is "OSInterfaceAttribute" or "OSInterface");
+            var hasOSInterfaceAttribute = HasAttribute(containingType, OSInterfaceAttributeNames);
 
             bool implementsOSInterface = false;
             if (!hasOSInterfaceAttribute)
             {
-                implementsOSInterface = containingType.Interfaces
-                    .Any(i => i.GetAttributes()
-                        .Any(a => a.AttributeClass?.Name is "OSInterfaceAttribute" or "OSInterface"));
+                implementsOSInterface = containingType.Interfaces.Any(i => HasAttribute(i, OSInterfaceAttributeNames));
             }
 
             // If this method is part of the OSInterface or an implementation of it, check for underscores
@@ -746,7 +738,7 @@ private static void AnalyzeMethod(SymbolAnalysisContext context, IMethodSymbol m
                         context.Compilation,
                         t => !t.DeclaringSyntaxReferences.IsEmpty &&
                              t.TypeKind == TypeKind.Struct &&
-                             !t.GetAttributes().Any(attr => attr.AttributeClass?.Name is "OSStructureAttribute" or "OSStructure"));
+                             !HasAttribute(t, OSStructureAttributeNames));
 
                     // Determine if any structure type used in the parameter is not decorated with OSStructure
                     bool usesUndecoratedStruct = allStructuresNotExposed.Any(s =>
@@ -785,8 +777,7 @@ private static void AnalyzeClass(SymbolAnalysisContext context, INamedTypeSymbol
             // Check each interface implemented by this class to see if it has [OSInterface]
             foreach (var implementedInterface in typeSymbol.Interfaces)
             {
-                var hasOSInterfaceAttribute = implementedInterface.GetAttributes()
-                    .Any(a => a.AttributeClass?.Name is "OSInterfaceAttribute" or "OSInterface");
+                bool hasOSInterfaceAttribute = HasAttribute(implementedInterface, OSInterfaceAttributeNames);
 
                 if (hasOSInterfaceAttribute)
                 {
@@ -921,8 +912,7 @@ private static void AnalyzeCompilationEnd(
             // Check for duplicate struct names across the compilation
             var allStructures = GetAllTypesInCompilation(
                 context.Compilation,
-                t => t.TypeKind == TypeKind.Struct &&
-                     t.GetAttributes().Any(a => a.AttributeClass?.Name is "OSStructureAttribute" or "OSStructure"));
+                t => t.TypeKind == TypeKind.Struct && HasAttribute(t, OSStructureAttributeNames));
 
 #pragma warning disable RS1024
             var duplicates = allStructures.GroupBy(x => x.Name).Where(g => g.Count() > 1);
@@ -945,6 +935,61 @@ private static void AnalyzeCompilationEnd(
             }
         }
 
+
+        /// <summary>
+        /// Valid names for the OSInterface attribute.
+        /// </summary>
+        private static readonly HashSet<string> OSInterfaceAttributeNames = new()
+        {
+            "OSInterfaceAttribute",
+            "OSInterface"
+        };
+
+        /// <summary>
+        /// Valid names for the OSStructure attribute.
+        /// </summary>
+        private static readonly HashSet<string> OSStructureAttributeNames = new()
+        {
+            "OSStructureAttribute",
+            "OSStructure"
+        };
+
+        /// <summary>
+        /// Valid names for the OSStructureField attribute.
+        /// </summary>
+        private static readonly HashSet<string> OSStructureFieldAttributeNames = new()
+        {
+            "OSStructureFieldAttribute",
+            "OSStructureField"
+        };
+
+        /// <summary>
+        /// Valid names for the OSIgnore attribute.
+        /// </summary>
+        private static readonly HashSet<string> OSIgnoreAttributeNames = new()
+        {
+            "OSIgnoreAttribute",
+            "OSIgnore"
+        };
+
+        /// <summary>
+        /// Contains valid names for OSIgnore attribute, used to mark fields that should be ignored during serialization.
+        /// </summary>
+        private static bool HasAttribute(ISymbol symbol, HashSet<string> attributeNames)
+        {
+            return symbol.GetAttributes()
+                .Any(attr => attributeNames.Contains(attr.AttributeClass?.Name));
+        }
+
+        /// <summary>
+        /// Checks if a symbol has any of the specified attributes from the provided set of names.
+        /// </summary>
+        private static AttributeData GetAttribute(ISymbol symbol, HashSet<string> attributeNames)
+        {
+            return symbol.GetAttributes()
+                .FirstOrDefault(attr => attributeNames.Contains(attr.AttributeClass?.Name));
+        }
+
         /// <summary>
         /// Retrieves all <see cref="INamedTypeSymbol"/>s in the current compilation 
         /// that match the given predicate. Traverses through all namespaces in a DFS manner.
@@ -978,18 +1023,16 @@ private static IEnumerable<INamedTypeSymbol> GetAllTypesInCompilation(
         /// A set of valid parameter types for <see cref="UnsupportedDefaultValueRule"/>.
         /// Anything not in this set (and is not null for reference types) is considered invalid.
         /// </summary>
-        private static readonly HashSet<string> ValidParameterTypes = new()
-        {
-            "String",
-            "Int32",
-            "Int64",
-            "Single",
-            "Double",
-            "Decimal",
-            "Boolean",
-            "DateTime",
-            "Byte[]"
-        };
+        private static readonly ImmutableHashSet<SpecialType> ValidParameterSpecialTypes = ImmutableHashSet.Create(
+           SpecialType.System_String,
+           SpecialType.System_Int32,
+           SpecialType.System_Int64,
+           SpecialType.System_Single,
+           SpecialType.System_Double,
+           SpecialType.System_Decimal,
+           SpecialType.System_Boolean,
+           SpecialType.System_DateTime
+        );
 
         /// <summary>
         /// Checks whether a parameter's default value is a compile-time constant of a supported type.
@@ -1006,8 +1049,11 @@ private static bool IsValidParameterDefaultValue(IParameterSymbol parameter)
             {
                 return true;
             }
-            // Check if the type is in the set of valid parameter types
-            if (!ValidParameterTypes.Contains(parameter.Type.Name))
+
+            // Check if type is supported
+            if (!ValidParameterSpecialTypes.Contains(parameter.Type.SpecialType) &&
+                !(parameter.Type is IArrayTypeSymbol arrayType &&
+                  arrayType.ElementType.SpecialType == SpecialType.System_Byte))
             {
                 return false;
             }
@@ -1039,37 +1085,34 @@ private static bool IsValidParameterType(ITypeSymbol typeSymbol, Compilation com
             {
                 return false;
             }
+
             // Check for primitive or special types
-            if (typeSymbol.SpecialType is
-                SpecialType.System_String or
-                SpecialType.System_Int32 or
-                SpecialType.System_Int64 or
-                SpecialType.System_Boolean or
-                SpecialType.System_Decimal or
-                SpecialType.System_Single or
-                SpecialType.System_Double or
-                SpecialType.System_DateTime)
+            if (ValidParameterSpecialTypes.Contains(typeSymbol.SpecialType))
             {
                 return true;
             }
+
             // Check if the type is a byte array
             if (typeSymbol is IArrayTypeSymbol { ElementType.SpecialType: SpecialType.System_Byte })
             {
                 return true;
             }
+
             // Check if the type is a struct with [OSStructure]
-            if (typeSymbol.TypeKind == TypeKind.Struct &&
-                typeSymbol.GetAttributes().Any(a => a.AttributeClass?.Name is "OSStructureAttribute" or "OSStructure"))
+            if (typeSymbol is INamedTypeSymbol { TypeKind: TypeKind.Struct } structType &&
+                HasAttribute(structType, OSStructureAttributeNames))
             {
                 return true;
             }
+
             // Check if the type is a generic type that implements IEnumerable
             if (typeSymbol is INamedTypeSymbol { IsGenericType: true } namedTypeSymbol &&
                 namedTypeSymbol.AllInterfaces.Any(i => i.ToDisplayString() == "System.Collections.IEnumerable"))
             {
                 var typeArg = namedTypeSymbol.TypeArguments.FirstOrDefault();
                 return typeArg != null && IsValidParameterType(typeArg, compilation);
             }
+
             // If none match, it's not a supported parameter type
             return false;
         }