Skip to content

Commit 8d6b88b

Browse files
borsbors
committed
Auto merge of #130237 - matthiaskrgr:rollup-qmgr8i7, r=matthiaskrgr
Rollup of 9 pull requests Successful merges: - #129260 (Don't suggest adding return type for closures with default return type) - #129520 (Suggest the correct pattern syntax on usage of unit variant pattern for a struct variant) - #129866 (Clarify documentation labelling and definitions for std::collections) - #130123 (Report the `note` when specified in `diagnostic::on_unimplemented`) - #130161 (refactor merge base logic and fix `x fmt`) - #130206 (Map `WSAEDQUOT` to `ErrorKind::FilesystemQuotaExceeded`) - #130207 (Map `ERROR_CANT_RESOLVE_FILENAME` to `ErrorKind::FilesystemLoop`) - #130219 (Fix false positive with `missing_docs` and `#[test]`) - #130221 (Make SearchPath::new public) r? `@ghost` `@rustbot` modify labels: rollup
2 parents 5bce6d4 + 678c249 commit 8d6b88b

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

43 files changed

+354
-171
lines changed

Diff for: ‎compiler/rustc_builtin_macros/src/test.rs

+2
Original file line numberDiff line numberDiff line change
@@ -277,6 +277,8 @@ pub(crate) fn expand_test_or_bench(
277277
cx.attr_nested_word(sym::cfg, sym::test, attr_sp),
278278
// #[rustc_test_marker = "test_case_sort_key"]
279279
cx.attr_name_value_str(sym::rustc_test_marker, test_path_symbol, attr_sp),
280+
// #[doc(hidden)]
281+
cx.attr_nested_word(sym::doc, sym::hidden, attr_sp),
280282
],
281283
// const $ident: test::TestDescAndFn =
282284
ast::ItemKind::Const(

Diff for: ‎compiler/rustc_builtin_macros/src/test_harness.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -326,8 +326,8 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
326326
let main_attr = ecx.attr_word(sym::rustc_main, sp);
327327
// #[coverage(off)]
328328
let coverage_attr = ecx.attr_nested_word(sym::coverage, sym::off, sp);
329-
// #[allow(missing_docs)]
330-
let missing_docs_attr = ecx.attr_nested_word(sym::allow, sym::missing_docs, sp);
329+
// #[doc(hidden)]
330+
let doc_hidden_attr = ecx.attr_nested_word(sym::doc, sym::hidden, sp);
331331

332332
// pub fn main() { ... }
333333
let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(ThinVec::new()));
@@ -357,7 +357,7 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
357357

