Reindented whole project

Author: odrobnik

Sources/SAAE/CodeDistributor.swift

@@ -3,24 +3,24 @@ import SwiftSyntax
 
 /// Distributes Swift declarations across multiple files
 public class CodeDistributor {
-    
+
     public init() {}
-    
-    /// Distributes declarations from a source file, keeping the first declaration in the original file
-    /// and moving all others to appropriately named separate files.
-    ///
-    /// - Parameters:
-    ///   - tree: The syntax tree to distribute
-    ///   - originalFileName: The original filename to use for the modified file
-    /// - Returns: Distribution result with modified original file and new files
-    /// - Throws: Distribution errors
+
+/// Distributes declarations from a source file, keeping the first declaration in the original file
+/// and moving all others to appropriately named separate files.
+///
+/// - Parameters:
+///   - tree: The syntax tree to distribute
+///   - originalFileName: The original filename to use for the modified file
+/// - Returns: Distribution result with modified original file and new files
+/// - Throws: Distribution errors
     public func distributeKeepingFirst(tree: SyntaxTree, originalFileName: String) throws -> DistributionResult {
-        // Extract imports and declarations
+// Extract imports and declarations
         let overview = CodeOverview(tree: tree, minVisibility: .private) // Include all declarations
         let imports = overview.imports
         let declarations = overview.declarations
-        
-        // Separate type vs non-type declarations
+
+// Separate type vs non-type declarations
         var typeDeclarations: [DeclarationOverview] = []
         var nonTypeDeclarations: [DeclarationOverview] = []
         for decl in declarations {
@@ -30,14 +30,14 @@ public class CodeDistributor {
                 nonTypeDeclarations.append(decl)
             }
         }
-        
-        // Build files for type declarations, merging multiple extensions with the same filename
+
+// Build files for type declarations, merging multiple extensions with the same filename
         var fileBuilders: [String: (content: String, declarations: [DeclarationOverview])] = [:]
         let importHeader: String = {
-            guard !imports.isEmpty else { return "" }
-            return imports.map { "import \($0)" }.joined(separator: "\n") + "\n\n"
-        }()
-        
+        guard !imports.isEmpty else { return "" }
+        return imports.map { "import \($0)" }.joined(separator: "\n") + "\n\n"
+    }()
+
         for declaration in typeDeclarations {
             let fileName = generateFileName(for: declaration, tree: tree)
             let declSource = generateDeclarationSource(declaration, in: tree.sourceFile)
@@ -50,78 +50,78 @@ public class CodeDistributor {
                 fileBuilders[fileName] = (initialContent, [declaration])
             }
         }
-        
+
         let newFiles: [GeneratedFile] = fileBuilders.map { key, value in
-            GeneratedFile(fileName: key, content: value.content, imports: imports, declarations: value.declarations)
-        }
-        
-        // Build modified original file (for non-type code)
+        GeneratedFile(fileName: key, content: value.content, imports: imports, declarations: value.declarations)
+    }
+
+// Build modified original file (for non-type code)
         var modifiedOriginalFile: GeneratedFile? = nil
         if !nonTypeDeclarations.isEmpty {
             let content = try generateFileContent(imports: imports, targetDeclarations: nonTypeDeclarations, sourceFile: tree.sourceFile)
             modifiedOriginalFile = GeneratedFile(fileName: originalFileName, content: content, imports: imports, declarations: nonTypeDeclarations)
         }
-        
+
         return DistributionResult(modifiedOriginalFile: modifiedOriginalFile, newFiles: newFiles)
     }
-    
-    /// Removes specific declarations from a source file
+
+/// Removes specific declarations from a source file
     internal func removeDeclarations(_ declarationsToRemove: [DeclarationOverview], from sourceFile: SourceFileSyntax) throws -> SourceFileSyntax {
-        // Get the indices of declarations to remove (1-based paths converted to 0-based indices)
+// Get the indices of declarations to remove (1-based paths converted to 0-based indices)
         let indicesToRemove = Set(declarationsToRemove.compactMap { declaration -> Int? in
-            let pathComponents = declaration.path.split(separator: ".").compactMap { Int($0) }
-            guard let firstIndex = pathComponents.first, firstIndex > 0 else { return nil }
-            
-            // Convert to 0-based index in declaration statements (not all statements)
-            return firstIndex - 1
-        })
-        
-        // Filter statements to remove target declarations
+        let pathComponents = declaration.path.split(separator: ".").compactMap { Int($0) }
+        guard let firstIndex = pathComponents.first, firstIndex > 0 else { return nil }
+
+// Convert to 0-based index in declaration statements (not all statements)
+        return firstIndex - 1
+    })
+
+// Filter statements to remove target declarations
         var newStatements: [CodeBlockItemSyntax] = []
         var declarationIndex = 0
