bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #88992 - Manishearth:rollup-k9hijii, r=Manishearth

Browse source 
Rollup of 8 pull requests

Successful merges:

 - #87320 (Introduce -Z remap-cwd-prefix switch)
 - #88690 (Accept `m!{ .. }.method()` and `m!{ .. }?` statements. )
 - #88775 (Revert anon union parsing)
 - #88841 (feat(rustc_typeck): suggest removing bad parens in `(recv.method)()`)
 - #88907 (Highlight the `const fn` if error happened because of a bound on the impl block)
 - #88915 (`Wrapping<T>` has the same layout and ABI as `T`)
 - #88933 (Remove implementation of `min_align_of` intrinsic)
 - #88951 (Update books)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2021-09-16 02:00:08 +00:00
commit 34327f6eee
40 changed files with 275 additions and 628 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_ast/src/ast.rs
View file

@ -1902,10 +1902,6 @@ pub enum TyKind {
Never,
/// A tuple (`(A, B, C, D,...)`).
Tup(Vec<P<Ty>>),
/// An anonymous struct type i.e. `struct { foo: Type }`
AnonymousStruct(Vec<FieldDef>, bool),
/// An anonymous union type i.e. `union { bar: Type }`
AnonymousUnion(Vec<FieldDef>, bool),
/// A path (`module::module::...::Type`), optionally
/// "qualified", e.g., `<Vec<T> as SomeTrait>::SomeType`.
///

3
compiler/rustc_ast/src/mut_visit.rs
View file

@ -484,9 +484,6 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
visit_vec(bounds, |bound| vis.visit_param_bound(bound));
}
TyKind::MacCall(mac) => vis.visit_mac_call(mac),
TyKind::AnonymousStruct(fields, ..) | TyKind::AnonymousUnion(fields, ..) => {
fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
}
}
vis.visit_span(span);
visit_lazy_tts(tokens, vis);

3
compiler/rustc_ast/src/visit.rs
View file

@ -407,9 +407,6 @@ pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) {
TyKind::Typeof(ref expression) => visitor.visit_anon_const(expression),
TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err => {}
TyKind::MacCall(ref mac) => visitor.visit_mac_call(mac),
TyKind::AnonymousStruct(ref fields, ..) | TyKind::AnonymousUnion(ref fields, ..) => {
walk_list!(visitor, visit_field_def, fields)
}
TyKind::Never | TyKind::CVarArgs => {}
}
}

5
compiler/rustc_ast_lowering/src/item.rs
View file

