@@ -42,7 +42,7 @@ use ast::RangeEnd;
42
42
use { ast, attr} ;
43
43
use codemap:: { self , CodeMap , Spanned , respan} ;
44
44
use syntax_pos:: { self , Span , BytePos } ;
45
- use errors:: { self , DiagnosticBuilder , Level } ;
45
+ use errors:: { self , DiagnosticBuilder } ;
46
46
use parse:: { self , classify, token} ;
47
47
use parse:: common:: SeqSep ;
48
48
use parse:: lexer:: TokenAndSpan ;
@@ -441,7 +441,14 @@ fn dummy_arg(span: Span) -> Arg {
441
441
Arg { ty : P ( ty) , pat : pat, id : ast:: DUMMY_NODE_ID }
442
442
}
443
443
444
- type RewindPoint = ( token:: Token , Span , Option < Span > , Span , TokenCursor , Vec < TokenType > ) ;
444
+ struct RewindPoint {
445
+ token : token:: Token ,
446
+ span : Span ,
447
+ meta_var_span : Option < Span > ,
448
+ prev_span : Span ,
449
+ token_cursor : TokenCursor ,
450
+ expected_tokens : Vec < TokenType > ,
451
+ }
445
452
446
453
impl < ' a > Parser < ' a > {
447
454
pub fn new ( sess : & ' a ParseSess ,
@@ -2835,11 +2842,13 @@ impl<'a> Parser<'a> {
2835
2842
// Rewind to before attempting to parse the type with generics, to get
2836
2843
// arround #22644.
2837
2844
let rp_err = self . get_rewind_point ( ) ;
2845
+ let sp = rp_err. span . clone ( ) ;
2838
2846
self . rewind ( rp) ;
2839
2847
let lo = self . span ;
2840
2848
let path = match self . parse_path_without_generics ( PathStyle :: Type ) {
2841
2849
Ok ( path) => {
2842
2850
// Successfully parsed the type leaving a `<` yet to parse
2851
+ err. cancel ( ) ;
2843
2852
let codemap = self . sess . codemap ( ) ;
2844
2853
let suggestion_span = lhs_span. to ( self . prev_span ) ;
2845
2854
let suggestion = match codemap. span_to_snippet ( suggestion_span) {
@@ -2850,15 +2859,17 @@ impl<'a> Parser<'a> {
2850
2859
Ok ( lstring) => format ! ( "`{}`" , lstring) ,
2851
2860
_ => "a type" . to_string ( ) ,
2852
2861
} ;
2853
- err. span_suggestion ( suggestion_span,
2862
+ let msg = format ! ( "`<` is interpreted as a start of generic \
2863
+ arguments for {}, not a comparison",
2864
+ warn_message) ;
2865
+ let mut warn = self . sess . span_diagnostic . struct_span_warn ( sp, & msg) ;
2866
+ warn. span_label ( sp, "interpreted as generic argument" ) ;
2867
+ warn. span_label ( self . span , "not interpreted as comparison" ) ;
2868
+ warn. span_suggestion ( suggestion_span,
2854
2869
"if you want to compare the casted value \
2855
2870
then write:",
2856
2871
suggestion) ;
2857
- err. level = Level :: Warning ;
2858
- err. set_message ( & format ! ( "`<` is interpreted as a start of generic \
2859
- arguments for {}, not a comparison",
2860
- warn_message) ) ;
2861
- err. emit ( ) ;
2872
+ warn. emit ( ) ;
2862
2873
path
2863
2874
}
2864
2875
Err ( mut path_err) => {
@@ -6255,23 +6266,22 @@ impl<'a> Parser<'a> {
6255
6266
}
6256
6267
6257
6268
fn get_rewind_point ( & mut self ) -> RewindPoint {
6258
- (
6259
- self . token . clone ( ) ,
6260
- self . span ,
6261
- self . meta_var_span ,
6262
- self . prev_span ,
6263
- self . token_cursor . clone ( ) ,
6264
- self . expected_tokens . clone ( ) ,
6265
- )
6269
+ RewindPoint {
6270
+ token : self . token . clone ( ) ,
6271
+ span : self . span ,
6272
+ meta_var_span : self . meta_var_span ,
6273
+ prev_span : self . prev_span ,
6274
+ token_cursor : self . token_cursor . clone ( ) ,
6275
+ expected_tokens : self . expected_tokens . clone ( ) ,
6276
+ }
6266
6277
}
6267
6278
6268
6279
fn rewind ( & mut self , rp : RewindPoint ) {
6269
- let ( token, span, meta_var_span, prev_span, token_cursor, expected_tokens, ) = rp;
6270
- self . token = token;
6271
- self . span = span;
6272
- self . meta_var_span = meta_var_span;
6273
- self . prev_span = prev_span;
6274
- self . token_cursor = token_cursor;
6275
- self . expected_tokens = expected_tokens;
6280
+ self . token = rp. token ;
6281
+ self . span = rp. span ;
6282
+ self . meta_var_span = rp. meta_var_span ;
6283
+ self . prev_span = rp. prev_span ;
6284
+ self . token_cursor = rp. token_cursor ;
6285
+ self . expected_tokens = rp. expected_tokens ;
6276
6286
}
6277
6287
}
0 commit comments