@ibyar/expressions 0.3.0 → 0.3.8

package/v8/parser.js

@@ -1,22 +1,24 @@
 import { Token } from './token.js';
 import { TokenStream } from './stream.js';
 import { OfNode, Identifier, ThisNode, GetIdentifier, SetIdentifier, AsyncIdentifier, NullNode, StringLiteral, AwaitIdentifier, ConstructorIdentifier, NameIdentifier, EvalIdentifier, ArgumentsIdentifier, TaggedTemplateExpression, TemplateLiteral } from '../api/definition/values.js';
-import { EmptyStatement } from '../api/statement/controlflow/empty.js';
-import { BlockStatement } from '../api/statement/controlflow/block.js';
-import { ArrowFunctionExpression, ArrowFunctionType, FunctionKind, Paramter, FunctionExpression } from '../api/definition/function.js';
-import { IfStatement } from '../api/statement/controlflow/if.js';
+import { EmptyStatement } from '../api/statement/control/empty.js';
+import { BlockStatement } from '../api/statement/control/block.js';
+import { ArrowFunctionExpression, ArrowFunctionType, FunctionKind, Param, FunctionExpression, FunctionDeclaration } from '../api/definition/function.js';
+import { IfStatement } from '../api/statement/control/if.js';
 import { NewExpression } from '../api/computing/new.js';
 import { SpreadElement } from '../api/computing/spread.js';
+import { RestElement } from '../api/computing/rest.js';
 import { AssignmentExpression } from '../api/operators/assignment.js';
 import { GroupingExpression } from '../api/operators/grouping.js';
 import { MemberExpression } from '../api/definition/member.js';
+import { BindExpression } from '../api/definition/bind.js';
 import { ObjectExpression, Property, ObjectPattern } from '../api/definition/object.js';
 import { ArrayExpression, ArrayPattern } from '../api/definition/array.js';
 import { CallExpression } from '../api/computing/call.js';
 import { DoWhileNode, WhileNode } from '../api/statement/iterations/while.js';
 import { CatchClauseNode, ThrowStatement, TryCatchNode } from '../api/computing/throw.js';
-import { SwitchCase, DefaultExpression, SwitchStatement } from '../api/statement/controlflow/switch.js';
-import { BreakStatement, ContinueStatement } from '../api/statement/controlflow/terminate.js';
+import { SwitchCase, DefaultExpression, SwitchStatement } from '../api/statement/control/switch.js';
+import { BreakStatement, ContinueStatement } from '../api/statement/control/terminate.js';
 import { ReturnStatement } from '../api/computing/return.js';
 import { VariableNode, VariableDeclarationNode } from '../api/statement/declarations/declares.js';
 import { ForNode, ForOfNode, ForInNode, ForAwaitOfNode } from '../api/statement/iterations/for.js';
@@ -27,7 +29,7 @@ import { SequenceExpression } from '../api/operators/comma.js';
 import { ChainExpression } from '../api/operators/chaining.js';
 import { ExpressionStatement } from '../api/definition/statement.js';
 import { buildPostfixExpression, buildUnaryExpression, expressionFromLiteral, shortcutNumericLiteralBinaryExpression } from './nodes.js';
