Support nested generics and where clauses

Instead of only looking for generics and where clauses on the immediate parent,
we can traverse all the `ancestors` and collect all the generics and where
clauses that may be in scope.

Author: DorianListens

crates/ide-assists/src/handlers/extract_function.rs

@@ -284,8 +284,8 @@ struct ContainerInfo {
     parent_loop: Option<SyntaxNode>,
     /// The function's return type, const's type etc.
     ret_type: Option<hir::Type>,
-    generic_param_list: Option<ast::GenericParamList>,
-    where_clause: Option<ast::WhereClause>,
+    generic_param_lists: Vec<ast::GenericParamList>,
+    where_clauses: Vec<ast::WhereClause>,
 }
 
 /// Control flow that is exported from extracted function
@@ -715,15 +715,11 @@ impl FunctionBody {
             }
         };
 
-        let mut generic_param_list = None;
-        let mut where_clause = None;
-
         let (is_const, expr, ty) = loop {
             let anc = ancestors.next()?;
             break match_ast! {
                 match anc {
                     ast::ClosureExpr(closure) => {
-                        generic_param_list = closure.generic_param_list();
                         (false, closure.body(), infer_expr_opt(closure.body()))
                     },
                     ast::BlockExpr(block_expr) => {
@@ -744,8 +740,6 @@ impl FunctionBody {
                                 ret_ty = async_ret;
                             }
                         }
-                        generic_param_list = fn_.generic_param_list();
-                        where_clause = fn_.where_clause();
                         (fn_.const_token().is_some(), fn_.body().map(ast::Expr::BlockExpr), Some(ret_ty))
                     },
                     ast::Static(statik) => {
@@ -790,13 +784,18 @@ impl FunctionBody {
             container_tail.zip(self.tail_expr()).map_or(false, |(container_tail, body_tail)| {
                 container_tail.syntax().text_range().contains_range(body_tail.syntax().text_range())
             });
+
+        let parent = self.parent()?;
+        let generic_param_list = parent_generic_param_lists(&parent);
+        let where_clause = parent_where_clauses(&parent);
+
         Some(ContainerInfo {
             is_in_tail,
             is_const,
             parent_loop,
             ret_type: ty,
-            generic_param_list,
-            where_clause,
+            generic_param_lists: generic_param_list,
+            where_clauses: where_clause,
         })
     }
 
@@ -954,6 +953,26 @@ impl FunctionBody {
     }
 }
 
+fn parent_where_clauses(parent: &SyntaxNode) -> Vec<ast::WhereClause> {
+    let mut where_clause: Vec<ast::WhereClause> = parent
+        .ancestors()
+        .filter_map(ast::AnyHasGenericParams::cast)
+        .filter_map(|it| it.where_clause())
+        .collect();
+    where_clause.reverse();
+    where_clause
+}
+
+fn parent_generic_param_lists(parent: &SyntaxNode) -> Vec<ast::GenericParamList> {
+    let mut generic_param_list: Vec<ast::GenericParamList> = parent
+        .ancestors()
+        .filter_map(ast::AnyHasGenericParams::cast)
+        .filter_map(|it| it.generic_param_list())
+        .collect();
+    generic_param_list.reverse();
+    generic_param_list
+}
+
 /// checks if relevant var is used with `&mut` access inside body
 fn has_exclusive_usages(ctx: &AssistContext, usages: &LocalUsages, body: &FunctionBody) -> bool {
     usages
@@ -1393,14 +1412,14 @@ fn format_function(
 
     format_to!(fn_def, "{}", params);
 
-    if let Some(where_clause) = where_clause {
-        format_to!(fn_def, " {}", where_clause);
-    }
-
     if let Some(ret_ty) = ret_ty {
         format_to!(fn_def, " {}", ret_ty);
     }
 
+    if let Some(where_clause) = where_clause {
+        format_to!(fn_def, " {}", where_clause);
+    }
+
     format_to!(fn_def, " {}", body);
 
     fn_def
@@ -1412,34 +1431,32 @@ fn make_generic_params_and_where_clause(
 ) -> (Option<ast::GenericParamList>, Option<ast::WhereClause>) {
     let used_type_params = fun.type_params(ctx);
 
-    let generic_param_list = fun
-        .mods
-        .generic_param_list
-        .as_ref()
-        .map(|parent_params| make_generic_param_list(ctx, parent_params, &used_type_params))
-        .flatten();
-
-    let where_clause =
-        fun.mods.where_clause.as_ref().map(|parent_where_clause| {
-            make_where_clause(ctx, parent_where_clause, &used_type_params)
-        });
+    let generic_param_list = make_generic_param_list(ctx, fun, &used_type_params);
+    let where_clause = make_where_clause(ctx, fun, &used_type_params);
 
     (generic_param_list, where_clause)
 }
 
 fn make_generic_param_list(
     ctx: &AssistContext,
-    parent_params: &ast::GenericParamList,
+    fun: &Function,
     used_type_params: &[TypeParam],
 ) -> Option<ast::GenericParamList> {
-    let required_generic_params: Vec<ast::GenericParam> = parent_params
-        .generic_params()
-        .filter(|param| param_is_required(ctx, param, used_type_params))
-        .collect();
-    if required_generic_params.is_empty() {
-        None
+    let mut generic_params = fun
+        .mods
+        .generic_param_lists
+        .iter()
+        .flat_map(|parent_params| {
+            parent_params
+                .generic_params()
+                .filter(|param| param_is_required(ctx, param, used_type_params))
+        })
+        .peekable();
+
+    if generic_params.peek().is_some() {
+        Some(make::generic_param_list(generic_params))
     } else {
-        Some(make::generic_param_list(required_generic_params))
+        None
     }
 }
 
@@ -1451,21 +1468,33 @@ fn param_is_required(
     match param {
         ast::GenericParam::ConstParam(_) | ast::GenericParam::LifetimeParam(_) => false,
         ast::GenericParam::TypeParam(type_param) => match &ctx.sema.to_def(type_param) {
-            Some(def) => used_type_params.iter().contains(def),
+            Some(def) => used_type_params.contains(def),
             _ => false,
         },
     }
 }
 
 fn make_where_clause(
     ctx: &AssistContext,
-    parent_where_clause: &ast::WhereClause,
+    fun: &Function,
     used_type_params: &[TypeParam],
-) -> ast::WhereClause {
-    let preds = parent_where_clause
-        .predicates()
-        .filter(|pred| pred_is_required(ctx, pred, used_type_params));
-    make::where_clause(preds)
+) -> Option<ast::WhereClause> {
+    let mut predicates = fun
+        .mods
+        .where_clauses
+        .iter()
+        .flat_map(|parent_where_clause| {
+            parent_where_clause
+                .predicates()
+                .filter(|pred| pred_is_required(ctx, pred, used_type_params))
+        })
+        .peekable();
+
+    if predicates.peek().is_some() {
+        Some(make::where_clause(predicates))
+    } else {
+        None
+    }
 }
 
 fn pred_is_required(
@@ -5052,6 +5081,122 @@ fn func<T, U>(i: T, u: U) where T: Debug, U: Copy {
 fn $0fun_name<T>(i: T) where T: Debug {
     foo(i);
 }
+"#,
+        );
+    }
+
+    #[test]
+    fn nested_generics() {
+        check_assist(
+            extract_function,
+            r#"
+struct Struct<T: Into<i32>>(T);
+impl <T: Into<i32> + Copy> Struct<T> {
+    fn func<V: Into<i32>>(&self, v: V) -> i32 {
+        let t = self.0;
+        $0t.into() + v.into()$0
+    }
+}
+"#,
+            r#"
+struct Struct<T: Into<i32>>(T);
+impl <T: Into<i32> + Copy> Struct<T> {
+    fn func<V: Into<i32>>(&self, v: V) -> i32 {
+        let t = self.0;
+        fun_name(t, v)
+    }
+}
+
+fn $0fun_name<T: Into<i32> + Copy, V: Into<i32>>(t: T, v: V) -> i32 {
+    t.into() + v.into()
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn filters_unused_nested_generics() {
+        check_assist(
+            extract_function,
+            r#"
+struct Struct<T: Into<i32>, U: Debug>(T, U);
+impl <T: Into<i32> + Copy, U: Debug> Struct<T, U> {
+    fn func<V: Into<i32>>(&self, v: V) -> i32 {
+        let t = self.0;
+        $0t.into() + v.into()$0
+    }
+}
+"#,
+            r#"
+struct Struct<T: Into<i32>, U: Debug>(T, U);
+impl <T: Into<i32> + Copy, U: Debug> Struct<T, U> {
+    fn func<V: Into<i32>>(&self, v: V) -> i32 {
+        let t = self.0;
+        fun_name(t, v)
+    }
+}
+
+fn $0fun_name<T: Into<i32> + Copy, V: Into<i32>>(t: T, v: V) -> i32 {
+    t.into() + v.into()
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn nested_where_clauses() {
+        check_assist(
+            extract_function,
+            r#"
+struct Struct<T>(T) where T: Into<i32>;
+impl <T> Struct<T> where T: Into<i32> + Copy {
+    fn func<V>(&self, v: V) -> i32 where V: Into<i32> {
+        let t = self.0;
+        $0t.into() + v.into()$0
+    }
+}
+"#,
+            r#"
+struct Struct<T>(T) where T: Into<i32>;
+impl <T> Struct<T> where T: Into<i32> + Copy {
+    fn func<V>(&self, v: V) -> i32 where V: Into<i32> {
+        let t = self.0;
+        fun_name(t, v)
+    }
+}
+
+fn $0fun_name<T, V>(t: T, v: V) -> i32 where T: Into<i32> + Copy, V: Into<i32> {
+    t.into() + v.into()
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn filters_unused_nested_where_clauses() {
+        check_assist(
+            extract_function,
+            r#"
+struct Struct<T, U>(T, U) where T: Into<i32>, U: Debug;
+impl <T, U> Struct<T, U> where T: Into<i32> + Copy, U: Debug {
+    fn func<V>(&self, v: V) -> i32 where V: Into<i32> {
+        let t = self.0;
+        $0t.into() + v.into()$0
+    }
+}
+"#,
+            r#"
+struct Struct<T, U>(T, U) where T: Into<i32>, U: Debug;
+impl <T, U> Struct<T, U> where T: Into<i32> + Copy, U: Debug {
+    fn func<V>(&self, v: V) -> i32 where V: Into<i32> {
+        let t = self.0;
+        fun_name(t, v)
+    }
+}
+
+fn $0fun_name<T, V>(t: T, v: V) -> i32 where T: Into<i32> + Copy, V: Into<i32> {
+    t.into() + v.into()
+}
 "#,
         );
     }