don't offer to re-wrap anonymous functions

Author: treuherz

compiler-core/src/ast/untyped.rs

@@ -298,6 +298,13 @@ pub enum FunctionLiteralKind {
 }
 
 impl FunctionLiteralKind {
+    pub fn is_anonymous(&self) -> bool {
+        match self {
+            FunctionLiteralKind::Anonymous { .. } => true,
+            FunctionLiteralKind::Capture { .. } | FunctionLiteralKind::Use { .. } => false,
+        }
+    }
+
     pub fn is_capture(&self) -> bool {
         match self {
             FunctionLiteralKind::Capture { .. } => true,

compiler-core/src/language_server/code_action.rs

@@ -8285,7 +8285,14 @@ impl<'ast> ast::visit::Visit<'ast> for WrapInAnonymousFunction<'ast> {
             return;
         }
 
-        if let Type::Fn { ref arguments, .. } = *expression.type_() {
+        let is_excluded = match expression {
+            TypedExpr::Fn { kind, .. } if kind.is_anonymous() => true,
+            _ => false,
+        };
+
+        if let Type::Fn { arguments, .. } = &*expression.type_()
+            && !is_excluded
+        {
             self.functions.push(FunctionToWrap {
                 location: expression.location(),
                 arguments: arguments.clone(),
@@ -8299,7 +8306,7 @@ impl<'ast> ast::visit::Visit<'ast> for WrapInAnonymousFunction<'ast> {
     /// We don't want to apply to functions that are being explicitly called
     /// already, so we need to intercept visits to function calls and bounce
     /// them out again so they don't end up in our impl for visit_typed_expr.
-    /// Otherwise this is the same as [ast::visit::visit_typed_expr_call].
+    /// Otherwise this is the same as [].
     fn visit_typed_expr_call(
         &mut self,
         _location: &'ast SrcSpan,

compiler-core/src/language_server/tests/action.rs

@@ -9901,8 +9901,8 @@ pub fn main() {
 }
 
 #[test]
-fn wrap_anonymous_function_in_anonymous_function() {
-    assert_code_action!(
+fn dont_wrap_anonymous_function_in_anonymous_function() {
+    assert_no_code_actions!(
         WRAP_IN_ANONYMOUS_FUNCTION,
         "pub fn main() {
   let f = fn(in) { ception(in) }