Allow IStream to marshal from native to managed (#369)

Author: asundheimMSFT

src/Microsoft.DiaSymReader.Tests/SymUnmanagedFactoryTests.cs

@@ -9,6 +9,10 @@
 using Roslyn.Test.Utilities;
 using Xunit;
 
+#if NET9_0_OR_GREATER
+using System.Runtime.InteropServices.Marshalling;
+#endif
+
 namespace Microsoft.DiaSymReader.UnitTests
 {
     public class SymUnmanagedFactoryTests
@@ -62,5 +66,38 @@ public void GetEnvironmentVariable()
         {
             Assert.NotNull(SymUnmanagedFactory.GetEnvironmentVariable("MICROSOFT_DIASYMREADER_NATIVE_ALT_LOAD_PATH"));
         }
+
+#if NET9_0_OR_GREATER
+        /// <summary>
+        /// This test is intended to verify that the marshalling doesn't fall over when we have to do the marshalling conversion from
+        /// <see cref="System.Runtime.InteropServices.ComTypes.IStream"/> to <see cref="IUnsafeComStream"/>.
+        /// </summary>
+        [ConditionalFact(typeof(WindowsOnly))]
+        public unsafe void ComWrappersCanMarshalIStream()
+        {
+            var pdbStream = new MemoryStream(TestResources.SourceLink.WindowsPdb);
+            var reader = SymUnmanagedReaderFactory.CreateReader<ISymUnmanagedReader5>(pdbStream,
+                DummySymReaderMetadataProvider.Instance, SymUnmanagedReaderCreationOptions.UseAlternativeLoadPath);
+            Assert.NotNull(reader);
+
+            IUnsafeComStream stream = new ComMemoryStream();
+            stream.SetSize((int)pdbStream.Length);
+
+            fixed (byte* pBytes = TestResources.SourceLink.WindowsPdb)
+            {
+                int written = 0;
+                stream.Write(pBytes, TestResources.SourceLink.WindowsPdb.Length, &written);
+
+                long newPos = 0;
+                stream.Seek(0, 0, &newPos);
+            }
+
+            IntPtr pStream = (IntPtr)ComInterfaceMarshaller<IUnsafeComStream>.ConvertToUnmanaged(stream);
+            System.Runtime.InteropServices.ComTypes.IStream comStream = ComStreamWrapper.Marshaller.ConvertToManaged(pStream);
+
+            int hr = reader.UpdateSymbolStore(null, comStream);
+            Assert.Equal(0, hr);
+        }
+#endif
     }
 }

src/Microsoft.DiaSymReader/Utilities/ComStreamWrapper.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the License.txt file in the project root for more information.
 
+using Microsoft.DiaSymReader.Utilities;
 using System;
 using System.Diagnostics;
 using System.IO;
@@ -208,8 +209,17 @@ public static IntPtr ConvertToUnmanaged(System.Runtime.InteropServices.ComTypes.
                 throw new NotSupportedException("IStream implementation cannot be marshalled");
             }
 
