Move Ty

Author: matklad

Cargo.lock

@@ -6,8 +6,10 @@ use std::sync::Arc;
 
 use hir_def::{
     adt::VariantData,
+    body::{Body, BodySourceMap},
     builtin_type::BuiltinType,
     docs::Documentation,
+    expr::{BindingAnnotation, Pat, PatId},
     per_ns::PerNs,
     resolver::HasResolver,
     type_ref::{Mutability, TypeRef},
@@ -20,12 +22,12 @@ use hir_expand::{
     name::{self, AsName},
     AstId, MacroDefId,
 };
+use hir_ty::expr::ExprValidator;
 use ra_db::{CrateId, Edition, FileId, FilePosition};
 use ra_syntax::{ast, AstNode, SyntaxNode};
 
 use crate::{
     db::{DefDatabase, HirDatabase},
-    expr::{BindingAnnotation, Body, BodySourceMap, ExprValidator, Pat, PatId},
     ty::display::HirFormatter,
     ty::{
         self, InEnvironment, InferenceResult, TraitEnvironment, TraitRef, Ty, TyDefId, TypeCtor,
@@ -353,8 +355,8 @@ impl Struct {
             .map(|(id, _)| StructField { parent: self.into(), id })
     }
 
-    pub fn ty(self, db: &impl HirDatabase) -> Ty {
-        db.ty(self.id.into())
+    pub fn ty(self, db: &impl HirDatabase) -> Type {
+        Type::from_def(db, self.id.module(db).krate, self.id)
     }
 
     pub fn constructor_ty(self, db: &impl HirDatabase) -> Ty {
@@ -380,8 +382,8 @@ impl Union {
         Module { id: self.id.module(db) }
     }
 
-    pub fn ty(self, db: &impl HirDatabase) -> Ty {
-        db.ty(self.id.into())
+    pub fn ty(self, db: &impl HirDatabase) -> Type {
+        Type::from_def(db, self.id.module(db).krate, self.id)
     }
 
     pub fn fields(self, db: &impl HirDatabase) -> Vec<StructField> {
@@ -441,8 +443,8 @@ impl Enum {
             .map(|(id, _)| EnumVariant { parent: self, id })
     }
 
-    pub fn ty(self, db: &impl HirDatabase) -> Ty {
-        db.ty(self.id.into())
+    pub fn ty(self, db: &impl HirDatabase) -> Type {
+        Type::from_def(db, self.id.module(db).krate, self.id)
     }
 }
 
@@ -640,7 +642,7 @@ impl Function {
     pub fn diagnostics(self, db: &impl HirDatabase, sink: &mut DiagnosticSink) {
         let infer = self.infer(db);
         infer.add_diagnostics(db, self.id, sink);
-        let mut validator = ExprValidator::new(self, infer, sink);
+        let mut validator = ExprValidator::new(self.id, infer, sink);
         validator.validate_body(db);
     }
 }
@@ -946,13 +948,12 @@ impl ImplBlock {
         db.impl_data(self.id).target_type.clone()
     }
 
-    pub fn target_ty(&self, db: &impl HirDatabase) -> Ty {
-        Ty::from_hir(db, &self.id.resolver(db), &self.target_type(db))
-    }
-
-    pub fn target_trait_ref(&self, db: &impl HirDatabase) -> Option<TraitRef> {
-        let target_ty = self.target_ty(db);
-        TraitRef::from_hir(db, &self.id.resolver(db), &self.target_trait(db)?, Some(target_ty))
+    pub fn target_ty(&self, db: &impl HirDatabase) -> Type {
+        let impl_data = db.impl_data(self.id);
+        let resolver = self.id.resolver(db);
+        let environment = TraitEnvironment::lower(db, &resolver);
+        let ty = Ty::from_hir(db, &resolver, &impl_data.target_type);
+        Type { krate: self.id.module(db).krate, ty: InEnvironment { value: ty, environment } }
     }
 
     pub fn items(&self, db: &impl DefDatabase) -> Vec<AssocItem> {
@@ -1130,6 +1131,22 @@ impl Type {
         Some(adt.into())
     }
 
+    // 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,
+                }
+            }
+            _ => false,
+        }
+    }
+
     fn derived(&self, ty: Ty) -> Type {
         Type {
             krate: self.krate,

crates/ra_hir/src/code_model.rs

@@ -1,18 +1,5 @@
 //! FIXME: write short doc here
 
-use std::sync::Arc;
-
-use hir_def::{DefWithBodyId, GenericDefId, ImplId, LocalStructFieldId, TraitId, VariantId};
-use ra_arena::map::ArenaMap;
-use ra_db::{salsa, CrateId};
-
-use crate::ty::{
-    method_resolution::CrateImplBlocks,
-    traits::{AssocTyValue, Impl},
-    CallableDef, FnSig, GenericPredicate, InferenceResult, Substs, Ty, TyDefId, TypeCtor,
-    ValueTyDefId,
-};
-
 pub use hir_def::db::{
     BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQuery, CrateLangItemsQuery,
     DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery, ExprScopesQuery,
@@ -24,104 +11,12 @@ pub use hir_expand::db::{
     AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
     ParseMacroQuery,
 };
-
-#[salsa::query_group(HirDatabaseStorage)]
-#[salsa::requires(salsa::Database)]
-pub trait HirDatabase: DefDatabase {
-    #[salsa::invoke(crate::ty::infer_query)]
-    fn infer(&self, def: DefWithBodyId) -> Arc<InferenceResult>;
-
-    #[salsa::invoke(crate::ty::ty_query)]
-    fn ty(&self, def: TyDefId) -> Ty;
-
-    #[salsa::invoke(crate::ty::value_ty_query)]
-    fn value_ty(&self, def: ValueTyDefId) -> Ty;
-
-    #[salsa::invoke(crate::ty::field_types_query)]
-    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalStructFieldId, Ty>>;
-
-    #[salsa::invoke(crate::ty::callable_item_sig)]
-    fn callable_item_signature(&self, def: CallableDef) -> FnSig;
-
-    #[salsa::invoke(crate::ty::generic_predicates_for_param_query)]
-    fn generic_predicates_for_param(
-        &self,
-        def: GenericDefId,
-        param_idx: u32,
-    ) -> Arc<[GenericPredicate]>;
-
-    #[salsa::invoke(crate::ty::generic_predicates_query)]
-    fn generic_predicates(&self, def: GenericDefId) -> Arc<[GenericPredicate]>;
-
-    #[salsa::invoke(crate::ty::generic_defaults_query)]
-    fn generic_defaults(&self, def: GenericDefId) -> Substs;
-
-    #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)]
-    fn impls_in_crate(&self, krate: CrateId) -> Arc<CrateImplBlocks>;
-
-    #[salsa::invoke(crate::ty::traits::impls_for_trait_query)]
-    fn impls_for_trait(&self, krate: CrateId, trait_: TraitId) -> Arc<[ImplId]>;
-
-    /// This provides the Chalk trait solver instance. Because Chalk always
-    /// works from a specific crate, this query is keyed on the crate; and
-    /// because Chalk does its own internal caching, the solver is wrapped in a
-    /// Mutex and the query does an untracked read internally, to make sure the
-    /// cached state is thrown away when input facts change.
-    #[salsa::invoke(crate::ty::traits::trait_solver_query)]
-    fn trait_solver(&self, krate: CrateId) -> crate::ty::traits::TraitSolver;
-
-    // Interned IDs for Chalk integration
-    #[salsa::interned]
-    fn intern_type_ctor(&self, type_ctor: TypeCtor) -> crate::ty::TypeCtorId;
-    #[salsa::interned]
-    fn intern_chalk_impl(&self, impl_: Impl) -> crate::ty::traits::GlobalImplId;
-    #[salsa::interned]
-    fn intern_assoc_ty_value(
-        &self,
-        assoc_ty_value: AssocTyValue,
-    ) -> crate::ty::traits::AssocTyValueId;
-
-    #[salsa::invoke(crate::ty::traits::chalk::associated_ty_data_query)]
-    fn associated_ty_data(
-        &self,
-        id: chalk_ir::TypeId,
-    ) -> Arc<chalk_rust_ir::AssociatedTyDatum<chalk_ir::family::ChalkIr>>;
-
-    #[salsa::invoke(crate::ty::traits::chalk::trait_datum_query)]
-    fn trait_datum(
-        &self,
-        krate: CrateId,
-        trait_id: chalk_ir::TraitId,
-    ) -> Arc<chalk_rust_ir::TraitDatum<chalk_ir::family::ChalkIr>>;
-
-    #[salsa::invoke(crate::ty::traits::chalk::struct_datum_query)]
-    fn struct_datum(
-        &self,
-        krate: CrateId,
-        struct_id: chalk_ir::StructId,
-    ) -> Arc<chalk_rust_ir::StructDatum<chalk_ir::family::ChalkIr>>;
-
-    #[salsa::invoke(crate::ty::traits::chalk::impl_datum_query)]
-    fn impl_datum(
-        &self,
-        krate: CrateId,
-        impl_id: chalk_ir::ImplId,
-    ) -> Arc<chalk_rust_ir::ImplDatum<chalk_ir::family::ChalkIr>>;
-
-    #[salsa::invoke(crate::ty::traits::chalk::associated_ty_value_query)]
-    fn associated_ty_value(
-        &self,
-        krate: CrateId,
-        id: chalk_rust_ir::AssociatedTyValueId,
-    ) -> Arc<chalk_rust_ir::AssociatedTyValue<chalk_ir::family::ChalkIr>>;
-
-    #[salsa::invoke(crate::ty::traits::trait_solve_query)]
-    fn trait_solve(
-        &self,
-        krate: CrateId,
-        goal: crate::ty::Canonical<crate::ty::InEnvironment<crate::ty::Obligation>>,
-    ) -> Option<crate::ty::traits::Solution>;
-}
+pub use hir_ty::db::{
+    AssociatedTyDataQuery, CallableItemSignatureQuery, FieldTypesQuery, GenericDefaultsQuery,
+    GenericPredicatesQuery, HirDatabase, HirDatabaseStorage, ImplDatumQuery, ImplsForTraitQuery,
+    ImplsInCrateQuery, InferQuery, StructDatumQuery, TraitDatumQuery, TraitSolveQuery, TyQuery,
+    ValueTyQuery,
+};
 
 #[test]
 fn hir_database_is_object_safe() {

crates/ra_hir/src/db.rs

@@ -1,93 +1,4 @@
 //! FIXME: write short doc here
-
-use std::any::Any;
-
-use hir_expand::HirFileId;
-use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};
-
-use crate::{db::AstDatabase, Name, Source};
-
 pub use hir_def::diagnostics::UnresolvedModule;
 pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
-
-#[derive(Debug)]
-pub struct NoSuchField {
-    pub file: HirFileId,
-    pub field: AstPtr<ast::RecordField>,
-}
-
-impl Diagnostic for NoSuchField {
-    fn message(&self) -> String {
-        "no such field".to_string()
-    }
-
-    fn source(&self) -> Source<SyntaxNodePtr> {
-        Source { file_id: self.file, value: self.field.into() }
-    }
-
-    fn as_any(&self) -> &(dyn Any + Send + 'static) {
-        self
-    }
-}
-
-#[derive(Debug)]
-pub struct MissingFields {
-    pub file: HirFileId,
-    pub field_list: AstPtr<ast::RecordFieldList>,
-    pub missed_fields: Vec<Name>,
-}
-
-impl Diagnostic for MissingFields {
-    fn message(&self) -> String {
-        use std::fmt::Write;
-        let mut message = String::from("Missing structure fields:\n");
-        for field in &self.missed_fields {
-            write!(message, "- {}\n", field).unwrap();
-        }
-        message
-    }
-    fn source(&self) -> Source<SyntaxNodePtr> {
-        Source { file_id: self.file, value: self.field_list.into() }
-    }
-    fn as_any(&self) -> &(dyn Any + Send + 'static) {
-        self
-    }
-}
-
-impl AstDiagnostic for MissingFields {
-    type AST = ast::RecordFieldList;
-
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
-        let root = db.parse_or_expand(self.source().file_id).unwrap();
-        let node = self.source().value.to_node(&root);
-        ast::RecordFieldList::cast(node).unwrap()
-    }
-}
-
-#[derive(Debug)]
-pub struct MissingOkInTailExpr {
-    pub file: HirFileId,
-    pub expr: AstPtr<ast::Expr>,
-}
-
-impl Diagnostic for MissingOkInTailExpr {
-    fn message(&self) -> String {
-        "wrap return expression in Ok".to_string()
-    }
-    fn source(&self) -> Source<SyntaxNodePtr> {
-        Source { file_id: self.file, value: self.expr.into() }
-    }
-    fn as_any(&self) -> &(dyn Any + Send + 'static) {
-        self
-    }
-}
-
-impl AstDiagnostic for MissingOkInTailExpr {
-    type AST = ast::Expr;
-
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
-        let root = db.parse_or_expand(self.file).unwrap();
-        let node = self.source().value.to_node(&root);
-        ast::Expr::cast(node).unwrap()
-    }
-}
+pub use hir_ty::diagnostics::{MissingFields, MissingOkInTailExpr, NoSuchField};

crates/ra_hir/src/diagnostics.rs

@@ -32,28 +32,20 @@ pub mod db;
 pub mod source_binder;
 
 mod ty;
-mod expr;
 pub mod diagnostics;
-mod util;
 
 mod from_id;
 mod code_model;
 
 pub mod from_source;
 
-#[cfg(test)]
-mod test_db;
-#[cfg(test)]
-mod marks;
-
 pub use crate::{
     code_model::{
         src::HasSource, Adt, AssocItem, AttrDef, Const, Container, Crate, CrateDependency,
         DefWithBody, Docs, Enum, EnumVariant, FieldSource, Function, GenericDef, GenericParam,
         HasAttrs, ImplBlock, Import, Local, MacroDef, Module, ModuleDef, ModuleSource, ScopeDef,
         Static, Struct, StructField, Trait, Type, TypeAlias, Union, VariantDef,
     },
-    expr::ExprScopes,
     from_source::FromSource,
     source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
     ty::{
@@ -64,6 +56,7 @@ pub use crate::{
 };
 
 pub use hir_def::{
+    body::scope::ExprScopes,
     builtin_type::BuiltinType,
     docs::Documentation,
     path::{Path, PathKind},