crates/ide_assists/src/lib.rs

   1 //! `assists` crate provides a bunch of code assists, also known as code actions
   2 //! (in LSP) or intentions (in IntelliJ).
   3 //!
   4 //! An assist is a micro-refactoring, which is automatically activated in
   5 //! certain context. For example, if the cursor is over `,`, a "swap `,`" assist
   6 //! becomes available.
   7 //!
   8 //! ## Assists Guidelines
   9 //!
  10 //! Assists are the main mechanism to deliver advanced IDE features to the user,
  11 //! so we should pay extra attention to the UX.
  12 //!
  13 //! The power of assists comes from their context-awareness. The main problem
  14 //! with IDE features is that there are a lot of them, and it's hard to teach
  15 //! the user what's available. Assists solve this problem nicely: 💡 signifies
  16 //! that *something* is possible, and clicking on it reveals a *short* list of
  17 //! actions. Contrast it with Emacs `M-x`, which just spits an infinite list of
  18 //! all the features.
  19 //!
  20 //! Here are some considerations when creating a new assist:
  21 //!
  22 //! * It's good to preserve semantics, and it's good to keep the code compiling,
  23 //!   but it isn't necessary. Example: "flip binary operation" might change
  24 //!   semantics.
  25 //! * Assist shouldn't necessary make the code "better". A lot of assist come in
  26 //!   pairs: "if let <-> match".
  27 //! * Assists should have as narrow scope as possible. Each new assists greatly
  28 //!   improves UX for cases where the user actually invokes it, but it makes UX
  29 //!   worse for every case where the user clicks 💡 to invoke some *other*
  30 //!   assist. So, a rarely useful assist which is always applicable can be a net
  31 //!   negative.
  32 //! * Rarely useful actions are tricky. Sometimes there are features which are
  33 //!   clearly useful to some users, but are just noise most of the time. We
  34 //!   don't have a good solution here, our current approach is to make this
  35 //!   functionality available only if assist is applicable to the whole
  36 //!   selection. Example: `sort_items` sorts items alphabetically. Naively, it
  37 //!   should be available more or less everywhere, which isn't useful. So
  38 //!   instead we only show it if the user *selects* the items they want to sort.
  39 //! * Consider grouping related assists together (see [`Assists::add_group`]).
  40 //! * Make assists robust. If the assist depends on results of type-inference to
  41 //!   much, it might only fire in fully-correct code. This makes assist less
  42 //!   useful and (worse) less predictable. The user should have a clear
  43 //!   intuition when each particular assist is available.
  44 //! * Make small assists, which compose. Example: rather than auto-importing
  45 //!   enums in `fill_match_arms`, we use fully-qualified names. There's a
  46 //!   separate assist to shorten a fully-qualified name.
  47 //! * Distinguish between assists and fixits for diagnostics. Internally, fixits
  48 //!   and assists are equivalent. They have the same "show a list + invoke a
  49 //!   single element" workflow, and both use [`Assist`] data structure. The main
  50 //!   difference is in the UX: while 💡 looks only at the cursor position,
  51 //!   diagnostics squigglies and fixits are calculated for the whole file and
  52 //!   are presented to the user eagerly. So, diagnostics should be fixable
  53 //!   errors, while assists can be just suggestions for an alternative way to do
  54 //!   something. If something *could* be a diagnostic, it should be a
  55 //!   diagnostic. Conversely, it might be valuable to turn a diagnostic with a
  56 //!   lot of false errors into an assist.
  57 //! *
  58 //!
  59 //! See also this post:
  60 //! <https://rust-analyzer.github.io/blog/2020/09/28/how-to-make-a-light-bulb.html>
  61 #[allow(unused)]
  62 macro_rules! eprintln {
  63     ($($tt:tt)*) => { stdx::eprintln!($($tt)*) };
  64 }
  65
  66 mod assist_config;
  67 mod assist_context;
  68 #[cfg(test)]
  69 mod tests;
  70 pub mod utils;
  71
  72 use hir::Semantics;
  73 use ide_db::{base_db::FileRange, RootDatabase};
  74 use syntax::TextRange;
  75
  76 pub(crate) use crate::assist_context::{AssistContext, Assists};
  77
  78 pub use assist_config::AssistConfig;
  79 pub use ide_db::assists::{
  80     Assist, AssistId, AssistKind, AssistResolveStrategy, GroupLabel, SingleResolve,
  81 };
  82
  83 /// Return all the assists applicable at the given position.
  84 ///
  85 // NOTE: We don't have a `Feature: ` section for assists, they are special-cased
  86 // in the manual.
  87 pub fn assists(
  88     db: &RootDatabase,
  89     config: &AssistConfig,
  90     resolve: AssistResolveStrategy,
  91     range: FileRange,
  92 ) -> Vec<Assist> {
  93     let sema = Semantics::new(db);
  94     let ctx = AssistContext::new(sema, config, range);
  95     let mut acc = Assists::new(&ctx, resolve);
  96     handlers::all().iter().for_each(|handler| {
  97         handler(&mut acc, &ctx);
  98     });
  99     acc.finish()
 100 }
 101
 102 mod handlers {
 103     use crate::{AssistContext, Assists};
 104
 105     pub(crate) type Handler = fn(&mut Assists, &AssistContext) -> Option<()>;
 106
 107     mod add_explicit_type;
 108     mod add_lifetime_to_type;
 109     mod add_missing_impl_members;
 110     mod add_turbo_fish;
 111     mod apply_demorgan;
 112     mod auto_import;
 113     mod change_visibility;
 114     mod convert_bool_then;
 115     mod convert_comment_block;
 116     mod convert_integer_literal;
 117     mod convert_into_to_from;
 118     mod convert_iter_for_each_to_for;
 119     mod convert_tuple_struct_to_named_struct;
 120     mod convert_to_guarded_return;
 121     mod convert_while_to_loop;
 122     mod destructure_tuple_binding;
 123     mod expand_glob_import;
 124     mod extract_function;
 125     mod extract_struct_from_enum_variant;
 126     mod extract_type_alias;
 127     mod extract_variable;
 128     mod add_missing_match_arms;
 129     mod fix_visibility;
 130     mod flip_binexpr;
 131     mod flip_comma;
 132     mod flip_trait_bound;
 133     mod generate_constant;
 134     mod generate_default_from_enum_variant;
 135     mod generate_default_from_new;
 136     mod generate_deref;
 137     mod generate_derive;
 138     mod generate_enum_is_method;
 139     mod generate_enum_projection_method;
 140     mod generate_from_impl_for_enum;
 141     mod generate_function;
 142     mod generate_getter;
 143     mod generate_impl;
 144     mod generate_is_empty_from_len;
 145     mod generate_new;
 146     mod generate_setter;
 147     mod add_return_type;
 148     mod inline_call;
 149     mod inline_local_variable;
 150     mod introduce_named_lifetime;
 151     mod invert_if;
 152     mod merge_imports;
 153     mod merge_match_arms;
 154     mod move_bounds;
 155     mod move_guard;
 156     mod move_module_to_file;
 157     mod move_to_mod_rs;
 158     mod move_from_mod_rs;
 159     mod pull_assignment_up;
 160     mod qualify_path;
 161     mod raw_string;
 162     mod remove_dbg;
 163     mod remove_mut;
 164     mod remove_unused_param;
 165     mod reorder_fields;
 166     mod reorder_impl;
 167     mod replace_derive_with_manual_impl;
 168     mod replace_if_let_with_match;
 169     mod introduce_named_generic;
 170     mod replace_let_with_if_let;
 171     mod replace_qualified_name_with_use;
 172     mod replace_string_with_char;
 173     mod split_import;
 174     mod sort_items;
 175     mod toggle_ignore;
 176     mod unmerge_use;
 177     mod unwrap_block;
 178     mod wrap_return_type_in_result;
 179
 180     pub(crate) fn all() -> &'static [Handler] {
 181         &[
 182             // These are alphabetic for the foolish consistency
 183             add_explicit_type::add_explicit_type,
 184             add_missing_match_arms::add_missing_match_arms,
 185             add_lifetime_to_type::add_lifetime_to_type,
 186             add_return_type::add_return_type,
 187             add_turbo_fish::add_turbo_fish,
 188             apply_demorgan::apply_demorgan,
 189             auto_import::auto_import,
 190             change_visibility::change_visibility,
 191             convert_bool_then::convert_bool_then_to_if,
 192             convert_bool_then::convert_if_to_bool_then,
 193             convert_comment_block::convert_comment_block,
 194             convert_integer_literal::convert_integer_literal,
 195             convert_into_to_from::convert_into_to_from,
 196             convert_iter_for_each_to_for::convert_iter_for_each_to_for,
 197             convert_iter_for_each_to_for::convert_for_loop_with_for_each,
 198             convert_to_guarded_return::convert_to_guarded_return,
 199             convert_tuple_struct_to_named_struct::convert_tuple_struct_to_named_struct,
 200             convert_while_to_loop::convert_while_to_loop,
 201             destructure_tuple_binding::destructure_tuple_binding,
 202             expand_glob_import::expand_glob_import,
 203             extract_struct_from_enum_variant::extract_struct_from_enum_variant,
 204             extract_type_alias::extract_type_alias,
 205             fix_visibility::fix_visibility,
 206             flip_binexpr::flip_binexpr,
 207             flip_comma::flip_comma,
 208             flip_trait_bound::flip_trait_bound,
 209             generate_constant::generate_constant,
 210             generate_default_from_enum_variant::generate_default_from_enum_variant,
 211             generate_default_from_new::generate_default_from_new,
 212             generate_deref::generate_deref,
 213             generate_derive::generate_derive,
 214             generate_enum_is_method::generate_enum_is_method,
 215             generate_enum_projection_method::generate_enum_as_method,
 216             generate_enum_projection_method::generate_enum_try_into_method,
 217             generate_from_impl_for_enum::generate_from_impl_for_enum,
 218             generate_function::generate_function,
 219             generate_impl::generate_impl,
 220             generate_is_empty_from_len::generate_is_empty_from_len,
 221             generate_new::generate_new,
 222             inline_call::inline_call,
 223             inline_call::inline_into_callers,
 224             inline_local_variable::inline_local_variable,
 225             introduce_named_generic::introduce_named_generic,
 226             introduce_named_lifetime::introduce_named_lifetime,
 227             invert_if::invert_if,
 228             merge_imports::merge_imports,
 229             merge_match_arms::merge_match_arms,
 230             move_bounds::move_bounds_to_where_clause,
 231             move_guard::move_arm_cond_to_match_guard,
 232             move_guard::move_guard_to_arm_body,
 233             move_module_to_file::move_module_to_file,
 234             move_to_mod_rs::move_to_mod_rs,
 235             move_from_mod_rs::move_from_mod_rs,
 236             pull_assignment_up::pull_assignment_up,
 237             qualify_path::qualify_path,
 238             raw_string::add_hash,
 239             raw_string::make_usual_string,
 240             raw_string::remove_hash,
 241             remove_dbg::remove_dbg,
 242             remove_mut::remove_mut,
 243             remove_unused_param::remove_unused_param,
 244             reorder_fields::reorder_fields,
 245             reorder_impl::reorder_impl,
 246             replace_derive_with_manual_impl::replace_derive_with_manual_impl,
 247             replace_if_let_with_match::replace_if_let_with_match,
 248             replace_if_let_with_match::replace_match_with_if_let,
 249             replace_let_with_if_let::replace_let_with_if_let,
 250             replace_qualified_name_with_use::replace_qualified_name_with_use,
 251             sort_items::sort_items,
 252             split_import::split_import,
 253             toggle_ignore::toggle_ignore,
 254             unmerge_use::unmerge_use,
 255             unwrap_block::unwrap_block,
 256             wrap_return_type_in_result::wrap_return_type_in_result,
 257             // These are manually sorted for better priorities. By default,
 258             // priority is determined by the size of the target range (smaller
 259             // target wins). If the ranges are equal, position in this list is
 260             // used as a tie-breaker.
 261             add_missing_impl_members::add_missing_impl_members,
 262             add_missing_impl_members::add_missing_default_members,
 263             //
 264             replace_string_with_char::replace_string_with_char,
 265             replace_string_with_char::replace_char_with_string,
 266             raw_string::make_raw_string,
 267             //
 268             extract_variable::extract_variable,
 269             extract_function::extract_function,
 270             //
 271             generate_getter::generate_getter,
 272             generate_getter::generate_getter_mut,
 273             generate_setter::generate_setter,
 274             // Are you sure you want to add new assist here, and not to the
 275             // sorted list above?
 276         ]
 277     }
 278 }