Expose AST of current source file

[vjpr]

It would be nice to have easy access to the AST of a source file.

Approaches

Expose AST as variable

Maybe something like: import.meta.ast...

Allow passing AST nodes to macros

Might also be cool to be able to do reflection really simply, by passing in AST nodes as input to macros...

E.g.

import {BunASTNode} from Bun // doesn't exist yet
import {getComment} from 'get-comment-macro' assert {type: 'macro'}

// bar function comment
function bar() {}

console.log(getComment(bar) as BunASTNode /* doesn't exist yet */) // bar function comment

Tricky though to indicate when you want to pass a value vs AST node.

Workarounds

You can use 3rd party AST parsing libraries such as: ts-morph

Bun Macro

an-app-source-file.ts

// A file that prints all the functions inside it.

import {getAllFunctionsInFile} from './my-ast-parser.macro.ts' assert {type: 'macro'}

const modulePath = import.meta.path
const functions = getAllFunctionsInFile(modulePath)
console.log(functions) // Prints: ['foo', 'bar']

function foo() {}

function bar() {}

./my-ast-parser.macro.ts

import {Project} from 'ts-morph'

function getAllFunctionsInFile(filePath) {
  const project = new Project({})
  const file = project.addSourceFileAtPath(filePath)
  const functions = file.getFunctions()
  return functions.map(fn => {name: func.getName()})
}

Bun Plugin

You essentially end up re-implementing macros.

Not shown here, but you would normally parse comments to indicate what code should be run/inserted.

import type {BunPlugin} from 'bun'

export function bunPlugin(opts) {
  const plugin: BunPlugin = {
    name: 'my plugin',
    async setup(build) {
      
      const {compile} = await import('./my-ast-parser.ts')
      const {readFileSync} = await import('fs')

      build.onLoad({filter: /\.tsx?$/}, async ({path}) => {
        const code = readFileSync(path, 'utf8')
        const contents = await compile(code, {
          filename: path,
        })

        return {
          contents,
          loader: 'tsx',
        }
      })
    },
  }
  return plugin
}

./my-ast-parser.ts

import {getAllFunctionsInFile} from 'blah.ts'

export async function compile(code, {filename}) {

  const functions = getAllFunctionsInFile(filename)

  code = 'const $getAllFunctionsInFile$() { return ' + JSON.stringify(functions, null, 2) + ' }\n\n' + code

  return code

}

index.ts

declare var $getAllFunctionsInFile$;

console.log($getAllFunctionsInFile$())

Notes

There is an existing issue to expose AST via Bun.Transpiler: #2729. This would be a first step...

Similar stuff

Type reflection

Good discussion: https://news.ycombinator.com/item?id=36637221

reflect-metadata

https://github.com/rbuckton/reflect-metadata

Uses @Reflect.metadata decorator proposal (not from TypeScript team).

class Foo {
  @Reflect.metadata("blah", "some metadata!")
  foo() {}
}

const target = new Foo
const propertyKey = 'foo'
Reflect.getMetadata("blah", target, propertyKey);

TypeScript has built-in support for this specific library to avoid needing to annotate specific methods...

"experimentalDecorators": true,
"emitDecoratorMetadata": true

class Foo {
  // No decorator needed!
  foo() {}
}

const target = new Foo
const propertyKey = 'foo'
// `design:type` is hard-coded in `tsc`..."design" as in "design-time" or "compile-time"
Reflect.getMetadata("design:type", target, propertyKey);

From Typescript documentation: https://www.typescriptlang.org/docs/handbook/decorators.html#metadata

There are no function decorators though so this is sucky.

tst-reflect

https://github.com/Hookyns/tst-reflect

typescript-rtti

https://github.com/typescript-rtti/typescript-rtti

Requires ttypescript (patching typescript), but is deprecated.

[janwilmake]

I agree this would be super cool. I'm using @swc/core now to parse my ts files on the fly. It's super fast but import.meta.ast would also be helpful.

https://swc.rs