bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

use List<Ty<'tcx>> for tuples

Browse source
This commit is contained in:
lcnr 2022-02-07 16:06:31 +01:00
parent a9c1ab82f5
commit 1245131a11
53 changed files with 128 additions and 170 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_typeck/src/check/cast.rs
View file

@ -111,7 +111,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
},
ty::Tuple(fields) => match fields.last() {
None => Some(PointerKind::Thin),
Some(f) => self.pointer_kind(f.expect_ty(), span)?,
Some(&f) => self.pointer_kind(f, span)?,
},
// Pointers to foreign types are thin, despite being unsized

4
compiler/rustc_typeck/src/check/closure.rs
View file

@ -270,7 +270,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
debug!("deduce_sig_from_projection: arg_param_ty={:?}", arg_param_ty);
match arg_param_ty.kind() {
ty::Tuple(tys) => tys.into_iter().map(|k| k.expect_ty()).collect::<Vec<_>>(),
&ty::Tuple(tys) => tys,
_ => return None,
}
} else {
@ -286,7 +286,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let sig = projection.rebind(self.tcx.mk_fn_sig(
input_tys.iter(),
&ret_param_ty,
ret_param_ty,
false,
hir::Unsafety::Normal,
Abi::Rust,

6
compiler/rustc_typeck/src/check/expr.rs
View file

@ -1291,7 +1291,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| match flds {
Some(fs) if i < fs.len() => {
let ety = fs[i].expect_ty();
let ety = fs[i];
self.check_expr_coercable_to_type(&e, ety, None);
ety
}
@ -1877,13 +1877,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let fstr = field.as_str();
if let Ok(index) = fstr.parse::<usize>() {
if fstr == index.to_string() {
if let Some(field_ty) = tys.get(index) {
if let Some(&field_ty) = tys.get(index) {
let adjustments = self.adjust_steps(&autoderef);
self.apply_adjustments(base, adjustments);
self.register_predicates(autoderef.into_obligations());
self.write_field_index(expr.hir_id, index);
return field_ty.expect_ty();
return field_ty;
}
}
}

9
compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
View file

@ -147,12 +147,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
let expected_input_tys = match expected_input_tys.get(0) {
Some(&ty) => match ty.kind() {
ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
ty::Tuple(tys) => tys.iter().collect(),
_ => vec![],
},
None => vec![],
};
(arg_types.iter().map(|k| k.expect_ty()).collect(), expected_input_tys)
(arg_types.iter().collect(), expected_input_tys)
}
_ => {
// Otherwise, there's a mismatch, so clear out what we're expecting, and set
@ -495,12 +495,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expected_input_tys: &[Ty<'tcx>],
provided_args: &'tcx [hir::Expr<'tcx>],
) -> Option<FnArgsAsTuple<'_>> {
let [expected_arg_type] = &expected_input_tys[..] else { return None };
let [expected_arg_type] = expected_input_tys[..] else { return None };
let ty::Tuple(expected_elems) = self.resolve_vars_if_possible(*expected_arg_type).kind()
let &ty::Tuple(expected_types) = self.resolve_vars_if_possible(expected_arg_type).kind()
else { return None };
let expected_types: Vec<_> = expected_elems.iter().map(|k| k.expect_ty()).collect();
let supplied_types: Vec<_> = provided_args.iter().map(|arg| self.check_expr(arg)).collect();
let all_match = iter::zip(expected_types, supplied_types)

6
compiler/rustc_typeck/src/check/generator_interior.rs
View file

@ -539,16 +539,16 @@ pub fn check_must_not_suspend_ty<'tcx>(
}
has_emitted
}
ty::Tuple(_) => {
ty::Tuple(fields) => {
let mut has_emitted = false;
let comps = match data.expr.map(|e| &e.kind) {
Some(hir::ExprKind::Tup(comps)) => {
debug_assert_eq!(comps.len(), ty.tuple_fields().count());
debug_assert_eq!(comps.len(), fields.len());
Some(comps)
}
_ => None,
};
for (i, ty) in ty.tuple_fields().enumerate() {
for (i, ty) in fields.iter().enumerate() {
let descr_post = &format!(" in tuple element {}", i);
let span = comps.and_then(|c| c.get(i)).map(|e| e.span).unwrap_or(data.source_span);
if check_must_not_suspend_ty(

11
compiler/rustc_typeck/src/check/pat.rs
View file

@ -9,7 +9,6 @@ use rustc_hir::pat_util::EnumerateAndAdjustIterator;
use rustc_hir::{HirId, Pat, PatKind};
use rustc_infer::infer;
use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
use rustc_middle::ty::subst::GenericArg;
use rustc_middle::ty::{self, Adt, BindingMode, Ty, TypeFoldable};
use rustc_session::lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
use rustc_span::hygiene::DesugaringKind;
@ -1072,7 +1071,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
(ty::Adt(_, substs), [field], false) => {
let field_ty = self.field_ty(pat_span, field, substs);
match field_ty.kind() {
ty::Tuple(_) => field_ty.tuple_fields().count() == subpats.len(),
ty::Tuple(fields) => fields.len() == subpats.len(),
_ => false,
}
}
@ -1183,13 +1182,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let max_len = cmp::max(expected_len, elements.len());
let element_tys_iter = (0..max_len).map(|_| {
GenericArg::from(self.next_ty_var(
self.next_ty_var(
// FIXME: `MiscVariable` for now -- obtaining the span and name information
// from all tuple elements isn't trivial.
TypeVariableOrigin { kind: TypeVariableOriginKind::TypeInference, span },
))
)
});
let element_tys = tcx.mk_substs(element_tys_iter);
let element_tys = tcx.mk_type_list(element_tys_iter);
let pat_ty = tcx.mk_ty(ty::Tuple(element_tys));
if let Some(mut err) = self.demand_eqtype_pat_diag(span, expected, pat_ty, ti) {
err.emit();
@ -1202,7 +1201,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
tcx.mk_tup(element_tys_iter)
} else {
for (i, elem) in elements.iter().enumerate_and_adjust(max_len, ddpos) {
self.check_pat(elem, element_tys[i].expect_ty(), def_bm, ti);
self.check_pat(elem, element_tys[i], def_bm, ti);
}
pat_ty
}

4
compiler/rustc_typeck/src/check/upvar.rs
View file

@ -1448,7 +1448,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
)
}
ty::Tuple(..) => {
ty::Tuple(fields) => {
// Only Field projections can be applied to a tuple.
assert!(
captured_by_move_projs.iter().all(|projs| matches!(
@ -1457,7 +1457,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
))
);
base_path_ty.tuple_fields().enumerate().any(|(i, element_ty)| {
fields.iter().enumerate().any(|(i, element_ty)| {
let paths_using_field = captured_by_move_projs
.iter()
.filter_map(|projs| {

2
compiler/rustc_typeck/src/variance/constraints.rs
View file

@ -278,7 +278,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
ty::Tuple(subtys) => {
for subty in subtys {
self.add_constraints_from_ty(current, subty.expect_ty(), variance);
self.add_constraints_from_ty(current, subty, variance);
}
}