Extract struct DynSemantics<'db> from struct Semantics<'db, DB>

Author: regexident

crates/hir/src/lib.rs

@@ -97,8 +97,8 @@ pub use crate::{
     diagnostics::*,
     has_source::HasSource,
     semantics::{
-        PathResolution, PathResolutionPerNs, Semantics, SemanticsImpl, SemanticsScope, TypeInfo,
-        VisibleTraits,
+        DynSemantics, PathResolution, PathResolutionPerNs, Semantics, SemanticsImpl,
+        SemanticsScope, TypeInfo, VisibleTraits,
     },
 };
 

crates/hir/src/semantics.rs

@@ -146,17 +146,11 @@ impl TypeInfo {
     }
 }
 
-/// Primary API to get semantic information, like types, from syntax trees.
+/// Primary API to get semantic information, like types, from syntax trees,
+/// with tight coupling to underlying database.
 pub struct Semantics<'db, DB> {
     pub db: &'db DB,
-    imp: SemanticsImpl<'db>,
-}
-
-pub struct SemanticsImpl<'db> {
-    pub db: &'db dyn HirDatabase,
-    s2d_cache: RefCell<SourceToDefCache>,
-    /// MacroCall to its expansion's MacroCallId cache
-    macro_call_cache: RefCell<FxHashMap<InFile<ast::MacroCall>, MacroCallId>>,
+    sema: DynSemantics<'db>,
 }
 
 impl<DB> fmt::Debug for Semantics<'_, DB> {
@@ -166,17 +160,46 @@ impl<DB> fmt::Debug for Semantics<'_, DB> {
 }
 
 impl<'db, DB> ops::Deref for Semantics<'db, DB> {
+    type Target = DynSemantics<'db>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.sema
+    }
+}
+
+impl<'db, DB: HirDatabase> Semantics<'db, DB> {
+    pub fn new(db: &'db DB) -> Semantics<'db, DB> {
+        let sema = DynSemantics::new(db);
+        Self { db, sema }
+    }
+
+    pub fn into_dyn(self) -> DynSemantics<'db> {
+        self.sema
+    }
+}
+
+/// Primary API to get semantic information, like types, from syntax trees.
+pub struct DynSemantics<'db> {
+    imp: SemanticsImpl<'db>,
+}
+
+impl fmt::Debug for DynSemantics<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Semantics {{ ... }}")
+    }
+}
+
+impl<'db> ops::Deref for DynSemantics<'db> {
     type Target = SemanticsImpl<'db>;
 
     fn deref(&self) -> &Self::Target {
         &self.imp
     }
 }
 
-impl<DB: HirDatabase> Semantics<'_, DB> {
-    pub fn new(db: &DB) -> Semantics<'_, DB> {
-        let impl_ = SemanticsImpl::new(db);
-        Semantics { db, imp: impl_ }
+impl<'db> DynSemantics<'db> {
+    pub fn new(db: &'db dyn HirDatabase) -> Self {
+        Self { imp: SemanticsImpl::new(db) }
     }
 
     pub fn hir_file_for(&self, syntax_node: &SyntaxNode) -> HirFileId {
@@ -319,6 +342,13 @@ impl<DB: HirDatabase> Semantics<'_, DB> {
     }
 }
 
