nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 08:13:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

move into_ and as_ generation to a separate file

Browse Source
This commit is contained in:
Domantas Jadenkus 2021-02-15 23:25:33 +02:00
parent 6f25fef36a
commit f098a2b31b
4 changed files with 340 additions and 402 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

406
crates/ide_assists/src/handlers/generate_enum_match_method.rs
View File

@ -1,11 +1,9 @@
use itertools::Itertools;
use stdx::to_lower_snake_case;
use syntax::ast::VisibilityOwner;
use syntax::ast::{self, AstNode, NameOwner};
use crate::{
assist_context::AssistBuilder,
utils::{find_impl_block_end, find_struct_impl, generate_impl_text},
utils::{add_method_to_adt, find_struct_impl},
AssistContext, AssistId, AssistKind, Assists,
};
@ -39,7 +37,11 @@ pub(crate) fn generate_enum_is_method(acc: &mut Assists, ctx: &AssistContext) ->
let variant = ctx.find_node_at_offset::<ast::Variant>()?;
let variant_name = variant.name()?;
let parent_enum = ast::Adt::Enum(variant.parent_enum());
let variant_kind = variant_kind(&variant);
let pattern_suffix = match variant.kind() {
ast::StructKind::Record(_) => " { .. }",
ast::StructKind::Tuple(_) => "(..)",
ast::StructKind::Unit => "",
};
let enum_lowercase_name = to_lower_snake_case(&parent_enum.name()?.to_string());
let fn_name = format!("is_{}", &to_lower_snake_case(variant_name.text()));
@ -59,12 +61,7 @@ pub(crate) fn generate_enum_is_method(acc: &mut Assists, ctx: &AssistContext) ->
{}fn {}(&self) -> bool {{
matches!(self, Self::{}{})
}}",
enum_lowercase_name,
variant_name,
vis,
fn_name,
variant_name,
variant_kind.pattern_suffix(),
enum_lowercase_name, variant_name, vis, fn_name, variant_name, pattern_suffix,
);
add_method_to_adt(builder, &parent_enum, impl_def, &method);
@ -72,237 +69,6 @@ pub(crate) fn generate_enum_is_method(acc: &mut Assists, ctx: &AssistContext) ->
)
}
// Assist: generate_enum_into_method
//
// Generate an `into_` method for an enum variant.
//
// ```
// enum Value {
// Number(i32),
// Text(String)$0,
// }
// ```
// ->
// ```
// enum Value {
// Number(i32),
// Text(String),
// }
//
// impl Value {
// fn into_text(self) -> Option<String> {
// if let Self::Text(v) = self {
// Some(v)
// } else {
// None
// }
// }
// }
// ```
pub(crate) fn generate_enum_into_method(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
let variant = ctx.find_node_at_offset::<ast::Variant>()?;
let variant_name = variant.name()?;
let parent_enum = ast::Adt::Enum(variant.parent_enum());
let variant_kind = variant_kind(&variant);
let fn_name = format!("into_{}", &to_lower_snake_case(variant_name.text()));
// Return early if we've found an existing new fn
let impl_def = find_struct_impl(&ctx, &parent_enum, &fn_name)?;
let field_type = variant_kind.single_field_type()?;
let (pattern_suffix, bound_name) = variant_kind.binding_pattern()?;
let target = variant.syntax().text_range();
acc.add(
AssistId("generate_enum_into_method", AssistKind::Generate),
"Generate an `into_` method for an enum variant",
target,
|builder| {
let vis = parent_enum.visibility().map_or(String::new(), |v| format!("{} ", v));
let method = format!(
" {}fn {}(self) -> Option<{}> {{
if let Self::{}{} = self {{
Some({})
}} else {{
None
}}
}}",
vis,
fn_name,
field_type.syntax(),
variant_name,
pattern_suffix,
bound_name,
);
add_method_to_adt(builder, &parent_enum, impl_def, &method);
},
)
}
// Assist: generate_enum_as_method
//
// Generate an `as_` method for an enum variant.
//
// ```
// enum Value {
// Number(i32),
// Text(String)$0,
// }
// ```
// ->
// ```
// enum Value {
// Number(i32),
// Text(String),
// }
//
// impl Value {
// fn as_text(&self) -> Option<&String> {
// if let Self::Text(v) = self {
// Some(v)
// } else {
// None
// }
// }
// }
// ```
pub(crate) fn generate_enum_as_method(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
let variant = ctx.find_node_at_offset::<ast::Variant>()?;
let variant_name = variant.name()?;
let parent_enum = ast::Adt::Enum(variant.parent_enum());
let variant_kind = variant_kind(&variant);
let fn_name = format!("as_{}", &to_lower_snake_case(variant_name.text()));
// Return early if we've found an existing new fn
let impl_def = find_struct_impl(&ctx, &parent_enum, &fn_name)?;
let field_type = variant_kind.single_field_type()?;
let (pattern_suffix, bound_name) = variant_kind.binding_pattern()?;
let target = variant.syntax().text_range();
acc.add(
AssistId("generate_enum_as_method", AssistKind::Generate),
"Generate an `as_` method for an enum variant",
target,
|builder| {
let vis = parent_enum.visibility().map_or(String::new(), |v| format!("{} ", v));
let method = format!(
" {}fn {}(&self) -> Option<&{}> {{
if let Self::{}{} = self {{
Some({})
}} else {{
None
}}
}}",
vis,
fn_name,
field_type.syntax(),
variant_name,
pattern_suffix,
bound_name,
);
add_method_to_adt(builder, &parent_enum, impl_def, &method);
},
)
}
fn add_method_to_adt(
builder: &mut AssistBuilder,
adt: &ast::Adt,
impl_def: Option<ast::Impl>,
method: &str,
) {
let mut buf = String::with_capacity(method.len() + 2);
if impl_def.is_some() {
buf.push('\n');
}
buf.push_str(method);
let start_offset = impl_def
.and_then(|impl_def| find_impl_block_end(impl_def, &mut buf))
.unwrap_or_else(|| {
buf = generate_impl_text(&adt, &buf);
adt.syntax().text_range().end()
});
builder.insert(start_offset, buf);
}
enum VariantKind {
Unit,
/// Tuple with a single field
NewtypeTuple {
ty: Option<ast::Type>,
},
/// Tuple with 0 or more than 2 fields
Tuple,
/// Record with a single field
NewtypeRecord {
field_name: Option<ast::Name>,
field_type: Option<ast::Type>,
},
/// Record with 0 or more than 2 fields
Record,
}
impl VariantKind {
fn pattern_suffix(&self) -> &'static str {
match self {
VariantKind::Unit => "",
VariantKind::NewtypeTuple { .. } | VariantKind::Tuple => "(..)",
VariantKind::NewtypeRecord { .. } | VariantKind::Record => " { .. }",
}
}
fn binding_pattern(&self) -> Option<(String, String)> {
match self {
VariantKind::Unit
| VariantKind::Tuple
| VariantKind::Record
| VariantKind::NewtypeRecord { field_name: None, .. } => None,
VariantKind::NewtypeTuple { .. } => Some(("(v)".to_owned(), "v".to_owned())),
VariantKind::NewtypeRecord { field_name: Some(name), .. } => {
Some((format!(" {{ {} }}", name.syntax()), name.syntax().to_string()))
}
}
}
fn single_field_type(&self) -> Option<&ast::Type> {
match self {
VariantKind::Unit | VariantKind::Tuple | VariantKind::Record => None,
VariantKind::NewtypeTuple { ty } => ty.as_ref(),
VariantKind::NewtypeRecord { field_type, .. } => field_type.as_ref(),
}
}
}
fn variant_kind(variant: &ast::Variant) -> VariantKind {
match variant.kind() {
ast::StructKind::Record(record) => {
if let Some((single_field,)) = record.fields().collect_tuple() {
let field_name = single_field.name();
let field_type = single_field.ty();
VariantKind::NewtypeRecord { field_name, field_type }
} else {
VariantKind::Record
}
}
ast::StructKind::Tuple(tuple) => {
if let Some((single_field,)) = tuple.fields().collect_tuple() {
let ty = single_field.ty();
VariantKind::NewtypeTuple { ty }
} else {
VariantKind::Tuple
}
}
ast::StructKind::Unit => VariantKind::Unit,
}
}
#[cfg(test)]
mod tests {
use crate::tests::{check_assist, check_assist_not_applicable};
@ -478,164 +244,6 @@ impl Variant {
fn is_major(&self) -> bool {
matches!(self, Self::Major)
}
}"#,
);
}
#[test]
fn test_generate_enum_into_tuple_variant() {
check_assist(
generate_enum_into_method,
r#"
enum Value {
Number(i32),
Text(String)$0,
}"#,
r#"enum Value {
Number(i32),
Text(String),
}
impl Value {
fn into_text(self) -> Option<String> {
if let Self::Text(v) = self {
Some(v)
} else {
None
}
}
}"#,
);
}
#[test]
fn test_generate_enum_into_already_implemented() {
check_assist_not_applicable(
generate_enum_into_method,
r#"enum Value {
Number(i32),
Text(String)$0,
}
impl Value {
fn into_text(self) -> Option<String> {
if let Self::Text(v) = self {
Some(v)
} else {
None
}
}
}"#,
);
}
#[test]
fn test_generate_enum_into_unit_variant() {
check_assist_not_applicable(
generate_enum_into_method,
r#"enum Value {
Number(i32),
Text(String),
Unit$0,
}"#,
);
}
#[test]
fn test_generate_enum_into_record_with_multiple_fields() {
check_assist_not_applicable(
generate_enum_into_method,
r#"enum Value {
Number(i32),
Text(String),
Both { first: i32, second: String }$0,
}"#,
);
}
#[test]
fn test_generate_enum_into_tuple_with_multiple_fields() {
check_assist_not_applicable(
generate_enum_into_method,
r#"enum Value {
Number(i32),
Text(String, String)$0,
}"#,
);
}
#[test]
fn test_generate_enum_into_record_variant() {
check_assist(
generate_enum_into_method,
r#"enum Value {
Number(i32),
Text { text: String }$0,
}"#,
r#"enum Value {
Number(i32),
Text { text: String },
}
impl Value {
fn into_text(self) -> Option<String> {
if let Self::Text { text } = self {
Some(text)
} else {
None
}
}
}"#,
);
}
#[test]
fn test_generate_enum_as_tuple_variant() {
check_assist(
generate_enum_as_method,
r#"
enum Value {
Number(i32),
Text(String)$0,
}"#,
r#"enum Value {
Number(i32),
Text(String),
}
impl Value {
fn as_text(&self) -> Option<&String> {
if let Self::Text(v) = self {
Some(v)
} else {
None
}
}
}"#,
);
}
#[test]
fn test_generate_enum_as_record_variant() {
check_assist(
generate_enum_as_method,
r#"enum Value {
Number(i32),
Text { text: String }$0,
}"#,
r#"enum Value {
Number(i32),
Text { text: String },
}
impl Value {
fn as_text(&self) -> Option<&String> {
if let Self::Text { text } = self {
Some(text)
} else {
None
}
}
}"#,
);
}

