fix(config): preprocess paths per config file

Resolve relative workspace paths before merged runtime config loses the
declaring file context. Keep the raw single-file config loader for edit
commands, and cover parent library/package paths plus entry-local
ignoreDir preprocessing.

Author: lewis6991

crates/emmylua_code_analysis/src/config/config_loader.rs

@@ -6,89 +6,137 @@ use crate::{config::lua_loader::load_lua_config, read_file_with_encoding};
 
 use super::{Emmyrc, flatten_config::FlattenConfigObject};
 
-pub fn load_configs_raw(config_files: Vec<PathBuf>, partial_emmyrcs: Option<Vec<Value>>) -> Value {
-    let mut config_jsons = Vec::new();
+/// Load a config file into an Emmyrc-shaped JSON value without path preprocessing.
+///
+/// This keeps file-relative paths exactly as written in the source config. It is
+/// intended for callers that need to inspect or edit the raw config shape before
+/// writing it back to disk.
+pub fn load_config_json_unprocessed(config_file: PathBuf) -> Value {
+    let Some(config_value) = load_config_file_value(&config_file) else {
+        log::info!("No valid config file found.");
+        return Value::Object(Default::default());
+    };
+
+    FlattenConfigObject::parse(config_value).to_emmyrc()
+}
+
+/// Load config files into a final [`Emmyrc`].
+///
+/// Unlike [`load_config_json_unprocessed`], this is the semantic runtime loader.
+/// Each file config is flattened and preprocessed relative to the directory that
+/// declared it before configs are merged. That has to happen pre-merge because
+/// relative settings such as `library`, `packages`, and per-entry ignores lose
+/// their originating config path once they have been folded into one JSON value.
+pub fn load_configs(config_files: Vec<PathBuf>, partial_emmyrcs: Option<Vec<Value>>) -> Emmyrc {
+    // This starts as a placeholder; the first surviving config becomes the real merge base.
+    let mut merged_emmyrc_json = Value::Object(Default::default());
+    let mut has_config = false;
 
     for config_file in config_files {
-        log::info!("Loading config file: {:?}", config_file);
-        let config_content = match read_file_with_encoding(&config_file, "utf-8") {
-            Some(content) => content,
-            None => {
+        let Some(config_value) = load_config_file_value(&config_file) else {
+            continue;
+        };
+
+        // Preprocess while we still know which config file produced these values. After merge,
+        // a relative `library` / `packages` / `ignoreDir` entry no longer carries its base dir.
+        let config_emmyrc_json = FlattenConfigObject::parse(config_value).to_emmyrc();
+        let mut emmyrc: Emmyrc = match serde_json::from_value(config_emmyrc_json) {
+            Ok(emmyrc) => emmyrc,
+            Err(err) => {
                 log::error!(
-                    "Failed to read config file: {:?}, error: File not found or unreadable",
-                    config_file
+                    "Failed to parse config file as emmyrc {:?}: {:?}",
+                    config_file,
+                    err
                 );
                 continue;
             }
         };
 
-        let config_value = if config_file.extension().and_then(|s| s.to_str()) == Some("lua") {
-            match load_lua_config(&config_content) {
-                Ok(value) => value,
-                Err(e) => {
-                    log::error!(
-                        "Failed to parse lua config file: {:?}, error: {:?}",
-                        &config_file,
-                        e
-                    );
-                    continue;
+        if let Some(config_root) = config_file.parent() {
+            emmyrc.pre_process_emmyrc(config_root);
+        }
+
+        match serde_json::to_value(emmyrc) {
+            Ok(config_emmyrc_json) => {
+                if has_config {
+                    merge_values(&mut merged_emmyrc_json, config_emmyrc_json);
+                } else {
+                    merged_emmyrc_json = config_emmyrc_json;
+                    has_config = true;
                 }
             }
-        } else {
-            match serde_json::from_str(&config_content) {
-                Ok(json) => json,
-                Err(e) => {
-                    log::error!(
-                        "Failed to parse config file: {:?}, error: {:?}",
-                        &config_file,
-                        e
-                    );
-                    continue;
-                }
+            Err(err) => {
+                log::error!(
+                    "Failed to serialize pre-processed config {:?}: {:?}",
+                    config_file,
+                    err
+                );
             }
         };
-
-        config_jsons.push(config_value);
     }
 
     if let Some(partial_emmyrcs) = partial_emmyrcs {
+        // Partial configs are late overlays from the client, so they win over file-backed config.
         for partial_emmyrc in partial_emmyrcs {
-            config_jsons.push(partial_emmyrc);
+            if has_config {
+                merge_values(&mut merged_emmyrc_json, partial_emmyrc);
+            } else {
+                merged_emmyrc_json = partial_emmyrc;
+                has_config = true;
+            }
         }
     }
 
-    if config_jsons.is_empty() {
+    if !has_config {
         log::info!("No valid config file found.");
-        Value::Object(Default::default())
-    } else if config_jsons.len() == 1 {
-        let first_config = config_jsons.into_iter().next().unwrap_or_else(|| {
-            log::error!("No valid config file found.");
-            Value::Object(Default::default())
-        });
-
-        let flatten_config = FlattenConfigObject::parse(first_config);
-        flatten_config.to_emmyrc()
-    } else {
-        let merge_config =
-            config_jsons
-                .into_iter()
-                .fold(Value::Object(Default::default()), |mut acc, item| {
-                    merge_values(&mut acc, item);
-                    acc
-                });
-        let flatten_config = FlattenConfigObject::parse(merge_config.clone());
-        flatten_config.to_emmyrc()
     }
-}
 
-pub fn load_configs(config_files: Vec<PathBuf>, partial_emmyrcs: Option<Vec<Value>>) -> Emmyrc {
-    let emmyrc_json_value = load_configs_raw(config_files, partial_emmyrcs);
-    serde_json::from_value(emmyrc_json_value).unwrap_or_else(|err| {
+    serde_json::from_value(merged_emmyrc_json).unwrap_or_else(|err| {
         log::error!("Failed to parse config: error: {:?}", err);
         Emmyrc::default()
     })
 }
 
+fn load_config_file_value(config_file: &PathBuf) -> Option<Value> {
+    log::info!("Loading config file: {:?}", config_file);
+    let config_content = match read_file_with_encoding(config_file, "utf-8") {
+        Some(content) => content,
+        None => {
+            log::error!(
+                "Failed to read config file: {:?}, error: File not found or unreadable",
+                config_file
+            );
+            return None;
+        }
+    };
+
+    if config_file.extension().and_then(|s| s.to_str()) == Some("lua") {
+        match load_lua_config(&config_content) {
+            Ok(value) => Some(value),
+            Err(err) => {
+                log::error!(
+                    "Failed to parse lua config file: {:?}, error: {:?}",
+                    config_file,
+                    err
+                );
+                None
+            }
+        }
+    } else {
+        match serde_json::from_str(&config_content) {
+            Ok(json) => Some(json),
+            Err(err) => {
+                log::error!(
+                    "Failed to parse config file: {:?}, error: {:?}",
+                    config_file,
+                    err
+                );
+                None
+            }
+        }
+    }
+}
+
 fn merge_values(base: &mut Value, overlay: Value) {
     match (base, overlay) {
         (Value::Object(base_map), Value::Object(overlay_map)) => {
@@ -116,3 +164,148 @@ fn merge_values(base: &mut Value, overlay: Value) {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        fs,
+        path::{Path, PathBuf},
+        sync::atomic::{AtomicU64, Ordering},
+        time::{SystemTime, UNIX_EPOCH},
+    };
+
+    use super::{Emmyrc, load_config_json_unprocessed, load_configs};
+
+    static TEST_CONFIG_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+    struct TestConfigRoot {
+        root: PathBuf,
+    }
+
+    impl TestConfigRoot {
+        fn new() -> Self {
+            let unique = SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_nanos();
+            let counter = TEST_CONFIG_COUNTER.fetch_add(1, Ordering::Relaxed);
+            let root = std::env::temp_dir().join(format!(
+                "emmylua-config-loader-{}-{}-{}",
+                std::process::id(),
+                unique,
+                counter,
+            ));
+            fs::create_dir_all(&root).unwrap();
+            Self { root }
+        }
+
+        fn write_file(&self, relative_path: &str, contents: &str) -> PathBuf {
+            let path = self.root.join(relative_path);
+            fs::create_dir_all(path.parent().unwrap()).unwrap();
+            fs::write(&path, contents).unwrap();
+            path
+        }
+
+        fn path(&self, relative_path: &str) -> PathBuf {
+            self.root.join(relative_path)
+        }
+    }
+
+    impl Drop for TestConfigRoot {
+        fn drop(&mut self) {
+            let _ = fs::remove_dir_all(&self.root);
+        }
+    }
+
+    fn to_string(path: &Path) -> String {
+        path.to_string_lossy().to_string()
+    }
+
+    #[test]
+    fn merged_configs_should_resolve_relative_workspace_paths_from_declaring_config_file() {
+        let workspace = TestConfigRoot::new();
+        let shared_config = workspace.write_file(
+            "shared/config/.luarc.json",
+            r#"{
+                "workspace": {
+                    "library": ["../shared-lib"]
+                }
+            }"#,
+        );
+        let workspace_config = workspace.write_file(
+            "project/.luarc.json",
+            r#"{
+                "workspace": {
+                    "library": ["./vendor"]
+                }
+            }"#,
+        );
+        let workspace_root = workspace.path("project");
+        let expected = vec![
+            to_string(&workspace.path("shared/shared-lib")),
+            to_string(&workspace.path("project/vendor")),
+        ];
+
+        let mut emmyrc = load_configs(vec![shared_config, workspace_config], None);
+        emmyrc.pre_process_emmyrc(&workspace_root);
+
+        let actual = emmyrc
+            .workspace
+            .library
+            .iter()
+            .map(|item| item.get_path().clone())
+            .collect::<Vec<_>>();
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn raw_config_loader_keeps_relative_workspace_paths_as_authored() {
+        let workspace = TestConfigRoot::new();
+        let config = workspace.write_file(
+            "project/.luarc.json",
+            r#"{
+                "workspace": {
+                    "library": ["../shared-lib"]
+                }
+            }"#,
+        );
+
+        let emmyrc_value = load_config_json_unprocessed(config);
+        let emmyrc: Emmyrc = serde_json::from_value(emmyrc_value).unwrap();
+
+        let actual = emmyrc
+            .workspace
+            .library
+            .iter()
+            .map(|item| item.get_path().clone())
+            .collect::<Vec<_>>();
+
+        assert_eq!(actual, vec!["../shared-lib".to_string()]);
+    }
+
+    #[test]
+    fn invalid_config_does_not_override_earlier_valid_settings() {
+        let workspace = TestConfigRoot::new();
+        let valid_config = workspace.write_file(
+            "project/.luarc.json",
+            r#"{
+                "diagnostics": {
+                    "enable": false
+                }
+            }"#,
+        );
+        let invalid_config = workspace.write_file(
+            "project/invalid.luarc.json",
+            r#"{
+                "diagnostics": {
+                    "enable": "oops"
+                }
+            }"#,
+        );
+
+        let emmyrc = load_configs(vec![valid_config, invalid_config], None);
+
+        assert!(!emmyrc.diagnostics.enable);
+    }
+}

crates/emmylua_code_analysis/src/config/mod.rs

@@ -6,7 +6,7 @@ mod pre_process;
 
 use std::{collections::HashMap, path::Path};
 
-pub use config_loader::{load_configs, load_configs_raw};
+pub use config_loader::{load_config_json_unprocessed, load_configs};
 pub use configs::{
     DiagnosticSeveritySetting, DocSyntax, EmmyLibraryConfig, EmmyLibraryItem, EmmyrcCodeAction,
     EmmyrcCodeLens, EmmyrcCompletion, EmmyrcDiagnostic, EmmyrcDoc, EmmyrcDocumentColor,