Skip to content

Commit 34327f6

Browse files
borsbors
committed
Auto merge of rust-lang#88992 - Manishearth:rollup-k9hijii, r=Manishearth
Rollup of 8 pull requests Successful merges: - rust-lang#87320 (Introduce -Z remap-cwd-prefix switch) - rust-lang#88690 (Accept `m!{ .. }.method()` and `m!{ .. }?` statements. ) - rust-lang#88775 (Revert anon union parsing) - rust-lang#88841 (feat(rustc_typeck): suggest removing bad parens in `(recv.method)()`) - rust-lang#88907 (Highlight the `const fn` if error happened because of a bound on the impl block) - rust-lang#88915 (`Wrapping<T>` has the same layout and ABI as `T`) - rust-lang#88933 (Remove implementation of `min_align_of` intrinsic) - rust-lang#88951 (Update books) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup
2 parents 4aed1ab + 1da3c1d commit 34327f6

File tree

40 files changed

+275
-628
lines changed

40 files changed

+275
-628
lines changed

Diff for: ‎compiler/rustc_ast/src/ast.rs

-4
Original file line numberDiff line numberDiff line change
@@ -1902,10 +1902,6 @@ pub enum TyKind {
19021902
Never,
19031903
/// A tuple (`(A, B, C, D,...)`).
19041904
Tup(Vec<P<Ty>>),
1905-
/// An anonymous struct type i.e. `struct { foo: Type }`
1906-
AnonymousStruct(Vec<FieldDef>, bool),
1907-
/// An anonymous union type i.e. `union { bar: Type }`
1908-
AnonymousUnion(Vec<FieldDef>, bool),
19091905
/// A path (`module::module::...::Type`), optionally
19101906
/// "qualified", e.g., `<Vec<T> as SomeTrait>::SomeType`.
19111907
///

Diff for: ‎compiler/rustc_ast/src/mut_visit.rs

-3
Original file line numberDiff line numberDiff line change
@@ -484,9 +484,6 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
484484
visit_vec(bounds, |bound| vis.visit_param_bound(bound));
485485
}
486486
TyKind::MacCall(mac) => vis.visit_mac_call(mac),
487-
TyKind::AnonymousStruct(fields, ..) | TyKind::AnonymousUnion(fields, ..) => {
488-
fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
489-
}
490487
}
491488
vis.visit_span(span);
492489
visit_lazy_tts(tokens, vis);

Diff for: ‎compiler/rustc_ast/src/visit.rs

-3
Original file line numberDiff line numberDiff line change
@@ -407,9 +407,6 @@ pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) {
407407
TyKind::Typeof(ref expression) => visitor.visit_anon_const(expression),
408408
TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err => {}
409409
TyKind::MacCall(ref mac) => visitor.visit_mac_call(mac),
410-
TyKind::AnonymousStruct(ref fields, ..) | TyKind::AnonymousUnion(ref fields, ..) => {
411-
walk_list!(visitor, visit_field_def, fields)
412-
}
413410
TyKind::Never | TyKind::CVarArgs => {}
414411
}
415412
}

Diff for: ‎compiler/rustc_ast_lowering/src/item.rs

+1-4
Original file line numberDiff line numberDiff line change
@@ -748,10 +748,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
748748
}
749749
}
750750

