From b302f69b7c5b1b966ec3f8637761ecb867e3bcca Mon Sep 17 00:00:00 2001 From: Charles Lew Date: Sun, 13 Sep 2020 10:24:19 +0800 Subject: Update chalk to 0.27 and adapt to chalk changes. --- crates/hir_def/src/item_tree.rs | 1 + crates/hir_def/src/item_tree/lower.rs | 6 ++- crates/hir_def/src/item_tree/tests.rs | 2 +- crates/hir_ty/Cargo.toml | 6 +-- crates/hir_ty/src/display.rs | 9 ++++ crates/hir_ty/src/lib.rs | 11 +++++ crates/hir_ty/src/traits/chalk.rs | 22 ++++++---- crates/hir_ty/src/traits/chalk/interner.rs | 1 + crates/hir_ty/src/traits/chalk/mapping.rs | 69 +++++++++++++++++++++++------- crates/hir_ty/src/traits/chalk/tls.rs | 11 +++-- 10 files changed, 105 insertions(+), 33 deletions(-) (limited to 'crates') diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs index e14722cae..52abb8e7f 100644 --- a/crates/hir_def/src/item_tree.rs +++ b/crates/hir_def/src/item_tree.rs @@ -592,6 +592,7 @@ pub struct TypeAlias { pub bounds: Box<[TypeBound]>, pub generic_params: GenericParamsId, pub type_ref: Option, + pub is_extern: bool, pub ast_id: FileAstId, } diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs index 6a503d785..d93377c3b 100644 --- a/crates/hir_def/src/item_tree/lower.rs +++ b/crates/hir_def/src/item_tree/lower.rs @@ -364,6 +364,7 @@ impl Ctx { generic_params, type_ref, ast_id, + is_extern: false, }; Some(id(self.data().type_aliases.alloc(res))) } @@ -558,8 +559,9 @@ impl Ctx { statik.into() } ast::ExternItem::TypeAlias(ty) => { - let id = self.lower_type_alias(&ty)?; - id.into() + let foreign_ty = self.lower_type_alias(&ty)?; + self.data().type_aliases[foreign_ty.index].is_extern = true; + foreign_ty.into() } ast::ExternItem::MacroCall(_) => return None, }; diff --git a/crates/hir_def/src/item_tree/tests.rs b/crates/hir_def/src/item_tree/tests.rs index 620e697d4..eed3d0d6f 100644 --- a/crates/hir_def/src/item_tree/tests.rs +++ b/crates/hir_def/src/item_tree/tests.rs @@ -236,7 +236,7 @@ fn smoke() { #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("on_trait"))] }, input: None }]) }] Trait { name: Name(Text("Tr")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(0), auto: false, items: [TypeAlias(Idx::(0)), Const(Idx::(0)), Function(Idx::(0)), Function(Idx::(1))], ast_id: FileAstId::(2) } > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_ty"))] }, input: None }]) }] - > TypeAlias { name: Name(Text("AssocTy")), visibility: RawVisibilityId("pub(self)"), bounds: [Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Tr"))] }, generic_args: [Some(GenericArgs { args: [Type(Tuple([]))], has_self_type: false, bindings: [] })] })], generic_params: GenericParamsId(4294967295), type_ref: None, ast_id: FileAstId::(8) } + > TypeAlias { name: Name(Text("AssocTy")), visibility: RawVisibilityId("pub(self)"), bounds: [Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Tr"))] }, generic_args: [Some(GenericArgs { args: [Type(Tuple([]))], has_self_type: false, bindings: [] })] })], generic_params: GenericParamsId(4294967295), type_ref: None, is_extern: false, ast_id: FileAstId::(8) } > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_const"))] }, input: None }]) }] > Const { name: Some(Name(Text("CONST"))), visibility: RawVisibilityId("pub(self)"), type_ref: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("u8"))] }, generic_args: [None] }), ast_id: FileAstId::(9) } > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_method"))] }, input: None }]) }] diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml index 7d02aaf95..bc86df2b1 100644 --- a/crates/hir_ty/Cargo.toml +++ b/crates/hir_ty/Cargo.toml @@ -17,9 +17,9 @@ ena = "0.14.0" log = "0.4.8" rustc-hash = "1.1.0" scoped-tls = "1" -chalk-solve = { version = "0.25.0" } -chalk-ir = { version = "0.25.0" } -chalk-recursive = { version = "0.25.0" } +chalk-solve = { version = "0.27.0" } +chalk-ir = { version = "0.27.0" } +chalk-recursive = { version = "0.27.0" } stdx = { path = "../stdx", version = "0.0.0" } hir_def = { path = "../hir_def", version = "0.0.0" } diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs index efb48c7ee..f389c5a4b 100644 --- a/crates/hir_ty/src/display.rs +++ b/crates/hir_ty/src/display.rs @@ -380,6 +380,15 @@ impl HirDisplay for ApplicationTy { write!(f, ">")?; } } + TypeCtor::ForeignType(type_alias) => { + let type_alias = f.db.type_alias_data(type_alias); + write!(f, "{}", type_alias.name)?; + if self.parameters.len() > 0 { + write!(f, "<")?; + f.write_joined(&*self.parameters.0, ", ")?; + write!(f, ">")?; + } + } TypeCtor::OpaqueType(opaque_ty_id) => { match opaque_ty_id { OpaqueTyId::ReturnTypeImplTrait(func, idx) => { diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs index f16d1fc97..768d95eff 100644 --- a/crates/hir_ty/src/lib.rs +++ b/crates/hir_ty/src/lib.rs @@ -134,6 +134,9 @@ pub enum TypeCtor { /// representing the Future::Output type. OpaqueType(OpaqueTyId), + /// Represents a foreign type declared in external blocks. + ForeignType(TypeAliasId), + /// The type of a specific closure. /// /// The closure signature is stored in a `FnPtr` type in the first type @@ -168,6 +171,10 @@ impl TypeCtor { let generic_params = generics(db.upcast(), type_alias.into()); generic_params.len() } + TypeCtor::ForeignType(type_alias) => { + let generic_params = generics(db.upcast(), type_alias.into()); + generic_params.len() + } TypeCtor::OpaqueType(opaque_ty_id) => { match opaque_ty_id { OpaqueTyId::ReturnTypeImplTrait(func, _) => { @@ -204,6 +211,9 @@ impl TypeCtor { TypeCtor::AssociatedType(type_alias) => { Some(type_alias.lookup(db.upcast()).module(db.upcast()).krate) } + TypeCtor::ForeignType(type_alias) => { + Some(type_alias.lookup(db.upcast()).module(db.upcast()).krate) + } TypeCtor::OpaqueType(opaque_ty_id) => match opaque_ty_id { OpaqueTyId::ReturnTypeImplTrait(func, _) => { Some(func.lookup(db.upcast()).module(db.upcast()).krate) @@ -231,6 +241,7 @@ impl TypeCtor { TypeCtor::Adt(adt) => Some(adt.into()), TypeCtor::FnDef(callable) => Some(callable.into()), TypeCtor::AssociatedType(type_alias) => Some(type_alias.into()), + TypeCtor::ForeignType(type_alias) => Some(type_alias.into()), TypeCtor::OpaqueType(_impl_trait_id) => None, } } diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs index 57d0a32df..27f0ed628 100644 --- a/crates/hir_ty/src/traits/chalk.rs +++ b/crates/hir_ty/src/traits/chalk.rs @@ -23,7 +23,8 @@ use crate::{ ProjectionTy, Substs, TraitRef, Ty, TypeCtor, }; use mapping::{ - convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue, + convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsAssocType, + TypeAliasAsValue, }; pub use self::interner::*; @@ -340,7 +341,7 @@ pub(crate) fn associated_ty_data_query( id: AssocTypeId, ) -> Arc { debug!("associated_ty_data {:?}", id); - let type_alias: TypeAliasId = from_chalk(db, id); + let type_alias: TypeAliasId = from_chalk::(db, id).0; let trait_ = match type_alias.lookup(db.upcast()).container { AssocContainerId::TraitId(t) => t, _ => panic!("associated type not in trait"), @@ -394,8 +395,10 @@ pub(crate) fn trait_datum_query( fundamental: false, }; let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars); - let associated_ty_ids = - trait_data.associated_types().map(|type_alias| type_alias.to_chalk(db)).collect(); + let associated_ty_ids = trait_data + .associated_types() + .map(|type_alias| TypeAliasAsAssocType(type_alias).to_chalk(db)) + .collect(); let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses }; let well_known = lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name)); @@ -433,6 +436,7 @@ fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str { WellKnownTrait::FnMut => "fn_mut", WellKnownTrait::Fn => "fn", WellKnownTrait::Unsize => "unsize", + WellKnownTrait::Unpin => "unpin", } } @@ -576,7 +580,7 @@ fn type_alias_associated_ty_value( let value_bound = rust_ir::AssociatedTyValueBound { ty: ty.value.to_chalk(db) }; let value = rust_ir::AssociatedTyValue { impl_id: impl_id.to_chalk(db), - associated_ty_id: assoc_ty.to_chalk(db), + associated_ty_id: TypeAliasAsAssocType(assoc_ty).to_chalk(db), value: make_binders(value_bound, ty.num_binders), }; Arc::new(value) @@ -611,9 +615,11 @@ pub(crate) fn fn_def_datum_query( }; let datum = FnDefDatum { id: fn_def_id, - abi: (), - safety: chalk_ir::Safety::Safe, - variadic: sig.value.is_varargs, + sig: chalk_ir::FnSig { + abi: (), + safety: chalk_ir::Safety::Safe, + variadic: sig.value.is_varargs, + }, binders: make_binders(bound, sig.num_binders), }; Arc::new(datum) diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/traits/chalk/interner.rs index eb35db3ff..f9304b7d0 100644 --- a/crates/hir_ty/src/traits/chalk/interner.rs +++ b/crates/hir_ty/src/traits/chalk/interner.rs @@ -12,6 +12,7 @@ pub struct Interner; pub type AssocTypeId = chalk_ir::AssocTypeId; pub type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum; +pub type ForeignDefId = chalk_ir::ForeignDefId; pub type TraitId = chalk_ir::TraitId; pub type TraitDatum = chalk_solve::rust_ir::TraitDatum; pub type AdtId = chalk_ir::AdtId; diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs index d6bacba1d..d42f4bba9 100644 --- a/crates/hir_ty/src/traits/chalk/mapping.rs +++ b/crates/hir_ty/src/traits/chalk/mapping.rs @@ -34,9 +34,11 @@ impl ToChalk for Ty { let substitution = apply_ty.parameters.to_chalk(db).shifted_in(&Interner); chalk_ir::TyData::Function(chalk_ir::FnPointer { num_binders: 0, - abi: (), - safety: chalk_ir::Safety::Safe, - variadic: is_varargs, + sig: chalk_ir::FnSig { + abi: (), + safety: chalk_ir::Safety::Safe, + variadic: is_varargs, + }, substitution, }) .intern(&Interner) @@ -48,7 +50,7 @@ impl ToChalk for Ty { } }, Ty::Projection(proj_ty) => { - let associated_ty_id = proj_ty.associated_ty.to_chalk(db); + let associated_ty_id = TypeAliasAsAssocType(proj_ty.associated_ty).to_chalk(db); let substitution = proj_ty.parameters.to_chalk(db); chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy { associated_ty_id, @@ -114,7 +116,8 @@ impl ToChalk for Ty { Ty::Placeholder(db.lookup_intern_type_param_id(interned_id)) } chalk_ir::TyData::Alias(chalk_ir::AliasTy::Projection(proj)) => { - let associated_ty = from_chalk(db, proj.associated_ty_id); + let associated_ty = + from_chalk::(db, proj.associated_ty_id).0; let parameters = from_chalk(db, proj.substitution); Ty::Projection(ProjectionTy { associated_ty, parameters }) } @@ -125,7 +128,7 @@ impl ToChalk for Ty { } chalk_ir::TyData::Function(chalk_ir::FnPointer { num_binders, - variadic, + sig: chalk_ir::FnSig { variadic, .. }, substitution, .. }) => { @@ -290,8 +293,9 @@ impl ToChalk for TypeCtor { fn to_chalk(self, db: &dyn HirDatabase) -> TypeName { match self { TypeCtor::AssociatedType(type_alias) => { - let type_id = type_alias.to_chalk(db); - TypeName::AssociatedType(type_id) + let assoc_type = TypeAliasAsAssocType(type_alias); + let assoc_type_id = assoc_type.to_chalk(db); + TypeName::AssociatedType(assoc_type_id) } TypeCtor::OpaqueType(impl_trait_id) => { @@ -299,6 +303,12 @@ impl ToChalk for TypeCtor { TypeName::OpaqueType(id) } + TypeCtor::ForeignType(type_alias) => { + let foreign_type = TypeAliasAsForeignType(type_alias); + let foreign_type_id = foreign_type.to_chalk(db); + TypeName::Foreign(foreign_type_id) + } + TypeCtor::Bool => TypeName::Scalar(Scalar::Bool), TypeCtor::Char => TypeName::Scalar(Scalar::Char), TypeCtor::Int(int_ty) => TypeName::Scalar(int_ty_to_chalk(int_ty)), @@ -339,7 +349,9 @@ impl ToChalk for TypeCtor { fn from_chalk(db: &dyn HirDatabase, type_name: TypeName) -> TypeCtor { match type_name { TypeName::Adt(struct_id) => TypeCtor::Adt(struct_id.0), - TypeName::AssociatedType(type_id) => TypeCtor::AssociatedType(from_chalk(db, type_id)), + TypeName::AssociatedType(type_id) => { + TypeCtor::AssociatedType(from_chalk::(db, type_id).0) + } TypeName::OpaqueType(opaque_type_id) => { TypeCtor::OpaqueType(from_chalk(db, opaque_type_id)) } @@ -379,6 +391,10 @@ impl ToChalk for TypeCtor { TypeCtor::Closure { def, expr } } + TypeName::Foreign(foreign_def_id) => { + TypeCtor::ForeignType(from_chalk::(db, foreign_def_id).0) + } + TypeName::Error => { // this should not be reached, since we don't represent TypeName::Error with TypeCtor unreachable!() @@ -488,15 +504,31 @@ impl ToChalk for CallableDefId { } } -impl ToChalk for TypeAliasId { +pub struct TypeAliasAsAssocType(pub TypeAliasId); + +impl ToChalk for TypeAliasAsAssocType { type Chalk = AssocTypeId; fn to_chalk(self, _db: &dyn HirDatabase) -> AssocTypeId { - chalk_ir::AssocTypeId(self.as_intern_id()) + chalk_ir::AssocTypeId(self.0.as_intern_id()) + } + + fn from_chalk(_db: &dyn HirDatabase, assoc_type_id: AssocTypeId) -> TypeAliasAsAssocType { + TypeAliasAsAssocType(InternKey::from_intern_id(assoc_type_id.0)) + } +} + +pub struct TypeAliasAsForeignType(pub TypeAliasId); + +impl ToChalk for TypeAliasAsForeignType { + type Chalk = ForeignDefId; + + fn to_chalk(self, _db: &dyn HirDatabase) -> ForeignDefId { + chalk_ir::ForeignDefId(self.0.as_intern_id()) } - fn from_chalk(_db: &dyn HirDatabase, type_alias_id: AssocTypeId) -> TypeAliasId { - InternKey::from_intern_id(type_alias_id.0) + fn from_chalk(_db: &dyn HirDatabase, foreign_def_id: ForeignDefId) -> TypeAliasAsForeignType { + TypeAliasAsForeignType(InternKey::from_intern_id(foreign_def_id.0)) } } @@ -580,7 +612,7 @@ impl ToChalk for ProjectionTy { fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::ProjectionTy { chalk_ir::ProjectionTy { - associated_ty_id: self.associated_ty.to_chalk(db), + associated_ty_id: TypeAliasAsAssocType(self.associated_ty).to_chalk(db), substitution: self.parameters.to_chalk(db), } } @@ -590,7 +622,11 @@ impl ToChalk for ProjectionTy { projection_ty: chalk_ir::ProjectionTy, ) -> ProjectionTy { ProjectionTy { - associated_ty: from_chalk(db, projection_ty.associated_ty_id), + associated_ty: from_chalk::( + db, + projection_ty.associated_ty_id, + ) + .0, parameters: from_chalk(db, projection_ty.substitution), } } @@ -789,7 +825,8 @@ pub(super) fn generic_predicate_to_inline_bound( let alias_eq_bound = rust_ir::AliasEqBound { value: proj.ty.clone().to_chalk(db), trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), args_no_self }, - associated_ty_id: proj.projection_ty.associated_ty.to_chalk(db), + associated_ty_id: TypeAliasAsAssocType(proj.projection_ty.associated_ty) + .to_chalk(db), parameters: Vec::new(), // FIXME we don't support generic associated types yet }; Some(rust_ir::InlineBound::AliasEqBound(alias_eq_bound)) diff --git a/crates/hir_ty/src/traits/chalk/tls.rs b/crates/hir_ty/src/traits/chalk/tls.rs index cb6b0fe81..b4568cff6 100644 --- a/crates/hir_ty/src/traits/chalk/tls.rs +++ b/crates/hir_ty/src/traits/chalk/tls.rs @@ -4,7 +4,7 @@ use std::fmt; use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication, TypeName}; use itertools::Itertools; -use super::{from_chalk, Interner}; +use super::{from_chalk, Interner, TypeAliasAsAssocType}; use crate::{db::HirDatabase, CallableDefId, TypeCtor}; use hir_def::{AdtId, AssocContainerId, DefWithBodyId, Lookup, TypeAliasId}; @@ -77,6 +77,10 @@ impl DebugContext<'_> { write!(f, "{{impl trait of async block {} of {:?}}}", idx.into_raw(), def)?; } }, + TypeCtor::ForeignType(type_alias) => { + let name = self.0.type_alias_data(type_alias).name.clone(); + write!(f, "{}", name)?; + } TypeCtor::Closure { def, expr } => { write!(f, "{{closure {:?} in ", expr.into_raw())?; match def { @@ -119,7 +123,7 @@ impl DebugContext<'_> { id: super::AssocTypeId, fmt: &mut fmt::Formatter<'_>, ) -> Result<(), fmt::Error> { - let type_alias: TypeAliasId = from_chalk(self.0, id); + let type_alias: TypeAliasId = from_chalk::(self.0, id).0; let type_alias_data = self.0.type_alias_data(type_alias); let trait_ = match type_alias.lookup(self.0.upcast()).container { AssocContainerId::TraitId(t) => t, @@ -153,7 +157,8 @@ impl DebugContext<'_> { projection_ty: &chalk_ir::ProjectionTy, fmt: &mut fmt::Formatter<'_>, ) -> Result<(), fmt::Error> { - let type_alias: TypeAliasId = from_chalk(self.0, projection_ty.associated_ty_id); + let type_alias: TypeAliasId = + from_chalk::(self.0, projection_ty.associated_ty_id).0; let type_alias_data = self.0.type_alias_data(type_alias); let trait_ = match type_alias.lookup(self.0.upcast()).container { AssocContainerId::TraitId(t) => t, -- cgit v1.2.3 From 389d9a6c2d297d838b4cfa754565b6bea5f8c757 Mon Sep 17 00:00:00 2001 From: Charles Lew Date: Wed, 16 Sep 2020 20:57:14 +0800 Subject: Lower extern type alias as foreign opaque type. --- crates/hir_def/src/data.rs | 2 ++ crates/hir_ty/src/lower.rs | 8 ++++++-- 2 files changed, 8 insertions(+), 2 deletions(-) (limited to 'crates') diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs index 9a8eb4ede..6190906da 100644 --- a/crates/hir_def/src/data.rs +++ b/crates/hir_def/src/data.rs @@ -54,6 +54,7 @@ pub struct TypeAliasData { pub name: Name, pub type_ref: Option, pub visibility: RawVisibility, + pub is_extern: bool, /// Bounds restricting the type alias itself (eg. `type Ty: Bound;` in a trait or impl). pub bounds: Vec, } @@ -71,6 +72,7 @@ impl TypeAliasData { name: typ.name.clone(), type_ref: typ.type_ref.clone(), visibility: item_tree[typ.visibility].clone(), + is_extern: typ.is_extern, bounds: typ.bounds.to_vec(), }) } diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs index cd574e983..39252bc5e 100644 --- a/crates/hir_ty/src/lower.rs +++ b/crates/hir_ty/src/lower.rs @@ -1101,9 +1101,13 @@ fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders { let resolver = t.resolver(db.upcast()); let ctx = TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); - let type_ref = &db.type_alias_data(t).type_ref; let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); - let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error)); + let inner = if db.type_alias_data(t).is_extern { + Ty::simple(TypeCtor::ForeignType(t)) + } else { + let type_ref = &db.type_alias_data(t).type_ref; + Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error)) + }; Binders::new(substs.len(), inner) } -- cgit v1.2.3 From eb969647561f46c783469469284538ed95d77076 Mon Sep 17 00:00:00 2001 From: Charles Lew Date: Thu, 17 Sep 2020 00:21:34 +0800 Subject: Add a test. --- crates/hir_ty/src/tests/method_resolution.rs | 38 ++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) (limited to 'crates') diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs index 23b2601e6..690f9d66e 100644 --- a/crates/hir_ty/src/tests/method_resolution.rs +++ b/crates/hir_ty/src/tests/method_resolution.rs @@ -1051,3 +1051,41 @@ fn dyn_trait_super_trait_not_in_scope() { "#]], ); } + +#[test] +fn method_resolution_foreign_opaque_type() { + check_infer( + r#" + extern "C" { + type S; + fn f() -> &'static S; + } + + impl S { + fn foo(&self) -> bool { + true + } + } + + fn test() { + let s = unsafe { f() }; + s.foo(); + } + "#, + // FIXME: 's.foo()' should be `bool`. + expect![[r#" + 75..79 'self': &S + 89..109 '{ ... }': bool + 99..103 'true': bool + 123..167 '{ ...o(); }': () + 133..134 's': &S + 137..151 'unsafe { f() }': &S + 144..151 '{ f() }': &S + 146..147 'f': fn f() -> &S + 146..149 'f()': &S + 157..158 's': &S + 157..164 's.foo()': {unknown} + "#]], + ); +} + -- cgit v1.2.3 From 3fff5aa4d72df9775baca32f54728da8cb6c31ed Mon Sep 17 00:00:00 2001 From: Charles Lew Date: Thu, 17 Sep 2020 00:50:24 +0800 Subject: Use Ty::apply instead of simple and fix method resolution. --- crates/hir_ty/src/lower.rs | 10 +++++----- crates/hir_ty/src/method_resolution.rs | 8 ++++++++ crates/hir_ty/src/tests/method_resolution.rs | 4 +--- 3 files changed, 14 insertions(+), 8 deletions(-) (limited to 'crates') diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs index 39252bc5e..708e2af0f 100644 --- a/crates/hir_ty/src/lower.rs +++ b/crates/hir_ty/src/lower.rs @@ -1102,13 +1102,13 @@ fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders { let ctx = TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); - let inner = if db.type_alias_data(t).is_extern { - Ty::simple(TypeCtor::ForeignType(t)) + if db.type_alias_data(t).is_extern { + Binders::new(substs.len(), Ty::apply(TypeCtor::ForeignType(t), substs)) } else { let type_ref = &db.type_alias_data(t).type_ref; - Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error)) - }; - Binders::new(substs.len(), inner) + let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error)); + Binders::new(substs.len(), inner) + } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs index ec59145c7..8961df404 100644 --- a/crates/hir_ty/src/method_resolution.rs +++ b/crates/hir_ty/src/method_resolution.rs @@ -250,6 +250,14 @@ impl Ty { TypeCtor::Adt(def_id) => { return Some(std::iter::once(def_id.module(db.upcast()).krate).collect()) } + TypeCtor::ForeignType(type_alias_id) => { + return Some( + std::iter::once( + type_alias_id.lookup(db.upcast()).module(db.upcast()).krate, + ) + .collect(), + ) + } TypeCtor::Bool => lang_item_crate!("bool"), TypeCtor::Char => lang_item_crate!("char"), TypeCtor::Float(f) => match f.bitness { diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs index 690f9d66e..0f17ff151 100644 --- a/crates/hir_ty/src/tests/method_resolution.rs +++ b/crates/hir_ty/src/tests/method_resolution.rs @@ -1072,7 +1072,6 @@ fn method_resolution_foreign_opaque_type() { s.foo(); } "#, - // FIXME: 's.foo()' should be `bool`. expect![[r#" 75..79 'self': &S 89..109 '{ ... }': bool @@ -1084,8 +1083,7 @@ fn method_resolution_foreign_opaque_type() { 146..147 'f': fn f() -> &S 146..149 'f()': &S 157..158 's': &S - 157..164 's.foo()': {unknown} + 157..164 's.foo()': bool "#]], ); } - -- cgit v1.2.3