Merge pull request #942 from Y-Nak/func-ty

Func ty

Author: sbillig

crates/common2/src/diagnostics.rs

@@ -148,6 +148,7 @@ pub enum DiagnosticPass {
     TraitDefinition,
     ImplTraitDefinition,
     TraitSatisfaction,
+    MethodDefinition,
 
     ExternalAnalysis(ExternalAnalysisKey),
 }
@@ -161,6 +162,7 @@ impl DiagnosticPass {
             Self::TraitDefinition => 4,
             Self::ImplTraitDefinition => 5,
             Self::TraitSatisfaction => 6,
+            Self::MethodDefinition => 7,
 
             Self::ExternalAnalysis(_) => std::u16::MAX,
         }

crates/driver2/src/lib.rs

@@ -17,7 +17,10 @@ use hir::{
 };
 use hir_analysis::{
     name_resolution::{DefConflictAnalysisPass, ImportAnalysisPass, PathAnalysisPass},
-    ty::{ImplTraitAnalysisPass, TraitAnalysisPass, TypeAliasAnalysisPass, TypeDefAnalysisPass},
+    ty::{
+        FuncAnalysisPass, ImplAnalysisPass, ImplTraitAnalysisPass, TraitAnalysisPass,
+        TypeAliasAnalysisPass, TypeDefAnalysisPass,
+    },
     HirAnalysisDb,
 };
 
@@ -148,6 +151,8 @@ fn initialize_analysis_pass(db: &DriverDataBase) -> AnalysisPassManager<'_> {
     pass_manager.add_module_pass(Box::new(TypeDefAnalysisPass::new(db)));
     pass_manager.add_module_pass(Box::new(TypeAliasAnalysisPass::new(db)));
     pass_manager.add_module_pass(Box::new(TraitAnalysisPass::new(db)));
+    pass_manager.add_module_pass(Box::new(ImplAnalysisPass::new(db)));
     pass_manager.add_module_pass(Box::new(ImplTraitAnalysisPass::new(db)));
+    pass_manager.add_module_pass(Box::new(FuncAnalysisPass::new(db)));
     pass_manager
 }

crates/hir-analysis/src/lib.rs