751-
pub(super) fn lower_field_def(
752-
&mut self,
753-
(index, f): (usize, &FieldDef),
754-
) -> hir::FieldDef<'hir> {
751+
fn lower_field_def(&mut self, (index, f): (usize, &FieldDef)) -> hir::FieldDef<'hir> {
755752
let ty = if let TyKind::Path(ref qself, ref path) = f.ty.kind {
756753
let t = self.lower_path_ty(
757754
&f.ty,

Diff for: ‎compiler/rustc_ast_lowering/src/lib.rs

-9
Original file line numberDiff line numberDiff line change
@@ -1301,15 +1301,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
13011301
let kind = match t.kind {
13021302
TyKind::Infer => hir::TyKind::Infer,
13031303
TyKind::Err => hir::TyKind::Err,
1304-
// FIXME(unnamed_fields): IMPLEMENTATION IN PROGRESS
1305-
TyKind::AnonymousStruct(ref _fields, _recovered) => {
1306-
self.sess.struct_span_err(t.span, "anonymous structs are unimplemented").emit();
1307-
hir::TyKind::Err
1308-
}
1309-
TyKind::AnonymousUnion(ref _fields, _recovered) => {
1310-
self.sess.struct_span_err(t.span, "anonymous unions are unimplemented").emit();
1311-
hir::TyKind::Err
1312-
}
13131304
TyKind::Slice(ref ty) => hir::TyKind::Slice(self.lower_ty(ty, itctx)),
13141305
TyKind::Ptr(ref mt) => hir::TyKind::Ptr(self.lower_mt(mt, itctx)),
13151306
TyKind::Rptr(ref region, ref mt) => {

Diff for: ‎compiler/rustc_ast_passes/src/ast_validation.rs

-68
Original file line numberDiff line numberDiff line change
@@ -193,19 +193,13 @@ impl<'a> AstValidator<'a> {
193193
}
194194
}
195195
}
196-
TyKind::AnonymousStruct(ref fields, ..) | TyKind::AnonymousUnion(ref fields, ..) => {
197-
self.with_banned_assoc_ty_bound(|this| {
198-
walk_list!(this, visit_struct_field_def, fields)
199-
});
200-
}
201196
_ => visit::walk_ty(self, t),
202197
}
203198
}
204199

