Merge #9047 #9048

9047: fix: proc_macro_srv: temporary abi fix (rust-lang/rust#84717) r=lnicola a=lnicola

bors r+

9048: Add some lint completion tests r=Veykril a=Veykril

bors r+

Co-authored-by: cynecx <[email protected]>
Co-authored-by: Lukas Wirth <[email protected]>

Author: 3 people

crates/ide_completion/src/completions/attribute.rs

@@ -3,8 +3,6 @@
 //! This module uses a bit of static metadata to provide completions
 //! for built-in attributes.
 
-use std::mem;
-
 use once_cell::sync::Lazy;
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::{ast, AstNode, NodeOrToken, SyntaxKind, T};
@@ -272,27 +270,27 @@ const ATTRIBUTES: &[AttrCompletion] = &[
 fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Option<FxHashSet<String>> {
     let (l_paren, r_paren) = derive_input.l_paren_token().zip(derive_input.r_paren_token())?;
     let mut input_derives = FxHashSet::default();
-    let mut current_derive = String::new();
-    for token in derive_input
+    let mut tokens = derive_input
         .syntax()
         .children_with_tokens()
         .filter_map(NodeOrToken::into_token)
         .skip_while(|token| token != &l_paren)
         .skip(1)
         .take_while(|token| token != &r_paren)
-    {
-        if token.kind() == T![,] {
-            if !current_derive.is_empty() {
-                input_derives.insert(mem::take(&mut current_derive));
-            }
-        } else {
-            current_derive.push_str(token.text().trim());
+        .peekable();
+    let mut input = String::new();
+    while tokens.peek().is_some() {
+        for token in tokens.by_ref().take_while(|t| t.kind() != T![,]) {
+            input.push_str(token.text());
         }
-    }
 
-    if !current_derive.is_empty() {
-        input_derives.insert(current_derive);
+        if !input.is_empty() {
+            input_derives.insert(input.trim().to_owned());
+        }
+
+        input.clear();
     }
+
     Some(input_derives)
 }
 

crates/ide_completion/src/completions/attribute/derive.rs

@@ -45,6 +45,7 @@ pub(super) fn complete_derive(
         }
     }
 }
+
 fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
     let mut result = FxHashSet::default();
     ctx.scope.process_all_names(&mut |name, scope_def| {
@@ -89,12 +90,14 @@ mod tests {
     }
 
     #[test]
-    fn empty_derive_completion() {
+    fn no_completion_for_incorrect_derive() {
+        check(r#"#[derive{$0)] struct Test;"#, expect![[]])
+    }
+
+    #[test]
+    fn empty_derive() {
         check(
-            r#"
-#[derive($0)]
-struct Test {}
-        "#,
+            r#"#[derive($0)] struct Test;"#,
             expect![[r#"
                 at Clone
                 at Clone, Copy
@@ -110,23 +113,26 @@ struct Test {}
     }
 
     #[test]
-    fn no_completion_for_incorrect_derive() {
+    fn derive_with_input() {
         check(
-            r#"
-#[derive{$0)]
-struct Test {}
-"#,
-            expect![[r#""#]],
+            r#"#[derive(serde::Serialize, PartialEq, $0)] struct Test;"#,
+            expect![[r#"
+                at Clone
+                at Clone, Copy
+                at Debug
+                at Default
+                at Hash
+                at Eq
+                at PartialOrd
+                at Eq, PartialOrd, Ord
+            "#]],
         )
     }
 
     #[test]
-    fn derive_with_input_completion() {
+    fn derive_with_input2() {
         check(
-            r#"
-#[derive(serde::Serialize, PartialEq, $0)]
-struct Test {}
-"#,
+            r#"#[derive($0 serde::Serialize, PartialEq)] struct Test;"#,
             expect![[r#"
                 at Clone
                 at Clone, Copy

crates/ide_completion/src/completions/attribute/lint.rs

@@ -152,3 +152,36 @@ pub(super) const DEFAULT_LINT_COMPLETIONS: &[LintCompletion] = &[
     LintCompletion { label: "unconditional_panic", description: r#"operation will cause a panic at runtime"# },
     LintCompletion { label: "unknown_crate_types", description: r#"unknown crate type found in `#[crate_type]` directive"# },
 ];
+
+#[cfg(test)]
+mod tests {
+
+    use crate::test_utils::check_edit;
+
+    #[test]
+    fn check_empty() {
+        check_edit(
+            "deprecated",
+            r#"#[allow($0)] struct Test;"#,
+            r#"#[allow(deprecated)] struct Test;"#,
+        )
+    }
+
+    #[test]
+    fn check_with_existing() {
+        check_edit(
+            "deprecated",
+            r#"#[allow(keyword_idents, $0)] struct Test;"#,
+            r#"#[allow(keyword_idents, deprecated)] struct Test;"#,
+        )
+    }
+
+    #[test]
+    fn check_qualified() {
+        check_edit(
+            "deprecated",
+            r#"#[allow(keyword_idents, $0)] struct Test;"#,
+            r#"#[allow(keyword_idents, deprecated)] struct Test;"#,
+        )
+    }
+}

crates/proc_macro_srv/src/proc_macro/bridge/mod.rs

@@ -112,6 +112,7 @@ macro_rules! with_api {
             Literal {
                 fn drop($self: $S::Literal);
                 fn clone($self: &$S::Literal) -> $S::Literal;
+                fn from_str(s: &str) -> Result<$S::Literal, ()>;
                 fn debug_kind($self: &$S::Literal) -> String;
                 fn symbol($self: &$S::Literal) -> String;
                 fn suffix($self: &$S::Literal) -> Option<String>;
@@ -318,6 +319,19 @@ impl<T: Unmark> Unmark for Option<T> {
     }
 }
 
+impl<T: Mark, E: Mark> Mark for Result<T, E> {
+    type Unmarked = Result<T::Unmarked, E::Unmarked>;
+    fn mark(unmarked: Self::Unmarked) -> Self {
+        unmarked.map(T::mark).map_err(E::mark)
+    }
+}
+impl<T: Unmark, E: Unmark> Unmark for Result<T, E> {
+    type Unmarked = Result<T::Unmarked, E::Unmarked>;
+    fn unmark(self) -> Self::Unmarked {
+        self.map(T::unmark).map_err(E::unmark)
+    }
+}
+
 macro_rules! mark_noop {
     ($($ty:ty),* $(,)?) => {
         $(

crates/proc_macro_srv/src/proc_macro/mod.rs

@@ -37,6 +37,12 @@ pub struct LexError {
     _inner: (),
 }
 
+impl LexError {
+    fn new() -> Self {
+        LexError { _inner: () }
+    }
+}
+
 impl TokenStream {
     /// Returns an empty `TokenStream` containing no token trees.
     pub fn new() -> TokenStream {
@@ -925,6 +931,17 @@ impl fmt::Debug for Literal {
     }
 }
 
+impl FromStr for Literal {
+    type Err = LexError;
+
+    fn from_str(src: &str) -> Result<Self, LexError> {
+        match bridge::client::Literal::from_str(src) {
+            Ok(literal) => Ok(Literal(literal)),
+            Err(()) => Err(LexError::new()),
+        }
+    }
+}
+
 pub mod tracked_env {
     use std::env::{self, VarError};
     use std::ffi::OsStr;

crates/proc_macro_srv/src/rustc_server.rs

@@ -521,6 +521,9 @@ impl server::Ident for Rustc {
 }
 
 impl server::Literal for Rustc {
+    fn from_str(&mut self, _s: &str) -> Result<Self::Literal, ()> {
+        unimplemented!()
+    }
     fn debug_kind(&mut self, _literal: &Self::Literal) -> String {
         // r-a: debug_kind and suffix are unsupported; corresponding client code has been changed to not call these.
         // They must still be present to be ABI-compatible and work with upstream proc_macro.