skir 0.0.3 → 0.0.6

package/src/compiler.ts

@@ -4,15 +4,15 @@ import { glob } from "glob";
 import * as paths from "path";
 import type { CodeGenerator } from "skir-internal";
 import Watcher from "watcher";
-import * as yaml from "yaml";
-import { fromZodError } from "zod-validation-error";
 import { parseCommandLine } from "./command_line_parser.js";
-import { GeneratorConfig, SkirConfig } from "./config.js";
+import { GeneratorConfig } from "./config.js";
+import { importCodeGenerator, parseSkirConfig } from "./config_parser.js";
 import {
   makeGray,
   makeGreen,
   makeRed,
   renderErrors,
+  renderSkirConfigErrors,
 } from "./error_renderer.js";
 import { formatModule } from "./formatter.js";
 import { REAL_FILE_SYSTEM } from "./io.js";
@@ -33,32 +33,19 @@ async function makeGeneratorBundle(
   config: GeneratorConfig,
   root: string,
 ): Promise<GeneratorBundle> {
-  const mod = await import(config.mod);
-  const generator = mod.GENERATOR;
-  if (typeof generator !== "object") {
-    throw new Error(`Cannot import GENERATOR from module ${config.mod}`);
-  }
-  // Validate the generator config.
-  const parsedConfig = generator.configType.safeParse(config.config);
-  if (!parsedConfig.success) {
-    const { id } = generator;
-    console.error(makeRed(`Invalid config for ${id} generator`));
-    const validationError = fromZodError(parsedConfig.error);
-    console.error(validationError.toString());
-    process.exit(1);
-  }
+  const generator = await importCodeGenerator(config.mod);
   let skiroutDirs: string[];
-  if (config.skiroutDir === undefined) {
+  if (config.outDir === undefined) {
     skiroutDirs = ["skirout"];
-  } else if (typeof config.skiroutDir === "string") {
-    skiroutDirs = [config.skiroutDir];
+  } else if (typeof config.outDir === "string") {
+    skiroutDirs = [config.outDir];
   } else {
-    skiroutDirs = config.skiroutDir;
+    skiroutDirs = config.outDir;
   }
   skiroutDirs = skiroutDirs.map((d) => paths.join(root, d));
   return {
-    generator,
-    config: parsedConfig.data,
+    generator: generator,
+    config: config.config,
     skiroutDirs: skiroutDirs,
   };
 }
@@ -362,28 +349,27 @@ async function main(): Promise<void> {
     }
   }
 
