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
feat(php): PHP language level for Intelephense (#1264)
Daniel Adámekf3afe69ca214
diff --git a/crates/ide-core/src/settings.rs b/crates/ide-core/src/settings.rsindex e34941471..e1031c1e6 100644--- a/crates/ide-core/src/settings.rs+++ b/crates/ide-core/src/settings.rs@@ -713,6 +713,9 @@ impl Default for PythonSettings {pub struct PhpSettings {/// `php` CLI executable; empty = the one on `PATH`.pub interpreter: String,+ /// PHP version the language server checks the code against (`7.4`); empty = from+ /// `composer.json` (`config.platform.php`, else the lowest version `require.php` allows).+ pub language_level: String,}#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex 372cb97a6..c0ed65146 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -221,6 +221,8 @@ impl Host {ide_sdk::jdtls::launch_directly(cfg);}ide_sdk::apply::server_protocol_overrides(cfg, &effective);+ // After the overrides: the PHP version they may set decides the storage.+ ide_sdk::php::configure_intelephense_storage(cfg, &data_dir);if cfg.name == "jdtls" {let (excluded_poms, build_files) = jdtls_maven_import(root, &effective);ide_sdk::apply::configure_maven_import(cfg, root, &excluded_poms, build_files.as_deref());@@ -310,6 +312,9 @@ impl Host {kotlin_bridge.files_changed(changed.iter().chain(&batch.removed));lsp.project_files_changed(batch.created.iter().chain(&batch.removed));lsp.watched_files_changed(&batch.created, &batch.modified, &batch.removed, &batch.excluded_dirs);+ if composer_changed(&root, changed.iter().chain(&batch.removed)) {+ lsp.reconfigure_soon();+ }// Atomic saves by external tools surface as `created`.documents.on_disk_changed(&[&changed[..], &ignored].concat());// A framework's root marker (`angular.json`) created or deleted: its@@ -415,7 +420,16 @@ impl Host {let content_watchers = extra_roots.iter().filter_map(|r| {- let w = content_root_watcher(r, &excludes, &sink, &index, &documents, &history, Some(&kotlin_bridge))?;+ let w = content_root_watcher(+ r,+ &excludes,+ &sink,+ &index,+ &documents,+ &history,+ &lsp,+ Some(&kotlin_bridge),+ )?;Some((r.clone(), w))}).collect();@@ -908,6 +922,7 @@ impl Project {&self.index,&self.documents,&self.history,+ &self.lsp,self.kotlin_bridge.as_ref(),) {watchers.push((r, w));@@ -1034,6 +1049,7 @@ impl Project {}}+#[allow(clippy::too_many_arguments)]fn content_root_watcher(dir: &Path,excludes: &[String],@@ -1041,10 +1057,12 @@ fn content_root_watcher(index: &Arc<ProjectIndex>,documents: &Arc<Documents>,history: &Arc<LocalHistory>,+ lsp: &Arc<LspManager>,kotlin_bridge: Option<&Arc<crate::kotlin_bridge::KotlinBridge>>,) -> Option<Watcher> {let kotlin_bridge = kotlin_bridge.cloned();- let (index, documents, history) = (index.clone(), documents.clone(), history.clone());+ let (index, documents, history, lsp) = (index.clone(), documents.clone(), history.clone(), lsp.clone());+ let root = dir.to_path_buf();Watcher::start(dir,excludes.to_vec(),@@ -1053,6 +1071,10 @@ fn content_root_watcher(let changed: Vec<PathBuf> = batch.created.iter().chain(&batch.modified).cloned().collect();let (ignored, ignored_gone) = ignored_changes(batch);index.update(&[&changed[..], &ignored].concat(), &[&batch.removed[..], &ignored_gone].concat());+ // A workspace member's PHP language level follows its own composer.json.+ if composer_changed(&root, changed.iter().chain(&batch.removed)) {+ lsp.reconfigure_soon();+ }if let Some(bridge) = &kotlin_bridge {bridge.files_changed(changed.iter().chain(&batch.removed));}@@ -1064,6 +1086,13 @@ fn content_root_watcher(.ok()}+/// Whether the `composer.json` of `root` is among `paths`: the PHP language level follows it+/// (`ide_sdk::php`).+fn composer_changed<'a>(root: &Path, mut paths: impl Iterator<Item = &'a PathBuf>) -> bool {+ let composer = root.join("composer.json");+ paths.any(|p| *p == composer)+}+/// Where agent tasks create their worktrees: next to the project, `<parent>/<name>.worktrees`,/// so they sit on the project's drive and outside its tree (not indexed, watched or shown in/// its git status); `fallback` for a project at a filesystem root.@@ -1480,3 +1509,21 @@ mod agent_worktree_tests {assert_eq!(agent_worktrees_dir(Path::new("/"), fallback), fallback());}}++#[cfg(test)]+mod composer_tests {+ use super::composer_changed;+ use std::path::{Path, PathBuf};++ #[test]+ fn only_the_roots_own_composer_json_counts() {+ let root = Path::new("/work/app");+ let changed = |paths: &[&str]| {+ let paths: Vec<PathBuf> = paths.iter().map(|p| root.join(p)).collect();+ composer_changed(root, paths.iter())+ };+ assert!(changed(&["src/a.php", "composer.json"]));+ assert!(!changed(&["composer.lock", "vendor/acme/lib/composer.json", "packages/b/composer.json"]));+ assert!(!changed(&[]));+ }+}diff --git a/crates/ide-jsonrpc/src/lib.rs b/crates/ide-jsonrpc/src/lib.rsindex 929fcef30..f78646ce2 100644--- a/crates/ide-jsonrpc/src/lib.rs+++ b/crates/ide-jsonrpc/src/lib.rs@@ -216,6 +216,9 @@ pub trait Handler: Send + Sync + 'static {fn on_request_with_data(&self, method: &str, params: Value) -> Result<Value, (i64, String, Option<Value>)> {self.on_request(method, params).map_err(|(code, message)| (code, message, None))}++ /// Called once the response to a `method` request is queued: what it sends follows the response.+ fn after_response(&self, _method: &str) {}}/// A [`Handler`] that ignores notifications and rejects requests.@@ -755,7 +758,8 @@ enum Incoming {async fn handle_request(inner: Arc<Inner>, handler: Arc<dyn Handler>, id: Value, method: String, params: Value) {let m = method.clone();- let result = tokio::task::spawn_blocking(move || handler.on_request_with_data(&m, params)).await;+ let h = handler.clone();+ let result = tokio::task::spawn_blocking(move || h.on_request_with_data(&m, params)).await;let reply = match result {Ok(Ok(result)) => json!({ "jsonrpc": "2.0", "id": id, "result": result }),Ok(Err((code, message, data))) => {@@ -770,7 +774,9 @@ async fn handle_request(inner: Arc<Inner>, handler: Arc<dyn Handler>, id: Value,"error": { "code": codes::INTERNAL_ERROR, "message": format!("handler for {method} panicked") }}),};- let _ = inner.send_value(&reply);+ if inner.send_value(&reply).is_ok() {+ handler.after_response(&method);+ }}fn dispatch(inner: &Arc<Inner>, notif_tx: &std::sync::mpsc::Sender<Incoming>, body: &[u8]) {diff --git a/crates/ide-jsonrpc/src/tests.rs b/crates/ide-jsonrpc/src/tests.rsindex 0eb57031f..9efee601c 100644--- a/crates/ide-jsonrpc/src/tests.rs+++ b/crates/ide-jsonrpc/src/tests.rs@@ -251,6 +251,34 @@ async fn server_to_client_request() {assert!(matches!(err, RpcError::Server { code: codes::METHOD_NOT_FOUND, .. }));}+#[tokio::test(flavor = "multi_thread")]+async fn after_response_messages_follow_the_response() {+ #[derive(Default)]+ struct Client(std::sync::OnceLock<Peer>);+ impl Handler for Client {+ fn on_notification(&self, _: &str, _: Value) {}+ fn on_request(&self, _: &str, _: Value) -> Result<Value, (i64, String)> {+ Ok(json!("answer"))+ }+ fn after_response(&self, method: &str) {+ self.0.get().unwrap().notify("after", method).unwrap();+ }+ }+ let client = Arc::new(Client::default());+ let (client_io, server_io) = duplex(64 * 1024);+ let (cr, cw) = tokio::io::split(client_io);+ assert!(client.0.set(Peer::connect(cr, cw, client.clone())).is_ok());+ let (sr, mut sw) = tokio::io::split(server_io);+ let request = br#"{"jsonrpc":"2.0","id":1,"method":"workspace/configuration","params":{}}"#;+ framing::write_message(&mut sw, request).await.unwrap();+ let mut reader = tokio::io::BufReader::new(sr);+ let mut next = async || -> Value {+ serde_json::from_slice(&framing::read_message(&mut reader).await.unwrap().unwrap()).unwrap()+ };+ assert_eq!(next().await, json!({ "jsonrpc": "2.0", "id": 1, "result": "answer" }));+ assert_eq!(next().await, json!({ "jsonrpc": "2.0", "method": "after", "params": "workspace/configuration" }));+}+#[tokio::test(flavor = "multi_thread")]async fn requests_start_after_the_notifications_before_them() {// `seen` answers with the notifications handled so far; handling one is slow.diff --git a/crates/ide-language/src/lib.rs b/crates/ide-language/src/lib.rsindex 908108744..8d606d3df 100644--- a/crates/ide-language/src/lib.rs+++ b/crates/ide-language/src/lib.rs@@ -155,6 +155,11 @@ pub struct LanguageServerConfig {/// Register source files with tsserver when no project configuration exists.#[serde(default)]pub tsserver_project: bool,+ /// Re-sends the open documents (unchanged) once `workspace/configuration` is answered:+ /// the server (Intelephense) applies some settings, such as the PHP version, only when+ /// it parses a document.+ #[serde(default)]+ pub resync_on_configuration: bool,/// Set on plugin languages: start exactly this approved program.#[serde(skip)]pub pinned: Option<ProgramPin>,diff --git a/crates/ide-lsp/src/handler.rs b/crates/ide-lsp/src/handler.rsindex c288623fd..1c89fd9cb 100644--- a/crates/ide-lsp/src/handler.rs+++ b/crates/ide-lsp/src/handler.rs@@ -310,6 +310,15 @@ impl Handler for ClientHandler {other => Err((codes::METHOD_NOT_FOUND, format!("unsupported method {other}"))),}}++ fn after_response(&self, method: &str) {+ if method == "workspace/configuration"+ && self.server.config.resync_on_configuration+ && let Some(mgr) = self.mgr.upgrade()+ {+ mgr.resync_documents(&self.server, self.generation);+ }+ }}/// What `workspace/configuration` sections are looked up in: the server'sdiff --git a/crates/ide-lsp/src/lib.rs b/crates/ide-lsp/src/lib.rsindex c18d4814f..1ea13785c 100644--- a/crates/ide-lsp/src/lib.rs+++ b/crates/ide-lsp/src/lib.rs@@ -946,6 +946,28 @@ impl LspManager {self.schedule_pull(doc, None, pull::AFTER_EDIT);}+ /// Sends the documents open on instance `generation` of `server` again, as a `didChange`+ /// with their unchanged text, so the server parses them with the settings it just read.+ pub(crate) fn resync_documents(&self, server: &Server, generation: u64) {+ let Some(run) = server.running_gen(generation) else { return };+ if run.caps.read().sync == SyncKind::None {+ return;+ }+ let docs = self.docs.lock();+ for d in docs.values() {+ if !d.servers.iter().any(|a| a.server.id == server.id && a.opened_gen == Some(generation)) {+ continue;+ }+ let params = json!({+ "textDocument": { "uri": d.uri, "version": d.version },+ "contentChanges": [{ "text": d.text.as_str() }],+ });+ if let Err(e) = run.peer.notify("textDocument/didChange", params) {+ tracing::debug!("{}: didChange: {e}", server.name);+ }+ }+ }+pub fn did_save(&self, doc: DocId, text: &str) {let mut docs = self.docs.lock();let Some(d) = docs.get_mut(&doc) else { return };@@ -2528,6 +2550,12 @@ impl LspManager {}}+ /// [`Self::reconfigure`] on the manager's runtime, for callers outside one (file watchers).+ pub fn reconfigure_soon(self: &Arc<Self>) {+ let me = self.clone();+ self.runtime.spawn(async move { me.reconfigure().await });+ }+pub async fn reconfigure(&self) {if !self.execution_allowed.load(Ordering::Acquire) {let servers = self.servers.lock().clone();diff --git a/crates/ide-lsp/tests/mock_server.rs b/crates/ide-lsp/tests/mock_server.rsindex deca000f0..6475c872b 100644--- a/crates/ide-lsp/tests/mock_server.rs+++ b/crates/ide-lsp/tests/mock_server.rs@@ -31,6 +31,8 @@ struct MockState {errors: Mutex<HashMap<String, (i64, String)>>,/// Computes a response from the request and the open documents (before `responses`).responder: Mutex<Option<Responder>>,+ /// Holds the handling of notifications of this method until the gate opens.+ held: Mutex<Option<(String, Arc<Gate>)>>,peer: Mutex<Option<Peer>>,}@@ -74,6 +76,12 @@ struct MockHandler(Arc<MockState>);impl Handler for MockHandler {fn on_notification(&self, method: &str, params: Value) {let s = &self.0;+ let held = s.held.lock().clone();+ if let Some((m, gate)) = held+ && m == method+ {+ gate.hold();+ }// Held throughout: a test that sees the effect (a document, the peer gone) also sees the record.let mut log = s.notifications.lock();let uri = params["textDocument"]["uri"].as_str().unwrap_or_default().to_owned();@@ -230,6 +238,7 @@ fn server_cfg(name: &str) -> LanguageServerConfig {max_java: None,launch_error: None,tsserver_project: false,+ resync_on_configuration: false,pinned: None,}}@@ -1218,6 +1227,54 @@ async fn preparation_refreshes_config_and_survives_unchanged_settings() {assert_eq!(h.launcher.state("mock").launches.load(Ordering::SeqCst), 1);}+/// Intelephense applies the PHP version only to documents it parses after reading its+/// configuration: once that is answered, servers that opt in get their open documents again.+#[tokio::test(flavor = "multi_thread")]+async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {+ let h = harness_configured("mock", "mk", &[("mock", incremental_caps()), ("extra", incremental_caps())], |cfg| {+ cfg.resync_on_configuration = cfg.name == "mock"+ });+ let (doc, path) = h.open("a.mk", "enum A {}");+ let uri = uri_of(&path);+ let (s, extra) = (h.launcher.state("mock"), h.launcher.state("extra"));+ h.wait_status("mock", ServerStatus::Ready).await;+ h.wait_status("extra", ServerStatus::Ready).await;+ eventually(|| s.docs.lock().contains_key(&uri) && extra.docs.lock().contains_key(&uri)).await;+ h.mgr.did_change(doc, 2, &[change(rng(0, 9, 0, 9), "\n")], &|| unreachable!());+ eventually(|| s.notified("textDocument/didChange").len() == 1).await;++ let items = |section: &str| json!({ "items": [{ "section": section }] });+ let options = json!([{ "flag": true, "nested": { "deep": 1 } }]);+ let answer: Value = extra.peer().request("workspace/configuration", items("extra"), None).await.unwrap();+ assert_eq!(answer, options);+ // The mock handles what arrives in order, answers included: a re-sync sent before the+ // answer would hold it back here.+ let gate = Arc::new(Gate::default());+ *s.held.lock() = Some(("textDocument/didChange".into(), gate.clone()));+ let peer = s.peer();+ let request = peer.request::<_, Value>("workspace/configuration", items("mock"), None);+ let answer = tokio::time::timeout(Duration::from_secs(10), request).await.expect("re-sync sent before the answer");+ assert_eq!(answer.unwrap(), options);+ eventually(|| gate.entered()).await;+ assert_eq!(s.notified("textDocument/didChange").len(), 1);+ gate.open();+ eventually(|| s.notified("textDocument/didChange").len() == 2).await;+ assert_eq!(+ s.notified("textDocument/didChange")[1],+ json!({ "textDocument": { "uri": uri, "version": 2 }, "contentChanges": [{ "text": "enum A {}\n" }] })+ );+ assert_eq!(s.docs.lock()[&uri], "enum A {}\n");++ // A notification sent after both answers reaches the servers after anything they triggered.+ h.mgr.did_save(doc, "enum A {}\n");+ eventually(|| extra.notified("textDocument/didSave").len() == 1 && s.notified("textDocument/didSave").len() == 1)+ .await;+ assert_eq!(s.notified("textDocument/didChange").len(), 2, "one re-sync per answer");+ let methods: Vec<String> = extra.notifications.lock().iter().map(|(m, _)| m.clone()).collect();+ assert_eq!(methods, ["initialized", "textDocument/didOpen", "textDocument/didChange", "textDocument/didSave"]);+ assert_eq!(s.launches.load(Ordering::SeqCst), 1);+}+#[tokio::test(flavor = "multi_thread")]async fn settings_changes_reach_servers_without_restarts() {let h = harness(&[("mock", incremental_caps()), ("extra", incremental_caps())]);diff --git a/crates/ide-lsp/tests/real_servers.rs b/crates/ide-lsp/tests/real_servers.rsindex 533ce79d0..589b74147 100644--- a/crates/ide-lsp/tests/real_servers.rs+++ b/crates/ide-lsp/tests/real_servers.rs@@ -135,6 +135,7 @@ async fn missing_binary_is_reported_with_install_hint() {max_java: None,launch_error: None,tsserver_project: false,+ resync_on_configuration: false,pinned: None,};let (mgr, events) = manager(dir.path(), LanguageRegistry::from_configs(vec![lang("nope", "nope", server)]));@@ -404,6 +405,7 @@ async fn typescript_language_server_end_to_end() {max_java: None,launch_error: None,tsserver_project: false,+ resync_on_configuration: false,pinned: None,};let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![lang("typescript", "ts", server)]));@@ -453,6 +455,7 @@ fn npm_server(tools: &Path, name: &str, bin: &str, init: Option<serde_json::Valumax_java: None,launch_error: None,tsserver_project: false,+ resync_on_configuration: false,pinned: None,}}diff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rsindex a496a4333..815565c32 100644--- a/crates/ide-sdk/src/apply.rs+++ b/crates/ide-sdk/src/apply.rs@@ -301,7 +301,7 @@ pub fn tsdk(root: &Path, s: &Settings) -> Option<PathBuf> {const PYTHON_SERVERS: [&str; 7] = ["basedpyright", "pyright", "ty", "pyrefly", "pylsp", "jedi-language-server", "ruff"];-fn merge(base: &mut Value, layer: Value) {+pub(crate) fn merge(base: &mut Value, layer: Value) {match (base, layer) {(Value::Object(base), Value::Object(layer)) => {for (k, v) in layer {@@ -562,6 +562,13 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_rootconfigure_vue_typescript(cfg, root, server_root, s);}+ // Intelephense reads it as `intelephense.environment.phpVersion` (`workspace/configuration`).+ if name == "intelephense"+ && let Some(version) = crate::php::language_level(root, s)+ {+ merge_init_options(cfg, json!({ "environment": { "phpVersion": version } }));+ }+// Node-based servers (`#!/usr/bin/env node`) run on the selected Node.js.if let Some(dir) = node_dir(root, s) {path_dirs.push(dir);@@ -628,6 +635,7 @@ fn custom_server(name: &str, ls: &LanguageServerSettings) -> LanguageServerConfimax_java: None,launch_error: None,tsserver_project: false,+ resync_on_configuration: false,pinned: None,}}diff --git a/crates/ide-sdk/src/lib.rs b/crates/ide-sdk/src/lib.rsindex ac8c34eb8..35d524173 100644--- a/crates/ide-sdk/src/lib.rs+++ b/crates/ide-sdk/src/lib.rs@@ -18,6 +18,7 @@ pub mod locate;pub mod lombok;pub mod maven_profiles;mod npm;+pub mod php;pub mod pinned;pub mod python;pub mod ruby;diff --git a/crates/ide-sdk/src/php.rs b/crates/ide-sdk/src/php.rsnew file mode 100644index 000000000..3e697bc5d--- /dev/null+++ b/crates/ide-sdk/src/php.rs@@ -0,0 +1,210 @@+//! The PHP language level: the one chosen in Settings › PHP, else the one the root+//! `composer.json` declares (`config.platform.php`, else the lowest version `require.php` allows);+//! and the Intelephense storage that goes with it.++use crate::apply::{merge, merge_init_options};+use ide_core::settings::Settings;+use ide_language::LanguageServerConfig;+use serde_json::{Value, json};+use std::path::Path;++/// The project's PHP version as `X.Y.Z`; `None` when neither the settings nor+/// `composer.json` name one.+pub fn language_level(root: &Path, s: &Settings) -> Option<String> {+ let explicit = s.languages.php.language_level.trim();+ if !explicit.is_empty() {+ return version(explicit).map(dotted);+ }+ let text = std::fs::read_to_string(root.join("composer.json")).ok()?;+ let composer: Value = serde_json::from_str(&text).ok()?;+ let platform = composer.pointer("/config/platform/php").and_then(Value::as_str).and_then(version);+ platform.or_else(|| lowest_allowed(composer.pointer("/require/php")?.as_str()?)).map(dotted)+}++/// Gives each PHP version its own Intelephense workspace storage (below `data_dir`).+/// Intelephense keeps the built-in functions of the version a workspace was first indexed+/// with in that storage, and reuses them after the version changes. Without a version, or+/// with a `storagePath` of the user's, the server keeps its own storage.+pub fn configure_intelephense_storage(cfg: &mut LanguageServerConfig, data_dir: &Path) {+ if cfg.name != "intelephense" {+ return;+ }+ let mut options =+ cfg.initialization_options.as_ref().and_then(|v| serde_json::to_value(v).ok()).unwrap_or(Value::Null);+ if options.get("storagePath").is_some() {+ return;+ }+ // The version Intelephense reads: `workspace/configuration` is answered from the+ // settings merged over the initialization options (`ide_lsp::handler::all_settings`).+ if let Some(settings) = &cfg.settings {+ merge(&mut options, settings.clone());+ }+ let section = options.pointer("/settings/intelephense").unwrap_or(&options);+ let version = section.pointer("/environment/phpVersion").and_then(Value::as_str);+ let Some(version) = version.filter(|v| !v.is_empty() && v.chars().all(|c| c.is_ascii_digit() || c == '.')) else {+ return;+ };+ let storage = data_dir.join("lsp").join("intelephense").join(version);+ merge_init_options(cfg, json!({ "storagePath": storage.to_string_lossy() }));+}++type Version = (u32, u32, u32);++fn dotted((major, minor, patch): Version) -> String {+ format!("{major}.{minor}.{patch}")+}++/// `7`, `7.4`, `v7.4.3`, `8.1.*`, `7.4.0-dev`: missing parts are 0.+fn version(s: &str) -> Option<Version> {+ let s = s.trim().trim_start_matches(['v', 'V']);+ let mut parts = s.split('.').map(|p| {+ let digits: &str = &p[..p.find(|c: char| !c.is_ascii_digit()).unwrap_or(p.len())];+ digits.parse::<u32>().ok()+ });+ let major = parts.next()??;+ let minor = parts.next().flatten().unwrap_or(0);+ let patch = parts.next().flatten().unwrap_or(0);+ Some((major, minor, patch))+}++/// The lowest version a Composer constraint allows: the lowest lower bound of its+/// `||` alternatives. `None` when an alternative has no lower bound (`*`, `<8.0`).+fn lowest_allowed(constraint: &str) -> Option<Version> {+ let bounds: Option<Vec<Version>> =+ constraint.split('|').filter(|alt| !alt.trim().is_empty()).map(lower_bound).collect();+ bounds?.into_iter().min()+}++/// The lower bound of constraints that must all hold (`>=7.2 <8.4`, `^7.4, !=7.4.1`,+/// `7.2 - 8.0`): the highest of their lower bounds.+fn lower_bound(alternative: &str) -> Option<Version> {+ // A hyphen range: its first version.+ let alternative = alternative.split(" - ").next().unwrap_or(alternative);+ let mut tokens: Vec<String> = Vec::new();+ for token in alternative.split([' ', ',']).filter(|t| !t.is_empty()) {+ // `>= 7.2`: the operator and its version.+ match tokens.last_mut() {+ Some(op) if op.chars().all(|c| "<>=!~^".contains(c)) => op.push_str(token),+ _ => tokens.push(token.to_owned()),+ }+ }+ tokens+ .iter()+ .filter_map(|t| {+ let t = t.split('@').next().unwrap_or(t);+ if t.starts_with('<') || t.starts_with("!=") {+ return None;+ }+ version(t.trim_start_matches(['>', '=', '^', '~']))+ })+ .max()+}++#[cfg(test)]+mod tests {+ use super::*;++ fn level(composer: Option<&str>, explicit: &str) -> Option<String> {+ let tmp = tempfile::tempdir().unwrap();+ if let Some(composer) = composer {+ std::fs::write(tmp.path().join("composer.json"), composer).unwrap();+ }+ let mut s = Settings::default();+ s.languages.php.language_level = explicit.into();+ language_level(tmp.path(), &s)+ }++ fn required(constraint: &str) -> Option<String> {+ level(Some(&serde_json::json!({ "require": { "php": constraint } }).to_string()), "")+ }++ #[test]+ fn lowest_version_require_php_allows() {+ assert_eq!(required("^7.4 || ^8.0").as_deref(), Some("7.4.0"));+ assert_eq!(required("^8.0 || ^7.4").as_deref(), Some("7.4.0"));+ assert_eq!(required(">=7.2 <8.4").as_deref(), Some("7.2.0"));+ assert_eq!(required(">= 7.2, < 8.4").as_deref(), Some("7.2.0"));+ assert_eq!(required("8.1.*").as_deref(), Some("8.1.0"));+ assert_eq!(required("~7.4.3").as_deref(), Some("7.4.3"));+ assert_eq!(required("7.2 - 8.0").as_deref(), Some("7.2.0"));+ assert_eq!(required("^7.3|^8.0").as_deref(), Some("7.3.0"));+ assert_eq!(required(">=8.1@dev").as_deref(), Some("8.1.0"));+ assert_eq!(required("8").as_deref(), Some("8.0.0"));+ }++ #[test]+ fn no_lower_bound_gives_nothing() {+ for constraint in ["*", "<8.0", "", "^7.4 || *", "dev-main"] {+ assert_eq!(required(constraint), None, "{constraint}");+ }+ }++ #[test]+ fn platform_overrides_require() {+ let composer = r#"{"require": {"php": "^8.2"}, "config": {"platform": {"php": "7.2.34"}}}"#;+ assert_eq!(level(Some(composer), "").as_deref(), Some("7.2.34"));+ }++ #[test]+ fn no_requirement_gives_nothing() {+ assert_eq!(level(None, ""), None);+ assert_eq!(level(Some(r#"{"require": {"ext-json": "*"}}"#), ""), None);+ assert_eq!(level(Some("not json"), ""), None);+ }++ #[test]+ fn each_php_version_gets_its_own_intelephense_storage() {+ let data = Path::new("/data");+ let server = |name: &str, options: Value| {+ let mut cfg: LanguageServerConfig =+ toml::from_str(&format!("name = \"{name}\"\ncommand = \"{name}\"")).unwrap();+ if !options.is_null() {+ merge_init_options(&mut cfg, options);+ }+ cfg+ };+ let options = |cfg: &LanguageServerConfig| serde_json::to_value(&cfg.initialization_options).unwrap();++ let mut cfg = server("intelephense", json!({"environment": {"phpVersion": "7.4.0"}, "clearCache": false}));+ configure_intelephense_storage(&mut cfg, data);+ let storage = data.join("lsp").join("intelephense").join("7.4.0");+ assert_eq!(+ options(&cfg),+ json!({"environment": {"phpVersion": "7.4.0"}, "clearCache": false, "storagePath": storage.to_string_lossy()})+ );++ // The version Intelephense reads wins: Settings > Language Servers `settings` over the options.+ let storage_of = |init: Value, settings: Value| {+ let mut cfg = server("intelephense", init);+ cfg.settings = Some(settings);+ configure_intelephense_storage(&mut cfg, data);+ options(&cfg)["storagePath"].clone()+ };+ let path = |v: &str| json!(data.join("lsp").join("intelephense").join(v).to_string_lossy());+ let init = json!({"environment": {"phpVersion": "7.4.0"}});+ assert_eq!(storage_of(init.clone(), json!({"environment": {"phpVersion": "8.3.0"}})), path("8.3.0"));+ assert_eq!(storage_of(init, json!({"other": 1})), path("7.4.0"));+ let nested = json!({"settings": {"intelephense": {"environment": {"phpVersion": "8.0.0"}}}});+ assert_eq!(storage_of(Value::Null, nested), path("8.0.0"));++ // No version, the user's own storage, not a version, another server: unchanged.+ for unchanged in [+ server("intelephense", Value::Null),+ server("intelephense", json!({"environment": {"includePaths": []}})),+ server("intelephense", json!({"environment": {"phpVersion": "8.1.0"}, "storagePath": "/mine"})),+ server("intelephense", json!({"environment": {"phpVersion": "../8.1"}})),+ server("phpactor", json!({"environment": {"phpVersion": "8.1.0"}})),+ ] {+ let mut cfg = unchanged.clone();+ configure_intelephense_storage(&mut cfg, data);+ assert_eq!(cfg, unchanged);+ }+ }++ #[test]+ fn explicit_level_wins() {+ let composer = r#"{"require": {"php": "^7.4"}, "config": {"platform": {"php": "7.4.33"}}}"#;+ assert_eq!(level(Some(composer), "8.1").as_deref(), Some("8.1.0"));+ assert_eq!(level(None, " 5.6 ").as_deref(), Some("5.6.0"));+ }+}diff --git a/crates/ide-sdk/src/tests.rs b/crates/ide-sdk/src/tests.rsindex 4a61ad1d5..250204560 100644--- a/crates/ide-sdk/src/tests.rs+++ b/crates/ide-sdk/src/tests.rs@@ -38,6 +38,7 @@ fn server(name: &str) -> LanguageServerConfig {max_java: None,launch_error: None,tsserver_project: false,+ resync_on_configuration: false,pinned: None,}}@@ -1293,6 +1294,37 @@ fn php_sources_and_selected_interpreter() {assert!(configs[3].env.get("PATH").is_none_or(|p| !p.contains("php82")));}+#[test]+fn intelephense_gets_the_php_language_level() {+ use serde_json::json;+ let tmp = tempfile::tempdir().unwrap();+ let configured = |name: &str, s: &Settings| {+ let mut cfg = server(name);+ configure_server(&mut cfg, tmp.path(), tmp.path(), s);+ cfg+ };+ let options = |cfg: LanguageServerConfig| serde_json::to_value(cfg.initialization_options).unwrap();++ // Nothing to resolve: the options stay as they were (the rest depends on the machine's tools).+ assert_eq!(configured("intelephense", &Settings::default()).initialization_options, None);++ std::fs::write(tmp.path().join("composer.json"), r#"{"require": {"php": "^7.4 || ^8.0"}}"#).unwrap();+ assert_eq!(+ options(configured("intelephense", &Settings::default())),+ json!({"environment": {"phpVersion": "7.4.0"}})+ );+ for other in ["phpactor", "basedpyright", "vtsls"] {+ assert_eq!(options(configured(other, &Settings::default())).get("environment"), None, "{other}");+ }++ let mut s = Settings::default();+ s.languages.php.language_level = "8.1".into();+ let mut cfg = server("intelephense");+ cfg.initialization_options = Some(toml::Value::try_from(json!({"clearCache": true})).unwrap());+ configure_server(&mut cfg, tmp.path(), tmp.path(), &s);+ assert_eq!(options(cfg), json!({"clearCache": true, "environment": {"phpVersion": "8.1.0"}}));+}+#[test]fn go_constraints_change_only_protocol_settings() {use serde_json::json;diff --git a/languages/php.toml b/languages/php.tomlindex 4b14b8d82..b0fc0f4e3 100644--- a/languages/php.toml+++ b/languages/php.toml@@ -14,6 +14,8 @@ command = "intelephense"args = ["--stdio"]root-markers = ["composer.json", ".phpactor.json", "index.php"]install-hint = "npm i -g intelephense"+# Intelephense applies the PHP version only to documents it parses after reading it.+resync-on-configuration = true[[language-servers]]name = "phpactor"diff --git a/src/bindings.ts b/src/bindings.tsindex 72ac50c86..042adce4f 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -5265,6 +5265,11 @@ export type PathCompletion = {export type PhpSettings = {/** `php` CLI executable; empty = the one on `PATH`. */interpreter?: string,+ /**+ * PHP version the language server checks the code against (`7.4`); empty = from+ * `composer.json` (`config.platform.php`, else the lowest version `require.php` allows).+ */+ languageLevel?: string,};/** The focused editor when a plugin command is invoked. */diff --git a/src/features/settings/__tests__/languages.test.ts b/src/features/settings/__tests__/languages.test.tsindex a53555f33..fcb8897c1 100644--- a/src/features/settings/__tests__/languages.test.ts+++ b/src/features/settings/__tests__/languages.test.ts@@ -1,6 +1,7 @@import { describe, expect, it } from "vitest";import {DEFAULT_LANGUAGES,+ PHP_LANGUAGE_LEVELS,folderRole,markFolder,normalizeFolder,@@ -43,6 +44,22 @@ describe("languages settings", () => {expect(validateSettings(settings).languages.ruby.interpreter).toBe("/opt/ruby/bin/ruby");});+ it("defaults the PHP language level to Auto and keeps only known levels", () => {+ expect(validateSettings({}).languages.php).toEqual({ interpreter: "", languageLevel: "" });+ expect(validateLanguages({ php: { languageLevel: "7.4" } }).php.languageLevel).toBe("7.4");+ for (const level of ["7.4.3", "9.0", 8.1, null]) {+ expect(validateLanguages({ php: { languageLevel: level } }).php.languageLevel).toBe("");+ }+ expect(PHP_LANGUAGE_LEVELS[0]).toBe("");+ expect(PHP_LANGUAGE_LEVELS).toContain("5.6");+ expect(PHP_LANGUAGE_LEVELS.at(-1)).toBe("8.5");+ });++ it("finds the PHP page by its language level", () => {+ const php = LANGUAGE_PAGES.find((p) => p.id === "languages.php")!;+ expect(php.keywords).toContain("language level");+ });+it("keeps Prettier opt-in on save and normalizes its enabled languages", () => {expect(validateLanguages({}).prettier).toMatchObject({ prefer: false, runOnSave: false, path: "" });expect(diff --git a/src/features/settings/languages/LanguagePages.tsx b/src/features/settings/languages/LanguagePages.tsxindex aef869b3b..c30b755b0 100644--- a/src/features/settings/languages/LanguagePages.tsx+++ b/src/features/settings/languages/LanguagePages.tsx@@ -5,6 +5,7 @@*/import { useId, useMemo } from "react";import { IconButton, Input, type SelectOption } from "@/ui";+import { PHP_LANGUAGE_LEVELS } from "@/platform/languageSettings";import { Row, Section, Select, Toggle } from "../components/Form";import { choosePath } from "./api";import { useSetting } from "../components/context";@@ -112,12 +113,25 @@ export function NodePage() {// ---------------------------------------------------------------------------// PHP+const PHP_LEVEL_OPTIONS: SelectOption[] = PHP_LANGUAGE_LEVELS.map((level) =>+ level ? { value: level, label: level } : { value: "", label: "Auto", detail: "from composer.json" },+);+export function PhpPage() {const [interpreter] = useSetting<string>("languages.php.interpreter");+ const [level, setLevel] = useSetting<string>("languages.php.languageLevel");const { list } = useDetected("php");const selected = list.find((s) => s.path === interpreter) ?? (interpreter ? undefined : list[0]);return (<div className={styles.page}>+ <Section>+ <Row+ label="PHP language level"+ hint="The PHP version Intelephense checks the code against: newer syntax and functions are reported. Auto uses config.platform.php from composer.json, else the lowest version require.php allows."+ >+ <Select value={level} options={PHP_LEVEL_OPTIONS} onChange={setLevel} aria-label="PHP language level" />+ </Row>+ </Section><Section title="CLI Interpreter"><SdkRowk="languages.php.interpreter"diff --git a/src/features/settings/pages/languages.tsx b/src/features/settings/pages/languages.tsxindex bf31e0b14..e547ba22e 100644--- a/src/features/settings/pages/languages.tsx+++ b/src/features/settings/pages/languages.tsx@@ -148,6 +148,8 @@ export const LANGUAGE_PAGES: PageSpec[] = [keywords: ["php interpreter","cli interpreter",+ "language level",+ "php version","php","composer","phpunit",diff --git a/src/platform/languageSettings.ts b/src/platform/languageSettings.tsindex e3cfe0f3e..5347ad918 100644--- a/src/platform/languageSettings.ts+++ b/src/platform/languageSettings.ts@@ -55,11 +55,28 @@ const DEFAULT_FORMATTER: ExternalFormatterValid = {runOnSave: false,};+/** `languages.php.languageLevel` values; `""` = Auto (from `composer.json`). */+export const PHP_LANGUAGE_LEVELS = [+ "",+ "5.6",+ "7.0",+ "7.1",+ "7.2",+ "7.3",+ "7.4",+ "8.0",+ "8.1",+ "8.2",+ "8.3",+ "8.4",+ "8.5",+] as const;+export interface LanguagesValid {python: { interpreter: string; activateVirtualenv: boolean };ruby: { interpreter: string };node: { interpreter: string; packageManager: "" | "npm" | "pnpm" | "yarn" | "bun" };- php: { interpreter: string };+ php: { interpreter: string; languageLevel: (typeof PHP_LANGUAGE_LEVELS)[number] };rust: {toolchain: string;stdlib: string;@@ -121,7 +138,7 @@ export const DEFAULT_LANGUAGES: LanguagesValid = {python: { interpreter: "", activateVirtualenv: true },ruby: { interpreter: "" },node: { interpreter: "", packageManager: "" },- php: { interpreter: "" },+ php: { interpreter: "", languageLevel: "" },rust: { toolchain: "", stdlib: "", checkOnSave: true, checkCommand: "check", rustfmtArgs: "" },go: { goroot: "", gopath: "", buildTags: DEFAULT_GO_BUILD_TAGS, modules: { env: {}, autoVendor: true } },typescript: { version: "bundled" },@@ -222,7 +239,10 @@ export function validateLanguages(raw: unknown): LanguagesValid {interpreter: text(node.interpreter, d.node.interpreter),packageManager: oneOf(node.packageManager, ["", "npm", "pnpm", "yarn", "bun"] as const, d.node.packageManager),},- php: { interpreter: text(php.interpreter, d.php.interpreter) },+ php: {+ interpreter: text(php.interpreter, d.php.interpreter),+ languageLevel: oneOf(php.languageLevel, PHP_LANGUAGE_LEVELS, d.php.languageLevel),+ },rust: {toolchain: text(rust.toolchain, d.rust.toolchain),stdlib: text(rust.stdlib, d.rust.stdlib),diff --git a/src/platform/locales/text/fr.json b/src/platform/locales/text/fr.jsonindex c015e9f07..6c6f3f28c 100644--- a/src/platform/locales/text/fr.json+++ b/src/platform/locales/text/fr.json@@ -5768,6 +5768,9 @@"{name}: {error}": "{name} : {error}","unsupported clipboard media type": "type de média du presse-papiers non pris en charge","Select PHP Interpreter": "Sélectionner l'interpréteur PHP",+ "PHP language level": "Niveau de langage PHP",+ "The PHP version Intelephense checks the code against: newer syntax and functions are reported. Auto uses config.platform.php from composer.json, else the lowest version require.php allows.": "La version de PHP par rapport à laquelle Intelephense vérifie le code : la syntaxe et les fonctions plus récentes sont signalées. Auto utilise config.platform.php de composer.json, sinon la version la plus basse autorisée par require.php.",+ "from composer.json": "depuis composer.json","select files in a git repository to shelve": "sélectionnez les fichiers d'un dépôt git à mettre de côté","select files from a single git repository to shelve": "sélectionnez les fichiers d'un seul dépôt git à mettre de côté","External file changes sync may be slow": "La synchronisation des modifications externes de fichiers peut être lente",diff --git a/src/platform/locales/text/ko.json b/src/platform/locales/text/ko.jsonindex 269aa70d3..3a0d1445f 100644--- a/src/platform/locales/text/ko.json+++ b/src/platform/locales/text/ko.json@@ -5616,6 +5616,9 @@"PHP interpreter": "PHP 인터프리터","Runs PHP scripts, PHPUnit, Composer and artisan, and the PHP-based language servers (phpactor). Its folder is put first on PATH, so vendor/bin/phpunit and other #!/usr/bin/env php scripts use it too.": "PHP 스크립트, PHPUnit, Composer, artisan 및 PHP 기반 언어 서버(phpactor)를 실행합니다. 해당 폴더가 PATH 맨 앞에 추가되므로 vendor/bin/phpunit 및 기타 #!/usr/bin/env php 스크립트도 이 인터프리터를 사용합니다.","Select PHP Interpreter": "PHP 인터프리터 선택",+ "PHP language level": "PHP 언어 레벨",+ "The PHP version Intelephense checks the code against: newer syntax and functions are reported. Auto uses config.platform.php from composer.json, else the lowest version require.php allows.": "Intelephense가 코드를 검사하는 기준 PHP 버전입니다. 더 새로운 문법과 함수가 보고됩니다. 자동은 composer.json의 config.platform.php를 사용하고, 없으면 require.php가 허용하는 가장 낮은 버전을 사용합니다.",+ "from composer.json": "composer.json 기준","select files in a git repository to shelve": "셸브할 git 저장소의 파일을 선택하세요","select files from a single git repository to shelve": "셸브할 단일 git 저장소의 파일을 선택하세요","External file changes sync may be slow": "외부 파일 변경 사항 동기화가 느릴 수 있습니다",diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.jsonindex 78259d0a5..37e46c865 100644--- a/src/platform/locales/text/zh.json+++ b/src/platform/locales/text/zh.json@@ -5645,6 +5645,9 @@"PHP interpreter": "PHP 解释器","Runs PHP scripts, PHPUnit, Composer and artisan, and the PHP-based language servers (phpactor). Its folder is put first on PATH, so vendor/bin/phpunit and other #!/usr/bin/env php scripts use it too.": "运行 PHP 脚本、PHPUnit、Composer 和 artisan,以及基于 PHP 的语言服务器(phpactor)。其所在文件夹会被置于 PATH 最前,因此 vendor/bin/phpunit 等 #!/usr/bin/env php 脚本也会使用它。","Select PHP Interpreter": "选择 PHP 解释器",+ "PHP language level": "PHP 语言级别",+ "The PHP version Intelephense checks the code against: newer syntax and functions are reported. Auto uses config.platform.php from composer.json, else the lowest version require.php allows.": "Intelephense 检查代码时所针对的 PHP 版本:更新版本的语法和函数会被报告。“自动”使用 composer.json 中的 config.platform.php,否则使用 require.php 允许的最低版本。",+ "from composer.json": "来自 composer.json","select files in a git repository to shelve": "请选择 Git 仓库中的文件以搁置更改","select files from a single git repository to shelve": "请一次只选择同一个 Git 仓库中的文件以搁置更改","External file changes sync may be slow": "外部文件更改同步可能较慢",