tla-ts 0.0.1 → 0.0.3-dev.763cc71

package/src/cli-options.ts

@@ -0,0 +1,58 @@
+export interface OptionSpec {
+  flag: string;
+  isRequired?: boolean;
+  isRepeatable?: boolean;
+}
+
+export interface ParsedOption {
+  name: string;
+  values: string[];
+}
+
+export interface ParsedArgs {
+  options: ParsedOption[];
+  positionals: string[];
+  unknown: string[];
+  incomplete: ParsedOption | undefined;
+  has: (name: string) => boolean;
+  get: (name: string) => string[] | undefined;
+}
+
+const formatOption = (spec: OptionSpec) => {
+  const text = spec.isRequired ? spec.flag : `[${spec.flag}]`;
+  return spec.isRepeatable ? `${text}...` : text;
+};
+
+// Each <name> in a flag such as "--toolbox <start> <end>" is one value the option takes, and
+// {options} in the usage stands for the options.
+export const defineCommand = (usage: string, specs: OptionSpec[]) => {
+  const arities = new Map(
+    specs.map((spec) => {
+      const [name, ...values] = spec.flag.split(" ");
+      return [name, values.length];
+    }),
+  );
+  const parse = (args: string[]): ParsedArgs => {
+    const options: ParsedOption[] = [];
+    const positionals: string[] = [];
+    const unknown: string[] = [];
+    for (let index = 0; index < args.length; index++) {
+      const arity = arities.get(args[index]);
+      if (arity === undefined) {
+        (args[index].startsWith("-") ? unknown : positionals).push(args[index]);
+        continue;
+      }
+      options.push({ name: args[index], values: args.slice(index + 1, index + 1 + arity) });
+      index += arity;
+    }
+    return {
+      options,
+      positionals,
+      unknown,
+      incomplete: options.find((option) => option.values.length < (arities.get(option.name) ?? 0)),
+      has: (name) => options.some((option) => option.name === name),
+      get: (name) => options.findLast((option) => option.name === name)?.values,
+    };
+  };
+  return { usage: usage.replace("{options}", specs.map(formatOption).join(" ")), parse };
+};

package/src/codegen.ts

