fix: more style issues

Signed-off-by: jbrinkman <[email protected]>

Author: jbrinkman

Taskfile.yml

@@ -145,11 +145,11 @@ tasks:
   code:fix:stylecop:
     desc: Run StyleCop fix scripts
     cmds:
-      - powershell -ExecutionPolicy Bypass -File ./scripts/Fix-SA1513.ps1
-      - powershell -ExecutionPolicy Bypass -File ./scripts/Fix-ConstructorInitializers.ps1
-      - powershell -ExecutionPolicy Bypass -File ./scripts/Fix-ParameterFormatting.ps1
-      - powershell -ExecutionPolicy Bypass -File ./scripts/Fix-TrailingCommas.ps1
-      - powershell -ExecutionPolicy Bypass -File ./scripts/Add-FinalNewlines.ps1
+      - pwsh -ExecutionPolicy Bypass -File ./scripts/Fix-SA1513.ps1
+      - pwsh -ExecutionPolicy Bypass -File ./scripts/Fix-ConstructorInitializers.ps1
+      - pwsh -ExecutionPolicy Bypass -File ./scripts/Fix-ParameterFormatting.ps1
+      - pwsh -ExecutionPolicy Bypass -File ./scripts/Fix-TrailingCommas.ps1
+      - pwsh -ExecutionPolicy Bypass -File ./scripts/Add-FinalNewlines.ps1
 
   ci:
     desc: Run CI build and test sequence

src/DotNetApiDiff/ApiExtraction/ApiExtractor.cs

@@ -19,65 +19,85 @@ public class ApiExtractor : IApiExtractor
     /// </summary>
     /// <param name="typeAnalyzer">Type analyzer for detailed member analysis</param>
     /// <param name="logger">Logger for diagnostic information</param>
-    public ApiExtractor(ITypeAnalyzer typeAnalyzer, ILogger<ApiExtractor> logger)
+    public ApiExtractor(
+        ITypeAnalyzer typeAnalyzer, ILogger<ApiExtractor> logger)
     {
-        _typeAnalyzer = typeAnalyzer ?? throw new ArgumentNullException(nameof(typeAnalyzer));
-        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        _typeAnalyzer = typeAnalyzer ?? throw new ArgumentNullException(
+        nameof(typeAnalyzer));
+        _logger = logger ?? throw new ArgumentNullException(
+        nameof(logger));,
     }
 
     /// <summary>
     /// Extracts all public API members from the specified assembly
     /// </summary>
     /// <param name="assembly">Assembly to extract API members from</param>
     /// <returns>Collection of public API members</returns>
-    public IEnumerable<ApiMember> ExtractApiMembers(Assembly assembly)
+    public IEnumerable<ApiMember> ExtractApiMembers(
+        Assembly assembly)
     {
         if (assembly == null)
         {
-            throw new ArgumentNullException(nameof(assembly));
+            throw new ArgumentNullException(
+        nameof(assembly));,
         }
 
-        _logger.LogInformation("Extracting API members from assembly: {AssemblyName}", assembly.GetName().Name);
+        _logger.LogInformation(
+        "Extracting API members from assembly: {AssemblyName}", assembly.GetName().Name);
 
         var apiMembers = new List<ApiMember>();
 
         try
         {
             // Get all public types from the assembly
-            var types = GetPublicTypes(assembly).ToList();
-            _logger.LogDebug("Found {TypeCount} public types in assembly {AssemblyName}",
-                types.Count, assembly.GetName().Name);
+            var types = GetPublicTypes(
+        assembly).ToList();
+            _logger.LogDebug(
+        "Found {TypeCount} public types in assembly {AssemblyName}",
+                types.Count, assembly.GetName(
+        ).Name);
 
             // Process each type
             foreach (var type in types)
             {
                 try
                 {
                     // Add the type itself
-                    var typeMember = _typeAnalyzer.AnalyzeType(type);
-                    apiMembers.Add(typeMember);
+                    var typeMember = _typeAnalyzer.AnalyzeType(
+        type);
+                    apiMembers.Add(
+        typeMember);
 
                     // Add all members of the type
-                    var typeMembers = ExtractTypeMembers(type).ToList();
-                    apiMembers.AddRange(typeMembers);
-
-                    _logger.LogDebug("Extracted {MemberCount} members from type {TypeName}",
-                        typeMembers.Count, type.FullName);
+                    var typeMembers = ExtractTypeMembers(
+        type).ToList();
+                    apiMembers.AddRange(
+        typeMembers);
+
+                    _logger.LogDebug(
+        "Extracted {MemberCount} members from type {TypeName}",
+                        typeMembers.Count, type.FullName);,
                 }
+
                 catch (Exception ex)
                 {
-                    _logger.LogError(ex, "Error extracting members from type {TypeName}", type.FullName);
+                    _logger.LogError(
+        ex, "Error extracting members from type {TypeName}", type.FullName);,
                 }
             }
 
-            _logger.LogInformation("Extracted {MemberCount} total API members from assembly {AssemblyName}",
-                apiMembers.Count, assembly.GetName().Name);
+            _logger.LogInformation(
+        "Extracted {MemberCount} total API members from assembly {AssemblyName}",
+                apiMembers.Count, assembly.GetName(
+        ).Name);
 
-            return apiMembers;
+            return apiMembers;,
         }
+
         catch (ReflectionTypeLoadException ex)
         {
-            _logger.LogError(ex, "Error loading types from assembly {AssemblyName}", assembly.GetName().Name);
+            _logger.LogError(
+        ex, "Error loading types from assembly {AssemblyName}", assembly.GetName().Name);
 
             // Log the loader exceptions for more detailed diagnostics
             if (ex.LoaderExceptions != null)
@@ -86,19 +106,23 @@ public IEnumerable<ApiMember> ExtractApiMembers(Assembly assembly)
                 {
                     if (loaderEx != null)
                     {
-                        _logger.LogError(loaderEx, "Loader exception: {Message}", loaderEx.Message);
+                        _logger.LogError(
+        loaderEx, "Loader exception: {Message}", loaderEx.Message);,
                     }
-                }
+                },
             }
 
             // Return any types that were successfully loaded
