From 4fe18a6fb5a1181a04c47391f558ebab5b8b0f39 Mon Sep 17 00:00:00 2001 From: Shoyu Vanilla Date: Mon, 27 Jan 2025 00:48:19 +0900 Subject: [PATCH] Add a test for field default value body as defining usage of TAIT --- crates/hir-def/src/lib.rs | 6 +- crates/hir-ty/src/tests.rs | 112 ++++++++++++++---- .../src/tests/type_alias_impl_traits.rs | 50 +++++++- 3 files changed, 141 insertions(+), 27 deletions(-) diff --git a/crates/hir-def/src/lib.rs b/crates/hir-def/src/lib.rs index cf97d27fd1..80aa551660 100644 --- a/crates/hir-def/src/lib.rs +++ b/crates/hir-def/src/lib.rs @@ -1399,11 +1399,7 @@ impl HasModule for DefWithBodyId { DefWithBodyId::ConstId(it) => it.module(db), DefWithBodyId::VariantId(it) => it.module(db), DefWithBodyId::InTypeConstId(it) => it.lookup(db).owner.module(db), - DefWithBodyId::FieldId(it) => match it.parent { - VariantId::EnumVariantId(it) => it.module(db), - VariantId::StructId(it) => it.module(db), - VariantId::UnionId(it) => it.module(db), - }, + DefWithBodyId::FieldId(it) => it.module(db), } } } diff --git a/crates/hir-ty/src/tests.rs b/crates/hir-ty/src/tests.rs index a5af712b42..5177ed07b1 100644 --- a/crates/hir-ty/src/tests.rs +++ b/crates/hir-ty/src/tests.rs @@ -16,6 +16,7 @@ use std::env; use std::sync::LazyLock; use base_db::SourceDatabaseFileInputExt as _; +use either::Either; use expect_test::Expect; use hir_def::{ db::DefDatabase, @@ -23,12 +24,14 @@ use hir_def::{ hir::{ExprId, Pat, PatId}, item_scope::ItemScope, nameres::DefMap, - src::HasSource, - AssocItemId, DefWithBodyId, HasModule, LocalModuleId, Lookup, ModuleDefId, SyntheticSyntax, + src::{HasChildSource, HasSource}, + AdtId, AssocItemId, DefWithBodyId, FieldId, HasModule, LocalModuleId, Lookup, ModuleDefId, + SyntheticSyntax, }; use hir_expand::{db::ExpandDatabase, FileRange, InFile}; use itertools::Itertools; use rustc_hash::FxHashMap; +use span::TextSize; use stdx::format_to; use syntax::{ ast::{self, AstNode, HasName}, @@ -132,14 +135,40 @@ fn check_impl( None => continue, }; let def_map = module.def_map(&db); - visit_module(&db, &def_map, module.local_id, &mut |it| { - defs.push(match it { - ModuleDefId::FunctionId(it) => it.into(), - ModuleDefId::EnumVariantId(it) => it.into(), - ModuleDefId::ConstId(it) => it.into(), - ModuleDefId::StaticId(it) => it.into(), - _ => return, - }) + visit_module(&db, &def_map, module.local_id, &mut |it| match it { + ModuleDefId::FunctionId(it) => defs.push(it.into()), + ModuleDefId::EnumVariantId(it) => { + defs.push(it.into()); + let variant_id = it.into(); + let vd = db.variant_data(variant_id); + defs.extend(vd.fields().iter().filter_map(|(local_id, fd)| { + if fd.has_default { + let field = FieldId { parent: variant_id, local_id, has_default: true }; + Some(DefWithBodyId::FieldId(field)) + } else { + None + } + })); + } + ModuleDefId::ConstId(it) => defs.push(it.into()), + ModuleDefId::StaticId(it) => defs.push(it.into()), + ModuleDefId::AdtId(it) => { + let variant_id = match it { + AdtId::StructId(it) => it.into(), + AdtId::UnionId(it) => it.into(), + AdtId::EnumId(_) => return, + }; + let vd = db.variant_data(variant_id); + defs.extend(vd.fields().iter().filter_map(|(local_id, fd)| { + if fd.has_default { + let field = FieldId { parent: variant_id, local_id, has_default: true }; + Some(DefWithBodyId::FieldId(field)) + } else { + None + } + })); + } + _ => {} }); } defs.sort_by_key(|def| match def { @@ -160,12 +189,20 @@ fn check_impl( loc.source(&db).value.syntax().text_range().start() } DefWithBodyId::InTypeConstId(it) => it.source(&db).syntax().text_range().start(), - DefWithBodyId::FieldId(_) => unreachable!(), + DefWithBodyId::FieldId(it) => { + let cs = it.parent.child_source(&db); + match cs.value.get(it.local_id) { + Some(Either::Left(it)) => it.syntax().text_range().start(), + Some(Either::Right(it)) => it.syntax().text_range().end(), + None => TextSize::new(u32::MAX), + } + } }); let mut unexpected_type_mismatches = String::new(); for def in defs { let (body, body_source_map) = db.body_with_source_map(def); let inference_result = db.infer(def); + dbg!(&inference_result); for (pat, mut ty) in inference_result.type_of_pat.iter() { if let Pat::Bind { id, .. } = body.pats[pat] { @@ -389,14 +426,40 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String { let def_map = module.def_map(&db); let mut defs: Vec = Vec::new(); - visit_module(&db, &def_map, module.local_id, &mut |it| { - defs.push(match it { - ModuleDefId::FunctionId(it) => it.into(), - ModuleDefId::EnumVariantId(it) => it.into(), - ModuleDefId::ConstId(it) => it.into(), - ModuleDefId::StaticId(it) => it.into(), - _ => return, - }) + visit_module(&db, &def_map, module.local_id, &mut |it| match it { + ModuleDefId::FunctionId(it) => defs.push(it.into()), + ModuleDefId::EnumVariantId(it) => { + defs.push(it.into()); + let variant_id = it.into(); + let vd = db.variant_data(variant_id); + defs.extend(vd.fields().iter().filter_map(|(local_id, fd)| { + if fd.has_default { + let field = FieldId { parent: variant_id, local_id, has_default: true }; + Some(DefWithBodyId::FieldId(field)) + } else { + None + } + })); + } + ModuleDefId::ConstId(it) => defs.push(it.into()), + ModuleDefId::StaticId(it) => defs.push(it.into()), + ModuleDefId::AdtId(it) => { + let variant_id = match it { + AdtId::StructId(it) => it.into(), + AdtId::UnionId(it) => it.into(), + AdtId::EnumId(_) => return, + }; + let vd = db.variant_data(variant_id); + defs.extend(vd.fields().iter().filter_map(|(local_id, fd)| { + if fd.has_default { + let field = FieldId { parent: variant_id, local_id, has_default: true }; + Some(DefWithBodyId::FieldId(field)) + } else { + None + } + })); + } + _ => {} }); defs.sort_by_key(|def| match def { DefWithBodyId::FunctionId(it) => { @@ -416,7 +479,14 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String { loc.source(&db).value.syntax().text_range().start() } DefWithBodyId::InTypeConstId(it) => it.source(&db).syntax().text_range().start(), - DefWithBodyId::FieldId(_) => unreachable!(), + DefWithBodyId::FieldId(it) => { + let cs = it.parent.child_source(&db); + match cs.value.get(it.local_id) { + Some(Either::Left(it)) => it.syntax().text_range().start(), + Some(Either::Right(it)) => it.syntax().text_range().end(), + None => TextSize::new(u32::MAX), + } + } }); for def in defs { let (body, source_map) = db.body_with_source_map(def); @@ -477,7 +547,7 @@ pub(crate) fn visit_module( let body = db.body(it.into()); visit_body(db, &body, cb); } - ModuleDefId::AdtId(hir_def::AdtId::EnumId(it)) => { + ModuleDefId::AdtId(AdtId::EnumId(it)) => { db.enum_data(it).variants.iter().for_each(|&(it, _)| { let body = db.body(it.into()); cb(it.into()); diff --git a/crates/hir-ty/src/tests/type_alias_impl_traits.rs b/crates/hir-ty/src/tests/type_alias_impl_traits.rs index e2b7bf379c..a2aada57da 100644 --- a/crates/hir-ty/src/tests/type_alias_impl_traits.rs +++ b/crates/hir-ty/src/tests/type_alias_impl_traits.rs @@ -157,5 +157,53 @@ static ALIAS: i32 = { 217..218 '5': i32 205..211: expected impl Trait + ?Sized, got Struct "#]], - ) + ); +} + +#[test] +fn defining_type_alias_impl_trait_from_default_fields() { + check_no_mismatches( + r#" +trait Trait {} + +struct Struct; + +impl Trait for Struct {} + +type AliasTy = impl Trait; + +struct Foo { + foo: AliasTy = { + let x: AliasTy = Struct; + x + }, +} +"#, + ); + + check_infer_with_mismatches( + r#" +trait Trait {} + +struct Struct; + +impl Trait for Struct {} + +type AliasTy = impl Trait; + +struct Foo { + foo: i32 = { + let x: AliasTy = Struct; + 5 + }, +} +"#, + expect![[r#" + 114..164 '{ ... }': i32 + 128..129 'x': impl Trait + ?Sized + 141..147 'Struct': Struct + 157..158 '5': i32 + 141..147: expected impl Trait + ?Sized, got Struct + "#]], + ); }