tla-ts 0.0.1 → 0.0.3-dev.a50fc89

package/src/substitution-levels.ts

@@ -0,0 +1,184 @@
+import type { Declaration, Definition, Expression, SourceLocation } from "./ast";
+import { TlaSyntaxError } from "./errors";
+import {
+  createLevelAnalyzer,
+  getArgumentKey,
+  MAX_LEVEL,
+  parseArgumentParamKey,
+  putArgConstraint,
+  putConstraint,
+  type OperatorLevels,
+  type Scope,
+} from "./levels";
+
+export interface InstanceCheck {
+  module: string;
+  instancer: string;
+  lets: Definition[];
+  substitutions: Map<string, Expression>;
+  location: SourceLocation;
+}
+
+interface ModuleContext {
+  constants: Declaration[];
+  variables: string[];
+  definitions: Definition[];
+  assumptions: Expression[];
+  getDefinition: (name: string) => Definition | undefined;
+}
+
+interface ModuleLevels {
+  isConstant: boolean;
+  constraints: Map<string, number>;
+  argConstraints: Map<string, number>;
+  argParams: Set<string>;
+}
+
+interface Substituted {
+  name: string;
+  maximumLevel: number;
+  arity: number;
+  level: number;
+  operator: OperatorLevels | undefined;
+  isLeibniz: boolean;
+}
+
+const getMaxLevel = (operator: OperatorLevels, index: number) =>
+  operator.maxLevels[index] ?? MAX_LEVEL;
+
+export const checkInstances = (
+  checks: InstanceCheck[],
+  getModule: (name: string) => ModuleContext,
+) => {
+  const analyzers = new Map<string, ReturnType<typeof createLevelAnalyzer>>();
+  const getAnalyzer = (name: string) => {
+    const cached = analyzers.get(name);
+    if (cached) return cached;
+    const module = getModule(name);
+    const analyzer = createLevelAnalyzer({
+      constants: new Set(module.constants.map((constant) => constant.name)),
+      variables: new Set(module.variables),
+      getDefinition: module.getDefinition,
+    });
+    analyzers.set(name, analyzer);
+    return analyzer;
+  };
+
+  const moduleLevels = new Map<string, ModuleLevels>();
+  const getModuleLevels = (name: string) => {
+    const cached = moduleLevels.get(name);
+    if (cached) return cached;
+    const module = getModule(name);
+    const analyzer = getAnalyzer(name);
+    const definitions = module.definitions.map((definition) =>
+      analyzer.analyzeDefinition(definition, new Map()),
+    );
+    const levels: ModuleLevels = {
+      isConstant:
+        module.variables.length === 0 && definitions.every((definition) => definition.level === 0),
+      constraints: new Map(),
+      argConstraints: new Map(),
+      argParams: new Set(),
+    };
+    if (!levels.isConstant) {
+      module.constants.forEach((constant) => putConstraint(levels.constraints, constant.name, 0));
+    }
+    const addLevels = (
+      data: Omit<ModuleLevels, "isConstant">,
+      isKept: (operator: string, param: string) => boolean,
+    ) => {
+      data.constraints.forEach((value, key) => putConstraint(levels.constraints, key, value));
+      data.argConstraints.forEach((value, key) =>
+        putArgConstraint(levels.argConstraints, key, value),
+      );
+      data.argParams.forEach((key) => {
+        const parameter = parseArgumentParamKey(key);
+        if (isKept(parameter.operator, parameter.param)) levels.argParams.add(key);
+      });
+    };
+    definitions.forEach((definition) =>
+      addLevels(definition, (operator, param) =>
+        definition.formals.every((formal) => formal.name !== operator && formal.name !== param),
+      ),
+    );
+    module.assumptions.forEach((assumption) =>
+      addLevels(analyzer.analyze(assumption, new Map()), () => true),
+    );
+    moduleLevels.set(name, levels);
+    return levels;
+  };
+
+  const messages = new Set<string>();
+  checks.forEach((check) => {
+    const location = `at line ${check.location.line}, column ${check.location.column}`;
+    const addMessage = (message: string) => messages.add(`${message} ${location}`);
+    const instancee = getModule(check.module);
+    const levels = getModuleLevels(check.module);
+    const analyzer = getAnalyzer(check.instancer);
+    const scope: Scope = new Map();
+    check.lets.forEach((definition) =>
+      scope.set(definition.name, { kind: "Let", definition, scope }),
+    );
+    const declarations = [
+      ...instancee.constants.map((constant) => ({ ...constant, maximumLevel: 0 })),
+      ...instancee.variables.map((variable) => ({ name: variable, arity: 0, maximumLevel: 1 })),
+    ];
+    const substituted = declarations.flatMap((declaration): Substituted[] => {
+      const expression = check.substitutions.get(declaration.name);
+      if (!expression) return [];
+      if (declaration.arity === 0) {
+        const data = analyzer.analyze(expression, scope);
+        return [{ ...declaration, level: data.level, operator: undefined, isLeibniz: true }];
+      }
+      const operand = analyzer.toOperand(expression, scope);
+      return [
+        {
+          ...declaration,
+          level: operand.data.level,
+          operator: operand.operator,
+          isLeibniz: operand.operator === undefined || operand.operator.nonLeibniz.size === 0,
+        },
+      ];
+    });
+    const getLevelMessage = (name: string, level: number) =>
+      `Level error in instantiating module '${check.module}': the level of the expression or operator substituted for '${name}' must be at most ${level}`;
+    substituted.forEach((item) => {
+      if (!levels.isConstant && item.level > item.maximumLevel) {
+        addMessage(getLevelMessage(item.name, item.maximumLevel));
+      }
+      if (!item.isLeibniz) {
+        addMessage(
+          `Error in instantiating module '${check.module}': a non-Leibniz operator substituted for '${item.name}'`,
+        );
+      }
+    });
+    substituted.forEach((item) => {
+      const maximum = levels.constraints.get(item.name);
+      if (maximum !== undefined && item.level > maximum)
+        addMessage(getLevelMessage(item.name, maximum));
+      const operator = item.operator;
+      if (!operator) return;
+      Array.from({ length: item.arity }, (_, index) => {
+        const minimum = levels.argConstraints.get(getArgumentKey(item.name, index));
+        if (minimum !== undefined && getMaxLevel(operator, index) < minimum) {
+          addMessage(
+            `Level error in instantiating module '${check.module}': the level of the argument ${index + 1} of the operator ${operator.name} must be at least ${minimum}`,
+          );
+        }
+      });
+    });
+    levels.argParams.forEach((key) => {
+      const parameter = parseArgumentParamKey(key);
+      const operator = substituted.find((item) => item.name === parameter.operator)?.operator;
+      const argument = substituted.find((item) => item.name === parameter.param);
+      if (!operator || !argument) return;
+      const maximum = getMaxLevel(operator, parameter.index);
+      if (argument.level > maximum) {
+        addMessage(
+          `Level error when instantiating module '${check.module}': the level of the argument ${parameter.index} of the operator ${parameter.operator}' must be at most ${maximum}`,
+        );
+      }
+    });
+  });
+  if (messages.size > 0) throw new TlaSyntaxError([...messages].join("\n"));
+};

