From 96756f1b1df4729fd00ca96a59971b3997c91934 Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Mon, 5 Apr 2021 22:08:16 +0200 Subject: Add Lifetime to TyKind::Ref --- crates/hir_ty/src/infer/coerce.rs | 6 ++++-- crates/hir_ty/src/infer/expr.rs | 22 +++++++++++++++------- crates/hir_ty/src/infer/pat.rs | 20 ++++++++++++-------- crates/hir_ty/src/infer/unify.rs | 2 +- 4 files changed, 32 insertions(+), 18 deletions(-) (limited to 'crates/hir_ty/src/infer') diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs index 32c273afc..d6c48870a 100644 --- a/crates/hir_ty/src/infer/coerce.rs +++ b/crates/hir_ty/src/infer/coerce.rs @@ -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), diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs index ff564106b..77fb36332 100644 --- a/crates/hir_ty/src/infer/expr.rs +++ b/crates/hir_ty/src/infer/expr.rs @@ -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); diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs index 252ae914a..b5e97cc8c 100644 --- a/crates/hir_ty/src/infer/pat.rs +++ b/crates/hir_ty/src/infer/pat.rs @@ -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); diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs index 2f9523325..c7878ebfd 100644 --- a/crates/hir_ty/src/infer/unify.rs +++ b/crates/hir_ty/src/infer/unify.rs @@ -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), -- cgit v1.2.3