hermes-transform 0.6.0 → 0.7.0

package/dist/transform/comments/comments.js.flow

@@ -23,9 +23,17 @@ import {
   // $FlowExpectedError[untyped-import]
   addTrailingComment as untypedAddTrailingComment,
 } from './prettier/common/util';
+import {EOL} from 'os';
 
 export type Options = $ReadOnly<{}>;
 
+export enum CommentPlacement {
+  LEADING_OWN_LINE,
+  LEADING_INLINE,
+  TRAILING_OWN_LINE,
+  TRAILING_INLINE,
+}
+
 export function attachComments(
   comments: $ReadOnlyArray<Comment>,
   ast: Program,
@@ -80,18 +88,23 @@ export function isTrailingComment(comment: Comment): boolean {
   return comment.trailing === true;
 }
 
-export function addLeadingComment(
-  node: ESNode | DetachedNode<ESNode>,
-  comment: Comment,
-): void {
-  untypedAddLeadingComment(node, comment);
-}
-
-export function addTrailingComment(
+export function addComment(
   node: ESNode | DetachedNode<ESNode>,
   comment: Comment,
+  placement: CommentPlacement,
 ): void {
-  untypedAddTrailingComment(node, comment);
+  switch (placement) {
+    case CommentPlacement.LEADING_OWN_LINE:
+    case CommentPlacement.LEADING_INLINE: {
+      untypedAddLeadingComment(node, comment);
+      break;
+    }
+    case CommentPlacement.TRAILING_OWN_LINE:
+    case CommentPlacement.TRAILING_INLINE: {
+      untypedAddTrailingComment(node, comment);
+      break;
+    }
+  }
 }
 
 export function cloneComment<T: Comment>(comment: T): T {
@@ -116,30 +129,94 @@ export function cloneCommentWithMarkers<T: Comment>(comment: T): T {
   };
 }
 
-export function appendCommentToSource(code: string, comment: Comment): string {
-  // prettier slices comments directly from the source code when printing
-  // https://github.com/prettier/prettier/blob/5f0ee39fa03532c85bd1c35291450fe7ac3667b3/src/language-js/print/comment.js#L15-L20
-  // this means that we need to have any appended comments directly in the
-  // source code or else prettier will slice nothing and bork up the transform
+function getFirstNewlineIndex(code: string): number {
+  return code.search(/\r\n|\n|\r/);
+}
+
+function getFirstNonWhitespaceIndex(code: string): number {
+  return code.search(/\S/);
+}
 
-  let commentText = comment.value;
+export function appendCommentToSource(
+  code: string,
+  comment: Comment,
+  placement: CommentPlacement,
+): string {
+  let newCode = code;
   switch (comment.type) {
-    case 'Block':
-      commentText = `/*${commentText}*/`;
+    case 'Block': {
+      // Prettier decides if a newline is necessary between the comment and its node by looking
+      // to see if a newline seperates them in the source text. We can trick prettier into
+      // formatting how we want for new comments by placing the range such that a newline
+      // will (OWN_LINE) or will not (INLINE) be found when searching from the specified range
+      // position.
+      switch (placement) {
+        case CommentPlacement.LEADING_OWN_LINE:
+        case CommentPlacement.TRAILING_OWN_LINE: {
+          // Since we always want a line break we need to ensure a newline is found when
+          // searching out from either side of the comment range.
+          let firstNewline = getFirstNewlineIndex(code);
+          if (firstNewline === -1) {
+            // No newline in file, lets add one.
+            newCode += EOL;
+            firstNewline = newCode.length;
+          }
+          // Prettier only uses these ranges for detecting whitespace, so this nonsensical
+          // range is safe.
+          // $FlowExpectedError[cannot-write]
+          comment.range = [firstNewline + 1, firstNewline];
+          break;
+        }
+        case CommentPlacement.LEADING_INLINE:
+        case CommentPlacement.TRAILING_INLINE: {
+          // Since we don't want a line break we need to ensure a non whitespace char is
+          // always found before a newline when searching out from either side of the
+          // comment range.
+          let firstNonWhitespace = getFirstNonWhitespaceIndex(code);
+          if (firstNonWhitespace === -1) {
+            // No non whitespace chars in file, lets add an identifiable statement for prettier to find.
+            newCode += '$FORCE_INLINE_ON_EMPTY_FILE_TOKEN$;';
+            firstNonWhitespace = newCode.length;
+            break;
+          }
+
+          // $FlowExpectedError[cannot-write]
+          comment.range = [firstNonWhitespace + 1, firstNonWhitespace];
+          break;
+        }
+      }
       break;
-    case 'Line':
-      commentText = `//${commentText}`;
+    }
+    case 'Line': {
+      // For `Line` comments prettier slices comments directly from the source code when printing
+      // https://github.com/prettier/prettier/blob/5f0ee39fa03532c85bd1c35291450fe7ac3667b3/src/language-js/print/comment.js#L15-L20
+      // this means that we need to have any appended comments directly in the
+      // source code or else prettier will slice nothing and bork up the transform
+      const commentText = `//${comment.value}`;
+
+      const lastChar = newCode[newCode.length - 1];
+      if (lastChar !== '\n' && lastChar !== '\r') {
+        newCode += EOL;
+      }
+
+      // Line comments cannot be inline before a node so we only place trailing Line comments inline.
+      if (placement === CommentPlacement.TRAILING_INLINE) {
+        // Prettier determines an "end of line" comment by walking backwards from
+        // the comment start range through the source code to see if it finds a non
+        // newline token. In order to trick prettier for new comments we need to
+        // insert fake source code for it to find.
+        newCode += '$FORCE_END_OF_LINE_COMMENT_TOKEN$;';
+      }
+      const start = newCode.length;
+      newCode += commentText;
+      const end = newCode.length;
+
+      // $FlowExpectedError[cannot-write]
+      comment.range = [start, end];
+
       break;
+    }
   }
 
-  let newCode = code;
-  newCode += '\n';
-  const start = newCode.length;
-  newCode += commentText;
-  const end = newCode.length;
-
-  // $FlowExpectedError[cannot-write]
-  comment.range = [start, end];
-
   return newCode;
 }

package/dist/transform/getTransformedAST.js

@@ -26,9 +26,7 @@ var _TransformContext = require("./TransformContext");
 
 var _comments = require("./comments/comments");
 
-var _AddLeadingComments = require("./mutations/AddLeadingComments");
-
-var _AddTrailingComments = require("./mutations/AddTrailingComments");
+var _AddComments = require("./mutations/AddComments");
 
 var _CloneCommentsTo = require("./mutations/CloneCommentsTo");
 
@@ -55,8 +53,8 @@ function getTransformedAST(code, visitors) {
 
   (0, _comments.attachComments)(ast.comments, ast, code); // traverse the AST and colllect the mutations
 
-  const transformContext = (0, _TransformContext.getTransformContext)(code);
-  (0, _traverse.traverseWithContext)(ast, scopeManager, () => transformContext, visitors); // apply the mutations to the AST
+  const transformContext = (0, _TransformContext.getTransformContext)();
+  (0, _traverse.traverseWithContext)(code, ast, scopeManager, () => transformContext, visitors); // apply the mutations to the AST
 
   const mutationContext = new _MutationContext.MutationContext(code);
   const removeCommentMutations = [];
@@ -96,14 +94,9 @@ function getTransformedAST(code, visitors) {
             return null;
           }
 
-        case 'addLeadingComments':
-          {
-            return (0, _AddLeadingComments.performAddLeadingCommentsMutation)(mutationContext, mutation);
-          }
-
-        case 'addTrailingComments':
+        case 'addComments':
           {
-            return (0, _AddTrailingComments.performAddTrailingCommentsMutation)(mutationContext, mutation);
+            return (0, _AddComments.performAddCommentsMutation)(mutationContext, mutation);
           }
 
         case 'cloneCommentsTo':

package/dist/transform/getTransformedAST.js.flow

@@ -11,8 +11,7 @@
 'use strict';
 
 import type {ESNode, Program} from 'hermes-estree';
-import type {Visitor} from '../traverse/traverse';
-import type {TransformContext} from './TransformContext';
+import type {TransformVisitor} from './transform';
 import type {RemoveCommentMutation} from './mutations/RemoveComment';
 
 import {parseForESLint} from 'hermes-eslint';
@@ -21,8 +20,7 @@ import {traverseWithContext} from '../traverse/traverse';
 import {MutationContext} from './MutationContext';
 import {getTransformContext} from './TransformContext';
 import {attachComments} from './comments/comments';
-import {performAddLeadingCommentsMutation} from './mutations/AddLeadingComments';
-import {performAddTrailingCommentsMutation} from './mutations/AddTrailingComments';
+import {performAddCommentsMutation} from './mutations/AddComments';
 import {performCloneCommentsToMutation} from './mutations/CloneCommentsTo';
 import {performInsertStatementMutation} from './mutations/InsertStatement';
 import {performRemoveCommentMutations} from './mutations/RemoveComment';
@@ -33,7 +31,7 @@ import {performReplaceStatementWithManyMutation} from './mutations/ReplaceStatem
 
 export function getTransformedAST(
   code: string,
-  visitors: Visitor<TransformContext>,
+  visitors: TransformVisitor,
 ): {
   ast: Program,
   astWasMutated: boolean,
@@ -48,8 +46,14 @@ export function getTransformedAST(
   attachComments(ast.comments, ast, code);
 
   // traverse the AST and colllect the mutations
-  const transformContext = getTransformContext(code);
-  traverseWithContext(ast, scopeManager, () => transformContext, visitors);
+  const transformContext = getTransformContext();
+  traverseWithContext(
+    code,
+    ast,
+    scopeManager,
+    () => transformContext,
+    visitors,
+  );
 
   // apply the mutations to the AST
   const mutationContext = new MutationContext(code);
@@ -88,12 +92,8 @@ export function getTransformedAST(
           return null;
         }
 
-        case 'addLeadingComments': {
-          return performAddLeadingCommentsMutation(mutationContext, mutation);
-        }
-
-        case 'addTrailingComments': {
-          return performAddTrailingCommentsMutation(mutationContext, mutation);
+        case 'addComments': {
+          return performAddCommentsMutation(mutationContext, mutation);
         }
 
         case 'cloneCommentsTo': {

package/dist/transform/mutations/{AddLeadingComments.js → AddComments.js}

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createAddLeadingCommentsMutation = createAddLeadingCommentsMutation;
-exports.performAddLeadingCommentsMutation = performAddLeadingCommentsMutation;
+exports.createAddCommentsMutation = createAddCommentsMutation;
+exports.performAddCommentsMutation = performAddCommentsMutation;
 
 var _comments = require("../comments/comments");
 
@@ -17,23 +17,26 @@ var _comments = require("../comments/comments");
  * 
  * @format
  */
-function createAddLeadingCommentsMutation(node, comments) {
+function createAddCommentsMutation(node, comments) {
   if (comments.length === 0) {
     return null;
   }
 
   return {
-    type: 'addLeadingComments',
+    type: 'addComments',
     comments,
     node
   };
 }
 
-function performAddLeadingCommentsMutation(mutationContext, mutation) {
-  for (const originalComment of mutation.comments) {
+function performAddCommentsMutation(mutationContext, mutation) {
+  for (const {
+    comment: originalComment,
+    placement
+  } of mutation.comments) {
     const comment = (0, _comments.cloneComment)(originalComment);
-    mutationContext.appendCommentToSource(comment);
-    (0, _comments.addLeadingComment)(mutation.node, comment);
+    mutationContext.appendCommentToSource(comment, placement);
+    (0, _comments.addComment)(mutation.node, comment, placement);
   }
 
   return null;

package/dist/transform/mutations/AddComments.js.flow

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type {Comment, ESNode} from 'hermes-estree';
+import type {DetachedNode} from '../../detachedNode';
+import type {MutationContext} from '../MutationContext';
+import type {CommentPlacement} from '../comments/comments';
+
+import {addComment, cloneComment} from '../comments/comments';
+
+export type AddCommentsMutation = $ReadOnly<{
+  type: 'addComments',
+  comments: $ReadOnlyArray<{comment: Comment, placement: CommentPlacement}>,
+  node: ESNode | DetachedNode<ESNode>,
+}>;
+
+export function createAddCommentsMutation(
+  node: AddCommentsMutation['node'],
+  comments: AddCommentsMutation['comments'],
+): ?AddCommentsMutation {
+  if (comments.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'addComments',
+    comments,
+    node,
+  };
+}
+
+export function performAddCommentsMutation(
+  mutationContext: MutationContext,
+  mutation: AddCommentsMutation,
+): null {
+  for (const {comment: originalComment, placement} of mutation.comments) {
+    const comment = cloneComment(originalComment);
+    mutationContext.appendCommentToSource(comment, placement);
+    addComment(mutation.node, comment, placement);
+  }
+
+  return null;
+}

package/dist/transform/mutations/CloneCommentsTo.js

@@ -25,12 +25,11 @@ function createCloneCommentsToMutation(target, destination) {
   };
 }
 
-function performCloneCommentsToMutation(mutationContext, mutation) {
+function performCloneCommentsToMutation(_mutationContext, mutation) {
   const newComments = [];
 
   for (const originalComment of (0, _comments.getCommentsForNode)(mutation.target)) {
     const comment = (0, _comments.cloneCommentWithMarkers)(originalComment);
-    mutationContext.appendCommentToSource(comment);
     newComments.push(comment);
   }
 

package/dist/transform/mutations/CloneCommentsTo.js.flow

@@ -36,13 +36,12 @@ export function createCloneCommentsToMutation(
 }
 
 export function performCloneCommentsToMutation(
-  mutationContext: MutationContext,
+  _mutationContext: MutationContext,
   mutation: CloneCommentsToMutation,
 ): null {
   const newComments = [];
   for (const originalComment of getCommentsForNode(mutation.target)) {
     const comment = cloneCommentWithMarkers(originalComment);
-    mutationContext.appendCommentToSource(comment);
     newComments.push(comment);
   }
   addCommentsToNode(mutation.destination, newComments);

package/dist/transform/mutations/InsertStatement.js

@@ -57,7 +57,7 @@ function performInsertStatementMutation(mutationContext, mutation) {
     switch (mutation.side) {
       case 'before':
         {
-          parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(parent[insertionParent.key], insertionParent.targetIndex - 1, mutation.nodesToInsert);
+          parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(parent[insertionParent.key], insertionParent.targetIndex, mutation.nodesToInsert);
           break;
         }
 

package/dist/transform/mutations/InsertStatement.js.flow

@@ -70,7 +70,7 @@ export function performInsertStatementMutation(
       case 'before': {
         parent[insertionParent.key] = insertInArray(
           parent[insertionParent.key],
-          insertionParent.targetIndex - 1,
+          insertionParent.targetIndex,
           mutation.nodesToInsert,
         );
         break;

package/dist/transform/mutations/utils/arrayUtils.js

@@ -16,14 +16,28 @@ exports.replaceInArray = replaceInArray;
  * 
  * @format
  */
+function assertArrayBounds(array, index) {
+  if (index < 0 || index >= array.length) {
+    throw new Error(`Invalid Mutation: Tried to mutate an elements array with an out of bounds index. Index: ${index}, Array Size: ${array.length}`);
+  }
+}
+
 function insertInArray(array, index, elements) {
+  if (index === array.length) {
+    // Support the insert at end of array case.
+    return array.concat(elements);
+  }
+
+  assertArrayBounds(array, index);
   return array.slice(0, index).concat(elements).concat(array.slice(index));
 }
 
 function removeFromArray(array, index) {
+  assertArrayBounds(array, index);
   return [...array.slice(0, index), ...array.slice(index + 1)];
 }
 
 function replaceInArray(array, index, elements) {
+  assertArrayBounds(array, index);
   return array.slice(0, index).concat(elements).concat(array.slice(index + 1));
 }

package/dist/transform/mutations/utils/arrayUtils.js.flow

@@ -8,11 +8,24 @@
  * @format
  */
 
+function assertArrayBounds<T>(array: $ReadOnlyArray<T>, index: number): void {
+  if (index < 0 || index >= array.length) {
+    throw new Error(
+      `Invalid Mutation: Tried to mutate an elements array with an out of bounds index. Index: ${index}, Array Size: ${array.length}`,
+    );
+  }
+}
+
 export function insertInArray<T>(
   array: $ReadOnlyArray<T>,
   index: number,
   elements: $ReadOnlyArray<T>,
 ): Array<T> {
+  if (index === array.length) {
+    // Support the insert at end of array case.
+    return array.concat(elements);
+  }
+  assertArrayBounds(array, index);
   return array.slice(0, index).concat(elements).concat(array.slice(index));
 }
 
@@ -20,6 +33,7 @@ export function removeFromArray<T>(
   array: $ReadOnlyArray<T>,
   index: number,
 ): Array<T> {
+  assertArrayBounds(array, index);
   return [...array.slice(0, index), ...array.slice(index + 1)];
 }
 
@@ -28,6 +42,7 @@ export function replaceInArray<T>(
   index: number,
   elements: $ReadOnlyArray<T>,
 ): Array<T> {
+  assertArrayBounds(array, index);
   return array
     .slice(0, index)
     .concat(elements)

package/dist/transform/transform.js.flow

@@ -11,13 +11,13 @@
 'use strict';
 
 import type {Visitor} from '../traverse/traverse';
-import type {TransformContext} from './TransformContext';
+import type {TransformContextAdditions} from './TransformContext';
 
 import * as prettier from 'prettier';
 import {getTransformedAST} from './getTransformedAST';
 import {SimpleTraverser} from '../traverse/SimpleTraverser';
 
-export type TransformVisitor = Visitor<TransformContext>;
+export type TransformVisitor = Visitor<TransformContextAdditions>;
 
 export function transform(
   originalCode: string,

package/dist/traverse/traverse.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.traverse = traverse;
 exports.traverseWithContext = traverseWithContext;
 
+var _codeFrame = require("@babel/code-frame");
+
 var _NodeEventGenerator = require("./NodeEventGenerator");
 
 var _SafeEmitter = require("./SafeEmitter");
@@ -28,7 +30,7 @@ var _SimpleTraverser = require("./SimpleTraverser");
  * @param scopeManager the eslint-scope compatible scope manager instance calculated using the ast
  * @param additionalContext a callback function which returns additional context members to add to the context provided to the visitor
  */
-function traverseWithContext(ast, scopeManager, additionalContext, visitor) {
+function traverseWithContext(code, ast, scopeManager, additionalContext, visitor) {
   const emitter = new _SafeEmitter.SafeEmitter();
   const nodeQueue = [];
   let currentNode = ast; // set parent pointers and build up the traversal queue
@@ -72,6 +74,28 @@ function traverseWithContext(ast, scopeManager, additionalContext, visitor) {
   };
 
   const traversalContextBase = Object.freeze({
+    buildCodeFrame: (node, message) => {
+      // babel uses 1-indexed columns
+      const locForBabel = {
+        start: {
+          line: node.loc.start.line,
+          column: node.loc.start.column + 1
+        },
+        end: {
+          line: node.loc.end.line,
+          column: node.loc.end.column + 1
+        }
+      };
+      return (0, _codeFrame.codeFrameColumns)(code, locForBabel, {
+        linesAbove: 0,
+        linesBelow: 0,
+        highlightCode: process.env.NODE_ENV !== 'test',
+        message: message
+      });
+    },
+    buildSimpleCodeFrame: (node, message) => {
+      return `[${node.type}:${node.loc.start.line}:${node.loc.start.column}] ${message}`;
+    },
     getDeclaredVariables: node => scopeManager.getDeclaredVariables(node),
     getBinding: name => {
       let currentScope = getScope();
@@ -122,6 +146,6 @@ function traverseWithContext(ast, scopeManager, additionalContext, visitor) {
   });
 }
 
-function traverse(ast, scopeManager, visitor) {
-  traverseWithContext(ast, scopeManager, () => {}, visitor);
+function traverse(code, ast, scopeManager, visitor) {
+  traverseWithContext(code, ast, scopeManager, () => {}, visitor);
 }

package/dist/traverse/traverse.js.flow

@@ -12,11 +12,12 @@ import type {ESNode, ESQueryNodeSelectors, Program} from 'hermes-estree';
 import type {ScopeManager, Scope, Variable} from 'hermes-eslint';
 import type {EmitterListener} from './SafeEmitter';
 
+import {codeFrameColumns} from '@babel/code-frame';
 import {NodeEventGenerator} from './NodeEventGenerator';
 import {SafeEmitter} from './SafeEmitter';
 import {SimpleTraverser} from './SimpleTraverser';
 
-export type TraversalContext<T = void> = $ReadOnly<{
+export type TraversalContextBase = $ReadOnly<{
   /**
    * Gets the variables that were declared by the given node.
    */
@@ -31,13 +32,36 @@ export type TraversalContext<T = void> = $ReadOnly<{
    * Defaults to the currently traversed node.
    */
   getScope: (node?: ESNode) => Scope,
-
+  /**
+   * Creates a full code frame for the node along with the message.
+   *
+   * i.e. `context.buildCodeFrame(node, 'foo')` will create a string like:
+   * ```
+   * 56 | function () {
+   *    | ^^^^^^^^^^^^^
+   * 57 | }.bind(this)
+   *    | ^^ foo
+   * ```
+   */
+  buildCodeFrame: (node: ESNode, message: string) => string,
+  /**
+   * Creates a simple code frame for the node along with the message.
+   * Use this if you want a condensed marker for your message.
+   *
+   * i.e. `context.logWithNode(node, 'foo')` will create a string like:
+   * ```
+   * [FunctionExpression:56:44] foo
+   * ```
+   * (where 56:44 represents L56, Col44)
+   */
+  buildSimpleCodeFrame: (node: ESNode, message: string) => string,
+}>;
+export type TraversalContext<T> = $ReadOnly<{
+  ...TraversalContextBase,
   ...T,
 }>;
 
-export type Visitor<T = void> = (
-  context: TraversalContext<T>,
-) => ESQueryNodeSelectors;
+export type Visitor<T> = (context: TraversalContext<T>) => ESQueryNodeSelectors;
 
 /**
  * Traverse the AST with additional context members provided by `additionalContext`.
@@ -45,10 +69,11 @@ export type Visitor<T = void> = (
  * @param scopeManager the eslint-scope compatible scope manager instance calculated using the ast
  * @param additionalContext a callback function which returns additional context members to add to the context provided to the visitor
  */
-export function traverseWithContext<T = void>(
+export function traverseWithContext<T = TraversalContextBase>(
+  code: string,
   ast: Program,
   scopeManager: ScopeManager,
-  additionalContext: (TraversalContext<void>) => T,
+  additionalContext: TraversalContextBase => T,
   visitor: Visitor<T>,
 ): void {
   const emitter = new SafeEmitter();
@@ -86,9 +111,34 @@ export function traverseWithContext<T = void>(
     return scopeManager.scopes[0];
   };
 
-  const traversalContextBase: TraversalContext<void> = Object.freeze({
+  const traversalContextBase: TraversalContextBase = Object.freeze({
+    buildCodeFrame: (node: ESNode, message: string): string => {
+      // babel uses 1-indexed columns
+      const locForBabel = {
+        start: {
+          line: node.loc.start.line,
+          column: node.loc.start.column + 1,
+        },
+        end: {
+          line: node.loc.end.line,
+          column: node.loc.end.column + 1,
+        },
+      };
+      return codeFrameColumns(code, locForBabel, {
+        linesAbove: 0,
+        linesBelow: 0,
+        highlightCode: process.env.NODE_ENV !== 'test',
+        message: message,
+      });
+    },
+
+    buildSimpleCodeFrame: (node: ESNode, message: string): string => {
+      return `[${node.type}:${node.loc.start.line}:${node.loc.start.column}] ${message}`;
+    },
+
     getDeclaredVariables: (node: ESNode) =>
       scopeManager.getDeclaredVariables(node),
+
     getBinding: (name: string) => {
       let currentScope = getScope();
 
@@ -103,8 +153,10 @@ export function traverseWithContext<T = void>(
 
       return null;
     },
+
     getScope,
   });
+
   const traversalContext: TraversalContext<T> = Object.freeze({
     ...traversalContextBase,
     ...additionalContext(traversalContextBase),
@@ -141,9 +193,10 @@ export function traverseWithContext<T = void>(
 }
 
 export function traverse(
+  code: string,
   ast: Program,
   scopeManager: ScopeManager,
   visitor: Visitor<void>,
 ): void {
-  traverseWithContext(ast, scopeManager, () => {}, visitor);
+  traverseWithContext(code, ast, scopeManager, () => {}, visitor);
 }