skir 0.0.6 → 0.0.8

package/src/compiler.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import * as fs from "fs/promises";
+import * as FileSystem from "fs/promises";
 import { glob } from "glob";
-import * as paths from "path";
+import * as Paths from "path";
 import type { CodeGenerator } from "skir-internal";
 import Watcher from "watcher";
 import { parseCommandLine } from "./command_line_parser.js";
@@ -14,8 +14,13 @@ import {
   renderErrors,
   renderSkirConfigErrors,
 } from "./error_renderer.js";
+import { ExitError } from "./exit_error.js";
 import { formatModule } from "./formatter.js";
-import { REAL_FILE_SYSTEM } from "./io.js";
+import {
+  isDirectory,
+  REAL_FILE_SYSTEM,
+  rewritePathForRendering,
+} from "./io.js";
 import { collectModules } from "./module_collector.js";
 import { ModuleSet } from "./module_set.js";
 import { initializeProject } from "./project_initializer.js";
@@ -35,14 +40,12 @@ async function makeGeneratorBundle(
 ): Promise<GeneratorBundle> {
   const generator = await importCodeGenerator(config.mod);
   let skiroutDirs: string[];
-  if (config.outDir === undefined) {
-    skiroutDirs = ["skirout"];
-  } else if (typeof config.outDir === "string") {
+  if (typeof config.outDir === "string") {
     skiroutDirs = [config.outDir];
   } else {
     skiroutDirs = config.outDir;
   }
-  skiroutDirs = skiroutDirs.map((d) => paths.join(root, d));
+  skiroutDirs = skiroutDirs.map((d) => Paths.join(root, d));
   return {
     generator: generator,
     config: config.config,
@@ -133,7 +136,7 @@ class WatchModeMainLoop {
           const successMessage = `Generation succeeded at ${date}`;
           console.log(makeGreen(successMessage));
           console.log("\nWaiting for changes in files matching:");
-          const glob = paths.resolve(paths.join(this.srcDir, "/**/*.skir"));
+          const glob = Paths.resolve(Paths.join(this.srcDir, "/**/*.skir"));
           console.log(`  ${glob}`);
         }
         return true;
@@ -150,11 +153,11 @@ class WatchModeMainLoop {
     const { skiroutDirs } = this;
     const preExistingAbsolutePaths = new Set<string>();
     for (const skiroutDir of skiroutDirs) {
-      await fs.mkdir(skiroutDir, { recursive: true });
+      await FileSystem.mkdir(skiroutDir, { recursive: true });
 
       // Collect all the files in all the skirout dirs.
       (
-        await glob(paths.join(skiroutDir, "**/*"), { withFileTypes: true })
+        await glob(Paths.join(skiroutDir, "**/*"), { withFileTypes: true })
       ).forEach((p) => preExistingAbsolutePaths.add(p.fullpath()));
     }
 
@@ -169,7 +172,9 @@ class WatchModeMainLoop {
       for (const file of files) {
         const { path } = file;
         if (pathToFile.has(path)) {
-          throw new Error(`Multiple generators produce ${path}`);
+          throw new ExitError(
+            "Multiple generators produce " + rewritePathForRendering(path),
+          );
         }
         pathToFile.set(path, file);
         pathToGenerator.set(path, generator);
@@ -179,10 +184,10 @@ class WatchModeMainLoop {
           for (
             let pathToKeep = path;
             pathToKeep !== ".";
-            pathToKeep = paths.dirname(pathToKeep)
+            pathToKeep = Paths.dirname(pathToKeep)
           ) {
             preExistingAbsolutePaths.delete(
-              paths.resolve(paths.join(skiroutDir, pathToKeep)),
+              Paths.resolve(Paths.join(skiroutDir, pathToKeep)),
             );
           }
         }
@@ -196,9 +201,9 @@ class WatchModeMainLoop {
         const oldFile = lastWriteBatch.pathToFile.get(p);
         const generator = pathToGenerator.get(p)!;
         for (const skiroutDir of generator.skiroutDirs) {
-          const fsPath = paths.join(skiroutDir, p);
+          const fsPath = Paths.join(skiroutDir, p);
           if (oldFile?.code === newFile.code) {
-            const mtime = (await fs.stat(fsPath)).mtime;
+            const mtime = (await FileSystem.stat(fsPath)).mtime;
             if (
               mtime !== null &&
               mtime.getDate() <= lastWriteBatch.writeTime.getDate()
@@ -206,8 +211,8 @@ class WatchModeMainLoop {
               return;
             }
           }
-          await fs.mkdir(paths.dirname(fsPath), { recursive: true });
-          await fs.writeFile(fsPath, newFile.code, "utf-8");
+          await FileSystem.mkdir(Paths.dirname(fsPath), { recursive: true });
+          await FileSystem.writeFile(fsPath, newFile.code, "utf-8");
         }
       }),
     );
@@ -218,8 +223,8 @@ class WatchModeMainLoop {
         .sort((a, b) => b.localeCompare(a, "en-US"))
         .map(async (p) => {
           try {
-            await fs.rm(p, { force: true, recursive: true });
-          } catch (e) {
+            await FileSystem.rm(p, { force: true, recursive: true });
+          } catch (_e) {
             // Ignore error.
           }
         }),
@@ -240,25 +245,19 @@ class WatchModeMainLoop {
   };
 }
 
-async function isDirectory(path: string): Promise<boolean> {
-  try {
-    return (await fs.lstat(path)).isDirectory();
-  } catch (e) {
-    return false;
-  }
-}
-
 function checkNoOverlappingSkiroutDirs(skiroutDirs: readonly string[]): void {
   for (let i = 0; i < skiroutDirs.length; ++i) {
     for (let j = i + 1; j < skiroutDirs.length; ++j) {
-      const dirA = paths.normalize(skiroutDirs[i]!);
-      const dirB = paths.normalize(skiroutDirs[j]!);
+      const dirA = Paths.normalize(skiroutDirs[i]!);
+      const dirB = Paths.normalize(skiroutDirs[j]!);
 
       if (
-        dirA.startsWith(dirB + paths.sep) ||
-        dirB.startsWith(dirA + paths.sep)
+        dirA.startsWith(dirB + Paths.sep) ||
+        dirB.startsWith(dirA + Paths.sep)
       ) {
-        throw new Error(`Overlapping skirout directories: ${dirA} and ${dirB}`);
+        throw new ExitError(
+          `Overlapping skirout directories: ${dirA} and ${dirB}`,
+        );
       }
     }
   }
@@ -270,7 +269,7 @@ interface ModuleFormatResult {
 }
 
 async function format(root: string, mode: "fix" | "check"): Promise<void> {
-  const skirFiles = await glob(paths.join(root, "**/*.skir"), {
+  const skirFiles = await glob(Paths.join(root, "**/*.skir"), {
     withFileTypes: true,
   });
   const pathToFormatResult = new Map<string, ModuleFormatResult>();
@@ -280,7 +279,9 @@ async function format(root: string, mode: "fix" | "check"): Promise<void> {
     }
     const unformattedCode = REAL_FILE_SYSTEM.readTextFile(skirFile.fullpath());
     if (unformattedCode === undefined) {
-      throw new Error(`Cannot read ${skirFile.fullpath()}`);
+      throw new ExitError(
+        "Cannot read " + rewritePathForRendering(skirFile.fullpath()),
+      );
     }
     const tokens = tokenizeModule(unformattedCode, "");
     if (tokens.errors.length) {
@@ -295,7 +296,7 @@ async function format(root: string, mode: "fix" | "check"): Promise<void> {
   }
   let numFilesNotFormatted = 0;
   for (const [path, result] of pathToFormatResult) {
-    const relativePath = paths.relative(root, path).replace(/\\/g, "/");
+    const relativePath = Paths.relative(root, path).replace(/\\/g, "/");
     if (mode === "fix") {
       if (result.alreadyFormatted) {
         console.log(`${makeGray(relativePath)} (unchanged)`);
@@ -333,14 +334,14 @@ async function main(): Promise<void> {
 
   const root = args.root || ".";
 
-  if (!(await isDirectory(root!))) {
+  if (!(await isDirectory(root))) {
     console.error(makeRed(`Not a directory: ${root}`));
     process.exit(1);
   }
 
   switch (args.kind) {
     case "init": {
-      initializeProject(root!);
+      initializeProject(root);
       return;
     }
     case "help":
@@ -349,14 +350,7 @@ async function main(): Promise<void> {
     }
   }
 
-  let skirConfigPath = paths.join(root!, "skir.yml");
-  if (
-    !paths.isAbsolute(skirConfigPath) &&
-    !/^\.{1,2}[/\\]$/.test(skirConfigPath)
-  ) {
-    // To make it clear that it's a path, prepend "./"
-    skirConfigPath = `.${paths.sep}${skirConfigPath}`;
-  }
+  const skirConfigPath = rewritePathForRendering(Paths.join(root, "skir.yml"));
   const skirConfigCode = REAL_FILE_SYSTEM.readTextFile(skirConfigPath);
   if (skirConfigCode === undefined) {
     console.error(makeRed(`Cannot find ${skirConfigPath}`));
@@ -366,32 +360,30 @@ async function main(): Promise<void> {
   const skirConfigResult = await parseSkirConfig(skirConfigCode, "import-mods");
   if (skirConfigResult.errors.length > 0) {
     console.error(makeRed("Invalid skir config"));
-    renderSkirConfigErrors(skirConfigResult.errors, { skirConfigPath });
+    const { maybeForgotToEditAfterInit } = skirConfigResult;
+    renderSkirConfigErrors(skirConfigResult.errors, {
+      skirConfigPath,
+      maybeForgotToEditAfterInit,
+    });
     process.exit(1);
   }
   const skirConfig = skirConfigResult.skirConfig!;
 
-  const srcDir = paths.join(root!, skirConfig.srcDir || ".");
+  const srcDir = Paths.join(root, skirConfig.srcDir || ".");
 
   switch (args.kind) {
     case "format": {
       // Check or fix the formatting to the .skir files in the source directory.
-      await format(srcDir, args.subcommand === "check" ? "check" : "fix");
+      await format(srcDir, args.subcommand === "ci" ? "check" : "fix");
       break;
     }
     case "gen": {
       // Run the skir code generators in watch mode or once.
       const generatorBundles: GeneratorBundle[] = await Promise.all(
         skirConfig.generators.map((config) =>
-          makeGeneratorBundle(config, root!),
+          makeGeneratorBundle(config, root),
         ),
       );
-      // Sort for consistency.
-      generatorBundles.sort((a, b) => {
-        const aId = a.generator.id;
-        const bId = b.generator.id;
-        return aId.localeCompare(bId, "en-US");
-      });
       // Look for duplicates.
       for (let i = 0; i < generatorBundles.length - 1; ++i) {
         const { id } = generatorBundles[i]!.generator;
@@ -417,14 +409,17 @@ async function main(): Promise<void> {
     case "snapshot": {
       if (args.subcommand === "view") {
         viewSnapshot({
-          rootDir: root!,
+          rootDir: root,
         });
       } else {
-        takeSnapshot({
-          rootDir: root!,
+        const success = takeSnapshot({
+          rootDir: root,
           srcDir: srcDir,
-          check: args.subcommand === "check",
+          subcommand: args.subcommand,
         });
+        if (!success) {
+          process.exit(1);
+        }
       }
       break;
     }
@@ -435,4 +430,14 @@ async function main(): Promise<void> {
   }
 }
 
-main();
+try {
+  await main();
+} catch (e) {
+  if (e instanceof Error) {
+    console.error(makeRed(e.message));
+    if (e instanceof ExitError) {
+      process.exit(1);
+    }
+  }
+  throw e;
+}

package/src/config.ts

@@ -2,13 +2,11 @@ import { z } from "zod";
 
 export const GeneratorConfig = z.strictObject({
   mod: z.string(),
+  outDir: z.union([
+    z.string().endsWith("/skirout"),
+    z.array(z.string().endsWith("/skirout")),
+  ]),
   config: z.any(),
-  outDir: z
-    .union([
-      z.string().endsWith("/skirout"),
-      z.array(z.string().endsWith("/skirout")),
-    ])
-    .optional(),
 });
 
 export type GeneratorConfig = z.infer<typeof GeneratorConfig>;

package/src/config_parser.ts

@@ -1,16 +1,22 @@
-import * as ccGen from "skir-cc-gen";
-import * as dartGen from "skir-dart-gen";
+import * as CcGen from "skir-cc-gen";
+import * as DartGen from "skir-dart-gen";
 import { CodeGenerator } from "skir-internal";
-import * as javaGen from "skir-java-gen";
-import * as kotlinGen from "skir-kotlin-gen";
-import * as pythonGen from "skir-python-gen";
-import * as typescriptGen from "skir-typescript-gen";
+import * as JavaGen from "skir-java-gen";
+import * as KotlinGen from "skir-kotlin-gen";
+import * as PythonGen from "skir-python-gen";
+import * as TypescriptGen from "skir-typescript-gen";
 import { LineCounter, parseDocument, Scalar, YAMLMap } from "yaml";
 import { SkirConfig } from "./config.js";
 
 export interface SkirConfigResult {
+  /** Defined if and only if `errors` is empty. */
   skirConfig: SkirConfig | undefined;
   errors: readonly SkirConfigError[];
+  /**
+   * If true, the user may have forgotten to edit skir.yml after running
+   * `npx skir init`.
+   */
+  maybeForgotToEditAfterInit?: boolean;
 }
 
 export interface SkirConfigError {
@@ -66,6 +72,39 @@ export async function parseSkirConfig(
     }
     return offsetRangeToRange(node.range[0], node.range[1]);
   };
+  const pushErrorAtPath = (
+    path: readonly PropertyKey[],
+    message: string,
+  ): void => {
+    const pathRemainder: PropertyKey[] = [];
+    while (path.length !== 0) {
+      const range = pathToRange(path);
+      if (range) {
+        break;
+      } else {
+        // It's possible that 'path' does not map to a node if 'path' refers to
+        // a property which is missing. In that case, we pop the last element
+        // of 'path' and try again, until we find a node that exists. The
+        // elements which were popped will be included in the error message.
+        pathRemainder.push(path.at(-1)!);
+        path = path.slice(0, -1);
+      }
+    }
+    pathRemainder.reverse();
+    const pathRemainderStr = pathRemainder
+      .map((p, i) =>
+        typeof p === "number" ? `[${p}]` : i === 0 ? p : `.${String(p)}`,
+      )
+      .join("");
+    const messagePrefix = pathRemainder.length
+      ? `Missing property '${pathRemainderStr}': `
+      : "";
+    const range = pathToRange(path);
+    errors.push({
+      message: messagePrefix + message,
+      range: range,
+    });
+  };
 
   // Check for YAML parsing errors
   if (doc.errors.length > 0) {
@@ -76,24 +115,27 @@ export async function parseSkirConfig(
         range: range,
       });
     }
-    return { skirConfig: undefined, errors: errors };
+    return {
+      skirConfig: undefined,
+      errors: errors,
+    };
   }
 
-  const jsData = doc.toJS();
-
   // 2. Validate with Zod schema
+  const jsData = doc.toJS();
   const result = SkirConfig.safeParse(jsData);
 
   if (!result.success) {
     for (const issue of result.error.issues) {
-      // Map the Zod path to the YAML node
-      const range = pathToRange(issue.path);
-      errors.push({
-        message: issue.message,
-        range: range,
-      });
+      pushErrorAtPath(issue.path, issue.message);
     }
-    return { skirConfig: undefined, errors: errors };
+    const maybeForgotToEditAfterInit =
+      jsData && typeof jsData === "object" && jsData.generators === null;
+    return {
+      skirConfig: undefined,
+      errors: errors,
+      maybeForgotToEditAfterInit,
+    };
   }
 
   // 3. Validate each generator's config with Zod schema
@@ -106,11 +148,7 @@ export async function parseSkirConfig(
         generator = await importCodeGenerator(mod);
       } catch (e) {
         if (e instanceof Error) {
-          const range = pathToRange(["generators", i, "mod"]);
-          errors.push({
-            message: e.message,
-            range: range,
-          });
+          pushErrorAtPath(["generators", i, "mod"], e.message);
           continue;
         } else {
           throw e;
@@ -119,13 +157,13 @@ export async function parseSkirConfig(
     } else {
       // TODO: rm the casts
       const modToGenerator: Record<string, CodeGenerator<unknown>> = {
-        "skir-cc-gen": ccGen.GENERATOR as any as CodeGenerator<unknown>,
-        "skir-dart-gen": dartGen.GENERATOR as any as CodeGenerator<unknown>,
-        "skir-java-gen": javaGen.GENERATOR as any as CodeGenerator<unknown>,
-        "skir-kotlin-gen": kotlinGen.GENERATOR as any as CodeGenerator<unknown>,
-        "skir-python-gen": pythonGen.GENERATOR as any as CodeGenerator<unknown>,
+        "skir-cc-gen": CcGen.GENERATOR as any as CodeGenerator<unknown>,
+        "skir-dart-gen": DartGen.GENERATOR as any as CodeGenerator<unknown>,
+        "skir-java-gen": JavaGen.GENERATOR as any as CodeGenerator<unknown>,
+        "skir-kotlin-gen": KotlinGen.GENERATOR as any as CodeGenerator<unknown>,
+        "skir-python-gen": PythonGen.GENERATOR as any as CodeGenerator<unknown>,
         "skir-typescript-gen":
-          typescriptGen.GENERATOR as any as CodeGenerator<unknown>,
+          TypescriptGen.GENERATOR as any as CodeGenerator<unknown>,
       };
       generator = modToGenerator[mod];
     }
@@ -141,11 +179,7 @@ export async function parseSkirConfig(
             "config",
             ...issue.path,
           ];
-          const range = pathToRange(path);
-          errors.push({
-            message: issue.message ?? "Error",
-            range: range,
-          });
+          pushErrorAtPath(path, issue.message ?? "Error");
         }
       }
     }

package/src/error_renderer.ts

@@ -61,6 +61,7 @@ export function renderSkirConfigErrors(
   errors: readonly SkirConfigError[],
   context: {
     skirConfigPath: string;
+    maybeForgotToEditAfterInit: boolean | undefined;
   },
 ): void {
   for (const error of errors) {
@@ -68,6 +69,13 @@ export function renderSkirConfigErrors(
     console.error(formatSkirConfigError(error, context));
   }
   console.error();
+  if (context.maybeForgotToEditAfterInit) {
+    const { skirConfigPath } = context;
+    console.warn(
+      `Did you forget to edit ${skirConfigPath} after running 'npx skir init'?`,
+    );
+    console.warn();
+  }
 }
 
 function formatSkirConfigError(
@@ -179,9 +187,9 @@ function formatBreakingChange(
       const { enumEpression, number, record, variantName } = breakingChange;
       const errorHeader = makeRed("Illegal variant kind change");
       const enumName = map(record, getQualifiedName);
-      const variantKind = map(variantName, (vn) => {
-        caseMatches(vn.text, "lower_underscore") ? "wrapper" : "constant";
-      });
+      const variantKind = map(variantName, (vn) =>
+        caseMatches(vn.text, "lower_underscore") ? "wrapper" : "constant",
+      );
       return [
         `${locationPrefix}${errorHeader}\n`,
         "  [Last snapshot]\n",

package/src/exit_error.ts

@@ -0,0 +1,6 @@
+/**
+ * If this error is thrown during the execution of the compiler, the message
+ * will be printed to stderr before exiting. The stack trace will not be
+ * printed.
+ */
+export class ExitError extends Error {}

package/src/io.ts

@@ -1,4 +1,6 @@
-import * as fs from "fs";
+import * as FileSystem from "fs";
+import * as FileSystemPromises from "fs/promises";
+import * as Paths from "path";
 
 export interface FileReader {
   readTextFile(path: string): string | undefined;
@@ -11,7 +13,7 @@ export interface FileWriter {
 class RealFileSystem implements FileReader, FileWriter {
   readTextFile(path: string): string | undefined {
     try {
-      return fs.readFileSync(path, "utf-8");
+      return FileSystem.readFileSync(path, "utf-8");
     } catch (error) {
       if (
         error &&
@@ -26,8 +28,25 @@ class RealFileSystem implements FileReader, FileWriter {
   }
 
   writeTextFile(path: string, contents: string): void {
-    fs.writeFileSync(path, contents, "utf-8");
+    FileSystem.writeFileSync(path, contents, "utf-8");
   }
 }
 
 export const REAL_FILE_SYSTEM = new RealFileSystem();
+
+export async function isDirectory(path: string): Promise<boolean> {
+  try {
+    return (await FileSystemPromises.lstat(path)).isDirectory();
+  } catch (_e) {
+    return false;
+  }
+}
+
+export function rewritePathForRendering(path: string): string {
+  if (Paths.isAbsolute(path) || /^\.{1,2}[/\\]$/.test(path)) {
+    return path;
+  } else {
+    // To make it clear that it's a path, prepend "./"
+    return `.${Paths.sep}${path}`;
+  }
+}

package/src/module_collector.ts

@@ -1,21 +1,35 @@
 import { glob } from "glob";
-import * as paths from "path";
-import { REAL_FILE_SYSTEM } from "./io.js";
+import * as Paths from "path";
+import { ExitError } from "./exit_error.js";
+import {
+  isDirectory,
+  REAL_FILE_SYSTEM,
+  rewritePathForRendering,
+} from "./io.js";
 import { ModuleSet } from "./module_set.js";
 
 export async function collectModules(srcDir: string): Promise<ModuleSet> {
   const modules = ModuleSet.create(REAL_FILE_SYSTEM, srcDir);
-  const skirFiles = await glob(paths.join(srcDir, "**/*.skir"), {
+  const skirFiles = await glob(Paths.join(srcDir, "**/*.skir"), {
     stat: true,
     withFileTypes: true,
   });
-  for await (const skirFile of skirFiles) {
+  if (skirFiles.length === 0) {
+    const isDir = await isDirectory(srcDir);
+    if (!isDir) {
+      throw new ExitError(
+        "Source directory does not exist: " + rewritePathForRendering(srcDir),
+      );
+    }
+  }
+  for (const skirFile of skirFiles) {
     if (!skirFile.isFile) {
       continue;
     }
-    const relativePath = paths
-      .relative(srcDir, skirFile.fullpath())
-      .replace(/\\/g, "/");
+    const relativePath = Paths.relative(srcDir, skirFile.fullpath()).replace(
+      /\\/g,
+      "/",
+    );
     modules.parseAndResolve(relativePath);
   }
   return modules;

package/src/module_set.ts

@@ -1,4 +1,4 @@
-import * as paths from "path";
+import * as Paths from "path";
 import {
   MutableDocReferenceName,
   unquoteAndUnescape,
@@ -1311,7 +1311,7 @@ class DefaultModuleParser extends ModuleParserBase {
   }
 
   readSourceCode(modulePath: string): string | undefined {
-    return this.fileReader.readTextFile(paths.join(this.rootPath, modulePath));
+    return this.fileReader.readTextFile(Paths.join(this.rootPath, modulePath));
   }
 }
 
@@ -1341,12 +1341,12 @@ function resolveModulePath(
   if (modulePath.startsWith("./") || modulePath.startsWith("../")) {
     // This is a relative path from the module. Let's transform it into a
     // relative path from root.
-    modulePath = paths.join(originModulePath, "..", modulePath);
+    modulePath = Paths.join(originModulePath, "..", modulePath);
   }
   // "a/./b/../c" => "a/c"
   // Note that `paths.normalize` will use backslashes on Windows.
   // We don't want that.
-  modulePath = paths.normalize(modulePath).replace(/\\/g, "/");
+  modulePath = Paths.normalize(modulePath).replace(/\\/g, "/");
   if (modulePath.startsWith(`../`)) {
     errors.push({
       token: pathToken,

package/src/parser.ts

@@ -28,7 +28,7 @@ import type {
   UnresolvedType,
 } from "skir-internal";
 import { convertCase, simpleHash } from "skir-internal";
-import * as casing from "./casing.js";
+import * as Casing from "./casing.js";
 import { mergeDocs } from "./doc_comment_parser.js";
 import { ModuleTokens } from "./tokenizer.js";
 
@@ -398,7 +398,7 @@ function parseRecord(
     if (nameMatch.case < 0) {
       return null;
     }
-    casing.validate(nameMatch.token, "UpperCamel", it.errors);
+    Casing.validate(nameMatch.token, "UpperCamel", it.errors);
     nameToken = nameMatch.token;
   }
   let stableId: number | null = null;
@@ -476,7 +476,7 @@ function parseField(
       }
       case 2: {
         const expectedCasing = type ? "lower_underscore" : "UPPER_UNDERSCORE";
-        casing.validate(name, expectedCasing, it.errors);
+        Casing.validate(name, expectedCasing, it.errors);
         if (recordType === "enum" && name.text === "UNKNOWN") {
           it.errors.push({
             token: name,
@@ -790,7 +790,7 @@ function parseImportAs(it: TokenIterator): ImportAlias | null {
   if (aliasMatch.case < 0) {
     return null;
   }
-  casing.validate(aliasMatch.token, "lower_underscore", it.errors);
+  Casing.validate(aliasMatch.token, "lower_underscore", it.errors);
   if (it.expectThenNext(["from"]).case < 0) return null;
   const modulePathMatch = it.expectThenNext([TOKEN_IS_STRING_LITERAL]);
   if (modulePathMatch.case < 0) {
@@ -838,7 +838,7 @@ function parseMethod(it: TokenIterator, doc: Doc): MutableMethod | null {
     return null;
   }
   const name = nameMatch.token;
-  casing.validate(name, "UpperCamel", it.errors);
+  Casing.validate(name, "UpperCamel", it.errors);
   if (it.expectThenNext(["("]).case < 0) {
     return null;
   }
@@ -898,7 +898,7 @@ function parseConstant(it: TokenIterator, doc: Doc): MutableConstant | null {
   if (nameMatch.case < 0) {
     return null;
   }
-  casing.validate(nameMatch.token, "UPPER_UNDERSCORE", it.errors);
+  Casing.validate(nameMatch.token, "UPPER_UNDERSCORE", it.errors);
   if (it.expectThenNext([":"]).case < 0) {
     return null;
   }