})?;
stdx::always!(
matches!(path, ast::Expr::PathExpr(_) | ast::Expr::MacroCall(_)),
+
"unexpected expression type for variable usage: {:?}",
path
);
r#"
fn foo() {
foo($01 + 1$0);
-}"#,
+}
+"#,
r#"
fn foo() {
foo(fun_name());
fn $0fun_name() -> i32 {
1 + 1
-}"#,
+}
+"#,
);
}
fn foo() {
foo($01 + 1$0);
}
-}"#,
+}
+"#,
r#"
mod bar {
fn foo() {
fn $0fun_name() -> i32 {
1 + 1
}
-}"#,
+}
+"#,
);
}
r#"
fn foo() {
$0{ 1 + 1 }$0;
-}"#,
+}
+"#,
r#"
fn foo() {
fun_name();
fn $0fun_name() -> i32 {
1 + 1
-}"#,
+}
+"#,
);
}
let k = 1;
$0let m = 1;
m + 1$0
-}"#,
+}
+"#,
r#"
fn foo() -> i32 {
let k = 1;
fn $0fun_name() -> i32 {
let m = 1;
m + 1
-}"#,
+}
+"#,
);
}
$0let m = 1;
let n = m + 1;$0
let g = 5;
-}"#,
+}
+"#,
r#"
fn foo() {
let k = 3;
fn $0fun_name() {
let m = 1;
let n = m + 1;
-}"#,
+}
+"#,
);
}
r#"
fn foo() {
$0if true { }$0
-}"#,
+}
+"#,
r#"
fn foo() {
fun_name();
fn $0fun_name() {
if true { }
-}"#,
+}
+"#,
);
}
r#"
fn foo() -> i32 {
$0if true { 1 } else { 2 }$0
-}"#,
+}
+"#,
r#"
fn foo() -> i32 {
fun_name()
fn $0fun_name() -> i32 {
if true { 1 } else { 2 }
-}"#,
+}
+"#,
);
}
r#"
fn foo() -> i32 {
$0if let true = false { 1 } else { 2 }$0
-}"#,
+}
+"#,
r#"
fn foo() -> i32 {
fun_name()
fn $0fun_name() -> i32 {
if let true = false { 1 } else { 2 }
-}"#,
+}
+"#,
);
}
true => 1,
false => 2,
}$0
-}"#,
+}
+"#,
r#"
fn foo() -> i32 {
fun_name()
true => 1,
false => 2,
}
-}"#,
+}
+"#,
);
}
r#"
fn foo() {
$0while true { }$0
-}"#,
+}
+"#,
r#"
fn foo() {
fun_name();
fn $0fun_name() {
while true { }
-}"#,
+}
+"#,
);
}
r#"
fn foo() {
$0for v in &[0, 1] { }$0
-}"#,
+}
+"#,
r#"
fn foo() {
fun_name();
fn $0fun_name() {
for v in &[0, 1] { }
-}"#,
+}
+"#,
);
}
$0loop {
let m = 1;
}$0
-}"#,
+}
+"#,
r#"
fn foo() {
fun_name()
loop {
let m = 1;
}
-}"#,
+}
+"#,
);
}
let m = 1;
break m;
}$0;
-}"#,
+}
+"#,
r#"
fn foo() {
let v = fun_name();
let m = 1;
break m;
}
-}"#,
+}
+"#,
);
}
Some(x) => x,
None => 0,
}$0;
-}"#,
+}
+"#,
r#"
fn foo() {
let v: i32 = fun_name();
Some(x) => x,
None => 0,
}
-}"#,
+}
+"#,
);
}
let n = 1;
let mut v = $0n * n;$0
v += 1;
-}"#,
+}
+"#,
r#"
fn foo() {
let n = 1;
fn $0fun_name(n: i32) -> i32 {
let mut v = n * n;
v
-}"#,
+}
+"#,
);
}
let mut w = 3;$0
v += 1;
w += 1;
-}"#,
+}
+"#,
r#"
fn foo() {
let m = 2;
let mut v = m * n;
let mut w = 3;
(v, w)
-}"#,
+}
+"#,
);
}
fn argument_form_expr() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() -> u32 {
let n = 2;
$0n+2$0
-}",
- r"
+}
+"#,
+ r#"
fn foo() -> u32 {
let n = 2;
fun_name(n)
fn $0fun_name(n: u32) -> u32 {
n+2
-}",
+}
+"#,
)
}
fn argument_used_twice_form_expr() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() -> u32 {
let n = 2;
$0n+n$0
-}",
- r"
+}
+"#,
+ r#"
fn foo() -> u32 {
let n = 2;
fun_name(n)
fn $0fun_name(n: u32) -> u32 {
n+n
-}",
+}
+"#,
)
}
fn two_arguments_form_expr() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() -> u32 {
let n = 2;
let m = 3;
$0n+n*m$0
-}",
- r"
+}
+"#,
+ r#"
fn foo() -> u32 {
let n = 2;
let m = 3;
fn $0fun_name(n: u32, m: u32) -> u32 {
n+n*m
-}",
+}
+"#,
)
}
fn argument_and_locals() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() -> u32 {
let n = 2;
$0let m = 1;
n + m$0
-}",
- r"
+}
+"#,
+ r#"
fn foo() -> u32 {
let n = 2;
fun_name(n)
fn $0fun_name(n: u32) -> u32 {
let m = 1;
n + m
-}",
+}
+"#,
)
}
fn part_of_expr_stmt() {
check_assist(
extract_function,
- "
+ r#"
fn foo() {
$01$0 + 1;
-}",
- "
+}
+"#,
+ r#"
fn foo() {
fun_name() + 1;
}
fn $0fun_name() -> i32 {
1
-}",
+}
+"#,
);
}
r#"
fn foo() {
$0bar(1 + 1)$0
-}"#,
+}
+"#,
r#"
fn foo() {
fun_name();
fn $0fun_name() {
bar(1 + 1)
-}"#,
+}
+"#,
)
}
fn extract_from_nested() {
check_assist(
extract_function,
- r"
+ r#"
fn main() {
let x = true;
let tuple = match x {
true => ($02 + 2$0, true)
_ => (0, false)
};
-}",
- r"
+}
+"#,
+ r#"
fn main() {
let x = true;
let tuple = match x {
fn $0fun_name() -> i32 {
2 + 2
-}",
+}
+"#,
);
}
fn param_from_closure() {
check_assist(
extract_function,
- r"
+ r#"
fn main() {
let lambda = |x: u32| $0x * 2$0;
-}",
- r"
+}
+"#,
+ r#"
fn main() {
let lambda = |x: u32| fun_name(x);
}
fn $0fun_name(x: u32) -> u32 {
x * 2
-}",
+}
+"#,
);
}
fn extract_return_stmt() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() -> u32 {
$0return 2 + 2$0;
-}",
- r"
+}
+"#,
+ r#"
fn foo() -> u32 {
return fun_name();
}
fn $0fun_name() -> u32 {
2 + 2
-}",
+}
+"#,
);
}
fn does_not_add_extra_whitespace() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() -> u32 {
$0return 2 + 2$0;
-}",
- r"
+}
+"#,
+ r#"
fn foo() -> u32 {
fn $0fun_name() -> u32 {
2 + 2
-}",
+}
+"#,
);
}
fn break_stmt() {
check_assist(
extract_function,
- r"
+ r#"
fn main() {
let result = loop {
$0break 2 + 2$0;
};
-}",
- r"
+}
+"#,
+ r#"
fn main() {
let result = loop {
break fun_name();
fn $0fun_name() -> i32 {
2 + 2
-}",
+}
+"#,
);
}
fn extract_cast() {
check_assist(
extract_function,
- r"
+ r#"
fn main() {
let v = $00f32 as u32$0;
-}",
- r"
+}
+"#,
+ r#"
fn main() {
let v = fun_name();
}
fn $0fun_name() -> u32 {
0f32 as u32
-}",
+}
+"#,
);
}
fn method_to_freestanding() {
check_assist(
extract_function,
- r"
+ r#"
struct S;
impl S {
fn foo(&self) -> i32 {
$01+1$0
}
-}",
- r"
+}
+"#,
+ r#"
struct S;
impl S {
fn $0fun_name() -> i32 {
1+1
-}",
+}
+"#,
);
}
fn method_with_reference() {
check_assist(
extract_function,
- r"
+ r#"
struct S { f: i32 };
impl S {
fn foo(&self) -> i32 {
$01+self.f$0
}
-}",
- r"
+}
+"#,
+ r#"
struct S { f: i32 };
impl S {
fn $0fun_name(&self) -> i32 {
1+self.f
}
-}",
+}
+"#,
);
}
fn method_with_mut() {
check_assist(
extract_function,
- r"
+ r#"
struct S { f: i32 };
impl S {
fn foo(&mut self) {
$0self.f += 1;$0
}
-}",
- r"
+}
+"#,
+ r#"
struct S { f: i32 };
impl S {
fn $0fun_name(&mut self) {
self.f += 1;
}
-}",
+}
+"#,
);
}
fn variable_defined_inside_and_used_after_no_ret() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() {
let n = 1;
$0let k = n * n;$0
let m = k + 1;
-}",
- r"
+}
+"#,
+ r#"
fn foo() {
let n = 1;
let k = fun_name(n);
fn $0fun_name(n: i32) -> i32 {
let k = n * n;
k
-}",
+}
+"#,
);
}
fn variable_defined_inside_and_used_after_mutably_no_ret() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() {
let n = 1;
$0let mut k = n * n;$0
k += 1;
-}",
- r"
+}
+"#,
+ r#"
fn foo() {
let n = 1;
let mut k = fun_name(n);
fn $0fun_name(n: i32) -> i32 {
let mut k = n * n;
k
-}",
+}
+"#,
);
}
fn two_variables_defined_inside_and_used_after_no_ret() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() {
let n = 1;
$0let k = n * n;
let m = k + 2;$0
let h = k + m;
-}",
- r"
+}
+"#,
+ r#"
fn foo() {
let n = 1;
let (k, m) = fun_name(n);
let k = n * n;
let m = k + 2;
(k, m)
-}",
+}
+"#,
);
}
fn multi_variables_defined_inside_and_used_after_mutably_no_ret() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() {
let n = 1;
$0let mut k = n * n;
o += 1;$0
k += o;
m = 1;
-}",
- r"
+}
+"#,
+ r#"
fn foo() {
let n = 1;
let (mut k, mut m, o) = fun_name(n);
let mut o = m + 3;
o += 1;
(k, m, o)
-}",
+}
+"#,
);
}
fn nontrivial_patterns_define_variables() {
check_assist(
extract_function,
- r"
+ r#"
struct Counter(i32);
fn foo() {
$0let Counter(n) = Counter(0);$0
let m = n;
-}",
- r"
+}
+"#,
+ r#"
struct Counter(i32);
fn foo() {
let n = fun_name();
fn $0fun_name() -> i32 {
let Counter(n) = Counter(0);
n
-}",
+}
+"#,
);
}
fn struct_with_two_fields_pattern_define_variables() {
check_assist(
extract_function,
- r"
+ r#"
struct Counter { n: i32, m: i32 };
fn foo() {
$0let Counter { n, m: k } = Counter { n: 1, m: 2 };$0
let h = n + k;
-}",
- r"
+}
+"#,
+ r#"
struct Counter { n: i32, m: i32 };
fn foo() {
let (n, k) = fun_name();
fn $0fun_name() -> (i32, i32) {
let Counter { n, m: k } = Counter { n: 1, m: 2 };
(n, k)
-}",
+}
+"#,
);
}
fn mut_var_from_outer_scope() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() {
let mut n = 1;
$0n += 1;$0
let m = n + 1;
-}",
- r"
+}
+"#,
+ r#"
fn foo() {
let mut n = 1;
fun_name(&mut n);
fn $0fun_name(n: &mut i32) {
*n += 1;
-}",
+}
+"#,
);
}
fn mut_field_from_outer_scope() {
check_assist(
extract_function,
- r"
+ r#"
struct C { n: i32 }
fn foo() {
let mut c = C { n: 0 };
$0c.n += 1;$0
let m = c.n + 1;
-}",
- r"
+}
+"#,
+ r#"
struct C { n: i32 }
fn foo() {
let mut c = C { n: 0 };
fn $0fun_name(c: &mut C) {
c.n += 1;
-}",
+}
+"#,
);
}
fn mut_nested_field_from_outer_scope() {
check_assist(
extract_function,
- r"
+ r#"
struct P { n: i32}
struct C { p: P }
fn foo() {
$0c.p.n += u.p.n;
let r = &mut v.p.n;$0
let m = c.p.n + v.p.n + u.p.n;
-}",
- r"
+}
+"#,
+ r#"
struct P { n: i32}
struct C { p: P }
fn foo() {
fn $0fun_name(c: &mut C, u: &C, v: &mut C) {
c.p.n += u.p.n;
let r = &mut v.p.n;
-}",
+}
+"#,
);
}
fn mut_param_many_usages_stmt() {
check_assist(
extract_function,
- r"
+ r#"
fn bar(k: i32) {}
trait I: Copy {
fn succ(&self) -> Self;
*v = v.succ();
n.succ();$0
let m = n + 1;
-}",
- r"
+}
+"#,
+ r#"
fn bar(k: i32) {}
trait I: Copy {
fn succ(&self) -> Self;
let v = n;
*v = v.succ();
n.succ();
-}",
+}
+"#,
);
}
fn mut_param_many_usages_expr() {
check_assist(
extract_function,
- r"
+ r#"
fn bar(k: i32) {}
trait I: Copy {
fn succ(&self) -> Self;
n.succ();
}$0
let m = n + 1;
-}",
- r"
+}
+"#,
+ r#"
fn bar(k: i32) {}
trait I: Copy {
fn succ(&self) -> Self;
let v = n;
*v = v.succ();
n.succ();
-}",
+}
+"#,
);
}
fn mut_param_by_value() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() {
let mut n = 1;
$0n += 1;$0
-}",
+}
+"#,
r"
fn foo() {
let mut n = 1;
fn $0fun_name(mut n: i32) {
n += 1;
-}",
+}
+",
);
}
fn mut_param_because_of_mut_ref() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() {
let mut n = 1;
$0let v = &mut n;
*v += 1;$0
let k = n;
-}",
- r"
+}
+"#,
+ r#"
fn foo() {
let mut n = 1;
fun_name(&mut n);
fn $0fun_name(n: &mut i32) {
let v = n;
*v += 1;
-}",
+}
+"#,
);
}
let mut n = 1;
$0let v = &mut n;
*v += 1;$0
-}",
- r"
+}
+",
+ r#"
fn foo() {
let mut n = 1;
fun_name(n);
fn $0fun_name(mut n: i32) {
let v = &mut n;
*v += 1;
-}",
+}
+"#,
);
}
fn mut_method_call() {
check_assist(
extract_function,
- r"
+ r#"
trait I {
fn inc(&mut self);
}
fn foo() {
let mut n = 1;
$0n.inc();$0
-}",
- r"
+}
+"#,
+ r#"
trait I {
fn inc(&mut self);
}
fn $0fun_name(mut n: i32) {
n.inc();
-}",
+}
+"#,
);
}
fn shared_method_call() {
check_assist(
extract_function,
- r"
+ r#"
trait I {
fn succ(&self);
}
fn foo() {
let mut n = 1;
$0n.succ();$0
-}",
+}
+"#,
r"
trait I {
fn succ(&self);
fn $0fun_name(n: i32) {
n.succ();
-}",
+}
+",
);
}
fn mut_method_call_with_other_receiver() {
check_assist(
extract_function,
- r"
+ r#"
trait I {
fn inc(&mut self, n: i32);
}
let mut n = 1;
$0let mut m = 2;
m.inc(n);$0
-}",
+}
+"#,
r"
trait I {
fn inc(&mut self, n: i32);
fn $0fun_name(n: i32) {
let mut m = 2;
m.inc(n);
-}",
+}
+",
);
}
fn non_copy_without_usages_after() {
check_assist(
extract_function,
- r"
+ r#"
struct Counter(i32);
fn foo() {
let c = Counter(0);
$0let n = c.0;$0
-}",
+}
+"#,
r"
struct Counter(i32);
fn foo() {
fn $0fun_name(c: Counter) {
let n = c.0;
-}",
+}
+",
);
}
let c = Counter(0);
$0let n = c.0;$0
let m = c.0;
-}",
- r"
+}
+",
+ r#"
struct Counter(i32);
fn foo() {
let c = Counter(0);
fn $0fun_name(c: &Counter) {
let n = c.0;
-}",
+}
+"#,
);
}
fn copy_used_after() {
check_assist(
extract_function,
- r##"
-#[lang = "copy"]
-pub trait Copy {}
-impl Copy for i32 {}
+ r#"
+//- minicore: copy
fn foo() {
let n = 0;
$0let m = n;$0
let k = n;
-}"##,
- r##"
-#[lang = "copy"]
-pub trait Copy {}
-impl Copy for i32 {}
+}
+"#,
+ r#"
fn foo() {
let n = 0;
fun_name(n);
fn $0fun_name(n: i32) {
let m = n;
-}"##,
+}
+"#,
)
}
fn copy_custom_used_after() {
check_assist(
extract_function,
- r##"
-#[lang = "copy"]
-pub trait Copy {}
+ r#"
+//- minicore: copy, derive
+#[derive(Clone, Copy)]
struct Counter(i32);
-impl Copy for Counter {}
fn foo() {
let c = Counter(0);
$0let n = c.0;$0
let m = c.0;
-}"##,
- r##"
-#[lang = "copy"]
-pub trait Copy {}
+}
+"#,
+ r#"
+#[derive(Clone, Copy)]
struct Counter(i32);
-impl Copy for Counter {}
fn foo() {
let c = Counter(0);
fun_name(c);
fn $0fun_name(c: Counter) {
let n = c.0;
-}"##,
+}
+"#,
);
}
fn indented_stmts() {
check_assist(
extract_function,
- r"
+ r#"
fn foo() {
if true {
loop {
let m = 2;$0
}
}
-}",
- r"
+}
+"#,
+ r#"
fn foo() {
if true {
loop {
fn $0fun_name() {
let n = 1;
let m = 2;
-}",
+}
+"#,
);
}
fn indented_stmts_inside_mod() {
check_assist(
extract_function,
- r"
+ r#"
mod bar {
fn foo() {
if true {
}
}
}
-}",
- r"
+}
+"#,
+ r#"
mod bar {
fn foo() {
if true {
let n = 1;
let m = 2;
}
-}",
+}
+"#,
);
}
fn break_loop() {
check_assist(
extract_function,
- r##"
+ r#"
enum Option<T> {
#[lang = "None"] None,
#[lang = "Some"] Some(T),
let k = 2;$0
let h = 1 + k;
}
-}"##,
- r##"
+}
+"#,
+ r#"
enum Option<T> {
#[lang = "None"] None,
#[lang = "Some"] Some(T),
return None;
let k = 2;
Some(k)
-}"##,
+}
+"#,
);
}
fn return_to_parent() {
check_assist(
extract_function,
- r##"
-#[lang = "copy"]
-pub trait Copy {}
-impl Copy for i32 {}
-enum Result<T, E> {
- #[lang = "Ok"] Ok(T),
- #[lang = "Err"] Err(E),
-}
-use Result::*;
+ r#"
+//- minicore: copy, result
fn foo() -> i64 {
let n = 1;
$0let m = n + 1;
return 1;
let k = 2;$0
(n + k) as i64
-}"##,
- r##"
-#[lang = "copy"]
-pub trait Copy {}
-impl Copy for i32 {}
-enum Result<T, E> {
- #[lang = "Ok"] Ok(T),
- #[lang = "Err"] Err(E),
-}
-use Result::*;
+}
+"#,
+ r#"
fn foo() -> i64 {
let n = 1;
let k = match fun_name(n) {
return Err(1);
let k = 2;
Ok(k)
-}"##,
+}
+"#,
);
}
cov_mark::check!(external_control_flow_break_and_continue);
check_assist_not_applicable(
extract_function,
- r##"
+ r#"
fn foo() {
loop {
let n = 1;
let k = k + 1;$0
let r = n + k;
}
-}"##,
+}
+"#,
);
}
cov_mark::check!(external_control_flow_return_and_bc);
check_assist_not_applicable(
extract_function,
- r##"
+ r#"
fn foo() {
loop {
let n = 1;
let k = k + 1;$0
let r = n + k;
}
-}"##,
+}
+"#,
);
}
fn break_loop_with_if() {
check_assist(
extract_function,
- r##"
+ r#"
fn foo() {
loop {
let mut n = 1;
n += m;$0
let h = 1 + n;
}
-}"##,
- r##"
+}
+"#,
+ r#"
fn foo() {
loop {
let mut n = 1;
return true;
*n += m;
false
-}"##,
+}
+"#,
);
}
fn break_loop_nested() {
check_assist(
extract_function,
- r##"
+ r#"
fn foo() {
loop {
let mut n = 1;
}$0
let h = 1;
}
-}"##,
- r##"
+}
+"#,
+ r#"
fn foo() {
loop {
let mut n = 1;
return true;
}
false
-}"##,
+}
+"#,
);
}
fn return_from_nested_loop() {
check_assist(
extract_function,
- r##"
+ r#"
fn foo() {
loop {
let n = 1;
let m = k + 1;$0
let h = 1 + m;
}
-}"##,
- r##"
+}
+"#,
+ r#"
fn foo() {
loop {
let n = 1;
}
let m = k + 1;
Some(m)
-}"##,
+}
+"#,
);
}
fn break_from_nested_loop() {
check_assist(
extract_function,
- r##"
+ r#"
fn foo() {
loop {
let n = 1;
let m = k + 1;$0
let h = 1 + m;
}
-}"##,
- r##"
+}
+"#,
+ r#"
fn foo() {
loop {
let n = 1;
}
let m = k + 1;
m
-}"##,
+}
+"#,
);
}
fn break_from_nested_and_outer_loops() {
check_assist(
extract_function,
- r##"
+ r#"
fn foo() {
loop {
let n = 1;
let m = k + 1;$0
let h = 1 + m;
}
-}"##,
- r##"
+}
+"#,
+ r#"
fn foo() {
loop {
let n = 1;
}
let m = k + 1;
Some(m)
-}"##,
+}
+"#,
);
}
fn return_from_nested_fn() {
check_assist(
extract_function,
- r##"
+ r#"
fn foo() {
loop {
let n = 1;
let m = k + 1;$0
let h = 1 + m;
}
-}"##,
- r##"
+}
+"#,
+ r#"
fn foo() {
loop {
let n = 1;
}
let m = k + 1;
m
-}"##,
+}
+"#,
);
}
fn break_with_value() {
check_assist(
extract_function,
- r##"
+ r#"
fn foo() -> i32 {
loop {
let n = 1;
let m = k + 1;$0
let h = 1;
}
-}"##,
- r##"
+}
+"#,
+ r#"
fn foo() -> i32 {
loop {
let n = 1;
}
let m = k + 1;
None
-}"##,
+}
+"#,
);
}
fn break_with_value_and_return() {
check_assist(
extract_function,
- r##"
+ r#"
fn foo() -> i64 {
loop {
let n = 1;
let m = k + 1;$0
let h = 1 + m;
}
-}"##,
- r##"
+}
+"#,
+ r#"
fn foo() -> i64 {
loop {
let n = 1;
}
let m = k + 1;
Ok(m)
-}"##,
+}
+"#,
);
}
fn try_option() {
check_assist(
extract_function,
- r##"
-enum Option<T> { None, Some(T), }
-use Option::*;
+ r#"
+//- minicore: option
fn bar() -> Option<i32> { None }
fn foo() -> Option<()> {
let n = bar()?;
let m = k + 1;$0
let h = 1 + m;
Some(())
-}"##,
- r##"
-enum Option<T> { None, Some(T), }
-use Option::*;
+}
+"#,
+ r#"
fn bar() -> Option<i32> { None }
fn foo() -> Option<()> {
let n = bar()?;
let k = foo()?;
let m = k + 1;
Some(m)
-}"##,
+}
+"#,
);
}
fn try_option_unit() {
check_assist(
extract_function,
- r##"
-enum Option<T> { None, Some(T), }
-use Option::*;
+ r#"
+//- minicore: option
fn foo() -> Option<()> {
let n = 1;
$0let k = foo()?;
let m = k + 1;$0
let h = 1 + n;
Some(())
-}"##,
- r##"
-enum Option<T> { None, Some(T), }
-use Option::*;
+}
+"#,
+ r#"
fn foo() -> Option<()> {
let n = 1;
fun_name()?;
let k = foo()?;
let m = k + 1;
Some(())
-}"##,
+}
+"#,
);
}
fn try_result() {
check_assist(
extract_function,
- r##"
-enum Result<T, E> { Ok(T), Err(E), }
-use Result::*;
+ r#"
+//- minicore: result
fn foo() -> Result<(), i64> {
let n = 1;
$0let k = foo()?;
let m = k + 1;$0
let h = 1 + m;
Ok(())
-}"##,
- r##"
-enum Result<T, E> { Ok(T), Err(E), }
-use Result::*;
+}
+"#,
+ r#"
fn foo() -> Result<(), i64> {
let n = 1;
let m = fun_name()?;
let k = foo()?;
let m = k + 1;
Ok(m)
-}"##,
+}
+"#,
);
}
fn try_option_with_return() {
check_assist(
extract_function,
- r##"
-enum Option<T> { None, Some(T) }
-use Option::*;
+ r#"
+//- minicore: option
fn foo() -> Option<()> {
let n = 1;
$0let k = foo()?;
let m = k + 1;$0
let h = 1 + m;
Some(())
-}"##,
- r##"
-enum Option<T> { None, Some(T) }
-use Option::*;
+}
+"#,
+ r#"
fn foo() -> Option<()> {
let n = 1;
let m = fun_name()?;
}
let m = k + 1;
Some(m)
-}"##,
+}
+"#,
);
}
fn try_result_with_return() {
check_assist(
extract_function,
- r##"
-enum Result<T, E> { Ok(T), Err(E), }
-use Result::*;
+ r#"
+//- minicore: result
fn foo() -> Result<(), i64> {
let n = 1;
$0let k = foo()?;
let m = k + 1;$0
let h = 1 + m;
Ok(())
-}"##,
- r##"
-enum Result<T, E> { Ok(T), Err(E), }
-use Result::*;
+}
+"#,
+ r#"
fn foo() -> Result<(), i64> {
let n = 1;
let m = fun_name()?;
}
let m = k + 1;
Ok(m)
-}"##,
+}
+"#,
);
}
cov_mark::check!(external_control_flow_try_and_bc);
check_assist_not_applicable(
extract_function,
- r##"
-enum Option<T> { None, Some(T) }
-use Option::*;
+ r#"
+//- minicore: option
fn foo() -> Option<()> {
loop {
let n = Some(1);
let r = n + k;
}
Some(())
-}"##,
+}
+"#,
);
}
cov_mark::check!(external_control_flow_try_and_return_non_err);
check_assist_not_applicable(
extract_function,
- r##"
-enum Result<T, E> { Ok(T), Err(E), }
-use Result::*;
+ r#"
+//- minicore: result
fn foo() -> Result<(), i64> {
let n = 1;
$0let k = foo()?;
let m = k + 1;$0
let h = 1 + m;
Ok(())
-}"##,
+}
+"#,
);
}
fn param_usage_in_macro() {
check_assist(
extract_function,
- r"
+ r#"
macro_rules! m {
($val:expr) => { $val };
}
let n = 1;
$0let k = n * m!(n);$0
let m = k + 1;
-}",
- r"
+}
+"#,
+ r#"
macro_rules! m {
($val:expr) => { $val };
}
fn $0fun_name(n: i32) -> i32 {
let k = n * m!(n);
k
-}",
+}
+"#,
);
}
fn extract_with_await() {
check_assist(
extract_function,
- r#"fn main() {
+ r#"
+fn main() {
$0some_function().await;$0
}
fn extract_with_await_in_args() {
check_assist(
extract_function,
- r#"fn main() {
+ r#"
+fn main() {
$0function_call("a", some_function().await);$0
}
//! iterator: option
//! iterators: iterator
//! default: sized
+//! clone: sized
+//! copy: clone
//! from: sized
//! eq: sized
//! ord: eq, option
#[lang = "unsize"]
pub trait Unsize<T: ?Sized> {}
// endregion:unsize
+
+ // region:copy
+ #[lang = "copy"]
+ pub trait Copy: Clone {}
+ // region:derive
+ #[rustc_builtin_macro]
+ pub macro Copy($item:item) {}
+ // endregion:derive
+
+ mod copy_impls {
+ use super::Copy;
+
+ macro_rules! impl_copy {
+ ($($t:ty)*) => {
+ $(
+ impl Copy for $t {}
+ )*
+ }
+ }
+
+ impl_copy! {
+ usize u8 u16 u32 u64 u128
+ isize i8 i16 i32 i64 i128
+ f32 f64
+ bool char
+ }
+
+ impl<T: ?Sized> Copy for *const T {}
+ impl<T: ?Sized> Copy for *mut T {}
+ impl<T: ?Sized> Copy for &T {}
+ }
+ // endregion:copy
}
// region:default
}
// endregion:default
+// region:clone
+pub mod clone {
+ #[lang = "clone"]
+ pub trait Clone: Sized {
+ fn clone(&self) -> Self;
+ }
+ // region:derive
+ #[rustc_builtin_macro]
+ pub macro Clone($item:item) {}
+ // endregion:derive
+}
+// endregion:clone
+
// region:from
pub mod convert {
pub trait From<T>: Sized {
}
// endregion:deref_mut
}
- pub use self::deref::Deref;
- pub use self::deref::DerefMut; //:deref_mut
- // endregion:deref
+ pub use self::deref::{
+ Deref,
+ DerefMut, // :deref_mut
+ };
+ // endregion:deref
// region:range
mod range {
pub mod prelude {
pub mod v1 {
pub use crate::{
+ clone::Clone, // :clone
cmp::{Eq, PartialEq}, // :eq
cmp::{Ord, PartialOrd}, // :ord
convert::{From, Into}, // :from
default::Default, // :default
iter::{IntoIterator, Iterator}, // :iterator
macros::builtin::derive, // :derive
+ marker::Copy, // :copy
marker::Sized, // :sized
ops::{Fn, FnMut, FnOnce}, // :fn
option::Option::{self, None, Some}, // :option