Cache the hash in compilation options

src/Compilers/CSharp/Portable/CSharpCompilationOptions.cs

@@ -18,7 +18,9 @@ namespace Microsoft.CodeAnalysis.CSharp
     /// whether to emit an executable or a library, whether to optimize
     /// generated code, and so on.
     /// </summary>
+#pragma warning disable CS0659 // Type overrides Object.Equals(object o) but does not override Object.GetHashCode().
     public sealed class CSharpCompilationOptions : CompilationOptions, IEquatable<CSharpCompilationOptions>
+#pragma warning restore CS0659 // Type overrides Object.Equals(object o) but does not override Object.GetHashCode().
     {
         /// <summary>
         /// Allow unsafe regions (i.e. unsafe modifiers on members and unsafe blocks).
@@ -748,9 +750,9 @@ public override bool Equals(object? obj)
             return this.Equals(obj as CSharpCompilationOptions);
         }
 
-        public override int GetHashCode()
+        protected override int ComputeHashCode()
         {
-            return Hash.Combine(base.GetHashCodeHelper(),
+            return Hash.Combine(GetHashCodeHelper(),
                    Hash.Combine(this.AllowUnsafe,
                    Hash.Combine(Hash.CombineValues(this.Usings, StringComparer.Ordinal),
                    Hash.Combine(TopLevelBinderFlags.GetHashCode(), this.NullableContextOptions.GetHashCode()))));

src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt

@@ -1,3 +1,4 @@
+*REMOVED*override Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.GetHashCode() -> int
 Microsoft.CodeAnalysis.CSharp.Conversion.ConstrainedToType.get -> Microsoft.CodeAnalysis.ITypeSymbol?
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedMultiLineRawStringStartToken = 9073 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterpolatedRawStringEndToken = 9074 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind

src/Compilers/CSharp/Test/Symbol/Compilation/CSharpCompilationOptionsTests.cs

@@ -354,7 +354,7 @@ public void ConstructorValidation()
         }
 
         /// <summary>
-        /// If this test fails, please update the <see cref="CSharpCompilationOptions.GetHashCode"/>
+        /// If this test fails, please update the <see cref="CompilationOptions.GetHashCode"/>
         /// and <see cref="CSharpCompilationOptions.Equals(CSharpCompilationOptions)"/> methods to
         /// make sure they are doing the right thing with your new field and then update the baseline
         /// here.

src/Compilers/Core/Portable/Compilation/CompilationOptions.cs

@@ -261,6 +261,8 @@ protected set
 
         private readonly Lazy<ImmutableArray<Diagnostic>> _lazyErrors;
 
+        private int _hashCode;
+
         // Expects correct arguments.
         internal CompilationOptions(
             OutputKind outputKind,
@@ -651,7 +653,18 @@ protected bool EqualsHelper([NotNullWhen(true)] CompilationOptions? other)
             return equal;
         }
 
-        public abstract override int GetHashCode();
+        public sealed override int GetHashCode()
+        {
+            if (_hashCode == 0)
+            {
+                var hashCode = ComputeHashCode();
+                _hashCode = hashCode == 0 ? 1 : hashCode;
+            }
+
+            return _hashCode;
+        }
+
+        protected abstract int ComputeHashCode();
 
         protected int GetHashCodeHelper()
         {

src/Compilers/Core/Portable/InternalUtilities/Hash.cs

@@ -68,6 +68,25 @@ internal static int CombineValues<T>(IEnumerable<T>? values, int maxItemsToHash
             return hashCode;
         }
 
+        internal static int CombineValues<TKey, TValue>(ImmutableDictionary<TKey, TValue> values, int maxItemsToHash = int.MaxValue)
+            where TKey : notnull
+        {
+            if (values == null)
+                return 0;
+
+            var hashCode = 0;
+            var count = 0;
+            foreach (var value in values)
+            {
+                if (count++ >= maxItemsToHash)
+                    break;
+
+                hashCode = Hash.Combine(value.GetHashCode(), hashCode);
+            }
+
+            return hashCode;
+        }
+
         internal static int CombineValues<T>(T[]? values, int maxItemsToHash = int.MaxValue)
         {
             if (values == null)
@@ -143,6 +162,31 @@ internal static int CombineValues(IEnumerable<string?>? values, StringComparer s
             return hashCode;
         }
 
+        internal static int CombineValues(ImmutableArray<string> values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue)
+        {
+            if (values == null)
+            {
+                return 0;
+            }
+
+            var hashCode = 0;
+            var count = 0;
+            foreach (var value in values)
+            {
+                if (count++ >= maxItemsToHash)
+                {
+                    break;
+                }
+
+                if (value != null)
+                {
+                    hashCode = Hash.Combine(stringComparer.GetHashCode(value), hashCode);
+                }
+            }
+
+            return hashCode;
+        }
+
         /// <summary>
         /// The offset bias value used in the FNV-1a algorithm
         /// See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

src/Compilers/Core/Portable/PublicAPI.Unshipped.txt

@@ -71,6 +71,7 @@ Microsoft.CodeAnalysis.ISymbol.Accept<TArgument, TResult>(Microsoft.CodeAnalysis
 Microsoft.CodeAnalysis.SymbolVisitor<TArgument, TResult>
 Microsoft.CodeAnalysis.SymbolVisitor<TArgument, TResult>.SymbolVisitor() -> void
 Microsoft.CodeAnalysis.SyntaxValueProvider.ForAttributeWithMetadataName<T>(string! fullyQualifiedMetadataName, System.Func<Microsoft.CodeAnalysis.SyntaxNode!, System.Threading.CancellationToken, bool>! predicate, System.Func<Microsoft.CodeAnalysis.GeneratorAttributeSyntaxContext, System.Threading.CancellationToken, T>! transform) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<T>
+override sealed Microsoft.CodeAnalysis.CompilationOptions.GetHashCode() -> int
 override sealed Microsoft.CodeAnalysis.Diagnostic.Equals(object? obj) -> bool
 *REMOVED*static Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceSyntax<TRoot>(this TRoot! root, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode!>! nodes, System.Func<Microsoft.CodeAnalysis.SyntaxNode!, Microsoft.CodeAnalysis.SyntaxNode!, Microsoft.CodeAnalysis.SyntaxNode!>! computeReplacementNode, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxToken>! tokens, System.Func<Microsoft.CodeAnalysis.SyntaxToken, Microsoft.CodeAnalysis.SyntaxToken, Microsoft.CodeAnalysis.SyntaxToken>! computeReplacementToken, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTrivia>! trivia, System.Func<Microsoft.CodeAnalysis.SyntaxTrivia, Microsoft.CodeAnalysis.SyntaxTrivia, Microsoft.CodeAnalysis.SyntaxTrivia>! computeReplacementTrivia) -> TRoot!
 static Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation.Create(System.Collections.Immutable.ImmutableArray<byte> compressedSlotMap, System.Collections.Immutable.ImmutableArray<byte> compressedLambdaMap, System.Collections.Immutable.ImmutableArray<byte> compressedStateMachineStateMap) -> Microsoft.CodeAnalysis.Emit.EditAndContinueMethodDebugInformation

src/Compilers/VisualBasic/Portable/VisualBasicCompilationOptions.vb

@@ -1117,8 +1117,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ''' Creates a hashcode for this instance.
         ''' </summary>
         ''' <returns>A hashcode representing this instance.</returns>
-        Public Overrides Function GetHashCode() As Integer
-            Return Hash.Combine(MyBase.GetHashCodeHelper(),
+        Protected Overrides Function ComputeHashCode() As Integer
+            Return Hash.Combine(GetHashCodeHelper(),
                    Hash.Combine(Hash.CombineValues(Me.GlobalImports),
                    Hash.Combine(If(Me.RootNamespace IsNot Nothing, StringComparer.Ordinal.GetHashCode(Me.RootNamespace), 0),
                    Hash.Combine(Me.OptionStrict,