Initial step for adding AssemblyBuilder.Save implementation

src/libraries/System.Reflection.Emit/src/CompatibilitySuppressions.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- https://learn.microsoft.com/en-us/dotnet/fundamentals/package-validation/diagnostic-ids -->
+<Suppressions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+  <Suppression>
+    <DiagnosticId>CP0001</DiagnosticId>
+    <Target>T:System.Reflection.Emit.Experiment.PersistableAssemblyBuilder</Target>
+    <Left>ref/net8.0/System.Reflection.Emit.dll</Left>
+    <Right>lib/net8.0/System.Reflection.Emit.dll</Right>
+  </Suppression>
+</Suppressions>

src/libraries/System.Reflection.Emit/src/System.Reflection.Emit.csproj

@@ -1,9 +1,22 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <IsPartialFacadeAssembly>true</IsPartialFacadeAssembly>
     <TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
+    <IsPartialFacadeAssembly>true</IsPartialFacadeAssembly>
+    <ContractTypesPartiallyMoved>true</ContractTypesPartiallyMoved>
   </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="System\Reflection\Emit\MetadataHelper.cs" />
+    <Compile Include="System\Reflection\Emit\PersistableAssemblyBuilder.cs" />
+    <Compile Include="System\Reflection\Emit\PersistableFieldBuilder.cs" />
+    <Compile Include="System\Reflection\Emit\PersistableMethodBuilder.cs" />
+    <Compile Include="System\Reflection\Emit\PersistableModuleBuilder.cs" />
+    <Compile Include="System\Reflection\Emit\PersistableTypeBuilder.cs" />
+    <Compile Include="System\Reflection\Emit\SignatureHelper.cs" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="$(CoreLibProject)" />
+    <ProjectReference Include="$(LibrariesProjectRoot)\System.Collections.Immutable\src\System.Collections.Immutable.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)\System.Reflection.Metadata\src\System.Reflection.Metadata.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)\System.Runtime\src\System.Runtime.csproj" />
   </ItemGroup>
 </Project>

src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/MetadataHelper.cs

@@ -0,0 +1,79 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
+
+namespace System.Reflection.Emit.Experiment
+{
+    //This static helper class adds common entities to a Metadata Builder.
+    internal static class MetadataHelper
+    {
+        internal static AssemblyReferenceHandle AddAssemblyReference(Assembly assembly, MetadataBuilder metadata)
+        {
+            AssemblyName assemblyName = assembly.GetName();
+
+            if (assemblyName == null || assemblyName.Name == null)
+            {
+                throw new ArgumentNullException(nameof(assemblyName));
+            }
+
+            return AddAssemblyReference(metadata, assemblyName.Name, assemblyName.Version, assemblyName.CultureName, assemblyName.GetPublicKey(), (AssemblyFlags)assemblyName.Flags);
+        }
+
+        internal static AssemblyReferenceHandle AddAssemblyReference(MetadataBuilder metadata, string name, Version? version, string? culture, byte[]? publicKey, AssemblyFlags flags)
+        {
+            return metadata.AddAssemblyReference(
+                name: metadata.GetOrAddString(name),
+                version: version ?? new Version(0, 0, 0, 0),
+                culture: (culture == null) ? default : metadata.GetOrAddString(value: culture),
+                publicKeyOrToken: (publicKey == null) ? default : metadata.GetOrAddBlob(publicKey),
+                flags: flags,
+                hashValue: default); // not sure where to find hashValue.
+        }
+
+        internal static TypeDefinitionHandle AddTypeDef(MetadataBuilder metadata, PersistableTypeBuilder typeBuilder, EntityHandle baseType, int methodToken)
+        {
+            //Add type metadata
+            return metadata.AddTypeDefinition(
+                attributes: typeBuilder.Attributes,
+                (typeBuilder.Namespace == null) ? default : metadata.GetOrAddString(typeBuilder.Namespace),
+                name: metadata.GetOrAddString(typeBuilder.Name),
+                baseType: baseType,
+                fieldList: MetadataTokens.FieldDefinitionHandle(1), //Update once we support fields.
+                methodList: MetadataTokens.MethodDefinitionHandle(methodToken));
+        }
+
+        internal static TypeReferenceHandle AddTypeReference(MetadataBuilder metadata, Type type, AssemblyReferenceHandle parent)
+        {
+            return AddTypeReference(metadata, parent, type.Name, type.Namespace);
+        }
+
+        internal static TypeReferenceHandle AddTypeReference(MetadataBuilder metadata, AssemblyReferenceHandle parent, string name, string? nameSpace)
+        {
+            return metadata.AddTypeReference(
+                parent,
+                (nameSpace == null) ? default : metadata.GetOrAddString(nameSpace),
+                metadata.GetOrAddString(name)
+                );
+        }
+
+        internal static MethodDefinitionHandle AddMethodDefintion(MetadataBuilder metadata, PersistableMethodBuilder methodBuilder)
+        {
+            return metadata.AddMethodDefinition(
+                methodBuilder.Attributes,
+                MethodImplAttributes.IL,
+                metadata.GetOrAddString(methodBuilder.Name),
+                metadata.GetOrAddBlob(MetadataSignatureHelper.MethodSignatureEncoder(methodBuilder._parameters, methodBuilder._returnType, !methodBuilder.IsStatic)),
+                -1, //No body supported
+                parameterList: default
+                );
+        }
+
+        internal static FieldDefinitionHandle AddFieldDefintion(MetadataBuilder metadata, FieldInfo field)
+        {
+            return metadata.AddFieldDefinition(field.Attributes, metadata.GetOrAddString(field.Name),
+                metadata.GetOrAddBlob(MetadataSignatureHelper.FieldSignatureEncoder(field.FieldType)));
+        }
+    }
+}

