Fix resolution of call of imported enum tuple variant constructor

sbillig · sbillig · commit 1dd1ec53aaab · 2025-01-26T17:27:57.000-08:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/driver/src/db.rs b/crates/driver/src/db.rs
@@ -243,6 +243,10 @@ impl DriverDataBase {
 
 pub struct DiagnosticsCollection<'db>(Vec<Box<dyn DiagnosticVoucher<'db> + 'db>>);
 impl<'db> DiagnosticsCollection<'db> {
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
     pub fn emit(&self, db: &'db DriverDataBase) {
         let writer = BufferWriter::stderr(ColorChoice::Auto);
         let mut buffer = writer.buffer();
diff --git a/crates/hir-analysis/Cargo.toml b/crates/hir-analysis/Cargo.toml
@@ -24,6 +24,7 @@ test-utils.workspace = true
 hir.workspace = true
 
 [dev-dependencies]
+camino.workspace = true
 codespan-reporting.workspace = true
 dir-test.workspace = true
 # TODO move cs diagnostics utils
diff --git a/crates/hir-analysis/src/name_resolution/path_resolver.rs b/crates/hir-analysis/src/name_resolution/path_resolver.rs
@@ -15,8 +15,9 @@ use super::{
 use crate::{
     name_resolution::{NameResKind, QueryDirective},
     ty::{
-        adt_def::{lower_adt, AdtRef, AdtRefId},
-        func_def::lower_func,
+        adt_def::{lower_adt, AdtRefId},
+        binder::Binder,
+        func_def::{lower_func, FuncDef, HirFuncDefKind},
         trait_def::TraitDef,
         trait_lower::lower_trait,
         ty_def::{InvalidCause, TyId},
@@ -249,6 +250,10 @@ pub struct ResolvedVariant<'db> {
 }
 
 impl<'db> ResolvedVariant<'db> {
+    pub fn new(ty: TyId<'db>, idx: usize, path: PathId<'db>) -> Self {
+        Self { ty, idx, path }
+    }
+
     pub fn variant_def(&self, db: &'db dyn HirAnalysisDb) -> &'db VariantDef<'db> {
         &self.enum_(db).variants(db.as_hir_db()).data(db.as_hir_db())[self.idx]
     }
@@ -258,14 +263,59 @@ impl<'db> ResolvedVariant<'db> {
     }
 
     pub fn enum_(&self, db: &'db dyn HirAnalysisDb) -> Enum<'db> {
-        let AdtRef::Enum(enum_) = self.ty.adt_ref(db).unwrap().data(db) else {
-            unreachable!()
-        };
-        enum_
+        self.ty.as_enum(db).unwrap()
     }
 
-    pub fn new(ty: TyId<'db>, idx: usize, path: PathId<'db>) -> Self {
-        Self { ty, idx, path }
+    pub fn iter_field_types(
+        &self,
+        db: &'db dyn HirAnalysisDb,
+    ) -> impl Iterator<Item = Binder<TyId<'db>>> {
+        self.ty
+            .adt_def(db)
+            .unwrap()
+            .fields(db)
+            .get(self.idx)
+            .unwrap()
+            .iter_types(db)
+    }
+
+    pub fn constructor_func_ty(&self, db: &'db dyn HirAnalysisDb) -> Option<TyId<'db>> {
+        let mut ty = TyId::func(db, self.to_funcdef(db)?);
+
+        for &arg in self.ty.generic_args(db) {
+            if ty.applicable_ty(db).is_some() {
+                ty = TyId::app(db, ty, arg);
+            }
+        }
+        Some(ty)
+    }
+
+    pub fn to_funcdef(&self, db: &'db dyn HirAnalysisDb) -> Option<FuncDef<'db>> {
+        if !matches!(self.variant_kind(db), VariantKind::Tuple(_)) {
+            return None;
+        }
+
+        let adt = self.ty.adt_def(db).unwrap();
+        let arg_tys = adt
+            .fields(db)
+            .get(self.idx)
+            .unwrap()
+            .iter_types(db)
+            .collect();
+
+        let adt_param_set = adt.param_set(db);
+
+        let mut ret_ty = TyId::adt(db, adt);
+        ret_ty = TyId::foldl(db, ret_ty, adt.param_set(db).params(db));
+
+        Some(FuncDef::new(
+            db,
+            HirFuncDefKind::VariantCtor(self.enum_(db), self.idx),
+            *self.variant_def(db).name.unwrap(),
+            *adt_param_set,
+            arg_tys,
+            Binder::bind(ret_ty),
+        ))
     }
 }
 
diff --git a/crates/hir-analysis/src/ty/method_table.rs b/crates/hir-analysis/src/ty/method_table.rs
@@ -1,19 +1,15 @@
-use hir::hir_def::{Enum, IdentId, Impl, IngotId, VariantKind};
+use hir::hir_def::{IdentId, Impl, IngotId};
 use rustc_hash::FxHashMap;
 
 use super::{
-    adt_def::{lower_adt, AdtRefId},
     binder::Binder,
     canonical::Canonical,
-    func_def::{lower_func, FuncDef, HirFuncDefKind},
+    func_def::{lower_func, FuncDef},
     ty_def::{InvalidCause, TyBase, TyId},
     ty_lower::lower_hir_ty,
     unify::UnificationTable,
 };
-use crate::{
-    ty::{ty_def::TyData, ty_lower::GenericParamTypeSet},
-    HirAnalysisDb,
-};
+use crate::{ty::ty_def::TyData, HirAnalysisDb};
 
 #[salsa::tracked(return_ref)]
 pub(crate) fn collect_methods<'db>(
@@ -22,11 +18,7 @@ pub(crate) fn collect_methods<'db>(
 ) -> MethodTable<'db> {
     let mut collector = MethodCollector::new(db, ingot);
 
-    let enums = ingot.all_enums(db.as_hir_db());
-    collector.collect_variant_ctors(enums);
-
     let impls = ingot.all_impls(db.as_hir_db());
-
     collector.collect_impls(impls);
     collector.finalize()
 }
@@ -150,47 +142,6 @@ impl<'db> MethodCollector<'db> {
         }
     }
 
-    fn collect_variant_ctors(&mut self, enums: &[Enum<'db>]) {
-        let hir_db = self.db.as_hir_db();
-        for &enum_ in enums {
-            let adt_ref = AdtRefId::new(self.db, enum_.into());
-            let adt = lower_adt(self.db, adt_ref);
-            for (i, variant) in enum_.variants(hir_db).data(hir_db).iter().enumerate() {
-                if !matches!(variant.kind, VariantKind::Tuple(_)) {
-                    continue;
-                };
-                let (Some(name), Some(variant)) =
-                    (variant.name.to_opt(), adt.fields(self.db).get(i))
-                else {
-                    continue;
-                };
-
-                let arg_tys = variant.iter_types(self.db).collect();
-                let mut ret_ty = TyId::adt(self.db, adt);
-                let adt_param_set = adt.param_set(self.db);
-                ret_ty = TyId::foldl(self.db, ret_ty, adt.param_set(self.db).params(self.db));
-
-                let param_set = GenericParamTypeSet::new(
-                    self.db,
-                    adt_param_set.params_precursor(self.db).to_vec(),
-                    adt_param_set.scope(self.db),
-                    adt_param_set.len(self.db),
-                );
-
-                let func = FuncDef::new(
-                    self.db,
-                    HirFuncDefKind::VariantCtor(enum_, i),
-                    name,
-                    param_set,
-                    arg_tys,
-                    Binder::bind(ret_ty),
-                );
-
-                self.insert(ret_ty, func)
-            }
-        }
-    }
-
     fn collect_impls(&mut self, impls: &[Impl<'db>]) {
         for impl_ in impls {
             let ty = match impl_.ty(self.db.as_hir_db()).to_opt() {
diff --git a/crates/hir-analysis/src/ty/ty_check/expr.rs b/crates/hir-analysis/src/ty/ty_check/expr.rs
@@ -447,9 +447,10 @@ impl<'db> TyChecker<'db> {
                 PathRes::EnumVariant(variant) => {
                     let ty = match variant.variant_kind(self.db) {
                         VariantKind::Unit => variant.ty,
-                        VariantKind::Tuple(_) => self
-                            .select_method_candidate_for_path(variant.ty, *path, span.path())
-                            .unwrap_or_else(|| TyId::invalid(self.db, InvalidCause::Other)),
+                        VariantKind::Tuple(_) => {
+                            let ty = variant.constructor_func_ty(self.db).unwrap();
+                            self.table.instantiate_to_term(ty)
+                        }
                         VariantKind::Record(_) => {
                             let diag = BodyDiag::unit_variant_expected(
                                 self.db,
diff --git a/crates/hir-analysis/src/ty/ty_lower.rs b/crates/hir-analysis/src/ty/ty_lower.rs
@@ -285,10 +285,6 @@ impl<'db> GenericParamTypeSet<'db> {
         Self::new(db, Vec::new(), scope, 0)
     }
 
-    pub(crate) fn len(self, db: &dyn HirAnalysisDb) -> usize {
-        self.params_precursor(db).len()
-    }
-
     pub(crate) fn trait_self(&self, db: &'db dyn HirAnalysisDb) -> Option<TyId<'db>> {
         let params = self.params_precursor(db);
         let cand = params.first()?;
diff --git a/crates/uitest/fixtures/name_resolution/imported_enum_constructor.fe b/crates/uitest/fixtures/name_resolution/imported_enum_constructor.fe
@@ -0,0 +1,14 @@
+use core::{Option, panic}
+
+fn f() -> u32 {
+    let x = Option::Some(10)
+    x.unwrap() // FIXME
+
+    let y: Option<u8> = Option::none() // FIXME
+    let z: Option<u8> = Option::default()
+
+    match x {
+        Option::Some(x) => x
+        Option::None => panic()
+    }
+}
diff --git a/crates/uitest/fixtures/name_resolution/imported_enum_constructor.snap b/crates/uitest/fixtures/name_resolution/imported_enum_constructor.snap
@@ -0,0 +1,16 @@
+---
+source: crates/uitest/tests/name_resolution.rs
+expression: diags
+input_file: fixtures/name_resolution/imported_enum_constructor.fe
+---
+error[8-0029]: `unwrap` is not found
+  ┌─ imported_enum_constructor.fe:5:7
+  │
+5 │     x.unwrap() // FIXME
+  │       ^^^^^^ `unwrap` is not found in `Option`
+
+error[8-0029]: `none` is not found
+  ┌─ imported_enum_constructor.fe:7:33
+  │
+7 │     let y: Option<u8> = Option::none() // FIXME
+  │                                 ^^^^ `none` is not found in `Option`
diff --git a/crates/uitest/tests/name_resolution.rs b/crates/uitest/tests/name_resolution.rs
@@ -11,7 +11,8 @@ fn run_name_resolution(fixture: Fixture<&str>) {
     let mut db = DriverDataBase::default();
     let path = Utf8Path::new(fixture.path());
 
-    let (ingot, file) = db.standalone_no_core(path, fixture.content());
+    let (core, _) = db.static_core_ingot();
+    let (ingot, file) = db.standalone(path, fixture.content(), core);
     let top_mod = db.top_mod(ingot, file);
 
     let diags = db.run_on_top_mod(top_mod);
@@ -37,7 +38,8 @@ mod wasm {
         let mut db = DriverDataBase::default();
         let path = Utf8Path::new(fixture.path());
 
-        let (ingot, file) = db.standalone_no_core(path, fixture.content());
+        let (core, _) = db.static_core_ingot();
+        let (ingot, file) = db.standalone(path, fixture.content(), core);
         let top_mod = db.top_mod(ingot, file);
         db.run_on_top_mod(top_mod);
     }
diff --git a/library/core/src/lib.fe b/library/core/src/lib.fe
@@ -1,2 +1,31 @@
-/// remove once useful code is added to core
-pub fn foo() { }
+extern {
+    pub fn panic() -> !
+}
+
+pub enum Option<T> {
+    Some(T),
+    None,
+}
+
+impl<T> Option<T> {
+    pub fn none() -> Self {
+        Self::None
+    }
+
+    pub fn unwrap(self) -> T {
+        match self {
+            Self::Some(t) => t,
+            None => panic()
+        }
+    }
+}
+
+pub trait Default {
+    fn default() -> Self
+}
+
+impl<T> Default for Option<T> {
+    fn default() -> Self {
+        Self::None
+    }
+}
