# Transforms

AssemblyScript is compiled statically, so code transformation cannot be done at runtime but must instead be performed at compile-time. To enable this, the compiler frontend (asc) provides a mechanism to hook into the compilation process before, while and after the module is being compiled.

Specifying --transform ./myTransform on the command line will load the node module pointed to by ./myTransform.

const { Transform } = require("assemblyscript/cli/transform")
const assemblyscript = require("assemblyscript")
class MyTransform extends Transform {
  ...
}
module.exports = MyTransform

# Properties

A transform is an ES6 class/node module with the following inherited properties:

```
readonly program: Program
```
Reference to the Program instance.
```
readonly baseDir: string
```
Base directory used by the compiler.
```
readonly stdout: OutputStream
```
Output stream used by the compiler.
```
readonly stderr: OutputStream
```
Error stream uses by the compiler.
```
readonly log: typeof console.log
```
Logs a message to console.

function writeFile(filename: string, contents: string | Uint8Array, baseDir: string): boolean

Writes a file to disk.

function readFile(filename: string, baseDir: string): string | null

Reads a file from disk.

function listFiles(dirname: string, baseDir: string): string[] | null

Lists all files in a directory.

# Hooks

The frontend will call several hooks, if present on the transform, during the compilation process:

```
function afterParse(parser: Parser): void
```
Called when parsing is complete, before a program is initialized from the AST. Note that types are not yet known at this stage and there is no easy way to obtain them.
```
function afterInitialize(program: Program): void
```
Called once the program is initialized, before it is being compiled. Types are known at this stage, respectively can be resolved where necessary.
```
function afterCompile(module: Module): void
```
Called with the resulting module before it is being emitted. Useful to modify the IR before writing any output, for example to replace imports with actual functionality or to add custom sections.

Transforms are a very powerful feature, but may require profound knowledge of the compiler to utilize them to their full extent, so reading through the compiler sources is a plus.

← Interoperability Development →