Roadmap for enhancement

[kngwyu]

Here's a list of functionalities I want to implement in racer.
Please comment anything you think!

Completions

Completion based on trait bounds(#706)

• for FnArg
  already implemented in Completion by trait bounds for fnarg #828

fn f<T: Clone>(a: T) {
    let b = a.clo~
}

• for struct member

struct S<T> {
    mem: T
}
fn f<T: Clone>(a: S<T>) {
    let b = a.mem.clo~
}
impl<T: Clone> S<T> {
    fn f(self) {
        let b = a.mem.clo~
    } 
}

• for closures

fn fun<F: Fn() -> Option<i64>>(f: F) {
    let a = f().unwra~
}

Others

• closure arguments

let f = |v: Vec<i64>| {
    v.le~
};

• macros in other crate(related to Add complete support for std lib macros such as println! #777)

• resolve associated type bounded by type parameter, using real type (thanks to @cynecx !)

use std::ops::Deref;

struct Foo {}

impl Foo {
    fn bar(&self) {
        println!("nights");
    }
}

struct Ref<'a, T: 'a> {
    obj: &'a T,
}

impl<'a, T> Deref for Ref<'a, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        self.obj
    }
}

fn main() {
    let a = Ref { obj: &Foo {} };
    // a. // Auto-complete does not work here
}

Nightly features

• impl trait(universal_impl_trait, conservative_impl_trait)
• dyn_trait
  Currently dyn cause parse error in racer, and racer can't complete members in a struct with dyn, like

struct AppHandler {
    name: String,
    app: Box<dyn Application>,
}

• try_trait
• extern_in_paths
• use_nested_groups (It's stable now!)
• crate_visibility_modifier

Since syntex-syntax isn't maintained now, we need rustc-ap-syntax to support these features.

Misc

• Union support(Add support for unions #769)
• loop label support
  like

'label: loop {
    for i in 0..10 {
         if i == 5 {
            break 'lab~
        }
    }
}

(Though I don't know anyone need this...)

• make racer's search flag more specific(extern crate ~ autocomplete should include only crate names #830 )

[cynecx]

I am not sure if this is just a bug or it's simply not supported:

use std::ops::Deref;

struct Foo {}

impl Foo {
    fn bar(&self) {
        println!("nights");
    }
}

struct Ref<'a, T: 'a> {
    obj: &'a T,
}

impl<'a, T> Deref for Ref<'a, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        self.obj
    }
}

fn main() {
    let a = Ref { obj: &Foo {} };
    // a. // Auto-complete does not work here
}

This doesn't work with rls, but since rls is actually using racer for auto-completion, I assume that it is more appropriate to report this here.

[kngwyu]

@cynecx
Are you pointing out that racer doesn't complete a.bar() ?
Racer supports method completion based on type coercions by Deref, but if Target is generic type parameter, racer doesn't seem to work well.
Though I'm not sure it's a bug or not, I'm going to open a separate issue after checking more deeper.
Thanks for reporting!

[cynecx]

@kngwyu Oh yeah, sorry, I forgot to mention that. The field obj and the method deref are shown in the auto-completion set, the method bar however is not included in that set.

[kngwyu]

Hmm...
Now I feel this problem more difficult than others in this roadmap, so I decided to add it to this page and not to open separate issue.

[abbec]

I would love to see support for use_nested_groups!

[kngwyu]

@abbec
use_nested_groups is already supported in my nightly version

[abbec]

Trying right now :D

[abbec]

Works, awesome ❤️ !

[Dushistov]

use_nested_groups is already supported in my nightly version

@kngwyu Any plans to merge it into racer mainline?

[kngwyu]

@Dushistov
I got push previlege for this repository 2 days ago so I will send a PR soon.
Sorry for delay.