Add new visitor to get deterministic SARIF log by sorting results

src/Sarif.Multitool.Library/RewriteCommand.cs

@@ -59,6 +59,11 @@ public int Run(RewriteOptions options)
                 SarifLog reformattedLog = new RemoveOptionalDataVisitor(dataToRemove).VisitSarifLog(actualLog);
                 reformattedLog = new InsertOptionalDataVisitor(dataToInsert, originalUriBaseIds, insertProperties: options.InsertProperties).VisitSarifLog(reformattedLog);
 
+                if (options.SortResults)
+                {
+                    reformattedLog = new SortingVisitor().VisitSarifLog(reformattedLog);
+                }
+
                 if (options.SarifOutputVersion == SarifVersion.OneZeroZero)
                 {
                     var visitor = new SarifCurrentToVersionOneVisitor();

src/Sarif.Multitool.Library/RewriteOptions.cs

@@ -10,5 +10,11 @@ namespace Microsoft.CodeAnalysis.Sarif.Multitool
     [Verb("rewrite", HelpText = "Enrich a SARIF file with additional data.")]
     public class RewriteOptions : SingleFileOptionsBase
     {
+        [Option(
+            's',
+            "sort-results",
+            Default = false,
+            HelpText = "Sort results in the final output file.")]
+        public bool SortResults { get; set; }
     }
 }

src/Sarif/Comparers/ArtifactContentSortingComparer.cs

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+
+/// <summary>
+/// All Comparer implementations should be replaced by auto-generated codes by JSchema as 
+/// part of EqualityComparer in a planned comprehensive solution.
+/// Tracking by issue: https://github.com/microsoft/jschema/issues/141
+/// </summary>
+namespace Microsoft.CodeAnalysis.Sarif
+{
+    internal class ArtifactContentSortingComparer : IComparer<ArtifactContent>
+    {
+        internal static readonly ArtifactContentSortingComparer Instance = new ArtifactContentSortingComparer();
+
+        public int Compare(ArtifactContent left, ArtifactContent right)
+        {
+            if (ReferenceEquals(left, right))
+            {
+                return 0;
+            }
+
+            if (left == null)
+            {
+                return -1;
+            }
+
+            if (right == null)
+            {
+                return 1;
+            }
+
+            int compareResult = 0;
+            compareResult = string.Compare(left.Text, right.Text);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = string.Compare(left.Binary, right.Binary);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = MultiformatMessageStringSortingComparer.Instance.Compare(left.Rendered, right.Rendered);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            return compareResult;
+        }
+    }
+}

src/Sarif/Comparers/ArtifactLocationSortingComparer.cs

@@ -0,0 +1,77 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+
+/// <summary>
+/// All Comparer implementations should be replaced by auto-generated codes by JSchema as 
+/// part of EqualityComparer in a planned comprehensive solution.
+/// Tracking by issue: https://github.com/microsoft/jschema/issues/141
+/// </summary>
+namespace Microsoft.CodeAnalysis.Sarif
+{
+    internal class ArtifactLocationSortingComparer : IComparer<ArtifactLocation>
+    {
+        internal static readonly ArtifactLocationSortingComparer Instance = new ArtifactLocationSortingComparer();
+
+        public int Compare(ArtifactLocation left, ArtifactLocation right)
+        {
+            if (ReferenceEquals(left, right))
+            {
+                return 0;
+            }
+
+            if (left == null)
+            {
+                return -1;
+            }
+
+            if (right == null)
+            {
+                return 1;
+            }
+
+            int compareResult = 0;
+            if (ReferenceEquals(left.Uri, right.Uri))
+            {
+                return 0;
+            }
+
+            if (left.Uri == null)
+            {
+                return -1;
+            }
+
+            if (right.Uri == null)
+            {
+                return 1;
+            }
+
+            compareResult = string.Compare(left.Uri.OriginalString, right.Uri.OriginalString);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = string.Compare(left.UriBaseId, right.UriBaseId);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = left.Index.CompareTo(right.Index);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = MessageSortingComparer.Instance.Compare(left.Description, right.Description);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            return compareResult;
+        }
+    }
+}

src/Sarif/Comparers/ArtifactSortingComparer.cs

