Support visualization of scopes, borrows and moves

Cargo.toml

@@ -16,10 +16,10 @@ env_logger = "0.4"
 languageserver-types = "0.11"
 log = "0.3"
 racer = "2.0.6"
-rls-analysis = "0.4"
-rls-data = "0.7"
-rls-span = { version = "0.4" , features = ["serialize-serde"] }
-rls-vfs = { version = "0.4", features = ["racer-impls"] }
+rls-analysis = { path = "../rls-analysis" }
+rls-data = { path = "../rls-data", default-features = true, features = ["borrows"] }
+rls-span = { version = "0.4", features = ["serialize-serde"] }
+rls-vfs = { version = "0.4.2", features = ["racer-impls"] }
 rustfmt-nightly = "0.1"
 serde = "1.0"
 serde_json = "1.0"

src/actions/mod.rs

@@ -435,6 +435,35 @@ impl ActionHandler {
         }
     }
 
+    pub fn borrow_info<O: Output>(&self, id: usize, params: TextDocumentPositionParams, out: O) {
+        let t = thread::current();
+        let span = self.convert_pos_to_span(&params.text_document, params.position);
+
+        trace!("borrow_info: {:?}", span);
+
+        let analysis = self.analysis.clone();
+        let rustw_handle = thread::spawn(move || {
+            let bi = analysis.borrow_info(&span);
+            t.unpark();
+            bi.map(|b| b.into())
+        });
+
+        thread::park_timeout(Duration::from_millis(::COMPILER_TIMEOUT));
+
+        let result = rustw_handle.join();
+        match result {
+            Ok(Ok(r)) => {
+                out.success(id, ResponseData::BorrowInfo(r));
+            },
+            Ok(Err(e)) => {
+                out.failure(id, &format!("BorrowInfo not available for that location: {:?}", e)[..]);
+            }
+            Err(_) => {
+                out.failure(id, "BorrowInfo failed to complete successfully");
+            }
+        }
+    }
+
     pub fn execute_command<O: Output>(&self, id: usize, params: ExecuteCommandParams, out: O) {
         match &*params.command {
             "rls.applySuggestion" => {

src/build.rs

@@ -570,6 +570,7 @@ impl BuildQueue {
                 let analysis = self.analysis.clone();
 
                 result.after_analysis.callback = Box::new(move |state| {
+                    let borrow_analysis = state.borrow_analysis_map.take().unwrap();
                     // There are two ways to move the data from rustc to the RLS, either
                     // directly or by serialising and deserialising. We only want to do 
                     // the latter when there are compatibility issues between crates.
@@ -578,6 +579,7 @@ impl BuildQueue {
                     // save::process_crate(state.tcx.unwrap(),
                     //                     state.expanded_crate.unwrap(),
                     //                     state.analysis.unwrap(),
+                    //                     borrow_analysis,
                     //                     state.crate_name.unwrap(),
                     //                     save::DumpHandler::new(save::Format::Json,
                     //                                            state.out_dir,
@@ -586,6 +588,7 @@ impl BuildQueue {
                     save::process_crate(state.tcx.unwrap(),
                                         state.expanded_crate.unwrap(),
                                         state.analysis.unwrap(),
+                                        borrow_analysis,
                                         state.crate_name.unwrap(),
                                         CallbackHandler {
                                             callback: &mut |a| {

src/cmd.rs

@@ -76,6 +76,12 @@ pub fn run() {
                 let col = bits.next().expect("Expected column number");
                 hover(file_name, row, col)
             }
+            "borrows" => {
+                let file_name = bits.next().expect("Expected file name");
+                let row = bits.next().expect("Expected line number");
+                let col = bits.next().expect("Expected column number");
+                borrow_info(file_name, row, col)
+            }
             "h" | "help" => {
                 help();
                 continue;
@@ -127,6 +133,19 @@ fn rename(file_name: &str, row: &str, col: &str, new_name: &str) -> ServerMessag
     ServerMessage::Request(request)
 }
 
+fn borrow_info(file_name: &str, row: &str, col: &str) -> ServerMessage {
+    let params = TextDocumentPositionParams {
+        text_document: TextDocumentIdentifier::new(url(file_name)),
+        position: Position::new(u64::from_str(row).expect("Bad line number"),
+                                u64::from_str(col).expect("Bad column number")),
+    };
+    let request = Request {
+        id: next_id(),
+        method: Method::BorrowInfo(params),
+    };
+    ServerMessage::Request(request)
+}
+
 fn hover(file_name: &str, row: &str, col: &str) -> ServerMessage {
     let params = TextDocumentPositionParams {
         text_document: TextDocumentIdentifier::new(url(file_name)),
@@ -258,4 +277,8 @@ fn help() {
     println!("    hover   file_name line_number column_number");
     println!("            textDocument/hover");
     println!("            used for 'hover'");
+    println!("");
+    println!("    borrows file_name line_number column_number");
+    println!("            rustDocument/borrowInfo");
+    println!("            used for 'borrow info'");
 }

src/custom_types.rs

@@ -0,0 +1,77 @@
+use lsp_data::Range;
+use lsp_data::ls_util::rls_to_range;
+use std::convert::From;
+use analysis;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BorrowData {
+    pub scopes: Vec<Scope>,
+    pub loans: Vec<Loan>,
+    pub moves: Vec<Move>,
+}
+
+impl From<analysis::BorrowData> for BorrowData {
+    fn from(borrows: analysis::BorrowData) -> BorrowData {
+        BorrowData {
+            scopes: borrows.scopes.into_iter().map(|a| a.into()).collect(),
+            moves: borrows.moves.into_iter().map(|m| m.into()).collect(),
+            loans: borrows.loans.into_iter().map(|l| l.into()).collect(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum BorrowKind {
+    ImmBorrow,
+    MutBorrow,
+}
+
+impl From<analysis::BorrowKind> for BorrowKind {
+    fn from(kind: analysis::BorrowKind) -> BorrowKind {
+        match kind {
+            analysis::BorrowKind::ImmBorrow => BorrowKind::ImmBorrow,
+            analysis::BorrowKind::MutBorrow => BorrowKind::MutBorrow,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Loan {
+    pub kind: BorrowKind,
+    pub range: Range,
+}
+
+impl From<analysis::Loan> for Loan {
+    fn from(loan: analysis::Loan) -> Loan {
+        Loan {
+            kind: loan.kind.into(),
+            range: rls_to_range(loan.span.range),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Move {
+    pub range: Range,
+}
+
+impl From<analysis::Move> for Move {
+    fn from(mov: analysis::Move) -> Move {
+        Move {
+            range: rls_to_range(mov.span.range),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Scope {
+    pub range: Range,
+}
+
+impl From<analysis::Scope> for Scope {
+    fn from(scope: analysis::Scope) -> Scope {
+        Scope {
+            range: rls_to_range(scope.span.range),
+        }
+    }
+}

src/main.rs

@@ -48,6 +48,7 @@ mod cmd;
 mod config;
 mod lsp_data;
 mod server;
+mod custom_types;
 
 #[cfg(test)]
 mod test;

src/server.rs

@@ -15,6 +15,7 @@ use serde_json;
 use build::*;
 use lsp_data::*;
 use actions::ActionHandler;
+use custom_types::BorrowData;
 
 use std::fmt;
 use std::io::{self, Read, Write, ErrorKind};
@@ -93,6 +94,7 @@ serializable_enum!(ResponseData,
     Locations(Vec<Location>),
     Highlights(Vec<DocumentHighlight>),
     HoverSuccess(Hover),
+    BorrowInfo(BorrowData),
     Commands(Vec<Command>),
     Ack(Ack)
 );
@@ -244,6 +246,7 @@ messages! {
         "textDocument/references" => References(ReferenceParams);
         "textDocument/completion" => Completion(TextDocumentPositionParams);
         "textDocument/documentHighlight" => DocumentHighlight(TextDocumentPositionParams);
+        "rustDocument/borrowInfo" => BorrowInfo(TextDocumentPositionParams);
         // currently, we safely ignore this as a pass-through since we fully handle
         // textDocument/completion.  In the future, we may want to use this method as a
         // way to more lazily fill out completion information
@@ -442,6 +445,7 @@ impl<O: Output> LsService<O> {
                 References(params) => { action: find_all_refs };
                 Completion(params) => { action: complete };
                 DocumentHighlight(params) => { action: highlight };
+                BorrowInfo(params) => { action: borrow_info };
                 ResolveCompletionItem(params) => {
                     this.output.success(id, ResponseData::CompletionItems(vec![params]))
                 };