Version 7.5.1-preview: [V8] Added support for JavaScript explicit resource management and script-side host object disposal (GitHub Issue #533); [V8] added support for JavaScript object disposal from the host; added JavaScriptObjectFlags: Iterable, AsyncIterable, Disposable, AsyncDisposable; added IJavaScriptObject.Update; made HostItemFlags.DirectAccess apply to all fully public classes by default (GitHub Discussion #626); added HostSettings.DisableInteropAssemblyConstruction (GitHub Issue #645); added ScriptEngine.MarshalEnumAsUnderlyingType and AcceptEnumAsUnderlyingType (GitHub Discussion #693); [V8] updated V8FastArgs to use ArrayPool; removed initialization script minimization to ease debugging; updated API documentation. Tested with V8 14.3.127.17.

Author: ClearScriptLib

ClearScript/ByRefArg.cs

@@ -10,7 +10,8 @@ namespace Microsoft.ClearScript
     internal interface IByRefArg
     {
         Type Type { get; }
-        object Value { get; set; }
+        object Value { get; }
+        object SetValue(IHostContext context, object value);
     }
 
     internal interface IOutArg : IByRefArg
@@ -80,11 +81,9 @@ public override Invocability GetInvocability(IHostContext context, BindingFlags
 
         #region IByRefArg implementation
 
-        object IByRefArg.Value
-        {
-            get => target.Value;
-            set => ((IHostVariable)target).Value = value;
-        }
+        object IByRefArg.Value => target.Value;
+        
+        object IByRefArg.SetValue(IHostContext context, object value) => ((IHostVariable)target).SetValue(context, value);
 
         #endregion
     }

ClearScript/DefaultDocumentLoader.cs

@@ -27,9 +27,12 @@ public class DefaultDocumentLoader : DocumentLoader, DocumentLoader.IStatistics
             ".." + Path.AltDirectorySeparatorChar,
         };
 
+        private static readonly Func<HttpClientHandler> defaultHttpClientHandlerFactory = static () => new HttpClientHandler();
+
         private readonly List<Document> cache = new();
         private long fileCheckCount;
         private long webCheckCount;
+        private Func<HttpClientHandler> httpClientHandlerFactory;
 
         // ReSharper disable EmptyConstructor
 
@@ -43,6 +46,12 @@ public DefaultDocumentLoader()
 
         // ReSharper restore EmptyConstructor
 
