@ibyar/expressions 0.8.2-dev.20221008 → 0.8.4

package/v8/inline.d.ts

@@ -1,34 +1,35 @@
-import type { ExpressionNode } from '../api/expression.js';
-import { Token, TokenExpression } from './token.js';
-import { TokenStream } from './stream.js';
+import type { DeclarationExpression, ExpressionNode } from '../api/expression.js';
+import type { NodeFactory } from './node.js';
+import { ClassDeclaration, ClassExpression } from '../api/class/class.js';
+import { FunctionDeclaration, FunctionExpression } from '../api/definition/function.js';
 import { Identifier, TaggedTemplateExpression, TemplateLiteral } from '../api/definition/values.js';
-import { EmptyStatement } from '../api/statement/control/empty.js';
 import { BlockStatement } from '../api/statement/control/block.js';
-import { Param, FunctionExpression, FunctionDeclaration } from '../api/definition/function.js';
-import { NewExpression } from '../api/computing/new.js';
-import { MemberExpression } from '../api/definition/member.js';
-import { ObjectExpression, Property } from '../api/definition/object.js';
-import { ArrayExpression, ArrayPattern } from '../api/definition/array.js';
-import { CallExpression } from '../api/computing/call.js';
 import { VariableDeclarationNode } from '../api/statement/declarations/declares.js';
-import { ForNode, ForOfNode, ForInNode, ForAwaitOfNode } from '../api/statement/iterations/for.js';
-import { ClassDeclaration, ClassExpression } from '../api/class/class.js';
 import { AllowLabelledFunctionStatement, FunctionBodyType, FunctionInfo, FunctionKind, FunctionSyntaxKind, ParseFunctionFlag, ParsingArrowHeadFlag, PropertyKindInfo, VariableDeclarationContext } from './enums.js';
-import { DebuggerStatement } from '../api/computing/debugger.js';
+import { TokenStream } from './stream.js';
+import { Token, TokenExpression } from './token.js';
 import { LanguageMode } from './language.js';
