Filter where clause predicates

Author: DorianListens

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

@@ -697,7 +697,9 @@ impl FunctionBody {
             }
         };
 
-        let (mut generic_param_list, mut where_clause) = (None, None);
+        let mut generic_param_list = None;
+        let mut where_clause = None;
+
         let (is_const, expr, ty) = loop {
             let anc = ancestors.next()?;
             break match_ast! {
@@ -1346,93 +1348,144 @@ fn format_function(
     let const_kw = if fun.mods.is_const { "const " } else { "" };
     let async_kw = if fun.control_flow.is_async { "async " } else { "" };
     let unsafe_kw = if fun.control_flow.is_unsafe { "unsafe " } else { "" };
-    let (generic_params, where_clause) = format_generic_params_and_where_clause(ctx, fun);
+    let (generic_params, where_clause) = make_generic_params_and_where_clause(ctx, fun);
     match ctx.config.snippet_cap {
         Some(_) => format_to!(
             fn_def,
-            "\n\n{}{}{}{}fn $0{}{}{}{}",
+            "\n\n{}{}{}{}fn $0{}",
             new_indent,
             const_kw,
             async_kw,
             unsafe_kw,
             fun.name,
-            generic_params,
-            params,
-            where_clause
         ),
         None => format_to!(
             fn_def,
-            "\n\n{}{}{}{}fn {}{}{}{}",
+            "\n\n{}{}{}{}fn {}",
             new_indent,
             const_kw,
             async_kw,
             unsafe_kw,
             fun.name,
-            generic_params,
-            params,
-            where_clause,
         ),
     }
+
+    if let Some(generic_params) = generic_params {
+        format_to!(fn_def, "{}", generic_params);
+    }
+
+    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);
     }
+
     format_to!(fn_def, " {}", body);
 
     fn_def
 }
 
-fn format_generic_params_and_where_clause(ctx: &AssistContext, fun: &Function) -> (String, String) {
-    (format_generic_param_list(fun, ctx), format_where_clause(fun))
-}
-
-fn format_generic_param_list(fun: &Function, ctx: &AssistContext) -> String {
-    let type_params_in_descendant_paths =
-        fun.body.descendant_paths().filter_map(|it| match ctx.sema.resolve_path(&it) {
-            Some(PathResolution::TypeParam(type_param)) => Some(type_param),
-            _ => None,
+fn make_generic_params_and_where_clause(
+    ctx: &AssistContext,
+    fun: &Function,
+) -> (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 type_params_in_params = fun.params.iter().filter_map(|p| p.ty.as_type_param(ctx.db()));
+    (generic_param_list, where_clause)
+}
 
-    let used_type_params: Vec<TypeParam> =
-        type_params_in_descendant_paths.chain(type_params_in_params).collect();
+fn make_generic_param_list(
+    ctx: &AssistContext,
+    parent_params: &ast::GenericParamList,
+    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
+    } else {
+        Some(make::generic_param_list(required_generic_params))
+    }
+}
 
-    match &fun.mods.generic_param_list {
-        Some(list) => {
-            let filtered_generic_params = filter_generic_param_list(ctx, list, used_type_params);
-            if filtered_generic_params.is_empty() {
-                return "".to_string();
-            }
-            format!("{}", make::generic_param_list(filtered_generic_params))
-        }
-        None => "".to_string(),
+fn param_is_required(
+    ctx: &AssistContext,
+    param: &ast::GenericParam,
+    used_type_params: &[TypeParam],
+) -> bool {
+    match param {
+        ast::GenericParam::ConstParam(_) | ast::GenericParam::LifetimeParam(_) => true,
+        ast::GenericParam::TypeParam(type_param) => match &ctx.sema.to_def(type_param) {
+            Some(def) => used_type_params.iter().contains(def),
+            _ => false,
+        },
     }
 }
 
-fn filter_generic_param_list(
+fn make_where_clause(
     ctx: &AssistContext,
-    list: &ast::GenericParamList,
-    used_type_params: Vec<TypeParam>,
-) -> Vec<ast::GenericParam> {
-    list.generic_params()
-        .filter(|p| match p {
-            ast::GenericParam::ConstParam(_) | ast::GenericParam::LifetimeParam(_) => true,
-            ast::GenericParam::TypeParam(type_param) => match &ctx.sema.to_def(type_param) {
-                Some(def) => used_type_params.iter().contains(def),
-                _ => false,
-            },
-        })
-        .collect()
+    parent_where_clause: &ast::WhereClause,
+    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)
 }
 
-fn format_where_clause(fun: &Function) -> String {
-    match &fun.mods.where_clause {
-        Some(it) => format!(" {}", it),
-        None => "".to_string(),
+fn pred_is_required(
+    ctx: &AssistContext,
+    pred: &ast::WherePred,
+    used_type_params: &[TypeParam],
+) -> bool {
+    match resolved_type_param(ctx, pred) {
+        Some(it) => used_type_params.contains(&it),
+        None => false,
+    }
+}
+
+fn resolved_type_param(ctx: &AssistContext, pred: &ast::WherePred) -> Option<TypeParam> {
+    let path = match pred.ty()? {
+        ast::Type::PathType(path_type) => path_type.path(),
+        _ => None,
+    }?;
+
+    match ctx.sema.resolve_path(&path)? {
+        PathResolution::TypeParam(type_param) => Some(type_param),
+        _ => None,
     }
 }
 
 impl Function {
+    /// Collect all the `TypeParam`s used in the `body` and `params`.
+    fn type_params(&self, ctx: &AssistContext) -> Vec<TypeParam> {
+        let type_params_in_descendant_paths =
+            self.body.descendant_paths().filter_map(|it| match ctx.sema.resolve_path(&it) {
+                Some(PathResolution::TypeParam(type_param)) => Some(type_param),
+                _ => None,
+            });
+        let type_params_in_params = self.params.iter().filter_map(|p| p.ty.as_type_param(ctx.db()));
+        type_params_in_descendant_paths.chain(type_params_in_params).collect()
+    }
+
     fn make_param_list(&self, ctx: &AssistContext, module: hir::Module) -> ast::ParamList {
         let self_param = self.self_param.clone();
         let params = self.params.iter().map(|param| param.to_param(ctx, module));
@@ -4906,6 +4959,29 @@ fn func<T>(i: T) where T: Debug {
     fun_name(i);
 }
 
+fn $0fun_name<T>(i: T) where T: Debug {
+    foo(i);
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn filter_unused_where_clause() {
+        check_assist(
+            extract_function,
+            r#"
+fn func<T, U>(i: T, u: U) where T: Debug, U: Copy {
+    bar(u);
+    $0foo(i);$0
+}
+"#,
+            r#"
+fn func<T, U>(i: T, u: U) where T: Debug, U: Copy {
+    bar(u);
+    fun_name(i);
+}
+
 fn $0fun_name<T>(i: T) where T: Debug {
     foo(i);
 }