Merge #5592

5592: Rename TypeParamList -> GenericParamList r=matklad a=matklad



bors r+
🤖

Co-authored-by: Aleksey Kladov <[email protected]>

Author: bors[bot]

crates/ra_assists/src/handlers/generate_function.rs

@@ -104,7 +104,7 @@ impl FunctionTemplate {
 struct FunctionBuilder {
     target: GeneratedFunctionTarget,
     fn_name: ast::Name,
-    type_params: Option<ast::TypeParamList>,
+    type_params: Option<ast::GenericParamList>,
     params: ast::ParamList,
     file: FileId,
     needs_pub: bool,
@@ -200,7 +200,7 @@ fn fn_args(
     ctx: &AssistContext,
     target_module: hir::Module,
     call: &ast::CallExpr,
-) -> Option<(Option<ast::TypeParamList>, ast::ParamList)> {
+) -> Option<(Option<ast::GenericParamList>, ast::ParamList)> {
     let mut arg_names = Vec::new();
     let mut arg_types = Vec::new();
     for arg in call.arg_list()?.args() {

crates/ra_assists/src/handlers/generate_impl.rs

@@ -1,4 +1,4 @@
-use ra_syntax::ast::{self, AstNode, NameOwner, TypeParamsOwner};
+use ra_syntax::ast::{self, AstNode, GenericParamsOwner, NameOwner};
 use stdx::{format_to, SepBy};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -31,7 +31,7 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()
         format!("Generate impl for `{}`", name),
         target,
         |edit| {
-            let type_params = nominal.type_param_list();
+            let type_params = nominal.generic_param_list();
             let start_offset = nominal.syntax().text_range().end();
             let mut buf = String::new();
             buf.push_str("\n\nimpl");

crates/ra_assists/src/handlers/generate_new.rs

@@ -1,7 +1,8 @@
 use hir::Adt;
 use ra_syntax::{
     ast::{
-        self, AstNode, NameOwner, StructKind, TypeAscriptionOwner, TypeParamsOwner, VisibilityOwner,
+        self, AstNode, GenericParamsOwner, NameOwner, StructKind, TypeAscriptionOwner,
+        VisibilityOwner,
     },
     T,
 };
@@ -91,7 +92,7 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
 // Generates the surrounding `impl Type { <code> }` including type and lifetime
 // parameters
 fn generate_impl_text(strukt: &ast::StructDef, code: &str) -> String {
-    let type_params = strukt.type_param_list();
+    let type_params = strukt.generic_param_list();
     let mut buf = String::with_capacity(code.len());
     buf.push_str("\n\nimpl");
     if let Some(type_params) = &type_params {

crates/ra_assists/src/handlers/introduce_named_lifetime.rs

@@ -1,5 +1,5 @@
 use ra_syntax::{
-    ast::{self, NameOwner, TypeAscriptionOwner, TypeParamsOwner},
+    ast::{self, GenericParamsOwner, NameOwner, TypeAscriptionOwner},
     AstNode, SyntaxKind, TextRange, TextSize,
 };
 use rustc_hash::FxHashSet;
@@ -54,7 +54,7 @@ fn generate_fn_def_assist(
     lifetime_loc: TextRange,
 ) -> Option<()> {
     let param_list: ast::ParamList = fn_def.param_list()?;
-    let new_lifetime_param = generate_unique_lifetime_param_name(&fn_def.type_param_list())?;
+    let new_lifetime_param = generate_unique_lifetime_param_name(&fn_def.generic_param_list())?;
     let end_of_fn_ident = fn_def.name()?.ident_token()?.text_range().end();
     let self_param =
         // use the self if it's a reference and has no explicit lifetime
@@ -96,7 +96,7 @@ fn generate_impl_def_assist(
     impl_def: &ast::ImplDef,
     lifetime_loc: TextRange,
 ) -> Option<()> {
-    let new_lifetime_param = generate_unique_lifetime_param_name(&impl_def.type_param_list())?;
+    let new_lifetime_param = generate_unique_lifetime_param_name(&impl_def.generic_param_list())?;
     let end_of_impl_kw = impl_def.impl_token()?.text_range().end();
     acc.add(AssistId(ASSIST_NAME, AssistKind::Refactor), ASSIST_LABEL, lifetime_loc, |builder| {
         add_lifetime_param(impl_def, builder, end_of_impl_kw, new_lifetime_param);
@@ -107,7 +107,7 @@ fn generate_impl_def_assist(
 /// Given a type parameter list, generate a unique lifetime parameter name
 /// which is not in the list
 fn generate_unique_lifetime_param_name(
-    existing_type_param_list: &Option<ast::TypeParamList>,
+    existing_type_param_list: &Option<ast::GenericParamList>,
 ) -> Option<char> {
     match existing_type_param_list {
         Some(type_params) => {
@@ -123,13 +123,13 @@ fn generate_unique_lifetime_param_name(
 
 /// Add the lifetime param to `builder`. If there are type parameters in `type_params_owner`, add it to the end. Otherwise
 /// add new type params brackets with the lifetime parameter at `new_type_params_loc`.
-fn add_lifetime_param<TypeParamsOwner: ast::TypeParamsOwner>(
+fn add_lifetime_param<TypeParamsOwner: ast::GenericParamsOwner>(
     type_params_owner: &TypeParamsOwner,
     builder: &mut AssistBuilder,
     new_type_params_loc: TextSize,
     new_lifetime_param: char,
 ) {
-    match type_params_owner.type_param_list() {
+    match type_params_owner.generic_param_list() {
         // add the new lifetime parameter to an existing type param list
         Some(type_params) => {
             builder.insert(

crates/ra_assists/src/handlers/move_bounds.rs

@@ -23,7 +23,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let type_param_list = ctx.find_node_at_offset::<ast::TypeParamList>()?;
+    let type_param_list = ctx.find_node_at_offset::<ast::GenericParamList>()?;
 
     let mut type_params = type_param_list.type_params();
     if type_params.all(|p| p.type_bound_list().is_none()) {

crates/ra_hir_def/src/generics.rs

@@ -12,7 +12,7 @@ use hir_expand::{
 use ra_arena::{map::ArenaMap, Arena};
 use ra_db::FileId;
 use ra_prof::profile;
-use ra_syntax::ast::{self, NameOwner, TypeBoundsOwner, TypeParamsOwner};
+use ra_syntax::ast::{self, GenericParamsOwner, NameOwner, TypeBoundsOwner};
 
 use crate::{
     body::LowerCtx,
@@ -205,9 +205,9 @@ impl GenericParams {
         &mut self,
         lower_ctx: &LowerCtx,
         sm: &mut SourceMap,
-        node: &dyn TypeParamsOwner,
+        node: &dyn GenericParamsOwner,
     ) {
-        if let Some(params) = node.type_param_list() {
+        if let Some(params) = node.generic_param_list() {
             self.fill_params(lower_ctx, sm, params)
         }
         if let Some(where_clause) = node.where_clause() {
@@ -232,7 +232,7 @@ impl GenericParams {
         &mut self,
         lower_ctx: &LowerCtx,
         sm: &mut SourceMap,
-        params: ast::TypeParamList,
+        params: ast::GenericParamList,
     ) {
         for type_param in params.type_params() {
             let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());

crates/ra_hir_def/src/item_tree/lower.rs

@@ -568,10 +568,10 @@ impl Ctx {
     fn lower_generic_params_and_inner_items(
         &mut self,
         owner: GenericsOwner<'_>,
-        node: &impl ast::TypeParamsOwner,
+        node: &impl ast::GenericParamsOwner,
     ) -> GenericParamsId {
         // Generics are part of item headers and may contain inner items we need to collect.
-        if let Some(params) = node.type_param_list() {
+        if let Some(params) = node.generic_param_list() {
             self.collect_inner_items(params.syntax());
         }
         if let Some(clause) = node.where_clause() {
@@ -584,7 +584,7 @@ impl Ctx {
     fn lower_generic_params(
         &mut self,
         owner: GenericsOwner<'_>,
-        node: &impl ast::TypeParamsOwner,
+        node: &impl ast::GenericParamsOwner,
     ) -> GenericParamsId {
         let mut sm = &mut ArenaMap::default();
         let mut generics = GenericParams::default();

crates/ra_hir_expand/src/builtin_derive.rs

@@ -4,7 +4,7 @@ use log::debug;
 
 use ra_parser::FragmentKind;
 use ra_syntax::{
-    ast::{self, AstNode, ModuleItemOwner, NameOwner, TypeParamsOwner},
+    ast::{self, AstNode, GenericParamsOwner, ModuleItemOwner, NameOwner},
     match_ast,
 };
 
@@ -72,9 +72,9 @@ fn parse_adt(tt: &tt::Subtree) -> Result<BasicAdtInfo, mbe::ExpandError> {
     let node = item.syntax();
     let (name, params) = match_ast! {
         match node {
-            ast::StructDef(it) => (it.name(), it.type_param_list()),
-            ast::EnumDef(it) => (it.name(), it.type_param_list()),
-            ast::UnionDef(it) => (it.name(), it.type_param_list()),
+            ast::StructDef(it) => (it.name(), it.generic_param_list()),
+            ast::EnumDef(it) => (it.name(), it.generic_param_list()),
+            ast::UnionDef(it) => (it.name(), it.generic_param_list()),
             _ => {
                 debug!("unexpected node is {:?}", node);
                 return Err(mbe::ExpandError::ConversionError)

crates/ra_ide/src/display.rs

@@ -5,7 +5,7 @@ mod navigation_target;
 mod short_label;
 
 use ra_syntax::{
-    ast::{self, AstNode, AttrsOwner, NameOwner, TypeParamsOwner},
+    ast::{self, AstNode, AttrsOwner, GenericParamsOwner, NameOwner},
     SyntaxKind::{ATTR, COMMENT},
 };
 
@@ -37,7 +37,7 @@ pub(crate) fn function_declaration(node: &ast::Fn) -> String {
     if let Some(name) = node.name() {
         format_to!(buf, "fn {}", name)
     }
-    if let Some(type_params) = node.type_param_list() {
+    if let Some(type_params) = node.generic_param_list() {
         format_to!(buf, "{}", type_params);
     }
     if let Some(param_list) = node.param_list() {

crates/ra_ide/src/extend_selection.rs

@@ -44,7 +44,7 @@ fn try_extend_selection(
         RECORD_FIELD_LIST,
         ENUM_VARIANT_LIST,
         USE_TREE_LIST,
-        TYPE_PARAM_LIST,
+        GENERIC_PARAM_LIST,
         TYPE_ARG_LIST,
         TYPE_BOUND_LIST,
         PARAM_LIST,