@newt-dev/compiler 0.1.0

package/src/errors.ts

@@ -0,0 +1,164 @@
+export type NewtErrorSeverity = "error" | "warning";
+
+export type NewtErrorCode =
+  | "NEWT_E001"
+  | "NEWT_E002"
+  | "NEWT_E003"
+  | "NEWT_E004"
+  | "NEWT_E005"
+  | "NEWT_E006"
+  | "NEWT_E007"
+  | "NEWT_E008"
+  | "NEWT_E009"
+  | "NEWT_E010"
+  | "NEWT_E011"
+  | "NEWT_E012"
+  | "NEWT_E013"
+  | "NEWT_E014"
+  | "NEWT_E015";
+
+export interface NewtErrorOptions {
+  code: NewtErrorCode;
+  message: string;
+  line: number;
+  column: number;
+  sourceLine?: string;
+  suggestion?: string;
+  severity?: NewtErrorSeverity;
+  filename?: string;
+  length?: number;
+}
+
+export class NewtError extends Error {
+  readonly code: NewtErrorCode;
+  readonly line: number;
+  readonly column: number;
+  readonly sourceLine?: string;
+  readonly suggestion?: string;
+  readonly severity: NewtErrorSeverity;
+  readonly filename?: string;
+  readonly length: number;
+
+  constructor(options: NewtErrorOptions) {
+    super(options.message);
+    this.name = "NewtError";
+    this.code = options.code;
+    this.line = options.line;
+    this.column = options.column;
+    this.sourceLine = options.sourceLine;
+    this.suggestion = options.suggestion;
+    this.severity = options.severity ?? "error";
+    this.filename = options.filename;
+    this.length = options.length ?? 1;
+  }
+}
+
+export const errorCatalog: Record<NewtErrorCode, { message: string; suggestion: string; severity?: NewtErrorSeverity }> = {
+  NEWT_E001: {
+    message: "Strings must be in quotes.",
+    suggestion: "Wrap the text in double quotes, like: reply \"Hello!\""
+  },
+  NEWT_E002: {
+    message: "Event handlers need a colon at the end.",
+    suggestion: "Try ending the line with a colon, like: on command \"hello\":"
+  },
+  NEWT_E003: {
+    message: "That is not a known event name.",
+    suggestion: "Try one of: on ready, on command, on join, on leave, on message contains, or on reaction add."
+  },
+  NEWT_E004: {
+    message: "This line needs to be inside a handler.",
+    suggestion: "Put this action under a line like: on command \"hello\":"
+  },
+  NEWT_E005: {
+    message: "[SECURITY WARNING] Never put your bot token directly in the file.",
+    suggestion: "Use: bot token from env \"DISCORD_TOKEN\"",
+    severity: "warning"
+  },
+  NEWT_E006: {
+    message: "Indentation looks off on this line.",
+    suggestion: "Use 2 or 4 spaces consistently within the file."
+  },
+  NEWT_E007: {
+    message: "This variable has not been defined yet.",
+    suggestion: "Add a let line before using it, like: let name = \"Newt\""
+  },
+  NEWT_E008: {
+    message: "Your bot needs a name.",
+    suggestion: "Add a line near the top: bot name \"MyBot\""
+  },
+  NEWT_E009: {
+    message: "Your bot needs a token source.",
+    suggestion: "Add: bot token from env \"DISCORD_TOKEN\""
+  },
+  NEWT_E010: {
+    message: "Embed colors must be hex colors.",
+    suggestion: "Use a six-digit color like: color #5865F2"
+  },
+  NEWT_E011: {
+    message: "Network requests should have an error fallback.",
+    suggestion: "Put fetch inside try: and add an on error: block."
+  },
+  NEWT_E012: {
+    message: "target only works when a command message mentions someone.",
+    suggestion: "Make sure this command is used like: !mute @Someone"
+  },
+  NEWT_E013: {
+    message: "That built-in variable does not exist.",
+    suggestion: "Use a built-in like user.name, message.content, channel.name, server.name, args, or target."
+  },
+  NEWT_E014: {
+    message: "Timer intervals must be greater than zero.",
+    suggestion: "Use a positive interval, like: every 1 hour:"
+  },
+  NEWT_E015: {
+    message: "Role names cannot be empty.",
+    suggestion: "Use a real role name, like: require role \"Moderator\""
+  }
+};
+
+export function makeCatalogError(
+  code: NewtErrorCode,
+  line: number,
+  column: number,
+  sourceLine?: string,
+  overrides: Partial<NewtErrorOptions> = {}
+): NewtError {
+  const entry = errorCatalog[code];
+  return new NewtError({
+    code,
+    line,
+    column,
+    sourceLine,
+    message: entry.message,
+    suggestion: entry.suggestion,
+    severity: entry.severity,
+    ...overrides
+  });
+}
+
+export function formatError(error: NewtError, sourceOrFilename = ""): string {
+  const filename = error.filename ?? (sourceOrFilename.includes("\n") ? "input.newt" : sourceOrFilename || "input.newt");
+  const sourceLine = error.sourceLine ?? getSourceLine(sourceOrFilename, error.line);
+  const label = error.severity === "warning" ? "Warning" : "Error";
+  const caretOffset = Math.max(0, error.column - 1);
+  const caretLength = Math.max(1, error.length);
+  const caretLine = `${" ".repeat(caretOffset)}${"^".repeat(caretLength)}`;
+  const suggestion = error.suggestion ? ` ${error.suggestion}` : "";
+
+  return [
+    `${label} [${error.code}] on line ${error.line} in ${filename}:`,
+    "",
+    `    ${sourceLine}`,
+    `    ${caretLine}`,
+    `${error.message}${suggestion}`
+  ].join("\n");
+}
+
+function getSourceLine(source: string, line: number): string {
+  if (!source.includes("\n")) {
+    return "";
+  }
+
+  return source.split(/\r?\n/)[line - 1] ?? "";
+}

