Use `dyn Trait` for working with databse

It improves compile time in `--release` mode quite a bit, it doesn't really slow things down and, conceptually, it seems closer to what we want the physical architecture to look like (we don't want to monomorphise EVERYTHING in a single leaf crate).
author: Aleksey Kladov <[email protected]> 2020-03-13 15:05:46 +0000
committer: Aleksey Kladov <[email protected]> 2020-03-16 16:42:30 +0000
commit: 9faea2364dee4fbc9391ad233c570b70256ef002 (patch)
tree: 160af959553ce57fdfcbc0a6c79bafcc3611aeea /crates/ra_hir_ty/src/infer.rs
parent: 648df02953a6ebf87a5876668eceba208687e8a7 (diff)
1 files changed, 19 insertions, 19 deletions
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index 947833412..246b0e9be 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -63,9 +63,9 @@ mod pat;
 mod coerce;
 /// The entry point of type inference.
-pub(crate) fn infer_query(db: &impl HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
+pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
    let _p = profile("infer_query");
-    let resolver = def.resolver(db);
+    let resolver = def.resolver(db.upcast());
    let mut ctx = InferenceContext::new(db, def, resolver);
    match def {
@@ -164,7 +164,7 @@ impl InferenceResult {
    }
    pub fn add_diagnostics(
        &self,
-        db: &impl HirDatabase,
+        db: &dyn HirDatabase,
        owner: FunctionId,
        sink: &mut DiagnosticSink,
    ) {
@@ -190,8 +190,8 @@ impl Index<PatId> for InferenceResult {
 /// The inference context contains all information needed during type inference.
 #[derive(Clone, Debug)]
-struct InferenceContext<'a, D: HirDatabase> {
+struct InferenceContext<'a> {
-    db: &'a D,
+    db: &'a dyn HirDatabase,
    owner: DefWithBodyId,
    body: Arc<Body>,
    resolver: Resolver,
@@ -208,8 +208,8 @@ struct InferenceContext<'a, D: HirDatabase> {
    return_ty: Ty,
 }
-impl<'a, D: HirDatabase> InferenceContext<'a, D> {
+impl<'a> InferenceContext<'a> {
-    fn new(db: &'a D, owner: DefWithBodyId, resolver: Resolver) -> Self {
+    fn new(db: &'a dyn HirDatabase, owner: DefWithBodyId, resolver: Resolver) -> Self {
        InferenceContext {
            result: InferenceResult::default(),
            table: unify::InferenceTable::new(),
@@ -425,7 +425,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
        // FIXME: this should resolve assoc items as well, see this example:
        // https://play.rust-lang.org/?gist=087992e9e22495446c01c0d4e2d69521
-        return match resolver.resolve_path_in_type_ns_fully(self.db, path.mod_path()) {
+        return match resolver.resolve_path_in_type_ns_fully(self.db.upcast(), path.mod_path()) {
            Some(TypeNs::AdtId(AdtId::StructId(strukt))) => {
                let substs = Ty::substs_from_path(&ctx, path, strukt.into());
                let ty = self.db.ty(strukt.into());
@@ -439,7 +439,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                (ty, Some(var.into()))
            }
            Some(TypeNs::SelfType(impl_id)) => {
-                let generics = crate::utils::generics(self.db, impl_id.into());
+                let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
                let substs = Substs::type_params_for_generics(&generics);
                let ty = self.db.impl_self_ty(impl_id).subst(&substs);
                let variant = ty_variant(&ty);
@@ -500,13 +500,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn resolve_into_iter_item(&self) -> Option<TypeAliasId> {
        let path = path![std::iter::IntoIterator];
-        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
+        let trait_ = self.resolver.resolve_known_trait(self.db.upcast(), &path)?;
        self.db.trait_data(trait_).associated_type_by_name(&name![Item])
    }
    fn resolve_ops_try_ok(&self) -> Option<TypeAliasId> {
        let path = path![std::ops::Try];
-        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
+        let trait_ = self.resolver.resolve_known_trait(self.db.upcast(), &path)?;
        self.db.trait_data(trait_).associated_type_by_name(&name![Ok])
    }
@@ -532,37 +532,37 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn resolve_range_full(&self) -> Option<AdtId> {
        let path = path![std::ops::RangeFull];
-        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
+        let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
        Some(struct_.into())
    }
    fn resolve_range(&self) -> Option<AdtId> {
        let path = path![std::ops::Range];
-        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
+        let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
        Some(struct_.into())
    }
    fn resolve_range_inclusive(&self) -> Option<AdtId> {
        let path = path![std::ops::RangeInclusive];
-        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
+        let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
        Some(struct_.into())
    }
    fn resolve_range_from(&self) -> Option<AdtId> {
        let path = path![std::ops::RangeFrom];
-        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
+        let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
        Some(struct_.into())
    }
    fn resolve_range_to(&self) -> Option<AdtId> {
        let path = path![std::ops::RangeTo];
-        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
+        let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
        Some(struct_.into())
    }
    fn resolve_range_to_inclusive(&self) -> Option<AdtId> {
        let path = path![std::ops::RangeToInclusive];
-        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
+        let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
        Some(struct_.into())
    }
@@ -676,13 +676,13 @@ mod diagnostics {
    impl InferenceDiagnostic {
        pub(super) fn add_to(
            &self,
-            db: &impl HirDatabase,
+            db: &dyn HirDatabase,
            owner: FunctionId,
            sink: &mut DiagnosticSink,
        ) {
            match self {
                InferenceDiagnostic::NoSuchField { expr, field } => {
-                    let file = owner.lookup(db).source(db).file_id;
+                    let file = owner.lookup(db.upcast()).source(db.upcast()).file_id;
                    let (_, source_map) = db.body_with_source_map(owner.into());
                    let field = source_map.field_syntax(*expr, *field);
                    sink.push(NoSuchField { file, field })
author	Aleksey Kladov <[email protected]>	2020-03-13 15:05:46 +0000
committer	Aleksey Kladov <[email protected]>	2020-03-16 16:42:30 +0000
commit	9faea2364dee4fbc9391ad233c570b70256ef002 (patch)
tree	160af959553ce57fdfcbc0a6c79bafcc3611aeea /crates/ra_hir_ty/src/infer.rs
parent	648df02953a6ebf87a5876668eceba208687e8a7 (diff)

diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs index 947833412..246b0e9be 100644 --- a/crates/ra_hir_ty/src/infer.rs +++ b/crates/ra_hir_ty/src/infer.rs
@@ -63,9 +63,9 @@ mod pat;
63	mod coerce;	63	mod coerce;
64		64
65	/// The entry point of type inference.	65	/// The entry point of type inference.
66	pub(crate) fn infer_query(db: &impl HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {	66	pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
67	let _p = profile("infer_query");	67	let _p = profile("infer_query");
68	let resolver = def.resolver(db);	68	let resolver = def.resolver(db.upcast());
69	let mut ctx = InferenceContext::new(db, def, resolver);	69	let mut ctx = InferenceContext::new(db, def, resolver);
70		70
71	match def {	71	match def {
@@ -164,7 +164,7 @@ impl InferenceResult {
164	}	164	}
165	pub fn add_diagnostics(	165	pub fn add_diagnostics(
166	&self,	166	&self,
167	db: &impl HirDatabase,	167	db: &dyn HirDatabase,
168	owner: FunctionId,	168	owner: FunctionId,
169	sink: &mut DiagnosticSink,	169	sink: &mut DiagnosticSink,
170	) {	170	) {
@@ -190,8 +190,8 @@ impl Index<PatId> for InferenceResult {
190		190
191	/// The inference context contains all information needed during type inference.	191	/// The inference context contains all information needed during type inference.
192	#[derive(Clone, Debug)]	192	#[derive(Clone, Debug)]
193	struct InferenceContext<'a, D: HirDatabase> {	193	struct InferenceContext<'a> {
194	db: &'a D,	194	db: &'a dyn HirDatabase,
195	owner: DefWithBodyId,	195	owner: DefWithBodyId,
196	body: Arc<Body>,	196	body: Arc<Body>,
197	resolver: Resolver,	197	resolver: Resolver,
@@ -208,8 +208,8 @@ struct InferenceContext<'a, D: HirDatabase> {
208	return_ty: Ty,	208	return_ty: Ty,
209	}	209	}
210		210
211	impl<'a, D: HirDatabase> InferenceContext<'a, D> {	211	impl<'a> InferenceContext<'a> {
212	fn new(db: &'a D, owner: DefWithBodyId, resolver: Resolver) -> Self {	212	fn new(db: &'a dyn HirDatabase, owner: DefWithBodyId, resolver: Resolver) -> Self {
213	InferenceContext {	213	InferenceContext {
214	result: InferenceResult::default(),	214	result: InferenceResult::default(),
215	table: unify::InferenceTable::new(),	215	table: unify::InferenceTable::new(),
@@ -425,7 +425,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
425	let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);	425	let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
426	// FIXME: this should resolve assoc items as well, see this example:	426	// FIXME: this should resolve assoc items as well, see this example:
427	// https://play.rust-lang.org/?gist=087992e9e22495446c01c0d4e2d69521	427	// https://play.rust-lang.org/?gist=087992e9e22495446c01c0d4e2d69521
428	return match resolver.resolve_path_in_type_ns_fully(self.db, path.mod_path()) {	428	return match resolver.resolve_path_in_type_ns_fully(self.db.upcast(), path.mod_path()) {
429	Some(TypeNs::AdtId(AdtId::StructId(strukt))) => {	429	Some(TypeNs::AdtId(AdtId::StructId(strukt))) => {
430	let substs = Ty::substs_from_path(&ctx, path, strukt.into());	430	let substs = Ty::substs_from_path(&ctx, path, strukt.into());
431	let ty = self.db.ty(strukt.into());	431	let ty = self.db.ty(strukt.into());
@@ -439,7 +439,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
439	(ty, Some(var.into()))	439	(ty, Some(var.into()))
440	}	440	}
441	Some(TypeNs::SelfType(impl_id)) => {	441	Some(TypeNs::SelfType(impl_id)) => {
442	let generics = crate::utils::generics(self.db, impl_id.into());	442	let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
443	let substs = Substs::type_params_for_generics(&generics);	443	let substs = Substs::type_params_for_generics(&generics);
444	let ty = self.db.impl_self_ty(impl_id).subst(&substs);	444	let ty = self.db.impl_self_ty(impl_id).subst(&substs);
445	let variant = ty_variant(&ty);	445	let variant = ty_variant(&ty);
@@ -500,13 +500,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
500		500
501	fn resolve_into_iter_item(&self) -> Option<TypeAliasId> {	501	fn resolve_into_iter_item(&self) -> Option<TypeAliasId> {
502	let path = path![std::iter::IntoIterator];	502	let path = path![std::iter::IntoIterator];
503	let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;	503	let trait_ = self.resolver.resolve_known_trait(self.db.upcast(), &path)?;
504	self.db.trait_data(trait_).associated_type_by_name(&name![Item])	504	self.db.trait_data(trait_).associated_type_by_name(&name![Item])
505	}	505	}
506		506
507	fn resolve_ops_try_ok(&self) -> Option<TypeAliasId> {	507	fn resolve_ops_try_ok(&self) -> Option<TypeAliasId> {
508	let path = path![std::ops::Try];	508	let path = path![std::ops::Try];
509	let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;	509	let trait_ = self.resolver.resolve_known_trait(self.db.upcast(), &path)?;
510	self.db.trait_data(trait_).associated_type_by_name(&name![Ok])	510	self.db.trait_data(trait_).associated_type_by_name(&name![Ok])
511	}	511	}
512		512
@@ -532,37 +532,37 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
532		532
533	fn resolve_range_full(&self) -> Option<AdtId> {	533	fn resolve_range_full(&self) -> Option<AdtId> {
534	let path = path![std::ops::RangeFull];	534	let path = path![std::ops::RangeFull];
535	let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;	535	let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
536	Some(struct_.into())	536	Some(struct_.into())
537	}	537	}
538		538
539	fn resolve_range(&self) -> Option<AdtId> {	539	fn resolve_range(&self) -> Option<AdtId> {
540	let path = path![std::ops::Range];	540	let path = path![std::ops::Range];
541	let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;	541	let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
542	Some(struct_.into())	542	Some(struct_.into())
543	}	543	}
544		544
545	fn resolve_range_inclusive(&self) -> Option<AdtId> {	545	fn resolve_range_inclusive(&self) -> Option<AdtId> {
546	let path = path![std::ops::RangeInclusive];	546	let path = path![std::ops::RangeInclusive];
547	let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;	547	let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
548	Some(struct_.into())	548	Some(struct_.into())
549	}	549	}
550		550
551	fn resolve_range_from(&self) -> Option<AdtId> {	551	fn resolve_range_from(&self) -> Option<AdtId> {
552	let path = path![std::ops::RangeFrom];	552	let path = path![std::ops::RangeFrom];
553	let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;	553	let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
554	Some(struct_.into())	554	Some(struct_.into())
555	}	555	}
556		556
557	fn resolve_range_to(&self) -> Option<AdtId> {	557	fn resolve_range_to(&self) -> Option<AdtId> {
558	let path = path![std::ops::RangeTo];	558	let path = path![std::ops::RangeTo];
559	let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;	559	let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
560	Some(struct_.into())	560	Some(struct_.into())
561	}	561	}
562		562
563	fn resolve_range_to_inclusive(&self) -> Option<AdtId> {	563	fn resolve_range_to_inclusive(&self) -> Option<AdtId> {
564	let path = path![std::ops::RangeToInclusive];	564	let path = path![std::ops::RangeToInclusive];
565	let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;	565	let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?;
566	Some(struct_.into())	566	Some(struct_.into())
567	}	567	}
568		568
@@ -676,13 +676,13 @@ mod diagnostics {
676	impl InferenceDiagnostic {	676	impl InferenceDiagnostic {
677	pub(super) fn add_to(	677	pub(super) fn add_to(
678	&self,	678	&self,
679	db: &impl HirDatabase,	679	db: &dyn HirDatabase,
680	owner: FunctionId,	680	owner: FunctionId,
681	sink: &mut DiagnosticSink,	681	sink: &mut DiagnosticSink,
682	) {	682	) {
683	match self {	683	match self {
684	InferenceDiagnostic::NoSuchField { expr, field } => {	684	InferenceDiagnostic::NoSuchField { expr, field } => {
685	let file = owner.lookup(db).source(db).file_id;	685	let file = owner.lookup(db.upcast()).source(db.upcast()).file_id;
686	let (_, source_map) = db.body_with_source_map(owner.into());	686	let (_, source_map) = db.body_with_source_map(owner.into());
687	let field = source_map.field_syntax(expr, field);	687	let field = source_map.field_syntax(expr, field);
688	sink.push(NoSuchField { file, field })	688	sink.push(NoSuchField { file, field })