Rollup of 5 pull requests

.gitmodules

@@ -15,13 +15,13 @@
 	url = https://github.com/rust-lang/book.git
 [submodule "src/tools/rls"]
 	path = src/tools/rls
-	url = https://github.com/rust-lang-nursery/rls.git
+	url = https://github.com/rust-lang/rls.git
 [submodule "src/tools/clippy"]
 	path = src/tools/clippy
-	url = https://github.com/rust-lang-nursery/rust-clippy.git
+	url = https://github.com/rust-lang/rust-clippy.git
 [submodule "src/tools/rustfmt"]
 	path = src/tools/rustfmt
-	url = https://github.com/rust-lang-nursery/rustfmt.git
+	url = https://github.com/rust-lang/rustfmt.git
 [submodule "src/tools/miri"]
 	path = src/tools/miri
 	url = https://github.com/rust-lang/miri.git

src/libcore/fmt/builders.rs

@@ -133,7 +133,7 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
-    pub fn field(&mut self, name: &str, value: &dyn fmt::Debug) -> &mut DebugStruct<'a, 'b> {
+    pub fn field(&mut self, name: &str, value: &dyn fmt::Debug) -> &mut Self {
         self.result = self.result.and_then(|_| {
             if self.is_pretty() {
                 if !self.has_fields {
@@ -330,7 +330,7 @@ impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
-    pub fn field(&mut self, value: &dyn fmt::Debug) -> &mut DebugTuple<'a, 'b> {
+    pub fn field(&mut self, value: &dyn fmt::Debug) -> &mut Self {
         self.result = self.result.and_then(|_| {
             if self.is_pretty() {
                 if self.fields == 0 {
@@ -492,7 +492,7 @@ impl<'a, 'b: 'a> DebugSet<'a, 'b> {
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
-    pub fn entry(&mut self, entry: &dyn fmt::Debug) -> &mut DebugSet<'a, 'b> {
+    pub fn entry(&mut self, entry: &dyn fmt::Debug) -> &mut Self {
         self.inner.entry(entry);
         self
     }
@@ -521,7 +521,7 @@ impl<'a, 'b: 'a> DebugSet<'a, 'b> {
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
-    pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>
+    pub fn entries<D, I>(&mut self, entries: I) -> &mut Self
     where
         D: fmt::Debug,
         I: IntoIterator<Item = D>,
@@ -624,7 +624,7 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> {
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
-    pub fn entry(&mut self, entry: &dyn fmt::Debug) -> &mut DebugList<'a, 'b> {
+    pub fn entry(&mut self, entry: &dyn fmt::Debug) -> &mut Self {
         self.inner.entry(entry);
         self
     }
@@ -653,7 +653,7 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> {
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
-    pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugList<'a, 'b>
+    pub fn entries<D, I>(&mut self, entries: I) -> &mut Self
     where
         D: fmt::Debug,
         I: IntoIterator<Item = D>,
@@ -760,7 +760,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
-    pub fn entry(&mut self, key: &dyn fmt::Debug, value: &dyn fmt::Debug) -> &mut DebugMap<'a, 'b> {
+    pub fn entry(&mut self, key: &dyn fmt::Debug, value: &dyn fmt::Debug) -> &mut Self {
         self.key(key).value(value)
     }
 
@@ -797,7 +797,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     /// );
     /// ```
     #[unstable(feature = "debug_map_key_value", reason = "recently added", issue = "62482")]
-    pub fn key(&mut self, key: &dyn fmt::Debug) -> &mut DebugMap<'a, 'b> {
+    pub fn key(&mut self, key: &dyn fmt::Debug) -> &mut Self {
         self.result = self.result.and_then(|_| {
             assert!(
                 !self.has_key,
@@ -862,7 +862,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     /// );
     /// ```
     #[unstable(feature = "debug_map_key_value", reason = "recently added", issue = "62482")]
-    pub fn value(&mut self, value: &dyn fmt::Debug) -> &mut DebugMap<'a, 'b> {
+    pub fn value(&mut self, value: &dyn fmt::Debug) -> &mut Self {
         self.result = self.result.and_then(|_| {
             assert!(self.has_key, "attempted to format a map value before its key");
 
@@ -908,7 +908,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
-    pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
+    pub fn entries<K, V, I>(&mut self, entries: I) -> &mut Self
     where
         K: fmt::Debug,
         V: fmt::Debug,

src/librustc_error_codes/error_codes/E0229.md

@@ -1,5 +1,7 @@
 An associated type binding was done outside of the type parameter declaration
-and `where` clause. Erroneous code example:
+and `where` clause.
+
+Erroneous code example:
 
 ```compile_fail,E0229
 pub trait Foo {

src/librustc_error_codes/error_codes/E0261.md

@@ -1,7 +1,6 @@
-When using a lifetime like `'a` in a type, it must be declared before being
-used.
+An undeclared lifetime was used.
 
-These two examples illustrate the problem:
+Erroneous code example:
 
 ```compile_fail,E0261
 // error, use of undeclared lifetime name `'a`

src/test/ui/type-alias-impl-trait/issue-57611-trait-alias.rs

@@ -0,0 +1,27 @@
+// Regression test for issue #57611
+// Ensures that we don't ICE
+// FIXME: This should compile, but it currently doesn't
+
+#![feature(trait_alias)]
+#![feature(type_alias_impl_trait)]
+
+trait Foo {
+    type Bar: Baz<Self, Self>;
+
+    fn bar(&self) -> Self::Bar;
+}
+
+struct X;
+
+impl Foo for X {
+    type Bar = impl Baz<Self, Self>; //~ ERROR type mismatch in closure arguments
+    //~^ ERROR type mismatch resolving
+
+    fn bar(&self) -> Self::Bar {
+        |x| x
+    }
+}
+
+trait Baz<A, B> = Fn(&A) -> &B;
+
+fn main() {}

src/test/ui/type-alias-impl-trait/issue-57611-trait-alias.stderr

@@ -0,0 +1,23 @@
+error[E0631]: type mismatch in closure arguments
+  --> $DIR/issue-57611-trait-alias.rs:17:5
+   |
+LL |     type Bar = impl Baz<Self, Self>;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected signature of `for<'r> fn(&'r X) -> _`
+...
+LL |         |x| x
+   |         ----- found signature of `fn(_) -> _`
+   |
+   = note: the return type of a function must have a statically known size
+
+error[E0271]: type mismatch resolving `for<'r> <[closure@$DIR/issue-57611-trait-alias.rs:21:9: 21:14] as std::ops::FnOnce<(&'r X,)>>::Output == &'r X`
+  --> $DIR/issue-57611-trait-alias.rs:17:5
+   |
+LL |     type Bar = impl Baz<Self, Self>;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected bound lifetime parameter, found concrete lifetime
+   |
+   = note: the return type of a function must have a statically known size
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0271, E0631.
+For more information about an error, try `rustc --explain E0271`.

src/test/ui/type-alias-impl-trait/issue-57807-associated-type.rs

@@ -0,0 +1,31 @@
+// Regression test for issue #57807 - ensure
+// that we properly unify associated types within
+// a type alias impl trait
+// check-pass
+#![feature(type_alias_impl_trait)]
+
+trait Bar {
+    type A;
+}
+
+impl Bar for () {
+    type A = ();
+}
+
+trait Foo {
+    type A;
+    type B: Bar<A = Self::A>;
+
+    fn foo() -> Self::B;
+}
+
+impl Foo for () {
+    type A = ();
+    type B = impl Bar<A = Self::A>;
+
+    fn foo() -> Self::B {
+        ()
+    }
+}
+
+fn main() {}

src/test/ui/use/auxiliary/extern-use-primitive-type-lib.rs

@@ -0,0 +1,3 @@
+// compile-flags: --edition=2018
+
+pub use u32;

src/test/ui/use/issue-60976-extern-use-primitive-type.rs

@@ -0,0 +1,7 @@
+// Regression test for #60976: ICE (with <=1.36.0) when another file had `use <primitive_type>;`.
+// check-pass
+// aux-build:extern-use-primitive-type-lib.rs
+
+extern crate extern_use_primitive_type_lib;
+
+fn main() {}