change idents for globvsglob example

Author: yaahc

src/names/name-resolution.md

@@ -130,7 +130,8 @@ use m1::ambig;
 fn f() {
     // This shadows `ambig` in the inner scope.
     use m2::ambig;
-    // The `use` from the inner scope is used here.
+    // The inner candidate is selected here
+    // as the resolution of `ambig`.
     use ambig::C;
     const { assert!(C == 2) };
 }
@@ -148,65 +149,67 @@ r[names.resolution.expansion.imports.ambiguity]
 r[names.resolution.expansion.imports.ambiguity.intro]
 Some situations are an error when there is an ambiguity as to which macro definition, `use` declaration, or module an import or macro invocation's name refers to. This happens when there are two name candidates that do not resolve to the same entity where neither candidate is [permitted] to shadow the other.
 
+TODO rewrite
+
 r[names.resolution.expansion.imports.ambiguity.glob-vs-glob]
 Names may not be resolved through ambiguous glob imports. Glob imports are allowed to import conflicting names in the same namespace as long as the name is not used. Names with conflicting candidates from ambiguous glob imports may still be shadowed by non glob imports and used without producing an error. The errors occur at time of use, not time of import.
 
 For example:
 
 ```rust,compile_fail,E0659
-mod foo {
-    pub struct Qux;
+mod m1 {
+    pub struct Ambig;
 }
 
-mod bar {
-    pub struct Qux;
+mod m2 {
+    pub struct Ambig;
 }
 
-use foo::*;
-use bar::*; // OK, no name conflict.
+use m1::*;
+use m2::*; // OK, no name conflict.
 
 fn ambiguous_use() {
-    let x = Qux; // ERROR: `Qux` is ambiguous
+    let x = Ambig; // ERROR: `Ambig` is ambiguous
 }
 ```
 
 ```rust
-# mod foo {
-#     pub struct Qux;
+# mod m1 {
+#     pub struct Ambig;
 # }
 #
-# mod bar {
-#     pub struct Qux;
+# mod m2 {
+#     pub struct Ambig;
 # }
 #
-# use foo::*;
-# use bar::*; // OK, no name conflict.
+# use m1::*;
+# use m2::*; // OK, no name conflict.
 fn ambiguous_shadow() {
     // This is permitted, since resolution is not through the ambiguous globs.
-    struct Qux;
-    let x = Qux;
+    struct Ambig;
+    let x = Ambig;
 }
 ```
 
-Multiple glob imports are allowed to import the same name, and that name is allowed to be used if the imports are of the same item (following re-exports). The visibility of the name is the maximum visibility of the imports. For example:
+Multiple glob imports are allowed to import the same name, and that name is allowed to be used if the imports are of the same item (following re-exports). The visibility of the name is the maximum visibility of the imports.
 
 ```rust
-mod foo {
-    pub struct Qux;
+mod m1 {
+    pub struct Ambig;
 }
 
-mod bar {
-    pub use super::foo::Qux;
+mod m2 {
+    pub use super::m1::Ambig;
 }
 
-// These both import the same `Qux`. The visibility of `Qux`
-// is `pub` because that is the maximum visibility between
-// these two `use` declarations.
-pub use bar::*;
-use foo::*;
+// These both import the same `Ambig`. The visibility of `Ambig` is
+// `pub` because that is the maximum visibility between these two `use`
+// declarations.
+pub use m2::*;
+use m1::*;
 
 fn main() {
-    let _: Qux = Qux;
+    let _: Ambig = Ambig;
 }
 ```