-            return apiMembers;
+            return apiMembers;,
         }
+
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error extracting API members from assembly {AssemblyName}",
-                assembly.GetName().Name);
-            return apiMembers;
+            _logger.LogError(
+        ex, "Error extracting API members from assembly {AssemblyName}",
+                assembly.GetName(
+        ).Name);
+            return apiMembers;,
         }
     }
 
@@ -107,38 +131,47 @@ public IEnumerable<ApiMember> ExtractApiMembers(Assembly assembly)
     /// </summary>
     /// <param name="type">Type to extract members from</param>
     /// <returns>Collection of public API members for the type</returns>
-    public IEnumerable<ApiMember> ExtractTypeMembers(Type type)
+    public IEnumerable<ApiMember> ExtractTypeMembers(
+        Type type)
     {
         if (type == null)
         {
-            throw new ArgumentNullException(nameof(type));
+            throw new ArgumentNullException(
+        nameof(type));,
         }
 
         var members = new List<ApiMember>();
 
         try
         {
             // Extract methods
-            members.AddRange(_typeAnalyzer.AnalyzeMethods(type));
+            members.AddRange(
+        _typeAnalyzer.AnalyzeMethods(type));
 
             // Extract properties
-            members.AddRange(_typeAnalyzer.AnalyzeProperties(type));
+            members.AddRange(
+        _typeAnalyzer.AnalyzeProperties(type));
 
             // Extract fields
-            members.AddRange(_typeAnalyzer.AnalyzeFields(type));
+            members.AddRange(
+        _typeAnalyzer.AnalyzeFields(type));
 
             // Extract events
-            members.AddRange(_typeAnalyzer.AnalyzeEvents(type));
+            members.AddRange(
+        _typeAnalyzer.AnalyzeEvents(type));
 
             // Extract constructors
-            members.AddRange(_typeAnalyzer.AnalyzeConstructors(type));
+            members.AddRange(
+        _typeAnalyzer.AnalyzeConstructors(type));
 
-            return members;
+            return members;,
         }
+
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error extracting members from type {TypeName}", type.FullName);
-            return members;
+            _logger.LogError(
+        ex, "Error extracting members from type {TypeName}", type.FullName);
+            return members;,
         }
     }
 
@@ -147,34 +180,45 @@ public IEnumerable<ApiMember> ExtractTypeMembers(Type type)
     /// </summary>
     /// <param name="assembly">Assembly to get types from</param>
     /// <returns>Collection of public types</returns>
-    public virtual IEnumerable<Type> GetPublicTypes(Assembly assembly)
+    public virtual IEnumerable<Type> GetPublicTypes(
+        Assembly assembly)
     {
         if (assembly == null)
         {
-            throw new ArgumentNullException(nameof(assembly));
+            throw new ArgumentNullException(
+        nameof(assembly));,
         }
 
         try
         {
             // Get all exported (public) types from the assembly
-            return assembly.GetExportedTypes()
-                .Where(t => !t.IsCompilerGenerated() && !t.IsSpecialName)
-                .OrderBy(t => t.FullName);
+            return assembly.GetExportedTypes(
+        )
+                .Where(
+        t => !t.IsCompilerGenerated() && !t.IsSpecialName)
+                .OrderBy(
+        t => t.FullName);,
         }
+
         catch (ReflectionTypeLoadException ex)
         {
-            _logger.LogError(ex, "Error loading types from assembly {AssemblyName}", assembly.GetName().Name);
+            _logger.LogError(
+        ex, "Error loading types from assembly {AssemblyName}", assembly.GetName().Name);
 
             // Return any types that were successfully loaded
-            return ex.Types.Where(t => t != null).Cast<Type>();
+            return ex.Types.Where(
+        t => t != null).Cast<Type>();,
         }
+
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error getting public types from assembly {AssemblyName}",
-                assembly.GetName().Name);
-            return Enumerable.Empty<Type>();
+            _logger.LogError(
+        ex, "Error getting public types from assembly {AssemblyName}",
+                assembly.GetName(
+        ).Name);
+            return Enumerable.Empty<Type>();,
         }
-    }
+    },
 }
 
 /// <summary>
@@ -187,17 +231,24 @@ public static class ReflectionExtensions
     /// </summary>
     /// <param name="type">Type to check</param>
     /// <returns>True if compiler-generated, false otherwise</returns>
-    public static bool IsCompilerGenerated(this Type type)
+    public static bool IsCompilerGenerated(
+        this Type type)
     {
         // Check for compiler-generated types like closures, iterators, etc.
-        if (type.Name.Contains('<') || type.Name.StartsWith("__"))
+        if (type.Name.Contains(
+        '<') || type.Name.StartsWith("__"))
         {
-            return true;
+            return true;,
         }
 
         // Check for CompilerGeneratedAttribute using IsDefined for better performance
-        return type.IsDefined(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute), true);
+        return type.IsDefined(
+        typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute), true);,
     }
 }
 
 
+
+
+
+