Auto merge of #126593 - matthiaskrgr:rollup-a5jfg7w, r=matthiaskrgr

Rollup of 3 pull requests

Successful merges:

 - #126568 (mark undetermined if target binding in current ns is not got)
 - #126577 (const_refs_to_static test and cleanup)
 - #126584 (Do not ICE in privacy when type inference fails.)

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

compiler/rustc_const_eval/messages.ftl

@@ -399,7 +399,6 @@ const_eval_unwind_past_top =
 
 ## The `front_matter`s here refer to either `const_eval_front_matter_invalid_value` or `const_eval_front_matter_invalid_value_with_path`.
 ## (We'd love to sort this differently to make that more clear but tidy won't let us...)
-const_eval_validation_box_to_static = {$front_matter}: encountered a box pointing to a static variable in a constant
 const_eval_validation_box_to_uninhabited = {$front_matter}: encountered a box pointing to uninhabited type {$ty}
 
 const_eval_validation_const_ref_to_extern = {$front_matter}: encountered reference to `extern` static in `const`
@@ -454,7 +453,6 @@ const_eval_validation_out_of_range = {$front_matter}: encountered {$value}, but
 const_eval_validation_partial_pointer = {$front_matter}: encountered a partial pointer or a mix of pointers
 const_eval_validation_pointer_as_int = {$front_matter}: encountered a pointer, but {$expected}
 const_eval_validation_ptr_out_of_range = {$front_matter}: encountered a pointer, but expected something that cannot possibly fail to be {$in_range}
-const_eval_validation_ref_to_static = {$front_matter}: encountered a reference pointing to a static variable in a constant
 const_eval_validation_ref_to_uninhabited = {$front_matter}: encountered a reference pointing to uninhabited type {$ty}
 const_eval_validation_unaligned_box = {$front_matter}: encountered an unaligned box (required {$required_bytes} byte alignment but found {$found_bytes})
 const_eval_validation_unaligned_ref = {$front_matter}: encountered an unaligned reference (required {$required_bytes} byte alignment but found {$found_bytes})

compiler/rustc_const_eval/src/errors.rs

@@ -640,9 +640,6 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
                 const_eval_validation_ref_to_uninhabited
             }
 
-            PtrToStatic { ptr_kind: PointerKind::Box } => const_eval_validation_box_to_static,
-            PtrToStatic { ptr_kind: PointerKind::Ref(_) } => const_eval_validation_ref_to_static,
-
             PointerAsInt { .. } => const_eval_validation_pointer_as_int,
             PartialPointer => const_eval_validation_partial_pointer,
             ConstRefToMutable => const_eval_validation_const_ref_to_mutable,
@@ -807,7 +804,6 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
                 );
             }
             NullPtr { .. }
-            | PtrToStatic { .. }
             | ConstRefToMutable
             | ConstRefToExtern
             | MutableRefToImmutable

compiler/rustc_middle/src/mir/interpret/error.rs

@@ -438,9 +438,6 @@ pub enum ValidationErrorKind<'tcx> {
         ptr_kind: PointerKind,
         ty: Ty<'tcx>,
     },
-    PtrToStatic {
-        ptr_kind: PointerKind,
-    },
     ConstRefToMutable,
     ConstRefToExtern,
     MutableRefToImmutable,

compiler/rustc_privacy/src/lib.rs

