Introduction to ast-types

The ast-types library is a powerful tool used for programmatic manipulation of Abstract Syntax Trees (ASTs). ASTs are a crucial component in the process of code analysis, transformation, and generation. This library offers a variety of APIs that simplify working with ASTs, making it easier for developers to create and maintain complex codebases.

Installation

npm install ast-types

Discovering the AST

Here’s a basic example of how to parse JavaScript code into an AST:

const recast = require("recast");
const astTypes = require("ast-types");

const code = 'function add(a, b) { return a + b; }';
const ast = recast.parse(code);

console.log(JSON.stringify(ast, null, 2));

Inspecting Nodes

The ast-types library provides type inspectors to help with understanding AST nodes:

astTypes.visit(ast, {
  visitFunctionDeclaration(path) {
    console.log("Function name:", path.node.id.name);
    this.traverse(path);
  }
});

Modifying AST Nodes

Modifying AST nodes is straightforward with the provided APIs:

astTypes.visit(ast, {
  visitIdentifier(path) {
    if (path.node.name === "add") {
      path.node.name = "sum";
    }
    this.traverse(path);
  }
});

const modifiedCode = recast.print(ast).code;
console.log(modifiedCode);

Adding New Nodes

Adding additional nodes to the AST can enhance or extend the functionality of your code:

const builders = astTypes.builders;

astTypes.visit(ast, {
  visitFunctionDeclaration(path) {
    const logStatement = builders.expressionStatement(
      builders.callExpression(
        builders.memberExpression(
          builders.identifier('console'),
          builders.identifier('log'),
          false
        ),
        [builders.literal('Function add called')]
      )
    );

    path.get('body', 'body').unshift(logStatement);
    this.traverse(path);
  }
});

const updatedCode = recast.print(ast).code;
console.log(updatedCode);

Example Application: Code Transform Tool

Here is an example application that uses the APIs introduced above to create a tool that transforms JavaScript code:

const { parse, print } = require("recast");
const astTypes = require("ast-types");

function transformCode(code) {
  const ast = parse(code);

  astTypes.visit(ast, {
    visitFunctionDeclaration(path) {
      if (path.node.id.name === "add") {
        path.node.id.name = "sum";

        const logStatement = astTypes.builders.expressionStatement(
          astTypes.builders.callExpression(
            astTypes.builders.memberExpression(
              astTypes.builders.identifier('console'),
              astTypes.builders.identifier('log'),
              false
            ),
            [astTypes.builders.literal('Function sum called')]
          )
        );

        path.get('body', 'body').unshift(logStatement);
      }
      this.traverse(path);
    }
  });

  return print(ast).code;
}

const code = 'function add(a, b) { return a + b; }';
const transformedCode = transformCode(code);
console.log(transformedCode);

Conclusion

The ast-types library offers a robust set of tools for AST manipulation. By leveraging these tools, developers can automate many tasks related to code analysis and transformation, leading to cleaner and more maintainable codebases.

Whether you’re refactoring existing code, adding new features, or generating code programmatically, ast-types provides the functionality you need to work effectively with ASTs.

Hash: 769fd17037c3ee3d87b1f3b0ec281504dd5f3d83eb3efac745fef3da5633517b