Product
Docs
Resources
Log InSign Up

Want to learn more about Courier?

Request a demo to see how Courier works to make product notifications delightful.

parsing-header
ENGINEERING

Build a WebAssembly Language for Fun and Profit: Parsing

Andrew Youngwerth

August 25, 2022

In the last post of this series on how to build a WebAssembly programming language, we constructed a lexer. In this post, we’ll cover the next phase of our compiler, parsing. Parsing is the portion of our compiler that takes the token stream generated by the lexer and converts it into an abstract syntax tree (AST).

An AST is a tree-like data structure that organizes the tokens into a logical hierarchy that can more easily be translated into machine code. Thankfully, because wispy is an S-expression language, our code is essentially already an AST. Take the following stream of tokens:

1
“(“, “add”, “3”, “(“, “sub”, “2”, “1”, “)”, “)”

Each set of parentheses represents a subtree, where the first token is the operator node and the following tokens are its operands. If we run into another opening parenthesis before the current set is closed, we know it represents an operand that itself is a subtree. The above stream of tokens would be organized into a tree that looks like this:

AST explanation

If you're interested in writing a parser for a more complex C-like syntax, see my previous Building A Programming Language series.

More About AST

As we did with the lexer, we'll start by defining our types. These types will define the structure of our AST. Each type represents a “Node”, the circle from our diagram in the intro. Here are the basic nodes. We'll gloss over them, as they aren't a lot different from the tokens we defined in the lexer:

1
// src/types/ast.mts
2
3
export type IntNode = {
4
type: "int";
5
value: number;
6
};
7
8
export type FloatNode = {
9
type: "float";
10
value: number;
11
};
12
13
export type IdentifierNode = {
14
type: "identifier";
15
identifier: string;
16
};
17
18
export type TypedIdentifierNode = {
19
type: "typed-identifier";
20
// Note that here, we break down the identifier into its components
21
identifier: string;
22
typeIdentifier: string;
23
};

A new concept to the AST is the BlockNode. A BlockNode is an expression made up of a group of other nodes.

For example, (add 1 2) is a block of three nodes:

  1. An identifier that evaluates to a function, add.
  2. An Int that simply evaluates to the number 1.
  3. An Int that simply evaluates to the number 2.

How the block itself gets evaluated is up to the compiler. We'll get to that in the next post.

Here's the definition:

1
// src/types/ast.mts
2
3
export type BlockNode = {
4
type: "block";
5
expressions: AstNode[];
6
};

Finally, we define the AstNode. Like the Token type from the lexer, AstNode is a discriminated union that can be one of any other node we previously defined:

1
export type AstNode = IntNode | FloatNode | IdentifierNode | TypedIdentifierNode | BlockNode;

You may have noticed that BlockNode has an array of AstNodes, Since AstNode can be a BlockNode, BlockNodes can contain child BlockNodes. In other words, BlockNode is a recursive type. This ability to recursively represent children that can have children is the foundation of our AST. It's where the tree in AST is allowed to form.

At this point src/types/ast.mts is finished and should look like this file.

Now export the types from src/types/index.mts as we did with the token types:

1
// src/types/index.mts
2
export * from "./token.mjs";
3
export * from "./ast.mjs";

Constructing the AST

Now that we've defined the AST, it's time to build one.

Create a new src/parser.mts file and add all the imports we'll use:

1
// src/parser.mts
2
import {
3
Token,
4
IdentifierNode,
5
TypedIdentifierNode,
6
IdentifierToken,
7
TypedIdentifierToken,
8
FloatToken,
9
FloatNode,
10
IntToken,
11
IntNode,
12
AstNode,
13
BlockNode,
14
} from "./types/index.mjs";

Now we can define our top level parse function. The parse function takes the tokens generated by the lexer and returns a BlockNode that acts as our tree’s root.

1
// src/parser.mts
2
export const parse = (tokens: Token[]): BlockNode => {
3
const blocks: BlockNode[] = [];
4
5
// This loop is run as long as there are tokens to consume
6
while (tokens.length) {
7
// consumeTokenTree converts an array of tokens into a tree of tokens, more on that later.
8
const tree = consumeTokenTree(tokens);
9
10
// parseBlock turns our new tree of tokens into an actual BlockNode, recursively. More on that later as well.
11
blocks.push(parseBlock(tree));
12
}
13
14
// Finally we return the top level BlockNode
15
return {
16
type: "block",
17
expressions: blocks,
18
};
19
};

