tla-ts 0.0.2 → 0.0.3-dev.3cf2ad0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tla-ts",
-  "version": "0.0.2",
+  "version": "0.0.3-dev.3cf2ad0",
   "description": "A TLA+ interpreter and model checker in TypeScript, 2× faster than TLC",
   "keywords": [
     "formal verification",
@@ -71,6 +71,8 @@
     "conformance:sany": "tsx scripts/proof-conformance.ts",
     "conformance:record": "tsx scripts/record-tlc.ts",
     "conformance:record-sany": "tsx scripts/record-sany.ts",
+    "conformance:record-tlapm": "tsx scripts/record-tlapm.ts",
+    "conformance:tlapm": "tsx scripts/tlapm-conformance.ts",
     "publint": "publint",
     "test": "vp test",
     "typecheck": "tsc --noEmit"

package/src/ast.ts

@@ -44,6 +44,9 @@ export interface ApplyExpression {
   kind: "Apply";
   operator: string;
   args: Expression[];
+  // The number of args each part of a name like F(x)!l(y) takes, when a part before the last takes
+  // some.
+  argumentCounts?: number[];
   location: SourceLocation;
   resolution?: LocalResolution;
 }
@@ -64,6 +67,7 @@ export interface LambdaExpression {
 export interface JunctionExpression {
   kind: "And" | "Or";
   operands: Expression[];
+  isBulleted?: boolean;
   location: SourceLocation;
 }
 
@@ -129,6 +133,7 @@ export interface QuantifierExpression {
 
 export interface UnboundedQuantifierExpression {
   kind: "UnboundedQuantifier";
+  quantifier: "Forall" | "Exists";
   names: string[];
   isTemporal?: boolean;
   body: Expression;
@@ -317,6 +322,7 @@ export type Expression =
 export interface OperatorParam {
   name: string;
   arity: number;
+  location?: SourceLocation;
 }
 
 export interface OperatorDefinition {
@@ -368,6 +374,8 @@ export interface Instance {
   substitutions: InstanceSubstitution[];
   isLocal: boolean;
   location: SourceLocation;
+  instanceRange: SourceRange;
+  definitionRange?: SourceRange;
 }
 
 export interface NewSymbol {
@@ -388,18 +396,33 @@ export interface AssumeProve {
 
 export type Fact = Expression | { kind: "ModuleFact"; name: string; location: SourceLocation };
 
+// keyword is the range of the USE or HIDE token and any ONLY after it.
 export interface UseOrHide {
   kind: "Use" | "Hide";
   isOnly: boolean;
   facts: Fact[];
   defs: Fact[];
+  keyword: SourceRange;
   location: SourceLocation;
 }
 
+// keyword is the range of the BY, OBVIOUS, or OMITTED token.
 export type Proof =
-  | { kind: "Obvious" | "Omitted"; location: SourceLocation }
-  | { kind: "By"; isOnly: boolean; facts: Fact[]; defs: Fact[]; location: SourceLocation }
-  | { kind: "Steps"; level: number; steps: ProofStep[]; location: SourceLocation };
+  | { kind: "Obvious" | "Omitted"; keyword: SourceRange; location: SourceLocation }
+  | {
+      kind: "By";
+      isOnly: boolean;
+      facts: Fact[];
+      defs: Fact[];
+      keyword: SourceRange;
+      location: SourceLocation;
+    }
+  | {
+      kind: "Steps";
+      level: number;
+      steps: ProofStep[];
+      location: SourceLocation;
+    };
 
 export interface DefineStep {
   kind: "Define";
@@ -419,9 +442,12 @@ export type StepBody =
   | { kind: "Assert"; isSuffices: boolean; statement: Expression | AssumeProve }
   | { kind: "Qed" };
 
+// head is the range of the step number and its statement, without the proof.
 export interface ProofStep {
   name: string | undefined;
+  token: string;
   body: StepBody;
+  head: SourceRange;
   proof: Proof | undefined;
   location: SourceLocation;
 }
@@ -433,10 +459,23 @@ export interface Theorem {
   location: SourceLocation;
 }
 
+// The units of a module in source order, for consumers that need the order across kinds.
+export type ModuleUnit =
+  | { kind: "Constants"; declarations: Declaration[] }
+  | { kind: "Variables"; declarations: Declaration[] }
+  | { kind: "Recursive"; declarations: Declaration[] }
+  | { kind: "Definition"; definition: Definition }
+  | { kind: "Instance"; instance: Instance }
+  | { kind: "Assumption"; assumption: Assumption }
+  | { kind: "Theorem"; theorem: Theorem }
+  | { kind: "Use"; use: UseOrHide }
+  | { kind: "Module"; module: Module };
+
 export interface Module {
   name: string;
   modules: Module[];
   extends: string[];
+  extendsRanges: SourceRange[];
   constants: Declaration[];
   variables: Declaration[];
   definitions: Definition[];
@@ -445,4 +484,5 @@ export interface Module {
   location: SourceLocation;
   theorems: Theorem[];
   uses: UseOrHide[];
+  units: ModuleUnit[];
 }

package/src/check.ts

@@ -13,6 +13,7 @@ import {
   getDefinition,
   isConstantLevel,
   isImpure,
+  isLocallyResolved,
   type Context,
   type Environment,
   type Scope,
@@ -54,6 +55,7 @@ import {
   getValueHash,
   isFunctionValue,
   isSameValue,
+  isUpdatedElementOf,
   setStringOrder,
   toFiniteFunction,
   type Value,
@@ -139,6 +141,13 @@ interface NamedExpression {
 
 interface StateCheck extends NamedExpression {
   variables: number[] | undefined;
+  membership: Membership | undefined;
+}
+
+// A conjunct `x \in S` whose S reads no variables.
+interface Membership {
+  variable: number;
+  set: Expression;
 }
 
 interface ActionProperty {
@@ -481,14 +490,32 @@ const getPossiblePredicates = (names: string[], environment: Environment) =>
     return { name, expression, scope: undefined };
   });
 
+const getMembership = (
+  expression: Expression,
+  variables: number[] | undefined,
+  environment: Environment,
+): Membership | undefined => {
+  if (expression.kind !== "Apply" || expression.operator !== "\\in" || variables?.length !== 1)
+    return undefined;
+  const element = expression.args[0];
+  if (element.kind !== "Identifier" || isLocallyResolved(element)) return undefined;
+  return environment.variableIndex.get(element.name) === variables[0]
+    ? { variable: variables[0], set: expression.args[1] }
+    : undefined;
+};
+
 const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
   named.flatMap((item) =>
-    getConjuncts(item.expression, environment).map((expression) => ({
-      name: item.name,
-      expression,
-      scope: item.scope,
-      variables: getReadVariables(expression, environment),
-    })),
+    getConjuncts(item.expression, environment).map((expression) => {
+      const variables = getReadVariables(expression, environment);
+      return {
+        name: item.name,
+        expression,
+        scope: item.scope,
+        variables,
+        membership: getMembership(expression, variables, environment),
+      };
+    }),
   );
 
 const isUnchangedFor = (stateCheck: StateCheck, state: Value[], parent: Value[] | undefined) => {
@@ -743,10 +770,16 @@ export const createSearch = (
       invariants.find((invariant) => {
         if (isUnchangedFor(invariant, state, parent)) return false;
         try {
-          return !holdsLikeTlc(
-            invariant.expression,
-            getContext(environment, state, undefined, invariant.scope),
-          );
+          const context = getContext(environment, state, undefined, invariant.scope);
+          const membership = invariant.membership;
+          // The parent satisfies every invariant, so only the entries the step changed can fail.
+          return parent && membership
+            ? !isUpdatedElementOf(
+                state[membership.variable],
+                parent[membership.variable],
+                evaluate(membership.set, context),
+              )
+            : !holdsLikeTlc(invariant.expression, context);
         } catch (error) {
           // TLC reports a failure only on a state after the initial states as an invariant failure.
           if (!parent) throw error;

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/errors.ts

@@ -7,10 +7,20 @@ export class TlaError extends Error {
   }
 }
 
+export interface SyntaxFailure {
+  reason: string;
+  line: number;
+  column: number;
+  isEnd: boolean;
+}
+
 export class TlaSyntaxError extends TlaError {
-  constructor(message: string, cause?: unknown) {
+  failure: SyntaxFailure | undefined;
+
+  constructor(message: string, cause?: unknown, failure?: SyntaxFailure) {
     super(message, cause);
     this.name = "TlaSyntaxError";
+    this.failure = failure;
   }
 }
 
@@ -38,6 +48,32 @@ export class TlaModuleError extends TlaEvaluationError {
   }
 }
 
+export interface TlapmReport {
+  failure?: string;
+  exception?: string;
+}
+
+export class TlaProofError extends TlaError {
+  failure: string | undefined;
+  exception: string;
+
+  constructor(message: string, report: TlapmReport = {}) {
+    super(message);
+    this.name = "TlaProofError";
+    this.failure = report.exception === undefined ? (report.failure ?? message) : undefined;
+    this.exception = report.exception ?? `Failure(${JSON.stringify(this.failure)})`;
+  }
+}
+
+// tlapm fails one of its own assertions, which it reports as a bug in itself. It keeps the name
+// TlaProofError, and index.ts doesn't export it.
+export class TlapmBugError extends TlaProofError {
+  constructor(exception = "Assert_failure") {
+    super("Oops, this seems to be a bug in TLAPM.", { exception });
+    this.name = "TlaProofError";
+  }
+}
+
 export class TlaUnsupportedError extends TlaError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);

package/src/evaluate.ts

@@ -734,7 +734,9 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
     if (global === undefined) {
       return (context) => {
         const binding = lookupScope(context.scope, argument.name);
-        return binding?.kind === "Value" ? binding : createThunk(argument, context);
+        return binding?.kind === "Value" || binding?.kind === "Thunk"
+          ? binding
+          : createThunk(argument, context);
       };
     }
   }

package/src/fingerprints.ts

@@ -1,12 +1,10 @@
 import { getValueFingerprint, getValueHash, type Value } from "./values";
 
 const EMPTY = 0;
-const TOMBSTONE = 1;
 const INITIAL_CAPACITY = 1 << 12;
 
 interface FingerprintTable {
   insert: (first: number, second: number) => boolean;
-  remove: (first: number, second: number) => void;
 }
 
 const mix = (hash: number) => {
@@ -26,15 +24,13 @@ export const writeStateFingerprint = (state: Value[], fingerprint: Int32Array) =
   fingerprint[1] = mix(second);
 };
 
-export const getFingerprintOwner = (second: number, count: number) => (second >>> 0) % count;
-
 export const createFingerprintTable = (): FingerprintTable => {
   const table = { slots: new Int32Array(INITIAL_CAPACITY * 2), used: 0 };
   const findSlot = (slots: Int32Array, first: number, second: number) => {
     const mask = slots.length / 2 - 1;
     for (let index = first & mask; ; index = (index + 1) & mask) {
       const stored = slots[index * 2];
-      if (stored === EMPTY && slots[index * 2 + 1] === EMPTY) return index;
+      if (stored === EMPTY) return index;
       if (stored === first && slots[index * 2 + 1] === second) return index;
     }
   };
@@ -59,11 +55,50 @@ export const createFingerprintTable = (): FingerprintTable => {
       table.used++;
       return true;
     },
-    remove: (first, second) => {
-      const slot = findSlot(table.slots, first, second);
-      if (table.slots[slot * 2] !== first) return;
-      table.slots[slot * 2] = EMPTY;
-      table.slots[slot * 2 + 1] = TOMBSTONE;
-    },
   };
 };
+
+// Workers share one table of 64-bit fingerprints. The first word is never 0, so 0 marks an empty slot.
+export interface SharedFingerprints {
+  slots: BigInt64Array;
+  used: Int32Array;
+}
+
+const INITIAL_SHARED_CAPACITY = 1 << 10;
+
+const insertSharedKey = (slots: BigInt64Array, key: bigint) => {
+  const mask = slots.length - 1;
+  for (let index = Number(key >> 32n) & mask; ; index = (index + 1) & mask) {
+    const stored = Atomics.load(slots, index);
+    if (stored === key) return false;
+    if (stored !== 0n) continue;
+    const previous = Atomics.compareExchange(slots, index, 0n, key);
+    if (previous === 0n) return true;
+    if (previous === key) return false;
+  }
+};
+
+export const createSharedFingerprints = (): SharedFingerprints => ({
+  slots: new BigInt64Array(new SharedArrayBuffer(INITIAL_SHARED_CAPACITY * 8)),
+  used: new Int32Array(new SharedArrayBuffer(4)),
+});
+
+export const insertSharedFingerprint = (
+  table: SharedFingerprints,
+  first: number,
+  second: number,
+) => {
+  const key = BigInt.asIntN(64, (BigInt(first) << 32n) | BigInt(second >>> 0));
+  if (!insertSharedKey(table.slots, key)) return false;
+  Atomics.add(table.used, 0, 1);
+  return true;
+};
+
+export const isSharedFingerprintsFull = (table: SharedFingerprints) =>
+  Atomics.load(table.used, 0) * 2 >= table.slots.length;
+
+export const growSharedFingerprints = (table: SharedFingerprints): SharedFingerprints => {
+  const slots = new BigInt64Array(new SharedArrayBuffer(table.slots.byteLength * 2));
+  for (const key of table.slots) if (key !== 0n) insertSharedKey(slots, key);
+  return { slots, used: table.used };
+};

package/src/lexer.ts

@@ -380,7 +380,12 @@ export const tokenize = (source: string): Token[] => {
     }
   };
   const createError = (message: string) =>
-    new TlaSyntaxError(`${message} at line ${cursor.line}, column ${getColumn()}`);
+    new TlaSyntaxError(`${message} at line ${cursor.line}, column ${getColumn()}`, undefined, {
+      reason: message,
+      line: cursor.line,
+      column: getColumn(),
+      isEnd: cursor.index >= source.length,
+    });
 
   while (cursor.index < source.length) {
     const character = source[cursor.index];