Yet another attempt at nice API

Author: matklad

crates/ra_hir/src/lib.rs

@@ -26,6 +26,7 @@ macro_rules! impl_froms {
     }
 }
 
+mod semantics;
 pub mod db;
 pub mod source_analyzer;
 pub mod source_binder;
@@ -45,6 +46,7 @@ pub use crate::{
         StructField, Trait, Type, TypeAlias, TypeParam, Union, VariantDef,
     },
     has_source::HasSource,
+    semantics::Semantics,
     source_analyzer::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
     source_binder::SourceBinder,
 };

crates/ra_hir/src/semantics.rs

@@ -0,0 +1,123 @@
+use std::{cell::RefCell, iter::successors};
+
+use ra_db::FileId;
+use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxToken};
+use rustc_hash::FxHashMap;
+
+use crate::{
+    db::HirDatabase, source_binder::ToDef, Function, HirFileId, InFile, MacroDef, PathResolution,
+    SourceAnalyzer, SourceBinder, StructField, Type,
+};
+
+pub struct Semantics<'a, DB> {
+    pub db: &'a DB,
+    sb: RefCell<SourceBinder<'a, DB>>,
+    cache: RefCell<FxHashMap<SyntaxNode, HirFileId>>,
+}
+
+impl<DB: HirDatabase> Semantics<'_, DB> {
+    pub fn new(db: &DB) -> Semantics<DB> {
+        let sb = RefCell::new(SourceBinder::new(db));
+        Semantics { db, sb, cache: RefCell::default() }
+    }
+
+    pub fn file_syntax(&self, file_id: FileId) -> ast::SourceFile {
+        let tree = self.db.parse(file_id).tree();
+        self.cache(tree.syntax().clone(), file_id.into());
+        tree
+    }
+
+    pub fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
+        let parent = token.parent();
+        let parent = self.find_file(parent);
+        let sa = self.sb.borrow_mut().analyze(parent.as_ref(), None);
+
+        let token = successors(Some(parent.with_value(token)), |token| {
+            let macro_call = token.value.ancestors().find_map(ast::MacroCall::cast)?;
+            let tt = macro_call.token_tree()?;
+            if !token.value.text_range().is_subrange(&tt.syntax().text_range()) {
+                return None;
+            }
+            let exp = sa.expand(self.db, token.with_value(&macro_call))?;
+            let token = exp.map_token_down(self.db, token.as_ref())?;
+
+            self.cache(find_root(&token.value.parent()), token.file_id);
+
+            Some(token)
+        })
+        .last()
+        .unwrap();
+
+        token.value
+    }
+
+    pub fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
+        let node = self.find_file(node);
+        node.ancestors_with_macros(self.db).map(|it| it.value)
+    }
+
+    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
+        self.analyze(expr.syntax().clone()).type_of(self.db, &expr)
+    }
+
+    pub fn type_of_pat(&self, pat: &ast::Pat) -> Option<Type> {
+        self.analyze(pat.syntax().clone()).type_of_pat(self.db, &pat)
+    }
+
+    pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
+        self.analyze(call.syntax().clone()).resolve_method_call(call)
+    }
+
+    pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<StructField> {
+        self.analyze(field.syntax().clone()).resolve_field(field)
+    }
+
+    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<StructField> {
+        self.analyze(field.syntax().clone()).resolve_record_field(field)
+    }
+
+    pub fn resolve_macro_call(&self, macro_call: &ast::MacroCall) -> Option<MacroDef> {
+        let sa = self.analyze(macro_call.syntax().clone());
+        let macro_call = self.find_file(macro_call.syntax().clone()).with_value(macro_call);
+        sa.resolve_macro_call(self.db, macro_call)
+    }
+
+    pub fn resolve_path(&self, path: &ast::Path) -> Option<PathResolution> {
+        self.analyze(path.syntax().clone()).resolve_path(self.db, path)
+    }
+
+    // FIXME: use this instead?
+    // pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option<???>;
+
+    pub fn to_def<T: ToDef>(&self, src: T) -> Option<T::Def> {
+        let src = self.find_file(src.syntax().clone()).with_value(src);
+        let mut sb = self.sb.borrow_mut();
+        T::to_def(&mut sb, src)
+    }
+
+    fn analyze(&self, node: SyntaxNode) -> SourceAnalyzer {
+        let src = self.find_file(node.clone());
+        self.sb.borrow_mut().analyze(src.as_ref(), None)
+    }
+
+    fn cache(&self, root_node: SyntaxNode, file_id: HirFileId) {
+        assert!(root_node.parent().is_none());
+        let mut cache = self.cache.borrow_mut();
+        let prev = cache.insert(root_node, file_id);
+        assert!(prev.is_none());
+    }
+    fn lookup(&self, root_node: &SyntaxNode) -> HirFileId {
+        let cache = self.cache.borrow();
+        cache[root_node]
+    }
+
+    fn find_file(&self, node: SyntaxNode) -> InFile<SyntaxNode> {
+        let root_node = find_root(&node);
+        let file_id = self.lookup(&root_node);
+        InFile::new(file_id, node)
+    }
+}
+
+fn find_root(node: &SyntaxNode) -> SyntaxNode {
+    node.ancestors().last().unwrap()
+}

