Merge pull request #19322 from CyrusNajmabadi/serializePerf

Improve performance of tree serialization.

src/Compilers/Core/CodeAnalysisTest/ObjectSerializationTests.cs

@@ -919,7 +919,8 @@ private static void TestWritingPrimitiveValues(ObjectWriter writer)
             writer.WriteValue("\uD800\uDC00"); // valid surrogate pair
             writer.WriteValue("\uDC00\uD800"); // invalid surrogate pair
             writer.WriteValue("\uD800"); // incomplete surrogate pair
-            writer.WriteValue(null);
+            writer.WriteValue((object)null);
+            writer.WriteValue((IObjectWritable)null);
             unchecked
             {
                 writer.WriteInt64((long)ConsoleColor.Cyan);
@@ -958,6 +959,7 @@ private static void TestReadingPrimitiveValues(ObjectReader reader)
             Assert.Equal("\uDC00\uD800", (String)reader.ReadValue()); // invalid surrogate pair
             Assert.Equal("\uD800", (String)reader.ReadValue()); // incomplete surrogate pair
             Assert.Equal(null, reader.ReadValue());
+            Assert.Equal(null, reader.ReadValue());
 
             unchecked
             {

src/Compilers/Core/Portable/Diagnostic/Diagnostic.cs

@@ -362,7 +362,7 @@ public bool IsWarningAsError
         /// if there is no entry. This can be used to put diagnostic specific information you want 
         /// to pass around. for example, to corresponding fixer.
         /// </summary>
-        public virtual ImmutableDictionary<string, string> Properties 
+        public virtual ImmutableDictionary<string, string> Properties
             => ImmutableDictionary<string, string>.Empty;
 
         string IFormattable.ToString(string ignored, IFormatProvider formatProvider)
@@ -516,4 +516,4 @@ internal abstract class RequiredLanguageVersion : IMessageSerializable
     {
         public abstract override string ToString();
     }
-}
+}
\ No newline at end of file

src/Compilers/Core/Portable/Serialization/ObjectWriter.cs

@@ -215,10 +215,21 @@ public void WriteValue(object value)
             }
             else
             {
-                WriteObject(value);
+                WriteObject(instance: value, instanceAsWritableOpt: null);
             }
         }
 
+        public void WriteValue(IObjectWritable value)
+        {
+            if (value == null)
+            {
+                _writer.Write((byte)EncodingKind.Null);
+                return;
+            }
+
+            WriteObject(instance: value, instanceAsWritableOpt: value);
+        }
+
         private void WriteEncodedInt32(int v)
         {
             if (v >= 0 && v <= 10)
@@ -438,8 +449,7 @@ private void WriteArray(Array array)
 
             var elementType = array.GetType().GetElementType();
 
-            EncodingKind elementKind;
-            if (s_typeMap.TryGetValue(elementType, out elementKind))
+            if (s_typeMap.TryGetValue(elementType, out var elementKind))
             {
                 this.WritePrimitiveType(elementType, elementKind);
                 this.WritePrimitiveTypeArrayElements(elementType, elementKind, array);
@@ -459,7 +469,7 @@ private void WriteArray(Array array)
                     // don't blow the stack.  'LongRunning' ensures that we get a dedicated thread
                     // to do this work.  That way we don't end up blocking the threadpool.
                     var task = Task.Factory.StartNew(
-                        () => WriteArrayValues(array), 
+                        () => WriteArrayValues(array),
                         _cancellationToken,
                         TaskCreationOptions.LongRunning,
                         TaskScheduler.Default);
@@ -670,13 +680,15 @@ private void WriteKnownType(Type type)
             this.WriteInt32(_binderSnapshot.GetTypeId(type));
         }
 
-        private void WriteObject(object instance)
+        private void WriteObject(object instance, IObjectWritable instanceAsWritableOpt)
         {
+            Debug.Assert(instance != null);
+            Debug.Assert(instanceAsWritableOpt == null || instance == instanceAsWritableOpt);
+
             _cancellationToken.ThrowIfCancellationRequested();
 
             // write object ref if we already know this instance
-            int id;
-            if (_objectReferenceMap.TryGetReferenceId(instance, out id))
+            if (_objectReferenceMap.TryGetReferenceId(instance, out var id))
             {
                 Debug.Assert(id >= 0);
                 if (id <= byte.MaxValue)
@@ -697,10 +709,14 @@ private void WriteObject(object instance)
             }
             else
             {
-                var writable = instance as IObjectWritable;
+                var writable = instanceAsWritableOpt;
                 if (writable == null)
                 {
-                    throw NoSerializationWriterException($"{instance.GetType()} must implement {nameof(IObjectWritable)}");
+                    writable = instance as IObjectWritable;
+                    if (writable == null)
+                    {
+                        throw NoSerializationWriterException($"{instance.GetType()} must implement {nameof(IObjectWritable)}");
+                    }
                 }
 
                 var oldDepth = _recursionDepth;
@@ -712,7 +728,7 @@ private void WriteObject(object instance)
                     // don't blow the stack.  'LongRunning' ensures that we get a dedicated thread
                     // to do this work.  That way we don't end up blocking the threadpool.
                     var task = Task.Factory.StartNew(
-                        () => WriteObjectWorker(instance, writable), 
+                        () => WriteObjectWorker(instance, writable),
                         _cancellationToken,
                         TaskCreationOptions.LongRunning,
                         TaskScheduler.Default);