src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/PersistableAssemblyBuilder.cs

@@ -0,0 +1,136 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
+using System.Reflection.PortableExecutable;
+
+namespace System.Reflection.Emit.Experiment
+{
+    public sealed class PersistableAssemblyBuilder : AssemblyBuilder
+    {
+        private bool _previouslySaved;
+        private AssemblyName _assemblyName;
+        private PersistableModuleBuilder? _module;
+
+        internal PersistableAssemblyBuilder(AssemblyName name, IEnumerable<CustomAttributeBuilder>? assemblyAttributes)
+        {
+            ArgumentNullException.ThrowIfNull(name);
+
+            _assemblyName = name;
+
+            _module = new PersistableModuleBuilder(PersistableModuleBuilder.ManifestModuleName, this);
+
+            if (assemblyAttributes != null)
+            {
+                foreach (CustomAttributeBuilder assemblyAttribute in assemblyAttributes)
+                {
+                    SetCustomAttribute(assemblyAttribute);
+                }
+            }
+        }
+
+        public static PersistableAssemblyBuilder DefineDynamicAssembly(AssemblyName name)
+            => new PersistableAssemblyBuilder(name, null);
+
+        public static PersistableAssemblyBuilder DefineDynamicAssembly(
+            AssemblyName name,
+            IEnumerable<CustomAttributeBuilder>? assemblyAttributes)
+                => new PersistableAssemblyBuilder(name, assemblyAttributes);
+
+        private static void WritePEImage(Stream peStream, MetadataBuilder metadataBuilder, BlobBuilder ilBuilder) // MethodDefinitionHandle entryPointHandle when we have main method.
+        {
+            // Create executable with the managed metadata from the specified MetadataBuilder.
+            var peHeaderBuilder = new PEHeaderBuilder(
+                imageCharacteristics: Characteristics.Dll // Start off with a simple DLL
+                );
+
+            var peBuilder = new ManagedPEBuilder(
+                peHeaderBuilder,
+                new MetadataRootBuilder(metadataBuilder),
+                ilBuilder,
+                flags: CorFlags.ILOnly,
+                deterministicIdProvider: content => new BlobContentId(Guid.NewGuid(), 0x04030201)); // Const ID, will reexamine as project progresses.
+
+            // Write executable into the specified stream.
+            var peBlob = new BlobBuilder();
+            BlobContentId contentId = peBuilder.Serialize(peBlob);
+            peBlob.WriteContentTo(peStream);
+        }
+
+        public void Save(Stream stream)
+        {
+            if (_previouslySaved) // Cannot save an assembly multiple times. This is consistent with Save() in .Net Framework.
+            {
+                throw new InvalidOperationException("Cannot save an assembly multiple times");
+            }
+
+            ArgumentNullException.ThrowIfNull(stream);
+
+            if (_assemblyName == null || _assemblyName.Name == null)
+            {
+                throw new InvalidOperationException();
+            }
+
+            if (_module == null)
+            {
+                throw new InvalidOperationException("Assembly needs at least one module defined");
+            }
+
+            // Add assembly metadata
+            var metadata = new MetadataBuilder();
+            metadata.AddAssembly( // Metadata is added for the new assembly - Current design - metadata generated only when Save method is called.
+               metadata.GetOrAddString(value: _assemblyName.Name),
+               version: _assemblyName.Version ?? new Version(0, 0, 0, 0),
+               culture: _assemblyName.CultureName == null ? default : metadata.GetOrAddString(value: _assemblyName.CultureName),
+               publicKey: _assemblyName.GetPublicKey() is byte[] publicKey ? metadata.GetOrAddBlob(value: publicKey) : default,
+               flags: (AssemblyFlags)_assemblyName.Flags,
+               hashAlgorithm: AssemblyHashAlgorithm.None); // AssemblyName.HashAlgorithm is obsolete so default value used.
+
+            // Add module's metadata
+            _module.AppendMetadata(metadata);
+
+            var ilBuilder = new BlobBuilder();
+            WritePEImage(stream, metadata, ilBuilder);
+            _previouslySaved = true;
+        }
+
+        public void Save(string assemblyFileName)
+        {
+            ArgumentNullException.ThrowIfNull(assemblyFileName);
+
+            using var peStream = new FileStream(assemblyFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite);
+            Save(peStream);
+        }
+
+        protected override ModuleBuilder DefineDynamicModuleCore(string name)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(name);
+
+            if (_module == null)
+            {
+                throw new InvalidOperationException("Module not found");
+            }
+
+            return _module;
+        }
+
+        protected override ModuleBuilder? GetDynamicModuleCore(string name)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(name);
+
+            if (PersistableModuleBuilder.ManifestModuleName.Equals(name))
+            {
+                return _module;
+            }
+
+            return null;
+        }
+
+        protected override void SetCustomAttributeCore(ConstructorInfo con, byte[] binaryAttribute) => throw new NotSupportedException();
+
+        protected override void SetCustomAttributeCore(CustomAttributeBuilder customBuilder) => throw new NotSupportedException();
+    }
+}

