From cf94bdc0742c13e2a0cac864c478b8626b266e1b Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:11:38 +0200 Subject: Merging upstream version 1.66.0+dfsg1. Signed-off-by: Daniel Baumann --- compiler/rustc_typeck/src/check/place_op.rs | 451 ---------------------------- 1 file changed, 451 deletions(-) delete mode 100644 compiler/rustc_typeck/src/check/place_op.rs (limited to 'compiler/rustc_typeck/src/check/place_op.rs') diff --git a/compiler/rustc_typeck/src/check/place_op.rs b/compiler/rustc_typeck/src/check/place_op.rs deleted file mode 100644 index 2e0f37eba..000000000 --- a/compiler/rustc_typeck/src/check/place_op.rs +++ /dev/null @@ -1,451 +0,0 @@ -use crate::check::method::MethodCallee; -use crate::check::{has_expected_num_generic_args, FnCtxt, PlaceOp}; -use rustc_ast as ast; -use rustc_errors::Applicability; -use rustc_hir as hir; -use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; -use rustc_infer::infer::InferOk; -use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref, PointerCast}; -use rustc_middle::ty::adjustment::{AllowTwoPhase, AutoBorrow, AutoBorrowMutability}; -use rustc_middle::ty::{self, Ty}; -use rustc_span::symbol::{sym, Ident}; -use rustc_span::Span; -use rustc_trait_selection::autoderef::Autoderef; -use std::slice; - -impl<'a, 'tcx> FnCtxt<'a, 'tcx> { - /// Type-check `*oprnd_expr` with `oprnd_expr` type-checked already. - pub(super) fn lookup_derefing( - &self, - expr: &hir::Expr<'_>, - oprnd_expr: &'tcx hir::Expr<'tcx>, - oprnd_ty: Ty<'tcx>, - ) -> Option> { - if let Some(mt) = oprnd_ty.builtin_deref(true) { - return Some(mt.ty); - } - - let ok = self.try_overloaded_deref(expr.span, oprnd_ty)?; - let method = self.register_infer_ok_obligations(ok); - if let ty::Ref(region, _, hir::Mutability::Not) = method.sig.inputs()[0].kind() { - self.apply_adjustments( - oprnd_expr, - vec![Adjustment { - kind: Adjust::Borrow(AutoBorrow::Ref(*region, AutoBorrowMutability::Not)), - target: method.sig.inputs()[0], - }], - ); - } else { - span_bug!(expr.span, "input to deref is not a ref?"); - } - let ty = self.make_overloaded_place_return_type(method).ty; - self.write_method_call(expr.hir_id, method); - Some(ty) - } - - /// Type-check `*base_expr[index_expr]` with `base_expr` and `index_expr` type-checked already. - pub(super) fn lookup_indexing( - &self, - expr: &hir::Expr<'_>, - base_expr: &'tcx hir::Expr<'tcx>, - base_ty: Ty<'tcx>, - index_expr: &'tcx hir::Expr<'tcx>, - idx_ty: Ty<'tcx>, - ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> { - // FIXME(#18741) -- this is almost but not quite the same as the - // autoderef that normal method probing does. They could likely be - // consolidated. - - let mut autoderef = self.autoderef(base_expr.span, base_ty); - let mut result = None; - while result.is_none() && autoderef.next().is_some() { - result = self.try_index_step(expr, base_expr, &autoderef, idx_ty, index_expr); - } - self.register_predicates(autoderef.into_obligations()); - result - } - - fn negative_index( - &self, - ty: Ty<'tcx>, - span: Span, - base_expr: &hir::Expr<'_>, - ) -> Option<(Ty<'tcx>, Ty<'tcx>)> { - let ty = self.resolve_vars_if_possible(ty); - let mut err = self.tcx.sess.struct_span_err( - span, - &format!("negative integers cannot be used to index on a `{ty}`"), - ); - err.span_label(span, &format!("cannot use a negative integer for indexing on `{ty}`")); - if let (hir::ExprKind::Path(..), Ok(snippet)) = - (&base_expr.kind, self.tcx.sess.source_map().span_to_snippet(base_expr.span)) - { - // `foo[-1]` to `foo[foo.len() - 1]` - err.span_suggestion_verbose( - span.shrink_to_lo(), - &format!( - "to access an element starting from the end of the `{ty}`, compute the index", - ), - format!("{snippet}.len() "), - Applicability::MachineApplicable, - ); - } - err.emit(); - Some((self.tcx.ty_error(), self.tcx.ty_error())) - } - - /// To type-check `base_expr[index_expr]`, we progressively autoderef - /// (and otherwise adjust) `base_expr`, looking for a type which either - /// supports builtin indexing or overloaded indexing. - /// This loop implements one step in that search; the autoderef loop - /// is implemented by `lookup_indexing`. - fn try_index_step( - &self, - expr: &hir::Expr<'_>, - base_expr: &hir::Expr<'_>, - autoderef: &Autoderef<'a, 'tcx>, - index_ty: Ty<'tcx>, - index_expr: &hir::Expr<'_>, - ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> { - let adjusted_ty = - self.structurally_resolved_type(autoderef.span(), autoderef.final_ty(false)); - debug!( - "try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \ - index_ty={:?})", - expr, base_expr, adjusted_ty, index_ty - ); - - if let hir::ExprKind::Unary( - hir::UnOp::Neg, - hir::Expr { - kind: hir::ExprKind::Lit(hir::Lit { node: ast::LitKind::Int(..), .. }), - .. - }, - ) = index_expr.kind - { - match adjusted_ty.kind() { - ty::Adt(def, _) if self.tcx.is_diagnostic_item(sym::Vec, def.did()) => { - return self.negative_index(adjusted_ty, index_expr.span, base_expr); - } - ty::Slice(_) | ty::Array(_, _) => { - return self.negative_index(adjusted_ty, index_expr.span, base_expr); - } - _ => {} - } - } - - for unsize in [false, true] { - let mut self_ty = adjusted_ty; - if unsize { - // We only unsize arrays here. - if let ty::Array(element_ty, _) = adjusted_ty.kind() { - self_ty = self.tcx.mk_slice(*element_ty); - } else { - continue; - } - } - - // If some lookup succeeds, write callee into table and extract index/element - // type from the method signature. - // If some lookup succeeded, install method in table - let input_ty = self.next_ty_var(TypeVariableOrigin { - kind: TypeVariableOriginKind::AutoDeref, - span: base_expr.span, - }); - let method = - self.try_overloaded_place_op(expr.span, self_ty, &[input_ty], PlaceOp::Index); - - if let Some(result) = method { - debug!("try_index_step: success, using overloaded indexing"); - let method = self.register_infer_ok_obligations(result); - - let mut adjustments = self.adjust_steps(autoderef); - if let ty::Ref(region, _, hir::Mutability::Not) = method.sig.inputs()[0].kind() { - adjustments.push(Adjustment { - kind: Adjust::Borrow(AutoBorrow::Ref(*region, AutoBorrowMutability::Not)), - target: self.tcx.mk_ref( - *region, - ty::TypeAndMut { mutbl: hir::Mutability::Not, ty: adjusted_ty }, - ), - }); - } else { - span_bug!(expr.span, "input to index is not a ref?"); - } - if unsize { - adjustments.push(Adjustment { - kind: Adjust::Pointer(PointerCast::Unsize), - target: method.sig.inputs()[0], - }); - } - self.apply_adjustments(base_expr, adjustments); - - self.write_method_call(expr.hir_id, method); - - return Some((input_ty, self.make_overloaded_place_return_type(method).ty)); - } - } - - None - } - - /// Try to resolve an overloaded place op. We only deal with the immutable - /// variant here (Deref/Index). In some contexts we would need the mutable - /// variant (DerefMut/IndexMut); those would be later converted by - /// `convert_place_derefs_to_mutable`. - pub(super) fn try_overloaded_place_op( - &self, - span: Span, - base_ty: Ty<'tcx>, - arg_tys: &[Ty<'tcx>], - op: PlaceOp, - ) -> Option>> { - debug!("try_overloaded_place_op({:?},{:?},{:?})", span, base_ty, op); - - let (imm_tr, imm_op) = match op { - PlaceOp::Deref => (self.tcx.lang_items().deref_trait(), sym::deref), - PlaceOp::Index => (self.tcx.lang_items().index_trait(), sym::index), - }; - - // If the lang item was declared incorrectly, stop here so that we don't - // run into an ICE (#83893). The error is reported where the lang item is - // declared. - if !has_expected_num_generic_args( - self.tcx, - imm_tr, - match op { - PlaceOp::Deref => 0, - PlaceOp::Index => 1, - }, - ) { - return None; - } - - imm_tr.and_then(|trait_did| { - self.lookup_method_in_trait( - span, - Ident::with_dummy_span(imm_op), - trait_did, - base_ty, - Some(arg_tys), - ) - }) - } - - fn try_mutable_overloaded_place_op( - &self, - span: Span, - base_ty: Ty<'tcx>, - arg_tys: &[Ty<'tcx>], - op: PlaceOp, - ) -> Option>> { - debug!("try_mutable_overloaded_place_op({:?},{:?},{:?})", span, base_ty, op); - - let (mut_tr, mut_op) = match op { - PlaceOp::Deref => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut), - PlaceOp::Index => (self.tcx.lang_items().index_mut_trait(), sym::index_mut), - }; - - // If the lang item was declared incorrectly, stop here so that we don't - // run into an ICE (#83893). The error is reported where the lang item is - // declared. - if !has_expected_num_generic_args( - self.tcx, - mut_tr, - match op { - PlaceOp::Deref => 0, - PlaceOp::Index => 1, - }, - ) { - return None; - } - - mut_tr.and_then(|trait_did| { - self.lookup_method_in_trait( - span, - Ident::with_dummy_span(mut_op), - trait_did, - base_ty, - Some(arg_tys), - ) - }) - } - - /// Convert auto-derefs, indices, etc of an expression from `Deref` and `Index` - /// into `DerefMut` and `IndexMut` respectively. - /// - /// This is a second pass of typechecking derefs/indices. We need this because we do not - /// always know whether a place needs to be mutable or not in the first pass. - /// This happens whether there is an implicit mutable reborrow, e.g. when the type - /// is used as the receiver of a method call. - pub fn convert_place_derefs_to_mutable(&self, expr: &hir::Expr<'_>) { - // Gather up expressions we want to munge. - let mut exprs = vec![expr]; - - while let hir::ExprKind::Field(ref expr, _) - | hir::ExprKind::Index(ref expr, _) - | hir::ExprKind::Unary(hir::UnOp::Deref, ref expr) = exprs.last().unwrap().kind - { - exprs.push(expr); - } - - debug!("convert_place_derefs_to_mutable: exprs={:?}", exprs); - - // Fix up autoderefs and derefs. - let mut inside_union = false; - for (i, &expr) in exprs.iter().rev().enumerate() { - debug!("convert_place_derefs_to_mutable: i={} expr={:?}", i, expr); - - let mut source = self.node_ty(expr.hir_id); - if matches!(expr.kind, hir::ExprKind::Unary(hir::UnOp::Deref, _)) { - // Clear previous flag; after a pointer indirection it does not apply any more. - inside_union = false; - } - if source.is_union() { - inside_union = true; - } - // Fix up the autoderefs. Autorefs can only occur immediately preceding - // overloaded place ops, and will be fixed by them in order to get - // the correct region. - // Do not mutate adjustments in place, but rather take them, - // and replace them after mutating them, to avoid having the - // typeck results borrowed during (`deref_mut`) method resolution. - let previous_adjustments = - self.typeck_results.borrow_mut().adjustments_mut().remove(expr.hir_id); - if let Some(mut adjustments) = previous_adjustments { - for adjustment in &mut adjustments { - if let Adjust::Deref(Some(ref mut deref)) = adjustment.kind - && let Some(ok) = self.try_mutable_overloaded_place_op( - expr.span, - source, - &[], - PlaceOp::Deref, - ) - { - let method = self.register_infer_ok_obligations(ok); - if let ty::Ref(region, _, mutbl) = *method.sig.output().kind() { - *deref = OverloadedDeref { region, mutbl, span: deref.span }; - } - // If this is a union field, also throw an error for `DerefMut` of `ManuallyDrop` (see RFC 2514). - // This helps avoid accidental drops. - if inside_union - && source.ty_adt_def().map_or(false, |adt| adt.is_manually_drop()) - { - let mut err = self.tcx.sess.struct_span_err( - expr.span, - "not automatically applying `DerefMut` on `ManuallyDrop` union field", - ); - err.help( - "writing to this reference calls the destructor for the old value", - ); - err.help("add an explicit `*` if that is desired, or call `ptr::write` to not run the destructor"); - err.emit(); - } - } - source = adjustment.target; - } - self.typeck_results.borrow_mut().adjustments_mut().insert(expr.hir_id, adjustments); - } - - match expr.kind { - hir::ExprKind::Index(base_expr, ..) => { - self.convert_place_op_to_mutable(PlaceOp::Index, expr, base_expr); - } - hir::ExprKind::Unary(hir::UnOp::Deref, base_expr) => { - self.convert_place_op_to_mutable(PlaceOp::Deref, expr, base_expr); - } - _ => {} - } - } - } - - fn convert_place_op_to_mutable( - &self, - op: PlaceOp, - expr: &hir::Expr<'_>, - base_expr: &hir::Expr<'_>, - ) { - debug!("convert_place_op_to_mutable({:?}, {:?}, {:?})", op, expr, base_expr); - if !self.typeck_results.borrow().is_method_call(expr) { - debug!("convert_place_op_to_mutable - builtin, nothing to do"); - return; - } - - // Need to deref because overloaded place ops take self by-reference. - let base_ty = self - .typeck_results - .borrow() - .expr_ty_adjusted(base_expr) - .builtin_deref(false) - .expect("place op takes something that is not a ref") - .ty; - - let arg_ty = match op { - PlaceOp::Deref => None, - PlaceOp::Index => { - // We would need to recover the `T` used when we resolve `<_ as Index>::index` - // in try_index_step. This is the subst at index 1. - // - // Note: we should *not* use `expr_ty` of index_expr here because autoderef - // during coercions can cause type of index_expr to differ from `T` (#72002). - // We also could not use `expr_ty_adjusted` of index_expr because reborrowing - // during coercions can also cause type of index_expr to differ from `T`, - // which can potentially cause regionck failure (#74933). - Some(self.typeck_results.borrow().node_substs(expr.hir_id).type_at(1)) - } - }; - let arg_tys = match arg_ty { - None => &[], - Some(ref ty) => slice::from_ref(ty), - }; - - let method = self.try_mutable_overloaded_place_op(expr.span, base_ty, arg_tys, op); - let method = match method { - Some(ok) => self.register_infer_ok_obligations(ok), - // Couldn't find the mutable variant of the place op, keep the - // current, immutable version. - None => return, - }; - debug!("convert_place_op_to_mutable: method={:?}", method); - self.write_method_call(expr.hir_id, method); - - let ty::Ref(region, _, hir::Mutability::Mut) = method.sig.inputs()[0].kind() else { - span_bug!(expr.span, "input to mutable place op is not a mut ref?"); - }; - - // Convert the autoref in the base expr to mutable with the correct - // region and mutability. - let base_expr_ty = self.node_ty(base_expr.hir_id); - if let Some(adjustments) = - self.typeck_results.borrow_mut().adjustments_mut().get_mut(base_expr.hir_id) - { - let mut source = base_expr_ty; - for adjustment in &mut adjustments[..] { - if let Adjust::Borrow(AutoBorrow::Ref(..)) = adjustment.kind { - debug!("convert_place_op_to_mutable: converting autoref {:?}", adjustment); - let mutbl = AutoBorrowMutability::Mut { - // Deref/indexing can be desugared to a method call, - // so maybe we could use two-phase here. - // See the documentation of AllowTwoPhase for why that's - // not the case today. - allow_two_phase_borrow: AllowTwoPhase::No, - }; - adjustment.kind = Adjust::Borrow(AutoBorrow::Ref(*region, mutbl)); - adjustment.target = self - .tcx - .mk_ref(*region, ty::TypeAndMut { ty: source, mutbl: mutbl.into() }); - } - source = adjustment.target; - } - - // If we have an autoref followed by unsizing at the end, fix the unsize target. - if let [ - .., - Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. }, - Adjustment { kind: Adjust::Pointer(PointerCast::Unsize), ref mut target }, - ] = adjustments[..] - { - *target = method.sig.inputs()[0]; - } - } - } -} -- cgit v1.2.3