Learn to parse a as usize < b

src/librustc_errors/diagnostic.rs

@@ -248,6 +248,10 @@ impl Diagnostic {
         self.message.iter().map(|i| i.0.to_owned()).collect::<String>()
     }
 
+    pub fn set_message(&mut self, message: &str) {
+        self.message = vec![(message.to_owned(), Style::NoStyle)];
+    }
+
     pub fn styled_message(&self) -> &Vec<(String, Style)> {
         &self.message
     }

src/libsyntax/parse/parser.rs

@@ -193,11 +193,13 @@ pub struct Parser<'a> {
 }
 
 
+#[derive(Clone)]
 struct TokenCursor {
     frame: TokenCursorFrame,
     stack: Vec<TokenCursorFrame>,
 }
 
+#[derive(Clone)]
 struct TokenCursorFrame {
     delim: token::DelimToken,
     span: Span,
@@ -397,6 +399,7 @@ impl Error {
     }
 }
 
+#[derive(Debug)]
 pub enum LhsExpr {
     NotYetParsed,
     AttributesParsed(ThinVec<Attribute>),
@@ -438,6 +441,15 @@ fn dummy_arg(span: Span) -> Arg {
     Arg { ty: P(ty), pat: pat, id: ast::DUMMY_NODE_ID }
 }
 
+struct RewindPoint {
+    token: token::Token,
+    span: Span,
+    meta_var_span: Option<Span>,
+    prev_span: Span,
+    token_cursor: TokenCursor,
+    expected_tokens: Vec<TokenType>,
+}
+
 impl<'a> Parser<'a> {
     pub fn new(sess: &'a ParseSess,
                tokens: TokenStream,
@@ -786,6 +798,13 @@ impl<'a> Parser<'a> {
         }
     }
 
+    fn is_lt(&mut self) -> bool {
+        match self.token {
+            token::Lt | token::BinOp(token::Shl) => true,
+            _ => false,
+        }
+    }
+
     /// Attempt to consume a `<`. If `<<` is seen, replace it with a single
     /// `<` and continue. If a `<` is not seen, return false.
     ///
@@ -1724,7 +1743,7 @@ impl<'a> Parser<'a> {
 
         let segments = match mode {
             PathStyle::Type => {
-                self.parse_path_segments_without_colons()?
+                self.parse_path_segments_without_colons(false)?
             }
             PathStyle::Expr => {
                 self.parse_path_segments_with_colons()?
@@ -1745,6 +1764,16 @@ impl<'a> Parser<'a> {
     /// bounds are permitted and whether `::` must precede type parameter
     /// groups.
     pub fn parse_path(&mut self, mode: PathStyle) -> PResult<'a, ast::Path> {
+        self.parse_path_common(mode, false)
+    }
+
+    pub fn parse_path_without_generics(&mut self, mode: PathStyle) -> PResult<'a, ast::Path> {
+        self.parse_path_common(mode, true)
+    }
+
+    fn parse_path_common(&mut self, mode: PathStyle, dont_parse_generics: bool)
+        -> PResult<'a, ast::Path>
+    {
         maybe_whole!(self, NtPath, |x| x);
 
         let lo = self.meta_var_span.unwrap_or(self.span);
@@ -1755,7 +1784,7 @@ impl<'a> Parser<'a> {
         // A bound set is a set of type parameter bounds.
         let mut segments = match mode {
             PathStyle::Type => {
-                self.parse_path_segments_without_colons()?
+                self.parse_path_segments_without_colons(dont_parse_generics)?
             }
             PathStyle::Expr => {
                 self.parse_path_segments_with_colons()?
@@ -1800,7 +1829,9 @@ impl<'a> Parser<'a> {
     /// - `a::b<T,U>::c<V,W>`
     /// - `a::b<T,U>::c(V) -> W`
     /// - `a::b<T,U>::c(V)`
-    pub fn parse_path_segments_without_colons(&mut self) -> PResult<'a, Vec<PathSegment>> {
+    pub fn parse_path_segments_without_colons(&mut self, dont_parse_generics: bool)
+        -> PResult<'a, Vec<PathSegment>>
+    {
         let mut segments = Vec::new();
         loop {
             // First, parse an identifier.
@@ -1819,7 +1850,8 @@ impl<'a> Parser<'a> {
             }
 
             // Parse types, optionally.
-            let parameters = if self.eat_lt() {
+            let parameters = if self.is_lt() && !dont_parse_generics {
+                let _ = self.eat_lt();
                 let (lifetimes, types, bindings) = self.parse_generic_args()?;
                 self.expect_gt()?;
                 ast::AngleBracketedParameterData {
@@ -2798,8 +2830,62 @@ impl<'a> Parser<'a> {
             }
             // Special cases:
             if op == AssocOp::As {
-                let rhs = self.parse_ty_no_plus()?;
-                lhs = self.mk_expr(lhs_span.to(rhs.span), ExprKind::Cast(lhs, rhs), ThinVec::new());
+                // Save the state of the parser before parsing type normally, in case there is a
+                // LessThan comparison after this cast.
+                let rp = self.get_rewind_point();
+                match self.parse_ty_no_plus() {
+                    Ok(rhs) => {
+                        lhs = self.mk_expr(lhs_span.to(rhs.span),
+                                           ExprKind::Cast(lhs, rhs), ThinVec::new());
+                    }
+                    Err(mut err) => {
+                        // Rewind to before attempting to parse the type with generics, to get
+                        // arround #22644.
+                        let rp_err = self.get_rewind_point();
+                        let sp = rp_err.span.clone();
+                        self.rewind(rp);
+                        let lo = self.span;
+                        let path = match self.parse_path_without_generics(PathStyle::Type) {
+                            Ok(path) => {
+                                // Successfully parsed the type leaving a `<` yet to parse
+                                err.cancel();
+                                let codemap = self.sess.codemap();
+                                let suggestion_span = lhs_span.to(self.prev_span);
+                                let suggestion = match codemap.span_to_snippet(suggestion_span) {
+                                    Ok(lstring) => format!("({})", lstring),
+                                    _ => format!("(<expression>)")
+                                };
+                                let warn_message = match codemap.span_to_snippet(self.prev_span) {
+                                    Ok(lstring) => format!("`{}`", lstring),
+                                    _ => "a type".to_string(),
+                                };
+                                let msg = format!("`<` is interpreted as a start of generic \
+                                                   arguments for {}, not a comparison",
+                                                  warn_message);
+                                let mut warn = self.sess.span_diagnostic.struct_span_warn(sp, &msg);
+                                warn.span_label(sp, "interpreted as generic argument");
+                                warn.span_label(self.span, "not interpreted as comparison");
+                                warn.span_suggestion(suggestion_span,
+                                                    "if you want to compare the casted value \
+                                                     then write:",
+                                                    suggestion);
+                                warn.emit();
+                                path
+                            }
+                            Err(mut path_err) => {
+                                // Still couldn't parse, return original error and parser state
+                                path_err.cancel();
+                                self.rewind(rp_err);
+                                return Err(err);
+                            }
+                        };
+                        let path = TyKind::Path(None, path);
+                        let span = lo.to(self.prev_span);
+                        let rhs = P(Ty { node: path, span: span, id: ast::DUMMY_NODE_ID });
+                        lhs = self.mk_expr(lhs_span.to(rhs.span),
+                                           ExprKind::Cast(lhs, rhs), ThinVec::new());
+                    }
+                };
                 continue
             } else if op == AssocOp::Colon {
                 let rhs = self.parse_ty_no_plus()?;
@@ -2901,7 +2987,9 @@ impl<'a> Parser<'a> {
     /// We only need to check lhs, not rhs, because all comparison ops
     /// have same precedence and are left-associative
     fn check_no_chained_comparison(&mut self, lhs: &Expr, outer_op: &AssocOp) {
-        debug_assert!(outer_op.is_comparison());
+        debug_assert!(outer_op.is_comparison(),
+                      "check_no_chained_comparison: {:?} is not comparison",
+                      outer_op);
         match lhs.node {
             ExprKind::Binary(op, _, _) if op.node.is_comparison() => {
                 // respan to include both operators
@@ -2925,7 +3013,9 @@ impl<'a> Parser<'a> {
     fn parse_prefix_range_expr(&mut self,
                                already_parsed_attrs: Option<ThinVec<Attribute>>)
                                -> PResult<'a, P<Expr>> {
-        debug_assert!(self.token == token::DotDot || self.token == token::DotDotDot);
+        debug_assert!(self.token == token::DotDot || self.token == token::DotDotDot,
+                      "parse_prefix_range_expr: token {:?} is not DotDot or DotDotDot",
+                      self.token);
         let tok = self.token.clone();
         let attrs = self.parse_or_use_outer_attributes(already_parsed_attrs)?;
         let lo = self.span;
@@ -6174,4 +6264,24 @@ impl<'a> Parser<'a> {
             _ =>  Err(self.fatal("expected string literal"))
         }
     }
+
+    fn get_rewind_point(&mut self) -> RewindPoint {
+        RewindPoint {
+            token: self.token.clone(),
+            span: self.span,
+            meta_var_span: self.meta_var_span,
+            prev_span: self.prev_span,
+            token_cursor: self.token_cursor.clone(),
+            expected_tokens: self.expected_tokens.clone(),
+        }
+    }
+
+    fn rewind(&mut self, rp: RewindPoint) {
+        self.token = rp.token;
+        self.span = rp.span;
+        self.meta_var_span = rp.meta_var_span;
+        self.prev_span = rp.prev_span;
+        self.token_cursor = rp.token_cursor;
+        self.expected_tokens = rp.expected_tokens;
+    }
 }

src/libsyntax/tokenstream.rs

@@ -227,14 +227,17 @@ impl TokenStream {
     }
 }
 
+#[derive(Clone)]
 pub struct Cursor(CursorKind);
 
+#[derive(Clone)]
 enum CursorKind {
     Empty,
     Tree(TokenTree, bool /* consumed? */),
     Stream(StreamCursor),
 }
 
+#[derive(Clone)]
 struct StreamCursor {
     stream: RcSlice<TokenStream>,
     index: usize,

src/test/parse-fail/better-expected.rs

@@ -11,5 +11,5 @@
 // compile-flags: -Z parse-only
 
 fn main() {
-    let x: [isize 3]; //~ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `3`
+    let x: [isize 3]; //~ ERROR expected one of `!`, `(`, `+`, `::`, `;`, or `]`, found `3`
 }

src/test/parse-fail/bounds-type-where.rs

@@ -18,6 +18,6 @@ type A where T: Trait + Trait = u8; // OK
 type A where = u8; // OK
 type A where T: Trait + = u8; // OK
 type A where T, = u8;
-//~^ ERROR expected one of `!`, `(`, `+`, `::`, `:`, `<`, `==`, or `=`, found `,`
+//~^ ERROR expected one of `!`, `(`, `+`, `::`, `:`, `==`, or `=`, found `,`
 
 fn main() {}

src/test/parse-fail/closure-return-syntax.rs

@@ -13,5 +13,5 @@
 
 fn main() {
     let x = || -> i32 22;
-    //~^ ERROR expected one of `!`, `(`, `::`, `<`, or `{`, found `22`
+    //~^ ERROR expected one of `!`, `(`, `::`, or `{`, found `22`
 }

src/test/parse-fail/empty-impl-semicolon.rs

@@ -10,4 +10,4 @@
 
 // compile-flags: -Z parse-only
 
-impl Foo; //~ ERROR expected one of `!`, `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `;`
+impl Foo; //~ ERROR expected one of `!`, `(`, `+`, `::`, `for`, `where`, or `{`, found `;`

src/test/parse-fail/multitrait.rs

@@ -15,7 +15,7 @@ struct S {
 }
 
 impl Cmp, ToString for S {
-//~^ ERROR: expected one of `!`, `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `,`
+//~^ ERROR: expected one of `!`, `(`, `+`, `::`, `for`, `where`, or `{`, found `,`
   fn eq(&&other: S) { false }
   fn to_string(&self) -> String { "hi".to_string() }
 }

src/test/parse-fail/removed-syntax-closure-lifetime.rs

@@ -11,4 +11,4 @@
 // compile-flags: -Z parse-only
 
 type closure = Box<lt/fn()>;
-//~^ ERROR expected one of `!`, `(`, `+`, `,`, `::`, `<`, or `>`, found `/`
+//~^ ERROR expected one of `!`, `(`, `+`, `,`, `::`, or `>`, found `/`

src/test/parse-fail/removed-syntax-fixed-vec.rs

@@ -10,4 +10,4 @@
 
 // compile-flags: -Z parse-only
 
-type v = [isize * 3]; //~ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `*`
+type v = [isize * 3]; //~ ERROR expected one of `!`, `(`, `+`, `::`, `;`, or `]`, found `*`

src/test/parse-fail/removed-syntax-ptr-lifetime.rs

@@ -10,4 +10,4 @@
 
 // compile-flags: -Z parse-only
 
-type bptr = &lifetime/isize; //~ ERROR expected one of `!`, `(`, `::`, `;`, or `<`, found `/`
+type bptr = &lifetime/isize; //~ ERROR expected one of `!`, `(`, `::`, or `;`, found `/`

src/test/ui/issue-22644.rs

@@ -0,0 +1,18 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    let a : u32 = 0;
+    let b : usize = 0;
+
+    println!("{}", a as usize > b);
+    println!("{}", a as usize < b);
+    println!("{}", a as usize < 4);
+}

src/test/ui/issue-22644.stderr

@@ -0,0 +1,22 @@
+warning: `<` is interpreted as a start of generic arguments for `usize`, not a comparison
+  --> $DIR/issue-22644.rs:16:33
+   |
+16 |     println!("{}", a as usize < b);
+   |                               - ^ interpreted as generic argument
+   |                               |
+   |                               not interpreted as comparison
+   |
+help: if you want to compare the casted value then write:
+   |     println!("{}", (a as usize) < b);
+
+warning: `<` is interpreted as a start of generic arguments for `usize`, not a comparison
+  --> $DIR/issue-22644.rs:17:33
+   |
+17 |     println!("{}", a as usize < 4);
+   |                               - ^ interpreted as generic argument
+   |                               |
+   |                               not interpreted as comparison
+   |
+help: if you want to compare the casted value then write:
+   |     println!("{}", (a as usize) < 4);
+