nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 16:24:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #110024 - matthiaskrgr:rollup-mydkufd, r=matthiaskrgr

Browse Source 
Rollup of 6 pull requests

Successful merges:

 - #109806 (Workaround #109797 on windows-gnu)
 - #109957 (diagnostics: account for self type when looking for source of unsolved type variable)
 - #109960 (Fix buffer overrun in bootstrap and (test-only) symlink_junction)
 - #110013 (Label `non_exhaustive` attribute on privacy errors from non-local items)
 - #110016 (Run collapsed GUI test in mobile mode as well)
 - #110022 (fix: fix regression in #109203)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2023-04-07 00:11:26 +00:00
commit c934ce9e0a
17 changed files with 184 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
View File

@ -1191,11 +1191,14 @@ impl<'a, 'tcx> Visitor<'tcx> for FindInferSourceVisitor<'a, 'tcx> {
have_turbofish,
} = args;
let generics = tcx.generics_of(generics_def_id);
if let Some(argument_index) = generics
if let Some(mut argument_index) = generics
.own_substs(substs)
.iter()
.position(|&arg| self.generic_arg_contains_target(arg))
{
if generics.parent.is_none() && generics.has_self {
argument_index += 1;
}
let substs = self.infcx.resolve_vars_if_possible(substs);
let generic_args = &generics.own_substs_no_defaults(tcx, substs)
[generics.own_counts().lifetimes..];

4
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@ -423,11 +423,11 @@ impl<'a> Parser<'a> {
if let token::Literal(Lit {
kind: token::LitKind::Integer | token::LitKind::Float,
symbol,
suffix,
suffix: Some(suffix), // no suffix makes it a valid literal
}) = self.token.kind
&& rustc_ast::MetaItemLit::from_token(&self.token).is_none()
{
Some((symbol.as_str().len(), suffix.unwrap()))
Some((symbol.as_str().len(), suffix))
} else {
None
}

20
compiler/rustc_resolve/src/diagnostics.rs
View File

@ -1607,7 +1607,17 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let mut err =
struct_span_err!(self.tcx.sess, ident.span, E0603, "{} `{}` is private", descr, ident);
err.span_label(ident.span, &format!("private {}", descr));
if let Some(span) = ctor_fields_span {
let mut non_exhaustive = None;
// If an ADT is foreign and marked as `non_exhaustive`, then that's
// probably why we have the privacy error.
// Otherwise, point out if the struct has any private fields.
if let Some(def_id) = res.opt_def_id()
&& !def_id.is_local()
&& let Some(attr) = self.tcx.get_attr(def_id, sym::non_exhaustive)
{
non_exhaustive = Some(attr.span);
} else if let Some(span) = ctor_fields_span {
err.span_label(span, "a constructor is private if any of the fields is private");
if let Res::Def(_, d) = res && let Some(fields) = self.field_visibility_spans.get(&d) {
err.multipart_suggestion_verbose(
@ -1656,6 +1666,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if !first && binding.vis.is_public() {
note_span.push_span_label(def_span, "consider importing it directly");
}
// Final step in the import chain, point out if the ADT is `non_exhaustive`
// which is probably why this privacy violation occurred.
if next_binding.is_none() && let Some(span) = non_exhaustive {
note_span.push_span_label(
span,
format!("cannot be constructed because it is `#[non_exhaustive]`"),
);
}
err.span_note(note_span, &msg);
}

4
library/std/src/sys/common/thread_local/os_local.rs
View File

@ -49,7 +49,9 @@ macro_rules! __thread_local_inner {
#[inline]
fn __init() -> $t { $init }
#[cfg_attr(not(bootstrap), inline)]
// `#[inline] does not work on windows-gnu due to linking errors around dllimports.
// See https://github.com/rust-lang/rust/issues/109797.
#[cfg_attr(not(windows), inline)]
unsafe fn __getit(
init: $crate::option::Option<&mut $crate::option::Option<$t>>,
) -> $crate::option::Option<&'static $t> {

34
library/std/src/sys/windows/fs.rs
View File

@ -1403,24 +1403,40 @@ fn symlink_junction_inner(original: &Path, junction: &Path) -> io::Result<()> {
opts.custom_flags(c::FILE_FLAG_OPEN_REPARSE_POINT | c::FILE_FLAG_BACKUP_SEMANTICS);
let f = File::open(junction, &opts)?;
let h = f.as_inner().as_raw_handle();
unsafe {
let mut data = Align8([MaybeUninit::<u8>::uninit(); c::MAXIMUM_REPARSE_DATA_BUFFER_SIZE]);
let data_ptr = data.0.as_mut_ptr();
let data_end = data_ptr.add(c::MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
let db = data_ptr.cast::<c::REPARSE_MOUNTPOINT_DATA_BUFFER>();
// Zero the header to ensure it's fully initialized, including reserved parameters.
*db = mem::zeroed();
let buf = ptr::addr_of_mut!((*db).ReparseTarget).cast::<c::WCHAR>();
let mut i = 0;
let reparse_target_slice = {
let buf_start = ptr::addr_of_mut!((*db).ReparseTarget).cast::<c::WCHAR>();
// Compute offset in bytes and then divide so that we round down
// rather than hit any UB (admittedly this arithmetic should work
// out so that this isn't necessary)
let buf_len_bytes = usize::try_from(data_end.byte_offset_from(buf_start)).unwrap();
let buf_len_wchars = buf_len_bytes / core::mem::size_of::<c::WCHAR>();
core::slice::from_raw_parts_mut(buf_start, buf_len_wchars)
};
// FIXME: this conversion is very hacky
let v = br"\??\";
let v = v.iter().map(|x| *x as u16);
for c in v.chain(original.as_os_str().encode_wide()) {
*buf.add(i) = c;
let iter = br"\??\"
.iter()
.map(|x| *x as u16)
.chain(original.as_os_str().encode_wide())
.chain(core::iter::once(0));
let mut i = 0;
for c in iter {
if i >= reparse_target_slice.len() {
return Err(crate::io::const_io_error!(
crate::io::ErrorKind::InvalidFilename,
"Input filename is too long"
));
}
reparse_target_slice[i] = c;
i += 1;
}
*buf.add(i) = 0;
i += 1;
(*db).ReparseTag = c::IO_REPARSE_TAG_MOUNT_POINT;
(*db).ReparseTargetMaximumLength = (i * 2) as c::WORD;
(*db).ReparseTargetLength = ((i - 1) * 2) as c::WORD;

11
src/bootstrap/Cargo.lock
View File

@ -45,6 +45,7 @@ dependencies = [
"hex",
"ignore",
"is-terminal",
"junction",
"libc",
"object",
"once_cell",
@ -349,6 +350,16 @@ version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d"
[[package]]
name = "junction"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca39ef0d69b18e6a2fd14c2f0a1d593200f4a4ed949b240b5917ab51fac754cb"
dependencies = [
"scopeguard",
"winapi",
]
[[package]]
name = "lazy_static"
version = "1.4.0"

3
src/bootstrap/Cargo.toml
View File

@ -61,6 +61,9 @@ sysinfo = { version = "0.26.0", optional = true }
[target.'cfg(not(target_os = "solaris"))'.dependencies]
fd-lock = "3.0.8"
[target.'cfg(windows)'.dependencies.junction]
version = "1.0.0"
[target.'cfg(windows)'.dependencies.windows]
version = "0.46.0"
features = [

99
src/bootstrap/util.rs
View File

@ -146,106 +146,9 @@ pub fn symlink_dir(config: &Config, src: &Path, dest: &Path) -> io::Result<()> {
fs::symlink(src, dest)
}
// Creating a directory junction on windows involves dealing with reparse
// points and the DeviceIoControl function, and this code is a skeleton of
// what can be found here:
//
// http://www.flexhex.com/docs/articles/hard-links.phtml
#[cfg(windows)]
fn symlink_dir_inner(target: &Path, junction: &Path) -> io::Result<()> {
use std::ffi::OsStr;
use std::os::windows::ffi::OsStrExt;
use windows::{
core::PCWSTR,
Win32::Foundation::{CloseHandle, HANDLE},
Win32::Storage::FileSystem::{
CreateFileW, FILE_ACCESS_FLAGS, FILE_FLAG_BACKUP_SEMANTICS,
FILE_FLAG_OPEN_REPARSE_POINT, FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE,
MAXIMUM_REPARSE_DATA_BUFFER_SIZE, OPEN_EXISTING,
},
Win32::System::Ioctl::FSCTL_SET_REPARSE_POINT,
Win32::System::SystemServices::{GENERIC_WRITE, IO_REPARSE_TAG_MOUNT_POINT},
Win32::System::IO::DeviceIoControl,
};
#[allow(non_snake_case)]
#[repr(C)]
struct REPARSE_MOUNTPOINT_DATA_BUFFER {
ReparseTag: u32,
ReparseDataLength: u32,
Reserved: u16,
ReparseTargetLength: u16,
ReparseTargetMaximumLength: u16,
Reserved1: u16,
ReparseTarget: u16,
}
fn to_u16s<S: AsRef<OsStr>>(s: S) -> io::Result<Vec<u16>> {
Ok(s.as_ref().encode_wide().chain(Some(0)).collect())
}
// We're using low-level APIs to create the junction, and these are more
// picky about paths. For example, forward slashes cannot be used as a
// path separator, so we should try to canonicalize the path first.
let target = fs::canonicalize(target)?;
fs::create_dir(junction)?;
let path = to_u16s(junction)?;
let h = unsafe {
CreateFileW(
PCWSTR(path.as_ptr()),
FILE_ACCESS_FLAGS(GENERIC_WRITE),
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
None,
OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
HANDLE::default(),
)
}
.map_err(|_| io::Error::last_os_error())?;
unsafe {
#[repr(C, align(8))]
struct Align8<T>(T);
let mut data = Align8([0u8; MAXIMUM_REPARSE_DATA_BUFFER_SIZE as usize]);
let db = data.0.as_mut_ptr() as *mut REPARSE_MOUNTPOINT_DATA_BUFFER;
let buf = core::ptr::addr_of_mut!((*db).ReparseTarget) as *mut u16;
let mut i = 0;
// FIXME: this conversion is very hacky
let v = br"\??\";
let v = v.iter().map(|x| *x as u16);
for c in v.chain(target.as_os_str().encode_wide().skip(4)) {
*buf.offset(i) = c;
i += 1;
}
*buf.offset(i) = 0;
i += 1;
(*db).ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
(*db).ReparseTargetMaximumLength = (i * 2) as u16;
(*db).ReparseTargetLength = ((i - 1) * 2) as u16;
(*db).ReparseDataLength = ((*db).ReparseTargetLength + 12) as u32;
let mut ret = 0u32;
DeviceIoControl(
h,
FSCTL_SET_REPARSE_POINT,
Some(db.cast()),
(*db).ReparseDataLength + 8,
None,
0,
Some(&mut ret),
None,
)
.ok()
.map_err(|_| io::Error::last_os_error())?;
}
unsafe { CloseHandle(h) };
Ok(())
junction::create(&target, &junction)
}
}

35
tests/rustdoc-gui/go-to-collapsed-elem.goml
View File

@ -9,13 +9,32 @@ property: ("#implementations-list .implementors-toggle", {"open": "false"})
click: "//*[@class='sidebar']//a[@href='#method.must_use']"
assert-property: ("#implementations-list .implementors-toggle", {"open": "true"})
// Now we do the same through search result.
// First we reload the page without the anchor in the URL.
define-function: ("collapsed-from-search", (), block {
// Now we do the same through search result.
// First we reload the page without the anchor in the URL.
goto: "file://" + |DOC_PATH| + "/test_docs/struct.Foo.html"
// Then we collapse the section again...
property: ("#implementations-list .implementors-toggle", {"open": "false"})
// Then we run the search.
write: (".search-input", "foo::must_use")
wait-for: "//*[@id='search']//a[@href='../test_docs/struct.Foo.html#method.must_use']"
click: "//*[@id='search']//a[@href='../test_docs/struct.Foo.html#method.must_use']"
assert-property: ("#implementations-list .implementors-toggle", {"open": "true"})
})
call-function: ("collapsed-from-search", {})
// Now running the same check but with mobile.
size: (600, 600)
goto: "file://" + |DOC_PATH| + "/test_docs/struct.Foo.html"
// Then we collapse the section again...
property: ("#implementations-list .implementors-toggle", {"open": "false"})
// Then we run the search.
write: (".search-input", "foo::must_use")
wait-for: "//*[@id='search']//a[@href='../test_docs/struct.Foo.html#method.must_use']"
click: "//*[@id='search']//a[@href='../test_docs/struct.Foo.html#method.must_use']"
// We check that the implementors block is expanded.
assert-property: ("#implementations-list .implementors-toggle", {"open": "true"})
// We now collapse the implementors block.
property: ("#implementations-list .implementors-toggle", {"open": "false"})
// First we expand the mobile menu.
click: ".sidebar-menu-toggle"
// Then we click on the link to the method to ensure it'll expand the implementors block.
click: "//*[@class='sidebar shown']//a[@href='#method.must_use']"
assert-property: ("#implementations-list .implementors-toggle", {"open": "true"})
call-function: ("collapsed-from-search", {})

3
tests/ui/inference/need_type_info/concrete-impl.rs
View File

@ -7,10 +7,13 @@ struct Two;
struct Struct;
impl Ambiguous<One> for Struct {}
//~^ NOTE multiple `impl`s satisfying `Struct: Ambiguous<_>` found
impl Ambiguous<Two> for Struct {}
fn main() {
<Struct as Ambiguous<_>>::method();
//~^ ERROR type annotations needed
//~| NOTE cannot infer type of the type parameter `A`
//~| ERROR type annotations needed
//~| NOTE infer type of the type parameter `A`
}

9
tests/ui/inference/need_type_info/concrete-impl.stderr
View File

@ -1,20 +1,21 @@
error[E0282]: type annotations needed
--> $DIR/concrete-impl.rs:13:5
--> $DIR/concrete-impl.rs:14:5
|
LL | <Struct as Ambiguous<_>>::method();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `Self` declared on the trait `Ambiguous`
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `A` declared on the trait `Ambiguous`
error[E0283]: type annotations needed
--> $DIR/concrete-impl.rs:13:5
--> $DIR/concrete-impl.rs:14:5
|
LL | <Struct as Ambiguous<_>>::method();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `Self` declared on the trait `Ambiguous`
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `A` declared on the trait `Ambiguous`
|
note: multiple `impl`s satisfying `Struct: Ambiguous<_>` found
--> $DIR/concrete-impl.rs:9:1
|
LL | impl Ambiguous<One> for Struct {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL |
LL | impl Ambiguous<Two> for Struct {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

25
tests/ui/inference/need_type_info/issue-109905.rs Normal file
View File

@ -0,0 +1,25 @@
// Test that we show the correct type parameter that couldn't be inferred and that we don't
// end up stating nonsense like "type parameter `'a`" which we used to do.
trait Trait<'a, T> {
fn m(self);
}
impl<'a, A> Trait<'a, A> for () {
fn m(self) {}
}
fn qualified() {
<() as Trait<'static, _>>::m(());
//~^ ERROR type annotations needed
//~| NOTE cannot infer type of the type parameter `T`
}
fn unqualified() {
Trait::<'static, _>::m(());
//~^ ERROR type annotations needed
//~| NOTE cannot infer type of the type parameter `T`
}
fn main() {}

15
tests/ui/inference/need_type_info/issue-109905.stderr Normal file
View File

@ -0,0 +1,15 @@
error[E0282]: type annotations needed
--> $DIR/issue-109905.rs:13:5
|
LL | <() as Trait<'static, _>>::m(());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the trait `Trait`
error[E0282]: type annotations needed
--> $DIR/issue-109905.rs:20:5
|
LL | Trait::<'static, _>::m(());
| ^^^^^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the trait `Trait`
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0282`.

3
tests/ui/parser/issues/issue-110014.rs Normal file
View File

@ -0,0 +1,3 @@
fn`2222222222222222222222222222222222222222() {}
//~^ ERROR unknown start of token: `
//~^^ ERROR expected identifier, found `2222222222222222222222222222222222222222`

19
tests/ui/parser/issues/issue-110014.stderr Normal file
View File

@ -0,0 +1,19 @@
error: unknown start of token: `
--> $DIR/issue-110014.rs:1:3
|
LL | fn`2222222222222222222222222222222222222222() {}
| ^
|
help: Unicode character '`' (Grave Accent) looks like ''' (Single Quote), but it is not
|
LL | fn'2222222222222222222222222222222222222222() {}
| ~
error: expected identifier, found `2222222222222222222222222222222222222222`
--> $DIR/issue-110014.rs:1:4
|
LL | fn`2222222222222222222222222222222222222222() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected identifier
error: aborting due to 2 previous errors

9
tests/ui/rfc-2008-non-exhaustive/struct.stderr
View File

@ -10,14 +10,11 @@ error[E0603]: tuple struct constructor `TupleStruct` is private
LL | let ts_explicit = structs::TupleStruct(640, 480);
| ^^^^^^^^^^^ private tuple struct constructor
|
::: $DIR/auxiliary/structs.rs:12:24
|
LL | pub struct TupleStruct(pub u16, pub u16);
| ---------------- a constructor is private if any of the fields is private
|
note: the tuple struct constructor `TupleStruct` is defined here
--> $DIR/auxiliary/structs.rs:12:1
|
LL | #[non_exhaustive]
| ----------------- cannot be constructed because it is `#[non_exhaustive]`
LL | pub struct TupleStruct(pub u16, pub u16);
| ^^^^^^^^^^^^^^^^^^^^^^
@ -30,6 +27,8 @@ LL | let us_explicit = structs::UnitStruct;
note: the unit struct `UnitStruct` is defined here
--> $DIR/auxiliary/structs.rs:9:1
|
LL | #[non_exhaustive]
| ----------------- cannot be constructed because it is `#[non_exhaustive]`
LL | pub struct UnitStruct;
| ^^^^^^^^^^^^^^^^^^^^^

20
tests/ui/rfc-2008-non-exhaustive/variant.stderr
View File

@ -8,7 +8,9 @@ note: the tuple variant `Tuple` is defined here
--> $DIR/auxiliary/variants.rs:5:23
|
LL | #[non_exhaustive] Tuple(u32),
| ^^^^^
| ----------------- ^^^^^
| |
| cannot be constructed because it is `#[non_exhaustive]`
error[E0603]: unit variant `Unit` is private
--> $DIR/variant.rs:14:47
@ -20,7 +22,9 @@ note: the unit variant `Unit` is defined here
--> $DIR/auxiliary/variants.rs:4:23
|
LL | #[non_exhaustive] Unit,
| ^^^^
| ----------------- ^^^^
| |
| cannot be constructed because it is `#[non_exhaustive]`
error[E0603]: unit variant `Unit` is private
--> $DIR/variant.rs:18:32
@ -32,7 +36,9 @@ note: the unit variant `Unit` is defined here
--> $DIR/auxiliary/variants.rs:4:23
|
LL | #[non_exhaustive] Unit,
| ^^^^
| ----------------- ^^^^
| |
| cannot be constructed because it is `#[non_exhaustive]`
error[E0603]: tuple variant `Tuple` is private
--> $DIR/variant.rs:20:32
@ -44,7 +50,9 @@ note: the tuple variant `Tuple` is defined here
--> $DIR/auxiliary/variants.rs:5:23
|
LL | #[non_exhaustive] Tuple(u32),
| ^^^^^
| ----------------- ^^^^^
| |
| cannot be constructed because it is `#[non_exhaustive]`
error[E0603]: tuple variant `Tuple` is private
--> $DIR/variant.rs:26:35
@ -56,7 +64,9 @@ note: the tuple variant `Tuple` is defined here
--> $DIR/auxiliary/variants.rs:5:23
|
LL | #[non_exhaustive] Tuple(u32),
| ^^^^^
| ----------------- ^^^^^
| |
| cannot be constructed because it is `#[non_exhaustive]`
error[E0639]: cannot create non-exhaustive variant using struct expression
--> $DIR/variant.rs:8:26