package/src/index.ts

@@ -0,0 +1,48 @@
+import { generate, type GeneratedProject } from "./codegen.js";
+import { formatError, NewtError } from "./errors.js";
+import { tokenize } from "./lexer.js";
+import { parse } from "./parser.js";
+import { validate } from "./validator.js";
+
+export interface CompileSuccess extends GeneratedProject {
+  success: true;
+}
+
+export interface CompileFailure {
+  success: false;
+  errors: NewtError[];
+}
+
+export type CompileResult = CompileSuccess | CompileFailure;
+
+export function compile(source: string, filename = "input.newt"): CompileResult {
+  try {
+    const tokens = tokenize(source);
+    const program = parse(tokens);
+    const errors = validate(program, source).map((error) => {
+      if (!error.filename) {
+        return new NewtError({ ...error, filename });
+      }
+      return error;
+    });
+
+    const fatalErrors = errors.filter((error) => error.severity === "error");
+    if (fatalErrors.length > 0) {
+      return { success: false, errors };
+    }
+
+    return { success: true, ...generate(program) };
+  } catch (error) {
+    if (error instanceof NewtError) {
+      return { success: false, errors: [new NewtError({ ...error, filename })] };
+    }
+    throw error;
+  }
+}
+
+export { generate } from "./codegen.js";
+export { formatError, NewtError } from "./errors.js";
+export { tokenize, type Token, type TokenType } from "./lexer.js";
+export { parse } from "./parser.js";
+export { validate } from "./validator.js";
+export type * from "./ast.js";

package/src/lexer.ts

