1 files changed, 25 insertions, 56 deletions

diff --git a/src/librustc_save_analysis/span_utils.rs b/src/librustc_save_analysis/span_utils.rs
index b9d82b8e251..ff1a8541e06 100644
--- a/src/librustc_save_analysis/span_utils.rs
+++ b/src/librustc_save_analysis/span_utils.rs
@@ -42,7 +42,11 @@ impl<'a> SpanUtils<'a> {
         if path.is_absolute() {
             path.clone().display().to_string()
         } else {
-            env::current_dir().unwrap().join(&path).display().to_string()
+            env::current_dir()
+                .unwrap()
+                .join(&path)
+                .display()
+                .to_string()
         }
     }
 
@@ -66,7 +70,7 @@ impl<'a> SpanUtils<'a> {
         loop {
             let ts = toks.real_token();
             if ts.tok == token::Eof {
-                return result
+                return result;
             }
             if bracket_count == 0 && (ts.tok.is_ident() || ts.tok.is_keyword(keywords::SelfValue)) {
                 result = Some(ts.sp);
@@ -103,47 +107,6 @@ impl<'a> SpanUtils<'a> {
         }
     }
 
-    // Return the span for the last ident before a `(` or `<` or '::<' and outside any
-    // any brackets, or the last span.
-    pub fn sub_span_for_meth_name(&self, span: Span) -> Option<Span> {
-        let mut toks = self.retokenise_span(span);
-        let mut prev = toks.real_token();
-        let mut result = None;
-        let mut bracket_count = 0;
-        let mut prev_span = None;
-        while prev.tok != token::Eof {
-            prev_span = None;
-            let mut next = toks.real_token();
-
-            if (next.tok == token::OpenDelim(token::Paren) || next.tok == token::Lt) &&
-               bracket_count == 0 && prev.tok.is_ident() {
-                result = Some(prev.sp);
-            }
-
-            if bracket_count == 0 && next.tok == token::ModSep {
-                let old = prev;
-                prev = next;
-                next = toks.real_token();
-                if next.tok == token::Lt && old.tok.is_ident() {
-                    result = Some(old.sp);
-                }
-            }
-
-            bracket_count += match prev.tok {
-                token::OpenDelim(token::Paren) | token::Lt => 1,
-                token::CloseDelim(token::Paren) | token::Gt => -1,
-                token::BinOp(token::Shr) => -2,
-                _ => 0,
-            };
-
-            if prev.tok.is_ident() && bracket_count == 0 {
-                prev_span = Some(prev.sp);
-            }
-            prev = next;
-        }
-        result.or(prev_span)
-    }
-
     // Return the span for the last ident before a `<` and outside any
     // angle brackets, or the last span.
     pub fn sub_span_for_type_name(&self, span: Span) -> Option<Span> {
@@ -163,10 +126,9 @@ impl<'a> SpanUtils<'a> {
         loop {
             let next = toks.real_token();
 
-            if (next.tok == token::Lt || next.tok == token::Colon) &&
-               angle_count == 0 &&
-               bracket_count == 0 &&
-               prev.tok.is_ident() {
+            if (next.tok == token::Lt || next.tok == token::Colon) && angle_count == 0
+                && bracket_count == 0 && prev.tok.is_ident()
+            {
                 result = Some(prev.sp);
             }
 
@@ -193,12 +155,14 @@ impl<'a> SpanUtils<'a> {
         }
         if angle_count != 0 || bracket_count != 0 {
             let loc = self.sess.codemap().lookup_char_pos(span.lo());
-            span_bug!(span,
-                      "Mis-counted brackets when breaking path? Parsing '{}' \
-                       in {}, line {}",
-                      self.snippet(span),
-                      loc.file.name,
-                      loc.line);
+            span_bug!(
+                span,
+                "Mis-counted brackets when breaking path? Parsing '{}' \
+                 in {}, line {}",
+                self.snippet(span),
+                loc.file.name,
+                loc.line
+            );
         }
         if result.is_none() && prev.tok.is_ident() && angle_count == 0 {
             return Some(prev.sp);
@@ -252,7 +216,7 @@ impl<'a> SpanUtils<'a> {
             if f(ts.tok) {
                 let ts = toks.real_token();
                 if ts.tok == token::Eof {
-                    return None
+                    return None;
                 } else {
                     return Some(ts.sp);
                 }
@@ -319,7 +283,12 @@ impl<'a> SpanUtils<'a> {
         };
 
         //If the span comes from a fake filemap, filter it.
-        if !self.sess.codemap().lookup_char_pos(parent.lo()).file.is_real_file() {
+        if !self.sess
+            .codemap()
+            .lookup_char_pos(parent.lo())
+            .file
+            .is_real_file()
+        {
             return true;
         }
 
@@ -330,7 +299,7 @@ impl<'a> SpanUtils<'a> {
 }
 
 macro_rules! filter {
-    ($util: expr, $span: ident, $parent: expr, None) => {
+    ($util: expr, $span: expr, $parent: expr, None) => {
         if $util.filter_generated($span, $parent) {
             return None;
         }