@@ -4,12 +4,10 @@ use rustc_errors::{self, AddToDiagnostic, Diagnostic, IntoDiagnosticArg, Subdiag
44use  rustc_middle:: ty:: { self ,  TyCtxt } ; 
55use  rustc_span:: { symbol:: kw,  Span } ; 
66
7- #[ derive( Default ) ]  
87struct  DescriptionCtx < ' a >  { 
98    span :  Option < Span > , 
109    kind :  & ' a  str , 
1110    arg :  String , 
12-     num_arg :  u32 , 
1311} 
1412
1513impl < ' a >  DescriptionCtx < ' a >  { 
@@ -18,102 +16,74 @@ impl<'a> DescriptionCtx<'a> {
1816        region :  ty:: Region < ' tcx > , 
1917        alt_span :  Option < Span > , 
2018    )  -> Option < Self >  { 
21-         let  mut  me = DescriptionCtx :: default ( ) ; 
22-         me. span  = alt_span; 
23-         match  * region { 
24-             ty:: ReEarlyBound ( _)  | ty:: ReFree ( _)  => { 
25-                 return  Self :: from_early_bound_and_free_regions ( tcx,  region) ; 
26-             } 
27-             ty:: ReStatic  => { 
28-                 me. kind  = "restatic" ; 
29-             } 
30- 
31-             ty:: RePlaceholder ( _)  => return  None , 
32- 
33-             ty:: ReError ( _)  => return  None , 
34- 
35-             // FIXME(#13998) RePlaceholder should probably print like 
36-             // ReFree rather than dumping Debug output on the user. 
37-             // 
38-             // We shouldn't really be having unification failures with ReVar 
39-             // and ReLateBound though. 
40-             ty:: ReVar ( _)  | ty:: ReLateBound ( ..)  | ty:: ReErased  => { 
41-                 me. kind  = "revar" ; 
42-                 me. arg  = format ! ( "{:?}" ,  region) ; 
43-             } 
44-         } ; 
45-         Some ( me) 
46-     } 
47- 
48-     fn  from_early_bound_and_free_regions < ' tcx > ( 
49-         tcx :  TyCtxt < ' tcx > , 
50-         region :  ty:: Region < ' tcx > , 
51-     )  -> Option < Self >  { 
52-         let  mut  me = DescriptionCtx :: default ( ) ; 
53-         let  scope = region. free_region_binding_scope ( tcx) . expect_local ( ) ; 
54-         match  * region { 
19+         let  ( span,  kind,  arg)  = match  * region { 
5520            ty:: ReEarlyBound ( ref  br)  => { 
56-                 let  mut  sp =  tcx. def_span ( scope ) ; 
57-                 if  let  Some ( param)  =
21+                 let  scope = region . free_region_binding_scope ( tcx) . expect_local ( ) ; 
22+                 let  span =  if  let  Some ( param)  =
5823                    tcx. hir ( ) . get_generics ( scope) . and_then ( |generics| generics. get_named ( br. name ) ) 
5924                { 
60-                     sp = param. span ; 
61-                 } 
62-                 if  br. has_name ( )  { 
63-                     me. kind  = "as_defined" ; 
64-                     me. arg  = br. name . to_string ( ) ; 
25+                     param. span 
6526                }  else  { 
66-                     me . kind  =  "as_defined_anon" ; 
27+                     tcx . def_span ( scope ) 
6728                } ; 
68-                 me. span  = Some ( sp) 
29+                 if  br. has_name ( )  { 
30+                     ( Some ( span) ,  "as_defined" ,  br. name . to_string ( ) ) 
31+                 }  else  { 
32+                     ( Some ( span) ,  "as_defined_anon" ,  String :: new ( ) ) 
33+                 } 
6934            } 
7035            ty:: ReFree ( ref  fr)  => { 
7136                if  !fr. bound_region . is_named ( ) 
7237                    && let  Some ( ( ty,  _) )  = find_anon_type ( tcx,  region,  & fr. bound_region ) 
7338                { 
74-                     me. kind  = "defined_here" ; 
75-                     me. span  = Some ( ty. span ) ; 
39+                     ( Some ( ty. span ) ,  "defined_here" ,  String :: new ( ) ) 
7640                }  else  { 
41+                     let  scope = region. free_region_binding_scope ( tcx) . expect_local ( ) ; 
7742                    match  fr. bound_region  { 
7843                        ty:: BoundRegionKind :: BrNamed ( _,  name)  => { 
79-                             let  mut  sp = tcx. def_span ( scope) ; 
80-                             if  let  Some ( param)  =
81-                                 tcx. hir ( ) . get_generics ( scope) . and_then ( |generics| generics. get_named ( name) ) 
44+                             let  span = if  let  Some ( param)  = tcx
45+                                 . hir ( ) 
46+                                 . get_generics ( scope) 
47+                                 . and_then ( |generics| generics. get_named ( name) ) 
8248                            { 
83-                                 sp = param. span ; 
84-                             } 
85-                             if  name == kw:: UnderscoreLifetime  { 
86-                                 me. kind  = "as_defined_anon" ; 
49+                                 param. span 
8750                            }  else  { 
88-                                 me. kind  = "as_defined" ; 
89-                                 me. arg  = name. to_string ( ) ; 
51+                                 tcx. def_span ( scope) 
9052                            } ; 
91-                             me. span  = Some ( sp) ; 
53+                             if  name == kw:: UnderscoreLifetime  { 
54+                                 ( Some ( span) ,  "as_defined_anon" ,  String :: new ( ) ) 
55+                             }  else  { 
56+                                 ( Some ( span) ,  "as_defined" ,  name. to_string ( ) ) 
57+                             } 
9258                        } 
9359                        ty:: BrAnon ( span)  => { 
94-                             me. kind  = "defined_here" ; 
95-                             me. span  = match  span { 
60+                             let  span = match  span { 
9661                                Some ( _)  => span, 
9762                                None  => Some ( tcx. def_span ( scope) ) , 
98-                             } 
99-                         } , 
63+                             } ; 
64+                             ( span,  "defined_here" ,  String :: new ( ) ) 
65+                         } 
10066                        _ => { 
101-                             me. kind  = "defined_here_reg" ; 
102-                             me. arg  = region. to_string ( ) ; 
103-                             me. span  = Some ( tcx. def_span ( scope) ) ; 
104-                         } , 
67+                             ( Some ( tcx. def_span ( scope) ) ,  "defined_here_reg" ,  region. to_string ( ) ) 
68+                         } 
10569                    } 
10670                } 
10771            } 
108-             _ => bug ! ( ) , 
109-         } 
110-         Some ( me) 
111-     } 
11272
113-     fn  add_to ( self ,  diag :  & mut  rustc_errors:: Diagnostic )  { 
114-         diag. set_arg ( "desc_kind" ,  self . kind ) ; 
115-         diag. set_arg ( "desc_arg" ,  self . arg ) ; 
116-         diag. set_arg ( "desc_num_arg" ,  self . num_arg ) ; 
73+             ty:: ReStatic  => ( alt_span,  "restatic" ,  String :: new ( ) ) , 
74+ 
75+             ty:: RePlaceholder ( _)  | ty:: ReError ( _)  => return  None , 
76+ 
77+             // FIXME(#13998) RePlaceholder should probably print like 
78+             // ReFree rather than dumping Debug output on the user. 
79+             // 
80+             // We shouldn't really be having unification failures with ReVar 
81+             // and ReLateBound though. 
82+             ty:: ReVar ( _)  | ty:: ReLateBound ( ..)  | ty:: ReErased  => { 
83+                 ( alt_span,  "revar" ,  format ! ( "{:?}" ,  region) ) 
84+             } 
85+         } ; 
86+         Some ( DescriptionCtx  {  span,  kind,  arg } ) 
11787    } 
11888} 
11989
@@ -198,10 +168,11 @@ impl AddToDiagnostic for RegionExplanation<'_> {
198168    { 
199169        diag. set_arg ( "pref_kind" ,  self . prefix ) ; 
200170        diag. set_arg ( "suff_kind" ,  self . suffix ) ; 
201-         let  desc_span = self . desc . span ; 
202-         self . desc . add_to ( diag) ; 
171+         diag. set_arg ( "desc_kind" ,  self . desc . kind ) ; 
172+         diag. set_arg ( "desc_arg" ,  self . desc . arg ) ; 
173+ 
203174        let  msg = f ( diag,  fluent:: infer_region_explanation. into ( ) ) ; 
204-         if  let  Some ( span)  = desc_span  { 
175+         if  let  Some ( span)  = self . desc . span  { 
205176            diag. span_note ( span,  msg) ; 
206177        }  else  { 
207178            diag. note ( msg) ; 
0 commit comments