diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs index ad0e0384acffa..57c39671c3559 100644 --- a/compiler/rustc_ast_passes/src/feature_gate.rs +++ b/compiler/rustc_ast_passes/src/feature_gate.rs @@ -274,10 +274,12 @@ impl<'a> PostExpansionVisitor<'a> { ); } abi => { - self.sess.parse_sess.span_diagnostic.delay_span_bug( - span, - &format!("unrecognized ABI not caught in lowering: {}", abi), - ); + if self.sess.opts.pretty.map_or(true, |ppm| ppm.needs_hir()) { + self.sess.parse_sess.span_diagnostic.delay_span_bug( + span, + &format!("unrecognized ABI not caught in lowering: {}", abi), + ); + } } } } diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs index 18b671d410dc7..e0179bd3ed1e8 100644 --- a/compiler/rustc_hir_pretty/src/lib.rs +++ b/compiler/rustc_hir_pretty/src/lib.rs @@ -211,6 +211,10 @@ pub fn path_to_string(segment: &hir::Path<'_>) -> String { to_string(NO_ANN, |s| s.print_path(segment, false)) } +pub fn qpath_to_string(segment: &hir::QPath<'_>) -> String { + to_string(NO_ANN, |s| s.print_qpath(segment, false)) +} + pub fn fn_to_string( decl: &hir::FnDecl<'_>, header: hir::FnHeader, diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index 0e52bf34661d6..55307b9cebb70 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -2707,6 +2707,14 @@ impl PpMode { | MirCFG => true, } } + pub fn needs_hir(&self) -> bool { + use PpMode::*; + match *self { + Source(_) | AstTree(_) => false, + + Hir(_) | HirTree | ThirTree | Mir | MirCFG => true, + } + } pub fn needs_analysis(&self) -> bool { use PpMode::*; diff --git a/compiler/rustc_typeck/src/check/callee.rs b/compiler/rustc_typeck/src/check/callee.rs index d14d06237be30..00c8aa3a1bbda 100644 --- a/compiler/rustc_typeck/src/check/callee.rs +++ b/compiler/rustc_typeck/src/check/callee.rs @@ -4,7 +4,7 @@ use crate::type_error_struct; use rustc_errors::{struct_span_err, Applicability, Diagnostic}; use rustc_hir as hir; -use rustc_hir::def::{Namespace, Res}; +use rustc_hir::def::{self, Namespace, Res}; use rustc_hir::def_id::{DefId, LOCAL_CRATE}; use rustc_infer::{ infer, @@ -390,17 +390,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { (fn_sig, Some(def_id)) } ty::FnPtr(sig) => (sig, None), - ref t => { + _ => { let mut unit_variant = None; - let mut removal_span = call_expr.span; - if let ty::Adt(adt_def, ..) = t - && adt_def.is_enum() - && let hir::ExprKind::Call(expr, _) = call_expr.kind + if let hir::ExprKind::Path(qpath) = &callee_expr.kind + && let Res::Def(def::DefKind::Ctor(kind, def::CtorKind::Const), _) + = self.typeck_results.borrow().qpath_res(qpath, callee_expr.hir_id) + // Only suggest removing parens if there are no arguments + && arg_exprs.is_empty() { - removal_span = - expr.span.shrink_to_hi().to(call_expr.span.shrink_to_hi()); + let descr = match kind { + def::CtorOf::Struct => "struct", + def::CtorOf::Variant => "enum variant", + }; + let removal_span = + callee_expr.span.shrink_to_hi().to(call_expr.span.shrink_to_hi()); unit_variant = - self.tcx.sess.source_map().span_to_snippet(expr.span).ok(); + Some((removal_span, descr, rustc_hir_pretty::qpath_to_string(qpath))); } let callee_ty = self.resolve_vars_if_possible(callee_ty); @@ -410,8 +415,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { callee_ty, E0618, "expected function, found {}", - match unit_variant { - Some(ref path) => format!("enum variant `{path}`"), + match &unit_variant { + Some((_, kind, path)) => format!("{kind} `{path}`"), None => format!("`{callee_ty}`"), } ); @@ -423,11 +428,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { callee_expr.span, ); - if let Some(ref path) = unit_variant { + if let Some((removal_span, kind, path)) = &unit_variant { err.span_suggestion_verbose( - removal_span, + *removal_span, &format!( - "`{path}` is a unit variant, you need to write it without the parentheses", + "`{path}` is a unit {kind}, and does not take parentheses to be constructed", ), "", Applicability::MachineApplicable, @@ -470,7 +475,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if let Some(span) = self.tcx.hir().res_span(def) { let callee_ty = callee_ty.to_string(); let label = match (unit_variant, inner_callee_path) { - (Some(path), _) => Some(format!("`{path}` defined here")), + (Some((_, kind, path)), _) => Some(format!("{kind} `{path}` defined here")), (_, Some(hir::QPath::Resolved(_, path))) => self .tcx .sess diff --git a/compiler/rustc_typeck/src/check/compare_method.rs b/compiler/rustc_typeck/src/check/compare_method.rs index a53217ef81882..6ae17fc61762f 100644 --- a/compiler/rustc_typeck/src/check/compare_method.rs +++ b/compiler/rustc_typeck/src/check/compare_method.rs @@ -1505,6 +1505,21 @@ pub fn check_type_bounds<'tcx>( &outlives_environment, ); + let constraints = infcx.inner.borrow_mut().opaque_type_storage.take_opaque_types(); + for (key, value) in constraints { + infcx + .report_mismatched_types( + &ObligationCause::misc( + value.hidden_type.span, + tcx.hir().local_def_id_to_hir_id(impl_ty.def_id.expect_local()), + ), + tcx.mk_opaque(key.def_id, key.substs), + value.hidden_type.ty, + TypeError::Mismatch, + ) + .emit(); + } + Ok(()) }) } diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs index 02e493f725864..2d22e9bc76e5a 100644 --- a/compiler/rustc_typeck/src/check/expr.rs +++ b/compiler/rustc_typeck/src/check/expr.rs @@ -531,7 +531,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { tcx.ty_error() } Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => { - report_unexpected_variant_res(tcx, res, expr.span); + report_unexpected_variant_res(tcx, res, qpath, expr.span); tcx.ty_error() } _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, expr.hir_id).0, diff --git a/compiler/rustc_typeck/src/check/mod.rs b/compiler/rustc_typeck/src/check/mod.rs index 849e96445d3ea..2b037c3fd2b0e 100644 --- a/compiler/rustc_typeck/src/check/mod.rs +++ b/compiler/rustc_typeck/src/check/mod.rs @@ -863,17 +863,14 @@ fn bad_non_zero_sized_fields<'tcx>( err.emit(); } -fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span) { +fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, qpath: &hir::QPath<'_>, span: Span) { struct_span_err!( tcx.sess, span, E0533, - "expected unit struct, unit variant or constant, found {}{}", + "expected unit struct, unit variant or constant, found {} `{}`", res.descr(), - tcx.sess - .source_map() - .span_to_snippet(span) - .map_or_else(|_| String::new(), |s| format!(" `{s}`",)), + rustc_hir_pretty::qpath_to_string(qpath), ) .emit(); } diff --git a/compiler/rustc_typeck/src/check/pat.rs b/compiler/rustc_typeck/src/check/pat.rs index fbfbfba5c2ad2..c7318cd6e531f 100644 --- a/compiler/rustc_typeck/src/check/pat.rs +++ b/compiler/rustc_typeck/src/check/pat.rs @@ -183,7 +183,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { PatKind::TupleStruct(ref qpath, subpats, ddpos) => { self.check_pat_tuple_struct(pat, qpath, subpats, ddpos, expected, def_bm, ti) } - PatKind::Path(_) => self.check_pat_path(pat, path_res.unwrap(), expected, ti), + PatKind::Path(ref qpath) => { + self.check_pat_path(pat, qpath, path_res.unwrap(), expected, ti) + } PatKind::Struct(ref qpath, fields, has_rest_pat) => { self.check_pat_struct(pat, qpath, fields, has_rest_pat, expected, def_bm, ti) } @@ -800,6 +802,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { fn check_pat_path<'b>( &self, pat: &Pat<'_>, + qpath: &hir::QPath<'_>, path_resolution: (Res, Option>, &'b [hir::PathSegment<'b>]), expected: Ty<'tcx>, ti: TopInfo<'tcx>, @@ -814,7 +817,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { return tcx.ty_error(); } Res::Def(DefKind::AssocFn | DefKind::Ctor(_, CtorKind::Fictive | CtorKind::Fn), _) => { - report_unexpected_variant_res(tcx, res, pat.span); + report_unexpected_variant_res(tcx, res, qpath, pat.span); return tcx.ty_error(); } Res::SelfCtor(..) diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs index 77fd1ec2b8ea2..1270a72634b9d 100644 --- a/library/core/src/slice/mod.rs +++ b/library/core/src/slice/mod.rs @@ -1340,7 +1340,7 @@ impl [T] { /// from the `remainder` function of the iterator. /// /// Due to each chunk having exactly `chunk_size` elements, the compiler can often optimize the - /// resulting code better than in the case of [`chunks`]. + /// resulting code better than in the case of [`rchunks`]. /// /// See [`rchunks`] for a variant of this iterator that also returns the remainder as a smaller /// chunk, and [`chunks_exact`] for the same iterator but starting at the beginning of the diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs index ebc769ac7ca3b..b636dc491a4b1 100644 --- a/library/core/src/sync/atomic.rs +++ b/library/core/src/sync/atomic.rs @@ -581,8 +581,7 @@ impl AtomicBool { /// `failure` describes the required ordering for the load operation that takes place when /// the comparison fails. Using [`Acquire`] as success ordering makes the store part /// of this operation [`Relaxed`], and using [`Release`] makes the successful load - /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] - /// and must be equivalent to or weaker than the success ordering. + /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]. /// /// **Note:** This method is only available on platforms that support atomic /// operations on `u8`. @@ -640,8 +639,7 @@ impl AtomicBool { /// `failure` describes the required ordering for the load operation that takes place when /// the comparison fails. Using [`Acquire`] as success ordering makes the store part /// of this operation [`Relaxed`], and using [`Release`] makes the successful load - /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] - /// and must be equivalent to or weaker than the success ordering. + /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]. /// /// **Note:** This method is only available on platforms that support atomic /// operations on `u8`. @@ -941,8 +939,7 @@ impl AtomicBool { /// Using [`Acquire`] as success ordering makes the store part of this /// operation [`Relaxed`], and using [`Release`] makes the final successful /// load [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`], - /// [`Acquire`] or [`Relaxed`] and must be equivalent to or weaker than the - /// success ordering. + /// [`Acquire`] or [`Relaxed`]. /// /// **Note:** This method is only available on platforms that support atomic /// operations on `u8`. @@ -1301,8 +1298,7 @@ impl AtomicPtr { /// `failure` describes the required ordering for the load operation that takes place when /// the comparison fails. Using [`Acquire`] as success ordering makes the store part /// of this operation [`Relaxed`], and using [`Release`] makes the successful load - /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] - /// and must be equivalent to or weaker than the success ordering. + /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]. /// /// **Note:** This method is only available on platforms that support atomic /// operations on pointers. @@ -1347,8 +1343,7 @@ impl AtomicPtr { /// `failure` describes the required ordering for the load operation that takes place when /// the comparison fails. Using [`Acquire`] as success ordering makes the store part /// of this operation [`Relaxed`], and using [`Release`] makes the successful load - /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] - /// and must be equivalent to or weaker than the success ordering. + /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]. /// /// **Note:** This method is only available on platforms that support atomic /// operations on pointers. @@ -1404,8 +1399,7 @@ impl AtomicPtr { /// Using [`Acquire`] as success ordering makes the store part of this /// operation [`Relaxed`], and using [`Release`] makes the final successful /// load [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`], - /// [`Acquire`] or [`Relaxed`] and must be equivalent to or weaker than the - /// success ordering. + /// [`Acquire`] or [`Relaxed`]. /// /// **Note:** This method is only available on platforms that support atomic /// operations on pointers. @@ -2227,8 +2221,7 @@ macro_rules! atomic_int { /// `failure` describes the required ordering for the load operation that takes place when /// the comparison fails. Using [`Acquire`] as success ordering makes the store part /// of this operation [`Relaxed`], and using [`Release`] makes the successful load - /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] - /// and must be equivalent to or weaker than the success ordering. + /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]. /// /// **Note**: This method is only available on platforms that support atomic operations on #[doc = concat!("[`", $s_int_type, "`].")] @@ -2279,8 +2272,7 @@ macro_rules! atomic_int { /// `failure` describes the required ordering for the load operation that takes place when /// the comparison fails. Using [`Acquire`] as success ordering makes the store part /// of this operation [`Relaxed`], and using [`Release`] makes the successful load - /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] - /// and must be equivalent to or weaker than the success ordering. + /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]. /// /// **Note**: This method is only available on platforms that support atomic operations on #[doc = concat!("[`", $s_int_type, "`].")] @@ -2517,8 +2509,7 @@ macro_rules! atomic_int { /// /// Using [`Acquire`] as success ordering makes the store part /// of this operation [`Relaxed`], and using [`Release`] makes the final successful load - /// [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] - /// and must be equivalent to or weaker than the success ordering. + /// [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]. /// /// **Note**: This method is only available on platforms that support atomic operations on #[doc = concat!("[`", $s_int_type, "`].")] @@ -3035,22 +3026,29 @@ unsafe fn atomic_compare_exchange( let (val, ok) = unsafe { match (success, failure) { (Relaxed, Relaxed) => intrinsics::atomic_cxchg_relaxed_relaxed(dst, old, new), - //(Relaxed, Acquire) => intrinsics::atomic_cxchg_relaxed_acquire(dst, old, new), - //(Relaxed, SeqCst) => intrinsics::atomic_cxchg_relaxed_seqcst(dst, old, new), + #[cfg(not(bootstrap))] + (Relaxed, Acquire) => intrinsics::atomic_cxchg_relaxed_acquire(dst, old, new), + #[cfg(not(bootstrap))] + (Relaxed, SeqCst) => intrinsics::atomic_cxchg_relaxed_seqcst(dst, old, new), (Acquire, Relaxed) => intrinsics::atomic_cxchg_acquire_relaxed(dst, old, new), (Acquire, Acquire) => intrinsics::atomic_cxchg_acquire_acquire(dst, old, new), - //(Acquire, SeqCst) => intrinsics::atomic_cxchg_acquire_seqcst(dst, old, new), + #[cfg(not(bootstrap))] + (Acquire, SeqCst) => intrinsics::atomic_cxchg_acquire_seqcst(dst, old, new), (Release, Relaxed) => intrinsics::atomic_cxchg_release_relaxed(dst, old, new), - //(Release, Acquire) => intrinsics::atomic_cxchg_release_acquire(dst, old, new), - //(Release, SeqCst) => intrinsics::atomic_cxchg_release_seqcst(dst, old, new), + #[cfg(not(bootstrap))] + (Release, Acquire) => intrinsics::atomic_cxchg_release_acquire(dst, old, new), + #[cfg(not(bootstrap))] + (Release, SeqCst) => intrinsics::atomic_cxchg_release_seqcst(dst, old, new), (AcqRel, Relaxed) => intrinsics::atomic_cxchg_acqrel_relaxed(dst, old, new), (AcqRel, Acquire) => intrinsics::atomic_cxchg_acqrel_acquire(dst, old, new), - //(AcqRel, SeqCst) => intrinsics::atomic_cxchg_acqrel_seqcst(dst, old, new), + #[cfg(not(bootstrap))] + (AcqRel, SeqCst) => intrinsics::atomic_cxchg_acqrel_seqcst(dst, old, new), (SeqCst, Relaxed) => intrinsics::atomic_cxchg_seqcst_relaxed(dst, old, new), (SeqCst, Acquire) => intrinsics::atomic_cxchg_seqcst_acquire(dst, old, new), (SeqCst, SeqCst) => intrinsics::atomic_cxchg_seqcst_seqcst(dst, old, new), (_, AcqRel) => panic!("there is no such thing as an acquire-release failure ordering"), (_, Release) => panic!("there is no such thing as a release failure ordering"), + #[cfg(bootstrap)] _ => panic!("a failure ordering can't be stronger than a success ordering"), } }; @@ -3070,22 +3068,29 @@ unsafe fn atomic_compare_exchange_weak( let (val, ok) = unsafe { match (success, failure) { (Relaxed, Relaxed) => intrinsics::atomic_cxchgweak_relaxed_relaxed(dst, old, new), - //(Relaxed, Acquire) => intrinsics::atomic_cxchgweak_relaxed_acquire(dst, old, new), - //(Relaxed, SeqCst) => intrinsics::atomic_cxchgweak_relaxed_seqcst(dst, old, new), + #[cfg(not(bootstrap))] + (Relaxed, Acquire) => intrinsics::atomic_cxchgweak_relaxed_acquire(dst, old, new), + #[cfg(not(bootstrap))] + (Relaxed, SeqCst) => intrinsics::atomic_cxchgweak_relaxed_seqcst(dst, old, new), (Acquire, Relaxed) => intrinsics::atomic_cxchgweak_acquire_relaxed(dst, old, new), (Acquire, Acquire) => intrinsics::atomic_cxchgweak_acquire_acquire(dst, old, new), - //(Acquire, SeqCst) => intrinsics::atomic_cxchgweak_acquire_seqcst(dst, old, new), + #[cfg(not(bootstrap))] + (Acquire, SeqCst) => intrinsics::atomic_cxchgweak_acquire_seqcst(dst, old, new), (Release, Relaxed) => intrinsics::atomic_cxchgweak_release_relaxed(dst, old, new), - //(Release, Acquire) => intrinsics::atomic_cxchgweak_release_acquire(dst, old, new), - //(Release, SeqCst) => intrinsics::atomic_cxchgweak_release_seqcst(dst, old, new), + #[cfg(not(bootstrap))] + (Release, Acquire) => intrinsics::atomic_cxchgweak_release_acquire(dst, old, new), + #[cfg(not(bootstrap))] + (Release, SeqCst) => intrinsics::atomic_cxchgweak_release_seqcst(dst, old, new), (AcqRel, Relaxed) => intrinsics::atomic_cxchgweak_acqrel_relaxed(dst, old, new), (AcqRel, Acquire) => intrinsics::atomic_cxchgweak_acqrel_acquire(dst, old, new), - //(AcqRel, SeqCst) => intrinsics::atomic_cxchgweak_acqrel_seqcst(dst, old, new), + #[cfg(not(bootstrap))] + (AcqRel, SeqCst) => intrinsics::atomic_cxchgweak_acqrel_seqcst(dst, old, new), (SeqCst, Relaxed) => intrinsics::atomic_cxchgweak_seqcst_relaxed(dst, old, new), (SeqCst, Acquire) => intrinsics::atomic_cxchgweak_seqcst_acquire(dst, old, new), (SeqCst, SeqCst) => intrinsics::atomic_cxchgweak_seqcst_seqcst(dst, old, new), (_, AcqRel) => panic!("there is no such thing as an acquire-release failure ordering"), (_, Release) => panic!("there is no such thing as a release failure ordering"), + #[cfg(bootstrap)] _ => panic!("a failure ordering can't be stronger than a success ordering"), } }; diff --git a/src/librustdoc/html/static/js/source-script.js b/src/librustdoc/html/static/js/source-script.js index 1e9bfa5cc8959..a6a0b09ef31fe 100644 --- a/src/librustdoc/html/static/js/source-script.js +++ b/src/librustdoc/html/static/js/source-script.js @@ -33,7 +33,7 @@ function createDirEntry(elem, parent, fullPath, hasFoundFile) { folders.className = "folders"; if (elem.dirs) { for (const dir of elem.dirs) { - if (createDirEntry(dir, folders, fullPath, hasFoundFile)) { + if (createDirEntry(dir, folders, fullPath, false)) { dirEntry.open = true; hasFoundFile = true; } diff --git a/src/test/rustdoc-gui/sidebar-source-code.goml b/src/test/rustdoc-gui/sidebar-source-code.goml index 86df478fa1dd2..e882080c7daba 100644 --- a/src/test/rustdoc-gui/sidebar-source-code.goml +++ b/src/test/rustdoc-gui/sidebar-source-code.goml @@ -16,15 +16,27 @@ click: (10, 10) wait-for: "html:not(.expanded)" assert: "nav.sidebar" +// Checking that only the path to the current file is "open". +goto: file://|DOC_PATH|/src/lib2/another_folder/sub_mod/mod.rs.html +// First we expand the sidebar again. +click: (10, 10) +// We wait for the sidebar to be expanded. +wait-for-css: (".source-sidebar-expanded nav.sidebar", {"width": "300px"}) +assert: "//*[@class='dir-entry' and @open]/*[text()='lib2']" +assert: "//*[@class='dir-entry' and @open]/*[text()='another_folder']" +assert: "//*[@class='dir-entry' and @open]/*[text()='sub_mod']" +// Only "another_folder" should be "open" in "lib2". +assert: "//*[@class='dir-entry' and not(@open)]/*[text()='another_mod']" +// All other trees should be collapsed. +assert-count: ("//*[@id='source-sidebar']/details[not(text()='lib2') and not(@open)]", 5) + // We now switch to mobile mode. size: (600, 600) -// We check that the sidebar has the expected width (0). -assert-css: ("nav.sidebar", {"width": "0px"}) -// We expand the sidebar. -click: "#sidebar-toggle" -assert-css: (".source-sidebar-expanded nav.sidebar", {"width": "600px"}) +wait-for-css: (".source-sidebar-expanded nav.sidebar", {"width": "600px"}) // We collapse the sidebar. click: (10, 10) +// We check that the sidebar has the expected width (0). +assert-css: ("nav.sidebar", {"width": "0px"}) // We ensure that the class has been removed. assert-false: ".source-sidebar-expanded" assert: "nav.sidebar" diff --git a/src/test/rustdoc-gui/src/lib2/another_folder/mod.rs b/src/test/rustdoc-gui/src/lib2/another_folder/mod.rs new file mode 100644 index 0000000000000..ec9a20859243d --- /dev/null +++ b/src/test/rustdoc-gui/src/lib2/another_folder/mod.rs @@ -0,0 +1,3 @@ +pub fn another_fn() {} + +pub mod sub_mod; diff --git a/src/test/rustdoc-gui/src/lib2/another_folder/sub_mod/mod.rs b/src/test/rustdoc-gui/src/lib2/another_folder/sub_mod/mod.rs new file mode 100644 index 0000000000000..f16722cf35b7b --- /dev/null +++ b/src/test/rustdoc-gui/src/lib2/another_folder/sub_mod/mod.rs @@ -0,0 +1 @@ +pub fn subsubsub() {} diff --git a/src/test/rustdoc-gui/src/lib2/another_mod/mod.rs b/src/test/rustdoc-gui/src/lib2/another_mod/mod.rs new file mode 100644 index 0000000000000..9a4f007a2f0ca --- /dev/null +++ b/src/test/rustdoc-gui/src/lib2/another_mod/mod.rs @@ -0,0 +1 @@ +pub fn tadam() {} diff --git a/src/test/rustdoc-gui/src/lib2/lib.rs b/src/test/rustdoc-gui/src/lib2/lib.rs index d06b46f952d0e..4546449e10291 100644 --- a/src/test/rustdoc-gui/src/lib2/lib.rs +++ b/src/test/rustdoc-gui/src/lib2/lib.rs @@ -2,6 +2,9 @@ #![feature(doc_cfg)] +pub mod another_folder; +pub mod another_mod; + pub mod module { pub mod sub_module { pub mod sub_sub_module { diff --git a/src/test/ui/codemap_tests/unicode.expanded.stdout b/src/test/ui/codemap_tests/unicode.expanded.stdout new file mode 100644 index 0000000000000..d14bb42b2fdb2 --- /dev/null +++ b/src/test/ui/codemap_tests/unicode.expanded.stdout @@ -0,0 +1,13 @@ +#![feature(prelude_import)] +#![no_std] +#[prelude_import] +use ::std::prelude::rust_2015::*; +#[macro_use] +extern crate std; +// revisions: normal expanded +//[expanded] check-pass +//[expanded]compile-flags: -Zunpretty=expanded + +extern "路濫狼á́́" fn foo() {} + +fn main() {} diff --git a/src/test/ui/codemap_tests/unicode.stderr b/src/test/ui/codemap_tests/unicode.normal.stderr similarity index 96% rename from src/test/ui/codemap_tests/unicode.stderr rename to src/test/ui/codemap_tests/unicode.normal.stderr index bf7aaa5f0ebbf..60f8cff84b30c 100644 --- a/src/test/ui/codemap_tests/unicode.stderr +++ b/src/test/ui/codemap_tests/unicode.normal.stderr @@ -1,5 +1,5 @@ error[E0703]: invalid ABI: found `路濫狼á́́` - --> $DIR/unicode.rs:1:8 + --> $DIR/unicode.rs:5:8 | LL | extern "路濫狼á́́" fn foo() {} | ^^^^^^^^^ invalid ABI diff --git a/src/test/ui/codemap_tests/unicode.rs b/src/test/ui/codemap_tests/unicode.rs index 7180e903b5c3c..4df9a5270c317 100644 --- a/src/test/ui/codemap_tests/unicode.rs +++ b/src/test/ui/codemap_tests/unicode.rs @@ -1,3 +1,7 @@ -extern "路濫狼á́́" fn foo() {} //~ ERROR invalid ABI +// revisions: normal expanded +//[expanded] check-pass +//[expanded]compile-flags: -Zunpretty=expanded + +extern "路濫狼á́́" fn foo() {} //[normal]~ ERROR invalid ABI fn main() { } diff --git a/src/test/ui/empty/empty-struct-unit-expr.rs b/src/test/ui/empty/empty-struct-unit-expr.rs index b192e3a92c38e..8f3688a2a0764 100644 --- a/src/test/ui/empty/empty-struct-unit-expr.rs +++ b/src/test/ui/empty/empty-struct-unit-expr.rs @@ -12,10 +12,10 @@ enum E { } fn main() { - let e2 = Empty2(); //~ ERROR expected function, found `Empty2` + let e2 = Empty2(); //~ ERROR expected function, found struct `Empty2` let e4 = E::Empty4(); //~^ ERROR expected function, found enum variant `E::Empty4` [E0618] - let xe2 = XEmpty2(); //~ ERROR expected function, found `empty_struct::XEmpty2` + let xe2 = XEmpty2(); //~ ERROR expected function, found struct `XEmpty2` let xe4 = XE::XEmpty4(); //~^ ERROR expected function, found enum variant `XE::XEmpty4` [E0618] } diff --git a/src/test/ui/empty/empty-struct-unit-expr.stderr b/src/test/ui/empty/empty-struct-unit-expr.stderr index cd51274dce81b..e97209527fe34 100644 --- a/src/test/ui/empty/empty-struct-unit-expr.stderr +++ b/src/test/ui/empty/empty-struct-unit-expr.stderr @@ -1,38 +1,50 @@ -error[E0618]: expected function, found `Empty2` +error[E0618]: expected function, found struct `Empty2` --> $DIR/empty-struct-unit-expr.rs:15:14 | LL | struct Empty2; - | ------------- `Empty2` defined here + | ------------- struct `Empty2` defined here ... LL | let e2 = Empty2(); | ^^^^^^-- | | | call expression requires function + | +help: `Empty2` is a unit struct, and does not take parentheses to be constructed + | +LL - let e2 = Empty2(); +LL + let e2 = Empty2; + | error[E0618]: expected function, found enum variant `E::Empty4` --> $DIR/empty-struct-unit-expr.rs:16:14 | LL | Empty4 - | ------ `E::Empty4` defined here + | ------ enum variant `E::Empty4` defined here ... LL | let e4 = E::Empty4(); | ^^^^^^^^^-- | | | call expression requires function | -help: `E::Empty4` is a unit variant, you need to write it without the parentheses +help: `E::Empty4` is a unit enum variant, and does not take parentheses to be constructed | LL - let e4 = E::Empty4(); LL + let e4 = E::Empty4; | -error[E0618]: expected function, found `empty_struct::XEmpty2` +error[E0618]: expected function, found struct `XEmpty2` --> $DIR/empty-struct-unit-expr.rs:18:15 | LL | let xe2 = XEmpty2(); | ^^^^^^^-- | | | call expression requires function + | +help: `XEmpty2` is a unit struct, and does not take parentheses to be constructed + | +LL - let xe2 = XEmpty2(); +LL + let xe2 = XEmpty2; + | error[E0618]: expected function, found enum variant `XE::XEmpty4` --> $DIR/empty-struct-unit-expr.rs:19:15 @@ -42,7 +54,7 @@ LL | let xe4 = XE::XEmpty4(); | | | call expression requires function | -help: `XE::XEmpty4` is a unit variant, you need to write it without the parentheses +help: `XE::XEmpty4` is a unit enum variant, and does not take parentheses to be constructed | LL - let xe4 = XE::XEmpty4(); LL + let xe4 = XE::XEmpty4; diff --git a/src/test/ui/error-codes/E0618.stderr b/src/test/ui/error-codes/E0618.stderr index fcee6b47c1d2b..793ec02a86fc6 100644 --- a/src/test/ui/error-codes/E0618.stderr +++ b/src/test/ui/error-codes/E0618.stderr @@ -2,14 +2,14 @@ error[E0618]: expected function, found enum variant `X::Entry` --> $DIR/E0618.rs:6:5 | LL | Entry, - | ----- `X::Entry` defined here + | ----- enum variant `X::Entry` defined here ... LL | X::Entry(); | ^^^^^^^^-- | | | call expression requires function | -help: `X::Entry` is a unit variant, you need to write it without the parentheses +help: `X::Entry` is a unit enum variant, and does not take parentheses to be constructed | LL - X::Entry(); LL + X::Entry; diff --git a/src/test/ui/impl-trait/issues/issue-99348-impl-compatibility.rs b/src/test/ui/impl-trait/issues/issue-99348-impl-compatibility.rs new file mode 100644 index 0000000000000..d29a82f76a793 --- /dev/null +++ b/src/test/ui/impl-trait/issues/issue-99348-impl-compatibility.rs @@ -0,0 +1,26 @@ +#![feature(type_alias_impl_trait)] + +struct Concrete; + +type Tait = impl Sized; + +impl Foo for Concrete { + type Item = Concrete; + //~^ mismatched types +} + +impl Bar for Concrete { + type Other = Tait; +} + +trait Foo { + type Item: Bar; +} + +trait Bar { + type Other; +} + +fn tait() -> Tait {} + +fn main() {} diff --git a/src/test/ui/impl-trait/issues/issue-99348-impl-compatibility.stderr b/src/test/ui/impl-trait/issues/issue-99348-impl-compatibility.stderr new file mode 100644 index 0000000000000..a25f0cd87616b --- /dev/null +++ b/src/test/ui/impl-trait/issues/issue-99348-impl-compatibility.stderr @@ -0,0 +1,15 @@ +error[E0308]: mismatched types + --> $DIR/issue-99348-impl-compatibility.rs:8:17 + | +LL | type Tait = impl Sized; + | ---------- the expected opaque type +... +LL | type Item = Concrete; + | ^^^^^^^^ types differ + | + = note: expected opaque type `Tait` + found struct `Concrete` + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/issues/issue-20714.rs b/src/test/ui/issues/issue-20714.rs index 0a4817c1164dd..3aa39bb7388fa 100644 --- a/src/test/ui/issues/issue-20714.rs +++ b/src/test/ui/issues/issue-20714.rs @@ -1,5 +1,5 @@ struct G; fn main() { - let g = G(); //~ ERROR: expected function, found `G` + let g = G(); //~ ERROR: expected function, found struct `G` } diff --git a/src/test/ui/issues/issue-20714.stderr b/src/test/ui/issues/issue-20714.stderr index 2d88ce5e51107..a3447aa6845b9 100644 --- a/src/test/ui/issues/issue-20714.stderr +++ b/src/test/ui/issues/issue-20714.stderr @@ -1,13 +1,19 @@ -error[E0618]: expected function, found `G` +error[E0618]: expected function, found struct `G` --> $DIR/issue-20714.rs:4:13 | LL | struct G; - | -------- `G` defined here + | -------- struct `G` defined here ... LL | let g = G(); | ^-- | | | call expression requires function + | +help: `G` is a unit struct, and does not take parentheses to be constructed + | +LL - let g = G(); +LL + let g = G; + | error: aborting due to previous error diff --git a/src/test/ui/issues/issue-21701.rs b/src/test/ui/issues/issue-21701.rs index fb2d5a4ad2a2c..bfa03c5e42f8d 100644 --- a/src/test/ui/issues/issue-21701.rs +++ b/src/test/ui/issues/issue-21701.rs @@ -7,7 +7,7 @@ struct Bar; pub fn some_func() { let f = Bar(); -//~^ ERROR: expected function, found `Bar` +//~^ ERROR: expected function, found struct `Bar` } fn main() { diff --git a/src/test/ui/issues/issue-21701.stderr b/src/test/ui/issues/issue-21701.stderr index ada6f44319dec..9f1fe7dde735a 100644 --- a/src/test/ui/issues/issue-21701.stderr +++ b/src/test/ui/issues/issue-21701.stderr @@ -8,16 +8,22 @@ LL | let y = t(); | | | call expression requires function -error[E0618]: expected function, found `Bar` +error[E0618]: expected function, found struct `Bar` --> $DIR/issue-21701.rs:9:13 | LL | struct Bar; - | ---------- `Bar` defined here + | ---------- struct `Bar` defined here ... LL | let f = Bar(); | ^^^-- | | | call expression requires function + | +help: `Bar` is a unit struct, and does not take parentheses to be constructed + | +LL - let f = Bar(); +LL + let f = Bar; + | error: aborting due to 2 previous errors diff --git a/src/test/ui/methods/method-path-in-pattern.stderr b/src/test/ui/methods/method-path-in-pattern.stderr index ed3c0222c7542..1d1bdb6b052a8 100644 --- a/src/test/ui/methods/method-path-in-pattern.stderr +++ b/src/test/ui/methods/method-path-in-pattern.stderr @@ -4,13 +4,13 @@ error[E0533]: expected unit struct, unit variant or constant, found associated f LL | Foo::bar => {} | ^^^^^^^^ -error[E0533]: expected unit struct, unit variant or constant, found associated function `::bar` +error[E0533]: expected unit struct, unit variant or constant, found associated function `Foo::bar` --> $DIR/method-path-in-pattern.rs:19:9 | LL | ::bar => {} | ^^^^^^^^^^ -error[E0533]: expected unit struct, unit variant or constant, found associated function `::trait_bar` +error[E0533]: expected unit struct, unit variant or constant, found associated function `Foo::trait_bar` --> $DIR/method-path-in-pattern.rs:23:9 | LL | ::trait_bar => {} @@ -22,7 +22,7 @@ error[E0533]: expected unit struct, unit variant or constant, found associated f LL | if let Foo::bar = 0u32 {} | ^^^^^^^^ -error[E0533]: expected unit struct, unit variant or constant, found associated function `::bar` +error[E0533]: expected unit struct, unit variant or constant, found associated function `Foo::bar` --> $DIR/method-path-in-pattern.rs:28:12 | LL | if let ::bar = 0u32 {} diff --git a/src/test/ui/qualified/qualified-path-params.stderr b/src/test/ui/qualified/qualified-path-params.stderr index 2be2deeb75549..82cc6e19f9d1e 100644 --- a/src/test/ui/qualified/qualified-path-params.stderr +++ b/src/test/ui/qualified/qualified-path-params.stderr @@ -1,4 +1,4 @@ -error[E0533]: expected unit struct, unit variant or constant, found associated function `::A::f::` +error[E0533]: expected unit struct, unit variant or constant, found associated function `<::A>::f` --> $DIR/qualified-path-params.rs:20:9 | LL | ::A::f:: => {} diff --git a/src/test/ui/resolve/privacy-enum-ctor.stderr b/src/test/ui/resolve/privacy-enum-ctor.stderr index e546d9f64ecad..f885ac2151d61 100644 --- a/src/test/ui/resolve/privacy-enum-ctor.stderr +++ b/src/test/ui/resolve/privacy-enum-ctor.stderr @@ -336,14 +336,14 @@ error[E0618]: expected function, found enum variant `Z::Unit` --> $DIR/privacy-enum-ctor.rs:31:17 | LL | Unit, - | ---- `Z::Unit` defined here + | ---- enum variant `Z::Unit` defined here ... LL | let _ = Z::Unit(); | ^^^^^^^-- | | | call expression requires function | -help: `Z::Unit` is a unit variant, you need to write it without the parentheses +help: `Z::Unit` is a unit enum variant, and does not take parentheses to be constructed | LL - let _ = Z::Unit(); LL + let _ = Z::Unit; @@ -371,14 +371,14 @@ error[E0618]: expected function, found enum variant `m::E::Unit` --> $DIR/privacy-enum-ctor.rs:47:16 | LL | Unit, - | ---- `m::E::Unit` defined here + | ---- enum variant `m::E::Unit` defined here ... LL | let _: E = m::E::Unit(); | ^^^^^^^^^^-- | | | call expression requires function | -help: `m::E::Unit` is a unit variant, you need to write it without the parentheses +help: `m::E::Unit` is a unit enum variant, and does not take parentheses to be constructed | LL - let _: E = m::E::Unit(); LL + let _: E = m::E::Unit; @@ -406,14 +406,14 @@ error[E0618]: expected function, found enum variant `E::Unit` --> $DIR/privacy-enum-ctor.rs:55:16 | LL | Unit, - | ---- `E::Unit` defined here + | ---- enum variant `E::Unit` defined here ... LL | let _: E = E::Unit(); | ^^^^^^^-- | | | call expression requires function | -help: `E::Unit` is a unit variant, you need to write it without the parentheses +help: `E::Unit` is a unit enum variant, and does not take parentheses to be constructed | LL - let _: E = E::Unit(); LL + let _: E = E::Unit; diff --git a/src/test/ui/suggestions/issue-99240-2.rs b/src/test/ui/suggestions/issue-99240-2.rs new file mode 100644 index 0000000000000..0a418b5aeef1d --- /dev/null +++ b/src/test/ui/suggestions/issue-99240-2.rs @@ -0,0 +1,10 @@ +enum Enum { + Unit, +} +type Alias = Enum; + +fn main() { + Alias:: + Unit(); + //~^^ ERROR expected function, found enum variant `Alias::Unit` +} diff --git a/src/test/ui/suggestions/issue-99240-2.stderr b/src/test/ui/suggestions/issue-99240-2.stderr new file mode 100644 index 0000000000000..2af60f5975992 --- /dev/null +++ b/src/test/ui/suggestions/issue-99240-2.stderr @@ -0,0 +1,24 @@ +error[E0618]: expected function, found enum variant `Alias::Unit` + --> $DIR/issue-99240-2.rs:7:5 + | +LL | Unit, + | ---- enum variant `Alias::Unit` defined here +... +LL | Alias:: + | _____^ + | |_____| + | || +LL | || Unit(); + | ||________^_- call expression requires function + | |_________| + | + | +help: `Alias::Unit` is a unit enum variant, and does not take parentheses to be constructed + | +LL - Unit(); +LL + Unit; + | + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0618`. diff --git a/src/test/ui/suggestions/issue-99240.rs b/src/test/ui/suggestions/issue-99240.rs new file mode 100644 index 0000000000000..2115a42662e1a --- /dev/null +++ b/src/test/ui/suggestions/issue-99240.rs @@ -0,0 +1,6 @@ +fn fmt(it: &(std::cell::Cell>,)) { + (it.0.take())() + //~^ ERROR expected function +} + +fn main() {} diff --git a/src/test/ui/suggestions/issue-99240.stderr b/src/test/ui/suggestions/issue-99240.stderr new file mode 100644 index 0000000000000..f1bea688b4ed5 --- /dev/null +++ b/src/test/ui/suggestions/issue-99240.stderr @@ -0,0 +1,11 @@ +error[E0618]: expected function, found `Option` + --> $DIR/issue-99240.rs:2:5 + | +LL | (it.0.take())() + | ^^^^^^^^^^^^^-- + | | + | call expression requires function + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0618`. diff --git a/src/test/ui/type-alias-enum-variants/incorrect-variant-form-through-alias-caught.stderr b/src/test/ui/type-alias-enum-variants/incorrect-variant-form-through-alias-caught.stderr index 8ddf9f7cd6819..8f3180a8639d8 100644 --- a/src/test/ui/type-alias-enum-variants/incorrect-variant-form-through-alias-caught.stderr +++ b/src/test/ui/type-alias-enum-variants/incorrect-variant-form-through-alias-caught.stderr @@ -20,14 +20,14 @@ error[E0618]: expected function, found enum variant `Alias::Unit` --> $DIR/incorrect-variant-form-through-alias-caught.rs:15:5 | LL | enum Enum { Braced {}, Unit, Tuple() } - | ---- `Alias::Unit` defined here + | ---- enum variant `Alias::Unit` defined here ... LL | Alias::Unit(); | ^^^^^^^^^^^-- | | | call expression requires function | -help: `Alias::Unit` is a unit variant, you need to write it without the parentheses +help: `Alias::Unit` is a unit enum variant, and does not take parentheses to be constructed | LL - Alias::Unit(); LL + Alias::Unit;