Bail when character.only is supplied

Author: lionel-

crates/ark/src/lsp/diagnostics.rs

@@ -822,12 +822,23 @@ fn recurse_call(
 }
 
 fn handle_package_attach_call(node: Node, context: &mut DiagnosticContext) -> anyhow::Result<()> {
-    // Find the first argument (package name). Positionally for now.
-    let Some(value) = node.arguments_values().nth(0) else {
+    // Find the first argument (package name). Positionally for now, no attempt
+    // at argument matching whatsoever.
+    let Some(package_node) = node.arguments_values().nth(0) else {
         return Err(anyhow::anyhow!("Can't unpack attached package argument"));
     };
 
-    let package_name = value.get_identifier_or_string_text(context.contents)?;
+    // Just bail if `character.only` is passed, even if it's actually `FALSE`.
+    // We'll do better when we have a more capable argument inspection
+    // infrastructure.
+    if let Some(_) = node
+        .arguments_names_as_string(context.contents)
+        .find(|n| n == "character.only")
+    {
+        return Ok(());
+    }
+
+    let package_name = package_node.get_identifier_or_string_text(context.contents)?;
     let attach_pos = node.end_position();
 
     let package = match insert_package_exports(&package_name, attach_pos, context) {
@@ -1666,8 +1677,26 @@ foo
                 bar
             ";
             let document = Document::new(code, None);
-            let diagnostics = generate_diagnostics(document, state);
+            let diagnostics = generate_diagnostics(document, state.clone());
             assert_eq!(diagnostics.len(), 0);
+
+            // If the library call includes the `character.only` argument, we bail
+            let code = r#"
+                library(mockpkg, character.only = TRUE)
+                foo()
+            "#;
+            let document = Document::new(code, None);
+            let diagnostics = generate_diagnostics(document, state.clone());
+            assert_eq!(diagnostics.len(), 1);
+
+            // Same if passed `FALSE`, we're not trying to be smart (yet)
+            let code = r#"
+                library(mockpkg, character.only = FALSE)
+                foo()
+            "#;
+            let document = Document::new(code, None);
+            let diagnostics = generate_diagnostics(document, state);
+            assert_eq!(diagnostics.len(), 1);
         });
     }
 

crates/ark/src/lsp/traits/node.rs

@@ -11,6 +11,7 @@ use tree_sitter::Range;
 use tree_sitter::TreeCursor;
 
 use crate::lsp::traits::point::PointExt;
+use crate::lsp::traits::rope::RopeExt;
 
 fn _dump_impl(cursor: &mut TreeCursor, source: &str, indent: &str, output: &mut String) {
     let node = cursor.node();
@@ -95,6 +96,7 @@ pub trait NodeExt: Sized {
     fn arguments(&self) -> impl Iterator<Item = (Option<Self>, Option<Self>)>;
     fn arguments_values(&self) -> impl Iterator<Item = Self>;
     fn arguments_names(&self) -> impl Iterator<Item = Self>;
+    fn arguments_names_as_string(&self, contents: &ropey::Rope) -> impl Iterator<Item = String>;
 }
 
 impl<'tree> NodeExt for Node<'tree> {
@@ -279,6 +281,18 @@ impl<'tree> NodeExt for Node<'tree> {
         self.arguments().filter_map(|(name, _value)| name)
     }
 
+    fn arguments_names_as_string(&self, contents: &ropey::Rope) -> impl Iterator<Item = String> {
+        self.arguments_names().filter_map(|node| -> Option<String> {
+            match contents.node_slice(&node) {
+                Err(err) => {
+                    tracing::error!("Can't convert argument name to text: {err:?}");
+                    None
+                },
+                Ok(text) => Some(text.to_string()),
+            }
+        })
+    }
+
     fn arguments_values(&self) -> impl Iterator<Item = Node<'tree>> {
         self.arguments().filter_map(|(_name, value)| value)
     }