Merge #5153

5153: Make SemanticsScope non-generic r=matklad a=lnicola

This slightly reduces the build times:

![image](https://user-images.githubusercontent.com/308347/86210975-3a809480-bb7e-11ea-8975-788457f6b353.png)

(compare to https://github.com/rust-analyzer/rust-analyzer/issues/1987#issuecomment-652202248)

Co-authored-by: Laurențiu Nicola <[email protected]>

3 files changed, 15 insertions, 19 deletions

diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 00fa95b6c..01adb834c 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -2,7 +2,6 @@
 use rustc_hash::FxHashMap;
 
 use hir::{HirDisplay, PathResolution, SemanticsScope};
-use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::SyntaxRewriter,
     ast::{self, AstNode},
@@ -32,14 +31,14 @@ impl<'a> AstTransform<'a> for NullTransformer {
 }
 
 pub struct SubstituteTypeParams<'a> {
-    source_scope: &'a SemanticsScope<'a, RootDatabase>,
+    source_scope: &'a SemanticsScope<'a>,
     substs: FxHashMap<hir::TypeParam, ast::TypeRef>,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
 impl<'a> SubstituteTypeParams<'a> {
     pub fn for_trait_impl(
-        source_scope: &'a SemanticsScope<'a, RootDatabase>,
+        source_scope: &'a SemanticsScope<'a>,
         // FIXME: there's implicit invariant that `trait_` and  `source_scope` match...
         trait_: hir::Trait,
         impl_def: ast::ImplDef,
@@ -126,16 +125,13 @@ impl<'a> AstTransform<'a> for SubstituteTypeParams<'a> {
 }
 
 pub struct QualifyPaths<'a> {
-    target_scope: &'a SemanticsScope<'a, RootDatabase>,
-    source_scope: &'a SemanticsScope<'a, RootDatabase>,
+    target_scope: &'a SemanticsScope<'a>,
+    source_scope: &'a SemanticsScope<'a>,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
 impl<'a> QualifyPaths<'a> {
-    pub fn new(
-        target_scope: &'a SemanticsScope<'a, RootDatabase>,
-        source_scope: &'a SemanticsScope<'a, RootDatabase>,
-    ) -> Self {
+    pub fn new(target_scope: &'a SemanticsScope<'a>, source_scope: &'a SemanticsScope<'a>) -> Self {
         Self { target_scope, source_scope, previous: Box::new(NullTransformer) }
     }
 
@@ -156,7 +152,7 @@ impl<'a> QualifyPaths<'a> {
         let resolution = self.source_scope.resolve_hir_path(&hir_path?)?;
         match resolution {
             PathResolution::Def(def) => {
-                let found_path = from.find_use_path(self.source_scope.db, def)?;
+                let found_path = from.find_use_path(self.source_scope.db.upcast(), def)?;
                 let mut path = path_to_ast(found_path);
 
                 let type_args = p
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 6a49c424a..810c49d6f 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -297,19 +297,19 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         self.with_ctx(|ctx| ctx.file_to_def(file)).map(Module::from)
     }
 
-    pub fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db, DB> {
+    pub fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db> {
         let node = self.find_file(node.clone());
         let resolver = self.analyze2(node.as_ref(), None).resolver;
         SemanticsScope { db: self.db, resolver }
     }
 
-    pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db, DB> {
+    pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db> {
         let node = self.find_file(node.clone());
         let resolver = self.analyze2(node.as_ref(), Some(offset)).resolver;
         SemanticsScope { db: self.db, resolver }
     }
 
-    pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db, DB> {
+    pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db> {
         let resolver = def.id.resolver(self.db);
         SemanticsScope { db: self.db, resolver }
     }
@@ -419,12 +419,12 @@ fn find_root(node: &SyntaxNode) -> SyntaxNode {
     node.ancestors().last().unwrap()
 }
 
-pub struct SemanticsScope<'a, DB> {
-    pub db: &'a DB,
+pub struct SemanticsScope<'a> {
+    pub db: &'a dyn HirDatabase,
     resolver: Resolver,
 }
 
-impl<'a, DB: HirDatabase> SemanticsScope<'a, DB> {
+impl<'a> SemanticsScope<'a> {
     pub fn module(&self) -> Option<Module> {
         Some(Module { id: self.resolver.module()? })
     }
@@ -433,13 +433,13 @@ impl<'a, DB: HirDatabase> SemanticsScope<'a, DB> {
     // FIXME: rename to visible_traits to not repeat scope?
     pub fn traits_in_scope(&self) -> FxHashSet<TraitId> {
         let resolver = &self.resolver;
-        resolver.traits_in_scope(self.db)
+        resolver.traits_in_scope(self.db.upcast())
     }
 
     pub fn process_all_names(&self, f: &mut dyn FnMut(Name, ScopeDef)) {
         let resolver = &self.resolver;
 
-        resolver.process_all_names(self.db, &mut |name, def| {
+        resolver.process_all_names(self.db.upcast(), &mut |name, def| {
             let def = match def {
                 resolver::ScopeDef::PerNs(it) => {
                     let items = ScopeDef::all_items(it);
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 560fb19e6..ef22ea54d 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -213,7 +213,7 @@ impl<'a> CompletionContext<'a> {
         }
     }
 
-    pub(crate) fn scope(&self) -> SemanticsScope<'_, RootDatabase> {
+    pub(crate) fn scope(&self) -> SemanticsScope<'_> {
         self.sema.scope_at_offset(&self.token.parent(), self.offset)
     }