From 2cb460e6259af63924a719beaf91c5804dd0a789 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Wed, 25 Sep 2019 22:55:04 +0300
Subject: [PATCH 01/23] Use `saturating_sub` where applicable

---
 src/librustc_errors/emitter.rs | 24 ++++++------------------
 1 file changed, 6 insertions(+), 18 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 2a89c94652a24..c5b03acb622f6 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -99,8 +99,8 @@ impl Margin {
         // ```
 
         let mut m = Margin {
-            whitespace_left: if whitespace_left >= 6 { whitespace_left - 6 } else { 0 },
-            span_left: if span_left >= 6 { span_left - 6 } else { 0 },
+            whitespace_left: whitespace_left.saturating_sub(6),
+            span_left: span_left.saturating_sub(6),
             span_right: span_right + 6,
             computed_left: 0,
             computed_right: 0,
@@ -167,7 +167,7 @@ impl Margin {
     }
 
     fn right(&self, line_len: usize) -> usize {
-        if max(line_len, self.computed_left) - self.computed_left <= self.column_width {
+        if line_len.saturating_sub(self.computed_left) <= self.column_width {
             line_len
         } else if self.computed_right > line_len {
             line_len
@@ -941,17 +941,9 @@ impl EmitterWriter {
                 Style::LabelSecondary
             };
             let (pos, col) = if pos == 0 {
-                (pos + 1, if annotation.end_col + 1 > left {
-                    annotation.end_col + 1 - left
-                } else {
-                    0
-                })
+                (pos + 1, (annotation.end_col + 1).saturating_sub(left))
             } else {
-                (pos + 2, if annotation.start_col > left {
-                    annotation.start_col - left
-                } else {
-                    0
-                })
+                (pos + 2, annotation.start_col.saturating_sub(left))
             };
             if let Some(ref label) = annotation.label {
                 buffer.puts(line_offset + pos, code_offset + col, &label, style);
@@ -991,11 +983,7 @@ impl EmitterWriter {
             for p in annotation.start_col..annotation.end_col {
                 buffer.putc(
                     line_offset + 1,
-                    if code_offset + p > left {
-                        code_offset + p - left
-                    } else {
-                        0
-                    },
+                    (code_offset + p).saturating_sub(left),
                     underline,
                     style,
                 );

From e9a93be53a6ccec5ba76f17333acf3c198313c61 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Wed, 25 Sep 2019 23:08:09 +0300
Subject: [PATCH 02/23] Use `max` instead of `if`s

---
 src/librustc_errors/emitter.rs | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index c5b03acb622f6..45c3dd8f4d825 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -169,10 +169,8 @@ impl Margin {
     fn right(&self, line_len: usize) -> usize {
         if line_len.saturating_sub(self.computed_left) <= self.column_width {
             line_len
-        } else if self.computed_right > line_len {
-            line_len
         } else {
-            self.computed_right
+            min(line_len, self.computed_right)
         }
     }
 }
@@ -797,9 +795,7 @@ impl EmitterWriter {
                     }
                 }
             }
-            if line_len < p {
-                line_len = p;
-            }
+            line_len = max(line_len, p);
         }
 
         if line_len != 0 {
@@ -1772,9 +1768,7 @@ impl FileWithAnnotatedLines {
 
         let mut max_depth = 0;  // max overlapping multiline spans
         for (file, ann) in multiline_annotations {
-            if ann.depth > max_depth {
-                max_depth = ann.depth;
-            }
+            max_depth = max(max_depth, ann.depth);
             let mut end_ann = ann.as_end();
             if !ann.overlaps_exactly {
                 // avoid output like

From 4fc5650d17794c00fbf03597b35979de7094d386 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Wed, 25 Sep 2019 23:13:19 +0300
Subject: [PATCH 03/23] Simplify Unicode-aware trimming

---
 src/librustc_errors/emitter.rs | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 45c3dd8f4d825..151c06ddbbd4c 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -529,18 +529,21 @@ impl EmitterWriter {
         let left = margin.left(line_len);
         let right = margin.right(line_len);
         // On long lines, we strip the source line, accounting for unicode.
-        let mut taken = 0;
-        let code: String = source_string.chars().skip(left).take_while(|ch| {
-            // Make sure that the trimming on the right will fall within the terminal width.
-            // FIXME: `unicode_width` sometimes disagrees with terminals on how wide a `char` is.
-            // For now, just accept that sometimes the code line will be longer than desired.
-            let next = unicode_width::UnicodeWidthChar::width(*ch).unwrap_or(1);
-            if taken + next > right - left {
-                return false;
-            }
-            taken += next;
-            true
-        }).collect();
+        // Make sure that the trimming on the right will fall within the terminal width.
+        // FIXME: `unicode_width` sometimes disagrees with terminals on how wide a `char` is.
+        // For now, just accept that sometimes the code line will be longer than desired.
+        let code: String = source_string.chars().skip(left)
+            .map(|ch| {
+                let width = unicode_width::UnicodeWidthChar::width(*ch).unwrap_or(1);
+                (width, ch)
+            })
+            .scan(0, |len, (width, ch)| {
+                *len += width;
+                Some(*len, ch)
+            })
+            .take_while(|&(prefix_len, _ch)| prefix_len <= right - left)
+            .map(|(_prefix_len, ch)| ch)
+            .collect();
         buffer.puts(line_offset, code_offset, &code, Style::Quotation);
         if margin.was_cut_left() {
             // We have stripped some code/whitespace from the beginning, make it clear.

From d6327e8f12cc51254d62e6755f67ea580fc4dd21 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Wed, 25 Sep 2019 23:23:19 +0300
Subject: [PATCH 04/23] Use map + sum instead of fold for computing Unicode
 width

---
 src/librustc_errors/emitter.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 151c06ddbbd4c..17a5fac6da75e 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -594,9 +594,9 @@ impl EmitterWriter {
 
         let left = margin.left(source_string.len()); // Left trim
         // Account for unicode characters of width !=0 that were removed.
-        let left = source_string.chars().take(left).fold(0, |acc, ch| {
-            acc + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1)
-        });
+        let left = source_string.chars().take(left)
+            .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
+            .sum();
 
         self.draw_line(
             buffer,
@@ -1512,9 +1512,9 @@ impl EmitterWriter {
                             .saturating_sub(part.snippet.trim_start().len());
                         // ...or trailing spaces. Account for substitutions containing unicode
                         // characters.
-                        let sub_len = part.snippet.trim().chars().fold(0, |acc, ch| {
-                            acc + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1)
-                        });
+                        let sub_len = part.snippet.trim().chars()
+                            .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
+                            .sum();
 
                         let underline_start = (span_start_pos + start) as isize + offset;
                         let underline_end = (span_start_pos + start + sub_len) as isize + offset;
@@ -1535,9 +1535,9 @@ impl EmitterWriter {
                         }
 
                         // length of the code after substitution
-                        let full_sub_len = part.snippet.chars().fold(0, |acc, ch| {
-                            acc + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1) as isize
-                        });
+                        let full_sub_len = part.snippet.chars()
+                            .map(|ch| acc + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
+                            .sum() as isize;
 
                         // length of the code to be substituted
                         let snippet_len = span_end_pos as isize - span_start_pos as isize;

From aef169b4e637fe417f05fa50450b90e403023a5f Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Wed, 25 Sep 2019 23:41:27 +0300
Subject: [PATCH 05/23] Use Option::map_or where applicable

---
 src/librustc_errors/emitter.rs | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 17a5fac6da75e..61bd4899f3c54 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -764,11 +764,7 @@ impl EmitterWriter {
             annotations_position.push((p, annotation));
             for (j, next) in annotations.iter().enumerate() {
                 if j > i  {
-                    let l = if let Some(ref label) = next.label {
-                        label.len() + 2
-                    } else {
-                        0
-                    };
+                    let l = next.label.map_or(0, |label| label.len() + 2);
                     if (overlaps(next, annotation, l) // Do not allow two labels to be in the same
                                                      // line if they overlap including padding, to
                                                      // avoid situations like:
@@ -1311,13 +1307,12 @@ impl EmitterWriter {
                 for line in &annotated_file.lines {
                     max_line_len = max(max_line_len, annotated_file.file
                         .get_line(line.line_index - 1)
-                        .map(|s| s.len())
-                        .unwrap_or(0));
+                        .map_or(0, |s| s.len());
                     for ann in &line.annotations {
                         span_right_margin = max(span_right_margin, ann.start_col);
                         span_right_margin = max(span_right_margin, ann.end_col);
                         // FIXME: account for labels not in the same line
-                        let label_right = ann.label.as_ref().map(|l| l.len() + 1).unwrap_or(0);
+                        let label_right = ann.label.as_ref().map_or(0, |l| l.len() + 1);
                         label_right_margin = max(label_right_margin, ann.end_col + label_right);
                     }
                 }

From 9b447e2f9fb9b0d3366de90b2de72541b195e99d Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Wed, 25 Sep 2019 23:46:33 +0300
Subject: [PATCH 06/23] Unify order of variables in chained comparison

---
 src/librustc_errors/emitter.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 61bd4899f3c54..362e28661d919 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -125,7 +125,7 @@ impl Margin {
         } else {
             self.computed_right
         };
-        right < line_len && line_len > self.computed_left + self.column_width
+        right < line_len && self.computed_left + self.column_width < line_len
     }
 
     fn compute(&mut self, max_line_len: usize) {

From f93827f9e446e52619953c3ad2aa6604dfc9f986 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Thu, 26 Sep 2019 00:31:16 +0300
Subject: [PATCH 07/23] Simplify `Emitter::fix_multispan_in_std_macros`

1. Rewrite `if let` into `match` to return earl and avoid indenting giant block
2. Assign `spans_updated` only once
---
 src/librustc_errors/emitter.rs | 129 +++++++++++++++++----------------
 1 file changed, 65 insertions(+), 64 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 362e28661d919..efb5c63bd0847 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -295,81 +295,82 @@ pub trait Emitter {
                                    source_map: &Option<Lrc<SourceMapperDyn>>,
                                    span: &mut MultiSpan,
                                    always_backtrace: bool) -> bool {
-        let mut spans_updated = false;
+        let sm = match source_map {
+            Some(ref sm) => sm,
+            None => return false,
+        };
 
-        if let Some(ref sm) = source_map {
-            let mut before_after: Vec<(Span, Span)> = vec![];
-            let mut new_labels: Vec<(Span, String)> = vec![];
+        let mut before_after: Vec<(Span, Span)> = vec![];
+        let mut new_labels: Vec<(Span, String)> = vec![];
 
-            // First, find all the spans in <*macros> and point instead at their use site
-            for sp in span.primary_spans() {
-                if sp.is_dummy() {
+        // First, find all the spans in <*macros> and point instead at their use site
+        for sp in span.primary_spans() {
+            if sp.is_dummy() {
+                continue;
+            }
+            let call_sp = sm.call_span_if_macro(*sp);
+            if call_sp != *sp && !always_backtrace {
+                before_after.push((*sp, call_sp));
+            }
+            let backtrace_len = sp.macro_backtrace().len();
+            for (i, trace) in sp.macro_backtrace().iter().rev().enumerate() {
+                // Only show macro locations that are local
+                // and display them like a span_note
+                if trace.def_site_span.is_dummy() {
                     continue;
                 }
-                let call_sp = sm.call_span_if_macro(*sp);
-                if call_sp != *sp && !always_backtrace {
-                    before_after.push((*sp, call_sp));
+                if always_backtrace {
+                    new_labels.push((trace.def_site_span,
+                                        format!("in this expansion of `{}`{}",
+                                                trace.macro_decl_name,
+                                                if backtrace_len > 2 {
+                                                    // if backtrace_len == 1 it'll be pointed
+                                                    // at by "in this macro invocation"
+                                                    format!(" (#{})", i + 1)
+                                                } else {
+                                                    String::new()
+                                                })));
                 }
-                let backtrace_len = sp.macro_backtrace().len();
-                for (i, trace) in sp.macro_backtrace().iter().rev().enumerate() {
-                    // Only show macro locations that are local
-                    // and display them like a span_note
-                    if trace.def_site_span.is_dummy() {
-                        continue;
-                    }
-                    if always_backtrace {
-                        new_labels.push((trace.def_site_span,
-                                            format!("in this expansion of `{}`{}",
-                                                    trace.macro_decl_name,
-                                                    if backtrace_len > 2 {
-                                                        // if backtrace_len == 1 it'll be pointed
-                                                        // at by "in this macro invocation"
-                                                        format!(" (#{})", i + 1)
-                                                    } else {
-                                                        String::new()
-                                                    })));
-                    }
-                    // Check to make sure we're not in any <*macros>
-                    if !sm.span_to_filename(trace.def_site_span).is_macros() &&
-                        !trace.macro_decl_name.starts_with("desugaring of ") &&
-                        !trace.macro_decl_name.starts_with("#[") ||
-                        always_backtrace {
-                        new_labels.push((trace.call_site,
-                                            format!("in this macro invocation{}",
-                                                    if backtrace_len > 2 && always_backtrace {
-                                                        // only specify order when the macro
-                                                        // backtrace is multiple levels deep
-                                                        format!(" (#{})", i + 1)
-                                                    } else {
-                                                        String::new()
-                                                    })));
-                        if !always_backtrace {
-                            break;
-                        }
+                // Check to make sure we're not in any <*macros>
+                if !sm.span_to_filename(trace.def_site_span).is_macros() &&
+                    !trace.macro_decl_name.starts_with("desugaring of ") &&
+                    !trace.macro_decl_name.starts_with("#[") ||
+                    always_backtrace {
+                    new_labels.push((trace.call_site,
+                                        format!("in this macro invocation{}",
+                                                if backtrace_len > 2 && always_backtrace {
+                                                    // only specify order when the macro
+                                                    // backtrace is multiple levels deep
+                                                    format!(" (#{})", i + 1)
+                                                } else {
+                                                    String::new()
+                                                })));
+                    if !always_backtrace {
+                        break;
                     }
                 }
             }
-            for (label_span, label_text) in new_labels {
-                span.push_span_label(label_span, label_text);
+        }
+        for (label_span, label_text) in new_labels {
+            span.push_span_label(label_span, label_text);
+        }
+        for sp_label in span.span_labels() {
+            if sp_label.span.is_dummy() {
+                continue;
             }
-            for sp_label in span.span_labels() {
-                if sp_label.span.is_dummy() {
-                    continue;
-                }
-                if sm.span_to_filename(sp_label.span.clone()).is_macros() &&
-                    !always_backtrace
-                {
-                    let v = sp_label.span.macro_backtrace();
-                    if let Some(use_site) = v.last() {
-                        before_after.push((sp_label.span.clone(), use_site.call_site.clone()));
-                    }
+            if sm.span_to_filename(sp_label.span.clone()).is_macros() &&
+                !always_backtrace
+            {
+                let v = sp_label.span.macro_backtrace();
+                if let Some(use_site) = v.last() {
+                    before_after.push((sp_label.span.clone(), use_site.call_site.clone()));
                 }
             }
-            // After we have them, make sure we replace these 'bad' def sites with their use sites
-            for (before, after) in before_after {
-                span.replace(before, after);
-                spans_updated = true;
-            }
+        }
+        // After we have them, make sure we replace these 'bad' def sites with their use sites
+        let spans_updated = !before_after.is_empty();
+        for (before, after) in before_after {
+            span.replace(before, after);
         }
 
         spans_updated

From ea328625039229f9ad0002a68f1a86691a065cf6 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Thu, 26 Sep 2019 00:38:36 +0300
Subject: [PATCH 08/23] Use `sort_by_key` rather than `sort_by`

---
 src/librustc_errors/emitter.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index efb5c63bd0847..7513a9203fe25 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -954,9 +954,9 @@ impl EmitterWriter {
         //   | |  |
         //   | |  something about `foo`
         //   | something about `fn foo()`
-        annotations_position.sort_by(|a, b| {
+        annotations_position.sort_by_key(|x| {
             // Decreasing order. When `a` and `b` are the same length, prefer `Primary`.
-            (a.1.len(), !a.1.is_primary).cmp(&(b.1.len(), !b.1.is_primary)).reverse()
+            (Reverse(a.1.len()), a.1.is_primary)
         });
 
         // Write the underlines.

From 7a0725fdaf964fa1bf60eefb0cc5846b687426bf Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Thu, 26 Sep 2019 00:42:55 +0300
Subject: [PATCH 09/23] Simplify `style_or_override`

---
 src/librustc_errors/emitter.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 7513a9203fe25..b8b7488d8ae45 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1066,13 +1066,11 @@ impl EmitterWriter {
         let padding = " ".repeat(padding + label.len() + 5);
 
         /// Returns `true` if `style`, or the override if present and the style is `NoStyle`.
-        fn style_or_override(style: Style, override_style: Option<Style>) -> Style {
-            if let Some(o) = override_style {
-                if style == Style::NoStyle {
-                    return o;
-                }
+        fn style_or_override(style: Style, override: Option<Style>) -> Style {
+            match (style, override) {
+                (Style::NoStyle, Some(override)) => override,
+                _ => style,
             }
-            style
         }
 
         let mut line_number = 0;

From 75a7c27a54be31d823cf81a26f463428ab9c2d07 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Fri, 27 Sep 2019 00:58:18 +0300
Subject: [PATCH 10/23] Revert "Simplify Unicode-aware trimming"

`taken` is actually used afterwards
---
 src/librustc_errors/emitter.rs | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index b8b7488d8ae45..1aa6b405c8fad 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -530,21 +530,18 @@ impl EmitterWriter {
         let left = margin.left(line_len);
         let right = margin.right(line_len);
         // On long lines, we strip the source line, accounting for unicode.
-        // Make sure that the trimming on the right will fall within the terminal width.
-        // FIXME: `unicode_width` sometimes disagrees with terminals on how wide a `char` is.
-        // For now, just accept that sometimes the code line will be longer than desired.
-        let code: String = source_string.chars().skip(left)
-            .map(|ch| {
-                let width = unicode_width::UnicodeWidthChar::width(*ch).unwrap_or(1);
-                (width, ch)
-            })
-            .scan(0, |len, (width, ch)| {
-                *len += width;
-                Some(*len, ch)
-            })
-            .take_while(|&(prefix_len, _ch)| prefix_len <= right - left)
-            .map(|(_prefix_len, ch)| ch)
-            .collect();
+        let mut taken = 0;
+        let code: String = source_string.chars().skip(left).take_while(|ch| {
+            // Make sure that the trimming on the right will fall within the terminal width.
+            // FIXME: `unicode_width` sometimes disagrees with terminals on how wide a `char` is.
+            // For now, just accept that sometimes the code line will be longer than desired.
+            let next = unicode_width::UnicodeWidthChar::width(*ch).unwrap_or(1);
+            if taken + next > right - left {
+                return false;
+            }
+            taken += next;
+            true
+        }).collect();
         buffer.puts(line_offset, code_offset, &code, Style::Quotation);
         if margin.was_cut_left() {
             // We have stripped some code/whitespace from the beginning, make it clear.

From 7dc953b493d56f8b24f38d955cc580d9a14c1ae7 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Mon, 30 Sep 2019 23:33:17 +0300
Subject: [PATCH 11/23] Simplify code for special case of annotation

---
 src/librustc_errors/emitter.rs | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 1aa6b405c8fad..f17aee44e942c 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -622,18 +622,16 @@ impl EmitterWriter {
         // 3 | |
         // 4 | | }
         //   | |_^ test
-        if line.annotations.len() == 1 {
-            if let Some(ref ann) = line.annotations.get(0) {
-                if let AnnotationType::MultilineStart(depth) = ann.annotation_type {
-                    if source_string.chars().take(ann.start_col).all(|c| c.is_whitespace()) {
-                        let style = if ann.is_primary {
-                            Style::UnderlinePrimary
-                        } else {
-                            Style::UnderlineSecondary
-                        };
-                        buffer.putc(line_offset, width_offset + depth - 1, '/', style);
-                        return vec![(depth, style)];
-                    }
+        if let [ann] = &line.annotations[..] {
+            if let AnnotationType::MultilineStart(depth) = ann.annotation_type {
+                if source_string.chars().take(ann.start_col).all(|c| c.is_whitespace()) {
+                    let style = if ann.is_primary {
+                        Style::UnderlinePrimary
+                    } else {
+                        Style::UnderlineSecondary
+                    };
+                    buffer.putc(line_offset, width_offset + depth - 1, '/', style);
+                    return vec![(depth, style)];
                 }
             }
         }

From 6b6a79b19004fa2a62f8d02db2625cd7da547abf Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Mon, 30 Sep 2019 23:43:24 +0300
Subject: [PATCH 12/23] Simplify `EmitterWriter::get_multispan_max_line_num`

---
 src/librustc_errors/emitter.rs | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index f17aee44e942c..1d060ff133895 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -997,27 +997,27 @@ impl EmitterWriter {
     }
 
     fn get_multispan_max_line_num(&mut self, msp: &MultiSpan) -> usize {
+        let sm = match self.sm {
+            Some(ref sm) => sm,
+            None => return 0,
+        };
+        
         let mut max = 0;
-        if let Some(ref sm) = self.sm {
-            for primary_span in msp.primary_spans() {
-                if !primary_span.is_dummy() {
-                    let hi = sm.lookup_char_pos(primary_span.hi());
-                    if hi.line > max {
-                        max = hi.line;
-                    }
-                }
+        for primary_span in msp.primary_spans() {
+            if !primary_span.is_dummy() {
+                let hi = sm.lookup_char_pos(primary_span.hi());
+                max = max(max, hi.line);
             }
-            if !self.short_message {
-                for span_label in msp.span_labels() {
-                    if !span_label.span.is_dummy() {
-                        let hi = sm.lookup_char_pos(span_label.span.hi());
-                        if hi.line > max {
-                            max = hi.line;
-                        }
-                    }
+        }
+        if !self.short_message {
+            for span_label in msp.span_labels() {
+                if !span_label.span.is_dummy() {
+                    let hi = sm.lookup_char_pos(span_label.span.hi());
+                    max = max(max, hi.line);
                 }
             }
         }
+        
         max
     }
 

From 7b4c5c62aaa86301c2f358623bf3bfee39e7beef Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Mon, 30 Sep 2019 23:47:51 +0300
Subject: [PATCH 13/23] Simplify `EmitterWriter::get_max_line_num`

---
 src/librustc_errors/emitter.rs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 1d060ff133895..6727f2767598b 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1022,15 +1022,11 @@ impl EmitterWriter {
     }
 
     fn get_max_line_num(&mut self, span: &MultiSpan, children: &[SubDiagnostic]) -> usize {
-
         let primary = self.get_multispan_max_line_num(span);
-        let mut max = primary;
-
-        for sub in children {
-            let sub_result = self.get_multispan_max_line_num(&sub.span);
-            max = std::cmp::max(sub_result, max);
-        }
-        max
+        children.iter()
+            .map(|sub| self.get_multispan_max_line_num(&sub.span))
+            .max()
+            .unwrap_or(primary)
     }
 
     /// Adds a left margin to every line but the first, given a padding length and the label being

From 21724eda05abd377b23bac160f62664bc2ee0082 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Mon, 30 Sep 2019 23:50:58 +0300
Subject: [PATCH 14/23] Update doc comment for `style_or_override`

---
 src/librustc_errors/emitter.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 6727f2767598b..3407967c7c9c1 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1056,7 +1056,7 @@ impl EmitterWriter {
         //    `max_line_num_len`
         let padding = " ".repeat(padding + label.len() + 5);
 
-        /// Returns `true` if `style`, or the override if present and the style is `NoStyle`.
+        /// Returns `override` if it is present and `style` is `NoStyle` or `style` otherwise
         fn style_or_override(style: Style, override: Option<Style>) -> Style {
             match (style, override) {
                 (Style::NoStyle, Some(override)) => override,

From 7a807c5b147b0779f70ad713cb642b8702b73740 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Tue, 1 Oct 2019 00:01:22 +0300
Subject: [PATCH 15/23] Simplify `EmitterWriter::emit_suggestion_default`

Make function return early if source map is not present
---
 src/librustc_errors/emitter.rs | 211 +++++++++++++++++----------------
 1 file changed, 107 insertions(+), 104 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 3407967c7c9c1..cc71a299a73cd 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1431,122 +1431,125 @@ impl EmitterWriter {
         level: &Level,
         max_line_num_len: usize,
     ) -> io::Result<()> {
-        if let Some(ref sm) = self.sm {
-            let mut buffer = StyledBuffer::new();
+        let sm = match self.sm {
+            Some(ref sm) => sm,
+            None => return Ok(())
+        };
 
-            // Render the suggestion message
-            let level_str = level.to_string();
-            if !level_str.is_empty() {
-                buffer.append(0, &level_str, Style::Level(level.clone()));
-                buffer.append(0, ": ", Style::HeaderMsg);
+        let mut buffer = StyledBuffer::new();
+
+        // Render the suggestion message
+        let level_str = level.to_string();
+        if !level_str.is_empty() {
+            buffer.append(0, &level_str, Style::Level(level.clone()));
+            buffer.append(0, ": ", Style::HeaderMsg);
+        }
+        self.msg_to_buffer(
+            &mut buffer,
+            &[(suggestion.msg.to_owned(), Style::NoStyle)],
+            max_line_num_len,
+            "suggestion",
+            Some(Style::HeaderMsg),
+        );
+
+        // Render the replacements for each suggestion
+        let suggestions = suggestion.splice_lines(&**sm);
+
+        let mut row_num = 2;
+        for &(ref complete, ref parts) in suggestions.iter().take(MAX_SUGGESTIONS) {
+            // Only show underline if the suggestion spans a single line and doesn't cover the
+            // entirety of the code output. If you have multiple replacements in the same line
+            // of code, show the underline.
+            let show_underline = !(parts.len() == 1
+                && parts[0].snippet.trim() == complete.trim())
+                && complete.lines().count() == 1;
+
+            let lines = sm.span_to_lines(parts[0].span).unwrap();
+
+            assert!(!lines.lines.is_empty());
+
+            let line_start = sm.lookup_char_pos(parts[0].span.lo()).line;
+            draw_col_separator_no_space(&mut buffer, 1, max_line_num_len + 1);
+            let mut line_pos = 0;
+            let mut lines = complete.lines();
+            for line in lines.by_ref().take(MAX_HIGHLIGHT_LINES) {
+                // Print the span column to avoid confusion
+                buffer.puts(row_num,
+                            0,
+                            &self.maybe_anonymized(line_start + line_pos),
+                            Style::LineNumber);
+                // print the suggestion
+                draw_col_separator(&mut buffer, row_num, max_line_num_len + 1);
+                buffer.append(row_num, line, Style::NoStyle);
+                line_pos += 1;
+                row_num += 1;
             }
-            self.msg_to_buffer(
-                &mut buffer,
-                &[(suggestion.msg.to_owned(), Style::NoStyle)],
-                max_line_num_len,
-                "suggestion",
-                Some(Style::HeaderMsg),
-            );
-
-            // Render the replacements for each suggestion
-            let suggestions = suggestion.splice_lines(&**sm);
-
-            let mut row_num = 2;
-            for &(ref complete, ref parts) in suggestions.iter().take(MAX_SUGGESTIONS) {
-                // Only show underline if the suggestion spans a single line and doesn't cover the
-                // entirety of the code output. If you have multiple replacements in the same line
-                // of code, show the underline.
-                let show_underline = !(parts.len() == 1
-                    && parts[0].snippet.trim() == complete.trim())
-                    && complete.lines().count() == 1;
-
-                let lines = sm.span_to_lines(parts[0].span).unwrap();
-
-                assert!(!lines.lines.is_empty());
-
-                let line_start = sm.lookup_char_pos(parts[0].span.lo()).line;
-                draw_col_separator_no_space(&mut buffer, 1, max_line_num_len + 1);
-                let mut line_pos = 0;
-                let mut lines = complete.lines();
-                for line in lines.by_ref().take(MAX_HIGHLIGHT_LINES) {
-                    // Print the span column to avoid confusion
-                    buffer.puts(row_num,
-                                0,
-                                &self.maybe_anonymized(line_start + line_pos),
-                                Style::LineNumber);
-                    // print the suggestion
-                    draw_col_separator(&mut buffer, row_num, max_line_num_len + 1);
-                    buffer.append(row_num, line, Style::NoStyle);
-                    line_pos += 1;
-                    row_num += 1;
-                }
 
-                // This offset and the ones below need to be signed to account for replacement code
-                // that is shorter than the original code.
-                let mut offset: isize = 0;
-                // Only show an underline in the suggestions if the suggestion is not the
-                // entirety of the code being shown and the displayed code is not multiline.
-                if show_underline {
-                    draw_col_separator(&mut buffer, row_num, max_line_num_len + 1);
-                    for part in parts {
-                        let span_start_pos = sm.lookup_char_pos(part.span.lo()).col_display;
-                        let span_end_pos = sm.lookup_char_pos(part.span.hi()).col_display;
-
-                        // Do not underline the leading...
-                        let start = part.snippet.len()
-                            .saturating_sub(part.snippet.trim_start().len());
-                        // ...or trailing spaces. Account for substitutions containing unicode
-                        // characters.
-                        let sub_len = part.snippet.trim().chars()
-                            .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
-                            .sum();
-
-                        let underline_start = (span_start_pos + start) as isize + offset;
-                        let underline_end = (span_start_pos + start + sub_len) as isize + offset;
-                        for p in underline_start..underline_end {
+            // This offset and the ones below need to be signed to account for replacement code
+            // that is shorter than the original code.
+            let mut offset: isize = 0;
+            // Only show an underline in the suggestions if the suggestion is not the
+            // entirety of the code being shown and the displayed code is not multiline.
+            if show_underline {
+                draw_col_separator(&mut buffer, row_num, max_line_num_len + 1);
+                for part in parts {
+                    let span_start_pos = sm.lookup_char_pos(part.span.lo()).col_display;
+                    let span_end_pos = sm.lookup_char_pos(part.span.hi()).col_display;
+
+                    // Do not underline the leading...
+                    let start = part.snippet.len()
+                        .saturating_sub(part.snippet.trim_start().len());
+                    // ...or trailing spaces. Account for substitutions containing unicode
+                    // characters.
+                    let sub_len = part.snippet.trim().chars()
+                        .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
+                        .sum();
+
+                    let underline_start = (span_start_pos + start) as isize + offset;
+                    let underline_end = (span_start_pos + start + sub_len) as isize + offset;
+                    for p in underline_start..underline_end {
+                        buffer.putc(row_num,
+                                    max_line_num_len + 3 + p as usize,
+                                    '^',
+                                    Style::UnderlinePrimary);
+                    }
+                    // underline removals too
+                    if underline_start == underline_end {
+                        for p in underline_start-1..underline_start+1 {
                             buffer.putc(row_num,
                                         max_line_num_len + 3 + p as usize,
-                                        '^',
-                                        Style::UnderlinePrimary);
-                        }
-                        // underline removals too
-                        if underline_start == underline_end {
-                            for p in underline_start-1..underline_start+1 {
-                                buffer.putc(row_num,
-                                            max_line_num_len + 3 + p as usize,
-                                            '-',
-                                            Style::UnderlineSecondary);
-                            }
+                                        '-',
+                                        Style::UnderlineSecondary);
                         }
-
-                        // length of the code after substitution
-                        let full_sub_len = part.snippet.chars()
-                            .map(|ch| acc + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
-                            .sum() as isize;
-
-                        // length of the code to be substituted
-                        let snippet_len = span_end_pos as isize - span_start_pos as isize;
-                        // For multiple substitutions, use the position *after* the previous
-                        // substitutions have happened.
-                        offset += full_sub_len - snippet_len;
                     }
-                    row_num += 1;
-                }
 
-                // if we elided some lines, add an ellipsis
-                if lines.next().is_some() {
-                    buffer.puts(row_num, max_line_num_len - 1, "...", Style::LineNumber);
-                } else if !show_underline {
-                    draw_col_separator_no_space(&mut buffer, row_num, max_line_num_len + 1);
-                    row_num += 1;
+                    // length of the code after substitution
+                    let full_sub_len = part.snippet.chars()
+                        .map(|ch| acc + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
+                        .sum() as isize;
+
+                    // length of the code to be substituted
+                    let snippet_len = span_end_pos as isize - span_start_pos as isize;
+                    // For multiple substitutions, use the position *after* the previous
+                    // substitutions have happened.
+                    offset += full_sub_len - snippet_len;
                 }
+                row_num += 1;
             }
-            if suggestions.len() > MAX_SUGGESTIONS {
-                let msg = format!("and {} other candidates", suggestions.len() - MAX_SUGGESTIONS);
-                buffer.puts(row_num, 0, &msg, Style::NoStyle);
+
+            // if we elided some lines, add an ellipsis
+            if lines.next().is_some() {
+                buffer.puts(row_num, max_line_num_len - 1, "...", Style::LineNumber);
+            } else if !show_underline {
+                draw_col_separator_no_space(&mut buffer, row_num, max_line_num_len + 1);
+                row_num += 1;
             }
-            emit_to_destination(&buffer.render(), level, &mut self.dst, self.short_message)?;
         }
+        if suggestions.len() > MAX_SUGGESTIONS {
+            let msg = format!("and {} other candidates", suggestions.len() - MAX_SUGGESTIONS);
+            buffer.puts(row_num, 0, &msg, Style::NoStyle);
+        }
+        emit_to_destination(&buffer.render(), level, &mut self.dst, self.short_message)?;
         Ok(())
     }
 

From 9d73176978c1eece320fe7786d7f66db2bbb6838 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Tue, 1 Oct 2019 00:10:23 +0300
Subject: [PATCH 16/23] Remove redundant `.iter_mut()`

---
 src/librustc_errors/emitter.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index cc71a299a73cd..0e384567846e2 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1655,7 +1655,7 @@ impl FileWithAnnotatedLines {
                                   line_index: usize,
                                   ann: Annotation) {
 
-            for slot in file_vec.iter_mut() {
+            for slot in file_vec {
                 // Look through each of our files for the one we're adding to
                 if slot.file.name == file.name {
                     // See if we already have a line for it

From 55b54285c811b6ab12bb0ba001126fd5b7d3bd09 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Tue, 1 Oct 2019 01:08:51 +0300
Subject: [PATCH 17/23] Simplify a conditional in `collect_annotations`

Also avoid excessive cloning
---
 src/librustc_errors/emitter.rs | 27 +++++++++++----------------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 0e384567846e2..d5e9d7184300e 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1707,7 +1707,7 @@ impl FileWithAnnotatedLines {
                     hi.col_display += 1;
                 }
 
-                let ann_type = if lo.line != hi.line {
+                if lo.line != hi.line {
                     let ml = MultilineAnnotation {
                         depth: 1,
                         line_start: lo.line,
@@ -1715,25 +1715,20 @@ impl FileWithAnnotatedLines {
                         start_col: lo.col_display,
                         end_col: hi.col_display,
                         is_primary: span_label.is_primary,
-                        label: span_label.label.clone(),
+                        label: span_label.label,
                         overlaps_exactly: false,
                     };
-                    multiline_annotations.push((lo.file.clone(), ml.clone()));
-                    AnnotationType::Multiline(ml)
+                    multiline_annotations.push((lo.file, ml));
                 } else {
-                    AnnotationType::Singleline
-                };
-                let ann = Annotation {
-                    start_col: lo.col_display,
-                    end_col: hi.col_display,
-                    is_primary: span_label.is_primary,
-                    label: span_label.label.clone(),
-                    annotation_type: ann_type,
-                };
-
-                if !ann.is_multiline() {
+                    let ann = Annotation {
+                        start_col: lo.col_display,
+                        end_col: hi.col_display,
+                        is_primary: span_label.is_primary,
+                        label: span_label.label,
+                        annotation_type: AnnotationType::Singleline,
+                    };
                     add_annotation_to_file(&mut output, lo.file, lo.line, ann);
-                }
+                };
             }
         }
 

From bb442881fc3d91175c032c8ff347c81ca59ed777 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Tue, 1 Oct 2019 01:12:36 +0300
Subject: [PATCH 18/23] Use pattern matching instead of indexing tuples

---
 src/librustc_errors/emitter.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index d5e9d7184300e..28e67fa09129c 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1734,10 +1734,8 @@ impl FileWithAnnotatedLines {
 
         // Find overlapping multiline annotations, put them at different depths
         multiline_annotations.sort_by_key(|&(_, ref ml)| (ml.line_start, ml.line_end));
-        for item in multiline_annotations.clone() {
-            let ann = item.1;
-            for item in multiline_annotations.iter_mut() {
-                let ref mut a = item.1;
+        for (_, ann) in multiline_annotations.clone() {
+            for (_, a) in multiline_annotations.iter_mut() {
                 // Move all other multiline annotations overlapping with this one
                 // one level to the right.
                 if !(ann.same_span(a)) &&

From e5db5b34d74098a30f70eb30f18ef8c9da3615d2 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Tue, 1 Oct 2019 02:30:52 +0300
Subject: [PATCH 19/23] (fmt) remove trailing whitespaces

---
 src/librustc_errors/emitter.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 28e67fa09129c..967b98b9b4599 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1001,7 +1001,7 @@ impl EmitterWriter {
             Some(ref sm) => sm,
             None => return 0,
         };
-        
+
         let mut max = 0;
         for primary_span in msp.primary_spans() {
             if !primary_span.is_dummy() {
@@ -1017,7 +1017,7 @@ impl EmitterWriter {
                 }
             }
         }
-        
+
         max
     }
 

From 61bc38ecaad8d2dae451f88b87e8d1ddd3735307 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Tue, 1 Oct 2019 02:38:35 +0300
Subject: [PATCH 20/23] Fix errors

---
 src/librustc_errors/emitter.rs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 967b98b9b4599..a9599edab4f3c 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -949,9 +949,9 @@ impl EmitterWriter {
         //   | |  |
         //   | |  something about `foo`
         //   | something about `fn foo()`
-        annotations_position.sort_by_key(|x| {
-            // Decreasing order. When `a` and `b` are the same length, prefer `Primary`.
-            (Reverse(a.1.len()), a.1.is_primary)
+        annotations_position.sort_by_key(|(_, ann)| {
+            // Decreasing order. When annotations share the same length, prefer `Primary`.
+            (Reverse(ann.len()), ann.is_primary)
         });
 
         // Write the underlines.
@@ -1006,14 +1006,14 @@ impl EmitterWriter {
         for primary_span in msp.primary_spans() {
             if !primary_span.is_dummy() {
                 let hi = sm.lookup_char_pos(primary_span.hi());
-                max = max(max, hi.line);
+                max = (hi.line).max(max);
             }
         }
         if !self.short_message {
             for span_label in msp.span_labels() {
                 if !span_label.span.is_dummy() {
                     let hi = sm.lookup_char_pos(span_label.span.hi());
-                    max = max(max, hi.line);
+                    max = (hi.line).max(max);
                 }
             }
         }
@@ -1057,9 +1057,9 @@ impl EmitterWriter {
         let padding = " ".repeat(padding + label.len() + 5);
 
         /// Returns `override` if it is present and `style` is `NoStyle` or `style` otherwise
-        fn style_or_override(style: Style, override: Option<Style>) -> Style {
-            match (style, override) {
-                (Style::NoStyle, Some(override)) => override,
+        fn style_or_override(style: Style, override_: Option<Style>) -> Style {
+            match (style, override_) {
+                (Style::NoStyle, Some(override_)) => override_,
                 _ => style,
             }
         }
@@ -1297,7 +1297,7 @@ impl EmitterWriter {
                 for line in &annotated_file.lines {
                     max_line_len = max(max_line_len, annotated_file.file
                         .get_line(line.line_index - 1)
-                        .map_or(0, |s| s.len());
+                        .map_or(0, |s| s.len()));
                     for ann in &line.annotations {
                         span_right_margin = max(span_right_margin, ann.start_col);
                         span_right_margin = max(span_right_margin, ann.end_col);
@@ -1525,7 +1525,7 @@ impl EmitterWriter {
 
                     // length of the code after substitution
                     let full_sub_len = part.snippet.chars()
-                        .map(|ch| acc + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
+                        .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
                         .sum() as isize;
 
                     // length of the code to be substituted

From 515262cc131c8b0bb41f8ba2db233f1bf987501e Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Tue, 1 Oct 2019 02:53:44 +0300
Subject: [PATCH 21/23] Ascript type explicitly

---
 src/librustc_errors/emitter.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index a9599edab4f3c..aaae99655695c 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1501,7 +1501,7 @@ impl EmitterWriter {
                         .saturating_sub(part.snippet.trim_start().len());
                     // ...or trailing spaces. Account for substitutions containing unicode
                     // characters.
-                    let sub_len = part.snippet.trim().chars()
+                    let sub_len: usize = part.snippet.trim().chars()
                         .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
                         .sum();
 

From fdce4168fc4c0a46bbe59d482f3d8a4cb4155537 Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Tue, 1 Oct 2019 03:04:01 +0300
Subject: [PATCH 22/23] Hint type for `.sum()`

---
 src/librustc_errors/emitter.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index aaae99655695c..263ffb0d17cc6 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1526,7 +1526,7 @@ impl EmitterWriter {
                     // length of the code after substitution
                     let full_sub_len = part.snippet.chars()
                         .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
-                        .sum() as isize;
+                        .sum::<usize>() as isize;
 
                     // length of the code to be substituted
                     let snippet_len = span_end_pos as isize - span_start_pos as isize;

From 50c2a58d086ec9124a6749eb75afc35c0bc1652f Mon Sep 17 00:00:00 2001
From: AnthonyMikh <anthony.mikh@yandex.ru>
Date: Tue, 1 Oct 2019 03:22:07 +0300
Subject: [PATCH 23/23] Fix borrowck errors

Reborrowing doesn't work for loops
---
 src/librustc_errors/emitter.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index 263ffb0d17cc6..0c7aa3582ac23 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -760,7 +760,7 @@ impl EmitterWriter {
             annotations_position.push((p, annotation));
             for (j, next) in annotations.iter().enumerate() {
                 if j > i  {
-                    let l = next.label.map_or(0, |label| label.len() + 2);
+                    let l = next.label.as_ref().map_or(0, |label| label.len() + 2);
                     if (overlaps(next, annotation, l) // Do not allow two labels to be in the same
                                                      // line if they overlap including padding, to
                                                      // avoid situations like:
@@ -1655,7 +1655,7 @@ impl FileWithAnnotatedLines {
                                   line_index: usize,
                                   ann: Annotation) {
 
-            for slot in file_vec {
+            for slot in file_vec.iter_mut() {
                 // Look through each of our files for the one we're adding to
                 if slot.file.name == file.name {
                     // See if we already have a line for it