tla-ts 0.0.1 → 0.0.3-dev.a50fc89

package/src/exit-codes.ts

@@ -0,0 +1,75 @@
+import type { LivenessChecker } from "./liveness";
+
+// TLC's exit statuses, from EC.ExitStatus.
+export const EXIT_STATUS = {
+  success: 0,
+  assumptionViolation: 10,
+  deadlock: 11,
+  safetyViolation: 12,
+  livenessViolation: 13,
+  assertViolation: 14,
+  specEvaluationFailure: 75,
+  safetyEvaluationFailure: 76,
+  livenessEvaluationFailure: 77,
+  specParseError: 150,
+  configParseError: 151,
+  error: 255,
+} as const;
+
+const exitCodes = new WeakMap<Error, number>();
+const moduleExitCodes = new WeakMap<Error, number>();
+const phase = { isNextState: false };
+
+export const setNextStatePhase = (isNextState: boolean) => {
+  phase.isNextState = isNextState;
+};
+
+// The innermost site that knows TLC's exit status for an error sets it first and wins.
+export const setExitCode = <Thrown>(error: Thrown, code: number) => {
+  if (error instanceof Error && !exitCodes.has(error)) exitCodes.set(error, code);
+  return error;
+};
+
+// TLC exits with the code of an exception from a standard module's Java code only when the exception
+// escapes the computation of next states. In every other phase, the phase decides the code.
+export const setModuleExitCode = (error: Error, code: number) => {
+  if (phase.isNextState) moduleExitCodes.set(error, code);
+};
+
+export const getExitCode = (error: Error) => exitCodes.get(error) ?? moduleExitCodes.get(error);
+
+// TLC exits with 255 when it fails to process or evaluate a liveness property, in any phase.
+export const withLivenessExitCode = (
+  create: () => LivenessChecker | undefined,
+): LivenessChecker | undefined => {
+  try {
+    const checker = create();
+    return (
+      checker && {
+        addInitialState: (index, state) => {
+          try {
+            checker.addInitialState(index, state);
+          } catch (error) {
+            throw setExitCode(error, EXIT_STATUS.error);
+          }
+        },
+        addState: (index, state, successors) => {
+          try {
+            return checker.addState(index, state, successors);
+          } catch (error) {
+            throw setExitCode(error, EXIT_STATUS.error);
+          }
+        },
+        findViolation: () => {
+          try {
+            return checker.findViolation();
+          } catch (error) {
+            throw setExitCode(error, EXIT_STATUS.error);
+          }
+        },
+      }
+    );
+  } catch (error) {
+    throw setExitCode(error, EXIT_STATUS.error);
+  }
+};

package/src/fingerprints.ts

@@ -4,7 +4,7 @@ const EMPTY = 0;
 const TOMBSTONE = 1;
 const INITIAL_CAPACITY = 1 << 12;
 
