oxc-parser 0.90.0 → 0.91.0

package/README.md

@@ -39,7 +39,13 @@ import { Statement } from '@oxc-project/types';
 
 ### Visitor
 
-[oxc-walker](https://www.npmjs.com/package/oxc-walker) or [estree-walker](https://www.npmjs.com/package/estree-walker) can be used.
+An AST visitor is provided. See example below.
+
+This package also exports visitor keys which can be used with any other ESTree walker.
+
+```js
+import { visitorKeys } from 'oxc-parser';
+```
 
 ### Fast Mode
 
@@ -93,15 +99,15 @@ export interface EcmaScriptModule {
 ## API
 
 ```javascript
-import oxc from 'oxc-parser';
+import { parseSync, Visitor } from 'oxc-parser';
 
 const code = 'const url: String = /* 🤨 */ import.meta.url;';
 
 // File extension is used to determine which dialect to parse source as.
 const filename = 'test.tsx';
 
-const result = oxc.parseSync(filename, code);
-// or `await oxc.parseAsync(filename, code)`
+const result = parseSync(filename, code);
+// or `await parseAsync(filename, code)`
 
 // An array of errors, if any.
 console.log(result.errors);
@@ -111,6 +117,26 @@ console.log(result.program, result.comments);
 
 // ESM information - imports, exports, `import.meta`s.
 console.log(result.module);
+
+// Visit the AST
+const visitations = [];
+
+const visitor = new Visitor({
+  VariableDeclaration(decl) {
+    visitations.push(`enter ${decl.kind}`);
+  },
+  'VariableDeclaration:exit'(decl) {
+    visitations.push(`exit ${decl.kind}`);
+  },
+  Identifier(ident) {
+    visitations.push(ident.name);
+  },
+});
+
+visitor.visit(result.program);
+
+// Logs: [ 'enter const', 'url', 'String', 'import', 'meta', 'url', 'exit const' ]
+console.log(visitations);
 ```
 
 ### Options

package/generated/deserialize/js.mjs

@@ -1371,12 +1371,16 @@ function deserializeTSIntersectionType(pos) {
 }
 
 function deserializeTSParenthesizedType(pos) {
-  return {
-    type: 'TSParenthesizedType',
-    typeAnnotation: deserializeTSType(pos + 8),
-    start: deserializeU32(pos),
-    end: deserializeU32(pos + 4),
-  };
+  let node = deserializeTSType(pos + 8);
+  if (preserveParens) {
+    node = {
+      type: 'TSParenthesizedType',
+      typeAnnotation: node,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
+    };
+  }
+  return node;
 }
 
 function deserializeTSTypeOperator(pos) {

package/generated/deserialize/ts.mjs

@@ -1502,12 +1502,16 @@ function deserializeTSIntersectionType(pos) {
 }
 
 function deserializeTSParenthesizedType(pos) {
-  return {
-    type: 'TSParenthesizedType',
-    typeAnnotation: deserializeTSType(pos + 8),
-    start: deserializeU32(pos),
-    end: deserializeU32(pos + 4),
-  };
+  let node = deserializeTSType(pos + 8);
+  if (preserveParens) {
+    node = {
+      type: 'TSParenthesizedType',
+      typeAnnotation: node,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
+    };
+  }
+  return node;
 }
 
 function deserializeTSTypeOperator(pos) {

package/generated/lazy/constructors.mjs

@@ -1,8 +1,8 @@
 // Auto-generated code, DO NOT EDIT DIRECTLY!
 // To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer_lazy.rs`.
 
-import { constructorError, TOKEN } from '../../raw-transfer/lazy-common.mjs';
-import { NodeArray } from '../../raw-transfer/node-array.mjs';
+import { constructorError, TOKEN } from '../../src-js/raw-transfer/lazy-common.mjs';
+import { NodeArray } from '../../src-js/raw-transfer/node-array.mjs';
 
 const textDecoder = new TextDecoder('utf-8', { ignoreBOM: true }),
   decodeStr = textDecoder.decode.bind(textDecoder),

package/generated/visit/keys.mjs

@@ -0,0 +1,172 @@
+// Auto-generated code, DO NOT EDIT DIRECTLY!
+// To edit this generated file you have to edit `tasks/ast_tools/src/generators/estree_visit.rs`.
+
+export default {
+  // Leaf nodes
+  DebuggerStatement: [],
+  EmptyStatement: [],
+  Literal: [],
+  PrivateIdentifier: [],
+  Super: [],
+  TemplateElement: [],
+  ThisExpression: [],
+  JSXClosingFragment: [],
+  JSXEmptyExpression: [],
+  JSXIdentifier: [],
+  JSXOpeningFragment: [],
+  JSXText: [],
+  TSAnyKeyword: [],
+  TSBigIntKeyword: [],
+  TSBooleanKeyword: [],
+  TSIntrinsicKeyword: [],
+  TSJSDocUnknownType: [],
+  TSNeverKeyword: [],
+  TSNullKeyword: [],
+  TSNumberKeyword: [],
+  TSObjectKeyword: [],
+  TSStringKeyword: [],
+  TSSymbolKeyword: [],
+  TSThisType: [],
+  TSUndefinedKeyword: [],
+  TSUnknownKeyword: [],
+  TSVoidKeyword: [],
+  // Non-leaf nodes
+  AccessorProperty: ['decorators', 'key', 'typeAnnotation', 'value'],
+  ArrayExpression: ['elements'],
+  ArrayPattern: ['decorators', 'elements', 'typeAnnotation'],
+  ArrowFunctionExpression: ['typeParameters', 'params', 'returnType', 'body'],
+  AssignmentExpression: ['left', 'right'],
+  AssignmentPattern: ['decorators', 'left', 'right', 'typeAnnotation'],
+  AwaitExpression: ['argument'],
+  BinaryExpression: ['left', 'right'],
+  BlockStatement: ['body'],
+  BreakStatement: ['label'],
+  CallExpression: ['callee', 'typeArguments', 'arguments'],
+  CatchClause: ['param', 'body'],
+  ChainExpression: ['expression'],
+  ClassBody: ['body'],
+  ClassDeclaration: ['decorators', 'id', 'typeParameters', 'superClass', 'superTypeArguments', 'implements', 'body'],
+  ClassExpression: ['decorators', 'id', 'typeParameters', 'superClass', 'superTypeArguments', 'implements', 'body'],
+  ConditionalExpression: ['test', 'consequent', 'alternate'],
+  ContinueStatement: ['label'],
+  Decorator: ['expression'],
+  DoWhileStatement: ['body', 'test'],
+  ExportAllDeclaration: ['exported', 'source', 'attributes'],
+  ExportDefaultDeclaration: ['declaration'],
+  ExportNamedDeclaration: ['declaration', 'specifiers', 'source', 'attributes'],
+  ExportSpecifier: ['local', 'exported'],
+  ExpressionStatement: ['expression'],
+  ForInStatement: ['left', 'right', 'body'],
+  ForOfStatement: ['left', 'right', 'body'],
+  ForStatement: ['init', 'test', 'update', 'body'],
+  FunctionDeclaration: ['id', 'typeParameters', 'params', 'returnType', 'body'],
+  FunctionExpression: ['id', 'typeParameters', 'params', 'returnType', 'body'],
+  Identifier: ['decorators', 'typeAnnotation'],
+  IfStatement: ['test', 'consequent', 'alternate'],
+  ImportAttribute: ['key', 'value'],
+  ImportDeclaration: ['specifiers', 'source', 'attributes'],
+  ImportDefaultSpecifier: ['local'],
+  ImportExpression: ['source', 'options'],
+  ImportNamespaceSpecifier: ['local'],
+  ImportSpecifier: ['imported', 'local'],
+  LabeledStatement: ['label', 'body'],
+  LogicalExpression: ['left', 'right'],
+  MemberExpression: ['object', 'property'],
+  MetaProperty: ['meta', 'property'],
+  MethodDefinition: ['decorators', 'key', 'value'],
+  NewExpression: ['callee', 'typeArguments', 'arguments'],
+  ObjectExpression: ['properties'],
+  ObjectPattern: ['decorators', 'properties', 'typeAnnotation'],
+  ParenthesizedExpression: ['expression'],
+  Program: ['body'],
+  Property: ['key', 'value'],
+  PropertyDefinition: ['decorators', 'key', 'typeAnnotation', 'value'],
+  RestElement: ['decorators', 'argument', 'typeAnnotation'],
+  ReturnStatement: ['argument'],
+  SequenceExpression: ['expressions'],
+  SpreadElement: ['argument'],
+  StaticBlock: ['body'],
+  SwitchCase: ['test', 'consequent'],
+  SwitchStatement: ['discriminant', 'cases'],
+  TaggedTemplateExpression: ['tag', 'typeArguments', 'quasi'],
+  TemplateLiteral: ['quasis', 'expressions'],
+  ThrowStatement: ['argument'],
+  TryStatement: ['block', 'handler', 'finalizer'],
+  UnaryExpression: ['argument'],
+  UpdateExpression: ['argument'],
+  V8IntrinsicExpression: ['name', 'arguments'],
+  VariableDeclaration: ['declarations'],
+  VariableDeclarator: ['id', 'init'],
+  WhileStatement: ['test', 'body'],
+  WithStatement: ['object', 'body'],
+  YieldExpression: ['argument'],
+  JSXAttribute: ['name', 'value'],
+  JSXClosingElement: ['name'],
+  JSXElement: ['openingElement', 'children', 'closingElement'],
+  JSXExpressionContainer: ['expression'],
+  JSXFragment: ['openingFragment', 'children', 'closingFragment'],
+  JSXMemberExpression: ['object', 'property'],
+  JSXNamespacedName: ['namespace', 'name'],
+  JSXOpeningElement: ['name', 'typeArguments', 'attributes'],
+  JSXSpreadAttribute: ['argument'],
+  JSXSpreadChild: ['expression'],
+  TSAbstractAccessorProperty: ['decorators', 'key', 'typeAnnotation'],
+  TSAbstractMethodDefinition: ['key', 'value'],
+  TSAbstractPropertyDefinition: ['decorators', 'key', 'typeAnnotation'],
+  TSArrayType: ['elementType'],
+  TSAsExpression: ['expression', 'typeAnnotation'],
+  TSCallSignatureDeclaration: ['typeParameters', 'params', 'returnType'],
+  TSClassImplements: ['expression', 'typeArguments'],
+  TSConditionalType: ['checkType', 'extendsType', 'trueType', 'falseType'],
+  TSConstructSignatureDeclaration: ['typeParameters', 'params', 'returnType'],
+  TSConstructorType: ['typeParameters', 'params', 'returnType'],
+  TSDeclareFunction: ['id', 'typeParameters', 'params', 'returnType', 'body'],
+  TSEmptyBodyFunctionExpression: ['id', 'typeParameters', 'params', 'returnType'],
+  TSEnumBody: ['members'],
+  TSEnumDeclaration: ['id', 'body'],
+  TSEnumMember: ['id', 'initializer'],
+  TSExportAssignment: ['expression'],
+  TSExternalModuleReference: ['expression'],
+  TSFunctionType: ['typeParameters', 'params', 'returnType'],
+  TSImportEqualsDeclaration: ['id', 'moduleReference'],
+  TSImportType: ['argument', 'options', 'qualifier', 'typeArguments'],
+  TSIndexSignature: ['parameters', 'typeAnnotation'],
+  TSIndexedAccessType: ['objectType', 'indexType'],
+  TSInferType: ['typeParameter'],
+  TSInstantiationExpression: ['expression', 'typeArguments'],
+  TSInterfaceBody: ['body'],
+  TSInterfaceDeclaration: ['id', 'typeParameters', 'extends', 'body'],
+  TSInterfaceHeritage: ['expression', 'typeArguments'],
+  TSIntersectionType: ['types'],
+  TSJSDocNonNullableType: ['typeAnnotation'],
+  TSJSDocNullableType: ['typeAnnotation'],
+  TSLiteralType: ['literal'],
+  TSMappedType: ['key', 'constraint', 'nameType', 'typeAnnotation'],
+  TSMethodSignature: ['key', 'typeParameters', 'params', 'returnType'],
+  TSModuleBlock: ['body'],
+  TSModuleDeclaration: ['id', 'body'],
+  TSNamedTupleMember: ['label', 'elementType'],
+  TSNamespaceExportDeclaration: ['id'],
+  TSNonNullExpression: ['expression'],
+  TSOptionalType: ['typeAnnotation'],
+  TSParameterProperty: ['decorators', 'parameter'],
+  TSParenthesizedType: ['typeAnnotation'],
+  TSPropertySignature: ['key', 'typeAnnotation'],
+  TSQualifiedName: ['left', 'right'],
+  TSRestType: ['typeAnnotation'],
+  TSSatisfiesExpression: ['expression', 'typeAnnotation'],
+  TSTemplateLiteralType: ['quasis', 'types'],
+  TSTupleType: ['elementTypes'],
+  TSTypeAliasDeclaration: ['id', 'typeParameters', 'typeAnnotation'],
+  TSTypeAnnotation: ['typeAnnotation'],
+  TSTypeAssertion: ['typeAnnotation', 'expression'],
+  TSTypeLiteral: ['members'],
+  TSTypeOperator: ['typeAnnotation'],
+  TSTypeParameter: ['name', 'constraint', 'default'],
+  TSTypeParameterDeclaration: ['params'],
+  TSTypeParameterInstantiation: ['params'],
+  TSTypePredicate: ['parameterName', 'typeAnnotation'],
+  TSTypeQuery: ['exprName', 'typeArguments'],
+  TSTypeReference: ['typeName', 'typeArguments'],
+  TSUnionType: ['types'],
+};

package/generated/visit/types.mjs

@@ -0,0 +1,176 @@
+// Auto-generated code, DO NOT EDIT DIRECTLY!
+// To edit this generated file you have to edit `tasks/ast_tools/src/generators/estree_visit.rs`.
+
+// Mapping from node type name to node type ID
+export const NODE_TYPE_IDS_MAP = new Map([
+  // Leaf nodes
+  ['DebuggerStatement', 0],
+  ['EmptyStatement', 1],
+  ['Literal', 2],
+  ['PrivateIdentifier', 3],
+  ['Super', 4],
+  ['TemplateElement', 5],
+  ['ThisExpression', 6],
+  ['JSXClosingFragment', 7],
+  ['JSXEmptyExpression', 8],
+  ['JSXIdentifier', 9],
+  ['JSXOpeningFragment', 10],
+  ['JSXText', 11],
+  ['TSAnyKeyword', 12],
+  ['TSBigIntKeyword', 13],
+  ['TSBooleanKeyword', 14],
+  ['TSIntrinsicKeyword', 15],
+  ['TSJSDocUnknownType', 16],
+  ['TSNeverKeyword', 17],
+  ['TSNullKeyword', 18],
+  ['TSNumberKeyword', 19],
+  ['TSObjectKeyword', 20],
+  ['TSStringKeyword', 21],
+  ['TSSymbolKeyword', 22],
+  ['TSThisType', 23],
+  ['TSUndefinedKeyword', 24],
+  ['TSUnknownKeyword', 25],
+  ['TSVoidKeyword', 26],
+  // Non-leaf nodes
+  ['AccessorProperty', 27],
+  ['ArrayExpression', 28],
+  ['ArrayPattern', 29],
+  ['ArrowFunctionExpression', 30],
+  ['AssignmentExpression', 31],
+  ['AssignmentPattern', 32],
+  ['AwaitExpression', 33],
+  ['BinaryExpression', 34],
+  ['BlockStatement', 35],
+  ['BreakStatement', 36],
+  ['CallExpression', 37],
+  ['CatchClause', 38],
+  ['ChainExpression', 39],
+  ['ClassBody', 40],
+  ['ClassDeclaration', 41],
+  ['ClassExpression', 42],
+  ['ConditionalExpression', 43],
+  ['ContinueStatement', 44],
+  ['Decorator', 45],
+  ['DoWhileStatement', 46],
+  ['ExportAllDeclaration', 47],
+  ['ExportDefaultDeclaration', 48],
+  ['ExportNamedDeclaration', 49],
+  ['ExportSpecifier', 50],
+  ['ExpressionStatement', 51],
+  ['ForInStatement', 52],
+  ['ForOfStatement', 53],
+  ['ForStatement', 54],
+  ['FunctionDeclaration', 55],
+  ['FunctionExpression', 56],
+  ['Identifier', 57],
+  ['IfStatement', 58],
+  ['ImportAttribute', 59],
+  ['ImportDeclaration', 60],
+  ['ImportDefaultSpecifier', 61],
+  ['ImportExpression', 62],
+  ['ImportNamespaceSpecifier', 63],
+  ['ImportSpecifier', 64],
+  ['LabeledStatement', 65],
+  ['LogicalExpression', 66],
+  ['MemberExpression', 67],
+  ['MetaProperty', 68],
+  ['MethodDefinition', 69],
+  ['NewExpression', 70],
+  ['ObjectExpression', 71],
+  ['ObjectPattern', 72],
+  ['ParenthesizedExpression', 73],
+  ['Program', 74],
+  ['Property', 75],
+  ['PropertyDefinition', 76],
+  ['RestElement', 77],
+  ['ReturnStatement', 78],
+  ['SequenceExpression', 79],
+  ['SpreadElement', 80],
+  ['StaticBlock', 81],
+  ['SwitchCase', 82],
+  ['SwitchStatement', 83],
+  ['TaggedTemplateExpression', 84],
+  ['TemplateLiteral', 85],
+  ['ThrowStatement', 86],
+  ['TryStatement', 87],
+  ['UnaryExpression', 88],
+  ['UpdateExpression', 89],
+  ['V8IntrinsicExpression', 90],
+  ['VariableDeclaration', 91],
+  ['VariableDeclarator', 92],
+  ['WhileStatement', 93],
+  ['WithStatement', 94],
+  ['YieldExpression', 95],
+  ['JSXAttribute', 96],
+  ['JSXClosingElement', 97],
+  ['JSXElement', 98],
+  ['JSXExpressionContainer', 99],
+  ['JSXFragment', 100],
+  ['JSXMemberExpression', 101],
+  ['JSXNamespacedName', 102],
+  ['JSXOpeningElement', 103],
+  ['JSXSpreadAttribute', 104],
+  ['JSXSpreadChild', 105],
+  ['TSAbstractAccessorProperty', 106],
+  ['TSAbstractMethodDefinition', 107],
+  ['TSAbstractPropertyDefinition', 108],
+  ['TSArrayType', 109],
+  ['TSAsExpression', 110],
+  ['TSCallSignatureDeclaration', 111],
+  ['TSClassImplements', 112],
+  ['TSConditionalType', 113],
+  ['TSConstructSignatureDeclaration', 114],
+  ['TSConstructorType', 115],
+  ['TSDeclareFunction', 116],
+  ['TSEmptyBodyFunctionExpression', 117],
+  ['TSEnumBody', 118],
+  ['TSEnumDeclaration', 119],
+  ['TSEnumMember', 120],
+  ['TSExportAssignment', 121],
+  ['TSExternalModuleReference', 122],
+  ['TSFunctionType', 123],
+  ['TSImportEqualsDeclaration', 124],
+  ['TSImportType', 125],
+  ['TSIndexSignature', 126],
+  ['TSIndexedAccessType', 127],
+  ['TSInferType', 128],
+  ['TSInstantiationExpression', 129],
+  ['TSInterfaceBody', 130],
+  ['TSInterfaceDeclaration', 131],
+  ['TSInterfaceHeritage', 132],
+  ['TSIntersectionType', 133],
+  ['TSJSDocNonNullableType', 134],
+  ['TSJSDocNullableType', 135],
+  ['TSLiteralType', 136],
+  ['TSMappedType', 137],
+  ['TSMethodSignature', 138],
+  ['TSModuleBlock', 139],
+  ['TSModuleDeclaration', 140],
+  ['TSNamedTupleMember', 141],
+  ['TSNamespaceExportDeclaration', 142],
+  ['TSNonNullExpression', 143],
+  ['TSOptionalType', 144],
+  ['TSParameterProperty', 145],
+  ['TSParenthesizedType', 146],
+  ['TSPropertySignature', 147],
+  ['TSQualifiedName', 148],
+  ['TSRestType', 149],
+  ['TSSatisfiesExpression', 150],
+  ['TSTemplateLiteralType', 151],
+  ['TSTupleType', 152],
+  ['TSTypeAliasDeclaration', 153],
+  ['TSTypeAnnotation', 154],
+  ['TSTypeAssertion', 155],
+  ['TSTypeLiteral', 156],
+  ['TSTypeOperator', 157],
+  ['TSTypeParameter', 158],
+  ['TSTypeParameterDeclaration', 159],
+  ['TSTypeParameterInstantiation', 160],
+  ['TSTypePredicate', 161],
+  ['TSTypeQuery', 162],
+  ['TSTypeReference', 163],
+  ['TSUnionType', 164],
+]);
+
+export const NODE_TYPES_COUNT = 165;
+export const LEAF_NODE_TYPES_COUNT = 27;