Review comments

Author: estebank

Diff for: src/libsyntax/ext/tt/macro_rules.rs

@@ -120,15 +120,16 @@ fn generic_extension<'cx>(cx: &'cx mut ExtCtxt,
                     _ => cx.span_bug(sp, "malformed macro rhs"),
                 };
 
+                let rhs_spans = rhs.iter().map(|t| t.span()).collect::<Vec<_>>();
                 // rhs has holes ( `$id` and `$(...)` that need filled)
-                let mut tts = transcribe(cx, Some(named_matches), rhs.clone());
+                let mut tts = transcribe(cx, Some(named_matches), rhs);
 
                 // Replace all the tokens for the corresponding positions in the macro, to maintain
                 // proper positions in error reporting, while maintaining the macro_backtrace.
-                if rhs.len() == tts.len() {
-                    tts = tts.map_pos(|i, tt| {
+                if rhs_spans.len() == tts.len() {
+                    tts = tts.map_enumerated(|i, tt| {
                         let mut tt = tt.clone();
-                        let mut sp = rhs[i].span();
+                        let mut sp = rhs_spans[i];
                         sp.ctxt = tt.span().ctxt;
                         tt.set_span(sp);
                         tt

Diff for: src/libsyntax/tokenstream.rs

@@ -258,7 +258,7 @@ impl TokenStream {
         }
     }
 
-    pub fn map_pos<F: FnMut(usize, TokenTree) -> TokenTree>(self, mut f: F) -> TokenStream {
+    pub fn map_enumerated<F: FnMut(usize, TokenTree) -> TokenTree>(self, mut f: F) -> TokenStream {
         let mut trees = self.into_trees();
         let mut result = Vec::new();
         let mut i = 0;

Diff for: src/libsyntax_pos/lib.rs

@@ -185,29 +185,18 @@ impl Span {
         result
     }
 
-    pub fn empty_ctxt(&self) -> bool {
-        self.ctxt == SyntaxContext::empty()
-    }
-
     /// Return a `Span` that would enclose both `self` and `end`.
     pub fn to(self, end: Span) -> Span {
-        let lo = if self.lo < end.lo {
-            self.lo
-        } else {
-            end.lo
-        };
-        let hi = if self.hi > end.hi {
-            self.hi
-        } else {
-            end.hi
-        };
-        // FIXME(jseyfried): self.ctxt should always equal end.ctxt here (c.f. issue #23480)
-        let ctxt = if self.ctxt == SyntaxContext::empty() {
-            end.ctxt
-        } else {
-            self.ctxt
-        };
-        Span {lo, hi, ctxt}
+        Span {
+            lo: cmp::min(self.lo, end.lo),
+            hi: cmp::max(self.hi, end.hi),
+            // FIXME(jseyfried): self.ctxt should always equal end.ctxt here (c.f. issue #23480)
+            ctxt: if self.ctxt == SyntaxContext::empty() {
+                end.ctxt
+            } else {
+                self.ctxt
+            },
+        }
     }
 
     /// Return a `Span` between the end of `self` to the beginning of `end`.