Revert "Reintroduce FNV hashing (#9721)" (#9768)

This reverts commit 23f7752.

src/Build.UnitTests/Evaluation/Expander_Tests.cs

@@ -3890,14 +3890,8 @@ public void PropertyStringConstructorConsumingItemMetadata(string metadatumName,
             result.ShouldBe(metadatumValue);
         }
 
-        public static IEnumerable<object[]> GetHashAlgoTypes()
-            => Enum.GetNames(typeof(IntrinsicFunctions.StringHashingAlgorithm))
-                .Append(null)
-                .Select(t => new object[] { t });
-
-        [Theory]
-        [MemberData(nameof(GetHashAlgoTypes))]
-        public void PropertyFunctionHashCodeSameOnlyIfStringSame(string hashType)
+        [Fact]
+        public void PropertyFunctionHashCodeSameOnlyIfStringSame()
         {
             PropertyDictionary<ProjectPropertyInstance> pg = new PropertyDictionary<ProjectPropertyInstance>();
             Expander<ProjectPropertyInstance, ProjectItemInstance> expander = new Expander<ProjectPropertyInstance, ProjectItemInstance>(pg, FileSystems.Default);
@@ -3912,9 +3906,8 @@ public void PropertyFunctionHashCodeSameOnlyIfStringSame(string hashType)
                 "cat12s",
                 "cat1s"
             };
-            string hashTypeString = hashType == null ? "" : $", '{hashType}'";
-            object[] hashes = stringsToHash.Select(toHash =>
-                expander.ExpandPropertiesLeaveTypedAndEscaped($"$([MSBuild]::StableStringHash('{toHash}'{hashTypeString}))", ExpanderOptions.ExpandProperties, MockElementLocation.Instance))
+            int[] hashes = stringsToHash.Select(toHash =>
+                (int)expander.ExpandPropertiesLeaveTypedAndEscaped($"$([MSBuild]::StableStringHash('{toHash}'))", ExpanderOptions.ExpandProperties, MockElementLocation.Instance))
                 .ToArray();
             for (int a = 0; a < hashes.Length; a++)
             {
@@ -3932,33 +3925,6 @@ public void PropertyFunctionHashCodeSameOnlyIfStringSame(string hashType)
             }
         }
 
-        [Theory]
-        [MemberData(nameof(GetHashAlgoTypes))]
-        public void PropertyFunctionHashCodeReturnsExpectedType(string hashType)
-        {
-            PropertyDictionary<ProjectPropertyInstance> pg = new PropertyDictionary<ProjectPropertyInstance>();
-            Expander<ProjectPropertyInstance, ProjectItemInstance> expander = new Expander<ProjectPropertyInstance, ProjectItemInstance>(pg, FileSystems.Default);
-            Type expectedType;
-
-            expectedType = hashType switch
-            {
-                null => typeof(int),
-                "Legacy" => typeof(int),
-                "Fnv1a32bit" => typeof(int),
-                "Fnv1a32bitFast" => typeof(int),
-                "Fnv1a64bit" => typeof(long),
-                "Fnv1a64bitFast" => typeof(long),
-                "Sha256" => typeof(string),
-                _ => throw new ArgumentOutOfRangeException(nameof(hashType))
-            };
-
-
-            string hashTypeString = hashType == null ? "" : $", '{hashType}'";
-            object hashValue = expander.ExpandPropertiesLeaveTypedAndEscaped($"$([MSBuild]::StableStringHash('FooBar'{hashTypeString}))", ExpanderOptions.ExpandProperties, MockElementLocation.Instance);
-
-            hashValue.ShouldBeOfType(expectedType);
-        }
-
         [Theory]
         [InlineData("easycase")]
         [InlineData("")]

src/Build/Evaluation/Expander.cs

@@ -4162,11 +4162,6 @@ private bool TryExecuteWellKnownFunction(out object returnVal, object objectInst
                                 returnVal = IntrinsicFunctions.StableStringHash(arg0);
                                 return true;
                             }
-                            else if (TryGetArgs(args, out string arg1, out string arg2) && Enum.TryParse<IntrinsicFunctions.StringHashingAlgorithm>(arg2, true, out var hashAlgorithm))
-                            {
-                                returnVal = IntrinsicFunctions.StableStringHash(arg1, hashAlgorithm);
-                                return true;
-                            }
                         }
                         else if (string.Equals(_methodMethodName, nameof(IntrinsicFunctions.AreFeaturesEnabled), StringComparison.OrdinalIgnoreCase))
                         {

src/Build/Evaluation/IntrinsicFunctions.cs

@@ -14,7 +14,6 @@
 using Microsoft.Build.Shared;
 using Microsoft.Build.Shared.FileSystem;
 using Microsoft.Build.Utilities;
-using Microsoft.NET.StringTools;
 using Microsoft.Win32;
 
 // Needed for DoesTaskHostExistForParameters
@@ -398,49 +397,12 @@ internal static string ConvertFromBase64(string toDecode)
             return Encoding.UTF8.GetString(Convert.FromBase64String(toDecode));
         }
 