-export declare type InlineParserOptions = {
+export type InlineParserOptions = {
     mode?: LanguageMode;
     acceptIN?: boolean;
+    factory?: NodeFactory;
+    addLocation?: boolean;
+};
+export type Range = [number, number];
+export type RangeOrVoid = Range | undefined;
+export type PositionMark = {
+    range?: Range;
 };
 export declare abstract class AbstractParser {
     protected scanner: TokenStream;
+    protected factory: NodeFactory;
     protected acceptIN: boolean;
     protected previousAcceptIN: boolean[];
     protected functionKind: FunctionKind;
     protected previousFunctionKind: FunctionKind[];
     get languageMode(): LanguageMode;
     set languageMode(mode: LanguageMode);
-    constructor(scanner: TokenStream, acceptIN?: boolean);
+    constructor(scanner: TokenStream, factory: NodeFactory, acceptIN?: boolean);
     abstract scan(): ExpressionNode;
     protected position(): number;
     protected setAcceptIN(acceptIN: boolean): void;
@@ -44,28 +45,28 @@ export declare abstract class AbstractParser {
     protected peekAhead(): TokenExpression;
     protected peekAheadPosition(): number;
     protected peekPosition(): number;
-    protected consume(token: Token): void;
+    protected createRange(): undefined;
+    protected createRange(start: Required<PositionMark>): Range;
+    protected createRange(start?: PositionMark): RangeOrVoid;
+    protected createRangeByStart(start: Required<PositionMark>): Range;
+    protected createStartPosition(): Range;
+    protected updateRangeEnd(range: Range): void;
+    protected consume(token: Token): TokenExpression;
     protected check(token: Token): boolean;
     protected checkAndGetValue(token: Token): ExpressionNode | undefined;
     protected checkValue(value: ExpressionNode): boolean;
-    protected expect(token: Token): void;
+    protected expect(token: Token): TokenExpression;
     protected expectAndGetValue(token: Token): ExpressionNode;
     protected checkInOrOf(): 'IN' | 'OF' | false;
     protected peekInOrOf(): 'IN' | 'OF' | false;
-    protected isArguments(name: ExpressionNode): boolean;
-    protected isEval(name: ExpressionNode): boolean;
-    protected isEvalOrArguments(name: ExpressionNode): boolean;
+    protected isArguments(node: ExpressionNode): boolean;
+    protected isEval(node: ExpressionNode): boolean;
+    protected isEvalOrArguments(node: ExpressionNode): boolean;
     protected isNextLetKeyword(): boolean;
-    protected isIdentifier(expression: ExpressionNode): expression is Identifier;
     protected markParenthesized(expression: ExpressionNode): void;
     protected clearParenthesized(expression: ExpressionNode): void;
     protected isParenthesized(expression: ExpressionNode): boolean;
     protected isAssignableIdentifier(expression: ExpressionNode): boolean;
-    protected isPattern(expression: ExpressionNode): expression is (ObjectExpression | ArrayExpression);
-    protected isProperty(expression: ExpressionNode): expression is Property | MemberExpression;
-    protected isCallNew(expression: ExpressionNode): expression is NewExpression;
-    protected isCall(expression: ExpressionNode): expression is CallExpression;
-    protected isEmptyStatement(expression: ExpressionNode): expression is EmptyStatement;
     protected isValidReferenceExpression(expression: ExpressionNode): boolean;
     protected expectSemicolon(): void;
     protected peekAnyIdentifier(): boolean;
@@ -85,8 +86,8 @@ export declare abstract class AbstractParser {
     protected reportErrorMessage(message: string): void;
 }
 export declare class JavaScriptInlineParser extends AbstractParser {
-    static parse(source: string | TokenExpression[] | TokenStream, { mode, acceptIN }?: InlineParserOptions): ExpressionNode;
-    constructor(scanner: TokenStream, acceptIN?: boolean);
+    static parse(source: string | TokenExpression[] | TokenStream, { mode, acceptIN, factory, addLocation }?: InlineParserOptions): ExpressionNode;
+    constructor(scanner: TokenStream, factory: NodeFactory, acceptIN?: boolean);
     scan(): ExpressionNode;
     /**
      * Statement ::
@@ -107,7 +108,7 @@ export declare class JavaScriptInlineParser extends AbstractParser {
      * DebuggerStatement
      */
     protected parseStatement(allowFunction?: AllowLabelledFunctionStatement): ExpressionNode;
-    protected parseDebuggerStatement(): DebuggerStatement;
+    protected parseDebuggerStatement(): import("../index.js").DebuggerStatement;
     protected parseTryStatement(): ExpressionNode;
     protected parseNonRestrictedIdentifier(): Identifier;
     protected parseBlock(): BlockStatement;
@@ -131,19 +132,19 @@ export declare class JavaScriptInlineParser extends AbstractParser {
      */
     protected parseStatementListItem(): ExpressionNode | undefined;
     protected parseFunctionExpression(): FunctionExpression | FunctionDeclaration;
-    protected parseAsyncFunctionDeclaration(names: string[] | undefined, defaultExport: boolean): FunctionDeclaration;
+    protected parseAsyncFunctionDeclaration(names: string[] | undefined, defaultExport: boolean, start: PositionMark): FunctionDeclaration;
     protected parseIfStatement(): ExpressionNode;
     protected parseScopedStatement(): ExpressionNode;
     protected parseDoWhileStatement(): ExpressionNode;
-    protected parseWhileStatement(): ExpressionNode;
+    protected parseWhileStatement(): import("../index.js").WhileNode;
     protected parseThrowStatement(): ExpressionNode;
     protected parseSwitchStatement(): ExpressionNode;
-    protected parseForStatement(): ForNode | ForOfNode | ForInNode;
-    protected parseStandardForLoopWithLexicalDeclarations(initializer: VariableDeclarationNode): ForNode;
-    protected parseForEachStatementWithDeclarations(initializer: VariableDeclarationNode, forMode: 'IN' | 'OF'): ForOfNode | ForInNode;
-    protected parseForEachStatementWithoutDeclarations(initializer: ExpressionNode, forMode: 'IN' | 'OF'): ForOfNode | ForInNode;
-    protected parseStandardForLoop(initializer: ExpressionNode): ForNode;
-    protected parseForAwaitStatement(): ForAwaitOfNode;
+    protected parseForStatement(): import("../api/statement/iterations/for.js").ForNode | import("../api/statement/iterations/for.js").ForOfNode | import("../api/statement/iterations/for.js").ForInNode;
+    protected parseStandardForLoopWithLexicalDeclarations(initializer: VariableDeclarationNode, start: PositionMark): import("../api/statement/iterations/for.js").ForNode;
+    protected parseForEachStatementWithDeclarations(initializer: VariableDeclarationNode, forMode: 'IN' | 'OF', start: PositionMark): import("../api/statement/iterations/for.js").ForOfNode | import("../api/statement/iterations/for.js").ForInNode;
+    protected parseForEachStatementWithoutDeclarations(initializer: ExpressionNode, forMode: 'IN' | 'OF', start: PositionMark): import("../api/statement/iterations/for.js").ForOfNode | import("../api/statement/iterations/for.js").ForInNode;
+    protected parseStandardForLoop(initializer: ExpressionNode, start: PositionMark): import("../api/statement/iterations/for.js").ForNode;
+    protected parseForAwaitStatement(): import("../api/statement/iterations/for.js").ForAwaitOfNode;
     protected parseVariableDeclarations(varContext: VariableDeclarationContext): VariableDeclarationNode;
     protected parseBindingPattern(isPattern: boolean): ExpressionNode;
     protected parseAndClassifyIdentifier(next: TokenExpression): ExpressionNode;
@@ -154,34 +155,34 @@ export declare class JavaScriptInlineParser extends AbstractParser {
     protected parseExpression(): ExpressionNode;
     protected parseFunctionDeclaration(): FunctionDeclaration;
     protected parseAsyncFunctionLiteral(): FunctionExpression | FunctionDeclaration;
-    protected parseHoistableDeclaration(names: string[] | undefined, defaultExport: boolean): FunctionExpression | FunctionDeclaration;
-    protected parseHoistableDeclaration01(flag: FunctionKind, names: string[] | undefined, defaultExport: boolean): FunctionExpression | FunctionDeclaration;
+    protected parseHoistableDeclaration(names: string[] | undefined, defaultExport: boolean, start: PositionMark): FunctionExpression | FunctionDeclaration;
+    protected parseHoistableDeclaration01(flag: FunctionKind, names: string[] | undefined, defaultExport: boolean, start: PositionMark): FunctionExpression | FunctionDeclaration;
     protected parseIdentifier(kind?: FunctionKind): Identifier;
     protected getIdentifier(): Identifier;
-    protected parseFunctionLiteral(flag: FunctionKind, functionSyntaxKind: FunctionSyntaxKind, name?: Identifier): FunctionDeclaration | FunctionExpression;
+    protected parseFunctionLiteral(flag: FunctionKind, functionSyntaxKind: FunctionSyntaxKind, name: Identifier | undefined, start: PositionMark): FunctionDeclaration | FunctionExpression;
     protected parseFunctionBody(kind: FunctionKind, bodyType: FunctionBodyType.BLOCK, functionSyntaxKind: FunctionSyntaxKind): ExpressionNode[];
     protected parseFunctionBody(kind: FunctionKind, bodyType: FunctionBodyType.EXPRESSION, functionSyntaxKind: FunctionSyntaxKind): ExpressionNode;
     protected parseAndRewriteAsyncGeneratorFunctionBody(kind: FunctionKind): ExpressionNode[];
     protected parseAndRewriteGeneratorFunctionBody(kind: FunctionKind): ExpressionNode[];
     protected parseAsyncFunctionBody(): ExpressionNode[];
     protected parseStatementList(endToken: Token): ExpressionNode[];
-    protected parseFormalParameterList(functionInfo: FunctionInfo): ExpressionNode[];
-    protected parseFormalParameter(functionInfo: FunctionInfo): ExpressionNode;
+    protected parseFormalParameterList(functionInfo: FunctionInfo): DeclarationExpression[];
+    protected parseFormalParameter(functionInfo: FunctionInfo): DeclarationExpression;
     protected parseExpressionCoverGrammar(): ExpressionNode;
     protected parseArrowParametersWithRest(list: ExpressionNode[]): ExpressionNode;
     protected expressionListToExpression(list: ExpressionNode[]): ExpressionNode;
     protected parseMemberExpression(): ExpressionNode;
-    protected toParamNode(expression: ExpressionNode): Param;
     protected parsePrimaryExpression(): ExpressionNode;
     protected parseTemplateLiteral(tag?: ExpressionNode): ExpressionNode;
-    protected createTemplateLiteralExpressionNode(strings: string[], expressions: ExpressionNode[], tag?: ExpressionNode): TaggedTemplateExpression | TemplateLiteral;
+    protected createTemplateLiteralExpressionNode(strings: string[], expressions: ExpressionNode[], tag?: ExpressionNode, range?: RangeOrVoid): TaggedTemplateExpression | TemplateLiteral;
     protected parseMemberWithPresentNewPrefixesExpression(): ExpressionNode;
     protected parseArguments(maybeArrow?: ParsingArrowHeadFlag): ExpressionNode[];
     protected parseAssignmentExpressionCoverGrammar(): ExpressionNode;
     protected parseAssignmentExpression(): ExpressionNode;
-    protected parseArrowFunctionLiteral(parameters: ExpressionNode[], kind: FunctionKind): ExpressionNode;
+    private checkParamType;
+    protected parseArrowFunctionLiteral(parameters: DeclarationExpression[], kind: FunctionKind, range: Range): ExpressionNode;
     protected parseRegExpLiteral(): ExpressionNode;
-    protected parseArrayLiteral(isPattern: boolean): ArrayExpression | ArrayPattern;
+    protected parseArrayLiteral(isPattern: boolean): import("../index.js").ArrayExpression | import("../index.js").ArrayPattern;
     protected parsePossibleDestructuringSubPattern(): ExpressionNode;
     protected parseObjectLiteral(isPattern: boolean): ExpressionNode;
     protected parseObjectPropertyDefinition(isPattern: boolean): ExpressionNode;
@@ -205,10 +206,11 @@ export declare class JavaScriptInlineParser extends AbstractParser {
     protected parseNullishExpression(expression: ExpressionNode): ExpressionNode;
     protected parseConditionalContinuation(expression: ExpressionNode): ExpressionNode;
     protected parseYieldExpression(): ExpressionNode;
-    protected parseNewTargetExpression(): ExpressionNode;
+    protected parseNewTargetExpression(start?: PositionMark): ExpressionNode;
     protected parseClassExpression(): ClassExpression;
-    protected parseClassDeclaration(names: string[] | undefined, defaultExport: boolean): ClassDeclaration;
+    protected parseClassDeclaration(names: string[] | undefined, defaultExport: boolean, start: PositionMark): ClassDeclaration;
     protected parseClassLiteral(name: ExpressionNode | undefined, isStrictReserved: boolean): ExpressionNode;
     protected parseSuperExpression(): ExpressionNode;
     protected parseImportExpressions(): ExpressionNode;
+    protected parseWithStatement(): ExpressionNode;
 }