C#: Introduce AssemblyPath and re-factor AssemblyCache to use this instead of strings.

Author: michaelnebel

csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/AssemblyCache.cs

@@ -1,61 +1,107 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using Semmle.Util.Logging;
 
 namespace Semmle.Extraction.CSharp.DependencyFetching
 {
     /// <summary>
-    /// Manages the set of assemblies.
-    /// Searches for assembly DLLs, indexes them and provides
-    /// a lookup facility from assembly ID to filename.
+    /// Used to represent a path to an assembly or a directory containing assemblies
+    /// and a selector function to determine which files to include, when indexing the assemblies.
     /// </summary>
-    internal class AssemblyCache
+    internal sealed class AssemblyPath(string p, Func<string, bool> includeFileName)
     {
+        public string Path => p;
+
+        public AssemblyPath(string p) : this(p, _ => true) { }
+
+        public static implicit operator AssemblyPath(string path) => new(path);
+
         /// <summary>
-        /// Locate all reference files and index them.
+        /// Finds all assemblies nested within the directory `path`
+        /// and adds them to the a list of assembly names to index.
+        /// Indexing is performed at a later stage. This only collects the names.
         /// </summary>
-        /// <param name="paths">
-        /// Paths to search. Directories are searched recursively. Files are added directly to the
-        /// assembly cache.
-        /// </param>
-        /// <param name="logger">Callback for progress.</param>
-        public AssemblyCache(IEnumerable<string> paths, IEnumerable<string> frameworkPaths, ILogger logger)
+        /// <param name="dir">The directory to index.</param>
+        private void AddReferenceDirectory(List<string> dllsToIndex, ILogger logger)
         {
-            this.logger = logger;
-            foreach (var path in paths)
+            foreach (var dll in new DirectoryInfo(p).EnumerateFiles("*.dll", SearchOption.AllDirectories))
             {
-                if (File.Exists(path))
+                if (includeFileName(dll.Name))
                 {
-                    dllsToIndex.Add(path);
-                    continue;
+                    dllsToIndex.Add(dll.FullName);
                 }
+                else
+                {
+                    logger.LogInfo($"AssemblyPath: Skipping {dll.FullName}.");
+                }
+            }
+        }
 
-                if (Directory.Exists(path))
+        /// <summary>
+        /// Finds all assemblies in `p` that should be indexed and adds them to
+        /// the list of assembly names to index.
+        /// </summary>
+        /// <param name="dllsToIndex">List of assembly names to index.</param>
+        /// <param name="logger">Logger</param>
+        public void Process(List<string> dllsToIndex, ILogger logger)
+        {
+            if (File.Exists(p))
+            {
+                if (includeFileName(System.IO.Path.GetFileName(p)))
                 {
-                    logger.LogInfo($"Finding reference DLLs in {path}...");
-                    AddReferenceDirectory(path);
+                    dllsToIndex.Add(p);
                 }
                 else
                 {
-                    logger.LogInfo("AssemblyCache: Path not found: " + path);
+                    logger.LogInfo($"AssemblyPath: Skipping {p}.");
                 }
+                return;
+            }
+
+            if (Directory.Exists(p))
+            {
+                logger.LogInfo($"AssemblyPath: Finding reference DLLs in {p}...");
+                AddReferenceDirectory(dllsToIndex, logger);
+            }
+            else
+            {
+                logger.LogInfo("AssemblyCache: Path not found: " + p);
             }
-            IndexReferences(frameworkPaths);
         }
 
+        public override bool Equals(object? obj) =>
+            obj is AssemblyPath ap && p.Equals(ap.Path);
+
+        public override int GetHashCode() => p.GetHashCode();
+
+        public override string ToString() => p;
+    }
+
+    /// <summary>
+    /// Manages the set of assemblies.
+    /// Searches for assembly DLLs, indexes them and provides
+    /// a lookup facility from assembly ID to filename.
+    /// </summary>
+    internal class AssemblyCache
+    {
         /// <summary>
-        /// Finds all assemblies nested within a directory
-        /// and adds them to its index.
-        /// (Indexing is performed at a later stage by IndexReferences()).
+        /// Locate all reference files and index them.
         /// </summary>
-        /// <param name="dir">The directory to index.</param>
-        private void AddReferenceDirectory(string dir)
+        /// <param name="paths">
+        /// Paths to search. Directories are searched recursively. Files are added directly to the
+        /// assembly cache.
+        /// </param>
+        /// <param name="logger">Callback for progress.</param>
+        public AssemblyCache(IEnumerable<AssemblyPath> paths, IEnumerable<string> frameworkPaths, ILogger logger)
         {
-            foreach (var dll in new DirectoryInfo(dir).EnumerateFiles("*.dll", SearchOption.AllDirectories))
+            this.logger = logger;
+            foreach (var path in paths)
             {
-                dllsToIndex.Add(dll.FullName);
+                path.Process(dllsToIndex, logger);
             }
+            IndexReferences(frameworkPaths);
         }
 
         /// <summary>

csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/DependencyManager.Nuget.cs

@@ -12,7 +12,7 @@ namespace Semmle.Extraction.CSharp.DependencyFetching
 {
     public sealed partial class DependencyManager
     {
-        private void RestoreNugetPackages(List<FileInfo> allNonBinaryFiles, IEnumerable<string> allProjects, IEnumerable<string> allSolutions, HashSet<string> dllPaths)
+        private void RestoreNugetPackages(List<FileInfo> allNonBinaryFiles, IEnumerable<string> allProjects, IEnumerable<string> allSolutions, HashSet<AssemblyPath> dllPaths)
         {
             try
             {
@@ -55,7 +55,7 @@ private void RestoreNugetPackages(List<FileInfo> allNonBinaryFiles, IEnumerable<
                 }
 
                 nugetPackageDllPaths.ExceptWith(excludedPaths);
-                dllPaths.UnionWith(nugetPackageDllPaths);
+                dllPaths.UnionWith(nugetPackageDllPaths.Select(p => new AssemblyPath(p)));
             }
             catch (Exception exc)
             {
@@ -72,7 +72,7 @@ private void RestoreNugetPackages(List<FileInfo> allNonBinaryFiles, IEnumerable<
                 .Paths
                 .Select(d => Path.Combine(packageDirectory.DirInfo.FullName, d))
                 .ToList();
-            dllPaths.UnionWith(paths);
+            dllPaths.UnionWith(paths.Select(p => new AssemblyPath(p)));
 
             LogAllUnusedPackages(dependencies);
             DownloadMissingPackages(allNonBinaryFiles, dllPaths);
@@ -148,7 +148,7 @@ private void RestoreProjects(IEnumerable<string> projects, out IEnumerable<strin
             CompilationInfos.Add(("Failed project restore with package source error", nugetSourceFailures.ToString()));
         }
 
-        private void DownloadMissingPackages(List<FileInfo> allFiles, ISet<string> dllPaths, bool withNugetConfig = true)
+        private void DownloadMissingPackages(List<FileInfo> allFiles, ISet<AssemblyPath> dllPaths, bool withNugetConfig = true)
         {
             var alreadyDownloadedPackages = GetRestoredPackageDirectoryNames(packageDirectory.DirInfo);
             var alreadyDownloadedLegacyPackages = GetRestoredLegacyPackageNames();

csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/DependencyManager.cs

@@ -46,7 +46,7 @@ public sealed partial class DependencyManager : IDisposable
         /// <summary>
         /// Performs C# dependency fetching.
         /// </summary>
-        /// <param name="options">Dependency fetching options</param>
+        /// <param name="srcDir">Path to directory containing source code.</param>
         /// <param name="logger">Logger for dependency fetching progress.</param>
         public DependencyManager(string srcDir, ILogger logger)
         {
@@ -91,7 +91,7 @@ public DependencyManager(string srcDir, ILogger logger)
             this.generatedSources = new();
             var allProjects = allNonBinaryFiles.SelectFileNamesByExtension(".csproj").ToList();
             var allSolutions = allNonBinaryFiles.SelectFileNamesByExtension(".sln").ToList();
-            var dllPaths = allFiles.SelectFileNamesByExtension(".dll").ToHashSet();
+            var dllPaths = allFiles.SelectFileNamesByExtension(".dll").Select<string, AssemblyPath>(x => x).ToHashSet();
 
             logger.LogInfo($"Found {allFiles.Count} files, {nonGeneratedSources.Count} source files, {allProjects.Count} project files, {allSolutions.Count} solution files, {dllPaths.Count} DLLs.");
 
@@ -192,7 +192,7 @@ void exitCallback(int ret, string msg, bool silent)
             ]);
         }
 
-        private HashSet<string> AddFrameworkDlls(HashSet<string> dllPaths)
+        private HashSet<string> AddFrameworkDlls(HashSet<AssemblyPath> dllPaths)
         {
             var frameworkLocations = new HashSet<string>();
 
@@ -230,7 +230,7 @@ private HashSet<string> AddFrameworkDlls(HashSet<string> dllPaths)
                             continue;
                         }
 
-                        dllPaths.UnionWith(dlls);
+                        dllPaths.UnionWith(dlls.Select<string, AssemblyPath>(x => x));
                         frameworkLocations.UnionWith(dlls);
                     }
                     catch (Exception e)
@@ -284,7 +284,7 @@ private void RemoveNugetAnalyzerReferences()
             }
         }
 
-        private void SelectNewestFrameworkPath(string frameworkPath, string frameworkType, ISet<string> dllPaths, ISet<string> frameworkLocations)
+        private void SelectNewestFrameworkPath(string frameworkPath, string frameworkType, ISet<AssemblyPath> dllPaths, ISet<string> frameworkLocations)
         {
             var versionFolders = GetPackageVersionSubDirectories(frameworkPath);
             if (versionFolders.Length > 1)
@@ -313,7 +313,7 @@ private static DirectoryInfo[] GetPackageVersionSubDirectories(string packagePat
                 .ToArray();
         }
 
-        private void RemoveFrameworkNugetPackages(ISet<string> dllPaths, int fromIndex = 0)
+        private void RemoveFrameworkNugetPackages(ISet<AssemblyPath> dllPaths, int fromIndex = 0)
         {
             var packagesInPrioOrder = FrameworkPackageNames.NetFrameworks;
             for (var i = fromIndex; i < packagesInPrioOrder.Length; i++)
@@ -322,7 +322,7 @@ private void RemoveFrameworkNugetPackages(ISet<string> dllPaths, int fromIndex =
             }
         }
 
-        private void AddNetFrameworkDlls(ISet<string> dllPaths, ISet<string> frameworkLocations)
+        private void AddNetFrameworkDlls(ISet<AssemblyPath> dllPaths, ISet<string> frameworkLocations)
         {
             // Multiple dotnet framework packages could be present.
             // The order of the packages is important, we're adding the first one that is present in the nuget cache.
@@ -375,7 +375,7 @@ private void AddNetFrameworkDlls(ISet<string> dllPaths, ISet<string> frameworkLo
             frameworkLocations.Add(runtimeLocation);
         }
 
-        private void RemoveNugetPackageReference(string packagePrefix, ISet<string> dllPaths)
+        private void RemoveNugetPackageReference(string packagePrefix, ISet<AssemblyPath> dllPaths)
         {
             var packageFolder = packageDirectory.DirInfo.FullName.ToLowerInvariant();
             if (packageFolder == null)
@@ -384,7 +384,7 @@ private void RemoveNugetPackageReference(string packagePrefix, ISet<string> dllP
             }
 
             var packagePathPrefix = Path.Combine(packageFolder, packagePrefix.ToLowerInvariant());
-            var toRemove = dllPaths.Where(s => s.StartsWith(packagePathPrefix, StringComparison.InvariantCultureIgnoreCase));
+            var toRemove = dllPaths.Where(s => s.Path.StartsWith(packagePathPrefix, StringComparison.InvariantCultureIgnoreCase));
             foreach (var path in toRemove)
             {
                 dllPaths.Remove(path);
@@ -397,7 +397,7 @@ private bool IsAspNetCoreDetected()
             return fileContent.IsNewProjectStructureUsed && fileContent.UseAspNetCoreDlls;
         }
 
-        private void AddAspNetCoreFrameworkDlls(ISet<string> dllPaths, ISet<string> frameworkLocations)
+        private void AddAspNetCoreFrameworkDlls(ISet<AssemblyPath> dllPaths, ISet<string> frameworkLocations)
         {
             if (!IsAspNetCoreDetected())
             {
@@ -419,7 +419,7 @@ private void AddAspNetCoreFrameworkDlls(ISet<string> dllPaths, ISet<string> fram
             }
         }
 
-        private void AddMicrosoftWindowsDesktopDlls(ISet<string> dllPaths, ISet<string> frameworkLocations)
+        private void AddMicrosoftWindowsDesktopDlls(ISet<AssemblyPath> dllPaths, ISet<string> frameworkLocations)
         {
             if (GetPackageDirectory(FrameworkPackageNames.WindowsDesktopFramework, packageDirectory) is string windowsDesktopApp)
             {