205200
fn visit_struct_field_def(&mut self, field: &'a FieldDef) {
206201
if let Some(ident) = field.ident {
207202
if ident.name == kw::Underscore {
208-
self.check_anonymous_field(field);
209203
self.visit_vis(&field.vis);
210204
self.visit_ident(ident);
211205
self.visit_ty_common(&field.ty);
@@ -251,66 +245,6 @@ impl<'a> AstValidator<'a> {
251245
err.emit();
252246
}
253247

254-
fn check_anonymous_field(&self, field: &FieldDef) {
255-
let FieldDef { ty, .. } = field;
256-
match &ty.kind {
257-
TyKind::AnonymousStruct(..) | TyKind::AnonymousUnion(..) => {
258-
// We already checked for `kw::Underscore` before calling this function,
259-
// so skip the check
260-
}
261-
TyKind::Path(..) => {
262-
// If the anonymous field contains a Path as type, we can't determine
263-
// if the path is a valid struct or union, so skip the check
264-
}
265-
_ => {
266-
let msg = "unnamed fields can only have struct or union types";
267-
let label = "not a struct or union";
268-
self.err_handler()
269-
.struct_span_err(field.span, msg)
270-
.span_label(ty.span, label)
271-
.emit();
272-
}
273-
}
274-
}
275-
276-
fn deny_anonymous_struct(&self, ty: &Ty) {
277-
match &ty.kind {
278-
TyKind::AnonymousStruct(..) => {
279-
self.err_handler()
280-
.struct_span_err(
281-
ty.span,
282-
"anonymous structs are not allowed outside of unnamed struct or union fields",
283-
)
284-
.span_label(ty.span, "anonymous struct declared here")
285-
.emit();
286-
}
287-
TyKind::AnonymousUnion(..) => {
288-
self.err_handler()
289-
.struct_span_err(
290-
ty.span,
291-
"anonymous unions are not allowed outside of unnamed struct or union fields",
292-
)
293-
.span_label(ty.span, "anonymous union declared here")
294-
.emit();
295-
}
296-
_ => {}
297-
}
298-
}
299-
300-
fn deny_anonymous_field(&self, field: &FieldDef) {
301-
if let Some(ident) = field.ident {
302-
if ident.name == kw::Underscore {
303-
self.err_handler()
304-
.struct_span_err(
305-
field.span,
306-
"anonymous fields are not allowed outside of structs or unions",
307-
)
308-
.span_label(ident.span, "anonymous field declared here")
309-
.emit()
310-
}
311-
}
312-
}
313-
314248
fn check_decl_no_pat(decl: &FnDecl, mut report_err: impl FnMut(Span, Option<Ident>, bool)) {
315249
for Param { pat, .. } in &decl.inputs {
316250
match pat.kind {
@@ -1081,7 +1015,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
10811015

10821016
fn visit_ty(&mut self, ty: &'a Ty) {
10831017
self.visit_ty_common(ty);
1084-
self.deny_anonymous_struct(ty);
10851018
self.walk_ty(ty)
10861019
}
10871020

@@ -1096,7 +1029,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
10961029
}
10971030

10981031
fn visit_field_def(&mut self, s: &'a FieldDef) {
1099-
self.deny_anonymous_field(s);
11001032
visit::walk_field_def(self, s)
11011033
}
11021034

Diff for: ‎compiler/rustc_ast_passes/src/feature_gate.rs

-1
Original file line numberDiff line numberDiff line change
@@ -668,7 +668,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session) {
668668
// involved, so we only emit errors where there are no other parsing errors.
669669
gate_all!(destructuring_assignment, "destructuring assignments are unstable");
670670
}
671-
gate_all!(unnamed_fields, "unnamed fields are not yet fully implemented");
672671

673672
// All uses of `gate_all!` below this point were added in #65742,
674673
// and subsequently disabled (with the non-early gating readded).

Diff for: ‎compiler/rustc_ast_pretty/src/pprust/state.rs

+6-10
Original file line numberDiff line numberDiff line change
@@ -985,14 +985,6 @@ impl<'a> State<'a> {
985985
}
986986
self.pclose();
987987
}
988-
ast::TyKind::AnonymousStruct(ref fields, ..) => {
989-
self.head("struct");
990-
self.print_record_struct_body(&fields, ty.span);
991-
}
992-
ast::TyKind::AnonymousUnion(ref fields, ..) => {
993-
self.head("union");
994-
self.print_record_struct_body(&fields, ty.span);
995-
}
996988
ast::TyKind::Paren(ref typ) => {
997989
self.popen();
998990
self.print_type(typ);
@@ -1413,7 +1405,12 @@ impl<'a> State<'a> {
14131405
}
14141406
}
14151407

1416-
crate fn print_record_struct_body(&mut self, fields: &[ast::FieldDef], span: rustc_span::Span) {
1408+
crate fn print_record_struct_body(
1409+
&mut self,
1410+
fields: &Vec<ast::FieldDef>,
1411+
span: rustc_span::Span,
1412+
) {
1413+
self.nbsp();
14171414
self.bopen();
14181415
self.hardbreak_if_not_bol();
14191416

@@ -1462,7 +1459,6 @@ impl<'a> State<'a> {
14621459
}
14631460
ast::VariantData::Struct(ref fields, ..) => {
14641461
self.print_where_clause(&generics.where_clause);
1465-
self.nbsp();
14661462
self.print_record_struct_body(fields, span);
14671463
}
14681464
}

Diff for: ‎compiler/rustc_const_eval/src/interpret/intrinsics.rs

+2-7
Original file line numberDiff line numberDiff line change
@@ -62,15 +62,10 @@ crate fn eval_nullary_intrinsic<'tcx>(
6262
ensure_monomorphic_enough(tcx, tp_ty)?;
6363
ConstValue::from_bool(tp_ty.needs_drop(tcx, param_env))
6464
}
65-
sym::min_align_of | sym::pref_align_of => {
65+
sym::pref_align_of => {
6666
// Correctly handles non-monomorphic calls, so there is no need for ensure_monomorphic_enough.
6767
let layout = tcx.layout_of(param_env.and(tp_ty)).map_err(|e| err_inval!(Layout(e)))?;
68-
let n = match name {
69-
sym::pref_align_of => layout.align.pref.bytes(),
70-
sym::min_align_of => layout.align.abi.bytes(),
71-
_ => bug!(),
72-
};
73-
ConstValue::from_machine_usize(n, &tcx)
68+
ConstValue::from_machine_usize(layout.align.pref.bytes(), &tcx)
7469
}
7570
sym::type_id => {
7671
ensure_monomorphic_enough(tcx, tp_ty)?;

Diff for: ‎compiler/rustc_const_eval/src/transform/check_consts/ops.rs

+11-2
Original file line numberDiff line numberDiff line change
@@ -599,12 +599,21 @@ pub mod ty {
599599
}
600600

601601
fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
602-
feature_err(
602+
let mut builder = feature_err(
603603
&ccx.tcx.sess.parse_sess,
604604
sym::const_fn_trait_bound,
605605
span,
606606
"trait bounds other than `Sized` on const fn parameters are unstable",
607-
)
607+
);
608+
609+
match ccx.fn_sig() {
610+
Some(fn_sig) if !fn_sig.span.contains(span) => {
611+
builder.span_label(fn_sig.span, "function declared as const here");
612+
}
613+
_ => {}
614+
}
615+
616+
builder
608617
}
609618
}
610619

Diff for: ‎compiler/rustc_feature/src/active.rs

-3
Original file line numberDiff line numberDiff line change
@@ -638,9 +638,6 @@ declare_features! (
638638
/// Allows specifying the as-needed link modifier
639639
(active, native_link_modifiers_as_needed, "1.53.0", Some(81490), None),
640640

641-
/// Allows unnamed fields of struct and union type
642-
(incomplete, unnamed_fields, "1.53.0", Some(49804), None),
643-
644641
/// Allows qualified paths in struct expressions, struct patterns and tuple struct patterns.
645642
(active, more_qualified_paths, "1.54.0", Some(86935), None),
646643

Diff for: ‎compiler/rustc_interface/src/tests.rs

+1
Original file line numberDiff line numberDiff line change
@@ -754,6 +754,7 @@ fn test_debugging_options_tracking_hash() {
754754
tracked!(profiler_runtime, "abc".to_string());
755755
tracked!(relax_elf_relocations, Some(true));
756756
tracked!(relro_level, Some(RelroLevel::Full));
757+
tracked!(remap_cwd_prefix, Some(PathBuf::from("abc")));
757758
tracked!(simulate_remapped_rust_src_base, Some(PathBuf::from("/rustc/abc")));
758759
tracked!(report_delayed_bugs, true);
759760
tracked!(sanitizer, SanitizerSet::ADDRESS);

Diff for: ‎compiler/rustc_parse/src/parser/item.rs

+16-22
Original file line numberDiff line numberDiff line change
@@ -1247,7 +1247,7 @@ impl<'a> Parser<'a> {
12471247
Ok((class_name, ItemKind::Union(vdata, generics)))
12481248
}
12491249

1250-
pub(super) fn parse_record_struct_body(
1250+
fn parse_record_struct_body(
12511251
&mut self,
12521252
adt_ty: &str,
12531253
) -> PResult<'a, (Vec<FieldDef>, /* recovered */ bool)> {
@@ -1481,28 +1481,22 @@ impl<'a> Parser<'a> {
14811481
fn parse_field_ident(&mut self, adt_ty: &str, lo: Span) -> PResult<'a, Ident> {
14821482
let (ident, is_raw) = self.ident_or_err()?;
14831483
if !is_raw && ident.is_reserved() {
1484-
if ident.name == kw::Underscore {
1485-
self.sess.gated_spans.gate(sym::unnamed_fields, lo);
1484+
let err = if self.check_fn_front_matter(false) {
1485+
// We use `parse_fn` to get a span for the function
1486+
if let Err(mut db) = self.parse_fn(&mut Vec::new(), |_| true, lo) {
1487+
db.delay_as_bug();
1488+
}
1489+
let mut err = self.struct_span_err(
1490+
lo.to(self.prev_token.span),
1491+
&format!("functions are not allowed in {} definitions", adt_ty),
1492+
);
1493+
err.help("unlike in C++, Java, and C#, functions are declared in `impl` blocks");
1494+
err.help("see https://doc.rust-lang.org/book/ch05-03-method-syntax.html for more information");
1495+
err
14861496
} else {
1487-
let err = if self.check_fn_front_matter(false) {
1488-
// We use `parse_fn` to get a span for the function
1489-
if let Err(mut db) = self.parse_fn(&mut Vec::new(), |_| true, lo) {
1490-
db.delay_as_bug();
1491-
}
1492-
let mut err = self.struct_span_err(
1493-
lo.to(self.prev_token.span),
1494-
&format!("functions are not allowed in {} definitions", adt_ty),
1495-
);
1496-
err.help(
1497-
"unlike in C++, Java, and C#, functions are declared in `impl` blocks",
1498-
);
1499-
err.help("see https://doc.rust-lang.org/book/ch05-03-method-syntax.html for more information");
1500-
err
1501-
} else {
1502-
self.expected_ident_found()
1503-
};
1504-
return Err(err);
1505-
}
1497+
self.expected_ident_found()
1498+
};
1499+
return Err(err);
15061500
}
15071501
self.bump();
15081502
Ok(ident)

Diff for: ‎compiler/rustc_parse/src/parser/stmt.rs

+14-11
Original file line numberDiff line numberDiff line change
@@ -155,17 +155,20 @@ impl<'a> Parser<'a> {
155155

156156
let mac = MacCall { path, args, prior_type_ascription: self.last_type_ascription };
157157

158-
let kind = if delim == token::Brace || self.token == token::Semi || self.token == token::Eof
159-
{
160-
StmtKind::MacCall(P(MacCallStmt { mac, style, attrs, tokens: None }))
161-
} else {
162-
// Since none of the above applied, this is an expression statement macro.
163-
let e = self.mk_expr(lo.to(hi), ExprKind::MacCall(mac), AttrVec::new());
164-
let e = self.maybe_recover_from_bad_qpath(e, true)?;
165-
let e = self.parse_dot_or_call_expr_with(e, lo, attrs.into())?;
166-
let e = self.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(e))?;
167-
StmtKind::Expr(e)
168-
};
158+
let kind =
159+
if (delim == token::Brace && self.token != token::Dot && self.token != token::Question)
160+
|| self.token == token::Semi
161+
|| self.token == token::Eof
162+
{
163+
StmtKind::MacCall(P(MacCallStmt { mac, style, attrs, tokens: None }))
164+
} else {
165+
// Since none of the above applied, this is an expression statement macro.
166+
let e = self.mk_expr(lo.to(hi), ExprKind::MacCall(mac), AttrVec::new());
167+
let e = self.maybe_recover_from_bad_qpath(e, true)?;
168+
let e = self.parse_dot_or_call_expr_with(e, lo, attrs.into())?;
169+
let e = self.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(e))?;
170+
StmtKind::Expr(e)
171+
};
169172
Ok(self.mk_stmt(lo.to(hi), kind))
170173
}
171174

Diff for: ‎compiler/rustc_parse/src/parser/ty.rs

-13
Original file line numberDiff line numberDiff line change
@@ -226,19 +226,6 @@ impl<'a> Parser<'a> {
226226
}
227227
} else if self.eat_keyword(kw::Impl) {
228228
self.parse_impl_ty(&mut impl_dyn_multi)?
229-
} else if self.token.is_keyword(kw::Union)
230-
&& self.look_ahead(1, |t| t == &token::OpenDelim(token::Brace))
231-
{
232-
self.bump();
233-
let (fields, recovered) = self.parse_record_struct_body("union")?;
234-
let span = lo.to(self.prev_token.span);
235-
self.sess.gated_spans.gate(sym::unnamed_fields, span);
236-
TyKind::AnonymousUnion(fields, recovered)
237-
} else if self.eat_keyword(kw::Struct) {
238-
let (fields, recovered) = self.parse_record_struct_body("struct")?;
239-
let span = lo.to(self.prev_token.span);
240-
self.sess.gated_spans.gate(sym::unnamed_fields, span);
241-
TyKind::AnonymousStruct(fields, recovered)
242229
} else if self.is_explicit_dyn_type() {
243230
self.parse_dyn_ty(&mut impl_dyn_multi)?
244231
} else if self.eat_lt() {

0 commit comments

Comments
 (0)