307
crates/ide_assists/src/handlers/generate_enum_projection_method.rs Normal file
View File

@ -0,0 +1,307 @@
use itertools::Itertools;
use stdx::to_lower_snake_case;
use syntax::ast::VisibilityOwner;
use syntax::ast::{self, AstNode, NameOwner};
use crate::{
utils::{add_method_to_adt, find_struct_impl},
AssistContext, AssistId, AssistKind, Assists,
};
// Assist: generate_enum_into_method
//
// Generate an `into_` method for an enum variant.
//
// ```
// enum Value {
// Number(i32),
// Text(String)$0,
// }
// ```
// ->
// ```
// enum Value {
// Number(i32),
// Text(String),
// }
//
// impl Value {
// fn into_text(self) -> Option<String> {
// if let Self::Text(v) = self {
// Some(v)
// } else {
// None
// }
// }
// }
// ```
pub(crate) fn generate_enum_into_method(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
generate_enum_projection_method(
acc,
ctx,
"generate_enum_into_method",
"Generate an `into_` method for an enum variant",
"into",
"",
)
}
// Assist: generate_enum_as_method
//
// Generate an `as_` method for an enum variant.
//
// ```
// enum Value {
// Number(i32),
// Text(String)$0,
// }
// ```
// ->
// ```
// enum Value {
// Number(i32),
// Text(String),
// }
//
// impl Value {
// fn as_text(&self) -> Option<&String> {
// if let Self::Text(v) = self {
// Some(v)
// } else {
// None
// }
// }
// }
// ```
pub(crate) fn generate_enum_as_method(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
generate_enum_projection_method(
acc,
ctx,
"generate_enum_as_method",
"Generate an `as_` method for an enum variant",
"as",
"&",
)
}
pub(crate) fn generate_enum_projection_method(
acc: &mut Assists,
ctx: &AssistContext,
assist_id: &'static str,
assist_description: &str,
fn_name_prefix: &str,
ref_prefix: &str,
) -> Option<()> {
let variant = ctx.find_node_at_offset::<ast::Variant>()?;
let variant_name = variant.name()?;
let parent_enum = ast::Adt::Enum(variant.parent_enum());
let (pattern_suffix, field_type, bound_name) = match variant.kind() {
ast::StructKind::Record(record) => {
let (field,) = record.fields().collect_tuple()?;
let name = field.name()?.to_string();
let ty = field.ty()?;
let pattern_suffix = format!(" {{ {} }}", name);
(pattern_suffix, ty, name)
}
ast::StructKind::Tuple(tuple) => {
let (field,) = tuple.fields().collect_tuple()?;
let ty = field.ty()?;
("(v)".to_owned(), ty, "v".to_owned())
}
ast::StructKind::Unit => return None,
};
let fn_name = format!("{}_{}", fn_name_prefix, &to_lower_snake_case(variant_name.text()));
// Return early if we've found an existing new fn
let impl_def = find_struct_impl(&ctx, &parent_enum, &fn_name)?;
let target = variant.syntax().text_range();
acc.add(AssistId(assist_id, AssistKind::Generate), assist_description, target, |builder| {
let vis = parent_enum.visibility().map_or(String::new(), |v| format!("{} ", v));
let method = format!(
" {0}fn {1}({2}self) -> Option<{2}{3}> {{
if let Self::{4}{5} = self {{
Some({6})
}} else {{
None
}}
}}",
vis,
fn_name,
ref_prefix,
field_type.syntax(),
variant_name,
pattern_suffix,
bound_name,
);
add_method_to_adt(builder, &parent_enum, impl_def, &method);
})
}
#[cfg(test)]
mod tests {
use crate::tests::{check_assist, check_assist_not_applicable};
use super::*;
#[test]
fn test_generate_enum_into_tuple_variant() {
check_assist(
generate_enum_into_method,
r#"
enum Value {
Number(i32),
Text(String)$0,
}"#,
r#"enum Value {
Number(i32),
Text(String),
}
impl Value {
fn into_text(self) -> Option<String> {
if let Self::Text(v) = self {
Some(v)
} else {
None
}
}
}"#,
);
}
#[test]
fn test_generate_enum_into_already_implemented() {
check_assist_not_applicable(
generate_enum_into_method,
r#"enum Value {
Number(i32),
Text(String)$0,
}
impl Value {
fn into_text(self) -> Option<String> {
if let Self::Text(v) = self {
Some(v)
} else {
None
}
}
}"#,
);
}
#[test]
fn test_generate_enum_into_unit_variant() {
check_assist_not_applicable(
generate_enum_into_method,
r#"enum Value {
Number(i32),
Text(String),
Unit$0,
}"#,
);
}
#[test]
fn test_generate_enum_into_record_with_multiple_fields() {
check_assist_not_applicable(
generate_enum_into_method,
r#"enum Value {
Number(i32),
Text(String),
Both { first: i32, second: String }$0,
}"#,
);
}
#[test]
fn test_generate_enum_into_tuple_with_multiple_fields() {
check_assist_not_applicable(
generate_enum_into_method,
r#"enum Value {
Number(i32),
Text(String, String)$0,
}"#,
);
}
#[test]
fn test_generate_enum_into_record_variant() {
check_assist(
generate_enum_into_method,
r#"enum Value {
Number(i32),
Text { text: String }$0,
}"#,
r#"enum Value {
Number(i32),
Text { text: String },
}
impl Value {
fn into_text(self) -> Option<String> {
if let Self::Text { text } = self {
Some(text)
} else {
None
}
}
}"#,
);
}
#[test]
fn test_generate_enum_as_tuple_variant() {
check_assist(
generate_enum_as_method,
r#"
enum Value {
Number(i32),
Text(String)$0,
}"#,
r#"enum Value {
Number(i32),
Text(String),
}
impl Value {
fn as_text(&self) -> Option<&String> {
if let Self::Text(v) = self {
Some(v)
} else {
None
}
}
}"#,
);
}
#[test]
fn test_generate_enum_as_record_variant() {
check_assist(
generate_enum_as_method,
r#"enum Value {
Number(i32),
Text { text: String }$0,
}"#,
r#"enum Value {
Number(i32),
Text { text: String },
}
impl Value {
fn as_text(&self) -> Option<&String> {
if let Self::Text { text } = self {
Some(text)
} else {
None
}
}
}"#,
);
}
}