358358
let main = P(ast::Item {
359359
ident: main_id,
360-
attrs: thin_vec![main_attr, coverage_attr, missing_docs_attr],
360+
attrs: thin_vec![main_attr, coverage_attr, doc_hidden_attr],
361361
id: ast::DUMMY_NODE_ID,
362362
kind: main,
363363
vis: ast::Visibility { span: sp, kind: ast::VisibilityKind::Public, tokens: None },

Diff for: ‎compiler/rustc_hir_typeck/src/_match.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -389,7 +389,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
389389
{
390390
// check that the `if` expr without `else` is the fn body's expr
391391
if expr.span == sp {
392-
return self.get_fn_decl(hir_id).map(|(_, fn_decl, _)| {
392+
return self.get_fn_decl(hir_id).map(|(_, fn_decl)| {
393393
let (ty, span) = match fn_decl.output {
394394
hir::FnRetTy::DefaultReturn(span) => ("()".to_string(), span),
395395
hir::FnRetTy::Return(ty) => (ty_to_string(&self.tcx, ty), ty.span),

Diff for: ‎compiler/rustc_hir_typeck/src/coercion.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -1860,10 +1860,10 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
18601860
};
18611861

18621862
// If this is due to an explicit `return`, suggest adding a return type.
1863-
if let Some((fn_id, fn_decl, can_suggest)) = fcx.get_fn_decl(block_or_return_id)
1863+
if let Some((fn_id, fn_decl)) = fcx.get_fn_decl(block_or_return_id)
18641864
&& !due_to_block
18651865
{
1866-
fcx.suggest_missing_return_type(&mut err, fn_decl, expected, found, can_suggest, fn_id);
1866+
fcx.suggest_missing_return_type(&mut err, fn_decl, expected, found, fn_id);
18671867
}
18681868

18691869
// If this is due to a block, then maybe we forgot a `return`/`break`.

Diff for: ‎compiler/rustc_hir_typeck/src/expr.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -774,7 +774,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
774774
self.ret_coercion_span.set(Some(expr.span));
775775
}
776776
let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
777-
if let Some((_, fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
777+
if let Some((_, fn_decl)) = self.get_fn_decl(expr.hir_id) {
778778
coercion.coerce_forced_unit(
779779
self,
780780
&cause,

Diff for: ‎compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

+13-26
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ use rustc_middle::{bug, span_bug};
3030
use rustc_session::lint;
3131
use rustc_span::def_id::LocalDefId;
3232
use rustc_span::hygiene::DesugaringKind;
33-
use rustc_span::symbol::{kw, sym};
33+
use rustc_span::symbol::kw;
3434
use rustc_span::Span;
3535
use rustc_target::abi::FieldIdx;
3636
use rustc_trait_selection::error_reporting::infer::need_type_info::TypeAnnotationNeeded;
@@ -859,38 +859,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
859859
)
860860
}
861861

862-
/// Given a `HirId`, return the `HirId` of the enclosing function, its `FnDecl`, and whether a
863-
/// suggestion can be made, `None` otherwise.
862+
/// Given a `HirId`, return the `HirId` of the enclosing function and its `FnDecl`.
864863
pub(crate) fn get_fn_decl(
865864
&self,
866865
blk_id: HirId,
867-
) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>, bool)> {
866+
) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>)> {
868867
// Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
869868
// `while` before reaching it, as block tail returns are not available in them.
870869
self.tcx.hir().get_fn_id_for_return_block(blk_id).and_then(|item_id| {
871870
match self.tcx.hir_node(item_id) {
872871
Node::Item(&hir::Item {
873-
ident,
874-
kind: hir::ItemKind::Fn(ref sig, ..),
875-
owner_id,
876-
..
877-
}) => {
878-
// This is less than ideal, it will not suggest a return type span on any
879-
// method called `main`, regardless of whether it is actually the entry point,
880-
// but it will still present it as the reason for the expected type.
881-
Some((owner_id.def_id, sig.decl, ident.name != sym::main))
882-
}
872+
kind: hir::ItemKind::Fn(ref sig, ..), owner_id, ..
873+
}) => Some((owner_id.def_id, sig.decl)),
883874
Node::TraitItem(&hir::TraitItem {
884875
kind: hir::TraitItemKind::Fn(ref sig, ..),
885876
owner_id,
886877
..
887-
}) => Some((owner_id.def_id, sig.decl, true)),
888-
// FIXME: Suggestable if this is not a trait implementation
878+
}) => Some((owner_id.def_id, sig.decl)),
889879
Node::ImplItem(&hir::ImplItem {
890880
kind: hir::ImplItemKind::Fn(ref sig, ..),
891881
owner_id,
892882
..
893-
}) => Some((owner_id.def_id, sig.decl, false)),
883+
}) => Some((owner_id.def_id, sig.decl)),
894884
Node::Expr(&hir::Expr {
895885
hir_id,
896886
kind: hir::ExprKind::Closure(&hir::Closure { def_id, kind, fn_decl, .. }),
@@ -901,33 +891,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
901891
// FIXME(async_closures): Implement this.
902892
return None;
903893
}
904-
hir::ClosureKind::Closure => Some((def_id, fn_decl, true)),
894+
hir::ClosureKind::Closure => Some((def_id, fn_decl)),
905895
hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
906896
_,
907897
hir::CoroutineSource::Fn,
908898
)) => {
909-
let (ident, sig, owner_id) = match self.tcx.parent_hir_node(hir_id) {
899+
let (sig, owner_id) = match self.tcx.parent_hir_node(hir_id) {
910900
Node::Item(&hir::Item {
911-
ident,
912901
kind: hir::ItemKind::Fn(ref sig, ..),
913902
owner_id,
914903
..
915-
}) => (ident, sig, owner_id),
904+
}) => (sig, owner_id),
916905
Node::TraitItem(&hir::TraitItem {
917-
ident,
918906
kind: hir::TraitItemKind::Fn(ref sig, ..),
919907
owner_id,
920908
..
921-
}) => (ident, sig, owner_id),
909+
}) => (sig, owner_id),
922910
Node::ImplItem(&hir::ImplItem {
923-
ident,
924911
kind: hir::ImplItemKind::Fn(ref sig, ..),
925912
owner_id,
926913
..
927-
}) => (ident, sig, owner_id),
914+
}) => (sig, owner_id),
928915
_ => return None,
929916
};
930-
Some((owner_id.def_id, sig.decl, ident.name != sym::main))
917+
Some((owner_id.def_id, sig.decl))
931918
}
932919
_ => None,
933920
}