-            public static System.Runtime.InteropServices.ComTypes.IStream ConvertToManaged(IntPtr s)
-                => throw new NotSupportedException("IStream cannot be marshalled to managed");
+            public static System.Runtime.InteropServices.ComTypes.IStream ConvertToManaged(IntPtr native)
+            {
+                IUnsafeComStream marshalledStream = ComInterfaceMarshaller<IUnsafeComStream>.ConvertToManaged((void*)native);
+                if (marshalledStream is null)
+                {
+                    throw new NotSupportedException("IStream cannot be marshalled to managed");
+                }
+
+                // Put the ComWrappers-compatible IUnsafeComStream into a wrapper that also implements the ComWrappers-incompatible IStream
+                return new UnsafeComStreamWrapper(marshalledStream);
+            }
 
             public static void Free(IntPtr unmanaged)
             {

src/Microsoft.DiaSymReader/Utilities/UnsafeComStreamWrapper.cs

@@ -0,0 +1,97 @@
+// Licensed to the.NET Foundation under one or more agreements.
+// The.NET Foundation licenses this file to you under the MIT license.
+// See the License.txt file in the project root for more information.
+
+using System;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices.ComTypes;
+
+#if NET9_0_OR_GREATER
+using System.Runtime.InteropServices.Marshalling;
+#endif
+
+namespace Microsoft.DiaSymReader.Utilities;
+
+/// <summary>
+/// Provides an <see cref="IStream"/>-like wrapper around an <see cref="IUnsafeComStream"/> to handle incompatibilities
+/// introduced with source-generated ComWrappers.
+/// </summary>
+/// <remarks>
+/// <see cref="ComStreamWrapper"/> is a wrapper around a <see cref="Stream"/> that implements both interface definitions.
+/// This is a wrapper around a marshalled <see cref="IUnsafeComStream"/> that also implements the <see cref="IStream"/> interface./>
+/// </remarks>
+#if NET9_0_OR_GREATER
+[GeneratedComClass]
+#endif
+internal partial class UnsafeComStreamWrapper : IUnsafeComStream, IStream
+{
+    private readonly IUnsafeComStream _stream;
+
+    public UnsafeComStreamWrapper(IUnsafeComStream stream)
+    {
+        _stream = stream;
+    }
+
+    #region IUnsafeComStream
+
+    public unsafe void Read(byte* pv, int cb, int* pcbRead) => _stream.Read(pv, cb, pcbRead);
+
+    public unsafe void Write(byte* pv, int cb, int* pcbWritten) => _stream.Write(pv, cb, pcbWritten);
+
+    public unsafe void Seek(long dlibMove, int dwOrigin, long* plibNewPosition) => _stream.Seek(dlibMove, dwOrigin, plibNewPosition);
+
+    public void SetSize(long libNewSize) => _stream.SetSize(libNewSize);
+
+    public unsafe void CopyTo(IntPtr pstm, long cb, int* pcbRead, int* pcbWritten) => _stream.CopyTo(pstm, cb, pcbRead, pcbWritten);
+
+    public void Commit(int grfCommitFlags) => _stream.Commit(grfCommitFlags);
+
+    public void Revert() => _stream.Revert();
+
+    public void LockRegion(long libOffset, long cb, int dwLockType) => _stream.LockRegion(libOffset, cb, dwLockType);
+
+    public void UnlockRegion(long libOffset, long cb, int dwLockType) => _stream.UnlockRegion(libOffset, cb, dwLockType);
+
+    public void Stat(out STATSTG pstatstg, int grfStatFlag) => _stream.Stat(out pstatstg, grfStatFlag);
+
+    public void Clone(out IntPtr ppstm) => _stream.Clone(out ppstm);
+
+    #endregion
+
+    #region IStream
+
+    public void Clone(out IStream ppstm) => throw new NotSupportedException("Clone is not supported in this version.");
+
+    public void CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten) => throw new NotImplementedException("CopyTo is not implemented in this version.");
+
+    public unsafe void Read(byte[] pv, int cb, IntPtr pcbRead)
+    {
+        fixed (byte* pByte = pv)
+        {
+            _stream.Read(pByte, cb, (int*)pcbRead);
+        }
+    }
+
+    public unsafe void Seek(long dlibMove, int dwOrigin, IntPtr plibNewPosition) => _stream.Seek(dlibMove, dwOrigin, (long*)plibNewPosition);
+
+    public unsafe void Write(byte[] pv, int cb, IntPtr pcbWritten)
+    {
+        fixed (byte* pByte = pv)
+        {
+            _stream.Write(pByte, cb, (int*)pcbWritten);
+        }
+    }
+
+    void System.Runtime.InteropServices.ComTypes.IStream.Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag)
+    {
+        _stream.Stat(out var unsafeSTASTG, grfStatFlag);
+
+        pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG()
+        {
+            cbSize = unsafeSTASTG.cbSize,
+        };
+    }
+
+    #endregion
+}