Rollup merge of #35739 - circuitfox:E0403-update-error-format, r=jonathandturner

E0403 update error format

Fixes #35696

Part of #35233

r? @jonathandturner

Also did the bonus for this one.

diff --combined src/librustc_resolve/lib.rs
index d90a932a63d86081ae540569329326eb1ffe9902,823005e9c5388b9e61e5a0a3a0e4dd08430be4a8..525b8b3e30d70323f164774a5a19fd40d30b779f
--- 1/src/librustc_resolve/lib.rs
--- 2/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@@ -102,7 -102,7 +102,7 @@@ enum ResolutionError<'a> 
      /// error E0402: cannot use an outer type parameter in this context
      OuterTypeParameterContext,
      /// error E0403: the name is already used for a type parameter in this type parameter list
-     NameAlreadyUsedInTypeParameterList(Name),
+     NameAlreadyUsedInTypeParameterList(Name, &'a Span),
      /// error E0404: is not a trait
      IsNotATrait(&'a str),
      /// error E0405: use of undeclared trait name
@@@ -116,7 -116,7 +116,7 @@@
      /// error E0408: variable `{}` from pattern #{} is not bound in pattern #{}
      VariableNotBoundInPattern(Name, usize, usize),
      /// error E0409: variable is bound with different mode in pattern #{} than in pattern #1
 -    VariableBoundWithDifferentMode(Name, usize),
 +    VariableBoundWithDifferentMode(Name, usize, Span),
      /// error E0411: use of `Self` outside of an impl or trait
      SelfUsedOutsideImplOrTrait,
      /// error E0412: use of undeclared
@@@ -209,13 -209,17 +209,17 @@@ fn resolve_struct_error<'b, 'a: 'b, 'c>
                               E0402,
                               "cannot use an outer type parameter in this context")
          }
-         ResolutionError::NameAlreadyUsedInTypeParameterList(name) => {
-             struct_span_err!(resolver.session,
-                              span,
-                              E0403,
-                              "the name `{}` is already used for a type parameter in this type \
-                               parameter list",
-                              name)
+         ResolutionError::NameAlreadyUsedInTypeParameterList(name, first_use_span) => {
+              let mut err = struct_span_err!(resolver.session,
+                                             span,
+                                             E0403,
+                                             "the name `{}` is already used for a type parameter \
+                                             in this type parameter list",
+                                             name);
+              err.span_label(span, &format!("already used"));
+              err.span_label(first_use_span.clone(), &format!("first use of `{}`", name));
+              err
+ 
          }
          ResolutionError::IsNotATrait(name) => {
              let mut err = struct_span_err!(resolver.session,
@@@ -269,19 -273,14 +273,19 @@@
                               from,
                               to)
          }
 -        ResolutionError::VariableBoundWithDifferentMode(variable_name, pattern_number) => {
 -            struct_span_err!(resolver.session,
 +        ResolutionError::VariableBoundWithDifferentMode(variable_name,
 +                                                        pattern_number,
 +                                                        first_binding_span) => {
 +            let mut err = struct_span_err!(resolver.session,
                               span,
                               E0409,
                               "variable `{}` is bound with different mode in pattern #{} than in \
                                pattern #1",
                               variable_name,
 -                             pattern_number)
 +                             pattern_number);
 +            err.span_label(span, &format!("bound in different ways"));
 +            err.span_label(first_binding_span, &format!("first binding"));
 +            err
          }
          ResolutionError::SelfUsedOutsideImplOrTrait => {
              let mut err = struct_span_err!(resolver.session,
@@@ -321,13 -320,11 +325,13 @@@
              err
          }
          ResolutionError::DoesNotNameAStruct(name) => {
 -            struct_span_err!(resolver.session,
 +            let mut err = struct_span_err!(resolver.session,
                               span,
                               E0422,
                               "`{}` does not name a structure",
 -                             name)
 +                             name);
 +            err.span_label(span, &format!("not a structure"));
 +            err
          }
          ResolutionError::StructVariantUsedAsFunction(path_name) => {
              struct_span_err!(resolver.session,
@@@ -1726,17 -1723,19 +1730,19 @@@ impl<'a> Resolver<'a> 
          match type_parameters {
              HasTypeParameters(generics, rib_kind) => {
                  let mut function_type_rib = Rib::new(rib_kind);
-                 let mut seen_bindings = HashSet::new();
+                 let mut seen_bindings = HashMap::new();
                  for type_parameter in &generics.ty_params {
                      let name = type_parameter.ident.name;
                      debug!("with_type_parameter_rib: {}", type_parameter.id);
  
-                     if seen_bindings.contains(&name) {
+                     if seen_bindings.contains_key(&name) {
+                         let span = seen_bindings.get(&name).unwrap();
                          resolve_error(self,
                                        type_parameter.span,
-                                       ResolutionError::NameAlreadyUsedInTypeParameterList(name));
+                                       ResolutionError::NameAlreadyUsedInTypeParameterList(name,
+                                                                                           span));
                      }
-                     seen_bindings.insert(name);
+                     seen_bindings.entry(name).or_insert(type_parameter.span);
  
                      // plain insert (no renaming)
                      let def_id = self.definitions.local_def_id(type_parameter.id);
@@@ -2035,10 -2034,8 +2041,10 @@@
                          if binding_0.binding_mode != binding_i.binding_mode {
                              resolve_error(self,
                                            binding_i.span,
 -                                          ResolutionError::VariableBoundWithDifferentMode(key.name,
 -                                                                                          i + 1));
 +                                          ResolutionError::VariableBoundWithDifferentMode(
 +                                              key.name,
 +                                              i + 1,
 +                                              binding_0.span));
                          }
                      }
                  }