+++ /dev/null
-"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;
- });
- }
- /**
- * 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);
- }
- /**
- * Semantically, decorators are not allowed on function 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));
- }
- // 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 isLocallyOptional = node.questionDotToken !== undefined;
- // the optional expression should propagate up the member expression tree
- const isChildOptional = node_utils_1.isChildOptionalChain(node, object);
- if (isLocallyOptional || isChildOptional) {
- return this.createNode(node, {
- type: ts_estree_1.AST_NODE_TYPES.OptionalMemberExpression,
- object,
- property,
- computed,
- optional: isLocallyOptional,
- });
- }
- else {
- return this.createNode(node, {
- type: ts_estree_1.AST_NODE_TYPES.MemberExpression,
- object,
- property,
- computed,
- optional: false,
- });
- }
- }
- case SyntaxKind.ElementAccessExpression: {
- const object = this.convertChild(node.expression);
- const property = this.convertChild(node.argumentExpression);
- const computed = true;
- const isLocallyOptional = node.questionDotToken !== undefined;
- // the optional expression should propagate up the member expression tree
- const isChildOptional = node_utils_1.isChildOptionalChain(node, object);
- if (isLocallyOptional || isChildOptional) {
- return this.createNode(node, {
- type: ts_estree_1.AST_NODE_TYPES.OptionalMemberExpression,
- object,
- property,
- computed,
- optional: isLocallyOptional,
- });
- }
- else {
- return this.createNode(node, {
- type: ts_estree_1.AST_NODE_TYPES.MemberExpression,
- object,
- property,
- computed,
- optional: false,
- });
- }
- }
- 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));
- let result;
- const isLocallyOptional = node.questionDotToken !== undefined;
- // the optional expression should propagate up the member expression tree
- const isChildOptional = node_utils_1.isChildOptionalChain(node, callee);
- if (isLocallyOptional || isChildOptional) {
- result = this.createNode(node, {
- type: ts_estree_1.AST_NODE_TYPES.OptionalCallExpression,
- callee,
- arguments: args,
- optional: isLocallyOptional,
- });
- }
- else {
- result = this.createNode(node, {
- type: ts_estree_1.AST_NODE_TYPES.CallExpression,
- callee,
- arguments: args,
- optional: false,
- });
- }
- if (node.typeArguments) {
- result.typeParameters = this.convertTypeArgumentsToTypeParameters(node.typeArguments, node);
- }
- return result;
- }
- 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: {
- return this.createNode(node, {
- type: ts_estree_1.AST_NODE_TYPES.TSNonNullExpression,
- expression: this.convertChild(node.expression),
- });
- }
- 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;
- }
- }
- /**
- * Semantically, decorators are not allowed on interface 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.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);
- /**
- * Semantically, decorators are not allowed on enum 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));
- }
- // ...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
\ No newline at end of file
projects / dotfiles / .git / blobdiff