-        internal enum StringHashingAlgorithm
-        {
-            // Legacy way of calculating StableStringHash - which was derived from string GetHashCode
-            Legacy,
-            // FNV-1a 32bit hash
-            Fnv1a32bit,
-            // Custom FNV-1a 32bit hash - optimized for speed by hashing by the whole chars (not individual bytes)
-            Fnv1a32bitFast,
-            // FNV-1a 64bit hash
-            Fnv1a64bit,
-            // Custom FNV-1a 64bit hash - optimized for speed by hashing by the whole chars (not individual bytes)
-            Fnv1a64bitFast,
-            // SHA256 hash - gets the hex string of the hash (with no prefix)
-            Sha256
-        }
-
         /// <summary>
-        /// Hash the string independent of bitness, target framework and default codepage of the environment.
+        /// Hash the string independent of bitness and target framework.
         /// </summary>
-        internal static object StableStringHash(string toHash)
-            => StableStringHash(toHash, StringHashingAlgorithm.Legacy);
-
-        internal static object StableStringHash(string toHash, StringHashingAlgorithm algo) =>
-            algo switch
-            {
-                StringHashingAlgorithm.Legacy => CommunicationsUtilities.GetHashCode(toHash),
-                StringHashingAlgorithm.Fnv1a32bit => FowlerNollVo1aHash.ComputeHash32(toHash),
-                StringHashingAlgorithm.Fnv1a32bitFast => FowlerNollVo1aHash.ComputeHash32Fast(toHash),
-                StringHashingAlgorithm.Fnv1a64bit => FowlerNollVo1aHash.ComputeHash64(toHash),
-                StringHashingAlgorithm.Fnv1a64bitFast => FowlerNollVo1aHash.ComputeHash64Fast(toHash),
-                StringHashingAlgorithm.Sha256 => CalculateSha256(toHash),
-                _ => throw new ArgumentOutOfRangeException(nameof(algo), algo, null)
-            };
-
-        private static string CalculateSha256(string toHash)
-        {
-            var sha = System.Security.Cryptography.SHA256.Create();
-            var hashResult = new StringBuilder();
-            foreach (byte theByte in sha.ComputeHash(Encoding.UTF8.GetBytes(toHash)))
-            {
-                hashResult.Append(theByte.ToString("x2"));
-            }
-            return hashResult.ToString();
+        internal static int StableStringHash(string toHash)
+        {
+            return CommunicationsUtilities.GetHashCode(toHash);
         }
 
         /// <summary>

src/Build/Logging/BinaryLogger/BuildEventArgsWriter.cs

@@ -15,8 +15,6 @@
 using Microsoft.Build.Framework;
 using Microsoft.Build.Framework.Profiler;
 using Microsoft.Build.Shared;
-using Microsoft.Build.Utilities;
-using Microsoft.NET.StringTools;
 
 #nullable disable
 
@@ -1262,9 +1260,9 @@ private void Write(IExtendedBuildEventArgs extendedData)
 
         internal readonly struct HashKey : IEquatable<HashKey>
         {
-            private readonly long value;
+            private readonly ulong value;
 
-            private HashKey(long i)
+            private HashKey(ulong i)
             {
                 value = i;
             }
@@ -1277,13 +1275,13 @@ public HashKey(string text)
                 }
                 else
                 {
-                    value = FowlerNollVo1aHash.ComputeHash64Fast(text);
+                    value = FnvHash64.GetHashCode(text);
                 }
             }
 
             public static HashKey Combine(HashKey left, HashKey right)
             {
-                return new HashKey(FowlerNollVo1aHash.Combine64(left.value, right.value));
+                return new HashKey(FnvHash64.Combine(left.value, right.value));
             }
 
             public HashKey Add(HashKey other) => Combine(this, other);
@@ -1313,5 +1311,35 @@ public override string ToString()
                 return value.ToString();
             }
         }
+
+        internal static class FnvHash64
+        {
+            public const ulong Offset = 14695981039346656037;
+            public const ulong Prime = 1099511628211;
+
+            public static ulong GetHashCode(string text)
+            {
+                ulong hash = Offset;
+
+                unchecked
+                {
+                    for (int i = 0; i < text.Length; i++)
+                    {
+                        char ch = text[i];
+                        hash = (hash ^ ch) * Prime;
+                    }
+                }
+
+                return hash;
+            }
+
+            public static ulong Combine(ulong left, ulong right)
+            {
+                unchecked
+                {
+                    return (left ^ right) * Prime;
+                }
+            }
+        }
     }
 }