use racer::Coordinate;
use racer_testutils::*;
#[test]
fn completes_static_methods_for_aliased_struct() {
let src = r#"
mod mymod {
pub struct St {
mem1: String,
mem2: usize,
}
impl St {
pub fn new() -> Self {
St { mem1: "a".to_owned(), mem2: 5 }
}
}
}
fn main() {
use mymod::St as S;
let s = S::ne~
}
"#;
assert_eq!(get_only_completion(src, None).matchstr, "new");
}
#[test]
fn completes_names_for_aliased_module() {
let src = r#"
mod mymod {
pub struct St {
mem1: String,
mem2: usize,
}
impl St {
pub fn new() -> Self {
St { mem1: "a".to_owned(), mem2: 5 }
}
}
}
fn main() {
use mymod as m;
let s = m::St::ne~
}
"#;
assert_eq!(get_only_completion(src, None).matchstr, "new");
}
#[test]
fn finds_definition_of_use_as() {
let src = r#"
mod mymod {
pub struct St {
mem1: String,
mem2: usize,
}
}
fn main() {
use mymod::St as S;
let s = S~::new();
}
"#;
let got = get_definition(src, None);
assert_eq!(got.matchstr, "S");
assert_eq!(got.coords.unwrap(), Coordinate::new(9, 29));
}
#[test]
fn finds_definition_of_use_self_as() {
let src = r#"
mod mymod {
pub struct St {
mem1: String,
mem2: usize,
}
}
fn main() {
use mymod::{self as m, St};
let s = m~
}
"#;
let got = get_definition(src, None);
assert_eq!(got.matchstr, "m");
assert_eq!(got.coords.unwrap(), Coordinate::new(9, 32));
}
#[test]
fn follows_use_as() {
let src2 = "
pub fn myfn() {}
pub fn foo() {}
";
let src = "
use src2::myfn as myfoofn;
mod src2;
fn main() {
my~foofn();
}
";
let dir = TmpDir::new();
let _src2 = dir.write_file("src2.rs", src2);
let got = get_definition(src, Some(dir));
assert_eq!(got.matchstr, "myfoofn");
assert_eq!(got.contextstr, "src2::myfn as myfoofn");
}
#[test]
fn follows_use_as_in_braces() {
let src = "
mod m {
pub struct Wrapper {
pub x: i32,
}
pub struct Second {
pub y: i32,
}
}
fn main() {
use m::{Wrapper as Wpr, Second};
let _ = W~pr { x: 1 };
}
";
let got = get_definition(src, None);
assert_eq!(got.matchstr, "Wpr");
assert_eq!(got.contextstr, "Wrapper as Wpr");
}
#[test]
fn completes_for_type_alias() {
let src = "
mod inner {
pub type Alias = MyType;
pub struct MyType;
impl MyType {
pub fn method(&self) {}
}
}
fn foo() -> inner::Alias {
inner::MyType
}
fn main() {
foo().~
}
";
assert_eq!(get_only_completion(src, None).matchstr, "method");
}
#[test]
fn follows_use_aliased_self() {
let src = r"
use std::collections::{self as col, hash_map::*, HashMap};
fn main() {
let heap = col::BinaryHeap::ne~w();
}
";
let got = get_definition(src, None);
assert_eq!(got.matchstr, "new");
}
#[test]
fn completes_for_alias_with_resolved_generics() {
let src = "
type Svec = Vec<String>;
fn main() {
let v = Svec::new();
v[0].capa~
}
";
assert_eq!(get_only_completion(src, None).matchstr, "capacity");
}
#[test]
fn completes_for_alias_with_type_param() {
let src = "
struct MyError;
impl MyError {
fn method(&self) {}
}
type Result<V> = Result<V, MyError>;
fn fail() -> Result<V> {
Err(MyError)
}
fn main() {
if let Err(e) = fail() {
e.meth~
}
}
";
assert_eq!(get_only_completion(src, None).matchstr, "method");
}