Merge pull request #931 from Y-Nak/trait-solve

Fe type/trait system

Author: sbillig

Diff for: Cargo.lock

@@ -1,5 +1,6 @@
 [workspace]
 members = ["crates/*"]
+resolver = "2"
 
 [profile.dev.package.solc]
 opt-level = 3

Diff for: Cargo.toml

@@ -126,7 +126,8 @@ pub fn contract_public_function_map(
         contract
             .functions(db)
             .iter()
-            .filter_map(|(name, func)| func.is_public(db).then(|| (name.clone(), *func)))
+            .filter(|(_, func)| func.is_public(db))
+            .map(|(name, func)| (name.clone(), *func))
             .collect(),
     )
 }

Diff for: crates/analyzer/src/db/queries/contracts.rs

@@ -84,11 +84,8 @@ pub fn struct_field_map(
 
         let mut labels = fields
             .iter()
-            .filter_map(|(_, field)| {
-                field
-                    .is_indexed(db)
-                    .then(|| Label::primary(field.span(db), String::new()))
-            })
+            .filter(|(_, field)| field.is_indexed(db))
+            .map(|(_, field)| Label::primary(field.span(db), String::new()))
             .collect::<Vec<Label>>();
         labels.last_mut().unwrap().message = format!("{indexed_count} indexed fields");
 

Diff for: crates/analyzer/src/db/queries/structs.rs

@@ -91,16 +91,16 @@ pub struct Span {
 
 impl PartialOrd for Span {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        match self.file.cmp(&other.file) {
-            std::cmp::Ordering::Equal => self.range.start().partial_cmp(&other.range.start()),
-            ord => Some(ord),
-        }
+        Some(self.cmp(other))
     }
 }
 
 impl Ord for Span {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.partial_cmp(other).unwrap()
+        match self.file.cmp(&other.file) {
+            std::cmp::Ordering::Equal => self.range.start().cmp(&other.range.start()),
+            ord => ord,
+        }
     }
 }
 
@@ -144,7 +144,10 @@ pub enum DiagnosticPass {
 
     NameResolution,
 
-    TyCheck,
+    TypeDefinition,
+    TraitDefinition,
+    ImplTraitDefinition,
+    TraitSatisfaction,
 
     ExternalAnalysis(ExternalAnalysisKey),
 }
@@ -154,8 +157,10 @@ impl DiagnosticPass {
         match self {
             Self::Parse => 1,
             Self::NameResolution => 2,
-
-            Self::TyCheck => 3,
+            Self::TypeDefinition => 3,
+            Self::TraitDefinition => 4,
+            Self::ImplTraitDefinition => 5,
+            Self::TraitSatisfaction => 6,
 
             Self::ExternalAnalysis(_) => std::u16::MAX,
         }

Diff for: crates/common2/src/diagnostics.rs

@@ -17,6 +17,7 @@ use hir::{
 };
 use hir_analysis::{
     name_resolution::{DefConflictAnalysisPass, ImportAnalysisPass, PathAnalysisPass},
+    ty::{ImplTraitAnalysisPass, TraitAnalysisPass, TypeAliasAnalysisPass, TypeDefAnalysisPass},
     HirAnalysisDb,
 };
 
@@ -144,5 +145,9 @@ fn initialize_analysis_pass(db: &DriverDataBase) -> AnalysisPassManager<'_> {
     pass_manager.add_module_pass(Box::new(DefConflictAnalysisPass::new(db)));
     pass_manager.add_module_pass(Box::new(ImportAnalysisPass::new(db)));
     pass_manager.add_module_pass(Box::new(PathAnalysisPass::new(db)));
+    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(ImplTraitAnalysisPass::new(db)));
     pass_manager
 }

Diff for: crates/driver2/src/lib.rs

@@ -14,6 +14,7 @@ rustc-hash = "1.1.0"
 either = "1.8"
 derive_more = "0.99"
 itertools = "0.10"
+ena = "0.14"
 
 hir = { path = "../hir", package = "fe-hir" }
 common = { path = "../common2", package = "fe-common2" }

Diff for: crates/hir-analysis/Cargo.toml

