lawspec 0.7.0 → 0.9.0

package/index.d.ts

@@ -1,29 +1,248 @@
 // Generated from LawSpec.Gen. Do not edit.
-export type Target = 'java' | 'python' | 'javascript' | 'typescript' | 'go' | 'haskell' | 'kotlin';
-export interface Source { path: string; content: string }
-export interface Location { file: string; line: number; column: number }
-export interface Diagnostic { code: string; message: string; at: Location | null }
-export interface Artifact { path: string; content: string; ownership: 'user' | 'generated'; placement: 'source' | 'test' }
-export type Type = {tag: 'Named' | 'Variable'; contents: string} | {tag: 'Arrow'; contents: [Type, Type]} | {tag: 'Applied'; contents: ['Nullable' | 'Optional', Type]} | {tag:'Refined'; contents:[string, Type, Expr | null]} | {tag:'Qualified'; contents:[Constraint[],Type]} | {tag:'CheckedType'; contents:[Expr[],Type]} | {tag:'RefinementApp'; contents:[string,RefinementArgument[]]};
-export interface Constraint {tag:'Capability'; contents:['Eq'|'Integer'|'Ordered'|'Bounded',Type]}
-export type RefinementArgument = {tag:'TypeArgument'; contents:Type} | {tag:'ValueArgument'; contents:Expr};
-export interface Refinement {refinementName:string; refinementParameters:[string,Type][]; refinementRequirements:Constraint[]; refinementBody:Type}
-export interface Contract {contractName:string; contractArguments:[string,Type][]; contractResult:[string,Type]; contractPreconditions:Expr[]; contractPostconditions:Expr[]}
-export interface Generation {cases:number; maxAttempts:number; maxShrinks:number; exhaustiveLimit:number}
-export interface Input {inputName:string; inputId:string; inputType:Type; inputRefinements:Expr[]}
-export interface DomainPlan {domainInput:Input; domainBounds:[string,Expr][]}
-export type IntegerType = 'Int8' | 'Int16' | 'Int32' | 'Int64' | 'UInt8' | 'UInt16' | 'UInt32' | 'UInt64' | 'IntSize' | 'UIntSize' | 'UIntPtr' | 'Integer' | 'BigInt' | 'BigUInt';
-export type ScalarValue = {type: IntegerType; value: string} | {type: 'Bool'; value: boolean} | {type: 'Decimal'; coefficient: string; exponent: string} | {type: 'Rational'; numerator: string; denominator: string} | {type: 'Float32' | 'Float64'; bits: string} | {type: 'Complex64' | 'Complex128'; real: ScalarValue; imaginary: ScalarValue} | {type: 'Char' | 'CodePoint' | 'CodeUnit16'; value: number} | {type: 'Text' | 'CodePointText' | 'Utf16Text' | 'Bytes'; units: number[]} | {type: 'Symbol'; id: string; description: string} | {type: 'Unit' | 'Null' | 'Undefined'} | {type: 'Nullable' | 'Optional'; value: ScalarValue | null};
-export type Expr = {tag: 'Var' | 'StringLit'; contents: string} | {tag: 'Number'; contents: string} | {tag: 'DecimalNumber'; contents: [string, string]} | {tag: 'BoolLit'; contents: boolean} | {tag: 'Apply' | 'Compose'; contents: [Expr, Expr]} | {tag: 'ScalarLit'; contents: ScalarValue} | {tag: 'Annotate'; contents: [Expr, Type]} | {tag: 'Unary'; contents: [string, Expr]} | {tag: 'Binary'; contents: [string, Expr, Expr]} | {tag:'TypeBound'; contents:['min'|'max',Type]};
-export type Definition = {tag: 'Forall'; contents: [[string, Type][], Definition]} | {tag: 'Equal'; contents: [Expr, Expr]} | {tag: 'Holds'; contents: Expr} | {tag: 'Implies'; contents: [Expr, Definition]} | {tag: 'And'; contents: [Definition, Definition]} | {tag: 'Invoke'; contents: [string, Expr[]]};
-export interface Expectation { actual: Expr; expected: ScalarValue }
-export interface Example { exampleName: string; bindings: [string, ScalarValue][]; expectations: Expectation[] }
-export interface Law { lawName: string; parameters: [string, Type][]; requirements: Constraint[]; definition: Definition; description: string; rationale: string; examples: Example[]; references: string[]; location: Location }
-export type Assertion = {tag: 'AssertEqual'; contents: [Expr, Expr]} | {tag: 'AssertImplies'; contents: [Expr, Assertion]} | {tag: 'AssertAll'; contents: Assertion[]};
-export interface Expanded { owner: string; name: string; inputs: Input[]; left: Expr; right: Expr; guards: Expr[]; assertion: Assertion; trace: string[]; original: Law; typedExpressions: TypedExpr[]; propertyKind: 'law'|'contract'; generation:Generation; generationPlan:DomainPlan[] }
-export interface TypedExpr { expressionType: Type; expression: Expr; operands: TypedExpr[]; requiredConversion: Type | null }
-export interface CheckRequest { sources: Source[]; schemaVersion?: 2; machineBits?: 32 | 64; generation?:Partial<Generation> }
-export interface GenerationRequest extends CheckRequest { target: Target; sourceDir?: string; testDir?: string }
-export interface Result { schemaVersion: 2; machineBits?: 32 | 64; generation?:Generation; refinements?:{owner:string; declaration:Refinement}[]; contracts?:{owner:string; contract:Contract}[]; diagnostics: Diagnostic[]; laws?: Expanded[]; expansions?: string[]; files?: Artifact[] }
-export interface Compiler { check(input: CheckRequest): Promise<Result>; expand(input: CheckRequest): Promise<Result>; planGeneration(input: GenerationRequest): Promise<Result> }
+export type Target =
+    'java' |
+    'python' |
+    'javascript' |
+    'typescript' |
+    'go' |
+    'haskell' |
+    'kotlin' |
+    'rust';
+
+export interface Source {
+  path: string;
+  content: string;
+}
+
+export interface Location {
+  file: string;
+  line: number;
+  column: number;
+}
+
+export interface Span {
+  start: Location;
+  end: Location;
+}
+
+export interface Diagnostic {
+  code: string;
+  message: string;
+  at: Location | null;
+}
+
+export interface Artifact {
+  path: string;
+  content: string;
+  ownership: 'user' | 'generated';
+  placement: 'source' | 'test';
+  adapterReference?: string;
+}
+
+export type Type =
+    {kind: 'constructor'; name: string; arguments: TypeArgument[];} |
+    {kind: 'variable'; id: string;} |
+    {kind: 'function'; parameter: Type; result: Type;};
+
+export type TypeArgument =
+    {kind: 'type'; type: Type;} |
+    {kind: 'natural'; value: string;} |
+    {kind: 'indexVariable'; id: string;};
+
+export type Origin =
+    {kind: 'source'; span: Span;} | {kind: 'generated'; declaration: string;};
+
+export type Evidence = {kind: 'numeric' | 'structural'; type: Type;};
+
+export interface Expr {
+  type: Type;
+  origin: Origin;
+  text: string;
+  node: ExprNode;
+}
+
+export type ExprNode =
+    {kind: 'constant'; value: ScalarValue;} |
+    {kind: 'match'; value: Expr; cases: MatchCase[];} |
+    {kind: 'allElements'; value: Expr; binder: Binder; predicate: Expr;} |
+    {kind: 'allPayloads'; value: Expr; predicates: PayloadPredicate[];} |
+    {kind: 'construct'; constructor: string; arguments: Expr[];} |
+    {kind: 'local'; id: string;} |
+    {kind: 'call'; declaration: string; arguments: Expr[];} |
+    {
+      kind: 'binary';
+      operator: string;
+      evidence: Evidence;
+      left: Expr;
+      right: Expr;
+    } |
+    {kind: 'unary'; operator: '-' | '!'; argument: Expr;} |
+    {kind: 'shortCircuit'; operator: '&&' | '||'; left: Expr; right: Expr;} |
+    {kind: 'convert'; conversion: 'explicit' | 'checked'; argument: Expr;} |
+    {kind: 'helper'; name: string; arguments: Expr[];};
+
+export type Assertion =
+    {kind: 'equal'; evidence: Evidence; left: Expr; right: Expr;} |
+    {kind: 'implies'; guard: Expr; body: Assertion;} |
+    {kind: 'all'; items: Assertion[];};
+
+export interface Generation {
+  cases: number;
+  maxAttempts: number;
+  maxShrinks: number;
+  exhaustiveLimit: number;
+}
+
+export interface Binder {
+  id: string;
+  name: string;
+  type: Type;
+}
+
+export interface Definition {
+  owner: string;
+  id: string;
+  arguments: Binder[];
+  body: Expr;
+}
+
+export interface Input extends Binder {
+  predicates: Expr[];
+  bounds: {operator: string; value: Expr;}[];
+}
+
+export interface Example {
+  name: string;
+  bindings: (Binder & {value: DataValue;})[];
+  expectations: Assertion[];
+}
+
+export interface Law {
+  id: string;
+  owner: string;
+  name: string;
+  inputs: Input[];
+  assertion: Assertion;
+  examples: Example[];
+  description: string;
+  rationale: string;
+  references: string[];
+  location: Location;
+  trace: string[];
+  generation: Generation;
+}
+
+export interface Unit {
+  id: string;
+  declarations: (Binder & {origin: Origin;})[];
+}
+
+export interface DataTypeDeclaration {
+  id: string;
+  name: string;
+  parameters: string[];
+  origin: Origin;
+  constructors: {id: string; name: string; fields: Binder[]; origin: Origin;}[];
+}
+
+export interface Contract {
+  id: string;
+  name: string;
+  arguments: Binder[];
+  result: Binder;
+  preconditions: Expr[];
+  postconditions: Expr[];
+}
+
+export interface Refinement {
+  owner: string;
+  name: string;
+  parameters: {name: string; kind: 'type' | 'value'; type: string;}[];
+  requirements: {capability: string; type: string;}[];
+  definition: string;
+}
+
+export interface CheckRequest {
+  sources: Source[];
+  schemaVersion?: 3;
+  machineBits?: 32 | 64;
+  generation?: Partial<Generation>;
+}
+
+export interface GenerationRequest extends CheckRequest {
+  target: Target;
+  sourceDir?: string;
+  testDir?: string;
+  minify?: boolean;
+}
+
+export interface Result {
+  schemaVersion: 3;
+  machineBits?: 32 | 64;
+  generation?: Generation;
+  units?: Unit[];
+  dataTypes?: DataTypeDeclaration[];
+  definitions?: Definition[];
+  laws?: Law[];
+  contracts?: {owner: string; contract: Contract;}[];
+  refinements?: Refinement[];
+  diagnostics: Diagnostic[];
+  expansions?: string[];
+  files?: Artifact[];
+}
+
+export interface PayloadPredicate {
+  binder: Binder;
+  predicate: Expr;
+}
+
+export interface MatchCase {
+  constructor: string;
+  binders: Binder[];
+  body: Expr;
+}
+
+export type DataValue =
+    ScalarValue |
+    {kind: 'data'; type: Type; constructor: string; fields: DataValue[];};
+
+export type IntegerType =
+    'Int8' |
+    'Int16' |
+    'Int32' |
+    'Int64' |
+    'UInt8' |
+    'UInt16' |
+    'UInt32' |
+    'UInt64' |
+    'IntSize' |
+    'UIntSize' |
+    'UIntPtr' |
+    'Integer' |
+    'BigInt' |
+    'BigUInt';
+
+export type ScalarValue =
+    {type: IntegerType; value: string;} |
+    {type: 'Bool'; value: boolean;} |
+    {type: 'Decimal'; coefficient: string; exponent: string;} |
+    {type: 'Rational'; numerator: string; denominator: string;} |
+    {type: 'Float32' | 'Float64'; bits: string;} |
+    {
+      type: 'Complex64' | 'Complex128';
+      real: ScalarValue;
+      imaginary: ScalarValue;
+    } |
+    {type: 'Char' | 'CodePoint' | 'CodeUnit16'; value: number;} |
+    {type: 'Text' | 'CodePointText' | 'Utf16Text' | 'Bytes'; units: number[];} |
+    {type: 'Symbol'; id: string; description: string;} |
+    {type: 'Unit' | 'Null' | 'Undefined';} |
+    {type: 'Nullable' | 'Optional'; value: ScalarValue | null;};
+
+export interface Compiler {
+  check(input: CheckRequest): Promise<Result>;
+  expand(input: CheckRequest): Promise<Result>;
+  planGeneration(input: GenerationRequest): Promise<Result>;
+}
+
 export function createCompiler(): Promise<Compiler>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lawspec",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "State the law once. Check it everywhere.",
   "license": "MIT",
   "type": "module",
