squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Add Lifetime to TyKind::Ref

Browse source
This commit is contained in:
Lukas Wirth 2021-04-05 22:08:16 +02:00
parent 4bc8a01830
commit 96756f1b1d
13 changed files with 74 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
crates/hir/src/lib.rs
View file

@ -1888,9 +1888,10 @@ impl Type {
substs.iter(&Interner).filter_map(|a| a.ty(&Interner)).any(go)
}
TyKind::Array(ty) | TyKind::Slice(ty) | TyKind::Raw(_, ty) | TyKind::Ref(_, ty) => {
go(ty)
}
TyKind::Array(ty)
| TyKind::Slice(ty)
| TyKind::Raw(_, ty)
| TyKind::Ref(_, _, ty) => go(ty),
TyKind::Scalar(_)
| TyKind::Str
@ -2148,7 +2149,10 @@ impl Type {
);
}
TyKind::Ref(_, ty) | TyKind::Raw(_, ty) | TyKind::Array(ty) | TyKind::Slice(ty) => {
TyKind::Ref(_, _, ty)
| TyKind::Raw(_, ty)
| TyKind::Array(ty)
| TyKind::Slice(ty) => {
walk_type(db, &type_.derived(ty.clone()), cb);
}

2
crates/hir_ty/src/diagnostics/expr.rs
View file

@ -315,7 +315,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
if pat_ty == match_expr_ty
|| match_expr_ty
.as_reference()
.map(|(match_expr_ty, _)| match_expr_ty == pat_ty)
.map(|(match_expr_ty, ..)| match_expr_ty == pat_ty)
.unwrap_or(false)
{
// If we had a NotUsefulMatchArm diagnostic, we could

2
crates/hir_ty/src/display.rs
View file

@ -314,7 +314,7 @@ impl HirDisplay for Ty {
t.hir_fmt(f)?;
write!(f, "; _]")?;
}
TyKind::Raw(m, t) | TyKind::Ref(m, t) => {
TyKind::Raw(m, t) | TyKind::Ref(m, _, t) => {
let ty_display =
t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);

6
crates/hir_ty/src/infer/coerce.rs
View file

@ -81,7 +81,7 @@ impl<'a> InferenceContext<'a> {
// `&T` -> `*const T`
// `&mut T` -> `*mut T`/`*const T`
(TyKind::Ref(.., substs), &TyKind::Raw(m2 @ Mutability::Not, ..))
| (TyKind::Ref(Mutability::Mut, substs), &TyKind::Raw(m2, ..)) => {
| (TyKind::Ref(Mutability::Mut, _, substs), &TyKind::Raw(m2, ..)) => {
from_ty = TyKind::Raw(m2, substs.clone()).intern(&Interner);
}
@ -111,7 +111,9 @@ impl<'a> InferenceContext<'a> {
// Auto Deref if cannot coerce
match (from_ty.kind(&Interner), to_ty.kind(&Interner)) {
// FIXME: DerefMut
(TyKind::Ref(_, st1), TyKind::Ref(_, st2)) => self.unify_autoderef_behind_ref(st1, st2),
(TyKind::Ref(.., st1), TyKind::Ref(.., st2)) => {
self.unify_autoderef_behind_ref(st1, st2)
}
// Otherwise, normal unify
_ => self.unify(&from_ty, to_ty),

22
crates/hir_ty/src/infer/expr.rs
View file

@ -23,7 +23,7 @@ use crate::{
traits::{chalk::from_chalk, FnTrait},
utils::{generics, variant_data, Generics},
AdtId, Binders, CallableDefId, FnPointer, FnSig, FnSubst, InEnvironment, Interner,
ProjectionTyExt, Rawness, Scalar, Substitution, TraitRef, Ty, TyBuilder, TyKind, TypeWalk,
LifetimeData, ProjectionTyExt, Rawness, Scalar, Substitution, TraitRef, Ty, TyBuilder, TyKind,
};
use super::{
@ -527,7 +527,9 @@ impl<'a> InferenceContext<'a> {
let inner_ty = self.infer_expr_inner(*expr, &expectation);
match rawness {
Rawness::RawPtr => TyKind::Raw(mutability, inner_ty),
Rawness::Ref => TyKind::Ref(mutability, inner_ty),
Rawness::Ref => {
TyKind::Ref(mutability, LifetimeData::Static.intern(&Interner), inner_ty)
}
}
.intern(&Interner)
}
@ -730,13 +732,17 @@ impl<'a> InferenceContext<'a> {
}
Expr::Literal(lit) => match lit {
Literal::Bool(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
Literal::String(..) => {
TyKind::Ref(Mutability::Not, TyKind::Str.intern(&Interner)).intern(&Interner)
}
Literal::String(..) => TyKind::Ref(
Mutability::Not,
LifetimeData::Static.intern(&Interner),
TyKind::Str.intern(&Interner),
)
.intern(&Interner),
Literal::ByteString(..) => {
let byte_type = TyKind::Scalar(Scalar::Uint(UintTy::U8)).intern(&Interner);
let array_type = TyKind::Array(byte_type).intern(&Interner);
TyKind::Ref(Mutability::Not, array_type).intern(&Interner)
TyKind::Ref(Mutability::Not, LifetimeData::Static.intern(&Interner), array_type)
.intern(&Interner)
}
Literal::Char(..) => TyKind::Scalar(Scalar::Char).intern(&Interner),
Literal::Int(_v, ty) => match ty {
@ -872,7 +878,9 @@ impl<'a> InferenceContext<'a> {
// Apply autoref so the below unification works correctly
// FIXME: return correct autorefs from lookup_method
let actual_receiver_ty = match expected_receiver_ty.as_reference() {
Some((_, mutability)) => TyKind::Ref(mutability, derefed_receiver_ty).intern(&Interner),
Some((_, lifetime, mutability)) => {
TyKind::Ref(mutability, lifetime, derefed_receiver_ty).intern(&Interner)
}
_ => derefed_receiver_ty,
};
self.unify(&expected_receiver_ty, &actual_receiver_ty);

20
crates/hir_ty/src/infer/pat.rs
View file

@ -13,8 +13,8 @@ use hir_expand::name::Name;
use super::{BindingMode, Expectation, InferenceContext};
use crate::{
lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substitution, Ty, TyBuilder,
TyKind,
lower::lower_to_chalk_mutability, utils::variant_data, Interner, LifetimeData, Substitution,
Ty, TyBuilder, TyKind,
};
impl<'a> InferenceContext<'a> {
@ -104,7 +104,7 @@ impl<'a> InferenceContext<'a> {
let body = Arc::clone(&self.body); // avoid borrow checker problem
if is_non_ref_pat(&body, pat) {
while let Some((inner, mutability)) = expected.as_reference() {
while let Some((inner, _lifetime, mutability)) = expected.as_reference() {
expected = inner;
default_bm = match default_bm {
BindingMode::Move => BindingMode::Ref(mutability),
@ -162,7 +162,7 @@ impl<'a> InferenceContext<'a> {
Pat::Ref { pat, mutability } => {
let mutability = lower_to_chalk_mutability(*mutability);
let expectation = match expected.as_reference() {
Some((inner_ty, exp_mut)) => {
Some((inner_ty, _lifetime, exp_mut)) => {
if mutability != exp_mut {
// FIXME: emit type error?
}
@ -171,7 +171,8 @@ impl<'a> InferenceContext<'a> {
_ => self.result.standard_types.unknown.clone(),
};
let subty = self.infer_pat(*pat, &expectation, default_bm);
TyKind::Ref(mutability, subty).intern(&Interner)
TyKind::Ref(mutability, LifetimeData::Static.intern(&Interner), subty)
.intern(&Interner)
}
Pat::TupleStruct { path: p, args: subpats, ellipsis } => self.infer_tuple_struct_pat(
p.as_ref(),
@ -203,9 +204,12 @@ impl<'a> InferenceContext<'a> {
let inner_ty = self.insert_type_vars_shallow(inner_ty);
let bound_ty = match mode {
BindingMode::Ref(mutability) => {
TyKind::Ref(mutability, inner_ty.clone()).intern(&Interner)
}
BindingMode::Ref(mutability) => TyKind::Ref(
mutability,
LifetimeData::Static.intern(&Interner),
inner_ty.clone(),
)
.intern(&Interner),
BindingMode::Move => inner_ty.clone(),
};
let bound_ty = self.resolve_ty_as_possible(bound_ty);

2
crates/hir_ty/src/infer/unify.rs
View file

@ -317,7 +317,7 @@ impl InferenceTable {
| (TyKind::Closure(.., substs1), TyKind::Closure(.., substs2)) => {
self.unify_substs(substs1, substs2, depth + 1)
}
(TyKind::Ref(_, ty1), TyKind::Ref(_, ty2))
(TyKind::Ref(_, _, ty1), TyKind::Ref(_, _, ty2))
| (TyKind::Raw(_, ty1), TyKind::Raw(_, ty2))
| (TyKind::Array(ty1), TyKind::Array(ty2))
| (TyKind::Slice(ty1), TyKind::Slice(ty2)) => self.unify_inner(ty1, ty2, depth + 1),

8
crates/hir_ty/src/lib.rs
View file

@ -165,16 +165,16 @@ impl CallableSig {
}
impl Ty {
pub fn as_reference(&self) -> Option<(&Ty, Mutability)> {
pub fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)> {
match self.kind(&Interner) {
TyKind::Ref(mutability, ty) => Some((ty, *mutability)),
TyKind::Ref(mutability, lifetime, ty) => Some((ty, *lifetime, *mutability)),
_ => None,
}
}
pub fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)> {
match self.kind(&Interner) {
TyKind::Ref(mutability, ty) => Some((ty, Rawness::Ref, *mutability)),
TyKind::Ref(mutability, _, ty) => Some((ty, Rawness::Ref, *mutability)),
TyKind::Raw(mutability, ty) => Some((ty, Rawness::RawPtr, *mutability)),
_ => None,
}
@ -183,7 +183,7 @@ impl Ty {
pub fn strip_references(&self) -> &Ty {
let mut t: &Ty = self;
while let TyKind::Ref(_mutability, ty) = t.kind(&Interner) {
while let TyKind::Ref(_mutability, _lifetime, ty) = t.kind(&Interner) {
t = ty;
}

6
crates/hir_ty/src/lower.rs
View file

@ -34,7 +34,7 @@ use crate::{
variant_data, Generics,
},
AliasEq, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, DynTy, FnPointer, FnSig,
FnSubst, ImplTraitId, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause,
FnSubst, ImplTraitId, LifetimeData, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause,
QuantifiedWhereClauses, ReturnTypeImplTrait, ReturnTypeImplTraits, Substitution,
TraitEnvironment, TraitRef, Ty, TyBuilder, TyKind, TypeWalk, WhereClause,
};
@ -174,7 +174,9 @@ impl<'a> TyLoweringContext<'a> {
}
TypeRef::Reference(inner, _, mutability) => {
let inner_ty = self.lower_ty(inner);
TyKind::Ref(lower_to_chalk_mutability(*mutability), inner_ty).intern(&Interner)
let lifetime = LifetimeData::Static.intern(&Interner);
TyKind::Ref(lower_to_chalk_mutability(*mutability), lifetime, inner_ty)
.intern(&Interner)
}
TypeRef::Placeholder => TyKind::Error.intern(&Interner),
TypeRef::Fn(params, is_varargs) => {

18
crates/hir_ty/src/method_resolution.rs
View file

@ -21,8 +21,8 @@ use crate::{
primitive::{self, FloatTy, IntTy, UintTy},
utils::all_super_traits,
AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, FnPointer, FnSig, ForeignDefId,
InEnvironment, Interner, Scalar, Substitution, TraitEnvironment, Ty, TyBuilder, TyKind,
TypeWalk,
InEnvironment, Interner, LifetimeData, Scalar, Substitution, TraitEnvironment, Ty, TyBuilder,
TyKind, TypeWalk,
};
/// This is used as a key for indexing impls.
@ -453,7 +453,12 @@ fn iterate_method_candidates_with_autoref(
}
let refed = Canonical {
binders: deref_chain[0].binders.clone(),
value: TyKind::Ref(Mutability::Not, deref_chain[0].value.clone()).intern(&Interner),
value: TyKind::Ref(
Mutability::Not,
LifetimeData::Static.intern(&Interner),
deref_chain[0].value.clone(),
)
.intern(&Interner),
};
if iterate_method_candidates_by_receiver(
&refed,
@ -470,7 +475,12 @@ fn iterate_method_candidates_with_autoref(
}
let ref_muted = Canonical {
binders: deref_chain[0].binders.clone(),
value: TyKind::Ref(Mutability::Mut, deref_chain[0].value.clone()).intern(&Interner),
value: TyKind::Ref(
Mutability::Mut,
LifetimeData::Static.intern(&Interner),
deref_chain[0].value.clone(),
)
.intern(&Interner),
};
if iterate_method_candidates_by_receiver(
&ref_muted,

10
crates/hir_ty/src/traits/chalk/mapping.rs
View file

@ -11,7 +11,7 @@ use hir_def::{GenericDefId, TypeAliasId};
use crate::{
chalk_ext::ProjectionTyExt, db::HirDatabase, primitive::UintTy, AliasTy, CallableDefId,
Canonical, DomainGoal, FnPointer, GenericArg, InEnvironment, OpaqueTy, ProjectionTy,
Canonical, DomainGoal, FnPointer, GenericArg, InEnvironment, Lifetime, OpaqueTy, ProjectionTy,
QuantifiedWhereClause, Scalar, Substitution, TraitRef, Ty, TypeWalk, WhereClause,
};
@ -22,7 +22,7 @@ impl ToChalk for Ty {
type Chalk = chalk_ir::Ty<Interner>;
fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> {
match self.into_inner() {
TyKind::Ref(m, ty) => ref_to_chalk(db, m, ty),
TyKind::Ref(m, lt, ty) => ref_to_chalk(db, m, lt, ty),
TyKind::Array(ty) => array_to_chalk(db, ty),
TyKind::Function(FnPointer { sig, substitution: substs, .. }) => {
let substitution = chalk_ir::FnSubst(substs.0.to_chalk(db));
@ -167,8 +167,8 @@ impl ToChalk for Ty {
}
chalk_ir::TyKind::Raw(mutability, ty) => TyKind::Raw(mutability, from_chalk(db, ty)),
chalk_ir::TyKind::Slice(ty) => TyKind::Slice(from_chalk(db, ty)),
chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
TyKind::Ref(mutability, from_chalk(db, ty))
chalk_ir::TyKind::Ref(mutability, lifetime, ty) => {
TyKind::Ref(mutability, lifetime, from_chalk(db, ty))
}
chalk_ir::TyKind::Str => TyKind::Str,
chalk_ir::TyKind::Never => TyKind::Never,
@ -192,10 +192,10 @@ impl ToChalk for Ty {
fn ref_to_chalk(
db: &dyn HirDatabase,
mutability: chalk_ir::Mutability,
lifetime: Lifetime,
ty: Ty,
) -> chalk_ir::Ty<Interner> {
let arg = ty.to_chalk(db);
let lifetime = LifetimeData::Static.intern(&Interner);
chalk_ir::TyKind::Ref(mutability, lifetime, arg).intern(&Interner)
}

5
crates/hir_ty/src/types.rs
View file

@ -11,7 +11,8 @@ use smallvec::SmallVec;
use crate::{
AssocTypeId, CanonicalVarKinds, ChalkTraitId, ClosureId, FnDefId, FnSig, ForeignDefId,
InferenceVar, Interner, OpaqueTyId, PlaceholderIndex, TypeWalk, VariableKind, VariableKinds,
InferenceVar, Interner, Lifetime, OpaqueTyId, PlaceholderIndex, TypeWalk, VariableKind,
VariableKinds,
};
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
@ -122,7 +123,7 @@ pub enum TyKind {
/// A reference; a pointer with an associated lifetime. Written as
/// `&'a mut T` or `&'a T`.
Ref(Mutability, Ty),
Ref(Mutability, Lifetime, Ty),
/// This represents a placeholder for an opaque type in situations where we
/// don't know the hidden type (i.e. currently almost always). This is

4
crates/hir_ty/src/walk.rs
View file

@ -153,7 +153,7 @@ impl TypeWalk for Ty {
p.walk(f);
}
}
TyKind::Slice(ty) | TyKind::Array(ty) | TyKind::Ref(_, ty) | TyKind::Raw(_, ty) => {
TyKind::Slice(ty) | TyKind::Array(ty) | TyKind::Ref(_, _, ty) | TyKind::Raw(_, ty) => {
ty.walk(f);
}
TyKind::Function(fn_pointer) => {
@ -187,7 +187,7 @@ impl TypeWalk for Ty {
TyKind::Alias(AliasTy::Opaque(o_ty)) => {
o_ty.substitution.walk_mut_binders(f, binders);
}
TyKind::Slice(ty) | TyKind::Array(ty) | TyKind::Ref(_, ty) | TyKind::Raw(_, ty) => {
TyKind::Slice(ty) | TyKind::Array(ty) | TyKind::Ref(_, _, ty) | TyKind::Raw(_, ty) => {
ty.walk_mut_binders(f, binders);
}
TyKind::Function(fn_pointer) => {