nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-06-04 19:29:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Decouple more

Browse Source
This commit is contained in:
Aleksey Kladov 2019-11-27 15:56:20 +03:00
parent 35f57f35ec
commit d569869f7a
5 changed files with 41 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/ra_hir/src/code_model.rs
View File

@ -647,7 +647,7 @@ impl Function {
pub fn diagnostics(self, db: &impl HirDatabase, sink: &mut DiagnosticSink) {
let infer = self.infer(db);
infer.add_diagnostics(db, self, sink);
infer.add_diagnostics(db, self.id, sink);
let mut validator = ExprValidator::new(self, infer, sink);
validator.validate_body(db);
}

6
crates/ra_hir/src/source_binder.rs
View File

@ -214,17 +214,17 @@ impl SourceAnalyzer {
pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
let expr_id = self.expr_id(&call.clone().into())?;
self.infer.as_ref()?.method_resolution(expr_id)
self.infer.as_ref()?.method_resolution(expr_id).map(Function::from)
}
pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<crate::StructField> {
let expr_id = self.expr_id(&field.clone().into())?;
self.infer.as_ref()?.field_resolution(expr_id)
self.infer.as_ref()?.field_resolution(expr_id).map(|it| it.into())
}
pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<crate::StructField> {
let expr_id = self.expr_id(&field.expr()?)?;
self.infer.as_ref()?.record_field_resolution(expr_id)
self.infer.as_ref()?.record_field_resolution(expr_id).map(|it| it.into())
}
pub fn resolve_record_literal(&self, record_lit: &ast::RecordLit) -> Option<crate::VariantDef> {

54
crates/ra_hir/src/ty/infer.rs
View File

@ -22,11 +22,13 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
use rustc_hash::FxHashMap;
use hir_def::{
body::Body,
data::{ConstData, FunctionData},
path::known,
expr::{BindingAnnotation, ExprId, PatId},
path::{known, Path},
resolver::{HasResolver, Resolver, TypeNs},
type_ref::{Mutability, TypeRef},
AdtId, AssocItemId, DefWithBodyId,
AdtId, AssocItemId, DefWithBodyId, FunctionId, StructFieldId, TypeAliasId,
};
use hir_expand::{diagnostics::DiagnosticSink, name};
use ra_arena::map::ArenaMap;
@ -34,16 +36,14 @@ use ra_prof::profile;
use test_utils::tested_by;
use super::{
primitive::{FloatTy, IntTy},
traits::{Guidance, Obligation, ProjectionPredicate, Solution},
ApplicationTy, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeCtor,
TypeWalk, Uncertain,
};
use crate::{
code_model::TypeAlias,
db::HirDatabase,
expr::{BindingAnnotation, Body, ExprId, PatId},
ty::infer::diagnostics::InferenceDiagnostic,
AssocItem, DefWithBody, FloatTy, Function, IntTy, Path, StructField, VariantDef,
db::HirDatabase, ty::infer::diagnostics::InferenceDiagnostic, AssocItem, DefWithBody,
VariantDef,
};
macro_rules! ty_app {
@ -121,11 +121,11 @@ pub struct TypeMismatch {
#[derive(Clone, PartialEq, Eq, Debug, Default)]
pub struct InferenceResult {
/// For each method call expr, records the function it resolves to.
method_resolutions: FxHashMap<ExprId, Function>,
method_resolutions: FxHashMap<ExprId, FunctionId>,
/// For each field access expr, records the field it resolves to.
field_resolutions: FxHashMap<ExprId, StructField>,
field_resolutions: FxHashMap<ExprId, StructFieldId>,
/// For each field in record literal, records the field it resolves to.
record_field_resolutions: FxHashMap<ExprId, StructField>,
record_field_resolutions: FxHashMap<ExprId, StructFieldId>,
/// For each struct literal, records the variant it resolves to.
variant_resolutions: FxHashMap<ExprOrPatId, VariantDef>,
/// For each associated item record what it resolves to
@ -137,13 +137,13 @@ pub struct InferenceResult {
}
impl InferenceResult {
pub fn method_resolution(&self, expr: ExprId) -> Option<Function> {
pub fn method_resolution(&self, expr: ExprId) -> Option<FunctionId> {
self.method_resolutions.get(&expr).copied()
}
pub fn field_resolution(&self, expr: ExprId) -> Option<StructField> {
pub fn field_resolution(&self, expr: ExprId) -> Option<StructFieldId> {
self.field_resolutions.get(&expr).copied()
}
pub fn record_field_resolution(&self, expr: ExprId) -> Option<StructField> {
pub fn record_field_resolution(&self, expr: ExprId) -> Option<StructFieldId> {
self.record_field_resolutions.get(&expr).copied()
}
pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantDef> {
@ -164,7 +164,7 @@ impl InferenceResult {
pub(crate) fn add_diagnostics(
&self,
db: &impl HirDatabase,
owner: Function,
owner: FunctionId,
sink: &mut DiagnosticSink,
) {
self.diagnostics.iter().for_each(|it| it.add_to(db, owner, sink))
@ -243,11 +243,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
self.result.type_of_expr.insert(expr, ty);
}
fn write_method_resolution(&mut self, expr: ExprId, func: Function) {
fn write_method_resolution(&mut self, expr: ExprId, func: FunctionId) {
self.result.method_resolutions.insert(expr, func);
}
fn write_field_resolution(&mut self, expr: ExprId, field: StructField) {
fn write_field_resolution(&mut self, expr: ExprId, field: StructFieldId) {
self.result.field_resolutions.insert(expr, field);
}
@ -557,22 +557,22 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
self.infer_expr(self.body.body_expr, &Expectation::has_type(self.return_ty.clone()));
}
fn resolve_into_iter_item(&self) -> Option<TypeAlias> {
fn resolve_into_iter_item(&self) -> Option<TypeAliasId> {
let path = known::std_iter_into_iterator();
let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
self.db.trait_data(trait_).associated_type_by_name(&name::ITEM_TYPE).map(TypeAlias::from)
self.db.trait_data(trait_).associated_type_by_name(&name::ITEM_TYPE)
}
fn resolve_ops_try_ok(&self) -> Option<TypeAlias> {
fn resolve_ops_try_ok(&self) -> Option<TypeAliasId> {
let path = known::std_ops_try();
let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
self.db.trait_data(trait_).associated_type_by_name(&name::OK_TYPE).map(TypeAlias::from)
self.db.trait_data(trait_).associated_type_by_name(&name::OK_TYPE)
}
fn resolve_future_future_output(&self) -> Option<TypeAlias> {
fn resolve_future_future_output(&self) -> Option<TypeAliasId> {
let path = known::std_future_future();
let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
self.db.trait_data(trait_).associated_type_by_name(&name::OUTPUT_TYPE).map(TypeAlias::from)
self.db.trait_data(trait_).associated_type_by_name(&name::OUTPUT_TYPE)
}
fn resolve_boxed_box(&self) -> Option<AdtId> {
@ -696,9 +696,10 @@ impl Expectation {
}
mod diagnostics {
use hir_def::{expr::ExprId, FunctionId, HasSource, Lookup};
use hir_expand::diagnostics::DiagnosticSink;
use crate::{db::HirDatabase, diagnostics::NoSuchField, expr::ExprId, Function, HasSource};
use crate::{db::HirDatabase, diagnostics::NoSuchField};
#[derive(Debug, PartialEq, Eq, Clone)]
pub(super) enum InferenceDiagnostic {
@ -709,13 +710,14 @@ mod diagnostics {
pub(super) fn add_to(
&self,
db: &impl HirDatabase,
owner: Function,
owner: FunctionId,
sink: &mut DiagnosticSink,
) {
match self {
InferenceDiagnostic::NoSuchField { expr, field } => {
let file = owner.source(db).file_id;
let field = owner.body_source_map(db).field_syntax(*expr, *field);
let file = owner.lookup(db).source(db).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 })
}
}

12
crates/ra_hir/src/ty/infer/expr.rs
View File

@ -100,7 +100,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
let projection = ProjectionPredicate {
ty: pat_ty.clone(),
projection_ty: ProjectionTy {
associated_ty: into_iter_item_alias.id,
associated_ty: into_iter_item_alias,
parameters: Substs::single(iterable_ty),
},
};
@ -230,7 +230,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
}
});
if let Some(field_def) = field_def {
self.result.record_field_resolutions.insert(field.expr, field_def);
self.result.record_field_resolutions.insert(field.expr, field_def.into());
}
let field_ty = field_def
.map_or(Ty::Unknown, |it| field_types[it.id].clone())
@ -262,7 +262,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
self.db.struct_data(s).variant_data.field(name).map(|local_id| {
let field = StructFieldId { parent: s.into(), local_id }.into();
self.write_field_resolution(tgt_expr, field);
self.db.field_types(s.into())[field.id]
self.db.field_types(s.into())[field.local_id]
.clone()
.subst(&a_ty.parameters)
})
@ -285,7 +285,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
let projection = ProjectionPredicate {
ty: ty.clone(),
projection_ty: ProjectionTy {
associated_ty: future_future_output_alias.id,
associated_ty: future_future_output_alias,
parameters: Substs::single(inner_ty),
},
};
@ -304,7 +304,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
let projection = ProjectionPredicate {
ty: ty.clone(),
projection_ty: ProjectionTy {
associated_ty: ops_try_ok_alias.id,
associated_ty: ops_try_ok_alias,
parameters: Substs::single(inner_ty),
},
};
@ -557,7 +557,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
Some((ty, func)) => {
let ty = canonicalized_receiver.decanonicalize_ty(ty);
self.write_method_resolution(tgt_expr, func);
(ty, self.db.value_ty(func.id.into()), Some(self.db.generic_params(func.id.into())))
(ty, self.db.value_ty(func.into()), Some(self.db.generic_params(func.into())))
}
None => (receiver_ty, Ty::Unknown, None),
};

7
crates/ra_hir/src/ty/method_resolution.rs
View File

@ -7,7 +7,7 @@ use std::sync::Arc;
use arrayvec::ArrayVec;
use hir_def::{
lang_item::LangItemTarget, resolver::HasResolver, resolver::Resolver, type_ref::Mutability,
AssocItemId, AstItemDef, HasModule, ImplId, TraitId,
AssocItemId, AstItemDef, FunctionId, HasModule, ImplId, TraitId,
};
use hir_expand::name::Name;
use ra_db::CrateId;
@ -18,7 +18,6 @@ use crate::{
db::HirDatabase,
ty::primitive::{FloatBitness, Uncertain},
ty::{utils::all_super_traits, Ty, TypeCtor},
Function,
};
use super::{autoderef, Canonical, InEnvironment, TraitEnvironment, TraitRef};
@ -154,10 +153,10 @@ pub(crate) fn lookup_method(
db: &impl HirDatabase,
name: &Name,
resolver: &Resolver,
) -> Option<(Ty, Function)> {
) -> Option<(Ty, FunctionId)> {
iterate_method_candidates(ty, db, resolver, Some(name), LookupMode::MethodCall, |ty, f| match f
{
AssocItemId::FunctionId(f) => Some((ty.clone(), f.into())),
AssocItemId::FunctionId(f) => Some((ty.clone(), f)),
_ => None,
})
}