@ibyar/expressions 0.5.4 → 0.6.0

package/api/definition/function.js

@@ -3,29 +3,9 @@ import { __decorate, __metadata } from "tslib";
 import { Scope } from '../../scope/scope.js';
 import { AbstractExpressionNode, AwaitPromise, ReturnValue, YieldDelegateValue, YieldValue } from '../abstract.js';
 import { Deserializer } from '../deserialize/deserialize.js';
-import { BreakStatement, ContinueStatement } from '../statement/control/terminate.js';
-export var FunctionKind;
-(function (FunctionKind) {
-    FunctionKind["NORMAL"] = "NORMAL";
-    FunctionKind["ASYNC"] = "ASYNC";
-    FunctionKind["GENERATOR"] = "GENERATOR";
-    FunctionKind["ASYNC_GENERATOR"] = "ASYNC_GENERATOR";
-    FunctionKind["CONCISE"] = "CONCISE";
-    FunctionKind["ASYNC_CONCISE"] = "ASYNC_CONCISE";
-    FunctionKind["CONCISE_GENERATOR"] = "CONCISE_GENERATOR";
-    FunctionKind["ASYNC_CONCISE_GENERATOR"] = "ASYNC_CONCISE_GENERATOR";
-    FunctionKind["STATIC_CONCISE"] = "STATIC_CONCISE";
-    FunctionKind["STATIC_ASYNC_CONCISE"] = "STATIC_ASYNC_CONCISE";
-    FunctionKind["STATIC_CONCISE_GENERATOR"] = "STATIC_CONCISE_GENERATOR";
-    FunctionKind["STATIC_ASYNC_CONCISE_GENERATOR"] = "STATIC_ASYNC_CONCISE_GENERATOR";
-    FunctionKind["DERIVED_CONSTRUCTOR"] = "DERIVED_CONSTRUCTOR";
-    FunctionKind["BASE_CONSTRUCTOR"] = "BASE_CONSTRUCTOR";
-})(FunctionKind || (FunctionKind = {}));
-export var ArrowFunctionType;
-(function (ArrowFunctionType) {
-    ArrowFunctionType["NORMAL"] = "NORMAL";
-    ArrowFunctionType["ASYNC"] = "ASYNC";
-})(ArrowFunctionType || (ArrowFunctionType = {}));
+import { Identifier } from './values.js';
+import { TerminateReturnType } from '../statement/control/terminate.js';
+import { RestElement } from '../computing/rest.js';
 let Param = Param_1 = class Param extends AbstractExpressionNode {
     constructor(identifier, defaultValue) {
         super();
@@ -76,7 +56,7 @@ Param = Param_1 = __decorate([
     __metadata("design:paramtypes", [Object, Object])
 ], Param);
 export { Param };
-export class FunctionBaseExpression extends AbstractExpressionNode {
+export class BaseFunctionExpression extends AbstractExpressionNode {
     shareVariables(scopeList) {
         this.sharedVariables = scopeList;
     }
@@ -91,23 +71,22 @@ export class FunctionBaseExpression extends AbstractExpressionNode {
         stack.clearTo(innerScopes[0]);
     }
 }
-let FunctionExpression = FunctionExpression_1 = class FunctionExpression extends FunctionBaseExpression {
-    constructor(params, body, kind, id, rest, generator) {
+let FunctionExpression = FunctionExpression_1 = class FunctionExpression extends BaseFunctionExpression {
+    constructor(params, body, async, generator, id) {
         super();
         this.params = params;
         this.body = body;
-        this.kind = kind;
-        this.id = id;
-        this.rest = rest;
+        this.async = async;
         this.generator = generator;
+        this.id = id;
     }
     static fromJSON(node, deserializer) {
-        return new FunctionExpression_1(node.params.map(deserializer), node.body.map(deserializer), FunctionKind[node.kind], node.id ? deserializer(node.id) : void 0, node.rest, node.generator);
+        return new FunctionExpression_1(node.params.map(deserializer), deserializer(node.body), node.async, node.generator, node.id ? deserializer(node.id) : void 0);
     }
     static visit(node, visitNode) {
         node.id && visitNode(node.id);
         node.params.forEach(visitNode);
-        node.body.forEach(visitNode);
+        visitNode(node.body);
     }
     getParams() {
         return this.params;
@@ -115,182 +94,203 @@ let FunctionExpression = FunctionExpression_1 = class FunctionExpression extends
     getBody() {
         return this.body;
     }
-    getKind() {
-        return this.kind;
+    getGenerator() {
+        return this.generator;
     }
     getId() {
         return this.id;
     }
-    getRest() {
-        return this.rest;
+    getAsync() {
+        return this.async;
     }
     set(stack, value) {
         throw new Error(`${this.constructor.name}#set() has no implementation.`);
     }
     setParameter(stack, args) {
-        const limit = this.rest ? this.params.length - 1 : this.params.length;
+        const rest = this.params[this.params.length - 1] instanceof RestElement;
+        const limit = rest ? this.params.length - 1 : this.params.length;
         for (let i = 0; i < limit; i++) {
             this.params[i].set(stack, args[i]);
         }
-        if (this.rest) {
+        if (rest) {
             this.params[limit].set(stack, args.slice(limit));
         }
     }
     get(stack) {
-        const self = this;
         let func;
-        switch (this.kind) {
-            case FunctionKind.ASYNC:
-                func = async function (...args) {
-                    const innerScopes = self.initFunctionScope(stack);
-                    stack.declareVariable('this', this);
-                    self.setParameter(stack, args);
-                    let returnValue;
-                    for (const statement of self.body) {
-                        statement.shareVariables(innerScopes);
-                        returnValue = statement.get(stack);
-                        if (stack.awaitPromise.length > 0) {
-                            for (const awaitRef of stack.awaitPromise) {
-                                const awaitValue = await awaitRef.promise;
-                                if (awaitRef.declareVariable) {
-                                    awaitRef.node.declareVariable(stack, awaitValue);
-                                }
-                                else {
-                                    awaitRef.node.set(stack, awaitValue);
-                                }
-                            }
-                            stack.awaitPromise.splice(0);
+        if (this.async && this.generator) {
+            func = this.getAsyncGeneratorFunction(stack);
+        }
+        else if (this.async) {
+            func = this.getAsyncFunction(stack);
+        }
+        else if (this.generator) {
+            func = this.getGeneratorFunction(stack);
+        }
+        else {
+            func = this.getFunction(stack);
+        }
+        // this.id?.declareVariable(stack, func);
+        return func;
+    }
+    getAsyncFunction(stack) {
+        const self = this;
+        return async function (...args) {
+            const innerScopes = self.initFunctionScope(stack);
+            stack.declareVariable('this', this);
+            self.setParameter(stack, args);
+            let returnValue;
+            const statements = self.body.getBody();
+            for (const statement of statements) {
+                statement.shareVariables(innerScopes);
+                returnValue = statement.get(stack);
+                if (stack.awaitPromise?.length > 0) {
+                    for (const awaitRef of stack.awaitPromise) {
+                        const awaitValue = await awaitRef.promise;
+                        if (awaitRef.declareVariable) {
+                            awaitRef.node.declareVariable(stack, awaitValue);
                         }
-                        else if (stack.forAwaitAsyncIterable) {
-                            for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
-                                const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
-                                if (ContinueStatement.ContinueSymbol === result) {
-                                    continue;
-                                }
-                                else if (BreakStatement.BreakSymbol === result) {
-                                    break;
-                                }
-                                else if (result instanceof ReturnValue) {
-                                    returnValue = result;
-                                    break;
-                                }
-                            }
-                            stack.forAwaitAsyncIterable = undefined;
+                        else {
+                            awaitRef.node.set(stack, awaitValue);
                         }
-                        if (returnValue instanceof ReturnValue) {
-                            returnValue = returnValue.value;
-                            if (returnValue instanceof AwaitPromise) {
-                                returnValue = await returnValue.promise;
-                                self.clearFunctionScope(stack, innerScopes);
-                                return returnValue;
+                    }
+                    stack.awaitPromise.splice(0);
+                }
+                else if (stack.forAwaitAsyncIterable) {
+                    for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
+                        const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
+                        if (result instanceof TerminateReturnType) {
+                            if (result.type === 'continue') {
+                                continue;
+                            }
+                            else {
+                                break;
                             }
                         }
+                        else if (result instanceof ReturnValue) {
+                            returnValue = result;
+                            break;
+                        }
+                    }
+                    stack.forAwaitAsyncIterable = undefined;
+                }
+                if (returnValue instanceof ReturnValue) {
+                    returnValue = returnValue.value;
+                    if (returnValue instanceof AwaitPromise) {
+                        returnValue = await returnValue.promise;
                     }
                     self.clearFunctionScope(stack, innerScopes);
-                };
-                break;
-            case FunctionKind.GENERATOR:
-                func = function* (...args) {
-                    const innerScopes = self.initFunctionScope(stack);
-                    stack.declareVariable('this', this);
-                    self.setParameter(stack, args);
-                    let returnValue;
-                    for (const statement of self.body) {
-                        statement.shareVariables(innerScopes);
-                        returnValue = statement.get(stack);
-                        if (returnValue instanceof ReturnValue) {
-                            self.clearFunctionScope(stack, innerScopes);
-                            return returnValue.value;
-                        }
-                        else if (returnValue instanceof YieldValue) {
-                            yield returnValue.value;
+                    return returnValue;
+                }
+            }
+            self.clearFunctionScope(stack, innerScopes);
+        };
+    }
+    getGeneratorFunction(stack) {
+        const self = this;
+        return function* (...args) {
+            const innerScopes = self.initFunctionScope(stack);
+            stack.declareVariable('this', this);
+            self.setParameter(stack, args);
+            let returnValue;
+            const statements = self.body.getBody();
+            for (const statement of statements) {
+                statement.shareVariables(innerScopes);
+                returnValue = statement.get(stack);
+                if (returnValue instanceof ReturnValue) {
+                    self.clearFunctionScope(stack, innerScopes);
+                    return returnValue.value;
+                }
+                else if (returnValue instanceof YieldValue) {
+                    yield returnValue.value;
+                }
+                else if (returnValue instanceof YieldDelegateValue) {
+                    yield* returnValue.value;
+                }
+            }
+            self.clearFunctionScope(stack, innerScopes);
+        };
+    }
+    getAsyncGeneratorFunction(stack) {
+        const self = this;
+        return async function* (...args) {
+            const innerScopes = self.initFunctionScope(stack);
+            stack.declareVariable('this', this);
+            self.setParameter(stack, args);
+            let returnValue;
+            const statements = self.body.getBody();
+            for (const statement of statements) {
+                statement.shareVariables(innerScopes);
+                returnValue = statement.get(stack);
+                if (stack.awaitPromise?.length > 0) {
+                    for (const awaitRef of stack.awaitPromise) {
+                        const awaitValue = await awaitRef.promise;
+                        if (awaitRef.declareVariable) {
+                            awaitRef.node.declareVariable(stack, awaitValue);
                         }
-                        else if (returnValue instanceof YieldDelegateValue) {
-                            yield* returnValue.value;
+                        else {
+                            awaitRef.node.set(stack, awaitValue);
                         }
                     }
-                    self.clearFunctionScope(stack, innerScopes);
-                };
-                break;
-            case FunctionKind.ASYNC_GENERATOR:
-                func = async function* (...args) {
-                    const innerScopes = self.initFunctionScope(stack);
-                    stack.declareVariable('this', this);
-                    self.setParameter(stack, args);
-                    let returnValue;
-                    for (const statement of self.body) {
-                        statement.shareVariables(innerScopes);
-                        returnValue = statement.get(stack);
-                        if (stack.awaitPromise.length > 0) {
-                            for (const awaitRef of stack.awaitPromise) {
-                                const awaitValue = await awaitRef.promise;
-                                if (awaitRef.declareVariable) {
-                                    awaitRef.node.declareVariable(stack, awaitValue);
-                                }
-                                else {
-                                    awaitRef.node.set(stack, awaitValue);
-                                }
+                    stack.awaitPromise.splice(0);
+                }
+                else if (stack.forAwaitAsyncIterable) {
+                    for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
+                        const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
+                        if (result instanceof TerminateReturnType) {
+                            if (result.type === 'continue') {
+                                continue;
                             }
-                            stack.awaitPromise.splice(0);
-                        }
-                        else if (stack.forAwaitAsyncIterable) {
-                            for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
-                                const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
-                                if (ContinueStatement.ContinueSymbol === result) {
-                                    continue;
-                                }
-                                else if (BreakStatement.BreakSymbol === result) {
-                                    break;
-                                }
-                                else if (result instanceof ReturnValue) {
-                                    self.clearFunctionScope(stack, innerScopes);
-                                    returnValue = returnValue.value;
-                                    if (returnValue instanceof AwaitPromise) {
-                                        return await returnValue.promise;
-                                    }
-                                    else if (returnValue instanceof YieldValue) {
-                                        yield returnValue.value;
-                                    }
-                                    else if (returnValue instanceof YieldDelegateValue) {
-                                        yield* returnValue.value;
-                                    }
-                                    return returnValue;
-                                }
+                            else {
+                                break;
                             }
-                            stack.forAwaitAsyncIterable = undefined;
                         }
-                        if (returnValue instanceof ReturnValue) {
+                        else if (result instanceof ReturnValue) {
+                            self.clearFunctionScope(stack, innerScopes);
                             returnValue = returnValue.value;
                             if (returnValue instanceof AwaitPromise) {
                                 return await returnValue.promise;
                             }
+                            else if (returnValue instanceof YieldValue) {
+                                yield returnValue.value;
+                            }
+                            else if (returnValue instanceof YieldDelegateValue) {
+                                yield* returnValue.value;
+                            }
                             return returnValue;
                         }
                     }
-                    self.clearFunctionScope(stack, innerScopes);
-                };
-                break;
-            default:
-            case FunctionKind.NORMAL:
-                func = function (...args) {
-                    const innerScopes = self.initFunctionScope(stack);
-                    stack.declareVariable('this', this);
-                    self.setParameter(stack, args);
-                    let returnValue;
-                    for (const statement of self.body) {
-                        statement.shareVariables(innerScopes);
-                        returnValue = statement.get(stack);
-                        if (returnValue instanceof ReturnValue) {
-                            self.clearFunctionScope(stack, innerScopes);
-                            return returnValue.value;
-                        }
+                    stack.forAwaitAsyncIterable = undefined;
+                }
+                if (returnValue instanceof ReturnValue) {
+                    returnValue = returnValue.value;
+                    if (returnValue instanceof AwaitPromise) {
+                        return await returnValue.promise;
                     }
+                    return returnValue;
+                }
+            }
+            self.clearFunctionScope(stack, innerScopes);
+        };
+    }
+    getFunction(stack) {
+        const self = this;
+        return function (...args) {
+            const innerScopes = self.initFunctionScope(stack);
+            stack.declareVariable('this', this);
+            self.setParameter(stack, args);
+            let returnValue;
+            const statements = self.body.getBody();
+            for (const statement of statements) {
+                statement.shareVariables(innerScopes);
+                returnValue = statement.get(stack);
+                if (returnValue instanceof ReturnValue) {
                     self.clearFunctionScope(stack, innerScopes);
-                };
-                break;
-        }
-        this.id?.declareVariable(stack, func);
-        return func;
+                    return returnValue.value;
+                }
+            }
+            self.clearFunctionScope(stack, innerScopes);
+        };
     }
     dependency(computed) {
         return this.params.flatMap(param => param.dependency());
@@ -299,78 +299,75 @@ let FunctionExpression = FunctionExpression_1 = class FunctionExpression extends
         return this.params.flatMap(param => param.dependencyPath(computed));
     }
     toString() {
-        let declare;
-        switch (this.kind) {
-            case FunctionKind.ASYNC:
-                declare = 'async function';
-                break;
-            case FunctionKind.GENERATOR:
-                declare = 'function*';
-                break;
-            case FunctionKind.ASYNC_GENERATOR:
-                declare = 'async function*';
-                break;
-            default:
-            case FunctionKind.NORMAL:
-                declare = 'function';
-                break;
+        let declare = 'function ';
+        if (this.async && this.generator) {
+            declare = 'async function* ';
         }
-        return `${declare} ${this.id?.toString() || ''}(${this.params.map((param, index, array) => {
-            if (index === array.length - 1 && this.rest) {
-                return '...' + param.toString();
-            }
-            else {
-                return param.toString();
-            }
-        }).join(', ')}) ${this.body.toString()}`;
+        else if (this.async) {
+            declare = 'async function ';
+        }
+        else if (this.generator) {
+            declare = 'function* ';
+        }
+        return `${declare}${this.id?.toString() || ''}${this.paramsAndBodyToString()}`;
+    }
+    paramsAndBodyToString() {
+        return `(${this.params.map(param => param.toString()).join(', ')}) ${this.body.toString()}`;
     }
     toJson() {
         return {
             params: this.params.map(param => param.toJSON()),
-            body: this.body.map(statement => statement.toJSON()),
-            kind: this.kind,
+            body: this.body.toJSON(),
+            async: this.async,
             id: this.id?.toJSON(),
-            rest: this.rest,
             generator: this.generator
         };
     }
 };
 FunctionExpression = FunctionExpression_1 = __decorate([
     Deserializer('FunctionExpression'),
-    __metadata("design:paramtypes", [Array, Array, String, Object, Boolean, Boolean])
+    __metadata("design:paramtypes", [Array, Object, Boolean, Boolean, Identifier])
 ], FunctionExpression);
 export { FunctionExpression };
 let FunctionDeclaration = FunctionDeclaration_1 = class FunctionDeclaration extends FunctionExpression {
     static fromJSON(node, deserializer) {
-        return new FunctionDeclaration_1(node.params.map(deserializer), node.body.map(deserializer), FunctionKind[node.kind], node.id ? deserializer(node.id) : void 0, node.rest, node.generator);
+        return new FunctionDeclaration_1(node.params.map(deserializer), deserializer(node.body), node.async, node.generator, deserializer(node.id));
     }
     static visit(node, visitNode) {
-        node.id && visitNode(node.id);
+        visitNode(node.id);
         node.params.forEach(visitNode);
-        node.body.forEach(visitNode);
+        visitNode(node.body);
+    }
+    constructor(params, body, async, generator, id) {
+        super(params, body, async, generator, id);
+    }
+    get(stack) {
+        const func = super.get(stack);
+        this.declareVariable(stack, func);
+        return func;
     }
-    constructor(params, body, kind, id, rest, generator) {
-        super(params, body, kind, id, rest, generator);
+    declareVariable(stack, value) {
+        this.id.declareVariable(stack, value);
     }
 };
 FunctionDeclaration = FunctionDeclaration_1 = __decorate([
     Deserializer('FunctionDeclaration'),
-    __metadata("design:paramtypes", [Array, Array, String, Object, Boolean, Boolean])
+    __metadata("design:paramtypes", [Array, Object, Boolean, Boolean, Identifier])
 ], FunctionDeclaration);
 export { FunctionDeclaration };
-let ArrowFunctionExpression = ArrowFunctionExpression_1 = class ArrowFunctionExpression extends FunctionBaseExpression {
-    constructor(params, body, kind, rest, generator) {
+let ArrowFunctionExpression = ArrowFunctionExpression_1 = class ArrowFunctionExpression extends BaseFunctionExpression {
+    constructor(params, body, expression, async) {
         super();
         this.params = params;
         this.body = body;
-        this.kind = kind;
-        this.rest = rest;
-        this.generator = generator;
+        this.expression = expression;
+        this.async = async;
+        this.generator = false;
     }
     static fromJSON(node, deserializer) {
         return new ArrowFunctionExpression_1(node.params.map(deserializer), Array.isArray(node.body)
             ? node.body.map(deserializer)
-            : deserializer(node.body), ArrowFunctionType[node.kind], node.rest, node.generator);
+            : deserializer(node.body), node.expression, node.async);
     }
     static visit(node, visitNode) {
         node.params.forEach(visitNode);
@@ -384,98 +381,97 @@ let ArrowFunctionExpression = ArrowFunctionExpression_1 = class ArrowFunctionExp
     getBody() {
         return this.body;
     }
-    getRest() {
-        return this.rest;
+    getExpression() {
+        return this.expression;
     }
     set(stack, value) {
         throw new Error('ArrowFunctionExpression#set() has no implementation.');
     }
     setParameter(stack, args) {
-        const limit = this.rest ? this.params.length - 1 : this.params.length;
+        const rest = this.params[this.params.length - 1] instanceof RestElement;
+        const limit = rest ? this.params.length - 1 : this.params.length;
         for (let i = 0; i < limit; i++) {
             this.params[i].set(stack, args[i]);
         }
-        if (this.rest) {
+        if (rest) {
             this.params[limit].set(stack, args.slice(limit));
         }
     }
     get(stack) {
-        let func;
-        switch (this.kind) {
-            case ArrowFunctionType.ASYNC:
-                func = async (...args) => {
-                    const innerScopes = this.initFunctionScope(stack);
-                    this.setParameter(stack, args);
-                    let returnValue;
-                    const statements = Array.isArray(this.body) ? this.body : [this.body];
-                    for (const state of statements) {
-                        state.shareVariables(innerScopes);
-                        returnValue = state.get(stack);
-                        if (stack.awaitPromise.length > 0) {
-                            for (const awaitRef of stack.awaitPromise) {
-                                const awaitValue = await awaitRef.promise;
-                                if (awaitRef.declareVariable) {
-                                    awaitRef.node.declareVariable(stack, awaitValue);
-                                }
-                                else {
-                                    awaitRef.node.set(stack, awaitValue);
-                                }
-                            }
-                            stack.awaitPromise.splice(0);
+        return this.async ? this.getAsyncArrowFunction(stack) : this.getArrowFunction(stack);
+    }
+    getAsyncArrowFunction(stack) {
+        async (...args) => {
+            const innerScopes = this.initFunctionScope(stack);
+            this.setParameter(stack, args);
+            let returnValue;
+            const statements = Array.isArray(this.body) ? this.body : [this.body];
+            for (const state of statements) {
+                state.shareVariables(innerScopes);
+                returnValue = state.get(stack);
+                if (stack.awaitPromise?.length > 0) {
+                    for (const awaitRef of stack.awaitPromise) {
+                        const awaitValue = await awaitRef.promise;
+                        if (awaitRef.declareVariable) {
+                            awaitRef.node.declareVariable(stack, awaitValue);
                         }
-                        else if (stack.forAwaitAsyncIterable) {
-                            for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
-                                const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
-                                if (ContinueStatement.ContinueSymbol === result) {
-                                    continue;
-                                }
-                                else if (BreakStatement.BreakSymbol === result) {
-                                    break;
-                                }
-                                else if (result instanceof ReturnValue) {
-                                    returnValue = result;
-                                    break;
-                                }
-                            }
-                            stack.forAwaitAsyncIterable = undefined;
+                        else {
+                            awaitRef.node.set(stack, awaitValue);
                         }
-                        if (returnValue instanceof ReturnValue) {
-                            returnValue = returnValue.value;
-                            if (returnValue instanceof AwaitPromise) {
-                                this.clearFunctionScope(stack, innerScopes);
-                                return await returnValue.promise;
+                    }
+                    stack.awaitPromise.splice(0);
+                }
+                else if (stack.forAwaitAsyncIterable) {
+                    for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
+                        const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
+                        if (result instanceof TerminateReturnType) {
+                            if (result.type === 'continue') {
+                                continue;
+                            }
+                            else {
+                                break;
                             }
                         }
-                    }
-                    this.clearFunctionScope(stack, innerScopes);
-                    if (!Array.isArray(this.body)) {
-                        return returnValue;
-                    }
-                };
-                break;
-            default:
-            case ArrowFunctionType.NORMAL:
-                func = (...args) => {
-                    const innerScopes = this.initFunctionScope(stack);
-                    this.setParameter(stack, args);
-                    let returnValue;
-                    const statements = Array.isArray(this.body) ? this.body : [this.body];
-                    for (const statement of statements) {
-                        statement.shareVariables(innerScopes);
-                        returnValue = statement.get(stack);
-                        if (returnValue instanceof ReturnValue) {
-                            this.clearFunctionScope(stack, innerScopes);
-                            return returnValue.value;
+                        else if (result instanceof ReturnValue) {
+                            returnValue = result;
+                            break;
                         }
                     }
-                    this.clearFunctionScope(stack, innerScopes);
-                    if (!Array.isArray(this.body)) {
-                        return returnValue;
+                    stack.forAwaitAsyncIterable = undefined;
+                }
+                if (returnValue instanceof ReturnValue) {
+                    returnValue = returnValue.value;
+                    if (returnValue instanceof AwaitPromise) {
+                        this.clearFunctionScope(stack, innerScopes);
+                        return await returnValue.promise;
                     }
-                };
-                break;
-        }
-        return func;
+                }
+            }
+            this.clearFunctionScope(stack, innerScopes);
+            if (this.expression) {
+                return returnValue;
+            }
+        };
+    }
+    getArrowFunction(stack) {
+        return (...args) => {
+            const innerScopes = this.initFunctionScope(stack);
+            this.setParameter(stack, args);
+            let returnValue;
+            const statements = Array.isArray(this.body) ? this.body : [this.body];
+            for (const statement of statements) {
+                statement.shareVariables(innerScopes);
+                returnValue = statement.get(stack);
+                if (returnValue instanceof ReturnValue) {
+                    this.clearFunctionScope(stack, innerScopes);
+                    return returnValue.value;
+                }
+            }
+            this.clearFunctionScope(stack, innerScopes);
+            if (this.expression) {
+                return returnValue;
+            }
+        };
     }
     dependency(computed) {
         return this.params.flatMap(param => param.dependency());
@@ -484,24 +480,12 @@ let ArrowFunctionExpression = ArrowFunctionExpression_1 = class ArrowFunctionExp
         return this.params.flatMap(param => param.dependencyPath(computed));
     }
     toString() {
-        let str = this.kind === ArrowFunctionType.ASYNC ? 'async ' : '';
-        if (this.params.length === 0) {
-            str += '()';
-        }
-        else if (this.params.length === 1) {
+        let str = this.async ? 'async ' : '';
+        if (this.params.length === 1) {
             str += this.params[0].toString();
         }
         else {
-            str += '(';
-            str += this.params.map((param, index, array) => {
-                if (index === array.length - 1 && this.rest) {
-                    return '...' + param.toString();
-                }
-                else {
-                    return param.toString();
-                }
-            }).join(', ');
-            str += ')';
+            str += `(${this.params.map(param => param.toString()).join(', ')})`;
         }
         str += ' => ';
         str += this.body.toString();
@@ -512,15 +496,14 @@ let ArrowFunctionExpression = ArrowFunctionExpression_1 = class ArrowFunctionExp
             params: this.params.map(param => param.toJSON()),
             body: Array.isArray(this.body) ? this.body.map(item => item.toJSON()) : this.body.toJSON(),
             expression: true,
-            kind: this.kind,
-            rest: this.rest,
+            async: this.async,
             generator: this.generator
         };
     }
 };
 ArrowFunctionExpression = ArrowFunctionExpression_1 = __decorate([
     Deserializer('ArrowFunctionExpression'),
-    __metadata("design:paramtypes", [Array, Object, String, Boolean, Boolean])
+    __metadata("design:paramtypes", [Array, Object, Boolean, Boolean])
 ], ArrowFunctionExpression);
 export { ArrowFunctionExpression };
 //# sourceMappingURL=function.js.map