cure-engine 0.1.0

Language-agnostic semantic code simplification engine (patterns, rewrites, passes, fixed point, cost model)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# cure-engine

[![crates.io](https://img.shields.io/crates/v/cure-engine.svg)](https://crates.io/crates/cure-engine)
[![Documentation](https://docs.rs/cure-engine/badge.svg)](https://docs.rs/cure-engine)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/ejfkdev/cure/blob/main/LICENSE)

The language-agnostic core of [cure](https://github.com/ejfkdev/cure): a
semantic-preserving code simplification engine — pattern matching, tree
rewrites, effect analysis, and a fixed-point convergence driver.

This crate knows **nothing about Java**. It operates on any tree whose
language implements the [`Lang`] trait: you provide an arena of nodes with
stable ids, name resolution, and effect queries; the engine provides rule
application, work invalidation, and iteration to a fixed point.

## When to use it standalone

You are building a simplifier / normalizer / deobfuscator for **your own
language or AST** and want the engine machinery (not the Java rules):

- rule dispatch + fixed-point driver (`simplify` — re-runs until no rule
  applies; pings-pongs are bounded)
- edit invalidation: every accepted edit invalidates exactly the affected
  ancestor chains and re-analysis caches
- region event index: use/write/shadow events over stable name keys, with
  binary-search queries for kill-analysis rules (dead stores, dominating-path
  logic lives here)
- cost model: rewrites only apply when they provably reduce node cost
- effect analysis (pure / read / write / opaque) gating every transform

The reference implementation of the trait is
[`cure-java-ast`](https://crates.io/crates/cure-java-ast) (arena AST with
u32 node ids, interned name keys).

## Entry points

```rust
use cure_engine::{Config, Lang, Report, Rule, simplify};

/// Run a rule set over `root` until fixed point.
pub fn simplify<L: Lang>(
    lang: &mut L,
    root: L::Id,
    rules: &[Box<dyn Rule<L>>],
    cfg: &Config,
) -> Report;
```

Rules are pattern → rewrite functions receiving a `RewriteCtx` (node access,
children, effect queries). `Config` toggles individual rules and the
optional/dead-code tiers.

The Java front end lives in the sibling crates — see the
[pipeline example](https://github.com/ejfkdev/cure#usage) in the repository
README:

| Crate | Role |
|---|---|
| [cure-java-ast](https://crates.io/crates/cure-java-ast) | arena AST, `Lang` implementation |
| [cure-java-parser](https://crates.io/crates/cure-java-parser) | fault-tolerant Java parser |
| [cure-java-print](https://crates.io/crates/cure-java-print) | canonical printer/formatter |
| [cure-java-simplify](https://crates.io/crates/cure-java-simplify) | the Java rule pack |

License: MIT. Zero runtime dependencies.