Merge pull request #14228 from tamasvajk/standalone-implicit-usings

C#: Generate source file with implicit usings in Standalone

Author: tamasvajk

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

@@ -30,9 +30,7 @@ public sealed class DependencyManager : IDisposable
         private readonly DotNet dotnet;
         private readonly FileContent fileContent;
         private readonly TemporaryDirectory packageDirectory;
-        private TemporaryDirectory? razorWorkingDirectory;
-        private readonly Git git;
-
+        private readonly TemporaryDirectory tempWorkingDirectory;
 
         /// <summary>
         /// Performs C# dependency fetching.
@@ -60,20 +58,21 @@ public DependencyManager(string srcDir, IDependencyOptions options, ILogger logg
             this.progressMonitor.FindingFiles(srcDir);
 
             packageDirectory = new TemporaryDirectory(ComputeTempDirectory(sourceDir.FullName));
-            var allFiles = GetAllFiles().ToList();
-            var smallFiles = allFiles.SelectSmallFiles(progressMonitor).SelectFileNames();
-            this.fileContent = new FileContent(progressMonitor, smallFiles);
-            this.allSources = allFiles.SelectFileNamesByExtension(".cs").ToList();
-            var allProjects = allFiles.SelectFileNamesByExtension(".csproj");
+            tempWorkingDirectory = new TemporaryDirectory(GetTemporaryWorkingDirectory());
+
+            var allFiles = GetAllFiles();
+            var binaryFileExtensions = new HashSet<string>(new[] { ".dll", ".exe" }); // TODO: add more binary file extensions.
+            var allNonBinaryFiles = allFiles.Where(f => !binaryFileExtensions.Contains(f.Extension.ToLowerInvariant())).ToList();
+            var smallNonBinaryFiles = allNonBinaryFiles.SelectSmallFiles(progressMonitor).SelectFileNames();
+            this.fileContent = new FileContent(progressMonitor, smallNonBinaryFiles);
+            this.allSources = allNonBinaryFiles.SelectFileNamesByExtension(".cs").ToList();
+            var allProjects = allNonBinaryFiles.SelectFileNamesByExtension(".csproj");
             var solutions = options.SolutionFile is not null
                 ? new[] { options.SolutionFile }
-                : allFiles.SelectFileNamesByExtension(".sln");
-
-            // If DLL reference paths are specified on the command-line, use those to discover
-            // assemblies. Otherwise (the default), query the git CLI to determine which DLL files
-            // are tracked as part of the repository.
-            this.git = new Git(this.progressMonitor);
-            var dllDirNames = options.DllDirs.Count == 0 ? this.git.ListFiles("*.dll") : options.DllDirs.Select(Path.GetFullPath).ToList();
+                : allNonBinaryFiles.SelectFileNamesByExtension(".sln");
+            var dllDirNames = options.DllDirs.Count == 0
+                ? allFiles.SelectFileNamesByExtension(".dll").ToList()
+                : options.DllDirs.Select(Path.GetFullPath).ToList();
 
             // Find DLLs in the .Net / Asp.Net Framework
             if (options.ScanNetFrameworkDlls)
@@ -106,7 +105,7 @@ public DependencyManager(string srcDir, IDependencyOptions options, ILogger logg
                 var restoredProjects = RestoreSolutions(solutions);
                 var projects = allProjects.Except(restoredProjects);
                 RestoreProjects(projects);
-                DownloadMissingPackages(allFiles);
+                DownloadMissingPackages(allNonBinaryFiles);
             }
 
             assemblyCache = new AssemblyCache(dllDirNames, progressMonitor);
@@ -134,9 +133,11 @@ public DependencyManager(string srcDir, IDependencyOptions options, ILogger logg
             if (bool.TryParse(webViewExtractionOption, out var shouldExtractWebViews) &&
                 shouldExtractWebViews)
             {
-                GenerateSourceFilesFromWebViews(allFiles);
+                GenerateSourceFilesFromWebViews(allNonBinaryFiles);
             }
 
+            GenerateSourceFileFromImplicitUsings();
+
             progressMonitor.Summary(
                 AllSourceFiles.Count(),
                 ProjectSourceFiles.Count(),
@@ -149,6 +150,46 @@ public DependencyManager(string srcDir, IDependencyOptions options, ILogger logg
                 DateTime.Now - startTime);
         }
 
+        private void GenerateSourceFileFromImplicitUsings()
+        {
+            var usings = new HashSet<string>();
+            if (!fileContent.UseImplicitUsings)
+            {
+                return;
+            }
+
+            // Hardcoded values from https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#implicit-using-directives
+            usings.UnionWith(new[] { "System", "System.Collections.Generic", "System.IO", "System.Linq", "System.Net.Http", "System.Threading",
+                "System.Threading.Tasks" });
+
+            if (fileContent.UseAspNetDlls)
+            {
+                usings.UnionWith(new[] { "System.Net.Http.Json", "Microsoft.AspNetCore.Builder", "Microsoft.AspNetCore.Hosting",
+                    "Microsoft.AspNetCore.Http", "Microsoft.AspNetCore.Routing", "Microsoft.Extensions.Configuration",
+                    "Microsoft.Extensions.DependencyInjection", "Microsoft.Extensions.Hosting", "Microsoft.Extensions.Logging" });
+            }
+
+            usings.UnionWith(fileContent.CustomImplicitUsings);
+
+            if (usings.Count > 0)
+            {
+                var tempDir = GetTemporaryWorkingDirectory("implicitUsings");
+                var path = Path.Combine(tempDir, "GlobalUsings.g.cs");
+                using (var writer = new StreamWriter(path))
+                {
+                    writer.WriteLine("// <auto-generated/>");
+                    writer.WriteLine("");
+
+                    foreach (var u in usings.OrderBy(u => u))
+                    {
+                        writer.WriteLine($"global using global::{u};");
+                    }
+                }
+
+                this.allSources.Add(path);
+            }
+        }
+
         private void GenerateSourceFilesFromWebViews(List<FileInfo> allFiles)
         {
             progressMonitor.LogInfo($"Generating source files from cshtml and razor files.");
@@ -165,8 +206,8 @@ private void GenerateSourceFilesFromWebViews(List<FileInfo> allFiles)
                     try
                     {
                         var razor = new Razor(sdk, dotnet, progressMonitor);
-                        razorWorkingDirectory = new TemporaryDirectory(ComputeTempDirectory(sourceDir.FullName, "razor"));
-                        var generatedFiles = razor.GenerateFiles(views, usedReferences.Keys, razorWorkingDirectory.ToString());
+                        var targetDir = GetTemporaryWorkingDirectory("razor");
+                        var generatedFiles = razor.GenerateFiles(views, usedReferences.Keys, targetDir);
                         this.allSources.AddRange(generatedFiles);
                     }
                     catch (Exception ex)
@@ -180,24 +221,61 @@ private void GenerateSourceFilesFromWebViews(List<FileInfo> allFiles)
 
         public DependencyManager(string srcDir) : this(srcDir, DependencyOptions.Default, new ConsoleLogger(Verbosity.Info)) { }
 
-        private IEnumerable<FileInfo> GetAllFiles() =>
-             sourceDir.GetFiles("*.*", new EnumerationOptions { RecurseSubdirectories = true })
-                .Where(d => d.Extension != ".dll" && !options.ExcludesFile(d.FullName));
+        private IEnumerable<FileInfo> GetAllFiles()
+        {
+            var files = sourceDir.GetFiles("*.*", new EnumerationOptions { RecurseSubdirectories = true })
+                .Where(d => !options.ExcludesFile(d.FullName));
+
+            if (options.DotNetPath != null)
+            {
+                files = files.Where(f => !f.FullName.StartsWith(options.DotNetPath, StringComparison.OrdinalIgnoreCase));
+            }
+
+            return files;
+        }
 
         /// <summary>
         /// Computes a unique temp directory for the packages associated
         /// with this source tree. Use a SHA1 of the directory name.
         /// </summary>
         /// <returns>The full path of the temp directory.</returns>
-        private static string ComputeTempDirectory(string srcDir, string subfolderName = "packages")
+        private static string ComputeTempDirectory(string srcDir)
         {
             var bytes = Encoding.Unicode.GetBytes(srcDir);
             var sha = SHA1.HashData(bytes);
             var sb = new StringBuilder();
             foreach (var b in sha.Take(8))
                 sb.AppendFormat("{0:x2}", b);
 
-            return Path.Combine(Path.GetTempPath(), "GitHub", subfolderName, sb.ToString());
+            return Path.Combine(Path.GetTempPath(), "GitHub", "packages", sb.ToString());
+        }
+
+        private static string GetTemporaryWorkingDirectory()
+        {
+            var tempFolder = EnvironmentVariables.GetScratchDirectory();
+
+            if (string.IsNullOrEmpty(tempFolder))
+            {
+                var tempPath = Path.GetTempPath();
+                var name = Guid.NewGuid().ToString("N").ToUpper();
+                tempFolder = Path.Combine(tempPath, "GitHub", name);
+            }
+
+            return tempFolder;
+        }
+
+        /// <summary>
+        /// Creates a temporary directory with the given subfolder name.
+        /// The created directory might be inside the repo folder, and it is deleted when the object is disposed.
+        /// </summary>
+        /// <param name="subfolder"></param>
+        /// <returns></returns>
+        private string GetTemporaryWorkingDirectory(string subfolder)
+        {
+            var temp = Path.Combine(tempWorkingDirectory.ToString(), subfolder);
+            Directory.CreateDirectory(temp);
+
+            return temp;
         }
 
         /// <summary>
@@ -424,7 +502,7 @@ private void DownloadMissingPackages(List<FileInfo> allFiles)
             foreach (var package in notYetDownloadedPackages)
             {
                 progressMonitor.NugetInstall(package);
-                using var tempDir = new TemporaryDirectory(ComputeTempDirectory(package));
+                using var tempDir = new TemporaryDirectory(GetTemporaryWorkingDirectory(package));
                 var success = dotnet.New(tempDir.DirInfo.FullName);
                 if (!success)
                 {
@@ -467,7 +545,7 @@ private void AnalyseSolutions(IEnumerable<string> solutions)
         public void Dispose()
         {
             packageDirectory?.Dispose();
-            razorWorkingDirectory?.Dispose();
+            tempWorkingDirectory?.Dispose();
         }
     }
 }

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

@@ -19,6 +19,7 @@ internal partial class FileContent
         private readonly IUnsafeFileReader unsafeFileReader;
         private readonly IEnumerable<string> files;
         private readonly HashSet<string> allPackages = new HashSet<string>();
+        private readonly HashSet<string> implicitUsingNamespaces = new HashSet<string>();
         private readonly Initializer initialize;
 
         public HashSet<string> AllPackages
@@ -48,6 +49,26 @@ public bool UseAspNetDlls
             }
         }
 
+        private bool useImplicitUsings = false;
+
+        public bool UseImplicitUsings
+        {
+            get
+            {
+                initialize.Run();
+                return useImplicitUsings;
+            }
+        }
+
+        public HashSet<string> CustomImplicitUsings
+        {
+            get
+            {
+                initialize.Run();
+                return implicitUsingNamespaces;
+            }
+        }
+
         internal FileContent(ProgressMonitor progressMonitor,
             IEnumerable<string> files,
             IUnsafeFileReader unsafeFileReader)
@@ -62,7 +83,7 @@ internal FileContent(ProgressMonitor progressMonitor,
         public FileContent(ProgressMonitor progressMonitor, IEnumerable<string> files) : this(progressMonitor, files, new UnsafeFileReader())
         { }
 
-        private static string GetGroup(ReadOnlySpan<char> input, ValueMatch valueMatch, string groupPrefix)
+        private static string GetGroup(ReadOnlySpan<char> input, ValueMatch valueMatch, string groupPrefix, bool toLower)
         {
             var match = input.Slice(valueMatch.Index, valueMatch.Length);
             var includeIndex = match.IndexOf(groupPrefix, StringComparison.InvariantCultureIgnoreCase);
@@ -76,15 +97,22 @@ private static string GetGroup(ReadOnlySpan<char> input, ValueMatch valueMatch,
             var quoteIndex1 = match.IndexOf("\"");
             var quoteIndex2 = match.Slice(quoteIndex1 + 1).IndexOf("\"");
 
-            return match.Slice(quoteIndex1 + 1, quoteIndex2).ToString().ToLowerInvariant();
+            var result = match.Slice(quoteIndex1 + 1, quoteIndex2).ToString();
+
+            if (toLower)
+            {
+                result = result.ToLowerInvariant();
+            }
+
+            return result;
         }
 
         private static bool IsGroupMatch(ReadOnlySpan<char> line, Regex regex, string groupPrefix, string value)
         {
             foreach (var valueMatch in regex.EnumerateMatches(line))
             {
                 // We can't get the group from the ValueMatch, so doing it manually:
-                if (GetGroup(line, valueMatch, groupPrefix) == value.ToLowerInvariant())
+                if (GetGroup(line, valueMatch, groupPrefix, toLower: true) == value.ToLowerInvariant())
                 {
                     return true;
                 }
@@ -105,7 +133,7 @@ private void DoInitialize()
                         foreach (var valueMatch in PackageReference().EnumerateMatches(line))
                         {
                             // We can't get the group from the ValueMatch, so doing it manually:
-                            var packageName = GetGroup(line, valueMatch, "Include");
+                            var packageName = GetGroup(line, valueMatch, "Include", toLower: true);
                             if (!string.IsNullOrEmpty(packageName))
                             {
                                 allPackages.Add(packageName);
@@ -119,6 +147,23 @@ private void DoInitialize()
                                 IsGroupMatch(line, ProjectSdk(), "Sdk", "Microsoft.NET.Sdk.Web") ||
                                 IsGroupMatch(line, FrameworkReference(), "Include", "Microsoft.AspNetCore.App");
                         }
+
+                        // Determine if implicit usings are used.
+                        if (!useImplicitUsings)
+                        {
+                            useImplicitUsings = line.Contains("<ImplicitUsings>enable</ImplicitUsings>".AsSpan(), StringComparison.Ordinal) ||
+                                                line.Contains("<ImplicitUsings>true</ImplicitUsings>".AsSpan(), StringComparison.Ordinal);
+                        }
+
+                        // Find all custom implicit usings.
+                        foreach (var valueMatch in CustomImplicitUsingDeclarations().EnumerateMatches(line))
+                        {
+                            var ns = GetGroup(line, valueMatch, "Include", toLower: false);
+                            if (!string.IsNullOrEmpty(ns))
+                            {
+                                implicitUsingNamespaces.Add(ns);
+                            }
+                        }
                     }
                 }
                 catch (Exception ex)
@@ -136,6 +181,9 @@ private void DoInitialize()
 
         [GeneratedRegex("<(.*\\s)?Project.*\\sSdk=\"(.*?)\".*/?>", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.Singleline)]
         private static partial Regex ProjectSdk();
+
+        [GeneratedRegex("<Using.*\\sInclude=\"(.*?)\".*/?>", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.Singleline)]
+        private static partial Regex CustomImplicitUsingDeclarations();
     }
 
     internal interface IUnsafeFileReader