adjust language inference logic to fix #96

Author: tayloraswift

Sources/SymbolGraphBuilder/Builds/PackageBuild.Sources.Module.swift

@@ -78,16 +78,15 @@ extension PackageBuild.Sources.Module
             return
         }
 
-        let exclude:Set<FilePath> = exclude.reduce(into: []) { $0.insert(path / $1) }
+        let exclude:[FilePath] = exclude.map { path / $0 }
         var include:Set<FilePath> = []
-        var language:SymbolGraph.ModuleLanguage = self.module.language ?? .swift
 
         defer
         {
             self.articles.sort              { $0.string < $1.string }
             self.include = include.sorted   { $0.string < $1.string }
-            self.module.language = language
         }
+
         try path.directory.walk
         {
             let file:(path:FilePath, extension:String)
@@ -103,27 +102,38 @@ extension PackageBuild.Sources.Module
                 return
             }
 
-            switch (file.extension, excluded: exclude.contains(file.path))
+            guard file.extension != "md"
+            else
             {
-            case    ("md",  excluded: _):
                 //  It’s common to list markdown files under exclude paths.
                 self.articles.append(file.path)
+                return
+            }
 
-            case    ("h",   excluded: false):
+            //  TODO: might benefit from a better algorithm.
+            for prefix:FilePath in exclude
+            {
+                if  file.path.starts(with: prefix)
+                {
+                    return
+                }
+            }
+
+            switch file.extension
+            {
+            case "h":
+                //  Header files don’t indicate a C or C++ module on their own.
                 include.update(with: $0)
-                fallthrough
 
-            case    ("c",   excluded: false):
-                language |= .c
+            case "c":
+                self.module.language |= .c
 
-            case    ("hpp", excluded: false),
-                    ("hxx", excluded: false):
+            case "hpp", "hxx":
                 include.update(with: $0)
                 fallthrough
 
-            case    ("cpp", excluded: false),
-                    ("cxx", excluded: false):
-                language |= .cpp
+            case "cpp", "cxx":
+                self.module.language |= .cpp
 
             case _:
                 break

Sources/SymbolGraphs/Modules/SymbolGraph.ModuleLanguage.swift

@@ -22,14 +22,14 @@ extension SymbolGraph.ModuleLanguage
     /// This is most useful when inferring the language of a module from the languages of its
     /// constituent source files. For example, a C++ module may contain `.c` or `.h` files.
     @inlinable public static
-    func | (lhs:Self, rhs:Self) -> Self
+    func | (lhs:Self?, rhs:Self) -> Self
     {
-        max(lhs, rhs)
+        lhs.map { max($0, rhs) } ?? rhs
     }
 
     /// See ``|(_:_:)``.
     @inlinable public static
-    func |= (lhs:inout Self, rhs:Self)
+    func |= (lhs:inout Self?, rhs:Self)
     {
         lhs = lhs | rhs
     }