C#: Add alert suppression comments. Rename e to ex in catch clauses for consistency.

calumgrant · calumgrant · commit a44a86bf6ffb · 2019-01-11T12:32:24.000Z
diff --git a/csharp/autobuilder/Semmle.Autobuild/Project.cs b/csharp/autobuilder/Semmle.Autobuild/Project.cs
@@ -39,7 +39,7 @@ public Project(Autobuilder builder, string path) : base(builder, path)
             {
                 projFile = builder.Actions.LoadXml(FullPath);
             }
-            catch (Exception e) when (e is XmlException || e is FileNotFoundException)
+            catch (Exception ex) when (ex is XmlException || ex is FileNotFoundException)
             {
                 builder.Log(Severity.Info, $"Unable to read project file {path}.");
                 return;
diff --git a/csharp/autobuilder/Semmle.Autobuild/Solution.cs b/csharp/autobuilder/Semmle.Autobuild/Solution.cs
@@ -63,7 +63,7 @@ public Solution(Autobuilder builder, string path, bool allowProject) : base(buil
             {
                 solution = SolutionFile.Parse(FullPath);
             }
-            catch (Exception e) when (e is InvalidProjectFileException || e is FileNotFoundException)
+            catch (Exception ex) when (ex is InvalidProjectFileException || ex is FileNotFoundException)
             {
                 // We allow specifying projects as solutions in lgtm.yml, so model
                 // that scenario as a solution with just that one project
diff --git a/csharp/extractor/Semmle.Extraction.CIL/Entities/Assembly.cs b/csharp/extractor/Semmle.Extraction.CIL/Entities/Assembly.cs
@@ -143,7 +143,7 @@ public static void ExtractCIL(Layout layout, string assemblyPath, ILogger logger
                     }
                 }
             }
-            catch (Exception ex)
+            catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
             {
                 logger.Log(Severity.Error, string.Format("Exception extracting {0}: {1}", assemblyPath, ex));
             }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp.Standalone/BuildAnalysis.cs b/csharp/extractor/Semmle.Extraction.CSharp.Standalone/BuildAnalysis.cs
@@ -283,7 +283,7 @@ void AnalyseProjectFiles(FileInfo[] projectFiles)
                     }
                     ++succeededProjects;
                 }
-                catch (Exception ex)
+                catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
                 {
                     ++failedProjects;
                     progressMonitor.FailedProjectFile(proj.FullName, ex.Message);
diff --git a/csharp/extractor/Semmle.Extraction.CSharp.Standalone/NugetPackages.cs b/csharp/extractor/Semmle.Extraction.CSharp.Standalone/NugetPackages.cs
@@ -183,10 +183,10 @@ void RestoreNugetPackage(string package, IProgressMonitor pm)
                     }
                 }
             }
-            catch (Exception e)
-                when (e is System.ComponentModel.Win32Exception || e is FileNotFoundException)
+            catch (Exception ex)
+                when (ex is System.ComponentModel.Win32Exception || ex is FileNotFoundException)
             {
-                pm.FailedNugetCommand(pi.FileName, pi.Arguments, e.Message);
+                pm.FailedNugetCommand(pi.FileName, pi.Arguments, ex.Message);
             }
         }
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Analyser.cs b/csharp/extractor/Semmle.Extraction.CSharp/Analyser.cs
@@ -97,7 +97,7 @@ void SetReferencePaths()
                         extractor.SetAssemblyFile(assemblyIdentity, refPath);
                     }
                 }
-                catch (Exception ex)
+                catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
                 {
                     extractor.Message(new Message
                     {
@@ -272,7 +272,7 @@ void DoAnalyseAssembly(PortableExecutableReference r)
                     ReportProgress(assemblyPath, trapWriter.TrapFile, stopwatch.Elapsed, skipExtraction ? AnalysisAction.UpToDate : AnalysisAction.Extracted);
                 }
             }
-            catch (Exception ex)
+            catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
             {
                 Logger.Log(Severity.Error, "  Unhandled exception analyzing {0}: {1}", r.FilePath, ex);
             }
@@ -354,7 +354,7 @@ void DoExtractTree(SyntaxTree tree)
 
                 ReportProgress(sourcePath, trapPath, stopwatch.Elapsed, excluded ? AnalysisAction.Excluded : upToDate ? AnalysisAction.UpToDate : AnalysisAction.Extracted);
             }