-import { BinaryExpression } from '../api/index.js';
+import { BinaryExpression } from '../api/operators/binary.js';
 export var ParsingArrowHeadFlag;
 (function (ParsingArrowHeadFlag) {
     ParsingArrowHeadFlag[ParsingArrowHeadFlag["CertainlyNotArrowHead"] = 0] = "CertainlyNotArrowHead";
@@ -750,6 +752,9 @@ export class JavaScriptParser extends AbstractParser {
         const formals = this.parseFormalParameterList(functionInfo);
         this.expect(Token.R_PARENTHESES);
         const body = this.parseFunctionBody();
+        if (name) {
+            return new FunctionDeclaration(formals, body, flag, name, functionInfo.rest);
+        }
         return new FunctionExpression(formals, body, flag, name, functionInfo.rest);
     }
     parseFunctionBody() {
@@ -809,10 +814,10 @@ export class JavaScriptParser extends AbstractParser {
                 throw new Error(this.errorMessage(`Rest Default Initializer`));
             }
             const value = this.parseAssignmentExpression();
-            initializer = new Paramter(pattern, value);
+            initializer = new Param(pattern, value);
         }
         else {
-            initializer = new Paramter(pattern);
+            initializer = new Param(pattern);
         }
         return initializer;
     }
@@ -864,14 +869,14 @@ export class JavaScriptParser extends AbstractParser {
         const result = this.parsePrimaryExpression();
         return this.parseMemberExpressionContinuation(result);
     }
-    toParamterNode(expression) {
+    toParamNode(expression) {
         if (expression instanceof AssignmentExpression) {
-            return new Paramter(expression.getLeft(), expression.getRight());
+            return new Param(expression.getLeft(), expression.getRight());
         }
         if (expression instanceof GroupingExpression) {
-            return new Paramter(expression.getNode());
+            return new Param(expression.getNode());
         }
-        return new Paramter(expression);
+        return new Param(expression);
     }
     parsePrimaryExpression() {
         let token = this.peek();
@@ -892,10 +897,10 @@ export class JavaScriptParser extends AbstractParser {
                 const name = this.parseAndClassifyIdentifier(token);
                 const params = [];
                 if (name instanceof SequenceExpression) {
-                    params.push(...name.getExpressions().map(this.toParamterNode));
+                    params.push(...name.getExpressions().map(this.toParamNode));
                 }
                 else {
-                    params.push(this.toParamterNode(name));
+                    params.push(this.toParamNode(name));
                 }
                 return this.parseArrowFunctionLiteral(params, kind);
             }
@@ -954,7 +959,12 @@ export class JavaScriptParser extends AbstractParser {
                 }
                 this.expect(Token.R_PARENTHESES);
                 if (this.peek().isType(Token.ARROW)) {
-                    expression = this.parseArrowFunctionLiteral([expression], ArrowFunctionType.NORMAL, info.rest);
+                    if (expression instanceof SequenceExpression) {
+                        expression = this.parseArrowFunctionLiteral(expression.getExpressions(), ArrowFunctionType.NORMAL, info.rest);
+                    }
+                    else {
+                        expression = this.parseArrowFunctionLiteral([expression], ArrowFunctionType.NORMAL, info.rest);
+                    }
                 }
                 return expression;
             }
@@ -1052,13 +1062,13 @@ export class JavaScriptParser extends AbstractParser {
                 throw new Error(this.errorMessage(`Malformed Arrow Fun Param List`));
             }
             if (expression instanceof SequenceExpression) {
-                const params = expression.getExpressions().map(expr => new Paramter(expr));
+                const params = expression.getExpressions().map(expr => new Param(expr));
                 return this.parseArrowFunctionLiteral(params, ArrowFunctionType.NORMAL);
             }
             if (expression instanceof GroupingExpression) {
-                return this.parseArrowFunctionLiteral([new Paramter(expression.getNode())], ArrowFunctionType.NORMAL);
+                return this.parseArrowFunctionLiteral([new Param(expression.getNode())], ArrowFunctionType.NORMAL);
             }
-            return this.parseArrowFunctionLiteral([new Paramter(expression)], ArrowFunctionType.NORMAL);
+            return this.parseArrowFunctionLiteral([new Param(expression)], ArrowFunctionType.NORMAL);
         }
         if (this.isAssignableIdentifier(expression)) {
             if (this.isParenthesized(expression)) {
@@ -1112,7 +1122,9 @@ export class JavaScriptParser extends AbstractParser {
             }
             else if (this.check(Token.ELLIPSIS)) {
                 const argument = this.parsePossibleDestructuringSubPattern();
-                elem = new SpreadElement(argument);
+                elem = isPattern
+                    ? new RestElement(argument)
+                    : new SpreadElement(argument);
                 if (firstSpreadIndex < 0) {
                     firstSpreadIndex = values.length;
                 }
@@ -1137,7 +1149,7 @@ export class JavaScriptParser extends AbstractParser {
         this.consume(Token.L_CURLY);
         const properties = [];
         while (!this.check(Token.R_CURLY)) {
-            const property = this.parseObjectPropertyDefinition();
+            const property = this.parseObjectPropertyDefinition(isPattern);
             properties.push(property);
             if (this.peek().isNotType(Token.R_CURLY)) {
                 this.expect(Token.COMMA);
@@ -1148,13 +1160,16 @@ export class JavaScriptParser extends AbstractParser {
         }
         return new ObjectExpression(properties);
     }
-    parseObjectPropertyDefinition() {
+    parseObjectPropertyDefinition(isPattern) {
         const propInfo = { kind: PropertyKind.NotSet };
         const nameExpression = this.parseProperty(propInfo);
         switch (propInfo.kind) {
             case PropertyKind.Spread:
-                const spared = nameExpression;
-                return new Property(spared.getArgument(), spared, 'init');
+                let value = nameExpression;
+                if (isPattern) {
+                    value = new RestElement(value.getArgument());
+                }
+                return new Property(value.getArgument(), value, 'init');
             case PropertyKind.Value: {
                 this.consume(Token.COLON);
                 const value = this.parsePossibleDestructuringSubPattern();
@@ -1235,8 +1250,8 @@ export class JavaScriptParser extends AbstractParser {
             case Token.NUMBER:
             case Token.BIGINT:
                 this.consume(nextToken.token);
-                propInfo.name = nextToken.getValue().toString();
-                propertyName = new StringLiteral(propInfo.name);
+                propertyName = nextToken.getValue();
+                propInfo.name = propertyName.getValue();
                 break;
             case Token.L_BRACKETS:
                 this.consume(Token.L_BRACKETS);
@@ -1316,54 +1331,112 @@ export class JavaScriptParser extends AbstractParser {
         throw new Error(this.errorMessage(`Parsing property expression: Unexpected Token`));
     }
     parsePipelineExpression(expression) {
-        while (this.peek().isType(Token.PIPELINE)) {
-            this.consume(Token.PIPELINE);
-            const func = this.parseMemberExpression();
-            let args = [];
-            switch (this.peek().token) {
-                case Token.COLON:
-                    do {
-                        this.consume(Token.COLON);
-                        const isSpread = this.check(Token.ELLIPSIS);
-                        if (this.peek().isType(Token.CONDITIONAL)) {
-                            this.consume(Token.CONDITIONAL);
-                            if (isSpread) {
-                                args.push('...?');
-                            }
-                            else {
-                                args.push('?');
-                            }
+        let token;
+        while (Token.isPipelineOperator(token = this.peek().token)) {
+            this.consume(token);
+            expression = this.parsePipelineBody(expression);
+        }
+        return expression;
+    }
+    parsePipelineBody(lhs) {
+        let body;
+        let token = this.peek();
+        switch (token.token) {
+            case Token.FUNCTION:
+                this.consume(Token.FUNCTION);
+                if (this.peek().isType(Token.MUL)) {
+                    this.consume(Token.MUL);
+                    body = this.parseFunctionExpression(FunctionKind.GENERATOR);
+                    break;
+                }
+                body = this.parseFunctionExpression(FunctionKind.NORMAL);
+                break;
+            case Token.ASYNC:
+                if (this.peekAhead().isType(Token.FUNCTION)) {
+                    this.consume(Token.ASYNC);
+                    this.consume(Token.FUNCTION);
+                    if (this.peek().isType(Token.MUL)) {
+                        this.consume(Token.MUL);
+                        body = this.parseFunctionExpression(FunctionKind.ASYNC_GENERATOR);
+                        break;
+                    }
+                    body = this.parseFunctionExpression(FunctionKind.ASYNC);
+                    break;
+                }
+                break;
+            default:
+                break;
+        }
+        if (body) {
+            return new PipelineExpression(lhs, body);
+        }
+        if (token.isType(Token.L_PARENTHESES)) {
+            body = this.parsePrimaryExpression();
+            return new PipelineExpression(lhs, body);
+        }
+        const func = this.parseMemberExpression();
+        let args = [];
+        switch (this.peek().token) {
+            case Token.COLON:
+                do {
+                    this.consume(Token.COLON);
+                    const isSpread = this.check(Token.ELLIPSIS);
+                    if (this.peek().isType(Token.CONDITIONAL)) {
+                        this.consume(Token.CONDITIONAL);
+                        if (isSpread) {
+                            args.push('...?');
                         }
                         else {
-                            const arg = this.parseLogicalExpression();
-                            if (isSpread) {
-                                args.push(new SpreadElement(arg));
-                            }
-                            else {
-                                args.push(arg);
-                            }
+                            args.push('?');
                         }
-                    } while (this.peek().isType(Token.COLON));
-                    break;
-                case Token.L_PARENTHESES:
-                    this.consume(Token.L_PARENTHESES);
-                    while (this.peek().isNotType(Token.R_PARENTHESES)) {
-                        if (this.peek().isType(Token.CONDITIONAL)) {
-                            this.consume(Token.CONDITIONAL);
+                    }
+                    else {
+                        const arg = this.parseAssignmentExpressionCoverGrammar();
+                        if (isSpread) {
+                            args.push(new SpreadElement(arg));
+                        }
+                        else {
+                            args.push(arg);
+                        }
+                    }
+                } while (this.peek().isType(Token.COLON));
+                break;
+            case Token.L_PARENTHESES:
+                this.consume(Token.L_PARENTHESES);
+                let indexed = false;
+                while (this.peek().isNotType(Token.R_PARENTHESES)) {
+                    const isSpread = this.check(Token.ELLIPSIS);
+                    if (this.peek().isType(Token.CONDITIONAL)) {
+                        this.consume(Token.CONDITIONAL);
+                        indexed = true;
+                        if (isSpread) {
+                            args.push('...?');
+                        }
+                        else {
                             args.push('?');
                         }
+                    }
+                    else {
+                        const arg = this.parseAssignmentExpressionCoverGrammar();
+                        if (isSpread) {
+                            args.push(new SpreadElement(arg));
+                        }
                         else {
-                            args.push(this.parseLogicalExpression());
+                            args.push(arg);
                         }
                     }
-                    this.expect(Token.R_PARENTHESES);
-                    break;
-                default:
-                    break;
-            }
-            expression = new PipelineExpression(expression, func, args);
+                    this.check(Token.COMMA);
+                }
+                this.expect(Token.R_PARENTHESES);
+                if (!indexed) {
+                    body = new CallExpression(func, args);
+                    return new PipelineExpression(lhs, body);
+                }
+                break;
+            default:
+                break;
         }
-        return expression;
+        return new PipelineExpression(lhs, func, args);
     }
     parseConditionalExpression() {
         let expression = this.parseLogicalExpression();
@@ -1502,13 +1575,13 @@ export class JavaScriptParser extends AbstractParser {
                     if (Token.isPropertyOrCall(this.peek().token))
                         continue;
                     const key = this.parsePropertyName();
-                    result = new ChainExpression(result, key, 'property');
+                    result = new MemberExpression(result, key, false, isOptional);
                     break;
                 }
                 case Token.L_BRACKETS: {
                     this.consume(Token.L_BRACKETS);
                     const index = this.parseExpressionCoverGrammar();
-                    result = new MemberExpression(result, index, true);
+                    result = new MemberExpression(result, index, true, isOptional);
                     this.expect(Token.R_BRACKETS);
                     break;
                 }
@@ -1518,7 +1591,7 @@ export class JavaScriptParser extends AbstractParser {
                     }
                     this.consume(Token.PERIOD);
                     const key = this.parsePropertyName();
-                    result = new MemberExpression(result, key, false);
+                    result = new MemberExpression(result, key, false, isOptional);
                     break;
                 }
                 case Token.L_PARENTHESES: {
@@ -1526,7 +1599,27 @@ export class JavaScriptParser extends AbstractParser {
                     if (result.toString() === 'eval') {
                         throw new Error(this.errorMessage(`'eval(...)' is not supported.`));
                     }
-                    result = new CallExpression(result, args);
+                    result = new CallExpression(result, args, isOptional);
+                    break;
+                }
+                case Token.BIND: {
+                    if (isOptional) {
+                        throw new Error(this.errorMessage(`Unexpected Token:${this.position()}`));
+                    }
+                    this.consume(Token.BIND);
+                    const key = this.parsePropertyName();
+                    result = new BindExpression(result, key, false, isOptional);
+                    break;
+                }
+                case Token.QUESTION_BIND: {
+                    if (isOptional) {
+                        throw new Error(this.errorMessage(`Failure Expression`));
+                    }
+                    this.consume(Token.QUESTION_BIND);
+                    isOptional = true;
+                    optionalChaining = true;
+                    const key = this.parsePropertyName();
+                    result = new BindExpression(result, key, true, isOptional);
                     break;
                 }
                 default:
@@ -1540,6 +1633,9 @@ export class JavaScriptParser extends AbstractParser {
                 isOptional = false;
             }
         } while (Token.isPropertyOrCall(this.peek().token));
+        if (optionalChaining) {
+            result = new ChainExpression(result);
+        }
         return result;
     }
     parseAwaitExpression() {