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);

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)
@@ -670,13 +681,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 +710,18 @@ private void WriteObject(object instance)
             }
             else
             {
-                var writable = instance as IObjectWritable;
-                if (writable == null)
+                IObjectWritable writable;
+                if (instanceAsWritableOpt != null)
                 {
-                    throw NoSerializationWriterException($"{instance.GetType()} must implement {nameof(IObjectWritable)}");
+                    writable = instanceAsWritableOpt;
+                }
+                else
+                {
+                    writable = instance as IObjectWritable;
+                    if (writable == null)
+                    {
+                        throw NoSerializationWriterException($"{instance.GetType()} must implement {nameof(IObjectWritable)}");
+                    }
                 }
 
                 var oldDepth = _recursionDepth;
@@ -712,7 +733,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);