Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

implement rfc-2528 type_changing-struct-update #90035

Merged
merged 4 commits into from
Nov 9, 2021
Merged

implement rfc-2528 type_changing-struct-update #90035

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
7bde18a
implement type-changing-struct-update
SparrowLii Oct 19, 2021
f3679bc
move the processing part of `base_expr` into `check_expr_struct_fields`
SparrowLii Oct 29, 2021
1ab2616
Add feature trigger and correct `is_struct` check
SparrowLii Oct 29, 2021
926892d
Add feature trigger and enable is_struct check
SparrowLii Nov 5, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
177 changes: 112 additions & 65 deletions compiler/rustc_typeck/src/check/expr.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,11 +36,12 @@ use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKi
use rustc_infer::infer::InferOk;
use rustc_middle::ty;
use rustc_middle::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase};
use rustc_middle::ty::error::TypeError::{FieldMisMatch, Mismatch};
use rustc_middle::ty::error::TypeError::FieldMisMatch;
use rustc_middle::ty::subst::SubstsRef;
use rustc_middle::ty::Ty;
use rustc_middle::ty::TypeFoldable;
use rustc_middle::ty::{AdtKind, Visibility};
use rustc_session::parse::feature_err;
use rustc_span::edition::LATEST_STABLE_EDITION;
use rustc_span::hygiene::DesugaringKind;
use rustc_span::lev_distance::find_best_match_for_name;
Expand Down Expand Up @@ -1374,78 +1375,124 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}

