satisfy make tidy

nrc · nikomatsakis · commit e99da528a6f8 · 2015-01-05T13:23:55.000-05:00
diff --git a/src/libcore/array.rs b/src/libcore/array.rs
@@ -57,9 +57,13 @@ macro_rules! array_impls {
                 Rhs: Deref<Target=[B]>,
             {
                 #[inline(always)]
-                fn eq(&self, other: &Rhs) -> bool { PartialEq::eq(self.index(&FullRange), &**other) }
+                fn eq(&self, other: &Rhs) -> bool {
+                    PartialEq::eq(self.index(&FullRange), &**other)
+                }
                 #[inline(always)]
-                fn ne(&self, other: &Rhs) -> bool { PartialEq::ne(self.index(&FullRange), &**other) }
+                fn ne(&self, other: &Rhs) -> bool {
+                    PartialEq::ne(self.index(&FullRange), &**other)
+                }
             }
 
             #[stable]
@@ -68,9 +72,13 @@ macro_rules! array_impls {
                 Lhs: Deref<Target=[A]>
             {
                 #[inline(always)]
-                fn eq(&self, other: &[B; $N]) -> bool { PartialEq::eq(&**self, other.index(&FullRange)) }
+                fn eq(&self, other: &[B; $N]) -> bool {
+                    PartialEq::eq(&**self, other.index(&FullRange))
+                }
                 #[inline(always)]
-                fn ne(&self, other: &[B; $N]) -> bool { PartialEq::ne(&**self, other.index(&FullRange)) }
+                fn ne(&self, other: &[B; $N]) -> bool {
+                    PartialEq::ne(&**self, other.index(&FullRange))
+                }
             }
 
             #[stable]
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
@@ -492,7 +492,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
                                 None => {
                                     self.span_lint(builtin::UNKNOWN_LINTS, span,
                                                format!("unknown `{}` attribute: `{}`",
-                                                       level.as_str(), lint_name).index(&FullRange));
+                                                       level.as_str(), lint_name).as_slice());
                                     continue;
                                 }
                             }
@@ -784,7 +784,7 @@ pub fn check_crate(tcx: &ty::ctxt,
         for &(lint, span, ref msg) in v.iter() {
             tcx.sess.span_bug(span,
                               format!("unprocessed lint {} at {}: {}",
-                                      lint.as_str(), tcx.map.node_to_string(*id), *msg).index(&FullRange))
+                                      lint.as_str(), tcx.map.node_to_string(*id), *msg).as_slice())
         }
     }
 
diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs
@@ -624,7 +624,8 @@ impl<'a> Context<'a> {
                     return true
                 } else {
                     let (ref prefix, ref suffix) = dylibname;
-                    if file.starts_with(prefix.index(&FullRange)) && file.ends_with(suffix.index(&FullRange)) {
+                    if file.starts_with(prefix.index(&FullRange)) &&
+                       file.ends_with(suffix.index(&FullRange)) {
                         return true
                     }
                 }
diff --git a/src/librustc/middle/cfg/graphviz.rs b/src/librustc/middle/cfg/graphviz.rs
@@ -85,7 +85,9 @@ impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> {
             let s = self.ast_map.node_to_string(node_id);
             // left-aligns the lines
             let s = replace_newline_with_backslash_l(s);
-            label.push_str(format!("exiting scope_{} {}", i, s.index(&FullRange)).index(&FullRange));
+            label.push_str(format!("exiting scope_{} {}",
+                                   i,
+                                   s.index(&FullRange)).index(&FullRange));
         }
         dot::LabelText::EscStr(label.into_cow())
     }
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
@@ -639,7 +639,7 @@ pub fn build_target_config(opts: &Options, sp: &SpanHandler) -> Config {
     let target = match Target::search(opts.target_triple.index(&FullRange)) {
         Ok(t) => t,
         Err(e) => {
-            sp.handler().fatal((format!("Error loading target specification: {}", e)).index(&FullRange));
+            sp.handler().fatal((format!("Error loading target specification: {}", e)).as_slice());
     }
     };
 
diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs
@@ -247,7 +247,9 @@ impl Target {
             } );
             ($key_name:ident, bool) => ( {
                 let name = (stringify!($key_name)).replace("_", "-");
-                obj.find(name.index(&FullRange)).map(|o| o.as_boolean().map(|s| base.options.$key_name = s));
+                obj.find(name.index(&FullRange))
+                    .map(|o| o.as_boolean()
+                         .map(|s| base.options.$key_name = s));
             } );
             ($key_name:ident, list) => ( {
                 let name = (stringify!($key_name)).replace("_", "-");
diff --git a/src/librustc_borrowck/borrowck/doc.rs b/src/librustc_borrowck/borrowck/doc.rs
@@ -138,7 +138,7 @@
 //! - `FREEZE` means that the `LV` cannot be borrowed immutably;
 //!
 //! Finally, it is never possible to move from an lvalue that appears in a
-//! restriction. This implies that the "empty restriction" `(LV, .index(&FullRange))`,
+//! restriction. This implies that the "empty restriction" `(LV, [])`,
 //! which contains an empty set of actions, still has a purpose---it
 //! prevents moves from `LV`. I chose not to make `MOVE` a fourth kind of
 //! action because that would imply that sometimes moves are permitted
@@ -476,7 +476,7 @@
 //! ```text
 //! &mut LV =>   RESTRICTIONS(LV, LT, MUTATE|CLAIM|FREEZE)
 //! &LV =>       RESTRICTIONS(LV, LT, MUTATE|CLAIM)
-//! &const LV => RESTRICTIONS(LV, LT, .index(&FullRange))
+//! &const LV => RESTRICTIONS(LV, LT, [])
 //! ```
 //!
 //! The reasoning here is that a mutable borrow must be the only writer,
@@ -542,7 +542,7 @@
 //! restricting `MUTATE` and `CLAIM` actions:
 //!
 //! ```text
-//! RESTRICTIONS(*LV, LT, ACTIONS) = .index(&FullRange)                    // R-Deref-Imm-Borrowed
+//! RESTRICTIONS(*LV, LT, ACTIONS) = []                    // R-Deref-Imm-Borrowed
 //!   TYPE(LV) = &LT' Ty
 //!   LT <= LT'                                            // (1)
 //!   ACTIONS subset of [MUTATE, CLAIM]
@@ -660,7 +660,7 @@
 //! necessary to add any restrictions at all to the final result.
 //!
 //! ```text
-//!     RESTRICTIONS(*LV, LT, .index(&FullRange)) = .index(&FullRange)                         // R-Deref-Freeze-Borrowed
+//!     RESTRICTIONS(*LV, LT, []) = []                // R-Deref-Freeze-Borrowed
 //!       TYPE(LV) = &const Ty
 //! ```
 //!
diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs
@@ -820,7 +820,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
             mc::AliasableClosure(id) => {
                 self.tcx.sess.span_err(span,
                                        format!("{} in a captured outer \
-                                               variable in an `Fn` closure", prefix).index(&FullRange));
+                                               variable in an `Fn` closure", prefix).as_slice());
                 span_help!(self.tcx.sess, self.tcx.map.span(id),
                            "consider changing this closure to take self by mutable reference");
             }
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
@@ -3757,13 +3757,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                             self.resolve_error(path.span,
                                 format!("`{}` is not an enum variant, struct or const",
                                     token::get_ident(
-                                        path.segments.last().unwrap().identifier)).index(&FullRange));
+                                        path.segments.last().unwrap().identifier)).as_slice());
                         }
                         None => {
                             self.resolve_error(path.span,
                                 format!("unresolved enum variant, struct or const `{}`",
                                     token::get_ident(
-                                        path.segments.last().unwrap().identifier)).index(&FullRange));
+                                        path.segments.last().unwrap().identifier)).as_slice());
                         }
                     }
 
diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs
@@ -608,7 +608,7 @@ fn link_rlib<'a>(sess: &'a Session,
                 // extension to it. This is to work around a bug in LLDB that
                 // would cause it to crash if the name of a file in an archive
                 // was exactly 16 bytes.
-                let bc_filename = obj_filename.with_extension(format!("{}.bc", i).index(&FullRange));
+                let bc_filename = obj_filename.with_extension(format!("{}.bc", i).as_slice());
                 let bc_deflated_filename = obj_filename.with_extension(
                     format!("{}.bytecode.deflate", i).index(&FullRange));
 
