tla-ts 0.0.1 → 0.0.3-dev.a50fc89

package/src/java-overrides.ts

@@ -0,0 +1,241 @@
+import type { Definition, Expression, Module, SourceLocation } from "./ast";
+import { TlaSyntaxError, TlaUnsupportedError } from "./errors";
+
+interface PoolEntry {
+  tag: number;
+  text: string;
+  value: number;
+  first: number;
+  second: number;
+}
+
+interface JavaMethod {
+  name: string;
+  arity: number;
+  code: Uint8Array | undefined;
+}
+
+interface ObjectReference {
+  className: string;
+  value: Expression | undefined;
+}
+
+type StackItem = number | string | Expression | ObjectReference;
+
+const CLASS_MAGIC = 0xcafebabe;
+const ACCESS_PUBLIC = 0x0001;
+const ACCESS_STATIC = 0x0008;
+const VALUE_PACKAGE = "tlc2/value/impl/";
+
+const createReader = (bytes: Uint8Array) => {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const cursor = { offset: 0 };
+  const advance = (length: number) => {
+    const start = cursor.offset;
+    cursor.offset += length;
+    return start;
+  };
+  return {
+    readUint8: () => view.getUint8(advance(1)),
+    readUint16: () => view.getUint16(advance(2)),
+    readUint32: () => view.getUint32(advance(4)),
+    readInt32: () => view.getInt32(advance(4)),
+    readBytes: (length: number) => bytes.subarray(advance(length), cursor.offset),
+  };
+};
+
+const getParameterCount = (descriptor: string) => {
+  const parameters = descriptor.slice(1, descriptor.indexOf(")"));
+  return [...parameters.matchAll(/\[*(?:L[^;]*;|[BCDFIJSZ])/g)].length;
+};
+
+// The public static methods of a class file and their bytecode, as java.lang.Class lists them.
+const readMethods = (bytes: Uint8Array) => {
+  const reader = createReader(bytes);
+  if (reader.readUint32() !== CLASS_MAGIC)
+    throw new TlaSyntaxError("A module override is not a class file");
+  reader.readUint16();
+  reader.readUint16();
+  const pool: PoolEntry[] = [];
+  const count = reader.readUint16();
+  const decoder = new TextDecoder();
+  for (let index = 1; index < count; index++) {
+    const tag = reader.readUint8();
+    const entry = { tag, text: "", value: 0, first: 0, second: 0 };
+    pool[index] = entry;
+    if (tag === 1) entry.text = decoder.decode(reader.readBytes(reader.readUint16()));
+    else if (tag === 3) entry.value = reader.readInt32();
+    else if (tag === 4) reader.readUint32();
+    else if (tag === 5 || tag === 6) {
+      reader.readBytes(8);
+      index++;
+    } else if (tag === 7 || tag === 8 || tag === 16 || tag === 19 || tag === 20) {
+      entry.first = reader.readUint16();
+    } else if (tag === 15) {
+      reader.readUint8();
+      entry.first = reader.readUint16();
+    } else {
+      entry.first = reader.readUint16();
+      entry.second = reader.readUint16();
+    }
+  }
+  reader.readUint16();
+  reader.readUint16();
+  reader.readUint16();
+  reader.readBytes(reader.readUint16() * 2);
+  for (let fields = reader.readUint16(); fields > 0; fields--) {
+    reader.readBytes(6);
+    for (let attributes = reader.readUint16(); attributes > 0; attributes--) {
+      reader.readUint16();
+      reader.readBytes(reader.readUint32());
+    }
+  }
+  const methods: JavaMethod[] = [];
+  for (let remaining = reader.readUint16(); remaining > 0; remaining--) {
+    const access = reader.readUint16();
+    const name = pool[reader.readUint16()].text;
+    const descriptor = pool[reader.readUint16()].text;
+    const method: JavaMethod = { name, arity: getParameterCount(descriptor), code: undefined };
+    for (let attributes = reader.readUint16(); attributes > 0; attributes--) {
+      const attributeName = pool[reader.readUint16()].text;
+      const attribute = reader.readBytes(reader.readUint32());
+      if (attributeName === "Code") {
+        const length = new DataView(attribute.buffer, attribute.byteOffset + 4, 4).getUint32(0);
+        method.code = attribute.subarray(8, 8 + length);
+      }
+    }
+    const isOverride = (access & ACCESS_PUBLIC) !== 0 && (access & ACCESS_STATIC) !== 0;
+    if (isOverride) methods.push(method);
+  }
+  return { pool, methods };
+};
+
+const getClassName = (pool: PoolEntry[], index: number) => pool[pool[index].first].text;
+
+const getMember = (pool: PoolEntry[], index: number) => {
+  const reference = pool[index];
+  const nameAndType = pool[reference.second];
+  return {
+    className: getClassName(pool, reference.first),
+    name: pool[nameAndType.first].text,
+  };
+};
+
+// Runs the bytecode of an override that returns a constant TLC value, such as
+// BoolValue.ValTrue, IntValue.gen(3), or new StringValue("a"), and returns that value as a
+// literal.
+const getReturnedLiteral = (
+  method: JavaMethod,
+  pool: PoolEntry[],
+  className: string,
+  location: SourceLocation,
+) => {
+  const unsupported = () =>
+    new TlaUnsupportedError(
+      `The Java override ${className}.${method.name} computes its value, which tla-ts cannot run`,
+    );
+  const code = method.code;
+  if (!code) throw unsupported();
+  const stack: StackItem[] = [];
+  const pop = () => {
+    const item = stack.pop();
+    if (item === undefined) throw unsupported();
+    return item;
+  };
+  const getConstant = (index: number) => {
+    const entry = pool[index];
+    if (entry.tag === 3) return entry.value;
+    if (entry.tag === 8) return pool[entry.first].text;
+    throw unsupported();
+  };
+  for (let offset = 0; offset < code.length;) {
+    const opcode = code[offset];
+    const getIndex = () => (code[offset + 1] << 8) | code[offset + 2];
+    if (opcode >= 0x02 && opcode <= 0x08) {
+      stack.push(opcode - 0x03);
+      offset += 1;
+    } else if (opcode === 0x10) {
+      stack.push((code[offset + 1] << 24) >> 24);
+      offset += 2;
+    } else if (opcode === 0x11) {
+      stack.push((getIndex() << 16) >> 16);
+      offset += 3;
+    } else if (opcode === 0x12) {
+      stack.push(getConstant(code[offset + 1]));
+      offset += 2;
+    } else if (opcode === 0x13) {
+      stack.push(getConstant(getIndex()));
+      offset += 3;
+    } else if (opcode === 0x59) {
+      const top = pop();
+      stack.push(top, top);
+      offset += 1;
+    } else if (opcode === 0xb2) {
+      const field = getMember(pool, getIndex());
+      if (field.className !== `${VALUE_PACKAGE}BoolValue`) throw unsupported();
+      if (field.name !== "ValTrue" && field.name !== "ValFalse") throw unsupported();
+      stack.push({
+        kind: "Identifier",
+        name: field.name === "ValTrue" ? "TRUE" : "FALSE",
+        location,
+      });
+      offset += 3;
+    } else if (opcode === 0xb8) {
+      const callee = getMember(pool, getIndex());
+      const value = pop();
+      if (callee.className !== `${VALUE_PACKAGE}IntValue` || callee.name !== "gen") {
+        throw unsupported();
+      }
+      if (typeof value !== "number") throw unsupported();
+      stack.push({ kind: "Number", value, location });
+      offset += 3;
+    } else if (opcode === 0xbb) {
+      stack.push({ className: getClassName(pool, getIndex()), value: undefined });
+      offset += 3;
+    } else if (opcode === 0xb7) {
+      const constructor = getMember(pool, getIndex());
+      const text = pop();
+      const instance = pop();
+      const isStringValue =
+        constructor.className === `${VALUE_PACKAGE}StringValue` &&
+        constructor.name === "<init>" &&
+        typeof text === "string" &&
+        typeof instance === "object" &&
+        "className" in instance;
+      if (!isStringValue) throw unsupported();
+      instance.value = { kind: "String", value: text, location };
+      offset += 3;
+    } else if (opcode === 0xb0) {
+      const returned = pop();
+      if (typeof returned !== "object") throw unsupported();
+      if ("className" in returned) {
+        if (!returned.value) throw unsupported();
+        return returned.value;
+      }
+      return returned;
+    } else {
+      throw unsupported();
+    }
+  }
+  throw unsupported();
+};
+
+// TLC loads a class named after each module and replaces every operator the module defines
+// with the public static method of the same name and arity.
+export const overrideDefinitions = (module: Module, bytes: Uint8Array | undefined): Module => {
+  if (!bytes) return module;
+  const classFile = readMethods(bytes);
+  const definitions = module.definitions.map((definition): Definition => {
+    if (definition.kind !== "Operator") return definition;
+    const method = classFile.methods.find(
+      (candidate) =>
+        candidate.name === definition.name && candidate.arity === definition.params.length,
+    );
+    if (!method) return definition;
+    return {
+      ...definition,
+      body: getReturnedLiteral(method, classFile.pool, module.name, definition.location),
+    };
+  });
+  return { ...module, definitions };
+};

package/src/json.ts

@@ -1,8 +1,12 @@
-import { defineStateOperator, getValue } from "./builtins";
-import { TlaEvaluationError } from "./errors";
+import {
+  createJavaOverrideError,
+  defineStateOperator,
+  getJavaClassName,
+  getValue,
+} from "./builtins";
+import { TlaModuleError } from "./errors";
 import type { Builtin } from "./evaluate";
 import {
-  checkInteger,
   createRecord,
   createTuple,
   formatValue,
@@ -12,6 +16,7 @@ import {
   toFiniteFunction,
   toFiniteSet,
   type Value,
+  rankString,
 } from "./values";
 
 export interface FileSystem {
@@ -19,116 +24,192 @@ export interface FileSystem {
   writeFile: ((path: string, content: string) => void) | undefined;
 }
 
-type JsonValue = boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
+interface ParseContext {
+  source?: string;
+}
+
+const TO_JSON =
+  "public static tlc2.value.impl.StringValue tlc2.module.Json.toJson(tlc2.value.IValue) throws java.io.IOException";
+const TO_JSON_ARRAY =
+  "public static tlc2.value.impl.StringValue tlc2.module.Json.toJsonArray(tlc2.value.IValue) throws java.io.IOException";
+const TO_JSON_OBJECT =
+  "public static tlc2.value.impl.StringValue tlc2.module.Json.toJsonObject(tlc2.value.IValue) throws java.io.IOException";
+const SERIALIZE =
+  "public static synchronized tlc2.value.impl.BoolValue tlc2.module.Json.serialize(tlc2.value.impl.StringValue,tlc2.value.impl.Value) throws java.io.IOException";
+const ND_SERIALIZE =
+  "public static synchronized tlc2.value.impl.BoolValue tlc2.module.Json.ndSerialize(tlc2.value.impl.StringValue,tlc2.value.impl.Value) throws java.io.IOException";
+const DESERIALIZE =
+  "public static tlc2.value.IValue tlc2.module.Json.deserialize(tlc2.value.impl.StringValue) throws java.io.IOException";
+const ND_DESERIALIZE =
+  "public static tlc2.value.IValue tlc2.module.Json.ndDeserialize(tlc2.value.impl.StringValue) throws java.io.IOException";
 
-const toArray = (value: Value): JsonValue[] => {
-  if (isSetValue(value)) return toFiniteSet(value).elements.map(toJson);
-  const elements = getSequenceElements(value);
-  if (elements) return elements.map(toJson);
-  return Object.values(toObject(value));
+const isRecord = (value: Value) => {
+  if (!isFunctionValue(value)) return false;
+  const domain = toFiniteFunction(value).domain;
+  return domain.length > 0 && domain.every((key) => typeof key === "string");
 };
 
-const toObject = (value: Value): { [key: string]: JsonValue } => {
-  if (!isFunctionValue(value)) {
-    throw new TlaEvaluationError(`Cannot convert ${formatValue(value)} to a JSON object`);
-  }
-  const fn = toFiniteFunction(value);
-  return Object.fromEntries(
-    fn.domain.map((key, index): [string, JsonValue] => [
-      typeof key === "string" ? key : formatValue(key),
-      toJson(fn.range[index]),
-    ]),
+const createUnsupportedError = (method: string, value: Value) =>
+  createJavaOverrideError(
+    method,
+    `Cannot convert value: unsupported value type tlc2.value.impl.${getJavaClassName(value)}`,
   );
-};
 
-const toJson = (value: Value): JsonValue => {
-  if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
-    return value;
+const createCastError = (method: string, value: Value) =>
+  createJavaOverrideError(
+    method,
+    `Cannot cast tlc2.value.impl.${getJavaClassName(value)} to tlc2.value.impl.StringValue`,
+  );
+
+const toJsonString = (text: string) =>
+  JSON.stringify(text).replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+
+const toSetJson = (value: Value, method: string) => {
+  if (typeof value === "object" && (value.kind === "InfiniteSet" || value.kind === "SequenceSet")) {
+    throw createUnsupportedError(method, value);
   }
-  if (value.kind === "ModelValue") return value.name;
-  if (isSetValue(value)) return toArray(value);
-  if (getSequenceElements(value)) return toArray(value);
-  return toObject(value);
+  return `[${toFiniteSet(value)
+    .elements.map((element) => toJson(element, method))
+    .join(",")}]`;
+};
+
+const toFunctionJson = (value: Value, method: string) => {
+  const functionValue = toFiniteFunction(value);
+  const elements = getSequenceElements(functionValue);
+  if (elements) return `[${elements.map((element) => toJson(element, method)).join(",")}]`;
+  return `{${functionValue.domain
+    .map(
+      (key, index) =>
+        `${toJsonString(typeof key === "string" ? key : formatValue(key))}:${toJson(functionValue.range[index], method)}`,
+    )
+    .join(",")}}`;
 };
 
-const serialize = (json: JsonValue) =>
-  JSON.stringify(json).replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+const toJson = (value: Value, method: string): string => {
+  if (typeof value === "string") return toJsonString(value);
+  if (typeof value !== "object") return String(value);
+  if (value.kind === "ModelValue") return toJsonString(value.name);
+  if (isSetValue(value)) return toSetJson(value, method);
+  return toFunctionJson(value, method);
+};
+
+const toJsonArray = (value: Value) => {
+  if (isSetValue(value)) return toSetJson(value, TO_JSON_ARRAY);
+  if (!isFunctionValue(value) || isRecord(value))
+    throw createUnsupportedError(TO_JSON_ARRAY, value);
+  return toFunctionJson(value, TO_JSON_ARRAY);
+};
+
+const toJsonObject = (value: Value) => {
+  if (!isFunctionValue(value)) throw createUnsupportedError(TO_JSON_OBJECT, value);
+  return toFunctionJson(value, TO_JSON_OBJECT);
+};
 
-const fromJson = (json: unknown): Value => {
-  if (typeof json === "boolean" || typeof json === "string") return json;
-  if (typeof json === "number") return checkInteger(Math.trunc(json));
-  if (Array.isArray(json)) return createTuple(json.map(fromJson));
+// TLC reads a JSON number with Gson's intValue, which truncates the exact decimal toward zero and
+// keeps its low 32 bits, so 3000000000 becomes -1294967296 and 1.5 becomes 1.
+const toInteger = (source: string) => {
+  const [, sign, whole = "0", fraction = "", exponent = "0"] =
+    /^(-?)(\d+)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/.exec(source) ?? [];
+  const digits = BigInt(whole + fraction);
+  const shift = Number(exponent) - fraction.length;
+  const magnitude = shift >= 0 ? digits * 10n ** BigInt(shift) : digits / 10n ** BigInt(-shift);
+  return Number(BigInt.asIntN(32, sign === "-" ? -magnitude : magnitude));
+};
+
+const fromJson = (json: unknown, method: string): Value => {
+  if (typeof json === "boolean" || typeof json === "number") return json;
+  if (typeof json === "string") return rankString(json);
+  if (Array.isArray(json)) return createTuple(json.map((element) => fromJson(element, method)));
   if (json !== null && typeof json === "object") {
     return createRecord(
-      Object.entries(json).map(([key, field]): [string, Value] => [key, fromJson(field)]),
+      Object.entries(json).map(([key, field]): [string, Value] => [
+        rankString(key),
+        fromJson(field, method),
+      ]),
     );
   }
-  throw new TlaEvaluationError(`Cannot convert value: unsupported JSON value ${String(json)}`);
-};
-
-const getPath = (value: Value, name: string) => {
-  if (typeof value !== "string") {
-    throw new TlaEvaluationError(`${name} expects a file name but received ${formatValue(value)}`);
-  }
-  return value;
+  throw createJavaOverrideError(
+    method,
+    `Cannot convert value: unsupported JSON value ${String(json)}`,
+  );
 };
 
-const parseJson = (text: string): unknown => {
+const parseJson = (text: string, method: string) => {
+  if (text.trim() === "") return fromJson(null, method);
   try {
-    return JSON.parse(text);
+    return fromJson(
+      JSON.parse(text, (_, value: unknown, context?: ParseContext) =>
+        typeof value === "number" ? toInteger(context?.source ?? String(value)) : value,
+      ),
+      method,
+    );
   } catch (error) {
-    throw new TlaEvaluationError(`Cannot parse JSON: ${text}`, error);
+    if (!(error instanceof SyntaxError)) throw error;
+    throw createJavaOverrideError(method, error.message);
   }
 };
 
-const readText = (files: FileSystem, path: string) => {
+const getPath = (value: Value, method: string) => {
+  if (typeof value !== "string") throw createCastError(method, value);
+  return value;
+};
+
+const readText = (files: FileSystem, path: string, method: string) => {
   const text = files.readFile?.(path);
-  if (text === undefined) throw new TlaEvaluationError(`Cannot read the file ${path}`);
+  if (text === undefined) {
+    throw createJavaOverrideError(method, `${path} (No such file or directory)`);
+  }
   return text;
 };
 
 export const createJsonOperators = (files: FileSystem): Builtin[] => [
-  defineStateOperator("ToJson", 1, (args) => serialize(toJson(getValue(args, 0, "ToJson")))),
+  defineStateOperator("ToJson", 1, (args) =>
+    rankString(toJson(getValue(args, 0, "ToJson"), TO_JSON)),
+  ),
   defineStateOperator("ToJsonArray", 1, (args) =>
-    serialize(toArray(getValue(args, 0, "ToJsonArray"))),
+    rankString(toJsonArray(getValue(args, 0, "ToJsonArray"))),
+  ),
+  defineStateOperator("ToJsonObject", 1, (args) =>
+    rankString(toJsonObject(getValue(args, 0, "ToJsonObject"))),
   ),
-  defineStateOperator("ToJsonObject", 1, (args) => {
-    const value = getValue(args, 0, "ToJsonObject");
-    return serialize(getSequenceElements(value) ? toArray(value) : toObject(value));
-  }),
   defineStateOperator("JsonSerialize", 2, (args) => {
-    files.writeFile?.(
-      getPath(getValue(args, 0, "JsonSerialize"), "JsonSerialize"),
-      serialize(toJson(getValue(args, 1, "JsonSerialize"))),
-    );
+    const path = getPath(getValue(args, 0, "JsonSerialize"), SERIALIZE);
+    const value = getValue(args, 1, "JsonSerialize");
+    if (!getSequenceElements(value) && !isRecord(value)) {
+      throw new TlaModuleError(
+        `The second argument of JsonSerialize should be a sequence or record, but instead it is:\n${formatValue(value)}`,
+      );
+    }
+    files.writeFile?.(path, toJson(value, SERIALIZE));
     return true;
   }),
   defineStateOperator("ndJsonSerialize", 2, (args) => {
+    const path = getPath(getValue(args, 0, "ndJsonSerialize"), ND_SERIALIZE);
     const value = getValue(args, 1, "ndJsonSerialize");
     const elements = getSequenceElements(value);
     if (!elements) {
-      throw new TlaEvaluationError(
+      throw new TlaModuleError(
         `The second argument of ndJsonSerialize should be a sequence, but instead it is:\n${formatValue(value)}`,
       );
     }
     files.writeFile?.(
-      getPath(getValue(args, 0, "ndJsonSerialize"), "ndJsonSerialize"),
-      elements.map((element) => `${serialize(toJson(element))}\n`).join(""),
+      path,
+      elements.map((element) => `${toJson(element, ND_SERIALIZE)}\n`).join(""),
     );
     return true;
   }),
-  defineStateOperator("JsonDeserialize", 1, (args) =>
-    fromJson(
-      parseJson(readText(files, getPath(getValue(args, 0, "JsonDeserialize"), "JsonDeserialize"))),
-    ),
-  ),
-  defineStateOperator("ndJsonDeserialize", 1, (args) =>
-    createTuple(
-      readText(files, getPath(getValue(args, 0, "ndJsonDeserialize"), "ndJsonDeserialize"))
-        .split("\n")
+  defineStateOperator("JsonDeserialize", 1, (args) => {
+    const path = getPath(getValue(args, 0, "JsonDeserialize"), DESERIALIZE);
+    return parseJson(readText(files, path, DESERIALIZE), DESERIALIZE);
+  }),
+  defineStateOperator("ndJsonDeserialize", 1, (args) => {
+    const path = getPath(getValue(args, 0, "ndJsonDeserialize"), ND_DESERIALIZE);
+    return createTuple(
+      readText(files, path, ND_DESERIALIZE)
+        .split(/\r\n|\r|\n/)
         .map((line) => line.trim())
         .filter((line) => line !== "")
-        .map((line) => fromJson(parseJson(line))),
-    ),
-  ),
+        .map((line) => parseJson(line, ND_DESERIALIZE)),
+    );
+  }),
 ];