Merge branch 'master' into filtering+issue-101696

Author: JohnTitor

Cargo.lock

@@ -8,7 +8,7 @@ edition = "2021"
 
 [dependencies]
 alphanumeric-sort = "1.4.0"
-anyhow = "1.0.37"
+anyhow = { workspace = true }
 rayon = "1.5.0"
 tempfile = "3.1.0"
 
@@ -18,5 +18,11 @@ members = [
     "labeler"
 ]
 
+[workspace.dependencies]
+anyhow = "1.0.37"
+once_cell = "1.2.0"
+reqwest = { version = "0.11", features = ["blocking", "json"] }
+serde = { version = "1.0.101", features = ["derive"] }
+
 [patch.crates-io]
 glacier = { path = "." }

Cargo.toml

@@ -7,9 +7,9 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-anyhow = "1.0.26"
-git2 = { version = "0.15", default-features = false, features = ["https"] }
+anyhow = { workspace = true }
+git2 = { version = "0.16", default-features = false, features = ["https"] }
 glacier = "0.1.0"
-once_cell = "1.2.0"
-reqwest = { version = "0.11", features = ["blocking", "json"] }
-serde = { version = "1.0.101", features = ["derive"] }
+once_cell = { workspace = true }
+reqwest = { workspace = true }
+serde = { workspace = true }

autofix/Cargo.toml

@@ -18,16 +18,16 @@ fn format_descriptions(test: &TestResult) -> Result<Descriptions> {
     let title = test.title();
     let description = test.description().unwrap();
 
-    let commit_message = format!("{}\n\n{}\n", title, description);
+    let commit_message = format!("{title}\n\n{description}\n");
 
     let file = read_to_string(test.path())?;
     let syntax = test.syntax();
 
     let issue = format!("Issue: {}", test.issue_url());
-    let file_codeblock = format!("```{}\n{}\n```", syntax, file);
-    let description_codeblock = format!("```\n{}\n```", description);
+    let file_codeblock = format!("```{syntax}\n{file}\n```");
+    let description_codeblock = format!("```\n{description}\n```");
 
-    let pr_body = format!("{}\n{}\n{}\n", issue, file_codeblock, description_codeblock);
+    let pr_body = format!("{issue}\n{file_codeblock}\n{description_codeblock}\n");
 
     Ok(Descriptions {
         commit_message,
@@ -55,7 +55,7 @@ fn move_to_fixed<'a>(repo: &'a Repository, test: &TestResult) -> Result<Tree<'a>
     index.remove(test.path(), 0)?;
 
     let new_path =
-        new_path_bytes(test.path()).with_context(|| format!("ICE has no filename: {:?}", test))?;
+        new_path_bytes(test.path()).with_context(|| format!("ICE has no filename: {test:?}"))?;
 
     entry.path = new_path;
 
@@ -93,7 +93,7 @@ pub(crate) fn fix(test: &TestResult, config: &github::Config) -> Result<()> {
     let remote_branch = format!("refs/remotes/origin/autofix/{}", &path);
 
     if repo.find_reference(&remote_branch).is_ok() {
-        println!("Branch exists: {}", remote_branch);
+        println!("Branch exists: {remote_branch}");
         return Ok(());
     }
 
@@ -123,6 +123,6 @@ pub(crate) fn fix(test: &TestResult, config: &github::Config) -> Result<()> {
         },
     )?;
 
-    println!("Created pull request: {}", url);
+    println!("Created pull request: {url}");
     Ok(())
 }

autofix/src/fix.rs

@@ -50,7 +50,7 @@ pub(crate) fn pull_request(config: &Config, options: &PullRequestOptions) -> Res
     let url = format!("https://api.github.com/repos/{}/pulls", config.repo);
 
     let pr: PullRequest = CLIENT
-        .post(&url)
+        .post(url)
         .header(reqwest::header::ACCEPT, "application/vnd.github.v3+json")
         .bearer_auth(&config.token)
         .json(&options)

autofix/src/github.rs

@@ -9,4 +9,3 @@ fn main() {
 }
 
 EOF
-

ices/100114.rs fixed/100114.rs

@@ -1,7 +1,6 @@
 #!/bin/bash
 
-rustc   -Cincremental=/tmp/a -Zincremental-verify-ich=yes --crate-type lib - <<'EOF'
-
+rustc -Cincremental=/tmp/a -Zincremental-verify-ich=yes --crate-type lib - <<'EOF'
 
 #[derive(PartialEq, Eq)]
 struct Id<'a> {

ices/100183.rs fixed/100183.rs

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-rustc   -Cincremental=/tmp/a -Zincremental-verify-ich=yes --crate-type lib - <<'EOF'
+rustc -Cincremental=/tmp/a -Zincremental-verify-ich=yes --crate-type lib - <<'EOF'
 
 #[derive(Eq, PartialEq)]
 struct Id(&'static str);

ices/100672.rs fixed/100672.rs

@@ -0,0 +1,34 @@
+use std::marker::PhantomData;
+
+#[derive(Default)]
+struct MyType<'a> {
+    field: usize,
+    _phantom: PhantomData<&'a ()>,
+}
+
+#[derive(Default)]
+struct MyTypeVariant<'a> {
+    field: usize,
+    _phantom: PhantomData<&'a ()>,
+}
+
+trait AsVariantTrait {
+    type Type;
+}
+
+impl<'a> AsVariantTrait for MyType<'a> {
+    type Type = MyTypeVariant<'a>;
+}
+
+type Variant<G> = <G as AsVariantTrait>::Type;
+
+fn foo<T: Default, F: FnOnce(T)>(f: F) {
+    let input = T::default();
+    f(input);
+}
+
+fn main() {
+    foo(|a: Variant<MyType>| {
+        a.field;
+    });
+}

