Add support for using and await using (#2139)

Author: lahma

Jint.Tests.Test262/Test262Harness.settings.json

@@ -9,7 +9,6 @@
     "async-iteration",
     "Atomics",
     "decorators",
-    "explicit-resource-management",
     "import-defer",
     "iterator-helpers",
     "iterator-sequencing",
@@ -32,6 +31,9 @@
   ],
   "ExcludedFiles": [
 
+    // needs async-iteration
+    "built-ins/AsyncIteratorPrototype/Symbol.asyncDispose/*.js",
+
     // requires rewrite of destructing towards spec
     "language/destructuring/binding/keyed-destructuring-property-reference-target-evaluation-order-with-bindings.js",
     "language/expressions/assignment/destructuring/keyed-destructuring-property-reference-target-evaluation-order-with-bindings.js",

Jint.Tests/Runtime/InteropDisposeTests.cs

@@ -0,0 +1,64 @@
+namespace Jint.Tests.Runtime;
+
+public class InteropDisposeTests
+{
+    private readonly Engine _engine;
+    private readonly SyncDisposable _syncDisposable = new();
+
+#if NETCOREAPP
+    private readonly AsyncDisposable _asyncDisposable = new();
+#endif
+
+    public InteropDisposeTests()
+    {
+        _engine = new Engine();
+        _engine.SetValue("getSync", () => _syncDisposable);
+
+#if NETCOREAPP
+        _engine.SetValue("getAsync", () => _asyncDisposable);
+#endif
+    }
+
+    [Theory]
+    [InlineData("{ using temp = getSync(); }")]
+    [InlineData("(function x() { using temp = getSync(); })()")]
+    [InlineData("class X { constructor() { using temp = getSync(); } } new X();")]
+    [InlineData("class X { static { using temp = getSync(); } } new X();")]
+    [InlineData("for (let i = 0; i < 1; i++) { using temp = getSync(); }")]
+    public void ShouldSyncDispose(string program)
+    {
+        _engine.Execute(program);
+        _syncDisposable.Disposed.Should().BeTrue();
+    }
+
+    private class SyncDisposable : IDisposable
+    {
+        public bool Disposed { get; private set; }
+
+        public void Dispose()
+        {
+            Disposed = true;
+        }
+    }
+
+#if NETCOREAPP
+    [Theory]
+    [InlineData("(async function x() { await using temp = getAsync(); })();")]
+    public void ShouldAsyncDispose(string program)
+    {
+        _engine.Evaluate(program).UnwrapIfPromise();
+        _asyncDisposable.Disposed.Should().BeTrue();
+    }
+
+    private class AsyncDisposable : IAsyncDisposable
+    {
+        public bool Disposed { get; private set; }
+
+        public ValueTask DisposeAsync()
+        {
+            Disposed = true;
+            return default;
+        }
+    }
+#endif
+}

Jint/AstExtensions.cs

@@ -299,7 +299,7 @@ internal static void BindingInitialization(
         if (expression is Identifier identifier)
         {
             var catchEnvRecord = (DeclarativeEnvironment) env;
-            catchEnvRecord.CreateMutableBindingAndInitialize(identifier.Name, canBeDeleted: false, value);
+            catchEnvRecord.CreateMutableBindingAndInitialize(identifier.Name, canBeDeleted: false, value, DisposeHint.Normal);
         }
         else if (expression is DestructuringPattern pattern)
         {
@@ -498,6 +498,16 @@ internal static void AllPrivateIdentifiersValid(this Script script, Realm realm,
         validator.Visit(script);
     }
 
+    internal static DisposeHint GetDisposeHint(this VariableDeclarationKind statement)
+    {
+        return statement switch
+        {
+            VariableDeclarationKind.AwaitUsing => DisposeHint.Async,
+            VariableDeclarationKind.Using => DisposeHint.Sync,
+            _ => DisposeHint.Normal,
+        };
+    }
+
     private sealed class MinimalSyntaxElement : Node
     {
         public MinimalSyntaxElement(in SourceLocation location) : base(NodeType.Unknown)
@@ -545,4 +555,4 @@ private static void Throw(Realm r, PrivateIdentifier id)
             ExceptionHelper.ThrowSyntaxError(r, $"Private field '#{id.Name}' must be declared in an enclosing class");
         }
     }
-}
+}

Jint/Engine.Defaults.cs

@@ -7,7 +7,9 @@ public partial class Engine
     internal static readonly ParserOptions BaseParserOptions = ParserOptions.Default with
     {
         EcmaVersion = EcmaVersion.ES2023,
-        ExperimentalESFeatures = ExperimentalESFeatures.ImportAttributes | ExperimentalESFeatures.RegExpDuplicateNamedCapturingGroups,
+        ExperimentalESFeatures = ExperimentalESFeatures.ImportAttributes
+                                 | ExperimentalESFeatures.RegExpDuplicateNamedCapturingGroups
+                                 | ExperimentalESFeatures.ExplicitResourceManagement,
         Tolerant = false,
     };
 }

Jint/Engine.cs

@@ -1080,11 +1080,11 @@ private void GlobalDeclarationInstantiation(
 
             if (strict)
             {
-                env.CreateImmutableBindingAndInitialize(KnownKeys.Arguments, strict: false, ao);
+                env.CreateImmutableBindingAndInitialize(KnownKeys.Arguments, strict: false, ao, DisposeHint.Normal);
             }
             else
             {
-                env.CreateMutableBindingAndInitialize(KnownKeys.Arguments, canBeDeleted: false, ao);
+                env.CreateMutableBindingAndInitialize(KnownKeys.Arguments, canBeDeleted: false, ao, DisposeHint.Normal);
             }
         }
 
