Expose exported_symbols in Package

Author: lionel-

crates/ark/src/lsp/diagnostics.rs

@@ -957,7 +957,7 @@ fn insert_package_exports(
         .library_symbols
         .entry(attach_pos)
         .or_default()
-        .extend(package.namespace.exports.iter().cloned());
+        .extend(package.exported_symbols.iter().cloned());
 
     Ok(package)
 }
@@ -1657,7 +1657,7 @@ foo
                 depends: vec![],
                 fields: Dcf::new(),
             };
-            let package = Package::new(PathBuf::from("/mock/path"), description, namespace);
+            let package = Package::from_parts(PathBuf::from("/mock/path"), description, namespace);
 
             // Create a library with `mockpkg` installed
             let library = Library::new(vec![]).insert("mockpkg", package);
@@ -1753,7 +1753,8 @@ foo
                 depends: vec![],
                 fields: Dcf::new(),
             };
-            let package1 = Package::new(PathBuf::from("/mock/path1"), description1, namespace1);
+            let package1 =
+                Package::from_parts(PathBuf::from("/mock/path1"), description1, namespace1);
 
             // pkg2 exports `bar` and `baz`
             let namespace2 = Namespace {
@@ -1767,7 +1768,8 @@ foo
                 depends: vec![],
                 fields: Dcf::new(),
             };
-            let package2 = Package::new(PathBuf::from("/mock/path2"), description2, namespace2);
+            let package2 =
+                Package::from_parts(PathBuf::from("/mock/path2"), description2, namespace2);
 
             let library = Library::new(vec![])
                 .insert("pkg1", package1)
@@ -1823,7 +1825,7 @@ foo
                 depends: vec![],
                 fields: Dcf::new(),
             };
-            let package = Package::new(PathBuf::from("/mock/path"), description, namespace);
+            let package = Package::from_parts(PathBuf::from("/mock/path"), description, namespace);
 
             let library = Library::new(vec![]).insert("pkg", package);
 

crates/ark/src/lsp/inputs/package.rs

@@ -22,18 +22,50 @@ pub struct Package {
     pub description: Description,
     pub namespace: Namespace,
     pub documentation: Documentation,
+
+    // List of symbols exported via NAMESPACE `export()` directives and via
+    // `DocType{data}`. Note the latter should only apply to packages with
+    // `LazyData: true` but currently applies to all packages, as a stopgap
+    // to prevent spurious diagnostics (we accept false negatives to avoid
+    // annoying false positives).
+    pub exported_symbols: Vec<String>,
 }
 
 impl Package {
-    pub fn new(path: PathBuf, description: Description, namespace: Namespace) -> Self {
+    pub fn new(
+        path: PathBuf,
+        description: Description,
+        namespace: Namespace,
+        documentation: Documentation,
+    ) -> Self {
+        // Compute exported symbols. Start from explicit NAMESPACE exports.
+        let mut exported_symbols = namespace.exports.clone();
+
+        // Add exported datasets. Ideally we'd only do that for packages
+        // specifying `LazyData: true`.
+        let exported_datasets = documentation.rd_files.iter().filter_map(|rd| {
+            if rd.doc_type == Some(crate::lsp::inputs::documentation_rd_file::RdDocType::Data) {
+                rd.name.clone()
+            } else {
+                None
+            }
+        });
+        exported_symbols.extend(exported_datasets);
+
         Self {
             path,
             description,
             namespace,
-            documentation: Default::default(),
+            documentation,
+            exported_symbols,
         }
     }
 
+    #[cfg(test)]
+    pub fn from_parts(path: PathBuf, description: Description, namespace: Namespace) -> Self {
+        Self::new(path, description, namespace, Default::default())
+    }
+
     /// Load a package from a given path.
     pub fn load_from_folder(package_path: &std::path::Path) -> anyhow::Result<Option<Self>> {
         let description_path = package_path.join("DESCRIPTION");
@@ -69,12 +101,12 @@ impl Package {
             },
         };
 
-        Ok(Some(Package {
-            path: package_path.to_path_buf(),
+        Ok(Some(Self::new(
+            package_path.to_path_buf(),
             description,
             namespace,
             documentation,
-        }))
+        )))
     }
 
     /// Load a package from the given library path and name.
@@ -98,3 +130,57 @@ impl Package {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::lsp::inputs::documentation_rd_file::RdDocType;
+    use crate::lsp::inputs::documentation_rd_file::RdFile;
+    use crate::lsp::inputs::package_description::Description;
+    use crate::lsp::inputs::package_namespace::Namespace;
+
+    #[test]
+    fn test_exported_symbols_combining_namespace_and_rd_files() {
+        let namespace = Namespace {
+            exports: vec!["foo".to_string(), "bar".to_string()],
+            ..Default::default()
+        };
+
+        let rd_files = vec![
+            RdFile {
+                name: Some("data1".to_string()),
+                doc_type: Some(RdDocType::Data),
+            },
+            RdFile {
+                name: Some("pkgdoc".to_string()),
+                doc_type: Some(RdDocType::Package),
+            },
+            RdFile {
+                name: Some("other".to_string()),
+                doc_type: None,
+            },
+        ];
+        let documentation = Documentation { rd_files };
+
+        let description = Description {
+            name: "mypkg".to_string(),
+            version: "1.0.0".to_string(),
+            depends: vec![],
+            fields: Default::default(),
+        };
+
+        let package = Package::new(
+            PathBuf::from("/mock/path"),
+            description,
+            namespace,
+            documentation,
+        );
+
+        assert!(package.exported_symbols.contains(&"foo".to_string()));
+        assert!(package.exported_symbols.contains(&"bar".to_string()));
+        assert!(package.exported_symbols.contains(&"data1".to_string()));
+
+        assert!(!package.exported_symbols.contains(&"pkgdoc".to_string()));
+        assert!(!package.exported_symbols.contains(&"other".to_string()));
+    }
+}