-            catch (Exception ex)
+            catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
             {
                 extractor.Message(new Message { exception = ex, message = string.Format("Unhandled exception processing {0}: {1}", tree.FilePath, ex), severity = Severity.Error });
             }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Extractor.cs b/csharp/extractor/Semmle.Extraction.CSharp/Extractor.cs
@@ -165,9 +165,9 @@ public static ExitCode Run(string[] args)
 
                     return analyser.TotalErrors == 0 ? ExitCode.Ok : ExitCode.Errors;
                 }
-                catch (Exception e)
+                catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
                 {
-                    logger.Log(Severity.Error, "  Unhandled exception: {0}", e);
+                    logger.Log(Severity.Error, "  Unhandled exception: {0}", ex);
                     return ExitCode.Errors;
                 }
             }
@@ -354,9 +354,9 @@ public static void ExtractStandalone(
 
                     pm.MissingSummary(analyser.MissingTypes.Count(), analyser.MissingNamespaces.Count());
                 }
-                catch (Exception e)
+                catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
                 {
-                    analyser.Logger.Log(Severity.Error, "  Unhandled exception: {0}", e);
+                    analyser.Logger.Log(Severity.Error, "  Unhandled exception: {0}", ex);
                 }
             }
         }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Populators/Ast.cs b/csharp/extractor/Semmle.Extraction.CSharp/Populators/Ast.cs
@@ -54,9 +54,9 @@ public static void Extract(this Context cx, CSharpSyntaxNode node, IExpressionPa
                 {
                     node.Accept(new Ast(cx, parent, child));
                 }
-                catch (System.Exception e)
+                catch (System.Exception ex)  // lgtm[cs/catch-of-all-exceptions]
                 {
-                    cx.ModelError(node, "Exception processing syntax node of type {0}: {1}", node.Kind(), e);
+                    cx.ModelError(node, "Exception processing syntax node of type {0}: {1}", node.Kind(), ex);
                 }
             }
         }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Populators/Symbols.cs b/csharp/extractor/Semmle.Extraction.CSharp/Populators/Symbols.cs
@@ -55,9 +55,9 @@ public static IEntity CreateEntity(this Context cx, ISymbol symbol)
                 {
                     return symbol.Accept(new Symbols(cx));
                 }
-                catch (Exception e)
+                catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
                 {
-                    cx.ModelError(symbol, "Exception processing symbol '{2}' of type '{0}': {1}", symbol.Kind, e, symbol);
+                    cx.ModelError(symbol, "Exception processing symbol '{2}' of type '{0}': {1}", symbol.Kind, ex, symbol);
                     return null;
                 }
             }
diff --git a/csharp/extractor/Semmle.Extraction/Context.cs b/csharp/extractor/Semmle.Extraction/Context.cs
@@ -216,13 +216,13 @@ public void PopulateAll()
                 {
                     populateQueue.Dequeue()();
                 }
-                catch (InternalError e)
+                catch (InternalError ex)
                 {
-                    Extractor.Message(e.ExtractionMessage);
+                    Extractor.Message(ex.ExtractionMessage);
                 }
-                catch (Exception e)
+                catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
                 {
-                    Extractor.Message(new Message { severity = Severity.Error, exception = e, message = "Uncaught exception" });
+                    Extractor.Message(new Message { severity = Severity.Error, exception = ex, message = "Uncaught exception" });
                 }
             }
         }
@@ -504,7 +504,7 @@ static public void Try(this Context context, SyntaxNode node, ISymbol symbol, Ac
             {
                 a();
             }
-            catch (Exception ex)
+            catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
             {
                 var internalError = ex as InternalError;
                 var message = internalError != null
diff --git a/csharp/extractor/Semmle.Extraction/TrapWriter.cs b/csharp/extractor/Semmle.Extraction/TrapWriter.cs
@@ -190,7 +190,7 @@ public void Dispose()
                     FileUtils.TryDelete(tmpFile);
                 }
             }