ices/100689.rs fixed/100689.rs

@@ -0,0 +1,32 @@
+use std::marker::PhantomData;
+
+#[derive(Default)]
+struct MyType<'a> {
+    field: usize,
+    _phantom: PhantomData<&'a ()>,
+}
+
+#[derive(Default)]
+struct MyTypeVariant<'a> {
+    field: usize,
+    _phantom: PhantomData<&'a ()>,
+}
+
+trait AsVariantTrait {
+    type Type;
+}
+
+impl<'a> AsVariantTrait for MyType<'a> {
+    type Type = MyTypeVariant<'a>;
+}
+
+fn foo<T: Default, F: FnOnce(T)>(f: F) {
+    let input = T::default();
+    f(input);
+}
+
+fn main() {
+    foo(|a: <MyType as AsVariantTrait>::Type| {
+        a.field;
+    });
+}

ices/100772.sh fixed/100772.sh

@@ -0,0 +1,19 @@
+pub trait Trait {
+    type Fut<'a> where Self: 'a;
+    fn fun<'a, 'b>(&'a self, x: &'_ mut &'b ()) -> Self::Fut<'a>
+    where
+        'b: 'a;
+}
+impl Trait for () {
+    type Fut<'a> = impl ::std::future::Future + 'a
+    where
+        Self: 'a;
+    fn fun<'a, 'b>(&'a self, x: &'_ mut &'b ()) -> Self::Fut<'a>
+    where
+        'b: 'a,
+    {
+        async { }
+    }
+}
+
+pub fn main() {}

ices/100783.sh fixed/100783.sh

@@ -1,27 +1,26 @@
-// build-pass
-// compile-flags: -Z mir-opt-level=3
-
-#![crate_type="lib"]
+#![crate_type = "lib"]
 #![feature(lang_items)]
 #![no_std]
 
+struct NonNull<T: ?Sized>(*mut T);
+
+struct Unique<T: ?Sized>(NonNull<T>);
+
 #[lang = "owned_box"]
-pub struct Box<T: ?Sized>(*mut T);
+pub struct Box<T: ?Sized>(Unique<T>);
 
 impl<T: ?Sized> Drop for Box<T> {
-    fn drop(&mut self) {
-    }
+    fn drop(&mut self) {}
 }
 
 #[lang = "box_free"]
 #[inline(always)]
-unsafe fn box_free<T: ?Sized>(ptr: *mut T) {
-    dealloc(ptr)
+unsafe fn box_free<T: ?Sized>(ptr: Unique<T>) {
+    dealloc(ptr.0.0)
 }
 
 #[inline(never)]
-fn dealloc<T: ?Sized>(_: *mut T) {
-}
+fn dealloc<T: ?Sized>(_: *mut T) {}
 
 pub struct Foo<T>(T);
 

ices/100818.rs fixed/100818.rs

@@ -0,0 +1,15 @@
+// crash with edition=2021
+pub struct Example<'a, T> {
+  a: T,
+  b: &'a T,
+}
+
+impl<'a, T> Example<'a, T> {
+  pub fn error_trying_to_destructure_self_in_closure(self) {
+    let closure = || {
+      let Self { a, b } = self;
+    };
+  }
+}
+
+pub fn main() {}

ices/101001.sh fixed/101001.sh

@@ -0,0 +1,6 @@
+trait A{type B<'b>;}
+struct C;
+impl A for C {
+    type B<b> =impl;
+    fn a() -> Self::B<'a>;
+}

ices/101036.rs fixed/101036.rs

@@ -0,0 +1,13 @@
+trait A {
+    type B<'b>;
+    fn a() -> Self::B<'static>;
+}
+
+struct C;
+
+struct Wrapper<T>(T);
+
+impl A for C {
+    type B<T> = Wrapper<T>;
+    fn a() -> Self::B<'static> {}
+}

ices/101465.rs fixed/101465.rs

@@ -0,0 +1,27 @@
+#![crate_type = "lib"]
+#![feature(inline_const, const_type_id)]
+
+use std::alloc::Layout;
+use std::any::TypeId;
+use std::mem::transmute;
+use std::ptr::drop_in_place;
+
+pub struct VTable {
+    layout: Layout,
+    type_id: TypeId,
+    drop_in_place: unsafe fn(*mut ()),
+}
+
+impl VTable {
+    pub fn new<T>() -> &'static Self {
+        const {
+            &VTable {
+                layout: Layout::new::<T>(),
+                type_id: TypeId::of::<T>(),
+                drop_in_place: unsafe {
+                    transmute::<unsafe fn(*mut T), unsafe fn(*mut ())>(drop_in_place::<T>)
+                },
+            }
+        }
+    }
+}

ices/101518-1.sh fixed/101518-1.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+rustc -Zmir-opt-level=3 - <<'EOF'
+
+const L: usize = 4;
+
+pub trait Print<const N: usize> {
+    fn print(&self) -> usize {
+        N
+    }
+}
+
+pub struct Printer;
+impl Print<L> for Printer {}
+
+fn main() {
+    let p = Printer;
+    assert_eq!(p.print(), 4);
+}
+
+EOF
+

ices/101518-2.sh fixed/101518-2.sh

@@ -0,0 +1,23 @@
+#![feature(return_position_impl_trait_in_trait)]
+
+trait Marker {}
+impl Marker for u32 {}
+
+trait MyTrait {
+    fn foo(&self) -> impl Marker
+        where Self: Sized;
+}
+
+struct Outer;
+
+impl MyTrait for Outer {
+    fn foo(&self) -> impl Marker {
+        42
+    }
+}
+
+impl dyn MyTrait {
+    fn other(&self) -> impl Marker {
+        MyTrait::foo(&self)
+    }
+}

ices/101660-1.rs fixed/101660-1.rs

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+cat > out.rs <<'EOF'
+
+trait A<Y, N> {
+    type B;
+}
+type MaybeBox<T> = <T as A<T, Box<T>>>::B;
+struct P {
+    t: MaybeBox<P>
+}
+impl<Y, N> A<Y, N> for P {
+    type B = N;
+}
+fn main() {
+    let t: MaybeBox<P>;
+}
+
+EOF
+
+rustdoc --edition=2021 out.rs

ices/101660-2.rs fixed/101660-2.rs

@@ -0,0 +1,12 @@
+#![feature(allocator_api)]
+
+#![feature(const_trait_impl)]
+use core::convert::{From, TryFrom};
+use std::pin::Pin;
+use std::alloc::Allocator;
+impl<T: ?Sized, A: Allocator> const From<Box<T, A>> for Pin<Box<T, A>>
+where
+    A: 'static,
+{}
+
+pub fn main() {}

ices/101665.rs fixed/101665.rs

@@ -0,0 +1,8 @@
+#![feature(dyn_star)]
+#![allow(incomplete_features)]
+
+use std::fmt::Debug;
+
+fn main() {
+    let i = 42 as &dyn* Debug;
+}