Honoring the original order from a CODEOWNERS entry (#37)

Author: gmazzo

Demo/CODEOWNERS

@@ -1,4 +1,4 @@
-Sources/Demo/   @demo-devs
+Sources/Demo/   @demo-devs @baz-devs
 Foo/            @foo-devs
 Bar/            @bar-devs
 **/*Enum.swift  @team/enum-experts

Demo/Sources/Demo/CodeOwnersMacro.swift

@@ -1,2 +1,2 @@
 @freestanding(expression)
-public macro codeOwners() -> Set<String>? = #externalMacro(module: "Macros", type: "CodeOwnersMacro")
+public macro codeOwners() -> [String]? = #externalMacro(module: "Macros", type: "CodeOwnersMacro")

Demo/Tests/DemoTests/GenericTest.swift

@@ -4,12 +4,12 @@ import CodeOwnersAPI
 
 @Test
 func ownersOfGenericStruct() {
-    #expect(["demo-devs"] == codeOwnersOf(GenericStruct<Any>.self))
-    #expect(["demo-devs"] == codeOwnersOf(GenericStruct(value: "aValue")))
+    #expect(["demo-devs", "baz-devs"] == codeOwnersOf(GenericStruct<Any>.self))
+    #expect(["demo-devs", "baz-devs"] == codeOwnersOf(GenericStruct(value: "aValue")))
 }
 
 @Test
 func ownersOfGenericClass() {
-    #expect(["demo-devs"] == codeOwnersOf(GenericClass<Any>.self))
-    #expect(["demo-devs"] == codeOwnersOf(GenericClass(value: "aValue")))
+    #expect(["demo-devs", "baz-devs"] == codeOwnersOf(GenericClass<Any>.self))
+    #expect(["demo-devs", "baz-devs"] == codeOwnersOf(GenericClass(value: "aValue")))
 }

Demo/Tests/DemoTests/SomeClassTest.swift

@@ -4,6 +4,6 @@ import CodeOwnersAPI
 
 @Test
 func ownersOfSomeClass() {
-    #expect(["demo-devs"] == codeOwnersOf(SomeClassImpl.self))
-    #expect(["demo-devs"] == codeOwnersOf(SomeClassImpl()))
+    #expect(["demo-devs", "baz-devs"] == codeOwnersOf(SomeClassImpl.self))
+    #expect(["demo-devs", "baz-devs"] == codeOwnersOf(SomeClassImpl()))
 }

README.md

@@ -111,7 +111,7 @@ Finally, import the macro module and use the `#codeowners` macro in your code:
 
 ```swift
 @freestanding(expression)
-public macro codeOwners() -> Set<String>? = #externalMacro(module: "MyMacros", type: "CodeOwnersMacro")
+public macro codeOwners() -> [String]? = #externalMacro(module: "MyMacros", type: "CodeOwnersMacro")
 ```
 
 # The CODEOWNERS file

Sources/CodeOwnersAPI/CodeOwnersAPI.swift

@@ -4,7 +4,7 @@ private let lock = NSLock()
 nonisolated(unsafe) private var ownersCache: [Substring: [Substring: CodeOwners]] = [:]
 nonisolated(unsafe) private let nsClassNameRegEx = /(\w+)\.(\w+)/
 
-public typealias CodeOwners = Set<String>
+public typealias CodeOwners = [String] // order is important for attribution
 
 public protocol CodeOwnersMappingProvider  {
     static var codeOwners: [Substring: CodeOwners]? { get }

Sources/CodeOwnersResolver/CodeOwnersResolver.swift

@@ -5,10 +5,10 @@ public struct CodeOwnersResolver {
     fileprivate let root: URL
     fileprivate let entries: CodeOwners
 
-    public func codeOwnersOf(_ file: URL) -> Set<String>? {
+    public func codeOwnersOf(_ file: URL) -> [String]? {
         guard let relativePath = file.relativePathTo(root) else { return nil }
         guard let owners = entries.codeOwner(pattern: relativePath)?.owners else { return nil }
-        return Set(owners.map(asLiteral))
+        return owners.map(asLiteral)
     }
 }
 

Sources/CodeOwnersTool/CodeOwnersTool.swift

@@ -57,7 +57,7 @@ struct CodeOwnersTool: AsyncParsableCommand {
             renames: renames
         )
 
-        var mappings: [Substring: Set<String>] = [:]
+        var mappings: [Substring: [String]] = [:]
 
         try fm.walkFiles(at: sources) { sourceFile in
             if sourceFile.pathExtension != "swift" { return }
@@ -67,7 +67,7 @@ struct CodeOwnersTool: AsyncParsableCommand {
 
             do {
                 for typeName in try collectTypes(from: sourceFile) {
-                    mappings[typeName] = (mappings[typeName] ?? []).union(owners)
+                    mappings[typeName] = (mappings[typeName] ?? []) + owners
                 }
 
             } catch {
@@ -92,7 +92,7 @@ struct CodeOwnersTool: AsyncParsableCommand {
         return collector.rootTypes
     }
 
-    private func generateContent(_ mappings: [Substring: Set<String>]) -> String {
+    private func generateContent(_ mappings: [Substring: [String]]) -> String {
         if mappings.isEmpty { return "" }
 
         var content = """
@@ -103,7 +103,7 @@ struct CodeOwnersTool: AsyncParsableCommand {
         
         """
         for typeName in mappings.keys.sorted() {
-            let owners = mappings[typeName]!.sorted().map { "\"\($0)\"" }.joined(separator: ", ")
+            let owners = mappings[typeName]!.distinct().map { "\"\($0)\"" }.joined(separator: ", ")
 
             content += "        \"\(typeName)\": [\(owners)],\n"
         }
@@ -121,3 +121,10 @@ private func asRenameRule(regex: String, replace: String) -> RenameRule {
     if let rule = RenameRule(argument: argument) { return rule }
     fatalError("Rename rule should be in the <regex>=<replacement> format: \(argument)")
 }
+
+private extension Sequence where Iterator.Element: Hashable {
+  func distinct() -> [Iterator.Element] {
+    var seen: Set<Iterator.Element> = []
+    return filter { seen.insert($0).inserted }
+  }
+}

Tests/CodeOwnersMacroTests/CodeOwnerMacroTest.swift

@@ -31,10 +31,10 @@ struct CodeOwnersMacrosTest {
 
         assertMacroExpansion(
           """
-          let CODEOWNERS: Set<String> = #codeOwners
+          let CODEOWNERS: [String] = #codeOwners
           """,
           expandedSource: """
-            let CODEOWNERS: Set<String> = \(ownersLiteral.map { "[\($0)]" } ?? "nil")
+            let CODEOWNERS: [String] = \(ownersLiteral.map { "[\($0)]" } ?? "nil")
             """,
           macroSpecs: [ "codeOwners" : MacroSpec(type: CodeOwnersMacroTestImpl.self) ],
           testFileName: params.file