@newt-dev/compiler 0.1.0

package/dist/src/parser.js

@@ -0,0 +1,459 @@
+import { makeCatalogError, NewtError } from "./errors.js";
+export function parse(tokens) {
+    return new Parser(tokens).parseProgram();
+}
+class Parser {
+    tokens;
+    current = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parseProgram() {
+        const body = [];
+        this.skipNewlines();
+        while (!this.isAtEnd()) {
+            if (this.checkKeyword("bot")) {
+                body.push(this.parseBotDecl());
+            }
+            else if (this.checkKeyword("on")) {
+                body.push(this.parseHandler());
+            }
+            else if (this.checkKeyword("every") || this.checkKeyword("at")) {
+                body.push(this.parseTimer());
+            }
+            else {
+                const token = this.peek();
+                throw makeCatalogError("NEWT_E004", token.line, token.column, this.sourceLineHint(token));
+            }
+            this.skipNewlines();
+        }
+        return { type: "Program", loc: { line: 1, column: 1 }, body };
+    }
+    parseBotDecl() {
+        const start = this.consumeKeyword("bot");
+        const kindToken = this.consumeType("KEYWORD", "Bot declarations need a setting like name, prefix, or token.");
+        if (!["name", "prefix", "token"].includes(kindToken.value)) {
+            throw this.error(kindToken, "Bot declarations support name, prefix, and token.");
+        }
+        let fromEnv = false;
+        if (kindToken.value === "token" && this.matchKeyword("from")) {
+            this.consumeKeyword("env");
+            fromEnv = true;
+        }
+        const value = this.parseStringLiteral();
+        this.consumeLineEnd();
+        return {
+            type: "BotDecl",
+            loc: this.loc(start),
+            kind: kindToken.value,
+            value,
+            fromEnv
+        };
+    }
+    parseHandler() {
+        const start = this.consumeKeyword("on");
+        const event = this.consumeType("KEYWORD", "Handlers need an event name after on.");
+        let handler;
+        if (event.value === "ready") {
+            handler = { type: "ReadyHandler", loc: this.loc(start), body: [] };
+        }
+        else if (event.value === "command") {
+            const command = this.parseStringLiteral();
+            handler = { type: "CommandHandler", loc: this.loc(start), command: command.value, body: [] };
+        }
+        else if (event.value === "message") {
+            this.consumeKeyword("contains");
+            const needle = this.parseStringLiteral();
+            handler = { type: "MessageContainsHandler", loc: this.loc(start), needle, body: [] };
+        }
+        else if (event.value === "join") {
+            handler = { type: "JoinHandler", loc: this.loc(start), body: [] };
+        }
+        else if (event.value === "leave") {
+            handler = { type: "LeaveHandler", loc: this.loc(start), body: [] };
+        }
+        else if (event.value === "reaction") {
+            this.consumeKeyword("add");
+            const emoji = this.parseStringLiteral();
+            handler = { type: "ReactionAddHandler", loc: this.loc(start), emoji, body: [] };
+        }
+        else {
+            throw makeCatalogError("NEWT_E003", event.line, event.column, this.sourceLineHint(event));
+        }
+        this.consumeBlockStart();
+        handler.body = this.parseBlock();
+        return handler;
+    }
+    parseTimer() {
+        if (this.checkKeyword("every")) {
+            const start = this.advance();
+            const amount = this.parseNumberLiteral();
+            const unit = this.consumeType("KEYWORD", "Timers need a unit like seconds, minutes, or hours.");
+            this.consumeBlockStart();
+            return {
+                type: "EveryTimerDecl",
+                loc: this.loc(start),
+                amount,
+                unit: unit.value,
+                body: this.parseBlock()
+            };
+        }
+        const start = this.consumeKeyword("at");
+        const time = this.parseStringLiteral();
+        this.consumeKeyword("daily");
+        this.consumeBlockStart();
+        return { type: "DailyTimerDecl", loc: this.loc(start), time, body: this.parseBlock() };
+    }
+    parseBlock() {
+        this.skipNewlines();
+        this.consumeType("INDENT", "Indented lines should come after a block header.");
+        const body = [];
+        this.skipNewlines();
+        while (!this.isAtEnd() && !this.check("DEDENT")) {
+            body.push(this.parseStatement());
+            this.skipNewlines();
+        }
+        this.consumeType("DEDENT", "Blocks need to return to the previous indentation level.");
+        return body;
+    }
+    parseStatement() {
+        if (this.checkKeyword("reply")) {
+            const start = this.advance();
+            const message = this.parseExpressionUntilLineEnd();
+            this.consumeLineEnd();
+            return { type: "ReplyStatement", loc: this.loc(start), message };
+        }
+        if (this.checkKeyword("say")) {
+            return this.parseSayStatement();
+        }
+        if (this.checkKeyword("let")) {
+            const start = this.advance();
+            const name = this.consumeType("IDENTIFIER", "let needs a variable name.").value;
+            this.consumeType("EQUALS", "let needs an equals sign before the value.");
+            const value = this.parseExpressionUntilLineEnd();
+            this.consumeLineEnd();
+            return { type: "LetDecl", loc: this.loc(start), name, value };
+        }
+        if (this.checkKeyword("store")) {
+            const start = this.advance();
+            const namespace = this.parseAtom();
+            const key = this.consumeWord("store needs a key name after the namespace.").value;
+            this.consumeType("EQUALS", "store needs an equals sign before the value.");
+            const value = this.parseExpressionUntilLineEnd();
+            this.consumeLineEnd();
+            return { type: "StoreStatement", loc: this.loc(start), namespace, key, value };
+        }
+        if (this.checkKeyword("if")) {
+            return this.parseIfStatement();
+        }
+        if (this.checkKeyword("for")) {
+            return this.parseForEachStatement();
+        }
+        if (this.checkKeyword("require")) {
+            const start = this.advance();
+            this.consumeKeyword("role");
+            const role = this.parseStringLiteral();
+            this.consumeLineEnd();
+            return { type: "RequireRoleStatement", loc: this.loc(start), role };
+        }
+        if (this.checkKeyword("give") || this.checkKeyword("remove")) {
+            return this.parseRoleMutation();
+        }
+        if (this.checkKeyword("mute")) {
+            const start = this.advance();
+            const subject = this.parseAtom();
+            let duration;
+            if (this.matchKeyword("for")) {
+                duration = this.parseDuration();
+            }
+            this.consumeLineEnd();
+            return { type: "MuteStatement", loc: this.loc(start), subject, duration };
+        }
+        if (this.checkKeyword("kick") || this.checkKeyword("ban")) {
+            const start = this.advance();
+            const subject = this.parseAtom();
+            this.consumeLineEnd();
+            return { type: start.value === "kick" ? "KickStatement" : "BanStatement", loc: this.loc(start), subject };
+        }
+        if (this.checkKeyword("try")) {
+            return this.parseTryCatch();
+        }
+        if (this.checkKeyword("wait")) {
+            const start = this.advance();
+            this.consumeKeyword("for");
+            const duration = this.parseDuration();
+            this.consumeLineEnd();
+            return { type: "WaitStatement", loc: this.loc(start), duration };
+        }
+        const start = this.peek();
+        const expression = this.parseExpressionUntilLineEnd();
+        this.consumeLineEnd();
+        return { type: "ExpressionStatement", loc: this.loc(start), expression };
+    }
+    parseSayStatement() {
+        const start = this.consumeKeyword("say");
+        if (this.matchKeyword("embed")) {
+            this.consumeBlockStart();
+            const embed = this.parseEmbedBlock(start);
+            return { type: "SayEmbedStatement", loc: this.loc(start), embed };
+        }
+        const message = this.parseExpressionUntil(["NEWLINE", "EOF"], ["in"]);
+        let channel;
+        if (this.matchKeyword("in")) {
+            this.consumeKeyword("channel");
+            channel = this.parseStringLiteral();
+        }
+        this.consumeLineEnd();
+        return { type: "SayStatement", loc: this.loc(start), message, channel };
+    }
+    parseEmbedBlock(start) {
+        this.skipNewlines();
+        this.consumeType("INDENT", "Embed details need to be indented.");
+        const embed = { type: "EmbedBlock", loc: this.loc(start), fields: [] };
+        this.skipNewlines();
+        while (!this.isAtEnd() && !this.check("DEDENT")) {
+            if (this.matchKeyword("title")) {
+                embed.title = this.parseStringLiteral();
+            }
+            else if (this.matchKeyword("description")) {
+                embed.description = this.parseStringLiteral();
+            }
+            else if (this.matchKeyword("color")) {
+                const color = this.consumeType("HASH_COLOR", "Embed colors look like #5865F2.");
+                embed.color = { type: "ColorLiteral", loc: this.loc(color), value: color.value };
+            }
+            else if (this.matchKeyword("field")) {
+                const name = this.parseStringLiteral();
+                const value = this.parseStringLiteral();
+                embed.fields.push({ type: "EmbedField", loc: name.loc, name, value });
+            }
+            else {
+                throw this.error(this.peek(), "Embeds support title, description, color, and field lines.");
+            }
+            this.consumeLineEnd();
+            this.skipNewlines();
+        }
+        this.consumeType("DEDENT", "Embed blocks need to return to the previous indentation level.");
+        return embed;
+    }
+    parseIfStatement() {
+        const start = this.consumeKeyword("if");
+        const condition = this.parseExpressionUntil(["COLON"]);
+        this.consumeBlockStart();
+        const consequent = this.parseBlock();
+        let alternate = [];
+        if (this.matchKeyword("else")) {
+            this.consumeBlockStart();
+            alternate = this.parseBlock();
+        }
+        return { type: "IfStatement", loc: this.loc(start), condition, consequent, alternate };
+    }
+    parseForEachStatement() {
+        const start = this.consumeKeyword("for");
+        this.consumeKeyword("each");
+        const itemName = this.consumeWord("for each needs an item name.").value;
+        this.consumeKeyword("in");
+        const iterable = this.parseExpressionUntil(["COLON"]);
+        this.consumeBlockStart();
+        return { type: "ForEachStatement", loc: this.loc(start), itemName, iterable, body: this.parseBlock() };
+    }
+    parseRoleMutation() {
+        const start = this.advance();
+        const subject = this.parseAtom();
+        this.consumeKeyword("role");
+        const role = this.parseStringLiteral();
+        this.consumeLineEnd();
+        return start.value === "give"
+            ? { type: "GiveRoleStatement", loc: this.loc(start), subject, role }
+            : { type: "RemoveRoleStatement", loc: this.loc(start), subject, role };
+    }
+    parseTryCatch() {
+        const start = this.consumeKeyword("try");
+        this.consumeBlockStart();
+        const body = this.parseBlock();
+        this.consumeKeyword("on");
+        this.consumeKeyword("error");
+        this.consumeBlockStart();
+        const errorHandler = this.parseBlock();
+        return { type: "TryCatchStatement", loc: this.loc(start), body, errorHandler };
+    }
+    parseDuration() {
+        const amount = this.parseNumberLiteral();
+        const unit = this.consumeType("KEYWORD", "Durations need a unit like seconds, minutes, or hours.");
+        return { type: "DurationLiteral", loc: amount.loc, amount, unit: unit.value };
+    }
+    parseExpressionUntilLineEnd() {
+        return this.parseExpressionUntil(["NEWLINE", "EOF"]);
+    }
+    parseExpressionUntil(endTypes, endKeywords = []) {
+        const parts = [];
+        const operators = [];
+        while (!this.isAtEnd() && !endTypes.includes(this.peek().type) && !this.isEndKeyword(endKeywords)) {
+            if (this.check("OPERATOR") || this.checkKeyword("or") || this.checkKeyword("and") || this.checkKeyword("has")) {
+                const operator = this.advance();
+                operators.push(operator);
+                if (operator.value === "has" && this.checkKeyword("role")) {
+                    this.advance();
+                }
+            }
+            else {
+                parts.push(this.parseAtom());
+            }
+        }
+        if (parts.length === 0) {
+            throw this.error(this.peek(), "This line needs a value here.");
+        }
+        let expression = parts[0];
+        for (let index = 1; index < parts.length; index += 1) {
+            const operator = operators[index - 1]?.value ?? "+";
+            expression = {
+                type: "BinaryExpr",
+                loc: expression.loc,
+                operator,
+                left: expression,
+                right: parts[index]
+            };
+        }
+        return expression;
+    }
+    parseAtom() {
+        if (this.check("STRING")) {
+            return this.parseStringLiteral();
+        }
+        if (this.check("NUMBER")) {
+            return this.parseNumberLiteral();
+        }
+        if (this.matchKeyword("load")) {
+            const start = this.previous();
+            const namespace = this.parseAtom();
+            const key = this.consumeWord("load needs a key name after the namespace.").value;
+            let fallback;
+            if (this.matchKeyword("or")) {
+                fallback = this.parseAtom();
+            }
+            return { type: "LoadExpr", loc: this.loc(start), namespace, key, fallback };
+        }
+        if (this.matchKeyword("fetch")) {
+            const start = this.previous();
+            return { type: "FetchExpr", loc: this.loc(start), url: this.parseAtom() };
+        }
+        if (this.match("LPAREN")) {
+            const expression = this.parseExpressionUntil(["RPAREN"]);
+            this.consumeType("RPAREN", "Close this expression with ).");
+            return expression;
+        }
+        const token = this.consumeWord("Expected a value.");
+        const path = [token.value];
+        while (this.match("DOT")) {
+            path.push(this.consumeWord("Expected a name after the dot.").value);
+        }
+        if (path[0] === "args" && this.match("LBRACKET")) {
+            const index = this.parseNumberLiteral();
+            this.consumeType("RBRACKET", "Close args[index] with ].");
+            return { type: "ArgsIndexExpr", loc: this.loc(token), index: index.value };
+        }
+        return path.length === 1
+            ? { type: "IdentifierExpr", loc: this.loc(token), name: path[0] }
+            : { type: "MemberExpr", loc: this.loc(token), path };
+    }
+    parseStringLiteral() {
+        const token = this.consumeType("STRING", "Text values need double quotes.");
+        return { type: "StringLiteral", loc: this.loc(token), value: token.value, interpolated: Boolean(token.interpolated) };
+    }
+    parseNumberLiteral() {
+        const token = this.consumeType("NUMBER", "Expected a number here.");
+        return { type: "NumberLiteral", loc: this.loc(token), value: Number(token.value) };
+    }
+    consumeBlockStart() {
+        if (!this.match("COLON")) {
+            const token = this.peek();
+            throw makeCatalogError("NEWT_E002", token.line, token.column, this.sourceLineHint(token));
+        }
+        this.consumeLineEnd();
+    }
+    consumeLineEnd() {
+        if (this.match("NEWLINE") || this.check("EOF")) {
+            return;
+        }
+        throw this.error(this.peek(), "I expected this line to end here.");
+    }
+    skipNewlines() {
+        while (this.match("NEWLINE")) {
+            // Keep moving.
+        }
+    }
+    isEndKeyword(keywords) {
+        return this.check("KEYWORD") && keywords.includes(this.peek().value);
+    }
+    consumeKeyword(value) {
+        if (this.checkKeyword(value)) {
+            return this.advance();
+        }
+        throw this.error(this.peek(), `Expected "${value}" here.`);
+    }
+    matchKeyword(value) {
+        if (!this.checkKeyword(value)) {
+            return false;
+        }
+        this.advance();
+        return true;
+    }
+    checkKeyword(value) {
+        return this.check("KEYWORD") && this.peek().value === value;
+    }
+    consumeWord(message) {
+        if (this.check("IDENTIFIER") || this.check("KEYWORD")) {
+            return this.advance();
+        }
+        throw this.error(this.peek(), message);
+    }
+    consumeType(type, message) {
+        if (this.check(type)) {
+            return this.advance();
+        }
+        throw this.error(this.peek(), message);
+    }
+    match(type) {
+        if (!this.check(type)) {
+            return false;
+        }
+        this.advance();
+        return true;
+    }
+    check(type) {
+        if (this.isAtEnd()) {
+            return type === "EOF";
+        }
+        return this.peek().type === type;
+    }
+    advance() {
+        if (!this.isAtEnd()) {
+            this.current += 1;
+        }
+        return this.previous();
+    }
+    isAtEnd() {
+        return this.peek().type === "EOF";
+    }
+    peek() {
+        return this.tokens[this.current] ?? this.tokens[this.tokens.length - 1];
+    }
+    previous() {
+        return this.tokens[this.current - 1] ?? this.tokens[0];
+    }
+    loc(token) {
+        return { line: token.line, column: token.column };
+    }
+    sourceLineHint(_token) {
+        return undefined;
+    }
+    error(token, message) {
+        return new NewtError({
+            code: "NEWT_E001",
+            message,
+            suggestion: "Check the Newt syntax for this line and try again.",
+            line: token.line,
+            column: token.column
+        });
+    }
+}

