From b302f69b7c5b1b966ec3f8637761ecb867e3bcca Mon Sep 17 00:00:00 2001
From: Charles Lew <crlf0710@gmail.com>
Date: Sun, 13 Sep 2020 10:24:19 +0800
Subject: Update chalk to 0.27 and adapt to chalk changes.
---
Cargo.lock | 16 +++----
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 +++--
11 files changed, 113 insertions(+), 41 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index f35d63df2..72ec68624 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -162,9 +162,9 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
[[package]]
name = "chalk-derive"
-version = "0.25.0"
+version = "0.27.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624e14d3f029186e6ffd97081ffa082f98ddd5df20655b6f0e8efb83dd8ac8b4"
+checksum = "d5444ff2a211fe2a863e44d16a368c3d8a314d489de21b8eeb6879f14dd5d4a8"
dependencies = [
"proc-macro2",
"quote",
@@ -174,9 +174,9 @@ dependencies = [
[[package]]
name = "chalk-ir"
-version = "0.25.0"
+version = "0.27.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "118c68eccdda5604af50bbef84c94550f3854f76989cb03c36ffd36cc2ffe958"
+checksum = "e39c3db1dd4abfaa7658faaa62e5fe998a982a592b710bd971fad5b6adfcfdef"
dependencies = [
"chalk-derive",
"lazy_static",
@@ -184,9 +184,9 @@ dependencies = [
[[package]]
name = "chalk-recursive"
-version = "0.25.0"
+version = "0.27.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5130de3065e3cdfd2ab6d7d70b02b917bafbc096f270c9a643c23da249053606"
+checksum = "3bfae328eff80ca54dcd0d731725bbb56136ac21c59261b68f1e5498e056b306"
dependencies = [
"chalk-derive",
"chalk-ir",
@@ -197,9 +197,9 @@ dependencies = [
[[package]]
name = "chalk-solve"
-version = "0.25.0"
+version = "0.27.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45b235a1f568b28707f117b2d30eabbee9cbcfccaa0d6e9697300400c8ca0996"
+checksum = "a673abe3077adc25f8ee0894198aed494a5bb0ce50ee993900d0ee1a44e1948a"
dependencies = [
"chalk-derive",
"chalk-ir",
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<TypeRef>,
+ pub is_extern: bool,
pub ast_id: FileAstId<ast::TypeAlias>,
}
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::<TypeAlias>(0)), Const(Idx::<Const>(0)), Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<syntax::ast::generated::nodes::Trait>(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::<syntax::ast::generated::nodes::TypeAlias>(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::<syntax::ast::generated::nodes::TypeAlias>(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::<syntax::ast::generated::nodes::Const>(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<AssociatedTyDatum> {
debug!("associated_ty_data {:?}", id);
- let type_alias: TypeAliasId = from_chalk(db, id);
+ let type_alias: TypeAliasId = from_chalk::<TypeAliasAsAssocType, _>(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<Interner>;
pub type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
+pub type ForeignDefId = chalk_ir::ForeignDefId<Interner>;
pub type TraitId = chalk_ir::TraitId<Interner>;
pub type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
pub type AdtId = chalk_ir::AdtId<Interner>;
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::<TypeAliasAsAssocType, _>(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<Interner> {
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<Interner>) -> 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::<TypeAliasAsAssocType, _>(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::<TypeAliasAsForeignType, _>(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<Interner> {
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<Interner>,
) -> ProjectionTy {
ProjectionTy {
- associated_ty: from_chalk(db, projection_ty.associated_ty_id),
+ associated_ty: from_chalk::<TypeAliasAsAssocType, _>(
+ 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::<TypeAliasAsAssocType, _>(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<Interner>,
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::<TypeAliasAsAssocType, _>(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 <crlf0710@gmail.com>
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(-)
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<TypeRef>,
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<TypeBound>,
}
@@ -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<Ty> {
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 <crlf0710@gmail.com>
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(+)
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 <crlf0710@gmail.com>
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(-)
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<Ty> {
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