tla-ts 0.0.2 → 0.0.3-dev.a50fc89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tla-ts",
-  "version": "0.0.2",
+  "version": "0.0.3-dev.a50fc89",
   "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/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];