@@ -0,0 +1,349 @@
+import { makeCatalogError, NewtError } from "./errors.js";
+
+export type TokenType =
+  | "KEYWORD"
+  | "STRING"
+  | "NUMBER"
+  | "IDENTIFIER"
+  | "INDENT"
+  | "DEDENT"
+  | "NEWLINE"
+  | "COLON"
+  | "EQUALS"
+  | "LPAREN"
+  | "RPAREN"
+  | "LBRACKET"
+  | "RBRACKET"
+  | "COMMA"
+  | "DOT"
+  | "OPERATOR"
+  | "HASH_COLOR"
+  | "COMMENT"
+  | "EOF";
+
+export interface Token {
+  type: TokenType;
+  value: string;
+  line: number;
+  column: number;
+  interpolated?: boolean;
+}
+
+const keywords = new Set([
+  "bot",
+  "name",
+  "prefix",
+  "token",
+  "on",
+  "ready",
+  "command",
+  "join",
+  "leave",
+  "message",
+  "reaction",
+  "add",
+  "let",
+  "if",
+  "else",
+  "for",
+  "every",
+  "at",
+  "reply",
+  "say",
+  "give",
+  "remove",
+  "require",
+  "role",
+  "store",
+  "load",
+  "fetch",
+  "try",
+  "error",
+  "in",
+  "from",
+  "env",
+  "each",
+  "contains",
+  "has",
+  "or",
+  "and",
+  "not",
+  "embed",
+  "title",
+  "description",
+  "color",
+  "field",
+  "daily",
+  "mute",
+  "kick",
+  "ban",
+  "pin",
+  "delete",
+  "wait",
+  "target",
+  "channel",
+  "server",
+  "user",
+  "member",
+  "members",
+  "minutes",
+  "minute",
+  "hours",
+  "hour",
+  "seconds",
+  "second",
+  "days",
+  "day",
+  "args",
+  "random",
+  "between",
+  "round",
+  "floor",
+  "ceil",
+  "uppercase",
+  "lowercase",
+  "replace",
+  "split"
+]);
+
+export function tokenize(source: string): Token[] {
+  const lexer = new Lexer(source);
+  return lexer.tokenize();
+}
+
+class Lexer {
+  private readonly tokens: Token[] = [];
+  private readonly indentStack = [0];
+  private indentUnit: number | undefined;
+  private readonly lines: string[];
+
+  constructor(private readonly source: string) {
+    this.lines = source.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  }
+
+  tokenize(): Token[] {
+    for (let index = 0; index < this.lines.length; index += 1) {
+      this.tokenizeLine(this.lines[index] ?? "", index + 1);
+    }
+
+    const lastLine = Math.max(1, this.lines.length);
+    while (this.indentStack.length > 1) {
+      this.indentStack.pop();
+      this.push("DEDENT", "", lastLine, 1);
+    }
+
+    this.push("EOF", "", lastLine, (this.lines[this.lines.length - 1]?.length ?? 0) + 1);
+    return this.tokens;
+  }
+
+  private tokenizeLine(rawLine: string, lineNumber: number): void {
+    const lineWithoutTrailing = rawLine.replace(/\s+$/u, "");
+    const contentStart = this.countIndent(lineWithoutTrailing);
+    const content = lineWithoutTrailing.slice(contentStart);
+
+    if (content.length === 0 || content.startsWith("#")) {
+      return;
+    }
+
+    this.applyIndent(contentStart, lineNumber, rawLine);
+
+    let index = contentStart;
+    while (index < lineWithoutTrailing.length) {
+      const char = lineWithoutTrailing[index] ?? "";
+      const column = index + 1;
+
+      if (char === " " || char === "\t") {
+        index += 1;
+        continue;
+      }
+
+      if (char === "#") {
+        const maybeColor = lineWithoutTrailing.slice(index, index + 7);
+        if (/^#[0-9a-fA-F]{6}$/u.test(maybeColor)) {
+          this.push("HASH_COLOR", maybeColor, lineNumber, column);
+          index += 7;
+          continue;
+        }
+
+        this.push("COMMENT", lineWithoutTrailing.slice(index), lineNumber, column);
+        break;
+      }
+
+      if (char === "\"") {
+        index = this.readString(lineWithoutTrailing, index, lineNumber);
+        continue;
+      }
+
+      if (/[0-9]/u.test(char)) {
+        index = this.readNumber(lineWithoutTrailing, index, lineNumber);
+        continue;
+      }
+
+      if (/[A-Za-z_]/u.test(char)) {
+        index = this.readWord(lineWithoutTrailing, index, lineNumber);
+        continue;
+      }
+
+      const singleToken = this.singleCharToken(char);
+      if (singleToken) {
+        this.push(singleToken, char, lineNumber, column);
+        index += 1;
+        continue;
+      }
+
+      if ("+-*/<>!".includes(char)) {
+        const next = lineWithoutTrailing[index + 1];
+        const value = next === "=" ? `${char}=` : char;
+        this.push("OPERATOR", value, lineNumber, column);
+        index += value.length;
+        continue;
+      }
+
+      throw new NewtError({
+        code: "NEWT_E001",
+        message: `I do not know what to do with "${char}" here.`,
+        suggestion: "Check for a missing quote or an extra symbol.",
+        line: lineNumber,
+        column,
+        sourceLine: rawLine
+      });
+    }
+
+    this.push("NEWLINE", "", lineNumber, lineWithoutTrailing.length + 1);
+  }
+
+  private applyIndent(indent: number, lineNumber: number, sourceLine: string): void {
+    const current = this.indentStack[this.indentStack.length - 1] ?? 0;
+    if (indent === current) {
+      return;
+    }
+
+    if (indent > current) {
+      const diff = indent - current;
+      if (!this.indentUnit) {
+        if (diff !== 2 && diff !== 4) {
+          throw makeCatalogError("NEWT_E006", lineNumber, 1, sourceLine);
+        }
+        this.indentUnit = diff;
+      } else if (diff % this.indentUnit !== 0) {
+        throw makeCatalogError("NEWT_E006", lineNumber, 1, sourceLine);
+      }
+
+      this.indentStack.push(indent);
+      this.push("INDENT", "", lineNumber, 1);
+      return;
+    }
+
+    while (this.indentStack.length > 1 && indent < (this.indentStack[this.indentStack.length - 1] ?? 0)) {
+      this.indentStack.pop();
+      this.push("DEDENT", "", lineNumber, 1);
+    }
+
+    if (indent !== (this.indentStack[this.indentStack.length - 1] ?? 0)) {
+      throw makeCatalogError("NEWT_E006", lineNumber, 1, sourceLine);
+    }
+  }
+
+  private countIndent(line: string): number {
+    let count = 0;
+    for (const char of line) {
+      if (char === " ") {
+        count += 1;
+      } else if (char === "\t") {
+        count += 4;
+      } else {
+        break;
+      }
+    }
+    return count;
+  }
+
+  private readString(line: string, start: number, lineNumber: number): number {
+    let index = start + 1;
+    let value = "";
+    let escaped = false;
+
+    while (index < line.length) {
+      const char = line[index] ?? "";
+
+      if (escaped) {
+        value += char;
+        escaped = false;
+        index += 1;
+        continue;
+      }
+
+      if (char === "\\") {
+        escaped = true;
+        index += 1;
+        continue;
+      }
+
+      if (char === "\"") {
+        this.push("STRING", value, lineNumber, start + 1, /\{[^}]+\}/u.test(value));
+        return index + 1;
+      }
+
+      value += char;
+      index += 1;
+    }
+
+    throw new NewtError({
+      code: "NEWT_E001",
+      message: "This string starts with a quote but never closes.",
+      suggestion: "Add a closing double quote at the end of the text.",
+      line: lineNumber,
+      column: start + 1,
+      sourceLine: line,
+      length: Math.max(1, line.length - start)
+    });
+  }
+
+  private readNumber(line: string, start: number, lineNumber: number): number {
+    let index = start;
+    while (/[0-9.]/u.test(line[index] ?? "")) {
+      index += 1;
+    }
+
+    this.push("NUMBER", line.slice(start, index), lineNumber, start + 1);
+    return index;
+  }
+
+  private readWord(line: string, start: number, lineNumber: number): number {
+    let index = start;
+    while (/[A-Za-z0-9_]/u.test(line[index] ?? "")) {
+      index += 1;
+    }
+
+    const value = line.slice(start, index);
+    this.push(keywords.has(value) ? "KEYWORD" : "IDENTIFIER", value, lineNumber, start + 1);
+    return index;
+  }
+
+  private singleCharToken(char: string): TokenType | undefined {
+    switch (char) {
+      case ":":
+        return "COLON";
+      case "=":
+        return "EQUALS";
+      case "(":
+        return "LPAREN";
+      case ")":
+        return "RPAREN";
+      case "[":
+        return "LBRACKET";
+      case "]":
+        return "RBRACKET";
+      case ",":
+        return "COMMA";
+      case ".":
+        return "DOT";
+      default:
+        return undefined;
+    }
+  }
+
+  private push(type: TokenType, value: string, line: number, column: number, interpolated?: boolean): void {
+    this.tokens.push({ type, value, line, column, interpolated });
+  }
+}