@@ -7,6 +7,54 @@ pub struct Jar(
     name_resolution::resolve_imports,
     name_resolution::diagnostics::NameResolutionDiagAccumulator,
     name_resolution::diagnostics::ImportResolutionDiagAccumulator,
+    /// Type system.
+    ty::ty_def::TyId,
+    ty::ty_def::ty_kind,
+    ty::ty_def::free_inference_keys,
+    ty::ty_def::pretty_print_ty,
+    ty::ty_def::AdtDef,
+    ty::ty_def::AdtRefId,
+    /// Type lowering.
+    ty::ty_lower::lower_hir_ty,
+    ty::ty_lower::lower_adt,
+    ty::ty_lower::lower_type_alias,
+    ty::ty_lower::collect_generic_params,
+    ty::ty_lower::GenericParamOwnerId,
+    /// Trait lowering.
+    ty::trait_lower::lower_trait,
+    ty::trait_lower::lower_trait_ref,
+    ty::trait_lower::collect_trait_impls,
+    ty::trait_lower::lower_impl_trait,
+    /// 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_trait,
+    /// Trait system.
+    ty::trait_def::TraitDef,
+    ty::trait_def::TraitInstId,
+    ty::trait_def::Implementor,
+    ty::trait_def::ingot_trait_env,
+    ty::trait_def::trait_implementors,
+    ty::constraint::collect_super_traits,
+    ty::constraint::collect_trait_constraints,
+    ty::constraint::collect_adt_constraints,
+    ty::constraint::collect_implementor_constraints,
+    ty::constraint::super_trait_insts,
+    ty::constraint::compute_super_assumptions,
+    ty::constraint::ty_constraints,
+    ty::constraint::trait_inst_constraints,
+    ty::constraint::PredicateId,
+    ty::constraint::PredicateListId,
+    ty::constraint_solver::is_goal_satisfiable,
+    ty::constraint_solver::check_ty_app_sat,
+    ty::constraint_solver::check_trait_inst_sat,
+    /// Diagnostic accumulators.
+    ty::diagnostics::AdtDefDiagAccumulator,
+    ty::diagnostics::TypeAliasDefDiagAccumulator,
+    ty::diagnostics::TraitDefDiagAccumulator,
+    ty::diagnostics::ImplTraitDefDiagAccumulator,
 );
 
 pub trait HirAnalysisDb: salsa::DbWithJar<Jar> + HirDb {
@@ -17,6 +65,7 @@ pub trait HirAnalysisDb: salsa::DbWithJar<Jar> + HirDb {
 impl<DB> HirAnalysisDb for DB where DB: ?Sized + salsa::DbWithJar<Jar> + HirDb {}
 
 pub mod name_resolution;
+pub mod ty;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Spanned<T> {

Diff for: crates/hir-analysis/src/lib.rs

@@ -8,16 +8,16 @@ mod visibility_checker;
 use either::Either;
 pub use import_resolver::ResolvedImports;
 pub use name_resolver::{
-    NameDerivation, NameDomain, NameQuery, NameRes, NameResBucket, QueryDirective,
+    NameDerivation, NameDomain, NameQuery, NameRes, NameResBucket, NameResKind, QueryDirective,
 };
 pub use path_resolver::EarlyResolvedPath;
 
 use hir::{
     analysis_pass::ModuleAnalysisPass,
     diagnostics::DiagnosticVoucher,
     hir_def::{
-        scope_graph::ScopeId, Expr, ExprId, IdentId, IngotId, ItemKind, Partial, Pat, PatId,
-        PathId, TopLevelMod, TypeBound, TypeId,
+        scope_graph::ScopeId, Expr, ExprId, GenericArgListId, IdentId, IngotId, ItemKind, Partial,
+        Pat, PatId, PathId, TopLevelMod, TraitRefId, TypeId,
     },
     visitor::prelude::*,
 };
@@ -361,13 +361,13 @@ impl<'db, 'a> Visitor for EarlyPathVisitor<'db, 'a> {
         self.path_ctxt.pop();
     }
 
-    fn visit_type_bound(
+    fn visit_trait_ref(
         &mut self,
-        ctxt: &mut VisitorCtxt<'_, LazyTypeBoundSpan>,
-        bound: &TypeBound,
+        ctxt: &mut VisitorCtxt<'_, LazyTraitRefSpan>,
+        trait_ref: TraitRefId,
     ) {
         self.path_ctxt.push(ExpectedPathKind::Trait);
-        walk_type_bound(self, ctxt, bound);
+        walk_trait_ref(self, ctxt, trait_ref);
         self.path_ctxt.pop();
     }
 
@@ -401,6 +401,16 @@ impl<'db, 'a> Visitor for EarlyPathVisitor<'db, 'a> {
         walk_generic_param(self, ctxt, param);
     }
 
+    fn visit_generic_arg_list(
+        &mut self,
+        ctxt: &mut VisitorCtxt<'_, LazyGenericArgListSpan>,
+        args: GenericArgListId,
+    ) {
+        self.path_ctxt.push(ExpectedPathKind::Type);
+        walk_generic_arg_list(self, ctxt, args);
+        self.path_ctxt.pop();
+    }
+
     fn visit_ty(&mut self, ctxt: &mut VisitorCtxt<'_, LazyTySpan>, ty: TypeId) {
         self.path_ctxt.push(ExpectedPathKind::Type);
         walk_ty(self, ctxt, ty);

Diff for: crates/hir-analysis/src/name_resolution/mod.rs

@@ -442,32 +442,38 @@ impl NameDerivation {
 
 impl PartialOrd for NameDerivation {
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for NameDerivation {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
         match (self, other) {
-            (NameDerivation::Def, NameDerivation::Def) => Some(cmp::Ordering::Equal),
-            (NameDerivation::Def, _) => Some(cmp::Ordering::Greater),
-            (_, NameDerivation::Def) => Some(cmp::Ordering::Less),
+            (NameDerivation::Def, NameDerivation::Def) => cmp::Ordering::Equal,
+            (NameDerivation::Def, _) => cmp::Ordering::Greater,
+            (_, NameDerivation::Def) => cmp::Ordering::Less,
 
             (NameDerivation::NamedImported(_), NameDerivation::NamedImported(_)) => {
-                Some(cmp::Ordering::Equal)
+                cmp::Ordering::Equal
             }
-            (NameDerivation::NamedImported(_), _) => Some(cmp::Ordering::Greater),
-            (_, NameDerivation::NamedImported(_)) => Some(cmp::Ordering::Less),
+            (NameDerivation::NamedImported(_), _) => cmp::Ordering::Greater,
+            (_, NameDerivation::NamedImported(_)) => cmp::Ordering::Less,
 
             (NameDerivation::GlobImported(_), NameDerivation::GlobImported(_)) => {
-                Some(cmp::Ordering::Equal)
+                cmp::Ordering::Equal
             }
-            (NameDerivation::GlobImported(_), _) => Some(cmp::Ordering::Greater),
-            (_, NameDerivation::GlobImported(_)) => Some(cmp::Ordering::Less),
+            (NameDerivation::GlobImported(_), _) => cmp::Ordering::Greater,
+            (_, NameDerivation::GlobImported(_)) => cmp::Ordering::Less,
 
-            (NameDerivation::Lex(lhs), NameDerivation::Lex(rhs)) => lhs.partial_cmp(rhs),
-            (NameDerivation::Lex(_), _) => Some(cmp::Ordering::Greater),
-            (_, NameDerivation::Lex(_)) => Some(cmp::Ordering::Less),
+            (NameDerivation::Lex(lhs), NameDerivation::Lex(rhs)) => lhs.cmp(rhs),
+            (NameDerivation::Lex(_), _) => cmp::Ordering::Greater,
+            (_, NameDerivation::Lex(_)) => cmp::Ordering::Less,
 
-            (NameDerivation::External, NameDerivation::External) => Some(cmp::Ordering::Equal),
-            (NameDerivation::External, _) => Some(cmp::Ordering::Greater),
-            (_, NameDerivation::External) => Some(cmp::Ordering::Less),
+            (NameDerivation::External, NameDerivation::External) => cmp::Ordering::Equal,
+            (NameDerivation::External, _) => cmp::Ordering::Greater,
+            (_, NameDerivation::External) => cmp::Ordering::Less,
 
-            (NameDerivation::Prim, NameDerivation::Prim) => Some(cmp::Ordering::Equal),
+            (NameDerivation::Prim, NameDerivation::Prim) => cmp::Ordering::Equal,
         }
     }
 }
@@ -504,6 +510,7 @@ impl<'db, 'a> NameResolver<'db, 'a> {
     }
 
     pub(crate) fn resolve_query(&mut self, query: NameQuery) -> NameResBucket {
+        let hir_db = self.db.as_hir_db();
         // If the query is already resolved, return the cached result.
         if let Some(resolved) = self.cache_store.get(query) {
             return resolved.clone();
@@ -519,7 +526,7 @@ impl<'db, 'a> NameResolver<'db, 'a> {
 
         // 1. Look for the name in the current scope.
         let mut found_scopes = FxHashSet::default();
-        for edge in query.scope.edges(self.db.as_hir_db()) {
+        for edge in query.scope.edges(hir_db) {
             match edge.kind.propagate(&query) {
                 PropagationResult::Terminated => {
                     if found_scopes.insert(edge.dest) {
@@ -577,16 +584,16 @@ impl<'db, 'a> NameResolver<'db, 'a> {
         // 5. Look for the name in the external ingots.
         query
             .scope
-            .top_mod(self.db.as_hir_db())
-            .ingot(self.db.as_hir_db())
-            .external_ingots(self.db.as_hir_db())
+            .top_mod(hir_db)
+            .ingot(hir_db)
+            .external_ingots(hir_db)
             .iter()
-            .for_each(|(name, root_mod)| {
+            .for_each(|(name, ingot)| {
                 if *name == query.name {
                     // We don't care about the result of `push` because we assume ingots are
                     // guaranteed to be unique.
                     bucket.push(&NameRes::new_from_scope(
-                        ScopeId::from_item((*root_mod).into()),
+                        ScopeId::from_item((ingot.root_mod(hir_db)).into()),
                         NameDomain::Type,
                         NameDerivation::External,
                     ))
@@ -735,12 +742,6 @@ impl<'db, 'a> NameResolver<'db, 'a> {
     }
 }
 
-impl Ord for NameDerivation {
-    fn cmp(&self, other: &Self) -> cmp::Ordering {
-        self.partial_cmp(other).unwrap()
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum NameResolutionError {
     /// The name is not found.