tla-ts 0.0.1 → 0.0.2

package/src/lexer.ts

@@ -1,11 +1,13 @@
 import { TlaSyntaxError } from "./errors";
 
-export type TokenKind =
+type TokenKind =
   | "Identifier"
   | "Number"
+  | "Decimal"
   | "String"
   | "Operator"
   | "Keyword"
+  | "Step"
   | "Separator"
   | "ModuleEnd"
   | "End";
@@ -15,22 +17,31 @@ export interface Token {
   text: string;
   line: number;
   column: number;
+  endColumn: number;
 }
 
 const KEYWORDS = new Set([
+  "ACTION",
+  "ACTIONS",
   "ASSUME",
   "ASSUMPTION",
   "AXIOM",
+  "BY",
   "CASE",
   "CHOOSE",
   "CONSTANT",
   "CONSTANTS",
   "COROLLARY",
+  "DEF",
+  "DEFINE",
+  "DEFS",
   "DOMAIN",
   "ELSE",
   "ENABLED",
   "EXCEPT",
   "EXTENDS",
+  "HAVE",
+  "HIDE",
   "IF",
   "IN",
   "INSTANCE",
@@ -39,18 +50,32 @@ const KEYWORDS = new Set([
   "LET",
   "LOCAL",
   "MODULE",
+  "NEW",
+  "OBVIOUS",
+  "OMITTED",
+  "ONLY",
   "OTHER",
+  "PICK",
   "PROOF",
   "PROPOSITION",
+  "PROVE",
+  "QED",
   "RECURSIVE",
+  "STATE",
   "SUBSET",
+  "SUFFICES",
+  "TAKE",
+  "TEMPORAL",
+  "TEMPORALS",
   "THEN",
   "THEOREM",
   "UNCHANGED",
   "UNION",
+  "USE",
   "VARIABLE",
   "VARIABLES",
   "WITH",
+  "WITNESS",
 ]);
 
 const BACKSLASH_OPERATORS = new Map([
@@ -249,6 +274,12 @@ const NUMBER_BASES = new Map([
   ["h", 16],
 ]);
 
+// A numeral token keeps its text as typed, such as \hFF, so errors can quote it as TLC does.
+export const getNumeralValue = (text: string) =>
+  text.startsWith("\\")
+    ? parseInt(text.slice(2), NUMBER_BASES.get(text[1].toLowerCase()))
+    : Number(text);
+
 const MODULE_HEADER = /-{4,}[ \t]*MODULE\b/;
 
 const isIdentifierCharacter = (character: string) => /[A-Za-z0-9_]/.test(character);
@@ -262,8 +293,13 @@ export const matchOperator = (source: string, index: number): OperatorMatch | un
   const character = source[index];
   if (character === "\\" && /[A-Za-z]/.test(source[index + 1] ?? "")) {
     const word = /^[A-Za-z]+/.exec(source.slice(index + 1))?.[0] ?? "";
-    const operator = BACKSLASH_OPERATORS.get(word);
-    return operator === undefined ? undefined : { text: operator, length: word.length + 1 };
+    // Like SANY, read the longest operator that the word starts with, so S\used is S \ used.
+    const length = { value: word.length };
+    while (length.value > 0 && !BACKSLASH_OPERATORS.has(word.slice(0, length.value))) {
+      length.value--;
+    }
+    const operator = BACKSLASH_OPERATORS.get(word.slice(0, length.value));
+    return { text: operator ?? "\\", length: operator === undefined ? 1 : length.value + 1 };
   }
   const unicodeOperator = UNICODE_OPERATORS.get(character);
   if (unicodeOperator) return { text: unicodeOperator, length: character.length };
@@ -272,6 +308,33 @@ export const matchOperator = (source: string, index: number): OperatorMatch | un
   return character === "\\" ? { text: "\\", length: 1 } : undefined;
 };
 
+const isDigit = (character: string | undefined) =>
+  character !== undefined && character >= "0" && character <= "9";
+
+export const skipWhile = (
+  source: string,
+  index: number,
+  isMatch: (character: string) => boolean,
+) => {
+  const end = { value: index };
+  while (end.value < source.length && isMatch(source[end.value])) end.value++;
+  return end.value;
+};
+
+// The length of a step number such as <1>a., <+>, or <2>*., which SANY reads as one token wherever
+// it appears.
+const matchStep = (source: string, index: number) => {
+  if (source[index] !== "<") return 0;
+  const isImplicit = source[index + 1] === "+" || source[index + 1] === "*";
+  const levelEnd = isImplicit ? index + 2 : skipWhile(source, index + 1, isDigit);
+  if (levelEnd === index + 1 || source[levelEnd] !== ">") return 0;
+  const nameEnd = skipWhile(source, levelEnd + 1, isIdentifierCharacter);
+  const isDash = nameEnd === levelEnd + 1 && (source[nameEnd] === "*" || source[nameEnd] === "-");
+  return (
+    skipWhile(source, isDash ? nameEnd + 1 : nameEnd, (character) => character === ".") - index
+  );
+};
+
 const TAB_SIZE = 8;
 
 const getWidthAfter = (width: number, character: string | undefined) =>
@@ -303,7 +366,8 @@ export const tokenize = (source: string): Token[] => {
     return getWidthAfter(scan.width, source[cursor.index]);
   };
   const pushToken = (kind: TokenKind, text: string, length: number) => {
-    tokens.push({ kind, text, line: cursor.line, column: getColumn() });
+    const column = getColumn();
+    tokens.push({ kind, text, line: cursor.line, column, endColumn: column + length - 1 });
     cursor.index += length;
   };
   const advanceOver = (length: number) => {
@@ -320,18 +384,17 @@ export const tokenize = (source: string): Token[] => {
 
   while (cursor.index < source.length) {
     const character = source[cursor.index];
-    const rest = source.slice(cursor.index, cursor.index + 8);
 
     if (character === "\n" || character === " " || character === "\t" || character === "\r") {
       advanceOver(1);
       continue;
     }
-    if (rest.startsWith("\\*")) {
+    if (source.startsWith("\\*", cursor.index)) {
       const lineEnd = source.indexOf("\n", cursor.index);
       advanceOver((lineEnd === -1 ? source.length : lineEnd) - cursor.index);
       continue;
     }
-    if (rest.startsWith("(*")) {
+    if (source.startsWith("(*", cursor.index)) {
       const depth = { value: 0 };
       do {
         if (cursor.index >= source.length) throw createError("Unterminated comment");
@@ -347,8 +410,8 @@ export const tokenize = (source: string): Token[] => {
       } while (depth.value > 0);
       continue;
     }
-    if (rest.startsWith("----")) {
-      const length = /^-+/.exec(source.slice(cursor.index))?.[0].length ?? 0;
+    if (source.startsWith("----", cursor.index)) {
+      const length = skipWhile(source, cursor.index, (next) => next === "-") - cursor.index;
       if (
         source
           .slice(cursor.index + length)
@@ -359,14 +422,11 @@ export const tokenize = (source: string): Token[] => {
       pushToken("Separator", "----", length);
       continue;
     }
-    if (rest.startsWith("====")) {
-      const length = /^=+/.exec(source.slice(cursor.index))?.[0].length ?? 0;
+    if (source.startsWith("====", cursor.index)) {
+      const length = skipWhile(source, cursor.index, (next) => next === "=") - cursor.index;
       pushToken("ModuleEnd", "====", length);
       cursor.moduleDepth--;
-      if (cursor.moduleDepth > 0) continue;
-      const nextHeader = MODULE_HEADER.exec(source.slice(cursor.index));
-      if (!nextHeader) break;
-      advanceOver(nextHeader.index);
+      if (cursor.moduleDepth <= 0) break;
       continue;
     }
     if (character === '"') {
@@ -380,8 +440,7 @@ export const tokenize = (source: string): Token[] => {
         }
         if (source[cursor.index] === "\\") {
           const escaped = source[cursor.index + 1];
-          const replacement = { n: "\n", t: "\t", r: "\r", f: "\f" }[escaped] ?? escaped;
-          characters.push(replacement);
+          characters.push({ n: "\n", t: "\t", r: "\r", f: "\f" }[escaped] ?? escaped);
           advanceOver(2);
           continue;
         }
@@ -389,19 +448,28 @@ export const tokenize = (source: string): Token[] => {
         advanceOver(1);
       }
       advanceOver(1);
-      tokens.push({ kind: "String", text: characters.join(""), line, column });
+      tokens.push({
+        kind: "String",
+        text: characters.join(""),
+        line,
+        column,
+        endColumn: getColumn() - 1,
+      });
       continue;
     }
     const basedNumber = BASED_NUMBER.exec(source.slice(cursor.index, cursor.index + 64));
     if (basedNumber) {
-      const base = NUMBER_BASES.get(basedNumber[1][0].toLowerCase());
-      pushToken("Number", String(parseInt(basedNumber[1].slice(1), base)), basedNumber[0].length);
+      pushToken("Number", basedNumber[0], basedNumber[0].length);
       continue;
     }
     if (isIdentifierCharacter(character)) {
-      const word = /^[A-Za-z0-9_]+/.exec(source.slice(cursor.index))?.[0] ?? "";
+      const word = source.slice(
+        cursor.index,
+        skipWhile(source, cursor.index, isIdentifierCharacter),
+      );
       if (/^\d+$/.test(word)) {
-        pushToken("Number", word, word.length);
+        const number = /^\d+(\.\d+)?/.exec(source.slice(cursor.index))?.[0] ?? word;
+        pushToken(number.includes(".") ? "Decimal" : "Number", number, number.length);
         continue;
       }
       if (word.startsWith("WF_") || word.startsWith("SF_")) {
@@ -411,18 +479,20 @@ export const tokenize = (source: string): Token[] => {
       pushToken(KEYWORDS.has(word) ? "Keyword" : "Identifier", word, word.length);
       continue;
     }
+    const stepLength = matchStep(source, cursor.index);
+    if (stepLength > 0) {
+      pushToken("Step", source.slice(cursor.index, cursor.index + stepLength), stepLength);
+      continue;
+    }
     const operator = matchOperator(source, cursor.index);
     if (operator) {
       pushToken("Operator", operator.text, operator.length);
       continue;
     }
-    if (character === "\\") {
-      const word = /^[A-Za-z]+/.exec(source.slice(cursor.index + 1))?.[0] ?? "";
-      throw createError(`Unknown operator \\${word}`);
-    }
     throw createError(`Unexpected character ${JSON.stringify(character)}`);
   }
 
-  tokens.push({ kind: "End", text: "", line: cursor.line, column: getColumn() });
+  const endColumn = getColumn();
+  tokens.push({ kind: "End", text: "", line: cursor.line, column: endColumn, endColumn });
   return tokens;
 };

package/src/liveness.ts

@@ -1,6 +1,7 @@
-import type { Definition, Expression, SourceLocation } from "./ast";
+import type { Definition, Expression } from "./ast";
 import { TlaConfigError, TlaEvaluationError } from "./errors";
 import {
+  describeLocation,
   bindDefinitions,
   bindOperatorArguments,
   evaluate,
@@ -18,16 +19,16 @@ import {
   type Thunk,
 } from "./evaluate";
 import { mapChildren } from "./instances";
+import { ACTION_LEVEL, TEMPORAL_LEVEL } from "./levels";
 import { isEnabled } from "./successors";
 import {
+  createBoolean,
   createJunction,
   createPair,
   createUnary,
-  FALSE,
   getLiveLevel,
   getSolutions,
   isFulfilling,
-  TRUE,
   type LiveEnabled,
   type LiveExpression,
   type Solution,
@@ -55,7 +56,7 @@ export interface Lasso {
   cycle: number[];
 }
 
-export interface SafetyViolation {
+interface SafetyViolation {
   name: string;
   path: number[];
 }
@@ -88,10 +89,6 @@ interface BehaviorGraph {
   parents: number[];
 }
 
-export const ACTION_LEVEL = 2;
-
-export const TEMPORAL_LEVEL = 3;
-
 const MAXIMUM_EXPANSION_DEPTH = 100;
 
 const TEMPORAL_OPERATORS = new Set(["~>", "-+->"]);
@@ -107,9 +104,6 @@ const getConstantContext = (environment: Environment, scope: Scope | undefined):
   next: undefined,
 });
 
-const describeLocation = (expression: Expression) =>
-  `line ${expression.location.line}, column ${expression.location.column}`;
-
 const createCannotHandleError = (expression: Expression) =>
   new TlaEvaluationError(
     `TLC cannot handle the temporal formula at ${describeLocation(expression)}`,
@@ -121,7 +115,7 @@ export const getLevel = (
   environment: Environment,
   shadowed = new Set<string>(),
 ): number => {
-  const getBindingLevel = (name: string): number | undefined => {
+  const getBindingLevel = (name: string) => {
     const binding = lookupScope(scope, name);
     if (!binding) return undefined;
     if (binding.kind === "Value") return 0;
@@ -129,7 +123,7 @@ export const getLevel = (
     const operator = binding.operator;
     return operator.kind === "Closure" ? getLevel(operator.body, operator.scope, environment) : 0;
   };
-  const getGlobalLevel = (name: string): number | undefined => {
+  const getGlobalLevel = (name: string) => {
     if (environment.variableIndex.has(name)) return 1;
     if (environment.constants.has(name)) return 0;
     const definition = getDefinition(name, environment);
@@ -186,7 +180,7 @@ export const getLevel = (
   }
 };
 
-const getDefinitionLevel = (definition: Definition, environment: Environment): number => {
+const getDefinitionLevel = (definition: Definition, environment: Environment) => {
   const cached = definitionLevels.get(definition);
   if (cached !== undefined) return cached;
   definitionLevels.set(definition, 0);
@@ -203,34 +197,40 @@ export const expandTemporal = (
   expression: Expression,
   scope: Scope | undefined,
   environment: Environment,
+  isUnrollingForall: boolean,
   expanding = new Set<Definition>(),
 ): ScopedExpression[] => {
+  const expand = (
+    child: Expression,
+    childScope: Scope | undefined,
+    childExpanding = expanding,
+  ): ScopedExpression[] =>
+    expandTemporal(child, childScope, environment, isUnrollingForall, childExpanding);
   if (expression.kind === "And") {
-    return expression.operands.flatMap((operand) =>
-      expandTemporal(operand, scope, environment, expanding),
-    );
+    return expression.operands.flatMap((operand) => expand(operand, scope));
   }
-  if (expression.kind === "Label") {
-    return expandTemporal(expression.body, scope, environment, expanding);
+  if (expression.kind === "Label") return expand(expression.body, scope);
+  if (expression.kind === "Let") {
+    return expand(expression.body, bindLetDefinitions(expression, scope, environment));
   }
   if (expression.kind === "Identifier") {
     const binding = isLocallyResolved(expression) ? lookupScope(scope, expression.name) : undefined;
     if (binding?.kind === "Thunk") {
-      return expandTemporal(binding.expression, binding.scope, environment, expanding);
+      return expand(binding.expression, binding.scope);
     }
     const definition = environment.constants.has(expression.name)
       ? undefined
       : getDefinition(expression.name, environment);
-    if (!binding && definition?.kind === "Operator" && definition.params.length === 0) {
+    if (
+      !binding &&
+      definition?.kind === "Operator" &&
+      definition.params.length === 0 &&
+      getDefinitionLevel(definition, environment) > 0
+    ) {
       if (expanding.has(definition)) {
         throw new TlaConfigError(`The definition of ${expression.name} refers to itself`);
       }
-      return expandTemporal(
-        definition.body,
-        undefined,
-        environment,
-        new Set([...expanding, definition]),
-      );
+      return expand(definition.body, undefined, new Set([...expanding, definition]));
     }
   }
   const context = getConstantContext(environment, scope);
@@ -240,22 +240,18 @@ export const expandTemporal = (
       ? undefined
       : getDefinition(expression.operator, environment);
     if (operator?.kind === "Closure" && !definition?.isRecursive) {
-      return expandTemporal(
-        operator.body,
-        bindOperatorArguments(operator, expression.args, context),
-        environment,
-        expanding,
-      );
+      return expand(operator.body, bindOperatorArguments(operator, expression.args, context));
     }
   }
   const isUnrolled =
+    isUnrollingForall &&
     expression.kind === "Forall" &&
     getLevel(expression.body, scope, environment) === TEMPORAL_LEVEL &&
     expression.bounds.every((bound) => getLevel(bound.set, scope, environment) === 0);
-  if (expression.kind === "Forall" && isUnrolled) {
+  if (isUnrolled) {
     const expanded: ScopedExpression[] = [];
     forEachBinding(expression.bounds, context, (boundScope) => {
-      expanded.push(...expandTemporal(expression.body, boundScope, environment, expanding));
+      expanded.push(...expand(expression.body, boundScope));
       return false;
     });
     return expanded;
@@ -263,52 +259,6 @@ export const expandTemporal = (
   return [{ expression, scope }];
 };
 
-const toLiteral = (value: Value, location: SourceLocation): Expression | undefined => {
-  if (typeof value === "number") return { kind: "Number", value, location };
-  if (typeof value === "string") return { kind: "String", value, location };
-  if (typeof value === "boolean") {
-    return { kind: "Identifier", name: value ? "TRUE" : "FALSE", location };
-  }
-  return undefined;
-};
-
-export const toUnscopedExpression = (
-  expression: Expression,
-  scope: Scope | undefined,
-): Expression | undefined => {
-  const definitions: Definition[] = [];
-  for (let current = scope; current; current = current.parent) {
-    const binding = current.binding;
-    const closure =
-      binding.kind === "Operator" && binding.operator.kind === "Closure"
-        ? binding.operator
-        : undefined;
-    const body =
-      binding.kind === "Thunk"
-        ? binding.expression
-        : binding.kind === "Value"
-          ? toLiteral(binding.value, expression.location)
-          : closure?.body;
-    const isUnscoped =
-      binding.kind === "Thunk"
-        ? binding.scope === undefined
-        : binding.kind === "Value" || closure?.scope === undefined;
-    if (!body || !isUnscoped) return undefined;
-    definitions.unshift({
-      kind: "Operator",
-      name: current.name,
-      params: closure?.params ?? [],
-      body,
-      isLocal: true,
-      isRecursive: false,
-      location: body.location,
-    });
-  }
-  return definitions.length === 0
-    ? expression
-    : { kind: "Let", definitions, body: expression, location: expression.location };
-};
-
 const bindLetDefinitions = (
   expression: Expression & { kind: "Let" },
   scope: Scope | undefined,
@@ -346,7 +296,7 @@ const toLiveExpression = (
           `TLC expected a boolean in the temporal formula at ${describeLocation(expression)}`,
         );
       }
-      return value ? TRUE : FALSE;
+      return createBoolean(value);
     }
     if (atomLevel === 1) return { kind: "State", expression, scope };
     return { kind: "Action", expression, unchanged: undefined, scope };
@@ -375,7 +325,7 @@ const toLiveExpression = (
   const convertCall = (
     expression: Expression & { kind: "Identifier" | "Apply" },
     scope: Scope | undefined,
-  ): LiveExpression => {
+  ) => {
     const name = expression.kind === "Identifier" ? expression.name : expression.operator;
     const context = getConstantContext(environment, scope);
     const binding =
@@ -412,7 +362,7 @@ const toLiveExpression = (
       return false;
     });
     const isForall = expression.kind === "Forall";
-    if (operands.length === 0) return isForall ? TRUE : FALSE;
+    if (operands.length === 0) return createBoolean(isForall);
     const result = createJunction(isForall ? "And" : "Or", operands);
     const level = getLiveLevel(result);
     return level > ACTION_LEVEL ? result : toAtom(expression, scope, level);
@@ -851,6 +801,7 @@ export const createLivenessChecker = (
   };
 
   const addState = (index: number, state: Value[], successors: LiveSuccessor[]) => {
+    environment.runtime.setLivenessSource(index);
     states[index] = state;
     const edges: LiveSuccessor[] = [];
     const edgesByTarget = new Map<number, LiveSuccessor[]>();
@@ -893,6 +844,7 @@ export const createLivenessChecker = (
   };
 
   const computeActionResults = (source: number) => {
+    environment.runtime.setLivenessSource(source);
     const state = states[source];
     const successors = edgeStates[source];
     const values = successors.map(() => new Int8Array(actionKeys.size).fill(-1));
@@ -911,12 +863,14 @@ export const createLivenessChecker = (
       successors.forEach((successor, edgeIndex) => {
         const known = values[edgeIndex];
         for (let position = 0; position < actionCount; position++) {
-          const id = ids[position];
-          if (known[id] === -1) {
+          const actionId = ids[position];
+          if (known[actionId] === -1) {
             const predicate = solution.actionChecks[position];
-            known[id] = evaluateLive(predicate, state, successor, environment, stateCache) ? 1 : 0;
+            known[actionId] = evaluateLive(predicate, state, successor, environment, stateCache)
+              ? 1
+              : 0;
           }
-          actions[edgeIndex * actionCount + position] = known[id];
+          actions[edgeIndex * actionCount + position] = known[actionId];
         }
       });
       check.actionResults[source] = actions;
@@ -932,7 +886,9 @@ export const createLivenessChecker = (
     check.product ?? {
       states: states.map((_, index) => index),
       tableauNodes: states.map(() => -1),
-      edges: targets.map((list) => list.flatMap((target, edgeIndex) => [target, edgeIndex])),
+      edges: Array.from({ length: states.length }, (_, index) =>
+        (targets[index] ?? []).flatMap((target, edgeIndex) => [target, edgeIndex]),
+      ),
       initial,
       parents: [],
     };
@@ -1014,9 +970,9 @@ export const createLivenessChecker = (
           if (!isViolation) return false;
           const entry = component[component.length - 1];
           const waypoints = [
-            ...stateWitnesses.flatMap((witness) => (witness === undefined ? [] : [witness])),
+            ...stateWitnesses.flatMap((witness) => witness ?? []),
             ...actionWitnesses.flatMap((witness) => witness ?? []),
-            ...promiseWitnesses.flatMap((witness) => (witness === undefined ? [] : [witness])),
+            ...promiseWitnesses.flatMap((witness) => witness ?? []),
           ];
           const cycle = [entry];
           for (const waypoint of waypoints) {