-export interface FingerprintTable {
+interface FingerprintTable {
   insert: (first: number, second: number) => boolean;
   remove: (first: number, second: number) => void;
 }
@@ -15,7 +15,7 @@ const mix = (hash: number) => {
   return second ^ (second >>> 16);
 };
 
-export const getStateFingerprint = (state: Value[], fingerprint: Int32Array) => {
+export const writeStateFingerprint = (state: Value[], fingerprint: Int32Array) => {
   let first = 0x811c9dc5;
   let second = 0x6a09e667;
   for (let index = 0; index < state.length; index++) {

package/src/index.ts

@@ -1,5 +1,11 @@
-export { check } from "./check";
-export type { CheckOptions, CheckResult, CheckStatus, TraceStep, Violation } from "./check";
+export type {
+  CheckOptions,
+  CheckResult,
+  CheckStatus,
+  EvaluationFailure,
+  TraceStep,
+  Violation,
+} from "./check";
 export { parseConfig } from "./config";
 export type { ConfigValue, ConstantAssignment, ModelConfig, Substitution } from "./config";
 export {
@@ -9,8 +15,7 @@ export {
   TlaSyntaxError,
   TlaUnsupportedError,
 } from "./errors";
-export { checkInParallel } from "./parallel";
-export type { ParallelCheckOptions } from "./parallel";
+export { check } from "./parallel";
 export { parseModule } from "./parser";
 export type { Module } from "./ast";
 export { formatValue } from "./values";

package/src/instances.ts

@@ -7,19 +7,18 @@ import type {
   Module,
   OperatorParam,
   SourceLocation,
+  Theorem,
 } from "./ast";
 import { TlaSyntaxError } from "./errors";
 import { getChildren, isLocallyResolved } from "./evaluate";
-import { isBefore } from "./resolve";
-
-const getPatternNames = (pattern: BoundPattern) =>
-  pattern.kind === "Name" ? [pattern.name] : pattern.names;
-
-const getBoundNames = (bounds: Bound[]) =>
-  bounds.flatMap((bound) => getPatternNames(bound.pattern));
+import { getArity, getBoundNames, getPatternNames, isBefore } from "./resolve";
 
 export const substitutedExpressions = new WeakSet<Expression>();
 
+// Applications inside an instance with substitutions or parameters, which TLC evaluates in a
+// context that binds them.
+export const contextualApplications = new WeakSet<Expression>();
+
 export const renameLocals = (
   expression: Expression,
   names: Map<string, string>,
@@ -41,26 +40,39 @@ export const renameLocals = (
   return mapped;
 };
 
-const mapBounds = (bounds: Bound[], map: (child: Expression) => Expression): Bound[] =>
+const mapBounds = (bounds: Bound[], map: (child: Expression) => Expression) =>
   bounds.map((bound) => ({ pattern: bound.pattern, set: map(bound.set) }));
 
+const sourceNames = new WeakMap<Definition, string>();
+
+export const getSourceName = (definition: Definition) =>
+  sourceNames.get(definition) ?? definition.name;
+
+const withSourceName = (definition: Definition, source: Definition) => {
+  if (getSourceName(source) !== definition.name) sourceNames.set(definition, getSourceName(source));
+  return definition;
+};
+
 export const mapDefinition = (
   definition: Definition,
   map: (child: Expression, bound: string[]) => Expression,
 ): Definition =>
-  definition.kind === "Function"
-    ? {
-        ...definition,
-        bounds: mapBounds(definition.bounds, (child) => map(child, [])),
-        body: map(definition.body, getBoundNames(definition.bounds)),
-      }
-    : {
-        ...definition,
-        body: map(
-          definition.body,
-          definition.params.map((param) => param.name),
-        ),
-      };
+  withSourceName(
+    definition.kind === "Function"
+      ? {
+          ...definition,
+          bounds: mapBounds(definition.bounds, (child) => map(child, [])),
+          body: map(definition.body, getBoundNames(definition.bounds)),
+        }
+      : {
+          ...definition,
+          body: map(
+            definition.body,
+            definition.params.map((param) => param.name),
+          ),
+        },
+    definition,
+  );
 
 export const mapChildren = (
   expression: Expression,
@@ -69,6 +81,7 @@ export const mapChildren = (
   const plain = (child: Expression) => map(child, []);
   switch (expression.kind) {
     case "Number":
+    case "Decimal":
     case "String":
     case "Identifier":
     case "OperatorReference":
@@ -199,29 +212,131 @@ export const mapChildren = (
   }
 };
 
-export interface Instantiation {
+interface Instantiation {
   params: OperatorParam[];
   substitutions: Map<string, Expression>;
   variables: Set<string>;
   getDefinition: (key: string) => Definition | undefined;
   isParameterized: (key: string) => boolean;
   addDefinition: (name: string, create: (key: string) => Definition) => string;
+  createName: (name: string) => string;
 }
 
+// LAMBDA is a keyword, so no name bound inside the instance can capture it.
+const LAMBDA_NAME = "LAMBDA";
+
 type RewriteMode = "Normal" | "Enabled" | "Primed";
 
 interface Rewrite {
   instantiation: Instantiation;
+  substitutedNames: Set<string>;
   copies: Map<string, string>;
   mode: RewriteMode;
   modes: Map<RewriteMode, Rewrite>;
 }
 
+const getFreeNames = (expression: Expression, bound = new Set<string>()): string[] => {
+  const name =
+    expression.kind === "Identifier"
+      ? expression.name
+      : expression.kind === "Apply" || expression.kind === "OperatorReference"
+        ? expression.operator
+        : undefined;
+  const names = name === undefined || bound.has(name) ? [] : [name];
+  mapChildren(expression, (child, childBound) => {
+    names.push(
+      ...getFreeNames(child, childBound.length === 0 ? bound : new Set([...bound, ...childBound])),
+    );
+    return child;
+  });
+  return names;
+};
+
+const createRenamer = (rewrite: Rewrite) => {
+  const renamed = new Map<string, string>();
+  return (name: string) => {
+    if (!rewrite.substitutedNames.has(name)) return name;
+    const fresh = renamed.get(name) ?? rewrite.instantiation.createName(name);
+    renamed.set(name, fresh);
+    return fresh;
+  };
+};
+
+const bindNames = (bound: Map<string, string>, names: string[], rename: (name: string) => string) =>
+  new Map([...bound, ...names.map((name): [string, string] => [name, rename(name)])]);
+
+const renamePattern = (pattern: BoundPattern, rename: (name: string) => string): BoundPattern =>
+  pattern.kind === "Name"
+    ? { kind: "Name", name: rename(pattern.name) }
+    : { kind: "Tuple", names: pattern.names.map(rename) };
+
+const renameBounds = (bounds: Bound[], rename: (name: string) => string) =>
+  bounds.map((bound) => ({ pattern: renamePattern(bound.pattern, rename), set: bound.set }));
+
+const renameParams = (definition: Definition, rename: (name: string) => string): Definition =>
+  definition.kind === "Function"
+    ? { ...definition, bounds: renameBounds(definition.bounds, rename) }
+    : {
+        ...definition,
+        params: definition.params.map((param) => ({
+          name: rename(param.name),
+          arity: param.arity,
+        })),
+      };
+
+const renameNames = (
+  expression: Expression,
+  bound: Map<string, string>,
+  rename: (name: string) => string,
+): Expression => {
+  const getBoundName = (name: string) => bound.get(name) ?? name;
+  switch (expression.kind) {
+    case "Identifier":
+      return { ...expression, name: getBoundName(expression.name) };
+    case "Apply":
+    case "OperatorReference":
+      return { ...expression, operator: getBoundName(expression.operator) };
+    case "Label":
+      return { ...expression, params: expression.params.map(getBoundName) };
+    case "Lambda":
+      return { ...expression, params: expression.params.map(rename) };
+    case "Let":
+      return {
+        ...expression,
+        definitions: expression.definitions.map((definition) =>
+          withSourceName(
+            { ...renameParams(definition, rename), name: rename(definition.name) },
+            definition,
+          ),
+        ),
+      };
+    case "Forall":
+    case "Exists":
+    case "FunctionConstruction":
+    case "SetMap":
+      return { ...expression, bounds: renameBounds(expression.bounds, rename) };
+    case "UnboundedQuantifier":
+      return { ...expression, names: expression.names.map(rename) };
+    case "Choose":
+      return { ...expression, pattern: renamePattern(expression.pattern, rename) };
+    case "SetFilter":
+      return {
+        ...expression,
+        bound: {
+          pattern: renamePattern(expression.bound.pattern, rename),
+          set: expression.bound.set,
+        },
+      };
+    default:
+      return expression;
+  }
+};
+
 export const getEnabledVariableName = (name: string) => `${name}@ENABLED`;
 
 const getMode = (rewrite: Rewrite, mode: RewriteMode) => rewrite.modes.get(mode) ?? rewrite;
 
-const isVariable = (expression: Expression, rewrite: Rewrite, bound: Set<string>) =>
+const isVariable = (expression: Expression, rewrite: Rewrite, bound: Map<string, string>) =>
   expression.kind === "Identifier" &&
   !bound.has(expression.name) &&
   !isLocallyResolved(expression) &&
@@ -230,7 +345,7 @@ const isVariable = (expression: Expression, rewrite: Rewrite, bound: Set<string>
 const getUnchangedVariables = (
   expression: Expression,
   rewrite: Rewrite,
-  bound: Set<string>,
+  bound: Map<string, string>,
 ): string[] | undefined => {
   if (expression.kind === "Tuple") {
     const names = expression.elements.map((element) =>
@@ -244,14 +359,14 @@ const getUnchangedVariables = (
     ? undefined
     : rewrite.instantiation.getDefinition(expression.name);
   return definition?.kind === "Operator" && definition.params.length === 0
-    ? getUnchangedVariables(definition.body, rewrite, new Set())
+    ? getUnchangedVariables(definition.body, rewrite, new Map())
     : undefined;
 };
 
 const substituteInEnabled = (
   expression: Expression,
   rewrite: Rewrite,
-  bound: Set<string>,
+  bound: Map<string, string>,
 ): Expression | undefined => {
   if (rewrite.mode === "Normal") return undefined;
   if (rewrite.mode === "Primed") {
@@ -318,16 +433,15 @@ const substituteInEnabled = (
   };
 };
 
-const getParamArguments = (params: OperatorParam[], location: SourceLocation): Expression[] =>
-  params.map((param) => ({
-    kind: "Identifier",
-    name: param.name,
-    location,
-    resolution: { kind: "Local" },
-  }));
+const createLocalIdentifier = (name: string, location: SourceLocation): Expression => ({
+  kind: "Identifier",
+  name,
+  location,
+  resolution: { kind: "Local" },
+});
 
-const getArity = (definition: Definition) =>
-  definition.kind === "Operator" ? definition.params.length : 0;
+const getParamArguments = (params: OperatorParam[], location: SourceLocation) =>
+  params.map((param) => createLocalIdentifier(param.name, location));
 
 const getInstanceOperator = (
   key: string,
@@ -344,12 +458,7 @@ const getInstanceOperator = (
       operator: key,
       args: [
         ...getParamArguments(params, location),
-        ...names.map((name): Expression => ({
-          kind: "Identifier",
-          name,
-          location,
-          resolution: { kind: "Local" },
-        })),
+        ...names.map((name) => createLocalIdentifier(name, location)),
       ],
       location,
     },
@@ -360,7 +469,11 @@ const getInstanceOperator = (
 const getCopy = (rewrite: Rewrite, key: string) =>
   rewrite.instantiation.isParameterized(key) ? copyDefinition(rewrite, key) : undefined;
 
-const substitute = (expression: Expression, rewrite: Rewrite, bound: Set<string>): Expression => {
+const substitute = (
+  expression: Expression,
+  rewrite: Rewrite,
+  bound: Map<string, string>,
+): Expression => {
   const recurse = (node: Expression) => substitute(node, rewrite, bound);
   const instantiation = rewrite.instantiation;
   const params = instantiation.params;
@@ -375,7 +488,6 @@ const substitute = (expression: Expression, rewrite: Rewrite, bound: Set<string>
     (expression.kind === "WeakFairness" || expression.kind === "StrongFairness") &&
     rewrite.mode === "Normal"
   ) {
-    const enabled = getMode(rewrite, "Enabled");
     return {
       ...expression,
       subscript: recurse(expression.subscript),
@@ -387,7 +499,7 @@ const substitute = (expression: Expression, rewrite: Rewrite, bound: Set<string>
           subscript: expression.subscript,
           location: expression.location,
         },
-        enabled,
+        getMode(rewrite, "Enabled"),
         bound,
       ),
     };
@@ -417,22 +529,30 @@ const substitute = (expression: Expression, rewrite: Rewrite, bound: Set<string>
   if (expression.kind === "Apply" && isFree(expression.operator)) {
     const args = expression.args.map(recurse);
     const replacement = instantiation.substitutions.get(expression.operator);
+    const isContextual =
+      instantiation.substitutions.size > 0 ||
+      params.length > 0 ||
+      contextualApplications.has(expression);
+    const mark = (rewritten: Expression) => {
+      if (isContextual) contextualApplications.add(rewritten);
+      return rewritten;
+    };
     if (replacement?.kind === "Identifier" || replacement?.kind === "OperatorReference") {
       const operator = replacement.kind === "Identifier" ? replacement.name : replacement.operator;
-      return {
+      return mark({
         ...expression,
         operator,
         args,
         resolution: replacement.kind === "Identifier" ? replacement.resolution : undefined,
-      };
+      });
     }
     if (replacement?.kind === "Apply") {
-      return {
+      return mark({
         ...expression,
         operator: replacement.operator,
         args: [...replacement.args, ...args],
         resolution: replacement.resolution,
-      };
+      });
     }
     if (replacement?.kind === "Lambda") {
       return {
@@ -440,7 +560,7 @@ const substitute = (expression: Expression, rewrite: Rewrite, bound: Set<string>
         definitions: [
           {
             kind: "Operator",
-            name: replacement.kind,
+            name: LAMBDA_NAME,
             params: replacement.params.map((name) => ({ name, arity: 0 })),
             body: replacement.body,
             isLocal: true,
@@ -450,7 +570,7 @@ const substitute = (expression: Expression, rewrite: Rewrite, bound: Set<string>
         ],
         body: {
           ...expression,
-          operator: replacement.kind,
+          operator: LAMBDA_NAME,
           args,
           resolution: { kind: "Local" },
         },
@@ -463,7 +583,7 @@ const substitute = (expression: Expression, rewrite: Rewrite, bound: Set<string>
       );
     }
     const copy = getCopy(rewrite, expression.operator);
-    if (copy === undefined) return { ...expression, args };
+    if (copy === undefined) return mark({ ...expression, args });
     return {
       ...expression,
       operator: copy,
@@ -479,9 +599,13 @@ const substitute = (expression: Expression, rewrite: Rewrite, bound: Set<string>
     }
     return { ...expression, operator: copy };
   }
-  return mapChildren(expression, (child, names) =>
-    names.length === 0 ? recurse(child) : substitute(child, rewrite, new Set([...bound, ...names])),
+  const rename = createRenamer(rewrite);
+  const mapped = mapChildren(expression, (child, names) =>
+    names.length === 0
+      ? recurse(child)
+      : substitute(child, rewrite, bindNames(bound, names, rename)),
   );
+  return renameNames(mapped, bound, rename);
 };
 
 const withInstanceParams = (
@@ -500,7 +624,7 @@ const withInstanceParams = (
     body: {
       kind: "Let",
       definitions: [definition],
-      body: { kind: "Identifier", name: definition.name, location, resolution: { kind: "Local" } },
+      body: createLocalIdentifier(definition.name, location),
       location,
     },
     isLocal: definition.isLocal,
@@ -517,8 +641,12 @@ const copyDefinition = (rewrite: Rewrite, key: string): string => {
   if (!definition) return key;
   return instantiation.addDefinition(definition.name, (copyKey) => {
     rewrite.copies.set(key, copyKey);
-    const mapped = mapDefinition(definition, (child, bound) =>
-      substitute(child, rewrite, new Set(bound)),
+    const rename = createRenamer(rewrite);
+    const mapped = renameParams(
+      mapDefinition(definition, (child, bound) =>
+        substitute(child, rewrite, bindNames(new Map(), bound, rename)),
+      ),
+      rename,
     );
     return withInstanceParams(mapped, instantiation.params, definition.location);
   });
@@ -526,8 +654,17 @@ const copyDefinition = (rewrite: Rewrite, key: string): string => {
 
 export const createInstantiation = (instantiation: Instantiation) => {
   const modes = new Map<RewriteMode, Rewrite>();
+  const substitutedNames = new Set(
+    [...instantiation.substitutions.values()].flatMap((expression) => getFreeNames(expression)),
+  );
   const createRewrite = (mode: RewriteMode): Rewrite => {
-    const created = { instantiation, copies: new Map(), mode, modes };
+    const created = {
+      instantiation,
+      substitutedNames,
+      copies: new Map<string, string>(),
+      mode,
+      modes,
+    };
     modes.set(mode, created);
     return created;
   };
@@ -554,36 +691,54 @@ const hasLetInstance = (expression: Expression): boolean =>
 
 const expandLetInstances = (
   expression: Expression,
-  instantiate: (instance: Instance) => Definition[],
+  instantiate: (instance: Instance, lets: Definition[]) => Definition[],
+  lets: Definition[],
 ): Expression => {
-  const mapped = mapChildren(expression, (child) => expandLetInstances(child, instantiate));
+  const inner = expression.kind === "Let" ? [...lets, ...expression.definitions] : lets;
+  const mapped = mapChildren(expression, (child) => expandLetInstances(child, instantiate, inner));
   if (mapped.kind !== "Let" || !mapped.instances) return mapped;
   const definitions = mapped.instances.reduce((current, instance) => {
     const position = current.findIndex((definition) =>
       isBefore(instance.location, definition.location),
     );
     const index = position === -1 ? current.length : position;
-    return [...current.slice(0, index), ...instantiate(instance), ...current.slice(index)];
+    return [...current.slice(0, index), ...instantiate(instance, inner), ...current.slice(index)];
   }, mapped.definitions);
   return { kind: "Let", definitions, body: mapped.body, location: mapped.location };
 };
 
+// A named theorem's statement is linked as its definition.
+const getUnnamedStatement = (theorem: Theorem) =>
+  theorem.name === undefined && theorem.statement.kind !== "AssumeProve"
+    ? theorem.statement
+    : undefined;
+
 export const withLetInstances = (
   module: Module,
-  instantiate: (instance: Instance) => Definition[],
+  instantiate: (instance: Instance, lets: Definition[]) => Definition[],
 ): Module => {
-  const isExpanded =
+  const hasLetInstances =
     module.definitions.some((definition) => hasLetInstance(definition.body)) ||
-    module.assumptions.some((assumption) => hasLetInstance(assumption.expression));
-  if (!isExpanded) return module;
+    module.assumptions.some((assumption) => hasLetInstance(assumption.expression)) ||
+    module.theorems.some((theorem) => {
+      const statement = getUnnamedStatement(theorem);
+      return statement !== undefined && hasLetInstance(statement);
+    });
+  if (!hasLetInstances) return module;
   return {
     ...module,
     definitions: module.definitions.map((definition) =>
-      mapDefinition(definition, (child) => expandLetInstances(child, instantiate)),
+      mapDefinition(definition, (child) => expandLetInstances(child, instantiate, [])),
     ),
     assumptions: module.assumptions.map((assumption) => ({
       ...assumption,
-      expression: expandLetInstances(assumption.expression, instantiate),
+      expression: expandLetInstances(assumption.expression, instantiate, []),
     })),
+    theorems: module.theorems.map((theorem) => {
+      const statement = getUnnamedStatement(theorem);
+      return statement === undefined
+        ? theorem
+        : { ...theorem, statement: expandLetInstances(statement, instantiate, []) };
+    }),
   };
 };