Return generated typemap assemblies without a second buffer

Emitting a typemap assembly serialised the PE image into a BlobBuilder and
then copied every byte again into a MemoryStream, so each generated
assembly was held twice while it was produced.

Return a read-only, seekable stream over the chunks the serialiser already
produced instead. GeneratedAssembly.Content is now typed as Stream, which
is all the build task needs — it hashes the stream and copies it to disk
through Files.CopyIfStreamChanged, so atomic last-known-good replacement is
unchanged, as are the generated bytes.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: simonrozsival

src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/BlobBuilderStream.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection.Metadata;
+
+namespace Microsoft.Android.Sdk.TrimmableTypeMap;
+
+/// <summary>
+/// A read-only, seekable <see cref="Stream"/> over the chunks a <see cref="BlobBuilder"/> already
+/// holds, so a serialised PE image can be hashed and copied to disk without being duplicated into
+/// a second contiguous buffer.
+/// </summary>
+/// <remarks>
+/// Only the chunk arrays are retained — the <see cref="BlobBuilder"/> itself and the metadata
+/// graph that produced it stay collectible — so the live byte count matches what a
+/// <see cref="MemoryStream"/> copy would have held, without the transient second copy.
+/// </remarks>
+sealed class BlobBuilderStream : Stream
+{
+	readonly ArraySegment<byte> [] segments;
+	readonly long [] segmentStarts;
+	readonly long length;
+	long position;
+	int cursor;
+
+	public BlobBuilderStream (BlobBuilder builder)
+	{
+		_ = builder ?? throw new ArgumentNullException (nameof (builder));
+
+		var collected = new List<ArraySegment<byte>> ();
+		foreach (var blob in builder.GetBlobs ()) {
+			var bytes = blob.GetBytes ();
+			if (bytes.Count == 0 || bytes.Array is null) {
+				continue;
+			}
+			collected.Add (bytes);
+		}
+
+		segments = collected.ToArray ();
+		segmentStarts = new long [segments.Length + 1];
+		long total = 0;
+		for (int i = 0; i < segments.Length; i++) {
+			segmentStarts [i] = total;
+			total += segments [i].Count;
+		}
+		segmentStarts [segments.Length] = total;
+		length = total;
+	}
+
+	public override bool CanRead => true;
+
+	public override bool CanSeek => true;
+
+	public override bool CanWrite => false;
+
+	public override long Length => length;
+
+	public override long Position {
+		get => position;
+		set {
+			if (value < 0) {
+				throw new ArgumentOutOfRangeException (nameof (value));
+			}
+			position = value;
+		}
+	}
+
+	public override void Flush ()
+	{
+	}
+
+	public override int Read (byte [] buffer, int offset, int count)
+	{
+		if (buffer is null) {
+			throw new ArgumentNullException (nameof (buffer));
+		}
+		if (offset < 0 || count < 0 || buffer.Length - offset < count) {
+			throw new ArgumentOutOfRangeException (nameof (count));
+		}
+
+		int copied = 0;
+		while (count > 0 && position < length) {
+			int index = FindSegment (position);
+			var segment = segments [index];
+			int within = (int) (position - segmentStarts [index]);
+			int available = segment.Count - within;
+			int toCopy = Math.Min (available, count);
+			if (segment.Array is null) {
+				break;
+			}
+			Buffer.BlockCopy (segment.Array, segment.Offset + within, buffer, offset, toCopy);
+			position += toCopy;
+			offset += toCopy;
+			count -= toCopy;
+			copied += toCopy;
+		}
+		return copied;
+	}
+
+	public override long Seek (long offset, SeekOrigin origin)
+	{
+		long target = origin switch {
+			SeekOrigin.Begin => offset,
+			SeekOrigin.Current => position + offset,
+			SeekOrigin.End => length + offset,
+			_ => throw new ArgumentOutOfRangeException (nameof (origin)),
+		};
+		if (target < 0) {
+			throw new IOException ("Cannot seek before the beginning of the stream.");
+		}
+		position = target;
+		return position;
+	}
+
+	public override void SetLength (long value) => throw new NotSupportedException ();
+
+	public override void Write (byte [] buffer, int offset, int count) => throw new NotSupportedException ();
+
+	int FindSegment (long offset)
+	{
+		// Reads are overwhelmingly sequential, so try the last used chunk first.
+		if (cursor < segments.Length && offset >= segmentStarts [cursor] && offset < segmentStarts [cursor + 1]) {
+			return cursor;
+		}
+
+		int low = 0;
+		int high = segments.Length - 1;
+		while (low <= high) {
+			int middle = low + ((high - low) / 2);
+			if (offset < segmentStarts [middle]) {
+				high = middle - 1;
+			} else if (offset >= segmentStarts [middle + 1]) {
+				low = middle + 1;
+			} else {
+				cursor = middle;
+				return middle;
+			}
+		}
+		throw new ArgumentOutOfRangeException (nameof (offset));
+	}
+}

src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/PEAssemblyBuilder.cs