if let Some(base_expr) = base_expr {
jackh726 marked this conversation as resolved.
Show resolved Hide resolved
// FIXME: We are currently creating two branches here in order to maintain
// consistency. But they should be merged as much as possible.
let fru_tys = if self.tcx.features().type_changing_struct_update {
let base_ty = self.check_expr(base_expr);
match (adt_ty.kind(), base_ty.kind()) {
(ty::Adt(adt, substs), ty::Adt(base_adt, base_subs)) if adt == base_adt => {
if !adt.is_struct() {
self.tcx.sess.emit_err(FunctionalRecordUpdateOnNonStruct {
span: base_expr.span,
});
};
let expected = if self.tcx.features().type_changing_struct_update {
NoExpectation
} else {
ExpectHasType(adt_ty)
};
let mut ty = self.check_expr_with_expectation(base_expr, expected);

let expected_ty = expected.to_option(&self).unwrap_or(adt_ty);
// While we don't allow *arbitrary* coercions here, we *do* allow
// coercions from ! to `expected`.
if ty.is_never() {
assert!(
!self.typeck_results.borrow().adjustments().contains_key(base_expr.hir_id),
"expression with never type wound up being adjusted"
);
let adj_ty = self.next_ty_var(TypeVariableOrigin {
kind: TypeVariableOriginKind::AdjustmentType,
span: base_expr.span,
});
self.apply_adjustments(
base_expr,
vec![Adjustment { kind: Adjust::NeverToAny, target: adj_ty }],
);
ty = adj_ty;
}
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Hmm, what is this needed for? If this is needed, can you add a test for it?

let cause = self.misc(base_expr.span);
let mut fru_tys = None;
let mut err = None;
let is_struct;
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Why define this here?


if let ty::Adt(adt, substs) = expected_ty.kind() {
match ty.kind() {
ty::Adt(base_adt, base_subs) if adt == base_adt => {
if self.tcx.features().type_changing_struct_update {
let tys = variant
.fields
.iter()
.map(|f| {
let fru_ty = self.normalize_associated_types_in(
expr_span,
self.field_ty(base_expr.span, f, base_subs),
);
let ident = self.tcx.adjust_ident(f.ident, variant.def_id);
if let Some(_) = remaining_fields.remove(&ident) {
let target_ty = self.field_ty(base_expr.span, f, substs);
match self.at(&cause, self.param_env).sup(target_ty, fru_ty)
{
Ok(InferOk { obligations, value: () }) => {
self.register_predicates(obligations)
}
// FIXME: Need better diagnostics for `FieldMisMatch` error
Err(_) => {
if err.is_none() {
err = Some(self.report_mismatched_types(
&cause,
target_ty,
fru_ty,
FieldMisMatch(
variant.ident.name,
ident.name,
),
))
}
}
}
}
fru_ty
})
.collect();
fru_tys = Some(tys);
} else {
err = self.demand_suptype_diag(base_expr.span, expected_ty, ty);
if err.is_some() && self.tcx.sess.is_nightly_build() {
feature_err(
&self.tcx.sess.parse_sess,
sym::type_changing_struct_update,
base_expr.span,
"type changing struct updating is experimental",
)
.emit();
}
}
}
_ => {
err = self.demand_suptype_diag(base_expr.span, expected_ty, ty);
}
}
is_struct = adt.is_struct();
if is_struct && fru_tys.is_none() {
fru_tys = Some(
variant
.fields
.iter()
.map(|f| {
let fru_ty = self.normalize_associated_types_in(
self.normalize_associated_types_in(
expr_span,
self.field_ty(base_expr.span, f, base_subs),
);
let ident = self.tcx.adjust_ident(f.ident, variant.def_id);
if let Some(_) = remaining_fields.remove(&ident) {
let target_ty = self.field_ty(base_expr.span, f, substs);
let cause = self.misc(base_expr.span);
match self.at(&cause, self.param_env).sup(target_ty, fru_ty) {
Ok(InferOk { obligations, value: () }) => {
self.register_predicates(obligations)
}
// FIXME: Need better diagnostics for `FieldMisMatch` error
Err(_) => self
.report_mismatched_types(
&cause,
target_ty,
fru_ty,
FieldMisMatch(variant.ident.name, ident.name),
)
.emit(),
}
}
fru_ty
f.ty(self.tcx, substs),
)
})
.collect()
}
_ => {
return self
.report_mismatched_types(
&self.misc(base_expr.span),
adt_ty,
base_ty,
Mismatch,
)
.emit();
}
.collect(),
)
}
} else {
self.check_expr_has_type_or_error(base_expr, adt_ty, |_| {});
match adt_ty.kind() {
ty::Adt(adt, substs) if adt.is_struct() => variant
.fields
.iter()
.map(|f| {
self.normalize_associated_types_in(expr_span, f.ty(self.tcx, substs))
})
.collect(),
_ => {
return self
.tcx
.sess
.emit_err(FunctionalRecordUpdateOnNonStruct { span: base_expr.span });
}
}
};
self.typeck_results.borrow_mut().fru_field_types_mut().insert(expr_id, fru_tys);
err = self.demand_suptype_diag(base_expr.span, expected_ty, ty);
is_struct = false;
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Why not just emit the error here?

Or, better yet, any way we can just return early and do away with the nesting?

}
if let Some(mut err) = err {
let expr = base_expr.peel_drop_temps();
self.suggest_deref_ref_or_into(&mut err, expr, expected_ty, ty, None);
err.emit();
}
if let Some(fru_tys) = fru_tys {
self.typeck_results.borrow_mut().fru_field_types_mut().insert(expr_id, fru_tys);
}
if !is_struct {
let e = FunctionalRecordUpdateOnNonStruct { span: base_expr.span };
self.tcx.sess.emit_err(e);
}
} else if kind_name != "union" && !remaining_fields.is_empty() {
let inaccessible_remaining_fields = remaining_fields.iter().any(|(_, (_, field))| {
!field.vis.is_accessible_from(tcx.parent_module(expr_id).to_def_id(), tcx)
Expand Down
5 changes: 3 additions & 2 deletions src/test/ui/rfcs/rfc-2528-type-changing-struct-update/feature-gate.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,10 +17,11 @@ fn update_to_state2() {
common_field1: "hello",
common_field2: 2,
};
// FIXME: this should trigger feature gate
let m2: Machine<State2> = Machine {
state: State2,
..m1 //~ ERROR mismatched types
..m1
//~^ ERROR type changing struct updating is experimental [E0658]
//~| ERROR mismatched types [E0308]
};
assert_eq!(State2, m2.state);
}
Expand Down
16 changes: 13 additions & 3 deletions src/test/ui/rfcs/rfc-2528-type-changing-struct-update/feature-gate.stderr
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,12 +1,22 @@
error[E0658]: type changing struct updating is experimental
--> $DIR/feature-gate.rs:22:11
|
LL | ..m1
| ^^
|
= note: see issue #86555 <https://github.com/rust-lang/rust/issues/86555> for more information
= help: add `#![feature(type_changing_struct_update)]` to the crate attributes to enable

error[E0308]: mismatched types
--> $DIR/feature-gate.rs:23:11
--> $DIR/feature-gate.rs:22:11
|
LL | ..m1
| ^^ expected struct `State2`, found struct `State1`
|
= note: expected struct `Machine<State2>`
found struct `Machine<State1>`

error: aborting due to previous error
error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0308`.
Some errors have detailed explanations: E0308, E0658.
For more information about an error, try `rustc --explain E0308`.
1 change: 0 additions & 1 deletion src/test/ui/rfcs/rfc-2528-type-changing-struct-update/type-generic-update.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -50,7 +50,6 @@ fn fail_update() {
let m3 = Machine::<i32, i32> {
..m1
//~^ ERROR mismatched types [E0308]
//~| ERROR mismatched types [E0308]
};
}

Expand Down
11 changes: 1 addition & 10 deletions src/test/ui/rfcs/rfc-2528-type-changing-struct-update/type-generic-update.stderr
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,15 +16,6 @@ LL | ..m1
= note: expected type `i32`
found type `f64`

error[E0308]: mismatched types
--> $DIR/type-generic-update.rs:51:11
|
LL | ..m1
| ^^ field type mismatch: Machine.message
|
= note: expected type `i32`
found type `f64`

error: aborting due to 3 previous errors
error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0308`.