crates/ra_ide/src/goto_type_definition.rs

@@ -1,31 +1,31 @@
 //! FIXME: write short doc here
 
-use hir::db::AstDatabase;
 use ra_ide_db::RootDatabase;
-use ra_syntax::{ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset};
+use ra_syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset};
 
-use crate::{
-    display::ToNav, expand::descend_into_macros, FilePosition, NavigationTarget, RangeInfo,
-};
+use crate::{display::ToNav, FilePosition, NavigationTarget, RangeInfo};
 
 pub(crate) fn goto_type_definition(
     db: &RootDatabase,
     position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
-    let file = db.parse_or_expand(position.file_id.into())?;
-    let token = pick_best(file.token_at_offset(position.offset))?;
-    let token = descend_into_macros(db, position.file_id, token);
-
-    let node = token
-        .value
-        .ancestors()
-        .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?;
-
-    let analyzer = hir::SourceAnalyzer::new(db, token.with_value(&node), None);
+    let sema = hir::Semantics::new(db);
+
+    let file: ast::SourceFile = sema.file_syntax(position.file_id);
+    let token: SyntaxToken = pick_best(file.syntax().token_at_offset(position.offset))?;
+    let token: SyntaxToken = sema.descend_into_macros(token);
+
+    let (ty, node) = sema.ancestors_with_macros(token.parent()).find_map(|node| {
+        let ty = match_ast! {
+            match node {
+                ast::Expr(expr) => { sema.type_of_expr(&expr)? },
+                ast::Pat(pat) => { sema.type_of_pat(&pat)? },
+                _ => { return None },
+            }
+        };
 
-    let ty: hir::Type = ast::Expr::cast(node.clone())
-        .and_then(|e| analyzer.type_of(db, &e))
-        .or_else(|| ast::Pat::cast(node.clone()).and_then(|p| analyzer.type_of_pat(db, &p)))?;
+        Some((ty, node))
+    })?;
 
     let adt_def = ty.autoderef(db).find_map(|ty| ty.as_adt())?;
 

crates/ra_ide/src/references.rs

@@ -28,7 +28,7 @@ use ra_syntax::{
 use crate::{display::ToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
 
 pub(crate) use self::{
-    classify::{classify_name, classify_name_ref},
+    classify::{classify_name, classify_name_ref, classify_name_ref2},
     rename::rename,
 };
 pub(crate) use ra_ide_db::defs::NameDefinition;

crates/ra_ide/src/references/classify.rs

@@ -1,6 +1,6 @@
 //! Functions that are used to classify an element from its definition or reference.
 
-use hir::{InFile, PathResolution, SourceBinder};
+use hir::{InFile, PathResolution, Semantics, SourceBinder};
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode};
 use test_utils::tested_by;
@@ -69,3 +69,60 @@ pub(crate) fn classify_name_ref(
     };
     Some(res)
 }
+
+pub(crate) fn classify_name_ref2(
+    sema: &Semantics<RootDatabase>,
+    name_ref: &ast::NameRef,
+) -> Option<NameDefinition> {
+    let _p = profile("classify_name_ref");
+
+    let parent = name_ref.syntax().parent()?;
+
+    if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
+        tested_by!(goto_def_for_methods);
+        if let Some(func) = sema.resolve_method_call(&method_call) {
+            return Some(from_module_def(func.into()));
+        }
+    }
+
+    if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
+        tested_by!(goto_def_for_fields);
+        if let Some(field) = sema.resolve_field(&field_expr) {
+            return Some(from_struct_field(field));
+        }
+    }
+
+    if let Some(record_field) = ast::RecordField::cast(parent.clone()) {
+        tested_by!(goto_def_for_record_fields);
+        tested_by!(goto_def_for_field_init_shorthand);
+        if let Some(field_def) = sema.resolve_record_field(&record_field) {
+            return Some(from_struct_field(field_def));
+        }
+    }
+
+    if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
+        tested_by!(goto_def_for_macros);
+        if let Some(macro_def) = sema.resolve_macro_call(&macro_call) {
+            return Some(NameDefinition::Macro(macro_def));
+        }
+    }
+
+    let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
+    let resolved = sema.resolve_path(&path)?;
+    let res = match resolved {
+        PathResolution::Def(def) => from_module_def(def),
+        PathResolution::AssocItem(item) => {
+            let def = match item {
+                hir::AssocItem::Function(it) => it.into(),
+                hir::AssocItem::Const(it) => it.into(),
+                hir::AssocItem::TypeAlias(it) => it.into(),
+            };
+            from_module_def(def)
+        }
+        PathResolution::Local(local) => NameDefinition::Local(local),
+        PathResolution::TypeParam(par) => NameDefinition::TypeParam(par),
+        PathResolution::Macro(def) => NameDefinition::Macro(def),
+        PathResolution::SelfType(impl_block) => NameDefinition::SelfType(impl_block),
+    };
+    Some(res)
+}