+pub struct SemanticsImpl<'db> {
+    pub db: &'db dyn HirDatabase,
+    s2d_cache: RefCell<SourceToDefCache>,
+    /// MacroCall to its expansion's MacroCallId cache
+    macro_call_cache: RefCell<FxHashMap<InFile<ast::MacroCall>, MacroCallId>>,
+}
+
 impl<'db> SemanticsImpl<'db> {
     fn new(db: &'db dyn HirDatabase) -> Self {
         SemanticsImpl { db, s2d_cache: Default::default(), macro_call_cache: Default::default() }

crates/hir/src/symbols.rs

@@ -19,7 +19,7 @@ use intern::Symbol;
 use rustc_hash::FxHashMap;
 use syntax::{AstNode, AstPtr, SmolStr, SyntaxNode, SyntaxNodePtr, ToSmolStr, ast::HasName};
 
-use crate::{HasCrate, Module, ModuleDef, Semantics};
+use crate::{HasCrate, Module, ModuleDef, semantics::DynSemantics};
 
 pub type FxIndexSet<T> = indexmap::IndexSet<T, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>;
 
@@ -48,7 +48,7 @@ pub struct DeclarationLocation {
 }
 
 impl DeclarationLocation {
-    pub fn syntax<DB: HirDatabase>(&self, sema: &Semantics<'_, DB>) -> SyntaxNode {
+    pub fn syntax(&self, sema: &DynSemantics<'_>) -> SyntaxNode {
         let root = sema.parse_or_expand(self.hir_file_id);
         self.ptr.to_node(&root)
     }

crates/hir/src/term_search.rs

@@ -5,7 +5,7 @@ use hir_ty::db::HirDatabase;
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
 
-use crate::{ModuleDef, ScopeDef, Semantics, SemanticsScope, Type};
+use crate::{DynSemantics, ModuleDef, ScopeDef, SemanticsScope, Type};
 
 mod expr;
 pub use expr::Expr;
@@ -214,9 +214,9 @@ impl LookupTable {
 
 /// Context for the `term_search` function
 #[derive(Debug)]
-pub struct TermSearchCtx<'a, DB: HirDatabase> {
+pub struct TermSearchCtx<'a> {
     /// Semantics for the program
-    pub sema: &'a Semantics<'a, DB>,
+    pub sema: &'a DynSemantics<'a>,
     /// Semantic scope, captures context for the term search
     pub scope: &'a SemanticsScope<'a>,
     /// Target / expected output type
@@ -263,7 +263,7 @@ impl Default for TermSearchConfig {
 /// Note that there are usually more ways we can get to the `goal` type but some are discarded to
 /// reduce the memory consumption. It is also unlikely anyone is willing ti browse through
 /// thousands of possible responses so we currently take first 10 from every tactic.
-pub fn term_search<DB: HirDatabase>(ctx: &TermSearchCtx<'_, DB>) -> Vec<Expr> {
+pub fn term_search(ctx: &TermSearchCtx<'_>) -> Vec<Expr> {
     let module = ctx.scope.module();
     let mut defs = FxHashSet::default();
     defs.insert(ScopeDef::ModuleDef(ModuleDef::Module(module)));

crates/hir/src/term_search/tactics.rs

@@ -11,7 +11,6 @@
 use std::iter;
 
 use hir_ty::TyBuilder;
-use hir_ty::db::HirDatabase;
 use hir_ty::mir::BorrowKind;
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
@@ -40,8 +39,8 @@ use super::{LookupTable, NewTypesKey, TermSearchCtx};
 ///
 /// _Note that there is no use of calling this tactic in every iteration as the output does not
 /// depend on the current state of `lookup`_
-pub(super) fn trivial<'a, DB: HirDatabase>(
-    ctx: &'a TermSearchCtx<'a, DB>,
+pub(super) fn trivial<'a>(
+    ctx: &'a TermSearchCtx<'a>,
     defs: &'a FxHashSet<ScopeDef>,
     lookup: &'a mut LookupTable,
 ) -> impl Iterator<Item = Expr> + 'a {
@@ -104,8 +103,8 @@ pub(super) fn trivial<'a, DB: HirDatabase>(
 ///
 /// _Note that there is no use of calling this tactic in every iteration as the output does not
 /// depend on the current state of `lookup`_
-pub(super) fn assoc_const<'a, DB: HirDatabase>(
-    ctx: &'a TermSearchCtx<'a, DB>,
+pub(super) fn assoc_const<'a>(
+    ctx: &'a TermSearchCtx<'a>,
     defs: &'a FxHashSet<ScopeDef>,
     lookup: &'a mut LookupTable,
 ) -> impl Iterator<Item = Expr> + 'a {
@@ -152,8 +151,8 @@ pub(super) fn assoc_const<'a, DB: HirDatabase>(
 /// * `defs` - Set of items in scope at term search target location
 /// * `lookup` - Lookup table for types
 /// * `should_continue` - Function that indicates when to stop iterating
-pub(super) fn data_constructor<'a, DB: HirDatabase>(
-    ctx: &'a TermSearchCtx<'a, DB>,
+pub(super) fn data_constructor<'a>(
+    ctx: &'a TermSearchCtx<'a>,
     _defs: &'a FxHashSet<ScopeDef>,
     lookup: &'a mut LookupTable,
     should_continue: &'a dyn std::ops::Fn() -> bool,
@@ -301,8 +300,8 @@ pub(super) fn data_constructor<'a, DB: HirDatabase>(
 /// * `defs` - Set of items in scope at term search target location
 /// * `lookup` - Lookup table for types
 /// * `should_continue` - Function that indicates when to stop iterating
-pub(super) fn free_function<'a, DB: HirDatabase>(
-    ctx: &'a TermSearchCtx<'a, DB>,
+pub(super) fn free_function<'a>(
+    ctx: &'a TermSearchCtx<'a>,
     defs: &'a FxHashSet<ScopeDef>,
     lookup: &'a mut LookupTable,
     should_continue: &'a dyn std::ops::Fn() -> bool,
@@ -432,8 +431,8 @@ pub(super) fn free_function<'a, DB: HirDatabase>(
 /// * `defs` - Set of items in scope at term search target location
 /// * `lookup` - Lookup table for types
 /// * `should_continue` - Function that indicates when to stop iterating
-pub(super) fn impl_method<'a, DB: HirDatabase>(
-    ctx: &'a TermSearchCtx<'a, DB>,
+pub(super) fn impl_method<'a>(
+    ctx: &'a TermSearchCtx<'a>,
     _defs: &'a FxHashSet<ScopeDef>,
     lookup: &'a mut LookupTable,
     should_continue: &'a dyn std::ops::Fn() -> bool,
@@ -547,8 +546,8 @@ pub(super) fn impl_method<'a, DB: HirDatabase>(
 /// * `defs` - Set of items in scope at term search target location
 /// * `lookup` - Lookup table for types
 /// * `should_continue` - Function that indicates when to stop iterating
-pub(super) fn struct_projection<'a, DB: HirDatabase>(
-    ctx: &'a TermSearchCtx<'a, DB>,
+pub(super) fn struct_projection<'a>(
+    ctx: &'a TermSearchCtx<'a>,
     _defs: &'a FxHashSet<ScopeDef>,
     lookup: &'a mut LookupTable,
     should_continue: &'a dyn std::ops::Fn() -> bool,
@@ -589,8 +588,8 @@ pub(super) fn struct_projection<'a, DB: HirDatabase>(
 /// * `ctx` - Context for the term search
 /// * `defs` - Set of items in scope at term search target location
 /// * `lookup` - Lookup table for types
-pub(super) fn famous_types<'a, DB: HirDatabase>(
-    ctx: &'a TermSearchCtx<'a, DB>,
+pub(super) fn famous_types<'a>(
+    ctx: &'a TermSearchCtx<'a>,
     _defs: &'a FxHashSet<ScopeDef>,
     lookup: &'a mut LookupTable,
 ) -> impl Iterator<Item = Expr> + 'a {
@@ -620,8 +619,8 @@ pub(super) fn famous_types<'a, DB: HirDatabase>(
 /// * `defs` - Set of items in scope at term search target location
 /// * `lookup` - Lookup table for types
 /// * `should_continue` - Function that indicates when to stop iterating
-pub(super) fn impl_static_method<'a, DB: HirDatabase>(
-    ctx: &'a TermSearchCtx<'a, DB>,
+pub(super) fn impl_static_method<'a>(
+    ctx: &'a TermSearchCtx<'a>,
     _defs: &'a FxHashSet<ScopeDef>,
     lookup: &'a mut LookupTable,
     should_continue: &'a dyn std::ops::Fn() -> bool,
@@ -722,8 +721,8 @@ pub(super) fn impl_static_method<'a, DB: HirDatabase>(
 /// * `defs` - Set of items in scope at term search target location
 /// * `lookup` - Lookup table for types
 /// * `should_continue` - Function that indicates when to stop iterating
-pub(super) fn make_tuple<'a, DB: HirDatabase>(
-    ctx: &'a TermSearchCtx<'a, DB>,
+pub(super) fn make_tuple<'a>(
+    ctx: &'a TermSearchCtx<'a>,
     _defs: &'a FxHashSet<ScopeDef>,
     lookup: &'a mut LookupTable,
     should_continue: &'a dyn std::ops::Fn() -> bool,