-        
+
         for statement in sourceFile.statements {
-            // Check if this is a declaration statement (not import or other)
+// Check if this is a declaration statement (not import or other)
             if let declSyntax = statement.item.as(DeclSyntax.self) {
-                // Skip import declarations - they don't count towards declaration indices
+// Skip import declarations - they don't count towards declaration indices
                 if declSyntax.is(ImportDeclSyntax.self) {
                     newStatements.append(statement)
                     continue
                 }
-                
-                // Check if this declaration should be removed
+
+// Check if this declaration should be removed
                 if indicesToRemove.contains(declarationIndex) {
-                    // Skip this declaration (remove it)
+// Skip this declaration (remove it)
                     declarationIndex += 1
                     continue
                 } else {
-                    // Keep this declaration
+// Keep this declaration
                     newStatements.append(statement)
                     declarationIndex += 1
                 }
             } else {
-                // Non-declaration statement, keep it
+// Non-declaration statement, keep it
                 newStatements.append(statement)
             }
         }
-        
-        // Create new source file with modified statements
+
+// Create new source file with modified statements
         return sourceFile.with(\.statements, CodeBlockItemListSyntax(newStatements))
     }
-    
-    /// Generates file content for a single declaration
+
+/// Generates file content for a single declaration
     internal func generateFileContentForDeclaration(_ declaration: DeclarationOverview, imports: [String], sourceFile: SourceFileSyntax) throws -> String {
         var content = ""
-        // Add imports
+// Add imports
         if !imports.isEmpty {
             for importName in imports {
                 content += "import \(importName)\n"
             }
             content += "\n" // Only one newline after all imports
         }
-        // Add the target declaration
+// Add the target declaration
         if let declSyntax = findDeclarationSyntax(for: declaration, in: sourceFile) {
-            // Apply access control rewriting for extracted declarations
+// Apply access control rewriting for extracted declarations
             let rewriter = AccessControlRewriter()
             let rewrittenDecl = rewriter.visit(declSyntax)
             var declString = rewrittenDecl.description
@@ -130,90 +130,90 @@ public class CodeDistributor {
         }
         return content
     }
-    
-    /// Generates appropriate filename for a declaration
+
+/// Generates appropriate filename for a declaration
     internal func generateFileName(for declaration: DeclarationOverview, tree: SyntaxTree) -> String {
         if declaration.type == "extension" {
             return generateExtensionFileName(for: declaration, tree: tree)
         } else {
             return "\(declaration.name).swift"
         }
     }
-    
-    /// Generates filename for extension declarations
+
+/// Generates filename for extension declarations
     internal func generateExtensionFileName(for declaration: DeclarationOverview, tree: SyntaxTree) -> String {
-        // Try to extract the extended type name and protocol conformances
+// Try to extract the extended type name and protocol conformances
         if let extensionInfo = extractExtensionInfo(for: declaration, tree: tree) {
             if !extensionInfo.protocols.isEmpty {
-                // Extension with protocol conformance: Type+Protocol.swift
+// Extension with protocol conformance: Type+Protocol.swift
                 let protocolName = extensionInfo.protocols.joined(separator: "+")
                 return "\(extensionInfo.typeName)+\(protocolName).swift"
             } else {
-                // Extension without protocol: Type+Extensions.swift
+// Extension without protocol: Type+Extensions.swift
                 return "\(extensionInfo.typeName)+Extensions.swift"
             }
         } else {
-            // Fallback
+// Fallback
             return "\(declaration.name)+Extensions.swift"
         }
     }
-    
-    /// Information extracted from an extension declaration
+
+/// Information extracted from an extension declaration
     internal struct ExtensionInfo {
         let typeName: String
         let protocols: [String]
     }
-    
-    /// Extracts type name and protocol conformances from an extension
+
+/// Extracts type name and protocol conformances from an extension
     internal func extractExtensionInfo(for declaration: DeclarationOverview, tree: SyntaxTree) -> ExtensionInfo? {
-        // Find the extension syntax node using the declaration path
+// Find the extension syntax node using the declaration path
         guard let declSyntax = findDeclarationSyntax(for: declaration, in: tree.sourceFile) else {
-            return nil
-        }
-        
-        // Try to cast to ExtensionDeclSyntax
+        return nil
+    }
+
+// Try to cast to ExtensionDeclSyntax
         guard let extensionNode = declSyntax.as(ExtensionDeclSyntax.self) else {
-            return nil
-        }
-        
+        return nil
+    }
+
         let typeName = extensionNode.extendedType.description.trimmingCharacters(in: .whitespacesAndNewlines)
