go-fAST

Benchmarks

Rust-class speed, in pure Go

On a full parse, transform and generate cycle, go-fAST runs in the same league as the fastest Rust toolchains, and comfortably more than 10x ahead of Babel or the next Go parser. Lower is better.

Full parse, transform and code generation over a representative JavaScript file; the bar chart is scaled to the slowest tool. go-fAST is built with profile-guided optimisation (PGO). Times vary with input and hardware.

Three things, done fast

Parse. Transform. Generate.

A single, cohesive toolkit for the whole round-trip from JavaScript source to a typed tree and back again.

In practice

The full round-trip in one file

Parse a snippet, walk the tree with a visitor that renames an identifier, then print the result. That is the entire shape of a go-fAST program.

package main

import (
	"fmt"

	"github.com/t14raptor/go-fast/ast"
	"github.com/t14raptor/go-fast/generator"
	"github.com/t14raptor/go-fast/parser"
)

// renamer rewrites every identifier named "a" to "answer".
type renamer struct {
	ast.NoopVisitor
}

func (r *renamer) VisitIdentifier(n *ast.Identifier) {
	if n.Name == "a" {
		n.Name = "answer"
	}
	n.VisitChildrenWith(r.V)
}

func main() {
	// 1. Parse JavaScript into a typed AST.
	program, err := parser.ParseFile(`const a = 6 * 7; console.log(a);`)
	if err != nil {
		panic(err)
	}

	// 2. Walk the tree with a visitor and rewrite it.
	v := &renamer{}
	v.V = v
	program.VisitWith(v)

	// 3. Print the transformed source back out.
	fmt.Println(generator.Generate(program))
	// const answer = 6 * 7;
	// console.log(answer);
}

Why go-fAST

Reasons it earns its keep

Not a wrapper around someone else's runtime. A focused, native-Go toolkit with a few things going for it.

What it is for

Built for taking JavaScript apart

If your Go program needs to understand, rewrite or emit JavaScript, go-fAST is the layer underneath it.

FAQ

Questions