+        internal Func<HttpClientHandler> HttpClientHandlerFactory
+        {
+            get => httpClientHandlerFactory ?? defaultHttpClientHandlerFactory;
+            set => httpClientHandlerFactory = value;
+        }
+
         private Task<(Document, List<Uri>)> GetCachedDocumentOrCandidateUrisAsync(DocumentSettings settings, DocumentInfo? sourceInfo, Uri uri)
         {
             return GetCachedDocumentOrCandidateUrisWorkerAsync(settings, sourceInfo, uri.ToEnumerable());
@@ -229,7 +238,7 @@ private Task<bool> FileDocumentExistsAsync(string path)
         private async Task<bool> WebDocumentExistsAsync(Uri uri)
         {
             Interlocked.Increment(ref webCheckCount);
-            using (var client = new HttpClient())
+            using (var client = new HttpClient(HttpClientHandlerFactory()))
             {
                 using (var request = new HttpRequestMessage(HttpMethod.Head, uri))
                 {
@@ -282,7 +291,7 @@ private async Task<Document> LoadDocumentAsync(DocumentSettings settings, Uri ur
             }
             else
             {
-                using (var client = new HttpClient())
+                using (var client = new HttpClient(HttpClientHandlerFactory()))
                 {
                     contents = await client.GetStringAsync(uri).ConfigureAwait(false);
                 }

ClearScript/DelegateFactory.Generated.cs

@@ -185,11 +185,11 @@ protected static object GetArgValue(object arg)
                 return (arg is IByRefArg byRefArg) ? byRefArg.Value : arg;
             }
 
-            protected static void SetArgValue(object arg, object value)
+            protected void SetArgValue(object arg, object value)
             {
                 if (arg is IByRefArg byRefArg)
                 {
-                    byRefArg.Value = value;
+                    byRefArg.SetValue(Engine, value);
                 }
             }
 

ClearScript/DelegateFactory.cs

@@ -32,7 +32,7 @@ namespace Microsoft.ClearScript
         #>
 
         [ExcludeFromCodeCoverage]
-        private class ProcShim<#= typeParamList #> : ProcShim
+        private sealed class ProcShim<#= typeParamList #> : ProcShim
         {
             private static readonly MethodInfo method = typeof(ProcShim<#= typeParamList #>).GetMethod("InvokeTarget");
             private static readonly bool allByValue = <#= allByValueExpr #>;
@@ -103,7 +103,7 @@ namespace Microsoft.ClearScript
         #>
 
         [ExcludeFromCodeCoverage]
-        private class FuncShim<#= typeParamList #> : FuncShim<TResult>
+        private sealed class FuncShim<#= typeParamList #> : FuncShim<TResult>
         {
             private static readonly MethodInfo method = typeof(FuncShim<#= typeParamList #>).GetMethod("InvokeTarget");
             private static readonly bool allByValue = <#= allByValueExpr #>;

ClearScript/DelegateFactory.tt

@@ -140,7 +140,6 @@ public void AddSystemDocument(string identifier, DocumentCategory category, stri
             AddSystemDocument(identifier, new StringDocument(info, contents));
         }
 
-
         /// <summary>
         /// Adds the specified document as a system document to the configuration.
         /// </summary>

ClearScript/DocumentSettings.cs

@@ -5,7 +5,7 @@
 
 #pragma once
 
-#define CLEARSCRIPT_VERSION_STRING "7.5.0"
-#define CLEARSCRIPT_VERSION_COMMA_SEPARATED 7,5,0
-#define CLEARSCRIPT_VERSION_STRING_INFORMATIONAL "7.5.0"
-#define CLEARSCRIPT_FILE_FLAGS 0L
+#define CLEARSCRIPT_VERSION_STRING "7.5.1"
+#define CLEARSCRIPT_VERSION_COMMA_SEPARATED 7,5,1
+#define CLEARSCRIPT_VERSION_STRING_INFORMATIONAL "7.5.1-preview"
+#define CLEARSCRIPT_FILE_FLAGS VS_FF_PRERELEASE

ClearScript/Exports/VersionSymbols.h

@@ -13,12 +13,14 @@
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.ComTypes;
 using System.Runtime.InteropServices.Expando;
+using System.Threading.Tasks;
+using Microsoft.ClearScript.JavaScript;
 using Microsoft.ClearScript.Util;
 using Microsoft.ClearScript.Util.COM;
 
 namespace Microsoft.ClearScript
 {
-    internal partial class HostItem : DynamicObject, IReflect, IDynamic, IEnumVARIANT, ICustomQueryInterface, IHostItem, IHostTargetContext
+    internal partial class HostItem : DynamicObject, IReflect, IDynamic, IEnumVARIANT, ICustomQueryInterface, IDisposableHostItem, IHostTargetContext
     {
         #region data
 
@@ -821,6 +823,12 @@ protected virtual void RemoveExpandoMemberName(string name)
 
         private StringComparer MemberNameComparer => UseCaseInsensitiveMemberBinding ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
 
+        private void HostInvoke<TArg>(Action<TArg> action, in TArg arg)
+        {
+            BindTargetMemberData();
+            Engine.HostInvoke(action, arg);
+        }
+
         private TResult HostInvoke<TArg, TResult>(Func<TArg, TResult> func, in TArg arg)
         {
             BindTargetMemberData();
@@ -1784,8 +1792,8 @@ private object SetHostPropertyWorker(PropertyInfo property, MethodInfo setMethod
             if (argCount < paramCount)
             {
                 var missingArgs = Enumerable.Repeat(Missing.Value, paramCount - argCount).ToArray();
-                args = args.Take(argCount).Concat(missingArgs).Concat(value.ToEnumerable()).ToArray();
-                bindArgs = bindArgs.Take(argCount).Concat(missingArgs).Concat(bindArgs[bindArgs.Length - 1].ToEnumerable()).ToArray();
+                args = args.Take(argCount).Concat(missingArgs).Concat(EnumerableHelpers.ToEnumerable(value)).ToArray();
+                bindArgs = bindArgs.Take(argCount).Concat(missingArgs).Concat(EnumerableHelpers.ToEnumerable(bindArgs[bindArgs.Length - 1])).ToArray();
             }
 
             // ReSharper disable once SuspiciousTypeConversion.Global
@@ -1813,7 +1821,7 @@ private object SetHostPropertyWorker(PropertyInfo property, MethodInfo setMethod
                 }
             }
 
-            if (property.PropertyType.IsAssignableFromValue(ref value))
+            if (property.PropertyType.IsAssignableFromValue(this, ref value))
             {
                 args[args.Length - 1] = value;
                 InvokeHelpers.InvokeMethod(this, setMethod, Target.InvokeTarget, args, property.GetScriptMemberFlags(this));
@@ -1824,7 +1832,7 @@ private object SetHostPropertyWorker(PropertyInfo property, MethodInfo setMethod
             // the property type. The latter has failed, so let's try the former.
 
             var setParams = setMethod.GetParameters();
-            if ((setParams.Length >= args.Length) && (setParams[args.Length - 1].ParameterType.IsAssignableFromValue(ref value)))
+            if ((setParams.Length >= args.Length) && (setParams[args.Length - 1].ParameterType.IsAssignableFromValue(this, ref value)))
             {
                 args[args.Length - 1] = value;
                 InvokeHelpers.InvokeMethod(this, setMethod, Target.InvokeTarget, args, property.GetScriptMemberFlags(this));
@@ -1853,7 +1861,7 @@ private object SetHostField(BindSignature signature, FieldInfo field, object[] a
         private object SetHostFieldWorker(FieldInfo field, object[] args)
         {
             var value = args[0];
-            if (field.FieldType.IsAssignableFromValue(ref value))
+            if (field.FieldType.IsAssignableFromValue(this, ref value))
             {
                 field.SetValue(Target.InvokeTarget, value);
                 return value;
@@ -2003,7 +2011,7 @@ public override bool TrySetIndex(SetIndexBinder binder, object[] indices, object
 
             if (indices.Length > 1)
             {
-                ThisDynamic.SetProperty(SpecialMemberNames.Default, indices.Concat(value.ToEnumerable()).ToArray());
+                ThisDynamic.SetProperty(SpecialMemberNames.Default, indices.Concat(EnumerableHelpers.ToEnumerable(value)).ToArray());
             }
 
             throw new InvalidOperationException("Invalid argument or index count");
@@ -2442,6 +2450,40 @@ public object Unwrap()
 
         #endregion
 
+        #region IDisposableHostItem implementation
+
+        void IDisposableHostItem.Dispose()
+        {
+            HostInvoke(
+                static self =>
+                {
+                    if (self.BindSpecialTarget(out IDisposable disposable))
+                    {
+                        disposable.Dispose();
+                    }
+                },
+                this
+            );
+        }
+
+        object IDisposableHostItem.DisposeAsync()
+        {
+            return Engine.MarshalToScript(HostInvoke(
+                static self =>
+                {
+                    if (self.BindSpecialTarget(out IAsyncDisposable asyncDisposable))
+                    {
+                        return asyncDisposable.DisposeAsync().ToPromise(self.Engine);
+                    }
+
+                    return Task.CompletedTask.ToPromise(self.Engine);
+                },
+                this
+            ));
+        }
+
+        #endregion
+
         #region IHostTargetContext implementation
 
         public CustomAttributeLoader CustomAttributeLoader => CachedCustomAttributeLoader;

ClearScript/HostItem.cs

@@ -61,7 +61,7 @@ public object this[int index]
 
             set
             {
-                if (!typeof(T).IsAssignableFromValue(ref value))
+                if (!typeof(T).IsAssignableFromValue(engine, ref value))
                 {
                     throw new InvalidOperationException("Assignment invalid due to type mismatch");
                 }

ClearScript/HostList.cs

@@ -49,5 +49,14 @@ public static CustomAttributeLoader CustomAttributeLoader
             get => customAttributeLoader ?? CustomAttributeLoader.Default;
             set => customAttributeLoader = value;
         }
+
+        /// <summary>
+        /// Enables or disables interop assembly construction.
+        /// </summary>
+        /// <remarks>
+        /// Setting this property to <c>true</c> disables the construction of interop assemblies
+        /// at runtime. It is effective only on .NET Framework.
+        /// </remarks>
+        public static bool DisableInteropAssemblyConstruction { get; set; }
     }
 }