-  // Use an absolute path to make error messages more helpful.
-  const skirConfigPath = paths.resolve(paths.join(root!, "skir.yml"));
-  const skirConfigContents = REAL_FILE_SYSTEM.readTextFile(skirConfigPath);
-  if (skirConfigContents === undefined) {
+  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 skirConfigCode = REAL_FILE_SYSTEM.readTextFile(skirConfigPath);
+  if (skirConfigCode === undefined) {
     console.error(makeRed(`Cannot find ${skirConfigPath}`));
     process.exit(1);
   }
 
-  let skirConfig: SkirConfig;
-  {
-    // `yaml.parse` fail with a helpful error message, no need to add context.
-    const parseResult = SkirConfig.safeParse(yaml.parse(skirConfigContents));
-    if (parseResult.success) {
-      skirConfig = parseResult.data;
-    } else {
-      console.error(makeRed("Invalid skir config"));
-      console.error(`  Path: ${skirConfigPath}`);
-      const validationError = fromZodError(parseResult.error);
-      console.error(validationError.toString());
-      process.exit(1);
-    }
+  const skirConfigResult = await parseSkirConfig(skirConfigCode, "import-mods");
+  if (skirConfigResult.errors.length > 0) {
+    console.error(makeRed("Invalid skir config"));
+    renderSkirConfigErrors(skirConfigResult.errors, { skirConfigPath });
+    process.exit(1);
   }
+  const skirConfig = skirConfigResult.skirConfig!;
 
   const srcDir = paths.join(root!, skirConfig.srcDir || ".");
 

package/src/config.ts

@@ -1,20 +1,15 @@
 import { z } from "zod";
 
-export const GeneratorConfig = z
-  .object({
-    mod: z.string(),
-    config: z.any(),
-    skiroutDir: z
-      .union([
-        z
-          .string()
-          .regex(/^.*\/skirout$/)
-          .optional(),
-        z.array(z.string().regex(/^.*\/skirout$/)),
-      ])
-      .optional(),
-  })
-  .strict();
+export const GeneratorConfig = z.strictObject({
+  mod: z.string(),
+  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

@@ -0,0 +1,169 @@
+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 { LineCounter, parseDocument, Scalar, YAMLMap } from "yaml";
+import { SkirConfig } from "./config.js";
+
+export interface SkirConfigResult {
+  skirConfig: SkirConfig | undefined;
+  errors: readonly SkirConfigError[];
+}
+
+export interface SkirConfigError {
+  message: string;
+  range?: SkirConfigErrorRange;
+}
+
+export interface SkirConfigErrorRange {
+  start: SkirConfigErrorPos;
+  end: SkirConfigErrorPos;
+}
+
+export interface SkirConfigErrorPos {
+  /** 0-based */
+  offset: number;
+  /** 1-based */
+  lineNumber: number;
+  /** 2-based */
+  colNumber: number;
+}
+
+export async function parseSkirConfig(
+  yamlCode: string,
+  importMods?: "import-mods",
+): Promise<SkirConfigResult> {
+  const errors: SkirConfigError[] = [];
+
+  // 1. Parse YAML into a Document object
+  const lineCounter = new LineCounter();
+  const doc = parseDocument(yamlCode, { lineCounter });
+
+  const offsetToPos = (offset: number): SkirConfigErrorPos => {
+    const pos = lineCounter.linePos(offset);
+    return {
+      offset: offset,
+      lineNumber: pos.line,
+      colNumber: pos.col,
+    };
+  };
+  const offsetRangeToRange = (
+    start: number,
+    end: number,
+  ): SkirConfigErrorRange => ({
+    start: offsetToPos(start),
+    end: offsetToPos(end),
+  });
+  const pathToRange = (
+    path: readonly PropertyKey[],
+  ): SkirConfigErrorRange | undefined => {
+    const node = doc.getIn(path, true) as Scalar | YAMLMap | undefined;
+    if (!node || !node.range) {
+      return undefined;
+    }
+    return offsetRangeToRange(node.range[0], node.range[1]);
+  };
+
+  // Check for YAML parsing errors
+  if (doc.errors.length > 0) {
+    for (const error of doc.errors) {
+      const range = offsetRangeToRange(error.pos[0], error.pos[1]);
+      errors.push({
+        message: error.message,
+        range: range,
+      });
+    }
+    return { skirConfig: undefined, errors: errors };
+  }
+
+  const jsData = doc.toJS();
+
+  // 2. Validate with Zod schema
+  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,
+      });
+    }
+    return { skirConfig: undefined, errors: errors };
+  }
+
+  // 3. Validate each generator's config with Zod schema
+  for (let i = 0; i < result.data.generators.length; i++) {
+    const generatorConfig = result.data.generators[i]!;
+    const { mod } = generatorConfig;
+    let generator: CodeGenerator<unknown> | undefined;
+    if (importMods) {
+      try {
+        generator = await importCodeGenerator(mod);
+      } catch (e) {
+        if (e instanceof Error) {
+          const range = pathToRange(["generators", i, "mod"]);
+          errors.push({
+            message: e.message,
+            range: range,
+          });
+          continue;
+        } else {
+          throw e;
+        }
+      }
+    } 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-typescript-gen":
+          typescriptGen.GENERATOR as any as CodeGenerator<unknown>,
+      };
+      generator = modToGenerator[mod];
+    }
+    if (generator) {
+      const parsedGeneratorConfig = generator.configType.safeParse(
+        generatorConfig.config,
+      );
+      if (!parsedGeneratorConfig.success) {
+        for (const issue of parsedGeneratorConfig.error.issues) {
+          const path: readonly PropertyKey[] = [
+            "generators",
+            i,
+            "config",
+            ...issue.path,
+          ];
+          const range = pathToRange(path);
+          errors.push({
+            message: issue.message ?? "Error",
+            range: range,
+          });
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    return { skirConfig: undefined, errors: errors };
+  }
+
+  return { skirConfig: result.data, errors: [] };
+}
+
+export async function importCodeGenerator(
+  mod: string,
+): Promise<CodeGenerator<unknown>> {
+  const module = await import(mod);
+  const generator = module.GENERATOR;
+  if (typeof generator !== "object") {
+    throw new Error(`Cannot import GENERATOR from module ${mod}`);
+  }
+  return generator as CodeGenerator<unknown>;
+}

package/src/doc_comment_parser.ts

@@ -3,39 +3,58 @@ import type {
   Doc,
   DocPiece,
   DocReference,
+  DocReferenceName,
+  MutableDoc,
+  MutableDocPiece,
+  MutableDocReferenceName,
   Result,
   SkirError,
   Token,
 } from "skir-internal";
 
-export function parseDocComments(docComments: readonly Token[]): Result<Doc> {
-  const parser = new DocCommentsParser(docComments);
+export function parseDocComment(docComment: Token): Result<Doc> {
+  const parser = new DocCommentParser(docComment);
   return parser.parse();
 }
 
-class DocCommentsParser {
+class DocCommentParser {
   private readonly pieces: DocPiece[] = [];
   private readonly errors: SkirError[] = [];
   private currentText = "";
-  private docCommentIndex = -1;
   private charIndex = -1;
-  private contentOffset = -1;
-
-  constructor(private readonly docComments: readonly Token[]) {}
+  private readonly content: string;
+
+  constructor(private readonly docComment: Token) {
+    const { text } = docComment;
+    if (text.startsWith("/// ")) {
+      this.content = text.slice(4);
+    } else if (text.startsWith("///")) {
+      this.content = text.slice(3);
+    } else {
+      throw new Error("Expected doc comment to start with ///");
+    }
+    this.charIndex = 0;
+  }
 
   parse(): Result<Doc> {
-    while (this.nextDocComment()) {
-      this.parseCurrentDocComment();
-    }
+    this.parseDocComment();
 
     // Add any remaining text
     if (this.currentText.length > 0) {
       this.pieces.push({ kind: "text", text: this.currentText });
     }
 
-    const text = this.docComments
-      .map((c) => c.text.slice(c.text.startsWith("/// ") ? 4 : 3))
-      .join("\n");
+    const { pieces } = this;
+    const text = pieces
+      .map((p) => {
+        switch (p.kind) {
+          case "text":
+            return p.text;
+          case "reference":
+            return p.referenceRange.text;
+        }
+      })
+      .join("");
 
     return {
       result: {
@@ -46,7 +65,7 @@ class DocCommentsParser {
     };
   }
 
-  private parseCurrentDocComment(): void {
+  private parseDocComment(): void {
     // Matches unescaped [ or ], OR escaped [[ or ]]
     const specialCharRegex = /\[\[|\]\]|\[|\]/g;
 
@@ -93,18 +112,15 @@ class DocCommentsParser {
         this.charIndex++;
       }
     }
-
-    // Add newline between comment lines (except after the last line)
-    if (this.docCommentIndex < this.docComments.length - 1) {
-      this.currentText += "\n";
-    }
   }
 
   private parseReference(): DocReference {
     const { content, docComment } = this;
 
     const leftBracketCharIndex = this.charIndex;
-    const startPosition = docComment.position + leftBracketCharIndex;
+    const contentOffset = docComment.text.length - content.length;
+    const startPosition =
+      docComment.position + contentOffset + leftBracketCharIndex;
 
     const rightBracketCharIndex = content.indexOf("]", leftBracketCharIndex);
 
@@ -139,7 +155,8 @@ class DocCommentsParser {
     const tokens: Token[] = [];
     while (this.charIndex < endCharIndex) {
       const char = content[this.charIndex]!;
-      const position = docComment.position + this.charIndex;
+      const contentOffset = docComment.text.length - content.length;
+      const position = docComment.position + contentOffset + this.charIndex;
 
       const makeToken = (text: string): Token => ({
         text: text,
@@ -166,7 +183,9 @@ class DocCommentsParser {
         this.charIndex++;
       } else {
         // Invalid character in reference (including whitespace)
-        const column = this.docComment.colNumber + this.charIndex;
+        const contentOffset = docComment.text.length - content.length;
+        const column =
+          this.docComment.colNumber + contentOffset + this.charIndex;
         hasError = true;
         this.errors.push({
           token: referenceRange,
@@ -177,11 +196,11 @@ class DocCommentsParser {
       }
     }
 
-    const nameChain = hasError ? [] : this.parseNameChain(tokens);
+    const nameParts = hasError ? [] : this.parseNameParts(tokens);
 
     return {
       kind: "reference",
-      nameChain: nameChain,
+      nameParts: nameParts,
       absolute: tokens[0]?.text === ".",
       referee: undefined,
       docComment: this.docComment,
@@ -189,8 +208,10 @@ class DocCommentsParser {
     };
   }
 
-  private parseNameChain(tokens: readonly Token[]): Token[] {
-    const nameChain: Token[] = [];
+  private parseNameParts(
+    tokens: readonly Token[],
+  ): readonly DocReferenceName[] {
+    const nameParts: MutableDocReferenceName[] = [];
     let expect: "identifier" | "identifier or '.'" | "'.' or ']'" =
       "identifier or '.'";
     for (const token of tokens) {
@@ -198,7 +219,10 @@ class DocCommentsParser {
       if (/^[a-zA-Z]/.test(token.text)) {
         expected = expect === "identifier or '.'" || expect === "identifier";
         expect = "'.' or ']'";
-        nameChain.push(token);
+        nameParts.push({
+          token: token,
+          declaration: undefined,
+        });
       } else if (token.text === ".") {
         expected = expect === "identifier or '.'" || expect === "'.' or ']'";
         expect = "identifier";
@@ -214,38 +238,38 @@ class DocCommentsParser {
         return [];
       }
       if (token.text === "]") {
-        return nameChain;
+        return nameParts;
       }
     }
     // An error has already been pushed to signify the unterminated reference.
     return [];
   }
+}
 
-  /// The current doc comment being parsed.
-  private get docComment(): Token {
-    return this.docComments[this.docCommentIndex]!;
-  }
-
-  /// The text of the current doc comment being parsed.
-  private get content(): string {
-    return this.docComment.text;
+export function mergeDocs(docs: readonly Doc[]): MutableDoc {
+  if (docs.length <= 0) {
+    return EMPTY_DOC;
   }
-
-  private nextDocComment(): boolean {
-    if (this.docCommentIndex < this.docComments.length - 1) {
-      this.docCommentIndex++;
-      const { content } = this;
-      if (content.startsWith("/// ")) {
-        this.contentOffset = 4;
-      } else if (content.startsWith("///")) {
-        this.contentOffset = 3;
-      } else {
-        throw new Error("Expected doc comment to start with ///");
-      }
-      this.charIndex = this.contentOffset;
-      return true;
-    } else {
-      return false;
+  // Insert '\n' between each doc comment (== line)
+  const text = docs.map((d) => d.text).join("\n");
+  const pieces: MutableDocPiece[] = [];
+  for (let i = 0; i < docs.length; ++i) {
+    const doc = docs[i]!;
+    if (i !== 0) {
+      pieces.push({
+        kind: "text",
+        text: "\n",
+      });
     }
+    doc.pieces.forEach((p) => pieces.push(p));
   }
+  return {
+    text: text,
+    pieces: pieces,
+  };
 }
+
+const EMPTY_DOC: Doc = {
+  text: "",
+  pieces: [],
+};

package/src/error_renderer.ts

@@ -11,6 +11,7 @@ import {
   Expression,
   getTokenForBreakingChange,
 } from "./compatibility_checker.js";
+import { SkirConfigError } from "./config_parser.js";
 import { ModuleSet } from "./module_set.js";
 
 export function renderErrors(errors: readonly SkirError[]): void {
@@ -56,6 +57,39 @@ export function formatError(error: SkirError): string {
   return result;
 }
 
+export function renderSkirConfigErrors(
+  errors: readonly SkirConfigError[],
+  context: {
+    skirConfigPath: string;
+  },
+): void {
+  for (const error of errors) {
+    console.error();
+    console.error(formatSkirConfigError(error, context));
+  }
+  console.error();
+}
+
+function formatSkirConfigError(
+  error: SkirConfigError,
+  context: {
+    skirConfigPath: string;
+  },
+): string {
+  const { message, range } = error;
+  const { skirConfigPath } = context;
+  const location = range
+    ? [
+        makeCyan(skirConfigPath),
+        // Already 1-based
+        makeYellow(range.start.lineNumber.toString()),
+        // Already 1-based
+        makeYellow(range.start.colNumber.toString()),
+      ].join(":")
+    : makeCyan(skirConfigPath);
+  return [location, " - ", makeRed("error"), ": ", message].join("");
+}
+
 export function renderBreakingChanges(
   breakingChanges: readonly BreakingChange[],
   moduleSet: BeforeAfter<ModuleSet>,