nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-12-04 04:39:16 +00:00
Code Issues Packages Projects Releases Wiki Activity
Empowering everyone to build reliable and efficient software.
2,625 Commits 7 Branches 140 Tags 1.9 GiB
Rust 96.1%
RenderScript 0.7%
JavaScript 0.6%
Shell 0.6%
Fluent 0.4%
Other 1.4%
8e4be27086
Go to file
bors[bot] 8e4be27086 Merge #774 
774: Batch crate & command r=matklad a=flodiebold

This adds a new crate, `ra_batch`, which is intended for scenarios where you're loading a workspace once and then running some analyses using the HIR API. Also, it adds a command to `ra_cli` which uses that to type-check all crates in a workspace and print some statistics:

E.g. in rust-analyzer:
```
> $ time target/release/ra_cli analysis-stats
Database loaded, 21 roots
Crates in this dir: 28
Total modules found: 231
Total declarations: 3694
Total functions: 2408
Total expressions: 47017
Expressions of unknown type: 19826 (42%)
Expressions of partially unknown type: 4482 (9%)
target/release/ra_cli analysis-stats  3,23s user 0,60s system 100% cpu 3,821 total
```

Or in rust-lang/rust:
```
> $ time ../opensource/rust-analyzer/target/release/ra_cli analysis-stats
Database loaded, 77 roots
Crates in this dir: 130
Total modules found: 1820
Total declarations: 35038
Total functions: 25914
Total expressions: 753678
Expressions of unknown type: 337975 (44%)
Expressions of partially unknown type: 92314 (12%)
../opensource/rust-analyzer/target/release/ra_cli analysis-stats  13,45s user 2,08s system 100% cpu 15,477 total
```

~This still needs a test. Type-checking all of rust-analyzer sadly takes almost a minute when compiled in debug mode 😅 So I'll need to add something simpler (maybe just looking at a few modules).~

Co-authored-by: Florian Diebold <flodiebold@gmail.com>
2019-02-10 11:42:42 +00:00
.cargo Add cargo jinstall-lsp as a shorthand to include jemalloc support 2019-01-29 17:02:06 +00:00
.vscode Config for raLspServerPath will be overwritten if __RA_LSP_SERVER_DEBUG is set 2019-01-19 15:36:54 +03:00
crates Spell cases explicitly in Ty::walk{_mut} 2019-02-10 12:35:30 +01:00
editors Update dependencies 2019-02-10 10:32:45 +00:00
.gitignore Add .vscode/settings.json to .gitignore 2019-01-19 15:37:25 +03:00
.travis.yml fix verification on CI 2019-01-27 02:30:54 +03:00
ARCHITECTURE.md Add cargo jinstall-lsp as a shorthand to include jemalloc support 2019-01-29 17:02:06 +00:00
bors.toml don't gate on appveyor 2018-10-09 19:06:05 +03:00
Cargo.lock Add an ra_cli command that analyses all crates in the current workspace 2019-02-10 10:56:58 +01:00
Cargo.toml update salsa 2019-01-15 15:06:45 +03:00
CONTRIBUTING.md brush up docs 2018-10-15 01:05:18 +03:00
DEBUGGING.md Removed gif 2019-01-19 15:36:58 +03:00
guide.md add illustrations 2019-01-21 10:27:01 +02:00
LICENSE-APACHE Licenses 2018-01-10 22:47:04 +03:00
LICENSE-MIT Licenses 2018-01-10 22:47:04 +03:00
README.md Go to Implementation for structs and enums 2019-01-29 19:13:02 -05:00
ROADMAP.md don't mention beta channel Rust in ROADMAP 2018-12-28 14:38:27 -08:00
rustfmt.toml enable "small heuristics" 2019-02-08 14:49:26 +03:00

README.md

Rust Analyzer

Build Status

Rust Analyzer is an experimental modular compiler frontend for the Rust language, which aims to lay a foundation for excellent IDE support.

It doesn't implement much of compiler functionality yet, but the white-space preserving Rust parser works, and there are significant chunks of overall architecture (indexing, on-demand & lazy computation, snapshotable world view) in place. Some basic IDE functionality is provided via a language server.

Work on the Rust Analyzer is sponsored by

Ferrous Systems

Quick Start

Rust analyzer builds on Rust >= 1.31.0 and uses the 2018 edition.

# run tests
$ cargo test

# show syntax tree of a Rust file
$ cargo run --package ra_cli parse < crates/ra_syntax/src/lib.rs

# show symbols of a Rust file
$ cargo run --package ra_cli symbols < crates/ra_syntax/src/lib.rs

# install the language server
$ cargo install-lsp
or
$ cargo install --path crates/ra_lsp_server

See these instructions for VS Code setup and the list of features (some of which are VS Code specific).

Debugging

See these instructions on how to debug the vscode extension and the lsp server.

Current Status and Plans

Rust analyzer aims to fill the same niche as the official Rust Language Server, but uses a significantly different architecture. More details can be found in this thread, but the core issue is that RLS works in the "wait until user stops typing, run the build process, save the results of the analysis" mode, which arguably is the wrong foundation for IDE.

Rust Analyzer is an experimental project at the moment, there's exactly zero guarantees that it becomes production-ready one day.

The near/mid term plan is to work independently of the main rustc compiler and implement at least simplistic versions of name resolution, macro expansion and type inference. The purpose is two fold:

  • to quickly bootstrap usable and useful language server: solution that covers 80% of Rust code will be useful for IDEs, and will be vastly simpler than 100% solution.

  • to understand how the consumer-side of compiler API should look like (especially it's on-demand aspects). If you have get_expression_type function, you can write a ton of purely-IDE features on top of it, even if the function is only partially correct. Pluging in the precise function afterwards should just make IDE features more reliable.

The long term plan is to merge with the mainline rustc compiler, probably around the HIR boundary? That is, use rust analyzer for parsing, macro expansion and related bits of name resolution, but leave the rest (including type inference and trait selection) to the existing rustc.

Supported LSP features

General

Workspace

Text Synchronization

Diagnostics

Lanuguage Features

Getting in touch

We have a Discord server dedicated to compilers and language servers implemented in Rust: https://discord.gg/sx3RQZB.

Contributing

See CONTRIBUTING.md and ARCHITECTURE.md

License

Rust analyzer is primarily distributed under the terms of both the MIT license and the Apache License (Version 2.0).

See LICENSE-APACHE and LICENSE-MIT for details.