diff --git a/.gitignore b/.gitignore
index b7e8e8fa15752..87437a16fb392 100644
--- a/.gitignore
+++ b/.gitignore
@@ -69,8 +69,8 @@ __pycache__/
 *$py.class
 
 ## Node
-**node_modules
-**package-lock.json
+node_modules
+package-lock.json
 
 ## Rustdoc GUI tests
 src/test/rustdoc-gui/src/**.lock
diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs
index 1995fd64e6f2c..573124c8ec9a8 100644
--- a/compiler/rustc_index/src/bit_set.rs
+++ b/compiler/rustc_index/src/bit_set.rs
@@ -841,7 +841,7 @@ impl<T: Idx> GrowableBitSet<T> {
     #[inline]
     pub fn contains(&self, elem: T) -> bool {
         let (word_index, mask) = word_index_and_mask(elem);
-        if let Some(word) = self.bit_set.words.get(word_index) { (word & mask) != 0 } else { false }
+        self.bit_set.words.get(word_index).map_or(false, |word| (word & mask) != 0)
     }
 }
 
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index dea47c25a8e0a..e3970038a33b0 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1277,6 +1277,34 @@ impl<'a> Resolver<'a> {
 
         err.emit();
     }
+
+    crate fn find_similarly_named_module_or_crate(
+        &mut self,
+        ident: Symbol,
+        current_module: &Module<'a>,
+    ) -> Option<Symbol> {
+        let mut candidates = self
+            .extern_prelude
+            .iter()
+            .map(|(ident, _)| ident.name)
+            .chain(
+                self.module_map
+                    .iter()
+                    .filter(|(_, module)| {
+                        current_module.is_ancestor_of(module) && !ptr::eq(current_module, *module)
+                    })
+                    .map(|(_, module)| module.kind.name())
+                    .flatten(),
+            )
+            .filter(|c| !c.to_string().is_empty())
+            .collect::<Vec<_>>();
+        candidates.sort();
+        candidates.dedup();
+        match find_best_match_for_name(&candidates, ident, None) {
+            Some(sugg) if sugg == ident => None,
+            sugg => sugg,
+        }
+    }
 }
 
 impl<'a, 'b> ImportResolver<'a, 'b> {
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 3e7783033efa5..9652c483686f0 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -2555,7 +2555,22 @@ impl<'a> Resolver<'a> {
 
                             (format!("use of undeclared type `{}`", ident), suggestion)
                         } else {
-                            (format!("use of undeclared crate or module `{}`", ident), None)
+                            (
+                                format!("use of undeclared crate or module `{}`", ident),
+                                self.find_similarly_named_module_or_crate(
+                                    ident.name,
+                                    &parent_scope.module,
+                                )
+                                .map(|sugg| {
+                                    (
+                                        vec![(ident.span, sugg.to_string())],
+                                        String::from(
+                                            "there is a crate or module with a similar name",
+                                        ),
+                                        Applicability::MaybeIncorrect,
+                                    )
+                                }),
+                            )
                         }
                     } else {
                         let parent = path[i - 1].ident.name;
diff --git a/config.toml.example b/config.toml.example
index d811b914d20a1..b63ff14d7d38d 100644
--- a/config.toml.example
+++ b/config.toml.example
@@ -423,6 +423,18 @@ changelog-seen = 2
 # set this value to `true`.
 #debug-logging = rust.debug-assertions (boolean)
 
+# Whether or not overflow checks are enabled for the compiler and standard
+# library.
+#
+# Defaults to rust.debug value
+#overflow-checks = rust.debug (boolean)
+
+# Whether or not overflow checks are enabled for the standard library.
+# Overrides the `overflow-checks` option, if defined.
+#
+# Defaults to rust.overflow-checks value
+#overflow-checks-std = rust.overflow-checks (boolean)
+
 # Debuginfo level for most of Rust code, corresponds to the `-C debuginfo=N` option of `rustc`.
 # `0` - no debug info
 # `1` - line tables only - sufficient to generate backtraces that include line
diff --git a/library/alloc/src/str.rs b/library/alloc/src/str.rs
index ac7f230445656..e1d0ee42f4e90 100644
--- a/library/alloc/src/str.rs
+++ b/library/alloc/src/str.rs
@@ -538,7 +538,7 @@ impl str {
     /// [`make_ascii_uppercase`]: str::make_ascii_uppercase
     /// [`to_uppercase`]: #method.to_uppercase
     #[cfg(not(no_global_oom_handling))]
-    #[must_use = "to uppercase the value in-place, use `make_ascii_lowercase()`"]
+    #[must_use = "to uppercase the value in-place, use `make_ascii_uppercase()`"]
     #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
     #[inline]
     pub fn to_ascii_uppercase(&self) -> String {
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index a12acb1a1c07f..20a16869cb3f8 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -1973,8 +1973,9 @@ impl<T, A: Allocator> Vec<T, A> {
     /// `'a`. If the type has only static references, or none at all, then this
     /// may be chosen to be `'static`.
     ///
-    /// This function is similar to the [`leak`][Box::leak] function on [`Box`]
-    /// except that there is no way to recover the leaked memory.
+    /// As of Rust 1.57, this method does not reallocate or shrink the `Vec`,
+    /// so the leaked allocation may include unused capacity that is not part
+    /// of the returned slice.
     ///
     /// This function is mainly useful for data that lives for the remainder of
     /// the program's life. Dropping the returned reference will cause a memory
@@ -1997,7 +1998,8 @@ impl<T, A: Allocator> Vec<T, A> {
     where
         A: 'a,
     {
-        Box::leak(self.into_boxed_slice())
+        let mut me = ManuallyDrop::new(self);
+        unsafe { slice::from_raw_parts_mut(me.as_mut_ptr(), me.len) }
     }
 
     /// Returns the remaining spare capacity of the vector as a slice of
diff --git a/library/core/src/char/methods.rs b/library/core/src/char/methods.rs
index 3e7c5b3189cb5..3c4972bd3c9a4 100644
--- a/library/core/src/char/methods.rs
+++ b/library/core/src/char/methods.rs
@@ -328,9 +328,11 @@ impl char {
     ///
     /// ```should_panic
     /// // this panics
-    /// '1'.to_digit(37);
+    /// let _ = '1'.to_digit(37);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub fn to_digit(self, radix: u32) -> Option<u32> {
         assert!(radix <= 36, "to_digit: radix is too high (maximum 36)");
diff --git a/library/core/src/convert/mod.rs b/library/core/src/convert/mod.rs
index 83a73d9cbe506..fb8305273a83c 100644
--- a/library/core/src/convert/mod.rs
+++ b/library/core/src/convert/mod.rs
@@ -664,7 +664,7 @@ impl AsMut<str> for str {
 ///
 /// However there is one case where `!` syntax can be used
 /// before `!` is stabilized as a full-fledged type: in the position of a function’s return type.
-/// Specifically, it is possible implementations for two different function pointer types:
+/// Specifically, it is possible to have implementations for two different function pointer types:
 ///
 /// ```
 /// trait MyTrait {}
diff --git a/library/core/src/num/int_log10.rs b/library/core/src/num/int_log10.rs
index 398bb07a07e4c..a8455fb355b3c 100644
--- a/library/core/src/num/int_log10.rs
+++ b/library/core/src/num/int_log10.rs
@@ -1,5 +1,6 @@
 mod unchecked {
     // 0 < val <= u8::MAX
+    #[inline]
     pub const fn u8(val: u8) -> u32 {
         let val = val as u32;
 
@@ -20,6 +21,7 @@ mod unchecked {
     }
 
     // 0 < val < 100_000
+    #[inline]
     const fn less_than_5(val: u32) -> u32 {
         // Similar to u8, when adding one of these constants to val,
         // we get two possible bit patterns above the low 17 bits,
@@ -40,11 +42,13 @@ mod unchecked {
     }
 
     // 0 < val <= u16::MAX
+    #[inline]
     pub const fn u16(val: u16) -> u32 {
         less_than_5(val as u32)
     }
 
     // 0 < val <= u32::MAX
+    #[inline]
     pub const fn u32(mut val: u32) -> u32 {
         let mut log = 0;
         if val >= 100_000 {
@@ -55,6 +59,7 @@ mod unchecked {
     }
 
     // 0 < val <= u64::MAX
+    #[inline]
     pub const fn u64(mut val: u64) -> u32 {
         let mut log = 0;
         if val >= 10_000_000_000 {
@@ -69,6 +74,7 @@ mod unchecked {
     }
 
     // 0 < val <= u128::MAX
+    #[inline]
     pub const fn u128(mut val: u128) -> u32 {
         let mut log = 0;
         if val >= 100_000_000_000_000_000_000_000_000_000_000 {
@@ -84,26 +90,31 @@ mod unchecked {
     }
 
     // 0 < val <= i8::MAX
+    #[inline]
     pub const fn i8(val: i8) -> u32 {
         u8(val as u8)
     }
 
     // 0 < val <= i16::MAX
+    #[inline]
     pub const fn i16(val: i16) -> u32 {
         u16(val as u16)
     }
 
     // 0 < val <= i32::MAX
+    #[inline]
     pub const fn i32(val: i32) -> u32 {
         u32(val as u32)
     }
 
     // 0 < val <= i64::MAX
+    #[inline]
     pub const fn i64(val: i64) -> u32 {
         u64(val as u64)
     }
 
     // 0 < val <= i128::MAX
+    #[inline]
     pub const fn i128(val: i128) -> u32 {
         u128(val as u128)
     }
@@ -111,6 +122,7 @@ mod unchecked {
 
 macro_rules! impl_checked {
     ($T:ident) => {
+        #[inline]
         pub const fn $T(val: $T) -> Option<u32> {
             if val > 0 { Some(unchecked::$T(val)) } else { None }
         }
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index af9daf8297401..ee93f00a7fb9b 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -242,6 +242,8 @@ impl<T: ?Sized> NonNull<T> {
     /// The pointer can be later reconstructed with [`NonNull::from_raw_parts`].
     #[unstable(feature = "ptr_metadata", issue = "81513")]
     #[rustc_const_unstable(feature = "ptr_metadata", issue = "81513")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub const fn to_raw_parts(self) -> (NonNull<()>, <T as super::Pointee>::Metadata) {
         (self.cast(), super::metadata(self.as_ptr()))
@@ -386,6 +388,8 @@ impl<T: ?Sized> NonNull<T> {
     /// ```
     #[stable(feature = "nonnull_cast", since = "1.27.0")]
     #[rustc_const_stable(feature = "const_nonnull_cast", since = "1.36.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub const fn cast<U>(self) -> NonNull<U> {
         // SAFETY: `self` is a `NonNull` pointer which is necessarily non-null
diff --git a/library/std/src/ffi/c_str.rs b/library/std/src/ffi/c_str.rs
index 78eb91e41936b..6827d3a8d2448 100644
--- a/library/std/src/ffi/c_str.rs
+++ b/library/std/src/ffi/c_str.rs
@@ -1342,6 +1342,8 @@ impl CStr {
     /// assert_eq!(cstr.to_bytes(), b"foo");
     /// ```
     #[inline]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn to_bytes(&self) -> &[u8] {
         let bytes = self.to_bytes_with_nul();
@@ -1367,6 +1369,8 @@ impl CStr {
     /// assert_eq!(cstr.to_bytes_with_nul(), b"foo\0");
     /// ```
     #[inline]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn to_bytes_with_nul(&self) -> &[u8] {
         unsafe { &*(&self.inner as *const [c_char] as *const [u8]) }
@@ -1437,6 +1441,8 @@ impl CStr {
     ///     Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
     /// );
     /// ```
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[stable(feature = "cstr_to_str", since = "1.4.0")]
     pub fn to_string_lossy(&self) -> Cow<'_, str> {
         String::from_utf8_lossy(self.to_bytes())
diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs
index 3b0e88331449e..46c9aa5e627c5 100644
--- a/library/std/src/ffi/os_str.rs
+++ b/library/std/src/ffi/os_str.rs
@@ -576,6 +576,8 @@ impl OsStr {
     /// assert_eq!(os_str.to_str(), Some("foo"));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub fn to_str(&self) -> Option<&str> {
         self.inner.to_str()
@@ -627,6 +629,8 @@ impl OsStr {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub fn to_string_lossy(&self) -> Cow<'_, str> {
         self.inner.to_string_lossy()
@@ -644,6 +648,8 @@ impl OsStr {
     /// assert_eq!(os_string, OsString::from("foo"));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub fn to_os_string(&self) -> OsString {
         OsString { inner: self.inner.to_owned() }
diff --git a/library/std/src/net/ip.rs b/library/std/src/net/ip.rs
index 68b8bb8f3e190..e5e9fedb61eaf 100644
--- a/library/std/src/net/ip.rs
+++ b/library/std/src/net/ip.rs
@@ -426,6 +426,8 @@ impl IpAddr {
     /// assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1)).to_canonical().is_loopback(), true);
     /// ```
     #[inline]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[rustc_const_unstable(feature = "const_ip", issue = "76205")]
     #[unstable(feature = "ip", issue = "27709")]
     pub const fn to_canonical(&self) -> IpAddr {
@@ -901,6 +903,8 @@ impl Ipv4Addr {
     /// ```
     #[rustc_const_stable(feature = "const_ipv4", since = "1.50.0")]
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub const fn to_ipv6_compatible(&self) -> Ipv6Addr {
         let [a, b, c, d] = self.octets();
@@ -926,6 +930,8 @@ impl Ipv4Addr {
     /// ```
     #[rustc_const_stable(feature = "const_ipv4", since = "1.50.0")]
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
         let [a, b, c, d] = self.octets();
@@ -1648,6 +1654,8 @@ impl Ipv6Addr {
     /// ```
     #[rustc_const_unstable(feature = "const_ipv6", issue = "76205")]
     #[unstable(feature = "ip", issue = "27709")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub const fn to_ipv4_mapped(&self) -> Option<Ipv4Addr> {
         match self.octets() {
@@ -1685,6 +1693,8 @@ impl Ipv6Addr {
     /// ```
     #[rustc_const_stable(feature = "const_ipv6", since = "1.50.0")]
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub const fn to_ipv4(&self) -> Option<Ipv4Addr> {
         if let [0, 0, 0, 0, 0, 0 | 0xffff, ab, cd] = self.segments() {
@@ -1708,9 +1718,11 @@ impl Ipv6Addr {
     /// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1).is_loopback(), false);
     /// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1).to_canonical().is_loopback(), true);
     /// ```
-    #[inline]
     #[rustc_const_unstable(feature = "const_ipv6", issue = "76205")]
     #[unstable(feature = "ip", issue = "27709")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
+    #[inline]
     pub const fn to_canonical(&self) -> IpAddr {
         if let Some(mapped) = self.to_ipv4_mapped() {
             return IpAddr::V4(mapped);
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 5306403547586..47156dc33e518 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -1952,6 +1952,8 @@ impl Path {
     /// assert_eq!(path.to_str(), Some("foo.txt"));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub fn to_str(&self) -> Option<&str> {
         self.inner.to_str()
@@ -1978,6 +1980,8 @@ impl Path {
     /// Had `path` contained invalid unicode, the `to_string_lossy` call might
     /// have returned `"fo�.txt"`.
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub fn to_string_lossy(&self) -> Cow<'_, str> {
         self.inner.to_string_lossy()
@@ -1994,6 +1998,8 @@ impl Path {
     /// assert_eq!(path_buf, std::path::PathBuf::from("foo.txt"));
     /// ```
     #[rustc_conversion_suggestion]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn to_path_buf(&self) -> PathBuf {
         PathBuf::from(self.inner.to_os_string())
diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs
index 7df7a36f540dd..6750f7a549dd6 100644
--- a/src/bootstrap/builder.rs
+++ b/src/bootstrap/builder.rs
@@ -370,7 +370,7 @@ impl<'a> Builder<'a> {
         match kind {
             Kind::Build => describe!(
                 compile::Std,
-                compile::Rustc,
+                compile::Assemble,
                 compile::CodegenBackend,
                 compile::StartupObjects,
                 tool::BuildManifest,
diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs
index 4b189672226ea..e9cc7662e6397 100644
--- a/src/bootstrap/compile.rs
+++ b/src/bootstrap/compile.rs
@@ -528,7 +528,7 @@ impl Step for Rustc {
     const DEFAULT: bool = false;
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        run.path("compiler/rustc")
+        run.never()
     }
 
     fn make_run(run: RunConfig<'_>) {
@@ -1023,9 +1023,16 @@ pub struct Assemble {
 
 impl Step for Assemble {
     type Output = Compiler;
+    const ONLY_HOSTS: bool = true;
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        run.never()
+        run.path("compiler/rustc")
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(Assemble {
+            target_compiler: run.builder.compiler(run.builder.top_stage + 1, run.target),
+        });
     }
 
     /// Prepare a new compiler from the artifacts in `stage`
diff --git a/src/bootstrap/config.rs b/src/bootstrap/config.rs
index 062820040dc78..7818b8b7d515d 100644
--- a/src/bootstrap/config.rs
+++ b/src/bootstrap/config.rs
@@ -982,7 +982,8 @@ impl Config {
         config.rust_debug_assertions_std =
             debug_assertions_std.unwrap_or(config.rust_debug_assertions);
         config.rust_overflow_checks = overflow_checks.unwrap_or(default);
-        config.rust_overflow_checks_std = overflow_checks_std.unwrap_or(default);
+        config.rust_overflow_checks_std =
+            overflow_checks_std.unwrap_or(config.rust_overflow_checks);
 
         config.rust_debug_logging = debug_logging.unwrap_or(config.rust_debug_assertions);
 
diff --git a/src/bootstrap/configure.py b/src/bootstrap/configure.py
index fd148d14478d8..94424cb4548fa 100755
--- a/src/bootstrap/configure.py
+++ b/src/bootstrap/configure.py
@@ -75,7 +75,9 @@ def v(*args):
 o("llvm-assertions", "llvm.assertions", "build LLVM with assertions")
 o("llvm-plugins", "llvm.plugins", "build LLVM with plugin interface")
 o("debug-assertions", "rust.debug-assertions", "build with debugging assertions")
+o("debug-assertions-std", "rust.debug-assertions-std", "build the standard library with debugging assertions")
 o("overflow-checks", "rust.overflow-checks", "build with overflow checks")
+o("overflow-checks-std", "rust.overflow-checks-std", "build the standard library with overflow checks")
 o("llvm-release-debuginfo", "llvm.release-debuginfo", "build LLVM with debugger metadata")
 v("debuginfo-level", "rust.debuginfo-level", "debuginfo level for Rust code")
 v("debuginfo-level-rustc", "rust.debuginfo-level-rustc", "debuginfo level for the compiler")
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index c1a83ad5820cb..e4c2556118aeb 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -39,8 +39,9 @@ static FILES_UNVERSIONED: Lazy<FxHashMap<&str, &[u8]>> = Lazy::new(|| {
         "SourceCodePro-Semibold.ttf.woff" => static_files::source_code_pro::SEMIBOLD,
         "SourceCodePro-It.ttf.woff" => static_files::source_code_pro::ITALIC,
         "SourceCodePro-LICENSE.txt" => static_files::source_code_pro::LICENSE,
-        "noto-sans-kr-v13-korean-regular.woff" => static_files::noto_sans_kr::REGULAR,
-        "noto-sans-kr-v13-korean-regular-LICENSE.txt" => static_files::noto_sans_kr::LICENSE,
+        "noto-sans-kr-regular.woff2" => static_files::noto_sans_kr::REGULAR2,
+        "noto-sans-kr-regular.woff" => static_files::noto_sans_kr::REGULAR,
+        "noto-sans-kr-LICENSE.txt" => static_files::noto_sans_kr::LICENSE,
         "LICENSE-MIT.txt" => static_files::LICENSE_MIT,
         "LICENSE-APACHE.txt" => static_files::LICENSE_APACHE,
         "COPYRIGHT.txt" => static_files::COPYRIGHT,
diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index 962af66368d3b..11c54876dea30 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -75,12 +75,13 @@
 	font-display: swap;
 }
 
-/* Avoid using legacy CJK serif fonts in Windows like Batang */
+/* Avoid using legacy CJK serif fonts in Windows like Batang. */
 @font-face {
 	font-family: 'Noto Sans KR';
-	src: url("noto-sans-kr-v13-korean-regular.woff") format("woff");
+	src: url("noto-sans-kr-regular.woff2") format("woff2"),
+		url("noto-sans-kr-regular.woff") format("woff");
 	font-display: swap;
-	unicode-range: U+A960-A97F, U+AC00-D7AF, U+D7B0-D7FF;
+	unicode-range: U+AC00-D7AF, U+3130-318F, U+1100-11FF, U+A960-A97F, U+D7B0-D7FF;
 }
 
 * {
diff --git a/src/librustdoc/html/static/fonts/noto-sans-kr-v13-korean-regular-LICENSE.txt b/src/librustdoc/html/static/fonts/noto-sans-kr-LICENSE.txt
similarity index 100%
rename from src/librustdoc/html/static/fonts/noto-sans-kr-v13-korean-regular-LICENSE.txt
rename to src/librustdoc/html/static/fonts/noto-sans-kr-LICENSE.txt
diff --git a/src/librustdoc/html/static/fonts/noto-sans-kr-v13-korean-regular.woff b/src/librustdoc/html/static/fonts/noto-sans-kr-regular.woff
similarity index 94%
rename from src/librustdoc/html/static/fonts/noto-sans-kr-v13-korean-regular.woff
rename to src/librustdoc/html/static/fonts/noto-sans-kr-regular.woff
index 01d6b6b54664c..65e939c6b9f54 100644
Binary files a/src/librustdoc/html/static/fonts/noto-sans-kr-v13-korean-regular.woff and b/src/librustdoc/html/static/fonts/noto-sans-kr-regular.woff differ
diff --git a/src/librustdoc/html/static/fonts/noto-sans-kr-regular.woff2 b/src/librustdoc/html/static/fonts/noto-sans-kr-regular.woff2
new file mode 100644
index 0000000000000..8126492e41df3
Binary files /dev/null and b/src/librustdoc/html/static/fonts/noto-sans-kr-regular.woff2 differ
diff --git a/src/librustdoc/html/static_files.rs b/src/librustdoc/html/static_files.rs
index ccc25e6cc495f..924e3f1d29dc9 100644
--- a/src/librustdoc/html/static_files.rs
+++ b/src/librustdoc/html/static_files.rs
@@ -157,15 +157,14 @@ crate mod source_code_pro {
 }
 
 crate mod noto_sans_kr {
-    /// The file `noto-sans-kr-v13-korean-regular.woff`, the Regular variant of the Noto Sans KR
-    /// font.
-    crate static REGULAR: &[u8] =
-        include_bytes!("static/fonts/noto-sans-kr-v13-korean-regular.woff");
+    /// The file `noto-sans-kr.woff`, the Regular variant of the Noto Sans KR font.
+    crate static REGULAR: &[u8] = include_bytes!("static/fonts/noto-sans-kr-regular.woff");
 
-    /// The file `noto-sans-kr-v13-korean-regular-LICENSE.txt`, the license text of the Noto Sans KR
-    /// font.
-    crate static LICENSE: &[u8] =
-        include_bytes!("static/fonts/noto-sans-kr-v13-korean-regular-LICENSE.txt");
+    /// The file `noto-sans-kr.woff2`, the Regular variant of the Noto Sans KR font.
+    crate static REGULAR2: &[u8] = include_bytes!("static/fonts/noto-sans-kr-regular.woff2");
+
+    /// The file `noto-sans-kr-LICENSE.txt`, the license text of the Noto Sans KR font.
+    crate static LICENSE: &[u8] = include_bytes!("static/fonts/noto-sans-kr-LICENSE.txt");
 }
 
 /// Files related to the sidebar in rustdoc sources.
diff --git a/src/test/ui/consts/issue-88071.rs b/src/test/ui/consts/issue-88071.rs
new file mode 100644
index 0000000000000..a2d4a642128b4
--- /dev/null
+++ b/src/test/ui/consts/issue-88071.rs
@@ -0,0 +1,21 @@
+// check-pass
+//
+// regression test for #88071
+
+#![feature(const_btree_new)]
+#![feature(const_fn_trait_bound)]
+
+use std::collections::BTreeMap;
+
+pub struct CustomMap<K, V>(BTreeMap<K, V>);
+
+impl<K, V> CustomMap<K, V>
+where
+    K: Ord,
+{
+    pub const fn new() -> Self {
+        CustomMap(BTreeMap::new())
+    }
+}
+
+fn main() {}
diff --git a/src/test/ui/generic-associated-types/issue-87750.rs b/src/test/ui/generic-associated-types/issue-87750.rs
new file mode 100644
index 0000000000000..89bd79ac2991e
--- /dev/null
+++ b/src/test/ui/generic-associated-types/issue-87750.rs
@@ -0,0 +1,22 @@
+#![feature(generic_associated_types)]
+
+trait PointerFamily {
+    type Pointer<T>;
+}
+
+struct Rc<T>(Box<T>);
+struct RcFamily;
+
+impl PointerFamily for RcFamily {
+    type Pointer<T> = Rc<T>;
+}
+
+#[allow(dead_code)]
+enum Node<T, P: PointerFamily> where P::Pointer<Node<T, P>>: Sized {
+    Cons(P::Pointer<Node<T, P>>),
+}
+
+fn main() {
+    let _list: <RcFamily as PointerFamily>::Pointer<Node<i32, RcFamily>>;
+    //~^ ERROR overflow evaluating the requirement `Node<i32, RcFamily>: Sized`
+}
diff --git a/src/test/ui/generic-associated-types/issue-87750.stderr b/src/test/ui/generic-associated-types/issue-87750.stderr
new file mode 100644
index 0000000000000..854541f3d8fda
--- /dev/null
+++ b/src/test/ui/generic-associated-types/issue-87750.stderr
@@ -0,0 +1,9 @@
+error[E0275]: overflow evaluating the requirement `Node<i32, RcFamily>: Sized`
+  --> $DIR/issue-87750.rs:20:16
+   |
+LL |     let _list: <RcFamily as PointerFamily>::Pointer<Node<i32, RcFamily>>;
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0275`.
diff --git a/src/test/ui/macros/macro-inner-attributes.stderr b/src/test/ui/macros/macro-inner-attributes.stderr
index 8223220d9a4e2..77b6486155cd2 100644
--- a/src/test/ui/macros/macro-inner-attributes.stderr
+++ b/src/test/ui/macros/macro-inner-attributes.stderr
@@ -3,6 +3,11 @@ error[E0433]: failed to resolve: use of undeclared crate or module `a`
    |
 LL |     a::bar();
    |     ^ use of undeclared crate or module `a`
+   |
+help: there is a crate or module with a similar name
+   |
+LL |     b::bar();
+   |     ~
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/pattern/bindings-after-at/nested-type-ascription-syntactically-invalid.rs b/src/test/ui/pattern/bindings-after-at/nested-type-ascription-syntactically-invalid.rs
index 5c7769ce604cf..a709e34b5014c 100644
--- a/src/test/ui/pattern/bindings-after-at/nested-type-ascription-syntactically-invalid.rs
+++ b/src/test/ui/pattern/bindings-after-at/nested-type-ascription-syntactically-invalid.rs
@@ -1,5 +1,5 @@
 // Here we check that type ascription is syntactically invalid when
-// not in the top position of a ascribing a let binding or function parameter.
+// not in the top position of an ascribing `let` binding or function parameter.
 
 
 // This has no effect.
diff --git a/src/test/ui/suggestions/crate-or-module-typo.rs b/src/test/ui/suggestions/crate-or-module-typo.rs
new file mode 100644
index 0000000000000..2471b11c61efd
--- /dev/null
+++ b/src/test/ui/suggestions/crate-or-module-typo.rs
@@ -0,0 +1,17 @@
+// edition:2018
+
+use st::cell::Cell; //~ ERROR failed to resolve: use of undeclared crate or module `st`
+
+mod bar {
+    pub fn bar() { bar::baz(); } //~ ERROR failed to resolve: use of undeclared crate or module `bar`
+
+    fn baz() {}
+}
+
+use bas::bar; //~ ERROR unresolved import `bas`
+
+struct Foo {
+    bar: st::cell::Cell<bool> //~ ERROR failed to resolve: use of undeclared crate or module `st`
+}
+
+fn main() {}
diff --git a/src/test/ui/suggestions/crate-or-module-typo.stderr b/src/test/ui/suggestions/crate-or-module-typo.stderr
new file mode 100644
index 0000000000000..e8250c9fa5ff4
--- /dev/null
+++ b/src/test/ui/suggestions/crate-or-module-typo.stderr
@@ -0,0 +1,43 @@
+error[E0433]: failed to resolve: use of undeclared crate or module `st`
+  --> $DIR/crate-or-module-typo.rs:3:5
+   |
+LL | use st::cell::Cell;
+   |     ^^ use of undeclared crate or module `st`
+   |
+help: there is a crate or module with a similar name
+   |
+LL | use std::cell::Cell;
+   |     ~~~
+
+error[E0432]: unresolved import `bas`
+  --> $DIR/crate-or-module-typo.rs:11:5
+   |
+LL | use bas::bar;
+   |     ^^^ use of undeclared crate or module `bas`
+   |
+help: there is a crate or module with a similar name
+   |
+LL | use bar::bar;
+   |     ~~~
+
+error[E0433]: failed to resolve: use of undeclared crate or module `bar`
+  --> $DIR/crate-or-module-typo.rs:6:20
+   |
+LL |     pub fn bar() { bar::baz(); }
+   |                    ^^^ use of undeclared crate or module `bar`
+
+error[E0433]: failed to resolve: use of undeclared crate or module `st`
+  --> $DIR/crate-or-module-typo.rs:14:10
+   |
+LL |     bar: st::cell::Cell<bool>
+   |          ^^ use of undeclared crate or module `st`
+   |
+help: there is a crate or module with a similar name
+   |
+LL |     bar: std::cell::Cell<bool>
+   |          ~~~
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0432, E0433.
+For more information about an error, try `rustc --explain E0432`.
diff --git a/src/test/ui/traits/issue-52893.rs b/src/test/ui/traits/issue-52893.rs
new file mode 100644
index 0000000000000..d72598d5d5942
--- /dev/null
+++ b/src/test/ui/traits/issue-52893.rs
@@ -0,0 +1,57 @@
+// check-fail
+//
+// regression test for issue 52893
+trait At<Name> {
+    type AtRes;
+    fn at(self) -> Self::AtRes;
+}
+
+trait Push<T> {
+    type PushRes;
+    fn push(self, other: T) -> Self::PushRes;
+}
+
+trait AddClass<Name, F> {
+    type AddRes;
+    fn init(self, func: F);
+}
+
+trait ToRef {
+    type RefRes;
+    fn to_ref(&self) -> Self::RefRes;
+}
+
+struct Class<P>(P);
+
+impl<P> Class<P> {
+    fn with<Name, F>(self) -> <Self as AddClass<Name, F>>::AddRes
+    where
+        Self: AddClass<Name, F>,
+    {
+        todo!()
+    }
+
+    fn from<F>(self) -> <Self as AddClass<P, F>>::AddRes
+    where
+        Self: AddClass<P, F>,
+    {
+        todo!()
+    }
+}
+
+impl<F, Name, P> AddClass<Name, F> for Class<P>
+where
+    Self: At<Name>,
+    <Self as At<Name>>::AtRes: Push<F>,
+    <<Self as At<Name>>::AtRes as Push<F>>::PushRes: ToRef<RefRes = Self> + Push<F>,
+{
+    type AddRes = ();
+
+    fn init(self, func: F) {
+        let builder = self.at().push(func);
+        let output = builder.to_ref();
+        builder.push(output); //~ ERROR mismatched types [E0308]
+    }
+}
+
+fn main() {}
diff --git a/src/test/ui/traits/issue-52893.stderr b/src/test/ui/traits/issue-52893.stderr
new file mode 100644
index 0000000000000..bf732e2491566
--- /dev/null
+++ b/src/test/ui/traits/issue-52893.stderr
@@ -0,0 +1,15 @@
+error[E0308]: mismatched types
+  --> $DIR/issue-52893.rs:53:22
+   |
+LL | impl<F, Name, P> AddClass<Name, F> for Class<P>
+   |      - this type parameter
+...
+LL |         builder.push(output);
+   |                      ^^^^^^ expected type parameter `F`, found struct `Class`
+   |
+   = note: expected type parameter `F`
+                      found struct `Class<P>`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/src/test/ui/traits/issue-68295.rs b/src/test/ui/traits/issue-68295.rs
new file mode 100644
index 0000000000000..7ff54539adc5b
--- /dev/null
+++ b/src/test/ui/traits/issue-68295.rs
@@ -0,0 +1,47 @@
+// check-fail
+//
+// regression test for #68295
+
+struct Matrix<R, C, S>(R, C, S);
+
+impl<R, C, S> Matrix<R, C, S> {
+    fn into_owned(self) -> Matrix<R, C, Owned<R, C, ()>>
+    where
+        (): Allocator<R, C>,
+    {
+        unimplemented!()
+    }
+}
+
+impl<D, S> Matrix<D, D, S> {
+    fn hermitian_part(&self) -> Matrix<D, D, Owned<D, D, ()>>
+    where
+        (): Allocator<D, D>,
+    {
+        unimplemented!()
+    }
+}
+
+trait Allocator<R, C> {
+    type Buffer;
+}
+
+trait Trait<R, C, A> {
+    type Power;
+}
+
+impl<R, C, A: Allocator<R, C>> Trait<R, C, A> for () {
+    type Power = A::Buffer;
+}
+
+type Owned<R, C, G> = <G as Trait<R, C, ()>>::Power;
+
+fn crash<R, C>(input: Matrix<R, C, ()>) -> Matrix<R, C, u32>
+where
+    (): Allocator<R, C>,
+{
+    input.into_owned()
+    //~^ ERROR mismatched types [E0308]
+}
+
+fn main() {}
diff --git a/src/test/ui/traits/issue-68295.stderr b/src/test/ui/traits/issue-68295.stderr
new file mode 100644
index 0000000000000..cb6e6e0769cb8
--- /dev/null
+++ b/src/test/ui/traits/issue-68295.stderr
@@ -0,0 +1,17 @@
+error[E0308]: mismatched types
+  --> $DIR/issue-68295.rs:43:5
+   |
+LL | fn crash<R, C>(input: Matrix<R, C, ()>) -> Matrix<R, C, u32>
+   |                                            ----------------- expected `Matrix<R, C, u32>` because of return type
+...
+LL |     input.into_owned()
+   |     ^^^^^^^^^^^^^^^^^^ expected `u32`, found associated type
+   |
+   = note: expected struct `Matrix<_, _, u32>`
+              found struct `Matrix<_, _, <() as Allocator<R, C>>::Buffer>`
+   = help: consider constraining the associated type `<() as Allocator<R, C>>::Buffer` to `u32`
+   = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.