@@ -1083,8 +1083,8 @@ fn add_local_native_libraries(cmd: &mut Command, sess: &Session) {
             // -force_load is the OSX equivalent of --whole-archive, but it
             // involves passing the full path to the library to link.
             let lib = archive::find_library(l.index(&FullRange),
-                                            sess.target.target.options.staticlib_prefix.index(&FullRange),
-                                            sess.target.target.options.staticlib_suffix.index(&FullRange),
+                                            sess.target.target.options.staticlib_prefix.as_slice(),
+                                            sess.target.target.options.staticlib_suffix.as_slice(),
                                             search_path.index(&FullRange),
                                             &sess.diagnostic().handler);
             let mut v = b"-Wl,-force_load,".to_vec();
diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs
@@ -64,7 +64,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
         debug!("reading {}", file);
         for i in iter::count(0u, 1) {
             let bc_encoded = time(sess.time_passes(),
-                                  format!("check for {}.{}.bytecode.deflate", name, i).index(&FullRange),
+                                  format!("check for {}.{}.bytecode.deflate", name, i).as_slice(),
                                   (),
                                   |_| {
                                       archive.read(format!("{}.{}.bytecode.deflate",
diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs
@@ -383,8 +383,8 @@ unsafe extern "C" fn diagnostic_handler(info: DiagnosticInfoRef, user: *mut c_vo
                 cgcx.handler.note(format!("optimization {} for {} at {}: {}",
                                           opt.kind.describe(),
                                           pass_name,
-                                          if loc.is_empty() { "[unknown]" } else { loc.index(&FullRange) },
-                                          llvm::twine_to_string(opt.message)).index(&FullRange));
+                                          if loc.is_empty() { "[unknown]" } else { loc.as_slice() },
+                                          llvm::twine_to_string(opt.message)).as_slice());
             }
         }
 
diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs
@@ -292,7 +292,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                                 Some(def_id) => {
                                     result.push_str(" as ");
                                     result.push_str(
-                                        ty::item_path_str(&self.analysis.ty_cx, def_id).index(&FullRange));
+                                        ty::item_path_str(&self.analysis.ty_cx, def_id).as_slice());
                                 },
                                 None => {}
                             }
@@ -636,7 +636,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                         item.id);
 
                     for field in struct_def.fields.iter() {
-                        self.process_struct_field_def(field, qualname.index(&FullRange), variant.node.id);
+                        self.process_struct_field_def(field, qualname.as_slice(), variant.node.id);
                         self.visit_ty(&*field.node.ty);
                     }
                 }
@@ -774,7 +774,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         let def_map = self.analysis.ty_cx.def_map.borrow();
         if !def_map.contains_key(&id) {
             self.sess.span_bug(span,
-                               format!("def_map has no key for {} in visit_expr", id).index(&FullRange));
+                               format!("def_map has no key for {} in visit_expr", id).as_slice());
         }
         let def = &(*def_map)[id];
         let sub_span = self.span.span_for_last_ident(span);
@@ -1065,7 +1065,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
                                      value.index(&FullRange));
 
                 self.visit_ty(&**ty);
-                self.process_generic_params(ty_params, item.span, qualname.index(&FullRange), item.id);
+                self.process_generic_params(ty_params, item.span, qualname.as_slice(), item.id);
             },
             ast::ItemMac(_) => (),
             _ => visit::walk_item(self, item),
@@ -1418,7 +1418,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
             let def_map = self.analysis.ty_cx.def_map.borrow();
             if !def_map.contains_key(&id) {
                 self.sess.span_bug(p.span,
-                                   format!("def_map has no key for {} in visit_arm", id).index(&FullRange));
+                                   format!("def_map has no key for {} in visit_arm",
+                                           id).index(&FullRange));
             }
             let def = &(*def_map)[id];
             match *def {
diff --git a/src/librustc_trans/save/recorder.rs b/src/librustc_trans/save/recorder.rs
@@ -237,7 +237,7 @@ impl<'a> FmtStrs<'a> {
         if !needs_span {
             self.span.sess.span_bug(span,
                                     format!("Called record_with_span for '{}' \
-                                             which does not require a span", label).index(&FullRange));
+                                             which does not require a span", label).as_slice());
         }
 
         let values_str = match self.make_values_str(label, fields, values, span) {
diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs
@@ -1037,8 +1037,8 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                                         field_vals.len())
             );
             let mut vals = field_vals;
-            vals.push_all(vals_left.index(&FullRange));
-            compile_submatch(bcx, pats.index(&FullRange), vals.index(&FullRange), chk, has_genuine_default);
+            vals.push_all(vals_left.as_slice());
+            compile_submatch(bcx, pats.as_slice(), vals.as_slice(), chk, has_genuine_default);
             return;
         }
         _ => ()
diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs
@@ -2246,7 +2246,7 @@ pub fn update_linkage(ccx: &CrateContext,
     if let Some(id) = id {
         let item = ccx.tcx().map.get(id);
         if let ast_map::NodeItem(i) = item {
-            if let Some(name) = attr::first_attr_value_str_by_name(i.attrs.index(&FullRange), "linkage") {
+            if let Some(name) = attr::first_attr_value_str_by_name(i.attrs.as_slice(), "linkage") {
                 if let Some(linkage) = llvm_linkage_by_name(name.get()) {
                     llvm::SetLinkage(llval, linkage);
                 } else {
@@ -2605,7 +2605,11 @@ pub fn register_fn_llvmty(ccx: &CrateContext,
                           llfty: Type) -> ValueRef {
     debug!("register_fn_llvmty id={} sym={}", node_id, sym);
 
-    let llfn = decl_fn(ccx, sym.index(&FullRange), cc, llfty, ty::FnConverging(ty::mk_nil(ccx.tcx())));
+    let llfn = decl_fn(ccx,
+                       sym.index(&FullRange),
+                       cc,
+                       llfty,
+                       ty::FnConverging(ty::mk_nil(ccx.tcx())));
     finish_register_fn(ccx, sp, sym, node_id, llfn);
     llfn
 }
diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs
@@ -748,7 +748,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         debug!("calling llrustfn = {}, t = {}",
                ccx.tn().val_to_string(llrustfn), t.repr(ccx.tcx()));
         let attributes = base::get_fn_llvm_attributes(ccx, t);
-        let llrust_ret_val = builder.call(llrustfn, llrust_args.index(&FullRange), Some(attributes));
+        let llrust_ret_val = builder.call(llrustfn, llrust_args.as_slice(), Some(attributes));
 
         // Get the return value where the foreign fn expects it.
         let llforeign_ret_ty = match tys.fn_ty.ret_ty.cast {
@@ -869,7 +869,7 @@ fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
            ty.repr(ccx.tcx()),
            ccx.tn().types_to_str(llsig.llarg_tys.index(&FullRange)),
            ccx.tn().type_to_string(llsig.llret_ty),
-           ccx.tn().types_to_str(fn_ty.arg_tys.iter().map(|t| t.ty).collect::<Vec<_>>().index(&FullRange)),
+           ccx.tn().types_to_str(fn_ty.arg_tys.iter().map(|t| t.ty).collect::<Vec<_>>().as_slice()),
            ccx.tn().type_to_string(fn_ty.ret_ty.ty),
            llsig.ret_def);
 
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
@@ -568,7 +568,8 @@ pub fn instantiate_trait_ref<'tcx,AC,RS>(
         _ => {
             this.tcx().sess.span_fatal(
                 ast_trait_ref.path.span,
-                format!("`{}` is not a trait", ast_trait_ref.path.user_string(this.tcx())).index(&FullRange));
+                format!("`{}` is not a trait",
+                        ast_trait_ref.path.user_string(this.tcx())).index(&FullRange));
         }
     }
 }
@@ -1022,8 +1023,12 @@ pub fn ast_ty_to_ty<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
             ast::TyObjectSum(ref ty, ref bounds) => {
                 match ast_ty_to_trait_ref(this, rscope, &**ty, bounds.index(&FullRange)) {
                     Ok((trait_ref, projection_bounds)) => {
-                        trait_ref_to_object_type(this, rscope, ast_ty.span,
-                                                 trait_ref, projection_bounds, bounds.index(&FullRange))
+                        trait_ref_to_object_type(this,
+                                                 rscope,
+                                                 ast_ty.span,
+                                                 trait_ref,
+                                                 projection_bounds,
+                                                 bounds.index(&FullRange))
                     }
                     Err(ErrorReported) => {
                         this.tcx().types.err
diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs
@@ -564,7 +564,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
                                 &**base_expr,
                                 Some(&ty::AdjustDerefRef(base_adjustment.clone())));
                         let index_expr_ty = self.fcx.expr_ty(&**index_expr);
-                        
+
                         let result = check::try_index_step(
                             self.fcx,
                             MethodCall::expr(expr.id),
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -3977,7 +3977,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
           callee::check_call(fcx, expr, &**callee, args.as_slice());
       }
       ast::ExprMethodCall(ident, ref tps, ref args) => {
-        check_method_call(fcx, expr, ident, args.index(&FullRange), tps.index(&FullRange), lvalue_pref);
+        check_method_call(fcx, expr, ident, args.as_slice(), tps.as_slice(), lvalue_pref);
         let arg_tys = args.iter().map(|a| fcx.expr_ty(&**a));
         let  args_err = arg_tys.fold(false,
              |rest_err, a| {
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
diff --git a/src/libsyntax/ext/deriving/bounds.rs b/src/libsyntax/ext/deriving/bounds.rs
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
diff --git a/src/test/compile-fail/slice-mut.rs b/src/test/compile-fail/slice-mut.rs

Original file line number	Diff line number	Diff line change
`@@ -492,7 +492,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> {`
`492`	`492`	`None => {`
`493`	`493`	`self.span_lint(builtin::UNKNOWN_LINTS, span,`
`494`	`494`	format!("unknown `{}` attribute: `{}`",
`495`		`- level.as_str(), lint_name).index(&FullRange));`
	`495`	`+ level.as_str(), lint_name).as_slice());`
`496`	`496`	`continue;`
`497`	`497`	`}`
`498`	`498`	`}`
`@@ -784,7 +784,7 @@ pub fn check_crate(tcx: &ty::ctxt,`
`784`	`784`	`for &(lint, span, ref msg) in v.iter() {`
`785`	`785`	`tcx.sess.span_bug(span,`
`786`	`786`	`format!("unprocessed lint {} at {}: {}",`
`787`		`- lint.as_str(), tcx.map.node_to_string(id), msg).index(&FullRange))`
	`787`	`+ lint.as_str(), tcx.map.node_to_string(id), msg).as_slice())`
`788`	`788`	`}`
`789`	`789`	`}`
`790`	`790`
Original file line number	Diff line number	Diff line change
`@@ -624,7 +624,8 @@ impl<'a> Context<'a> {`
`624`	`624`	`return true`
`625`	`625`	`} else {`
`626`	`626`	`let (ref prefix, ref suffix) = dylibname;`
`627`		`- if file.starts_with(prefix.index(&FullRange)) && file.ends_with(suffix.index(&FullRange)) {`
	`627`	`+ if file.starts_with(prefix.index(&FullRange)) &&`
	`628`	`+ file.ends_with(suffix.index(&FullRange)) {`
`628`	`629`	`return true`
`629`	`630`	`}`
`630`	`631`	`}`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,9 @@ impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> {`
`85`	`85`	`let s = self.ast_map.node_to_string(node_id);`
`86`	`86`	`// left-aligns the lines`
`87`	`87`	`let s = replace_newline_with_backslash_l(s);`
`88`		`- label.push_str(format!("exiting scope_{} {}", i, s.index(&FullRange)).index(&FullRange));`
	`88`	`+ label.push_str(format!("exiting scope_{} {}",`
	`89`	`+ i,`
	`90`	`+ s.index(&FullRange)).index(&FullRange));`
`89`	`91`	`}`
`90`	`92`	`dot::LabelText::EscStr(label.into_cow())`
`91`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -639,7 +639,7 @@ pub fn build_target_config(opts: &Options, sp: &SpanHandler) -> Config {`
`639`	`639`	`let target = match Target::search(opts.target_triple.index(&FullRange)) {`
`640`	`640`	`Ok(t) => t,`
`641`	`641`	`Err(e) => {`
`642`		`- sp.handler().fatal((format!("Error loading target specification: {}", e)).index(&FullRange));`
	`642`	`+ sp.handler().fatal((format!("Error loading target specification: {}", e)).as_slice());`
`643`	`643`	`}`
`644`	`644`	`};`
`645`	`645`
Original file line number	Diff line number	Diff line change
`@@ -820,7 +820,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {`
`820`	`820`	`mc::AliasableClosure(id) => {`
`821`	`821`	`self.tcx.sess.span_err(span,`
`822`	`822`	`format!("{} in a captured outer \`
`823`		- variable in an `Fn` closure", prefix).index(&FullRange));
	`823`	+ variable in an `Fn` closure", prefix).as_slice());
`824`	`824`	`span_help!(self.tcx.sess, self.tcx.map.span(id),`
`825`	`825`	`"consider changing this closure to take self by mutable reference");`
`826`	`826`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3757,13 +3757,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {`
`3757`	`3757`	`self.resolve_error(path.span,`
`3758`	`3758`	format!("`{}` is not an enum variant, struct or const",
`3759`	`3759`	`token::get_ident(`
`3760`		`- path.segments.last().unwrap().identifier)).index(&FullRange));`
	`3760`	`+ path.segments.last().unwrap().identifier)).as_slice());`
`3761`	`3761`	`}`
`3762`	`3762`	`None => {`
`3763`	`3763`	`self.resolve_error(path.span,`
`3764`	`3764`	format!("unresolved enum variant, struct or const `{}`",
`3765`	`3765`	`token::get_ident(`
`3766`		`- path.segments.last().unwrap().identifier)).index(&FullRange));`
	`3766`	`+ path.segments.last().unwrap().identifier)).as_slice());`
`3767`	`3767`	`}`
`3768`	`3768`	`}`
`3769`	`3769`
Original file line number	Diff line number	Diff line change
`@@ -383,8 +383,8 @@ unsafe extern "C" fn diagnostic_handler(info: DiagnosticInfoRef, user: *mut c_vo`
`383`	`383`	`cgcx.handler.note(format!("optimization {} for {} at {}: {}",`
`384`	`384`	`opt.kind.describe(),`
`385`	`385`	`pass_name,`
`386`		`- if loc.is_empty() { "[unknown]" } else { loc.index(&FullRange) },`
`387`		`- llvm::twine_to_string(opt.message)).index(&FullRange));`
	`386`	`+ if loc.is_empty() { "[unknown]" } else { loc.as_slice() },`
	`387`	`+ llvm::twine_to_string(opt.message)).as_slice());`
`388`	`388`	`}`
`389`	`389`	`}`
`390`	`390`
Original file line number	Diff line number	Diff line change
`@@ -237,7 +237,7 @@ impl<'a> FmtStrs<'a> {`
`237`	`237`	`if !needs_span {`
`238`	`238`	`self.span.sess.span_bug(span,`
`239`	`239`	`format!("Called record_with_span for '{}' \`
`240`		`- which does not require a span", label).index(&FullRange));`
	`240`	`+ which does not require a span", label).as_slice());`
`241`	`241`	`}`
`242`	`242`
`243`	`243`	`let values_str = match self.make_values_str(label, fields, values, span) {`
Original file line number	Diff line number	Diff line change
`@@ -568,7 +568,8 @@ pub fn instantiate_trait_ref<'tcx,AC,RS>(`
`568`	`568`	`_ => {`
`569`	`569`	`this.tcx().sess.span_fatal(`
`570`	`570`	`ast_trait_ref.path.span,`
`571`		- format!("`{}` is not a trait", ast_trait_ref.path.user_string(this.tcx())).index(&FullRange));
	`571`	+ format!("`{}` is not a trait",
	`572`	`+ ast_trait_ref.path.user_string(this.tcx())).index(&FullRange));`
`572`	`573`	`}`
`573`	`574`	`}`
`574`	`575`	`}`
`@@ -1022,8 +1023,12 @@ pub fn ast_ty_to_ty<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(`
`1022`	`1023`	`ast::TyObjectSum(ref ty, ref bounds) => {`
`1023`	`1024`	`match ast_ty_to_trait_ref(this, rscope, &**ty, bounds.index(&FullRange)) {`
`1024`	`1025`	`Ok((trait_ref, projection_bounds)) => {`
`1025`		`- trait_ref_to_object_type(this, rscope, ast_ty.span,`
`1026`		`- trait_ref, projection_bounds, bounds.index(&FullRange))`
	`1026`	`+ trait_ref_to_object_type(this,`
	`1027`	`+ rscope,`
	`1028`	`+ ast_ty.span,`
	`1029`	`+ trait_ref,`
	`1030`	`+ projection_bounds,`
	`1031`	`+ bounds.index(&FullRange))`
`1027`	`1032`	`}`
`1028`	`1033`	`Err(ErrorReported) => {`
`1029`	`1034`	`this.tcx().types.err`
Original file line number	Diff line number	Diff line change
`@@ -3977,7 +3977,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,`
`3977`	`3977`	`callee::check_call(fcx, expr, &**callee, args.as_slice());`
`3978`	`3978`	`}`
`3979`	`3979`	`ast::ExprMethodCall(ident, ref tps, ref args) => {`
`3980`		`- check_method_call(fcx, expr, ident, args.index(&FullRange), tps.index(&FullRange), lvalue_pref);`
	`3980`	`+ check_method_call(fcx, expr, ident, args.as_slice(), tps.as_slice(), lvalue_pref);`
`3981`	`3981`	`let arg_tys = args.iter().map(\|a\| fcx.expr_ty(&**a));`
`3982`	`3982`	`let args_err = arg_tys.fold(false,`
`3983`	`3983`	`\|rest_err, a\| {`