@@ -1108,7 +1108,7 @@ private void GlobalDeclarationInstantiation(
             for (var i = 0; i < varsToInitialize.Count; i++)
             {
                 var pair = varsToInitialize[i];
-                env.CreateMutableBindingAndInitialize(pair.Name, canBeDeleted: false, JsValue.Undefined);
+                env.CreateMutableBindingAndInitialize(pair.Name, canBeDeleted: false, JsValue.Undefined, DisposeHint.Normal);
             }
 
             varEnv = env;
@@ -1126,7 +1126,7 @@ private void GlobalDeclarationInstantiation(
             {
                 var pair = varsToInitialize[i];
                 var initialValue = pair.InitialValue ?? env.GetBindingValue(pair.Name, strict: false);
-                varEnv.CreateMutableBindingAndInitialize(pair.Name, canBeDeleted: false, initialValue);
+                varEnv.CreateMutableBindingAndInitialize(pair.Name, canBeDeleted: false, initialValue, DisposeHint.Normal);
             }
         }
 
@@ -1367,7 +1367,7 @@ internal void EvalDeclarationInstantiation(
                 if (!bindingExists)
                 {
                     varEnvRec.CreateMutableBinding(fn, canBeDeleted: true);
-                    varEnvRec.InitializeBinding(fn, fo);
+                    varEnvRec.InitializeBinding(fn, fo, DisposeHint.Normal);
                 }
                 else
                 {
@@ -1388,7 +1388,7 @@ internal void EvalDeclarationInstantiation(
                 if (!bindingExists)
                 {
                     varEnvRec.CreateMutableBinding(vn, canBeDeleted: true);
-                    varEnvRec.InitializeBinding(vn, JsValue.Undefined);
+                    varEnvRec.InitializeBinding(vn, JsValue.Undefined, DisposeHint.Normal);
                 }
             }
         }

Jint/Jint.csproj

@@ -27,7 +27,7 @@
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(TargetFramework)' != 'net462' and '$(TargetFramework)' != 'netstandard2.0' ">
-    <DefineConstants>$(DefineConstants);SUPPORTS_SPAN_PARSE;SUPPORTS_WEAK_TABLE_ADD_OR_UPDATE;SUPPORTS_WEAK_TABLE_CLEAR</DefineConstants>
+    <DefineConstants>$(DefineConstants);SUPPORTS_SPAN_PARSE;SUPPORTS_WEAK_TABLE_ADD_OR_UPDATE;SUPPORTS_WEAK_TABLE_CLEAR;SUPPORTS_ASYNC_DISPOSE</DefineConstants>
   </PropertyGroup>
 
   <PropertyGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">

Jint/Native/Disposable/DisposeCapability.cs

@@ -2,13 +2,6 @@
 
 namespace Jint.Native.Disposable;
 
-internal enum DisposeHint
-{
-    Normal,
-    Sync,
-    Async,
-}
-
 internal sealed class DisposeCapability
 {
     private readonly Engine _engine;

Jint/Native/Function/ClassDefinition.cs

@@ -203,7 +203,7 @@ public JsValue BuildConstructor(EvaluationContext context, Environment env)
 
             if (_className is not null)
             {
-                classEnv.InitializeBinding(_className, F);
+                classEnv.InitializeBinding(_className, F, DisposeHint.Normal);
             }
 
             F._privateMethods = instancePrivateMethods;

Jint/Native/Function/ScriptFunction.cs

@@ -59,7 +59,7 @@ internal ScriptFunction(
     protected internal override JsValue Call(JsValue thisObject, JsCallArguments arguments)
     {
         var strict = _functionDefinition!.Strict || _thisMode == FunctionThisMode.Strict;
-        using (new StrictModeScope(strict, true))
+        using (new StrictModeScope(strict, force: true))
         {
             try
             {
@@ -76,6 +76,7 @@ protected internal override JsValue Call(JsValue thisObject, JsCallArguments arg
                 var context = _engine._activeEvaluationContext ?? new EvaluationContext(_engine);
 
                 var result = _functionDefinition.EvaluateBody(context, this, arguments);
+                result = calleeContext.LexicalEnvironment.DisposeResources(result);
 
                 if (result.Type == CompletionType.Throw)
                 {
@@ -159,6 +160,7 @@ ObjectInstance IConstructor.Construct(JsCallArguments arguments, JsValue newTarg
                 var context = _engine._activeEvaluationContext ?? new EvaluationContext(_engine);
 
                 var result = _functionDefinition!.EvaluateBody(context, this, arguments);
+                result = constructorEnv.DisposeResources(result);
 
                 // The DebugHandler needs the current execution context before the return for stepping through the return point
                 // We exclude the empty constructor generated for classes without an explicit constructor.

Jint/Native/Object/ObjectInstance.cs

@@ -5,7 +5,6 @@
 using Jint.Native.Array;
 using Jint.Native.BigInt;
 using Jint.Native.Boolean;
-using Jint.Native.Disposable;
 using Jint.Native.Json;
 using Jint.Native.Number;
 using Jint.Native.Promise;