crates/ra_ide/src/snapshots/rainbow_highlighting.html

@@ -25,14 +25,14 @@
 .keyword\.control  { color: #F0DFAF; font-weight: bold; }
 </style>
 <pre><code><span class="keyword">fn</span> <span class="function">main</span>() {
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span> = <span class="string">"hello"</span>;
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="4303609361109701698" style="color: hsl(242,75%,88%);">x</span> = <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span>.to_string();
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="13865792086344377029" style="color: hsl(340,64%,86%);">y</span> = <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span> = <span class="string">"hello"</span>;
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="2705725358298919760" style="color: hsl(17,51%,74%);">x</span> = <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="3365759661443752373" style="color: hsl(127,76%,66%);">y</span> = <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span>.to_string();
 
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="7011301204224269512" style="color: hsl(198,45%,40%);">x</span> = <span class="string">"other color please!"</span>;
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="12461245066629867975" style="color: hsl(132,91%,68%);">y</span> = <span class="variable" data-binding-hash="7011301204224269512" style="color: hsl(198,45%,40%);">x</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="794745962933817518" style="color: hsl(19,74%,76%);">x</span> = <span class="string">"other color please!"</span>;
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="6717528807933952652" style="color: hsl(85,49%,84%);">y</span> = <span class="variable" data-binding-hash="794745962933817518" style="color: hsl(19,74%,76%);">x</span>.to_string();
 }
 
 <span class="keyword">fn</span> <span class="function">bar</span>() {
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span> = <span class="string">"hello"</span>;
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span> = <span class="string">"hello"</span>;
 }</code></pre>