@@ -11,12 +11,15 @@ pub struct Jar(
     ty::ty_def::TyId,
     ty::ty_def::ty_kind,
     ty::ty_def::free_inference_keys,
+    ty::ty_def::collect_type_params,
     ty::ty_def::pretty_print_ty,
     ty::ty_def::AdtDef,
+    ty::ty_def::FuncDef,
     ty::ty_def::AdtRefId,
     /// Type lowering.
     ty::ty_lower::lower_hir_ty,
     ty::ty_lower::lower_adt,
+    ty::ty_lower::lower_func,
     ty::ty_lower::lower_type_alias,
     ty::ty_lower::collect_generic_params,
     ty::ty_lower::GenericParamOwnerId,
@@ -25,12 +28,17 @@ pub struct Jar(
     ty::trait_lower::lower_trait_ref,
     ty::trait_lower::collect_trait_impls,
     ty::trait_lower::lower_impl_trait,
+    ty::trait_lower::collect_implementor_methods,
+    /// Method collection.
+    ty::method_table::collect_methods,
     /// Item Definition analysis.
     ty::def_analysis::check_recursive_adt,
     ty::def_analysis::analyze_adt,
     ty::def_analysis::analyze_type_alias,
     ty::def_analysis::analyze_trait,
+    ty::def_analysis::analyze_impl,
     ty::def_analysis::analyze_impl_trait,
+    ty::def_analysis::analyze_func,
     /// Trait system.
     ty::trait_def::TraitDef,
     ty::trait_def::TraitInstId,
@@ -41,6 +49,8 @@ pub struct Jar(
     ty::constraint::collect_trait_constraints,
     ty::constraint::collect_adt_constraints,
     ty::constraint::collect_implementor_constraints,
+    ty::constraint::collect_impl_block_constraints,
+    ty::constraint::collect_func_def_constraints,
     ty::constraint::super_trait_insts,
     ty::constraint::compute_super_assumptions,
     ty::constraint::ty_constraints,
@@ -55,6 +65,8 @@ pub struct Jar(
     ty::diagnostics::TypeAliasDefDiagAccumulator,
     ty::diagnostics::TraitDefDiagAccumulator,
     ty::diagnostics::ImplTraitDefDiagAccumulator,
+    ty::diagnostics::ImplDefDiagAccumulator,
+    ty::diagnostics::FuncDefDiagAccumulator,
 );
 
 pub trait HirAnalysisDb: salsa::DbWithJar<Jar> + HirDb {

crates/hir-analysis/src/name_resolution/mod.rs

@@ -340,11 +340,11 @@ impl<'db, 'a> Visitor for EarlyPathVisitor<'db, 'a> {
             return;
         }
 
-        let scope = ScopeId::from_item(item);
-        // We don't need to check impl/impl-trait blocks for conflicts because they
+        // We don't need to check impl blocks for conflicts because they
         // needs ingot granularity analysis, the conflict checks for them is done by the
         // `ImplCollector`.
-        if !matches!(item, ItemKind::Impl(_) | ItemKind::ImplTrait(_)) {
+        if !matches!(item, ItemKind::Impl(_)) {
+            let scope = ScopeId::from_item(item);
             self.check_conflict(scope);
         }
 

crates/hir-analysis/src/ty/constraint.rs

@@ -3,20 +3,25 @@
 
 use std::collections::BTreeSet;
 
-use hir::hir_def::{scope_graph::ScopeId, GenericParam, GenericParamOwner, IngotId, TypeBound};
+use hir::hir_def::{
+    scope_graph::ScopeId, GenericParam, GenericParamOwner, Impl, IngotId, ItemKind, TypeBound,
+};
 use rustc_hash::FxHashMap;
 use salsa::function::Configuration;
 
 use crate::{
-    ty::{trait_lower::lower_trait, unify::InferenceKey},
+    ty::{
+        trait_lower::{lower_impl_trait, lower_trait},
+        unify::InferenceKey,
+    },
     HirAnalysisDb,
 };
 
 use super::{
     constraint_solver::{is_goal_satisfiable, GoalSatisfiability},
     trait_def::{Implementor, TraitDef, TraitInstId},
     trait_lower::lower_trait_ref,
-    ty_def::{AdtDef, Subst, TyConcrete, TyData, TyId},
+    ty_def::{AdtDef, FuncDef, Subst, TyBase, TyData, TyId},
     ty_lower::{collect_generic_params, lower_hir_ty, GenericParamOwnerId},
 };
 
@@ -40,30 +45,36 @@ pub(crate) fn ty_constraints(
     assert!(ty.free_inference_keys(db).is_empty());
 
     let (base, args) = ty.decompose_ty_app(db);
-    let TyData::TyCon(TyConcrete::Adt(adt)) = base.data(db) else {
-        return (
-            AssumptionListId::empty_list(db),
-            ConstraintListId::empty_list(db),
-        );
+    let (params, base_constraints) = match base.data(db) {
+        TyData::TyBase(TyBase::Adt(adt)) => (adt.params(db), collect_adt_constraints(db, adt)),
+        TyData::TyBase(TyBase::Func(func_def)) => (
+            func_def.params(db),
+            collect_func_def_constraints(db, func_def),
+        ),
+        _ => {
+            return (
+                AssumptionListId::empty_list(db),
+                ConstraintListId::empty_list(db),
+            );
+        }
     };
 
     let mut subst = FxHashMap::default();
     let mut arg_idx = 0;
-    for (&param, arg) in adt.params(db).iter().zip(args) {
+    for (&param, arg) in params.iter().zip(args) {
         subst.insert(param, arg);
         arg_idx += 1;
     }
 
     // Generalize unbound type parameters.
-    for &arg in adt.params(db).iter().skip(arg_idx) {
+    for &arg in params.iter().skip(arg_idx) {
         let key = InferenceKey(arg_idx as u32);
         let ty_var = TyId::ty_var(db, arg.kind(db).clone(), key);
         subst.insert(arg, ty_var);
         arg_idx += 1;
     }
 
-    // Substitute type parameters.
-    let constraints = collect_adt_constraints(db, adt).apply_subst(db, &mut subst);
+    let constraints = base_constraints.apply_subst(db, &mut subst);
 
     // If the predicate type is a type variable, collect it as an assumption
     // and remove it from the constraint.
@@ -182,19 +193,56 @@ pub(crate) fn collect_adt_constraints(db: &dyn HirAnalysisDb, adt: AdtDef) -> Co
     collector.collect()
 }
 
+#[salsa::tracked]
+pub(crate) fn collect_impl_block_constraints(
+    db: &dyn HirAnalysisDb,
+    impl_: Impl,
+) -> ConstraintListId {
+    let owner = GenericParamOwnerId::new(db, impl_.into());
+    ConstraintCollector::new(db, owner).collect()
+}
+
 /// Collect constraints that are specified by the given implementor(i.e., impl
 /// trait).
 #[salsa::tracked]
 pub(crate) fn collect_implementor_constraints(
     db: &dyn HirAnalysisDb,
     implementor: Implementor,
 ) -> ConstraintListId {
-    let impl_trait = implementor.impl_trait(db);
+    let impl_trait = implementor.hir_impl_trait(db);
     let collector = ConstraintCollector::new(db, GenericParamOwnerId::new(db, impl_trait.into()));
 
     collector.collect()
 }
 
+#[salsa::tracked]
+pub(crate) fn collect_func_def_constraints(
+    db: &dyn HirAnalysisDb,
+    func: FuncDef,
+) -> ConstraintListId {
+    let hir_func = func.hir_func(db);
+
+    let func_constraints =
+        ConstraintCollector::new(db, GenericParamOwnerId::new(db, hir_func.into())).collect();
+
+    let parent_constraints = match hir_func.scope().parent_item(db.as_hir_db()) {
+        Some(ItemKind::Trait(trait_)) => collect_trait_constraints(db, lower_trait(db, trait_)),
+
+        Some(ItemKind::Impl(impl_)) => collect_impl_block_constraints(db, impl_),
+
+        Some(ItemKind::ImplTrait(impl_trait)) => {
+            let Some(implementor) = lower_impl_trait(db, impl_trait) else {
+                return func_constraints;
+            };
+            collect_implementor_constraints(db, implementor)
+        }
+
+        _ => return func_constraints,
+    };
+
+    func_constraints.merge(db, parent_constraints)
+}
+
 /// Returns a list of assumptions derived from the given assumptions by looking
 /// up super traits.
 #[salsa::tracked(return_ref)]
@@ -231,6 +279,12 @@ impl PredicateId {
         let trait_ = self.trait_inst(db).apply_subst(db, subst);
         Self::new(db, ty, trait_)
     }
+
+    pub fn pretty_print(self, db: &dyn HirAnalysisDb) -> String {
+        let ty = self.ty(db);
+        let trait_ = self.trait_inst(db);
+        format!("{}: {}", ty.pretty_print(db), trait_.pretty_print(db))
+    }
 }
 
 /// The list of predicates.