Next we define the consumeTokenTree function. consumeTokenTree converts a flat array of tokens, into a tree of tokens.

Given this wispy expression:

1
(add (sub 3 1) (sub 5 2))

The lexer will produce this array of tokens:

1
// Note: I've simplified the Token format to just be strings to keep things short
2
["(", "add", "(", "sub", "3", "1", ")", "(", "sub", "5", "2", ")", ")"];

consumeTokenTree will take that flat array and turn it into a tree. This is as simple as putting every token in between a set of bracket tokens () into an array. So our token array from above becomes this token tree:

1
["add", [, "sub", "3", "1"], ["sub", "5", "2"]];

Here's the actual definition of consumeTokenTree:

1
// src/parser.mts
2
3
// This is token besides for the bracket tokens
4
export type NonBracketToken = Exclude<Token, "parenthesis" | "square-bracket">;
5
6
// The token tree is made of NonBracketTokens and other TokenTrees
7
export type TokenTree = (NonBracketToken | TokenTree)[];
8
9
const consumeTokenTree = (tokens: Token[]): TokenTree => {
10
const tree: TokenTree = [];
11
12
// Ensures the first token is a left bracket and then discards it, defined below this function.
13
consumeLeftBracket(tokens);
14
15
while (tokens.length) {
16
// Preview the next token
17
const token = tokens[0];
18
19
// Check to see if the next token is a left bracket.
20
if (token.type === "bracket" && getBracketDirection(token) === "left") {
21
// If it is, we just ran into a sub-TokenTree. So we can simply call this function within
22
// itself. Gotta love recursion.
23
tree.push(consumeTokenTree(tokens));
24
continue;
25
}
26
27
// Check to see if the next token is a right bracket
28
if (token.type === "bracket" && getBracketDirection(token) === "right") {
29
// If it is, we just found the end of the tree on our current level
30
tree.shift(); // Discard the right bracket
31
break; // Break the loop
32
}
33
34
// If the token isn't a bracket, it can simply be added to the tree on this level
35
tree.push(token);
36
37
// Consume / discard the token from the main tokens array
38
tokens.shift();
39
}
40
41
// Return the tree. Don't forget to check out the helper functions below!
42
return tree;
43
};
44
45
const consumeLeftBracket = (tokens: Token[]) => {
46
const bracketDirection = getBracketDirection(tokens[0]);
47
48
if (bracketDirection !== "left") {
49
throw new Error("Expected left bracket");
50
}
51
52
return tokens.shift();
53
};
54
55
const getBracketDirection = (token: Token): "left" | "right" => {
56
if (token.type !== "bracket") {
57
throw new Error(`Expected bracket, got ${token.type}`);
58
}
59
60
// If we match a left bracket return left
61
if (/[\(\[]/.test(token.value)) return "left";
62
63
// Otherwise return right
64
return "right";
65
};

Now that we have a token tree, we need to turn it into a block. To do so, we create a parseBlock function that takes the tree as its input and returns a BlockNode:

1
const parseBlock = (block?: TokenTree): BlockNode => {
2
return {
3
type: "block",
4
// This is where the recursive magic happens
5
expressions: block.map(parseExpression),
6
};
7
};

As you may have noticed, parseBlock maps each item of the tree with a yet to be written parseExpression function. parseExpression takes either a TokenTree or a NonBracketToken and transforms it to its corresponding AstNode type.

Here's the definition:

1
const parseExpression = (expression?: TokenTree | NonBracketToken): AstNode => {
2
// If the expression is an Array, we were passed another TokenTree, so we can
3
// pass the expression back to the parseBlock function
4
if (expression instanceof Array) {
5
return parseBlock(expression);
6
}
7
8
// The mapping here is pretty straight forward. Match the token type and pass the
9
// expression on to a more specific expression parser.
10
if (isTokenType(expression, "identifier")) return parseIdentifier(expression);
11
if (isTokenType(expression, "typed-identifier")) return parseTypedIdentifier(expression);
12
if (isTokenType(expression, "float")) return parseFloatToken(expression);
13
if (isTokenType(expression, "int")) return parseIntToken(expression);
14
15
throw new Error(`Unrecognized expression ${JSON.stringify(expression)}`);
16
};

Let's define the isTokenType function. This function is pretty neat and demonstrates one of the most powerful features of TypeScript, custom type guards. Simply put, isTokenType tests the expression and narrows down the type to a specific TokenType. This allows TypeScript to be certain we are passing the correct tokens to their corresponding parser functions down the line.

Here's the definition:

1
export const isTokenType = <T extends Token["type"]>(
2
item: TokenTree | NonBracketToken | undefined,
3
type: T
4
): item is Extract<Token, { type: T }> => {
5
return isToken(item) && item.type === type;
6
};
7
8
const isToken = (item?: TokenTree | NonBracketToken): item is NonBracketToken => {
9
return !(item instanceof Array);
10
};

There's a lot happening there, so let's walk through it. First up, we have a generic definition, <T extends Token["type"]>. This is essentially saying that T must be one of the possible values of the Token.type field. Typescript is smart enough to know that means T must be one of "int" | "float" | "identifier" | "typed-identifier" | "bracket.

The next interesting piece of code is the return type predicate item is Extract<Token, { type: T }>. This predicate tells TypeScript that if the return value of isTokenType is true, then item must be the Token whose type matches the string passed as the type parameter.

In practice that means that if we were to pass an unknown Token to isTokenType, typescript will be able to correctly narrow the value to a more specific token, like IntToken.

Now that we have our custom type guard defined, we can define the actual token parsers. The first three are simple; they essentially just return a copy or slightly modified copy of the token:

1
const parseFloatToken = (float: FloatToken): FloatNode => ({ ...float });
2
3
const parseIntToken = (int: IntToken): IntNode => ({ ...int });
4
5
const parseIdentifier = (identifier: IdentifierToken): IdentifierNode => {
6
return {
7
type: "identifier",
8
identifier: identifier.value,
9
};
10
};

The final parser is the parseTypedIdentifier. Remember that a typed identifier takes the form identifier:type. Parsing it is as simple as splitting the string by the colon. The first value of the returned array is the identifier, the second is the type. Here's the definition:

1
const parseTypedIdentifier = (identifier: TypedIdentifierToken): TypedIdentifierNode => {
2
const vals = identifier.value.split(":");
3
4
return {
5
type: "typed-identifier",
6
identifier: vals[0],
7
typeIdentifier: vals[1],
8
};
9
};

Here’s the finished file

That's all the code required for a working parser. Before we move on, let's update the main src/index.mts file to view the output of the parser:

1
// src/index.mts
2
#!/usr/bin/env node
3
import { readFileSync } from "fs";
4
import { lex } from "./lexer.mjs";
5
import { parse } from "./parser.mjs";
6
7
const file = process.argv[2];
8
const input = readFileSync(file, "utf8");
9
10
const tokens = lex(input);
11
const ast = parse(tokens);
12
console.log(JSON.stringify(tokens, undefined, 2));

Build and run project:

1
npx tsc
2
wispy example.wispy

If all goes well, the output should look like this.

With that, the parser is finished. We can now convert the stream of tokens from the lexer into an AST. In the next post, we can get into the juicy bits: generating and running machine-readable code.

Want to learn more about Courier?

Request a demo to see how Courier works to make product notifications delightful.

More from Engineering

serverless-lie-detector-thumbnail
ENGINEERINGINTEGRATIONS

Create a Discord Bot that Automates Secret Messages with Node.js

Our plan is to create and install a Discord bot that automates encrypted messages to the civilians and alerts them about the situation so that they can escape.

Shreya Gupta

Shreya Gupta

September 27, 2022

serverless-lie-detector-thumbnail
ENGINEERINGINTEGRATIONS

Build a Serverless Lie Detector that uses AI for Facial Recognition

When the Face API recognizes that one of our spies is being deceitful, we will use Courier to broadcast the identity of the mole to our spy network.

Shreya Gupta

Shreya Gupta

September 12, 2022

Build your first notification in minutes

Send up to 10,000 notifications every month, for free.

Email & push notification

Build your first notification in minutes

Send up to 10,000 notifications every month, for free.

Email & push notification

Product

Pricing

Providers

Developers

Documentation

API

Libraries

Status

© 2022 Courier. All rights reserved.