@@ -0,0 +1,139 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Linq;
+
+/// <summary>
+/// All Comparer implementations should be replaced by auto-generated codes by JSchema as 
+/// part of EqualityComparer in a planned comprehensive solution.
+/// Tracking by issue: https://github.com/microsoft/jschema/issues/141
+/// </summary>
+namespace Microsoft.CodeAnalysis.Sarif
+{
+    internal class ArtifactSortingComparer : IComparer<Artifact>
+    {
+        internal static readonly ArtifactSortingComparer Instance = new ArtifactSortingComparer();
+
+        public int Compare(Artifact left, Artifact right)
+        {
+            if (ReferenceEquals(left, right))
+            {
+                return 0;
+            }
+
+            if (left == null)
+            {
+                return -1;
+            }
+
+            if (right == null)
+            {
+                return 1;
+            }
+
+            int compareResult = 0;
+            compareResult = MessageSortingComparer.Instance.Compare(left.Description, right.Description);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = ArtifactLocationSortingComparer.Instance.Compare(left.Location, right.Location);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = left.ParentIndex.CompareTo(right.ParentIndex);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = left.Offset.CompareTo(right.Offset);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = left.Length.CompareTo(right.Length);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = left.Roles.CompareTo(right.Roles);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = string.Compare(left.MimeType, right.MimeType);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = ArtifactContentSortingComparer.Instance.Compare(left.Contents, right.Contents);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = string.Compare(left.Encoding, right.Encoding);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            compareResult = string.Compare(left.SourceLanguage, right.SourceLanguage);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            if (!object.ReferenceEquals(left.Hashes, right.Hashes))
+            {
+                if (left.Hashes == null)
+                {
+                    return -1;
+                }
+
+                if (right.Hashes == null)
+                {
+                    return 1;
+                }
+
+                compareResult = left.Hashes.Count.CompareTo(right.Hashes.Count);
+                if (compareResult != 0)
+                {
+                    return compareResult;
+                }
+
+                for (int i = 0; i < left.Hashes.Count; i++)
+                {
+                    compareResult = string.Compare(left.Hashes.ElementAt(i).Key, right.Hashes.ElementAt(i).Key);
+                    if (compareResult != 0)
+                    {
+                        return compareResult;
+                    }
+
+                    compareResult = string.Compare(left.Hashes.ElementAt(i).Value, right.Hashes.ElementAt(i).Value);
+                    if (compareResult != 0)
+                    {
+                        return compareResult;
+                    }
+                }
+            }
+
+            compareResult = left.LastModifiedTimeUtc.CompareTo(right.LastModifiedTimeUtc);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            return compareResult;
+        }
+    }
+}

src/Sarif/Comparers/CodeFlowSortingComparer.cs

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+
+/// <summary>
+/// All Comparer implementations should be replaced by auto-generated codes by JSchema as 
+/// part of EqualityComparer in a planned comprehensive solution.
+/// Tracking by issue: https://github.com/microsoft/jschema/issues/141
+/// </summary>
+namespace Microsoft.CodeAnalysis.Sarif
+{
+    internal class CodeFlowSortingComparer : IComparer<CodeFlow>
+    {
+        internal static readonly CodeFlowSortingComparer Instance = new CodeFlowSortingComparer();
+
+        public int Compare(CodeFlow left, CodeFlow right)
+        {
+            if (ReferenceEquals(left, right))
+            {
+                return 0;
+            }
+
+            if (left == null)
+            {
+                return -1;
+            }
+
+            if (right == null)
+            {
+                return 1;
+            }
+
+            int compareResult = 0;
+
+            compareResult = MessageSortingComparer.Instance.Compare(left.Message, right.Message);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+
+            if (!object.ReferenceEquals(left.ThreadFlows, right.ThreadFlows))
+            {
+
+                if (left.ThreadFlows == null)
+                {
+                    return -1;
+                }
+
+                if (right.ThreadFlows == null)
+                {
+                    return 1;
+                }
+
+                compareResult = left.ThreadFlows.Count.CompareTo(right.ThreadFlows.Count);
+                if (compareResult != 0)
+                {
+                    return compareResult;
+                }
+
+                for (int index_1 = 0; index_1 < left.ThreadFlows.Count; ++index_1)
+                {
+                    compareResult = ThreadFlowSortingComparer.Instance.Compare(left.ThreadFlows[index_1], right.ThreadFlows[index_1]);
+                    if (compareResult != 0)
+                    {
+                        return compareResult;
+                    }
+                }
+            }
+
+            return compareResult;
+        }
+    }
+}