The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
test(lsp): smoke-test everyday code intelligence per language with real servers (#1299)
l0ng-ai1e4eee27c42c
diff --git a/.github/workflows/language-smoke.yml b/.github/workflows/language-smoke.ymlnew file mode 100644index 000000000..0441fecf6--- /dev/null+++ b/.github/workflows/language-smoke.yml@@ -0,0 +1,97 @@+name: Language smoke+# Everyday code intelligence (completion, go to definition, Find Usages, hover, diagnostics+# with a quick fix, an intention, formatting, rename) per language, against the language+# server the app starts by default: crates/ide-host/tests/language_smoke.rs.+on:+ push:+ branches: [main]+ pull_request:+ branches: [main]+ types: [opened, synchronize, reopened]+ paths:+ - "crates/**"+ - "languages/**"+ - "fixtures/**"+ - "Cargo.toml"+ - "Cargo.lock"+ - ".github/workflows/language-smoke.yml"+ workflow_dispatch:++concurrency:+ group: language-smoke-${{ github.ref }}+ cancel-in-progress: true++env:+ CARGO_TERM_COLOR: always+ CARGO_INCREMENTAL: 0+ # Pinned so a server release can't fail an unrelated PR; bump them deliberately.+ VTSLS: 0.3.0+ TYPESCRIPT: 6.0.3+ BASEDPYRIGHT: 1.40.2+ RUFF: 0.17.3+ GOPLS: v0.24.0+ JDTLS: 1.63.0-202610191322+ KOTLIN_LSP: 263.7084.0+ GRADLE: 8.14.3++jobs:+ smoke:+ name: Language smoke (${{ matrix.language }})+ strategy:+ fail-fast: false+ matrix:+ language: [typescript, python, rust, go, java, kotlin]+ runs-on: ubuntu-22.04+ timeout-minutes: 40+ steps:+ - uses: actions/checkout@v4+ - uses: dtolnay/rust-toolchain@stable+ with: { components: "rust-analyzer, rustfmt" }+ # One build cache for every language; main saves it.+ - uses: Swatinem/rust-cache@v2+ with:+ shared-key: language-smoke+ save-if: ${{ github.ref == 'refs/heads/main' && matrix.language == 'rust' }}++ - if: matrix.language == 'typescript'+ uses: actions/setup-node@v4+ with: { node-version: 22 }+ - if: matrix.language == 'typescript'+ run: npm install --global "@vtsls/language-server@$VTSLS" "typescript@$TYPESCRIPT"++ - if: matrix.language == 'python'+ uses: actions/setup-python@v5+ with: { python-version: "3.12" }+ - if: matrix.language == 'python'+ run: pip install "basedpyright==$BASEDPYRIGHT" "ruff==$RUFF"++ - if: matrix.language == 'go'+ uses: actions/setup-go@v5+ with: { go-version: "1.27", cache: false }+ - if: matrix.language == 'go'+ run: go install "golang.org/x/tools/gopls@$GOPLS"++ - if: matrix.language == 'java' || matrix.language == 'kotlin'+ uses: actions/setup-java@v4+ with: { distribution: temurin, java-version: "21" }+ - if: matrix.language == 'java'+ run: |+ mkdir -p "$RUNNER_TEMP/jdtls"+ curl -fsSL "https://download.eclipse.org/jdtls/milestones/${JDTLS%-*}/jdt-language-server-$JDTLS.tar.gz" \+ | tar xz -C "$RUNNER_TEMP/jdtls"+ echo "$RUNNER_TEMP/jdtls/bin" >> "$GITHUB_PATH"++ # The Kotlin fixture has no Gradle wrapper: the server imports it with the Gradle on PATH.+ - if: matrix.language == 'kotlin'+ uses: gradle/actions/setup-gradle@v4+ with: { gradle-version: "${{ env.GRADLE }}" }+ - if: matrix.language == 'kotlin'+ run: |+ mkdir -p "$RUNNER_TEMP/kotlin-lsp" "$RUNNER_TEMP/bin"+ curl -fsSL "https://download.jetbrains.com/language-server/kotlin-server/$KOTLIN_LSP/kotlin-server-$KOTLIN_LSP.tar.gz" \+ | tar xz -C "$RUNNER_TEMP/kotlin-lsp" --strip-components=1+ ln -s "$RUNNER_TEMP/kotlin-lsp/kotlin-lsp.sh" "$RUNNER_TEMP/bin/kotlin-lsp"+ echo "$RUNNER_TEMP/bin" >> "$GITHUB_PATH"++ - run: cargo test --locked -p ide-host --test language_smoke --no-run+ - run: cargo test --locked -p ide-host --test language_smoke -- --ignored --exact ${{ matrix.language }}diff --git a/AGENTS.md b/AGENTS.mdindex 425fbc6e2..689bbba32 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -67,6 +67,8 @@ Shared agent skills live in `.agents/skills/` (`.claude/skills/` links to them):this worktree's running MCP bridges and actual ports.- `pnpm build` — typecheck + bundle frontend.- `cargo nextest run --workspace` (or `cargo test`), `cargo clippy --workspace --all-targets -- -D warnings`, `cargo fmt --all`.+- `cargo test -p ide-host --test language_smoke -- --ignored --exact <language>` — code intelligence+ on `fixtures/` with that language's real server installed (CI: `Language smoke`, pinned versions).- `pnpm test`, `pnpm e2e`, `pnpm lint`, `pnpm format:check`, `pnpm knip`, `pnpm typecheck`,`pnpm gen:bindings`.- `pnpm perf` (UI interaction latency / frames / leaks), `pnpm perf:rust` (criteriondiff --git a/crates/ide-host/tests/language_smoke.rs b/crates/ide-host/tests/language_smoke.rsnew file mode 100644index 000000000..da76a6e62--- /dev/null+++ b/crates/ide-host/tests/language_smoke.rs@@ -0,0 +1,714 @@+//! Language smoke tests: the everyday code intelligence of each language — completion, go to+//! definition, Find Usages, hover, diagnostics with a quick fix, an intention, rename and+//! formatting — on its `fixtures/` project, through the `ops` the app's commands call and the+//! language server the app starts by default.+//!+//! `#[ignore]`d because they need the servers installed. CI's `Language smoke` job installs+//! pinned versions and runs one language per job:+//! `cargo test -p ide-host --test language_smoke -- --ignored --exact <language>`.++use ide_core::{ChangeSet, DocId, IdeEvent, Pos, Range, RequestId, TextChange};+use ide_host::{Host, HostConfig, ops};+use ide_lsp::types::{FormatOptions, GotoKind};+use std::collections::BTreeSet;+use std::future::Future;+use std::path::{Path, PathBuf};+use std::sync::{Arc, Mutex};+use std::time::{Duration, Instant};++const WINDOW: &str = "main";++/// `word` on the first line of `file` that contains `line`.+#[derive(Clone, Copy, Debug)]+struct At {+ file: &'static str,+ line: &'static str,+ word: &'static str,+}++const fn at(file: &'static str, line: &'static str, word: &'static str) -> At {+ At { file, line, word }+}++/// A line typed after the first line of `file` containing `after`.+#[derive(Clone, Copy, Debug)]+struct Typed {+ file: &'static str,+ after: &'static str,+ text: &'static str,+}++const fn typed(file: &'static str, after: &'static str, text: &'static str) -> Typed {+ Typed { file, after, text }+}++/// One language's checklist. Every check names what it looks for, so a failure says which+/// operation broke.+struct Checks {+ fixture: &'static str,+ /// Files written into the project copy before it opens.+ files: &'static [(&'static str, &'static str)],+ /// How long the first answer may take (project import and indexing).+ warm_up: Duration,+ /// Go to definition from the first spot lands on the second.+ definition: (At, At),+ /// Find Usages of the symbol lists usages in these files.+ references: (At, &'static [&'static str]),+ /// Hover shows this text.+ hover: (At, &'static str),+ /// Completion at the end of the typed line offers this item.+ completion: (Typed, &'static str),+ /// The typed line is reported with this diagnostic; the quick fix with this title makes the+ /// file contain the last text.+ quick_fix: QuickFix,+ /// With the word selected, this intention is offered with an edit or command.+ intention: (At, &'static str),+ /// Formatting turns the typed line into the expected one.+ format: (Typed, &'static str),+ indent: Indent,+ /// Renaming the symbol to the new name edits these files.+ rename: (At, &'static str, &'static [&'static str]),+}++#[derive(Clone, Copy, Debug)]+struct QuickFix {+ typed: Typed,+ diagnostic: &'static str,+ title: &'static str,+ result: &'static str,+}++/// The editor's indentation, sent with a format request.+#[derive(Clone, Copy, Debug)]+enum Indent {+ Spaces(u32),+ Tabs,+}++type Events = Arc<Mutex<Vec<IdeEvent>>>;++struct Smoke {+ language: &'static str,+ host: Arc<Host>,+ root: PathBuf,+ events: Events,+ warm_up: Duration,+ _tmp: tempfile::TempDir,+}++fn fixture_dir(name: &str) -> PathBuf {+ Path::new(env!("CARGO_MANIFEST_DIR")).join("../../fixtures").join(name)+}++fn copy_dir(from: &Path, to: &Path) {+ std::fs::create_dir_all(to).unwrap();+ for entry in std::fs::read_dir(from).unwrap() {+ let entry = entry.unwrap();+ let name = entry.file_name();+ if matches!(name.to_str(), Some("node_modules" | "target" | "build" | ".gradle" | ".venv")) {+ continue;+ }+ let target = to.join(&name);+ if entry.file_type().unwrap().is_dir() {+ copy_dir(&entry.path(), &target);+ } else {+ std::fs::copy(entry.path(), target).unwrap();+ }+ }+}++fn utf16_len(s: &str) -> u32 {+ s.encode_utf16().count() as u32+}++/// The 0-based line index and text of the first line containing `needle`.+fn find_line<'a>(text: &'a str, needle: &str, what: &str) -> (u32, &'a str) {+ text.lines()+ .enumerate()+ .find(|(_, l)| l.contains(needle))+ .map(|(i, l)| (i as u32, l))+ .unwrap_or_else(|| panic!("{what}: no line containing {needle:?}"))+}++/// The byte offset of `word` in `line`, not as part of a longer identifier (`parse` in `parser::parse`).+fn find_word(line: &str, word: &str) -> Option<usize> {+ let ident = |c: char| c.is_alphanumeric() || c == '_';+ line.match_indices(word).map(|(i, _)| i).find(|&i| {+ let before = line[..i].chars().next_back();+ let after = line[i + word.len()..].chars().next();+ !(word.starts_with(ident) && before.is_some_and(ident)) && !(word.ends_with(ident) && after.is_some_and(ident))+ })+}++impl Smoke {+ async fn start(language: &'static str, checks: &Checks) -> Self {+ let tmp = tempfile::tempdir().unwrap();+ let root = dunce::canonicalize(tmp.path()).unwrap().join(checks.fixture);+ copy_dir(&fixture_dir(checks.fixture), &root);+ for (path, text) in checks.files {+ let path = root.join(path);+ std::fs::create_dir_all(path.parent().unwrap()).unwrap();+ std::fs::write(path, text).unwrap();+ }+ let events: Events = Arc::default();+ let app = tmp.path().join("app");+ let host = Arc::new(Host::new(HostConfig {+ config_dir: app.join("config"),+ data_dir: app.join("data"),+ local_data_dir: app.join("data"),+ languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),+ syntax: Arc::default(),+ sink_for: Box::new({+ let events = events.clone();+ move |_| {+ let events = events.clone();+ Arc::new(move |e: IdeEvent| events.lock().unwrap().push(e))+ }+ }),+ owner: |w| w,+ runtime: tokio::runtime::Handle::current(),+ project_environment: false,+ }));+ host.trust.decide(&root, true, false).unwrap();+ host.open_project(WINDOW, &root).unwrap();+ Smoke { language, host, root, events, warm_up: checks.warm_up, _tmp: tmp }+ }++ fn fail(&self, check: &str, message: impl std::fmt::Display) -> ! {+ let servers = ops::lsp::lsp_servers(&self.host, WINDOW).unwrap_or_default();+ let servers: Vec<String> = servers.iter().map(|s| format!("{} ({:?})", s.name, s.status)).collect();+ panic!("{} — {check}: {message}\nservers: {servers:?}", self.language)+ }++ /// Retries `f` until it succeeds (servers answer emptily while importing and indexing); on+ /// timeout, fails with its last answer.+ async fn retry<T, D: std::fmt::Debug, F: Future<Output = Result<T, D>>>(+ &self,+ check: &str,+ timeout: Duration,+ mut f: impl FnMut() -> F,+ ) -> T {+ let deadline = Instant::now() + timeout;+ loop {+ let last = match f().await {+ Ok(v) => return v,+ Err(last) => last,+ };+ if Instant::now() > deadline {+ self.fail(check, format_args!("timed out after {timeout:?}; last answer: {last:?}"));+ }+ tokio::time::sleep(Duration::from_millis(500)).await;+ }+ }++ async fn doc(&self, file: &str) -> (DocId, String) {+ let info = ops::doc::open(&self.host, WINDOW, self.root.join(file)).await.unwrap();+ let info = ops::doc::snapshot(&self.host, WINDOW, info.id).await.unwrap();+ (info.id, info.text)+ }++ async fn locate(&self, at: At) -> (DocId, Pos) {+ let (doc, text) = self.doc(at.file).await;+ let (line, content) = find_line(&text, at.line, at.file);+ let col = find_word(content, at.word).unwrap_or_else(|| panic!("{at:?}: word not on the line"));+ (doc, Pos::new(line, utf16_len(&content[..col])))+ }++ async fn word_range(&self, at: At) -> (DocId, Range) {+ let (doc, start) = self.locate(at).await;+ (doc, Range::new(start, Pos::new(start.line, start.col + utf16_len(at.word))))+ }++ /// Types a new line; returns the position at its end and the text before it.+ async fn type_line(&self, t: Typed) -> (DocId, Pos, String) {+ let (doc, text) = self.doc(t.file).await;+ let (line, content) = find_line(&text, t.after, t.file);+ let line_start: usize = text.lines().take(line as usize).map(|l| l.len() + 1).sum();+ let end = utf16_len(&text[..line_start + content.len()]);+ self.replace(doc, end, end, &format!("\n{}", t.text)).await;+ let col = utf16_len(t.text);+ (doc, Pos::new(line + 1, col), text)+ }++ async fn replace(&self, doc: DocId, from: u32, to: u32, insert: &str) {+ let version = ops::doc::snapshot(&self.host, WINDOW, doc).await.unwrap().version;+ let changes = ChangeSet { changes: vec![TextChange { from, to, insert: insert.into() }] };+ ops::doc::edit(&self.host, WINDOW, doc, version, changes).unwrap();+ }++ async fn restore(&self, doc: DocId, text: &str) {+ let current = ops::doc::snapshot(&self.host, WINDOW, doc).await.unwrap().text;+ self.replace(doc, 0, utf16_len(¤t), text).await;+ }++ fn path(&self, file: &str) -> PathBuf {+ self.root.join(file)+ }++ fn files<P: AsRef<Path>>(&self, paths: impl IntoIterator<Item = P>) -> BTreeSet<String> {+ paths+ .into_iter()+ .filter_map(|p| {+ let p = p.as_ref().strip_prefix(&self.root).ok()?;+ Some(p.to_string_lossy().replace('\\', "/"))+ })+ .collect()+ }++ async fn definition(&self, from: At, to: At) {+ let (doc, pos) = self.locate(from).await;+ let (_, target) = self.locate(to).await;+ let want = self.path(to.file);+ self.retry("go to definition", self.warm_up, || async {+ let found = ops::lsp::lsp_goto(&self.host, WINDOW, doc, pos, GotoKind::Definition).await;+ match &found {+ Ok(locs) if locs.iter().any(|l| *l.path == *want && l.range.start.line == target.line) => Ok(()),+ _ => Err(found),+ }+ })+ .await;+ }++ async fn references(&self, of: At, files: &[&str]) {+ let (doc, pos) = self.locate(of).await;+ let want: BTreeSet<String> = files.iter().map(|f| f.to_string()).collect();+ self.retry("find usages", self.warm_up, || async {+ let found = ops::lsp::lsp_references(&self.host, WINDOW, RequestId(1), doc, pos, true, true).await;+ match &found {+ Ok(r) if want.is_subset(&self.files(r.locations.iter().map(|l| l.path.clone()))) => Ok(()),+ _ => Err(found.map(|r| self.files(r.locations.into_iter().map(|l| l.path)))),+ }+ })+ .await;+ }++ async fn hover(&self, over: At, shows: &str) {+ let (doc, pos) = self.locate(over).await;+ self.retry("hover", self.warm_up, || async {+ let found = ops::lsp::lsp_hover(&self.host, WINDOW, RequestId(2), doc, pos).await;+ match &found {+ Ok(Some(h)) if h.contents.value.contains(shows) => Ok(()),+ _ => Err(found.map(|h| h.map(|h| h.contents.value))),+ }+ })+ .await;+ }++ async fn completion(&self, line: Typed, offers: &str) {+ let (doc, pos, before) = self.type_line(line).await;+ let trigger = line.text.ends_with('.').then(|| ".".to_string());+ self.retry("completion", self.warm_up, || async {+ let found = ops::lsp::lsp_completion(&self.host, WINDOW, RequestId(3), doc, pos, trigger.clone()).await;+ match &found {+ Ok(list)+ if list.items.iter().any(|i| i.label == offers || i.filter_text.as_deref() == Some(offers)) =>+ {+ Ok(())+ }+ _ => Err(found.map(|l| l.items.into_iter().take(30).map(|i| i.label).collect::<Vec<_>>())),+ }+ })+ .await;+ self.restore(doc, &before).await;+ }++ async fn diagnostic(&self, file: &str, message: &str) -> Range {+ let path = self.path(file);+ self.retry("diagnostics", self.warm_up, || async {+ let events = self.events.lock().unwrap();+ let latest = events.iter().rev().filter_map(|e| match e {+ IdeEvent::Diagnostics { path: p, items, source } if **p == *path => Some((source, items)),+ _ => None,+ });+ let mut seen = Vec::new();+ for (source, items) in latest {+ if let Some(d) = items.iter().find(|d| d.message.contains(message)) {+ return Ok(d.range);+ }+ seen.push(format!("{source}: {:?}", items.iter().map(|d| &d.message).collect::<Vec<_>>()));+ }+ Err(seen.into_iter().take(4).collect::<Vec<_>>())+ })+ .await+ }++ /// The code actions over `range` (all kinds, as the ⌥⏎ popup asks), the one titled `title`.+ async fn action(&self, check: &str, doc: DocId, range: Range, title: &str) -> ide_lsp::types::CodeAction {+ let action = self+ .retry(check, self.warm_up, || async {+ let found = ops::lsp::lsp_code_actions(&self.host, WINDOW, doc, range, vec![]).await;+ match found.as_ref().ok().and_then(|a| a.iter().find(|a| a.title.contains(title))) {+ Some(action) => Ok(action.clone()),+ None => Err(found.map(|a| a.into_iter().map(|a| a.title).collect::<Vec<_>>())),+ }+ })+ .await;+ if action.edit.is_some() || action.command.is_some() {+ return action;+ }+ ops::lsp::lsp_resolve_code_action(&self.host, WINDOW, doc, action)+ .await+ .unwrap_or_else(|e| self.fail(check, format_args!("resolving {title:?}: {e}")))+ }++ async fn quick_fix(&self, fix: QuickFix) {+ let (doc, _, before) = self.type_line(fix.typed).await;+ assert!(!before.contains(fix.result), "{fix:?}: the file already contains the result");+ let range = self.diagnostic(fix.typed.file, fix.diagnostic).await;+ let action = self.action("quick fix", doc, range, fix.title).await;+ ops::lsp::lsp_execute_code_action(&self.host, WINDOW, RequestId(4), doc, action, vec![])+ .await+ .unwrap_or_else(|e| self.fail("quick fix", format_args!("applying {:?}: {e}", fix.title)));+ self.retry("quick fix", Duration::from_secs(10), || async {+ let text = self.doc(fix.typed.file).await.1;+ if text.contains(fix.result) { Ok(()) } else { Err(text) }+ })+ .await;+ self.restore(doc, &before).await;+ }++ async fn intention(&self, on: At, title: &str) {+ let (doc, range) = self.word_range(on).await;+ let action = self.action("intention", doc, range, title).await;+ let edits = action.edit.as_ref().is_some_and(|e| !e.files.is_empty());+ if !edits && action.command.is_none() {+ self.fail("intention", format_args!("{title:?} has neither an edit nor a command: {action:?}"));+ }+ }++ async fn format(&self, line: Typed, indent: Indent, formatted: &str) {+ let (doc, _, before) = self.type_line(line).await;+ assert!(!before.lines().any(|l| l == formatted), "{line:?}: the file already has {formatted:?}");+ let (tab_size, insert_spaces) = match indent {+ Indent::Spaces(n) => (n, true),+ Indent::Tabs => (4, false),+ };+ let options = FormatOptions { tab_size, insert_spaces, on_save: false, tool: None };+ let text = self+ .retry("format", self.warm_up, || async {+ let edits = ops::lsp::lsp_format(&self.host, WINDOW, doc, None, options.clone()).await;+ let text = self.doc(line.file).await.1;+ let mut document = ide_text::Document::new(&text);+ match &edits {+ Ok(edits) if !edits.is_empty() && document.apply_edits(edits).is_ok() => Ok(document.text()),+ _ => Err(edits),+ }+ })+ .await;+ if !text.lines().any(|l| l == formatted) {+ self.fail("format", format_args!("no line {formatted:?} in:\n{text}"));+ }+ self.restore(doc, &before).await;+ }++ async fn rename(&self, symbol: At, to: &str, files: &[&str]) {+ let (doc, pos) = self.locate(symbol).await;+ let prepared = ops::lsp::lsp_prepare_rename(&self.host, WINDOW, doc, pos).await;+ if !matches!(prepared, Ok(Some(_))) {+ self.fail("rename", format_args!("prepare rename: {prepared:?}"));+ }+ let renamed = ops::lsp::lsp_rename(&self.host, WINDOW, RequestId(5), doc, pos, to.into())+ .await+ .unwrap_or_else(|e| self.fail("rename", e));+ let edited = self.files(renamed.edit.files.iter().filter_map(|f| match f {+ ide_core::FileEdit::Edit { path, .. } => Some(path.clone()),+ _ => None,+ }));+ let want: BTreeSet<String> = files.iter().map(|f| f.to_string()).collect();+ if !want.is_subset(&edited) {+ self.fail("rename", format_args!("edits {edited:?}, expected at least {want:?}: {:?}", renamed.edit));+ }+ let mut before = Vec::new();+ for file in files {+ before.push(self.doc(file).await.1.matches(to).count());+ }+ ops::lsp::apply_workspace_edit(&self.host, WINDOW, renamed.edit)+ .await+ .unwrap_or_else(|e| self.fail("rename", format_args!("applying the edit: {e}")));+ for (file, before) in files.iter().zip(before) {+ if self.doc(file).await.1.matches(to).count() <= before {+ self.fail("rename", format_args!("{file} has no new {to:?} after the rename"));+ }+ }+ }++ async fn run(&self, c: &Checks) {+ self.definition(c.definition.0, c.definition.1).await;+ self.references(c.references.0, c.references.1).await;+ self.hover(c.hover.0, c.hover.1).await;+ self.completion(c.completion.0, c.completion.1).await;+ self.quick_fix(c.quick_fix).await;+ self.intention(c.intention.0, c.intention.1).await;+ self.format(c.format.0, c.indent, c.format.1).await;+ self.rename(c.rename.0, c.rename.1, c.rename.2).await;+ let shutdown = self.host.project(WINDOW).unwrap().lsp.clone();+ let _ = tokio::time::timeout(Duration::from_secs(20), shutdown.shutdown_all()).await;+ }+}++async fn smoke(language: &'static str, checks: Checks) {+ let smoke = Smoke::start(language, &checks).await;+ smoke.run(&checks).await;+}++const TYPESCRIPT: Checks = Checks {+ fixture: "ts-app",+ files: &[],+ warm_up: Duration::from_secs(120),+ definition: (+ at("src/index.ts", "Total: ${formatMoney(total)}", "formatMoney"),+ at("src/money.ts", "export function formatMoney", "formatMoney"),+ ),+ references: (at("src/money.ts", "export function formatMoney", "formatMoney"), &["src/index.ts", "src/money.ts"]),+ hover: (at("src/index.ts", "price: cents(8999)", "cents"), "cents(value: number): Cents"),+ completion: (typed("src/index.ts", "const total = cart.total();", " cart."), "applyDiscount"),+ quick_fix: QuickFix {+ typed: typed("src/index.ts", "const total = cart.total();", " console.log(addMoney(total, total));"),+ diagnostic: "Cannot find name 'addMoney'",+ title: "import from \"./money.ts\"",+ result: "import { addMoney, cents, formatMoney } from \"./money.ts\";",+ },+ intention: (at("src/index.ts", "const total = cart.total();", "cart.total()"), "Extract to constant"),+ format: (+ typed("src/index.ts", "const total = cart.total();", " const shown={total,count:cart.count}"),+ " const shown = { total, count: cart.count }",+ ),+ indent: Indent::Spaces(2),+ rename: (+ // From a usage in another file: the declaration is renamed too, not aliased in the import.+ at("src/index.ts", "Total: ${formatMoney(total)}", "formatMoney"),+ "formatPrice",+ &["src/index.ts", "src/money.ts"],+ ),+};++#[tokio::test(flavor = "multi_thread", worker_threads = 4)]+#[ignore = "language smoke: needs vtsls"]+async fn typescript() {+ smoke("typescript", TYPESCRIPT).await;+}++const PYTHON: Checks = Checks {+ fixture: "python-app",+ // Ruff (lint, quick fixes, formatting) starts in projects configured for it.+ files: &[("ruff.toml", "")],+ warm_up: Duration::from_secs(120),+ definition: (+ at("src/tasks/cli.py", "tasks = TaskList()", "TaskList"),+ at("src/tasks/models.py", "class TaskList:", "TaskList"),+ ),+ references: (+ at("src/tasks/models.py", "class TaskList:", "TaskList"),+ &["src/tasks/cli.py", "src/tasks/models.py"],+ ),+ hover: (at("src/tasks/cli.py", "tasks.add(\"Write release notes\"", "add"), "def add("),+ completion: (typed("src/tasks/cli.py", "tasks = build_demo()", " tasks."), "pending"),+ quick_fix: QuickFix {+ typed: typed("src/tasks/cli.py", "tasks = build_demo()", " print(Task)"),+ diagnostic: "\"Task\" is not defined",+ title: "from .models import Task",+ result: "from .models import Priority, Task, TaskList",+ },+ // basedpyright has no refactorings; Ruff's fixes are the Python intentions.+ intention: (at("src/tasks/models.py", "import os", "os"), "Remove unused import"),+ format: (+ typed("src/tasks/cli.py", "tasks = build_demo()", " shown2 = {'a':1,'b': 2}"),+ " shown2 = {\"a\": 1, \"b\": 2}",+ ),+ indent: Indent::Spaces(4),+ rename: (+ at("src/tasks/models.py", "class TaskList:", "TaskList"),+ "TaskBoard",+ &["src/tasks/cli.py", "src/tasks/models.py"],+ ),+};++#[tokio::test(flavor = "multi_thread", worker_threads = 4)]+#[ignore = "language smoke: needs basedpyright and ruff"]+async fn python() {+ smoke("python", PYTHON).await;+}++const RUST: Checks = Checks {+ fixture: "rust-app",+ files: &[],+ warm_up: Duration::from_secs(180),+ definition: (+ at("src/main.rs", "match parser::parse(SAMPLE)", "parse"),+ at("src/parser.rs", "pub fn parse(text: &str)", "parse"),+ ),+ references: (at("src/parser.rs", "pub fn parse(text: &str)", "parse"), &["src/main.rs", "src/parser.rs"]),+ hover: (at("src/main.rs", "inventory.take(&Sku", "take"), "pub fn take("),+ completion: (typed("src/main.rs", "let mut inventory = Inventory::new();", " inventory."), "low_stock"),+ quick_fix: QuickFix {+ // rust-analyzer's own analysis, pulled as the file changes (no save, no `cargo check`).+ typed: typed(+ "src/main.rs",+ "let mut inventory = Inventory::new();",+ " let _blank = parser::ParseError { line: 1 };",+ ),+ diagnostic: "missing structure fields",+ title: "Fill struct fields",+ result: "ParseError { line: 1, message",+ },+ intention: (at("src/main.rs", "match parser::parse(SAMPLE)", "parser::parse(SAMPLE)"), "Extract into variable"),+ format: (+ typed("src/main.rs", "let mut inventory = Inventory::new();", " let _spaced=( 1,2 );"),+ " let _spaced = (1, 2);",+ ),+ indent: Indent::Spaces(4),+ rename: (at("src/parser.rs", "pub fn parse(text: &str)", "parse"), "parse_all", &["src/main.rs", "src/parser.rs"]),+};++#[tokio::test(flavor = "multi_thread", worker_threads = 4)]+#[ignore = "language smoke: needs rust-analyzer"]+async fn rust() {+ smoke("rust", RUST).await;+}++const GO: Checks = Checks {+ fixture: "go-app",+ files: &[],+ warm_up: Duration::from_secs(180),+ definition: (+ at("cmd/server/main.go", "s := store.New()", "New"),+ at("internal/store/store.go", "func New() *Store", "New"),+ ),+ references: (+ at("internal/store/store.go", "func New() *Store", "New"),+ &["cmd/server/main.go", "internal/store/store.go"],+ ),+ hover: (+ at("cmd/server/main.go", "writeJSON(w, s.Search(", "Search"),+ "func (s *store.Store) Search(q string) []store.Note",+ ),+ completion: (typed("cmd/server/main.go", "s := store.New()", "\ts."), "Create"),+ quick_fix: QuickFix {+ typed: typed("cmd/server/main.go", "s := store.New()", "\tfmt.Println(s)"),+ diagnostic: "undefined: fmt",+ title: "\"fmt\"",+ result: "\t\"fmt\"",+ },+ intention: (at("cmd/server/main.go", "s := store.New()", "store.New()"), "Extract"),+ format: (typed("cmd/server/main.go", "s := store.New()", "\t_ = []int{1,2}"), "\t_ = []int{1, 2}"),+ indent: Indent::Tabs,+ rename: (+ at("internal/store/store.go", "func New() *Store", "New"),+ "Open",+ &["cmd/server/main.go", "internal/store/store.go"],+ ),+};++#[tokio::test(flavor = "multi_thread", worker_threads = 4)]+#[ignore = "language smoke: needs gopls"]+async fn go() {+ smoke("go", GO).await;+}++const JAVA: Checks = Checks {+ fixture: "java-app",+ files: &[],+ warm_up: Duration::from_secs(300),+ definition: (+ at("src/main/java/com/example/orders/App.java", "book.place(\"alice\", \"Mechanical", "place"),+ at("src/main/java/com/example/orders/OrderBook.java", "public Order place(", "place"),+ ),+ references: (+ at("src/main/java/com/example/orders/OrderBook.java", "public Order place(", "place"),+ &["src/main/java/com/example/orders/App.java", "src/test/java/com/example/orders/OrderBookTest.java"],+ ),+ hover: (+ at("src/main/java/com/example/orders/App.java", "long revenue = book.revenueCents()", "revenueCents"),+ "long com.example.orders.OrderBook.revenueCents()",+ ),+ completion: (+ typed("src/main/java/com/example/orders/App.java", "long revenue = book.revenueCents();", " book."),+ "largest",+ ),+ quick_fix: QuickFix {+ typed: typed(+ "src/main/java/com/example/orders/App.java",+ "long revenue = book.revenueCents();",+ " List<Order> all = book.byCustomer(\"alice\");",+ ),+ diagnostic: "List cannot be resolved to a type",+ title: "Import 'List' (java.util)",+ result: "import java.util.List;",+ },+ intention: (+ at("src/main/java/com/example/orders/App.java", "long revenue = book.revenueCents();", "book.revenueCents()"),+ "Extract to local variable",+ ),+ format: (+ typed(+ "src/main/java/com/example/orders/App.java",+ "long revenue = book.revenueCents();",+ " long doubled=revenue*2;",+ ),+ " long doubled = revenue * 2;",+ ),+ indent: Indent::Spaces(4),+ rename: (+ at("src/main/java/com/example/orders/OrderBook.java", "public Order place(", "place"),+ "submit",+ &["src/main/java/com/example/orders/App.java", "src/main/java/com/example/orders/OrderBook.java"],+ ),+};++#[tokio::test(flavor = "multi_thread", worker_threads = 4)]+#[ignore = "language smoke: needs jdtls and JDK 21"]+async fn java() {+ smoke("java", JAVA).await;+}++const KOTLIN: Checks = Checks {+ fixture: "kotlin-gradle",+ files: &[],+ warm_up: Duration::from_secs(420),+ definition: (+ at("src/main/kotlin/com/example/library/App.kt", "val library = Library()", "Library"),+ at("src/main/kotlin/com/example/library/Library.kt", "class Library(", "Library"),+ ),+ references: (+ at("src/main/kotlin/com/example/library/Library.kt", "fun search(query: String)", "search"),+ &["src/main/kotlin/com/example/library/App.kt", "src/main/kotlin/com/example/library/Library.kt"],+ ),+ hover: (+ at("src/main/kotlin/com/example/library/App.kt", "library.search(\"java\")", "search"),+ "fun search(query: String): List<Book>",+ ),+ completion: (+ typed("src/main/kotlin/com/example/library/App.kt", "val library = Library()", " library."),+ "lend",+ ),+ quick_fix: QuickFix {+ typed: typed(+ "src/main/kotlin/com/example/library/App.kt",+ "val library = Library()",+ " val stamp = LocalDateTime.now()",+ ),+ diagnostic: "Unresolved reference",+ title: "Import",+ result: "import java.time.LocalDateTime",+ },+ intention: (+ at("src/main/kotlin/com/example/library/Library.kt", "fun giveBack(isbn: String): Boolean", "giveBack"),+ "block body",+ ),+ format: (+ typed("src/main/kotlin/com/example/library/App.kt", "val library = Library()", " val pair=listOf(1,2)"),+ " val pair = listOf(1, 2)",+ ),+ indent: Indent::Spaces(4),+ rename: (+ at("src/main/kotlin/com/example/library/Library.kt", "fun search(query: String)", "search"),+ "find",+ &["src/main/kotlin/com/example/library/App.kt", "src/main/kotlin/com/example/library/Library.kt"],+ ),+};++#[tokio::test(flavor = "multi_thread", worker_threads = 4)]+#[ignore = "language smoke: needs kotlin-lsp, a JDK and Gradle"]+async fn kotlin() {+ smoke("kotlin", KOTLIN).await;+}diff --git a/fixtures/README.md b/fixtures/README.mdindex c6c97e175..1966e5825 100644--- a/fixtures/README.md+++ b/fixtures/README.md@@ -12,11 +12,16 @@ something to show.| `python-app/` | Python 3.10+, pytest | `python -m tasks.cli` (from `src/`) | `pytest` | `OPENIDEA_FAIL=1 pytest` | unused imports in `models.py` || `go-app/` | Go 1.22+ | `go run ./cmd/server` | `go test ./...` | `OPENIDEA_FAIL=1 go test ./...` | unused `fmt.Sprintf` result in `internal/store/store.go` || `kotlin-gradle/` | JDK 21, Gradle 8 (no wrapper) | `gradle run` | `gradle test` | `gradle test -PopenideaFail` | unused variable in `App.kt` |+| `java-app/` | JDK 21, Maven 3.9 | `mvn compile exec:java` | `mvn test` | `mvn test -DopenideaFail=true` | unused variable in `App.java` || `polyglot/` | Go, TS, Python, C, shell, SQL, TOML/YAML/JSON, proto, Terraform | `make` | `make test` | — | unused variable in `native/hash.c` |The fixtures are standalone: `rust-app` declares its own `[workspace]` and`fixtures/eslint.config.js` keeps them out of the IDE's own lint run.+The language smoke test (`crates/ide-host/tests/language_smoke.rs`) runs completion,+navigation, diagnostics, quick fixes, formatting and rename on these projects with real+language servers: when you change a fixture, run it for that language.+## SetupWork on a **copy** so git and edits never touch this repository:diff --git a/fixtures/java-app/.gitignore b/fixtures/java-app/.gitignorenew file mode 100644index 000000000..2f7896d1d--- /dev/null+++ b/fixtures/java-app/.gitignore@@ -0,0 +1 @@+target/diff --git a/fixtures/java-app/pom.xml b/fixtures/java-app/pom.xmlnew file mode 100644index 000000000..916e31384--- /dev/null+++ b/fixtures/java-app/pom.xml@@ -0,0 +1,50 @@+<?xml version="1.0" encoding="UTF-8"?>+<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>com.example</groupId>+ <artifactId>openidea-fixture-orders</artifactId>+ <version>0.1.0</version>+ <description>OpenIDEA QA fixture: a tiny order book</description>++ <properties>+ <maven.compiler.release>21</maven.compiler.release>+ <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>+ <!-- `mvn test -DopenideaFail=true` runs the intentionally failing test. -->+ <openideaFail>false</openideaFail>+ </properties>++ <dependencies>+ <dependency>+ <groupId>org.junit.jupiter</groupId>+ <artifactId>junit-jupiter</artifactId>+ <version>5.11.3</version>+ <scope>test</scope>+ </dependency>+ </dependencies>++ <build>+ <plugins>+ <plugin>+ <groupId>org.apache.maven.plugins</groupId>+ <artifactId>maven-surefire-plugin</artifactId>+ <version>3.5.2</version>+ <configuration>+ <systemPropertyVariables>+ <openidea.fail>${openideaFail}</openidea.fail>+ </systemPropertyVariables>+ </configuration>+ </plugin>+ <plugin>+ <groupId>org.codehaus.mojo</groupId>+ <artifactId>exec-maven-plugin</artifactId>+ <version>3.5.0</version>+ <configuration>+ <mainClass>com.example.orders.App</mainClass>+ </configuration>+ </plugin>+ </plugins>+ </build>+</project>diff --git a/fixtures/java-app/src/main/java/com/example/orders/App.java b/fixtures/java-app/src/main/java/com/example/orders/App.javanew file mode 100644index 000000000..80bd50d7e--- /dev/null+++ b/fixtures/java-app/src/main/java/com/example/orders/App.java@@ -0,0 +1,16 @@+package com.example.orders;++public class App {+ public static void main(String[] args) {+ OrderBook book = new OrderBook();+ book.place("alice", "Mechanical keyboard", 1, 8999);+ book.place("bob", "Wireless mouse", 2, 2999);+ book.place("alice", "USB-C hub", 1, 3999);++ int unused = 42; // intentional warning: unused variable+ // Set a breakpoint here (QA: debugger) and inspect `book`.+ long revenue = book.revenueCents();+ System.out.printf("%d orders, revenue %.2f%n", book.size(), revenue / 100.0);+ book.largest().ifPresent(o -> System.out.println("Largest: " + o.product()));+ }+}diff --git a/fixtures/java-app/src/main/java/com/example/orders/Order.java b/fixtures/java-app/src/main/java/com/example/orders/Order.javanew file mode 100644index 000000000..a082b0c49--- /dev/null+++ b/fixtures/java-app/src/main/java/com/example/orders/Order.java@@ -0,0 +1,14 @@+package com.example.orders;++/** A customer order: a product, how many and the unit price in cents. */+public record Order(String customer, String product, int quantity, long unitPriceCents) {++ public Order {+ if (quantity <= 0) throw new IllegalArgumentException("quantity must be positive");+ }++ /** The order's total in cents. */+ public long totalCents() {+ return unitPriceCents * quantity;+ }+}diff --git a/fixtures/java-app/src/main/java/com/example/orders/OrderBook.java b/fixtures/java-app/src/main/java/com/example/orders/OrderBook.javanew file mode 100644index 000000000..079261512--- /dev/null+++ b/fixtures/java-app/src/main/java/com/example/orders/OrderBook.java@@ -0,0 +1,35 @@+package com.example.orders;++import java.util.ArrayList;+import java.util.Comparator;+import java.util.List;+import java.util.Optional;++/** Keeps the orders placed so far, in the order they were placed. */+public class OrderBook {+ private final List<Order> orders = new ArrayList<>();++ /** Places an order and returns it. */+ public Order place(String customer, String product, int quantity, long unitPriceCents) {+ Order order = new Order(customer, product, quantity, unitPriceCents);+ orders.add(order);+ return order;+ }++ public List<Order> byCustomer(String customer) {+ return orders.stream().filter(o -> o.customer().equals(customer)).toList();+ }++ public Optional<Order> largest() {+ return orders.stream().max(Comparator.comparingLong(Order::totalCents));+ }++ // TODO: discounts for repeat customers+ public long revenueCents() {+ return orders.stream().mapToLong(Order::totalCents).sum();+ }++ public int size() {+ return orders.size();+ }+}diff --git a/fixtures/java-app/src/test/java/com/example/orders/OrderBookTest.java b/fixtures/java-app/src/test/java/com/example/orders/OrderBookTest.javanew file mode 100644index 000000000..42b30c2d4--- /dev/null+++ b/fixtures/java-app/src/test/java/com/example/orders/OrderBookTest.java@@ -0,0 +1,29 @@+package com.example.orders;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;++import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.condition.EnabledIfSystemProperty;++class OrderBookTest {+ @Test+ void sumsRevenueOverAllOrders() {+ OrderBook book = new OrderBook();+ book.place("alice", "Keyboard", 2, 1000);+ book.place("bob", "Mouse", 1, 500);+ assertEquals(2500, book.revenueCents());+ assertEquals(1, book.byCustomer("bob").size());+ }++ @Test+ void rejectsEmptyOrders() {+ assertThrows(IllegalArgumentException.class, () -> new Order("alice", "Keyboard", 0, 1000));+ }++ @Test+ @EnabledIfSystemProperty(named = "openidea.fail", matches = "true")+ void intentionallyFails() {+ assertEquals(1, new OrderBook().size(), "QA: an intentionally failing test");+ }+}