Merge #350

350: Super simple macro support r=matklad a=matklad

Super simple support for macros, mostly for figuring out how to fit them into the current architecture. Expansion is hard-coded and string based (mid-term, we should try to copy-paste macro-by-example expander from rustc). 

Ideally, we should handle

* highlighting inside the macro (done)
* extend selection inside the macro 
* completion inside the macro
* indexing structs, produced by the macro

Co-authored-by: Aleksey Kladov <[email protected]>

5 files changed, 167 insertions, 22 deletions

diff --git a/crates/ra_analysis/src/extend_selection.rs b/crates/ra_analysis/src/extend_selection.rs
new file mode 100644
index 000000000..5e1fbee18
--- /dev/null
+++ b/crates/ra_analysis/src/extend_selection.rs
@@ -0,0 +1,11 @@
+use ra_db::SyntaxDatabase;
+
+use crate::{
+    TextRange, FileRange,
+    db::RootDatabase,
+};
+
+pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRange {
+    let file = db.source_file(frange.file_id);
+    ra_editor::extend_selection(&file, frange.range).unwrap_or(frange.range)
+}
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index e6663810d..fcb4cd957 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -23,7 +23,7 @@ use crate::{
     AnalysisChange,
     Cancelable,
     completion::{CompletionItem, completions},
-    CrateId, db, Diagnostic, FileId, FilePosition, FileSystemEdit,
+    CrateId, db, Diagnostic, FileId, FilePosition, FileRange, FileSystemEdit,
     Query, ReferenceResolution, RootChange, SourceChange, SourceFileEdit,
     symbol_index::{LibrarySymbolsQuery, SymbolIndex, SymbolsDatabase},
 };
@@ -404,19 +404,21 @@ impl AnalysisImpl {
         Ok(res)
     }
 