5
crates/ide_assists/src/lib.rs
View File

@ -129,6 +129,7 @@ mod handlers {
mod generate_default_from_enum_variant;
mod generate_derive;
mod generate_enum_match_method;
mod generate_enum_projection_method;
mod generate_from_impl_for_enum;
mod generate_function;
mod generate_getter;
@ -190,8 +191,8 @@ mod handlers {
generate_default_from_enum_variant::generate_default_from_enum_variant,
generate_derive::generate_derive,
generate_enum_match_method::generate_enum_is_method,
generate_enum_match_method::generate_enum_into_method,
generate_enum_match_method::generate_enum_as_method,
generate_enum_projection_method::generate_enum_into_method,
generate_enum_projection_method::generate_enum_as_method,
generate_from_impl_for_enum::generate_from_impl_for_enum,
generate_function::generate_function,
generate_getter::generate_getter,

24
crates/ide_assists/src/utils.rs
View File

@ -21,7 +21,7 @@ use syntax::{
};
use crate::{
assist_context::AssistContext,
assist_context::{AssistBuilder, AssistContext},
ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
};
@ -464,3 +464,25 @@ fn generate_impl_text_inner(adt: &ast::Adt, trait_text: Option<&str>, code: &str
buf
}
pub(crate) fn add_method_to_adt(
builder: &mut AssistBuilder,
adt: &ast::Adt,
impl_def: Option<ast::Impl>,
method: &str,
) {
let mut buf = String::with_capacity(method.len() + 2);
if impl_def.is_some() {
buf.push('\n');
}
buf.push_str(method);
let start_offset = impl_def
.and_then(|impl_def| find_impl_block_end(impl_def, &mut buf))
.unwrap_or_else(|| {
buf = generate_impl_text(&adt, &buf);
adt.syntax().text_range().end()
});
builder.insert(start_offset, buf);
}