-        
+
         var protocols: [String] = []
         if let inheritanceClause = extensionNode.inheritanceClause {
             for inheritedType in inheritanceClause.inheritedTypes {
                 let protocolName = inheritedType.type.description.trimmingCharacters(in: .whitespacesAndNewlines)
                 protocols.append(protocolName)
             }
         }
-        
+
         return ExtensionInfo(typeName: typeName, protocols: protocols)
     }
-    
-    /// Finds the syntax node for a declaration using its path
+
+/// Finds the syntax node for a declaration using its path
     internal func findDeclarationSyntax(for declaration: DeclarationOverview, in sourceFile: SourceFileSyntax) -> DeclSyntax? {
         let pathComponents = declaration.path.split(separator: ".").compactMap { Int($0) }
-        
+
         guard let firstIndex = pathComponents.first, firstIndex > 0 else { return nil }
-        
-        // Filter to only declaration statements (not imports or other statements)
+
+// Filter to only declaration statements (not imports or other statements)
         let declarationStatements = sourceFile.statements.compactMap { statement -> DeclSyntax? in
-            // Skip import declarations and other non-declaration statements
-            if let declSyntax = statement.item.as(DeclSyntax.self) {
-                // Check if it's an import declaration
-                if declSyntax.is(ImportDeclSyntax.self) {
-                    return nil // Skip imports
-                }
-                return declSyntax
+// Skip import declarations and other non-declaration statements
+        if let declSyntax = statement.item.as(DeclSyntax.self) {
+// Check if it's an import declaration
+            if declSyntax.is(ImportDeclSyntax.self) {
+                return nil // Skip imports
             }
-            return nil
+            return declSyntax
         }
-        
+        return nil
+    }
+
         guard firstIndex <= declarationStatements.count else { return nil }
-        
+
         return declarationStatements[firstIndex - 1]
     }
-    
-    /// Returns true if the given DeclSyntax is a type declaration (class, struct, enum, protocol, actor, extension)
+
+/// Returns true if the given DeclSyntax is a type declaration (class, struct, enum, protocol, actor, extension)
     internal func isTypeDeclaration(_ decl: DeclSyntax) -> Bool {
         return decl.is(ClassDeclSyntax.self) ||
                decl.is(StructDeclSyntax.self) ||
@@ -222,21 +222,21 @@ public class CodeDistributor {
                decl.is(ActorDeclSyntax.self) ||
                decl.is(ExtensionDeclSyntax.self)
     }
-    
-    /// Generates the complete source file content for given imports and specific target declarations
+
+/// Generates the complete source file content for given imports and specific target declarations
     internal func generateFileContent(imports: [String], targetDeclarations: [DeclarationOverview], sourceFile: SourceFileSyntax) throws -> String {
         var content = ""
-        // Add imports
+// Add imports
         if !imports.isEmpty {
             for importName in imports {
                 content += "import \(importName)\n"
             }
             content += "\n" // Only one newline after all imports
         }
-        // Add only the target declarations
+// Add only the target declarations
         for (index, targetDeclaration) in targetDeclarations.enumerated() {
             if let declSyntax = findDeclarationSyntax(for: targetDeclaration, in: sourceFile) {
-                // Remove leading newlines from the declaration
+// Remove leading newlines from the declaration
                 var declString = declSyntax.description
                 declString = declString.trimmingCharacters(in: .newlines)
                 content += declString
@@ -247,18 +247,18 @@ public class CodeDistributor {
         }
         return content
     }
-    
-    /// Generates source text for a declaration (without import headers)
+
+/// Generates source text for a declaration (without import headers)
     internal func generateDeclarationSource(_ declaration: DeclarationOverview, in sourceFile: SourceFileSyntax) -> String {
         guard let declSyntax = findDeclarationSyntax(for: declaration, in: sourceFile) else {
-            return ""
-        }
-        // Always apply AccessControlRewriter to the whole declaration (including top-level types)
+        return ""
+    }
+// Always apply AccessControlRewriter to the whole declaration (including top-level types)
         let rewriter = AccessControlRewriter()
         let rewrittenDecl = rewriter.visit(declSyntax)
-        // Preserve original formatting by not trimming newlines aggressively
+// Preserve original formatting by not trimming newlines aggressively
         let result = rewrittenDecl.description
-        // Only trim leading/trailing whitespace, preserve internal structure
+// Only trim leading/trailing whitespace, preserve internal structure
         return result.trimmingCharacters(in: .whitespacesAndNewlines)
     }
 }