"ra_batch 0.1.0",
"ra_db 0.1.0",
"ra_hir 0.1.0",
+ "ra_hir_def 0.1.0",
+ "ra_hir_ty 0.1.0",
"ra_ide 0.1.0",
"ra_prof 0.1.0",
"ra_syntax 0.1.0",
ra_syntax = { path = "../ra_syntax" }
ra_ide = { path = "../ra_ide" }
ra_batch = { path = "../ra_batch" }
-ra_hir = { path = "../ra_hir" }
+hir = { path = "../ra_hir", package = "ra_hir" }
+hir_ty = { path = "../ra_hir_ty", package = "ra_hir_ty" }
+hir_def = { path = "../ra_hir_def", package = "ra_hir_def" }
ra_db = { path = "../ra_db" }
[dependencies.ra_prof]
use std::{collections::HashSet, fmt::Write, path::Path, time::Instant};
+use hir::{
+ db::{DefDatabase, HirDatabase},
+ AssocItem, Crate, HasSource, HirDisplay, ModuleDef,
+};
+use hir_def::FunctionId;
+use hir_ty::{Ty, TypeWalk};
use ra_db::SourceDatabaseExt;
-use ra_hir::{AssocItem, Crate, HasSource, HirDisplay, ModuleDef, Ty, TypeWalk};
use ra_syntax::AstNode;
use crate::{progress_report::ProgressReport, Result, Verbosity};
continue;
}
}
- let body = f.body(db);
- let inference_result = f.infer(db);
+ let f_id = FunctionId::from(f);
+ let body = db.body(f_id.into());
+ let inference_result = db.infer(f_id.into());
for (expr_id, _) in body.exprs.iter() {
let ty = &inference_result[expr_id];
num_exprs += 1;
if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr_id) {
num_type_mismatches += 1;
if verbosity.is_verbose() {
- let src = f.body_source_map(db).expr_syntax(expr_id);
+ let (_, sm) = db.body_with_source_map(f_id.into());
+ let src = sm.expr_syntax(expr_id);
if let Some(src) = src {
// FIXME: it might be nice to have a function (on Analysis?) that goes from Source<T> -> (LineCol, LineCol) directly
let original_file = src.file_id.original_file(db);
name::{self, AsName},
MacroDefId,
};
-use hir_ty::expr::ExprValidator;
+use hir_ty::{
+ autoderef, display::HirFormatter, expr::ExprValidator, ApplicationTy, Canonical, InEnvironment,
+ TraitEnvironment, Ty, TyDefId, TypeCtor, TypeWalk,
+};
use ra_db::{CrateId, Edition, FileId};
use ra_syntax::ast;
use crate::{
db::{DefDatabase, HirDatabase},
- ty::display::HirFormatter,
- ty::{self, InEnvironment, TraitEnvironment, Ty, TyDefId, TypeCtor, TypeWalk},
CallableDef, HirDisplay, InFile, Name,
};
pub fn all(db: &impl DefDatabase) -> Vec<Crate> {
db.crate_graph().iter().map(|id| Crate { id }).collect()
}
-
- pub fn crate_id(self) -> CrateId {
- self.id
- }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub fn fields(&self, db: &impl HirDatabase) -> Vec<(StructField, Type)> {
if let Ty::Apply(a_ty) = &self.ty.value {
match a_ty.ctor {
- ty::TypeCtor::Adt(AdtId::StructId(s)) => {
+ TypeCtor::Adt(AdtId::StructId(s)) => {
let var_def = s.into();
return db
.field_types(var_def)
let mut res = Vec::new();
if let Ty::Apply(a_ty) = &self.ty.value {
match a_ty.ctor {
- ty::TypeCtor::Tuple { .. } => {
+ TypeCtor::Tuple { .. } => {
for ty in a_ty.parameters.iter() {
let ty = ty.clone().subst(&a_ty.parameters);
res.push(self.derived(ty));
pub fn autoderef<'a>(&'a self, db: &'a impl HirDatabase) -> impl Iterator<Item = Type> + 'a {
// There should be no inference vars in types passed here
// FIXME check that?
- let canonical = crate::ty::Canonical { value: self.ty.value.clone(), num_vars: 0 };
+ let canonical = Canonical { value: self.ty.value.clone(), num_vars: 0 };
let environment = self.ty.environment.clone();
let ty = InEnvironment { value: canonical, environment: environment.clone() };
- ty::autoderef(db, Some(self.krate), ty)
+ autoderef(db, Some(self.krate), ty)
.map(|canonical| canonical.value)
.map(move |ty| self.derived(ty))
}
// FIXME: provide required accessors such that it becomes implementable from outside.
pub fn is_equal_for_find_impls(&self, other: &Type) -> bool {
match (&self.ty.value, &other.ty.value) {
- (Ty::Apply(a_original_ty), Ty::Apply(ty::ApplicationTy { ctor, parameters })) => {
- match ctor {
- TypeCtor::Ref(..) => match parameters.as_single() {
- Ty::Apply(a_ty) => a_original_ty.ctor == a_ty.ctor,
- _ => false,
- },
- _ => a_original_ty.ctor == *ctor,
- }
- }
+ (Ty::Apply(a_original_ty), Ty::Apply(ApplicationTy { ctor, parameters })) => match ctor
+ {
+ TypeCtor::Ref(..) => match parameters.as_single() {
+ Ty::Apply(a_ty) => a_original_ty.ctor == a_ty.ctor,
+ _ => false,
+ },
+ _ => a_original_ty.ctor == *ctor,
+ },
_ => false,
}
}
};
use crate::{
- Adt, AssocItem, AttrDef, Crate, DefWithBody, EnumVariant, GenericDef, ModuleDef, StructField,
+ Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, ModuleDef, StructField,
VariantDef,
};
-impl From<ra_db::CrateId> for Crate {
- fn from(id: ra_db::CrateId) -> Self {
- Crate { id }
- }
-}
-
macro_rules! from_id {
($(($id:path, $ty:path)),*) => {$(
impl From<$id> for $ty {
$ty { id }
}
}
+ impl From<$ty> for $id {
+ fn from(ty: $ty) -> $id {
+ ty.id
+ }
+ }
)*}
}
from_id![
+ (ra_db::CrateId, crate::Crate),
(hir_def::ModuleId, crate::Module),
(hir_def::StructId, crate::Struct),
(hir_def::UnionId, crate::Union),
pub mod db;
pub mod source_binder;
-mod ty;
pub mod diagnostics;
mod from_id;
},
from_source::FromSource,
source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
- ty::{
- display::HirDisplay,
- primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness, Uncertain},
- ApplicationTy, CallableDef, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
- },
};
pub use hir_def::{
pub use hir_expand::{
name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc, MacroDefId, MacroFile,
};
+pub use hir_ty::{display::HirDisplay, CallableDef};
use hir_expand::{
hygiene::Hygiene, name::AsName, AstId, HirFileId, InFile, MacroCallId, MacroCallKind,
};
+use hir_ty::{
+ method_resolution::{self, implements_trait},
+ Canonical, InEnvironment, InferenceResult, TraitEnvironment, Ty,
+};
use ra_syntax::{
ast::{self, AstNode},
match_ast, AstPtr,
};
use crate::{
- db::HirDatabase,
- ty::{
- method_resolution::{self, implements_trait},
- InEnvironment, TraitEnvironment, Ty,
- },
- Adt, AssocItem, Const, DefWithBody, Enum, EnumVariant, FromSource, Function, ImplBlock, Local,
- MacroDef, Name, Path, ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam,
+ db::HirDatabase, Adt, AssocItem, Const, DefWithBody, Enum, EnumVariant, FromSource, Function,
+ ImplBlock, Local, MacroDef, Name, Path, ScopeDef, Static, Struct, Trait, Type, TypeAlias,
+ TypeParam,
};
fn try_get_resolver_for_node(db: &impl HirDatabase, node: InFile<&SyntaxNode>) -> Option<Resolver> {
resolver: Resolver,
body_owner: Option<DefWithBody>,
body_source_map: Option<Arc<BodySourceMap>>,
- infer: Option<Arc<crate::ty::InferenceResult>>,
+ infer: Option<Arc<InferenceResult>>,
scopes: Option<Arc<ExprScopes>>,
}
// There should be no inference vars in types passed here
// FIXME check that?
// FIXME replace Unknown by bound vars here
- let canonical = crate::ty::Canonical { value: ty.ty.value.clone(), num_vars: 0 };
+ let canonical = Canonical { value: ty.ty.value.clone(), num_vars: 0 };
method_resolution::iterate_method_candidates(
&canonical,
db,
// There should be no inference vars in types passed here
// FIXME check that?
// FIXME replace Unknown by bound vars here
- let canonical = crate::ty::Canonical { value: ty.ty.value.clone(), num_vars: 0 };
+ let canonical = Canonical { value: ty.ty.value.clone(), num_vars: 0 };
method_resolution::iterate_method_candidates(
&canonical,
db,
// ) -> impl Iterator<Item = Ty> + 'a {
// // There should be no inference vars in types passed here
// // FIXME check that?
- // let canonical = crate::ty::Canonical { value: ty, num_vars: 0 };
+ // let canonical = Canonical { value: ty, num_vars: 0 };
// let krate = self.resolver.krate();
// let environment = TraitEnvironment::lower(db, &self.resolver);
// let ty = crate::ty::InEnvironment { value: canonical, environment };
_ => return false,
};
- let canonical_ty = crate::ty::Canonical { value: ty, num_vars: 0 };
+ let canonical_ty = Canonical { value: ty, num_vars: 0 };
implements_trait(&canonical_ty, db, &self.resolver, krate.into(), std_future_trait)
}
+++ /dev/null
-//! The type system. We currently use this to infer types for completion, hover
-//! information and various assists.
-
-pub use hir_ty::*;
None => return Vec::new(),
};
let krate = module.krate();
- vec![krate.crate_id()]
+ vec![krate.into()]
}
#[cfg(test)]