rust-analyzer

diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index ecc8333503..e872585c57 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs

@@ -85,7 +85,9 @@ fn actual_main() -> anyhow::Result<ExitCode> {

flags::RustAnalyzerCmd::UnresolvedReferences(cmd) => cmd.run()?,

flags::RustAnalyzerCmd::Ssr(cmd) => cmd.run()?,

flags::RustAnalyzerCmd::Search(cmd) => cmd.run()?,

- flags::RustAnalyzerCmd::Lsif(cmd) => cmd.run()?,

+ flags::RustAnalyzerCmd::Lsif(cmd) => {

+ cmd.run(&mut std::io::stdout(), Some(project_model::RustLibSource::Discover))?

+ }

flags::RustAnalyzerCmd::Scip(cmd) => cmd.run()?,

flags::RustAnalyzerCmd::RunTests(cmd) => cmd.run()?,

flags::RustAnalyzerCmd::RustcTests(cmd) => cmd.run()?,

diff --git a/crates/rust-analyzer/src/cli/lsif.rs b/crates/rust-analyzer/src/cli/lsif.rs
index ca8acf57bf..33c4f31fbe 100644
--- a/crates/rust-analyzer/src/cli/lsif.rs
+++ b/crates/rust-analyzer/src/cli/lsif.rs

@@ -12,6 +12,7 @@ use load_cargo::{load_workspace, LoadCargoConfig, ProcMacroServerChoice};

use lsp_types::lsif;

use project_model::{CargoConfig, ProjectManifest, ProjectWorkspace, RustLibSource};

use rustc_hash::FxHashMap;

+use stdx::format_to;

use vfs::{AbsPathBuf, Vfs};

use crate::{

@@ -21,7 +22,7 @@ use crate::{

version::version,

};

-struct LsifManager<'a> {

+struct LsifManager<'a, 'w> {

count: i32,

token_map: FxHashMap<TokenId, Id>,

range_map: FxHashMap<FileRange, Id>,

@@ -30,6 +31,7 @@ struct LsifManager<'a> {

analysis: &'a Analysis,

db: &'a RootDatabase,

vfs: &'a Vfs,

+ out: &'w mut dyn std::io::Write,

}

#[derive(Clone, Copy)]

@@ -41,8 +43,13 @@ impl From<Id> for lsp_types::NumberOrString {

}

-impl LsifManager<'_> {

- fn new<'a>(analysis: &'a Analysis, db: &'a RootDatabase, vfs: &'a Vfs) -> LsifManager<'a> {

+impl LsifManager<'_, '_> {

+ fn new<'a, 'w>(

+ analysis: &'a Analysis,

+ db: &'a RootDatabase,

+ vfs: &'a Vfs,

+ out: &'w mut dyn std::io::Write,

+ ) -> LsifManager<'a, 'w> {

LsifManager {

count: 0,

token_map: FxHashMap::default(),

@@ -52,6 +59,7 @@ impl LsifManager<'_> {

analysis,

db,

vfs,

+ out,

}

@@ -70,9 +78,8 @@ impl LsifManager<'_> {

self.add(lsif::Element::Edge(edge))

}

- // FIXME: support file in addition to stdout here

- fn emit(&self, data: &str) {

- println!("{data}");

+ fn emit(&mut self, data: &str) {

+ format_to!(self.out, "{data}\n");

}

fn get_token_id(&mut self, id: TokenId) -> Id {

@@ -272,14 +279,14 @@ impl LsifManager<'_> {

}

impl flags::Lsif {

- pub fn run(self) -> anyhow::Result<()> {

+ pub fn run(

+ self,

+ out: &mut dyn std::io::Write,

+ sysroot: Option<RustLibSource>,

+ ) -> anyhow::Result<()> {

let now = Instant::now();

- let cargo_config = &CargoConfig {

- sysroot: Some(RustLibSource::Discover),

- all_targets: true,

- set_test: true,

- ..Default::default()

- };

+ let cargo_config =

+ &CargoConfig { sysroot, all_targets: true, set_test: true, ..Default::default() };

let no_progress = &|_| ();

let load_cargo_config = LoadCargoConfig {

load_out_dirs_from_check: true,

@@ -308,7 +315,7 @@ impl flags::Lsif {

let si = StaticIndex::compute(&analysis, vendored_libs_config);

- let mut lsif = LsifManager::new(&analysis, db, &vfs);

+ let mut lsif = LsifManager::new(&analysis, db, &vfs, out);

lsif.add_vertex(lsif::Vertex::MetaData(lsif::MetaData {

version: String::from("0.5.0"),

project_root: lsp_types::Url::from_file_path(path).unwrap(),

diff --git a/crates/rust-analyzer/tests/slow-tests/cli.rs b/crates/rust-analyzer/tests/slow-tests/cli.rs
new file mode 100644
index 0000000000..fba5466691
--- /dev/null
+++ b/crates/rust-analyzer/tests/slow-tests/cli.rs

@@ -0,0 +1,131 @@

+use expect_test::expect;

+use test_utils::skip_slow_tests;

+use crate::support::Project;

+// If you choose to change the test fixture here, please inform the ferrocene/needy maintainers by

+// opening an issue at https://github.com/ferrocene/needy as the tool relies on specific token

+// mapping behavior.

+#[test]

+fn lsif_contains_generated_constant() {

+ if skip_slow_tests() {

+ return;

+ }

+ let stdout = Project::with_fixture(

+ r#"

+//- /Cargo.toml

+[package]

+name = "foo"

+version = "0.0.0"

+//- /src/lib.rs

+#![allow(unused)]

+macro_rules! generate_const_from_identifier(

+ ($id:ident) => (

+ const _: () = { const $id: &str = "encoded_data"; };

+ )

+);

+generate_const_from_identifier!(REQ_001);

+mod tests {

+ use super::*;

+ generate_const_from_identifier!(REQ_002);

+"#,

+ )

+ .root("foo")

+ .run_lsif();

+ let n = stdout.find(r#"{"id":2,"#).unwrap();

+ // the first 2 entries contain paths that are not stable

+ let stdout = &stdout[n..];

+ expect![[r#"

+ {"id":2,"type":"vertex","label":"foldingRangeResult","result":[{"startLine":2,"startCharacter":43,"endLine":6,"endCharacter":1},{"startLine":3,"startCharacter":19,"endLine":5,"endCharacter":5},{"startLine":9,"startCharacter":10,"endLine":12,"endCharacter":1}]}

+ {"id":3,"type":"edge","label":"textDocument/foldingRange","inV":2,"outV":1}

+ {"id":4,"type":"vertex","label":"range","start":{"line":0,"character":3},"end":{"line":0,"character":8}}

+ {"id":5,"type":"vertex","label":"resultSet"}

+ {"id":6,"type":"edge","label":"next","inV":5,"outV":4}

+ {"id":7,"type":"vertex","label":"range","start":{"line":2,"character":13},"end":{"line":2,"character":43}}

+ {"id":8,"type":"vertex","label":"resultSet"}

+ {"id":9,"type":"edge","label":"next","inV":8,"outV":7}

+ {"id":10,"type":"vertex","label":"range","start":{"line":8,"character":0},"end":{"line":8,"character":30}}

+ {"id":11,"type":"edge","label":"next","inV":8,"outV":10}

+ {"id":12,"type":"vertex","label":"range","start":{"line":8,"character":32},"end":{"line":8,"character":39}}

+ {"id":13,"type":"vertex","label":"resultSet"}

+ {"id":14,"type":"edge","label":"next","inV":13,"outV":12}

+ {"id":15,"type":"vertex","label":"range","start":{"line":9,"character":4},"end":{"line":9,"character":9}}

+ {"id":16,"type":"vertex","label":"resultSet"}

+ {"id":17,"type":"edge","label":"next","inV":16,"outV":15}

+ {"id":18,"type":"vertex","label":"range","start":{"line":10,"character":8},"end":{"line":10,"character":13}}

+ {"id":19,"type":"vertex","label":"resultSet"}

+ {"id":20,"type":"edge","label":"next","inV":19,"outV":18}

+ {"id":21,"type":"vertex","label":"range","start":{"line":11,"character":4},"end":{"line":11,"character":34}}

+ {"id":22,"type":"edge","label":"next","inV":8,"outV":21}

+ {"id":23,"type":"vertex","label":"range","start":{"line":11,"character":36},"end":{"line":11,"character":43}}

+ {"id":24,"type":"vertex","label":"resultSet"}

+ {"id":25,"type":"edge","label":"next","inV":24,"outV":23}

+ {"id":26,"type":"edge","label":"contains","inVs":[4,7,10,12,15,18,21,23],"outV":1}

+ {"id":27,"type":"vertex","label":"hoverResult","result":{"contents":{"kind":"markdown","value":"\n```rust\n#[allow]\n```\n\n---\n\nValid forms are:\n\n* \\#\\[allow(lint1, lint2, ..., /\\*opt\\*/ reason = \"...\")\\]"}}}

+ {"id":28,"type":"edge","label":"textDocument/hover","inV":27,"outV":5}

+ {"id":29,"type":"vertex","label":"referenceResult"}

+ {"id":30,"type":"edge","label":"textDocument/references","inV":29,"outV":5}

+ {"id":31,"type":"edge","label":"item","document":1,"property":"references","inVs":[4],"outV":29}

+ {"id":32,"type":"vertex","label":"hoverResult","result":{"contents":{"kind":"markdown","value":"\n```rust\nfoo\n```\n\n```rust\nmacro_rules! generate_const_from_identifier\n```"}}}

+ {"id":33,"type":"edge","label":"textDocument/hover","inV":32,"outV":8}

+ {"id":34,"type":"vertex","label":"packageInformation","name":"foo","manager":"cargo","version":"0.0.0"}

+ {"id":35,"type":"vertex","label":"moniker","scheme":"rust-analyzer","identifier":"foo::generate_const_from_identifier","unique":"scheme","kind":"export"}

+ {"id":36,"type":"edge","label":"packageInformation","inV":34,"outV":35}

+ {"id":37,"type":"edge","label":"moniker","inV":35,"outV":8}

+ {"id":38,"type":"vertex","label":"definitionResult"}

+ {"id":39,"type":"edge","label":"item","document":1,"inVs":[7],"outV":38}

+ {"id":40,"type":"edge","label":"textDocument/definition","inV":38,"outV":8}

+ {"id":41,"type":"vertex","label":"referenceResult"}

+ {"id":42,"type":"edge","label":"textDocument/references","inV":41,"outV":8}

+ {"id":43,"type":"edge","label":"item","document":1,"property":"definitions","inVs":[7],"outV":41}

+ {"id":44,"type":"edge","label":"item","document":1,"property":"references","inVs":[10,21],"outV":41}

+ {"id":45,"type":"vertex","label":"hoverResult","result":{"contents":{"kind":"markdown","value":"\n```rust\nfoo\n```\n\n```rust\nconst REQ_001: &str = \"encoded_data\"\n```"}}}

+ {"id":46,"type":"edge","label":"textDocument/hover","inV":45,"outV":13}

+ {"id":47,"type":"vertex","label":"moniker","scheme":"rust-analyzer","identifier":"foo::REQ_001","unique":"scheme","kind":"export"}

+ {"id":48,"type":"edge","label":"packageInformation","inV":34,"outV":47}

+ {"id":49,"type":"edge","label":"moniker","inV":47,"outV":13}

+ {"id":50,"type":"vertex","label":"definitionResult"}

+ {"id":51,"type":"edge","label":"item","document":1,"inVs":[12],"outV":50}

+ {"id":52,"type":"edge","label":"textDocument/definition","inV":50,"outV":13}

+ {"id":53,"type":"vertex","label":"referenceResult"}

+ {"id":54,"type":"edge","label":"textDocument/references","inV":53,"outV":13}

+ {"id":55,"type":"edge","label":"item","document":1,"property":"definitions","inVs":[12],"outV":53}

+ {"id":56,"type":"vertex","label":"hoverResult","result":{"contents":{"kind":"markdown","value":"\n```rust\nfoo\n```\n\n```rust\nmod tests\n```"}}}

+ {"id":57,"type":"edge","label":"textDocument/hover","inV":56,"outV":16}

+ {"id":58,"type":"vertex","label":"moniker","scheme":"rust-analyzer","identifier":"foo::tests","unique":"scheme","kind":"export"}

+ {"id":59,"type":"edge","label":"packageInformation","inV":34,"outV":58}

+ {"id":60,"type":"edge","label":"moniker","inV":58,"outV":16}

+ {"id":61,"type":"vertex","label":"definitionResult"}

+ {"id":62,"type":"edge","label":"item","document":1,"inVs":[15],"outV":61}

+ {"id":63,"type":"edge","label":"textDocument/definition","inV":61,"outV":16}

+ {"id":64,"type":"vertex","label":"referenceResult"}

+ {"id":65,"type":"edge","label":"textDocument/references","inV":64,"outV":16}

+ {"id":66,"type":"edge","label":"item","document":1,"property":"definitions","inVs":[15],"outV":64}

+ {"id":67,"type":"vertex","label":"hoverResult","result":{"contents":{"kind":"markdown","value":"\n```rust\nextern crate foo\n```"}}}

+ {"id":68,"type":"edge","label":"textDocument/hover","inV":67,"outV":19}

+ {"id":69,"type":"vertex","label":"definitionResult"}

+ {"id":70,"type":"vertex","label":"range","start":{"line":0,"character":0},"end":{"line":13,"character":0}}

+ {"id":71,"type":"edge","label":"contains","inVs":[70],"outV":1}

+ {"id":72,"type":"edge","label":"item","document":1,"inVs":[70],"outV":69}

+ {"id":73,"type":"edge","label":"textDocument/definition","inV":69,"outV":19}

+ {"id":74,"type":"vertex","label":"referenceResult"}

+ {"id":75,"type":"edge","label":"textDocument/references","inV":74,"outV":19}

+ {"id":76,"type":"edge","label":"item","document":1,"property":"references","inVs":[18],"outV":74}

+ {"id":77,"type":"vertex","label":"hoverResult","result":{"contents":{"kind":"markdown","value":"\n```rust\nfoo::tests\n```\n\n```rust\nconst REQ_002: &str = \"encoded_data\"\n```"}}}

+ {"id":78,"type":"edge","label":"textDocument/hover","inV":77,"outV":24}

+ {"id":79,"type":"vertex","label":"moniker","scheme":"rust-analyzer","identifier":"foo::tests::REQ_002","unique":"scheme","kind":"export"}

+ {"id":80,"type":"edge","label":"packageInformation","inV":34,"outV":79}

+ {"id":81,"type":"edge","label":"moniker","inV":79,"outV":24}

+ {"id":82,"type":"vertex","label":"definitionResult"}

+ {"id":83,"type":"edge","label":"item","document":1,"inVs":[23],"outV":82}

+ {"id":84,"type":"edge","label":"textDocument/definition","inV":82,"outV":24}

+ {"id":85,"type":"vertex","label":"referenceResult"}

+ {"id":86,"type":"edge","label":"textDocument/references","inV":85,"outV":24}

+ {"id":87,"type":"edge","label":"item","document":1,"property":"definitions","inVs":[23],"outV":85}

+ "#]].assert_eq(stdout);

diff --git a/crates/rust-analyzer/tests/slow-tests/main.rs b/crates/rust-analyzer/tests/slow-tests/main.rs
index 54cd27f4b3..97c76bf8d1 100644
--- a/crates/rust-analyzer/tests/slow-tests/main.rs
+++ b/crates/rust-analyzer/tests/slow-tests/main.rs

@@ -10,6 +10,7 @@

#![allow(clippy::disallowed_types)]

+mod cli;

mod ratoml;

mod support;

mod testdir;

diff --git a/crates/rust-analyzer/tests/slow-tests/support.rs b/crates/rust-analyzer/tests/slow-tests/support.rs
index 18aface632..78572e37a9 100644
--- a/crates/rust-analyzer/tests/slow-tests/support.rs
+++ b/crates/rust-analyzer/tests/slow-tests/support.rs

@@ -6,11 +6,13 @@ use std::{

};

use crossbeam_channel::{after, select, Receiver};

+use itertools::Itertools;

use lsp_server::{Connection, Message, Notification, Request};

use lsp_types::{notification::Exit, request::Shutdown, TextDocumentIdentifier, Url};

use parking_lot::{Mutex, MutexGuard};

use paths::{Utf8Path, Utf8PathBuf};

use rust_analyzer::{

+ cli::flags,

config::{Config, ConfigChange, ConfigErrors},

lsp, main_loop,

};

@@ -84,6 +86,46 @@ impl Project<'_> {

self

}

+ pub(crate) fn run_lsif(self) -> String {

+ let tmp_dir = self.tmp_dir.unwrap_or_else(|| {

+ if self.root_dir_contains_symlink {

+ TestDir::new_symlink()

+ } else {

+ TestDir::new()

+ }

+ });

+ let FixtureWithProjectMeta {

+ fixture,

+ mini_core,

+ proc_macro_names,

+ toolchain,

+ target_data_layout: _,

+ } = FixtureWithProjectMeta::parse(self.fixture);

+ assert!(proc_macro_names.is_empty());

+ assert!(mini_core.is_none());

+ assert!(toolchain.is_none());

+ for entry in fixture {

+ let path = tmp_dir.path().join(&entry.path['/'.len_utf8()..]);

+ fs::create_dir_all(path.parent().unwrap()).unwrap();

+ fs::write(path.as_path(), entry.text.as_bytes()).unwrap();

+ }

+ let tmp_dir_path = AbsPathBuf::assert(tmp_dir.path().to_path_buf());

+ let mut buf = Vec::new();

+ flags::Lsif::run(

+ flags::Lsif {

+ path: tmp_dir_path.join(self.roots.iter().exactly_one().unwrap()).into(),

+ exclude_vendored_libraries: false,

+ },

+ &mut buf,

+ None,

+ )

+ .unwrap();

+ String::from_utf8(buf).unwrap()

+ }

pub(crate) fn server(self) -> Server {

static CONFIG_DIR_LOCK: Mutex<()> = Mutex::new(());

let tmp_dir = self.tmp_dir.unwrap_or_else(|| {