C# Add missing Windows Forms implicit usings

Author: tamasvajk

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

@@ -116,8 +116,16 @@ public DependencyManager(string srcDir, IDependencyOptions options, ILogger logg
                 bool.TryParse(webViewExtractionOption, out var shouldExtractWebViews) &&
                 shouldExtractWebViews)
             {
+                CompilationInfos.Add(("WebView extraction enabled", "1"));
                 GenerateSourceFilesFromWebViews(allNonBinaryFiles);
             }
+            else
+            {
+                CompilationInfos.Add(("WebView extraction enabled", "0"));
+            }
+
+            CompilationInfos.Add(("UseWPF set", fileContent.UseWpf ? "1" : "0"));
+            CompilationInfos.Add(("UseWindowsForms set", fileContent.UseWindowsForms ? "1" : "0"));
 
             GenerateSourceFileFromImplicitUsings();
 
@@ -434,6 +442,11 @@ private void GenerateSourceFileFromImplicitUsings()
                     "Microsoft.Extensions.DependencyInjection", "Microsoft.Extensions.Hosting", "Microsoft.Extensions.Logging" });
             }
 
+            if (fileContent.UseWindowsForms)
+            {
+                usings.UnionWith(new[] { "System.Drawing", "System.Windows.Forms" });
+            }
+
             usings.UnionWith(fileContent.CustomImplicitUsings);
 
             logger.LogInfo($"Generating source file for implicit usings. Namespaces: {string.Join(", ", usings.OrderBy(u => u))}");

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

@@ -61,6 +61,28 @@ public bool UseImplicitUsings
             }
         }
 
+        private bool useWpf = false;
+
+        public bool UseWpf
+        {
+            get
+            {
+                initialize.Run();
+                return useWpf;
+            }
+        }
+
+        private bool useWindowsForms = false;
+
+        public bool UseWindowsForms
+        {
+            get
+            {
+                initialize.Run();
+                return useWindowsForms;
+            }
+        }
+
         private bool isLegacyProjectStructureUsed = false;
 
         public bool IsLegacyProjectStructureUsed
@@ -173,6 +195,14 @@ private void DoInitialize()
                             || line.Contains("<ImplicitUsings>enable</ImplicitUsings>".AsSpan(), StringComparison.Ordinal)
                             || line.Contains("<ImplicitUsings>true</ImplicitUsings>".AsSpan(), StringComparison.Ordinal);
 
+                        // Determine if WPF is used.
+                        useWpf = useWpf
+                            || line.Contains("<UseWPF>true</UseWPF>".AsSpan(), StringComparison.Ordinal);
+
+                        // Determine if Windows Forms is used.
+                        useWindowsForms = useWindowsForms
+                            || line.Contains("<UseWindowsForms>true</UseWindowsForms>".AsSpan(), StringComparison.Ordinal);
+
                         // Find all custom implicit usings.
                         foreach (var valueMatch in CustomImplicitUsingDeclarations().EnumerateMatches(line))
                         {

csharp/extractor/Semmle.Extraction.Tests/FileContent.cs

@@ -84,7 +84,7 @@ public void TestFileContent2()
             Assert.Contains("StyleCop.Analyzers".ToLowerInvariant(), allPackages);
         }
 
-        private static void ImplicitUsingsTest(string line, bool expected)
+        private static void CsProjSettingsTest(string line, bool expected, Func<FileContent, bool> func)
         {
             // Setup
             var lines = new List<string>()
@@ -94,28 +94,52 @@ private static void ImplicitUsingsTest(string line, bool expected)
             var fileContent = new TestFileContent(lines);
 
             // Execute
-            var useImplicitUsings = fileContent.UseImplicitUsings;
+            var actual = func(fileContent);
 
             // Verify
-            Assert.Equal(expected, useImplicitUsings);
+            Assert.Equal(expected, actual);
         }
 
         [Fact]
         public void TestFileContent_ImplicitUsings0()
         {
-            ImplicitUsingsTest("<ImplicitUsings>false</ImplicitUsings>", false);
+            CsProjSettingsTest("<ImplicitUsings>false</ImplicitUsings>", false, fc => fc.UseImplicitUsings);
         }
 
         [Fact]
         public void TestFileContent_ImplicitUsings1()
         {
-            ImplicitUsingsTest("<ImplicitUsings>true</ImplicitUsings>", true);
+            CsProjSettingsTest("<ImplicitUsings>true</ImplicitUsings>", true, fc => fc.UseImplicitUsings);
         }
 
         [Fact]
         public void TestFileContent_ImplicitUsings2()
         {
-            ImplicitUsingsTest("<ImplicitUsings>enable</ImplicitUsings>", true);
+            CsProjSettingsTest("<ImplicitUsings>enable</ImplicitUsings>", true, fc => fc.UseImplicitUsings);
+        }
+
+        [Fact]
+        public void TestFileContent_UseWpf0()
+        {
+            CsProjSettingsTest("<UseWPF>false</UseWPF>", false, fc => fc.UseWpf);
+        }
+
+        [Fact]
+        public void TestFileContent_UseWpf1()
+        {
+            CsProjSettingsTest("<UseWPF>true</UseWPF>", true, fc => fc.UseWpf);
+        }
+
+        [Fact]
+        public void TestFileContent_UseWindowsForms0()
+        {
+            CsProjSettingsTest("<UseWindowsForms>false</UseWindowsForms>", false, fc => fc.UseWindowsForms);
+        }
+
+        [Fact]
+        public void TestFileContent_UseWindowsForms1()
+        {
+            CsProjSettingsTest("<UseWindowsForms>true</UseWindowsForms>", true, fc => fc.UseWindowsForms);
         }
 
         [Fact]