@ -748,10 +748,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
}
pub(super) fn lower_field_def(
&mut self,
(index, f): (usize, &FieldDef),
) -> hir::FieldDef<'hir> {
fn lower_field_def(&mut self, (index, f): (usize, &FieldDef)) -> hir::FieldDef<'hir> {
let ty = if let TyKind::Path(ref qself, ref path) = f.ty.kind {
let t = self.lower_path_ty(
&f.ty,

9
compiler/rustc_ast_lowering/src/lib.rs
View file

@ -1301,15 +1301,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let kind = match t.kind {
TyKind::Infer => hir::TyKind::Infer,
TyKind::Err => hir::TyKind::Err,
// FIXME(unnamed_fields): IMPLEMENTATION IN PROGRESS
TyKind::AnonymousStruct(ref _fields, _recovered) => {
self.sess.struct_span_err(t.span, "anonymous structs are unimplemented").emit();
hir::TyKind::Err
}
TyKind::AnonymousUnion(ref _fields, _recovered) => {
self.sess.struct_span_err(t.span, "anonymous unions are unimplemented").emit();
hir::TyKind::Err
}
TyKind::Slice(ref ty) => hir::TyKind::Slice(self.lower_ty(ty, itctx)),
TyKind::Ptr(ref mt) => hir::TyKind::Ptr(self.lower_mt(mt, itctx)),
TyKind::Rptr(ref region, ref mt) => {

68
compiler/rustc_ast_passes/src/ast_validation.rs
View file

@ -193,11 +193,6 @@ impl<'a> AstValidator<'a> {
}
}
}
TyKind::AnonymousStruct(ref fields, ..) | TyKind::AnonymousUnion(ref fields, ..) => {
self.with_banned_assoc_ty_bound(|this| {
walk_list!(this, visit_struct_field_def, fields)
});
}
_ => visit::walk_ty(self, t),
}
}
@ -205,7 +200,6 @@ impl<'a> AstValidator<'a> {
fn visit_struct_field_def(&mut self, field: &'a FieldDef) {
if let Some(ident) = field.ident {
if ident.name == kw::Underscore {
self.check_anonymous_field(field);
self.visit_vis(&field.vis);
self.visit_ident(ident);
self.visit_ty_common(&field.ty);
@ -251,66 +245,6 @@ impl<'a> AstValidator<'a> {
err.emit();
}
fn check_anonymous_field(&self, field: &FieldDef) {
let FieldDef { ty, .. } = field;
match &ty.kind {
TyKind::AnonymousStruct(..) | TyKind::AnonymousUnion(..) => {
// We already checked for `kw::Underscore` before calling this function,
// so skip the check
}
TyKind::Path(..) => {
// If the anonymous field contains a Path as type, we can't determine
// if the path is a valid struct or union, so skip the check
}
_ => {
let msg = "unnamed fields can only have struct or union types";
let label = "not a struct or union";
self.err_handler()
.struct_span_err(field.span, msg)
.span_label(ty.span, label)
.emit();
}
}
}
fn deny_anonymous_struct(&self, ty: &Ty) {
match &ty.kind {
TyKind::AnonymousStruct(..) => {
self.err_handler()
.struct_span_err(
ty.span,
"anonymous structs are not allowed outside of unnamed struct or union fields",
)
.span_label(ty.span, "anonymous struct declared here")
.emit();
}
TyKind::AnonymousUnion(..) => {
self.err_handler()
.struct_span_err(
ty.span,
"anonymous unions are not allowed outside of unnamed struct or union fields",
)
.span_label(ty.span, "anonymous union declared here")
.emit();
}
_ => {}
}
}
fn deny_anonymous_field(&self, field: &FieldDef) {
if let Some(ident) = field.ident {
if ident.name == kw::Underscore {
self.err_handler()
.struct_span_err(
field.span,
"anonymous fields are not allowed outside of structs or unions",
)
.span_label(ident.span, "anonymous field declared here")
.emit()
}
}
}
fn check_decl_no_pat(decl: &FnDecl, mut report_err: impl FnMut(Span, Option<Ident>, bool)) {
for Param { pat, .. } in &decl.inputs {
match pat.kind {
@ -1081,7 +1015,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
fn visit_ty(&mut self, ty: &'a Ty) {
self.visit_ty_common(ty);
self.deny_anonymous_struct(ty);
self.walk_ty(ty)
}
@ -1096,7 +1029,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
}
fn visit_field_def(&mut self, s: &'a FieldDef) {
self.deny_anonymous_field(s);
visit::walk_field_def(self, s)
}

1
compiler/rustc_ast_passes/src/feature_gate.rs
View file

@ -668,7 +668,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session) {
// involved, so we only emit errors where there are no other parsing errors.
gate_all!(destructuring_assignment, "destructuring assignments are unstable");
}
gate_all!(unnamed_fields, "unnamed fields are not yet fully implemented");
// All uses of `gate_all!` below this point were added in #65742,
// and subsequently disabled (with the non-early gating readded).

16
compiler/rustc_ast_pretty/src/pprust/state.rs
View file

@ -985,14 +985,6 @@ impl<'a> State<'a> {
}
self.pclose();
}
ast::TyKind::AnonymousStruct(ref fields, ..) => {
self.head("struct");
self.print_record_struct_body(&fields, ty.span);
}
ast::TyKind::AnonymousUnion(ref fields, ..) => {
self.head("union");
self.print_record_struct_body(&fields, ty.span);
}
ast::TyKind::Paren(ref typ) => {
self.popen();
self.print_type(typ);
@ -1413,7 +1405,12 @@ impl<'a> State<'a> {
}
}
crate fn print_record_struct_body(&mut self, fields: &[ast::FieldDef], span: rustc_span::Span) {
crate fn print_record_struct_body(
&mut self,
fields: &Vec<ast::FieldDef>,
span: rustc_span::Span,
) {
self.nbsp();
self.bopen();
self.hardbreak_if_not_bol();
@ -1462,7 +1459,6 @@ impl<'a> State<'a> {
}
ast::VariantData::Struct(ref fields, ..) => {
self.print_where_clause(&generics.where_clause);
self.nbsp();
self.print_record_struct_body(fields, span);
}
}

9
compiler/rustc_const_eval/src/interpret/intrinsics.rs
View file

@ -62,15 +62,10 @@ crate fn eval_nullary_intrinsic<'tcx>(
ensure_monomorphic_enough(tcx, tp_ty)?;
ConstValue::from_bool(tp_ty.needs_drop(tcx, param_env))
}
sym::min_align_of | sym::pref_align_of => {
sym::pref_align_of => {
// Correctly handles non-monomorphic calls, so there is no need for ensure_monomorphic_enough.
let layout = tcx.layout_of(param_env.and(tp_ty)).map_err(|e| err_inval!(Layout(e)))?;
let n = match name {
sym::pref_align_of => layout.align.pref.bytes(),
sym::min_align_of => layout.align.abi.bytes(),
_ => bug!(),
};
ConstValue::from_machine_usize(n, &tcx)
ConstValue::from_machine_usize(layout.align.pref.bytes(), &tcx)
}
sym::type_id => {
ensure_monomorphic_enough(tcx, tp_ty)?;

13
compiler/rustc_const_eval/src/transform/check_consts/ops.rs
View file

@ -599,12 +599,21 @@ pub mod ty {
}
fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
feature_err(
let mut builder = feature_err(
&ccx.tcx.sess.parse_sess,
sym::const_fn_trait_bound,
span,
"trait bounds other than `Sized` on const fn parameters are unstable",
)
);
match ccx.fn_sig() {
Some(fn_sig) if !fn_sig.span.contains(span) => {
builder.span_label(fn_sig.span, "function declared as const here");
}
_ => {}
}
builder
}
}

3
compiler/rustc_feature/src/active.rs
View file

@ -638,9 +638,6 @@ declare_features! (
/// Allows specifying the as-needed link modifier
(active, native_link_modifiers_as_needed, "1.53.0", Some(81490), None),
/// Allows unnamed fields of struct and union type
(incomplete, unnamed_fields, "1.53.0", Some(49804), None),
/// Allows qualified paths in struct expressions, struct patterns and tuple struct patterns.
(active, more_qualified_paths, "1.54.0", Some(86935), None),

1
compiler/rustc_interface/src/tests.rs
View file

@ -754,6 +754,7 @@ fn test_debugging_options_tracking_hash() {
tracked!(profiler_runtime, "abc".to_string());
tracked!(relax_elf_relocations, Some(true));
tracked!(relro_level, Some(RelroLevel::Full));
tracked!(remap_cwd_prefix, Some(PathBuf::from("abc")));
tracked!(simulate_remapped_rust_src_base, Some(PathBuf::from("/rustc/abc")));
tracked!(report_delayed_bugs, true);
tracked!(sanitizer, SanitizerSet::ADDRESS);

38
compiler/rustc_parse/src/parser/item.rs
View file

@ -1247,7 +1247,7 @@ impl<'a> Parser<'a> {
Ok((class_name, ItemKind::Union(vdata, generics)))
}
pub(super) fn parse_record_struct_body(
fn parse_record_struct_body(
&mut self,
adt_ty: &str,
) -> PResult<'a, (Vec<FieldDef>, /* recovered */ bool)> {
@ -1481,28 +1481,22 @@ impl<'a> Parser<'a> {
fn parse_field_ident(&mut self, adt_ty: &str, lo: Span) -> PResult<'a, Ident> {
let (ident, is_raw) = self.ident_or_err()?;
if !is_raw && ident.is_reserved() {
if ident.name == kw::Underscore {
self.sess.gated_spans.gate(sym::unnamed_fields, lo);
let err = if self.check_fn_front_matter(false) {
// We use `parse_fn` to get a span for the function
if let Err(mut db) = self.parse_fn(&mut Vec::new(), |_| true, lo) {
db.delay_as_bug();
}
let mut err = self.struct_span_err(
lo.to(self.prev_token.span),
&format!("functions are not allowed in {} definitions", adt_ty),
);
err.help("unlike in C++, Java, and C#, functions are declared in `impl` blocks");
err.help("see https://doc.rust-lang.org/book/ch05-03-method-syntax.html for more information");
err
} else {
let err = if self.check_fn_front_matter(false) {
// We use `parse_fn` to get a span for the function
if let Err(mut db) = self.parse_fn(&mut Vec::new(), |_| true, lo) {
db.delay_as_bug();
}
let mut err = self.struct_span_err(
lo.to(self.prev_token.span),
&format!("functions are not allowed in {} definitions", adt_ty),
);
err.help(
"unlike in C++, Java, and C#, functions are declared in `impl` blocks",
);
err.help("see https://doc.rust-lang.org/book/ch05-03-method-syntax.html for more information");
err
} else {
self.expected_ident_found()
};
return Err(err);
}
self.expected_ident_found()
};
return Err(err);
}
self.bump();
Ok(ident)

25
compiler/rustc_parse/src/parser/stmt.rs
View file

@ -155,17 +155,20 @@ impl<'a> Parser<'a> {
let mac = MacCall { path, args, prior_type_ascription: self.last_type_ascription };
let kind = if delim == token::Brace || self.token == token::Semi || self.token == token::Eof
{
StmtKind::MacCall(P(MacCallStmt { mac, style, attrs, tokens: None }))
} else {
// Since none of the above applied, this is an expression statement macro.
let e = self.mk_expr(lo.to(hi), ExprKind::MacCall(mac), AttrVec::new());
let e = self.maybe_recover_from_bad_qpath(e, true)?;
let e = self.parse_dot_or_call_expr_with(e, lo, attrs.into())?;
let e = self.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(e))?;
StmtKind::Expr(e)
};
let kind =
if (delim == token::Brace && self.token != token::Dot && self.token != token::Question)
|| self.token == token::Semi
|| self.token == token::Eof
{
StmtKind::MacCall(P(MacCallStmt { mac, style, attrs, tokens: None }))
} else {
// Since none of the above applied, this is an expression statement macro.
let e = self.mk_expr(lo.to(hi), ExprKind::MacCall(mac), AttrVec::new());
let e = self.maybe_recover_from_bad_qpath(e, true)?;
let e = self.parse_dot_or_call_expr_with(e, lo, attrs.into())?;
let e = self.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(e))?;
StmtKind::Expr(e)
};
Ok(self.mk_stmt(lo.to(hi), kind))
}

13
compiler/rustc_parse/src/parser/ty.rs
View file

@ -226,19 +226,6 @@ impl<'a> Parser<'a> {
}
} else if self.eat_keyword(kw::Impl) {
self.parse_impl_ty(&mut impl_dyn_multi)?
} else if self.token.is_keyword(kw::Union)
&& self.look_ahead(1, |t| t == &token::OpenDelim(token::Brace))
{
self.bump();
let (fields, recovered) = self.parse_record_struct_body("union")?;
let span = lo.to(self.prev_token.span);
self.sess.gated_spans.gate(sym::unnamed_fields, span);
TyKind::AnonymousUnion(fields, recovered)
} else if self.eat_keyword(kw::Struct) {
let (fields, recovered) = self.parse_record_struct_body("struct")?;
let span = lo.to(self.prev_token.span);
self.sess.gated_spans.gate(sym::unnamed_fields, span);
TyKind::AnonymousStruct(fields, recovered)
} else if self.is_explicit_dyn_type() {
self.parse_dyn_ty(&mut impl_dyn_multi)?
} else if self.eat_lt() {

15
compiler/rustc_session/src/config.rs
View file

@ -1920,9 +1920,10 @@ fn parse_extern_dep_specs(
fn parse_remap_path_prefix(
matches: &getopts::Matches,
debugging_opts: &DebuggingOptions,
error_format: ErrorOutputType,
) -> Vec<(PathBuf, PathBuf)> {
matches
let mut mapping: Vec<(PathBuf, PathBuf)> = matches
.opt_strs("remap-path-prefix")
.into_iter()
.map(|remap| match remap.rsplit_once('=') {
@ -1932,7 +1933,15 @@ fn parse_remap_path_prefix(
),
Some((from, to)) => (PathBuf::from(from), PathBuf::from(to)),
})
.collect()
.collect();
match &debugging_opts.remap_cwd_prefix {
Some(to) => match std::env::current_dir() {
Ok(cwd) => mapping.push((cwd, to.clone())),
Err(_) => (),
},
None => (),
};
mapping
}
pub fn build_session_options(matches: &getopts::Matches) -> Options {
@ -2077,7 +2086,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
let crate_name = matches.opt_str("crate-name");
let remap_path_prefix = parse_remap_path_prefix(matches, error_format);
let remap_path_prefix = parse_remap_path_prefix(matches, &debugging_opts, error_format);
let pretty = parse_pretty(&debugging_opts, error_format);

2
compiler/rustc_session/src/options.rs
View file

@ -1250,6 +1250,8 @@ options! {
"whether ELF relocations can be relaxed"),
relro_level: Option<RelroLevel> = (None, parse_relro_level, [TRACKED],
"choose which RELRO level to use"),
remap_cwd_prefix: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
"remap paths under the current working directory to this path prefix"),
simulate_remapped_rust_src_base: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
"simulate the effect of remap-debuginfo = true at bootstrapping by remapping path \
to rust's source base directory. only meant for testing purposes"),

1
compiler/rustc_span/src/symbol.rs
View file

@ -1359,7 +1359,6 @@ symbols! {
unix,
unlikely,
unmarked_api,
unnamed_fields,
unpin,
unreachable,
unreachable_code,

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

@ -1842,7 +1842,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expr_t
);
err.span_label(field.span, "method, not a field");
if !self.expr_in_place(expr.hir_id) {
let expr_is_call =
if let hir::Node::Expr(hir::Expr { kind: ExprKind::Call(callee, _args), .. }) =
self.tcx.hir().get(self.tcx.hir().get_parent_node(expr.hir_id))
{
expr.hir_id == callee.hir_id
} else {
false
};
let expr_snippet =
self.tcx.sess.source_map().span_to_snippet(expr.span).unwrap_or(String::new());
if expr_is_call && expr_snippet.starts_with("(") && expr_snippet.ends_with(")") {
let after_open = expr.span.lo() + rustc_span::BytePos(1);
let before_close = expr.span.hi() - rustc_span::BytePos(1);
err.multipart_suggestion(
"remove wrapping parentheses to call the method",
vec![
(expr.span.with_hi(after_open), String::new()),
(expr.span.with_lo(before_close), String::new()),
],
Applicability::MachineApplicable,
);
} else if !self.expr_in_place(expr.hir_id) {
self.suggest_method_call(
&mut err,
"use parentheses to call the method",

4
library/core/src/num/wrapping.rs
View file

@ -32,6 +32,10 @@ use crate::ops::{Shl, ShlAssign, Shr, ShrAssign, Sub, SubAssign};
///
/// assert_eq!(u32::MAX, (zero - one).0);
/// ```
///
/// # Layout
///
/// `Wrapping<T>` is guaranteed to have the same layout and ABI as `T`.
#[stable(feature = "rust1", since = "1.0.0")]
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default, Hash)]
#[repr(transparent)]

2
src/doc/embedded-book

@ -1 +1 @@
Subproject commit c3a51e23859554369e6bbb5128dcef0e4f159fb5
Subproject commit 4c76da9ddb4650203c129fceffdea95a3466c205

2
src/doc/rust-by-example

@ -1 +1 @@
Subproject commit 04f489c889235fe3b6dfe678ae5410d07deda958
Subproject commit 9d4132b56c4999cd3ce1aeca5f1b2f2cb0d11c24

2
src/doc/rustc-dev-guide

@ -1 +1 @@
Subproject commit 95f1acf9a39d6f402f654e917e2c1dfdb779c5fc
Subproject commit 9198465b6ca8bed669df0cbb67c0e6d0b140803c

24
src/doc/unstable-book/src/compiler-flags/remap-cwd-prefix.md Normal file
View file

@ -0,0 +1,24 @@
# `remap-cwd-prefix`
The tracking issue for this feature is: [#87325](https://github.com/rust-lang/rust/issues/87325).
------------------------
This flag will rewrite absolute paths under the current working directory,
replacing the current working directory prefix with a specified value.
The given value may be absolute or relative, or empty. This switch takes
precidence over `--remap-path-prefix` in case they would both match a given
path.
This flag helps to produce deterministic output, by removing the current working
directory from build output, while allowing the command line to be universally
reproducible, such that the same execution will work on all machines, regardless
of build environment.
## Example
```sh
# This would produce an absolute path to main.rs in build outputs of
# "./main.rs".
rustc -Z remap-cwd-prefix=. main.rs
```

24
src/test/pretty/anonymous-types.rs
View file

@ -1,24 +0,0 @@
// Test for issue 85480
// Pretty print anonymous struct and union types
// pp-exact
// pretty-compare-only
struct Foo {
_: union {
_: struct {
a: u8,
b: u16,
},
c: u32,
},
d: u64,
e: f32,
}
type A =
struct {
field: u8,
};
fn main() { }

65
src/test/run-make-fulldeps/reproducible-build/Makefile
View file

@ -9,9 +9,19 @@ all: \
opt \
link_paths \
remap_paths \
different_source_dirs \
different_source_dirs_rlib \
remap_cwd_rlib \
remap_cwd_to_empty \
extern_flags
# TODO: Builds of `bin` crate types are not deterministic with debuginfo=2 on
# Windows.
# See: https://github.com/rust-lang/rust/pull/87320#issuecomment-920105533
# Issue: https://github.com/rust-lang/rust/issues/88982
#
# different_source_dirs_bin \
# remap_cwd_bin \
smoke:
rm -rf $(TMPDIR) && mkdir $(TMPDIR)
$(RUSTC) linker.rs -O
@ -52,7 +62,19 @@ remap_paths:
$(RUSTC) reproducible-build.rs --crate-type rlib --remap-path-prefix=/b=/c
cmp "$(TMPDIR)/libreproducible_build.rlib" "$(TMPDIR)/libfoo.rlib" || exit 1
different_source_dirs:
different_source_dirs_bin:
rm -rf $(TMPDIR) && mkdir $(TMPDIR)
$(RUSTC) reproducible-build-aux.rs
mkdir $(TMPDIR)/test
cp reproducible-build.rs $(TMPDIR)/test
$(RUSTC) reproducible-build.rs --crate-type bin --remap-path-prefix=$$PWD=/b
cp $(TMPDIR)/reproducible-build $(TMPDIR)/foo
(cd $(TMPDIR)/test && $(RUSTC) reproducible-build.rs \
--remap-path-prefix=$(TMPDIR)/test=/b \
--crate-type bin)
cmp "$(TMPDIR)/reproducible-build" "$(TMPDIR)/foo" || exit 1
different_source_dirs_rlib:
rm -rf $(TMPDIR) && mkdir $(TMPDIR)
$(RUSTC) reproducible-build-aux.rs
mkdir $(TMPDIR)/test
@ -64,6 +86,45 @@ different_source_dirs:
--crate-type rlib)
cmp "$(TMPDIR)/libreproducible_build.rlib" "$(TMPDIR)/libfoo.rlib" || exit 1
remap_cwd_bin:
rm -rf $(TMPDIR) && mkdir $(TMPDIR)
$(RUSTC) reproducible-build-aux.rs
mkdir $(TMPDIR)/test
cp reproducible-build.rs $(TMPDIR)/test
$(RUSTC) reproducible-build.rs --crate-type bin -C debuginfo=2 \
-Z remap-cwd-prefix=.
cp $(TMPDIR)/reproducible-build $(TMPDIR)/first
(cd $(TMPDIR)/test && \
$(RUSTC) reproducible-build.rs --crate-type bin -C debuginfo=2 \
-Z remap-cwd-prefix=.)
cmp "$(TMPDIR)/first" "$(TMPDIR)/reproducible-build" || exit 1
remap_cwd_rlib:
rm -rf $(TMPDIR) && mkdir $(TMPDIR)
$(RUSTC) reproducible-build-aux.rs
mkdir $(TMPDIR)/test
cp reproducible-build.rs $(TMPDIR)/test
$(RUSTC) reproducible-build.rs --crate-type rlib -C debuginfo=2 \
-Z remap-cwd-prefix=.
cp $(TMPDIR)/libreproducible_build.rlib $(TMPDIR)/libfirst.rlib
(cd $(TMPDIR)/test && \
$(RUSTC) reproducible-build.rs --crate-type rlib -C debuginfo=2 \
-Z remap-cwd-prefix=.)
cmp "$(TMPDIR)/libfirst.rlib" "$(TMPDIR)/libreproducible_build.rlib" || exit 1
remap_cwd_to_empty:
rm -rf $(TMPDIR) && mkdir $(TMPDIR)
$(RUSTC) reproducible-build-aux.rs
mkdir $(TMPDIR)/test
cp reproducible-build.rs $(TMPDIR)/test
$(RUSTC) reproducible-build.rs --crate-type rlib -C debuginfo=2 \
-Z remap-cwd-prefix=
cp $(TMPDIR)/libreproducible_build.rlib $(TMPDIR)/libfirst.rlib
(cd $(TMPDIR)/test && \
$(RUSTC) reproducible-build.rs --crate-type rlib -C debuginfo=2 \
-Z remap-cwd-prefix=)
cmp "$(TMPDIR)/libfirst.rlib" "$(TMPDIR)/libreproducible_build.rlib" || exit 1
extern_flags:
rm -rf $(TMPDIR) && mkdir $(TMPDIR)
$(RUSTC) reproducible-build-aux.rs

21
src/test/ui/consts/min_const_fn/min_const_fn.stderr
View file

@ -214,6 +214,9 @@ error[E0658]: trait bounds other than `Sized` on const fn parameters are unstabl
|
LL | impl<T: std::fmt::Debug> Foo<T> {
| ^
LL |
LL | const fn foo(&self) {}
| ------------------- function declared as const here
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn_trait_bound)]` to the crate attributes to enable
@ -223,6 +226,9 @@ error[E0658]: trait bounds other than `Sized` on const fn parameters are unstabl
|
LL | impl<T: std::fmt::Debug + Sized> Foo<T> {
| ^
LL |
LL | const fn foo2(&self) {}
| -------------------- function declared as const here
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn_trait_bound)]` to the crate attributes to enable
@ -232,6 +238,9 @@ error[E0658]: trait bounds other than `Sized` on const fn parameters are unstabl
|
LL | impl<T: Sync + Sized> Foo<T> {
| ^
LL |
LL | const fn foo3(&self) {}
| -------------------- function declared as const here
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn_trait_bound)]` to the crate attributes to enable
@ -292,7 +301,9 @@ error[E0658]: trait bounds other than `Sized` on const fn parameters are unstabl
--> $DIR/min_const_fn.rs:139:41
|
LL | const fn really_no_traits_i_mean_it() { (&() as &dyn std::fmt::Debug, ()).1 }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ------------------------------------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| function declared as const here
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn_trait_bound)]` to the crate attributes to enable
@ -301,7 +312,9 @@ error[E0658]: trait bounds other than `Sized` on const fn parameters are unstabl
--> $DIR/min_const_fn.rs:139:42
|
LL | const fn really_no_traits_i_mean_it() { (&() as &dyn std::fmt::Debug, ()).1 }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ------------------------------------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| function declared as const here
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn_trait_bound)]` to the crate attributes to enable
@ -310,7 +323,9 @@ error[E0658]: trait bounds other than `Sized` on const fn parameters are unstabl
--> $DIR/min_const_fn.rs:139:42
|
LL | const fn really_no_traits_i_mean_it() { (&() as &dyn std::fmt::Debug, ()).1 }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ------------------------------------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| function declared as const here
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn_trait_bound)]` to the crate attributes to enable

6
src/test/ui/consts/min_const_fn/min_const_fn_dyn.stderr
View file

@ -1,6 +1,8 @@
error[E0658]: trait bounds other than `Sized` on const fn parameters are unstable
--> $DIR/min_const_fn_dyn.rs:9:5
|
LL | const fn no_inner_dyn_trait2(x: Hide) {
| ------------------------------------- function declared as const here
LL | x.0.field;
| ^^^^^^^^^
|
@ -11,7 +13,9 @@ error[E0658]: trait bounds other than `Sized` on const fn parameters are unstabl
--> $DIR/min_const_fn_dyn.rs:12:66
|
LL | const fn no_inner_dyn_trait_ret() -> Hide { Hide(HasDyn { field: &0 }) }
| ^^
| ----------------------------------------- ^^
| |
| function declared as const here
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn_trait_bound)]` to the crate attributes to enable

27
src/test/ui/feature-gates/feature-gate-unnamed_fields.rs
View file

@ -1,27 +0,0 @@
struct Foo {
foo: u8,
_: union { //~ ERROR unnamed fields are not yet fully implemented [E0658]
//~^ ERROR unnamed fields are not yet fully implemented [E0658]
//~| ERROR anonymous unions are unimplemented
bar: u8,
baz: u16
}
}
union Bar {
foobar: u8,
_: struct { //~ ERROR unnamed fields are not yet fully implemented [E0658]
//~^ ERROR unnamed fields are not yet fully implemented [E0658]
//~| ERROR anonymous structs are unimplemented
//~| ERROR unions may not contain fields that need dropping [E0740]
foobaz: u8,
barbaz: u16
}
}
struct S;
struct Baz {
_: S //~ ERROR unnamed fields are not yet fully implemented [E0658]
}
fn main(){}

111
src/test/ui/feature-gates/feature-gate-unnamed_fields.stderr
View file

@ -1,111 +0,0 @@
error[E0658]: unnamed fields are not yet fully implemented
--> $DIR/feature-gate-unnamed_fields.rs:3:5
|
LL | _: union {
| ^
|
= note: see issue #49804 <https://github.com/rust-lang/rust/issues/49804> for more information
= help: add `#![feature(unnamed_fields)]` to the crate attributes to enable
error[E0658]: unnamed fields are not yet fully implemented
--> $DIR/feature-gate-unnamed_fields.rs:3:8
|
LL | _: union {
| ________^
LL | |
LL | |
LL | | bar: u8,
LL | | baz: u16
LL | | }
| |_____^
|
= note: see issue #49804 <https://github.com/rust-lang/rust/issues/49804> for more information
= help: add `#![feature(unnamed_fields)]` to the crate attributes to enable
error[E0658]: unnamed fields are not yet fully implemented
--> $DIR/feature-gate-unnamed_fields.rs:13:5
|
LL | _: struct {
| ^
|
= note: see issue #49804 <https://github.com/rust-lang/rust/issues/49804> for more information
= help: add `#![feature(unnamed_fields)]` to the crate attributes to enable
error[E0658]: unnamed fields are not yet fully implemented
--> $DIR/feature-gate-unnamed_fields.rs:13:8
|
LL | _: struct {
| ________^
LL | |
LL | |
LL | |
LL | | foobaz: u8,
LL | | barbaz: u16
LL | | }
| |_____^
|
= note: see issue #49804 <https://github.com/rust-lang/rust/issues/49804> for more information
= help: add `#![feature(unnamed_fields)]` to the crate attributes to enable
error[E0658]: unnamed fields are not yet fully implemented
--> $DIR/feature-gate-unnamed_fields.rs:24:5
|
LL | _: S
| ^
|
= note: see issue #49804 <https://github.com/rust-lang/rust/issues/49804> for more information
= help: add `#![feature(unnamed_fields)]` to the crate attributes to enable
error: anonymous unions are unimplemented
--> $DIR/feature-gate-unnamed_fields.rs:3:8
|
LL | _: union {
| ________^
LL | |
LL | |
LL | | bar: u8,
LL | | baz: u16
LL | | }
| |_____^
error: anonymous structs are unimplemented
--> $DIR/feature-gate-unnamed_fields.rs:13:8
|
LL | _: struct {
| ________^
LL | |
LL | |
LL | |
LL | | foobaz: u8,
LL | | barbaz: u16
LL | | }
| |_____^
error[E0740]: unions may not contain fields that need dropping
--> $DIR/feature-gate-unnamed_fields.rs:13:5
|
LL | / _: struct {
LL | |
LL | |
LL | |
LL | | foobaz: u8,
LL | | barbaz: u16
LL | | }
| |_____^
|
note: `std::mem::ManuallyDrop` can be used to wrap the type
--> $DIR/feature-gate-unnamed_fields.rs:13:5
|
LL | / _: struct {
LL | |
LL | |
LL | |
LL | | foobaz: u8,
LL | | barbaz: u16
LL | | }
| |_____^
error: aborting due to 8 previous errors
Some errors have detailed explanations: E0658, E0740.
For more information about an error, try `rustc --explain E0658`.

15
src/test/ui/parser/issue-88583-union-as-ident.rs Normal file
View file

@ -0,0 +1,15 @@
// check-pass
#![allow(non_camel_case_types)]
struct union;
impl union {
pub fn new() -> Self {
union { }
}
}
fn main() {
let _u = union::new();
}

11
src/test/ui/parser/macro-braces-dot-question.rs Normal file
View file

@ -0,0 +1,11 @@
// check-pass
use std::io::Write;
fn main() -> Result<(), std::io::Error> {
vec! { 1, 2, 3 }.len();
write! { vec![], "" }?;
println!{""}
[0]; // separate statement, not indexing into the result of println.
Ok(())
}

9
src/test/ui/typeck/issue-88803-call-expr-method.fixed Normal file
View file

@ -0,0 +1,9 @@
// run-rustfix
fn main() {
let a = Some(42);
println!(
"The value is {}.",
a.unwrap() //~ERROR [E0615]
);
}

9
src/test/ui/typeck/issue-88803-call-expr-method.rs Normal file
View file

@ -0,0 +1,9 @@
// run-rustfix
fn main() {
let a = Some(42);
println!(
"The value is {}.",
(a.unwrap)() //~ERROR [E0615]
);
}

15
src/test/ui/typeck/issue-88803-call-expr-method.stderr Normal file
View file

@ -0,0 +1,15 @@
error[E0615]: attempted to take value of method `unwrap` on type `Option<{integer}>`
--> $DIR/issue-88803-call-expr-method.rs:7:12
|
LL | (a.unwrap)()
| ^^^^^^ method, not a field
|
help: remove wrapping parentheses to call the method
|
LL - (a.unwrap)()
LL + a.unwrap()
|
error: aborting due to previous error
For more information about this error, try `rustc --explain E0615`.

52
src/test/ui/unnamed_fields/restrict_anonymous.rs
View file

@ -1,52 +0,0 @@
#![allow(incomplete_features)]
#![feature(unnamed_fields)]
fn f() -> struct { field: u8 } {} //~ ERROR anonymous structs are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous structs are unimplemented
fn f2(a: struct { field: u8 } ) {} //~ ERROR anonymous structs are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous structs are unimplemented
union G {
field: struct { field: u8 } //~ ERROR anonymous structs are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous structs are unimplemented
}
//~| ERROR unions may not contain fields that need dropping [E0740]
struct H { _: u8 } // Should error after hir checks
struct I(struct { field: u8 }, u8); //~ ERROR anonymous structs are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous structs are unimplemented
enum J {
K(struct { field: u8 }), //~ ERROR anonymous structs are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous structs are unimplemented
L {
_ : struct { field: u8 } //~ ERROR anonymous structs are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous fields are not allowed outside of structs or unions
//~| ERROR anonymous structs are unimplemented
},
M {
_ : u8 //~ ERROR anonymous fields are not allowed outside of structs or unions
}
}
static M: union { field: u8 } = 0; //~ ERROR anonymous unions are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous unions are unimplemented
type N = union { field: u8 }; //~ ERROR anonymous unions are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous unions are unimplemented
fn main() {
const O: struct { field: u8 } = 0; //~ ERROR anonymous structs are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous structs are unimplemented
let p: [struct { field: u8 }; 1]; //~ ERROR anonymous structs are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous structs are unimplemented
let q: (struct { field: u8 }, u8); //~ ERROR anonymous structs are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous structs are unimplemented
let cl = || -> struct { field: u8 } {}; //~ ERROR anonymous structs are not allowed outside of unnamed struct or union fields
//~^ ERROR anonymous structs are unimplemented
}

175
src/test/ui/unnamed_fields/restrict_anonymous.stderr
View file

@ -1,175 +0,0 @@
error: anonymous structs are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:4:11
|
LL | fn f() -> struct { field: u8 } {}
| ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here
error: anonymous structs are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:7:10
|
LL | fn f2(a: struct { field: u8 } ) {}
| ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here
error: anonymous structs are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:11:12
|
LL | field: struct { field: u8 }
| ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here
error: anonymous structs are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:18:10
|
LL | struct I(struct { field: u8 }, u8);
| ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here
error: anonymous structs are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:22:7
|
LL | K(struct { field: u8 }),
| ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here
error: anonymous fields are not allowed outside of structs or unions
--> $DIR/restrict_anonymous.rs:25:9
|
LL | _ : struct { field: u8 }
| -^^^^^^^^^^^^^^^^^^^^^^^
| |
| anonymous field declared here
error: anonymous structs are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:25:13
|
LL | _ : struct { field: u8 }
| ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here
error: anonymous fields are not allowed outside of structs or unions
--> $DIR/restrict_anonymous.rs:30:9
|
LL | _ : u8
| -^^^^^
| |
| anonymous field declared here
error: anonymous unions are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:34:11
|
LL | static M: union { field: u8 } = 0;
| ^^^^^^^^^^^^^^^^^^^ anonymous union declared here
error: anonymous unions are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:37:10
|
LL | type N = union { field: u8 };
| ^^^^^^^^^^^^^^^^^^^ anonymous union declared here
error: anonymous structs are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:41:14
|
LL | const O: struct { field: u8 } = 0;
| ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here
error: anonymous structs are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:44:13
|
LL | let p: [struct { field: u8 }; 1];
| ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here
error: anonymous structs are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:47:13
|
LL | let q: (struct { field: u8 }, u8);
| ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here
error: anonymous structs are not allowed outside of unnamed struct or union fields
--> $DIR/restrict_anonymous.rs:50:20
|
LL | let cl = || -> struct { field: u8 } {};
| ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here
error: anonymous structs are unimplemented
--> $DIR/restrict_anonymous.rs:4:11
|
LL | fn f() -> struct { field: u8 } {}
| ^^^^^^^^^^^^^^^^^^^^
error: anonymous structs are unimplemented
--> $DIR/restrict_anonymous.rs:7:10
|
LL | fn f2(a: struct { field: u8 } ) {}
| ^^^^^^^^^^^^^^^^^^^^
error: anonymous structs are unimplemented
--> $DIR/restrict_anonymous.rs:11:12
|
LL | field: struct { field: u8 }
| ^^^^^^^^^^^^^^^^^^^^
error: anonymous structs are unimplemented
--> $DIR/restrict_anonymous.rs:18:10
|
LL | struct I(struct { field: u8 }, u8);
| ^^^^^^^^^^^^^^^^^^^^
error: anonymous structs are unimplemented
--> $DIR/restrict_anonymous.rs:22:7
|
LL | K(struct { field: u8 }),
| ^^^^^^^^^^^^^^^^^^^^
error: anonymous structs are unimplemented
--> $DIR/restrict_anonymous.rs:25:13
|
LL | _ : struct { field: u8 }
| ^^^^^^^^^^^^^^^^^^^^
error: anonymous unions are unimplemented
--> $DIR/restrict_anonymous.rs:34:11
|
LL | static M: union { field: u8 } = 0;
| ^^^^^^^^^^^^^^^^^^^
error: anonymous unions are unimplemented
--> $DIR/restrict_anonymous.rs:37:10
|
LL | type N = union { field: u8 };
| ^^^^^^^^^^^^^^^^^^^
error: anonymous structs are unimplemented
--> $DIR/restrict_anonymous.rs:44:13
|
LL | let p: [struct { field: u8 }; 1];
| ^^^^^^^^^^^^^^^^^^^^
error: anonymous structs are unimplemented
--> $DIR/restrict_anonymous.rs:47:13
|
LL | let q: (struct { field: u8 }, u8);
| ^^^^^^^^^^^^^^^^^^^^
error: anonymous structs are unimplemented
--> $DIR/restrict_anonymous.rs:50:20
|
LL | let cl = || -> struct { field: u8 } {};
| ^^^^^^^^^^^^^^^^^^^^
error: anonymous structs are unimplemented
--> $DIR/restrict_anonymous.rs:41:14
|
LL | const O: struct { field: u8 } = 0;
| ^^^^^^^^^^^^^^^^^^^^
error[E0740]: unions may not contain fields that need dropping
--> $DIR/restrict_anonymous.rs:11:5
|
LL | field: struct { field: u8 }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: `std::mem::ManuallyDrop` can be used to wrap the type
--> $DIR/restrict_anonymous.rs:11:5
|
LL | field: struct { field: u8 }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 27 previous errors
For more information about this error, try `rustc --explain E0740`.

11
src/tools/rustfmt/src/items.rs
View file

@ -6,7 +6,7 @@ use std::cmp::{max, min, Ordering};
use regex::Regex;
use rustc_ast::visit;
use rustc_ast::{ast, ptr};
use rustc_span::{symbol, BytePos, Span};
use rustc_span::{symbol, BytePos, Span, DUMMY_SP};
use crate::attr::filter_inline_attrs;
use crate::comment::{
@ -31,7 +31,12 @@ use crate::stmt::Stmt;
use crate::utils::*;
use crate::vertical::rewrite_with_alignment;
use crate::visitor::FmtVisitor;
use crate::DEFAULT_VISIBILITY;
const DEFAULT_VISIBILITY: ast::Visibility = ast::Visibility {
kind: ast::VisibilityKind::Inherited,
span: DUMMY_SP,
tokens: None,
};
fn type_annotation_separator(config: &Config) -> &str {
colon_spaces(config)
@ -972,7 +977,7 @@ impl<'a> StructParts<'a> {
format_header(context, self.prefix, self.ident, self.vis, offset)
}
pub(crate) fn from_variant(variant: &'a ast::Variant) -> Self {
fn from_variant(variant: &'a ast::Variant) -> Self {
StructParts {
prefix: "",
ident: variant.ident,

7
src/tools/rustfmt/src/lib.rs
View file

@ -32,7 +32,7 @@ use std::path::PathBuf;
use std::rc::Rc;
use rustc_ast::ast;
use rustc_span::{symbol, DUMMY_SP};
use rustc_span::symbol;
use thiserror::Error;
use crate::comment::LineClasses;
@ -96,11 +96,6 @@ mod types;
mod vertical;
pub(crate) mod visitor;
const DEFAULT_VISIBILITY: ast::Visibility = ast::Visibility {
kind: ast::VisibilityKind::Inherited,
span: DUMMY_SP,
tokens: None,
};
/// The various errors that can occur during formatting. Note that not all of
/// these can currently be propagated to clients.
#[derive(Error, Debug)]

59
src/tools/rustfmt/src/types.rs
View file

@ -1,15 +1,15 @@
use std::iter::ExactSizeIterator;
use std::ops::Deref;
use rustc_ast::ast::{self, AttrVec, FnRetTy, Mutability};
use rustc_span::{symbol::kw, symbol::Ident, BytePos, Pos, Span};
use rustc_ast::ast::{self, FnRetTy, Mutability};
use rustc_span::{symbol::kw, BytePos, Pos, Span};
use crate::comment::{combine_strs_with_missing_comments, contains_comment};
use crate::config::lists::*;
use crate::config::{IndentStyle, TypeDensity, Version};
use crate::expr::{
format_expr, rewrite_assign_rhs, rewrite_call, rewrite_tuple, rewrite_unary_prefix, ExprType,
};
use crate::items::StructParts;
use crate::lists::{
definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator,
};
@ -24,11 +24,6 @@ use crate::utils::{
colon_spaces, extra_offset, first_line_width, format_extern, format_mutability,
last_line_extendable, last_line_width, mk_sp, rewrite_ident,
};
use crate::DEFAULT_VISIBILITY;
use crate::{
comment::{combine_strs_with_missing_comments, contains_comment},
items::format_struct_struct,
};
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub(crate) enum PathContext {
@ -769,54 +764,6 @@ impl Rewrite for ast::Ty {
ast::TyKind::Tup(ref items) => {
rewrite_tuple(context, items.iter(), self.span, shape, items.len() == 1)
}
ast::TyKind::AnonymousStruct(ref fields, recovered) => {
let ident = Ident::new(
kw::Struct,
mk_sp(self.span.lo(), self.span.lo() + BytePos(6)),
);
let data = ast::VariantData::Struct(fields.clone(), recovered);
let variant = ast::Variant {
attrs: AttrVec::new(),
id: self.id,
span: self.span,
vis: DEFAULT_VISIBILITY,
ident,
data,
disr_expr: None,
is_placeholder: false,
};
format_struct_struct(
&context,
&StructParts::from_variant(&variant),
fields,
shape.indent,
None,
)
}
ast::TyKind::AnonymousUnion(ref fields, recovered) => {
let ident = Ident::new(
kw::Union,
mk_sp(self.span.lo(), self.span.lo() + BytePos(5)),
);
let data = ast::VariantData::Struct(fields.clone(), recovered);
let variant = ast::Variant {
attrs: AttrVec::new(),
id: self.id,
span: self.span,
vis: DEFAULT_VISIBILITY,
ident,
data,
disr_expr: None,
is_placeholder: false,
};
format_struct_struct(
&context,
&StructParts::from_variant(&variant),
fields,
shape.indent,
None,
)
}
ast::TyKind::Path(ref q_self, ref path) => {
rewrite_path(context, PathContext::Type, q_self.as_ref(), path, shape)
}