-    pub fn assists(&self, file_id: FileId, range: TextRange) -> Vec<SourceChange> {
-        let file = self.file_syntax(file_id);
-        let offset = range.start();
+    pub fn assists(&self, frange: FileRange) -> Vec<SourceChange> {
+        let file = self.file_syntax(frange.file_id);
+        let offset = frange.range.start();
         let actions = vec![
             ra_editor::flip_comma(&file, offset).map(|f| f()),
             ra_editor::add_derive(&file, offset).map(|f| f()),
             ra_editor::add_impl(&file, offset).map(|f| f()),
             ra_editor::make_pub_crate(&file, offset).map(|f| f()),
-            ra_editor::introduce_variable(&file, range).map(|f| f()),
+            ra_editor::introduce_variable(&file, frange.range).map(|f| f()),
         ];
         actions
             .into_iter()
-            .filter_map(|local_edit| Some(SourceChange::from_local_edit(file_id, local_edit?)))
+            .filter_map(|local_edit| {
+                Some(SourceChange::from_local_edit(frange.file_id, local_edit?))
+            })
             .collect()
     }
 
@@ -487,13 +489,15 @@ impl AnalysisImpl {
         Ok(None)
     }
 
-    pub fn type_of(&self, file_id: FileId, range: TextRange) -> Cancelable<Option<String>> {
-        let file = self.db.source_file(file_id);
+    pub fn type_of(&self, frange: FileRange) -> Cancelable<Option<String>> {
+        let file = self.db.source_file(frange.file_id);
         let syntax = file.syntax();
-        let node = find_covering_node(syntax, range);
+        let node = find_covering_node(syntax, frange.range);
         let parent_fn = ctry!(node.ancestors().find_map(FnDef::cast));
         let function = ctry!(source_binder::function_from_source(
-            &*self.db, file_id, parent_fn
+            &*self.db,
+            frange.file_id,
+            parent_fn
         )?);
         let infer = function.infer(&*self.db)?;
         Ok(infer.type_of_node(node).map(|t| t.to_string()))
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 65c3eb3ec..67b1c1482 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -16,6 +16,10 @@ mod completion;
 mod symbol_index;
 pub mod mock_analysis;
 
+mod extend_selection;
+mod syntax_highlighting;
+mod macros;
+
 use std::{fmt, sync::Arc};
 
 use rustc_hash::FxHashMap;
@@ -37,7 +41,7 @@ pub use ra_editor::{
 pub use hir::FnSignatureInfo;
 
 pub use ra_db::{
-    Canceled, Cancelable, FilePosition,
+    Canceled, Cancelable, FilePosition, FileRange,
     CrateGraph, CrateId, SourceRootId, FileId
 };
 
@@ -276,8 +280,8 @@ impl Analysis {
     pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
         self.imp.file_line_index(file_id)
     }
-    pub fn extend_selection(&self, file: &SourceFileNode, range: TextRange) -> TextRange {
-        ra_editor::extend_selection(file, range).unwrap_or(range)
+    pub fn extend_selection(&self, frange: FileRange) -> TextRange {
+        extend_selection::extend_selection(&self.imp.db, frange)
     }
     pub fn matching_brace(&self, file: &SourceFileNode, offset: TextUnit) -> Option<TextUnit> {
         ra_editor::matching_brace(file, offset)
@@ -286,9 +290,9 @@ impl Analysis {
         let file = self.imp.file_syntax(file_id);
         ra_editor::syntax_tree(&file)
     }
-    pub fn join_lines(&self, file_id: FileId, range: TextRange) -> SourceChange {
-        let file = self.imp.file_syntax(file_id);
-        SourceChange::from_local_edit(file_id, ra_editor::join_lines(&file, range))
+    pub fn join_lines(&self, frange: FileRange) -> SourceChange {
+        let file = self.imp.file_syntax(frange.file_id);
+        SourceChange::from_local_edit(frange.file_id, ra_editor::join_lines(&file, frange.range))
     }
     pub fn on_enter(&self, position: FilePosition) -> Option<SourceChange> {
         let file = self.imp.file_syntax(position.file_id);
@@ -340,14 +344,13 @@ impl Analysis {
         Ok(ra_editor::runnables(&file))
     }
     pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
-        let file = self.imp.file_syntax(file_id);
-        Ok(ra_editor::highlight(&file))
+        syntax_highlighting::highlight(&*self.imp.db, file_id)
     }
     pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
         self.imp.completions(position)
     }
-    pub fn assists(&self, file_id: FileId, range: TextRange) -> Cancelable<Vec<SourceChange>> {
-        Ok(self.imp.assists(file_id, range))
+    pub fn assists(&self, frange: FileRange) -> Cancelable<Vec<SourceChange>> {
+        Ok(self.imp.assists(frange))
     }
     pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
         self.imp.diagnostics(file_id)
@@ -358,8 +361,8 @@ impl Analysis {
     ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
         self.imp.resolve_callable(position)
     }
-    pub fn type_of(&self, file_id: FileId, range: TextRange) -> Cancelable<Option<String>> {
-        self.imp.type_of(file_id, range)
+    pub fn type_of(&self, frange: FileRange) -> Cancelable<Option<String>> {
+        self.imp.type_of(frange)
     }
 }
 
diff --git a/crates/ra_analysis/src/macros.rs b/crates/ra_analysis/src/macros.rs
new file mode 100644
index 000000000..c0dd49dc8
--- /dev/null
+++ b/crates/ra_analysis/src/macros.rs
@@ -0,0 +1,64 @@
+/// Begining of macro expansion.
+///
+/// This code should be moved out of ra_analysis into hir (?) ideally.
+use ra_syntax::{ast, AstNode, SourceFileNode, TextRange};
+
+use crate::{db::RootDatabase, FileId};
+
+pub(crate) fn expand(
+    _db: &RootDatabase,
+    _file_id: FileId,
+    macro_call: ast::MacroCall,
+) -> Option<MacroExpansion> {
+    let path = macro_call.path()?;
+    if path.qualifier().is_some() {
+        return None;
+    }
+    let name_ref = path.segment()?.name_ref()?;
+    if name_ref.text() != "ctry" {
+        return None;
+    }
+
+    let arg = macro_call.token_tree()?;
+    let text = format!(
+        r"
+        fn dummy() {{
+            match {} {{
+                None => return Ok(None),
+                Some(it) => it,
+            }}
+        }}",
+        arg.syntax().text()
+    );
+    let file = SourceFileNode::parse(&text);
+    let match_expr = file.syntax().descendants().find_map(ast::MatchExpr::cast)?;
+    let match_arg = match_expr.expr()?;
+    let ranges_map = vec![(arg.syntax().range(), match_arg.syntax().range())];
+    let res = MacroExpansion {
+        source_file: file,
+        ranges_map,
+    };
+    Some(res)
+}
+
+pub(crate) struct MacroExpansion {
+    pub(crate) source_file: SourceFileNode,
+    pub(crate) ranges_map: Vec<(TextRange, TextRange)>,
+}
+
+impl MacroExpansion {
+    pub(crate) fn source_file(&self) -> &SourceFileNode {
+        &self.source_file
+    }
+    pub(crate) fn map_range_back(&self, tgt_range: TextRange) -> Option<TextRange> {
+        for (s_range, t_range) in self.ranges_map.iter() {
+            if tgt_range.is_subrange(&t_range) {
+                let tgt_at_zero_range = tgt_range - tgt_range.start();
+                let tgt_range_offset = tgt_range.start() - t_range.start();
+                let src_range = tgt_at_zero_range + tgt_range_offset + s_range.start();
+                return Some(src_range);
+            }
+        }
+        None
+    }
+}
diff --git a/crates/ra_analysis/src/syntax_highlighting.rs b/crates/ra_analysis/src/syntax_highlighting.rs
new file mode 100644
index 000000000..38219da71
--- /dev/null
+++ b/crates/ra_analysis/src/syntax_highlighting.rs
@@ -0,0 +1,63 @@
+use ra_syntax::{ast, AstNode,};
+use ra_editor::HighlightedRange;
+use ra_db::SyntaxDatabase;
+
+use crate::{
+    db::RootDatabase,
+    FileId, Cancelable,
+};
+
+pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
+    let source_file = db.source_file(file_id);
+    let mut res = ra_editor::highlight(&source_file);
+    for macro_call in source_file
+        .syntax()
+        .descendants()
+        .filter_map(ast::MacroCall::cast)
+    {
+        if let Some(exp) = crate::macros::expand(db, file_id, macro_call) {
+            let mapped_ranges = ra_editor::highlight(exp.source_file())
+                .into_iter()
+                .filter_map(|r| {
+                    let mapped_range = exp.map_range_back(r.range)?;
+                    let res = HighlightedRange {
+                        range: mapped_range,
+                        tag: r.tag,
+                    };
+                    Some(res)
+                });
+            res.extend(mapped_ranges);
+        }
+    }
+    Ok(res)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::mock_analysis::single_file;
+    use test_utils::assert_eq_dbg;
+
+    #[test]
+    fn highlights_code_inside_macros() {
+        let (analysis, file_id) = single_file(
+            "
+            fn main() {
+                ctry!({ let x = 92; x});
+            }
+        ",
+        );
+        let highlights = analysis.highlight(file_id).unwrap();
+        assert_eq_dbg(
+            r#"[HighlightedRange { range: [13; 15), tag: "keyword" },
+                HighlightedRange { range: [16; 20), tag: "function" },
+                HighlightedRange { range: [41; 46), tag: "macro" },
+                HighlightedRange { range: [49; 52), tag: "keyword" },
+                HighlightedRange { range: [57; 59), tag: "literal" },
+                HighlightedRange { range: [49; 52), tag: "keyword" },
+                HighlightedRange { range: [53; 54), tag: "function" },
+                HighlightedRange { range: [57; 59), tag: "literal" },
+                HighlightedRange { range: [61; 62), tag: "text" }]"#,
+            &highlights,
+        )
+    }
+}