src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/PersistableFieldBuilder.cs

@@ -0,0 +1,87 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace System.Reflection.Emit.Experiment
+{
+    internal sealed class PersistableFieldBuilder : FieldBuilder
+    {
+        private PersistableTypeBuilder _typeBuilder;
+        private string _fieldName;
+        private FieldAttributes _attributes;
+        private Type _fieldType;
+
+        internal PersistableFieldBuilder(PersistableTypeBuilder typeBuilder, string fieldName, Type type,
+            Type[]? requiredCustomModifiers, Type[]? optionalCustomModifiers, FieldAttributes attributes)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(fieldName);
+
+            ArgumentNullException.ThrowIfNull(type);
+
+            if (type == typeof(void))
+                throw new ArgumentException("Bad field type");
+
+            _fieldName = fieldName;
+
+            _typeBuilder = typeBuilder;
+            _fieldType = type;
+            _attributes = attributes & ~FieldAttributes.ReservedMask;
+
+            SignatureHelper sigHelp = SignatureHelper.GetFieldSigHelper(_typeBuilder.Module);
+            sigHelp.AddArgument(type, requiredCustomModifiers, optionalCustomModifiers);
+        }
+
+        #region MemberInfo Overrides
+        protected override void SetConstantCore(object? defaultValue) => throw new NotImplementedException();
+        protected override void SetCustomAttributeCore(ConstructorInfo con, byte[] binaryAttribute) => throw new NotImplementedException();
+
+        protected override void SetCustomAttributeCore(CustomAttributeBuilder customBuilder) => throw new NotImplementedException();
+        protected override void SetOffsetCore(int iOffset) => throw new NotImplementedException();
+
+        public override int MetadataToken => throw new NotImplementedException();
+
+        public override Module Module => _typeBuilder.Module;
+
+        public override string Name => _fieldName;
+
+        public override Type? DeclaringType
+        {
+            get
+            {
+                return _typeBuilder;
+            }
+        }
+
+        public override Type? ReflectedType
+        {
+            get
+            {
+                return _typeBuilder;
+            }
+        }
+
+        #endregion
+
+        #region FieldInfo Overrides
+        public override Type FieldType => _fieldType;
+
+        public override object? GetValue(object? obj) => throw new NotSupportedException();
+
+        public override void SetValue(object? obj, object? val, BindingFlags invokeAttr, Binder? binder, CultureInfo? culture) => throw new NotSupportedException();
+        public override RuntimeFieldHandle FieldHandle => throw new NotSupportedException();
+
+        public override FieldAttributes Attributes => _attributes;
+
+        #endregion
+
+        #region ICustomAttributeProvider Implementation
+        public override object[] GetCustomAttributes(bool inherit) => throw new NotSupportedException();
+
+        public override object[] GetCustomAttributes(Type attributeType, bool inherit) => throw new NotSupportedException();
+
+        public override bool IsDefined(Type attributeType, bool inherit) => throw new NotSupportedException();
+        #endregion
+    }
+}