Progress on neutralizing types for persisted assemblies.

Author: RyanLamansky

WebAssembly.Tests/ApiQualityTests.cs

@@ -100,12 +100,12 @@ static IEnumerable<string> GatherViolations()
 
 #if NET9_0_OR_GREATER
     /// <summary>
-    /// Ensures that there's no collision between the default value of <see cref="Runtime.CompilerConfiguration.TypeName"/> and any compiled type.
+    /// Ensures that there's no collision between the default value of <see cref="Runtime.PersistedCompilerConfiguration.TypeName"/> and any compiled type.
     /// </summary>
     [TestMethod]
     public void NoTypeMatchingCompilerConfigurationDefaultNameExists()
     {
-        var defaultTypeName = new Runtime.CompilerConfiguration().TypeName;
+        var defaultTypeName = new Runtime.PersistedCompilerConfiguration(typeof(object).Assembly, typeof(Module).Assembly).TypeName;
         Assert.IsNull(typeof(Module).Assembly.GetType(defaultTypeName));
     }
 #endif

WebAssembly/Runtime/Compile.cs

@@ -221,14 +221,6 @@ private static void CheckPreamble(Reader reader)
     }
 
 #if NET9_0_OR_GREATER
-    /// <summary>
-    /// Creates a <see cref="PersistedAssemblyBuilder"/> from a binary WASM source.
-    /// </summary>
-    /// <param name="input">The source of data. The stream is left open after reading is complete.</param>
-    /// <returns>An assembly builder that can be used to further modify or save the assembly.</returns>
-    public static PersistedAssemblyBuilder CreatePersistedAssembly(Stream input)
-        => CreatePersistedAssembly(input, new());
-
     /// <summary>
     /// Creates a <see cref="PersistedAssemblyBuilder"/> from a binary WASM source.
     /// </summary>