@@ -8,6 +8,6 @@
   "bin": { "lawspec": "bin/lawspec.mjs" },
   "exports": { ".": { "types": "./index.d.ts", "import": "./api.mjs" } },
   "types": "index.d.ts",
-  "files": ["*.mjs", "*.json", "index.d.ts", "bin", "core.wasm", "core_jsffi.js", "README.md", "PRIMITIVES.md", "REFINEMENTS.md", "API-MIGRATION.md", "LICENSE", "starter.lawspec", "examples"],
+  "files": ["*.mjs", "*.json", "index.d.ts", "bin", "core.wasm", "core_jsffi.js", "README.md", "PRIMITIVES.md", "REFINEMENTS.md", "RUST.md", "JAVA.md", "PYTHON.md", "GO.md", "HASKELL.md", "KOTLIN.md", "WEB.md", "LANGUAGE.md", "API-MIGRATION.md", "RELEASE-0.9.md", "LICENSE", "starter.lawspec", "examples"],
   "scripts": { "test": "node --test test/*.test.mjs" }
 }

package/templates.mjs

@@ -6,8 +6,10 @@ export const targets = [
   "go",
   "haskell",
   "kotlin",
+  "rust",
 ];
 export const commands = {
+  rust: "cargo test",
   java: "mvn test",
   python: "python -m pytest",
   javascript: "node --test test/*.test.mjs",
@@ -18,6 +20,7 @@ export const commands = {
   kotlin: "gradle test",
 };
 export const setup = {
+  rust: "Use Rust 1.85+ with edition 2024, Proptest 1.11.0, num-bigint 0.4.8, num-rational 0.4.2, num-complex 0.4.6, and num-traits 0.2.19. Run cargo test.",
   java: "Use JDK 25+, Maven, JetCheck 0.3.0, JUnit Jupiter 5.14.x, compiler plugin 3.14.1+, Surefire 3.5.x, and maven.compiler.release=25. Run mvn test-compile.",
   python:
     'Use Python 3.13+. Install pytest 8.4.x and Hypothesis 6.x into the selected environment: python -m pip install -e ".[test]". Configure pytest pythonpath=["src"] and testpaths=["tests"]. Set the target python field to the interpreter path if needed.',
@@ -31,8 +34,97 @@ export const setup = {
   kotlin:
     "Use JDK 25, Gradle 9.3.0, Kotlin plugin 2.3.21, JVM target 25, Kotest 5.9.1 (runner, assertions, property), and useJUnitPlatform(). Run gradle testClasses.",
 };
-const json = (value) => JSON.stringify(value, null, 2) + "\n";
-export function templates(target) {
+// These render known scaffold structure; they never reformat user source.
+const element = (name, value, attributes = {}) => ({ name, value, attributes });
+const xmlEscape = (text) =>
+  String(text)
+    .replaceAll("&", "&")
+    .replaceAll('"', """)
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+function renderXml(node, minify, depth = 0) {
+  const indent = minify ? "" : "  ".repeat(depth);
+  const attributes = Object.entries(node.attributes).map(
+    ([key, value]) => `${key}="${xmlEscape(value)}"`,
+  );
+  const open = `<${node.name}${
+    attributes.length === 0
+      ? ""
+      : minify
+        ? " " + attributes.join(" ")
+        : "\n" + attributes.map((a) => indent + "  " + a).join("\n")
+  }>`;
+  if (!Array.isArray(node.value)) {
+    return `${indent}${open}${xmlEscape(node.value)}</${node.name}>`;
+  }
+  const children = node.value.map((child) =>
+    renderXml(child, minify, depth + 1),
+  );
+  return minify
+    ? `${open}${children.join("")}</${node.name}>`
+    : `${indent}${open}\n${children.join("\n")}\n${indent}</${node.name}>`;
+}
+function mavenProject(minify) {
+  const fields = (values) =>
+    Object.entries(values).map(([name, value]) => element(name, value));
+  const dependency = (groupId, artifactId, version) =>
+    element(
+      "dependency",
+      fields({ groupId, artifactId, version, scope: "test" }),
+    );
+  const plugin = (artifactId, version) =>
+    element(
+      "plugin",
+      fields({ groupId: "org.apache.maven.plugins", artifactId, version }),
+    );
+  return (
+    renderXml(
+      element(
+        "project",
+        [
+          ...fields({
+            modelVersion: "4.0.0",
+            groupId: "example",
+            artifactId: "lawspec-example",
+            version: "0.1.0",
+          }),
+          element(
+            "properties",
+            fields({
+              "maven.compiler.release": "25",
+              "project.build.sourceEncoding": "UTF-8",
+            }),
+          ),
+          element("dependencies", [
+            dependency("org.jetbrains", "jetCheck", "0.3.0"),
+            dependency("org.junit.jupiter", "junit-jupiter", "5.14.0"),
+          ]),
+          element("build", [
+            element("plugins", [
+              plugin("maven-compiler-plugin", "3.14.1"),
+              plugin("maven-surefire-plugin", "3.5.4"),
+            ]),
+          ]),
+        ],
+        {
+          xmlns: "http://maven.apache.org/POM/4.0.0",
+          "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+          "xsi:schemaLocation":
+            "http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd",
+        },
+      ),
+      minify,
+    ) + "\n"
+  );
+}
+export function templates(target, { minify = false } = {}) {
+  if (typeof minify !== "boolean") throw new Error("minify must be a boolean");
+  const json = (value) =>
+    JSON.stringify(value, null, minify ? undefined : 2) + "\n";
+  const kotlinBlock = (name, statements) =>
+    minify
+      ? `${name} { ${statements.join("; ")} }`
+      : `${name} {\n${statements.map((line) => "    " + line).join("\n")}\n}`;
   if (!targets.includes(target)) throw new Error(`Unknown target: ${target}`);
   const commonPackage = {
     name: "lawspec-example",
@@ -41,6 +133,28 @@ export function templates(target) {
     type: "module",
   };
   switch (target) {
+    case "rust":
+      return {
+        "src/lib.rs":
+          '// Application library. LawSpec maintains the included module declarations.\ninclude!("lawspec_modules.rs");\n',
+        "Cargo.toml": `[package]
+name = "lawspec-example"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.85"
+publish = false
+
+[dependencies]
+num-bigint = "=0.4.8"
+num-rational = "=0.4.2"
+num-complex = "=0.4.6"
+num-traits = "=0.2.19"
+
+[dev-dependencies]
+proptest = "=1.11.0"
+`,
+      };
+
     case "javascript":
       return {
         "package.json": json({
@@ -79,18 +193,7 @@ export function templates(target) {
       };
     case "java":
       return {
-        "pom.xml": `<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion><groupId>example</groupId><artifactId>lawspec-example</artifactId><version>0.1.0</version>
-  <properties><maven.compiler.release>25</maven.compiler.release><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties>
-  <dependencies>
-    <dependency><groupId>org.jetbrains</groupId><artifactId>jetCheck</artifactId><version>0.3.0</version><scope>test</scope></dependency>
-    <dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter</artifactId><version>5.14.0</version><scope>test</scope></dependency>
-  </dependencies>
-  <build><plugins>
-    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.14.1</version></plugin>
-    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-surefire-plugin</artifactId><version>3.5.4</version></plugin>
-  </plugins></build>
-</project>\n`,
+        "pom.xml": mavenProject(minify),
       };
     case "go":
       return {
@@ -100,13 +203,24 @@ export function templates(target) {
     case "haskell":
       return {
         "stack.yaml": "snapshot: lts-24.58\npackages: [.]\n",
-        "package.yaml": `name: lawspec-example\nversion: 0.1.0\ndependencies: [base, text, bytestring]\nlibrary:\n  source-dirs: src\ntests:\n  laws:\n    main: Spec.hs\n    source-dirs: test\n    dependencies: [lawspec-example, hspec, hedgehog, hspec-hedgehog]\n    build-tools: [hspec-discover]\n`,
+        "package.yaml": `name: lawspec-example\nversion: 0.1.0\ndependencies: [base, text, bytestring]\nlibrary:\n  source-dirs: src\ntests:\n  laws:\n    main: Spec.hs\n    source-dirs: test\n    dependencies: [lawspec-example, hspec, hedgehog, hspec-hedgehog, containers, mtl]\n    build-tools: [hspec-discover]\n`,
         "test/Spec.hs": "{-# OPTIONS_GHC -F -pgmF hspec-discover #-}\n",
       };
     case "kotlin":
       return {
         "settings.gradle.kts": 'rootProject.name = "lawspec-example"\n',
-        "build.gradle.kts": `plugins { kotlin("jvm") version "2.3.21" }\nrepositories { mavenCentral() }\nkotlin { jvmToolchain(25) }\ndependencies {\n  testImplementation("io.kotest:kotest-runner-junit5:5.9.1")\n  testImplementation("io.kotest:kotest-assertions-core:5.9.1")\n  testImplementation("io.kotest:kotest-property:5.9.1")\n}\ntasks.test { useJUnitPlatform() }\n`,
+        "build.gradle.kts":
+          [
+            kotlinBlock("plugins", ['kotlin("jvm") version "2.3.21"']),
+            kotlinBlock("repositories", ["mavenCentral()"]),
+            kotlinBlock("kotlin", ["jvmToolchain(25)"]),
+            kotlinBlock("dependencies", [
+              'testImplementation("io.kotest:kotest-runner-junit5:5.9.1")',
+              'testImplementation("io.kotest:kotest-assertions-core:5.9.1")',
+              'testImplementation("io.kotest:kotest-property:5.9.1")',
+            ]),
+            kotlinBlock("tasks.test", ["useJUnitPlatform()"]),
+          ].join(minify ? "\n" : "\n\n") + "\n",
       };
   }
 }