| "use strict"; |
| var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); |
| }) : (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| o[k2] = m[k]; |
| })); |
| var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { |
| Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| }) : function(o, v) { |
| o["default"] = v; |
| }); |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", { value: true }); |
| exports.Converter = exports.convertError = void 0; |
| // There's lots of funny stuff due to the typing of ts.Node |
| /* eslint-disable @typescript-eslint/no-explicit-any */ |
| const ts = __importStar(require("typescript")); |
| const node_utils_1 = require("./node-utils"); |
| const ts_estree_1 = require("./ts-estree"); |
| const version_check_1 = require("./version-check"); |
| const SyntaxKind = ts.SyntaxKind; |
| /** |
| * Extends and formats a given error object |
| * @param error the error object |
| * @returns converted error object |
| */ |
| function convertError(error) { |
| return node_utils_1.createError(error.file, error.start, error.message || error.messageText); |
| } |
| exports.convertError = convertError; |
| class Converter { |
| /** |
| * Converts a TypeScript node into an ESTree node |
| * @param ast the full TypeScript AST |
| * @param options additional options for the conversion |
| * @returns the converted ESTreeNode |
| */ |
| constructor(ast, options) { |
| this.esTreeNodeToTSNodeMap = new WeakMap(); |
| this.tsNodeToESTreeNodeMap = new WeakMap(); |
| this.allowPattern = false; |
| this.inTypeMode = false; |
| this.ast = ast; |
| this.options = Object.assign({}, options); |
| } |
| getASTMaps() { |
| return { |
| esTreeNodeToTSNodeMap: this.esTreeNodeToTSNodeMap, |
| tsNodeToESTreeNodeMap: this.tsNodeToESTreeNodeMap, |
| }; |
| } |
| convertProgram() { |
| return this.converter(this.ast); |
| } |
| /** |
| * Converts a TypeScript node into an ESTree node. |
| * @param node the child ts.Node |
| * @param parent parentNode |
| * @param inTypeMode flag to determine if we are in typeMode |
| * @param allowPattern flag to determine if patterns are allowed |
| * @returns the converted ESTree node |
| */ |
| converter(node, parent, inTypeMode, allowPattern) { |
| /** |
| * Exit early for null and undefined |
| */ |
| if (!node) { |
| return null; |
| } |
| const typeMode = this.inTypeMode; |
| const pattern = this.allowPattern; |
| if (inTypeMode !== undefined) { |
| this.inTypeMode = inTypeMode; |
| } |
| if (allowPattern !== undefined) { |
| this.allowPattern = allowPattern; |
| } |
| const result = this.convertNode(node, (parent !== null && parent !== void 0 ? parent : node.parent)); |
| this.registerTSNodeInNodeMap(node, result); |
| this.inTypeMode = typeMode; |
| this.allowPattern = pattern; |
| return result; |
| } |
| /** |
| * Fixes the exports of the given ts.Node |
| * @param node the ts.Node |
| * @param result result |
| * @returns the ESTreeNode with fixed exports |
| */ |
| fixExports(node, result) { |
| // check for exports |
| if (node.modifiers && node.modifiers[0].kind === SyntaxKind.ExportKeyword) { |
| /** |
| * Make sure that original node is registered instead of export |
| */ |
| this.registerTSNodeInNodeMap(node, result); |
| const exportKeyword = node.modifiers[0]; |
| const nextModifier = node.modifiers[1]; |
| const declarationIsDefault = nextModifier && nextModifier.kind === SyntaxKind.DefaultKeyword; |
| const varToken = declarationIsDefault |
| ? node_utils_1.findNextToken(nextModifier, this.ast, this.ast) |
| : node_utils_1.findNextToken(exportKeyword, this.ast, this.ast); |
| result.range[0] = varToken.getStart(this.ast); |
| result.loc = node_utils_1.getLocFor(result.range[0], result.range[1], this.ast); |
| if (declarationIsDefault) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ExportDefaultDeclaration, |
| declaration: result, |
| range: [exportKeyword.getStart(this.ast), result.range[1]], |
| exportKind: 'value', |
| }); |
| } |
| else { |
| const isType = result.type === ts_estree_1.AST_NODE_TYPES.TSInterfaceDeclaration || |
| result.type === ts_estree_1.AST_NODE_TYPES.TSTypeAliasDeclaration; |
| const isDeclare = result.declare === true; |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ExportNamedDeclaration, |
| declaration: result, |
| specifiers: [], |
| source: null, |
| exportKind: isType || isDeclare ? 'type' : 'value', |
| range: [exportKeyword.getStart(this.ast), result.range[1]], |
| }); |
| } |
| } |
| return result; |
| } |
| /** |
| * Register specific TypeScript node into map with first ESTree node provided |
| */ |
| registerTSNodeInNodeMap(node, result) { |
| if (result && this.options.shouldPreserveNodeMaps) { |
| if (!this.tsNodeToESTreeNodeMap.has(node)) { |
| this.tsNodeToESTreeNodeMap.set(node, result); |
| } |
| } |
| } |
| /** |
| * Converts a TypeScript node into an ESTree node. |
| * @param child the child ts.Node |
| * @param parent parentNode |
| * @returns the converted ESTree node |
| */ |
| convertPattern(child, parent) { |
| return this.converter(child, parent, this.inTypeMode, true); |
| } |
| /** |
| * Converts a TypeScript node into an ESTree node. |
| * @param child the child ts.Node |
| * @param parent parentNode |
| * @returns the converted ESTree node |
| */ |
| convertChild(child, parent) { |
| return this.converter(child, parent, this.inTypeMode, false); |
| } |
| /** |
| * Converts a TypeScript node into an ESTree node. |
| * @param child the child ts.Node |
| * @param parent parentNode |
| * @returns the converted ESTree node |
| */ |
| convertType(child, parent) { |
| return this.converter(child, parent, true, false); |
| } |
| createNode(node, data) { |
| const result = data; |
| if (!result.range) { |
| result.range = node_utils_1.getRange( |
| // this is completely valid, but TS hates it |
| node, this.ast); |
| } |
| if (!result.loc) { |
| result.loc = node_utils_1.getLocFor(result.range[0], result.range[1], this.ast); |
| } |
| if (result && this.options.shouldPreserveNodeMaps) { |
| this.esTreeNodeToTSNodeMap.set(result, node); |
| } |
| return result; |
| } |
| convertBindingNameWithTypeAnnotation(name, tsType, parent) { |
| const id = this.convertPattern(name); |
| if (tsType) { |
| id.typeAnnotation = this.convertTypeAnnotation(tsType, parent); |
| this.fixParentLocation(id, id.typeAnnotation.range); |
| } |
| return id; |
| } |
| /** |
| * Converts a child into a type annotation. This creates an intermediary |
| * TypeAnnotation node to match what Flow does. |
| * @param child The TypeScript AST node to convert. |
| * @param parent parentNode |
| * @returns The type annotation node. |
| */ |
| convertTypeAnnotation(child, parent) { |
| // in FunctionType and ConstructorType typeAnnotation has 2 characters `=>` and in other places is just colon |
| const offset = (parent === null || parent === void 0 ? void 0 : parent.kind) === SyntaxKind.FunctionType || |
| (parent === null || parent === void 0 ? void 0 : parent.kind) === SyntaxKind.ConstructorType |
| ? 2 |
| : 1; |
| const annotationStartCol = child.getFullStart() - offset; |
| const loc = node_utils_1.getLocFor(annotationStartCol, child.end, this.ast); |
| return { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypeAnnotation, |
| loc, |
| range: [annotationStartCol, child.end], |
| typeAnnotation: this.convertType(child), |
| }; |
| } |
| /** |
| * Coverts body Nodes and add a directive field to StringLiterals |
| * @param nodes of ts.Node |
| * @param parent parentNode |
| * @returns Array of body statements |
| */ |
| convertBodyExpressions(nodes, parent) { |
| let allowDirectives = node_utils_1.canContainDirective(parent); |
| return (nodes |
| .map(statement => { |
| const child = this.convertChild(statement); |
| if (allowDirectives) { |
| if ((child === null || child === void 0 ? void 0 : child.expression) && |
| ts.isExpressionStatement(statement) && |
| ts.isStringLiteral(statement.expression)) { |
| const raw = child.expression.raw; |
| child.directive = raw.slice(1, -1); |
| return child; // child can be null, but it's filtered below |
| } |
| else { |
| allowDirectives = false; |
| } |
| } |
| return child; // child can be null, but it's filtered below |
| }) |
| // filter out unknown nodes for now |
| .filter(statement => statement)); |
| } |
| /** |
| * Converts a ts.Node's typeArguments to TSTypeParameterInstantiation node |
| * @param typeArguments ts.NodeArray typeArguments |
| * @param node parent used to create this node |
| * @returns TypeParameterInstantiation node |
| */ |
| convertTypeArgumentsToTypeParameters(typeArguments, node) { |
| const greaterThanToken = node_utils_1.findNextToken(typeArguments, this.ast, this.ast); |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypeParameterInstantiation, |
| range: [typeArguments.pos - 1, greaterThanToken.end], |
| params: typeArguments.map(typeArgument => this.convertType(typeArgument)), |
| }); |
| } |
| /** |
| * Converts a ts.Node's typeParameters to TSTypeParameterDeclaration node |
| * @param typeParameters ts.Node typeParameters |
| * @returns TypeParameterDeclaration node |
| */ |
| convertTSTypeParametersToTypeParametersDeclaration(typeParameters) { |
| const greaterThanToken = node_utils_1.findNextToken(typeParameters, this.ast, this.ast); |
| return { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypeParameterDeclaration, |
| range: [typeParameters.pos - 1, greaterThanToken.end], |
| loc: node_utils_1.getLocFor(typeParameters.pos - 1, greaterThanToken.end, this.ast), |
| params: typeParameters.map(typeParameter => this.convertType(typeParameter)), |
| }; |
| } |
| /** |
| * Converts an array of ts.Node parameters into an array of ESTreeNode params |
| * @param parameters An array of ts.Node params to be converted |
| * @returns an array of converted ESTreeNode params |
| */ |
| convertParameters(parameters) { |
| if (!parameters || !parameters.length) { |
| return []; |
| } |
| return parameters.map(param => { |
| var _a; |
| const convertedParam = this.convertChild(param); |
| if ((_a = param.decorators) === null || _a === void 0 ? void 0 : _a.length) { |
| convertedParam.decorators = param.decorators.map(el => this.convertChild(el)); |
| } |
| return convertedParam; |
| }); |
| } |
| convertChainExpression(node, tsNode) { |
| const { child, isOptional } = (() => { |
| if (node.type === ts_estree_1.AST_NODE_TYPES.MemberExpression) { |
| return { child: node.object, isOptional: node.optional }; |
| } |
| if (node.type === ts_estree_1.AST_NODE_TYPES.CallExpression) { |
| return { child: node.callee, isOptional: node.optional }; |
| } |
| return { child: node.expression, isOptional: false }; |
| })(); |
| const isChildUnwrappable = node_utils_1.isChildUnwrappableOptionalChain(tsNode, child); |
| if (!isChildUnwrappable && !isOptional) { |
| return node; |
| } |
| if (isChildUnwrappable && node_utils_1.isChainExpression(child)) { |
| // unwrap the chain expression child |
| const newChild = child.expression; |
| if (node.type === ts_estree_1.AST_NODE_TYPES.MemberExpression) { |
| node.object = newChild; |
| } |
| else if (node.type === ts_estree_1.AST_NODE_TYPES.CallExpression) { |
| node.callee = newChild; |
| } |
| else { |
| node.expression = newChild; |
| } |
| } |
| return this.createNode(tsNode, { |
| type: ts_estree_1.AST_NODE_TYPES.ChainExpression, |
| expression: node, |
| }); |
| } |
| /** |
| * For nodes that are copied directly from the TypeScript AST into |
| * ESTree mostly as-is. The only difference is the addition of a type |
| * property instead of a kind property. Recursively copies all children. |
| */ |
| deeplyCopy(node) { |
| if (node.kind === ts.SyntaxKind.JSDocFunctionType) { |
| throw node_utils_1.createError(this.ast, node.pos, 'JSDoc types can only be used inside documentation comments.'); |
| } |
| const customType = `TS${SyntaxKind[node.kind]}`; |
| /** |
| * If the "errorOnUnknownASTType" option is set to true, throw an error, |
| * otherwise fallback to just including the unknown type as-is. |
| */ |
| if (this.options.errorOnUnknownASTType && !ts_estree_1.AST_NODE_TYPES[customType]) { |
| throw new Error(`Unknown AST_NODE_TYPE: "${customType}"`); |
| } |
| const result = this.createNode(node, { |
| type: customType, |
| }); |
| if ('type' in node) { |
| result.typeAnnotation = |
| node.type && 'kind' in node.type && ts.isTypeNode(node.type) |
| ? this.convertTypeAnnotation(node.type, node) |
| : null; |
| } |
| if ('typeArguments' in node) { |
| result.typeParameters = |
| node.typeArguments && 'pos' in node.typeArguments |
| ? this.convertTypeArgumentsToTypeParameters(node.typeArguments, node) |
| : null; |
| } |
| if ('typeParameters' in node) { |
| result.typeParameters = |
| node.typeParameters && 'pos' in node.typeParameters |
| ? this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters) |
| : null; |
| } |
| if ('decorators' in node && node.decorators && node.decorators.length) { |
| result.decorators = node.decorators.map(el => this.convertChild(el)); |
| } |
| Object.entries(node) |
| .filter(([key]) => !/^(?:_children|kind|parent|pos|end|flags|modifierFlagsCache|jsDoc|type|typeArguments|typeParameters|decorators)$/.test(key)) |
| .forEach(([key, value]) => { |
| if (Array.isArray(value)) { |
| result[key] = value.map(el => this.convertChild(el)); |
| } |
| else if (value && typeof value === 'object' && value.kind) { |
| // need to check node[key].kind to ensure we don't try to convert a symbol |
| result[key] = this.convertChild(value); |
| } |
| else { |
| result[key] = value; |
| } |
| }); |
| return result; |
| } |
| /** |
| * Converts a TypeScript JSX node.tagName into an ESTree node.name |
| * @param node the tagName object from a JSX ts.Node |
| * @param parent |
| * @returns the converted ESTree name object |
| */ |
| convertJSXTagName(node, parent) { |
| let result; |
| switch (node.kind) { |
| case SyntaxKind.PropertyAccessExpression: |
| if (node.name.kind === SyntaxKind.PrivateIdentifier) { |
| // This is one of the few times where TS explicitly errors, and doesn't even gracefully handle the syntax. |
| // So we shouldn't ever get into this state to begin with. |
| throw new Error('Non-private identifier expected.'); |
| } |
| result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXMemberExpression, |
| object: this.convertJSXTagName(node.expression, parent), |
| property: this.convertJSXTagName(node.name, parent), |
| }); |
| break; |
| case SyntaxKind.ThisKeyword: |
| result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXIdentifier, |
| name: 'this', |
| }); |
| break; |
| case SyntaxKind.Identifier: |
| default: |
| result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXIdentifier, |
| name: node.text, |
| }); |
| break; |
| } |
| this.registerTSNodeInNodeMap(node, result); |
| return result; |
| } |
| /** |
| * Applies the given TS modifiers to the given result object. |
| * @param result |
| * @param modifiers original ts.Nodes from the node.modifiers array |
| * @returns the current result object will be mutated |
| * @deprecated This method adds not standardized `modifiers` property in nodes |
| */ |
| applyModifiersToResult(result, modifiers) { |
| if (!modifiers || !modifiers.length) { |
| return; |
| } |
| /** |
| * Some modifiers are explicitly handled by applying them as |
| * boolean values on the result node. As well as adding them |
| * to the result, we remove them from the array, so that they |
| * are not handled twice. |
| */ |
| const handledModifierIndices = {}; |
| for (let i = 0; i < modifiers.length; i++) { |
| const modifier = modifiers[i]; |
| switch (modifier.kind) { |
| /** |
| * Ignore ExportKeyword and DefaultKeyword, they are handled |
| * via the fixExports utility function |
| */ |
| case SyntaxKind.ExportKeyword: |
| case SyntaxKind.DefaultKeyword: |
| handledModifierIndices[i] = true; |
| break; |
| case SyntaxKind.ConstKeyword: |
| result.const = true; |
| handledModifierIndices[i] = true; |
| break; |
| case SyntaxKind.DeclareKeyword: |
| result.declare = true; |
| handledModifierIndices[i] = true; |
| break; |
| default: |
| } |
| } |
| /** |
| * If there are still valid modifiers available which have |
| * not been explicitly handled above, we just convert and |
| * add the modifiers array to the result node. |
| */ |
| const remainingModifiers = modifiers.filter((_, i) => !handledModifierIndices[i]); |
| if (!remainingModifiers || !remainingModifiers.length) { |
| return; |
| } |
| result.modifiers = remainingModifiers.map(el => this.convertChild(el)); |
| } |
| /** |
| * Uses the provided range location to adjust the location data of the given Node |
| * @param result The node that will have its location data mutated |
| * @param childRange The child node range used to expand location |
| */ |
| fixParentLocation(result, childRange) { |
| if (childRange[0] < result.range[0]) { |
| result.range[0] = childRange[0]; |
| result.loc.start = node_utils_1.getLineAndCharacterFor(result.range[0], this.ast); |
| } |
| if (childRange[1] > result.range[1]) { |
| result.range[1] = childRange[1]; |
| result.loc.end = node_utils_1.getLineAndCharacterFor(result.range[1], this.ast); |
| } |
| } |
| /** |
| * Converts a TypeScript node into an ESTree node. |
| * The core of the conversion logic: |
| * Identify and convert each relevant TypeScript SyntaxKind |
| * @param node the child ts.Node |
| * @param parent parentNode |
| * @returns the converted ESTree node |
| */ |
| convertNode(node, parent) { |
| var _a, _b, _c, _d, _e, _f, _g, _h, _j; |
| switch (node.kind) { |
| case SyntaxKind.SourceFile: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Program, |
| body: this.convertBodyExpressions(node.statements, node), |
| sourceType: node.externalModuleIndicator ? 'module' : 'script', |
| range: [node.getStart(this.ast), node.endOfFileToken.end], |
| }); |
| } |
| case SyntaxKind.Block: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.BlockStatement, |
| body: this.convertBodyExpressions(node.statements, node), |
| }); |
| } |
| case SyntaxKind.Identifier: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Identifier, |
| name: node.text, |
| }); |
| } |
| case SyntaxKind.WithStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.WithStatement, |
| object: this.convertChild(node.expression), |
| body: this.convertChild(node.statement), |
| }); |
| // Control Flow |
| case SyntaxKind.ReturnStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ReturnStatement, |
| argument: this.convertChild(node.expression), |
| }); |
| case SyntaxKind.LabeledStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.LabeledStatement, |
| label: this.convertChild(node.label), |
| body: this.convertChild(node.statement), |
| }); |
| case SyntaxKind.ContinueStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ContinueStatement, |
| label: this.convertChild(node.label), |
| }); |
| case SyntaxKind.BreakStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.BreakStatement, |
| label: this.convertChild(node.label), |
| }); |
| // Choice |
| case SyntaxKind.IfStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.IfStatement, |
| test: this.convertChild(node.expression), |
| consequent: this.convertChild(node.thenStatement), |
| alternate: this.convertChild(node.elseStatement), |
| }); |
| case SyntaxKind.SwitchStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.SwitchStatement, |
| discriminant: this.convertChild(node.expression), |
| cases: node.caseBlock.clauses.map(el => this.convertChild(el)), |
| }); |
| case SyntaxKind.CaseClause: |
| case SyntaxKind.DefaultClause: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.SwitchCase, |
| // expression is present in case only |
| test: node.kind === SyntaxKind.CaseClause |
| ? this.convertChild(node.expression) |
| : null, |
| consequent: node.statements.map(el => this.convertChild(el)), |
| }); |
| // Exceptions |
| case SyntaxKind.ThrowStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ThrowStatement, |
| argument: this.convertChild(node.expression), |
| }); |
| case SyntaxKind.TryStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TryStatement, |
| block: this.convertChild(node.tryBlock), |
| handler: this.convertChild(node.catchClause), |
| finalizer: this.convertChild(node.finallyBlock), |
| }); |
| case SyntaxKind.CatchClause: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.CatchClause, |
| param: node.variableDeclaration |
| ? this.convertBindingNameWithTypeAnnotation(node.variableDeclaration.name, node.variableDeclaration.type) |
| : null, |
| body: this.convertChild(node.block), |
| }); |
| // Loops |
| case SyntaxKind.WhileStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.WhileStatement, |
| test: this.convertChild(node.expression), |
| body: this.convertChild(node.statement), |
| }); |
| /** |
| * Unlike other parsers, TypeScript calls a "DoWhileStatement" |
| * a "DoStatement" |
| */ |
| case SyntaxKind.DoStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.DoWhileStatement, |
| test: this.convertChild(node.expression), |
| body: this.convertChild(node.statement), |
| }); |
| case SyntaxKind.ForStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ForStatement, |
| init: this.convertChild(node.initializer), |
| test: this.convertChild(node.condition), |
| update: this.convertChild(node.incrementor), |
| body: this.convertChild(node.statement), |
| }); |
| case SyntaxKind.ForInStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ForInStatement, |
| left: this.convertPattern(node.initializer), |
| right: this.convertChild(node.expression), |
| body: this.convertChild(node.statement), |
| }); |
| case SyntaxKind.ForOfStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ForOfStatement, |
| left: this.convertPattern(node.initializer), |
| right: this.convertChild(node.expression), |
| body: this.convertChild(node.statement), |
| await: Boolean(node.awaitModifier && |
| node.awaitModifier.kind === SyntaxKind.AwaitKeyword), |
| }); |
| // Declarations |
| case SyntaxKind.FunctionDeclaration: { |
| const isDeclare = node_utils_1.hasModifier(SyntaxKind.DeclareKeyword, node); |
| const result = this.createNode(node, { |
| type: isDeclare || !node.body |
| ? ts_estree_1.AST_NODE_TYPES.TSDeclareFunction |
| : ts_estree_1.AST_NODE_TYPES.FunctionDeclaration, |
| id: this.convertChild(node.name), |
| generator: !!node.asteriskToken, |
| expression: false, |
| async: node_utils_1.hasModifier(SyntaxKind.AsyncKeyword, node), |
| params: this.convertParameters(node.parameters), |
| body: this.convertChild(node.body) || undefined, |
| }); |
| // Process returnType |
| if (node.type) { |
| result.returnType = this.convertTypeAnnotation(node.type, node); |
| } |
| if (isDeclare) { |
| result.declare = true; |
| } |
| // Process typeParameters |
| if (node.typeParameters) { |
| result.typeParameters = this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters); |
| } |
| // check for exports |
| return this.fixExports(node, result); |
| } |
| case SyntaxKind.VariableDeclaration: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.VariableDeclarator, |
| id: this.convertBindingNameWithTypeAnnotation(node.name, node.type, node), |
| init: this.convertChild(node.initializer), |
| }); |
| if (node.exclamationToken) { |
| result.definite = true; |
| } |
| return result; |
| } |
| case SyntaxKind.VariableStatement: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.VariableDeclaration, |
| declarations: node.declarationList.declarations.map(el => this.convertChild(el)), |
| kind: node_utils_1.getDeclarationKind(node.declarationList), |
| }); |
| /** |
| * Semantically, decorators are not allowed on variable declarations, |
| * but the TypeScript compiler will parse them and produce a valid AST, |
| * so we handle them here too. |
| */ |
| if (node.decorators) { |
| result.decorators = node.decorators.map(el => this.convertChild(el)); |
| } |
| if (node_utils_1.hasModifier(SyntaxKind.DeclareKeyword, node)) { |
| result.declare = true; |
| } |
| // check for exports |
| return this.fixExports(node, result); |
| } |
| // mostly for for-of, for-in |
| case SyntaxKind.VariableDeclarationList: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.VariableDeclaration, |
| declarations: node.declarations.map(el => this.convertChild(el)), |
| kind: node_utils_1.getDeclarationKind(node), |
| }); |
| // Expressions |
| case SyntaxKind.ExpressionStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ExpressionStatement, |
| expression: this.convertChild(node.expression), |
| }); |
| case SyntaxKind.ThisKeyword: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ThisExpression, |
| }); |
| case SyntaxKind.ArrayLiteralExpression: { |
| // TypeScript uses ArrayLiteralExpression in destructuring assignment, too |
| if (this.allowPattern) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ArrayPattern, |
| elements: node.elements.map(el => this.convertPattern(el)), |
| }); |
| } |
| else { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ArrayExpression, |
| elements: node.elements.map(el => this.convertChild(el)), |
| }); |
| } |
| } |
| case SyntaxKind.ObjectLiteralExpression: { |
| // TypeScript uses ObjectLiteralExpression in destructuring assignment, too |
| if (this.allowPattern) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ObjectPattern, |
| properties: node.properties.map(el => this.convertPattern(el)), |
| }); |
| } |
| else { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ObjectExpression, |
| properties: node.properties.map(el => this.convertChild(el)), |
| }); |
| } |
| } |
| case SyntaxKind.PropertyAssignment: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Property, |
| key: this.convertChild(node.name), |
| value: this.converter(node.initializer, node, this.inTypeMode, this.allowPattern), |
| computed: node_utils_1.isComputedProperty(node.name), |
| method: false, |
| shorthand: false, |
| kind: 'init', |
| }); |
| case SyntaxKind.ShorthandPropertyAssignment: { |
| if (node.objectAssignmentInitializer) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Property, |
| key: this.convertChild(node.name), |
| value: this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.AssignmentPattern, |
| left: this.convertPattern(node.name), |
| right: this.convertChild(node.objectAssignmentInitializer), |
| }), |
| computed: false, |
| method: false, |
| shorthand: true, |
| kind: 'init', |
| }); |
| } |
| else { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Property, |
| key: this.convertChild(node.name), |
| value: this.convertChild(node.name), |
| computed: false, |
| method: false, |
| shorthand: true, |
| kind: 'init', |
| }); |
| } |
| } |
| case SyntaxKind.ComputedPropertyName: |
| return this.convertChild(node.expression); |
| case SyntaxKind.PropertyDeclaration: { |
| const isAbstract = node_utils_1.hasModifier(SyntaxKind.AbstractKeyword, node); |
| const result = this.createNode(node, { |
| type: isAbstract |
| ? ts_estree_1.AST_NODE_TYPES.TSAbstractClassProperty |
| : ts_estree_1.AST_NODE_TYPES.ClassProperty, |
| key: this.convertChild(node.name), |
| value: this.convertChild(node.initializer), |
| computed: node_utils_1.isComputedProperty(node.name), |
| static: node_utils_1.hasModifier(SyntaxKind.StaticKeyword, node), |
| readonly: node_utils_1.hasModifier(SyntaxKind.ReadonlyKeyword, node) || undefined, |
| declare: node_utils_1.hasModifier(SyntaxKind.DeclareKeyword, node), |
| }); |
| if (node.type) { |
| result.typeAnnotation = this.convertTypeAnnotation(node.type, node); |
| } |
| if (node.decorators) { |
| result.decorators = node.decorators.map(el => this.convertChild(el)); |
| } |
| const accessibility = node_utils_1.getTSNodeAccessibility(node); |
| if (accessibility) { |
| result.accessibility = accessibility; |
| } |
| if ((node.name.kind === SyntaxKind.Identifier || |
| node.name.kind === SyntaxKind.ComputedPropertyName) && |
| node.questionToken) { |
| result.optional = true; |
| } |
| if (node.exclamationToken) { |
| result.definite = true; |
| } |
| if (result.key.type === ts_estree_1.AST_NODE_TYPES.Literal && node.questionToken) { |
| result.optional = true; |
| } |
| return result; |
| } |
| case SyntaxKind.GetAccessor: |
| case SyntaxKind.SetAccessor: |
| case SyntaxKind.MethodDeclaration: { |
| const method = this.createNode(node, { |
| type: !node.body |
| ? ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression |
| : ts_estree_1.AST_NODE_TYPES.FunctionExpression, |
| id: null, |
| generator: !!node.asteriskToken, |
| expression: false, |
| async: node_utils_1.hasModifier(SyntaxKind.AsyncKeyword, node), |
| body: this.convertChild(node.body), |
| range: [node.parameters.pos - 1, node.end], |
| params: [], |
| }); |
| if (node.type) { |
| method.returnType = this.convertTypeAnnotation(node.type, node); |
| } |
| // Process typeParameters |
| if (node.typeParameters) { |
| method.typeParameters = this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters); |
| this.fixParentLocation(method, method.typeParameters.range); |
| } |
| let result; |
| if (parent.kind === SyntaxKind.ObjectLiteralExpression) { |
| method.params = node.parameters.map(el => this.convertChild(el)); |
| result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Property, |
| key: this.convertChild(node.name), |
| value: method, |
| computed: node_utils_1.isComputedProperty(node.name), |
| method: node.kind === SyntaxKind.MethodDeclaration, |
| shorthand: false, |
| kind: 'init', |
| }); |
| } |
| else { |
| // class |
| /** |
| * Unlike in object literal methods, class method params can have decorators |
| */ |
| method.params = this.convertParameters(node.parameters); |
| /** |
| * TypeScript class methods can be defined as "abstract" |
| */ |
| const methodDefinitionType = node_utils_1.hasModifier(SyntaxKind.AbstractKeyword, node) |
| ? ts_estree_1.AST_NODE_TYPES.TSAbstractMethodDefinition |
| : ts_estree_1.AST_NODE_TYPES.MethodDefinition; |
| result = this.createNode(node, { |
| type: methodDefinitionType, |
| key: this.convertChild(node.name), |
| value: method, |
| computed: node_utils_1.isComputedProperty(node.name), |
| static: node_utils_1.hasModifier(SyntaxKind.StaticKeyword, node), |
| kind: 'method', |
| }); |
| if (node.decorators) { |
| result.decorators = node.decorators.map(el => this.convertChild(el)); |
| } |
| const accessibility = node_utils_1.getTSNodeAccessibility(node); |
| if (accessibility) { |
| result.accessibility = accessibility; |
| } |
| } |
| if (node.questionToken) { |
| result.optional = true; |
| } |
| if (node.kind === SyntaxKind.GetAccessor) { |
| result.kind = 'get'; |
| } |
| else if (node.kind === SyntaxKind.SetAccessor) { |
| result.kind = 'set'; |
| } |
| else if (!result.static && |
| node.name.kind === SyntaxKind.StringLiteral && |
| node.name.text === 'constructor' && |
| result.type !== ts_estree_1.AST_NODE_TYPES.Property) { |
| result.kind = 'constructor'; |
| } |
| return result; |
| } |
| // TypeScript uses this even for static methods named "constructor" |
| case SyntaxKind.Constructor: { |
| const lastModifier = node_utils_1.getLastModifier(node); |
| const constructorToken = (lastModifier && node_utils_1.findNextToken(lastModifier, node, this.ast)) || |
| node.getFirstToken(); |
| const constructor = this.createNode(node, { |
| type: !node.body |
| ? ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression |
| : ts_estree_1.AST_NODE_TYPES.FunctionExpression, |
| id: null, |
| params: this.convertParameters(node.parameters), |
| generator: false, |
| expression: false, |
| async: false, |
| body: this.convertChild(node.body), |
| range: [node.parameters.pos - 1, node.end], |
| }); |
| // Process typeParameters |
| if (node.typeParameters) { |
| constructor.typeParameters = this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters); |
| this.fixParentLocation(constructor, constructor.typeParameters.range); |
| } |
| // Process returnType |
| if (node.type) { |
| constructor.returnType = this.convertTypeAnnotation(node.type, node); |
| } |
| const constructorKey = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Identifier, |
| name: 'constructor', |
| range: [constructorToken.getStart(this.ast), constructorToken.end], |
| }); |
| const isStatic = node_utils_1.hasModifier(SyntaxKind.StaticKeyword, node); |
| const result = this.createNode(node, { |
| type: node_utils_1.hasModifier(SyntaxKind.AbstractKeyword, node) |
| ? ts_estree_1.AST_NODE_TYPES.TSAbstractMethodDefinition |
| : ts_estree_1.AST_NODE_TYPES.MethodDefinition, |
| key: constructorKey, |
| value: constructor, |
| computed: false, |
| static: isStatic, |
| kind: isStatic ? 'method' : 'constructor', |
| }); |
| const accessibility = node_utils_1.getTSNodeAccessibility(node); |
| if (accessibility) { |
| result.accessibility = accessibility; |
| } |
| return result; |
| } |
| case SyntaxKind.FunctionExpression: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.FunctionExpression, |
| id: this.convertChild(node.name), |
| generator: !!node.asteriskToken, |
| params: this.convertParameters(node.parameters), |
| body: this.convertChild(node.body), |
| async: node_utils_1.hasModifier(SyntaxKind.AsyncKeyword, node), |
| expression: false, |
| }); |
| // Process returnType |
| if (node.type) { |
| result.returnType = this.convertTypeAnnotation(node.type, node); |
| } |
| // Process typeParameters |
| if (node.typeParameters) { |
| result.typeParameters = this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters); |
| } |
| return result; |
| } |
| case SyntaxKind.SuperKeyword: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Super, |
| }); |
| case SyntaxKind.ArrayBindingPattern: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ArrayPattern, |
| elements: node.elements.map(el => this.convertPattern(el)), |
| }); |
| // occurs with missing array elements like [,] |
| case SyntaxKind.OmittedExpression: |
| return null; |
| case SyntaxKind.ObjectBindingPattern: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ObjectPattern, |
| properties: node.elements.map(el => this.convertPattern(el)), |
| }); |
| case SyntaxKind.BindingElement: { |
| if (parent.kind === SyntaxKind.ArrayBindingPattern) { |
| const arrayItem = this.convertChild(node.name, parent); |
| if (node.initializer) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.AssignmentPattern, |
| left: arrayItem, |
| right: this.convertChild(node.initializer), |
| }); |
| } |
| else if (node.dotDotDotToken) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.RestElement, |
| argument: arrayItem, |
| }); |
| } |
| else { |
| return arrayItem; |
| } |
| } |
| else { |
| let result; |
| if (node.dotDotDotToken) { |
| result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.RestElement, |
| argument: this.convertChild((_a = node.propertyName) !== null && _a !== void 0 ? _a : node.name), |
| }); |
| } |
| else { |
| result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Property, |
| key: this.convertChild((_b = node.propertyName) !== null && _b !== void 0 ? _b : node.name), |
| value: this.convertChild(node.name), |
| computed: Boolean(node.propertyName && |
| node.propertyName.kind === SyntaxKind.ComputedPropertyName), |
| method: false, |
| shorthand: !node.propertyName, |
| kind: 'init', |
| }); |
| } |
| if (node.initializer) { |
| result.value = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.AssignmentPattern, |
| left: this.convertChild(node.name), |
| right: this.convertChild(node.initializer), |
| range: [node.name.getStart(this.ast), node.initializer.end], |
| }); |
| } |
| return result; |
| } |
| } |
| case SyntaxKind.ArrowFunction: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ArrowFunctionExpression, |
| generator: false, |
| id: null, |
| params: this.convertParameters(node.parameters), |
| body: this.convertChild(node.body), |
| async: node_utils_1.hasModifier(SyntaxKind.AsyncKeyword, node), |
| expression: node.body.kind !== SyntaxKind.Block, |
| }); |
| // Process returnType |
| if (node.type) { |
| result.returnType = this.convertTypeAnnotation(node.type, node); |
| } |
| // Process typeParameters |
| if (node.typeParameters) { |
| result.typeParameters = this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters); |
| } |
| return result; |
| } |
| case SyntaxKind.YieldExpression: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.YieldExpression, |
| delegate: !!node.asteriskToken, |
| argument: this.convertChild(node.expression), |
| }); |
| case SyntaxKind.AwaitExpression: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.AwaitExpression, |
| argument: this.convertChild(node.expression), |
| }); |
| // Template Literals |
| case SyntaxKind.NoSubstitutionTemplateLiteral: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TemplateLiteral, |
| quasis: [ |
| this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TemplateElement, |
| value: { |
| raw: this.ast.text.slice(node.getStart(this.ast) + 1, node.end - 1), |
| cooked: node.text, |
| }, |
| tail: true, |
| }), |
| ], |
| expressions: [], |
| }); |
| case SyntaxKind.TemplateExpression: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TemplateLiteral, |
| quasis: [this.convertChild(node.head)], |
| expressions: [], |
| }); |
| node.templateSpans.forEach(templateSpan => { |
| result.expressions.push(this.convertChild(templateSpan.expression)); |
| result.quasis.push(this.convertChild(templateSpan.literal)); |
| }); |
| return result; |
| } |
| case SyntaxKind.TaggedTemplateExpression: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TaggedTemplateExpression, |
| typeParameters: node.typeArguments |
| ? this.convertTypeArgumentsToTypeParameters(node.typeArguments, node) |
| : undefined, |
| tag: this.convertChild(node.tag), |
| quasi: this.convertChild(node.template), |
| }); |
| case SyntaxKind.TemplateHead: |
| case SyntaxKind.TemplateMiddle: |
| case SyntaxKind.TemplateTail: { |
| const tail = node.kind === SyntaxKind.TemplateTail; |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TemplateElement, |
| value: { |
| raw: this.ast.text.slice(node.getStart(this.ast) + 1, node.end - (tail ? 1 : 2)), |
| cooked: node.text, |
| }, |
| tail, |
| }); |
| } |
| // Patterns |
| case SyntaxKind.SpreadAssignment: |
| case SyntaxKind.SpreadElement: { |
| if (this.allowPattern) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.RestElement, |
| argument: this.convertPattern(node.expression), |
| }); |
| } |
| else { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.SpreadElement, |
| argument: this.convertChild(node.expression), |
| }); |
| } |
| } |
| case SyntaxKind.Parameter: { |
| let parameter; |
| let result; |
| if (node.dotDotDotToken) { |
| parameter = result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.RestElement, |
| argument: this.convertChild(node.name), |
| }); |
| } |
| else if (node.initializer) { |
| parameter = this.convertChild(node.name); |
| result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.AssignmentPattern, |
| left: parameter, |
| right: this.convertChild(node.initializer), |
| }); |
| if (node.modifiers) { |
| // AssignmentPattern should not contain modifiers in range |
| result.range[0] = parameter.range[0]; |
| result.loc = node_utils_1.getLocFor(result.range[0], result.range[1], this.ast); |
| } |
| } |
| else { |
| parameter = result = this.convertChild(node.name, parent); |
| } |
| if (node.type) { |
| parameter.typeAnnotation = this.convertTypeAnnotation(node.type, node); |
| this.fixParentLocation(parameter, parameter.typeAnnotation.range); |
| } |
| if (node.questionToken) { |
| if (node.questionToken.end > parameter.range[1]) { |
| parameter.range[1] = node.questionToken.end; |
| parameter.loc.end = node_utils_1.getLineAndCharacterFor(parameter.range[1], this.ast); |
| } |
| parameter.optional = true; |
| } |
| if (node.modifiers) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSParameterProperty, |
| accessibility: (_c = node_utils_1.getTSNodeAccessibility(node)) !== null && _c !== void 0 ? _c : undefined, |
| readonly: node_utils_1.hasModifier(SyntaxKind.ReadonlyKeyword, node) || undefined, |
| static: node_utils_1.hasModifier(SyntaxKind.StaticKeyword, node) || undefined, |
| export: node_utils_1.hasModifier(SyntaxKind.ExportKeyword, node) || undefined, |
| parameter: result, |
| }); |
| } |
| return result; |
| } |
| // Classes |
| case SyntaxKind.ClassDeclaration: |
| case SyntaxKind.ClassExpression: { |
| const heritageClauses = (_d = node.heritageClauses) !== null && _d !== void 0 ? _d : []; |
| const classNodeType = node.kind === SyntaxKind.ClassDeclaration |
| ? ts_estree_1.AST_NODE_TYPES.ClassDeclaration |
| : ts_estree_1.AST_NODE_TYPES.ClassExpression; |
| const superClass = heritageClauses.find(clause => clause.token === SyntaxKind.ExtendsKeyword); |
| const implementsClause = heritageClauses.find(clause => clause.token === SyntaxKind.ImplementsKeyword); |
| const result = this.createNode(node, { |
| type: classNodeType, |
| id: this.convertChild(node.name), |
| body: this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ClassBody, |
| body: [], |
| range: [node.members.pos - 1, node.end], |
| }), |
| superClass: (superClass === null || superClass === void 0 ? void 0 : superClass.types[0]) ? this.convertChild(superClass.types[0].expression) |
| : null, |
| }); |
| if (superClass) { |
| if (superClass.types.length > 1) { |
| throw node_utils_1.createError(this.ast, superClass.types[1].pos, 'Classes can only extend a single class.'); |
| } |
| if ((_e = superClass.types[0]) === null || _e === void 0 ? void 0 : _e.typeArguments) { |
| result.superTypeParameters = this.convertTypeArgumentsToTypeParameters(superClass.types[0].typeArguments, superClass.types[0]); |
| } |
| } |
| if (node.typeParameters) { |
| result.typeParameters = this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters); |
| } |
| if (implementsClause) { |
| result.implements = implementsClause.types.map(el => this.convertChild(el)); |
| } |
| /** |
| * TypeScript class declarations can be defined as "abstract" |
| */ |
| if (node_utils_1.hasModifier(SyntaxKind.AbstractKeyword, node)) { |
| result.abstract = true; |
| } |
| if (node_utils_1.hasModifier(SyntaxKind.DeclareKeyword, node)) { |
| result.declare = true; |
| } |
| if (node.decorators) { |
| result.decorators = node.decorators.map(el => this.convertChild(el)); |
| } |
| const filteredMembers = node.members.filter(node_utils_1.isESTreeClassMember); |
| if (filteredMembers.length) { |
| result.body.body = filteredMembers.map(el => this.convertChild(el)); |
| } |
| // check for exports |
| return this.fixExports(node, result); |
| } |
| // Modules |
| case SyntaxKind.ModuleBlock: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSModuleBlock, |
| body: this.convertBodyExpressions(node.statements, node), |
| }); |
| case SyntaxKind.ImportDeclaration: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ImportDeclaration, |
| source: this.convertChild(node.moduleSpecifier), |
| specifiers: [], |
| importKind: 'value', |
| }); |
| if (node.importClause) { |
| if (node.importClause.isTypeOnly) { |
| result.importKind = 'type'; |
| } |
| if (node.importClause.name) { |
| result.specifiers.push(this.convertChild(node.importClause)); |
| } |
| if (node.importClause.namedBindings) { |
| switch (node.importClause.namedBindings.kind) { |
| case SyntaxKind.NamespaceImport: |
| result.specifiers.push(this.convertChild(node.importClause.namedBindings)); |
| break; |
| case SyntaxKind.NamedImports: |
| result.specifiers = result.specifiers.concat(node.importClause.namedBindings.elements.map(el => this.convertChild(el))); |
| break; |
| } |
| } |
| } |
| return result; |
| } |
| case SyntaxKind.NamespaceImport: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ImportNamespaceSpecifier, |
| local: this.convertChild(node.name), |
| }); |
| case SyntaxKind.ImportSpecifier: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ImportSpecifier, |
| local: this.convertChild(node.name), |
| imported: this.convertChild((_f = node.propertyName) !== null && _f !== void 0 ? _f : node.name), |
| }); |
| case SyntaxKind.ImportClause: { |
| const local = this.convertChild(node.name); |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ImportDefaultSpecifier, |
| local, |
| range: local.range, |
| }); |
| } |
| case SyntaxKind.ExportDeclaration: |
| if (((_g = node.exportClause) === null || _g === void 0 ? void 0 : _g.kind) === SyntaxKind.NamedExports) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ExportNamedDeclaration, |
| source: this.convertChild(node.moduleSpecifier), |
| specifiers: node.exportClause.elements.map(el => this.convertChild(el)), |
| exportKind: node.isTypeOnly ? 'type' : 'value', |
| declaration: null, |
| }); |
| } |
| else { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ExportAllDeclaration, |
| source: this.convertChild(node.moduleSpecifier), |
| exportKind: node.isTypeOnly ? 'type' : 'value', |
| exported: |
| // note - for compat with 3.7.x, where node.exportClause is always undefined and |
| // SyntaxKind.NamespaceExport does not exist yet (i.e. is undefined), this |
| // cannot be shortened to an optional chain, or else you end up with |
| // undefined === undefined, and the true path will hard error at runtime |
| node.exportClause && |
| node.exportClause.kind === SyntaxKind.NamespaceExport |
| ? this.convertChild(node.exportClause.name) |
| : null, |
| }); |
| } |
| case SyntaxKind.ExportSpecifier: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ExportSpecifier, |
| local: this.convertChild((_h = node.propertyName) !== null && _h !== void 0 ? _h : node.name), |
| exported: this.convertChild(node.name), |
| }); |
| case SyntaxKind.ExportAssignment: |
| if (node.isExportEquals) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSExportAssignment, |
| expression: this.convertChild(node.expression), |
| }); |
| } |
| else { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ExportDefaultDeclaration, |
| declaration: this.convertChild(node.expression), |
| exportKind: 'value', |
| }); |
| } |
| // Unary Operations |
| case SyntaxKind.PrefixUnaryExpression: |
| case SyntaxKind.PostfixUnaryExpression: { |
| const operator = node_utils_1.getTextForTokenKind(node.operator); |
| /** |
| * ESTree uses UpdateExpression for ++/-- |
| */ |
| if (operator === '++' || operator === '--') { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.UpdateExpression, |
| operator, |
| prefix: node.kind === SyntaxKind.PrefixUnaryExpression, |
| argument: this.convertChild(node.operand), |
| }); |
| } |
| else { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.UnaryExpression, |
| operator, |
| prefix: node.kind === SyntaxKind.PrefixUnaryExpression, |
| argument: this.convertChild(node.operand), |
| }); |
| } |
| } |
| case SyntaxKind.DeleteExpression: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.UnaryExpression, |
| operator: 'delete', |
| prefix: true, |
| argument: this.convertChild(node.expression), |
| }); |
| case SyntaxKind.VoidExpression: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.UnaryExpression, |
| operator: 'void', |
| prefix: true, |
| argument: this.convertChild(node.expression), |
| }); |
| case SyntaxKind.TypeOfExpression: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.UnaryExpression, |
| operator: 'typeof', |
| prefix: true, |
| argument: this.convertChild(node.expression), |
| }); |
| case SyntaxKind.TypeOperator: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypeOperator, |
| operator: node_utils_1.getTextForTokenKind(node.operator), |
| typeAnnotation: this.convertChild(node.type), |
| }); |
| // Binary Operations |
| case SyntaxKind.BinaryExpression: { |
| // TypeScript uses BinaryExpression for sequences as well |
| if (node_utils_1.isComma(node.operatorToken)) { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.SequenceExpression, |
| expressions: [], |
| }); |
| const left = this.convertChild(node.left); |
| if (left.type === ts_estree_1.AST_NODE_TYPES.SequenceExpression && |
| node.left.kind !== SyntaxKind.ParenthesizedExpression) { |
| result.expressions = result.expressions.concat(left.expressions); |
| } |
| else { |
| result.expressions.push(left); |
| } |
| result.expressions.push(this.convertChild(node.right)); |
| return result; |
| } |
| else { |
| const type = node_utils_1.getBinaryExpressionType(node.operatorToken); |
| if (this.allowPattern && |
| type === ts_estree_1.AST_NODE_TYPES.AssignmentExpression) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.AssignmentPattern, |
| left: this.convertPattern(node.left, node), |
| right: this.convertChild(node.right), |
| }); |
| } |
| return this.createNode(node, { |
| type, |
| operator: node_utils_1.getTextForTokenKind(node.operatorToken.kind), |
| left: this.converter(node.left, node, this.inTypeMode, type === ts_estree_1.AST_NODE_TYPES.AssignmentExpression), |
| right: this.convertChild(node.right), |
| }); |
| } |
| } |
| case SyntaxKind.PropertyAccessExpression: { |
| const object = this.convertChild(node.expression); |
| const property = this.convertChild(node.name); |
| const computed = false; |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.MemberExpression, |
| object, |
| property, |
| computed, |
| optional: node.questionDotToken !== undefined, |
| }); |
| return this.convertChainExpression(result, node); |
| } |
| case SyntaxKind.ElementAccessExpression: { |
| const object = this.convertChild(node.expression); |
| const property = this.convertChild(node.argumentExpression); |
| const computed = true; |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.MemberExpression, |
| object, |
| property, |
| computed, |
| optional: node.questionDotToken !== undefined, |
| }); |
| return this.convertChainExpression(result, node); |
| } |
| case SyntaxKind.CallExpression: { |
| if (node.expression.kind === SyntaxKind.ImportKeyword) { |
| if (node.arguments.length !== 1) { |
| throw node_utils_1.createError(this.ast, node.arguments.pos, 'Dynamic import must have one specifier as an argument.'); |
| } |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ImportExpression, |
| source: this.convertChild(node.arguments[0]), |
| }); |
| } |
| const callee = this.convertChild(node.expression); |
| const args = node.arguments.map(el => this.convertChild(el)); |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.CallExpression, |
| callee, |
| arguments: args, |
| optional: node.questionDotToken !== undefined, |
| }); |
| if (node.typeArguments) { |
| result.typeParameters = this.convertTypeArgumentsToTypeParameters(node.typeArguments, node); |
| } |
| return this.convertChainExpression(result, node); |
| } |
| case SyntaxKind.NewExpression: { |
| // NOTE - NewExpression cannot have an optional chain in it |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.NewExpression, |
| callee: this.convertChild(node.expression), |
| arguments: node.arguments |
| ? node.arguments.map(el => this.convertChild(el)) |
| : [], |
| }); |
| if (node.typeArguments) { |
| result.typeParameters = this.convertTypeArgumentsToTypeParameters(node.typeArguments, node); |
| } |
| return result; |
| } |
| case SyntaxKind.ConditionalExpression: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.ConditionalExpression, |
| test: this.convertChild(node.condition), |
| consequent: this.convertChild(node.whenTrue), |
| alternate: this.convertChild(node.whenFalse), |
| }); |
| case SyntaxKind.MetaProperty: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.MetaProperty, |
| meta: this.createNode( |
| // TODO: do we really want to convert it to Token? |
| node.getFirstToken(), { |
| type: ts_estree_1.AST_NODE_TYPES.Identifier, |
| name: node_utils_1.getTextForTokenKind(node.keywordToken), |
| }), |
| property: this.convertChild(node.name), |
| }); |
| } |
| case SyntaxKind.Decorator: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Decorator, |
| expression: this.convertChild(node.expression), |
| }); |
| } |
| // Literals |
| case SyntaxKind.StringLiteral: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Literal, |
| raw: '', |
| value: '', |
| }); |
| result.raw = this.ast.text.slice(result.range[0], result.range[1]); |
| if ('name' in parent && parent.name === node) { |
| result.value = node.text; |
| } |
| else { |
| result.value = node_utils_1.unescapeStringLiteralText(node.text); |
| } |
| return result; |
| } |
| case SyntaxKind.NumericLiteral: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Literal, |
| value: Number(node.text), |
| raw: node.getText(), |
| }); |
| } |
| case SyntaxKind.BigIntLiteral: { |
| const range = node_utils_1.getRange(node, this.ast); |
| const rawValue = this.ast.text.slice(range[0], range[1]); |
| const bigint = rawValue |
| // remove suffix `n` |
| .slice(0, -1) |
| // `BigInt` doesn't accept numeric separator |
| // and `bigint` property should not include numeric separator |
| .replace(/_/g, ''); |
| const value = typeof BigInt !== 'undefined' ? BigInt(bigint) : null; |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Literal, |
| raw: rawValue, |
| value: value, |
| bigint: value === null ? bigint : String(value), |
| range, |
| }); |
| } |
| case SyntaxKind.RegularExpressionLiteral: { |
| const pattern = node.text.slice(1, node.text.lastIndexOf('/')); |
| const flags = node.text.slice(node.text.lastIndexOf('/') + 1); |
| let regex = null; |
| try { |
| regex = new RegExp(pattern, flags); |
| } |
| catch (exception) { |
| regex = null; |
| } |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Literal, |
| value: regex, |
| raw: node.text, |
| regex: { |
| pattern, |
| flags, |
| }, |
| }); |
| } |
| case SyntaxKind.TrueKeyword: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Literal, |
| value: true, |
| raw: 'true', |
| }); |
| case SyntaxKind.FalseKeyword: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Literal, |
| value: false, |
| raw: 'false', |
| }); |
| case SyntaxKind.NullKeyword: { |
| if (!version_check_1.typescriptVersionIsAtLeast['4.0'] && this.inTypeMode) { |
| // 4.0 started nesting null types inside a LiteralType node, but we still need to support pre-4.0 |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSNullKeyword, |
| }); |
| } |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Literal, |
| value: null, |
| raw: 'null', |
| }); |
| } |
| case SyntaxKind.EmptyStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.EmptyStatement, |
| }); |
| case SyntaxKind.DebuggerStatement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.DebuggerStatement, |
| }); |
| // JSX |
| case SyntaxKind.JsxElement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXElement, |
| openingElement: this.convertChild(node.openingElement), |
| closingElement: this.convertChild(node.closingElement), |
| children: node.children.map(el => this.convertChild(el)), |
| }); |
| case SyntaxKind.JsxFragment: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXFragment, |
| openingFragment: this.convertChild(node.openingFragment), |
| closingFragment: this.convertChild(node.closingFragment), |
| children: node.children.map(el => this.convertChild(el)), |
| }); |
| case SyntaxKind.JsxSelfClosingElement: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXElement, |
| /** |
| * Convert SyntaxKind.JsxSelfClosingElement to SyntaxKind.JsxOpeningElement, |
| * TypeScript does not seem to have the idea of openingElement when tag is self-closing |
| */ |
| openingElement: this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXOpeningElement, |
| typeParameters: node.typeArguments |
| ? this.convertTypeArgumentsToTypeParameters(node.typeArguments, node) |
| : undefined, |
| selfClosing: true, |
| name: this.convertJSXTagName(node.tagName, node), |
| attributes: node.attributes.properties.map(el => this.convertChild(el)), |
| range: node_utils_1.getRange(node, this.ast), |
| }), |
| closingElement: null, |
| children: [], |
| }); |
| } |
| case SyntaxKind.JsxOpeningElement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXOpeningElement, |
| typeParameters: node.typeArguments |
| ? this.convertTypeArgumentsToTypeParameters(node.typeArguments, node) |
| : undefined, |
| selfClosing: false, |
| name: this.convertJSXTagName(node.tagName, node), |
| attributes: node.attributes.properties.map(el => this.convertChild(el)), |
| }); |
| case SyntaxKind.JsxClosingElement: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXClosingElement, |
| name: this.convertJSXTagName(node.tagName, node), |
| }); |
| case SyntaxKind.JsxOpeningFragment: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXOpeningFragment, |
| }); |
| case SyntaxKind.JsxClosingFragment: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXClosingFragment, |
| }); |
| case SyntaxKind.JsxExpression: { |
| const expression = node.expression |
| ? this.convertChild(node.expression) |
| : this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXEmptyExpression, |
| range: [node.getStart(this.ast) + 1, node.getEnd() - 1], |
| }); |
| if (node.dotDotDotToken) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXSpreadChild, |
| expression, |
| }); |
| } |
| else { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXExpressionContainer, |
| expression, |
| }); |
| } |
| } |
| case SyntaxKind.JsxAttribute: { |
| const attributeName = this.convertChild(node.name); |
| attributeName.type = ts_estree_1.AST_NODE_TYPES.JSXIdentifier; |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXAttribute, |
| name: attributeName, |
| value: this.convertChild(node.initializer), |
| }); |
| } |
| /** |
| * The JSX AST changed the node type for string literals |
| * inside a JSX Element from `Literal` to `JSXText`. We |
| * provide a flag to support both types until `Literal` |
| * node type is deprecated in ESLint v5. |
| */ |
| case SyntaxKind.JsxText: { |
| const start = node.getFullStart(); |
| const end = node.getEnd(); |
| if (this.options.useJSXTextNode) { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXText, |
| value: this.ast.text.slice(start, end), |
| raw: this.ast.text.slice(start, end), |
| range: [start, end], |
| }); |
| } |
| else { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.Literal, |
| value: this.ast.text.slice(start, end), |
| raw: this.ast.text.slice(start, end), |
| range: [start, end], |
| }); |
| } |
| } |
| case SyntaxKind.JsxSpreadAttribute: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.JSXSpreadAttribute, |
| argument: this.convertChild(node.expression), |
| }); |
| case SyntaxKind.QualifiedName: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSQualifiedName, |
| left: this.convertChild(node.left), |
| right: this.convertChild(node.right), |
| }); |
| } |
| // TypeScript specific |
| case SyntaxKind.TypeReference: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypeReference, |
| typeName: this.convertType(node.typeName), |
| typeParameters: node.typeArguments |
| ? this.convertTypeArgumentsToTypeParameters(node.typeArguments, node) |
| : undefined, |
| }); |
| } |
| case SyntaxKind.TypeParameter: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypeParameter, |
| name: this.convertType(node.name), |
| constraint: node.constraint |
| ? this.convertType(node.constraint) |
| : undefined, |
| default: node.default ? this.convertType(node.default) : undefined, |
| }); |
| } |
| case SyntaxKind.ThisType: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSThisType, |
| }); |
| case SyntaxKind.AnyKeyword: |
| case SyntaxKind.BigIntKeyword: |
| case SyntaxKind.BooleanKeyword: |
| case SyntaxKind.NeverKeyword: |
| case SyntaxKind.NumberKeyword: |
| case SyntaxKind.ObjectKeyword: |
| case SyntaxKind.StringKeyword: |
| case SyntaxKind.SymbolKeyword: |
| case SyntaxKind.UnknownKeyword: |
| case SyntaxKind.VoidKeyword: |
| case SyntaxKind.UndefinedKeyword: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES[`TS${SyntaxKind[node.kind]}`], |
| }); |
| } |
| case SyntaxKind.NonNullExpression: { |
| const nnExpr = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSNonNullExpression, |
| expression: this.convertChild(node.expression), |
| }); |
| return this.convertChainExpression(nnExpr, node); |
| } |
| case SyntaxKind.TypeLiteral: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypeLiteral, |
| members: node.members.map(el => this.convertChild(el)), |
| }); |
| } |
| case SyntaxKind.ArrayType: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSArrayType, |
| elementType: this.convertType(node.elementType), |
| }); |
| } |
| case SyntaxKind.IndexedAccessType: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSIndexedAccessType, |
| objectType: this.convertType(node.objectType), |
| indexType: this.convertType(node.indexType), |
| }); |
| } |
| case SyntaxKind.ConditionalType: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSConditionalType, |
| checkType: this.convertType(node.checkType), |
| extendsType: this.convertType(node.extendsType), |
| trueType: this.convertType(node.trueType), |
| falseType: this.convertType(node.falseType), |
| }); |
| } |
| case SyntaxKind.TypeQuery: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypeQuery, |
| exprName: this.convertType(node.exprName), |
| }); |
| } |
| case SyntaxKind.MappedType: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSMappedType, |
| typeParameter: this.convertType(node.typeParameter), |
| }); |
| if (node.readonlyToken) { |
| if (node.readonlyToken.kind === SyntaxKind.ReadonlyKeyword) { |
| result.readonly = true; |
| } |
| else { |
| result.readonly = node_utils_1.getTextForTokenKind(node.readonlyToken.kind); |
| } |
| } |
| if (node.questionToken) { |
| if (node.questionToken.kind === SyntaxKind.QuestionToken) { |
| result.optional = true; |
| } |
| else { |
| result.optional = node_utils_1.getTextForTokenKind(node.questionToken.kind); |
| } |
| } |
| if (node.type) { |
| result.typeAnnotation = this.convertType(node.type); |
| } |
| return result; |
| } |
| case SyntaxKind.ParenthesizedExpression: |
| return this.convertChild(node.expression, parent); |
| case SyntaxKind.TypeAliasDeclaration: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypeAliasDeclaration, |
| id: this.convertChild(node.name), |
| typeAnnotation: this.convertType(node.type), |
| }); |
| if (node_utils_1.hasModifier(SyntaxKind.DeclareKeyword, node)) { |
| result.declare = true; |
| } |
| // Process typeParameters |
| if (node.typeParameters) { |
| result.typeParameters = this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters); |
| } |
| // check for exports |
| return this.fixExports(node, result); |
| } |
| case SyntaxKind.MethodSignature: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSMethodSignature, |
| computed: node_utils_1.isComputedProperty(node.name), |
| key: this.convertChild(node.name), |
| params: this.convertParameters(node.parameters), |
| }); |
| if (node_utils_1.isOptional(node)) { |
| result.optional = true; |
| } |
| if (node.type) { |
| result.returnType = this.convertTypeAnnotation(node.type, node); |
| } |
| if (node_utils_1.hasModifier(SyntaxKind.ReadonlyKeyword, node)) { |
| result.readonly = true; |
| } |
| if (node.typeParameters) { |
| result.typeParameters = this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters); |
| } |
| const accessibility = node_utils_1.getTSNodeAccessibility(node); |
| if (accessibility) { |
| result.accessibility = accessibility; |
| } |
| if (node_utils_1.hasModifier(SyntaxKind.ExportKeyword, node)) { |
| result.export = true; |
| } |
| if (node_utils_1.hasModifier(SyntaxKind.StaticKeyword, node)) { |
| result.static = true; |
| } |
| return result; |
| } |
| case SyntaxKind.PropertySignature: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSPropertySignature, |
| optional: node_utils_1.isOptional(node) || undefined, |
| computed: node_utils_1.isComputedProperty(node.name), |
| key: this.convertChild(node.name), |
| typeAnnotation: node.type |
| ? this.convertTypeAnnotation(node.type, node) |
| : undefined, |
| initializer: this.convertChild(node.initializer) || undefined, |
| readonly: node_utils_1.hasModifier(SyntaxKind.ReadonlyKeyword, node) || undefined, |
| static: node_utils_1.hasModifier(SyntaxKind.StaticKeyword, node) || undefined, |
| export: node_utils_1.hasModifier(SyntaxKind.ExportKeyword, node) || undefined, |
| }); |
| const accessibility = node_utils_1.getTSNodeAccessibility(node); |
| if (accessibility) { |
| result.accessibility = accessibility; |
| } |
| return result; |
| } |
| case SyntaxKind.IndexSignature: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSIndexSignature, |
| parameters: node.parameters.map(el => this.convertChild(el)), |
| }); |
| if (node.type) { |
| result.typeAnnotation = this.convertTypeAnnotation(node.type, node); |
| } |
| if (node_utils_1.hasModifier(SyntaxKind.ReadonlyKeyword, node)) { |
| result.readonly = true; |
| } |
| const accessibility = node_utils_1.getTSNodeAccessibility(node); |
| if (accessibility) { |
| result.accessibility = accessibility; |
| } |
| if (node_utils_1.hasModifier(SyntaxKind.ExportKeyword, node)) { |
| result.export = true; |
| } |
| if (node_utils_1.hasModifier(SyntaxKind.StaticKeyword, node)) { |
| result.static = true; |
| } |
| return result; |
| } |
| case SyntaxKind.ConstructorType: |
| case SyntaxKind.FunctionType: |
| case SyntaxKind.ConstructSignature: |
| case SyntaxKind.CallSignature: { |
| let type; |
| switch (node.kind) { |
| case SyntaxKind.ConstructSignature: |
| type = ts_estree_1.AST_NODE_TYPES.TSConstructSignatureDeclaration; |
| break; |
| case SyntaxKind.CallSignature: |
| type = ts_estree_1.AST_NODE_TYPES.TSCallSignatureDeclaration; |
| break; |
| case SyntaxKind.FunctionType: |
| type = ts_estree_1.AST_NODE_TYPES.TSFunctionType; |
| break; |
| case SyntaxKind.ConstructorType: |
| default: |
| type = ts_estree_1.AST_NODE_TYPES.TSConstructorType; |
| break; |
| } |
| const result = this.createNode(node, { |
| type: type, |
| params: this.convertParameters(node.parameters), |
| }); |
| if (node.type) { |
| result.returnType = this.convertTypeAnnotation(node.type, node); |
| } |
| if (node.typeParameters) { |
| result.typeParameters = this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters); |
| } |
| return result; |
| } |
| case SyntaxKind.ExpressionWithTypeArguments: { |
| const result = this.createNode(node, { |
| type: parent && parent.kind === SyntaxKind.InterfaceDeclaration |
| ? ts_estree_1.AST_NODE_TYPES.TSInterfaceHeritage |
| : ts_estree_1.AST_NODE_TYPES.TSClassImplements, |
| expression: this.convertChild(node.expression), |
| }); |
| if (node.typeArguments) { |
| result.typeParameters = this.convertTypeArgumentsToTypeParameters(node.typeArguments, node); |
| } |
| return result; |
| } |
| case SyntaxKind.InterfaceDeclaration: { |
| const interfaceHeritageClauses = (_j = node.heritageClauses) !== null && _j !== void 0 ? _j : []; |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSInterfaceDeclaration, |
| body: this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSInterfaceBody, |
| body: node.members.map(member => this.convertChild(member)), |
| range: [node.members.pos - 1, node.end], |
| }), |
| id: this.convertChild(node.name), |
| }); |
| if (node.typeParameters) { |
| result.typeParameters = this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters); |
| } |
| if (interfaceHeritageClauses.length > 0) { |
| const interfaceExtends = []; |
| const interfaceImplements = []; |
| for (const heritageClause of interfaceHeritageClauses) { |
| if (heritageClause.token === SyntaxKind.ExtendsKeyword) { |
| for (const n of heritageClause.types) { |
| interfaceExtends.push(this.convertChild(n, node)); |
| } |
| } |
| else { |
| for (const n of heritageClause.types) { |
| interfaceImplements.push(this.convertChild(n, node)); |
| } |
| } |
| } |
| if (interfaceExtends.length) { |
| result.extends = interfaceExtends; |
| } |
| if (interfaceImplements.length) { |
| result.implements = interfaceImplements; |
| } |
| } |
| if (node_utils_1.hasModifier(SyntaxKind.AbstractKeyword, node)) { |
| result.abstract = true; |
| } |
| if (node_utils_1.hasModifier(SyntaxKind.DeclareKeyword, node)) { |
| result.declare = true; |
| } |
| // check for exports |
| return this.fixExports(node, result); |
| } |
| case SyntaxKind.TypePredicate: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypePredicate, |
| asserts: node.assertsModifier !== undefined, |
| parameterName: this.convertChild(node.parameterName), |
| typeAnnotation: null, |
| }); |
| /** |
| * Specific fix for type-guard location data |
| */ |
| if (node.type) { |
| result.typeAnnotation = this.convertTypeAnnotation(node.type, node); |
| result.typeAnnotation.loc = result.typeAnnotation.typeAnnotation.loc; |
| result.typeAnnotation.range = |
| result.typeAnnotation.typeAnnotation.range; |
| } |
| return result; |
| } |
| case SyntaxKind.ImportType: |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSImportType, |
| isTypeOf: !!node.isTypeOf, |
| parameter: this.convertChild(node.argument), |
| qualifier: this.convertChild(node.qualifier), |
| typeParameters: node.typeArguments |
| ? this.convertTypeArgumentsToTypeParameters(node.typeArguments, node) |
| : null, |
| }); |
| case SyntaxKind.EnumDeclaration: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSEnumDeclaration, |
| id: this.convertChild(node.name), |
| members: node.members.map(el => this.convertChild(el)), |
| }); |
| // apply modifiers first... |
| this.applyModifiersToResult(result, node.modifiers); |
| // ...then check for exports |
| return this.fixExports(node, result); |
| } |
| case SyntaxKind.EnumMember: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSEnumMember, |
| id: this.convertChild(node.name), |
| }); |
| if (node.initializer) { |
| result.initializer = this.convertChild(node.initializer); |
| } |
| if (node.name.kind === ts.SyntaxKind.ComputedPropertyName) { |
| result.computed = true; |
| } |
| return result; |
| } |
| case SyntaxKind.ModuleDeclaration: { |
| const result = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSModuleDeclaration, |
| id: this.convertChild(node.name), |
| }); |
| if (node.body) { |
| result.body = this.convertChild(node.body); |
| } |
| // apply modifiers first... |
| this.applyModifiersToResult(result, node.modifiers); |
| if (node.flags & ts.NodeFlags.GlobalAugmentation) { |
| result.global = true; |
| } |
| // ...then check for exports |
| return this.fixExports(node, result); |
| } |
| // TypeScript specific types |
| case SyntaxKind.ParenthesizedType: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSParenthesizedType, |
| typeAnnotation: this.convertType(node.type), |
| }); |
| } |
| case SyntaxKind.UnionType: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSUnionType, |
| types: node.types.map(el => this.convertType(el)), |
| }); |
| } |
| case SyntaxKind.IntersectionType: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSIntersectionType, |
| types: node.types.map(el => this.convertType(el)), |
| }); |
| } |
| case SyntaxKind.AsExpression: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSAsExpression, |
| expression: this.convertChild(node.expression), |
| typeAnnotation: this.convertType(node.type), |
| }); |
| } |
| case SyntaxKind.InferType: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSInferType, |
| typeParameter: this.convertType(node.typeParameter), |
| }); |
| } |
| case SyntaxKind.LiteralType: { |
| if (version_check_1.typescriptVersionIsAtLeast['4.0'] && |
| node.literal.kind === SyntaxKind.NullKeyword) { |
| // 4.0 started nesting null types inside a LiteralType node |
| // but our AST is designed around the old way of null being a keyword |
| return this.createNode(node.literal, { |
| type: ts_estree_1.AST_NODE_TYPES.TSNullKeyword, |
| }); |
| } |
| else { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSLiteralType, |
| literal: this.convertType(node.literal), |
| }); |
| } |
| } |
| case SyntaxKind.TypeAssertionExpression: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSTypeAssertion, |
| typeAnnotation: this.convertType(node.type), |
| expression: this.convertChild(node.expression), |
| }); |
| } |
| case SyntaxKind.ImportEqualsDeclaration: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSImportEqualsDeclaration, |
| id: this.convertChild(node.name), |
| moduleReference: this.convertChild(node.moduleReference), |
| isExport: node_utils_1.hasModifier(SyntaxKind.ExportKeyword, node), |
| }); |
| } |
| case SyntaxKind.ExternalModuleReference: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSExternalModuleReference, |
| expression: this.convertChild(node.expression), |
| }); |
| } |
| case SyntaxKind.NamespaceExportDeclaration: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSNamespaceExportDeclaration, |
| id: this.convertChild(node.name), |
| }); |
| } |
| case SyntaxKind.AbstractKeyword: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSAbstractKeyword, |
| }); |
| } |
| // Tuple |
| case SyntaxKind.TupleType: { |
| // In TS 4.0, the `elementTypes` property was changed to `elements`. |
| // To support both at compile time, we cast to access the newer version |
| // if the former does not exist. |
| const elementTypes = 'elementTypes' in node |
| ? node.elementTypes.map((el) => this.convertType(el)) |
| : node.elements.map((el) => this.convertType(el)); |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSTupleType, |
| elementTypes, |
| }); |
| } |
| case SyntaxKind.NamedTupleMember: { |
| const member = this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSNamedTupleMember, |
| elementType: this.convertType(node.type, node), |
| label: this.convertChild(node.name, node), |
| optional: node.questionToken != null, |
| }); |
| if (node.dotDotDotToken) { |
| // adjust the start to account for the "..." |
| member.range[0] = member.label.range[0]; |
| member.loc.start = member.label.loc.start; |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSRestType, |
| typeAnnotation: member, |
| }); |
| } |
| return member; |
| } |
| case SyntaxKind.OptionalType: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSOptionalType, |
| typeAnnotation: this.convertType(node.type), |
| }); |
| } |
| case SyntaxKind.RestType: { |
| return this.createNode(node, { |
| type: ts_estree_1.AST_NODE_TYPES.TSRestType, |
| typeAnnotation: this.convertType(node.type), |
| }); |
| } |
| default: |
| return this.deeplyCopy(node); |
| } |
| } |
| } |
| exports.Converter = Converter; |
| //# sourceMappingURL=convert.js.map |
