Auto merge of #128350 - matthiaskrgr:rollup-bcuhts8, r=matthiaskrgr

Rollup of 6 pull requests

Successful merges:

 - #127882 (Don't elaborate associated types with Sized bounds in `trait_object_ty` in cfi)
 - #128174 (Don't record trait aliases as marker traits)
 - #128202 (Tell users not to file a bug when using internal library features)
 - #128239 (Don't ICE when encountering error regions when confirming object method candidate)
 - #128337 (skip assoc type during infer source visitor)
 - #128341 (Make `rustc_attr::parse_version` pub)

r? `@ghost`
`@rustbot` modify labels: rollup

19 files changed, 228 insertions, 77 deletions

diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs
index 86afe08323f..12a19ae5c3d 100644
--- a/compiler/rustc_attr/src/builtin.rs
+++ b/compiler/rustc_attr/src/builtin.rs
@@ -578,7 +578,7 @@ fn gate_cfg(gated_cfg: &GatedCfg, cfg_span: Span, sess: &Session, features: &Fea
 /// Parse a rustc version number written inside string literal in an attribute,
 /// like appears in `since = "1.0.0"`. Suffixes like "-dev" and "-nightly" are
 /// not accepted in this position, unlike when parsing CFG_RELEASE.
-fn parse_version(s: Symbol) -> Option<RustcVersion> {
+pub fn parse_version(s: Symbol) -> Option<RustcVersion> {
     let mut components = s.as_str().split('-');
     let d = components.next()?;
     if components.next().is_some() {
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index 5310f39a19a..756290be0a8 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -117,6 +117,12 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
             // Otherwise, the feature is unknown. Record it as a lib feature.
             // It will be checked later.
             features.set_declared_lib_feature(name, mi.span());
+
+            // Similar to above, detect internal lib features to suppress
+            // the ICE message that asks for a report.
+            if features.internal(name) && ![sym::core, sym::alloc, sym::std].contains(&crate_name) {
+                sess.using_internal_features.store(true, std::sync::atomic::Ordering::Relaxed);
+            }
         }
     }
 
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 37aab83677a..47ff748547a 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -1207,25 +1207,29 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AdtDef<'_> {
 fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     let item = tcx.hir().expect_item(def_id);
 
-    let (is_auto, safety, items) = match item.kind {
+    let (is_alias, is_auto, safety, items) = match item.kind {
         hir::ItemKind::Trait(is_auto, safety, .., items) => {
-            (is_auto == hir::IsAuto::Yes, safety, items)
+            (false, is_auto == hir::IsAuto::Yes, safety, items)
         }
-        hir::ItemKind::TraitAlias(..) => (false, hir::Safety::Safe, &[][..]),
+        hir::ItemKind::TraitAlias(..) => (true, false, hir::Safety::Safe, &[][..]),
         _ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"),
     };
 
-    let constness = if tcx.has_attr(def_id, sym::const_trait) {
+    // Only regular traits can be const.
+    let constness = if !is_alias && tcx.has_attr(def_id, sym::const_trait) {
         hir::Constness::Const
     } else {
         hir::Constness::NotConst
     };
+
     let paren_sugar = tcx.has_attr(def_id, sym::rustc_paren_sugar);
     if paren_sugar && !tcx.features().unboxed_closures {
         tcx.dcx().emit_err(errors::ParenSugarAttribute { span: item.span });
     }
 
-    let is_marker = tcx.has_attr(def_id, sym::marker);
+    // Only regular traits can be marker.
+    let is_marker = !is_alias && tcx.has_attr(def_id, sym::marker);
+
     let rustc_coinductive = tcx.has_attr(def_id, sym::rustc_coinductive);
     let is_fundamental = tcx.has_attr(def_id, sym::fundamental);
 
diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs
index d0c1fecd6b9..f14159dc35a 100644
--- a/compiler/rustc_hir_typeck/src/method/confirm.rs
+++ b/compiler/rustc_hir_typeck/src/method/confirm.rs
@@ -16,7 +16,8 @@ use rustc_middle::ty::adjustment::{
 };
 use rustc_middle::ty::fold::TypeFoldable;
 use rustc_middle::ty::{
-    self, GenericArgs, GenericArgsRef, GenericParamDefKind, Ty, TyCtxt, UserArgs, UserType,
+    self, GenericArgs, GenericArgsRef, GenericParamDefKind, Ty, TyCtxt, TypeVisitableExt, UserArgs,
+    UserType,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::{Span, DUMMY_SP};
@@ -269,6 +270,17 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
 
             probe::ObjectPick => {
                 let trait_def_id = pick.item.container_id(self.tcx);
+
+                // This shouldn't happen for non-region error kinds, but may occur
+                // when we have error regions. Specifically, since we canonicalize
+                // during method steps, we may successfully deref when we assemble
+                // the pick, but fail to deref when we try to extract the object
+                // type from the pick during confirmation. This is fine, we're basically
+                // already doomed by this point.
+                if self_ty.references_error() {
+                    return ty::GenericArgs::extend_with_error(self.tcx, trait_def_id, &[]);
+                }
+
                 self.extract_existential_trait_ref(self_ty, |this, object_ty, principal| {
                     // The object data has no entry for the Self
                     // Type. For the purposes of this method call, we
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
index 7837c72393d..e628c17aca3 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
@@ -232,6 +232,7 @@ fn trait_object_ty<'tcx>(tcx: TyCtxt<'tcx>, poly_trait_ref: ty::PolyTraitRef<'tc
             tcx.associated_items(super_poly_trait_ref.def_id())
                 .in_definition_order()
                 .filter(|item| item.kind == ty::AssocKind::Type)
+                .filter(|item| !tcx.generics_require_sized_self(item.def_id))
                 .map(move |assoc_ty| {
                     super_poly_trait_ref.map_bound(|super_trait_ref| {
                         let alias_ty =
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index f667e4c80fd..f6dd7898fb2 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -934,13 +934,13 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
             // which makes this somewhat difficult and prevents us from just
             // using `self.path_inferred_arg_iter` here.
             hir::ExprKind::Struct(&hir::QPath::Resolved(_self_ty, path), _, _)
-            // FIXME(TaKO8Ki): Ideally we should support this. For that
-            // we have to map back from the self type to the
-            // type alias though. That's difficult.
+            // FIXME(TaKO8Ki): Ideally we should support other kinds,
+            // such as `TyAlias` or `AssocTy`. For that we have to map
+            // back from the self type to the type alias though. That's difficult.
             //
             // See the `need_type_info/issue-103053.rs` test for
             // a example.
-            if !matches!(path.res, Res::Def(DefKind::TyAlias, _)) => {
+            if matches!(path.res, Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, _)) => {
                 if let Some(ty) = self.opt_node_type(expr.hir_id)
                     && let ty::Adt(_, args) = ty.kind()
                 {
diff --git a/tests/crashes/121613-2.rs b/tests/crashes/121613-2.rs
deleted file mode 100644
index ddc4f37c96a..00000000000
--- a/tests/crashes/121613-2.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ known-bug: #121613
-fn main() {
-    // destructure through a qualified path
-    let <Foo as A>::Assoc { br } = StructStruct { br: 2 };
-    //~^ ERROR usage of qualified paths in this context is experimental
-    let _ = <Foo as A>::Assoc { br: 2 };
-    //~^ ERROR usage of qualified paths in this context is experimental
-    let <E>::V(..) = E::V(|a, b| a.cmp(b));
-    //~^ ERROR usage of qualified paths in this context is experimental
-}
-
-struct StructStruct {
-    br: i8,
-}
-
-struct Foo;
-
-trait A {
-    type Assoc;
-}
-
-impl A for Foo {
-    type Assoc = StructStruct;
-}
-
-enum E {
-    V(u8)
-}
diff --git a/tests/crashes/121613.rs b/tests/crashes/121613.rs
deleted file mode 100644
index ec9ba82a68c..00000000000
--- a/tests/crashes/121613.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ known-bug: #121613
-fn main() {
-    let _ = <Foo as A>::Assoc { br: 2 };
-
-    let <E>::V(..) = E::V(|a, b| a.cmp(b));
-}
-
-struct StructStruct {
-    br: i8,
-}
-
-struct Foo;
-
-trait A {
-    type Assoc;
-}
-
-impl A for Foo {
-    type Assoc = StructStruct;
-}
-
-enum E {
-    V(u8),
-}
diff --git a/tests/crashes/122914.rs b/tests/crashes/122914.rs
deleted file mode 100644
index 63a84bc8099..00000000000
--- a/tests/crashes/122914.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ known-bug: #122914
-use std::future::Future;
-use std::pin::Pin;
-
-impl<'a, F> Poll {
-    fn project<'_>(self: Pin<&'pin mut Future>) -> Projection<'pin, 'a, F> {
-        me.local_set.with(|| {
-            let _ = self.poll(cx);
-        })
-    }
-}
diff --git a/tests/crashes/127222.rs b/tests/crashes/127222.rs
deleted file mode 100644
index eda0ea3d9b7..00000000000
--- a/tests/crashes/127222.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//@ known-bug: rust-lang/rust#127222
-#[marker]
-trait Foo = PartialEq<i32> + Send;
diff --git a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.rs b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.rs
new file mode 100644
index 00000000000..830a6390fce
--- /dev/null
+++ b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.rs
@@ -0,0 +1,24 @@
+// issue#121613
+
+#![feature(more_qualified_paths)]
+
+struct S {}
+
+struct Foo;
+
+trait A {
+    type Assoc;
+}
+
+impl A for Foo {
+    type Assoc = S;
+}
+
+fn f() {}
+
+fn main() {
+  <Foo as A>::Assoc {};
+  f(|a, b| a.cmp(b));
+  //~^ ERROR: type annotations needed
+  //~| ERROR: this function takes 0 arguments but 1 argument was supplied
+}
diff --git a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr
new file mode 100644
index 00000000000..10056bdf3d4
--- /dev/null
+++ b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr
@@ -0,0 +1,32 @@
+error[E0282]: type annotations needed
+  --> $DIR/incompat-call-after-qualified-path-0.rs:21:6
+   |
+LL |   f(|a, b| a.cmp(b));
+   |      ^     - type must be known at this point
+   |
+help: consider giving this closure parameter an explicit type
+   |
+LL |   f(|a: /* Type */, b| a.cmp(b));
+   |       ++++++++++++
+
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+  --> $DIR/incompat-call-after-qualified-path-0.rs:21:3
+   |
+LL |   f(|a, b| a.cmp(b));
+   |   ^ --------------- unexpected argument
+   |
+note: function defined here
+  --> $DIR/incompat-call-after-qualified-path-0.rs:17:4
+   |
+LL | fn f() {}
+   |    ^
+help: remove the extra argument
+   |
+LL -   f(|a, b| a.cmp(b));
+LL +   f();
+   |
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0061, E0282.
+For more information about an error, try `rustc --explain E0061`.
diff --git a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.rs b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.rs
new file mode 100644
index 00000000000..6b786332a8f
--- /dev/null
+++ b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.rs
@@ -0,0 +1,28 @@
+// issue#121613
+
+#![feature(more_qualified_paths)]
+
+struct S<T> {
+    a: T
+}
+
+struct Foo;
+
+trait A {
+    type Assoc<T>;
+}
+
+impl A for Foo {
+    type Assoc<T> = S<T>;
+}
+
+fn f() {}
+
+fn main() {
+  <Foo as A>::Assoc::<i32> {
+    a: 1
+  };
+  f(|a, b| a.cmp(b));
+  //~^ ERROR: type annotations needed
+  //~| ERROR: this function takes 0 arguments but 1 argument was supplied
+}
diff --git a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr
new file mode 100644
index 00000000000..632a9b99f84
--- /dev/null
+++ b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr
@@ -0,0 +1,32 @@
+error[E0282]: type annotations needed
+  --> $DIR/incompat-call-after-qualified-path-1.rs:25:6
+   |
+LL |   f(|a, b| a.cmp(b));
+   |      ^     - type must be known at this point
+   |
+help: consider giving this closure parameter an explicit type
+   |
+LL |   f(|a: /* Type */, b| a.cmp(b));
+   |       ++++++++++++
+
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+  --> $DIR/incompat-call-after-qualified-path-1.rs:25:3
+   |
+LL |   f(|a, b| a.cmp(b));
+   |   ^ --------------- unexpected argument
+   |
+note: function defined here
+  --> $DIR/incompat-call-after-qualified-path-1.rs:19:4
+   |
+LL | fn f() {}
+   |    ^
+help: remove the extra argument
+   |
+LL -   f(|a, b| a.cmp(b));
+LL +   f();
+   |
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0061, E0282.
+For more information about an error, try `rustc --explain E0061`.
diff --git a/tests/ui/methods/dont-ice-on-object-lookup-w-error-region.rs b/tests/ui/methods/dont-ice-on-object-lookup-w-error-region.rs
new file mode 100644
index 00000000000..0a6d196364f
--- /dev/null
+++ b/tests/ui/methods/dont-ice-on-object-lookup-w-error-region.rs
@@ -0,0 +1,11 @@
+// Fix for issue: #122914
+
+use std::future::Future;
+use std::pin::Pin;
+
+fn project(x: Pin<&'missing mut dyn Future<Output = ()>>) {
+    //~^ ERROR use of undeclared lifetime name `'missing`
+    let _ = x.poll(todo!());
+}
+
+fn main() {}
diff --git a/tests/ui/methods/dont-ice-on-object-lookup-w-error-region.stderr b/tests/ui/methods/dont-ice-on-object-lookup-w-error-region.stderr
new file mode 100644
index 00000000000..2c33941be43
--- /dev/null
+++ b/tests/ui/methods/dont-ice-on-object-lookup-w-error-region.stderr
@@ -0,0 +1,11 @@
+error[E0261]: use of undeclared lifetime name `'missing`
+  --> $DIR/dont-ice-on-object-lookup-w-error-region.rs:6:20
+   |
+LL | fn project(x: Pin<&'missing mut dyn Future<Output = ()>>) {
+   |           -        ^^^^^^^^ undeclared lifetime
+   |           |
+   |           help: consider introducing lifetime `'missing` here: `<'missing>`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0261`.
diff --git a/tests/ui/sanitizer/cfi-sized-associated-ty.rs b/tests/ui/sanitizer/cfi-sized-associated-ty.rs
new file mode 100644
index 00000000000..f5b4e22e9d9
--- /dev/null
+++ b/tests/ui/sanitizer/cfi-sized-associated-ty.rs
@@ -0,0 +1,38 @@
+// Check that we only elaborate non-`Self: Sized` associated types when
+// erasing the receiver from trait ref.
+
+//@ revisions: cfi kcfi
+// FIXME(#122848) Remove only-linux once OSX CFI binaries work
+//@ only-linux
+//@ [cfi] needs-sanitizer-cfi
+//@ [kcfi] needs-sanitizer-kcfi
+//@ compile-flags: -C target-feature=-crt-static
+//@ [cfi] compile-flags: -C codegen-units=1 -C lto -C prefer-dynamic=off -C opt-level=0
+//@ [cfi] compile-flags: -Z sanitizer=cfi
+//@ [kcfi] compile-flags: -Z sanitizer=kcfi
+//@ [kcfi] compile-flags: -C panic=abort -C prefer-dynamic=off
+//@ run-pass
+
+trait Foo {
+    type Bar<'a>
+    where
+        Self: Sized;
+
+    fn test(&self);
+}
+
+impl Foo for () {
+    type Bar<'a> = ()
+    where
+        Self: Sized;
+
+    fn test(&self) {}
+}
+
+fn test(x: &dyn Foo) {
+    x.test();
+}
+
+fn main() {
+    test(&());
+}
diff --git a/tests/ui/traits/alias/not-a-marker.rs b/tests/ui/traits/alias/not-a-marker.rs
new file mode 100644
index 00000000000..b004b9ff9ae
--- /dev/null
+++ b/tests/ui/traits/alias/not-a-marker.rs
@@ -0,0 +1,7 @@
+#![feature(trait_alias, marker_trait_attr)]
+
+#[marker]
+//~^ ERROR attribute should be applied to a trait
+trait Foo = Send;
+
+fn main() {}
diff --git a/tests/ui/traits/alias/not-a-marker.stderr b/tests/ui/traits/alias/not-a-marker.stderr
new file mode 100644
index 00000000000..2f3f6fea30f
--- /dev/null
+++ b/tests/ui/traits/alias/not-a-marker.stderr
@@ -0,0 +1,11 @@
+error: attribute should be applied to a trait
+  --> $DIR/not-a-marker.rs:3:1
+   |
+LL | #[marker]
+   | ^^^^^^^^^
+LL |
+LL | trait Foo = Send;
+   | ----------------- not a trait
+
+error: aborting due to 1 previous error
+