@@ -237,7 +229,7 @@ public static PersistedAssemblyBuilder CreatePersistedAssembly(Stream input)
     /// <returns>An assembly builder that can be used to further modify or save the assembly.</returns>
     public static PersistedAssemblyBuilder CreatePersistedAssembly(
         Stream input,
-        CompilerConfiguration configuration
+        PersistedCompilerConfiguration configuration
         )
     {
         ArgumentNullException.ThrowIfNull(configuration, nameof(configuration));
@@ -250,7 +242,7 @@ CompilerConfiguration configuration
 
             var assembly = new PersistedAssemblyBuilder(
                 new AssemblyName("CompiledWebAssembly"),
-                typeof(object).Assembly
+                configuration.CoreAssembly
                 );
 
             var module = assembly.DefineDynamicModule("CompiledWebAssembly");
@@ -321,11 +313,7 @@ private static ConstructorInfo FromBinary(
 
         var context = new CompilationContext(configuration);
         var exportsBuilder = context.CheckedExportsBuilder = module.DefineType(
-#if NET9_0_OR_GREATER
-            configuration.TypeName,
-#else
-            "CompiledExports",
-#endif
+            configuration.CompiledTypeName,
             ClassAttributes,
             exportContainer);
         MethodBuilder? importedMemoryProvider = null;
@@ -336,7 +324,7 @@ private static ConstructorInfo FromBinary(
             var instanceConstructor = exportsBuilder.DefineConstructor(
                 ConstructorAttributes,
                 CallingConventions.Standard,
-                [typeof(Func<string, string, RuntimeImport>)]
+                [configuration.NeutralizeType(typeof(Func<string, string, RuntimeImport>))]
                 );
             instanceConstructor.DefineParameter(1, ParameterAttributes.None, "findImport");
             instanceConstructorIL = instanceConstructor.GetILGenerator();
@@ -544,13 +532,13 @@ private static ConstructorInfo FromBinary(
 
                         instanceConstructorIL.Emit(OpCodes.Stfld, memory);
 
-                        exportsBuilder.AddInterfaceImplementation(typeof(IDisposable));
+                        exportsBuilder.AddInterfaceImplementation(configuration.NeutralizeType(typeof(IDisposable)));
 
                         var dispose = exportsBuilder.DefineMethod(
                             "Dispose",
                             MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot,
                             CallingConventions.HasThis,
-                            typeof(void),
+                            configuration.NeutralizeType(typeof(void)),
                             emptyTypes
                             );
 

WebAssembly/Runtime/CompilerConfiguration.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Reflection;
 
 namespace WebAssembly.Runtime;
 
@@ -15,23 +16,9 @@ public CompilerConfiguration()
     {
     }
 
-#if NET9_0_OR_GREATER
-    private string typeName = "WebAssembly.CompiledFromWasm";
+    internal virtual string CompiledTypeName => "CompiledExports";
 
-    /// <summary>
-    /// Gets or sets the name of the type that hosts the compiled code.
-    /// Defaults to "WebAssembly.CompiledFromWasm".
-    /// </summary>
-    public string TypeName
-    {
-        get => typeName;
-        set
-        {
-            ArgumentNullException.ThrowIfNull(value);
-            typeName = value;
-        }
-    }
-#endif
+    internal virtual Type NeutralizeType(Type type) => type;
 
     [DebuggerBrowsable(DebuggerBrowsableState.Never)] //Wrapped by a property
     private GetDelegateForTypeCallback getDelegateForType = GetStandardDelegateForType;

WebAssembly/Runtime/PersistedCompilerConfiguration.cs

@@ -0,0 +1,82 @@
+#if NET9_0_OR_GREATER
+
+using System;
+using System.Linq;
+using System.Reflection;
+
+namespace WebAssembly.Runtime;
+
+/// <summary>
+/// Extended compiler configurations for generation of persisted assemblies.
+/// </summary>
+public class PersistedCompilerConfiguration : CompilerConfiguration
+{
+    /// <summary>
+    /// Creates a new <see cref="PersistedCompilerConfiguration"/> with the provided values.
+    /// </summary>
+    /// <param name="coreAssembly">A reference to a .NET Standard or .NET core DLL.</param>
+    /// <param name="webAssembly">A reference to a WebAssembly for .NET primary DLL linked to <paramref name="coreAssembly"/>.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="coreAssembly"/> and <paramref name="webAssembly"/> cannot be null.</exception>
+    public PersistedCompilerConfiguration(Assembly coreAssembly, Assembly webAssembly)
+    {
+        ArgumentNullException.ThrowIfNull(coreAssembly);
+        ArgumentNullException.ThrowIfNull(webAssembly);
+
+        CoreAssembly = coreAssembly;
+        WebAssembly = webAssembly;
+    }
+
+    /// <summary>
+    /// Gets the reference assembly used to find standard types.
+    /// Defaults to the runtime host of the <see cref="Assembly"/> type.
+    /// Required when persisted assembly compilation is used to control which version of .NET is required.
+    /// </summary>
+    public Assembly CoreAssembly { get; }
+
+    /// <summary>
+    /// Gets the assembly used to find the various WebAssembly for .NET types.
+    /// Defaults to the runtime host of the <see cref="Compile"/> type.
+    /// Required when persisted assembly compilation is used to control which version of WebAssembly for .NET is required.
+    /// </summary>
+    public Assembly WebAssembly { get; }
+
+    private string typeName = "WebAssembly.CompiledFromWasm";
+
+    /// <summary>
+    /// Gets or sets the name of the type that hosts the compiled code.
+    /// Defaults to "WebAssembly.CompiledFromWasm".
+    /// Intended for use with persisted assembly compilation.
+    /// </summary>
+    public string TypeName
+    {
+        get => typeName;
+        set
+        {
+            ArgumentNullException.ThrowIfNull(value);
+            typeName = value;
+        }
+    }
+
+    internal sealed override string CompiledTypeName => typeName;
+
+    internal override Type NeutralizeType(Type type)
+    {
+        switch (type.Namespace)
+        {
+            case "System":
+                if (type.IsGenericType)
+                {
+                    var genericArguments = type.GetGenericArguments().Select(NeutralizeType).ToArray();
+                    var rawType = CoreAssembly.GetType($"{type.Namespace}.{type.Name}")!;
+                    return rawType.MakeGenericType(genericArguments);
+                }
+
+                return CoreAssembly.GetType($"{type.Namespace}.{type.Name}")!;
+            case "WebAssembly.Runtime":
+                return WebAssembly.GetType($"{type.Namespace}.{type.Name}")!;
+        }
+
+        throw new InvalidOperationException($"Failed to neutralize type {type.Namespace}.{type.Name}.");
+    }
+}
+#endif