Diff for: ‎compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1873,7 +1873,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
18731873
// that highlight errors inline.
18741874
let mut sp = blk.span;
18751875
let mut fn_span = None;
1876-
if let Some((fn_def_id, decl, _)) = self.get_fn_decl(blk.hir_id) {
1876+
if let Some((fn_def_id, decl)) = self.get_fn_decl(blk.hir_id) {
18771877
let ret_sp = decl.output.span();
18781878
if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
18791879
// HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the

Diff for: ‎compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

+36-13
Original file line numberDiff line numberDiff line change
@@ -79,9 +79,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
7979
// `break` type mismatches provide better context for tail `loop` expressions.
8080
return false;
8181
}
82-
if let Some((fn_id, fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
82+
if let Some((fn_id, fn_decl)) = self.get_fn_decl(blk_id) {
8383
pointing_at_return_type =
84-
self.suggest_missing_return_type(err, fn_decl, expected, found, can_suggest, fn_id);
84+
self.suggest_missing_return_type(err, fn_decl, expected, found, fn_id);
8585
self.suggest_missing_break_or_return_expr(
8686
err, expr, fn_decl, expected, found, blk_id, fn_id,
8787
);
@@ -813,7 +813,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
813813
fn_decl: &hir::FnDecl<'tcx>,
814814
expected: Ty<'tcx>,
815815
found: Ty<'tcx>,
816-
can_suggest: bool,
817816
fn_id: LocalDefId,
818817
) -> bool {
819818
// Can't suggest `->` on a block-like coroutine
@@ -826,28 +825,26 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
826825
let found =
827826
self.resolve_numeric_literals_with_default(self.resolve_vars_if_possible(found));
828827
// Only suggest changing the return type for methods that
829-
// haven't set a return type at all (and aren't `fn main()` or an impl).
828+
// haven't set a return type at all (and aren't `fn main()`, impl or closure).
830829
match &fn_decl.output {
831-
&hir::FnRetTy::DefaultReturn(span) if expected.is_unit() && !can_suggest => {
832-
// `fn main()` must return `()`, do not suggest changing return type
833-
err.subdiagnostic(errors::ExpectedReturnTypeLabel::Unit { span });
834-
return true;
835-
}
830+
// For closure with default returns, don't suggest adding return type
831+
&hir::FnRetTy::DefaultReturn(_) if self.tcx.is_closure_like(fn_id.to_def_id()) => {}
836832
&hir::FnRetTy::DefaultReturn(span) if expected.is_unit() => {
837-
if let Some(found) = found.make_suggestable(self.tcx, false, None) {
833+
if !self.can_add_return_type(fn_id) {
834+
err.subdiagnostic(errors::ExpectedReturnTypeLabel::Unit { span });
835+
} else if let Some(found) = found.make_suggestable(self.tcx, false, None) {
838836
err.subdiagnostic(errors::AddReturnTypeSuggestion::Add {
839837
span,
840838
found: found.to_string(),
841839
});
842-
return true;
843840
} else if let Some(sugg) = suggest_impl_trait(self, self.param_env, found) {
844841
err.subdiagnostic(errors::AddReturnTypeSuggestion::Add { span, found: sugg });
845-
return true;
846842
} else {
847843
// FIXME: if `found` could be `impl Iterator` we should suggest that.
848844
err.subdiagnostic(errors::AddReturnTypeSuggestion::MissingHere { span });
849-
return true;
850845
}
846+
847+
return true;
851848
}
852849
hir::FnRetTy::Return(hir_ty) => {
853850
if let hir::TyKind::OpaqueDef(item_id, ..) = hir_ty.kind
@@ -905,6 +902,32 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
905902
false
906903
}
907904

905+
/// Checks whether we can add a return type to a function.
906+
/// Assumes given function doesn't have a explicit return type.
907+
fn can_add_return_type(&self, fn_id: LocalDefId) -> bool {
908+
match self.tcx.hir_node_by_def_id(fn_id) {
909+
Node::Item(&hir::Item { ident, .. }) => {
910+
// This is less than ideal, it will not suggest a return type span on any
911+
// method called `main`, regardless of whether it is actually the entry point,
912+
// but it will still present it as the reason for the expected type.
913+
ident.name != sym::main
914+
}
915+
Node::ImplItem(item) => {
916+
// If it doesn't impl a trait, we can add a return type
917+
let Node::Item(&hir::Item {
918+
kind: hir::ItemKind::Impl(&hir::Impl { of_trait, .. }),
919+
..
920+
}) = self.tcx.parent_hir_node(item.hir_id())
921+
else {
922+
unreachable!();
923+
};
924+
925+
of_trait.is_none()
926+
}
927+
_ => true,
928+
}
929+
}
930+
908931
fn try_note_caller_chooses_ty_for_ty_param(
909932
&self,
910933
diag: &mut Diag<'_>,

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

+31-1
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,7 @@ pub use coercion::can_coerce;
4343
use fn_ctxt::FnCtxt;
4444
use rustc_data_structures::unord::UnordSet;
4545
use rustc_errors::codes::*;
46-
use rustc_errors::{struct_span_code_err, Applicability, ErrorGuaranteed};
46+
use rustc_errors::{pluralize, struct_span_code_err, Applicability, ErrorGuaranteed};
4747
use rustc_hir as hir;
4848
use rustc_hir::def::{DefKind, Res};
4949
use rustc_hir::intravisit::Visitor;
@@ -423,6 +423,36 @@ fn report_unexpected_variant_res(
423423
err.multipart_suggestion_verbose(descr, suggestion, Applicability::MaybeIncorrect);
424424
err
425425
}
426+
Res::Def(DefKind::Variant, _) if expr.is_none() => {
427+
err.span_label(span, format!("not a {expected}"));
428+
429+
let fields = &tcx.expect_variant_res(res).fields.raw;
430+
let span = qpath.span().shrink_to_hi().to(span.shrink_to_hi());
431+
let (msg, sugg) = if fields.is_empty() {
432+
("use the struct variant pattern syntax".to_string(), " {}".to_string())
433+
} else {
434+
let msg = format!(
435+
"the struct variant's field{s} {are} being ignored",
436+
s = pluralize!(fields.len()),
437+
are = pluralize!("is", fields.len())
438+
);
439+
let fields = fields
440+
.iter()
441+
.map(|field| format!("{}: _", field.name.to_ident_string()))
442+
.collect::<Vec<_>>()
443+
.join(", ");
444+
let sugg = format!(" {{ {} }}", fields);
445+
(msg, sugg)
446+
};
447+
448+
err.span_suggestion_verbose(
449+
qpath.span().shrink_to_hi().to(span.shrink_to_hi()),
450+
msg,
451+
sugg,
452+
Applicability::HasPlaceholders,
453+
);
454+
err
455+
}
426456
_ => err.with_span_label(span, format!("not a {expected}")),
427457
}
428458
.emit()

Diff for: ‎compiler/rustc_hir_typeck/src/method/suggest.rs

+9-5
Original file line numberDiff line numberDiff line change
@@ -1317,7 +1317,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
13171317
let actual_prefix = rcvr_ty.prefix_string(self.tcx);
13181318
info!("unimplemented_traits.len() == {}", unimplemented_traits.len());
13191319
let mut long_ty_file = None;
1320-
let (primary_message, label) = if unimplemented_traits.len() == 1
1320+
let (primary_message, label, notes) = if unimplemented_traits.len() == 1
13211321
&& unimplemented_traits_only
13221322
{
13231323
unimplemented_traits
@@ -1327,16 +1327,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
13271327
if trait_ref.self_ty().references_error() || rcvr_ty.references_error()
13281328
{
13291329
// Avoid crashing.
1330-
return (None, None);
1330+
return (None, None, Vec::new());
13311331
}
1332-
let OnUnimplementedNote { message, label, .. } = self
1332+
let OnUnimplementedNote { message, label, notes, .. } = self
13331333
.err_ctxt()
13341334
.on_unimplemented_note(trait_ref, &obligation, &mut long_ty_file);
1335-
(message, label)
1335+
(message, label, notes)
13361336
})
13371337
.unwrap()
13381338
} else {
1339-
(None, None)
1339+
(None, None, Vec::new())
13401340
};
13411341
let primary_message = primary_message.unwrap_or_else(|| {
13421342
format!(
@@ -1363,6 +1363,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
13631363
"the following trait bounds were not satisfied:\n{bound_list}"
13641364
));
13651365
}
1366+
for note in notes {
1367+
err.note(note);
1368+
}
1369+
13661370
suggested_derive = self.suggest_derive(&mut err, unsatisfied_predicates);
13671371

13681372
unsatisfied_bounds = true;

Diff for: ‎compiler/rustc_session/src/search_paths.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -96,7 +96,7 @@ impl SearchPath {
9696
Self::new(PathKind::All, make_target_lib_path(sysroot, triple))
9797
}
9898

99-
fn new(kind: PathKind, dir: PathBuf) -> Self {
99+
pub fn new(kind: PathKind, dir: PathBuf) -> Self {
100100
// Get the files within the directory.
101101
let files = match std::fs::read_dir(&dir) {
102102
Ok(files) => files

Diff for: ‎compiler/rustc_span/src/symbol.rs

-1
Original file line numberDiff line numberDiff line change
@@ -1236,7 +1236,6 @@ symbols! {
12361236
mir_unwind_unreachable,
12371237
mir_variant,
12381238
miri,
1239-
missing_docs,
12401239
mmx_reg,
12411240
modifiers,
12421241
module,

0 commit comments

Comments
 (0)