diff --git a/its/plugin/sonarlint-tests/pom.xml b/its/plugin/sonarlint-tests/pom.xml
index 726a9c1f770..c90be42e0f5 100644
--- a/its/plugin/sonarlint-tests/pom.xml
+++ b/its/plugin/sonarlint-tests/pom.xml
@@ -10,6 +10,7 @@
javascript-it-plugin-sonarlint-tests
JavaScript :: IT :: Plugin :: SonarLint Tests
+ pom
-server
diff --git a/packages/jsts/src/analysis/analyzer.ts b/packages/jsts/src/analysis/analyzer.ts
index 2e1819ad8c5..20a0e951a19 100644
--- a/packages/jsts/src/analysis/analyzer.ts
+++ b/packages/jsts/src/analysis/analyzer.ts
@@ -31,6 +31,7 @@ import {
import { buildSourceCode } from '../builders';
import { JsTsAnalysisInput, JsTsAnalysisOutput } from './analysis';
import { serializeInProtobuf } from '../parsers';
+import { TSESTree } from '@typescript-eslint/utils';
/**
* Analyzes a JavaScript / TypeScript analysis input
@@ -112,7 +113,7 @@ function analyzeFile(
function serializeAst(sourceCode: SourceCode, filePath: string) {
try {
- return serializeInProtobuf(sourceCode.ast);
+ return serializeInProtobuf(sourceCode.ast as TSESTree.Program);
} catch (e) {
info(`Failed to serialize AST for file "${filePath}"`);
return null;
diff --git a/packages/jsts/src/parsers/ast.ts b/packages/jsts/src/parsers/ast.ts
index 2a654236bf0..9f876afabb3 100644
--- a/packages/jsts/src/parsers/ast.ts
+++ b/packages/jsts/src/parsers/ast.ts
@@ -19,8 +19,7 @@
*/
import * as protobuf from 'protobufjs';
import * as path from 'node:path';
-import * as estree from 'estree';
-import { AST } from 'eslint';
+import { TSESTree } from '@typescript-eslint/utils';
import { debug } from '@sonar/shared';
const PATH_TO_PROTOFILE = path.join(__dirname, 'estree.proto');
@@ -28,7 +27,7 @@ const PROTO_ROOT = protobuf.loadSync(PATH_TO_PROTOFILE);
const NODE_TYPE = PROTO_ROOT.lookupType('Node');
const NODE_TYPE_ENUM = PROTO_ROOT.lookupEnum('NodeType');
-export function serializeInProtobuf(ast: AST.Program): Uint8Array {
+export function serializeInProtobuf(ast: TSESTree.Program): Uint8Array {
const protobufAST = parseInProtobuf(ast);
return NODE_TYPE.encode(NODE_TYPE.create(protobufAST)).finish();
}
@@ -36,7 +35,7 @@ export function serializeInProtobuf(ast: AST.Program): Uint8Array {
/**
* Only used for tests
*/
-export function parseInProtobuf(ast: AST.Program) {
+export function parseInProtobuf(ast: TSESTree.Program) {
const protobugShapedAST = visitNode(ast);
const protobufType = PROTO_ROOT.lookupType('Node');
return protobufType.create(protobugShapedAST);
@@ -50,7 +49,7 @@ export function deserializeProtobuf(serialized: Uint8Array): any {
return decoded;
}
-export function visitNode(node: estree.BaseNodeWithoutComments | undefined | null): any {
+export function visitNode(node: TSESTree.Node | undefined | null): any {
if (!node) {
// Null and undefined will be both serialized as "not set" in protobuf when the field is optional.
return undefined;
@@ -66,174 +65,275 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
return str.charAt(0).toLowerCase() + str.slice(1);
}
- function getProtobufShapeForNode(node: estree.BaseNodeWithoutComments) {
+ function getProtobufShapeForNode(node: TSESTree.Node) {
switch (node.type) {
case 'Program':
- return visitProgram(node as estree.Program);
+ return visitProgram(node);
case 'ExportAllDeclaration':
- return visitExportAllDeclaration(node as estree.ExportAllDeclaration);
+ return visitExportAllDeclaration(node);
case 'Literal':
// Special case: can be 'SimpleLiteral', 'RegExpLiteral', or 'BigIntLiteral'.
- return visitLiteral(node as estree.Literal);
+ return visitLiteral(node);
case 'Identifier':
- return visitIdentifier(node as estree.Identifier);
+ return visitIdentifier(node);
case 'ExportDefaultDeclaration':
- return visitExportDefaultDeclaration(node as estree.ExportDefaultDeclaration);
+ return visitExportDefaultDeclaration(node);
case 'YieldExpression':
- return visitYieldExpression(node as estree.YieldExpression);
+ return visitYieldExpression(node);
case 'UpdateExpression':
- return visitUpdateExpression(node as estree.UpdateExpression);
+ return visitUpdateExpression(node);
case 'UnaryExpression':
- return visitUnaryExpression(node as estree.UnaryExpression);
+ return visitUnaryExpression(node);
case 'ThisExpression':
- return visitThisExpression(node as estree.ThisExpression);
+ return visitThisExpression(node);
case 'TemplateLiteral':
- return visitTemplateLiteral(node as estree.TemplateLiteral);
+ return visitTemplateLiteral(node);
case 'TaggedTemplateExpression':
- return visitTaggedTemplateExpression(node as estree.TaggedTemplateExpression);
+ return visitTaggedTemplateExpression(node);
case 'SequenceExpression':
- return visitSequenceExpression(node as estree.SequenceExpression);
+ return visitSequenceExpression(node);
case 'ObjectExpression':
- return visitObjectExpression(node as estree.ObjectExpression);
+ return visitObjectExpression(node);
case 'SpreadElement':
- return visitSpreadElement(node as estree.SpreadElement);
+ return visitSpreadElement(node);
case 'Property':
- return visitProperty(node as estree.Property);
+ return visitProperty(node);
case 'AssignmentPattern':
- return visitAssignmentPattern(node as estree.AssignmentPattern);
+ return visitAssignmentPattern(node);
case 'RestElement':
- return visitRestElement(node as estree.RestElement);
+ return visitRestElement(node);
case 'ArrayPattern':
- return visitArrayPattern(node as estree.ArrayPattern);
+ return visitArrayPattern(node);
case 'ObjectPattern':
- return visitObjectPattern(node as estree.ObjectPattern);
+ return visitObjectPattern(node);
case 'PrivateIdentifier':
- return visitPrivateIdentifier(node as estree.PrivateIdentifier);
+ return visitPrivateIdentifier(node);
case 'NewExpression':
- return visitNewExpression(node as estree.NewExpression);
+ return visitNewExpression(node);
case 'Super':
- return visitSuper(node as estree.Super);
+ return visitSuper(node);
case 'MetaProperty':
- return visitMetaProperty(node as estree.MetaProperty);
+ return visitMetaProperty(node);
case 'MemberExpression':
- return visitMemberExpression(node as estree.MemberExpression);
+ return visitMemberExpression(node);
case 'LogicalExpression':
- return visitLogicalExpression(node as estree.LogicalExpression);
+ return visitLogicalExpression(node);
case 'ImportExpression':
- return visitImportExpression(node as estree.ImportExpression);
+ return visitImportExpression(node);
case 'BlockStatement':
- return visitBlockStatement(node as estree.BlockStatement);
+ return visitBlockStatement(node);
case 'ConditionalExpression':
- return visitConditionalExpression(node as estree.ConditionalExpression);
+ return visitConditionalExpression(node);
case 'ClassExpression':
- return visitClassExpression(node as estree.ClassExpression);
+ return visitClassExpression(node);
case 'ClassBody':
- return visitClassBody(node as estree.ClassBody);
+ return visitClassBody(node);
case 'StaticBlock':
- return visitStaticBlock(node as estree.StaticBlock);
+ return visitStaticBlock(node);
case 'PropertyDefinition':
- return visitPropertyDefinition(node as estree.PropertyDefinition);
+ return visitPropertyDefinition(node);
case 'MethodDefinition':
- return visitMethodDefinition(node as estree.MethodDefinition);
+ return visitMethodDefinition(node);
case 'ChainExpression':
- return visitChainExpression(node as estree.ChainExpression);
+ return visitChainExpression(node);
case 'CallExpression':
- return visitCallExpression(node as estree.SimpleCallExpression);
+ return visitCallExpression(node);
case 'BinaryExpression':
- return visitBinaryExpression(node as estree.BinaryExpression);
+ return visitBinaryExpression(node);
case 'AwaitExpression':
- return visitAwaitExpression(node as estree.AwaitExpression);
+ return visitAwaitExpression(node);
case 'AssignmentExpression':
- return visitAssignmentExpression(node as estree.AssignmentExpression);
+ return visitAssignmentExpression(node);
case 'ArrowFunctionExpression':
- return visitArrowFunctionExpression(node as estree.ArrowFunctionExpression);
+ return visitArrowFunctionExpression(node);
case 'ArrayExpression':
- return visitArrayExpression(node as estree.ArrayExpression);
+ return visitArrayExpression(node);
case 'ClassDeclaration':
// Special case: the name is not the same as the type.
- return visitClassDeclaration(node as estree.MaybeNamedClassDeclaration);
+ return visitClassDeclaration(node);
case 'FunctionDeclaration':
// Special case: the name is not the same as the type.
- return visitFunctionDeclaration(node as estree.MaybeNamedFunctionDeclaration);
+ return visitFunctionDeclaration(node);
case 'ExportNamedDeclaration':
- return visitExportNamedDeclaration(node as estree.ExportNamedDeclaration);
+ return visitExportNamedDeclaration(node);
case 'ExportSpecifier':
- return visitExportSpecifier(node as estree.ExportSpecifier);
+ return visitExportSpecifier(node);
case 'VariableDeclaration':
- return visitVariableDeclaration(node as estree.VariableDeclaration);
+ return visitVariableDeclaration(node);
case 'VariableDeclarator':
- return visitVariableDeclarator(node as estree.VariableDeclarator);
+ return visitVariableDeclarator(node);
case 'ImportDeclaration':
- return visitImportDeclaration(node as estree.ImportDeclaration);
+ return visitImportDeclaration(node);
case 'ImportNamespaceSpecifier':
- return visitImportNamespaceSpecifier(node as estree.ImportNamespaceSpecifier);
+ return visitImportNamespaceSpecifier(node);
case 'ImportDefaultSpecifier':
- return visitImportDefaultSpecifier(node as estree.ImportDefaultSpecifier);
+ return visitImportDefaultSpecifier(node);
case 'ImportSpecifier':
- return visitImportSpecifier(node as estree.ImportSpecifier);
+ return visitImportSpecifier(node);
case 'ForOfStatement':
- return visitForOfStatement(node as estree.ForOfStatement);
+ return visitForOfStatement(node);
case 'ForInStatement':
- return visitForInStatement(node as estree.ForInStatement);
+ return visitForInStatement(node);
case 'ForStatement':
- return visitForStatement(node as estree.ForStatement);
+ return visitForStatement(node);
case 'DoWhileStatement':
- return visitDoWhileStatement(node as estree.DoWhileStatement);
+ return visitDoWhileStatement(node);
case 'WhileStatement':
- return visitWhileStatement(node as estree.WhileStatement);
+ return visitWhileStatement(node);
case 'TryStatement':
- return visitTryStatement(node as estree.TryStatement);
+ return visitTryStatement(node);
case 'CatchClause':
- return visitCatchClause(node as estree.CatchClause);
+ return visitCatchClause(node);
case 'ThrowStatement':
- return visitThrowStatement(node as estree.ThrowStatement);
+ return visitThrowStatement(node);
case 'SwitchStatement':
- return visitSwitchStatement(node as estree.SwitchStatement);
+ return visitSwitchStatement(node);
case 'SwitchCase':
- return visitSwitchCase(node as estree.SwitchCase);
+ return visitSwitchCase(node);
case 'IfStatement':
- return visitIfStatement(node as estree.IfStatement);
+ return visitIfStatement(node);
case 'ContinueStatement':
- return visitContinueStatement(node as estree.ContinueStatement);
+ return visitContinueStatement(node);
case 'BreakStatement':
- return visitBreakStatement(node as estree.BreakStatement);
+ return visitBreakStatement(node);
case 'LabeledStatement':
- return visitLabeledStatement(node as estree.LabeledStatement);
+ return visitLabeledStatement(node);
case 'ReturnStatement':
- return visitReturnStatement(node as estree.ReturnStatement);
+ return visitReturnStatement(node);
case 'WithStatement':
- return visitWithStatement(node as estree.WithStatement);
+ return visitWithStatement(node);
case 'DebuggerStatement':
- return visitDebuggerStatement(node as estree.DebuggerStatement);
+ return visitDebuggerStatement(node);
case 'EmptyStatement':
- return visitEmptyStatement(node as estree.EmptyStatement);
+ return visitEmptyStatement(node);
case 'ExpressionStatement':
// Special case: can be 'Directive' or 'ExpressionStatement'.
- return visitExpressionStatement(node as estree.ExpressionStatement);
+ return visitExpressionStatement(node);
case 'TemplateElement':
- return visitTemplateElement(node as estree.TemplateElement);
+ return visitTemplateElement(node);
case 'FunctionExpression':
- return visitFunctionExpression(node as estree.FunctionExpression);
- default:
+ return visitFunctionExpression(node);
+ case 'AccessorProperty':
+ case 'Decorator':
+ case 'ImportAttribute':
+ case 'JSXAttribute':
+ case 'JSXClosingElement':
+ case 'JSXClosingFragment':
+ case 'JSXElement':
+ case 'JSXEmptyExpression':
+ case 'JSXExpressionContainer':
+ case 'JSXFragment':
+ case 'JSXIdentifier':
+ case 'JSXMemberExpression':
+ case 'JSXNamespacedName':
+ case 'JSXOpeningElement':
+ case 'JSXOpeningFragment':
+ case 'JSXSpreadAttribute':
+ case 'JSXSpreadChild':
+ case 'JSXText':
+ case 'TSAbstractAccessorProperty':
+ case 'TSAbstractKeyword':
+ case 'TSAbstractMethodDefinition':
+ case 'TSAbstractPropertyDefinition':
+ case 'TSAnyKeyword':
+ case 'TSArrayType':
+ case 'TSAsExpression':
+ case 'TSAsyncKeyword':
+ case 'TSBigIntKeyword':
+ case 'TSBooleanKeyword':
+ case 'TSCallSignatureDeclaration':
+ case 'TSClassImplements':
+ case 'TSConditionalType':
+ case 'TSConstructorType':
+ case 'TSConstructSignatureDeclaration':
+ case 'TSDeclareFunction':
+ case 'TSDeclareKeyword':
+ case 'TSEmptyBodyFunctionExpression':
+ case 'TSEnumDeclaration':
+ case 'TSEnumMember':
+ case 'TSExportAssignment':
+ case 'TSExportKeyword':
+ case 'TSExternalModuleReference':
+ case 'TSFunctionType':
+ case 'TSInstantiationExpression':
+ case 'TSImportEqualsDeclaration':
+ case 'TSImportType':
+ case 'TSIndexedAccessType':
+ case 'TSIndexSignature':
+ case 'TSInferType':
+ case 'TSInterfaceBody':
+ case 'TSInterfaceDeclaration':
+ case 'TSInterfaceHeritage':
+ case 'TSIntersectionType':
+ case 'TSIntrinsicKeyword':
+ case 'TSLiteralType':
+ case 'TSMappedType':
+ case 'TSMethodSignature':
+ case 'TSModuleBlock':
+ case 'TSModuleDeclaration':
+ case 'TSNamedTupleMember':
+ case 'TSNamespaceExportDeclaration':
+ case 'TSNeverKeyword':
+ case 'TSNonNullExpression':
+ case 'TSNullKeyword':
+ case 'TSNumberKeyword':
+ case 'TSObjectKeyword':
+ case 'TSOptionalType':
+ case 'TSParameterProperty':
+ case 'TSPrivateKeyword':
+ case 'TSPropertySignature':
+ case 'TSProtectedKeyword':
+ case 'TSPublicKeyword':
+ case 'TSQualifiedName':
+ case 'TSReadonlyKeyword':
+ case 'TSRestType':
+ case 'TSSatisfiesExpression':
+ case 'TSStaticKeyword':
+ case 'TSStringKeyword':
+ case 'TSSymbolKeyword':
+ case 'TSTemplateLiteralType':
+ case 'TSThisType':
+ case 'TSTupleType':
+ case 'TSTypeAliasDeclaration':
+ case 'TSTypeAnnotation':
+ case 'TSTypeAssertion':
+ case 'TSTypeLiteral':
+ case 'TSTypeOperator':
+ case 'TSTypeParameter':
+ case 'TSTypeParameterDeclaration':
+ case 'TSTypeParameterInstantiation':
+ case 'TSTypePredicate':
+ case 'TSTypeQuery':
+ case 'TSTypeReference':
+ case 'TSUndefinedKeyword':
+ case 'TSUnionType':
+ case 'TSUnknownKeyword':
+ case 'TSVoidKeyword': {
+ // visitUnknownNode()
+ break;
+ }
+ default: {
+ // visitUnknownNode()
debug(`Unknown node type: ${node.type}`);
+ }
}
}
- function visitProgram(node: estree.Program) {
+ function visitProgram(node: TSESTree.Program) {
return {
sourceType: node.sourceType,
body: node.body.map(visitNode),
};
}
- function visitExportAllDeclaration(node: estree.ExportAllDeclaration) {
+ function visitExportAllDeclaration(node: TSESTree.ExportAllDeclaration) {
return {
exported: visitNode(node.exported),
source: visitNode(node.source),
};
}
- function visitLiteral(node: estree.Literal) {
+ function visitLiteral(node: TSESTree.Literal) {
if ('bigint' in node) {
return {
value: node.value,
@@ -268,26 +368,26 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
}
}
- function visitIdentifier(node: estree.Identifier) {
+ function visitIdentifier(node: TSESTree.Identifier) {
return {
name: node.name,
};
}
- function visitExportDefaultDeclaration(node: estree.ExportDefaultDeclaration) {
+ function visitExportDefaultDeclaration(node: TSESTree.ExportDefaultDeclaration) {
return {
declaration: visitNode(node.declaration),
};
}
- function visitYieldExpression(node: estree.YieldExpression) {
+ function visitYieldExpression(node: TSESTree.YieldExpression) {
return {
argument: visitNode(node.argument),
delegate: node.delegate,
};
}
- function visitUpdateExpression(node: estree.UpdateExpression) {
+ function visitUpdateExpression(node: TSESTree.UpdateExpression) {
return {
operator: node.operator,
argument: visitNode(node.argument),
@@ -295,7 +395,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitUnaryExpression(node: estree.UnaryExpression) {
+ function visitUnaryExpression(node: TSESTree.UnaryExpression) {
return {
operator: node.operator,
argument: visitNode(node.argument),
@@ -303,43 +403,43 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitThisExpression(_node: estree.ThisExpression) {
+ function visitThisExpression(_node: TSESTree.ThisExpression) {
return {};
}
- function visitTemplateLiteral(node: estree.TemplateLiteral) {
+ function visitTemplateLiteral(node: TSESTree.TemplateLiteral) {
return {
quasis: node.quasis.map(visitNode),
expressions: node.expressions.map(visitNode),
};
}
- function visitTaggedTemplateExpression(node: estree.TaggedTemplateExpression) {
+ function visitTaggedTemplateExpression(node: TSESTree.TaggedTemplateExpression) {
return {
tag: visitNode(node.tag),
quasi: visitNode(node.quasi),
};
}
- function visitSequenceExpression(node: estree.SequenceExpression) {
+ function visitSequenceExpression(node: TSESTree.SequenceExpression) {
return {
expressions: node.expressions.map(visitNode),
};
}
- function visitObjectExpression(node: estree.ObjectExpression) {
+ function visitObjectExpression(node: TSESTree.ObjectExpression) {
return {
properties: node.properties.map(visitNode),
};
}
- function visitSpreadElement(node: estree.SpreadElement) {
+ function visitSpreadElement(node: TSESTree.SpreadElement) {
return {
argument: visitNode(node.argument),
};
}
- function visitProperty(node: estree.Property) {
+ function visitProperty(node: TSESTree.Property) {
return {
key: visitNode(node.key),
value: visitNode(node.value),
@@ -350,57 +450,57 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitAssignmentPattern(node: estree.AssignmentPattern) {
+ function visitAssignmentPattern(node: TSESTree.AssignmentPattern) {
return {
left: visitNode(node.left),
right: visitNode(node.right),
};
}
- function visitRestElement(node: estree.RestElement) {
+ function visitRestElement(node: TSESTree.RestElement) {
return {
argument: visitNode(node.argument),
};
}
- function visitArrayPattern(node: estree.ArrayPattern) {
+ function visitArrayPattern(node: TSESTree.ArrayPattern) {
// When an entry is empty, it is represented as null in the array.
return {
elements: node.elements.map(visitArrayElement),
};
}
- function visitObjectPattern(node: estree.ObjectPattern) {
+ function visitObjectPattern(node: TSESTree.ObjectPattern) {
return {
properties: node.properties.map(visitNode),
};
}
- function visitPrivateIdentifier(node: estree.PrivateIdentifier) {
+ function visitPrivateIdentifier(node: TSESTree.PrivateIdentifier) {
return {
name: node.name,
};
}
- function visitNewExpression(node: estree.NewExpression) {
+ function visitNewExpression(node: TSESTree.NewExpression) {
return {
callee: visitNode(node.callee),
arguments: node.arguments.map(visitNode),
};
}
- function visitSuper(_node: estree.Super) {
+ function visitSuper(_node: TSESTree.Super) {
return {};
}
- function visitMetaProperty(node: estree.MetaProperty) {
+ function visitMetaProperty(node: TSESTree.MetaProperty) {
return {
meta: visitNode(node.meta),
property: visitNode(node.property),
};
}
- function visitMemberExpression(node: estree.MemberExpression) {
+ function visitMemberExpression(node: TSESTree.MemberExpression) {
return {
object: visitNode(node.object),
property: visitNode(node.property),
@@ -409,7 +509,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitLogicalExpression(node: estree.LogicalExpression) {
+ function visitLogicalExpression(node: TSESTree.LogicalExpression) {
return {
operator: node.operator,
left: visitNode(node.left),
@@ -417,19 +517,19 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitImportExpression(node: estree.ImportExpression) {
+ function visitImportExpression(node: TSESTree.ImportExpression) {
return {
source: visitNode(node.source),
};
}
- function visitBlockStatement(node: estree.BlockStatement) {
+ function visitBlockStatement(node: TSESTree.BlockStatement) {
return {
body: node.body.map(visitNode),
};
}
- function visitConditionalExpression(node: estree.ConditionalExpression) {
+ function visitConditionalExpression(node: TSESTree.ConditionalExpression) {
return {
test: visitNode(node.test),
consequent: visitNode(node.consequent),
@@ -437,7 +537,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitClassExpression(node: estree.ClassExpression) {
+ function visitClassExpression(node: TSESTree.ClassExpression) {
return {
id: visitNode(node.id),
superClass: visitNode(node.superClass),
@@ -445,19 +545,19 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitClassBody(node: estree.ClassBody) {
+ function visitClassBody(node: TSESTree.ClassBody) {
return {
body: node.body.map(visitNode),
};
}
- function visitStaticBlock(node: estree.StaticBlock) {
+ function visitStaticBlock(node: TSESTree.StaticBlock) {
return {
body: node.body.map(visitNode),
};
}
- function visitPropertyDefinition(node: estree.PropertyDefinition) {
+ function visitPropertyDefinition(node: TSESTree.PropertyDefinition) {
return {
key: visitNode(node.key),
value: visitNode(node.value),
@@ -466,7 +566,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitMethodDefinition(node: estree.MethodDefinition) {
+ function visitMethodDefinition(node: TSESTree.MethodDefinition) {
return {
key: visitNode(node.key),
value: visitNode(node.value),
@@ -476,13 +576,13 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitChainExpression(node: estree.ChainExpression) {
+ function visitChainExpression(node: TSESTree.ChainExpression) {
return {
expression: visitNode(node.expression),
};
}
- function visitCallExpression(node: estree.SimpleCallExpression) {
+ function visitCallExpression(node: TSESTree.CallExpression) {
return {
optional: node.optional,
callee: visitNode(node.callee),
@@ -490,7 +590,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitBinaryExpression(node: estree.BinaryExpression) {
+ function visitBinaryExpression(node: TSESTree.BinaryExpression) {
return {
operator: node.operator,
left: visitNode(node.left),
@@ -498,13 +598,13 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitAwaitExpression(node: estree.AwaitExpression) {
+ function visitAwaitExpression(node: TSESTree.AwaitExpression) {
return {
argument: visitNode(node.argument),
};
}
- function visitAssignmentExpression(node: estree.AssignmentExpression) {
+ function visitAssignmentExpression(node: TSESTree.AssignmentExpression) {
return {
operator: node.operator,
left: visitNode(node.left),
@@ -512,7 +612,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitArrowFunctionExpression(node: estree.ArrowFunctionExpression) {
+ function visitArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression) {
return {
expression: node.expression,
body: visitNode(node.body),
@@ -522,7 +622,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitArrayExpression(node: estree.ArrayExpression) {
+ function visitArrayExpression(node: TSESTree.ArrayExpression) {
// When an entry is empty, it is represented as null in the array.
return {
elements: node.elements.map(visitArrayElement),
@@ -530,14 +630,14 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
}
function visitArrayElement(
- element: estree.Pattern | estree.Expression | estree.SpreadElement | null,
+ element: TSESTree.DestructuringPattern | TSESTree.Expression | TSESTree.SpreadElement | null,
) {
return {
element: visitNode(element),
};
}
- function visitClassDeclaration(node: estree.MaybeNamedClassDeclaration) {
+ function visitClassDeclaration(node: TSESTree.ClassDeclaration) {
return {
id: visitNode(node.id),
superClass: visitNode(node.superClass),
@@ -545,7 +645,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitFunctionDeclaration(node: estree.MaybeNamedFunctionDeclaration) {
+ function visitFunctionDeclaration(node: TSESTree.FunctionDeclaration) {
return {
id: visitNode(node.id),
body: visitNode(node.body),
@@ -555,7 +655,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitExportNamedDeclaration(node: estree.ExportNamedDeclaration) {
+ function visitExportNamedDeclaration(node: TSESTree.ExportNamedDeclaration) {
return {
declaration: visitNode(node.declaration),
specifiers: node.specifiers.map(visitNode),
@@ -563,54 +663,54 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitExportSpecifier(node: estree.ExportSpecifier) {
+ function visitExportSpecifier(node: TSESTree.ExportSpecifier) {
return {
exported: visitNode(node.exported),
local: visitNode(node.local),
};
}
- function visitVariableDeclaration(node: estree.VariableDeclaration) {
+ function visitVariableDeclaration(node: TSESTree.VariableDeclaration) {
return {
declarations: node.declarations.map(visitNode),
kind: node.kind,
};
}
- function visitVariableDeclarator(node: estree.VariableDeclarator) {
+ function visitVariableDeclarator(node: TSESTree.VariableDeclarator) {
return {
id: visitNode(node.id),
init: visitNode(node.init),
};
}
- function visitImportDeclaration(node: estree.ImportDeclaration) {
+ function visitImportDeclaration(node: TSESTree.ImportDeclaration) {
return {
specifiers: node.specifiers.map(visitNode),
source: visitNode(node.source),
};
}
- function visitImportNamespaceSpecifier(node: estree.ImportNamespaceSpecifier) {
+ function visitImportNamespaceSpecifier(node: TSESTree.ImportNamespaceSpecifier) {
return {
local: visitNode(node.local),
};
}
- function visitImportDefaultSpecifier(node: estree.ImportDefaultSpecifier) {
+ function visitImportDefaultSpecifier(node: TSESTree.ImportDefaultSpecifier) {
return {
local: visitNode(node.local),
};
}
- function visitImportSpecifier(node: estree.ImportSpecifier) {
+ function visitImportSpecifier(node: TSESTree.ImportSpecifier) {
return {
imported: visitNode(node.imported),
local: visitNode(node.local),
};
}
- function visitForOfStatement(node: estree.ForOfStatement) {
+ function visitForOfStatement(node: TSESTree.ForOfStatement) {
return {
await: node.await,
left: visitNode(node.left),
@@ -619,7 +719,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitForInStatement(node: estree.ForInStatement) {
+ function visitForInStatement(node: TSESTree.ForInStatement) {
return {
left: visitNode(node.left),
right: visitNode(node.right),
@@ -627,7 +727,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitForStatement(node: estree.ForStatement) {
+ function visitForStatement(node: TSESTree.ForStatement) {
return {
init: visitNode(node.init),
test: visitNode(node.test),
@@ -636,21 +736,21 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitDoWhileStatement(node: estree.DoWhileStatement) {
+ function visitDoWhileStatement(node: TSESTree.DoWhileStatement) {
return {
body: visitNode(node.body),
test: visitNode(node.test),
};
}
- function visitWhileStatement(node: estree.WhileStatement) {
+ function visitWhileStatement(node: TSESTree.WhileStatement) {
return {
test: visitNode(node.test),
body: visitNode(node.body),
};
}
- function visitTryStatement(node: estree.TryStatement) {
+ function visitTryStatement(node: TSESTree.TryStatement) {
return {
block: visitNode(node.block),
handler: visitNode(node.handler),
@@ -658,34 +758,34 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitCatchClause(node: estree.CatchClause) {
+ function visitCatchClause(node: TSESTree.CatchClause) {
return {
param: visitNode(node.param),
body: visitNode(node.body),
};
}
- function visitThrowStatement(node: estree.ThrowStatement) {
+ function visitThrowStatement(node: TSESTree.ThrowStatement) {
return {
argument: visitNode(node.argument),
};
}
- function visitSwitchStatement(node: estree.SwitchStatement) {
+ function visitSwitchStatement(node: TSESTree.SwitchStatement) {
return {
discriminant: visitNode(node.discriminant),
cases: node.cases.map(visitNode),
};
}
- function visitSwitchCase(node: estree.SwitchCase) {
+ function visitSwitchCase(node: TSESTree.SwitchCase) {
return {
test: visitNode(node.test),
consequent: node.consequent.map(visitNode),
};
}
- function visitIfStatement(node: estree.IfStatement) {
+ function visitIfStatement(node: TSESTree.IfStatement) {
return {
test: visitNode(node.test),
consequent: visitNode(node.consequent),
@@ -693,48 +793,48 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitContinueStatement(node: estree.ContinueStatement) {
+ function visitContinueStatement(node: TSESTree.ContinueStatement) {
return {
label: visitNode(node.label),
};
}
- function visitBreakStatement(node: estree.BreakStatement) {
+ function visitBreakStatement(node: TSESTree.BreakStatement) {
return {
label: visitNode(node.label),
};
}
- function visitLabeledStatement(node: estree.LabeledStatement) {
+ function visitLabeledStatement(node: TSESTree.LabeledStatement) {
return {
label: visitNode(node.label),
body: visitNode(node.body),
};
}
- function visitReturnStatement(node: estree.ReturnStatement) {
+ function visitReturnStatement(node: TSESTree.ReturnStatement) {
return {
argument: visitNode(node.argument),
};
}
- function visitWithStatement(node: estree.WithStatement) {
+ function visitWithStatement(node: TSESTree.WithStatement) {
return {
object: visitNode(node.object),
body: visitNode(node.body),
};
}
- function visitDebuggerStatement(_node: estree.DebuggerStatement) {
+ function visitDebuggerStatement(_node: TSESTree.DebuggerStatement) {
return {};
}
- function visitEmptyStatement(_node: estree.EmptyStatement) {
+ function visitEmptyStatement(_node: TSESTree.EmptyStatement) {
return {};
}
- function visitExpressionStatement(node: estree.ExpressionStatement) {
- if ('directive' in node) {
+ function visitExpressionStatement(node: TSESTree.ExpressionStatement) {
+ if (node.directive !== undefined) {
return {
expression: visitNode(node.expression),
directive: node.directive,
@@ -746,7 +846,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
}
}
- function visitTemplateElement(node: estree.TemplateElement) {
+ function visitTemplateElement(node: TSESTree.TemplateElement) {
return {
tail: node.tail,
cooked: node.value.cooked,
@@ -754,7 +854,7 @@ export function visitNode(node: estree.BaseNodeWithoutComments | undefined | nul
};
}
- function visitFunctionExpression(node: estree.FunctionExpression) {
+ function visitFunctionExpression(node: TSESTree.FunctionExpression) {
return {
id: visitNode(node.id),
body: visitNode(node.body),
diff --git a/packages/jsts/tests/parsers/ast.test.ts b/packages/jsts/tests/parsers/ast.test.ts
index fbdc0cef6be..4593c3bc286 100644
--- a/packages/jsts/tests/parsers/ast.test.ts
+++ b/packages/jsts/tests/parsers/ast.test.ts
@@ -29,6 +29,7 @@ import {
serializeInProtobuf,
} from '../../src/parsers';
import { JsTsAnalysisInput } from '../../src/analysis';
+import { TSESTree } from '@typescript-eslint/utils';
const parseFunctions = [
{
@@ -55,8 +56,8 @@ describe('ast', () => {
async ({ parser, usingBabel }) => {
const filePath = path.join(__dirname, 'fixtures', 'ast', 'base.js');
const sc = await parseSourceCode(filePath, parser, usingBabel);
- const protoMessage = parseInProtobuf(sc.ast);
- const serialized = serializeInProtobuf(sc.ast);
+ const protoMessage = parseInProtobuf(sc.ast as TSESTree.Program);
+ const serialized = serializeInProtobuf(sc.ast as TSESTree.Program);
const deserializedProtoMessage = deserializeProtobuf(serialized);
compareASTs(protoMessage, deserializedProtoMessage);
},