Change next_point when shrink_to_hi is more appropriate

(cherry picked from commit b93ef68)

Author: estebank

src/librustc_parse/parser/diagnostics.rs

@@ -300,15 +300,13 @@ impl<'a> Parser<'a> {
                 expect.clone()
             };
             (format!("expected one of {}, found {}", expect, actual),
-                (self.sess.source_map().next_point(self.prev_span),
-                format!("expected one of {}", short_expect)))
+                (self.prev_span.shrink_to_hi(), format!("expected one of {}", short_expect)))
         } else if expected.is_empty() {
             (format!("unexpected token: {}", actual),
                 (self.prev_span, "unexpected token after this".to_string()))
         } else {
             (format!("expected {}, found {}", expect, actual),
-                (self.sess.source_map().next_point(self.prev_span),
-                format!("expected {}", expect)))
+                (self.prev_span.shrink_to_hi(), format!("expected {}", expect)))
         };
         self.last_unexpected_token_span = Some(self.token.span);
         let mut err = self.fatal(&msg_exp);
@@ -871,7 +869,7 @@ impl<'a> Parser<'a> {
             _ if self.prev_span == DUMMY_SP => (self.token.span, self.token.span),
             // EOF, don't want to point at the following char, but rather the last token.
             (token::Eof, None) => (self.prev_span, self.token.span),
-            _ => (self.sess.source_map().next_point(self.prev_span), self.token.span),
+            _ => (self.prev_span.shrink_to_hi(), self.token.span),
         };
         let msg = format!(
             "expected `{}`, found {}",
@@ -1179,7 +1177,7 @@ impl<'a> Parser<'a> {
                     err.span_label(sp, "unclosed delimiter");
                 }
                 err.span_suggestion_short(
-                    self.sess.source_map().next_point(self.prev_span),
+                    self.prev_span.shrink_to_hi(),
                     &format!("{} may belong here", delim.to_string()),
                     delim.to_string(),
                     Applicability::MaybeIncorrect,

src/librustc_parse/parser/expr.rs

@@ -1647,7 +1647,7 @@ impl<'a> Parser<'a> {
                             //   |      |
                             //   |      parsed until here as `"y" & X`
                             err.span_suggestion_short(
-                                cm.next_point(arm_start_span),
+                                arm_start_span.shrink_to_hi(),
                                 "missing a comma here to end this `match` arm",
                                 ",".to_owned(),
                                 Applicability::MachineApplicable

src/librustc_parse/parser/item.rs

@@ -1706,7 +1706,7 @@ impl<'a> Parser<'a> {
             // it's safe to peel off one character only when it has the close delim
             self.prev_span.with_lo(self.prev_span.hi() - BytePos(1))
         } else {
-            self.sess.source_map().next_point(self.prev_span)
+            self.prev_span.shrink_to_hi()
         };
 
         self.struct_span_err(
@@ -1720,7 +1720,7 @@ impl<'a> Parser<'a> {
             ],
             Applicability::MaybeIncorrect,
         ).span_suggestion(
-            self.sess.source_map().next_point(self.prev_span),
+            self.prev_span.shrink_to_hi(),
             "add a semicolon",
             ';'.to_string(),
             Applicability::MaybeIncorrect,

src/librustc_parse/parser/mod.rs

@@ -803,7 +803,7 @@ impl<'a> Parser<'a> {
                             break;
                         }
                         Err(mut expect_err) => {
-                            let sp = self.sess.source_map().next_point(self.prev_span);
+                            let sp = self.prev_span.shrink_to_hi();
                             let token_str = pprust::token_kind_to_string(t);
 
                             // Attempt to keep parsing if it was a similar separator.

src/librustc_typeck/check/callee.rs

@@ -254,7 +254,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             hir::ExprKind::Block(..),
         ) = (parent_node, callee_node) {
             let start = sp.shrink_to_lo();
-            let end = self.tcx.sess.source_map().next_point(callee_span);
+            let end = callee_span.shrink_to_hi();
             err.multipart_suggestion(
                 "if you meant to create this closure and immediately call it, surround the \
                 closure with parenthesis",
@@ -332,9 +332,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             let call_is_multiline =
                                 self.tcx.sess.source_map().is_multiline(call_expr.span);
                             if call_is_multiline {
-                                let span = self.tcx.sess.source_map().next_point(callee.span);
                                 err.span_suggestion(
-                                    span,
+                                    callee.span.shrink_to_hi(),
                                     "try adding a semicolon",
                                     ";".to_owned(),
                                     Applicability::MaybeIncorrect,

src/librustc_typeck/check/mod.rs

@@ -4834,9 +4834,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 ExprKind::Loop(..) |
                 ExprKind::Match(..) |
                 ExprKind::Block(..) => {
-                    let sp = self.tcx.sess.source_map().next_point(cause_span);
                     err.span_suggestion(
-                        sp,
+                        cause_span.shrink_to_hi(),
                         "try adding a semicolon",
                         ";".to_string(),
                         Applicability::MachineApplicable);

src/libsyntax_expand/mbe/macro_parser.rs

@@ -708,7 +708,7 @@ pub(super) fn parse(
                     Token::new(token::Eof, if parser.token.span.is_dummy() {
                         parser.token.span
                     } else {
-                        sess.source_map().next_point(parser.token.span)
+                        parser.token.span.shrink_to_hi()
                     }),
                     "missing tokens in macro arguments",
                 );

src/libsyntax_ext/assert.rs

@@ -105,7 +105,7 @@ fn parse_assert<'a>(
     let custom_message = if let token::Literal(token::Lit { kind: token::Str, .. })
                                 = parser.token.kind {
         let mut err = cx.struct_span_warn(parser.token.span, "unexpected string literal");
-        let comma_span = cx.source_map().next_point(parser.prev_span);
+        let comma_span = parser.prev_span.shrink_to_hi();
         err.span_suggestion_short(
             comma_span,
             "try adding a comma",