better error messages for building dictionary

Author: neverRare

build/build.ts

@@ -9,11 +9,17 @@ const BUILD_OPTIONS: ESBuild.BuildOptions = {
   minify: true,
   define: { LIVE_RELOAD: "false" },
 };
-if (import.meta.main) {
+async function main(): Promise<void> {
   const start = performance.now();
-  await Dictionary.build();
+  if (!await Dictionary.build()) {
+    Deno.exitCode = 1;
+    return;
+  }
   await ESBuild.build(BUILD_OPTIONS);
   const end = performance.now();
   // deno-lint-ignore no-console
   console.log(`Total time took: ${Math.floor(end - start)}ms`);
 }
+if (import.meta.main) {
+  await main();
+}

build/dev.ts

@@ -23,6 +23,7 @@ async function watchDictionary(): Promise<number> {
   const command = new Deno.Command(Deno.execPath(), {
     args: [
       "run",
+      "-E=NO_COLOR",
       "-R=./dictionary/dictionary",
       "-W=./dictionary/dictionary.ts",
       "--no-prompt",
@@ -42,18 +43,20 @@ async function watchDictionary(): Promise<number> {
   assert(!status.success);
   return status.code;
 }
-if (import.meta.main) {
-  let statusCode: number;
-  {
-    if (
-      !await exists(new URL("../dictionary/dictionary.ts", import.meta.url))
-    ) {
-      const Dictionary = await import("../dictionary/build.ts");
-      await Dictionary.build();
+async function main(): Promise<void> {
+  if (
+    !await exists(new URL("../dictionary/dictionary.ts", import.meta.url))
+  ) {
+    const Dictionary = await import("../dictionary/build.ts");
+    if (!await Dictionary.build()) {
+      Deno.exitCode = 1;
+      return;
     }
-    const statusCodePromise = watchDictionary();
-    await using _ = await watchMain();
-    statusCode = await statusCodePromise;
   }
-  Deno.exit(statusCode);
+  const statusCodePromise = watchDictionary();
+  await using _ = await watchMain();
+  Deno.exitCode = await statusCodePromise;
+}
+if (import.meta.main) {
+  await main();
 }

deno.json

@@ -22,7 +22,7 @@
     },
     "build-dictionary": {
       "description": "Builds the dictionary at `./dictionary/dictionary.ts`",
-      "command": "deno run -R=./dictionary/dictionary -W=./dictionary/dictionary.ts --no-prompt --frozen --cached-only ./dictionary/build.ts"
+      "command": "deno run -E=NO_COLOR -R=./dictionary/dictionary -W=./dictionary/dictionary.ts --no-prompt --frozen --cached-only ./dictionary/build.ts"
     }
   },
   "fmt": {

dictionary/build.ts

@@ -1,18 +1,29 @@
 // This code is Deno only
 
-import { parseDictionary } from "./parser.ts";
+// deno-lint-ignore-file no-console
+
+import { ArrayResultError } from "../src/mod.ts";
+import { PositionedError } from "../src/parser/parser_lib.ts";
+import { dictionaryParser } from "./parser.ts";
+import { Dictionary } from "./type.ts";
 
 const SOURCE = new URL("./dictionary", import.meta.url);
 const DESTINATION = new URL("./dictionary.ts", import.meta.url);
 
-export async function build(): Promise<void> {
-  // deno-lint-ignore no-console
+export async function build(): Promise<boolean> {
   console.log("Building dictionary...");
   const start = performance.now();
   const text = await Deno.readTextFile(SOURCE);
   const startDictionary = performance.now();
-  const dictionary = parseDictionary(text);
+  const result = dictionaryParser.parse(text);
   const endDictionary = performance.now();
+  let dictionary: Dictionary;
+  if (!result.isError()) {
+    dictionary = result.array[0];
+  } else {
+    displayError(text, result.errors);
+    return false;
+  }
   const json = JSON.stringify(
     Object.fromEntries(dictionary),
     undefined,
@@ -29,11 +40,37 @@ export const dictionary: Dictionary = new Map(Object.entries(${json}));
   const end = performance.now();
   const total = Math.floor(end - start);
   const parsing = Math.floor(endDictionary - startDictionary);
-  // deno-lint-ignore no-console
   console.log(
     `Building dictionary done in ${total}ms (parsing dictionary took ${parsing}ms)`,
   );
+  return true;
+}
+function displayError(
+  source: string,
+  errors: ReadonlyArray<ArrayResultError>,
+): void {
+  let color: boolean;
+  try {
+    color = Deno.env.get("NO_COLOR") !== "1";
+  } catch (error) {
+    if (error instanceof Deno.errors.NotCapable) {
+      color = true;
+    } else {
+      throw error;
+    }
+  }
+  for (const error of errors) {
+    console.error(`Error: ${error.message}`);
+    if (error instanceof PositionedError) {
+      const position = error.position;
+      const lines = source.slice(0, position?.position).split(/\r?\n/);
+      const line = lines.length;
+      const column = lines[lines.length - 1].length + 1;
+      console.error(`    at ${SOURCE}:${line}:${column}`);
+      console.error();
+    }
+  }
 }
 if (import.meta.main) {
-  await build();
+  Deno.exitCode = await build() ? 0 : 1;
 }

dictionary/parser.ts

@@ -23,7 +23,7 @@ import {
   UnexpectedError,
   withSource,
 } from "../src/parser/parser_lib.ts";
-import { Definition, Dictionary, Noun, PartialVerb } from "./type.ts";
+import { Definition, Noun, PartialVerb } from "./type.ts";
 
 const RESERVED_SYMBOLS = "#()*+/:;<=>@[\\]^`{|}~";
 
@@ -581,7 +581,7 @@ const entry = withSource(
   ),
 )
   .map(([definitions, source]) => ({ definitions, source: source.trimEnd() }));
-const dictionaryParser = ignore
+export const dictionaryParser = ignore
   .with(allWithCheck(new CheckedParser(notEnd, sequence(head, entry))))
   .map((entries) =>
     new Map(
@@ -590,6 +590,3 @@ const dictionaryParser = ignore
       ),
     )
   );
-export function parseDictionary(sourceText: string): Dictionary {
-  return dictionaryParser.parse(sourceText).unwrap()[0];
-}

dictionary/watch.ts

@@ -5,21 +5,15 @@ import { debounce } from "@std/async/debounce";
 import { AsyncDisposableStack } from "../misc/async_disposable_stack.ts";
 import { build } from "./build.ts";
 
-async function tryBuild(): Promise<void> {
-  try {
-    await build();
-  } catch (error) {
-    // deno-lint-ignore no-console
-    console.log(error);
-  }
-}
 if (import.meta.main) {
   await using stack = new AsyncDisposableStack();
   using watcher = Deno.watchFs("./dictionary/dictionary");
   let task = Promise.resolve();
   stack.defer(async () => await task);
   const buildDebounced = debounce(() => {
-    task = task.then(tryBuild);
+    task = task.then(async () => {
+      await build();
+    });
   }, 200);
   buildDebounced();
   buildDebounced.flush();

src/dictionary.ts

@@ -1,5 +1,5 @@
 import { dictionary as globalDictionary } from "../dictionary/dictionary.ts";
-import { parseDictionary } from "../dictionary/parser.ts";
+import { dictionaryParser } from "../dictionary/parser.ts";
 import { Definition, Dictionary } from "../dictionary/type.ts";
 import { load } from "../telo_misikeke/telo_misikeke.js";
 
@@ -18,7 +18,7 @@ export const tokiPonaWordSet: Set<string> = new Set();
 update();
 
 export function loadCustomDictionary(dictionaryText: string): void {
-  const dictionary = parseDictionary(dictionaryText);
+  const dictionary = dictionaryParser.parse(dictionaryText).unwrap()[0];
   customDictionary.clear();
   for (const [key, value] of dictionary) {
     customDictionary.set(key, value);