@@ -104,6 +104,22 @@ public void EmitPreamble (string assemblyName, string moduleName, ReadOnlySpan<b
 	/// Serialises the metadata + IL into a PE DLL and writes it to the given <paramref name="stream"/>.
 	/// </summary>
 	public void WritePE (Stream stream)
+	{
+		var peBlob = SerializePE ();
+		if (stream is MemoryStream memoryStream && memoryStream.Length == 0 && memoryStream.Capacity < peBlob.Count) {
+			memoryStream.Capacity = peBlob.Count;
+		}
+		peBlob.WriteContentTo (stream);
+	}
+
+	/// <summary>
+	/// Serialises the metadata + IL into a PE DLL and returns a read-only stream over the
+	/// serialised bytes. Unlike <see cref="WritePE(Stream)"/> the image is not copied into a
+	/// second contiguous buffer.
+	/// </summary>
+	public Stream CreatePEStream () => new BlobBuilderStream (SerializePE ());
+
+	BlobBuilder SerializePE ()
 	{
 		var peBuilder = new ManagedPEBuilder (
 			new PEHeaderBuilder (imageCharacteristics: Characteristics.Dll),
@@ -114,10 +130,7 @@ public void WritePE (Stream stream)
 			deterministicIdProvider: DeterministicContentId);
 		var peBlob = new BlobBuilder ();
 		peBuilder.Serialize (peBlob);
-		if (stream is MemoryStream memoryStream && memoryStream.Length == 0 && memoryStream.Capacity < peBlob.Count) {
-			memoryStream.Capacity = peBlob.Count;
-		}
-		peBlob.WriteContentTo (stream);
+		return peBlob;
 	}
 
 	static BlobContentId DeterministicContentId (IEnumerable<Blob> content)

src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs

@@ -188,6 +188,21 @@ internal void Emit (TypeMapAssemblyData model, Stream stream, bool useSharedType
 		_pe.WritePE (stream);
 	}
 
+	/// <summary>
+	/// Emits a PE assembly from the given model and returns a read-only stream over the serialised
+	/// image, avoiding the copy into a second buffer that <see cref="Emit(TypeMapAssemblyData, Stream, bool, byte[])"/>
+	/// performs.
+	/// </summary>
+	internal Stream EmitToStream (TypeMapAssemblyData model, bool useSharedTypemapUniverse, byte []? contentFingerprint)
+	{
+		if (model is null) {
+			throw new ArgumentNullException (nameof (model));
+		}
+
+		EmitCore (model, useSharedTypemapUniverse, contentFingerprint);
+		return _pe.CreatePEStream ();
+	}
+
 	void EmitCore (TypeMapAssemblyData model, bool useSharedTypemapUniverse, byte []? contentFingerprint)
 	{
 		contentFingerprint ??= MetadataHelper

src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyGenerator.cs

@@ -55,6 +55,16 @@ internal void Generate (TypeMapAssemblyData model, Stream stream, bool useShared
 		emitter.Emit (model, stream, useSharedTypemapUniverse, contentFingerprint);
 	}
 
+	/// <summary>
+	/// Generates the PE assembly and returns a read-only stream over the serialised image without
+	/// copying it into a second buffer.
+	/// </summary>
+	internal Stream GenerateToStream (TypeMapAssemblyData model, bool useSharedTypemapUniverse, byte []? contentFingerprint = null)
+	{
+		var emitter = new TypeMapAssemblyEmitter (_systemRuntimeVersion);
+		return emitter.EmitToStream (model, useSharedTypemapUniverse, contentFingerprint);
+	}
+
 	/// <summary>
 	/// Emits an empty typemap assembly (containing no type map entries) with the given
 	/// <paramref name="assemblyName"/>, writing it to <paramref name="stream"/>. Used to satisfy

src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs

@@ -326,9 +326,7 @@ internal List<GeneratedAssembly> GenerateTypeMapAssemblies (
 					continue;
 				}
 			}
-			var stream = new MemoryStream ();
-			generator.Generate (model, stream, useSharedTypemapUniverse, fingerprints.Content);
-			stream.Position = 0;
+			var stream = generator.GenerateToStream (model, useSharedTypemapUniverse, fingerprints.Content);
 			generatedAssemblies.Add (new GeneratedAssembly (typeMapAssemblyName, stream));
 			logger.LogGeneratedTypeMapAssemblyInfo (typeMapAssemblyName, peers.Count);
 		}

src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapTypes.cs

@@ -20,7 +20,11 @@ public record TrimmableTypeMapResult (
 		ApplicationRegistrationTypes ?? [];
 }
 
-public record GeneratedAssembly (string Name, MemoryStream Content);
+/// <summary>
+/// A generated typemap assembly. <paramref name="Content"/> is a read-only, seekable stream
+/// positioned at the start of the serialised PE image; callers own it and should dispose it.
+/// </summary>
+public record GeneratedAssembly (string Name, Stream Content);
 
 public record GeneratedJavaSource (string RelativePath, string Content);