@@ -973,8 +973,12 @@ impl<'tcx> NamePrivacyVisitor<'tcx> {
 
 impl<'tcx> Visitor<'tcx> for NamePrivacyVisitor<'tcx> {
     fn visit_nested_body(&mut self, body_id: hir::BodyId) {
-        let old_maybe_typeck_results =
-            self.maybe_typeck_results.replace(self.tcx.typeck_body(body_id));
+        let new_typeck_results = self.tcx.typeck_body(body_id);
+        // Do not try reporting privacy violations if we failed to infer types.
+        if new_typeck_results.tainted_by_errors.is_some() {
+            return;
+        }
+        let old_maybe_typeck_results = self.maybe_typeck_results.replace(new_typeck_results);
         self.visit_body(self.tcx.hir().body(body_id));
         self.maybe_typeck_results = old_maybe_typeck_results;
     }

compiler/rustc_resolve/src/ident.rs

@@ -966,7 +966,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         for single_import in &resolution.single_imports {
             let Some(import_vis) = single_import.vis.get() else {
                 // This branch handles a cycle in single imports, which occurs
-                // when we've previously captured the `vis` value during an import
+                // when we've previously **steal** the `vis` value during an import
                 // process.
                 //
                 // For example:
@@ -998,21 +998,28 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             let Some(module) = single_import.imported_module.get() else {
                 return Err((Undetermined, Weak::No));
             };
-            let ImportKind::Single { source: ident, target, target_bindings, .. } =
-                &single_import.kind
+            let ImportKind::Single { source, target, target_bindings, .. } = &single_import.kind
             else {
                 unreachable!();
             };
-            if (ident != target) && target_bindings.iter().all(|binding| binding.get().is_none()) {
+            if source != target {
                 // This branch allows the binding to be defined or updated later if the target name
-                // can hide the source but these bindings are not obtained.
-                // avoiding module inconsistency between the resolve process and the finalize process.
-                // See more details in #124840
-                return Err((Undetermined, Weak::No));
+                // can hide the source.
+                if target_bindings.iter().all(|binding| binding.get().is_none()) {
+                    // None of the target bindings are available, so we can't determine
+                    // if this binding is correct or not.
+                    // See more details in #124840
+                    return Err((Undetermined, Weak::No));
+                } else if target_bindings[ns].get().is_none() && binding.is_some() {
+                    // `binding.is_some()` avoids the condition where the binding
+                    // truly doesn't exist in this namespace and should return `Err(Determined)`.
+                    return Err((Undetermined, Weak::No));
+                }
             }
+
             match self.resolve_ident_in_module(
                 module,
-                *ident,
+                *source,
                 ns,
                 &single_import.parent_scope,
                 None,

tests/ui/imports/shadow-glob-module-resolution-3.rs

@@ -0,0 +1,19 @@
+// https://github.com/rust-lang/rust/issues/126389
+
+mod a {
+    pub mod b {
+        pub mod c {}
+    }
+}
+
+use a::*;
+
+use b::c;
+//~^ ERROR: unresolved import `b::c`
+//~| ERROR: cannot determine resolution for the import
+//~| ERROR: cannot determine resolution for the import
+use c as b;
+
+fn c() {}
+
+fn main() { }

tests/ui/imports/shadow-glob-module-resolution-3.stderr

@@ -0,0 +1,23 @@
+error: cannot determine resolution for the import
+  --> $DIR/shadow-glob-module-resolution-3.rs:11:5
+   |
+LL | use b::c;
+   |     ^^^^
+
+error: cannot determine resolution for the import
+  --> $DIR/shadow-glob-module-resolution-3.rs:11:5
+   |
+LL | use b::c;
+   |     ^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0432]: unresolved import `b::c`
+  --> $DIR/shadow-glob-module-resolution-3.rs:11:5
+   |
+LL | use b::c;
+   |     ^^^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0432`.

tests/ui/imports/shadow-glob-module-resolution-4.rs

@@ -0,0 +1,20 @@
+// https://github.com/rust-lang/rust/issues/126376
+
+mod a {
+    pub mod b {
+        pub trait C {}
+    }
+}
+
+use a::*;
+
+use e as b;
+
+use b::C as e;
+//~^ ERROR: unresolved import `b::C`
+//~| ERROR: cannot determine resolution for the import
+//~| ERROR: cannot determine resolution for the import
+
+fn e() {}
+
+fn main() { }

tests/ui/imports/shadow-glob-module-resolution-4.stderr

@@ -0,0 +1,23 @@
+error: cannot determine resolution for the import
+  --> $DIR/shadow-glob-module-resolution-4.rs:13:5
+   |
+LL | use b::C as e;
+   |     ^^^^^^^^^
+
+error: cannot determine resolution for the import
+  --> $DIR/shadow-glob-module-resolution-4.rs:13:5
+   |
+LL | use b::C as e;
+   |     ^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0432]: unresolved import `b::C`
+  --> $DIR/shadow-glob-module-resolution-4.rs:13:5
+   |
+LL | use b::C as e;
+   |     ^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0432`.

tests/crashes/122736.rs → tests/ui/privacy/no-ice-on-inference-failure.rs

@@ -1,9 +1,9 @@
-//@ known-bug: #122736
 fn main_ref() {
     let array = [(); {
         let mut x = &0;
         let mut n = 0;
         while n < 5 {
+            //~^ ERROR constant evaluation is taking a long time
             x = &0;
         }
         0

tests/ui/privacy/no-ice-on-inference-failure.stderr

@@ -0,0 +1,27 @@
+error: constant evaluation is taking a long time
+  --> $DIR/no-ice-on-inference-failure.rs:5:9
+   |
+LL | /         while n < 5 {
+LL | |
+LL | |             x = &0;
+LL | |         }
+   | |_________^
+   |
+   = note: this lint makes sure the compiler doesn't get stuck due to infinite loops in const eval.
+           If your compilation actually takes a long time, you can safely allow the lint.
+help: the constant being evaluated
+  --> $DIR/no-ice-on-inference-failure.rs:2:22
+   |
+LL |       let array = [(); {
+   |  ______________________^
+LL | |         let mut x = &0;
+LL | |         let mut n = 0;
+LL | |         while n < 5 {
+...  |
+LL | |         0
+LL | |     }];
+   | |_____^
+   = note: `#[deny(long_running_const_eval)]` on by default
+
+error: aborting due to 1 previous error
+

tests/ui/statics/const_generics.rs

@@ -0,0 +1,26 @@
+//! Check that we lose the information that `BAR` points to `FOO`
+//! when going through a const generic.
+//! This is not an intentional guarantee, it just describes the status quo.
+
+//@ run-pass
+// With optimizations, LLVM will deduplicate the constant `X` whose
+// value is `&42` to just be a reference to the static. This is correct,
+// but obscures the issue we're trying to show.
+//@ revisions: opt noopt
+//@[noopt] compile-flags: -Copt-level=0
+//@[opt] compile-flags: -O
+
+#![feature(const_refs_to_static)]
+#![feature(adt_const_params)]
+#![allow(incomplete_features)]
+
+static FOO: usize = 42;
+const BAR: &usize = &FOO;
+fn foo<const X: &'static usize>() {
+    // Without optimizations, `X` ends up pointing to a copy of `FOO` instead of `FOO` itself.
+    assert_eq!(cfg!(opt), std::ptr::eq(X, &FOO));
+}
+
+fn main() {
+    foo::<BAR>();
+}