package/src/successors.ts

@@ -1,6 +1,9 @@
 import type { Bound, Definition, Expression } from "./ast";
+import { getReadVariables } from "./dependencies";
 import { TlaEvaluationError } from "./errors";
+import { EXIT_STATUS, setExitCode } from "./exit-codes";
 import {
+  describeLocation,
   bindArgument,
   bindDefinitions,
   bindOperatorArguments,
@@ -10,7 +13,10 @@ import {
   expectBoolean,
   forEachBinding,
   getBoundsDomain,
+  getChildren,
   getDefinition,
+  getEnumeratedElements,
+  getReevaluatedDefinitions,
   lookupScope,
   resolveApplyOperator,
   resolveGlobalOperator,
@@ -20,12 +26,13 @@ import {
   type Scope,
   type State,
 } from "./evaluate";
+import { mapChildren } from "./instances";
 import {
   createTuple,
   formatValue,
+  getStreamedElements,
   isElementOf,
   isEnumerable,
-  toFiniteSet,
   valuesEqual,
   type Value,
 } from "./values";
@@ -39,6 +46,7 @@ interface Run {
   environment: Environment;
   isInit: boolean;
   current: Value[] | undefined;
+  isStopped: boolean;
 }
 
 type Continuation = (partial: State, action: string | undefined) => void;
@@ -62,10 +70,7 @@ type Conjunct = { expression: Expression } & (
 const initRunners = new WeakMap<Expression, Runner>();
 const nextRunners = new WeakMap<Expression, Runner>();
 
-const describeLocation = (expression: Expression) =>
-  `line ${expression.location.line}, column ${expression.location.column}`;
-
-const getContext = (run: Run, scope: Scope | undefined, partial: State): Context =>
+const getContext = (run: Run, scope: Scope | undefined, partial: State) =>
   run.isInit
     ? { environment: run.environment, scope, state: partial, next: undefined }
     : { environment: run.environment, scope, state: run.current, next: partial };
@@ -79,7 +84,12 @@ const assign = (partial: State, index: number, value: Value) => {
 const holds = (expression: Expression, context: Context) => {
   const value = evaluate(expression, context);
   if (typeof value === "boolean") return value;
-  return expectBoolean(value, `the action at ${describeLocation(expression)}`);
+  try {
+    return expectBoolean(value, `the action at ${describeLocation(expression)}`);
+  } catch (error) {
+    // TLC fails with an unexpected exception when the next-state relation isn't a boolean.
+    throw context.next === undefined ? error : setExitCode(error, EXIT_STATUS.error);
+  }
 };
 
 const isAssignmentOperator = (operator: string) =>
@@ -188,16 +198,12 @@ const ACTION_KINDS = new Set([
   "FunctionApplication",
 ]);
 
-const isGuard = (expression: Expression, environment: Environment, isInit: boolean): boolean => {
+const isGuard = (expression: Expression, environment: Environment, isInit: boolean) => {
   if (ACTION_KINDS.has(expression.kind)) return false;
   if (expression.kind === "Identifier") {
-    if (
-      environment.variableIndex.has(expression.name) ||
-      environment.constants.has(expression.name)
-    ) {
-      return true;
-    }
-    return false;
+    return (
+      environment.variableIndex.has(expression.name) || environment.constants.has(expression.name)
+    );
   }
   if (expression.kind !== "Apply") return true;
   if (expression.operator === "=>") return false;
@@ -212,6 +218,56 @@ const isGuard = (expression: Expression, environment: Environment, isInit: boole
   return definition === undefined && environment.builtins.has(expression.operator);
 };
 
+const NO_NAMES: ReadonlySet<string> = new Set();
+
+// The local names an expression reads from enclosing scopes, or undefined when it applies a local
+// operator, whose body may assign variables.
+const getReadLocals = (
+  expression: Expression,
+  bound: ReadonlySet<string>,
+): string[] | undefined => {
+  if (isLocallyResolved(expression)) {
+    if (expression.kind !== "Identifier") return undefined;
+    return bound.has(expression.name) ? [] : [expression.name];
+  }
+  const names: string[] = [];
+  const result = { isReadOnly: true };
+  mapChildren(expression, (child, childNames) => {
+    const childLocals = result.isReadOnly
+      ? getReadLocals(child, childNames.length === 0 ? bound : new Set([...bound, ...childNames]))
+      : [];
+    if (childLocals) names.push(...childLocals);
+    else result.isReadOnly = false;
+    return child;
+  });
+  return result.isReadOnly ? names : undefined;
+};
+
+// TLC generates a successor for every disjunct and witness that holds, so an expression only
+// checks like a guard when it has neither.
+const hasBranches = (
+  expression: Expression,
+  environment: Environment,
+  visited: Set<Definition>,
+): boolean => {
+  if (expression.kind === "Or" || expression.kind === "Exists") return true;
+  const name =
+    expression.kind === "Identifier"
+      ? expression.name
+      : expression.kind === "Apply"
+        ? expression.operator
+        : undefined;
+  const definition =
+    name === undefined || isLocallyResolved(expression)
+      ? undefined
+      : getDefinition(name, environment);
+  if (definition && !visited.has(definition)) {
+    visited.add(definition);
+    if (hasBranches(definition.body, environment, visited)) return true;
+  }
+  return getChildren(expression).some((child) => hasBranches(child, environment, visited));
+};
+
 const toConjunct = (
   expression: Expression,
   environment: Environment,
@@ -332,8 +388,8 @@ const compileMembership = (
         `In computing next states, the right side of \\in is not enumerable: ${formatValue(value)} at ${describeLocation(expression)}`,
       );
     }
-    const elements = toFiniteSet(value).elements;
-    for (let position = 0; position < elements.length; position++) {
+    const elements = getStreamedElements(value);
+    for (let position = 0; position < elements.length && !run.isStopped; position++) {
       onComplete(assign(partial, index, elements[position]), action);
     }
   };
@@ -542,6 +598,104 @@ const compileIdentifier = (
   };
 };
 
+// A PlusCal action starts with a guard such as pc[self] = "L1", and a process is a disjunction of
+// its actions. The labels an expression requires of one variable at one bound name let a
+// disjunction skip the operands whose guard is false without evaluating them.
+interface LabelGuard {
+  variable: number;
+  argument: string;
+  labels: Set<string>;
+}
+
+const getLabelGuard = (
+  expression: Expression,
+  environment: Environment,
+  visited: Set<Expression>,
+): LabelGuard | undefined => {
+  if (visited.has(expression)) return undefined;
+  visited.add(expression);
+  if (expression.kind === "And") {
+    const first = expression.operands[0];
+    if (first.kind !== "Apply" || first.operator !== "=" || isLocallyResolved(first)) {
+      return undefined;
+    }
+    const target = first.args[0];
+    const label = first.args[1];
+    if (target.kind !== "FunctionApplication" || label.kind !== "String") return undefined;
+    const argument = target.args.length === 1 ? target.args[0] : undefined;
+    if (argument?.kind !== "Identifier" || !isLocallyResolved(argument)) return undefined;
+    const variable = getStaticVariableIndex(target.function, environment, false);
+    if (variable === undefined) return undefined;
+    return { variable, argument: argument.name, labels: new Set([label.value]) };
+  }
+  if (expression.kind === "Or") {
+    const guards = expression.operands.map((operand) =>
+      getLabelGuard(operand, environment, visited),
+    );
+    const first = guards[0];
+    const isShared = guards.every(
+      (guard) =>
+        guard !== undefined &&
+        guard.variable === first?.variable &&
+        guard.argument === first.argument,
+    );
+    if (!first || !isShared) return undefined;
+    const labels = new Set(guards.flatMap((guard) => [...(guard?.labels ?? [])]));
+    return { variable: first.variable, argument: first.argument, labels };
+  }
+  if (expression.kind !== "Apply" || isLocallyResolved(expression)) return undefined;
+  const closure = resolveGlobalOperator(expression.operator, environment);
+  if (closure?.kind !== "Closure" || closure.scope !== undefined) return undefined;
+  const guard = getLabelGuard(closure.body, environment, visited);
+  const position = closure.params.findIndex(
+    (param) => param.arity === 0 && param.name === guard?.argument,
+  );
+  const argument = expression.args[position];
+  if (!guard || argument?.kind !== "Identifier" || !isLocallyResolved(argument)) {
+    return undefined;
+  }
+  return { variable: guard.variable, argument: argument.name, labels: guard.labels };
+};
+
+const getLabel = (run: Run, scope: Scope | undefined, guard: LabelGuard) => {
+  const binding = lookupScope(scope, guard.argument);
+  const functionValue = run.current?.[guard.variable];
+  if (
+    binding?.kind !== "Value" ||
+    typeof functionValue !== "object" ||
+    functionValue.kind !== "Function"
+  ) {
+    return undefined;
+  }
+  const position = functionValue.domain.indexOf(binding.value);
+  const label = position === -1 ? undefined : functionValue.range[position];
+  return typeof label === "string" ? label : undefined;
+};
+
+const compileDisjunction = (
+  operands: Expression[],
+  environment: Environment,
+  isInit: boolean,
+): Runner => {
+  const runners = operands.map((operand) => getRunner(operand, environment, isInit));
+  const guards = isInit
+    ? []
+    : operands.map((operand) => getLabelGuard(operand, environment, new Set()));
+  const dispatch = guards.find((guard) => guard !== undefined);
+  const labels = guards.map((guard) =>
+    guard?.variable === dispatch?.variable && guard?.argument === dispatch?.argument
+      ? guard?.labels
+      : undefined,
+  );
+  return (run, scope, partial, action, isFixed, onComplete) => {
+    const label = dispatch && getLabel(run, scope, dispatch);
+    for (let index = 0; index < runners.length && !run.isStopped; index++) {
+      if (label !== undefined && labels[index]?.has(label) === false) continue;
+      runners[index](run, scope, partial, action, isFixed, onComplete);
+    }
+  };
+};
+
 const compileAction = (
   expression: Expression,
   environment: Environment,
@@ -551,26 +705,19 @@ const compileAction = (
   switch (expression.kind) {
     case "And":
       return compileConjunction(expression.operands, environment, isInit);
-    case "Or": {
-      const operands = expression.operands.map(child);
-      return (run, scope, partial, action, isFixed, onComplete) => {
-        for (const operand of operands) operand(run, scope, partial, action, isFixed, onComplete);
-      };
-    }
+    case "Or":
+      return compileDisjunction(expression.operands, environment, isInit);
     case "Exists": {
       const body = child(expression.body);
       const bound = expression.bounds[0];
       if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
         const name = bound.pattern.name;
         return (run, scope, partial, action, isFixed, onComplete) => {
-          const set = evaluate(bound.set, getContext(run, scope, partial));
-          if (!isEnumerable(set)) {
-            throw new TlaEvaluationError(
-              `TLC encountered a non-enumerable quantifier bound ${formatValue(set)} at ${describeLocation(bound.set)}`,
-            );
-          }
-          const elements = toFiniteSet(set).elements;
-          for (let index = 0; index < elements.length; index++) {
+          const elements = getEnumeratedElements(
+            evaluate(bound.set, getContext(run, scope, partial)),
+            bound.set,
+          );
+          for (let index = 0; index < elements.length && !run.isStopped; index++) {
             body(
               run,
               bindValue(scope, name, elements[index]),
@@ -585,12 +732,18 @@ const compileAction = (
       return (run, scope, partial, action, isFixed, onComplete) => {
         forEachBinding(expression.bounds, getContext(run, scope, partial), (boundScope) => {
           body(run, boundScope, partial, action, isFixed, onComplete);
-          return false;
+          return run.isStopped;
         });
       };
     }
     case "Forall": {
       const body = child(expression.body);
+      const readLocals =
+        !isInit &&
+        getReadVariables(expression, environment) !== undefined &&
+        !hasBranches(expression.body, environment, new Set())
+          ? getReadLocals(expression, NO_NAMES)
+          : undefined;
       return (run, scope, partial, action, _isFixed, onComplete) => {
         const boundScopes: (Scope | undefined)[] = [];
         forEachBinding(expression.bounds, getContext(run, scope, partial), (boundScope) => {
@@ -598,6 +751,16 @@ const compileAction = (
           return false;
         });
         const scopes = [...boundScopes.slice(0, 1), ...boundScopes.slice(1).reverse()];
+        const isBoundToValues = readLocals?.every(
+          (name) => lookupScope(scope, name)?.kind === "Value",
+        );
+        if (isBoundToValues) {
+          const isSatisfied = scopes.every((boundScope) =>
+            holds(expression.body, getContext(run, boundScope, partial)),
+          );
+          if (isSatisfied) onComplete(partial, action);
+          return;
+        }
         const visit = (index: number, nextPartial: State, nextAction: string | undefined): void => {
           if (index === scopes.length) {
             onComplete(nextPartial, nextAction);
@@ -647,10 +810,11 @@ const compileAction = (
     }
     case "Let": {
       const body = child(expression.body);
+      const reevaluated = getReevaluatedDefinitions(expression.definitions, environment);
       return (run, scope, partial, action, isFixed, onComplete) =>
         body(
           run,
-          bindDefinitions(expression.definitions, getContext(run, scope, partial)),
+          bindDefinitions(expression.definitions, getContext(run, scope, partial), reevaluated),
           partial,
           action,
           isFixed,
@@ -751,7 +915,7 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
   const environment = context.environment;
   const found = { value: false };
   getRunner(expression, environment, false)(
-    { environment, isInit: false, current: state },
+    { environment, isInit: false, current: state, isStopped: false },
     context.scope,
     getEmptyState(environment),
     undefined,
@@ -763,48 +927,99 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
   return found.value;
 };
 
-export const getInitialStates = (expression: Expression, environment: Environment): Value[][] => {
-  const states: Value[][] = [];
-  const run: Run = { environment, isInit: true, current: undefined };
+export const forEachInitialState = (
+  expression: Expression,
+  environment: Environment,
+  onState: (state: Value[]) => boolean,
+  scope?: Scope,
+) => {
+  const run: Run = { environment, isInit: true, current: undefined, isStopped: false };
   getRunner(expression, environment, true)(
     run,
-    undefined,
+    scope,
     getEmptyState(environment),
     undefined,
     false,
     (partial) => {
+      if (run.isStopped) return;
       if (!isComplete(partial)) {
-        throw new TlaEvaluationError(
-          `The initial predicate does not assign ${getMissingVariables(partial, environment).join(", ")}`,
+        // TLC reports an initial state that isn't completely specified as an illegal state, not as
+        // an evaluation failure.
+        throw setExitCode(
+          new TlaEvaluationError(
+            `The initial predicate does not assign ${getMissingVariables(partial, environment).join(", ")}`,
+          ),
+          EXIT_STATUS.error,
         );
       }
-      states.push(partial);
+      run.isStopped = onState(partial);
+    },
+  );
+};
+
+export const getInitialStates = (
+  expression: Expression,
+  environment: Environment,
+  scope?: Scope,
+): Value[][] => {
+  const states: Value[][] = [];
+  forEachInitialState(
+    expression,
+    environment,
+    (state) => {
+      states.push(state);
+      return false;
     },
+    scope,
   );
   return states;
 };
 
-export const getSuccessors = (
+export const forEachSuccessor = (
   expression: Expression,
   state: Value[],
   environment: Environment,
-): Successor[] => {
-  const successors: Successor[] = [];
-  const run: Run = { environment, isInit: false, current: state };
+  onSuccessor: (successor: Successor) => boolean,
+  scope?: Scope,
+) => {
+  const run: Run = { environment, isInit: false, current: state, isStopped: false };
+  const counter = { successors: 0 };
   getRunner(expression, environment, false)(
     run,
-    undefined,
+    scope,
     getEmptyState(environment),
     undefined,
     false,
     (partial, action) => {
+      if (run.isStopped) return;
       if (!isComplete(partial)) {
         throw new TlaEvaluationError(
           `Successor state is not completely specified by action ${action ?? "Next"}. The following variables are not assigned: ${getMissingVariables(partial, environment).join(", ")}`,
         );
       }
-      successors.push({ state: partial, action });
+      counter.successors++;
+      run.isStopped = onSuccessor({ state: partial, action });
+    },
+  );
+  return counter.successors;
+};
+
+export const getSuccessors = (
+  expression: Expression,
+  state: Value[],
+  environment: Environment,
+  scope?: Scope,
+): Successor[] => {
+  const successors: Successor[] = [];
+  forEachSuccessor(
+    expression,
+    state,
+    environment,
+    (successor) => {
+      successors.push(successor);
+      return false;
     },
+    scope,
   );
   return successors;
 };