Makes Promise overridable

Author: nilproject

NiL.JS/BaseLibrary/Promise.cs

@@ -11,14 +11,7 @@
 
 namespace NiL.JS.BaseLibrary
 {
-    public enum PromiseState
-    {
-        Pending,
-        Fulfilled,
-        Rejected
-    }
-
-    public sealed class Promise
+    public sealed class Promise : IPromiseLike
     {
         private Task _innerTask;
         private Function _callback;
@@ -177,20 +170,20 @@ private void callbackInvoke()
                 _outerTask.SetResult(JSValue.undefined);
         }
 
-        public static Promise resolve(JSValue data)
+        public static IPromiseLike resolve(JSValue data)
         {
             return new Promise(fromResult(data));
         }
 
-        public static Promise race(IIterable promises)
+        public static IPromiseLike race(IIterable promises)
         {
             if (promises == null)
                 return new Promise(fromException(new JSException(new TypeError("Invalid argruments for Promise.race(...)"))));
 
             return new Promise(whenAny(promises.AsEnumerable().Select(convertToTask).ToArray()));
         }
 
-        public static Promise all(IIterable promises)
+        public static IPromiseLike all(IIterable promises)
         {
             if (promises == null)
                 return new Promise(fromException(new JSException(new TypeError("Invalid argruments for Promise.all(...)"))));
@@ -203,20 +196,20 @@ private static Task<JSValue> convertToTask(JSValue arg)
             return (arg.Value as Promise)?.Task ?? fromResult(arg);
         }
 
-        public Promise @catch(Function onRejection)
+        public IPromiseLike @catch(Function onRejection)
         {
             return then(null, onRejection);
         }
 
-        public Promise then(Function onFulfilment, Function onRejection)
+        public IPromiseLike then(Function onFulfilment, Function onRejection)
         {
             return then(
                 onFulfilment == null ? null as Func<JSValue, JSValue> : value => onFulfilment.Call(JSValue.undefined, new Arguments { value }),
                 onRejection == null ? null as Func<JSValue, JSValue> : value => onRejection.Call(JSValue.undefined, new Arguments { value }));
         }
 
         [Hidden]
-        public Promise then(Func<JSValue, JSValue> onFulfilment, Func<JSValue, JSValue> onRejection)
+        public IPromiseLike then(Func<JSValue, JSValue> onFulfilment, Func<JSValue, JSValue> onRejection)
         {
             if (onFulfilment == null && onRejection == null)
                 return resolve(JSValue.undefined);

NiL.JS/Core/Functions/AsyncFunction.cs

@@ -29,7 +29,7 @@ public void Build(JSValue promise)
 
             private JSValue subscribeOrReturnValue(JSValue promiseOrValue)
             {
-                var p = promiseOrValue?.Value as Promise;
+                var p = promiseOrValue?.Value as IPromiseLike;
                 if (p == null)
                     return promiseOrValue;
 

NiL.JS/Core/IPromiseLike.cs

@@ -0,0 +1,30 @@
+using System;
+using NiL.JS.BaseLibrary;
+using NiL.JS.Core.Interop;
+
+namespace NiL.JS.Core
+{
+    public enum PromiseState
+    {
+        Pending,
+        Fulfilled,
+        Rejected
+    }
+
+    public interface IPromiseLike
+    {
+        [Hidden]
+        PromiseState State { get; }
+
+#pragma warning disable IDE1006
+
+        IPromiseLike @catch(Function onRejection);
+
+        IPromiseLike then(Function onFulfilment, Function onRejection);
+
+        [Hidden]
+        IPromiseLike then(Func<JSValue, JSValue> onFulfilment, Func<JSValue, JSValue> onRejection);
+
+#pragma warning restore IDE1006
+    }
+}

NiL.JS/Expressions/AwaitExpression.cs

@@ -46,7 +46,7 @@ public override JSValue Evaluate(Context context)
                 return null;
             }
 
-            if (result != null && (result._valueType < JSValueType.Object || !(result.Value is Promise)))
+            if (result != null && (result._valueType < JSValueType.Object || !(result.Value is IPromiseLike)))
                 return result;
 
             context._executionMode = ExecutionMode.Suspend;