-            catch (Exception ex)
+            catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
             {
                 Logger.Log(Severity.Error, "Failed to move the trap file from {0} to {1} because {2}", tmpFile, TrapFile, ex);
             }
diff --git a/csharp/extractor/Semmle.Util/CanonicalPathCache.cs b/csharp/extractor/Semmle.Util/CanonicalPathCache.cs
@@ -70,7 +70,7 @@ class GetFinalPathNameByHandleStrategy : PathStrategy
         /// <returns>The canonical path.</returns>
         public override string GetCanonicalPath(string path, IPathCache cache)
         {
-            using (var hFile = Win32.CreateFile(
+            using (var hFile = Win32.CreateFile(  // lgtm[cs/call-to-unmanaged-code]
                 path,
                 0,
                 Win32.FILE_SHARE_READ | Win32.FILE_SHARE_WRITE,
@@ -88,13 +88,13 @@ public override string GetCanonicalPath(string path, IPathCache cache)
                 else
                 {
                     StringBuilder outPath = new StringBuilder(Win32.MAX_PATH);
-                    int length = Win32.GetFinalPathNameByHandle(hFile, outPath, outPath.Capacity, 0);
+                    int length = Win32.GetFinalPathNameByHandle(hFile, outPath, outPath.Capacity, 0);  // lgtm[cs/call-to-unmanaged-code]
                     if (length >= outPath.Capacity)
                     {
                         // Path length exceeded MAX_PATH.
                         // Possible if target has a long path.
                         outPath = new StringBuilder(length + 1);
-                        length = Win32.GetFinalPathNameByHandle(hFile, outPath, outPath.Capacity, 0);
+                        length = Win32.GetFinalPathNameByHandle(hFile, outPath, outPath.Capacity, 0);  // lgtm[cs/call-to-unmanaged-code]
                     }
 
                     const int PREAMBLE = 4; // outPath always starts \\?\
diff --git a/csharp/extractor/Semmle.Util/Logger.cs b/csharp/extractor/Semmle.Util/Logger.cs
@@ -74,9 +74,9 @@ public FileLogger(Verbosity verbosity, string outputFile)
                     FileShare.ReadWrite, 8192));
                 writer.AutoFlush = true;
             }
-            catch (Exception e)
+            catch (Exception ex)  // lgtm[cs/catch-of-all-exceptions]
             {
-                Console.Error.WriteLine("SEMMLE: Couldn't initialise C# extractor output: " + e.Message + "\n" + e.StackTrace);
+                Console.Error.WriteLine("SEMMLE: Couldn't initialise C# extractor output: " + ex.Message + "\n" + ex.StackTrace);
                 Console.Error.Flush();
                 throw;
             }
diff --git a/csharp/extractor/Semmle.Util/Win32.cs b/csharp/extractor/Semmle.Util/Win32.cs
@@ -11,14 +11,14 @@ namespace Semmle.Util
     public class Win32
     {
         [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
-        public static extern int GetFinalPathNameByHandle(
+        public static extern int GetFinalPathNameByHandle(  // lgtm[cs/unmanaged-code]
             SafeHandle handle,
             [In, Out] StringBuilder path,
             int bufLen,
             int flags);
 
         [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
-        public static extern SafeFileHandle CreateFile(
+        public static extern SafeFileHandle CreateFile(  // lgtm[cs/unmanaged-code]
             string filename,
             uint desiredAccess,
             uint shareMode,

Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ public Project(Autobuilder builder, string path) : base(builder, path)`
`39`	`39`	`{`
`40`	`40`	`projFile = builder.Actions.LoadXml(FullPath);`
`41`	`41`	`}`
`42`		`- catch (Exception e) when (e is XmlException \|\| e is FileNotFoundException)`
	`42`	`+ catch (Exception ex) when (ex is XmlException \|\| ex is FileNotFoundException)`
`43`	`43`	`{`
`44`	`44`	`builder.Log(Severity.Info, $"Unable to read project file {path}.");`
`45`	`45`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ public Solution(Autobuilder builder, string path, bool allowProject) : base(buil`
`63`	`63`	`{`
`64`	`64`	`solution = SolutionFile.Parse(FullPath);`
`65`	`65`	`}`
`66`		`- catch (Exception e) when (e is InvalidProjectFileException \|\| e is FileNotFoundException)`
	`66`	`+ catch (Exception ex) when (ex is InvalidProjectFileException \|\| ex is FileNotFoundException)`
`67`	`67`	`{`
`68`	`68`	`// We allow specifying projects as solutions in lgtm.yml, so model`
`69`	`69`	`// that scenario as a solution with just that one project`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ public static void ExtractCIL(Layout layout, string assemblyPath, ILogger logger`
`143`	`143`	`}`
`144`	`144`	`}`
`145`	`145`	`}`
`146`		`- catch (Exception ex)`
	`146`	`+ catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`147`	`147`	`{`
`148`	`148`	`logger.Log(Severity.Error, string.Format("Exception extracting {0}: {1}", assemblyPath, ex));`
`149`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -283,7 +283,7 @@ void AnalyseProjectFiles(FileInfo[] projectFiles)`
`283`	`283`	`}`
`284`	`284`	`++succeededProjects;`
`285`	`285`	`}`
`286`		`- catch (Exception ex)`
	`286`	`+ catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`287`	`287`	`{`
`288`	`288`	`++failedProjects;`
`289`	`289`	`progressMonitor.FailedProjectFile(proj.FullName, ex.Message);`
Original file line number	Diff line number	Diff line change
`@@ -183,10 +183,10 @@ void RestoreNugetPackage(string package, IProgressMonitor pm)`
`183`	`183`	`}`
`184`	`184`	`}`
`185`	`185`	`}`
`186`		`- catch (Exception e)`
`187`		`- when (e is System.ComponentModel.Win32Exception \|\| e is FileNotFoundException)`
	`186`	`+ catch (Exception ex)`
	`187`	`+ when (ex is System.ComponentModel.Win32Exception \|\| ex is FileNotFoundException)`
`188`	`188`	`{`
`189`		`- pm.FailedNugetCommand(pi.FileName, pi.Arguments, e.Message);`
	`189`	`+ pm.FailedNugetCommand(pi.FileName, pi.Arguments, ex.Message);`
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ void SetReferencePaths()`
`97`	`97`	`extractor.SetAssemblyFile(assemblyIdentity, refPath);`
`98`	`98`	`}`
`99`	`99`	`}`
`100`		`- catch (Exception ex)`
	`100`	`+ catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`101`	`101`	`{`
`102`	`102`	`extractor.Message(new Message`
`103`	`103`	`{`
`@@ -272,7 +272,7 @@ void DoAnalyseAssembly(PortableExecutableReference r)`
`272`	`272`	`ReportProgress(assemblyPath, trapWriter.TrapFile, stopwatch.Elapsed, skipExtraction ? AnalysisAction.UpToDate : AnalysisAction.Extracted);`
`273`	`273`	`}`
`274`	`274`	`}`
`275`		`- catch (Exception ex)`
	`275`	`+ catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`276`	`276`	`{`
`277`	`277`	`Logger.Log(Severity.Error, " Unhandled exception analyzing {0}: {1}", r.FilePath, ex);`
`278`	`278`	`}`
`@@ -354,7 +354,7 @@ void DoExtractTree(SyntaxTree tree)`
`354`	`354`
`355`	`355`	`ReportProgress(sourcePath, trapPath, stopwatch.Elapsed, excluded ? AnalysisAction.Excluded : upToDate ? AnalysisAction.UpToDate : AnalysisAction.Extracted);`
`356`	`356`	`}`
`357`		`- catch (Exception ex)`
	`357`	`+ catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`358`	`358`	`{`
`359`	`359`	`extractor.Message(new Message { exception = ex, message = string.Format("Unhandled exception processing {0}: {1}", tree.FilePath, ex), severity = Severity.Error });`
`360`	`360`	`}`
Original file line number	Diff line number	Diff line change
`@@ -165,9 +165,9 @@ public static ExitCode Run(string[] args)`
`165`	`165`
`166`	`166`	`return analyser.TotalErrors == 0 ? ExitCode.Ok : ExitCode.Errors;`
`167`	`167`	`}`
`168`		`- catch (Exception e)`
	`168`	`+ catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`169`	`169`	`{`
`170`		`- logger.Log(Severity.Error, " Unhandled exception: {0}", e);`
	`170`	`+ logger.Log(Severity.Error, " Unhandled exception: {0}", ex);`
`171`	`171`	`return ExitCode.Errors;`
`172`	`172`	`}`
`173`	`173`	`}`
`@@ -354,9 +354,9 @@ public static void ExtractStandalone(`
`354`	`354`
`355`	`355`	`pm.MissingSummary(analyser.MissingTypes.Count(), analyser.MissingNamespaces.Count());`
`356`	`356`	`}`
`357`		`- catch (Exception e)`
	`357`	`+ catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`358`	`358`	`{`
`359`		`- analyser.Logger.Log(Severity.Error, " Unhandled exception: {0}", e);`
	`359`	`+ analyser.Logger.Log(Severity.Error, " Unhandled exception: {0}", ex);`
`360`	`360`	`}`
`361`	`361`	`}`
`362`	`362`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,9 +54,9 @@ public static void Extract(this Context cx, CSharpSyntaxNode node, IExpressionPa`
`54`	`54`	`{`
`55`	`55`	`node.Accept(new Ast(cx, parent, child));`
`56`	`56`	`}`
`57`		`- catch (System.Exception e)`
	`57`	`+ catch (System.Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`58`	`58`	`{`
`59`		`- cx.ModelError(node, "Exception processing syntax node of type {0}: {1}", node.Kind(), e);`
	`59`	`+ cx.ModelError(node, "Exception processing syntax node of type {0}: {1}", node.Kind(), ex);`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,9 +55,9 @@ public static IEntity CreateEntity(this Context cx, ISymbol symbol)`
`55`	`55`	`{`
`56`	`56`	`return symbol.Accept(new Symbols(cx));`
`57`	`57`	`}`
`58`		`- catch (Exception e)`
	`58`	`+ catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`59`	`59`	`{`
`60`		`- cx.ModelError(symbol, "Exception processing symbol '{2}' of type '{0}': {1}", symbol.Kind, e, symbol);`
	`60`	`+ cx.ModelError(symbol, "Exception processing symbol '{2}' of type '{0}': {1}", symbol.Kind, ex, symbol);`
`61`	`61`	`return null;`
`62`	`62`	`}`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -216,13 +216,13 @@ public void PopulateAll()`
`216`	`216`	`{`
`217`	`217`	`populateQueue.Dequeue()();`
`218`	`218`	`}`
`219`		`- catch (InternalError e)`
	`219`	`+ catch (InternalError ex)`
`220`	`220`	`{`
`221`		`- Extractor.Message(e.ExtractionMessage);`
	`221`	`+ Extractor.Message(ex.ExtractionMessage);`
`222`	`222`	`}`
`223`		`- catch (Exception e)`
	`223`	`+ catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`224`	`224`	`{`
`225`		`- Extractor.Message(new Message { severity = Severity.Error, exception = e, message = "Uncaught exception" });`
	`225`	`+ Extractor.Message(new Message { severity = Severity.Error, exception = ex, message = "Uncaught exception" });`
`226`	`226`	`}`
`227`	`227`	`}`
`228`	`228`	`}`
`@@ -504,7 +504,7 @@ static public void Try(this Context context, SyntaxNode node, ISymbol symbol, Ac`
`504`	`504`	`{`
`505`	`505`	`a();`
`506`	`506`	`}`
`507`		`- catch (Exception ex)`
	`507`	`+ catch (Exception ex) // lgtm[cs/catch-of-all-exceptions]`
`508`	`508`	`{`
`509`	`509`	`var internalError = ex as InternalError;`
`510`	`510`	`var message = internalError != null`