luau-analyzer-sys 0.1.0

A high-performance, embedded Luau type-checking and analysis engine written in Rust. This crate provides bindings to the Luau analyzer, allowing you to integrate static analysis and code intelligence directly into your applications.
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
65
66
67

# luau-analyzer-sys


High-level ergonomic Rust bindings and low-level C++ FFI bindings for the native [Luau](https://luau.org/) static type analyzer and compiler frontend.

![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
![Rust](https://img.shields.io/badge/rust-1.70%2B-orange.svg)

## Overview


`luau-analyzer-sys` provides a bridge between Rust and Luau's C++ static type checking engine (`Luau::Frontend`). It abstracts away internal type resolution scopes, AST traversal checks, and linting routines into a safe, easy-to-use Rust interface (`NativeAnalyzer`).

### Key Features


- **Embedded Type Analysis**: Perform zero-overhead static checking of Luau codebases directly from Rust.
- **Custom Definitions**: Inject global environment mapping definitions dynamically via Luau `.d.luau` files.
- **Dependency Resolution**: Fully recursive module path resolution via safe Rust closures.
- **Granular Diagnostics**: Capture detailed warnings, errors, and lint output complete with source span offsets.
- **Deprecation Linting**: Native static interception of deprecated functions (e.g. `getfenv`) mapped via dynamic line deduplication.

## Usage


Add `luau-analyzer-sys` as a dependency in your `Cargo.toml`:

```toml
[dependencies]
luau-analyzer-sys = { path = "../luau-analyzer-sys" }
```

### Example: Checking a Luau Module


```rust
use luau_analyzer_sys::NativeAnalyzer;

fn main() {
    let mut analyzer = NativeAnalyzer::new();

    // 1. Inject global type definitions
    analyzer.add_definitions(r#"
declare task: {
    spawn: (...any) -> thread
}
"#);

    // 2. Check source code using a recursive string-resolving closure
    let source = "task.spawn(function() print('Checking native type structures') end)";
    let diagnostics = analyzer.check("main.luau", |module_name| {
        if module_name == "main.luau" {
            Some(source.to_string())
        } else {
            None
        }
    });

    if diagnostics.is_empty() {
        println!("Type checking completed successfully with zero errors.");
    } else {
        for diag in diagnostics {
            let severity = if diag.severity == 0 { "error" } else { "warning" };
            println!("{}: {} at line {}:{}", severity, diag.message, diag.line + 1, diag.col + 1);
        }
    }
}
```

## License


This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.