nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #100174 - Dylan-DPC:rollup-wnskbk6, r=Dylan-DPC

Browse Source 
Rollup of 6 pull requests

Successful merges:

 - #99835 (Suggest adding/removing `ref` for binding patterns)
 - #100155 (Use `node_type_opt` to skip over generics that were not expected)
 - #100157 (rustdoc: use `collect()` instead of repeatedly pushing)
 - #100158 (kmc-solid: Add a stub implementation of #98246 (`File::set_times`))
 - #100166 (Remove more Clean trait implementations)
 - #100168 (Improve diagnostics for `const a: = expr;`)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2022-08-05 16:35:15 +00:00
commit affe0d3a00
30 changed files with 414 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
compiler/rustc_parse/src/parser/item.rs
View File

@ -1179,10 +1179,11 @@ impl<'a> Parser<'a> {
// Parse the type of a `const` or `static mut?` item.
// That is, the `":" $ty` fragment.
let ty = if self.eat(&token::Colon) {
self.parse_ty()?
} else {
self.recover_missing_const_type(id, m)
let ty = match (self.eat(&token::Colon), self.check(&token::Eq) | self.check(&token::Semi))
{
// If there wasn't a `:` or the colon was followed by a `=` or `;` recover a missing type.
(true, false) => self.parse_ty()?,
(colon, _) => self.recover_missing_const_type(colon, m),
};
let expr = if self.eat(&token::Eq) { Some(self.parse_expr()?) } else { None };
@ -1190,9 +1191,9 @@ impl<'a> Parser<'a> {
Ok((id, ty, expr))
}
/// We were supposed to parse `:` but the `:` was missing.
/// We were supposed to parse `":" $ty` but the `:` or the type was missing.
/// This means that the type is missing.
fn recover_missing_const_type(&mut self, id: Ident, m: Option<Mutability>) -> P<Ty> {
fn recover_missing_const_type(&mut self, colon_present: bool, m: Option<Mutability>) -> P<Ty> {
// Construct the error and stash it away with the hope
// that typeck will later enrich the error with a type.
let kind = match m {
@ -1200,18 +1201,25 @@ impl<'a> Parser<'a> {
Some(Mutability::Not) => "static",
None => "const",
};
let mut err = self.struct_span_err(id.span, &format!("missing type for `{kind}` item"));
let colon = match colon_present {
true => "",
false => ":",
};
let span = self.prev_token.span.shrink_to_hi();
let mut err = self.struct_span_err(span, &format!("missing type for `{kind}` item"));
err.span_suggestion(
id.span,
span,
"provide a type for the item",
format!("{id}: <type>"),
format!("{colon} <type>"),
Applicability::HasPlaceholders,
);
err.stash(id.span, StashKey::ItemNoType);
err.stash(span, StashKey::ItemNoType);
// The user intended that the type be inferred,
// so treat this as if the user wrote e.g. `const A: _ = expr;`.
P(Ty { kind: TyKind::Infer, span: id.span, id: ast::DUMMY_NODE_ID, tokens: None })
P(Ty { kind: TyKind::Infer, span, id: ast::DUMMY_NODE_ID, tokens: None })
}
/// Parses an enum declaration.

14
compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
View File

@ -1761,13 +1761,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
.filter_map(|seg| seg.args.as_ref())
.flat_map(|a| a.args.iter())
{
if let hir::GenericArg::Type(hir_ty) = &arg {
let ty = self.resolve_vars_if_possible(
self.typeck_results.borrow().node_type(hir_ty.hir_id),
);
if ty == predicate.self_ty() {
error.obligation.cause.span = hir_ty.span;
}
if let hir::GenericArg::Type(hir_ty) = &arg
&& let Some(ty) =
self.typeck_results.borrow().node_type_opt(hir_ty.hir_id)
&& self.resolve_vars_if_possible(ty) == predicate.self_ty()
{
error.obligation.cause.span = hir_ty.span;
break;
}
}
}

53
compiler/rustc_typeck/src/check/pat.rs
View File

@ -600,7 +600,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// If there are multiple arms, make sure they all agree on
// what the type of the binding `x` ought to be.
if var_id != pat.hir_id {
self.check_binding_alt_eq_ty(pat.span, var_id, local_ty, ti);
self.check_binding_alt_eq_ty(ba, pat.span, var_id, local_ty, ti);
}
if let Some(p) = sub {
@ -610,7 +610,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
local_ty
}
fn check_binding_alt_eq_ty(&self, span: Span, var_id: HirId, ty: Ty<'tcx>, ti: TopInfo<'tcx>) {
fn check_binding_alt_eq_ty(
&self,
ba: hir::BindingAnnotation,
span: Span,
var_id: HirId,
ty: Ty<'tcx>,
ti: TopInfo<'tcx>,
) {
let var_ty = self.local_ty(span, var_id).decl_ty;
if let Some(mut err) = self.demand_eqtype_pat_diag(span, var_ty, ty, ti) {
let hir = self.tcx.hir();
@ -628,12 +635,50 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
});
let pre = if in_match { "in the same arm, " } else { "" };
err.note(&format!("{}a binding must have the same type in all alternatives", pre));
// FIXME: check if `var_ty` and `ty` can be made the same type by adding or removing
// `ref` or `&` to the pattern.
self.suggest_adding_missing_ref_or_removing_ref(
&mut err,
span,
var_ty,
self.resolve_vars_with_obligations(ty),
ba,
);
err.emit();
}
}
fn suggest_adding_missing_ref_or_removing_ref(
&self,
err: &mut Diagnostic,
span: Span,
expected: Ty<'tcx>,
actual: Ty<'tcx>,
ba: hir::BindingAnnotation,
) {
match (expected.kind(), actual.kind(), ba) {
(ty::Ref(_, inner_ty, _), _, hir::BindingAnnotation::Unannotated)
if self.can_eq(self.param_env, *inner_ty, actual).is_ok() =>
{
err.span_suggestion_verbose(
span.shrink_to_lo(),
"consider adding `ref`",
"ref ",
Applicability::MaybeIncorrect,
);
}
(_, ty::Ref(_, inner_ty, _), hir::BindingAnnotation::Ref)
if self.can_eq(self.param_env, expected, *inner_ty).is_ok() =>
{
err.span_suggestion_verbose(
span.with_hi(span.lo() + BytePos(4)),
"consider removing `ref`",
"",
Applicability::MaybeIncorrect,
);
}
_ => (),
}
}
// Precondition: pat is a Ref(_) pattern
fn borrow_pat_suggestion(&self, err: &mut Diagnostic, pat: &Pat<'_>) {
let tcx = self.tcx;

5
compiler/rustc_typeck/src/collect/type_of.rs
View File

@ -801,6 +801,9 @@ fn infer_placeholder_type<'a>(
match tcx.sess.diagnostic().steal_diagnostic(span, StashKey::ItemNoType) {
Some(mut err) => {
if !ty.references_error() {
// Only suggest adding `:` if it was missing (and suggested by parsing diagnostic)
let colon = if span == item_ident.span.shrink_to_hi() { ":" } else { "" };
// The parser provided a sub-optimal `HasPlaceholders` suggestion for the type.
// We are typeck and have the real type, so remove that and suggest the actual type.
// FIXME(eddyb) this looks like it should be functionality on `Diagnostic`.
@ -816,7 +819,7 @@ fn infer_placeholder_type<'a>(
err.span_suggestion(
span,
&format!("provide a type for the {item}", item = kind),
format!("{}: {}", item_ident, sugg_ty),
format!("{colon} {sugg_ty}"),
Applicability::MachineApplicable,
);
} else {

12
library/std/src/sys/solid/fs.rs
View File

@ -77,6 +77,9 @@ pub struct OpenOptions {
custom_flags: i32,
}
#[derive(Copy, Clone, Debug, Default)]
pub struct FileTimes {}
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct FilePermissions(c_short);
@ -126,6 +129,11 @@ impl FilePermissions {
}
}
impl FileTimes {
pub fn set_accessed(&mut self, _t: SystemTime) {}
pub fn set_modified(&mut self, _t: SystemTime) {}
}
impl FileType {
pub fn is_dir(&self) -> bool {
self.is(abi::S_IFDIR)
@ -452,6 +460,10 @@ impl File {
pub fn set_permissions(&self, _perm: FilePermissions) -> io::Result<()> {
unsupported()
}
pub fn set_times(&self, _times: FileTimes) -> io::Result<()> {
unsupported()
}
}
impl Drop for File {

163
src/librustdoc/clean/mod.rs
View File

@ -156,7 +156,7 @@ impl<'tcx> Clean<'tcx, Option<GenericBound>> for hir::GenericBound<'tcx> {
return None;
}
GenericBound::TraitBound(t.clean(cx), modifier)
GenericBound::TraitBound(clean_poly_trait_ref(t, cx), modifier)
}
})
}
@ -1001,69 +1001,68 @@ fn clean_trait_ref<'tcx>(trait_ref: &hir::TraitRef<'tcx>, cx: &mut DocContext<'t
path
}
impl<'tcx> Clean<'tcx, PolyTrait> for hir::PolyTraitRef<'tcx> {
fn clean(&self, cx: &mut DocContext<'tcx>) -> PolyTrait {
PolyTrait {
trait_: clean_trait_ref(&self.trait_ref, cx),
generic_params: self
.bound_generic_params
.iter()
.filter(|p| !is_elided_lifetime(p))
.map(|x| clean_generic_param(cx, None, x))
.collect(),
}
fn clean_poly_trait_ref<'tcx>(
poly_trait_ref: &hir::PolyTraitRef<'tcx>,
cx: &mut DocContext<'tcx>,
) -> PolyTrait {
PolyTrait {
trait_: clean_trait_ref(&poly_trait_ref.trait_ref, cx),
generic_params: poly_trait_ref
.bound_generic_params
.iter()
.filter(|p| !is_elided_lifetime(p))
.map(|x| clean_generic_param(cx, None, x))
.collect(),
}
}
impl<'tcx> Clean<'tcx, Item> for hir::TraitItem<'tcx> {
fn clean(&self, cx: &mut DocContext<'tcx>) -> Item {
let local_did = self.def_id.to_def_id();
cx.with_param_env(local_did, |cx| {
let inner = match self.kind {
hir::TraitItemKind::Const(ty, Some(default)) => AssocConstItem(
clean_ty(ty, cx),
ConstantKind::Local { def_id: local_did, body: default },
),
hir::TraitItemKind::Const(ty, None) => TyAssocConstItem(clean_ty(ty, cx)),
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
let m = clean_function(cx, sig, self.generics, body);
MethodItem(m, None)
}
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Required(names)) => {
let (generics, decl) = enter_impl_trait(cx, |cx| {
// NOTE: generics must be cleaned before args
let generics = self.generics.clean(cx);
let args = clean_args_from_types_and_names(cx, sig.decl.inputs, names);
let decl = clean_fn_decl_with_args(cx, sig.decl, args);
(generics, decl)
});
TyMethodItem(Box::new(Function { decl, generics }))
}
hir::TraitItemKind::Type(bounds, Some(default)) => {
let generics = enter_impl_trait(cx, |cx| self.generics.clean(cx));
let bounds = bounds.iter().filter_map(|x| x.clean(cx)).collect();
let item_type = clean_middle_ty(hir_ty_to_ty(cx.tcx, default), cx, None);
AssocTypeItem(
Box::new(Typedef {
type_: clean_ty(default, cx),
generics,
item_type: Some(item_type),
}),
bounds,
)
}
hir::TraitItemKind::Type(bounds, None) => {
let generics = enter_impl_trait(cx, |cx| self.generics.clean(cx));
let bounds = bounds.iter().filter_map(|x| x.clean(cx)).collect();
TyAssocTypeItem(Box::new(generics), bounds)
}
};
let what_rustc_thinks =
Item::from_def_id_and_parts(local_did, Some(self.ident.name), inner, cx);
// Trait items always inherit the trait's visibility -- we don't want to show `pub`.
Item { visibility: Inherited, ..what_rustc_thinks }
})
}
fn clean_trait_item<'tcx>(trait_item: &hir::TraitItem<'tcx>, cx: &mut DocContext<'tcx>) -> Item {
let local_did = trait_item.def_id.to_def_id();
cx.with_param_env(local_did, |cx| {
let inner = match trait_item.kind {
hir::TraitItemKind::Const(ty, Some(default)) => AssocConstItem(
clean_ty(ty, cx),
ConstantKind::Local { def_id: local_did, body: default },
),
hir::TraitItemKind::Const(ty, None) => TyAssocConstItem(clean_ty(ty, cx)),
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
let m = clean_function(cx, sig, trait_item.generics, body);
MethodItem(m, None)
}
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Required(names)) => {
let (generics, decl) = enter_impl_trait(cx, |cx| {
// NOTE: generics must be cleaned before args
let generics = trait_item.generics.clean(cx);
let args = clean_args_from_types_and_names(cx, sig.decl.inputs, names);
let decl = clean_fn_decl_with_args(cx, sig.decl, args);
(generics, decl)
});
TyMethodItem(Box::new(Function { decl, generics }))
}
hir::TraitItemKind::Type(bounds, Some(default)) => {
let generics = enter_impl_trait(cx, |cx| trait_item.generics.clean(cx));
let bounds = bounds.iter().filter_map(|x| x.clean(cx)).collect();
let item_type = clean_middle_ty(hir_ty_to_ty(cx.tcx, default), cx, None);
AssocTypeItem(
Box::new(Typedef {
type_: clean_ty(default, cx),
generics,
item_type: Some(item_type),
}),
bounds,
)
}
hir::TraitItemKind::Type(bounds, None) => {
let generics = enter_impl_trait(cx, |cx| trait_item.generics.clean(cx));
let bounds = bounds.iter().filter_map(|x| x.clean(cx)).collect();
TyAssocTypeItem(Box::new(generics), bounds)
}
};
let what_rustc_thinks =
Item::from_def_id_and_parts(local_did, Some(trait_item.ident.name), inner, cx);
// Trait items always inherit the trait's visibility -- we don't want to show `pub`.
Item { visibility: Inherited, ..what_rustc_thinks }
})
}
impl<'tcx> Clean<'tcx, Item> for hir::ImplItem<'tcx> {
@ -1515,7 +1514,7 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
}
TyKind::Path(_) => clean_qpath(ty, cx),
TyKind::TraitObject(bounds, ref lifetime, _) => {
let bounds = bounds.iter().map(|bound| bound.clean(cx)).collect();
let bounds = bounds.iter().map(|bound| clean_poly_trait_ref(bound, cx)).collect();
let lifetime =
if !lifetime.is_elided() { Some(clean_lifetime(*lifetime, cx)) } else { None };
DynTrait(bounds, lifetime)
@ -1617,9 +1616,10 @@ pub(crate) fn clean_middle_ty<'tcx>(
// HACK: pick the first `did` as the `did` of the trait object. Someone
// might want to implement "native" support for marker-trait-only
// trait objects.
let mut dids = obj.principal_def_id().into_iter().chain(obj.auto_traits());
let did = dids
.next()
let mut dids = obj.auto_traits();
let did = obj
.principal_def_id()
.or_else(|| dids.next())
.unwrap_or_else(|| panic!("found trait object `{:?}` with no traits?", this));
let substs = match obj.principal() {
Some(principal) => principal.skip_binder().substs,
@ -1630,19 +1630,18 @@ pub(crate) fn clean_middle_ty<'tcx>(
inline::record_extern_fqn(cx, did, ItemType::Trait);
let lifetime = clean_middle_region(*reg);
let mut bounds = vec![];
let mut bounds = dids
.map(|did| {
let empty = cx.tcx.intern_substs(&[]);
let path = external_path(cx, did, false, vec![], empty);
inline::record_extern_fqn(cx, did, ItemType::Trait);
PolyTrait { trait_: path, generic_params: Vec::new() }
})
.collect::<Vec<_>>();
for did in dids {
let empty = cx.tcx.intern_substs(&[]);
let path = external_path(cx, did, false, vec![], empty);
inline::record_extern_fqn(cx, did, ItemType::Trait);
let bound = PolyTrait { trait_: path, generic_params: Vec::new() };
bounds.push(bound);
}
let mut bindings = vec![];
for pb in obj.projection_bounds() {
bindings.push(TypeBinding {
let bindings = obj
.projection_bounds()
.map(|pb| TypeBinding {
assoc: projection_to_path_segment(
pb.skip_binder()
.lift_to_tcx(cx.tcx)
@ -1656,8 +1655,8 @@ pub(crate) fn clean_middle_ty<'tcx>(
kind: TypeBindingKind::Equality {
term: clean_middle_term(pb.skip_binder().term, cx),
},
});
}
})
.collect();
let path = external_path(cx, did, false, bindings, substs);
bounds.insert(0, PolyTrait { trait_: path, generic_params: Vec::new() });
@ -1953,8 +1952,10 @@ fn clean_maybe_renamed_item<'tcx>(
})
}
ItemKind::Trait(_, _, generics, bounds, item_ids) => {
let items =
item_ids.iter().map(|ti| cx.tcx.hir().trait_item(ti.id).clean(cx)).collect();
let items = item_ids
.iter()
.map(|ti| clean_trait_item(cx.tcx.hir().trait_item(ti.id), cx))
.collect();
TraitItem(Trait {
def_id,

7
src/test/ui/argument-suggestions/issue-100154.rs Normal file
View File

@ -0,0 +1,7 @@
fn foo(i: impl std::fmt::Display) {}
fn main() {
foo::<()>(());
//~^ ERROR this function takes 0 generic arguments but 1 generic argument was supplied
//~| ERROR `()` doesn't implement `std::fmt::Display`
}

35
src/test/ui/argument-suggestions/issue-100154.stderr Normal file
View File

@ -0,0 +1,35 @@
error[E0107]: this function takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/issue-100154.rs:4:5
|
LL | foo::<()>(());
| ^^^------ help: remove these generics
| |
| expected 0 generic arguments
|
note: function defined here, with 0 generic parameters
--> $DIR/issue-100154.rs:1:4
|
LL | fn foo(i: impl std::fmt::Display) {}
| ^^^
= note: `impl Trait` cannot be explicitly specified as a generic argument
error[E0277]: `()` doesn't implement `std::fmt::Display`
--> $DIR/issue-100154.rs:4:15
|
LL | foo::<()>(());
| --------- ^^ `()` cannot be formatted with the default formatter
| |
| required by a bound introduced by this call
|
= help: the trait `std::fmt::Display` is not implemented for `()`
= note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
note: required by a bound in `foo`
--> $DIR/issue-100154.rs:1:16
|
LL | fn foo(i: impl std::fmt::Display) {}
| ^^^^^^^^^^^^^^^^^ required by this bound in `foo`
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0107, E0277.
For more information about an error, try `rustc --explain E0107`.

4
src/test/ui/attributes/issue-90873.stderr
View File

@ -34,10 +34,10 @@ LL | #![a={impl std::ops::Neg for i8 {}}]
| ^ consider adding a `main` function to `$DIR/issue-90873.rs`
error: missing type for `static` item
--> $DIR/issue-90873.rs:1:16
--> $DIR/issue-90873.rs:1:17
|
LL | #![u=||{static d=||1;}]
| ^ help: provide a type for the item: `d: <type>`
| ^ help: provide a type for the item: `: <type>`
error: aborting due to 6 previous errors

14
src/test/ui/issues/issue-69396-const-no-type-in-macro.stderr
View File

@ -17,10 +17,10 @@ LL | | }
= note: this error originates in the macro `suite` (in Nightly builds, run with -Z macro-backtrace for more info)
error: missing type for `const` item
--> $DIR/issue-69396-const-no-type-in-macro.rs:4:19
--> $DIR/issue-69396-const-no-type-in-macro.rs:4:20
|
LL | const A = "A".$fn();
| ^ help: provide a type for the constant: `A: usize`
| ^ help: provide a type for the constant: `: usize`
...
LL | / suite! {
LL | | len;
@ -31,13 +31,13 @@ LL | | }
= note: this error originates in the macro `suite` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
--> $DIR/issue-69396-const-no-type-in-macro.rs:4:19
--> $DIR/issue-69396-const-no-type-in-macro.rs:4:20
|
LL | const A = "A".$fn();
| ^
| |
| not allowed in type signatures
| help: replace with the correct type: `bool`
| ^
| |
| not allowed in type signatures
| help: replace with the correct type: `bool`
...
LL | / suite! {
LL | | len;

4
src/test/ui/mismatched_types/E0409.stderr
View File

@ -17,6 +17,10 @@ LL | (0, ref y) | (y, 0) => {}
| first introduced with type `&{integer}` here
|
= note: in the same arm, a binding must have the same type in all alternatives
help: consider adding `ref`
|
LL | (0, ref y) | (ref y, 0) => {}
| +++
error: aborting due to 2 previous errors

21
src/test/ui/mismatched_types/suggest-adding-or-removing-ref-for-binding-pattern.fixed Normal file
View File

@ -0,0 +1,21 @@
// run-rustfix
#![allow(dead_code, unused_variables)]
fn main() {
enum Blah {
A(isize, isize, usize),
B(isize, usize),
}
match Blah::A(1, 1, 2) {
Blah::A(_, x, ref y) | Blah::B(x, ref y) => {}
//~^ ERROR mismatched types
//~| ERROR variable `y` is bound inconsistently across alternatives separated by `|`
}
match Blah::A(1, 1, 2) {
Blah::A(_, x, y) | Blah::B(x, y) => {}
//~^ ERROR mismatched types
//~| variable `y` is bound inconsistently across alternatives separated by `|`
}
}

21
src/test/ui/mismatched_types/suggest-adding-or-removing-ref-for-binding-pattern.rs Normal file
View File

@ -0,0 +1,21 @@
// run-rustfix
#![allow(dead_code, unused_variables)]
fn main() {
enum Blah {
A(isize, isize, usize),
B(isize, usize),
}
match Blah::A(1, 1, 2) {
Blah::A(_, x, ref y) | Blah::B(x, y) => {}
//~^ ERROR mismatched types
//~| ERROR variable `y` is bound inconsistently across alternatives separated by `|`
}
match Blah::A(1, 1, 2) {
Blah::A(_, x, y) | Blah::B(x, ref y) => {}
//~^ ERROR mismatched types
//~| variable `y` is bound inconsistently across alternatives separated by `|`
}
}

49
src/test/ui/mismatched_types/suggest-adding-or-removing-ref-for-binding-pattern.stderr Normal file
View File

@ -0,0 +1,49 @@
error[E0409]: variable `y` is bound inconsistently across alternatives separated by `|`
--> $DIR/suggest-adding-or-removing-ref-for-binding-pattern.rs:11:43
|
LL | Blah::A(_, x, ref y) | Blah::B(x, y) => {}
| - first binding ^ bound in different ways
error[E0409]: variable `y` is bound inconsistently across alternatives separated by `|`
--> $DIR/suggest-adding-or-removing-ref-for-binding-pattern.rs:17:43
|
LL | Blah::A(_, x, y) | Blah::B(x, ref y) => {}
| - first binding ^ bound in different ways
error[E0308]: mismatched types
--> $DIR/suggest-adding-or-removing-ref-for-binding-pattern.rs:11:43
|
LL | match Blah::A(1, 1, 2) {
| ---------------- this expression has type `Blah`
LL | Blah::A(_, x, ref y) | Blah::B(x, y) => {}
| ----- ^ expected `&usize`, found `usize`
| |
| first introduced with type `&usize` here
|
= note: in the same arm, a binding must have the same type in all alternatives
help: consider adding `ref`
|
LL | Blah::A(_, x, ref y) | Blah::B(x, ref y) => {}
| +++
error[E0308]: mismatched types
--> $DIR/suggest-adding-or-removing-ref-for-binding-pattern.rs:17:39
|
LL | match Blah::A(1, 1, 2) {
| ---------------- this expression has type `Blah`
LL | Blah::A(_, x, y) | Blah::B(x, ref y) => {}
| - ^^^^^ expected `usize`, found `&usize`
| |
| first introduced with type `usize` here
|
= note: in the same arm, a binding must have the same type in all alternatives
help: consider removing `ref`
|
LL - Blah::A(_, x, y) | Blah::B(x, ref y) => {}
LL + Blah::A(_, x, y) | Blah::B(x, y) => {}
|
error: aborting due to 4 previous errors
Some errors have detailed explanations: E0308, E0409.
For more information about an error, try `rustc --explain E0308`.

4
src/test/ui/parser/issues/issue-89574.stderr
View File

@ -1,8 +1,8 @@
error: missing type for `const` item
--> $DIR/issue-89574.rs:2:11
--> $DIR/issue-89574.rs:2:22
|
LL | const EMPTY_ARRAY = [];
| ^^^^^^^^^^^ help: provide a type for the item: `EMPTY_ARRAY: <type>`
| ^ help: provide a type for the item: `: <type>`
error: aborting due to previous error

4
src/test/ui/parser/item-free-const-no-body-semantic-fail.stderr
View File

@ -15,10 +15,10 @@ LL | const B;
| help: provide a definition for the constant: `= <expr>;`
error: missing type for `const` item
--> $DIR/item-free-const-no-body-semantic-fail.rs:6:7
--> $DIR/item-free-const-no-body-semantic-fail.rs:6:8
|
LL | const B;
| ^ help: provide a type for the item: `B: <type>`
| ^ help: provide a type for the item: `: <type>`
error: aborting due to 3 previous errors

8
src/test/ui/parser/item-free-static-no-body-semantic-fail.stderr
View File

@ -31,16 +31,16 @@ LL | static mut D;
| help: provide a definition for the static: `= <expr>;`
error: missing type for `static` item
--> $DIR/item-free-static-no-body-semantic-fail.rs:6:8
--> $DIR/item-free-static-no-body-semantic-fail.rs:6:9
|
LL | static B;
| ^ help: provide a type for the item: `B: <type>`
| ^ help: provide a type for the item: `: <type>`
error: missing type for `static mut` item
--> $DIR/item-free-static-no-body-semantic-fail.rs:10:12
--> $DIR/item-free-static-no-body-semantic-fail.rs:10:13
|
LL | static mut D;
| ^ help: provide a type for the item: `D: <type>`
| ^ help: provide a type for the item: `: <type>`
error: aborting due to 6 previous errors

4
src/test/ui/parser/removed-syntax-static-fn.stderr
View File

@ -16,10 +16,10 @@ LL | }
| - the item list ends here
error: missing type for `static` item
--> $DIR/removed-syntax-static-fn.rs:4:12
--> $DIR/removed-syntax-static-fn.rs:4:14
|
LL | static fn f() {}
| ^^ help: provide a type for the item: `r#fn: <type>`
| ^ help: provide a type for the item: `: <type>`
error: aborting due to 3 previous errors

8
src/test/ui/resolve/resolve-inconsistent-binding-mode.stderr
View File

@ -31,6 +31,10 @@ LL | Opts::A(ref i) | Opts::B(i) => {}
| first introduced with type `&isize` here
|
= note: in the same arm, a binding must have the same type in all alternatives
help: consider adding `ref`
|
LL | Opts::A(ref i) | Opts::B(ref i) => {}
| +++
error[E0308]: mismatched types
--> $DIR/resolve-inconsistent-binding-mode.rs:18:34
@ -43,6 +47,10 @@ LL | Opts::A(ref i) | Opts::B(i) => {}
| first introduced with type `&isize` here
|
= note: in the same arm, a binding must have the same type in all alternatives
help: consider adding `ref`
|
LL | Opts::A(ref i) | Opts::B(ref i) => {}
| +++
error[E0308]: mismatched types
--> $DIR/resolve-inconsistent-binding-mode.rs:27:38

1
src/test/ui/resolve/resolve-inconsistent-names.rs
View File

@ -23,6 +23,7 @@ fn main() {
//~| ERROR mismatched types
//~| ERROR variable `c` is not bound in all patterns
//~| HELP if you meant to match on unit variant `E::A`, use the full path in the pattern
//~| HELP consider removing `ref`
}
let z = (10, 20);

9
src/test/ui/resolve/resolve-inconsistent-names.stderr
View File

@ -55,7 +55,7 @@ LL | (A, B) | (ref B, c) | (c, A) => ()
| first binding
error[E0408]: variable `CONST1` is not bound in all patterns
--> $DIR/resolve-inconsistent-names.rs:30:23
--> $DIR/resolve-inconsistent-names.rs:31:23
|
LL | (CONST1, _) | (_, Const2) => ()
| ------ ^^^^^^^^^^^ pattern doesn't bind `CONST1`
@ -69,7 +69,7 @@ LL | const CONST1: usize = 10;
| ^^^^^^^^^^^^^^^^^^^^^^^^^ not accessible
error[E0408]: variable `Const2` is not bound in all patterns
--> $DIR/resolve-inconsistent-names.rs:30:9
--> $DIR/resolve-inconsistent-names.rs:31:9
|
LL | (CONST1, _) | (_, Const2) => ()
| ^^^^^^^^^^^ ------ variable not in all patterns
@ -92,6 +92,11 @@ LL | (A, B) | (ref B, c) | (c, A) => ()
| first introduced with type `E` here
|
= note: in the same arm, a binding must have the same type in all alternatives
help: consider removing `ref`
|
LL - (A, B) | (ref B, c) | (c, A) => ()
LL + (A, B) | (B, c) | (c, A) => ()
|
error: aborting due to 9 previous errors

14
src/test/ui/suggestions/const-no-type.rs
View File

@ -14,38 +14,38 @@ fn main() {}
const C2 = 42;
//~^ ERROR missing type for `const` item
//~| HELP provide a type for the item
//~| SUGGESTION C2: <type>
//~| SUGGESTION : <type>
#[cfg(FALSE)]
static S2 = "abc";
//~^ ERROR missing type for `static` item
//~| HELP provide a type for the item
//~| SUGGESTION S2: <type>
//~| SUGGESTION : <type>
#[cfg(FALSE)]
static mut SM2 = "abc";
//~^ ERROR missing type for `static mut` item
//~| HELP provide a type for the item
//~| SUGGESTION SM2: <type>
//~| SUGGESTION : <type>
// These will, so the diagnostics should be stolen by typeck:
const C = 42;
//~^ ERROR missing type for `const` item
//~| HELP provide a type for the constant
//~| SUGGESTION C: i32
//~| SUGGESTION : i32
const D = &&42;
//~^ ERROR missing type for `const` item
//~| HELP provide a type for the constant
//~| SUGGESTION D: &&i32
//~| SUGGESTION : &&i32
static S = Vec::<String>::new();
//~^ ERROR missing type for `static` item
//~| HELP provide a type for the static variable
//~| SUGGESTION S: Vec<String>
//~| SUGGESTION : Vec<String>
static mut SM = "abc";
//~^ ERROR missing type for `static mut` item
//~| HELP provide a type for the static variable
//~| SUGGESTION &str
//~| SUGGESTION : &str

28
src/test/ui/suggestions/const-no-type.stderr
View File

@ -1,44 +1,44 @@
error: missing type for `const` item
--> $DIR/const-no-type.rs:33:7
--> $DIR/const-no-type.rs:33:8
|
LL | const C = 42;
| ^ help: provide a type for the constant: `C: i32`
| ^ help: provide a type for the constant: `: i32`
error: missing type for `const` item
--> $DIR/const-no-type.rs:38:7
--> $DIR/const-no-type.rs:38:8
|
LL | const D = &&42;
| ^ help: provide a type for the constant: `D: &&i32`
| ^ help: provide a type for the constant: `: &&i32`
error: missing type for `static` item
--> $DIR/const-no-type.rs:43:8
--> $DIR/const-no-type.rs:43:9
|
LL | static S = Vec::<String>::new();
| ^ help: provide a type for the static variable: `S: Vec<String>`
| ^ help: provide a type for the static variable: `: Vec<String>`
error: missing type for `static mut` item
--> $DIR/const-no-type.rs:48:12
--> $DIR/const-no-type.rs:48:14
|
LL | static mut SM = "abc";
| ^^ help: provide a type for the static variable: `SM: &str`
| ^ help: provide a type for the static variable: `: &str`
error: missing type for `const` item
--> $DIR/const-no-type.rs:14:7
--> $DIR/const-no-type.rs:14:9
|
LL | const C2 = 42;
| ^^ help: provide a type for the item: `C2: <type>`
| ^ help: provide a type for the item: `: <type>`
error: missing type for `static` item
--> $DIR/const-no-type.rs:20:8
--> $DIR/const-no-type.rs:20:10
|
LL | static S2 = "abc";
| ^^ help: provide a type for the item: `S2: <type>`
| ^ help: provide a type for the item: `: <type>`
error: missing type for `static mut` item
--> $DIR/const-no-type.rs:26:12
--> $DIR/const-no-type.rs:26:15
|
LL | static mut SM2 = "abc";
| ^^^ help: provide a type for the item: `SM2: <type>`
| ^ help: provide a type for the item: `: <type>`
error: aborting due to 7 previous errors

20
src/test/ui/suggestions/unnamable-types.stderr
View File

@ -1,8 +1,8 @@
error: missing type for `const` item
--> $DIR/unnamable-types.rs:6:7
--> $DIR/unnamable-types.rs:6:8
|
LL | const A = 5;
| ^ help: provide a type for the constant: `A: i32`
| ^ help: provide a type for the constant: `: i32`
error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
--> $DIR/unnamable-types.rs:10:11
@ -26,10 +26,10 @@ LL | const C: _ = || 42;
| ^^^^^
error: missing type for `const` item
--> $DIR/unnamable-types.rs:23:7
--> $DIR/unnamable-types.rs:23:8
|
LL | const D = S { t: { let i = 0; move || -> i32 { i } } };
| ^
| ^
|
note: however, the inferred type `S<[closure@$DIR/unnamable-types.rs:23:31: 23:45]>` cannot be named
--> $DIR/unnamable-types.rs:23:11
@ -38,22 +38,22 @@ LL | const D = S { t: { let i = 0; move || -> i32 { i } } };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: missing type for `const` item
--> $DIR/unnamable-types.rs:29:7
--> $DIR/unnamable-types.rs:29:8
|
LL | const E = foo;
| ^ help: provide a type for the constant: `E: fn() -> i32`
| ^ help: provide a type for the constant: `: fn() -> i32`
error: missing type for `const` item
--> $DIR/unnamable-types.rs:32:7
--> $DIR/unnamable-types.rs:32:8
|
LL | const F = S { t: foo };
| ^ help: provide a type for the constant: `F: S<fn() -> i32>`
| ^ help: provide a type for the constant: `: S<fn() -> i32>`
error: missing type for `const` item
--> $DIR/unnamable-types.rs:37:7
--> $DIR/unnamable-types.rs:37:8
|
LL | const G = || -> i32 { yield 0; return 1; };
| ^
| ^
|
note: however, the inferred type `[generator@$DIR/unnamable-types.rs:37:11: 37:20]` cannot be named
--> $DIR/unnamable-types.rs:37:11

4
src/test/ui/transmutability/references.stderr
View File

@ -1,8 +1,8 @@
error[E0277]: `&'static Unit` cannot be safely transmuted into `&'static Unit` in the defining scope of `assert::Context`.
--> $DIR/references.rs:19:52
--> $DIR/references.rs:19:37
|
LL | assert::is_maybe_transmutable::<&'static Unit, &'static Unit>();
| ^^^^^^^^^^^^^ `&'static Unit` cannot be safely transmuted into `&'static Unit` in the defining scope of `assert::Context`.
| ^^^^^^^^^^^^^ `&'static Unit` cannot be safely transmuted into `&'static Unit` in the defining scope of `assert::Context`.
|
= help: the trait `BikeshedIntrinsicFrom<&'static Unit, assert::Context, true, true, true, true>` is not implemented for `&'static Unit`
note: required by a bound in `is_maybe_transmutable`

9
src/test/ui/typeck/issue-100164.fixed Normal file
View File

@ -0,0 +1,9 @@
// run-rustfix
const _A: i32 = 123;
//~^ ERROR: missing type for `const` item
fn main() {
const _B: i32 = 123;
//~^ ERROR: missing type for `const` item
}

9
src/test/ui/typeck/issue-100164.rs Normal file
View File

@ -0,0 +1,9 @@
// run-rustfix
const _A: = 123;
//~^ ERROR: missing type for `const` item
fn main() {
const _B: = 123;
//~^ ERROR: missing type for `const` item
}

14
src/test/ui/typeck/issue-100164.stderr Normal file
View File

@ -0,0 +1,14 @@
error: missing type for `const` item
--> $DIR/issue-100164.rs:3:10
|
LL | const _A: = 123;
| ^ help: provide a type for the constant: `i32`
error: missing type for `const` item
--> $DIR/issue-100164.rs:7:14
|
LL | const _B: = 123;
| ^ help: provide a type for the constant: `i32`
error: aborting due to 2 previous errors

4
src/test/ui/typeck/issue-79040.stderr
View File

@ -7,10 +7,10 @@ LL | const FOO = "hello" + 1;
| &str
error: missing type for `const` item
--> $DIR/issue-79040.rs:2:11
--> $DIR/issue-79040.rs:2:14
|
LL | const FOO = "hello" + 1;
| ^^^ help: provide a type for the item: `FOO: <type>`
| ^ help: provide a type for the item: `: <type>`
error: aborting due to 2 previous errors

4
src/test/ui/typeck/typeck_type_placeholder_item.stderr
View File

@ -189,10 +189,10 @@ LL ~ b: (T, T),
|
error: missing type for `static` item
--> $DIR/typeck_type_placeholder_item.rs:73:12
--> $DIR/typeck_type_placeholder_item.rs:73:13
|
LL | static A = 42;
| ^ help: provide a type for the static variable: `A: i32`
| ^ help: provide a type for the static variable: `: i32`
error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
--> $DIR/typeck_type_placeholder_item.rs:75:15