@@ -1,16 +1,24 @@
 import type { Expression } from "./ast";
 import { TlaEvaluationError } from "./errors";
 import {
+  describeLocation,
   bindValue,
   expectBoolean,
   findGlobalName,
   getChildren,
   getEnumeratedElements,
+  getConditionError,
+  getConjunctError,
+  getDomainOperator,
+  getSubsetOperator,
   getEvaluator,
+  getFieldError,
   isClosedConstant,
   isLocallyResolved,
+  isTlcInteger,
   isValueArgument,
   isWorthCaching,
+  keepLazy,
   resolveGlobalOperator,
   type Context,
   type Environment,
@@ -18,9 +26,11 @@ import {
 } from "./evaluate";
 import {
   applyFunction,
-  createSet,
+  compareValues,
+  createEnumeratedSet,
   createSortedFunction,
   createTuple,
+  createWrittenRecord,
   valuesEqual,
   type Value,
 } from "./values";
@@ -56,15 +66,21 @@ const GENERATED_KINDS = new Set([
   "Exists",
 ]);
 
-const describeLocation = (expression: Expression) =>
-  `line ${expression.location.line}, column ${expression.location.column}`;
-
 const createRuntime = () => ({
   bool: expectBoolean,
+  condition: (value: Value, expression: Expression) => {
+    if (typeof value !== "boolean") throw getConditionError(expression, value);
+    return value;
+  },
+  conjunct: (value: Value, expression: Expression & { kind: "And" | "Or" }, index: number) => {
+    if (typeof value !== "boolean") throw getConjunctError(expression, index, value);
+    return value;
+  },
   apply: applyFunction,
   tuple: createTuple,
-  set: createSet,
+  set: createEnumeratedSet,
   record: createSortedFunction,
+  writtenRecord: createWrittenRecord,
   equal: valuesEqual,
   enumerate: getEnumeratedElements,
   unassigned: (name: string, expression: Expression): never => {
@@ -103,7 +119,7 @@ const addReference = (generator: Generator, value: unknown) => {
 
 const createLocal = (generator: Generator) => `local${generator.counter++}`;
 
-const getFreeNames = (expression: Expression, names = new Set<string>()): Set<string> => {
+const getFreeNames = (expression: Expression, names = new Set<string>()) => {
   if (expression.kind === "Identifier") names.add(expression.name);
   if (expression.kind === "Apply") names.add(expression.operator);
   getChildren(expression).forEach((child) => getFreeNames(child, names));
@@ -131,7 +147,7 @@ const generateQuantifier = (
   const description = JSON.stringify(isForall ? "the body of \\A" : "the body of \\E");
   const name = `quantifier${generator.counter++}`;
   const outer = [...frame.locals.values()];
-  const inner: Frame = {
+  const inner = {
     context: "context",
     state: "state",
     next: "next",
@@ -174,6 +190,15 @@ const generateApply = (
   if (isLocallyResolved(expression)) return generateDelegate(generator, expression, frame);
   const builtin = resolveGlobalOperator(expression.operator, generator.environment);
   if (builtin?.kind !== "Builtin") return generateDelegate(generator, expression, frame);
+  if (builtin.name === "DOMAIN") {
+    const domain = addReference(generator, getDomainOperator(expression));
+    return `${domain}(${generateExpression(generator, args[0], frame)})`;
+  }
+  if (builtin.name === "TLCEval") return generateDelegate(generator, expression, frame);
+  if (builtin.name === "\\subseteq" && args.length === 2) {
+    const subset = addReference(generator, getSubsetOperator(expression, builtin));
+    return `${subset}(${generateExpression(generator, args[0], frame)}, ${generateExpression(generator, args[1], frame)})`;
+  }
   const environment = generator.environment;
   if (builtin.evaluateUnary && args.length === 1 && isValueArgument(args[0], environment)) {
     const operation = addReference(generator, builtin.evaluateUnary);
@@ -198,7 +223,7 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
   }
   switch (expression.kind) {
     case "Number":
-      if (Number.isInteger(expression.value) && Math.abs(expression.value) <= 2147483647) {
+      if (isTlcInteger(expression.value)) {
         return String(expression.value);
       }
       return generateDelegate(generator, expression, frame);
@@ -219,22 +244,26 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
     }
     case "Apply":
       return generateApply(generator, expression, frame);
-    case "And":
-      return `(${expression.operands.map((operand) => `bool(${generate(operand)}, "a conjunct")`).join(" && ")})`;
+    case "And": {
+      const node = addReference(generator, expression);
+      return `(${expression.operands.map((operand, index) => `conjunct(${generate(operand)}, ${node}, ${index})`).join(" && ")})`;
+    }
     case "Or":
       return `(${expression.operands.map((operand) => `bool(${generate(operand)}, "a disjunct")`).join(" || ")})`;
     case "If":
-      return `(bool(${generate(expression.condition)}, "an IF condition") ? ${generate(expression.consequent)} : ${generate(expression.alternative)})`;
+      return `(condition(${generate(expression.condition)}, ${addReference(generator, expression)}) ? ${generate(expression.consequent)} : ${generate(expression.alternative)})`;
     case "FunctionApplication": {
-      const fn = generate(expression.function);
-      if (expression.args.length === 1) return `apply(${fn}, ${generate(expression.args[0])})`;
-      return `apply(${fn}, tuple([${expression.args.map((arg) => generate(arg)).join(", ")}]))`;
+      keepLazy(expression.function);
+      const functionCode = generate(expression.function);
+      if (expression.args.length === 1)
+        return `apply(${functionCode}, ${generate(expression.args[0])})`;
+      return `apply(${functionCode}, tuple([${expression.args.map((arg) => generate(arg)).join(", ")}]))`;
     }
     case "FieldAccess":
-      return `apply(${generate(expression.record)}, ${JSON.stringify(expression.field)})`;
+      return `apply(${generate(expression.record)}, ${JSON.stringify(expression.field)}, ${addReference(generator, getFieldError(expression))})`;
     case "Record": {
       const fields = [...expression.fields].sort((left, right) =>
-        left.name < right.name ? -1 : 1,
+        compareValues(left.name, right.name),
       );
       const hasDuplicates = fields.some(
         (field, index) => index > 0 && fields[index - 1].name === field.name,
@@ -244,7 +273,12 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
         generator,
         fields.map((field) => field.name),
       );
-      return `record(${names}, [${fields.map((field) => generate(field.value)).join(", ")}])`;
+      const values = `[${fields.map((field) => generate(field.value)).join(", ")}]`;
+      const writtenNames = expression.fields.map((field) => field.name);
+      if (writtenNames.every((name, index) => name === fields[index].name)) {
+        return `record(${names}, ${values})`;
+      }
+      return `writtenRecord(${names}, ${values}, ${addReference(generator, writtenNames)})`;
     }
     case "Tuple":
       return `tuple([${expression.elements.map((element) => generate(element)).join(", ")}])`;
@@ -253,7 +287,7 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
     case "Prime": {
       const node = addReference(generator, expression);
       if (frame.isPrimed) return `primeOutsideAction(${node})`;
-      const primed: Frame = {
+      const primed = {
         context: `(primed ??= prime(${frame.context}))`,
         state: frame.next,
         next: "undefined",

package/src/config.ts

@@ -34,8 +34,11 @@ export interface ModelConfig {
   checkDeadlock: boolean;
   symmetry: string | undefined;
   view: string | undefined;
+  alias: string | undefined;
   postconditions: string[];
   possible: string[];
+  periodic: string | undefined;
+  rlReward: string | undefined;
 }
 
 interface ConfigToken {
@@ -65,11 +68,13 @@ const KEYWORDS = new Set([
   "POSTCONDITION",
   "POSTCONDITIONS",
   "_POSSIBLE",
+  "_PERIODIC",
+  "_RL_REWARD",
 ]);
 
 const SYMBOLS = ["<-", "<<", ">>", "=", "{", "}", ",", "[", "]", "(", ")"];
 
-const tokenizeConfig = (source: string): ConfigToken[] => {
+const tokenizeConfig = (source: string) => {
   const tokens: ConfigToken[] = [];
   const cursor = { index: 0, line: 1 };
   while (cursor.index < source.length) {
@@ -92,7 +97,7 @@ const tokenizeConfig = (source: string): ConfigToken[] => {
       cursor.index += end + 2;
       continue;
     }
-    const number = /^-?\d+(?![A-Za-z_])/.exec(rest)?.[0];
+    const number = /^\d+(?![A-Za-z_])/.exec(rest)?.[0];
     if (number) {
       tokens.push({ kind: "Number", text: number, line: cursor.line });
       cursor.index += number.length;
@@ -106,7 +111,7 @@ const tokenizeConfig = (source: string): ConfigToken[] => {
     }
     const string = /^"((?:[^"\\]|\\.)*)"/.exec(rest);
     if (string) {
-      tokens.push({ kind: "String", text: JSON.parse(`"${string[1]}"`), line: cursor.line });
+      tokens.push({ kind: "String", text: string[1], line: cursor.line });
       cursor.index += string[0].length;
       continue;
     }
@@ -144,10 +149,14 @@ export const parseConfig = (source: string): ModelConfig => {
     checkDeadlock: true,
     symmetry: undefined,
     view: undefined,
+    alias: undefined,
     postconditions: [],
     possible: [],
+    periodic: undefined,
+    rlReward: undefined,
   };
 
+  const deadlock = { isSet: false };
   const peek = () => tokens[cursor.index];
   const advance = () => tokens[cursor.index++];
   const isKeyword = (token: ConfigToken) => token.kind === "Word" && KEYWORDS.has(token.text);
@@ -168,13 +177,22 @@ export const parseConfig = (source: string): ModelConfig => {
     }
     return token.text;
   };
+  const isNameAhead = () => peek().kind === "Word" && !isKeyword(peek());
   const parseNames = () => {
     const names: string[] = [];
-    while (peek().kind === "Word" && !isKeyword(peek())) names.push(advance().text);
+    while (isNameAhead()) names.push(advance().text);
     return names;
   };
   const setSingle = (
-    key: "init" | "next" | "specification" | "symmetry" | "view",
+    key:
+      | "init"
+      | "next"
+      | "specification"
+      | "symmetry"
+      | "view"
+      | "alias"
+      | "periodic"
+      | "rlReward",
     keyword: string,
   ) => {
     if (config[key] !== undefined) throw new TlaConfigError(`The keyword ${keyword} appears twice`);
@@ -189,11 +207,12 @@ export const parseConfig = (source: string): ModelConfig => {
       return { kind: "Boolean", value: token.text === "TRUE" };
     if (token.text === "{") {
       const elements: ConfigValue[] = [];
-      while (peek().text !== "}") {
+      if (peek().text !== "}") elements.push(parseValue());
+      while (peek().text === ",") {
+        advance();
         elements.push(parseValue());
-        if (peek().text !== "}") expect(",");
       }
-      advance();
+      expect("}");
       return { kind: "Set", elements };
     }
     if (token.kind === "Word" && !isKeyword(token)) return { kind: "ModelValue", name: token.text };
@@ -211,7 +230,7 @@ export const parseConfig = (source: string): ModelConfig => {
   };
 
   const parseConstants = () => {
-    while (peek().kind === "Word" && !isKeyword(peek())) {
+    while (isNameAhead()) {
       const name = advance().text;
       if (peek().text === "(") {
         advance();
@@ -222,7 +241,8 @@ export const parseConfig = (source: string): ModelConfig => {
         }
         advance();
         expect("=");
-        config.constants.push({ name, value: parseValue(), args });
+        const module = parseModuleScope();
+        config.constants.push({ name, value: parseValue(), args, ...(module && { module }) });
         continue;
       }
       if (peek().text === "<-") {
@@ -276,7 +296,7 @@ export const parseConfig = (source: string): ModelConfig => {
         config.actionConstraints.push(...parseNames());
         break;
       case "ALIAS":
-        expectName();
+        setSingle("alias", token.text);
         break;
       case "POSTCONDITION":
       case "POSTCONDITIONS":
@@ -285,7 +305,15 @@ export const parseConfig = (source: string): ModelConfig => {
       case "_POSSIBLE":
         config.possible.push(...parseNames());
         break;
+      case "_PERIODIC":
+        setSingle("periodic", token.text);
+        break;
+      case "_RL_REWARD":
+        setSingle("rlReward", token.text);
+        break;
       case "CHECK_DEADLOCK": {
+        if (deadlock.isSet) throw new TlaConfigError("The keyword CHECK_DEADLOCK appears twice");
+        deadlock.isSet = true;
         const value = advance().text;
         if (value !== "TRUE" && value !== "FALSE") {
           throw new TlaConfigError(