package/dist/src/validator.d.ts

@@ -0,0 +1,3 @@
+import type { Program } from "./ast.js";
+import { NewtError } from "./errors.js";
+export declare function validate(program: Program, source?: string): NewtError[];

package/dist/src/validator.js

@@ -0,0 +1,176 @@
+import { makeCatalogError } from "./errors.js";
+const builtIns = new Set([
+    "user.name",
+    "user.id",
+    "user.mention",
+    "message.content",
+    "channel.name",
+    "server.name",
+    "server.members",
+    "args",
+    "target"
+]);
+export function validate(program, source = "") {
+    const validator = new Validator(source);
+    return validator.validate(program);
+}
+class Validator {
+    source;
+    errors = [];
+    hasBotName = false;
+    hasBotToken = false;
+    constructor(source) {
+        this.source = source;
+    }
+    validate(program) {
+        for (const node of program.body) {
+            this.visitTopLevel(node);
+        }
+        if (!this.hasBotName) {
+            this.errors.push(makeCatalogError("NEWT_E008", 1, 1, this.line(1)));
+        }
+        if (!this.hasBotToken) {
+            this.errors.push(makeCatalogError("NEWT_E009", 1, 1, this.line(1)));
+        }
+        return this.errors;
+    }
+    visitTopLevel(node) {
+        if (node.type === "BotDecl") {
+            this.visitBotDecl(node);
+            return;
+        }
+        if (node.type === "EveryTimerDecl" || node.type === "DailyTimerDecl") {
+            this.visitTimer(node);
+            return;
+        }
+        this.visitStatements(node.body, new Set());
+    }
+    visitBotDecl(node) {
+        if (node.kind === "name") {
+            this.hasBotName = true;
+        }
+        if (node.kind === "token") {
+            this.hasBotToken = true;
+            if (!node.fromEnv) {
+                this.errors.push(makeCatalogError("NEWT_E005", node.loc.line, node.loc.column, this.line(node.loc.line)));
+            }
+        }
+    }
+    visitTimer(node) {
+        if (node.type === "EveryTimerDecl" && node.amount.value <= 0) {
+            this.errors.push(makeCatalogError("NEWT_E014", node.loc.line, node.loc.column, this.line(node.loc.line)));
+        }
+        this.visitStatements(node.body, new Set());
+    }
+    visitStatements(statements, scope, inTry = false) {
+        for (const statement of statements) {
+            switch (statement.type) {
+                case "LetDecl":
+                    this.visitExpression(statement.value, scope, inTry);
+                    scope.add(statement.name);
+                    break;
+                case "ReplyStatement":
+                case "SayStatement":
+                case "ExpressionStatement":
+                    this.visitExpression("message" in statement ? statement.message : statement.expression, scope, inTry);
+                    break;
+                case "SayEmbedStatement":
+                    if (statement.embed.title)
+                        this.visitExpression(statement.embed.title, scope, inTry);
+                    if (statement.embed.description)
+                        this.visitExpression(statement.embed.description, scope, inTry);
+                    for (const field of statement.embed.fields) {
+                        this.visitExpression(field.name, scope, inTry);
+                        this.visitExpression(field.value, scope, inTry);
+                    }
+                    break;
+                case "StoreStatement":
+                    this.visitExpression(statement.namespace, scope, inTry);
+                    this.visitExpression(statement.value, scope, inTry);
+                    break;
+                case "IfStatement":
+                    this.visitExpression(statement.condition, scope, inTry);
+                    this.visitStatements(statement.consequent, new Set(scope), inTry);
+                    this.visitStatements(statement.alternate, new Set(scope), inTry);
+                    break;
+                case "ForEachStatement":
+                    this.visitExpression(statement.iterable, scope, inTry);
+                    this.visitStatements(statement.body, new Set([...scope, statement.itemName]), inTry);
+                    break;
+                case "RequireRoleStatement":
+                case "GiveRoleStatement":
+                case "RemoveRoleStatement":
+                    if ("role" in statement && statement.role.value.length === 0) {
+                        this.errors.push(makeCatalogError("NEWT_E015", statement.loc.line, statement.loc.column, this.line(statement.loc.line)));
+                    }
+                    if ("subject" in statement)
+                        this.visitExpression(statement.subject, scope, inTry);
+                    break;
+                case "MuteStatement":
+                case "KickStatement":
+                case "BanStatement":
+                    this.visitExpression(statement.subject, scope, inTry);
+                    break;
+                case "TryCatchStatement":
+                    this.visitStatements(statement.body, new Set(scope), true);
+                    this.visitStatements(statement.errorHandler, new Set(scope), true);
+                    break;
+                case "WaitStatement":
+                    if (statement.duration.amount.value <= 0) {
+                        this.errors.push(makeCatalogError("NEWT_E014", statement.loc.line, statement.loc.column, this.line(statement.loc.line)));
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    visitExpression(expression, scope, inTry) {
+        switch (expression.type) {
+            case "IdentifierExpr":
+                if (!scope.has(expression.name) && !["user", "message", "channel", "server", "args", "target", "member", "current"].includes(expression.name)) {
+                    this.errors.push(makeCatalogError("NEWT_E007", expression.loc.line, expression.loc.column, this.line(expression.loc.line), {
+                        length: expression.name.length
+                    }));
+                }
+                break;
+            case "MemberExpr": {
+                const path = expression.path.join(".");
+                const isKnown = builtIns.has(path) || scope.has(expression.path[0] ?? "") || expression.path[0] === "member";
+                if (!isKnown) {
+                    this.errors.push(makeCatalogError("NEWT_E013", expression.loc.line, expression.loc.column, this.line(expression.loc.line), {
+                        length: path.length
+                    }));
+                }
+                break;
+            }
+            case "LoadExpr":
+                this.visitExpression(expression.namespace, scope, inTry);
+                if (expression.fallback)
+                    this.visitExpression(expression.fallback, scope, inTry);
+                break;
+            case "FetchExpr":
+                if (!inTry) {
+                    this.errors.push(makeCatalogError("NEWT_E011", expression.loc.line, expression.loc.column, this.line(expression.loc.line)));
+                }
+                this.visitExpression(expression.url, scope, inTry);
+                break;
+            case "BinaryExpr":
+                this.visitExpression(expression.left, scope, inTry);
+                this.visitExpression(expression.right, scope, inTry);
+                break;
+            case "UnaryExpr":
+                this.visitExpression(expression.argument, scope, inTry);
+                break;
+            case "CallExpr":
+                for (const arg of expression.args)
+                    this.visitExpression(arg, scope, inTry);
+                break;
+            default:
+                break;
+        }
+    }
+    line(line) {
+        return this.source.split(/\r?\n/)[line - 1] ?? "";
+    }
+}

package/dist/test/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/integration.test.js

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { test } from "node:test";
+import { compile, tokenize } from "../src/index.js";
+const examplesDir = resolve("../../examples");
+test("all example programs compile", () => {
+    const files = readdirSync(examplesDir).filter((file) => file.endsWith(".newt"));
+    assert.deepEqual(files.sort(), [
+        "hello-world.newt",
+        "moderation-bot.newt",
+        "points-bot.newt",
+        "welcome-bot.newt"
+    ]);
+    for (const file of files) {
+        const source = readFileSync(join(examplesDir, file), "utf8");
+        const result = compile(source, file);
+        assert.equal(result.success, true, `${file} should compile`);
+        if (result.success) {
+            assert.match(result.botJs, /new Client/);
+            assert.match(result.packageJson, /discord\.js/);
+        }
+    }
+});
+test("lexer emits indentation and interpolated string tokens", () => {
+    const tokens = tokenize(`on command "hello":\n    reply "Hi {user.name}!"\n`);
+    assert.ok(tokens.some((token) => token.type === "INDENT"));
+    assert.ok(tokens.some((token) => token.type === "DEDENT"));
+    assert.ok(tokens.some((token) => token.type === "STRING" && token.interpolated));
+});
+test("compiler reports missing bot token", () => {
+    const result = compile(`bot name "NoToken"\n\non ready:\n    say "Ready"\n`, "broken.newt");
+    assert.equal(result.success, false);
+    if (!result.success) {
+        assert.ok(result.errors.some((error) => error.code === "NEWT_E009"));
+    }
+});